drivers/scsi/virtio_scsi.c

   1 /*
   2  * Virtio SCSI HBA driver
   3  *
   4  * Copyright IBM Corp. 2010
   5  * Copyright Red Hat, Inc. 2011
   6  *
   7  * Authors:
   8  *  Stefan Hajnoczi   <stefanha@linux.vnet.ibm.com>
   9  *  Paolo Bonzini   <pbonzini@redhat.com>
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  12  * See the COPYING file in the top-level directory.
  13  *
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/slab.h>
  18 #include <linux/mempool.h>
  19 #include <linux/virtio.h>
  20 #include <linux/virtio_ids.h>
  21 #include <linux/virtio_config.h>
  22 #include <linux/virtio_scsi.h>
  23 #include <scsi/scsi_host.h>
  24 #include <scsi/scsi_device.h>
  25 #include <scsi/scsi_cmnd.h>
  26
  27 #define VIRTIO_SCSI_MEMPOOL_SZ 64
  28
  29 /* Command queue element */
  30 struct virtio_scsi_cmd {
  31         struct scsi_cmnd *sc;
  32         struct completion *comp;
  33         union {
  34                 struct virtio_scsi_cmd_req       cmd;
  35                 struct virtio_scsi_ctrl_tmf_req  tmf;
  36                 struct virtio_scsi_ctrl_an_req   an;
  37         } req;
  38         union {
  39                 struct virtio_scsi_cmd_resp      cmd;
  40                 struct virtio_scsi_ctrl_tmf_resp tmf;
  41                 struct virtio_scsi_ctrl_an_resp  an;
  42                 struct virtio_scsi_event         evt;
  43         } resp;
  44 } ____cacheline_aligned_in_smp;
  45
  46 /* Driver instance state */
  47 struct virtio_scsi {
  48         /* Protects ctrl_vq, req_vq and sg[] */
  49         spinlock_t vq_lock;
  50
  51         struct virtio_device *vdev;
  52         struct virtqueue *ctrl_vq;
  53         struct virtqueue *event_vq;
  54         struct virtqueue *req_vq;
  55
  56         /* For sglist construction when adding commands to the virtqueue.  */
  57         struct scatterlist sg[];
  58 };
  59
  60 static struct kmem_cache *virtscsi_cmd_cache;
  61 static mempool_t *virtscsi_cmd_pool;
  62
  63 static inline struct Scsi_Host *virtio_scsi_host(struct virtio_device *vdev)
  64 {
  65         return vdev->priv;
  66 }
  67
  68 static void virtscsi_compute_resid(struct scsi_cmnd *sc, u32 resid)
  69 {
  70         if (!resid)
  71                 return;
  72
  73         if (!scsi_bidi_cmnd(sc)) {
  74                 scsi_set_resid(sc, resid);
  75                 return;
  76         }
  77
  78         scsi_in(sc)->resid = min(resid, scsi_in(sc)->length);
  79         scsi_out(sc)->resid = resid - scsi_in(sc)->resid;
  80 }
  81
  82 /**
  83  * virtscsi_complete_cmd - finish a scsi_cmd and invoke scsi_done
  84  *
  85  * Called with vq_lock held.
  86  */
  87 static void virtscsi_complete_cmd(void *buf)
  88 {
  89         struct virtio_scsi_cmd *cmd = buf;
  90         struct scsi_cmnd *sc = cmd->sc;
  91         struct virtio_scsi_cmd_resp *resp = &cmd->resp.cmd;
  92
  93         dev_dbg(&sc->device->sdev_gendev,
  94                 "cmd %p response %u status %#02x sense_len %u\n",
  95                 sc, resp->response, resp->status, resp->sense_len);
  96
  97         sc->result = resp->status;
  98         virtscsi_compute_resid(sc, resp->resid);
  99         switch (resp->response) {
 100         case VIRTIO_SCSI_S_OK:
 101                 set_host_byte(sc, DID_OK);
 102                 break;
 103         case VIRTIO_SCSI_S_OVERRUN:
 104                 set_host_byte(sc, DID_ERROR);
 105                 break;
 106         case VIRTIO_SCSI_S_ABORTED:
 107                 set_host_byte(sc, DID_ABORT);
 108                 break;
 109         case VIRTIO_SCSI_S_BAD_TARGET:
 110                 set_host_byte(sc, DID_BAD_TARGET);
 111                 break;
 112         case VIRTIO_SCSI_S_RESET:
 113                 set_host_byte(sc, DID_RESET);
 114                 break;
 115         case VIRTIO_SCSI_S_BUSY:
 116                 set_host_byte(sc, DID_BUS_BUSY);
 117                 break;
 118         case VIRTIO_SCSI_S_TRANSPORT_FAILURE:
 119                 set_host_byte(sc, DID_TRANSPORT_DISRUPTED);
 120                 break;
 121         case VIRTIO_SCSI_S_TARGET_FAILURE:
 122                 set_host_byte(sc, DID_TARGET_FAILURE);
 123                 break;
 124         case VIRTIO_SCSI_S_NEXUS_FAILURE:
 125                 set_host_byte(sc, DID_NEXUS_FAILURE);
 126                 break;
 127         default:
 128                 scmd_printk(KERN_WARNING, sc, "Unknown response %d",
 129                             resp->response);
 130                 /* fall through */
 131         case VIRTIO_SCSI_S_FAILURE:
 132                 set_host_byte(sc, DID_ERROR);
 133                 break;
 134         }
 135
 136         WARN_ON(resp->sense_len > VIRTIO_SCSI_SENSE_SIZE);
 137         if (sc->sense_buffer) {
 138                 memcpy(sc->sense_buffer, resp->sense,
 139                        min_t(u32, resp->sense_len, VIRTIO_SCSI_SENSE_SIZE));
 140                 if (resp->sense_len)
 141                         set_driver_byte(sc, DRIVER_SENSE);
 142         }
 143
 144         mempool_free(cmd, virtscsi_cmd_pool);
 145         sc->scsi_done(sc);
 146 }
 147
 148 static void virtscsi_vq_done(struct virtqueue *vq, void (*fn)(void *buf))
 149 {
 150         struct Scsi_Host *sh = virtio_scsi_host(vq->vdev);
 151         struct virtio_scsi *vscsi = shost_priv(sh);
 152         void *buf;
 153         unsigned long flags;
 154         unsigned int len;
 155
 156         spin_lock_irqsave(&vscsi->vq_lock, flags);
 157
 158         do {
 159                 virtqueue_disable_cb(vq);
 160                 while ((buf = virtqueue_get_buf(vq, &len)) != NULL)
 161                         fn(buf);
 162         } while (!virtqueue_enable_cb(vq));
 163
 164         spin_unlock_irqrestore(&vscsi->vq_lock, flags);
 165 }
 166
 167 static void virtscsi_req_done(struct virtqueue *vq)
 168 {
 169         virtscsi_vq_done(vq, virtscsi_complete_cmd);
 170 };
 171
 172 static void virtscsi_complete_free(void *buf)
 173 {
 174         struct virtio_scsi_cmd *cmd = buf;
 175
 176         if (cmd->comp)
 177                 complete_all(cmd->comp);
 178         else
 179                 mempool_free(cmd, virtscsi_cmd_pool);
 180 }
 181
 182 static void virtscsi_ctrl_done(struct virtqueue *vq)
 183 {
 184         virtscsi_vq_done(vq, virtscsi_complete_free);
 185 };
 186
 187 static void virtscsi_event_done(struct virtqueue *vq)
 188 {
 189         virtscsi_vq_done(vq, virtscsi_complete_free);
 190 };
 191
 192 static void virtscsi_map_sgl(struct scatterlist *sg, unsigned int *p_idx,
 193                              struct scsi_data_buffer *sdb)
 194 {
 195         struct sg_table *table = &sdb->table;
 196         struct scatterlist *sg_elem;
 197         unsigned int idx = *p_idx;
 198         int i;
 199
 200         for_each_sg(table->sgl, sg_elem, table->nents, i)
 201                 sg_set_buf(&sg[idx++], sg_virt(sg_elem), sg_elem->length);
 202
 203         *p_idx = idx;
 204 }
 205
 206 /**
 207  * virtscsi_map_cmd - map a scsi_cmd to a virtqueue scatterlist
 208  * @vscsi       : virtio_scsi state
 209  * @cmd         : command structure
 210  * @out_num     : number of read-only elements
 211  * @in_num      : number of write-only elements
 212  * @req_size    : size of the request buffer
 213  * @resp_size   : size of the response buffer
 214  *
 215  * Called with vq_lock held.
 216  */
 217 static void virtscsi_map_cmd(struct virtio_scsi *vscsi,
 218                              struct virtio_scsi_cmd *cmd,
 219                              unsigned *out_num, unsigned *in_num,
 220                              size_t req_size, size_t resp_size)
 221 {
 222         struct scsi_cmnd *sc = cmd->sc;
 223         struct scatterlist *sg = vscsi->sg;
 224         unsigned int idx = 0;
 225
 226         if (sc) {
 227                 struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
 228                 BUG_ON(scsi_sg_count(sc) > shost->sg_tablesize);
 229
 230                 /* TODO: check feature bit and fail if unsupported?  */
 231                 BUG_ON(sc->sc_data_direction == DMA_BIDIRECTIONAL);
 232         }
 233
 234         /* Request header.  */
 235         sg_set_buf(&sg[idx++], &cmd->req, req_size);
 236
 237         /* Data-out buffer.  */
 238         if (sc && sc->sc_data_direction != DMA_FROM_DEVICE)
 239                 virtscsi_map_sgl(sg, &idx, scsi_out(sc));
 240
 241         *out_num = idx;
 242
 243         /* Response header.  */
 244         sg_set_buf(&sg[idx++], &cmd->resp, resp_size);
 245
 246         /* Data-in buffer */
 247         if (sc && sc->sc_data_direction != DMA_TO_DEVICE)
 248                 virtscsi_map_sgl(sg, &idx, scsi_in(sc));
 249
 250         *in_num = idx - *out_num;
 251 }
 252
 253 static int virtscsi_kick_cmd(struct virtio_scsi *vscsi, struct virtqueue *vq,
 254                              struct virtio_scsi_cmd *cmd,
 255                              size_t req_size, size_t resp_size, gfp_t gfp)
 256 {
 257         unsigned int out_num, in_num;
 258         unsigned long flags;
 259         int ret;
 260
 261         spin_lock_irqsave(&vscsi->vq_lock, flags);
 262
 263         virtscsi_map_cmd(vscsi, cmd, &out_num, &in_num, req_size, resp_size);
 264
 265         ret = virtqueue_add_buf(vq, vscsi->sg, out_num, in_num, cmd, gfp);
 266         if (ret >= 0)
 267                 ret = virtqueue_kick_prepare(vq);
 268
 269         spin_unlock_irqrestore(&vscsi->vq_lock, flags);
 270         if (ret > 0)
 271                 virtqueue_notify(vq);
 272         return ret;
 273 }
 274
 275 static int virtscsi_queuecommand(struct Scsi_Host *sh, struct scsi_cmnd *sc)
 276 {
 277         struct virtio_scsi *vscsi = shost_priv(sh);
 278         struct virtio_scsi_cmd *cmd;
 279         int ret;
 280
 281         dev_dbg(&sc->device->sdev_gendev,
 282                 "cmd %p CDB: %#02x\n", sc, sc->cmnd[0]);
 283
 284         ret = SCSI_MLQUEUE_HOST_BUSY;
 285         cmd = mempool_alloc(virtscsi_cmd_pool, GFP_ATOMIC);
 286         if (!cmd)
 287                 goto out;
 288
 289         memset(cmd, 0, sizeof(*cmd));
 290         cmd->sc = sc;
 291         cmd->req.cmd = (struct virtio_scsi_cmd_req){
 292                 .lun[0] = 1,
 293                 .lun[1] = sc->device->id,
 294                 .lun[2] = (sc->device->lun >> 8) | 0x40,
 295                 .lun[3] = sc->device->lun & 0xff,
 296                 .tag = (unsigned long)sc,
 297                 .task_attr = VIRTIO_SCSI_S_SIMPLE,
 298                 .prio = 0,
 299                 .crn = 0,
 300         };
 301
 302         BUG_ON(sc->cmd_len > VIRTIO_SCSI_CDB_SIZE);
 303         memcpy(cmd->req.cmd.cdb, sc->cmnd, sc->cmd_len);
 304
 305         if (virtscsi_kick_cmd(vscsi, vscsi->req_vq, cmd,
 306                               sizeof cmd->req.cmd, sizeof cmd->resp.cmd,
 307                               GFP_ATOMIC) >= 0)
 308                 ret = 0;
 309
 310 out:
 311         return ret;
 312 }
 313
 314 static int virtscsi_tmf(struct virtio_scsi *vscsi, struct virtio_scsi_cmd *cmd)
 315 {
 316         DECLARE_COMPLETION_ONSTACK(comp);
 317         int ret = FAILED;
 318
 319         cmd->comp = &comp;
 320         if (virtscsi_kick_cmd(vscsi, vscsi->ctrl_vq, cmd,
 321                               sizeof cmd->req.tmf, sizeof cmd->resp.tmf,
 322                               GFP_NOIO) < 0)
 323                 goto out;
 324
 325         wait_for_completion(&comp);
 326         if (cmd->resp.tmf.response == VIRTIO_SCSI_S_OK ||
 327             cmd->resp.tmf.response == VIRTIO_SCSI_S_FUNCTION_SUCCEEDED)
 328                 ret = SUCCESS;
 329
 330 out:
 331         mempool_free(cmd, virtscsi_cmd_pool);
 332         return ret;
 333 }
 334
 335 static int virtscsi_device_reset(struct scsi_cmnd *sc)
 336 {
 337         struct virtio_scsi *vscsi = shost_priv(sc->device->host);
 338         struct virtio_scsi_cmd *cmd;
 339
 340         sdev_printk(KERN_INFO, sc->device, "device reset\n");
 341         cmd = mempool_alloc(virtscsi_cmd_pool, GFP_NOIO);
 342         if (!cmd)
 343                 return FAILED;
 344
 345         memset(cmd, 0, sizeof(*cmd));
 346         cmd->sc = sc;
 347         cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
 348                 .type = VIRTIO_SCSI_T_TMF,
 349                 .subtype = VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET,
 350                 .lun[0] = 1,
 351                 .lun[1] = sc->device->id,
 352                 .lun[2] = (sc->device->lun >> 8) | 0x40,
 353                 .lun[3] = sc->device->lun & 0xff,
 354         };
 355         return virtscsi_tmf(vscsi, cmd);
 356 }
 357
 358 static int virtscsi_abort(struct scsi_cmnd *sc)
 359 {
 360         struct virtio_scsi *vscsi = shost_priv(sc->device->host);
 361         struct virtio_scsi_cmd *cmd;
 362
 363         scmd_printk(KERN_INFO, sc, "abort\n");
 364         cmd = mempool_alloc(virtscsi_cmd_pool, GFP_NOIO);
 365         if (!cmd)
 366                 return FAILED;
 367
 368         memset(cmd, 0, sizeof(*cmd));
 369         cmd->sc = sc;
 370         cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
 371                 .type = VIRTIO_SCSI_T_TMF,
 372                 .subtype = VIRTIO_SCSI_T_TMF_ABORT_TASK,
 373                 .lun[0] = 1,
 374                 .lun[1] = sc->device->id,
 375                 .lun[2] = (sc->device->lun >> 8) | 0x40,
 376                 .lun[3] = sc->device->lun & 0xff,
 377                 .tag = (unsigned long)sc,
 378         };
 379         return virtscsi_tmf(vscsi, cmd);
 380 }
 381
 382 static struct scsi_host_template virtscsi_host_template = {
 383         .module = THIS_MODULE,
 384         .name = "Virtio SCSI HBA",
 385         .proc_name = "virtio_scsi",
 386         .queuecommand = virtscsi_queuecommand,
 387         .this_id = -1,
 388         .eh_abort_handler = virtscsi_abort,
 389         .eh_device_reset_handler = virtscsi_device_reset,
 390
 391         .can_queue = 1024,
 392         .dma_boundary = UINT_MAX,
 393         .use_clustering = ENABLE_CLUSTERING,
 394 };
 395
 396 #define virtscsi_config_get(vdev, fld) \
 397         ({ \
 398                 typeof(((struct virtio_scsi_config *)0)->fld) __val; \
 399                 vdev->config->get(vdev, \
 400                                   offsetof(struct virtio_scsi_config, fld), \
 401                                   &__val, sizeof(__val)); \
 402                 __val; \
 403         })
 404
 405 #define virtscsi_config_set(vdev, fld, val) \
 406         (void)({ \
 407                 typeof(((struct virtio_scsi_config *)0)->fld) __val = (val); \
 408                 vdev->config->set(vdev, \
 409                                   offsetof(struct virtio_scsi_config, fld), \
 410                                   &__val, sizeof(__val)); \
 411         })
 412
 413 static int virtscsi_init(struct virtio_device *vdev,
 414                          struct virtio_scsi *vscsi)
 415 {
 416         int err;
 417         struct virtqueue *vqs[3];
 418         vq_callback_t *callbacks[] = {
 419                 virtscsi_ctrl_done,
 420                 virtscsi_event_done,
 421                 virtscsi_req_done
 422         };
 423         const char *names[] = {
 424                 "control",
 425                 "event",
 426                 "request"
 427         };
 428
 429         /* Discover virtqueues and write information to configuration.  */
 430         err = vdev->config->find_vqs(vdev, 3, vqs, callbacks, names);
 431         if (err)
 432                 return err;
 433
 434         vscsi->ctrl_vq = vqs[0];
 435         vscsi->event_vq = vqs[1];
 436         vscsi->req_vq = vqs[2];
 437
 438         virtscsi_config_set(vdev, cdb_size, VIRTIO_SCSI_CDB_SIZE);
 439         virtscsi_config_set(vdev, sense_size, VIRTIO_SCSI_SENSE_SIZE);
 440         return 0;
 441 }
 442
 443 static int __devinit virtscsi_probe(struct virtio_device *vdev)
 444 {
 445         struct Scsi_Host *shost;
 446         struct virtio_scsi *vscsi;
 447         int err;
 448         u32 sg_elems;
 449         u32 cmd_per_lun;
 450
 451         /* We need to know how many segments before we allocate.
 452          * We need an extra sg elements at head and tail.
 453          */
 454         sg_elems = virtscsi_config_get(vdev, seg_max) ?: 1;
 455
 456         /* Allocate memory and link the structs together.  */
 457         shost = scsi_host_alloc(&virtscsi_host_template,
 458                 sizeof(*vscsi) + sizeof(vscsi->sg[0]) * (sg_elems + 2));
 459
 460         if (!shost)
 461                 return -ENOMEM;
 462
 463         shost->sg_tablesize = sg_elems;
 464         vscsi = shost_priv(shost);
 465         vscsi->vdev = vdev;
 466         vdev->priv = shost;
 467
 468         /* Random initializations.  */
 469         spin_lock_init(&vscsi->vq_lock);
 470         sg_init_table(vscsi->sg, sg_elems + 2);
 471
 472         err = virtscsi_init(vdev, vscsi);
 473         if (err)
 474                 goto virtscsi_init_failed;
 475
 476         cmd_per_lun = virtscsi_config_get(vdev, cmd_per_lun) ?: 1;
 477         shost->cmd_per_lun = min_t(u32, cmd_per_lun, shost->can_queue);
 478         shost->max_sectors = virtscsi_config_get(vdev, max_sectors) ?: 0xFFFF;
 479         shost->max_lun = virtscsi_config_get(vdev, max_lun) + 1;
 480         shost->max_id = virtscsi_config_get(vdev, max_target) + 1;
 481         shost->max_channel = 0;
 482         shost->max_cmd_len = VIRTIO_SCSI_CDB_SIZE;
 483         err = scsi_add_host(shost, &vdev->dev);
 484         if (err)
 485                 goto scsi_add_host_failed;
 486
 487         scsi_scan_host(shost);
 488
 489         return 0;
 490
 491 scsi_add_host_failed:
 492         vdev->config->del_vqs(vdev);
 493 virtscsi_init_failed:
 494         scsi_host_put(shost);
 495         return err;
 496 }
 497
 498 static void virtscsi_remove_vqs(struct virtio_device *vdev)
 499 {
 500         /* Stop all the virtqueues. */
 501         vdev->config->reset(vdev);
 502
 503         vdev->config->del_vqs(vdev);
 504 }
 505
 506 static void __devexit virtscsi_remove(struct virtio_device *vdev)
 507 {
 508         struct Scsi_Host *shost = virtio_scsi_host(vdev);
 509
 510         scsi_remove_host(shost);
 511
 512         virtscsi_remove_vqs(vdev);
 513         scsi_host_put(shost);
 514 }
 515
 516 #ifdef CONFIG_PM
 517 static int virtscsi_freeze(struct virtio_device *vdev)
 518 {
 519         virtscsi_remove_vqs(vdev);
 520         return 0;
 521 }
 522
 523 static int virtscsi_restore(struct virtio_device *vdev)
 524 {
 525         struct Scsi_Host *sh = virtio_scsi_host(vdev);
 526         struct virtio_scsi *vscsi = shost_priv(sh);
 527
 528         return virtscsi_init(vdev, vscsi);
 529 }
 530 #endif
 531
 532 static struct virtio_device_id id_table[] = {
 533         { VIRTIO_ID_SCSI, VIRTIO_DEV_ANY_ID },
 534         { 0 },
 535 };
 536
 537 static struct virtio_driver virtio_scsi_driver = {
 538         .driver.name = KBUILD_MODNAME,
 539         .driver.owner = THIS_MODULE,
 540         .id_table = id_table,
 541         .probe = virtscsi_probe,
 542 #ifdef CONFIG_PM
 543         .freeze = virtscsi_freeze,
 544         .restore = virtscsi_restore,
 545 #endif
 546         .remove = __devexit_p(virtscsi_remove),
 547 };
 548
 549 static int __init init(void)
 550 {
 551         int ret = -ENOMEM;
 552
 553         virtscsi_cmd_cache = KMEM_CACHE(virtio_scsi_cmd, 0);
 554         if (!virtscsi_cmd_cache) {
 555                 printk(KERN_ERR "kmem_cache_create() for "
 556                                 "virtscsi_cmd_cache failed\n");
 557                 goto error;
 558         }
 559
 560
 561         virtscsi_cmd_pool =
 562                 mempool_create_slab_pool(VIRTIO_SCSI_MEMPOOL_SZ,
 563                                          virtscsi_cmd_cache);
 564         if (!virtscsi_cmd_pool) {
 565                 printk(KERN_ERR "mempool_create() for"
 566                                 "virtscsi_cmd_pool failed\n");
 567                 goto error;
 568         }
 569         ret = register_virtio_driver(&virtio_scsi_driver);
 570         if (ret < 0)
 571                 goto error;
 572
 573         return 0;
 574
 575 error:
 576         if (virtscsi_cmd_pool) {
 577                 mempool_destroy(virtscsi_cmd_pool);
 578                 virtscsi_cmd_pool = NULL;
 579         }
 580         if (virtscsi_cmd_cache) {
 581                 kmem_cache_destroy(virtscsi_cmd_cache);
 582                 virtscsi_cmd_cache = NULL;
 583         }
 584         return ret;
 585 }
 586
 587 static void __exit fini(void)
 588 {
 589         unregister_virtio_driver(&virtio_scsi_driver);
 590         mempool_destroy(virtscsi_cmd_pool);
 591         kmem_cache_destroy(virtscsi_cmd_cache);
 592 }
 593 module_init(init);
 594 module_exit(fini);
 595
 596 MODULE_DEVICE_TABLE(virtio, id_table);
 597 MODULE_DESCRIPTION("Virtio SCSI HBA driver");
 598 MODULE_LICENSE("GPL");