1 // SPDX-License-Identifier: GPL-2.0
3 * bsg.c - block layer implementation of the sg v4 interface
5 #include <linux/module.h>
6 #include <linux/init.h>
7 #include <linux/file.h>
8 #include <linux/blkdev.h>
9 #include <linux/cdev.h>
10 #include <linux/jiffies.h>
11 #include <linux/percpu.h>
12 #include <linux/idr.h>
13 #include <linux/bsg.h>
14 #include <linux/slab.h>
16 #include <scsi/scsi.h>
17 #include <scsi/scsi_ioctl.h>
18 #include <scsi/scsi_cmnd.h>
19 #include <scsi/scsi_device.h>
20 #include <scsi/scsi_driver.h>
23 #define BSG_DESCRIPTION "Block layer SCSI generic (bsg) driver"
24 #define BSG_VERSION "0.4"
26 #define bsg_dbg(bd, fmt, ...) \
27 pr_debug("%s: " fmt, (bd)->name, ##__VA_ARGS__)
30 struct request_queue
*queue
;
32 struct hlist_node dev_list
;
38 #define BSG_DEFAULT_CMDS 64
39 #define BSG_MAX_DEVS 32768
41 static DEFINE_MUTEX(bsg_mutex
);
42 static DEFINE_IDR(bsg_minor_idr
);
44 #define BSG_LIST_ARRAY_SIZE 8
45 static struct hlist_head bsg_device_list
[BSG_LIST_ARRAY_SIZE
];
47 static struct class *bsg_class
;
50 static inline struct hlist_head
*bsg_dev_idx_hash(int index
)
52 return &bsg_device_list
[index
& (BSG_LIST_ARRAY_SIZE
- 1)];
55 #define uptr64(val) ((void __user *)(uintptr_t)(val))
57 static int bsg_scsi_check_proto(struct sg_io_v4
*hdr
)
59 if (hdr
->protocol
!= BSG_PROTOCOL_SCSI
||
60 hdr
->subprotocol
!= BSG_SUB_PROTOCOL_SCSI_CMD
)
65 static int bsg_scsi_fill_hdr(struct request
*rq
, struct sg_io_v4
*hdr
,
68 struct scsi_request
*sreq
= scsi_req(rq
);
70 if (hdr
->dout_xfer_len
&& hdr
->din_xfer_len
) {
71 pr_warn_once("BIDI support in bsg has been removed.\n");
75 sreq
->cmd_len
= hdr
->request_len
;
76 if (sreq
->cmd_len
> BLK_MAX_CDB
) {
77 sreq
->cmd
= kzalloc(sreq
->cmd_len
, GFP_KERNEL
);
82 if (copy_from_user(sreq
->cmd
, uptr64(hdr
->request
), sreq
->cmd_len
))
84 if (blk_verify_command(sreq
->cmd
, mode
))
89 static int bsg_scsi_complete_rq(struct request
*rq
, struct sg_io_v4
*hdr
)
91 struct scsi_request
*sreq
= scsi_req(rq
);
95 * fill in all the output members
97 hdr
->device_status
= sreq
->result
& 0xff;
98 hdr
->transport_status
= host_byte(sreq
->result
);
99 hdr
->driver_status
= 0;
100 if (scsi_status_is_check_condition(sreq
->result
))
101 hdr
->driver_status
= DRIVER_SENSE
;
103 if (hdr
->device_status
|| hdr
->transport_status
|| hdr
->driver_status
)
104 hdr
->info
|= SG_INFO_CHECK
;
105 hdr
->response_len
= 0;
107 if (sreq
->sense_len
&& hdr
->response
) {
108 int len
= min_t(unsigned int, hdr
->max_response_len
,
111 if (copy_to_user(uptr64(hdr
->response
), sreq
->sense
, len
))
114 hdr
->response_len
= len
;
117 if (rq_data_dir(rq
) == READ
)
118 hdr
->din_resid
= sreq
->resid_len
;
120 hdr
->dout_resid
= sreq
->resid_len
;
125 static void bsg_scsi_free_rq(struct request
*rq
)
127 scsi_req_free_cmd(scsi_req(rq
));
130 static const struct bsg_ops bsg_scsi_ops
= {
131 .check_proto
= bsg_scsi_check_proto
,
132 .fill_hdr
= bsg_scsi_fill_hdr
,
133 .complete_rq
= bsg_scsi_complete_rq
,
134 .free_rq
= bsg_scsi_free_rq
,
137 static int bsg_sg_io(struct request_queue
*q
, fmode_t mode
, void __user
*uarg
)
144 if (copy_from_user(&hdr
, uarg
, sizeof(hdr
)))
147 if (!q
->bsg_dev
.class_dev
)
150 if (hdr
.guard
!= 'Q')
152 ret
= q
->bsg_dev
.ops
->check_proto(&hdr
);
156 rq
= blk_get_request(q
, hdr
.dout_xfer_len
?
157 REQ_OP_SCSI_OUT
: REQ_OP_SCSI_IN
, 0);
161 ret
= q
->bsg_dev
.ops
->fill_hdr(rq
, &hdr
, mode
);
167 rq
->timeout
= msecs_to_jiffies(hdr
.timeout
);
169 rq
->timeout
= q
->sg_timeout
;
171 rq
->timeout
= BLK_DEFAULT_SG_TIMEOUT
;
172 if (rq
->timeout
< BLK_MIN_SG_TIMEOUT
)
173 rq
->timeout
= BLK_MIN_SG_TIMEOUT
;
175 if (hdr
.dout_xfer_len
) {
176 ret
= blk_rq_map_user(q
, rq
, NULL
, uptr64(hdr
.dout_xferp
),
177 hdr
.dout_xfer_len
, GFP_KERNEL
);
178 } else if (hdr
.din_xfer_len
) {
179 ret
= blk_rq_map_user(q
, rq
, NULL
, uptr64(hdr
.din_xferp
),
180 hdr
.din_xfer_len
, GFP_KERNEL
);
188 blk_execute_rq(NULL
, rq
, !(hdr
.flags
& BSG_FLAG_Q_AT_TAIL
));
189 ret
= rq
->q
->bsg_dev
.ops
->complete_rq(rq
, &hdr
);
190 blk_rq_unmap_user(bio
);
193 rq
->q
->bsg_dev
.ops
->free_rq(rq
);
195 if (!ret
&& copy_to_user(uarg
, &hdr
, sizeof(hdr
)))
200 static struct bsg_device
*bsg_alloc_device(void)
202 struct bsg_device
*bd
;
204 bd
= kzalloc(sizeof(struct bsg_device
), GFP_KERNEL
);
208 spin_lock_init(&bd
->lock
);
209 bd
->max_queue
= BSG_DEFAULT_CMDS
;
210 INIT_HLIST_NODE(&bd
->dev_list
);
214 static int bsg_put_device(struct bsg_device
*bd
)
216 struct request_queue
*q
= bd
->queue
;
218 mutex_lock(&bsg_mutex
);
220 if (!refcount_dec_and_test(&bd
->ref_count
)) {
221 mutex_unlock(&bsg_mutex
);
225 hlist_del(&bd
->dev_list
);
226 mutex_unlock(&bsg_mutex
);
228 bsg_dbg(bd
, "tearing down\n");
231 * close can always block
238 static struct bsg_device
*bsg_add_device(struct inode
*inode
,
239 struct request_queue
*rq
,
242 struct bsg_device
*bd
;
243 unsigned char buf
[32];
245 lockdep_assert_held(&bsg_mutex
);
247 if (!blk_get_queue(rq
))
248 return ERR_PTR(-ENXIO
);
250 bd
= bsg_alloc_device();
253 return ERR_PTR(-ENOMEM
);
258 refcount_set(&bd
->ref_count
, 1);
259 hlist_add_head(&bd
->dev_list
, bsg_dev_idx_hash(iminor(inode
)));
261 strncpy(bd
->name
, dev_name(rq
->bsg_dev
.class_dev
), sizeof(bd
->name
) - 1);
262 bsg_dbg(bd
, "bound to <%s>, max queue %d\n",
263 format_dev_t(buf
, inode
->i_rdev
), bd
->max_queue
);
268 static struct bsg_device
*__bsg_get_device(int minor
, struct request_queue
*q
)
270 struct bsg_device
*bd
;
272 lockdep_assert_held(&bsg_mutex
);
274 hlist_for_each_entry(bd
, bsg_dev_idx_hash(minor
), dev_list
) {
275 if (bd
->queue
== q
) {
276 refcount_inc(&bd
->ref_count
);
285 static struct bsg_device
*bsg_get_device(struct inode
*inode
, struct file
*file
)
287 struct bsg_device
*bd
;
288 struct bsg_class_device
*bcd
;
291 * find the class device
293 mutex_lock(&bsg_mutex
);
294 bcd
= idr_find(&bsg_minor_idr
, iminor(inode
));
297 bd
= ERR_PTR(-ENODEV
);
301 bd
= __bsg_get_device(iminor(inode
), bcd
->queue
);
303 bd
= bsg_add_device(inode
, bcd
->queue
, file
);
306 mutex_unlock(&bsg_mutex
);
310 static int bsg_open(struct inode
*inode
, struct file
*file
)
312 struct bsg_device
*bd
;
314 bd
= bsg_get_device(inode
, file
);
319 file
->private_data
= bd
;
323 static int bsg_release(struct inode
*inode
, struct file
*file
)
325 struct bsg_device
*bd
= file
->private_data
;
327 file
->private_data
= NULL
;
328 return bsg_put_device(bd
);
331 static int bsg_get_command_q(struct bsg_device
*bd
, int __user
*uarg
)
333 return put_user(bd
->max_queue
, uarg
);
336 static int bsg_set_command_q(struct bsg_device
*bd
, int __user
*uarg
)
340 if (get_user(queue
, uarg
))
345 spin_lock_irq(&bd
->lock
);
346 bd
->max_queue
= queue
;
347 spin_unlock_irq(&bd
->lock
);
351 static long bsg_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
353 struct bsg_device
*bd
= file
->private_data
;
354 void __user
*uarg
= (void __user
*) arg
;
360 case SG_GET_COMMAND_Q
:
361 return bsg_get_command_q(bd
, uarg
);
362 case SG_SET_COMMAND_Q
:
363 return bsg_set_command_q(bd
, uarg
);
368 case SG_GET_VERSION_NUM
:
369 case SCSI_IOCTL_GET_IDLUN
:
370 case SCSI_IOCTL_GET_BUS_NUMBER
:
373 case SG_GET_RESERVED_SIZE
:
374 case SG_SET_RESERVED_SIZE
:
375 case SG_EMULATED_HOST
:
376 case SCSI_IOCTL_SEND_COMMAND
:
377 return scsi_cmd_ioctl(bd
->queue
, NULL
, file
->f_mode
, cmd
, uarg
);
379 return bsg_sg_io(bd
->queue
, file
->f_mode
, uarg
);
385 static const struct file_operations bsg_fops
= {
387 .release
= bsg_release
,
388 .unlocked_ioctl
= bsg_ioctl
,
389 .compat_ioctl
= compat_ptr_ioctl
,
390 .owner
= THIS_MODULE
,
391 .llseek
= default_llseek
,
394 void bsg_unregister_queue(struct request_queue
*q
)
396 struct bsg_class_device
*bcd
= &q
->bsg_dev
;
401 mutex_lock(&bsg_mutex
);
402 idr_remove(&bsg_minor_idr
, bcd
->minor
);
404 sysfs_remove_link(&q
->kobj
, "bsg");
405 device_unregister(bcd
->class_dev
);
406 bcd
->class_dev
= NULL
;
407 mutex_unlock(&bsg_mutex
);
409 EXPORT_SYMBOL_GPL(bsg_unregister_queue
);
411 int bsg_register_queue(struct request_queue
*q
, struct device
*parent
,
412 const char *name
, const struct bsg_ops
*ops
)
414 struct bsg_class_device
*bcd
;
417 struct device
*class_dev
= NULL
;
420 * we need a proper transport to send commands, not a stacked device
426 memset(bcd
, 0, sizeof(*bcd
));
428 mutex_lock(&bsg_mutex
);
430 ret
= idr_alloc(&bsg_minor_idr
, bcd
, 0, BSG_MAX_DEVS
, GFP_KERNEL
);
432 if (ret
== -ENOSPC
) {
433 printk(KERN_ERR
"bsg: too many bsg devices\n");
442 dev
= MKDEV(bsg_major
, bcd
->minor
);
443 class_dev
= device_create(bsg_class
, parent
, dev
, NULL
, "%s", name
);
444 if (IS_ERR(class_dev
)) {
445 ret
= PTR_ERR(class_dev
);
448 bcd
->class_dev
= class_dev
;
451 ret
= sysfs_create_link(&q
->kobj
, &bcd
->class_dev
->kobj
, "bsg");
453 goto unregister_class_dev
;
456 mutex_unlock(&bsg_mutex
);
459 unregister_class_dev
:
460 device_unregister(class_dev
);
462 idr_remove(&bsg_minor_idr
, bcd
->minor
);
464 mutex_unlock(&bsg_mutex
);
468 int bsg_scsi_register_queue(struct request_queue
*q
, struct device
*parent
)
470 if (!blk_queue_scsi_passthrough(q
)) {
471 WARN_ONCE(true, "Attempt to register a non-SCSI queue\n");
475 return bsg_register_queue(q
, parent
, dev_name(parent
), &bsg_scsi_ops
);
477 EXPORT_SYMBOL_GPL(bsg_scsi_register_queue
);
479 static struct cdev bsg_cdev
;
481 static char *bsg_devnode(struct device
*dev
, umode_t
*mode
)
483 return kasprintf(GFP_KERNEL
, "bsg/%s", dev_name(dev
));
486 static int __init
bsg_init(void)
491 for (i
= 0; i
< BSG_LIST_ARRAY_SIZE
; i
++)
492 INIT_HLIST_HEAD(&bsg_device_list
[i
]);
494 bsg_class
= class_create(THIS_MODULE
, "bsg");
495 if (IS_ERR(bsg_class
))
496 return PTR_ERR(bsg_class
);
497 bsg_class
->devnode
= bsg_devnode
;
499 ret
= alloc_chrdev_region(&devid
, 0, BSG_MAX_DEVS
, "bsg");
501 goto destroy_bsg_class
;
503 bsg_major
= MAJOR(devid
);
505 cdev_init(&bsg_cdev
, &bsg_fops
);
506 ret
= cdev_add(&bsg_cdev
, MKDEV(bsg_major
, 0), BSG_MAX_DEVS
);
508 goto unregister_chrdev
;
510 printk(KERN_INFO BSG_DESCRIPTION
" version " BSG_VERSION
511 " loaded (major %d)\n", bsg_major
);
514 unregister_chrdev_region(MKDEV(bsg_major
, 0), BSG_MAX_DEVS
);
516 class_destroy(bsg_class
);
520 MODULE_AUTHOR("Jens Axboe");
521 MODULE_DESCRIPTION(BSG_DESCRIPTION
);
522 MODULE_LICENSE("GPL");
524 device_initcall(bsg_init
);