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 QEMUSGList *virtio_scsi_get_sg_list(SCSIRequest *r)
 410 {
 411     VirtIOSCSIReq *req = r->hba_private;
 412
 413     return &req->qsgl;
 414 }
 415
 416 static void virtio_scsi_request_cancelled(SCSIRequest *r)
 417 {
 418     VirtIOSCSIReq *req = r->hba_private;
 419
 420     if (!req) {
 421         return;
 422     }
 423     if (req->dev->resetting) {
 424         req->resp.cmd.response = VIRTIO_SCSI_S_RESET;
 425     } else {
 426         req->resp.cmd.response = VIRTIO_SCSI_S_ABORTED;
 427     }
 428     virtio_scsi_complete_cmd_req(req);
 429 }
 430
 431 static void virtio_scsi_fail_cmd_req(VirtIOSCSIReq *req)
 432 {
 433     req->resp.cmd.response = VIRTIO_SCSI_S_FAILURE;
 434     virtio_scsi_complete_cmd_req(req);
 435 }
 436
 437 static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
 438 {
 439     /* use non-QOM casts in the data path */
 440     VirtIOSCSI *s = (VirtIOSCSI *)vdev;
 441     VirtIOSCSICommon *vs = &s->parent_obj;
 442
 443     VirtIOSCSIReq *req;
 444     int n;
 445
 446     while ((req = virtio_scsi_pop_req(s, vq))) {
 447         SCSIDevice *d;
 448         int rc;
 449
 450         rc = virtio_scsi_parse_req(req, sizeof(VirtIOSCSICmdReq) + vs->cdb_size,
 451                                    sizeof(VirtIOSCSICmdResp) + vs->sense_size);
 452         if (rc < 0) {
 453             if (rc == -ENOTSUP) {
 454                 virtio_scsi_fail_cmd_req(req);
 455             } else {
 456                 virtio_scsi_bad_req();
 457             }
 458             continue;
 459         }
 460
 461         d = virtio_scsi_device_find(s, req->req.cmd.lun);
 462         if (!d) {
 463             req->resp.cmd.response = VIRTIO_SCSI_S_BAD_TARGET;
 464             virtio_scsi_complete_cmd_req(req);
 465             continue;
 466         }
 467         req->sreq = scsi_req_new(d, req->req.cmd.tag,
 468                                  virtio_scsi_get_lun(req->req.cmd.lun),
 469                                  req->req.cdb, req);
 470
 471         if (req->sreq->cmd.mode != SCSI_XFER_NONE
 472             && (req->sreq->cmd.mode != req->mode ||
 473                 req->sreq->cmd.xfer > req->qsgl.size)) {
 474             req->resp.cmd.response = VIRTIO_SCSI_S_OVERRUN;
 475             virtio_scsi_complete_cmd_req(req);
 476             continue;
 477         }
 478
 479         n = scsi_req_enqueue(req->sreq);
 480         if (n) {
 481             scsi_req_continue(req->sreq);
 482         }
 483     }
 484 }
 485
 486 static void virtio_scsi_get_config(VirtIODevice *vdev,
 487                                    uint8_t *config)
 488 {
 489     VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
 490     VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(vdev);
 491
 492     virtio_stl_p(vdev, &scsiconf->num_queues, s->conf.num_queues);
 493     virtio_stl_p(vdev, &scsiconf->seg_max, 128 - 2);
 494     virtio_stl_p(vdev, &scsiconf->max_sectors, s->conf.max_sectors);
 495     virtio_stl_p(vdev, &scsiconf->cmd_per_lun, s->conf.cmd_per_lun);
 496     virtio_stl_p(vdev, &scsiconf->event_info_size, sizeof(VirtIOSCSIEvent));
 497     virtio_stl_p(vdev, &scsiconf->sense_size, s->sense_size);
 498     virtio_stl_p(vdev, &scsiconf->cdb_size, s->cdb_size);
 499     virtio_stw_p(vdev, &scsiconf->max_channel, VIRTIO_SCSI_MAX_CHANNEL);
 500     virtio_stw_p(vdev, &scsiconf->max_target, VIRTIO_SCSI_MAX_TARGET);
 501     virtio_stl_p(vdev, &scsiconf->max_lun, VIRTIO_SCSI_MAX_LUN);
 502 }
 503
 504 static void virtio_scsi_set_config(VirtIODevice *vdev,
 505                                    const uint8_t *config)
 506 {
 507     VirtIOSCSIConfig *scsiconf = (VirtIOSCSIConfig *)config;
 508     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
 509
 510     if ((uint32_t) virtio_ldl_p(vdev, &scsiconf->sense_size) >= 65536 ||
 511         (uint32_t) virtio_ldl_p(vdev, &scsiconf->cdb_size) >= 256) {
 512         error_report("bad data written to virtio-scsi configuration space");
 513         exit(1);
 514     }
 515
 516     vs->sense_size = virtio_ldl_p(vdev, &scsiconf->sense_size);
 517     vs->cdb_size = virtio_ldl_p(vdev, &scsiconf->cdb_size);
 518 }
 519
 520 static uint32_t virtio_scsi_get_features(VirtIODevice *vdev,
 521                                          uint32_t requested_features)
 522 {
 523     return requested_features;
 524 }
 525
 526 static void virtio_scsi_reset(VirtIODevice *vdev)
 527 {
 528     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
 529     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
 530
 531     s->resetting++;
 532     qbus_reset_all(&s->bus.qbus);
 533     s->resetting--;
 534
 535     vs->sense_size = VIRTIO_SCSI_SENSE_SIZE;
 536     vs->cdb_size = VIRTIO_SCSI_CDB_SIZE;
 537     s->events_dropped = false;
 538 }
 539
 540 /* The device does not have anything to save beyond the virtio data.
 541  * Request data is saved with callbacks from SCSI devices.
 542  */
 543 static void virtio_scsi_save(QEMUFile *f, void *opaque)
 544 {
 545     VirtIODevice *vdev = VIRTIO_DEVICE(opaque);
 546     virtio_save(vdev, f);
 547 }
 548
 549 static int virtio_scsi_load(QEMUFile *f, void *opaque, int version_id)
 550 {
 551     VirtIODevice *vdev = VIRTIO_DEVICE(opaque);
 552     int ret;
 553
 554     ret = virtio_load(vdev, f, version_id);
 555     if (ret) {
 556         return ret;
 557     }
 558     return 0;
 559 }
 560
 561 static void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev,
 562                                    uint32_t event, uint32_t reason)
 563 {
 564     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
 565     VirtIOSCSIReq *req;
 566     VirtIOSCSIEvent *evt;
 567     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 568
 569     if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
 570         return;
 571     }
 572
 573     req = virtio_scsi_pop_req(s, vs->event_vq);
 574     if (!req) {
 575         s->events_dropped = true;
 576         return;
 577     }
 578
 579     if (s->events_dropped) {
 580         event |= VIRTIO_SCSI_T_EVENTS_MISSED;
 581         s->events_dropped = false;
 582     }
 583
 584     if (virtio_scsi_parse_req(req, 0, sizeof(VirtIOSCSIEvent))) {
 585         virtio_scsi_bad_req();
 586     }
 587
 588     evt = &req->resp.event;
 589     memset(evt, 0, sizeof(VirtIOSCSIEvent));
 590     evt->event = virtio_tswap32(vdev, event);
 591     evt->reason = virtio_tswap32(vdev, reason);
 592     if (!dev) {
 593         assert(event == VIRTIO_SCSI_T_EVENTS_MISSED);
 594     } else {
 595         evt->lun[0] = 1;
 596         evt->lun[1] = dev->id;
 597
 598         /* Linux wants us to keep the same encoding we use for REPORT LUNS.  */
 599         if (dev->lun >= 256) {
 600             evt->lun[2] = (dev->lun >> 8) | 0x40;
 601         }
 602         evt->lun[3] = dev->lun & 0xFF;
 603     }
 604     virtio_scsi_complete_req(req);
 605 }
 606
 607 static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)
 608 {
 609     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
 610
 611     if (s->events_dropped) {
 612         virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
 613     }
 614 }
 615
 616 static void virtio_scsi_change(SCSIBus *bus, SCSIDevice *dev, SCSISense sense)
 617 {
 618     VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
 619     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 620
 621     if (((vdev->guest_features >> VIRTIO_SCSI_F_CHANGE) & 1) &&
 622         dev->type != TYPE_ROM) {
 623         virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_PARAM_CHANGE,
 624                                sense.asc | (sense.ascq << 8));
 625     }
 626 }
 627
 628 static void virtio_scsi_hotplug(SCSIBus *bus, SCSIDevice *dev)
 629 {
 630     VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
 631     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 632
 633     if ((vdev->guest_features >> VIRTIO_SCSI_F_HOTPLUG) & 1) {
 634         virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_TRANSPORT_RESET,
 635                                VIRTIO_SCSI_EVT_RESET_RESCAN);
 636     }
 637 }
 638
 639 static void virtio_scsi_hot_unplug(SCSIBus *bus, SCSIDevice *dev)
 640 {
 641     VirtIOSCSI *s = container_of(bus, VirtIOSCSI, bus);
 642     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 643
 644     if ((vdev->guest_features >> VIRTIO_SCSI_F_HOTPLUG) & 1) {
 645         virtio_scsi_push_event(s, dev, VIRTIO_SCSI_T_TRANSPORT_RESET,
 646                                VIRTIO_SCSI_EVT_RESET_REMOVED);
 647     }
 648 }
 649
 650 static struct SCSIBusInfo virtio_scsi_scsi_info = {
 651     .tcq = true,
 652     .max_channel = VIRTIO_SCSI_MAX_CHANNEL,
 653     .max_target = VIRTIO_SCSI_MAX_TARGET,
 654     .max_lun = VIRTIO_SCSI_MAX_LUN,
 655
 656     .complete = virtio_scsi_command_complete,
 657     .cancel = virtio_scsi_request_cancelled,
 658     .change = virtio_scsi_change,
 659     .hotplug = virtio_scsi_hotplug,
 660     .hot_unplug = virtio_scsi_hot_unplug,
 661     .get_sg_list = virtio_scsi_get_sg_list,
 662     .save_request = virtio_scsi_save_request,
 663     .load_request = virtio_scsi_load_request,
 664 };
 665
 666 void virtio_scsi_common_realize(DeviceState *dev, Error **errp,
 667                                 HandleOutput ctrl, HandleOutput evt,
 668                                 HandleOutput cmd)
 669 {
 670     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 671     VirtIOSCSICommon *s = VIRTIO_SCSI_COMMON(dev);
 672     int i;
 673
 674     virtio_init(vdev, "virtio-scsi", VIRTIO_ID_SCSI,
 675                 sizeof(VirtIOSCSIConfig));
 676
 677     s->cmd_vqs = g_malloc0(s->conf.num_queues * sizeof(VirtQueue *));
 678     s->sense_size = VIRTIO_SCSI_SENSE_SIZE;
 679     s->cdb_size = VIRTIO_SCSI_CDB_SIZE;
 680
 681     s->ctrl_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,
 682                                   ctrl);
 683     s->event_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,
 684                                    evt);
 685     for (i = 0; i < s->conf.num_queues; i++) {
 686         s->cmd_vqs[i] = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE,
 687                                          cmd);
 688     }
 689 }
 690
 691 static void virtio_scsi_device_realize(DeviceState *dev, Error **errp)
 692 {
 693     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 694     VirtIOSCSI *s = VIRTIO_SCSI(dev);
 695     static int virtio_scsi_id;
 696     Error *err = NULL;
 697
 698     virtio_scsi_common_realize(dev, &err, virtio_scsi_handle_ctrl,
 699                                virtio_scsi_handle_event,
 700                                virtio_scsi_handle_cmd);
 701     if (err != NULL) {
 702         error_propagate(errp, err);
 703         return;
 704     }
 705
 706     scsi_bus_new(&s->bus, sizeof(s->bus), dev,
 707                  &virtio_scsi_scsi_info, vdev->bus_name);
 708
 709     if (!dev->hotplugged) {
 710         scsi_bus_legacy_handle_cmdline(&s->bus, &err);
 711         if (err != NULL) {
 712             error_propagate(errp, err);
 713             return;
 714         }
 715     }
 716
 717     register_savevm(dev, "virtio-scsi", virtio_scsi_id++, 1,
 718                     virtio_scsi_save, virtio_scsi_load, s);
 719 }
 720
 721 void virtio_scsi_common_unrealize(DeviceState *dev, Error **errp)
 722 {
 723     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
 724     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(dev);
 725
 726     g_free(vs->cmd_vqs);
 727     virtio_cleanup(vdev);
 728 }
 729
 730 static void virtio_scsi_device_unrealize(DeviceState *dev, Error **errp)
 731 {
 732     VirtIOSCSI *s = VIRTIO_SCSI(dev);
 733
 734     unregister_savevm(dev, "virtio-scsi", s);
 735
 736     virtio_scsi_common_unrealize(dev, errp);
 737 }
 738
 739 static Property virtio_scsi_properties[] = {
 740     DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSI, parent_obj.conf),
 741     DEFINE_PROP_END_OF_LIST(),
 742 };
 743
 744 static void virtio_scsi_common_class_init(ObjectClass *klass, void *data)
 745 {
 746     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 747     DeviceClass *dc = DEVICE_CLASS(klass);
 748
 749     vdc->get_config = virtio_scsi_get_config;
 750     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 751 }
 752
 753 static void virtio_scsi_class_init(ObjectClass *klass, void *data)
 754 {
 755     DeviceClass *dc = DEVICE_CLASS(klass);
 756     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
 757
 758     dc->props = virtio_scsi_properties;
 759     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 760     vdc->realize = virtio_scsi_device_realize;
 761     vdc->unrealize = virtio_scsi_device_unrealize;
 762     vdc->set_config = virtio_scsi_set_config;
 763     vdc->get_features = virtio_scsi_get_features;
 764     vdc->reset = virtio_scsi_reset;
 765 }
 766
 767 static const TypeInfo virtio_scsi_common_info = {
 768     .name = TYPE_VIRTIO_SCSI_COMMON,
 769     .parent = TYPE_VIRTIO_DEVICE,
 770     .instance_size = sizeof(VirtIOSCSICommon),
 771     .abstract = true,
 772     .class_init = virtio_scsi_common_class_init,
 773 };
 774
 775 static const TypeInfo virtio_scsi_info = {
 776     .name = TYPE_VIRTIO_SCSI,
 777     .parent = TYPE_VIRTIO_SCSI_COMMON,
 778     .instance_size = sizeof(VirtIOSCSI),
 779     .class_init = virtio_scsi_class_init,
 780 };
 781
 782 static void virtio_register_types(void)
 783 {
 784     type_register_static(&virtio_scsi_common_info);
 785     type_register_static(&virtio_scsi_info);
 786 }
 787
 788 type_init(virtio_register_types)