linux/block/bsg.c
<<
>>
Prefs
   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                return ret;
 162
 163        rq->timeout = msecs_to_jiffies(hdr.timeout);
 164        if (!rq->timeout)
 165                rq->timeout = q->sg_timeout;
 166        if (!rq->timeout)
 167                rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
 168        if (rq->timeout < BLK_MIN_SG_TIMEOUT)
 169                rq->timeout = BLK_MIN_SG_TIMEOUT;
 170
 171        if (hdr.dout_xfer_len) {
 172                ret = blk_rq_map_user(q, rq, NULL, uptr64(hdr.dout_xferp),
 173                                hdr.dout_xfer_len, GFP_KERNEL);
 174        } else if (hdr.din_xfer_len) {
 175                ret = blk_rq_map_user(q, rq, NULL, uptr64(hdr.din_xferp),
 176                                hdr.din_xfer_len, GFP_KERNEL);
 177        }
 178
 179        if (ret)
 180                goto out_free_rq;
 181
 182        bio = rq->bio;
 183
 184        blk_execute_rq(q, NULL, rq, !(hdr.flags & BSG_FLAG_Q_AT_TAIL));
 185        ret = rq->q->bsg_dev.ops->complete_rq(rq, &hdr);
 186        blk_rq_unmap_user(bio);
 187
 188out_free_rq:
 189        rq->q->bsg_dev.ops->free_rq(rq);
 190        blk_put_request(rq);
 191        if (!ret && copy_to_user(uarg, &hdr, sizeof(hdr)))
 192                return -EFAULT;
 193        return ret;
 194}
 195
 196static struct bsg_device *bsg_alloc_device(void)
 197{
 198        struct bsg_device *bd;
 199
 200        bd = kzalloc(sizeof(struct bsg_device), GFP_KERNEL);
 201        if (unlikely(!bd))
 202                return NULL;
 203
 204        spin_lock_init(&bd->lock);
 205        bd->max_queue = BSG_DEFAULT_CMDS;
 206        INIT_HLIST_NODE(&bd->dev_list);
 207        return bd;
 208}
 209
 210static int bsg_put_device(struct bsg_device *bd)
 211{
 212        struct request_queue *q = bd->queue;
 213
 214        mutex_lock(&bsg_mutex);
 215
 216        if (!refcount_dec_and_test(&bd->ref_count)) {
 217                mutex_unlock(&bsg_mutex);
 218                return 0;
 219        }
 220
 221        hlist_del(&bd->dev_list);
 222        mutex_unlock(&bsg_mutex);
 223
 224        bsg_dbg(bd, "tearing down\n");
 225
 226        /*
 227         * close can always block
 228         */
 229        kfree(bd);
 230        blk_put_queue(q);
 231        return 0;
 232}
 233
 234static struct bsg_device *bsg_add_device(struct inode *inode,
 235                                         struct request_queue *rq,
 236                                         struct file *file)
 237{
 238        struct bsg_device *bd;
 239        unsigned char buf[32];
 240
 241        lockdep_assert_held(&bsg_mutex);
 242
 243        if (!blk_get_queue(rq))
 244                return ERR_PTR(-ENXIO);
 245
 246        bd = bsg_alloc_device();
 247        if (!bd) {
 248                blk_put_queue(rq);
 249                return ERR_PTR(-ENOMEM);
 250        }
 251
 252        bd->queue = rq;
 253
 254        refcount_set(&bd->ref_count, 1);
 255        hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
 256
 257        strncpy(bd->name, dev_name(rq->bsg_dev.class_dev), sizeof(bd->name) - 1);
 258        bsg_dbg(bd, "bound to <%s>, max queue %d\n",
 259                format_dev_t(buf, inode->i_rdev), bd->max_queue);
 260
 261        return bd;
 262}
 263
 264static struct bsg_device *__bsg_get_device(int minor, struct request_queue *q)
 265{
 266        struct bsg_device *bd;
 267
 268        lockdep_assert_held(&bsg_mutex);
 269
 270        hlist_for_each_entry(bd, bsg_dev_idx_hash(minor), dev_list) {
 271                if (bd->queue == q) {
 272                        refcount_inc(&bd->ref_count);
 273                        goto found;
 274                }
 275        }
 276        bd = NULL;
 277found:
 278        return bd;
 279}
 280
 281static struct bsg_device *bsg_get_device(struct inode *inode, struct file *file)
 282{
 283        struct bsg_device *bd;
 284        struct bsg_class_device *bcd;
 285
 286        /*
 287         * find the class device
 288         */
 289        mutex_lock(&bsg_mutex);
 290        bcd = idr_find(&bsg_minor_idr, iminor(inode));
 291
 292        if (!bcd) {
 293                bd = ERR_PTR(-ENODEV);
 294                goto out_unlock;
 295        }
 296
 297        bd = __bsg_get_device(iminor(inode), bcd->queue);
 298        if (!bd)
 299                bd = bsg_add_device(inode, bcd->queue, file);
 300
 301out_unlock:
 302        mutex_unlock(&bsg_mutex);
 303        return bd;
 304}
 305
 306static int bsg_open(struct inode *inode, struct file *file)
 307{
 308        struct bsg_device *bd;
 309
 310        bd = bsg_get_device(inode, file);
 311
 312        if (IS_ERR(bd))
 313                return PTR_ERR(bd);
 314
 315        file->private_data = bd;
 316        return 0;
 317}
 318
 319static int bsg_release(struct inode *inode, struct file *file)
 320{
 321        struct bsg_device *bd = file->private_data;
 322
 323        file->private_data = NULL;
 324        return bsg_put_device(bd);
 325}
 326
 327static int bsg_get_command_q(struct bsg_device *bd, int __user *uarg)
 328{
 329        return put_user(bd->max_queue, uarg);
 330}
 331
 332static int bsg_set_command_q(struct bsg_device *bd, int __user *uarg)
 333{
 334        int queue;
 335
 336        if (get_user(queue, uarg))
 337                return -EFAULT;
 338        if (queue < 1)
 339                return -EINVAL;
 340
 341        spin_lock_irq(&bd->lock);
 342        bd->max_queue = queue;
 343        spin_unlock_irq(&bd->lock);
 344        return 0;
 345}
 346
 347static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 348{
 349        struct bsg_device *bd = file->private_data;
 350        void __user *uarg = (void __user *) arg;
 351
 352        switch (cmd) {
 353        /*
 354         * Our own ioctls
 355         */
 356        case SG_GET_COMMAND_Q:
 357                return bsg_get_command_q(bd, uarg);
 358        case SG_SET_COMMAND_Q:
 359                return bsg_set_command_q(bd, uarg);
 360
 361        /*
 362         * SCSI/sg ioctls
 363         */
 364        case SG_GET_VERSION_NUM:
 365        case SCSI_IOCTL_GET_IDLUN:
 366        case SCSI_IOCTL_GET_BUS_NUMBER:
 367        case SG_SET_TIMEOUT:
 368        case SG_GET_TIMEOUT:
 369        case SG_GET_RESERVED_SIZE:
 370        case SG_SET_RESERVED_SIZE:
 371        case SG_EMULATED_HOST:
 372        case SCSI_IOCTL_SEND_COMMAND:
 373                return scsi_cmd_ioctl(bd->queue, NULL, file->f_mode, cmd, uarg);
 374        case SG_IO:
 375                return bsg_sg_io(bd->queue, file->f_mode, uarg);
 376        default:
 377                return -ENOTTY;
 378        }
 379}
 380
 381static const struct file_operations bsg_fops = {
 382        .open           =       bsg_open,
 383        .release        =       bsg_release,
 384        .unlocked_ioctl =       bsg_ioctl,
 385        .compat_ioctl   =       compat_ptr_ioctl,
 386        .owner          =       THIS_MODULE,
 387        .llseek         =       default_llseek,
 388};
 389
 390void bsg_unregister_queue(struct request_queue *q)
 391{
 392        struct bsg_class_device *bcd = &q->bsg_dev;
 393
 394        if (!bcd->class_dev)
 395                return;
 396
 397        mutex_lock(&bsg_mutex);
 398        idr_remove(&bsg_minor_idr, bcd->minor);
 399        if (q->kobj.sd)
 400                sysfs_remove_link(&q->kobj, "bsg");
 401        device_unregister(bcd->class_dev);
 402        bcd->class_dev = NULL;
 403        mutex_unlock(&bsg_mutex);
 404}
 405EXPORT_SYMBOL_GPL(bsg_unregister_queue);
 406
 407int bsg_register_queue(struct request_queue *q, struct device *parent,
 408                const char *name, const struct bsg_ops *ops)
 409{
 410        struct bsg_class_device *bcd;
 411        dev_t dev;
 412        int ret;
 413        struct device *class_dev = NULL;
 414
 415        /*
 416         * we need a proper transport to send commands, not a stacked device
 417         */
 418        if (!queue_is_mq(q))
 419                return 0;
 420
 421        bcd = &q->bsg_dev;
 422        memset(bcd, 0, sizeof(*bcd));
 423
 424        mutex_lock(&bsg_mutex);
 425
 426        ret = idr_alloc(&bsg_minor_idr, bcd, 0, BSG_MAX_DEVS, GFP_KERNEL);
 427        if (ret < 0) {
 428                if (ret == -ENOSPC) {
 429                        printk(KERN_ERR "bsg: too many bsg devices\n");
 430                        ret = -EINVAL;
 431                }
 432                goto unlock;
 433        }
 434
 435        bcd->minor = ret;
 436        bcd->queue = q;
 437        bcd->ops = ops;
 438        dev = MKDEV(bsg_major, bcd->minor);
 439        class_dev = device_create(bsg_class, parent, dev, NULL, "%s", name);
 440        if (IS_ERR(class_dev)) {
 441                ret = PTR_ERR(class_dev);
 442                goto idr_remove;
 443        }
 444        bcd->class_dev = class_dev;
 445
 446        if (q->kobj.sd) {
 447                ret = sysfs_create_link(&q->kobj, &bcd->class_dev->kobj, "bsg");
 448                if (ret)
 449                        goto unregister_class_dev;
 450        }
 451
 452        mutex_unlock(&bsg_mutex);
 453        return 0;
 454
 455unregister_class_dev:
 456        device_unregister(class_dev);
 457idr_remove:
 458        idr_remove(&bsg_minor_idr, bcd->minor);
 459unlock:
 460        mutex_unlock(&bsg_mutex);
 461        return ret;
 462}
 463
 464int bsg_scsi_register_queue(struct request_queue *q, struct device *parent)
 465{
 466        if (!blk_queue_scsi_passthrough(q)) {
 467                WARN_ONCE(true, "Attempt to register a non-SCSI queue\n");
 468                return -EINVAL;
 469        }
 470
 471        return bsg_register_queue(q, parent, dev_name(parent), &bsg_scsi_ops);
 472}
 473EXPORT_SYMBOL_GPL(bsg_scsi_register_queue);
 474
 475static struct cdev bsg_cdev;
 476
 477static char *bsg_devnode(struct device *dev, umode_t *mode)
 478{
 479        return kasprintf(GFP_KERNEL, "bsg/%s", dev_name(dev));
 480}
 481
 482static int __init bsg_init(void)
 483{
 484        int ret, i;
 485        dev_t devid;
 486
 487        for (i = 0; i < BSG_LIST_ARRAY_SIZE; i++)
 488                INIT_HLIST_HEAD(&bsg_device_list[i]);
 489
 490        bsg_class = class_create(THIS_MODULE, "bsg");
 491        if (IS_ERR(bsg_class))
 492                return PTR_ERR(bsg_class);
 493        bsg_class->devnode = bsg_devnode;
 494
 495        ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
 496        if (ret)
 497                goto destroy_bsg_class;
 498
 499        bsg_major = MAJOR(devid);
 500
 501        cdev_init(&bsg_cdev, &bsg_fops);
 502        ret = cdev_add(&bsg_cdev, MKDEV(bsg_major, 0), BSG_MAX_DEVS);
 503        if (ret)
 504                goto unregister_chrdev;
 505
 506        printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
 507               " loaded (major %d)\n", bsg_major);
 508        return 0;
 509unregister_chrdev:
 510        unregister_chrdev_region(MKDEV(bsg_major, 0), BSG_MAX_DEVS);
 511destroy_bsg_class:
 512        class_destroy(bsg_class);
 513        return ret;
 514}
 515
 516MODULE_AUTHOR("Jens Axboe");
 517MODULE_DESCRIPTION(BSG_DESCRIPTION);
 518MODULE_LICENSE("GPL");
 519
 520device_initcall(bsg_init);
 521