xref: /kernel/linux/linux-5.10/block/bsg.c (revision 8c2ecf20) 
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * bsg.c - block layer implementation of the sg v4 interface
4 */
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>
15
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>
21#include <scsi/sg.h>
22
23#define BSG_DESCRIPTION	"Block layer SCSI generic (bsg) driver"
24#define BSG_VERSION	"0.4"
25
26#define bsg_dbg(bd, fmt, ...) \
27	pr_debug("%s: " fmt, (bd)->name, ##__VA_ARGS__)
28
29struct bsg_device {
30	struct request_queue *queue;
31	spinlock_t lock;
32	struct hlist_node dev_list;
33	refcount_t ref_count;
34	char name[20];
35	int max_queue;
36};
37
38#define BSG_DEFAULT_CMDS	64
39#define BSG_MAX_DEVS		32768
40
41static DEFINE_MUTEX(bsg_mutex);
42static DEFINE_IDR(bsg_minor_idr);
43
44#define BSG_LIST_ARRAY_SIZE	8
45static struct hlist_head bsg_device_list[BSG_LIST_ARRAY_SIZE];
46
47static struct class *bsg_class;
48static int bsg_major;
49
50static inline struct hlist_head *bsg_dev_idx_hash(int index)
51{
52	return &bsg_device_list[index & (BSG_LIST_ARRAY_SIZE - 1)];
53}
54
55#define uptr64(val) ((void __user *)(uintptr_t)(val))
56
57static int bsg_scsi_check_proto(struct sg_io_v4 *hdr)
58{
59	if (hdr->protocol != BSG_PROTOCOL_SCSI  ||
60	    hdr->subprotocol != BSG_SUB_PROTOCOL_SCSI_CMD)
61		return -EINVAL;
62	return 0;
63}
64
65static int bsg_scsi_fill_hdr(struct request *rq, struct sg_io_v4 *hdr,
66		fmode_t mode)
67{
68	struct scsi_request *sreq = scsi_req(rq);
69
70	if (hdr->dout_xfer_len && hdr->din_xfer_len) {
71		pr_warn_once("BIDI support in bsg has been removed.\n");
72		return -EOPNOTSUPP;
73	}
74
75	sreq->cmd_len = hdr->request_len;
76	if (sreq->cmd_len > BLK_MAX_CDB) {
77		sreq->cmd = kzalloc(sreq->cmd_len, GFP_KERNEL);
78		if (!sreq->cmd)
79			return -ENOMEM;
80	}
81
82	if (copy_from_user(sreq->cmd, uptr64(hdr->request), sreq->cmd_len))
83		return -EFAULT;
84	if (blk_verify_command(sreq->cmd, mode))
85		return -EPERM;
86	return 0;
87}
88
89static int bsg_scsi_complete_rq(struct request *rq, struct sg_io_v4 *hdr)
90{
91	struct scsi_request *sreq = scsi_req(rq);
92	int ret = 0;
93
94	/*
95	 * fill in all the output members
96	 */
97	hdr->device_status = sreq->result & 0xff;
98	hdr->transport_status = host_byte(sreq->result);
99	hdr->driver_status = driver_byte(sreq->result);
100	hdr->info = 0;
101	if (hdr->device_status || hdr->transport_status || hdr->driver_status)
102		hdr->info |= SG_INFO_CHECK;
103	hdr->response_len = 0;
104
105	if (sreq->sense_len && hdr->response) {
106		int len = min_t(unsigned int, hdr->max_response_len,
107					sreq->sense_len);
108
109		if (copy_to_user(uptr64(hdr->response), sreq->sense, len))
110			ret = -EFAULT;
111		else
112			hdr->response_len = len;
113	}
114
115	if (rq_data_dir(rq) == READ)
116		hdr->din_resid = sreq->resid_len;
117	else
118		hdr->dout_resid = sreq->resid_len;
119
120	return ret;
121}
122
123static void bsg_scsi_free_rq(struct request *rq)
124{
125	scsi_req_free_cmd(scsi_req(rq));
126}
127
128static const struct bsg_ops bsg_scsi_ops = {
129	.check_proto		= bsg_scsi_check_proto,
130	.fill_hdr		= bsg_scsi_fill_hdr,
131	.complete_rq		= bsg_scsi_complete_rq,
132	.free_rq		= bsg_scsi_free_rq,
133};
134
135static int bsg_sg_io(struct request_queue *q, fmode_t mode, void __user *uarg)
136{
137	struct request *rq;
138	struct bio *bio;
139	struct sg_io_v4 hdr;
140	int ret;
141
142	if (copy_from_user(&hdr, uarg, sizeof(hdr)))
143		return -EFAULT;
144
145	if (!q->bsg_dev.class_dev)
146		return -ENXIO;
147
148	if (hdr.guard != 'Q')
149		return -EINVAL;
150	ret = q->bsg_dev.ops->check_proto(&hdr);
151	if (ret)
152		return ret;
153
154	rq = blk_get_request(q, hdr.dout_xfer_len ?
155			REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
156	if (IS_ERR(rq))
157		return PTR_ERR(rq);
158
159	ret = q->bsg_dev.ops->fill_hdr(rq, &hdr, mode);
160	if (ret) {
161		blk_put_request(rq);
162		return ret;
163	}
164
165	rq->timeout = msecs_to_jiffies(hdr.timeout);
166	if (!rq->timeout)
167		rq->timeout = q->sg_timeout;
168	if (!rq->timeout)
169		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
170	if (rq->timeout < BLK_MIN_SG_TIMEOUT)
171		rq->timeout = BLK_MIN_SG_TIMEOUT;
172
173	if (hdr.dout_xfer_len) {
174		ret = blk_rq_map_user(q, rq, NULL, uptr64(hdr.dout_xferp),
175				hdr.dout_xfer_len, GFP_KERNEL);
176	} else if (hdr.din_xfer_len) {
177		ret = blk_rq_map_user(q, rq, NULL, uptr64(hdr.din_xferp),
178				hdr.din_xfer_len, GFP_KERNEL);
179	}
180
181	if (ret)
182		goto out_free_rq;
183
184	bio = rq->bio;
185
186	blk_execute_rq(q, NULL, rq, !(hdr.flags & BSG_FLAG_Q_AT_TAIL));
187	ret = rq->q->bsg_dev.ops->complete_rq(rq, &hdr);
188	blk_rq_unmap_user(bio);
189
190out_free_rq:
191	rq->q->bsg_dev.ops->free_rq(rq);
192	blk_put_request(rq);
193	if (!ret && copy_to_user(uarg, &hdr, sizeof(hdr)))
194		return -EFAULT;
195	return ret;
196}
197
198static struct bsg_device *bsg_alloc_device(void)
199{
200	struct bsg_device *bd;
201
202	bd = kzalloc(sizeof(struct bsg_device), GFP_KERNEL);
203	if (unlikely(!bd))
204		return NULL;
205
206	spin_lock_init(&bd->lock);
207	bd->max_queue = BSG_DEFAULT_CMDS;
208	INIT_HLIST_NODE(&bd->dev_list);
209	return bd;
210}
211
212static int bsg_put_device(struct bsg_device *bd)
213{
214	struct request_queue *q = bd->queue;
215
216	mutex_lock(&bsg_mutex);
217
218	if (!refcount_dec_and_test(&bd->ref_count)) {
219		mutex_unlock(&bsg_mutex);
220		return 0;
221	}
222
223	hlist_del(&bd->dev_list);
224	mutex_unlock(&bsg_mutex);
225
226	bsg_dbg(bd, "tearing down\n");
227
228	/*
229	 * close can always block
230	 */
231	kfree(bd);
232	blk_put_queue(q);
233	return 0;
234}
235
236static struct bsg_device *bsg_add_device(struct inode *inode,
237					 struct request_queue *rq,
238					 struct file *file)
239{
240	struct bsg_device *bd;
241	unsigned char buf[32];
242
243	lockdep_assert_held(&bsg_mutex);
244
245	if (!blk_get_queue(rq))
246		return ERR_PTR(-ENXIO);
247
248	bd = bsg_alloc_device();
249	if (!bd) {
250		blk_put_queue(rq);
251		return ERR_PTR(-ENOMEM);
252	}
253
254	bd->queue = rq;
255
256	refcount_set(&bd->ref_count, 1);
257	hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
258
259	strncpy(bd->name, dev_name(rq->bsg_dev.class_dev), sizeof(bd->name) - 1);
260	bsg_dbg(bd, "bound to <%s>, max queue %d\n",
261		format_dev_t(buf, inode->i_rdev), bd->max_queue);
262
263	return bd;
264}
265
266static struct bsg_device *__bsg_get_device(int minor, struct request_queue *q)
267{
268	struct bsg_device *bd;
269
270	lockdep_assert_held(&bsg_mutex);
271
272	hlist_for_each_entry(bd, bsg_dev_idx_hash(minor), dev_list) {
273		if (bd->queue == q) {
274			refcount_inc(&bd->ref_count);
275			goto found;
276		}
277	}
278	bd = NULL;
279found:
280	return bd;
281}
282
283static struct bsg_device *bsg_get_device(struct inode *inode, struct file *file)
284{
285	struct bsg_device *bd;
286	struct bsg_class_device *bcd;
287
288	/*
289	 * find the class device
290	 */
291	mutex_lock(&bsg_mutex);
292	bcd = idr_find(&bsg_minor_idr, iminor(inode));
293
294	if (!bcd) {
295		bd = ERR_PTR(-ENODEV);
296		goto out_unlock;
297	}
298
299	bd = __bsg_get_device(iminor(inode), bcd->queue);
300	if (!bd)
301		bd = bsg_add_device(inode, bcd->queue, file);
302
303out_unlock:
304	mutex_unlock(&bsg_mutex);
305	return bd;
306}
307
308static int bsg_open(struct inode *inode, struct file *file)
309{
310	struct bsg_device *bd;
311
312	bd = bsg_get_device(inode, file);
313
314	if (IS_ERR(bd))
315		return PTR_ERR(bd);
316
317	file->private_data = bd;
318	return 0;
319}
320
321static int bsg_release(struct inode *inode, struct file *file)
322{
323	struct bsg_device *bd = file->private_data;
324
325	file->private_data = NULL;
326	return bsg_put_device(bd);
327}
328
329static int bsg_get_command_q(struct bsg_device *bd, int __user *uarg)
330{
331	return put_user(bd->max_queue, uarg);
332}
333
334static int bsg_set_command_q(struct bsg_device *bd, int __user *uarg)
335{
336	int queue;
337
338	if (get_user(queue, uarg))
339		return -EFAULT;
340	if (queue < 1)
341		return -EINVAL;
342
343	spin_lock_irq(&bd->lock);
344	bd->max_queue = queue;
345	spin_unlock_irq(&bd->lock);
346	return 0;
347}
348
349static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
350{
351	struct bsg_device *bd = file->private_data;
352	void __user *uarg = (void __user *) arg;
353
354	switch (cmd) {
355	/*
356	 * Our own ioctls
357	 */
358	case SG_GET_COMMAND_Q:
359		return bsg_get_command_q(bd, uarg);
360	case SG_SET_COMMAND_Q:
361		return bsg_set_command_q(bd, uarg);
362
363	/*
364	 * SCSI/sg ioctls
365	 */
366	case SG_GET_VERSION_NUM:
367	case SCSI_IOCTL_GET_IDLUN:
368	case SCSI_IOCTL_GET_BUS_NUMBER:
369	case SG_SET_TIMEOUT:
370	case SG_GET_TIMEOUT:
371	case SG_GET_RESERVED_SIZE:
372	case SG_SET_RESERVED_SIZE:
373	case SG_EMULATED_HOST:
374		return scsi_cmd_ioctl(bd->queue, NULL, file->f_mode, cmd, uarg);
375	case SG_IO:
376		return bsg_sg_io(bd->queue, file->f_mode, uarg);
377	case SCSI_IOCTL_SEND_COMMAND:
378		pr_warn_ratelimited("%s: calling unsupported SCSI_IOCTL_SEND_COMMAND\n",
379				current->comm);
380		return -EINVAL;
381	default:
382		return -ENOTTY;
383	}
384}
385
386static const struct file_operations bsg_fops = {
387	.open		=	bsg_open,
388	.release	=	bsg_release,
389	.unlocked_ioctl	=	bsg_ioctl,
390	.compat_ioctl	=	compat_ptr_ioctl,
391	.owner		=	THIS_MODULE,
392	.llseek		=	default_llseek,
393};
394
395void bsg_unregister_queue(struct request_queue *q)
396{
397	struct bsg_class_device *bcd = &q->bsg_dev;
398
399	if (!bcd->class_dev)
400		return;
401
402	mutex_lock(&bsg_mutex);
403	idr_remove(&bsg_minor_idr, bcd->minor);
404	if (q->kobj.sd)
405		sysfs_remove_link(&q->kobj, "bsg");
406	device_unregister(bcd->class_dev);
407	bcd->class_dev = NULL;
408	mutex_unlock(&bsg_mutex);
409}
410EXPORT_SYMBOL_GPL(bsg_unregister_queue);
411
412int bsg_register_queue(struct request_queue *q, struct device *parent,
413		const char *name, const struct bsg_ops *ops)
414{
415	struct bsg_class_device *bcd;
416	dev_t dev;
417	int ret;
418	struct device *class_dev = NULL;
419
420	/*
421	 * we need a proper transport to send commands, not a stacked device
422	 */
423	if (!queue_is_mq(q))
424		return 0;
425
426	bcd = &q->bsg_dev;
427	memset(bcd, 0, sizeof(*bcd));
428
429	mutex_lock(&bsg_mutex);
430
431	ret = idr_alloc(&bsg_minor_idr, bcd, 0, BSG_MAX_DEVS, GFP_KERNEL);
432	if (ret < 0) {
433		if (ret == -ENOSPC) {
434			printk(KERN_ERR "bsg: too many bsg devices\n");
435			ret = -EINVAL;
436		}
437		goto unlock;
438	}
439
440	bcd->minor = ret;
441	bcd->queue = q;
442	bcd->ops = ops;
443	dev = MKDEV(bsg_major, bcd->minor);
444	class_dev = device_create(bsg_class, parent, dev, NULL, "%s", name);
445	if (IS_ERR(class_dev)) {
446		ret = PTR_ERR(class_dev);
447		goto idr_remove;
448	}
449	bcd->class_dev = class_dev;
450
451	if (q->kobj.sd) {
452		ret = sysfs_create_link(&q->kobj, &bcd->class_dev->kobj, "bsg");
453		if (ret)
454			goto unregister_class_dev;
455	}
456
457	mutex_unlock(&bsg_mutex);
458	return 0;
459
460unregister_class_dev:
461	device_unregister(class_dev);
462idr_remove:
463	idr_remove(&bsg_minor_idr, bcd->minor);
464unlock:
465	mutex_unlock(&bsg_mutex);
466	return ret;
467}
468
469int bsg_scsi_register_queue(struct request_queue *q, struct device *parent)
470{
471	if (!blk_queue_scsi_passthrough(q)) {
472		WARN_ONCE(true, "Attempt to register a non-SCSI queue\n");
473		return -EINVAL;
474	}
475
476	return bsg_register_queue(q, parent, dev_name(parent), &bsg_scsi_ops);
477}
478EXPORT_SYMBOL_GPL(bsg_scsi_register_queue);
479
480static struct cdev bsg_cdev;
481
482static char *bsg_devnode(struct device *dev, umode_t *mode)
483{
484	return kasprintf(GFP_KERNEL, "bsg/%s", dev_name(dev));
485}
486
487static int __init bsg_init(void)
488{
489	int ret, i;
490	dev_t devid;
491
492	for (i = 0; i < BSG_LIST_ARRAY_SIZE; i++)
493		INIT_HLIST_HEAD(&bsg_device_list[i]);
494
495	bsg_class = class_create(THIS_MODULE, "bsg");
496	if (IS_ERR(bsg_class))
497		return PTR_ERR(bsg_class);
498	bsg_class->devnode = bsg_devnode;
499
500	ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
501	if (ret)
502		goto destroy_bsg_class;
503
504	bsg_major = MAJOR(devid);
505
506	cdev_init(&bsg_cdev, &bsg_fops);
507	ret = cdev_add(&bsg_cdev, MKDEV(bsg_major, 0), BSG_MAX_DEVS);
508	if (ret)
509		goto unregister_chrdev;
510
511	printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
512	       " loaded (major %d)\n", bsg_major);
513	return 0;
514unregister_chrdev:
515	unregister_chrdev_region(MKDEV(bsg_major, 0), BSG_MAX_DEVS);
516destroy_bsg_class:
517	class_destroy(bsg_class);
518	return ret;
519}
520
521MODULE_AUTHOR("Jens Axboe");
522MODULE_DESCRIPTION(BSG_DESCRIPTION);
523MODULE_LICENSE("GPL");
524
525device_initcall(bsg_init);
526