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