drivers/scsi/virtio_scsi.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Virtio SCSI HBA driver
   4  *
   5  * Copyright IBM Corp. 2010
   6  * Copyright Red Hat, Inc. 2011
   7  *
   8  * Authors:
   9  *  Stefan Hajnoczi   <[email protected]>
  10  *  Paolo Bonzini   <[email protected]>
  11  */
  12
  13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  14
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17 #include <linux/mempool.h>
  18 #include <linux/interrupt.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 <linux/cpu.h>
  24 #include <linux/blkdev.h>
  25 #include <scsi/scsi_host.h>
  26 #include <scsi/scsi_device.h>
  27 #include <scsi/scsi_cmnd.h>
  28 #include <scsi/scsi_tcq.h>
  29 #include <scsi/scsi_devinfo.h>
  30 #include <linux/seqlock.h>
  31 #include <linux/blk-mq-virtio.h>
  32
  33 #define VIRTIO_SCSI_MEMPOOL_SZ 64
  34 #define VIRTIO_SCSI_EVENT_LEN 8
  35 #define VIRTIO_SCSI_VQ_BASE 2
  36
  37 /* Command queue element */
  38 struct virtio_scsi_cmd {
  39         struct scsi_cmnd *sc;
  40         struct completion *comp;
  41         union {
  42                 struct virtio_scsi_cmd_req       cmd;
  43                 struct virtio_scsi_cmd_req_pi    cmd_pi;
  44                 struct virtio_scsi_ctrl_tmf_req  tmf;
  45                 struct virtio_scsi_ctrl_an_req   an;
  46         } req;
  47         union {
  48                 struct virtio_scsi_cmd_resp      cmd;
  49                 struct virtio_scsi_ctrl_tmf_resp tmf;
  50                 struct virtio_scsi_ctrl_an_resp  an;
  51                 struct virtio_scsi_event         evt;
  52         } resp;
  53 } ____cacheline_aligned_in_smp;
  54
  55 struct virtio_scsi_event_node {
  56         struct virtio_scsi *vscsi;
  57         struct virtio_scsi_event event;
  58         struct work_struct work;
  59 };
  60
  61 struct virtio_scsi_vq {
  62         /* Protects vq */
  63         spinlock_t vq_lock;
  64
  65         struct virtqueue *vq;
  66 };
  67
  68 /* Driver instance state */
  69 struct virtio_scsi {
  70         struct virtio_device *vdev;
  71
  72         /* Get some buffers ready for event vq */
  73         struct virtio_scsi_event_node event_list[VIRTIO_SCSI_EVENT_LEN];
  74
  75         u32 num_queues;
  76
  77         struct hlist_node node;
  78
  79         /* Protected by event_vq lock */
  80         bool stop_events;
  81
  82         struct virtio_scsi_vq ctrl_vq;
  83         struct virtio_scsi_vq event_vq;
  84         struct virtio_scsi_vq req_vqs[];
  85 };
  86
  87 static struct kmem_cache *virtscsi_cmd_cache;
  88 static mempool_t *virtscsi_cmd_pool;
  89
  90 static inline struct Scsi_Host *virtio_scsi_host(struct virtio_device *vdev)
  91 {
  92         return vdev->priv;
  93 }
  94
  95 static void virtscsi_compute_resid(struct scsi_cmnd *sc, u32 resid)
  96 {
  97         if (resid)
  98                 scsi_set_resid(sc, resid);
  99 }
 100
 101 /**
 102  * virtscsi_complete_cmd - finish a scsi_cmd and invoke scsi_done
 103  *
 104  * Called with vq_lock held.
 105  */
 106 static void virtscsi_complete_cmd(struct virtio_scsi *vscsi, void *buf)
 107 {
 108         struct virtio_scsi_cmd *cmd = buf;
 109         struct scsi_cmnd *sc = cmd->sc;
 110         struct virtio_scsi_cmd_resp *resp = &cmd->resp.cmd;
 111
 112         dev_dbg(&sc->device->sdev_gendev,
 113                 "cmd %p response %u status %#02x sense_len %u\n",
 114                 sc, resp->response, resp->status, resp->sense_len);
 115
 116         sc->result = resp->status;
 117         virtscsi_compute_resid(sc, virtio32_to_cpu(vscsi->vdev, resp->resid));
 118         switch (resp->response) {
 119         case VIRTIO_SCSI_S_OK:
 120                 set_host_byte(sc, DID_OK);
 121                 break;
 122         case VIRTIO_SCSI_S_OVERRUN:
 123                 set_host_byte(sc, DID_ERROR);
 124                 break;
 125         case VIRTIO_SCSI_S_ABORTED:
 126                 set_host_byte(sc, DID_ABORT);
 127                 break;
 128         case VIRTIO_SCSI_S_BAD_TARGET:
 129                 set_host_byte(sc, DID_BAD_TARGET);
 130                 break;
 131         case VIRTIO_SCSI_S_RESET:
 132                 set_host_byte(sc, DID_RESET);
 133                 break;
 134         case VIRTIO_SCSI_S_BUSY:
 135                 set_host_byte(sc, DID_BUS_BUSY);
 136                 break;
 137         case VIRTIO_SCSI_S_TRANSPORT_FAILURE:
 138                 set_host_byte(sc, DID_TRANSPORT_DISRUPTED);
 139                 break;
 140         case VIRTIO_SCSI_S_TARGET_FAILURE:
 141                 set_host_byte(sc, DID_TARGET_FAILURE);
 142                 break;
 143         case VIRTIO_SCSI_S_NEXUS_FAILURE:
 144                 set_host_byte(sc, DID_NEXUS_FAILURE);
 145                 break;
 146         default:
 147                 scmd_printk(KERN_WARNING, sc, "Unknown response %d",
 148                             resp->response);
 149                 /* fall through */
 150         case VIRTIO_SCSI_S_FAILURE:
 151                 set_host_byte(sc, DID_ERROR);
 152                 break;
 153         }
 154
 155         WARN_ON(virtio32_to_cpu(vscsi->vdev, resp->sense_len) >
 156                 VIRTIO_SCSI_SENSE_SIZE);
 157         if (sc->sense_buffer) {
 158                 memcpy(sc->sense_buffer, resp->sense,
 159                        min_t(u32,
 160                              virtio32_to_cpu(vscsi->vdev, resp->sense_len),
 161                              VIRTIO_SCSI_SENSE_SIZE));
 162                 if (resp->sense_len)
 163                         set_driver_byte(sc, DRIVER_SENSE);
 164         }
 165
 166         sc->scsi_done(sc);
 167 }
 168
 169 static void virtscsi_vq_done(struct virtio_scsi *vscsi,
 170                              struct virtio_scsi_vq *virtscsi_vq,
 171                              void (*fn)(struct virtio_scsi *vscsi, void *buf))
 172 {
 173         void *buf;
 174         unsigned int len;
 175         unsigned long flags;
 176         struct virtqueue *vq = virtscsi_vq->vq;
 177
 178         spin_lock_irqsave(&virtscsi_vq->vq_lock, flags);
 179         do {
 180                 virtqueue_disable_cb(vq);
 181                 while ((buf = virtqueue_get_buf(vq, &len)) != NULL)
 182                         fn(vscsi, buf);
 183
 184                 if (unlikely(virtqueue_is_broken(vq)))
 185                         break;
 186         } while (!virtqueue_enable_cb(vq));
 187         spin_unlock_irqrestore(&virtscsi_vq->vq_lock, flags);
 188 }
 189
 190 static void virtscsi_req_done(struct virtqueue *vq)
 191 {
 192         struct Scsi_Host *sh = virtio_scsi_host(vq->vdev);
 193         struct virtio_scsi *vscsi = shost_priv(sh);
 194         int index = vq->index - VIRTIO_SCSI_VQ_BASE;
 195         struct virtio_scsi_vq *req_vq = &vscsi->req_vqs[index];
 196
 197         virtscsi_vq_done(vscsi, req_vq, virtscsi_complete_cmd);
 198 };
 199
 200 static void virtscsi_poll_requests(struct virtio_scsi *vscsi)
 201 {
 202         int i, num_vqs;
 203
 204         num_vqs = vscsi->num_queues;
 205         for (i = 0; i < num_vqs; i++)
 206                 virtscsi_vq_done(vscsi, &vscsi->req_vqs[i],
 207                                  virtscsi_complete_cmd);
 208 }
 209
 210 static void virtscsi_complete_free(struct virtio_scsi *vscsi, void *buf)
 211 {
 212         struct virtio_scsi_cmd *cmd = buf;
 213
 214         if (cmd->comp)
 215                 complete(cmd->comp);
 216 }
 217
 218 static void virtscsi_ctrl_done(struct virtqueue *vq)
 219 {
 220         struct Scsi_Host *sh = virtio_scsi_host(vq->vdev);
 221         struct virtio_scsi *vscsi = shost_priv(sh);
 222
 223         virtscsi_vq_done(vscsi, &vscsi->ctrl_vq, virtscsi_complete_free);
 224 };
 225
 226 static void virtscsi_handle_event(struct work_struct *work);
 227
 228 static int virtscsi_kick_event(struct virtio_scsi *vscsi,
 229                                struct virtio_scsi_event_node *event_node)
 230 {
 231         int err;
 232         struct scatterlist sg;
 233         unsigned long flags;
 234
 235         INIT_WORK(&event_node->work, virtscsi_handle_event);
 236         sg_init_one(&sg, &event_node->event, sizeof(struct virtio_scsi_event));
 237
 238         spin_lock_irqsave(&vscsi->event_vq.vq_lock, flags);
 239
 240         err = virtqueue_add_inbuf(vscsi->event_vq.vq, &sg, 1, event_node,
 241                                   GFP_ATOMIC);
 242         if (!err)
 243                 virtqueue_kick(vscsi->event_vq.vq);
 244
 245         spin_unlock_irqrestore(&vscsi->event_vq.vq_lock, flags);
 246
 247         return err;
 248 }
 249
 250 static int virtscsi_kick_event_all(struct virtio_scsi *vscsi)
 251 {
 252         int i;
 253
 254         for (i = 0; i < VIRTIO_SCSI_EVENT_LEN; i++) {
 255                 vscsi->event_list[i].vscsi = vscsi;
 256                 virtscsi_kick_event(vscsi, &vscsi->event_list[i]);
 257         }
 258
 259         return 0;
 260 }
 261
 262 static void virtscsi_cancel_event_work(struct virtio_scsi *vscsi)
 263 {
 264         int i;
 265
 266         /* Stop scheduling work before calling cancel_work_sync.  */
 267         spin_lock_irq(&vscsi->event_vq.vq_lock);
 268         vscsi->stop_events = true;
 269         spin_unlock_irq(&vscsi->event_vq.vq_lock);
 270
 271         for (i = 0; i < VIRTIO_SCSI_EVENT_LEN; i++)
 272                 cancel_work_sync(&vscsi->event_list[i].work);
 273 }
 274
 275 static void virtscsi_handle_transport_reset(struct virtio_scsi *vscsi,
 276                                             struct virtio_scsi_event *event)
 277 {
 278         struct scsi_device *sdev;
 279         struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
 280         unsigned int target = event->lun[1];
 281         unsigned int lun = (event->lun[2] << 8) | event->lun[3];
 282
 283         switch (virtio32_to_cpu(vscsi->vdev, event->reason)) {
 284         case VIRTIO_SCSI_EVT_RESET_RESCAN:
 285                 scsi_add_device(shost, 0, target, lun);
 286                 break;
 287         case VIRTIO_SCSI_EVT_RESET_REMOVED:
 288                 sdev = scsi_device_lookup(shost, 0, target, lun);
 289                 if (sdev) {
 290                         scsi_remove_device(sdev);
 291                         scsi_device_put(sdev);
 292                 } else {
 293                         pr_err("SCSI device %d 0 %d %d not found\n",
 294                                 shost->host_no, target, lun);
 295                 }
 296                 break;
 297         default:
 298                 pr_info("Unsupport virtio scsi event reason %x\n", event->reason);
 299         }
 300 }
 301
 302 static void virtscsi_handle_param_change(struct virtio_scsi *vscsi,
 303                                          struct virtio_scsi_event *event)
 304 {
 305         struct scsi_device *sdev;
 306         struct Scsi_Host *shost = virtio_scsi_host(vscsi->vdev);
 307         unsigned int target = event->lun[1];
 308         unsigned int lun = (event->lun[2] << 8) | event->lun[3];
 309         u8 asc = virtio32_to_cpu(vscsi->vdev, event->reason) & 255;
 310         u8 ascq = virtio32_to_cpu(vscsi->vdev, event->reason) >> 8;
 311
 312         sdev = scsi_device_lookup(shost, 0, target, lun);
 313         if (!sdev) {
 314                 pr_err("SCSI device %d 0 %d %d not found\n",
 315                         shost->host_no, target, lun);
 316                 return;
 317         }
 318
 319         /* Handle "Parameters changed", "Mode parameters changed", and
 320            "Capacity data has changed".  */
 321         if (asc == 0x2a && (ascq == 0x00 || ascq == 0x01 || ascq == 0x09))
 322                 scsi_rescan_device(&sdev->sdev_gendev);
 323
 324         scsi_device_put(sdev);
 325 }
 326
 327 static void virtscsi_handle_event(struct work_struct *work)
 328 {
 329         struct virtio_scsi_event_node *event_node =
 330                 container_of(work, struct virtio_scsi_event_node, work);
 331         struct virtio_scsi *vscsi = event_node->vscsi;
 332         struct virtio_scsi_event *event = &event_node->event;
 333
 334         if (event->event &
 335             cpu_to_virtio32(vscsi->vdev, VIRTIO_SCSI_T_EVENTS_MISSED)) {
 336                 event->event &= ~cpu_to_virtio32(vscsi->vdev,
 337                                                    VIRTIO_SCSI_T_EVENTS_MISSED);
 338                 scsi_scan_host(virtio_scsi_host(vscsi->vdev));
 339         }
 340
 341         switch (virtio32_to_cpu(vscsi->vdev, event->event)) {
 342         case VIRTIO_SCSI_T_NO_EVENT:
 343                 break;
 344         case VIRTIO_SCSI_T_TRANSPORT_RESET:
 345                 virtscsi_handle_transport_reset(vscsi, event);
 346                 break;
 347         case VIRTIO_SCSI_T_PARAM_CHANGE:
 348                 virtscsi_handle_param_change(vscsi, event);
 349                 break;
 350         default:
 351                 pr_err("Unsupport virtio scsi event %x\n", event->event);
 352         }
 353         virtscsi_kick_event(vscsi, event_node);
 354 }
 355
 356 static void virtscsi_complete_event(struct virtio_scsi *vscsi, void *buf)
 357 {
 358         struct virtio_scsi_event_node *event_node = buf;
 359
 360         if (!vscsi->stop_events)
 361                 queue_work(system_freezable_wq, &event_node->work);
 362 }
 363
 364 static void virtscsi_event_done(struct virtqueue *vq)
 365 {
 366         struct Scsi_Host *sh = virtio_scsi_host(vq->vdev);
 367         struct virtio_scsi *vscsi = shost_priv(sh);
 368
 369         virtscsi_vq_done(vscsi, &vscsi->event_vq, virtscsi_complete_event);
 370 };
 371
 372 /**
 373  * virtscsi_add_cmd - add a virtio_scsi_cmd to a virtqueue
 374  * @vq          : the struct virtqueue we're talking about
 375  * @cmd         : command structure
 376  * @req_size    : size of the request buffer
 377  * @resp_size   : size of the response buffer
 378  */
 379 static int virtscsi_add_cmd(struct virtqueue *vq,
 380                             struct virtio_scsi_cmd *cmd,
 381                             size_t req_size, size_t resp_size)
 382 {
 383         struct scsi_cmnd *sc = cmd->sc;
 384         struct scatterlist *sgs[6], req, resp;
 385         struct sg_table *out, *in;
 386         unsigned out_num = 0, in_num = 0;
 387
 388         out = in = NULL;
 389
 390         if (sc && sc->sc_data_direction != DMA_NONE) {
 391                 if (sc->sc_data_direction != DMA_FROM_DEVICE)
 392                         out = &sc->sdb.table;
 393                 if (sc->sc_data_direction != DMA_TO_DEVICE)
 394                         in = &sc->sdb.table;
 395         }
 396
 397         /* Request header.  */
 398         sg_init_one(&req, &cmd->req, req_size);
 399         sgs[out_num++] = &req;
 400
 401         /* Data-out buffer.  */
 402         if (out) {
 403                 /* Place WRITE protection SGLs before Data OUT payload */
 404                 if (scsi_prot_sg_count(sc))
 405                         sgs[out_num++] = scsi_prot_sglist(sc);
 406                 sgs[out_num++] = out->sgl;
 407         }
 408
 409         /* Response header.  */
 410         sg_init_one(&resp, &cmd->resp, resp_size);
 411         sgs[out_num + in_num++] = &resp;
 412
 413         /* Data-in buffer */
 414         if (in) {
 415                 /* Place READ protection SGLs before Data IN payload */
 416                 if (scsi_prot_sg_count(sc))
 417                         sgs[out_num + in_num++] = scsi_prot_sglist(sc);
 418                 sgs[out_num + in_num++] = in->sgl;
 419         }
 420
 421         return virtqueue_add_sgs(vq, sgs, out_num, in_num, cmd, GFP_ATOMIC);
 422 }
 423
 424 static int virtscsi_kick_cmd(struct virtio_scsi_vq *vq,
 425                              struct virtio_scsi_cmd *cmd,
 426                              size_t req_size, size_t resp_size)
 427 {
 428         unsigned long flags;
 429         int err;
 430         bool needs_kick = false;
 431
 432         spin_lock_irqsave(&vq->vq_lock, flags);
 433         err = virtscsi_add_cmd(vq->vq, cmd, req_size, resp_size);
 434         if (!err)
 435                 needs_kick = virtqueue_kick_prepare(vq->vq);
 436
 437         spin_unlock_irqrestore(&vq->vq_lock, flags);
 438
 439         if (needs_kick)
 440                 virtqueue_notify(vq->vq);
 441         return err;
 442 }
 443
 444 static void virtio_scsi_init_hdr(struct virtio_device *vdev,
 445                                  struct virtio_scsi_cmd_req *cmd,
 446                                  struct scsi_cmnd *sc)
 447 {
 448         cmd->lun[0] = 1;
 449         cmd->lun[1] = sc->device->id;
 450         cmd->lun[2] = (sc->device->lun >> 8) | 0x40;
 451         cmd->lun[3] = sc->device->lun & 0xff;
 452         cmd->tag = cpu_to_virtio64(vdev, (unsigned long)sc);
 453         cmd->task_attr = VIRTIO_SCSI_S_SIMPLE;
 454         cmd->prio = 0;
 455         cmd->crn = 0;
 456 }
 457
 458 #ifdef CONFIG_BLK_DEV_INTEGRITY
 459 static void virtio_scsi_init_hdr_pi(struct virtio_device *vdev,
 460                                     struct virtio_scsi_cmd_req_pi *cmd_pi,
 461                                     struct scsi_cmnd *sc)
 462 {
 463         struct request *rq = sc->request;
 464         struct blk_integrity *bi;
 465
 466         virtio_scsi_init_hdr(vdev, (struct virtio_scsi_cmd_req *)cmd_pi, sc);
 467
 468         if (!rq || !scsi_prot_sg_count(sc))
 469                 return;
 470
 471         bi = blk_get_integrity(rq->rq_disk);
 472
 473         if (sc->sc_data_direction == DMA_TO_DEVICE)
 474                 cmd_pi->pi_bytesout = cpu_to_virtio32(vdev,
 475                                                       bio_integrity_bytes(bi,
 476                                                         blk_rq_sectors(rq)));
 477         else if (sc->sc_data_direction == DMA_FROM_DEVICE)
 478                 cmd_pi->pi_bytesin = cpu_to_virtio32(vdev,
 479                                                      bio_integrity_bytes(bi,
 480                                                         blk_rq_sectors(rq)));
 481 }
 482 #endif
 483
 484 static struct virtio_scsi_vq *virtscsi_pick_vq_mq(struct virtio_scsi *vscsi,
 485                                                   struct scsi_cmnd *sc)
 486 {
 487         u32 tag = blk_mq_unique_tag(sc->request);
 488         u16 hwq = blk_mq_unique_tag_to_hwq(tag);
 489
 490         return &vscsi->req_vqs[hwq];
 491 }
 492
 493 static int virtscsi_queuecommand(struct Scsi_Host *shost,
 494                                  struct scsi_cmnd *sc)
 495 {
 496         struct virtio_scsi *vscsi = shost_priv(shost);
 497         struct virtio_scsi_vq *req_vq = virtscsi_pick_vq_mq(vscsi, sc);
 498         struct virtio_scsi_cmd *cmd = scsi_cmd_priv(sc);
 499         unsigned long flags;
 500         int req_size;
 501         int ret;
 502
 503         BUG_ON(scsi_sg_count(sc) > shost->sg_tablesize);
 504
 505         /* TODO: check feature bit and fail if unsupported?  */
 506         BUG_ON(sc->sc_data_direction == DMA_BIDIRECTIONAL);
 507
 508         dev_dbg(&sc->device->sdev_gendev,
 509                 "cmd %p CDB: %#02x\n", sc, sc->cmnd[0]);
 510
 511         cmd->sc = sc;
 512
 513         BUG_ON(sc->cmd_len > VIRTIO_SCSI_CDB_SIZE);
 514
 515 #ifdef CONFIG_BLK_DEV_INTEGRITY
 516         if (virtio_has_feature(vscsi->vdev, VIRTIO_SCSI_F_T10_PI)) {
 517                 virtio_scsi_init_hdr_pi(vscsi->vdev, &cmd->req.cmd_pi, sc);
 518                 memcpy(cmd->req.cmd_pi.cdb, sc->cmnd, sc->cmd_len);
 519                 req_size = sizeof(cmd->req.cmd_pi);
 520         } else
 521 #endif
 522         {
 523                 virtio_scsi_init_hdr(vscsi->vdev, &cmd->req.cmd, sc);
 524                 memcpy(cmd->req.cmd.cdb, sc->cmnd, sc->cmd_len);
 525                 req_size = sizeof(cmd->req.cmd);
 526         }
 527
 528         ret = virtscsi_kick_cmd(req_vq, cmd, req_size, sizeof(cmd->resp.cmd));
 529         if (ret == -EIO) {
 530                 cmd->resp.cmd.response = VIRTIO_SCSI_S_BAD_TARGET;
 531                 spin_lock_irqsave(&req_vq->vq_lock, flags);
 532                 virtscsi_complete_cmd(vscsi, cmd);
 533                 spin_unlock_irqrestore(&req_vq->vq_lock, flags);
 534         } else if (ret != 0) {
 535                 return SCSI_MLQUEUE_HOST_BUSY;
 536         }
 537         return 0;
 538 }
 539
 540 static int virtscsi_tmf(struct virtio_scsi *vscsi, struct virtio_scsi_cmd *cmd)
 541 {
 542         DECLARE_COMPLETION_ONSTACK(comp);
 543         int ret = FAILED;
 544
 545         cmd->comp = &comp;
 546         if (virtscsi_kick_cmd(&vscsi->ctrl_vq, cmd,
 547                               sizeof cmd->req.tmf, sizeof cmd->resp.tmf) < 0)
 548                 goto out;
 549
 550         wait_for_completion(&comp);
 551         if (cmd->resp.tmf.response == VIRTIO_SCSI_S_OK ||
 552             cmd->resp.tmf.response == VIRTIO_SCSI_S_FUNCTION_SUCCEEDED)
 553                 ret = SUCCESS;
 554
 555         /*
 556          * The spec guarantees that all requests related to the TMF have
 557          * been completed, but the callback might not have run yet if
 558          * we're using independent interrupts (e.g. MSI).  Poll the
 559          * virtqueues once.
 560          *
 561          * In the abort case, sc->scsi_done will do nothing, because
 562          * the block layer must have detected a timeout and as a result
 563          * REQ_ATOM_COMPLETE has been set.
 564          */
 565         virtscsi_poll_requests(vscsi);
 566
 567 out:
 568         mempool_free(cmd, virtscsi_cmd_pool);
 569         return ret;
 570 }
 571
 572 static int virtscsi_device_reset(struct scsi_cmnd *sc)
 573 {
 574         struct virtio_scsi *vscsi = shost_priv(sc->device->host);
 575         struct virtio_scsi_cmd *cmd;
 576
 577         sdev_printk(KERN_INFO, sc->device, "device reset\n");
 578         cmd = mempool_alloc(virtscsi_cmd_pool, GFP_NOIO);
 579         if (!cmd)
 580                 return FAILED;
 581
 582         memset(cmd, 0, sizeof(*cmd));
 583         cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
 584                 .type = VIRTIO_SCSI_T_TMF,
 585                 .subtype = cpu_to_virtio32(vscsi->vdev,
 586                                              VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET),
 587                 .lun[0] = 1,
 588                 .lun[1] = sc->device->id,
 589                 .lun[2] = (sc->device->lun >> 8) | 0x40,
 590                 .lun[3] = sc->device->lun & 0xff,
 591         };
 592         return virtscsi_tmf(vscsi, cmd);
 593 }
 594
 595 static int virtscsi_device_alloc(struct scsi_device *sdevice)
 596 {
 597         /*
 598          * Passed through SCSI targets (e.g. with qemu's 'scsi-block')
 599          * may have transfer limits which come from the host SCSI
 600          * controller or something on the host side other than the
 601          * target itself.
 602          *
 603          * To make this work properly, the hypervisor can adjust the
 604          * target's VPD information to advertise these limits.  But
 605          * for that to work, the guest has to look at the VPD pages,
 606          * which we won't do by default if it is an SPC-2 device, even
 607          * if it does actually support it.
 608          *
 609          * So, set the blist to always try to read the VPD pages.
 610          */
 611         sdevice->sdev_bflags = BLIST_TRY_VPD_PAGES;
 612
 613         return 0;
 614 }
 615
 616
 617 /**
 618  * virtscsi_change_queue_depth() - Change a virtscsi target's queue depth
 619  * @sdev:       Virtscsi target whose queue depth to change
 620  * @qdepth:     New queue depth
 621  */
 622 static int virtscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
 623 {
 624         struct Scsi_Host *shost = sdev->host;
 625         int max_depth = shost->cmd_per_lun;
 626
 627         return scsi_change_queue_depth(sdev, min(max_depth, qdepth));
 628 }
 629
 630 static int virtscsi_abort(struct scsi_cmnd *sc)
 631 {
 632         struct virtio_scsi *vscsi = shost_priv(sc->device->host);
 633         struct virtio_scsi_cmd *cmd;
 634
 635         scmd_printk(KERN_INFO, sc, "abort\n");
 636         cmd = mempool_alloc(virtscsi_cmd_pool, GFP_NOIO);
 637         if (!cmd)
 638                 return FAILED;
 639
 640         memset(cmd, 0, sizeof(*cmd));
 641         cmd->req.tmf = (struct virtio_scsi_ctrl_tmf_req){
 642                 .type = VIRTIO_SCSI_T_TMF,
 643                 .subtype = VIRTIO_SCSI_T_TMF_ABORT_TASK,
 644                 .lun[0] = 1,
 645                 .lun[1] = sc->device->id,
 646                 .lun[2] = (sc->device->lun >> 8) | 0x40,
 647                 .lun[3] = sc->device->lun & 0xff,
 648                 .tag = cpu_to_virtio64(vscsi->vdev, (unsigned long)sc),
 649         };
 650         return virtscsi_tmf(vscsi, cmd);
 651 }
 652
 653 static int virtscsi_map_queues(struct Scsi_Host *shost)
 654 {
 655         struct virtio_scsi *vscsi = shost_priv(shost);
 656         struct blk_mq_queue_map *qmap = &shost->tag_set.map[HCTX_TYPE_DEFAULT];
 657
 658         return blk_mq_virtio_map_queues(qmap, vscsi->vdev, 2);
 659 }
 660
 661 /*
 662  * The host guarantees to respond to each command, although I/O
 663  * latencies might be higher than on bare metal.  Reset the timer
 664  * unconditionally to give the host a chance to perform EH.
 665  */
 666 static enum blk_eh_timer_return virtscsi_eh_timed_out(struct scsi_cmnd *scmnd)
 667 {
 668         return BLK_EH_RESET_TIMER;
 669 }
 670
 671 static struct scsi_host_template virtscsi_host_template = {
 672         .module = THIS_MODULE,
 673         .name = "Virtio SCSI HBA",
 674         .proc_name = "virtio_scsi",
 675         .this_id = -1,
 676         .cmd_size = sizeof(struct virtio_scsi_cmd),
 677         .queuecommand = virtscsi_queuecommand,
 678         .change_queue_depth = virtscsi_change_queue_depth,
 679         .eh_abort_handler = virtscsi_abort,
 680         .eh_device_reset_handler = virtscsi_device_reset,
 681         .eh_timed_out = virtscsi_eh_timed_out,
 682         .slave_alloc = virtscsi_device_alloc,
 683
 684         .dma_boundary = UINT_MAX,
 685         .map_queues = virtscsi_map_queues,
 686         .track_queue_depth = 1,
 687         .force_blk_mq = 1,
 688 };
 689
 690 #define virtscsi_config_get(vdev, fld) \
 691         ({ \
 692                 typeof(((struct virtio_scsi_config *)0)->fld) __val; \
 693                 virtio_cread(vdev, struct virtio_scsi_config, fld, &__val); \
 694                 __val; \
 695         })
 696
 697 #define virtscsi_config_set(vdev, fld, val) \
 698         do { \
 699                 typeof(((struct virtio_scsi_config *)0)->fld) __val = (val); \
 700                 virtio_cwrite(vdev, struct virtio_scsi_config, fld, &__val); \
 701         } while(0)
 702
 703 static void virtscsi_init_vq(struct virtio_scsi_vq *virtscsi_vq,
 704                              struct virtqueue *vq)
 705 {
 706         spin_lock_init(&virtscsi_vq->vq_lock);
 707         virtscsi_vq->vq = vq;
 708 }
 709
 710 static void virtscsi_remove_vqs(struct virtio_device *vdev)
 711 {
 712         /* Stop all the virtqueues. */
 713         vdev->config->reset(vdev);
 714         vdev->config->del_vqs(vdev);
 715 }
 716
 717 static int virtscsi_init(struct virtio_device *vdev,
 718                          struct virtio_scsi *vscsi)
 719 {
 720         int err;
 721         u32 i;
 722         u32 num_vqs;
 723         vq_callback_t **callbacks;
 724         const char **names;
 725         struct virtqueue **vqs;
 726         struct irq_affinity desc = { .pre_vectors = 2 };
 727
 728         num_vqs = vscsi->num_queues + VIRTIO_SCSI_VQ_BASE;
 729         vqs = kmalloc_array(num_vqs, sizeof(struct virtqueue *), GFP_KERNEL);
 730         callbacks = kmalloc_array(num_vqs, sizeof(vq_callback_t *),
 731                                   GFP_KERNEL);
 732         names = kmalloc_array(num_vqs, sizeof(char *), GFP_KERNEL);
 733
 734         if (!callbacks || !vqs || !names) {
 735                 err = -ENOMEM;
 736                 goto out;
 737         }
 738
 739         callbacks[0] = virtscsi_ctrl_done;
 740         callbacks[1] = virtscsi_event_done;
 741         names[0] = "control";
 742         names[1] = "event";
 743         for (i = VIRTIO_SCSI_VQ_BASE; i < num_vqs; i++) {
 744                 callbacks[i] = virtscsi_req_done;
 745                 names[i] = "request";
 746         }
 747
 748         /* Discover virtqueues and write information to configuration.  */
 749         err = virtio_find_vqs(vdev, num_vqs, vqs, callbacks, names, &desc);
 750         if (err)
 751                 goto out;
 752
 753         virtscsi_init_vq(&vscsi->ctrl_vq, vqs[0]);
 754         virtscsi_init_vq(&vscsi->event_vq, vqs[1]);
 755         for (i = VIRTIO_SCSI_VQ_BASE; i < num_vqs; i++)
 756                 virtscsi_init_vq(&vscsi->req_vqs[i - VIRTIO_SCSI_VQ_BASE],
 757                                  vqs[i]);
 758
 759         virtscsi_config_set(vdev, cdb_size, VIRTIO_SCSI_CDB_SIZE);
 760         virtscsi_config_set(vdev, sense_size, VIRTIO_SCSI_SENSE_SIZE);
 761
 762         err = 0;
 763
 764 out:
 765         kfree(names);
 766         kfree(callbacks);
 767         kfree(vqs);
 768         if (err)
 769                 virtscsi_remove_vqs(vdev);
 770         return err;
 771 }
 772
 773 static int virtscsi_probe(struct virtio_device *vdev)
 774 {
 775         struct Scsi_Host *shost;
 776         struct virtio_scsi *vscsi;
 777         int err;
 778         u32 sg_elems, num_targets;
 779         u32 cmd_per_lun;
 780         u32 num_queues;
 781
 782         if (!vdev->config->get) {
 783                 dev_err(&vdev->dev, "%s failure: config access disabled\n",
 784                         __func__);
 785                 return -EINVAL;
 786         }
 787
 788         /* We need to know how many queues before we allocate. */
 789         num_queues = virtscsi_config_get(vdev, num_queues) ? : 1;
 790         num_queues = min_t(unsigned int, nr_cpu_ids, num_queues);
 791
 792         num_targets = virtscsi_config_get(vdev, max_target) + 1;
 793
 794         shost = scsi_host_alloc(&virtscsi_host_template,
 795                                 struct_size(vscsi, req_vqs, num_queues));
 796         if (!shost)
 797                 return -ENOMEM;
 798
 799         sg_elems = virtscsi_config_get(vdev, seg_max) ?: 1;
 800         shost->sg_tablesize = sg_elems;
 801         vscsi = shost_priv(shost);
 802         vscsi->vdev = vdev;
 803         vscsi->num_queues = num_queues;
 804         vdev->priv = shost;
 805
 806         err = virtscsi_init(vdev, vscsi);
 807         if (err)
 808                 goto virtscsi_init_failed;
 809
 810         shost->can_queue = virtqueue_get_vring_size(vscsi->req_vqs[0].vq);
 811
 812         cmd_per_lun = virtscsi_config_get(vdev, cmd_per_lun) ?: 1;
 813         shost->cmd_per_lun = min_t(u32, cmd_per_lun, shost->can_queue);
 814         shost->max_sectors = virtscsi_config_get(vdev, max_sectors) ?: 0xFFFF;
 815
 816         /* LUNs > 256 are reported with format 1, so they go in the range
 817          * 16640-32767.
 818          */
 819         shost->max_lun = virtscsi_config_get(vdev, max_lun) + 1 + 0x4000;
 820         shost->max_id = num_targets;
 821         shost->max_channel = 0;
 822         shost->max_cmd_len = VIRTIO_SCSI_CDB_SIZE;
 823         shost->nr_hw_queues = num_queues;
 824
 825 #ifdef CONFIG_BLK_DEV_INTEGRITY
 826         if (virtio_has_feature(vdev, VIRTIO_SCSI_F_T10_PI)) {
 827                 int host_prot;
 828
 829                 host_prot = SHOST_DIF_TYPE1_PROTECTION | SHOST_DIF_TYPE2_PROTECTION |
 830                             SHOST_DIF_TYPE3_PROTECTION | SHOST_DIX_TYPE1_PROTECTION |
 831                             SHOST_DIX_TYPE2_PROTECTION | SHOST_DIX_TYPE3_PROTECTION;
 832
 833                 scsi_host_set_prot(shost, host_prot);
 834                 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
 835         }
 836 #endif
 837
 838         err = scsi_add_host(shost, &vdev->dev);
 839         if (err)
 840                 goto scsi_add_host_failed;
 841
 842         virtio_device_ready(vdev);
 843
 844         if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG))
 845                 virtscsi_kick_event_all(vscsi);
 846
 847         scsi_scan_host(shost);
 848         return 0;
 849
 850 scsi_add_host_failed:
 851         vdev->config->del_vqs(vdev);
 852 virtscsi_init_failed:
 853         scsi_host_put(shost);
 854         return err;
 855 }
 856
 857 static void virtscsi_remove(struct virtio_device *vdev)
 858 {
 859         struct Scsi_Host *shost = virtio_scsi_host(vdev);
 860         struct virtio_scsi *vscsi = shost_priv(shost);
 861
 862         if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG))
 863                 virtscsi_cancel_event_work(vscsi);
 864
 865         scsi_remove_host(shost);
 866         virtscsi_remove_vqs(vdev);
 867         scsi_host_put(shost);
 868 }
 869
 870 #ifdef CONFIG_PM_SLEEP
 871 static int virtscsi_freeze(struct virtio_device *vdev)
 872 {
 873         virtscsi_remove_vqs(vdev);
 874         return 0;
 875 }
 876
 877 static int virtscsi_restore(struct virtio_device *vdev)
 878 {
 879         struct Scsi_Host *sh = virtio_scsi_host(vdev);
 880         struct virtio_scsi *vscsi = shost_priv(sh);
 881         int err;
 882
 883         err = virtscsi_init(vdev, vscsi);
 884         if (err)
 885                 return err;
 886
 887         virtio_device_ready(vdev);
 888
 889         if (virtio_has_feature(vdev, VIRTIO_SCSI_F_HOTPLUG))
 890                 virtscsi_kick_event_all(vscsi);
 891
 892         return err;
 893 }
 894 #endif
 895
 896 static struct virtio_device_id id_table[] = {
 897         { VIRTIO_ID_SCSI, VIRTIO_DEV_ANY_ID },
 898         { 0 },
 899 };
 900
 901 static unsigned int features[] = {
 902         VIRTIO_SCSI_F_HOTPLUG,
 903         VIRTIO_SCSI_F_CHANGE,
 904 #ifdef CONFIG_BLK_DEV_INTEGRITY
 905         VIRTIO_SCSI_F_T10_PI,
 906 #endif
 907 };
 908
 909 static struct virtio_driver virtio_scsi_driver = {
 910         .feature_table = features,
 911         .feature_table_size = ARRAY_SIZE(features),
 912         .driver.name = KBUILD_MODNAME,
 913         .driver.owner = THIS_MODULE,
 914         .id_table = id_table,
 915         .probe = virtscsi_probe,
 916 #ifdef CONFIG_PM_SLEEP
 917         .freeze = virtscsi_freeze,
 918         .restore = virtscsi_restore,
 919 #endif
 920         .remove = virtscsi_remove,
 921 };
 922
 923 static int __init init(void)
 924 {
 925         int ret = -ENOMEM;
 926
 927         virtscsi_cmd_cache = KMEM_CACHE(virtio_scsi_cmd, 0);
 928         if (!virtscsi_cmd_cache) {
 929                 pr_err("kmem_cache_create() for virtscsi_cmd_cache failed\n");
 930                 goto error;
 931         }
 932
 933
 934         virtscsi_cmd_pool =
 935                 mempool_create_slab_pool(VIRTIO_SCSI_MEMPOOL_SZ,
 936                                          virtscsi_cmd_cache);
 937         if (!virtscsi_cmd_pool) {
 938                 pr_err("mempool_create() for virtscsi_cmd_pool failed\n");
 939                 goto error;
 940         }
 941         ret = register_virtio_driver(&virtio_scsi_driver);
 942         if (ret < 0)
 943                 goto error;
 944
 945         return 0;
 946
 947 error:
 948         if (virtscsi_cmd_pool) {
 949                 mempool_destroy(virtscsi_cmd_pool);
 950                 virtscsi_cmd_pool = NULL;
 951         }
 952         if (virtscsi_cmd_cache) {
 953                 kmem_cache_destroy(virtscsi_cmd_cache);
 954                 virtscsi_cmd_cache = NULL;
 955         }
 956         return ret;
 957 }
 958
 959 static void __exit fini(void)
 960 {
 961         unregister_virtio_driver(&virtio_scsi_driver);
 962         mempool_destroy(virtscsi_cmd_pool);
 963         kmem_cache_destroy(virtscsi_cmd_cache);
 964 }
 965 module_init(init);
 966 module_exit(fini);
 967
 968 MODULE_DEVICE_TABLE(virtio, id_table);
 969 MODULE_DESCRIPTION("Virtio SCSI HBA driver");
 970 MODULE_LICENSE("GPL");