Branch data Line data Source code
1 : : /*
2 : : * bsg.c - block layer implementation of the sg v4 interface
3 : : *
4 : : * Copyright (C) 2004 Jens Axboe <axboe@suse.de> SUSE Labs
5 : : * Copyright (C) 2004 Peter M. Jones <pjones@redhat.com>
6 : : *
7 : : * This file is subject to the terms and conditions of the GNU General Public
8 : : * License version 2. See the file "COPYING" in the main directory of this
9 : : * archive for more details.
10 : : *
11 : : */
12 : : #include <linux/module.h>
13 : : #include <linux/init.h>
14 : : #include <linux/file.h>
15 : : #include <linux/blkdev.h>
16 : : #include <linux/poll.h>
17 : : #include <linux/cdev.h>
18 : : #include <linux/jiffies.h>
19 : : #include <linux/percpu.h>
20 : : #include <linux/uio.h>
21 : : #include <linux/idr.h>
22 : : #include <linux/bsg.h>
23 : : #include <linux/slab.h>
24 : :
25 : : #include <scsi/scsi.h>
26 : : #include <scsi/scsi_ioctl.h>
27 : : #include <scsi/scsi_cmnd.h>
28 : : #include <scsi/scsi_device.h>
29 : : #include <scsi/scsi_driver.h>
30 : : #include <scsi/sg.h>
31 : :
32 : : #define BSG_DESCRIPTION "Block layer SCSI generic (bsg) driver"
33 : : #define BSG_VERSION "0.4"
34 : :
35 : : struct bsg_device {
36 : : struct request_queue *queue;
37 : : spinlock_t lock;
38 : : struct list_head busy_list;
39 : : struct list_head done_list;
40 : : struct hlist_node dev_list;
41 : : atomic_t ref_count;
42 : : int queued_cmds;
43 : : int done_cmds;
44 : : wait_queue_head_t wq_done;
45 : : wait_queue_head_t wq_free;
46 : : char name[20];
47 : : int max_queue;
48 : : unsigned long flags;
49 : : };
50 : :
51 : : enum {
52 : : BSG_F_BLOCK = 1,
53 : : };
54 : :
55 : : #define BSG_DEFAULT_CMDS 64
56 : : #define BSG_MAX_DEVS 32768
57 : :
58 : : #undef BSG_DEBUG
59 : :
60 : : #ifdef BSG_DEBUG
61 : : #define dprintk(fmt, args...) printk(KERN_ERR "%s: " fmt, __func__, ##args)
62 : : #else
63 : : #define dprintk(fmt, args...)
64 : : #endif
65 : :
66 : : static DEFINE_MUTEX(bsg_mutex);
67 : : static DEFINE_IDR(bsg_minor_idr);
68 : :
69 : : #define BSG_LIST_ARRAY_SIZE 8
70 : : static struct hlist_head bsg_device_list[BSG_LIST_ARRAY_SIZE];
71 : :
72 : : static struct class *bsg_class;
73 : : static int bsg_major;
74 : :
75 : : static struct kmem_cache *bsg_cmd_cachep;
76 : :
77 : : /*
78 : : * our internal command type
79 : : */
80 : : struct bsg_command {
81 : : struct bsg_device *bd;
82 : : struct list_head list;
83 : : struct request *rq;
84 : : struct bio *bio;
85 : : struct bio *bidi_bio;
86 : : int err;
87 : : struct sg_io_v4 hdr;
88 : : char sense[SCSI_SENSE_BUFFERSIZE];
89 : : };
90 : :
91 : 0 : static void bsg_free_command(struct bsg_command *bc)
92 : : {
93 : 0 : struct bsg_device *bd = bc->bd;
94 : : unsigned long flags;
95 : :
96 : 0 : kmem_cache_free(bsg_cmd_cachep, bc);
97 : :
98 : 0 : spin_lock_irqsave(&bd->lock, flags);
99 : 0 : bd->queued_cmds--;
100 : : spin_unlock_irqrestore(&bd->lock, flags);
101 : :
102 : 0 : wake_up(&bd->wq_free);
103 : 0 : }
104 : :
105 : 0 : static struct bsg_command *bsg_alloc_command(struct bsg_device *bd)
106 : : {
107 : : struct bsg_command *bc = ERR_PTR(-EINVAL);
108 : :
109 : : spin_lock_irq(&bd->lock);
110 : :
111 [ # # ]: 0 : if (bd->queued_cmds >= bd->max_queue)
112 : : goto out;
113 : :
114 : 0 : bd->queued_cmds++;
115 : : spin_unlock_irq(&bd->lock);
116 : :
117 : 0 : bc = kmem_cache_zalloc(bsg_cmd_cachep, GFP_KERNEL);
118 [ # # ]: 0 : if (unlikely(!bc)) {
119 : : spin_lock_irq(&bd->lock);
120 : 0 : bd->queued_cmds--;
121 : : bc = ERR_PTR(-ENOMEM);
122 : 0 : goto out;
123 : : }
124 : :
125 : 0 : bc->bd = bd;
126 : 0 : INIT_LIST_HEAD(&bc->list);
127 : : dprintk("%s: returning free cmd %p\n", bd->name, bc);
128 : 0 : return bc;
129 : : out:
130 : : spin_unlock_irq(&bd->lock);
131 : 0 : return bc;
132 : : }
133 : :
134 : : static inline struct hlist_head *bsg_dev_idx_hash(int index)
135 : : {
136 : 0 : return &bsg_device_list[index & (BSG_LIST_ARRAY_SIZE - 1)];
137 : : }
138 : :
139 : 0 : static int bsg_io_schedule(struct bsg_device *bd)
140 : : {
141 : 0 : DEFINE_WAIT(wait);
142 : : int ret = 0;
143 : :
144 : : spin_lock_irq(&bd->lock);
145 : :
146 [ # # ]: 0 : BUG_ON(bd->done_cmds > bd->queued_cmds);
147 : :
148 : : /*
149 : : * -ENOSPC or -ENODATA? I'm going for -ENODATA, meaning "I have no
150 : : * work to do", even though we return -ENOSPC after this same test
151 : : * during bsg_write() -- there, it means our buffer can't have more
152 : : * bsg_commands added to it, thus has no space left.
153 : : */
154 [ # # ]: 0 : if (bd->done_cmds == bd->queued_cmds) {
155 : : ret = -ENODATA;
156 : : goto unlock;
157 : : }
158 : :
159 [ # # ]: 0 : if (!test_bit(BSG_F_BLOCK, &bd->flags)) {
160 : : ret = -EAGAIN;
161 : : goto unlock;
162 : : }
163 : :
164 : 0 : prepare_to_wait(&bd->wq_done, &wait, TASK_UNINTERRUPTIBLE);
165 : : spin_unlock_irq(&bd->lock);
166 : 0 : io_schedule();
167 : 0 : finish_wait(&bd->wq_done, &wait);
168 : :
169 : 0 : return ret;
170 : : unlock:
171 : : spin_unlock_irq(&bd->lock);
172 : 0 : return ret;
173 : : }
174 : :
175 : 0 : static int blk_fill_sgv4_hdr_rq(struct request_queue *q, struct request *rq,
176 : : struct sg_io_v4 *hdr, struct bsg_device *bd,
177 : : fmode_t has_write_perm)
178 : : {
179 [ # # ]: 0 : if (hdr->request_len > BLK_MAX_CDB) {
180 : 0 : rq->cmd = kzalloc(hdr->request_len, GFP_KERNEL);
181 [ # # ]: 0 : if (!rq->cmd)
182 : : return -ENOMEM;
183 : : }
184 : :
185 [ # # ]: 0 : if (copy_from_user(rq->cmd, (void __user *)(unsigned long)hdr->request,
186 : 0 : hdr->request_len))
187 : : return -EFAULT;
188 : :
189 [ # # ]: 0 : if (hdr->subprotocol == BSG_SUB_PROTOCOL_SCSI_CMD) {
190 [ # # ]: 0 : if (blk_verify_command(rq->cmd, has_write_perm))
191 : : return -EPERM;
192 [ # # ]: 0 : } else if (!capable(CAP_SYS_RAWIO))
193 : : return -EPERM;
194 : :
195 : : /*
196 : : * fill in request structure
197 : : */
198 : 0 : rq->cmd_len = hdr->request_len;
199 : 0 : rq->cmd_type = REQ_TYPE_BLOCK_PC;
200 : :
201 : 0 : rq->timeout = msecs_to_jiffies(hdr->timeout);
202 [ # # ]: 0 : if (!rq->timeout)
203 : 0 : rq->timeout = q->sg_timeout;
204 [ # # ]: 0 : if (!rq->timeout)
205 : 0 : rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
206 [ # # ]: 0 : if (rq->timeout < BLK_MIN_SG_TIMEOUT)
207 : 0 : rq->timeout = BLK_MIN_SG_TIMEOUT;
208 : :
209 : : return 0;
210 : : }
211 : :
212 : : /*
213 : : * Check if sg_io_v4 from user is allowed and valid
214 : : */
215 : : static int
216 : 0 : bsg_validate_sgv4_hdr(struct request_queue *q, struct sg_io_v4 *hdr, int *rw)
217 : : {
218 : : int ret = 0;
219 : :
220 [ # # ]: 0 : if (hdr->guard != 'Q')
221 : : return -EINVAL;
222 : :
223 [ # # ]: 0 : switch (hdr->protocol) {
224 : : case BSG_PROTOCOL_SCSI:
225 [ # # ]: 0 : switch (hdr->subprotocol) {
226 : : case BSG_SUB_PROTOCOL_SCSI_CMD:
227 : : case BSG_SUB_PROTOCOL_SCSI_TRANSPORT:
228 : : break;
229 : : default:
230 : : ret = -EINVAL;
231 : : }
232 : : break;
233 : : default:
234 : : ret = -EINVAL;
235 : : }
236 : :
237 : 0 : *rw = hdr->dout_xfer_len ? WRITE : READ;
238 : : return ret;
239 : : }
240 : :
241 : : /*
242 : : * map sg_io_v4 to a request.
243 : : */
244 : : static struct request *
245 : 0 : bsg_map_hdr(struct bsg_device *bd, struct sg_io_v4 *hdr, fmode_t has_write_perm,
246 : : u8 *sense)
247 : : {
248 : 0 : struct request_queue *q = bd->queue;
249 : : struct request *rq, *next_rq = NULL;
250 : : int ret, rw;
251 : : unsigned int dxfer_len;
252 : : void __user *dxferp = NULL;
253 : : struct bsg_class_device *bcd = &q->bsg_dev;
254 : :
255 : : /* if the LLD has been removed then the bsg_unregister_queue will
256 : : * eventually be called and the class_dev was freed, so we can no
257 : : * longer use this request_queue. Return no such address.
258 : : */
259 [ # # ]: 0 : if (!bcd->class_dev)
260 : : return ERR_PTR(-ENXIO);
261 : :
262 : : dprintk("map hdr %llx/%u %llx/%u\n", (unsigned long long) hdr->dout_xferp,
263 : : hdr->dout_xfer_len, (unsigned long long) hdr->din_xferp,
264 : : hdr->din_xfer_len);
265 : :
266 : 0 : ret = bsg_validate_sgv4_hdr(q, hdr, &rw);
267 [ # # ]: 0 : if (ret)
268 : : return ERR_PTR(ret);
269 : :
270 : : /*
271 : : * map scatter-gather elements separately and string them to request
272 : : */
273 : 0 : rq = blk_get_request(q, rw, GFP_KERNEL);
274 [ # # ]: 0 : if (!rq)
275 : : return ERR_PTR(-ENOMEM);
276 : 0 : ret = blk_fill_sgv4_hdr_rq(q, rq, hdr, bd, has_write_perm);
277 [ # # ]: 0 : if (ret)
278 : : goto out;
279 : :
280 [ # # ][ # # ]: 0 : if (rw == WRITE && hdr->din_xfer_len) {
281 [ # # ]: 0 : if (!test_bit(QUEUE_FLAG_BIDI, &q->queue_flags)) {
282 : : ret = -EOPNOTSUPP;
283 : : goto out;
284 : : }
285 : :
286 : 0 : next_rq = blk_get_request(q, READ, GFP_KERNEL);
287 [ # # ]: 0 : if (!next_rq) {
288 : : ret = -ENOMEM;
289 : : goto out;
290 : : }
291 : 0 : rq->next_rq = next_rq;
292 : 0 : next_rq->cmd_type = rq->cmd_type;
293 : :
294 : 0 : dxferp = (void __user *)(unsigned long)hdr->din_xferp;
295 : 0 : ret = blk_rq_map_user(q, next_rq, NULL, dxferp,
296 : 0 : hdr->din_xfer_len, GFP_KERNEL);
297 [ # # ]: 0 : if (ret)
298 : : goto out;
299 : : }
300 : :
301 [ # # ]: 0 : if (hdr->dout_xfer_len) {
302 : : dxfer_len = hdr->dout_xfer_len;
303 : 0 : dxferp = (void __user *)(unsigned long)hdr->dout_xferp;
304 [ # # ]: 0 : } else if (hdr->din_xfer_len) {
305 : : dxfer_len = hdr->din_xfer_len;
306 : 0 : dxferp = (void __user *)(unsigned long)hdr->din_xferp;
307 : : } else
308 : : dxfer_len = 0;
309 : :
310 [ # # ]: 0 : if (dxfer_len) {
311 : 0 : ret = blk_rq_map_user(q, rq, NULL, dxferp, dxfer_len,
312 : : GFP_KERNEL);
313 [ # # ]: 0 : if (ret)
314 : : goto out;
315 : : }
316 : :
317 : 0 : rq->sense = sense;
318 : 0 : rq->sense_len = 0;
319 : :
320 : : return rq;
321 : : out:
322 [ # # ]: 0 : if (rq->cmd != rq->__cmd)
323 : 0 : kfree(rq->cmd);
324 : 0 : blk_put_request(rq);
325 [ # # ]: 0 : if (next_rq) {
326 : 0 : blk_rq_unmap_user(next_rq->bio);
327 : 0 : blk_put_request(next_rq);
328 : : }
329 : : return ERR_PTR(ret);
330 : : }
331 : :
332 : : /*
333 : : * async completion call-back from the block layer, when scsi/ide/whatever
334 : : * calls end_that_request_last() on a request
335 : : */
336 : 0 : static void bsg_rq_end_io(struct request *rq, int uptodate)
337 : : {
338 : 0 : struct bsg_command *bc = rq->end_io_data;
339 : 0 : struct bsg_device *bd = bc->bd;
340 : : unsigned long flags;
341 : :
342 : : dprintk("%s: finished rq %p bc %p, bio %p stat %d\n",
343 : : bd->name, rq, bc, bc->bio, uptodate);
344 : :
345 : 0 : bc->hdr.duration = jiffies_to_msecs(jiffies - bc->hdr.duration);
346 : :
347 : 0 : spin_lock_irqsave(&bd->lock, flags);
348 : 0 : list_move_tail(&bc->list, &bd->done_list);
349 : 0 : bd->done_cmds++;
350 : : spin_unlock_irqrestore(&bd->lock, flags);
351 : :
352 : 0 : wake_up(&bd->wq_done);
353 : 0 : }
354 : :
355 : : /*
356 : : * do final setup of a 'bc' and submit the matching 'rq' to the block
357 : : * layer for io
358 : : */
359 : 0 : static void bsg_add_command(struct bsg_device *bd, struct request_queue *q,
360 : : struct bsg_command *bc, struct request *rq)
361 : : {
362 : 0 : int at_head = (0 == (bc->hdr.flags & BSG_FLAG_Q_AT_TAIL));
363 : :
364 : : /*
365 : : * add bc command to busy queue and submit rq for io
366 : : */
367 : 0 : bc->rq = rq;
368 : 0 : bc->bio = rq->bio;
369 [ # # ]: 0 : if (rq->next_rq)
370 : 0 : bc->bidi_bio = rq->next_rq->bio;
371 : 0 : bc->hdr.duration = jiffies;
372 : : spin_lock_irq(&bd->lock);
373 : 0 : list_add_tail(&bc->list, &bd->busy_list);
374 : : spin_unlock_irq(&bd->lock);
375 : :
376 : : dprintk("%s: queueing rq %p, bc %p\n", bd->name, rq, bc);
377 : :
378 : 0 : rq->end_io_data = bc;
379 : 0 : blk_execute_rq_nowait(q, NULL, rq, at_head, bsg_rq_end_io);
380 : 0 : }
381 : :
382 : 0 : static struct bsg_command *bsg_next_done_cmd(struct bsg_device *bd)
383 : : {
384 : : struct bsg_command *bc = NULL;
385 : :
386 : : spin_lock_irq(&bd->lock);
387 [ # # ]: 0 : if (bd->done_cmds) {
388 : 0 : bc = list_first_entry(&bd->done_list, struct bsg_command, list);
389 : : list_del(&bc->list);
390 : 0 : bd->done_cmds--;
391 : : }
392 : : spin_unlock_irq(&bd->lock);
393 : :
394 : 0 : return bc;
395 : : }
396 : :
397 : : /*
398 : : * Get a finished command from the done list
399 : : */
400 : 0 : static struct bsg_command *bsg_get_done_cmd(struct bsg_device *bd)
401 : : {
402 : : struct bsg_command *bc;
403 : : int ret;
404 : :
405 : : do {
406 : 0 : bc = bsg_next_done_cmd(bd);
407 [ # # ]: 0 : if (bc)
408 : : break;
409 : :
410 [ # # ]: 0 : if (!test_bit(BSG_F_BLOCK, &bd->flags)) {
411 : : bc = ERR_PTR(-EAGAIN);
412 : : break;
413 : : }
414 : :
415 [ # # ][ # # ]: 0 : ret = wait_event_interruptible(bd->wq_done, bd->done_cmds);
[ # # ]
416 [ # # ]: 0 : if (ret) {
417 : : bc = ERR_PTR(-ERESTARTSYS);
418 : : break;
419 : : }
420 : : } while (1);
421 : :
422 : : dprintk("%s: returning done %p\n", bd->name, bc);
423 : :
424 : 0 : return bc;
425 : : }
426 : :
427 : 0 : static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
428 : : struct bio *bio, struct bio *bidi_bio)
429 : : {
430 : : int ret = 0;
431 : :
432 : : dprintk("rq %p bio %p 0x%x\n", rq, bio, rq->errors);
433 : : /*
434 : : * fill in all the output members
435 : : */
436 : 0 : hdr->device_status = rq->errors & 0xff;
437 : 0 : hdr->transport_status = host_byte(rq->errors);
438 : 0 : hdr->driver_status = driver_byte(rq->errors);
439 : 0 : hdr->info = 0;
440 [ # # ][ # # ]: 0 : if (hdr->device_status || hdr->transport_status || hdr->driver_status)
[ # # ]
441 : 0 : hdr->info |= SG_INFO_CHECK;
442 : 0 : hdr->response_len = 0;
443 : :
444 [ # # ][ # # ]: 0 : if (rq->sense_len && hdr->response) {
445 : 0 : int len = min_t(unsigned int, hdr->max_response_len,
446 : : rq->sense_len);
447 : :
448 : 0 : ret = copy_to_user((void __user *)(unsigned long)hdr->response,
449 : 0 : rq->sense, len);
450 [ # # ]: 0 : if (!ret)
451 : 0 : hdr->response_len = len;
452 : : else
453 : : ret = -EFAULT;
454 : : }
455 : :
456 [ # # ]: 0 : if (rq->next_rq) {
457 : 0 : hdr->dout_resid = rq->resid_len;
458 : 0 : hdr->din_resid = rq->next_rq->resid_len;
459 : 0 : blk_rq_unmap_user(bidi_bio);
460 : 0 : blk_put_request(rq->next_rq);
461 [ # # ]: 0 : } else if (rq_data_dir(rq) == READ)
462 : 0 : hdr->din_resid = rq->resid_len;
463 : : else
464 : 0 : hdr->dout_resid = rq->resid_len;
465 : :
466 : : /*
467 : : * If the request generated a negative error number, return it
468 : : * (providing we aren't already returning an error); if it's
469 : : * just a protocol response (i.e. non negative), that gets
470 : : * processed above.
471 : : */
472 [ # # ][ # # ]: 0 : if (!ret && rq->errors < 0)
473 : : ret = rq->errors;
474 : :
475 : 0 : blk_rq_unmap_user(bio);
476 [ # # ]: 0 : if (rq->cmd != rq->__cmd)
477 : 0 : kfree(rq->cmd);
478 : 0 : blk_put_request(rq);
479 : :
480 : 0 : return ret;
481 : : }
482 : :
483 : 0 : static int bsg_complete_all_commands(struct bsg_device *bd)
484 : : {
485 : : struct bsg_command *bc;
486 : : int ret, tret;
487 : :
488 : : dprintk("%s: entered\n", bd->name);
489 : :
490 : : /*
491 : : * wait for all commands to complete
492 : : */
493 : : ret = 0;
494 : : do {
495 : 0 : ret = bsg_io_schedule(bd);
496 : : /*
497 : : * look for -ENODATA specifically -- we'll sometimes get
498 : : * -ERESTARTSYS when we've taken a signal, but we can't
499 : : * return until we're done freeing the queue, so ignore
500 : : * it. The signal will get handled when we're done freeing
501 : : * the bsg_device.
502 : : */
503 [ # # ]: 0 : } while (ret != -ENODATA);
504 : :
505 : : /*
506 : : * discard done commands
507 : : */
508 : : ret = 0;
509 : : do {
510 : : spin_lock_irq(&bd->lock);
511 [ # # ]: 0 : if (!bd->queued_cmds) {
512 : : spin_unlock_irq(&bd->lock);
513 : : break;
514 : : }
515 : : spin_unlock_irq(&bd->lock);
516 : :
517 : 0 : bc = bsg_get_done_cmd(bd);
518 [ # # ]: 0 : if (IS_ERR(bc))
519 : : break;
520 : :
521 : 0 : tret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,
522 : : bc->bidi_bio);
523 [ # # ]: 0 : if (!ret)
524 : : ret = tret;
525 : :
526 : 0 : bsg_free_command(bc);
527 : 0 : } while (1);
528 : :
529 : 0 : return ret;
530 : : }
531 : :
532 : : static int
533 : 0 : __bsg_read(char __user *buf, size_t count, struct bsg_device *bd,
534 : : const struct iovec *iov, ssize_t *bytes_read)
535 : : {
536 : : struct bsg_command *bc;
537 : : int nr_commands, ret;
538 : :
539 [ # # ]: 0 : if (count % sizeof(struct sg_io_v4))
540 : : return -EINVAL;
541 : :
542 : : ret = 0;
543 : 0 : nr_commands = count / sizeof(struct sg_io_v4);
544 [ # # ]: 0 : while (nr_commands) {
545 : 0 : bc = bsg_get_done_cmd(bd);
546 [ # # ]: 0 : if (IS_ERR(bc)) {
547 : : ret = PTR_ERR(bc);
548 : : break;
549 : : }
550 : :
551 : : /*
552 : : * this is the only case where we need to copy data back
553 : : * after completing the request. so do that here,
554 : : * bsg_complete_work() cannot do that for us
555 : : */
556 : 0 : ret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,
557 : : bc->bidi_bio);
558 : :
559 [ # # ]: 0 : if (copy_to_user(buf, &bc->hdr, sizeof(bc->hdr)))
560 : : ret = -EFAULT;
561 : :
562 : 0 : bsg_free_command(bc);
563 : :
564 [ # # ]: 0 : if (ret)
565 : : break;
566 : :
567 : 0 : buf += sizeof(struct sg_io_v4);
568 : 0 : *bytes_read += sizeof(struct sg_io_v4);
569 : 0 : nr_commands--;
570 : : }
571 : :
572 : : return ret;
573 : : }
574 : :
575 : : static inline void bsg_set_block(struct bsg_device *bd, struct file *file)
576 : : {
577 [ # # ][ # # ]: 0 : if (file->f_flags & O_NONBLOCK)
[ # # ]
578 : 0 : clear_bit(BSG_F_BLOCK, &bd->flags);
579 : : else
580 : 0 : set_bit(BSG_F_BLOCK, &bd->flags);
581 : : }
582 : :
583 : : /*
584 : : * Check if the error is a "real" error that we should return.
585 : : */
586 : : static inline int err_block_err(int ret)
587 : : {
588 [ # # ][ # # ]: 0 : if (ret && ret != -ENOSPC && ret != -ENODATA && ret != -EAGAIN)
[ # # ][ # # ]
589 : : return 1;
590 : :
591 : : return 0;
592 : : }
593 : :
594 : : static ssize_t
595 : 0 : bsg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
596 : : {
597 : 0 : struct bsg_device *bd = file->private_data;
598 : : int ret;
599 : : ssize_t bytes_read;
600 : :
601 : : dprintk("%s: read %Zd bytes\n", bd->name, count);
602 : :
603 : : bsg_set_block(bd, file);
604 : :
605 : 0 : bytes_read = 0;
606 : 0 : ret = __bsg_read(buf, count, bd, NULL, &bytes_read);
607 : 0 : *ppos = bytes_read;
608 : :
609 [ # # ][ # # ]: 0 : if (!bytes_read || err_block_err(ret))
610 : 0 : bytes_read = ret;
611 : :
612 : 0 : return bytes_read;
613 : : }
614 : :
615 : 0 : static int __bsg_write(struct bsg_device *bd, const char __user *buf,
616 : : size_t count, ssize_t *bytes_written,
617 : : fmode_t has_write_perm)
618 : : {
619 : : struct bsg_command *bc;
620 : : struct request *rq;
621 : : int ret, nr_commands;
622 : :
623 [ # # ]: 0 : if (count % sizeof(struct sg_io_v4))
624 : : return -EINVAL;
625 : :
626 : 0 : nr_commands = count / sizeof(struct sg_io_v4);
627 : : rq = NULL;
628 : : bc = NULL;
629 : : ret = 0;
630 [ # # ]: 0 : while (nr_commands) {
631 : 0 : struct request_queue *q = bd->queue;
632 : :
633 : 0 : bc = bsg_alloc_command(bd);
634 [ # # ]: 0 : if (IS_ERR(bc)) {
635 : : ret = PTR_ERR(bc);
636 : : bc = NULL;
637 : 0 : break;
638 : : }
639 : :
640 [ # # ]: 0 : if (copy_from_user(&bc->hdr, buf, sizeof(bc->hdr))) {
641 : : ret = -EFAULT;
642 : : break;
643 : : }
644 : :
645 : : /*
646 : : * get a request, fill in the blanks, and add to request queue
647 : : */
648 : 0 : rq = bsg_map_hdr(bd, &bc->hdr, has_write_perm, bc->sense);
649 [ # # ]: 0 : if (IS_ERR(rq)) {
650 : : ret = PTR_ERR(rq);
651 : : rq = NULL;
652 : 0 : break;
653 : : }
654 : :
655 : 0 : bsg_add_command(bd, q, bc, rq);
656 : : bc = NULL;
657 : : rq = NULL;
658 : 0 : nr_commands--;
659 : 0 : buf += sizeof(struct sg_io_v4);
660 : 0 : *bytes_written += sizeof(struct sg_io_v4);
661 : : }
662 : :
663 [ # # ]: 0 : if (bc)
664 : 0 : bsg_free_command(bc);
665 : :
666 : 0 : return ret;
667 : : }
668 : :
669 : : static ssize_t
670 : 0 : bsg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
671 : : {
672 : 0 : struct bsg_device *bd = file->private_data;
673 : : ssize_t bytes_written;
674 : : int ret;
675 : :
676 : : dprintk("%s: write %Zd bytes\n", bd->name, count);
677 : :
678 : : bsg_set_block(bd, file);
679 : :
680 : 0 : bytes_written = 0;
681 : 0 : ret = __bsg_write(bd, buf, count, &bytes_written,
682 : 0 : file->f_mode & FMODE_WRITE);
683 : :
684 : 0 : *ppos = bytes_written;
685 : :
686 : : /*
687 : : * return bytes written on non-fatal errors
688 : : */
689 [ # # ][ # # ]: 0 : if (!bytes_written || err_block_err(ret))
690 : 0 : bytes_written = ret;
691 : :
692 : : dprintk("%s: returning %Zd\n", bd->name, bytes_written);
693 : 0 : return bytes_written;
694 : : }
695 : :
696 : 0 : static struct bsg_device *bsg_alloc_device(void)
697 : : {
698 : : struct bsg_device *bd;
699 : :
700 : : bd = kzalloc(sizeof(struct bsg_device), GFP_KERNEL);
701 [ # # ]: 0 : if (unlikely(!bd))
702 : : return NULL;
703 : :
704 : 0 : spin_lock_init(&bd->lock);
705 : :
706 : 0 : bd->max_queue = BSG_DEFAULT_CMDS;
707 : :
708 : 0 : INIT_LIST_HEAD(&bd->busy_list);
709 : 0 : INIT_LIST_HEAD(&bd->done_list);
710 : : INIT_HLIST_NODE(&bd->dev_list);
711 : :
712 : 0 : init_waitqueue_head(&bd->wq_free);
713 : 0 : init_waitqueue_head(&bd->wq_done);
714 : 0 : return bd;
715 : : }
716 : :
717 : 0 : static void bsg_kref_release_function(struct kref *kref)
718 : : {
719 : : struct bsg_class_device *bcd =
720 : : container_of(kref, struct bsg_class_device, ref);
721 : 0 : struct device *parent = bcd->parent;
722 : :
723 [ # # ]: 0 : if (bcd->release)
724 : 0 : bcd->release(bcd->parent);
725 : :
726 : 0 : put_device(parent);
727 : 0 : }
728 : :
729 : 0 : static int bsg_put_device(struct bsg_device *bd)
730 : : {
731 : : int ret = 0, do_free;
732 : 0 : struct request_queue *q = bd->queue;
733 : :
734 : 0 : mutex_lock(&bsg_mutex);
735 : :
736 : 0 : do_free = atomic_dec_and_test(&bd->ref_count);
737 [ # # ]: 0 : if (!do_free) {
738 : 0 : mutex_unlock(&bsg_mutex);
739 : 0 : goto out;
740 : : }
741 : :
742 : : hlist_del(&bd->dev_list);
743 : 0 : mutex_unlock(&bsg_mutex);
744 : :
745 : : dprintk("%s: tearing down\n", bd->name);
746 : :
747 : : /*
748 : : * close can always block
749 : : */
750 : 0 : set_bit(BSG_F_BLOCK, &bd->flags);
751 : :
752 : : /*
753 : : * correct error detection baddies here again. it's the responsibility
754 : : * of the app to properly reap commands before close() if it wants
755 : : * fool-proof error detection
756 : : */
757 : 0 : ret = bsg_complete_all_commands(bd);
758 : :
759 : 0 : kfree(bd);
760 : : out:
761 : 0 : kref_put(&q->bsg_dev.ref, bsg_kref_release_function);
762 [ # # ]: 0 : if (do_free)
763 : 0 : blk_put_queue(q);
764 : 0 : return ret;
765 : : }
766 : :
767 : 0 : static struct bsg_device *bsg_add_device(struct inode *inode,
768 : : struct request_queue *rq,
769 : 0 : struct file *file)
770 : : {
771 : : struct bsg_device *bd;
772 : : #ifdef BSG_DEBUG
773 : : unsigned char buf[32];
774 : : #endif
775 [ # # ]: 0 : if (!blk_get_queue(rq))
776 : : return ERR_PTR(-ENXIO);
777 : :
778 : 0 : bd = bsg_alloc_device();
779 [ # # ]: 0 : if (!bd) {
780 : 0 : blk_put_queue(rq);
781 : 0 : return ERR_PTR(-ENOMEM);
782 : : }
783 : :
784 : 0 : bd->queue = rq;
785 : :
786 : : bsg_set_block(bd, file);
787 : :
788 : 0 : atomic_set(&bd->ref_count, 1);
789 : 0 : mutex_lock(&bsg_mutex);
790 : 0 : hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
791 : :
792 : 0 : strncpy(bd->name, dev_name(rq->bsg_dev.class_dev), sizeof(bd->name) - 1);
793 : : dprintk("bound to <%s>, max queue %d\n",
794 : : format_dev_t(buf, inode->i_rdev), bd->max_queue);
795 : :
796 : 0 : mutex_unlock(&bsg_mutex);
797 : 0 : return bd;
798 : : }
799 : :
800 : 0 : static struct bsg_device *__bsg_get_device(int minor, struct request_queue *q)
801 : : {
802 : : struct bsg_device *bd;
803 : :
804 : 0 : mutex_lock(&bsg_mutex);
805 : :
806 [ # # ][ # # ]: 0 : hlist_for_each_entry(bd, bsg_dev_idx_hash(minor), dev_list) {
[ # # ]
807 [ # # ]: 0 : if (bd->queue == q) {
808 : 0 : atomic_inc(&bd->ref_count);
809 : : goto found;
810 : : }
811 : : }
812 : : bd = NULL;
813 : : found:
814 : 0 : mutex_unlock(&bsg_mutex);
815 : 0 : return bd;
816 : : }
817 : :
818 : 0 : static struct bsg_device *bsg_get_device(struct inode *inode, struct file *file)
819 : : {
820 : : struct bsg_device *bd;
821 : : struct bsg_class_device *bcd;
822 : :
823 : : /*
824 : : * find the class device
825 : : */
826 : 0 : mutex_lock(&bsg_mutex);
827 : 0 : bcd = idr_find(&bsg_minor_idr, iminor(inode));
828 [ # # ]: 0 : if (bcd)
829 : : kref_get(&bcd->ref);
830 : 0 : mutex_unlock(&bsg_mutex);
831 : :
832 [ # # ]: 0 : if (!bcd)
833 : : return ERR_PTR(-ENODEV);
834 : :
835 : 0 : bd = __bsg_get_device(iminor(inode), bcd->queue);
836 [ # # ]: 0 : if (bd)
837 : : return bd;
838 : :
839 : 0 : bd = bsg_add_device(inode, bcd->queue, file);
840 [ # # ]: 0 : if (IS_ERR(bd))
841 : 0 : kref_put(&bcd->ref, bsg_kref_release_function);
842 : :
843 : 0 : return bd;
844 : : }
845 : :
846 : 0 : static int bsg_open(struct inode *inode, struct file *file)
847 : : {
848 : : struct bsg_device *bd;
849 : :
850 : 0 : bd = bsg_get_device(inode, file);
851 : :
852 [ # # ]: 0 : if (IS_ERR(bd))
853 : 0 : return PTR_ERR(bd);
854 : :
855 : 0 : file->private_data = bd;
856 : 0 : return 0;
857 : : }
858 : :
859 : 0 : static int bsg_release(struct inode *inode, struct file *file)
860 : : {
861 : 0 : struct bsg_device *bd = file->private_data;
862 : :
863 : 0 : file->private_data = NULL;
864 : 0 : return bsg_put_device(bd);
865 : : }
866 : :
867 : 0 : static unsigned int bsg_poll(struct file *file, poll_table *wait)
868 : : {
869 : 0 : struct bsg_device *bd = file->private_data;
870 : : unsigned int mask = 0;
871 : :
872 : 0 : poll_wait(file, &bd->wq_done, wait);
873 : 0 : poll_wait(file, &bd->wq_free, wait);
874 : :
875 : : spin_lock_irq(&bd->lock);
876 [ # # ]: 0 : if (!list_empty(&bd->done_list))
877 : : mask |= POLLIN | POLLRDNORM;
878 [ # # ]: 0 : if (bd->queued_cmds < bd->max_queue)
879 : 0 : mask |= POLLOUT;
880 : : spin_unlock_irq(&bd->lock);
881 : :
882 : 0 : return mask;
883 : : }
884 : :
885 : 0 : static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
886 : : {
887 : 0 : struct bsg_device *bd = file->private_data;
888 : 0 : int __user *uarg = (int __user *) arg;
889 : : int ret;
890 : :
891 [ # # # # : 0 : switch (cmd) {
# ]
892 : : /*
893 : : * our own ioctls
894 : : */
895 : : case SG_GET_COMMAND_Q:
896 : 0 : return put_user(bd->max_queue, uarg);
897 : : case SG_SET_COMMAND_Q: {
898 : : int queue;
899 : :
900 [ # # ]: 0 : if (get_user(queue, uarg))
901 : : return -EFAULT;
902 [ # # ]: 0 : if (queue < 1)
903 : : return -EINVAL;
904 : :
905 : : spin_lock_irq(&bd->lock);
906 : 0 : bd->max_queue = queue;
907 : : spin_unlock_irq(&bd->lock);
908 : 0 : return 0;
909 : : }
910 : :
911 : : /*
912 : : * SCSI/sg ioctls
913 : : */
914 : : case SG_GET_VERSION_NUM:
915 : : case SCSI_IOCTL_GET_IDLUN:
916 : : case SCSI_IOCTL_GET_BUS_NUMBER:
917 : : case SG_SET_TIMEOUT:
918 : : case SG_GET_TIMEOUT:
919 : : case SG_GET_RESERVED_SIZE:
920 : : case SG_SET_RESERVED_SIZE:
921 : : case SG_EMULATED_HOST:
922 : : case SCSI_IOCTL_SEND_COMMAND: {
923 : : void __user *uarg = (void __user *) arg;
924 : 0 : return scsi_cmd_ioctl(bd->queue, NULL, file->f_mode, cmd, uarg);
925 : : }
926 : : case SG_IO: {
927 : : struct request *rq;
928 : : struct bio *bio, *bidi_bio = NULL;
929 : : struct sg_io_v4 hdr;
930 : : int at_head;
931 : : u8 sense[SCSI_SENSE_BUFFERSIZE];
932 : :
933 [ # # ]: 0 : if (copy_from_user(&hdr, uarg, sizeof(hdr)))
934 : : return -EFAULT;
935 : :
936 : 0 : rq = bsg_map_hdr(bd, &hdr, file->f_mode & FMODE_WRITE, sense);
937 [ # # ]: 0 : if (IS_ERR(rq))
938 : 0 : return PTR_ERR(rq);
939 : :
940 : 0 : bio = rq->bio;
941 [ # # ]: 0 : if (rq->next_rq)
942 : 0 : bidi_bio = rq->next_rq->bio;
943 : :
944 : 0 : at_head = (0 == (hdr.flags & BSG_FLAG_Q_AT_TAIL));
945 : 0 : blk_execute_rq(bd->queue, NULL, rq, at_head);
946 : 0 : ret = blk_complete_sgv4_hdr_rq(rq, &hdr, bio, bidi_bio);
947 : :
948 [ # # ]: 0 : if (copy_to_user(uarg, &hdr, sizeof(hdr)))
949 : : return -EFAULT;
950 : :
951 : 0 : return ret;
952 : : }
953 : : /*
954 : : * block device ioctls
955 : : */
956 : : default:
957 : : #if 0
958 : : return ioctl_by_bdev(bd->bdev, cmd, arg);
959 : : #else
960 : : return -ENOTTY;
961 : : #endif
962 : : }
963 : : }
964 : :
965 : : static const struct file_operations bsg_fops = {
966 : : .read = bsg_read,
967 : : .write = bsg_write,
968 : : .poll = bsg_poll,
969 : : .open = bsg_open,
970 : : .release = bsg_release,
971 : : .unlocked_ioctl = bsg_ioctl,
972 : : .owner = THIS_MODULE,
973 : : .llseek = default_llseek,
974 : : };
975 : :
976 : 0 : void bsg_unregister_queue(struct request_queue *q)
977 : : {
978 : : struct bsg_class_device *bcd = &q->bsg_dev;
979 : :
980 [ # # ]: 0 : if (!bcd->class_dev)
981 : 0 : return;
982 : :
983 : 0 : mutex_lock(&bsg_mutex);
984 : 0 : idr_remove(&bsg_minor_idr, bcd->minor);
985 [ # # ]: 0 : if (q->kobj.sd)
986 : 0 : sysfs_remove_link(&q->kobj, "bsg");
987 : 0 : device_unregister(bcd->class_dev);
988 : 0 : bcd->class_dev = NULL;
989 : 0 : kref_put(&bcd->ref, bsg_kref_release_function);
990 : 0 : mutex_unlock(&bsg_mutex);
991 : : }
992 : : EXPORT_SYMBOL_GPL(bsg_unregister_queue);
993 : :
994 : 0 : int bsg_register_queue(struct request_queue *q, struct device *parent,
995 : : const char *name, void (*release)(struct device *))
996 : : {
997 : : struct bsg_class_device *bcd;
998 : : dev_t dev;
999 : : int ret;
1000 : : struct device *class_dev = NULL;
1001 : : const char *devname;
1002 : :
1003 [ # # ]: 0 : if (name)
1004 : : devname = name;
1005 : : else
1006 : : devname = dev_name(parent);
1007 : :
1008 : : /*
1009 : : * we need a proper transport to send commands, not a stacked device
1010 : : */
1011 [ # # ]: 0 : if (!q->request_fn)
1012 : : return 0;
1013 : :
1014 : 0 : bcd = &q->bsg_dev;
1015 : 0 : memset(bcd, 0, sizeof(*bcd));
1016 : :
1017 : 0 : mutex_lock(&bsg_mutex);
1018 : :
1019 : 0 : ret = idr_alloc(&bsg_minor_idr, bcd, 0, BSG_MAX_DEVS, GFP_KERNEL);
1020 [ # # ]: 0 : if (ret < 0) {
1021 [ # # ]: 0 : if (ret == -ENOSPC) {
1022 : 0 : printk(KERN_ERR "bsg: too many bsg devices\n");
1023 : : ret = -EINVAL;
1024 : : }
1025 : : goto unlock;
1026 : : }
1027 : :
1028 : 0 : bcd->minor = ret;
1029 : 0 : bcd->queue = q;
1030 : 0 : bcd->parent = get_device(parent);
1031 : 0 : bcd->release = release;
1032 : : kref_init(&bcd->ref);
1033 : 0 : dev = MKDEV(bsg_major, bcd->minor);
1034 : 0 : class_dev = device_create(bsg_class, parent, dev, NULL, "%s", devname);
1035 [ # # ]: 0 : if (IS_ERR(class_dev)) {
1036 : : ret = PTR_ERR(class_dev);
1037 : 0 : goto put_dev;
1038 : : }
1039 : 0 : bcd->class_dev = class_dev;
1040 : :
1041 [ # # ]: 0 : if (q->kobj.sd) {
1042 : 0 : ret = sysfs_create_link(&q->kobj, &bcd->class_dev->kobj, "bsg");
1043 [ # # ]: 0 : if (ret)
1044 : : goto unregister_class_dev;
1045 : : }
1046 : :
1047 : 0 : mutex_unlock(&bsg_mutex);
1048 : 0 : return 0;
1049 : :
1050 : : unregister_class_dev:
1051 : 0 : device_unregister(class_dev);
1052 : : put_dev:
1053 : 0 : put_device(parent);
1054 : 0 : idr_remove(&bsg_minor_idr, bcd->minor);
1055 : : unlock:
1056 : 0 : mutex_unlock(&bsg_mutex);
1057 : 0 : return ret;
1058 : : }
1059 : : EXPORT_SYMBOL_GPL(bsg_register_queue);
1060 : :
1061 : : static struct cdev bsg_cdev;
1062 : :
1063 : 0 : static char *bsg_devnode(struct device *dev, umode_t *mode)
1064 : : {
1065 : 0 : return kasprintf(GFP_KERNEL, "bsg/%s", dev_name(dev));
1066 : : }
1067 : :
1068 : 0 : static int __init bsg_init(void)
1069 : : {
1070 : : int ret, i;
1071 : : dev_t devid;
1072 : :
1073 : 0 : bsg_cmd_cachep = kmem_cache_create("bsg_cmd",
1074 : : sizeof(struct bsg_command), 0, 0, NULL);
1075 [ # # ]: 0 : if (!bsg_cmd_cachep) {
1076 : 0 : printk(KERN_ERR "bsg: failed creating slab cache\n");
1077 : 0 : return -ENOMEM;
1078 : : }
1079 : :
1080 [ # # ]: 0 : for (i = 0; i < BSG_LIST_ARRAY_SIZE; i++)
1081 : 0 : INIT_HLIST_HEAD(&bsg_device_list[i]);
1082 : :
1083 : 0 : bsg_class = class_create(THIS_MODULE, "bsg");
1084 [ # # ]: 0 : if (IS_ERR(bsg_class)) {
1085 : : ret = PTR_ERR(bsg_class);
1086 : 0 : goto destroy_kmemcache;
1087 : : }
1088 : 0 : bsg_class->devnode = bsg_devnode;
1089 : :
1090 : 0 : ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
1091 [ # # ]: 0 : if (ret)
1092 : : goto destroy_bsg_class;
1093 : :
1094 : 0 : bsg_major = MAJOR(devid);
1095 : :
1096 : 0 : cdev_init(&bsg_cdev, &bsg_fops);
1097 : 0 : ret = cdev_add(&bsg_cdev, MKDEV(bsg_major, 0), BSG_MAX_DEVS);
1098 [ # # ]: 0 : if (ret)
1099 : : goto unregister_chrdev;
1100 : :
1101 : 0 : printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
1102 : : " loaded (major %d)\n", bsg_major);
1103 : 0 : return 0;
1104 : : unregister_chrdev:
1105 : 0 : unregister_chrdev_region(MKDEV(bsg_major, 0), BSG_MAX_DEVS);
1106 : : destroy_bsg_class:
1107 : 0 : class_destroy(bsg_class);
1108 : : destroy_kmemcache:
1109 : 0 : kmem_cache_destroy(bsg_cmd_cachep);
1110 : 0 : return ret;
1111 : : }
1112 : :
1113 : : MODULE_AUTHOR("Jens Axboe");
1114 : : MODULE_DESCRIPTION(BSG_DESCRIPTION);
1115 : : MODULE_LICENSE("GPL");
1116 : :
1117 : : device_initcall(bsg_init);
|
