[linux.git] / block / bsg.c

// SPDX-License-Identifier: GPL-2.0
/*
 * bsg.c - block layer implementation of the sg v4 interface
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/file.h>
#include <linux/blkdev.h>
#include <linux/cdev.h>
#include <linux/jiffies.h>
#include <linux/percpu.h>
#include <linux/idr.h>
#include <linux/bsg.h>
#include <linux/slab.h>

#include <scsi/scsi.h>
#include <scsi/scsi_ioctl.h>
#include <scsi/sg.h>

#define BSG_DESCRIPTION	"Block layer SCSI generic (bsg) driver"
#define BSG_VERSION	"0.4"

struct bsg_device {
	struct request_queue *queue;
	struct device device;
	struct cdev cdev;
	int max_queue;
	unsigned int timeout;
	unsigned int reserved_size;
	bsg_sg_io_fn *sg_io_fn;
};

static inline struct bsg_device *to_bsg_device(struct inode *inode)
{
	return container_of(inode->i_cdev, struct bsg_device, cdev);
}

#define BSG_DEFAULT_CMDS	64
#define BSG_MAX_DEVS		32768

static DEFINE_IDA(bsg_minor_ida);
static struct class *bsg_class;
static int bsg_major;

static unsigned int bsg_timeout(struct bsg_device *bd, struct sg_io_v4 *hdr)
{
	unsigned int timeout = BLK_DEFAULT_SG_TIMEOUT;

	if (hdr->timeout)
		timeout = msecs_to_jiffies(hdr->timeout);
	else if (bd->timeout)
		timeout = bd->timeout;

	return max_t(unsigned int, timeout, BLK_MIN_SG_TIMEOUT);
}

static int bsg_sg_io(struct bsg_device *bd, fmode_t mode, void __user *uarg)
{
	struct sg_io_v4 hdr;
	int ret;

	if (copy_from_user(&hdr, uarg, sizeof(hdr)))
		return -EFAULT;
	if (hdr.guard != 'Q')
		return -EINVAL;
	ret = bd->sg_io_fn(bd->queue, &hdr, mode, bsg_timeout(bd, &hdr));
	if (!ret && copy_to_user(uarg, &hdr, sizeof(hdr)))
		return -EFAULT;
	return ret;
}

static int bsg_open(struct inode *inode, struct file *file)
{
	if (!blk_get_queue(to_bsg_device(inode)->queue))
		return -ENXIO;
	return 0;
}

static int bsg_release(struct inode *inode, struct file *file)
{
	blk_put_queue(to_bsg_device(inode)->queue);
	return 0;
}

static int bsg_get_command_q(struct bsg_device *bd, int __user *uarg)
{
	return put_user(READ_ONCE(bd->max_queue), uarg);
}

static int bsg_set_command_q(struct bsg_device *bd, int __user *uarg)
{
	int max_queue;

	if (get_user(max_queue, uarg))
		return -EFAULT;
	if (max_queue < 1)
		return -EINVAL;
	WRITE_ONCE(bd->max_queue, max_queue);
	return 0;
}

static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct bsg_device *bd = to_bsg_device(file_inode(file));
	struct request_queue *q = bd->queue;
	void __user *uarg = (void __user *) arg;
	int __user *intp = uarg;
	int val;

	switch (cmd) {
	/*
	 * Our own ioctls
	 */
	case SG_GET_COMMAND_Q:
		return bsg_get_command_q(bd, uarg);
	case SG_SET_COMMAND_Q:
		return bsg_set_command_q(bd, uarg);

	/*
	 * SCSI/sg ioctls
	 */
	case SG_GET_VERSION_NUM:
		return put_user(30527, intp);
	case SCSI_IOCTL_GET_IDLUN:
		return put_user(0, intp);
	case SCSI_IOCTL_GET_BUS_NUMBER:
		return put_user(0, intp);
	case SG_SET_TIMEOUT:
		if (get_user(val, intp))
			return -EFAULT;
		bd->timeout = clock_t_to_jiffies(val);
		return 0;
	case SG_GET_TIMEOUT:
		return jiffies_to_clock_t(bd->timeout);
	case SG_GET_RESERVED_SIZE:
		return put_user(min(bd->reserved_size, queue_max_bytes(q)),
				intp);
	case SG_SET_RESERVED_SIZE:
		if (get_user(val, intp))
			return -EFAULT;
		if (val < 0)
			return -EINVAL;
		bd->reserved_size =
			min_t(unsigned int, val, queue_max_bytes(q));
		return 0;
	case SG_EMULATED_HOST:
		return put_user(1, intp);
	case SG_IO:
		return bsg_sg_io(bd, file->f_mode, uarg);
	case SCSI_IOCTL_SEND_COMMAND:
		pr_warn_ratelimited("%s: calling unsupported SCSI_IOCTL_SEND_COMMAND\n",
				current->comm);
		return -EINVAL;
	default:
		return -ENOTTY;
	}
}

static const struct file_operations bsg_fops = {
	.open		=	bsg_open,
	.release	=	bsg_release,
	.unlocked_ioctl	=	bsg_ioctl,
	.compat_ioctl	=	compat_ptr_ioctl,
	.owner		=	THIS_MODULE,
	.llseek		=	default_llseek,
};

static void bsg_device_release(struct device *dev)
{
	struct bsg_device *bd = container_of(dev, struct bsg_device, device);

	ida_free(&bsg_minor_ida, MINOR(bd->device.devt));
	kfree(bd);
}

void bsg_unregister_queue(struct bsg_device *bd)
{
	struct gendisk *disk = bd->queue->disk;

	if (disk && disk->queue_kobj.sd)
		sysfs_remove_link(&disk->queue_kobj, "bsg");
	cdev_device_del(&bd->cdev, &bd->device);
	put_device(&bd->device);
}
EXPORT_SYMBOL_GPL(bsg_unregister_queue);

struct bsg_device *bsg_register_queue(struct request_queue *q,
		struct device *parent, const char *name, bsg_sg_io_fn *sg_io_fn)
{
	struct bsg_device *bd;
	int ret;

	bd = kzalloc(sizeof(*bd), GFP_KERNEL);
	if (!bd)
		return ERR_PTR(-ENOMEM);
	bd->max_queue = BSG_DEFAULT_CMDS;
	bd->reserved_size = INT_MAX;
	bd->queue = q;
	bd->sg_io_fn = sg_io_fn;

	ret = ida_alloc_max(&bsg_minor_ida, BSG_MAX_DEVS - 1, GFP_KERNEL);
	if (ret < 0) {
		if (ret == -ENOSPC)
			dev_err(parent, "bsg: too many bsg devices\n");
		kfree(bd);
		return ERR_PTR(ret);
	}
	bd->device.devt = MKDEV(bsg_major, ret);
	bd->device.class = bsg_class;
	bd->device.parent = parent;
	bd->device.release = bsg_device_release;
	dev_set_name(&bd->device, "%s", name);
	device_initialize(&bd->device);

	cdev_init(&bd->cdev, &bsg_fops);
	bd->cdev.owner = THIS_MODULE;
	ret = cdev_device_add(&bd->cdev, &bd->device);
	if (ret)
		goto out_put_device;

	if (q->disk && q->disk->queue_kobj.sd) {
		ret = sysfs_create_link(&q->disk->queue_kobj, &bd->device.kobj,
					"bsg");
		if (ret)
			goto out_device_del;
	}

	return bd;

out_device_del:
	cdev_device_del(&bd->cdev, &bd->device);
out_put_device:
	put_device(&bd->device);
	return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(bsg_register_queue);

static char *bsg_devnode(const struct device *dev, umode_t *mode)
{
	return kasprintf(GFP_KERNEL, "bsg/%s", dev_name(dev));
}

static int __init bsg_init(void)
{
	dev_t devid;
	int ret;

	bsg_class = class_create(THIS_MODULE, "bsg");
	if (IS_ERR(bsg_class))
		return PTR_ERR(bsg_class);
	bsg_class->devnode = bsg_devnode;

	ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
	if (ret)
		goto destroy_bsg_class;
	bsg_major = MAJOR(devid);

	printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
	       " loaded (major %d)\n", bsg_major);
	return 0;

destroy_bsg_class:
	class_destroy(bsg_class);
	return ret;
}

MODULE_AUTHOR("Jens Axboe");
MODULE_DESCRIPTION(BSG_DESCRIPTION);
MODULE_LICENSE("GPL");

device_initcall(bsg_init);
Commit	Line	Data
8c16567d	1	// SPDX-License-Identifier: GPL-2.0
3d6392cf	2	/*
0c6a89ba	3	* bsg.c - block layer implementation of the sg v4 interface
3d6392cf	4	*/
3d6392cf JA	5	#include <linux/module.h>
	6	#include <linux/init.h>
	7	#include <linux/file.h>
	8	#include <linux/blkdev.h>
3d6392cf	9	#include <linux/cdev.h>
ad5ebd2f	10	#include <linux/jiffies.h>
3d6392cf	11	#include <linux/percpu.h>
598443a2	12	#include <linux/idr.h>
3d6392cf	13	#include <linux/bsg.h>
5a0e3ad6	14	#include <linux/slab.h>
3d6392cf JA	15
	16	#include <scsi/scsi.h>
	17	#include <scsi/scsi_ioctl.h>
3d6392cf JA	18	#include <scsi/sg.h>
3d6392cf JA	19
0ed081ce FT	20	#define BSG_DESCRIPTION "Block layer SCSI generic (bsg) driver"
0ed081ce FT	21	#define BSG_VERSION "0.4"
3d6392cf	22
3d6392cf	23	struct bsg_device {
165125e1	24	struct request_queue *queue;
ead09dd3 CH	25	struct device device;
ead09dd3 CH	26	struct cdev cdev;
3d6392cf	27	int max_queue;
1e61c1a8 CH	28	unsigned int timeout;
1e61c1a8 CH	29	unsigned int reserved_size;
75ca5640	30	bsg_sg_io_fn *sg_io_fn;
3d6392cf JA	31	};
3d6392cf JA	32
ead09dd3 CH	33	static inline struct bsg_device to_bsg_device(struct inode inode)
	34	{
	35	return container_of(inode->i_cdev, struct bsg_device, cdev);
	36	}
	37
5309cb38	38	#define BSG_DEFAULT_CMDS 64
292b7f27	39	#define BSG_MAX_DEVS 32768
3d6392cf	40
ead09dd3	41	static DEFINE_IDA(bsg_minor_ida);
3d6392cf	42	static struct class *bsg_class;
46f6ef4a	43	static int bsg_major;
3d6392cf	44
75ca5640 CH	45	static unsigned int bsg_timeout(struct bsg_device bd, struct sg_io_v4 hdr)
	46	{
	47	unsigned int timeout = BLK_DEFAULT_SG_TIMEOUT;
	48
	49	if (hdr->timeout)
	50	timeout = msecs_to_jiffies(hdr->timeout);
	51	else if (bd->timeout)
	52	timeout = bd->timeout;
	53
	54	return max_t(unsigned int, timeout, BLK_MIN_SG_TIMEOUT);
	55	}
17cb960f	56
ead09dd3	57	static int bsg_sg_io(struct bsg_device bd, fmode_t mode, void __user uarg)
3d6392cf	58	{
ccf3209f	59	struct sg_io_v4 hdr;
aebf526b	60	int ret;
c7a841f3	61
ccf3209f CH	62	if (copy_from_user(&hdr, uarg, sizeof(hdr)))
ccf3209f CH	63	return -EFAULT;
ccf3209f CH	64	if (hdr.guard != 'Q')
ccf3209f CH	65	return -EINVAL;
75ca5640	66	ret = bd->sg_io_fn(bd->queue, &hdr, mode, bsg_timeout(bd, &hdr));
972248e9	67	if (!ret && copy_to_user(uarg, &hdr, sizeof(hdr)))
ccf3209f CH	68	return -EFAULT;
ccf3209f CH	69	return ret;
70e36ece FT	70	}
70e36ece FT	71
3d6392cf JA	72	static int bsg_open(struct inode inode, struct file file)
3d6392cf JA	73	{
ead09dd3 CH	74	if (!blk_get_queue(to_bsg_device(inode)->queue))
ead09dd3 CH	75	return -ENXIO;
3d6392cf JA	76	return 0;
	77	}
	78
	79	static int bsg_release(struct inode inode, struct file file)
	80	{
ead09dd3 CH	81	blk_put_queue(to_bsg_device(inode)->queue);
ead09dd3 CH	82	return 0;
3d6392cf JA	83	}
3d6392cf JA	84
ccf3209f CH	85	static int bsg_get_command_q(struct bsg_device bd, int __user uarg)
ccf3209f CH	86	{
ead09dd3	87	return put_user(READ_ONCE(bd->max_queue), uarg);
ccf3209f CH	88	}
	89
	90	static int bsg_set_command_q(struct bsg_device bd, int __user uarg)
	91	{
ead09dd3	92	int max_queue;
ccf3209f	93
ead09dd3	94	if (get_user(max_queue, uarg))
ccf3209f	95	return -EFAULT;
ead09dd3	96	if (max_queue < 1)
ccf3209f	97	return -EINVAL;
ead09dd3	98	WRITE_ONCE(bd->max_queue, max_queue);
ccf3209f CH	99	return 0;
	100	}
	101
25fd1643	102	static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3d6392cf	103	{
ead09dd3	104	struct bsg_device *bd = to_bsg_device(file_inode(file));
d52fe8f4	105	struct request_queue *q = bd->queue;
ccf3209f	106	void __user uarg = (void __user ) arg;
d52fe8f4 CH	107	int __user *intp = uarg;
d52fe8f4 CH	108	int val;
3d6392cf	109
3d6392cf	110	switch (cmd) {
ccf3209f CH	111	/*
	112	* Our own ioctls
	113	*/
3d6392cf	114	case SG_GET_COMMAND_Q:
ccf3209f CH	115	return bsg_get_command_q(bd, uarg);
	116	case SG_SET_COMMAND_Q:
	117	return bsg_set_command_q(bd, uarg);
3d6392cf JA	118
	119	/*
	120	* SCSI/sg ioctls
	121	*/
	122	case SG_GET_VERSION_NUM:
d52fe8f4	123	return put_user(30527, intp);
3d6392cf	124	case SCSI_IOCTL_GET_IDLUN:
d52fe8f4	125	return put_user(0, intp);
3d6392cf	126	case SCSI_IOCTL_GET_BUS_NUMBER:
d52fe8f4	127	return put_user(0, intp);
3d6392cf	128	case SG_SET_TIMEOUT:
d52fe8f4 CH	129	if (get_user(val, intp))
d52fe8f4 CH	130	return -EFAULT;
1e61c1a8	131	bd->timeout = clock_t_to_jiffies(val);
d52fe8f4	132	return 0;
3d6392cf	133	case SG_GET_TIMEOUT:
1e61c1a8	134	return jiffies_to_clock_t(bd->timeout);
3d6392cf	135	case SG_GET_RESERVED_SIZE:
1e61c1a8	136	return put_user(min(bd->reserved_size, queue_max_bytes(q)),
d52fe8f4	137	intp);
3d6392cf	138	case SG_SET_RESERVED_SIZE:
d52fe8f4 CH	139	if (get_user(val, intp))
	140	return -EFAULT;
	141	if (val < 0)
	142	return -EINVAL;
1e61c1a8	143	bd->reserved_size =
d52fe8f4 CH	144	min_t(unsigned int, val, queue_max_bytes(q));
d52fe8f4 CH	145	return 0;
3d6392cf	146	case SG_EMULATED_HOST:
d52fe8f4	147	return put_user(1, intp);
ccf3209f	148	case SG_IO:
ead09dd3	149	return bsg_sg_io(bd, file->f_mode, uarg);
beec64d0 CH	150	case SCSI_IOCTL_SEND_COMMAND:
	151	pr_warn_ratelimited("%s: calling unsupported SCSI_IOCTL_SEND_COMMAND\n",
	152	current->comm);
	153	return -EINVAL;
3d6392cf	154	default:
3d6392cf	155	return -ENOTTY;
3d6392cf JA	156	}
	157	}
	158
7344be05	159	static const struct file_operations bsg_fops = {
3d6392cf JA	160	.open = bsg_open,
3d6392cf JA	161	.release = bsg_release,
25fd1643	162	.unlocked_ioctl = bsg_ioctl,
fe0da4e5	163	.compat_ioctl = compat_ptr_ioctl,
3d6392cf	164	.owner = THIS_MODULE,
6038f373	165	.llseek = default_llseek,
3d6392cf JA	166	};
3d6392cf JA	167
1a0db774 ZY	168	static void bsg_device_release(struct device *dev)
	169	{
	170	struct bsg_device *bd = container_of(dev, struct bsg_device, device);
	171
873cdda1	172	ida_free(&bsg_minor_ida, MINOR(bd->device.devt));
1a0db774 ZY	173	kfree(bd);
	174	}
	175
ead09dd3	176	void bsg_unregister_queue(struct bsg_device *bd)
3d6392cf	177	{
2bd85221 CH	178	struct gendisk *disk = bd->queue->disk;
	179
	180	if (disk && disk->queue_kobj.sd)
	181	sysfs_remove_link(&disk->queue_kobj, "bsg");
ead09dd3	182	cdev_device_del(&bd->cdev, &bd->device);
1a0db774	183	put_device(&bd->device);
3d6392cf	184	}
4cf0723a	185	EXPORT_SYMBOL_GPL(bsg_unregister_queue);
3d6392cf	186
ead09dd3	187	struct bsg_device bsg_register_queue(struct request_queue q,
75ca5640	188	struct device parent, const char name, bsg_sg_io_fn *sg_io_fn)
3d6392cf	189	{
ead09dd3	190	struct bsg_device *bd;
bab998d6	191	int ret;
3d6392cf	192
ead09dd3 CH	193	bd = kzalloc(sizeof(*bd), GFP_KERNEL);
	194	if (!bd)
	195	return ERR_PTR(-ENOMEM);
	196	bd->max_queue = BSG_DEFAULT_CMDS;
1e61c1a8	197	bd->reserved_size = INT_MAX;
ead09dd3	198	bd->queue = q;
75ca5640	199	bd->sg_io_fn = sg_io_fn;
292b7f27	200
873cdda1	201	ret = ida_alloc_max(&bsg_minor_ida, BSG_MAX_DEVS - 1, GFP_KERNEL);
bab998d6	202	if (ret < 0) {
ead09dd3 CH	203	if (ret == -ENOSPC)
ead09dd3 CH	204	dev_err(parent, "bsg: too many bsg devices\n");
1a0db774 ZY	205	kfree(bd);
1a0db774 ZY	206	return ERR_PTR(ret);
4e2872d6	207	}
ead09dd3 CH	208	bd->device.devt = MKDEV(bsg_major, ret);
	209	bd->device.class = bsg_class;
	210	bd->device.parent = parent;
1a0db774	211	bd->device.release = bsg_device_release;
ead09dd3 CH	212	dev_set_name(&bd->device, "%s", name);
	213	device_initialize(&bd->device);
	214
	215	cdev_init(&bd->cdev, &bsg_fops);
	216	bd->cdev.owner = THIS_MODULE;
	217	ret = cdev_device_add(&bd->cdev, &bd->device);
	218	if (ret)
1a0db774	219	goto out_put_device;
4e2872d6	220
2bd85221 CH	221	if (q->disk && q->disk->queue_kobj.sd) {
	222	ret = sysfs_create_link(&q->disk->queue_kobj, &bd->device.kobj,
	223	"bsg");
4e2872d6	224	if (ret)
ead09dd3	225	goto out_device_del;
4e2872d6 FT	226	}
4e2872d6 FT	227
ead09dd3	228	return bd;
6826ee4f	229
ead09dd3 CH	230	out_device_del:
ead09dd3 CH	231	cdev_device_del(&bd->cdev, &bd->device);
1a0db774 ZY	232	out_put_device:
1a0db774 ZY	233	put_device(&bd->device);
ead09dd3	234	return ERR_PTR(ret);
4e2872d6	235	}
78011042	236	EXPORT_SYMBOL_GPL(bsg_register_queue);
4e2872d6	237
ff62b8e6	238	static char bsg_devnode(const struct device dev, umode_t *mode)
2bdf9149 KS	239	{
	240	return kasprintf(GFP_KERNEL, "bsg/%s", dev_name(dev));
	241	}
	242
3d6392cf JA	243	static int __init bsg_init(void)
3d6392cf JA	244	{
46f6ef4a	245	dev_t devid;
ead09dd3	246	int ret;
3d6392cf JA	247
3d6392cf JA	248	bsg_class = class_create(THIS_MODULE, "bsg");
28519c89 CH	249	if (IS_ERR(bsg_class))
28519c89 CH	250	return PTR_ERR(bsg_class);
e454cea2	251	bsg_class->devnode = bsg_devnode;
3d6392cf	252
46f6ef4a	253	ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
9b9f770c FT	254	if (ret)
9b9f770c FT	255	goto destroy_bsg_class;
46f6ef4a JA	256	bsg_major = MAJOR(devid);
46f6ef4a JA	257
5d3a8cd3	258	printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
0ed081ce	259	" loaded (major %d)\n", bsg_major);
3d6392cf	260	return 0;
ead09dd3	261
9b9f770c FT	262	destroy_bsg_class:
9b9f770c FT	263	class_destroy(bsg_class);
9b9f770c	264	return ret;
3d6392cf JA	265	}
	266
	267	MODULE_AUTHOR("Jens Axboe");
0ed081ce	268	MODULE_DESCRIPTION(BSG_DESCRIPTION);
3d6392cf JA	269	MODULE_LICENSE("GPL");
3d6392cf JA	270
4e2872d6	271	device_initcall(bsg_init);