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