hw/scsi/virtio-scsi.c

   1 /*
   2  * Virtio SCSI HBA
   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 "hw/virtio/virtio-scsi.h"
  17 #include "qemu/error-report.h"
  18 #include "qemu/iov.h"
  19 #include <hw/scsi/scsi.h>
  20 #include <block/scsi.h>
  21 #include <hw/virtio/virtio-bus.h>
  22 #include "hw/virtio/virtio-access.h"
  23
  24 typedef struct VirtIOSCSIReq {
  25     VirtIOSCSI *dev;
  26     VirtQueue *vq;
  27     VirtQueueElement elem;
  28     QEMUSGList qsgl;
  29     SCSIRequest *sreq;
  30     size_t resp_size;
  31     enum SCSIXferMode mode;
  32     QEMUIOVector resp_iov;
  33     union {
  34         VirtIOSCSICmdResp     cmd;
  35         VirtIOSCSICtrlTMFResp tmf;
  36         VirtIOSCSICtrlANResp  an;
  37         VirtIOSCSIEvent       event;
  38     } resp;
  39     union {
  40         struct {
  41             VirtIOSCSICmdReq  cmd;
  42             uint8_t           cdb[];
  43         } QEMU_PACKED;
  44         VirtIOSCSICtrlTMFReq  tmf;
  45         VirtIOSCSICtrlANReq   an;
  46     } req;
  47 } VirtIOSCSIReq;
  48
  49 QEMU_BUILD_BUG_ON(offsetof(VirtIOSCSIReq, req.cdb) !=
  50                   offsetof(VirtIOSCSIReq, req.cmd) + sizeof(VirtIOSCSICmdReq));
  51
  52 static inline int virtio_scsi_get_lun(uint8_t *lun)
  53 {
  54     return ((lun[2] << 8) | lun[3]) & 0x3FFF;
  55 }
  56
  57 static inline SCSIDevice *virtio_scsi_device_find(VirtIOSCSI *s, uint8_t *lun)
  58 {
  59     if (lun[0] != 1) {
  60         return NULL;
  61     }
  62     if (lun[2] != 0 && !(lun[2] >= 0x40 && lun[2] < 0x80)) {
  63         return NULL;
  64     }
  65     return scsi_device_find(&s->bus, 0, lun[1], virtio_scsi_get_lun(lun));
  66 }
  67
  68 static VirtIOSCSIReq *virtio_scsi_init_req(VirtIOSCSI *s, VirtQueue *vq)
  69 {
  70     VirtIOSCSIReq *req;
  71     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
  72
  73     req = g_malloc0(sizeof(*req) + vs->cdb_size);
  74
  75     req->vq = vq;
  76     req->dev = s;
  77     req->sreq = NULL;
  78     qemu_sglist_init(&req->qsgl, DEVICE(s), 8, &address_space_memory);
  79     qemu_iovec_init(&req->resp_iov, 1);
  80     return req;
  81 }
  82
  83 static void virtio_scsi_free_req(VirtIOSCSIReq *req)
  84 {
  85     qemu_iovec_destroy(&req->resp_iov);
  86     qemu_sglist_destroy(&req->qsgl);
  87     g_free(req);
  88 }
  89
  90 static void virtio_scsi_complete_req(VirtIOSCSIReq *req)
  91 {
  92     VirtIOSCSI *s = req->dev;
  93     VirtQueue *vq = req->vq;
  94     VirtIODevice *vdev = VIRTIO_DEVICE(s);
  95
  96     qemu_iovec_from_buf(&req->resp_iov, 0, &req->resp, req->resp_size);
  97     virtqueue_push(vq, &req->elem, req->qsgl.size + req->resp_iov.size);
  98     if (req->sreq) {
  99         req->sreq->hba_private = NULL;
 100         scsi_req_unref(req->sreq);
 101     }
 102     virtio_scsi_free_req(req);
 103     virtio_notify(vdev, vq);
 104 }
 105
 106 static void virtio_scsi_bad_req(void)
 107 {
 108     error_report("wrong size for virtio-scsi headers");
 109     exit(1);
 110 }
 111
 112 static size_t qemu_sgl_concat(VirtIOSCSIReq *req, struct iovec *iov,
 113                               hwaddr *addr, int num, size_t skip)
 114 {
 115     QEMUSGList *qsgl = &req->qsgl;
 116     size_t copied = 0;
 117
 118     while (num) {
 119         if (skip >= iov->iov_len) {
 120             skip -= iov->iov_len;
 121         } else {
 122             qemu_sglist_add(qsgl, *addr + skip, iov->iov_len - skip);
 123             copied += iov->iov_len - skip;
 124             skip = 0;
 125         }
 126         iov++;
 127         addr++;
 128         num--;
 129     }
 130
 131     assert(skip == 0);
 132     return copied;
 133 }
 134
 135 static int virtio_scsi_parse_req(VirtIOSCSIReq *req,
 136                                  unsigned req_size, unsigned resp_size)
 137 {
 138     size_t in_size, out_size;
 139
 140     if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0,
 141                    &req->req, req_size) < req_size) {
 142         return -EINVAL;
 143     }
 144
 145     if (qemu_iovec_concat_iov(&req->resp_iov,
 146                               req->elem.in_sg, req->elem.in_num, 0,
 147                               resp_size) < resp_size) {
 148         return -EINVAL;
 149     }
 150     req->resp_size = resp_size;
 151
 152     out_size = qemu_sgl_concat(req, req->elem.out_sg,
 153                                &req->elem.out_addr[0], req->elem.out_num,
 154                                req_size);
 155     in_size = qemu_sgl_concat(req, req->elem.in_sg,
 156                               &req->elem.in_addr[0], req->elem.in_num,
 157                               resp_size);
 158
 159     if (out_size && in_size) {
 160         return -ENOTSUP;
 161     }
 162
 163     if (out_size) {
 164         req->mode = SCSI_XFER_TO_DEV;
 165     } else if (in_size) {
 166         req->mode = SCSI_XFER_FROM_DEV;
 167     }
 168
 169     return 0;
 170 }
 171
 172 static VirtIOSCSIReq *virtio_scsi_pop_req(VirtIOSCSI *s, VirtQueue *vq)
 173 {
 174     VirtIOSCSIReq *req = virtio_scsi_init_req(s, vq);
 175     if (!virtqueue_pop(vq, &req->elem)) {
 176         virtio_scsi_free_req(req);
 177         return NULL;
 178     }
 179     return req;
 180 }
 181
 182 static void virtio_scsi_save_request(QEMUFile *f, SCSIRequest *sreq)
 183 {
 184     VirtIOSCSIReq *req = sreq->hba_private;
 185     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(req->dev);
 186     uint32_t n = virtio_queue_get_id(req->vq) - 2;
 187
 188     assert(n < vs->conf.num_queues);
 189     qemu_put_be32s(f, &n);
 190     qemu_put_buffer(f, (unsigned char *)&req->elem, sizeof(req->elem));
 191 }
 192
 193 static void *virtio_scsi_load_request(QEMUFile *f, SCSIRequest *sreq)
 194 {
 195     SCSIBus *bus = sreq->bus;
 196     VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
 197     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
 198     VirtIOSCSIReq *req;
 199     uint32_t n;
 200
 201     qemu_get_be32s(f, &n);
 202     assert(n < vs->conf.num_queues);
 203     req = virtio_scsi_init_req(s, vs->cmd_vqs[n]);
 204     qemu_get_buffer(f, (unsigned char *)&req->elem, sizeof(req->elem));
 205     /* TODO: add a way for SCSIBusInfo's load_request to fail,
 206      * and fail migration instead of asserting here.
 207      * When we do, we might be able to re-enable NDEBUG below.
 208      */
 209 #ifdef NDEBUG
 210 #error building with NDEBUG is not supported
 211 #endif
 212     assert(req->elem.in_num <= ARRAY_SIZE(req->elem.in_sg));
 213     assert(req->elem.out_num <= ARRAY_SIZE(req->elem.out_sg));
 214
 215     if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICmdReq) + vs->cdb_size,
 216                               sizeof(VirtIOSCSICmdResp) + vs->sense_size) < 0) {
 217         error_report("invalid SCSI request migration data");
 218         exit(1);
 219     }
 220
 221     scsi_req_ref(sreq);
 222     req->sreq = sreq;
 223     if (req->sreq->cmd.mode != SCSI_XFER_NONE) {
 224         assert(req->sreq->cmd.mode == req->mode);
 225     }
 226     return req;
 227 }
 228
 229 static void virtio_scsi_do_tmf(VirtIOSCSI *s, VirtIOSCSIReq *req)
 230 {
 231     SCSIDevice *d = virtio_scsi_device_find(s, req->req.tmf.lun);
 232     SCSIRequest *r, *next;
 233     BusChild *kid;
 234     int target;
 235
 236     /* Here VIRTIO_SCSI_S_OK means "FUNCTION COMPLETE".  */
 237     req->resp.tmf.response = VIRTIO_SCSI_S_OK;
 238
 239     virtio_tswap32s(VIRTIO_DEVICE(s), &req->req.tmf.subtype);
 240     switch (req->req.tmf.subtype) {
 241     case VIRTIO_SCSI_T_TMF_ABORT_TASK:
 242     case VIRTIO_SCSI_T_TMF_QUERY_TASK:
 243         if (!d) {
 244             goto fail;
 245         }
 246         if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) {
 247             goto incorrect_lun;
 248         }
 249         QTAILQ_FOREACH_SAFE(r, &d->requests, next, next) {
 250             VirtIOSCSIReq *cmd_req = r->hba_private;
 251             if (cmd_req && cmd_req->req.cmd.tag == req->req.tmf.tag) {
 252                 break;
 253             }
 254         }
 255         if (r) {
 256             /*
 257              * Assert that the request has not been completed yet, we
 258              * check for it in the loop above.
 259              */
 260             assert(r->hba_private);
 261             if (req->req.tmf.subtype == VIRTIO_SCSI_T_TMF_QUERY_TASK) {
 262                 /* "If the specified command is present in the task set, then
 263                  * return a service response set to FUNCTION SUCCEEDED".
 264                  */
 265                 req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_SUCCEEDED;
 266             } else {
 267                 scsi_req_cancel(r);
 268             }
 269         }
 270         break;
 271
 272     case VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET:
 273         if (!d) {
 274             goto fail;
 275         }
 276         if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) {
 277             goto incorrect_lun;
 278         }
 279         s->resetting++;
 280         qdev_reset_all(&d->qdev);
 281         s->resetting--;
 282         break;
 283
 284     case VIRTIO_SCSI_T_TMF_ABORT_TASK_SET:
 285     case VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET:
 286     case VIRTIO_SCSI_T_TMF_QUERY_TASK_SET:
 287         if (!d) {
 288             goto fail;
 289         }
 290         if (d->lun != virtio_scsi_get_lun(req->req.tmf.lun)) {
 291             goto incorrect_lun;
 292         }
 293         QTAILQ_FOREACH_SAFE(r, &d->requests, next, next) {
 294             if (r->hba_private) {
 295                 if (req->req.tmf.subtype == VIRTIO_SCSI_T_TMF_QUERY_TASK_SET) {
 296                     /* "If there is any command present in the task set, then
 297                      * return a service response set to FUNCTION SUCCEEDED".
 298                      */
 299                     req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_SUCCEEDED;
 300                     break;
 301                 } else {
 302                     scsi_req_cancel(r);
 303                 }
 304             }
 305         }
 306         break;
 307
 308     case VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET:
 309         target = req->req.tmf.lun[1];
 310         s->resetting++;
 311         QTAILQ_FOREACH(kid, &s->bus.qbus.children, sibling) {
 312              d = DO_UPCAST(SCSIDevice, qdev, kid->child);
 313              if (d->channel == 0 && d->id == target) {
 314                 qdev_reset_all(&d->qdev);
 315              }
 316         }
 317         s->resetting--;
 318         break;
 319
 320     case VIRTIO_SCSI_T_TMF_CLEAR_ACA:
 321     default:
 322         req->resp.tmf.response = VIRTIO_SCSI_S_FUNCTION_REJECTED;
 323         break;
 324     }
 325
 326     return;
 327
 328 incorrect_lun:
 329     req->resp.tmf.response = VIRTIO_SCSI_S_INCORRECT_LUN;
 330     return;
 331
 332 fail:
 333     req->resp.tmf.response = VIRTIO_SCSI_S_BAD_TARGET;
 334 }
 335
 336 static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
 337 {
 338     VirtIOSCSI *s = (VirtIOSCSI *)vdev;
 339     VirtIOSCSIReq *req;
 340
 341     while ((req = virtio_scsi_pop_req(s, vq))) {
 342         int type;
 343
 344         if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0,
 345                        &type, sizeof(type)) < sizeof(type)) {
 346             virtio_scsi_bad_req();
 347             continue;
 348         }
 349
 350         virtio_tswap32s(vdev, &req->req.tmf.type);
 351         if (req->req.tmf.type == VIRTIO_SCSI_T_TMF) {
 352             if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlTMFReq),
 353                                       sizeof(VirtIOSCSICtrlTMFResp)) < 0) {
 354                 virtio_scsi_bad_req();
 355             } else {
 356                 virtio_scsi_do_tmf(s, req);
 357             }
 358
 359         } else if (req->req.tmf.type == VIRTIO_SCSI_T_AN_QUERY ||
 360                    req->req.tmf.type == VIRTIO_SCSI_T_AN_SUBSCRIBE) {
 361             if (virtio_scsi_parse_req(req, sizeof(VirtIOSCSICtrlANReq),
 362                                       sizeof(VirtIOSCSICtrlANResp)) < 0) {
 363                 virtio_scsi_bad_req();
 364             } else {
 365                 req->resp.an.event_actual = 0;
 366                 req->resp.an.response = VIRTIO_SCSI_S_OK;
 367             }
 368         }
 369         virtio_scsi_complete_req(req);
 370     }
 371 }
 372
 373 static void virtio_scsi_complete_cmd_req(VirtIOSCSIReq *req)
 374 {
 375     /* Sense data is not in req->resp and is copied separately
 376      * in virtio_scsi_command_complete.
 377      */
 378     req->resp_size = sizeof(VirtIOSCSICmdResp);
 379     virtio_scsi_complete_req(req);
 380 }
 381
 382 static void virtio_scsi_command_complete(SCSIRequest *r, uint32_t status,
 383                                          size_t resid)
 384 {
 385     VirtIOSCSIReq *req = r->hba_private;
 386     uint8_t sense[SCSI_SENSE_BUF_SIZE];
 387     uint32_t sense_len;
 388     VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
 389
 390     if (r->io_canceled) {
 391         return;
 392     }
 393
 394     req->resp.cmd.response = VIRTIO_SCSI_S_OK;
 395     req->resp.cmd.status = status;
 396     if (req->resp.cmd.status == GOOD) {
 397         req->resp.cmd.resid = virtio_tswap32(vdev, resid);
 398     } else {
 399         req->resp.cmd.resid = 0;
 400         sense_len = scsi_req_get_sense(r, sense, sizeof(sense));
 401         sense_len = MIN(sense_len, req->resp_iov.size - sizeof(req->resp.cmd));
 402         qemu_iovec_from_buf(&req->resp_iov, sizeof(req->resp.cmd),
 403                             &req->resp, sense_len);
 404         req->resp.cmd.sense_len = virtio_tswap32(vdev, sense_len);
 405     }
 406     virtio_scsi_complete_cmd_req(req);
 407 }
 408
 409 static int virtio_scsi_parse_cdb(SCSIDevice *dev, SCSICommand *cmd,
 410                                  uint8_t *buf, void *hba_private)
 411 {
 412     VirtIOSCSIReq *req = hba_private;
 413
 414     if (cmd->len == 0) {
 415         cmd->len = MIN(VIRTIO_SCSI_CDB_SIZE, SCSI_CMD_BUF_SIZE);
 416         memcpy(cmd->buf, buf, cmd->len);
 417     }
 418
 419     /* Extract the direction and mode directly from the request, for
 420      * host device passthrough.
 421      */
 422     cmd->xfer = req->qsgl.size;
 423     if (cmd->xfer == 0) {
 424         cmd->mode = SCSI_XFER_NONE;
 425     } else if (iov_size(req->elem.in_sg, req->elem.in_num) > req->resp_size) {
 426         cmd->mode = SCSI_XFER_FROM_DEV;
 427     } else {
 428         cmd->mode = SCSI_XFER_TO_DEV;
 429     }
 430     return 0;
 431 }
 432
 433 static QEMUSGList *virtio_scsi_get_sg_list(SCSIRequest *r)
 434 {
 435     VirtIOSCSIReq *req = r->hba_private;
 436
 437     return &req->qsgl;
 438 }
 439
 440 static void virtio_scsi_request_cancelled(SCSIRequest *r)
 441 {
 442     VirtIOSCSIReq *req = r->hba_private;
 443
 444     if (!req) {
 445         return;
 446     }
 447     if (req->dev->resetting) {
 448         req->resp.cmd.response = VIRTIO_SCSI_S_RESET;
 449     } else {
 450         req->resp.cmd.response = VIRTIO_SCSI_S_ABORTED;
 451     }
 452     virtio_scsi_complete_cmd_req(req);
 453 }
 454
 455 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq *req)
 456 {
 457     req->resp.cmd.response = VIRTIO_SCSI_S_FAILURE;
 458     virtio_scsi_complete_cmd_req(req);
 459 }
 460
 461 static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
 462 {
 463     /* use non-QOM casts in the data path */
 464     VirtIOSCSI *s = (VirtIOSCSI *)vdev;
 465     VirtIOSCSICommon *vs = &s->parent_obj;
 466
 467     VirtIOSCSIReq *req;
 468     int n;
 469
 470     while ((req = virtio_scsi_pop_req(s, vq))) {
 471         SCSIDevice *d;
 472         int rc;
 473
 474         rc = virtio_scsi_parse_req(req, sizeof(VirtIOSCSICmdReq) + vs->cdb_size,
 475                                    sizeof(VirtIOSCSICmdResp) + vs->sense_size);
 476         if (rc < 0) {
 477             if (rc == -ENOTSUP) {
 478                 virtio_scsi_fail_cmd_req(req);
 479             } else {
 480                 virtio_scsi_bad_req();
 481             }
 482             continue;
 483         }
 484
 485         d = virtio_scsi_device_find(s, req->req.cmd.lun);
 486         if (!d) {
 487             req->resp.cmd.response = VIRTIO_SCSI_S_BAD_TARGET;
 488             virtio_scsi_complete_cmd_req(req);
 489             continue;
 490         }
 491         req->sreq = scsi_req_new(d, req->req.cmd.tag,
 492                                  virtio_scsi_get_lun(req->req.cmd.lun),
 493                                  req->req.cdb, req);
 494
 495         if (req->sreq->cmd.mode != SCSI_XFER_NONE
 496             && (req->sreq->cmd.mode != req->mode ||
 497                 req->sreq->cmd.xfer > req->qsgl.size)) {
 498             req->resp.cmd.response = VIRTIO_SCSI_S_OVERRUN;
 499             virtio_scsi_complete_cmd_req(req);
 500             continue;
 501         }
 502
 503         n = scsi_req_enqueue(req->sreq);
 504         if (n) {
 505             scsi_req_continue(req->sreq);
 506         }
 507     }
 508 }
 509
 510 static void virtio_scsi_get_config(VirtIODevice *vdev,
 511                                    uint8_t *config)
 512 {
 513     VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
 514     VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(vdev);
 515
 516     virtio_stl_p(vdev, &scsiconf->num_queues, s->conf.num_queues);
 517     virtio_stl_p(vdev, &scsiconf->seg_max, 128 - 2);
 518     virtio_stl_p(vdev, &scsiconf->max_sectors, s->conf.max_sectors);
 519     virtio_stl_p(vdev, &scsiconf->cmd_per_lun, s->conf.cmd_per_lun);
 520     virtio_stl_p(vdev, &scsiconf->event_info_size, sizeof(VirtIOSCSIEvent));
 521     virtio_stl_p(vdev, &scsiconf->sense_size, s->sense_size);
 522     virtio_stl_p(vdev, &scsiconf->cdb_size, s->cdb_size);
 523     virtio_stw_p(vdev, &scsiconf->max_channel, VIRTIO_SCSI_MAX_CHANNEL);
 524     virtio_stw_p(vdev, &scsiconf->max_target, VIRTIO_SCSI_MAX_TARGET);
 525     virtio_stl_p(vdev, &scsiconf->max_lun, VIRTIO_SCSI_MAX_LUN);
 526 }
 527
 528 static void virtio_scsi_set_config(VirtIODevice *vdev,
 529                                    const uint8_t *config)
 530 {
 531     VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
 532     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
 533
 534     if ((uint32_t) virtio_ldl_p(vdev, &scsiconf->sense_size) >= 65536 ||
 535         (uint32_t) virtio_ldl_p(vdev, &scsiconf->cdb_size) >= 256) {
 536         error_report("bad data written to virtio-scsi configuration space");
 537         exit(1);
 538     }
 539
 540     vs->sense_size = virtio_ldl_p(vdev, &scsiconf->sense_size);
 541     vs->cdb_size = virtio_ldl_p(vdev, &scsiconf->cdb_size);
 542 }
 543
 544 static uint32_t virtio_scsi_get_features(VirtIODevice *vdev,
 545                                          uint32_t requested_features)
 546 {
 547     return requested_features;
 548 }
 549
 550 static void virtio_scsi_reset(VirtIODevice *vdev)
 551 {
 552     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
 553     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
 554
 555     s->resetting++;
 556     qbus_reset_all(&s->bus.qbus);
 557     s->resetting--;
 558
 559     vs->sense_size = VIRTIO_SCSI_SENSE_SIZE;
 560     vs->cdb_size = VIRTIO_SCSI_CDB_SIZE;
 561     s->events_dropped = false;
 562 }
 563
 564 /* The device does not have anything to save beyond the virtio data.
 565  * Request data is saved with callbacks from SCSI devices.
 566  */
 567 static void virtio_scsi_save(QEMUFile *f, void *opaque)
 568 {
 569     VirtIODevice *vdev = VIRTIO_DEVICE(opaque);
 570     virtio_save(vdev, f);
 571 }
 572
 573 static int virtio_scsi_load(QEMUFile *f, void *opaque, int version_id)
 574 {
 575     VirtIODevice *vdev = VIRTIO_DEVICE(opaque);
 576     int ret;
 577
 578     ret = virtio_load(vdev, f, version_id);
 579     if (ret) {
 580         return ret;
 581     }
 582     return 0;
 583 }
 584
 585 static void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev,
 586                                    uint32_t event, uint32_t reason)
 587 {
 588     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
 589     VirtIOSCSIReq *req;
 590     VirtIOSCSIEvent *evt;
 591     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 592
 593     if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
 594         return;
 595     }
 596
 597     req = virtio_scsi_pop_req(s, vs->event_vq);
 598     if (!req) {
 599         s->events_dropped = true;
 600         return;
 601     }
 602
 603     if (s->events_dropped) {
 604         event |= VIRTIO_SCSI_T_EVENTS_MISSED;
 605         s->events_dropped = false;
 606     }
 607
 608     if (virtio_scsi_parse_req(req, 0, sizeof(VirtIOSCSIEvent))) {
 609         virtio_scsi_bad_req();
 610     }
 611
 612     evt = &req->resp.event;
 613     memset(evt, 0, sizeof(VirtIOSCSIEvent));
 614     evt->event = virtio_tswap32(vdev, event);
 615     evt->reason = virtio_tswap32(vdev, reason);
 616     if (!dev) {
 617         assert(event == VIRTIO_SCSI_T_EVENTS_MISSED);
 618     } else {
 619         evt->lun[0] = 1;
 620         evt->lun[1] = dev->id;
 621
 622         /* Linux wants us to keep the same encoding we use for REPORT LUNS.  */
 623         if (dev->lun >= 256) {
 624             evt->lun[2] = (dev->lun >> 8) | 0x40;
 625         }
 626         evt->lun[3] = dev->lun & 0xFF;
 627     }
 628     virtio_scsi_complete_req(req);
 629 }
 630
 631 static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)
 632 {
 633     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
 634
 635     if (s->events_dropped) {
 636         virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
 637     }
 638 }
 639
 640 static void virtio_scsi_change(SCSIBus *bus, SCSIDevice *dev, SCSISense sense)
 641 {
 642     VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
 643     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 644
 645     if (((vdev->guest_features >> VIRTIO_SCSI_F_CHANGE) & 1) &&
 646         dev->type != TYPE_ROM) {
 647         virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_PARAM_CHANGE,
 648                                sense.asc | (sense.ascq << 8));
 649     }
 650 }
 651
 652 static void virtio_scsi_hotplug(SCSIBus *bus, SCSIDevice *dev)
 653 {
 654     VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
 655     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 656
 657     if ((vdev->guest_features >> VIRTIO_SCSI_F_HOTPLUG) & 1) {
 658         virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_TRANSPORT_RESET,
 659                                VIRTIO_SCSI_EVT_RESET_RESCAN);
 660     }
 661 }
 662
 663 static void virtio_scsi_hot_unplug(SCSIBus *bus, SCSIDevice *dev)
 664 {
 665     VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
 666     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 667
 668     if ((vdev->guest_features >> VIRTIO_SCSI_F_HOTPLUG) & 1) {
 669         virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_TRANSPORT_RESET,
 670                                VIRTIO_SCSI_EVT_RESET_REMOVED);
 671     }
 672 }
 673
 674 static struct SCSIBusInfo virtio_scsi_scsi_info = {
 675     .tcq = true,
 676     .max_channel = VIRTIO_SCSI_MAX_CHANNEL,
 677     .max_target = VIRTIO_SCSI_MAX_TARGET,
 678     .max_lun = VIRTIO_SCSI_MAX_LUN,
 679
 680     .complete = virtio_scsi_command_complete,
 681     .cancel = virtio_scsi_request_cancelled,
 682     .change = virtio_scsi_change,
 683     .hotplug = virtio_scsi_hotplug,
 684     .hot_unplug = virtio_scsi_hot_unplug,
 685     .parse_cdb = virtio_scsi_parse_cdb,
 686     .get_sg_list = virtio_scsi_get_sg_list,
 687     .save_request = virtio_scsi_save_request,
 688     .load_request = virtio_scsi_load_request,
 689 };
 690
 691 void virtio_scsi_common_realize(DeviceState *dev, Error **errp,
 692                                 HandleOutput ctrl, HandleOutput evt,
 693                                 HandleOutput cmd)
 694 {
 695     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 696     VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(dev);
 697     int i;
 698
 699     virtio_init(vdev, "virtio-scsi", VIRTIO_ID_SCSI,
 700                 sizeof(VirtIOSCSIConfig));
 701
 702     if (s->conf.num_queues <= 0 || s->conf.num_queues > VIRTIO_PCI_QUEUE_MAX) {
 703         error_setg(errp, "Invalid number of queues (= %" PRId32 "), "
 704                          "must be a positive integer less than %d.",
 705                    s->conf.num_queues, VIRTIO_PCI_QUEUE_MAX);
 706         return;
 707     }
 708     s->cmd_vqs = g_malloc0(s->conf.num_queues * sizeof(VirtQueue *));
 709     s->sense_size = VIRTIO_SCSI_SENSE_SIZE;
 710     s->cdb_size = VIRTIO_SCSI_CDB_SIZE;
 711
 712     s->ctrl_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,
 713                                   ctrl);
 714     s->event_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,
 715                                    evt);
 716     for (i = 0; i < s->conf.num_queues; i++) {
 717         s->cmd_vqs[i] = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,
 718                                          cmd);
 719     }
 720 }
 721
 722 static void virtio_scsi_device_realize(DeviceState *dev, Error **errp)
 723 {
 724     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 725     VirtIOSCSI *s = VIRTIO_SCSI(dev);
 726     static int virtio_scsi_id;
 727     Error *err = NULL;
 728
 729     virtio_scsi_common_realize(dev, &err, virtio_scsi_handle_ctrl,
 730                                virtio_scsi_handle_event,
 731                                virtio_scsi_handle_cmd);
 732     if (err != NULL) {
 733         error_propagate(errp, err);
 734         return;
 735     }
 736
 737     scsi_bus_new(&s->bus, sizeof(s->bus), dev,
 738                  &virtio_scsi_scsi_info, vdev->bus_name);
 739
 740     if (!dev->hotplugged) {
 741         scsi_bus_legacy_handle_cmdline(&s->bus, &err);
 742         if (err != NULL) {
 743             error_propagate(errp, err);
 744             return;
 745         }
 746     }
 747
 748     register_savevm(dev, "virtio-scsi", virtio_scsi_id++, 1,
 749                     virtio_scsi_save, virtio_scsi_load, s);
 750 }
 751
 752 void virtio_scsi_common_unrealize(DeviceState *dev, Error **errp)
 753 {
 754     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 755     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev);
 756
 757     g_free(vs->cmd_vqs);
 758     virtio_cleanup(vdev);
 759 }
 760
 761 static void virtio_scsi_device_unrealize(DeviceState *dev, Error **errp)
 762 {
 763     VirtIOSCSI *s = VIRTIO_SCSI(dev);
 764
 765     unregister_savevm(dev, "virtio-scsi", s);
 766
 767     virtio_scsi_common_unrealize(dev, errp);
 768 }
 769
 770 static Property virtio_scsi_properties[] = {
 771     DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSI, parent_obj.conf),
 772     DEFINE_PROP_END_OF_LIST(),
 773 };
 774
 775 static void virtio_scsi_common_class_init(ObjectClass *klass, void *data)
 776 {
 777     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 778     DeviceClass *dc = DEVICE_CLASS(klass);
 779
 780     vdc->get_config = virtio_scsi_get_config;
 781     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 782 }
 783
 784 static void virtio_scsi_class_init(ObjectClass *klass, void *data)
 785 {
 786     DeviceClass *dc = DEVICE_CLASS(klass);
 787     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 788
 789     dc->props = virtio_scsi_properties;
 790     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 791     vdc->realize = virtio_scsi_device_realize;
 792     vdc->unrealize = virtio_scsi_device_unrealize;
 793     vdc->set_config = virtio_scsi_set_config;
 794     vdc->get_features = virtio_scsi_get_features;
 795     vdc->reset = virtio_scsi_reset;
 796 }
 797
 798 static const TypeInfo virtio_scsi_common_info = {
 799     .name = TYPE_VIRTIO_SCSI_COMMON,
 800     .parent = TYPE_VIRTIO_DEVICE,
 801     .instance_size = sizeof(VirtIOSCSICommon),
 802     .abstract = true,
 803     .class_init = virtio_scsi_common_class_init,
 804 };
 805
 806 static const TypeInfo virtio_scsi_info = {
 807     .name = TYPE_VIRTIO_SCSI,
 808     .parent = TYPE_VIRTIO_SCSI_COMMON,
 809     .instance_size = sizeof(VirtIOSCSI),
 810     .class_init = virtio_scsi_class_init,
 811 };
 812
 813 static void virtio_register_types(void)
 814 {
 815     type_register_static(&virtio_scsi_common_info);
 816     type_register_static(&virtio_scsi_info);
 817 }
 818
 819 type_init(virtio_register_types)