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