block/bsg.c

   1 /*
   2  * bsg.c - block layer implementation of the sg v4 interface
   3  *
   4  * Copyright (C) 2004 Jens Axboe <[email protected]> SUSE Labs
   5  * Copyright (C) 2004 Peter M. Jones <[email protected]>
   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  */
  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>
  18 #include <linux/jiffies.h>
  19 #include <linux/percpu.h>
  20 #include <linux/uio.h>
  21 #include <linux/idr.h>
  22 #include <linux/bsg.h>
  23 #include <linux/slab.h>
  24
  25 #include <scsi/scsi.h>
  26 #include <scsi/scsi_ioctl.h>
  27 #include <scsi/scsi_cmnd.h>
  28 #include <scsi/scsi_device.h>
  29 #include <scsi/scsi_driver.h>
  30 #include <scsi/sg.h>
  31
  32 #define BSG_DESCRIPTION "Block layer SCSI generic (bsg) driver"
  33 #define BSG_VERSION     "0.4"
  34
  35 #define bsg_dbg(bd, fmt, ...) \
  36         pr_debug("%s: " fmt, (bd)->name, ##__VA_ARGS__)
  37
  38 struct bsg_device {
  39         struct request_queue *queue;
  40         spinlock_t lock;
  41         struct list_head busy_list;
  42         struct list_head done_list;
  43         struct hlist_node dev_list;
  44         atomic_t ref_count;
  45         int queued_cmds;
  46         int done_cmds;
  47         wait_queue_head_t wq_done;
  48         wait_queue_head_t wq_free;
  49         char name[20];
  50         int max_queue;
  51         unsigned long flags;
  52 };
  53
  54 enum {
  55         BSG_F_BLOCK             = 1,
  56 };
  57
  58 #define BSG_DEFAULT_CMDS        64
  59 #define BSG_MAX_DEVS            32768
  60
  61 static DEFINE_MUTEX(bsg_mutex);
  62 static DEFINE_IDR(bsg_minor_idr);
  63
  64 #define BSG_LIST_ARRAY_SIZE     8
  65 static struct hlist_head bsg_device_list[BSG_LIST_ARRAY_SIZE];
  66
  67 static struct class *bsg_class;
  68 static int bsg_major;
  69
  70 static struct kmem_cache *bsg_cmd_cachep;
  71
  72 /*
  73  * our internal command type
  74  */
  75 struct bsg_command {
  76         struct bsg_device *bd;
  77         struct list_head list;
  78         struct request *rq;
  79         struct bio *bio;
  80         struct bio *bidi_bio;
  81         int err;
  82         struct sg_io_v4 hdr;
  83 };
  84
  85 static void bsg_free_command(struct bsg_command *bc)
  86 {
  87         struct bsg_device *bd = bc->bd;
  88         unsigned long flags;
  89
  90         kmem_cache_free(bsg_cmd_cachep, bc);
  91
  92         spin_lock_irqsave(&bd->lock, flags);
  93         bd->queued_cmds--;
  94         spin_unlock_irqrestore(&bd->lock, flags);
  95
  96         wake_up(&bd->wq_free);
  97 }
  98
  99 static struct bsg_command *bsg_alloc_command(struct bsg_device *bd)
 100 {
 101         struct bsg_command *bc = ERR_PTR(-EINVAL);
 102
 103         spin_lock_irq(&bd->lock);
 104
 105         if (bd->queued_cmds >= bd->max_queue)
 106                 goto out;
 107
 108         bd->queued_cmds++;
 109         spin_unlock_irq(&bd->lock);
 110
 111         bc = kmem_cache_zalloc(bsg_cmd_cachep, GFP_KERNEL);
 112         if (unlikely(!bc)) {
 113                 spin_lock_irq(&bd->lock);
 114                 bd->queued_cmds--;
 115                 bc = ERR_PTR(-ENOMEM);
 116                 goto out;
 117         }
 118
 119         bc->bd = bd;
 120         INIT_LIST_HEAD(&bc->list);
 121         bsg_dbg(bd, "returning free cmd %p\n", bc);
 122         return bc;
 123 out:
 124         spin_unlock_irq(&bd->lock);
 125         return bc;
 126 }
 127
 128 static inline struct hlist_head *bsg_dev_idx_hash(int index)
 129 {
 130         return &bsg_device_list[index & (BSG_LIST_ARRAY_SIZE - 1)];
 131 }
 132
 133 #define uptr64(val) ((void __user *)(uintptr_t)(val))
 134
 135 static int bsg_scsi_check_proto(struct sg_io_v4 *hdr)
 136 {
 137         if (hdr->protocol != BSG_PROTOCOL_SCSI  ||
 138             hdr->subprotocol != BSG_SUB_PROTOCOL_SCSI_CMD)
 139                 return -EINVAL;
 140         return 0;
 141 }
 142
 143 static int bsg_scsi_fill_hdr(struct request *rq, struct sg_io_v4 *hdr,
 144                 fmode_t mode)
 145 {
 146         struct scsi_request *sreq = scsi_req(rq);
 147
 148         sreq->cmd_len = hdr->request_len;
 149         if (sreq->cmd_len > BLK_MAX_CDB) {
 150                 sreq->cmd = kzalloc(sreq->cmd_len, GFP_KERNEL);
 151                 if (!sreq->cmd)
 152                         return -ENOMEM;
 153         }
 154
 155         if (copy_from_user(sreq->cmd, uptr64(hdr->request), sreq->cmd_len))
 156                 return -EFAULT;
 157         if (blk_verify_command(sreq->cmd, mode))
 158                 return -EPERM;
 159         return 0;
 160 }
 161
 162 static int bsg_scsi_complete_rq(struct request *rq, struct sg_io_v4 *hdr)
 163 {
 164         struct scsi_request *sreq = scsi_req(rq);
 165         int ret = 0;
 166
 167         /*
 168          * fill in all the output members
 169          */
 170         hdr->device_status = sreq->result & 0xff;
 171         hdr->transport_status = host_byte(sreq->result);
 172         hdr->driver_status = driver_byte(sreq->result);
 173         hdr->info = 0;
 174         if (hdr->device_status || hdr->transport_status || hdr->driver_status)
 175                 hdr->info |= SG_INFO_CHECK;
 176         hdr->response_len = 0;
 177
 178         if (sreq->sense_len && hdr->response) {
 179                 int len = min_t(unsigned int, hdr->max_response_len,
 180                                         sreq->sense_len);
 181
 182                 if (copy_to_user(uptr64(hdr->response), sreq->sense, len))
 183                         ret = -EFAULT;
 184                 else
 185                         hdr->response_len = len;
 186         }
 187
 188         if (rq->next_rq) {
 189                 hdr->dout_resid = sreq->resid_len;
 190                 hdr->din_resid = scsi_req(rq->next_rq)->resid_len;
 191         } else if (rq_data_dir(rq) == READ) {
 192                 hdr->din_resid = sreq->resid_len;
 193         } else {
 194                 hdr->dout_resid = sreq->resid_len;
 195         }
 196
 197         return ret;
 198 }
 199
 200 static void bsg_scsi_free_rq(struct request *rq)
 201 {
 202         scsi_req_free_cmd(scsi_req(rq));
 203 }
 204
 205 static const struct bsg_ops bsg_scsi_ops = {
 206         .check_proto            = bsg_scsi_check_proto,
 207         .fill_hdr               = bsg_scsi_fill_hdr,
 208         .complete_rq            = bsg_scsi_complete_rq,
 209         .free_rq                = bsg_scsi_free_rq,
 210 };
 211
 212 static struct request *
 213 bsg_map_hdr(struct request_queue *q, struct sg_io_v4 *hdr, fmode_t mode)
 214 {
 215         struct request *rq, *next_rq = NULL;
 216         int ret;
 217
 218         if (!q->bsg_dev.class_dev)
 219                 return ERR_PTR(-ENXIO);
 220
 221         if (hdr->guard != 'Q')
 222                 return ERR_PTR(-EINVAL);
 223
 224         ret = q->bsg_dev.ops->check_proto(hdr);
 225         if (ret)
 226                 return ERR_PTR(ret);
 227
 228         rq = blk_get_request(q, hdr->dout_xfer_len ?
 229                         REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
 230         if (IS_ERR(rq))
 231                 return rq;
 232
 233         ret = q->bsg_dev.ops->fill_hdr(rq, hdr, mode);
 234         if (ret)
 235                 goto out;
 236
 237         rq->timeout = msecs_to_jiffies(hdr->timeout);
 238         if (!rq->timeout)
 239                 rq->timeout = q->sg_timeout;
 240         if (!rq->timeout)
 241                 rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
 242         if (rq->timeout < BLK_MIN_SG_TIMEOUT)
 243                 rq->timeout = BLK_MIN_SG_TIMEOUT;
 244
 245         if (hdr->dout_xfer_len && hdr->din_xfer_len) {
 246                 if (!test_bit(QUEUE_FLAG_BIDI, &q->queue_flags)) {
 247                         ret = -EOPNOTSUPP;
 248                         goto out;
 249                 }
 250
 251                 next_rq = blk_get_request(q, REQ_OP_SCSI_IN, 0);
 252                 if (IS_ERR(next_rq)) {
 253                         ret = PTR_ERR(next_rq);
 254                         goto out;
 255                 }
 256
 257                 rq->next_rq = next_rq;
 258                 ret = blk_rq_map_user(q, next_rq, NULL, uptr64(hdr->din_xferp),
 259                                        hdr->din_xfer_len, GFP_KERNEL);
 260                 if (ret)
 261                         goto out_free_nextrq;
 262         }
 263
 264         if (hdr->dout_xfer_len) {
 265                 ret = blk_rq_map_user(q, rq, NULL, uptr64(hdr->dout_xferp),
 266                                 hdr->dout_xfer_len, GFP_KERNEL);
 267         } else if (hdr->din_xfer_len) {
 268                 ret = blk_rq_map_user(q, rq, NULL, uptr64(hdr->din_xferp),
 269                                 hdr->din_xfer_len, GFP_KERNEL);
 270         } else {
 271                 ret = blk_rq_map_user(q, rq, NULL, NULL, 0, GFP_KERNEL);
 272         }
 273
 274         if (ret)
 275                 goto out_unmap_nextrq;
 276         return rq;
 277
 278 out_unmap_nextrq:
 279         if (rq->next_rq)
 280                 blk_rq_unmap_user(rq->next_rq->bio);
 281 out_free_nextrq:
 282         if (rq->next_rq)
 283                 blk_put_request(rq->next_rq);
 284 out:
 285         q->bsg_dev.ops->free_rq(rq);
 286         blk_put_request(rq);
 287         return ERR_PTR(ret);
 288 }
 289
 290 /*
 291  * async completion call-back from the block layer, when scsi/ide/whatever
 292  * calls end_that_request_last() on a request
 293  */
 294 static void bsg_rq_end_io(struct request *rq, blk_status_t status)
 295 {
 296         struct bsg_command *bc = rq->end_io_data;
 297         struct bsg_device *bd = bc->bd;
 298         unsigned long flags;
 299
 300         bsg_dbg(bd, "finished rq %p bc %p, bio %p\n",
 301                 rq, bc, bc->bio);
 302
 303         bc->hdr.duration = jiffies_to_msecs(jiffies - bc->hdr.duration);
 304
 305         spin_lock_irqsave(&bd->lock, flags);
 306         list_move_tail(&bc->list, &bd->done_list);
 307         bd->done_cmds++;
 308         spin_unlock_irqrestore(&bd->lock, flags);
 309
 310         wake_up(&bd->wq_done);
 311 }
 312
 313 /*
 314  * do final setup of a 'bc' and submit the matching 'rq' to the block
 315  * layer for io
 316  */
 317 static void bsg_add_command(struct bsg_device *bd, struct request_queue *q,
 318                             struct bsg_command *bc, struct request *rq)
 319 {
 320         int at_head = (0 == (bc->hdr.flags & BSG_FLAG_Q_AT_TAIL));
 321
 322         /*
 323          * add bc command to busy queue and submit rq for io
 324          */
 325         bc->rq = rq;
 326         bc->bio = rq->bio;
 327         if (rq->next_rq)
 328                 bc->bidi_bio = rq->next_rq->bio;
 329         bc->hdr.duration = jiffies;
 330         spin_lock_irq(&bd->lock);
 331         list_add_tail(&bc->list, &bd->busy_list);
 332         spin_unlock_irq(&bd->lock);
 333
 334         bsg_dbg(bd, "queueing rq %p, bc %p\n", rq, bc);
 335
 336         rq->end_io_data = bc;
 337         blk_execute_rq_nowait(q, NULL, rq, at_head, bsg_rq_end_io);
 338 }
 339
 340 static struct bsg_command *bsg_next_done_cmd(struct bsg_device *bd)
 341 {
 342         struct bsg_command *bc = NULL;
 343
 344         spin_lock_irq(&bd->lock);
 345         if (bd->done_cmds) {
 346                 bc = list_first_entry(&bd->done_list, struct bsg_command, list);
 347                 list_del(&bc->list);
 348                 bd->done_cmds--;
 349         }
 350         spin_unlock_irq(&bd->lock);
 351
 352         return bc;
 353 }
 354
 355 /*
 356  * Get a finished command from the done list
 357  */
 358 static struct bsg_command *bsg_get_done_cmd(struct bsg_device *bd)
 359 {
 360         struct bsg_command *bc;
 361         int ret;
 362
 363         do {
 364                 bc = bsg_next_done_cmd(bd);
 365                 if (bc)
 366                         break;
 367
 368                 if (!test_bit(BSG_F_BLOCK, &bd->flags)) {
 369                         bc = ERR_PTR(-EAGAIN);
 370                         break;
 371                 }
 372
 373                 ret = wait_event_interruptible(bd->wq_done, bd->done_cmds);
 374                 if (ret) {
 375                         bc = ERR_PTR(-ERESTARTSYS);
 376                         break;
 377                 }
 378         } while (1);
 379
 380         bsg_dbg(bd, "returning done %p\n", bc);
 381
 382         return bc;
 383 }
 384
 385 static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
 386                                     struct bio *bio, struct bio *bidi_bio)
 387 {
 388         int ret;
 389
 390         ret = rq->q->bsg_dev.ops->complete_rq(rq, hdr);
 391
 392         if (rq->next_rq) {
 393                 blk_rq_unmap_user(bidi_bio);
 394                 blk_put_request(rq->next_rq);
 395         }
 396
 397         blk_rq_unmap_user(bio);
 398         rq->q->bsg_dev.ops->free_rq(rq);
 399         blk_put_request(rq);
 400         return ret;
 401 }
 402
 403 static bool bsg_complete(struct bsg_device *bd)
 404 {
 405         bool ret = false;
 406         bool spin;
 407
 408         do {
 409                 spin_lock_irq(&bd->lock);
 410
 411                 BUG_ON(bd->done_cmds > bd->queued_cmds);
 412
 413                 /*
 414                  * All commands consumed.
 415                  */
 416                 if (bd->done_cmds == bd->queued_cmds)
 417                         ret = true;
 418
 419                 spin = !test_bit(BSG_F_BLOCK, &bd->flags);
 420
 421                 spin_unlock_irq(&bd->lock);
 422         } while (!ret && spin);
 423
 424         return ret;
 425 }
 426
 427 static int bsg_complete_all_commands(struct bsg_device *bd)
 428 {
 429         struct bsg_command *bc;
 430         int ret, tret;
 431
 432         bsg_dbg(bd, "entered\n");
 433
 434         /*
 435          * wait for all commands to complete
 436          */
 437         io_wait_event(bd->wq_done, bsg_complete(bd));
 438
 439         /*
 440          * discard done commands
 441          */
 442         ret = 0;
 443         do {
 444                 spin_lock_irq(&bd->lock);
 445                 if (!bd->queued_cmds) {
 446                         spin_unlock_irq(&bd->lock);
 447                         break;
 448                 }
 449                 spin_unlock_irq(&bd->lock);
 450
 451                 bc = bsg_get_done_cmd(bd);
 452                 if (IS_ERR(bc))
 453                         break;
 454
 455                 tret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,
 456                                                 bc->bidi_bio);
 457                 if (!ret)
 458                         ret = tret;
 459
 460                 bsg_free_command(bc);
 461         } while (1);
 462
 463         return ret;
 464 }
 465
 466 static int
 467 __bsg_read(char __user *buf, size_t count, struct bsg_device *bd,
 468            const struct iovec *iov, ssize_t *bytes_read)
 469 {
 470         struct bsg_command *bc;
 471         int nr_commands, ret;
 472
 473         if (count % sizeof(struct sg_io_v4))
 474                 return -EINVAL;
 475
 476         ret = 0;
 477         nr_commands = count / sizeof(struct sg_io_v4);
 478         while (nr_commands) {
 479                 bc = bsg_get_done_cmd(bd);
 480                 if (IS_ERR(bc)) {
 481                         ret = PTR_ERR(bc);
 482                         break;
 483                 }
 484
 485                 /*
 486                  * this is the only case where we need to copy data back
 487                  * after completing the request. so do that here,
 488                  * bsg_complete_work() cannot do that for us
 489                  */
 490                 ret = blk_complete_sgv4_hdr_rq(bc->rq, &bc->hdr, bc->bio,
 491                                                bc->bidi_bio);
 492
 493                 if (copy_to_user(buf, &bc->hdr, sizeof(bc->hdr)))
 494                         ret = -EFAULT;
 495
 496                 bsg_free_command(bc);
 497
 498                 if (ret)
 499                         break;
 500
 501                 buf += sizeof(struct sg_io_v4);
 502                 *bytes_read += sizeof(struct sg_io_v4);
 503                 nr_commands--;
 504         }
 505
 506         return ret;
 507 }
 508
 509 static inline void bsg_set_block(struct bsg_device *bd, struct file *file)
 510 {
 511         if (file->f_flags & O_NONBLOCK)
 512                 clear_bit(BSG_F_BLOCK, &bd->flags);
 513         else
 514                 set_bit(BSG_F_BLOCK, &bd->flags);
 515 }
 516
 517 /*
 518  * Check if the error is a "real" error that we should return.
 519  */
 520 static inline int err_block_err(int ret)
 521 {
 522         if (ret && ret != -ENOSPC && ret != -ENODATA && ret != -EAGAIN)
 523                 return 1;
 524
 525         return 0;
 526 }
 527
 528 static ssize_t
 529 bsg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 530 {
 531         struct bsg_device *bd = file->private_data;
 532         int ret;
 533         ssize_t bytes_read;
 534
 535         bsg_dbg(bd, "read %zd bytes\n", count);
 536
 537         bsg_set_block(bd, file);
 538
 539         bytes_read = 0;
 540         ret = __bsg_read(buf, count, bd, NULL, &bytes_read);
 541         *ppos = bytes_read;
 542
 543         if (!bytes_read || err_block_err(ret))
 544                 bytes_read = ret;
 545
 546         return bytes_read;
 547 }
 548
 549 static int __bsg_write(struct bsg_device *bd, const char __user *buf,
 550                        size_t count, ssize_t *bytes_written, fmode_t mode)
 551 {
 552         struct bsg_command *bc;
 553         struct request *rq;
 554         int ret, nr_commands;
 555
 556         if (count % sizeof(struct sg_io_v4))
 557                 return -EINVAL;
 558
 559         nr_commands = count / sizeof(struct sg_io_v4);
 560         rq = NULL;
 561         bc = NULL;
 562         ret = 0;
 563         while (nr_commands) {
 564                 struct request_queue *q = bd->queue;
 565
 566                 bc = bsg_alloc_command(bd);
 567                 if (IS_ERR(bc)) {
 568                         ret = PTR_ERR(bc);
 569                         bc = NULL;
 570                         break;
 571                 }
 572
 573                 if (copy_from_user(&bc->hdr, buf, sizeof(bc->hdr))) {
 574                         ret = -EFAULT;
 575                         break;
 576                 }
 577
 578                 /*
 579                  * get a request, fill in the blanks, and add to request queue
 580                  */
 581                 rq = bsg_map_hdr(bd->queue, &bc->hdr, mode);
 582                 if (IS_ERR(rq)) {
 583                         ret = PTR_ERR(rq);
 584                         rq = NULL;
 585                         break;
 586                 }
 587
 588                 bsg_add_command(bd, q, bc, rq);
 589                 bc = NULL;
 590                 rq = NULL;
 591                 nr_commands--;
 592                 buf += sizeof(struct sg_io_v4);
 593                 *bytes_written += sizeof(struct sg_io_v4);
 594         }
 595
 596         if (bc)
 597                 bsg_free_command(bc);
 598
 599         return ret;
 600 }
 601
 602 static ssize_t
 603 bsg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 604 {
 605         struct bsg_device *bd = file->private_data;
 606         ssize_t bytes_written;
 607         int ret;
 608
 609         bsg_dbg(bd, "write %zd bytes\n", count);
 610
 611         if (unlikely(uaccess_kernel()))
 612                 return -EINVAL;
 613
 614         bsg_set_block(bd, file);
 615
 616         bytes_written = 0;
 617         ret = __bsg_write(bd, buf, count, &bytes_written, file->f_mode);
 618
 619         *ppos = bytes_written;
 620
 621         /*
 622          * return bytes written on non-fatal errors
 623          */
 624         if (!bytes_written || err_block_err(ret))
 625                 bytes_written = ret;
 626
 627         bsg_dbg(bd, "returning %zd\n", bytes_written);
 628         return bytes_written;
 629 }
 630
 631 static struct bsg_device *bsg_alloc_device(void)
 632 {
 633         struct bsg_device *bd;
 634
 635         bd = kzalloc(sizeof(struct bsg_device), GFP_KERNEL);
 636         if (unlikely(!bd))
 637                 return NULL;
 638
 639         spin_lock_init(&bd->lock);
 640
 641         bd->max_queue = BSG_DEFAULT_CMDS;
 642
 643         INIT_LIST_HEAD(&bd->busy_list);
 644         INIT_LIST_HEAD(&bd->done_list);
 645         INIT_HLIST_NODE(&bd->dev_list);
 646
 647         init_waitqueue_head(&bd->wq_free);
 648         init_waitqueue_head(&bd->wq_done);
 649         return bd;
 650 }
 651
 652 static int bsg_put_device(struct bsg_device *bd)
 653 {
 654         int ret = 0, do_free;
 655         struct request_queue *q = bd->queue;
 656
 657         mutex_lock(&bsg_mutex);
 658
 659         do_free = atomic_dec_and_test(&bd->ref_count);
 660         if (!do_free) {
 661                 mutex_unlock(&bsg_mutex);
 662                 goto out;
 663         }
 664
 665         hlist_del(&bd->dev_list);
 666         mutex_unlock(&bsg_mutex);
 667
 668         bsg_dbg(bd, "tearing down\n");
 669
 670         /*
 671          * close can always block
 672          */
 673         set_bit(BSG_F_BLOCK, &bd->flags);
 674
 675         /*
 676          * correct error detection baddies here again. it's the responsibility
 677          * of the app to properly reap commands before close() if it wants
 678          * fool-proof error detection
 679          */
 680         ret = bsg_complete_all_commands(bd);
 681
 682         kfree(bd);
 683 out:
 684         if (do_free)
 685                 blk_put_queue(q);
 686         return ret;
 687 }
 688
 689 static struct bsg_device *bsg_add_device(struct inode *inode,
 690                                          struct request_queue *rq,
 691                                          struct file *file)
 692 {
 693         struct bsg_device *bd;
 694         unsigned char buf[32];
 695
 696         lockdep_assert_held(&bsg_mutex);
 697
 698         if (!blk_get_queue(rq))
 699                 return ERR_PTR(-ENXIO);
 700
 701         bd = bsg_alloc_device();
 702         if (!bd) {
 703                 blk_put_queue(rq);
 704                 return ERR_PTR(-ENOMEM);
 705         }
 706
 707         bd->queue = rq;
 708
 709         bsg_set_block(bd, file);
 710
 711         atomic_set(&bd->ref_count, 1);
 712         hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(iminor(inode)));
 713
 714         strncpy(bd->name, dev_name(rq->bsg_dev.class_dev), sizeof(bd->name) - 1);
 715         bsg_dbg(bd, "bound to <%s>, max queue %d\n",
 716                 format_dev_t(buf, inode->i_rdev), bd->max_queue);
 717
 718         return bd;
 719 }
 720
 721 static struct bsg_device *__bsg_get_device(int minor, struct request_queue *q)
 722 {
 723         struct bsg_device *bd;
 724
 725         lockdep_assert_held(&bsg_mutex);
 726
 727         hlist_for_each_entry(bd, bsg_dev_idx_hash(minor), dev_list) {
 728                 if (bd->queue == q) {
 729                         atomic_inc(&bd->ref_count);
 730                         goto found;
 731                 }
 732         }
 733         bd = NULL;
 734 found:
 735         return bd;
 736 }
 737
 738 static struct bsg_device *bsg_get_device(struct inode *inode, struct file *file)
 739 {
 740         struct bsg_device *bd;
 741         struct bsg_class_device *bcd;
 742
 743         /*
 744          * find the class device
 745          */
 746         mutex_lock(&bsg_mutex);
 747         bcd = idr_find(&bsg_minor_idr, iminor(inode));
 748
 749         if (!bcd) {
 750                 bd = ERR_PTR(-ENODEV);
 751                 goto out_unlock;
 752         }
 753
 754         bd = __bsg_get_device(iminor(inode), bcd->queue);
 755         if (!bd)
 756                 bd = bsg_add_device(inode, bcd->queue, file);
 757
 758 out_unlock:
 759         mutex_unlock(&bsg_mutex);
 760         return bd;
 761 }
 762
 763 static int bsg_open(struct inode *inode, struct file *file)
 764 {
 765         struct bsg_device *bd;
 766
 767         bd = bsg_get_device(inode, file);
 768
 769         if (IS_ERR(bd))
 770                 return PTR_ERR(bd);
 771
 772         file->private_data = bd;
 773         return 0;
 774 }
 775
 776 static int bsg_release(struct inode *inode, struct file *file)
 777 {
 778         struct bsg_device *bd = file->private_data;
 779
 780         file->private_data = NULL;
 781         return bsg_put_device(bd);
 782 }
 783
 784 static __poll_t bsg_poll(struct file *file, poll_table *wait)
 785 {
 786         struct bsg_device *bd = file->private_data;
 787         __poll_t mask = 0;
 788
 789         poll_wait(file, &bd->wq_done, wait);
 790         poll_wait(file, &bd->wq_free, wait);
 791
 792         spin_lock_irq(&bd->lock);
 793         if (!list_empty(&bd->done_list))
 794                 mask |= EPOLLIN | EPOLLRDNORM;
 795         if (bd->queued_cmds < bd->max_queue)
 796                 mask |= EPOLLOUT;
 797         spin_unlock_irq(&bd->lock);
 798
 799         return mask;
 800 }
 801
 802 static long bsg_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 803 {
 804         struct bsg_device *bd = file->private_data;
 805         int __user *uarg = (int __user *) arg;
 806         int ret;
 807
 808         switch (cmd) {
 809                 /*
 810                  * our own ioctls
 811                  */
 812         case SG_GET_COMMAND_Q:
 813                 return put_user(bd->max_queue, uarg);
 814         case SG_SET_COMMAND_Q: {
 815                 int queue;
 816
 817                 if (get_user(queue, uarg))
 818                         return -EFAULT;
 819                 if (queue < 1)
 820                         return -EINVAL;
 821
 822                 spin_lock_irq(&bd->lock);
 823                 bd->max_queue = queue;
 824                 spin_unlock_irq(&bd->lock);
 825                 return 0;
 826         }
 827
 828         /*
 829          * SCSI/sg ioctls
 830          */
 831         case SG_GET_VERSION_NUM:
 832         case SCSI_IOCTL_GET_IDLUN:
 833         case SCSI_IOCTL_GET_BUS_NUMBER:
 834         case SG_SET_TIMEOUT:
 835         case SG_GET_TIMEOUT:
 836         case SG_GET_RESERVED_SIZE:
 837         case SG_SET_RESERVED_SIZE:
 838         case SG_EMULATED_HOST:
 839         case SCSI_IOCTL_SEND_COMMAND: {
 840                 void __user *uarg = (void __user *) arg;
 841                 return scsi_cmd_ioctl(bd->queue, NULL, file->f_mode, cmd, uarg);
 842         }
 843         case SG_IO: {
 844                 struct request *rq;
 845                 struct bio *bio, *bidi_bio = NULL;
 846                 struct sg_io_v4 hdr;
 847                 int at_head;
 848
 849                 if (copy_from_user(&hdr, uarg, sizeof(hdr)))
 850                         return -EFAULT;
 851
 852                 rq = bsg_map_hdr(bd->queue, &hdr, file->f_mode);
 853                 if (IS_ERR(rq))
 854                         return PTR_ERR(rq);
 855
 856                 bio = rq->bio;
 857                 if (rq->next_rq)
 858                         bidi_bio = rq->next_rq->bio;
 859
 860                 at_head = (0 == (hdr.flags & BSG_FLAG_Q_AT_TAIL));
 861                 blk_execute_rq(bd->queue, NULL, rq, at_head);
 862                 ret = blk_complete_sgv4_hdr_rq(rq, &hdr, bio, bidi_bio);
 863
 864                 if (copy_to_user(uarg, &hdr, sizeof(hdr)))
 865                         return -EFAULT;
 866
 867                 return ret;
 868         }
 869         default:
 870                 return -ENOTTY;
 871         }
 872 }
 873
 874 static const struct file_operations bsg_fops = {
 875         .read           =       bsg_read,
 876         .write          =       bsg_write,
 877         .poll           =       bsg_poll,
 878         .open           =       bsg_open,
 879         .release        =       bsg_release,
 880         .unlocked_ioctl =       bsg_ioctl,
 881         .owner          =       THIS_MODULE,
 882         .llseek         =       default_llseek,
 883 };
 884
 885 void bsg_unregister_queue(struct request_queue *q)
 886 {
 887         struct bsg_class_device *bcd = &q->bsg_dev;
 888
 889         if (!bcd->class_dev)
 890                 return;
 891
 892         mutex_lock(&bsg_mutex);
 893         idr_remove(&bsg_minor_idr, bcd->minor);
 894         if (q->kobj.sd)
 895                 sysfs_remove_link(&q->kobj, "bsg");
 896         device_unregister(bcd->class_dev);
 897         bcd->class_dev = NULL;
 898         mutex_unlock(&bsg_mutex);
 899 }
 900 EXPORT_SYMBOL_GPL(bsg_unregister_queue);
 901
 902 int bsg_register_queue(struct request_queue *q, struct device *parent,
 903                 const char *name, const struct bsg_ops *ops)
 904 {
 905         struct bsg_class_device *bcd;
 906         dev_t dev;
 907         int ret;
 908         struct device *class_dev = NULL;
 909
 910         /*
 911          * we need a proper transport to send commands, not a stacked device
 912          */
 913         if (!queue_is_rq_based(q))
 914                 return 0;
 915
 916         bcd = &q->bsg_dev;
 917         memset(bcd, 0, sizeof(*bcd));
 918
 919         mutex_lock(&bsg_mutex);
 920
 921         ret = idr_alloc(&bsg_minor_idr, bcd, 0, BSG_MAX_DEVS, GFP_KERNEL);
 922         if (ret < 0) {
 923                 if (ret == -ENOSPC) {
 924                         printk(KERN_ERR "bsg: too many bsg devices\n");
 925                         ret = -EINVAL;
 926                 }
 927                 goto unlock;
 928         }
 929
 930         bcd->minor = ret;
 931         bcd->queue = q;
 932         bcd->ops = ops;
 933         dev = MKDEV(bsg_major, bcd->minor);
 934         class_dev = device_create(bsg_class, parent, dev, NULL, "%s", name);
 935         if (IS_ERR(class_dev)) {
 936                 ret = PTR_ERR(class_dev);
 937                 goto idr_remove;
 938         }
 939         bcd->class_dev = class_dev;
 940
 941         if (q->kobj.sd) {
 942                 ret = sysfs_create_link(&q->kobj, &bcd->class_dev->kobj, "bsg");
 943                 if (ret)
 944                         goto unregister_class_dev;
 945         }
 946
 947         mutex_unlock(&bsg_mutex);
 948         return 0;
 949
 950 unregister_class_dev:
 951         device_unregister(class_dev);
 952 idr_remove:
 953         idr_remove(&bsg_minor_idr, bcd->minor);
 954 unlock:
 955         mutex_unlock(&bsg_mutex);
 956         return ret;
 957 }
 958
 959 int bsg_scsi_register_queue(struct request_queue *q, struct device *parent)
 960 {
 961         if (!blk_queue_scsi_passthrough(q)) {
 962                 WARN_ONCE(true, "Attempt to register a non-SCSI queue\n");
 963                 return -EINVAL;
 964         }
 965
 966         return bsg_register_queue(q, parent, dev_name(parent), &bsg_scsi_ops);
 967 }
 968 EXPORT_SYMBOL_GPL(bsg_scsi_register_queue);
 969
 970 static struct cdev bsg_cdev;
 971
 972 static char *bsg_devnode(struct device *dev, umode_t *mode)
 973 {
 974         return kasprintf(GFP_KERNEL, "bsg/%s", dev_name(dev));
 975 }
 976
 977 static int __init bsg_init(void)
 978 {
 979         int ret, i;
 980         dev_t devid;
 981
 982         bsg_cmd_cachep = kmem_cache_create("bsg_cmd",
 983                                 sizeof(struct bsg_command), 0, 0, NULL);
 984         if (!bsg_cmd_cachep) {
 985                 printk(KERN_ERR "bsg: failed creating slab cache\n");
 986                 return -ENOMEM;
 987         }
 988
 989         for (i = 0; i < BSG_LIST_ARRAY_SIZE; i++)
 990                 INIT_HLIST_HEAD(&bsg_device_list[i]);
 991
 992         bsg_class = class_create(THIS_MODULE, "bsg");
 993         if (IS_ERR(bsg_class)) {
 994                 ret = PTR_ERR(bsg_class);
 995                 goto destroy_kmemcache;
 996         }
 997         bsg_class->devnode = bsg_devnode;
 998
 999         ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
1000         if (ret)
1001                 goto destroy_bsg_class;
1002
1003         bsg_major = MAJOR(devid);
1004
1005         cdev_init(&bsg_cdev, &bsg_fops);
1006         ret = cdev_add(&bsg_cdev, MKDEV(bsg_major, 0), BSG_MAX_DEVS);
1007         if (ret)
1008                 goto unregister_chrdev;
1009
1010         printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
1011                " loaded (major %d)\n", bsg_major);
1012         return 0;
1013 unregister_chrdev:
1014         unregister_chrdev_region(MKDEV(bsg_major, 0), BSG_MAX_DEVS);
1015 destroy_bsg_class:
1016         class_destroy(bsg_class);
1017 destroy_kmemcache:
1018         kmem_cache_destroy(bsg_cmd_cachep);
1019         return ret;
1020 }
1021
1022 MODULE_AUTHOR("Jens Axboe");
1023 MODULE_DESCRIPTION(BSG_DESCRIPTION);
1024 MODULE_LICENSE("GPL");
1025
1026 device_initcall(bsg_init);