hw/scsi-disk.c

   1 /*
   2  * SCSI Device emulation
   3  *
   4  * Copyright (c) 2006 CodeSourcery.
   5  * Based on code by Fabrice Bellard
   6  *
   7  * Written by Paul Brook
   8  * Modifications:
   9  *  2009-Dec-12 Artyom Tarasenko : implemented stamdard inquiry for the case
  10  *                                 when the allocation length of CDB is smaller
  11  *                                 than 36.
  12  *  2009-Oct-13 Artyom Tarasenko : implemented the block descriptor in the
  13  *                                 MODE SENSE response.
  14  *
  15  * This code is licensed under the LGPL.
  16  *
  17  * Note that this file only handles the SCSI architecture model and device
  18  * commands.  Emulation of interface/link layer protocols is handled by
  19  * the host adapter emulator.
  20  */
  21
  22 //#define DEBUG_SCSI
  23
  24 #ifdef DEBUG_SCSI
  25 #define DPRINTF(fmt, ...) \
  26 do { printf("scsi-disk: " fmt , ## __VA_ARGS__); } while (0)
  27 #else
  28 #define DPRINTF(fmt, ...) do {} while(0)
  29 #endif
  30
  31 #define BADF(fmt, ...) \
  32 do { fprintf(stderr, "scsi-disk: " fmt , ## __VA_ARGS__); } while (0)
  33
  34 #include "qemu-common.h"
  35 #include "qemu-error.h"
  36 #include "scsi.h"
  37 #include "scsi-defs.h"
  38 #include "sysemu.h"
  39 #include "blockdev.h"
  40 #include "block_int.h"
  41 #include "dma.h"
  42
  43 #ifdef __linux
  44 #include <scsi/sg.h>
  45 #endif
  46
  47 #define SCSI_DMA_BUF_SIZE    131072
  48 #define SCSI_MAX_INQUIRY_LEN 256
  49
  50 typedef struct SCSIDiskState SCSIDiskState;
  51
  52 typedef struct SCSIDiskReq {
  53     SCSIRequest req;
  54     /* Both sector and sector_count are in terms of qemu 512 byte blocks.  */
  55     uint64_t sector;
  56     uint32_t sector_count;
  57     uint32_t buflen;
  58     struct iovec iov;
  59     QEMUIOVector qiov;
  60     BlockAcctCookie acct;
  61 } SCSIDiskReq;
  62
  63 struct SCSIDiskState
  64 {
  65     SCSIDevice qdev;
  66     uint32_t removable;
  67     bool media_changed;
  68     bool media_event;
  69     bool eject_request;
  70     QEMUBH *bh;
  71     char *version;
  72     char *serial;
  73     bool tray_open;
  74     bool tray_locked;
  75 };
  76
  77 static int scsi_handle_rw_error(SCSIDiskReq *r, int error);
  78
  79 static void scsi_free_request(SCSIRequest *req)
  80 {
  81     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
  82
  83     if (r->iov.iov_base) {
  84         qemu_vfree(r->iov.iov_base);
  85     }
  86 }
  87
  88 /* Helper function for command completion with sense.  */
  89 static void scsi_check_condition(SCSIDiskReq *r, SCSISense sense)
  90 {
  91     DPRINTF("Command complete tag=0x%x sense=%d/%d/%d\n",
  92             r->req.tag, sense.key, sense.asc, sense.ascq);
  93     scsi_req_build_sense(&r->req, sense);
  94     scsi_req_complete(&r->req, CHECK_CONDITION);
  95 }
  96
  97 /* Cancel a pending data transfer.  */
  98 static void scsi_cancel_io(SCSIRequest *req)
  99 {
 100     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 101
 102     DPRINTF("Cancel tag=0x%x\n", req->tag);
 103     if (r->req.aiocb) {
 104         bdrv_aio_cancel(r->req.aiocb);
 105
 106         /* This reference was left in by scsi_*_data.  We take ownership of
 107          * it the moment scsi_req_cancel is called, independent of whether
 108          * bdrv_aio_cancel completes the request or not.  */
 109         scsi_req_unref(&r->req);
 110     }
 111     r->req.aiocb = NULL;
 112 }
 113
 114 static uint32_t scsi_init_iovec(SCSIDiskReq *r, size_t size)
 115 {
 116     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 117
 118     if (!r->iov.iov_base) {
 119         r->buflen = size;
 120         r->iov.iov_base = qemu_blockalign(s->qdev.conf.bs, r->buflen);
 121     }
 122     r->iov.iov_len = MIN(r->sector_count * 512, r->buflen);
 123     qemu_iovec_init_external(&r->qiov, &r->iov, 1);
 124     return r->qiov.size / 512;
 125 }
 126
 127 static void scsi_disk_save_request(QEMUFile *f, SCSIRequest *req)
 128 {
 129     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 130
 131     qemu_put_be64s(f, &r->sector);
 132     qemu_put_be32s(f, &r->sector_count);
 133     qemu_put_be32s(f, &r->buflen);
 134     if (r->buflen && r->req.cmd.mode == SCSI_XFER_TO_DEV) {
 135         qemu_put_buffer(f, r->iov.iov_base, r->iov.iov_len);
 136     }
 137 }
 138
 139 static void scsi_disk_load_request(QEMUFile *f, SCSIRequest *req)
 140 {
 141     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 142
 143     qemu_get_be64s(f, &r->sector);
 144     qemu_get_be32s(f, &r->sector_count);
 145     qemu_get_be32s(f, &r->buflen);
 146     if (r->buflen) {
 147         scsi_init_iovec(r, r->buflen);
 148         if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
 149             qemu_get_buffer(f, r->iov.iov_base, r->iov.iov_len);
 150         }
 151     }
 152
 153     qemu_iovec_init_external(&r->qiov, &r->iov, 1);
 154 }
 155
 156 static void scsi_flush_complete(void * opaque, int ret)
 157 {
 158     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 159     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 160
 161     bdrv_acct_done(s->qdev.conf.bs, &r->acct);
 162
 163     if (ret < 0) {
 164         if (scsi_handle_rw_error(r, -ret)) {
 165             goto done;
 166         }
 167     }
 168
 169     scsi_req_complete(&r->req, GOOD);
 170
 171 done:
 172     if (!r->req.io_canceled) {
 173         scsi_req_unref(&r->req);
 174     }
 175 }
 176
 177 static void scsi_dma_complete(void *opaque, int ret)
 178 {
 179     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 180     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 181
 182     bdrv_acct_done(s->qdev.conf.bs, &r->acct);
 183
 184     if (ret < 0) {
 185         if (scsi_handle_rw_error(r, -ret)) {
 186             goto done;
 187         }
 188     }
 189
 190     r->sector += r->sector_count;
 191     r->sector_count = 0;
 192     scsi_req_complete(&r->req, GOOD);
 193
 194 done:
 195     if (!r->req.io_canceled) {
 196         scsi_req_unref(&r->req);
 197     }
 198 }
 199
 200 static void scsi_read_complete(void * opaque, int ret)
 201 {
 202     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 203     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 204     int n;
 205
 206     if (r->req.aiocb != NULL) {
 207         r->req.aiocb = NULL;
 208         bdrv_acct_done(s->qdev.conf.bs, &r->acct);
 209     }
 210
 211     if (ret < 0) {
 212         if (scsi_handle_rw_error(r, -ret)) {
 213             goto done;
 214         }
 215     }
 216
 217     DPRINTF("Data ready tag=0x%x len=%zd\n", r->req.tag, r->qiov.size);
 218
 219     n = r->qiov.size / 512;
 220     r->sector += n;
 221     r->sector_count -= n;
 222     scsi_req_data(&r->req, r->qiov.size);
 223
 224 done:
 225     if (!r->req.io_canceled) {
 226         scsi_req_unref(&r->req);
 227     }
 228 }
 229
 230 /* Read more data from scsi device into buffer.  */
 231 static void scsi_read_data(SCSIRequest *req)
 232 {
 233     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 234     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 235     uint32_t n;
 236
 237     if (r->sector_count == (uint32_t)-1) {
 238         DPRINTF("Read buf_len=%zd\n", r->iov.iov_len);
 239         r->sector_count = 0;
 240         scsi_req_data(&r->req, r->iov.iov_len);
 241         return;
 242     }
 243     DPRINTF("Read sector_count=%d\n", r->sector_count);
 244     if (r->sector_count == 0) {
 245         /* This also clears the sense buffer for REQUEST SENSE.  */
 246         scsi_req_complete(&r->req, GOOD);
 247         return;
 248     }
 249
 250     /* No data transfer may already be in progress */
 251     assert(r->req.aiocb == NULL);
 252
 253     /* The request is used as the AIO opaque value, so add a ref.  */
 254     scsi_req_ref(&r->req);
 255     if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
 256         DPRINTF("Data transfer direction invalid\n");
 257         scsi_read_complete(r, -EINVAL);
 258         return;
 259     }
 260
 261     if (s->tray_open) {
 262         scsi_read_complete(r, -ENOMEDIUM);
 263         return;
 264     }
 265
 266     if (r->req.sg) {
 267         dma_acct_start(s->qdev.conf.bs, &r->acct, r->req.sg, BDRV_ACCT_READ);
 268         r->req.resid -= r->req.sg->size;
 269         r->req.aiocb = dma_bdrv_read(s->qdev.conf.bs, r->req.sg, r->sector,
 270                                      scsi_dma_complete, r);
 271     } else {
 272         n = scsi_init_iovec(r, SCSI_DMA_BUF_SIZE);
 273         bdrv_acct_start(s->qdev.conf.bs, &r->acct, n * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);
 274         r->req.aiocb = bdrv_aio_readv(s->qdev.conf.bs, r->sector, &r->qiov, n,
 275                                       scsi_read_complete, r);
 276     }
 277 }
 278
 279 /*
 280  * scsi_handle_rw_error has two return values.  0 means that the error
 281  * must be ignored, 1 means that the error has been processed and the
 282  * caller should not do anything else for this request.  Note that
 283  * scsi_handle_rw_error always manages its reference counts, independent
 284  * of the return value.
 285  */
 286 static int scsi_handle_rw_error(SCSIDiskReq *r, int error)
 287 {
 288     int is_read = (r->req.cmd.xfer == SCSI_XFER_FROM_DEV);
 289     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 290     BlockErrorAction action = bdrv_get_on_error(s->qdev.conf.bs, is_read);
 291
 292     if (action == BLOCK_ERR_IGNORE) {
 293         bdrv_emit_qmp_error_event(s->qdev.conf.bs, BDRV_ACTION_IGNORE, is_read);
 294         return 0;
 295     }
 296
 297     if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
 298             || action == BLOCK_ERR_STOP_ANY) {
 299
 300         bdrv_emit_qmp_error_event(s->qdev.conf.bs, BDRV_ACTION_STOP, is_read);
 301         vm_stop(RUN_STATE_IO_ERROR);
 302         bdrv_iostatus_set_err(s->qdev.conf.bs, error);
 303         scsi_req_retry(&r->req);
 304     } else {
 305         switch (error) {
 306         case ENOMEDIUM:
 307             scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
 308             break;
 309         case ENOMEM:
 310             scsi_check_condition(r, SENSE_CODE(TARGET_FAILURE));
 311             break;
 312         case EINVAL:
 313             scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
 314             break;
 315         default:
 316             scsi_check_condition(r, SENSE_CODE(IO_ERROR));
 317             break;
 318         }
 319         bdrv_emit_qmp_error_event(s->qdev.conf.bs, BDRV_ACTION_REPORT, is_read);
 320     }
 321     return 1;
 322 }
 323
 324 static void scsi_write_complete(void * opaque, int ret)
 325 {
 326     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 327     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 328     uint32_t n;
 329
 330     if (r->req.aiocb != NULL) {
 331         r->req.aiocb = NULL;
 332         bdrv_acct_done(s->qdev.conf.bs, &r->acct);
 333     }
 334
 335     if (ret < 0) {
 336         if (scsi_handle_rw_error(r, -ret)) {
 337             goto done;
 338         }
 339     }
 340
 341     n = r->qiov.size / 512;
 342     r->sector += n;
 343     r->sector_count -= n;
 344     if (r->sector_count == 0) {
 345         scsi_req_complete(&r->req, GOOD);
 346     } else {
 347         scsi_init_iovec(r, SCSI_DMA_BUF_SIZE);
 348         DPRINTF("Write complete tag=0x%x more=%d\n", r->req.tag, r->qiov.size);
 349         scsi_req_data(&r->req, r->qiov.size);
 350     }
 351
 352 done:
 353     if (!r->req.io_canceled) {
 354         scsi_req_unref(&r->req);
 355     }
 356 }
 357
 358 static void scsi_write_data(SCSIRequest *req)
 359 {
 360     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 361     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 362     uint32_t n;
 363
 364     /* No data transfer may already be in progress */
 365     assert(r->req.aiocb == NULL);
 366
 367     /* The request is used as the AIO opaque value, so add a ref.  */
 368     scsi_req_ref(&r->req);
 369     if (r->req.cmd.mode != SCSI_XFER_TO_DEV) {
 370         DPRINTF("Data transfer direction invalid\n");
 371         scsi_write_complete(r, -EINVAL);
 372         return;
 373     }
 374
 375     if (!r->req.sg && !r->qiov.size) {
 376         /* Called for the first time.  Ask the driver to send us more data.  */
 377         scsi_write_complete(r, 0);
 378         return;
 379     }
 380     if (s->tray_open) {
 381         scsi_write_complete(r, -ENOMEDIUM);
 382         return;
 383     }
 384
 385     if (r->req.sg) {
 386         dma_acct_start(s->qdev.conf.bs, &r->acct, r->req.sg, BDRV_ACCT_WRITE);
 387         r->req.resid -= r->req.sg->size;
 388         r->req.aiocb = dma_bdrv_write(s->qdev.conf.bs, r->req.sg, r->sector,
 389                                       scsi_dma_complete, r);
 390     } else {
 391         n = r->qiov.size / 512;
 392         bdrv_acct_start(s->qdev.conf.bs, &r->acct, n * BDRV_SECTOR_SIZE, BDRV_ACCT_WRITE);
 393         r->req.aiocb = bdrv_aio_writev(s->qdev.conf.bs, r->sector, &r->qiov, n,
 394                                        scsi_write_complete, r);
 395     }
 396 }
 397
 398 /* Return a pointer to the data buffer.  */
 399 static uint8_t *scsi_get_buf(SCSIRequest *req)
 400 {
 401     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 402
 403     return (uint8_t *)r->iov.iov_base;
 404 }
 405
 406 static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
 407 {
 408     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
 409     int buflen = 0;
 410
 411     if (req->cmd.buf[1] & 0x2) {
 412         /* Command support data - optional, not implemented */
 413         BADF("optional INQUIRY command support request not implemented\n");
 414         return -1;
 415     }
 416
 417     if (req->cmd.buf[1] & 0x1) {
 418         /* Vital product data */
 419         uint8_t page_code = req->cmd.buf[2];
 420         if (req->cmd.xfer < 4) {
 421             BADF("Error: Inquiry (EVPD[%02X]) buffer size %zd is "
 422                  "less than 4\n", page_code, req->cmd.xfer);
 423             return -1;
 424         }
 425
 426         outbuf[buflen++] = s->qdev.type & 0x1f;
 427         outbuf[buflen++] = page_code ; // this page
 428         outbuf[buflen++] = 0x00;
 429
 430         switch (page_code) {
 431         case 0x00: /* Supported page codes, mandatory */
 432         {
 433             int pages;
 434             DPRINTF("Inquiry EVPD[Supported pages] "
 435                     "buffer size %zd\n", req->cmd.xfer);
 436             pages = buflen++;
 437             outbuf[buflen++] = 0x00; // list of supported pages (this page)
 438             if (s->serial) {
 439                 outbuf[buflen++] = 0x80; // unit serial number
 440             }
 441             outbuf[buflen++] = 0x83; // device identification
 442             if (s->qdev.type == TYPE_DISK) {
 443                 outbuf[buflen++] = 0xb0; // block limits
 444                 outbuf[buflen++] = 0xb2; // thin provisioning
 445             }
 446             outbuf[pages] = buflen - pages - 1; // number of pages
 447             break;
 448         }
 449         case 0x80: /* Device serial number, optional */
 450         {
 451             int l;
 452
 453             if (!s->serial) {
 454                 DPRINTF("Inquiry (EVPD[Serial number] not supported\n");
 455                 return -1;
 456             }
 457
 458             l = strlen(s->serial);
 459             if (l > 20) {
 460                 l = 20;
 461             }
 462
 463             DPRINTF("Inquiry EVPD[Serial number] "
 464                     "buffer size %zd\n", req->cmd.xfer);
 465             outbuf[buflen++] = l;
 466             memcpy(outbuf+buflen, s->serial, l);
 467             buflen += l;
 468             break;
 469         }
 470
 471         case 0x83: /* Device identification page, mandatory */
 472         {
 473             const char *str = s->serial ?: bdrv_get_device_name(s->qdev.conf.bs);
 474             int max_len = s->serial ? 20 : 255 - 8;
 475             int id_len = strlen(str);
 476
 477             if (id_len > max_len) {
 478                 id_len = max_len;
 479             }
 480             DPRINTF("Inquiry EVPD[Device identification] "
 481                     "buffer size %zd\n", req->cmd.xfer);
 482
 483             outbuf[buflen++] = 4 + id_len;
 484             outbuf[buflen++] = 0x2; // ASCII
 485             outbuf[buflen++] = 0;   // not officially assigned
 486             outbuf[buflen++] = 0;   // reserved
 487             outbuf[buflen++] = id_len; // length of data following
 488
 489             memcpy(outbuf+buflen, str, id_len);
 490             buflen += id_len;
 491             break;
 492         }
 493         case 0xb0: /* block limits */
 494         {
 495             unsigned int unmap_sectors =
 496                     s->qdev.conf.discard_granularity / s->qdev.blocksize;
 497             unsigned int min_io_size =
 498                     s->qdev.conf.min_io_size / s->qdev.blocksize;
 499             unsigned int opt_io_size =
 500                     s->qdev.conf.opt_io_size / s->qdev.blocksize;
 501
 502             if (s->qdev.type == TYPE_ROM) {
 503                 DPRINTF("Inquiry (EVPD[%02X] not supported for CDROM\n",
 504                         page_code);
 505                 return -1;
 506             }
 507             /* required VPD size with unmap support */
 508             outbuf[3] = buflen = 0x3c;
 509
 510             memset(outbuf + 4, 0, buflen - 4);
 511
 512             /* optimal transfer length granularity */
 513             outbuf[6] = (min_io_size >> 8) & 0xff;
 514             outbuf[7] = min_io_size & 0xff;
 515
 516             /* optimal transfer length */
 517             outbuf[12] = (opt_io_size >> 24) & 0xff;
 518             outbuf[13] = (opt_io_size >> 16) & 0xff;
 519             outbuf[14] = (opt_io_size >> 8) & 0xff;
 520             outbuf[15] = opt_io_size & 0xff;
 521
 522             /* optimal unmap granularity */
 523             outbuf[28] = (unmap_sectors >> 24) & 0xff;
 524             outbuf[29] = (unmap_sectors >> 16) & 0xff;
 525             outbuf[30] = (unmap_sectors >> 8) & 0xff;
 526             outbuf[31] = unmap_sectors & 0xff;
 527             break;
 528         }
 529         case 0xb2: /* thin provisioning */
 530         {
 531             outbuf[3] = buflen = 8;
 532             outbuf[4] = 0;
 533             outbuf[5] = 0x40; /* write same with unmap supported */
 534             outbuf[6] = 0;
 535             outbuf[7] = 0;
 536             break;
 537         }
 538         default:
 539             BADF("Error: unsupported Inquiry (EVPD[%02X]) "
 540                  "buffer size %zd\n", page_code, req->cmd.xfer);
 541             return -1;
 542         }
 543         /* done with EVPD */
 544         return buflen;
 545     }
 546
 547     /* Standard INQUIRY data */
 548     if (req->cmd.buf[2] != 0) {
 549         BADF("Error: Inquiry (STANDARD) page or code "
 550              "is non-zero [%02X]\n", req->cmd.buf[2]);
 551         return -1;
 552     }
 553
 554     /* PAGE CODE == 0 */
 555     if (req->cmd.xfer < 5) {
 556         BADF("Error: Inquiry (STANDARD) buffer size %zd "
 557              "is less than 5\n", req->cmd.xfer);
 558         return -1;
 559     }
 560
 561     buflen = req->cmd.xfer;
 562     if (buflen > SCSI_MAX_INQUIRY_LEN) {
 563         buflen = SCSI_MAX_INQUIRY_LEN;
 564     }
 565     memset(outbuf, 0, buflen);
 566
 567     outbuf[0] = s->qdev.type & 0x1f;
 568     outbuf[1] = s->removable ? 0x80 : 0;
 569     if (s->qdev.type == TYPE_ROM) {
 570         memcpy(&outbuf[16], "QEMU CD-ROM     ", 16);
 571     } else {
 572         memcpy(&outbuf[16], "QEMU HARDDISK   ", 16);
 573     }
 574     memcpy(&outbuf[8], "QEMU    ", 8);
 575     memset(&outbuf[32], 0, 4);
 576     memcpy(&outbuf[32], s->version, MIN(4, strlen(s->version)));
 577     /*
 578      * We claim conformance to SPC-3, which is required for guests
 579      * to ask for modern features like READ CAPACITY(16) or the
 580      * block characteristics VPD page by default.  Not all of SPC-3
 581      * is actually implemented, but we're good enough.
 582      */
 583     outbuf[2] = 5;
 584     outbuf[3] = 2; /* Format 2 */
 585
 586     if (buflen > 36) {
 587         outbuf[4] = buflen - 5; /* Additional Length = (Len - 1) - 4 */
 588     } else {
 589         /* If the allocation length of CDB is too small,
 590                the additional length is not adjusted */
 591         outbuf[4] = 36 - 5;
 592     }
 593
 594     /* Sync data transfer and TCQ.  */
 595     outbuf[7] = 0x10 | (req->bus->info->tcq ? 0x02 : 0);
 596     return buflen;
 597 }
 598
 599 static inline bool media_is_dvd(SCSIDiskState *s)
 600 {
 601     uint64_t nb_sectors;
 602     if (s->qdev.type != TYPE_ROM) {
 603         return false;
 604     }
 605     if (!bdrv_is_inserted(s->qdev.conf.bs)) {
 606         return false;
 607     }
 608     bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
 609     return nb_sectors > CD_MAX_SECTORS;
 610 }
 611
 612 static inline bool media_is_cd(SCSIDiskState *s)
 613 {
 614     uint64_t nb_sectors;
 615     if (s->qdev.type != TYPE_ROM) {
 616         return false;
 617     }
 618     if (!bdrv_is_inserted(s->qdev.conf.bs)) {
 619         return false;
 620     }
 621     bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
 622     return nb_sectors <= CD_MAX_SECTORS;
 623 }
 624
 625 static int scsi_read_dvd_structure(SCSIDiskState *s, SCSIDiskReq *r,
 626                                    uint8_t *outbuf)
 627 {
 628     static const int rds_caps_size[5] = {
 629         [0] = 2048 + 4,
 630         [1] = 4 + 4,
 631         [3] = 188 + 4,
 632         [4] = 2048 + 4,
 633     };
 634
 635     uint8_t media = r->req.cmd.buf[1];
 636     uint8_t layer = r->req.cmd.buf[6];
 637     uint8_t format = r->req.cmd.buf[7];
 638     int size = -1;
 639
 640     if (s->qdev.type != TYPE_ROM) {
 641         return -1;
 642     }
 643     if (media != 0) {
 644         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
 645         return -1;
 646     }
 647
 648     if (format != 0xff) {
 649         if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) {
 650             scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
 651             return -1;
 652         }
 653         if (media_is_cd(s)) {
 654             scsi_check_condition(r, SENSE_CODE(INCOMPATIBLE_FORMAT));
 655             return -1;
 656         }
 657         if (format >= ARRAY_SIZE(rds_caps_size)) {
 658             return -1;
 659         }
 660         size = rds_caps_size[format];
 661         memset(outbuf, 0, size);
 662     }
 663
 664     switch (format) {
 665     case 0x00: {
 666         /* Physical format information */
 667         uint64_t nb_sectors;
 668         if (layer != 0) {
 669             goto fail;
 670         }
 671         bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
 672
 673         outbuf[4] = 1;   /* DVD-ROM, part version 1 */
 674         outbuf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
 675         outbuf[6] = 1;   /* one layer, read-only (per MMC-2 spec) */
 676         outbuf[7] = 0;   /* default densities */
 677
 678         stl_be_p(&outbuf[12], (nb_sectors >> 2) - 1); /* end sector */
 679         stl_be_p(&outbuf[16], (nb_sectors >> 2) - 1); /* l0 end sector */
 680         break;
 681     }
 682
 683     case 0x01: /* DVD copyright information, all zeros */
 684         break;
 685
 686     case 0x03: /* BCA information - invalid field for no BCA info */
 687         return -1;
 688
 689     case 0x04: /* DVD disc manufacturing information, all zeros */
 690         break;
 691
 692     case 0xff: { /* List capabilities */
 693         int i;
 694         size = 4;
 695         for (i = 0; i < ARRAY_SIZE(rds_caps_size); i++) {
 696             if (!rds_caps_size[i]) {
 697                 continue;
 698             }
 699             outbuf[size] = i;
 700             outbuf[size + 1] = 0x40; /* Not writable, readable */
 701             stw_be_p(&outbuf[size + 2], rds_caps_size[i]);
 702             size += 4;
 703         }
 704         break;
 705      }
 706
 707     default:
 708         return -1;
 709     }
 710
 711     /* Size of buffer, not including 2 byte size field */
 712     stw_be_p(outbuf, size - 2);
 713     return size;
 714
 715 fail:
 716     return -1;
 717 }
 718
 719 static int scsi_event_status_media(SCSIDiskState *s, uint8_t *outbuf)
 720 {
 721     uint8_t event_code, media_status;
 722
 723     media_status = 0;
 724     if (s->tray_open) {
 725         media_status = MS_TRAY_OPEN;
 726     } else if (bdrv_is_inserted(s->qdev.conf.bs)) {
 727         media_status = MS_MEDIA_PRESENT;
 728     }
 729
 730     /* Event notification descriptor */
 731     event_code = MEC_NO_CHANGE;
 732     if (media_status != MS_TRAY_OPEN) {
 733         if (s->media_event) {
 734             event_code = MEC_NEW_MEDIA;
 735             s->media_event = false;
 736         } else if (s->eject_request) {
 737             event_code = MEC_EJECT_REQUESTED;
 738             s->eject_request = false;
 739         }
 740     }
 741
 742     outbuf[0] = event_code;
 743     outbuf[1] = media_status;
 744
 745     /* These fields are reserved, just clear them. */
 746     outbuf[2] = 0;
 747     outbuf[3] = 0;
 748     return 4;
 749 }
 750
 751 static int scsi_get_event_status_notification(SCSIDiskState *s, SCSIDiskReq *r,
 752                                               uint8_t *outbuf)
 753 {
 754     int size;
 755     uint8_t *buf = r->req.cmd.buf;
 756     uint8_t notification_class_request = buf[4];
 757     if (s->qdev.type != TYPE_ROM) {
 758         return -1;
 759     }
 760     if ((buf[1] & 1) == 0) {
 761         /* asynchronous */
 762         return -1;
 763     }
 764
 765     size = 4;
 766     outbuf[0] = outbuf[1] = 0;
 767     outbuf[3] = 1 << GESN_MEDIA; /* supported events */
 768     if (notification_class_request & (1 << GESN_MEDIA)) {
 769         outbuf[2] = GESN_MEDIA;
 770         size += scsi_event_status_media(s, &outbuf[size]);
 771     } else {
 772         outbuf[2] = 0x80;
 773     }
 774     stw_be_p(outbuf, size - 4);
 775     return size;
 776 }
 777
 778 static int scsi_get_configuration(SCSIDiskState *s, uint8_t *outbuf)
 779 {
 780     int current;
 781
 782     if (s->qdev.type != TYPE_ROM) {
 783         return -1;
 784     }
 785     current = media_is_dvd(s) ? MMC_PROFILE_DVD_ROM : MMC_PROFILE_CD_ROM;
 786     memset(outbuf, 0, 40);
 787     stl_be_p(&outbuf[0], 36); /* Bytes after the data length field */
 788     stw_be_p(&outbuf[6], current);
 789     /* outbuf[8] - outbuf[19]: Feature 0 - Profile list */
 790     outbuf[10] = 0x03; /* persistent, current */
 791     outbuf[11] = 8; /* two profiles */
 792     stw_be_p(&outbuf[12], MMC_PROFILE_DVD_ROM);
 793     outbuf[14] = (current == MMC_PROFILE_DVD_ROM);
 794     stw_be_p(&outbuf[16], MMC_PROFILE_CD_ROM);
 795     outbuf[18] = (current == MMC_PROFILE_CD_ROM);
 796     /* outbuf[20] - outbuf[31]: Feature 1 - Core feature */
 797     stw_be_p(&outbuf[20], 1);
 798     outbuf[22] = 0x08 | 0x03; /* version 2, persistent, current */
 799     outbuf[23] = 8;
 800     stl_be_p(&outbuf[24], 1); /* SCSI */
 801     outbuf[28] = 1; /* DBE = 1, mandatory */
 802     /* outbuf[32] - outbuf[39]: Feature 3 - Removable media feature */
 803     stw_be_p(&outbuf[32], 3);
 804     outbuf[34] = 0x08 | 0x03; /* version 2, persistent, current */
 805     outbuf[35] = 4;
 806     outbuf[36] = 0x39; /* tray, load=1, eject=1, unlocked at powerup, lock=1 */
 807     /* TODO: Random readable, CD read, DVD read, drive serial number,
 808        power management */
 809     return 40;
 810 }
 811
 812 static int scsi_emulate_mechanism_status(SCSIDiskState *s, uint8_t *outbuf)
 813 {
 814     if (s->qdev.type != TYPE_ROM) {
 815         return -1;
 816     }
 817     memset(outbuf, 0, 8);
 818     outbuf[5] = 1; /* CD-ROM */
 819     return 8;
 820 }
 821
 822 static int mode_sense_page(SCSIDiskState *s, int page, uint8_t **p_outbuf,
 823                            int page_control)
 824 {
 825     static const int mode_sense_valid[0x3f] = {
 826         [MODE_PAGE_HD_GEOMETRY]            = (1 << TYPE_DISK),
 827         [MODE_PAGE_FLEXIBLE_DISK_GEOMETRY] = (1 << TYPE_DISK),
 828         [MODE_PAGE_CACHING]                = (1 << TYPE_DISK) | (1 << TYPE_ROM),
 829         [MODE_PAGE_R_W_ERROR]              = (1 << TYPE_DISK) | (1 << TYPE_ROM),
 830         [MODE_PAGE_AUDIO_CTL]              = (1 << TYPE_ROM),
 831         [MODE_PAGE_CAPABILITIES]           = (1 << TYPE_ROM),
 832     };
 833
 834     BlockDriverState *bdrv = s->qdev.conf.bs;
 835     int cylinders, heads, secs;
 836     uint8_t *p = *p_outbuf;
 837
 838     if ((mode_sense_valid[page] & (1 << s->qdev.type)) == 0) {
 839         return -1;
 840     }
 841
 842     p[0] = page;
 843
 844     /*
 845      * If Changeable Values are requested, a mask denoting those mode parameters
 846      * that are changeable shall be returned. As we currently don't support
 847      * parameter changes via MODE_SELECT all bits are returned set to zero.
 848      * The buffer was already menset to zero by the caller of this function.
 849      */
 850     switch (page) {
 851     case MODE_PAGE_HD_GEOMETRY:
 852         p[1] = 0x16;
 853         if (page_control == 1) { /* Changeable Values */
 854             break;
 855         }
 856         /* if a geometry hint is available, use it */
 857         bdrv_guess_geometry(bdrv, &cylinders, &heads, &secs);
 858         p[2] = (cylinders >> 16) & 0xff;
 859         p[3] = (cylinders >> 8) & 0xff;
 860         p[4] = cylinders & 0xff;
 861         p[5] = heads & 0xff;
 862         /* Write precomp start cylinder, disabled */
 863         p[6] = (cylinders >> 16) & 0xff;
 864         p[7] = (cylinders >> 8) & 0xff;
 865         p[8] = cylinders & 0xff;
 866         /* Reduced current start cylinder, disabled */
 867         p[9] = (cylinders >> 16) & 0xff;
 868         p[10] = (cylinders >> 8) & 0xff;
 869         p[11] = cylinders & 0xff;
 870         /* Device step rate [ns], 200ns */
 871         p[12] = 0;
 872         p[13] = 200;
 873         /* Landing zone cylinder */
 874         p[14] = 0xff;
 875         p[15] =  0xff;
 876         p[16] = 0xff;
 877         /* Medium rotation rate [rpm], 5400 rpm */
 878         p[20] = (5400 >> 8) & 0xff;
 879         p[21] = 5400 & 0xff;
 880         break;
 881
 882     case MODE_PAGE_FLEXIBLE_DISK_GEOMETRY:
 883         p[1] = 0x1e;
 884         if (page_control == 1) { /* Changeable Values */
 885             break;
 886         }
 887         /* Transfer rate [kbit/s], 5Mbit/s */
 888         p[2] = 5000 >> 8;
 889         p[3] = 5000 & 0xff;
 890         /* if a geometry hint is available, use it */
 891         bdrv_guess_geometry(bdrv, &cylinders, &heads, &secs);
 892         p[4] = heads & 0xff;
 893         p[5] = secs & 0xff;
 894         p[6] = s->qdev.blocksize >> 8;
 895         p[8] = (cylinders >> 8) & 0xff;
 896         p[9] = cylinders & 0xff;
 897         /* Write precomp start cylinder, disabled */
 898         p[10] = (cylinders >> 8) & 0xff;
 899         p[11] = cylinders & 0xff;
 900         /* Reduced current start cylinder, disabled */
 901         p[12] = (cylinders >> 8) & 0xff;
 902         p[13] = cylinders & 0xff;
 903         /* Device step rate [100us], 100us */
 904         p[14] = 0;
 905         p[15] = 1;
 906         /* Device step pulse width [us], 1us */
 907         p[16] = 1;
 908         /* Device head settle delay [100us], 100us */
 909         p[17] = 0;
 910         p[18] = 1;
 911         /* Motor on delay [0.1s], 0.1s */
 912         p[19] = 1;
 913         /* Motor off delay [0.1s], 0.1s */
 914         p[20] = 1;
 915         /* Medium rotation rate [rpm], 5400 rpm */
 916         p[28] = (5400 >> 8) & 0xff;
 917         p[29] = 5400 & 0xff;
 918         break;
 919
 920     case MODE_PAGE_CACHING:
 921         p[0] = 8;
 922         p[1] = 0x12;
 923         if (page_control == 1) { /* Changeable Values */
 924             break;
 925         }
 926         if (bdrv_enable_write_cache(s->qdev.conf.bs)) {
 927             p[2] = 4; /* WCE */
 928         }
 929         break;
 930
 931     case MODE_PAGE_R_W_ERROR:
 932         p[1] = 10;
 933         p[2] = 0x80; /* Automatic Write Reallocation Enabled */
 934         if (s->qdev.type == TYPE_ROM) {
 935             p[3] = 0x20; /* Read Retry Count */
 936         }
 937         break;
 938
 939     case MODE_PAGE_AUDIO_CTL:
 940         p[1] = 14;
 941         break;
 942
 943     case MODE_PAGE_CAPABILITIES:
 944         p[1] = 0x14;
 945         if (page_control == 1) { /* Changeable Values */
 946             break;
 947         }
 948
 949         p[2] = 0x3b; /* CD-R & CD-RW read */
 950         p[3] = 0; /* Writing not supported */
 951         p[4] = 0x7f; /* Audio, composite, digital out,
 952                         mode 2 form 1&2, multi session */
 953         p[5] = 0xff; /* CD DA, DA accurate, RW supported,
 954                         RW corrected, C2 errors, ISRC,
 955                         UPC, Bar code */
 956         p[6] = 0x2d | (s->tray_locked ? 2 : 0);
 957         /* Locking supported, jumper present, eject, tray */
 958         p[7] = 0; /* no volume & mute control, no
 959                      changer */
 960         p[8] = (50 * 176) >> 8; /* 50x read speed */
 961         p[9] = (50 * 176) & 0xff;
 962         p[10] = 2 >> 8; /* Two volume levels */
 963         p[11] = 2 & 0xff;
 964         p[12] = 2048 >> 8; /* 2M buffer */
 965         p[13] = 2048 & 0xff;
 966         p[14] = (16 * 176) >> 8; /* 16x read speed current */
 967         p[15] = (16 * 176) & 0xff;
 968         p[18] = (16 * 176) >> 8; /* 16x write speed */
 969         p[19] = (16 * 176) & 0xff;
 970         p[20] = (16 * 176) >> 8; /* 16x write speed current */
 971         p[21] = (16 * 176) & 0xff;
 972         break;
 973
 974     default:
 975         return -1;
 976     }
 977
 978     *p_outbuf += p[1] + 2;
 979     return p[1] + 2;
 980 }
 981
 982 static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf)
 983 {
 984     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 985     uint64_t nb_sectors;
 986     int page, dbd, buflen, ret, page_control;
 987     uint8_t *p;
 988     uint8_t dev_specific_param;
 989
 990     dbd = r->req.cmd.buf[1]  & 0x8;
 991     page = r->req.cmd.buf[2] & 0x3f;
 992     page_control = (r->req.cmd.buf[2] & 0xc0) >> 6;
 993     DPRINTF("Mode Sense(%d) (page %d, xfer %zd, page_control %d)\n",
 994         (r->req.cmd.buf[0] == MODE_SENSE) ? 6 : 10, page, r->req.cmd.xfer, page_control);
 995     memset(outbuf, 0, r->req.cmd.xfer);
 996     p = outbuf;
 997
 998     if (bdrv_is_read_only(s->qdev.conf.bs)) {
 999         dev_specific_param = 0x80; /* Readonly.  */
1000     } else {
1001         dev_specific_param = 0x00;
1002     }
1003
1004     if (r->req.cmd.buf[0] == MODE_SENSE) {
1005         p[1] = 0; /* Default media type.  */
1006         p[2] = dev_specific_param;
1007         p[3] = 0; /* Block descriptor length.  */
1008         p += 4;
1009     } else { /* MODE_SENSE_10 */
1010         p[2] = 0; /* Default media type.  */
1011         p[3] = dev_specific_param;
1012         p[6] = p[7] = 0; /* Block descriptor length.  */
1013         p += 8;
1014     }
1015
1016     /* MMC prescribes that CD/DVD drives have no block descriptors.  */
1017     bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
1018     if (!dbd && s->qdev.type == TYPE_DISK && nb_sectors) {
1019         if (r->req.cmd.buf[0] == MODE_SENSE) {
1020             outbuf[3] = 8; /* Block descriptor length  */
1021         } else { /* MODE_SENSE_10 */
1022             outbuf[7] = 8; /* Block descriptor length  */
1023         }
1024         nb_sectors /= (s->qdev.blocksize / 512);
1025         if (nb_sectors > 0xffffff) {
1026             nb_sectors = 0;
1027         }
1028         p[0] = 0; /* media density code */
1029         p[1] = (nb_sectors >> 16) & 0xff;
1030         p[2] = (nb_sectors >> 8) & 0xff;
1031         p[3] = nb_sectors & 0xff;
1032         p[4] = 0; /* reserved */
1033         p[5] = 0; /* bytes 5-7 are the sector size in bytes */
1034         p[6] = s->qdev.blocksize >> 8;
1035         p[7] = 0;
1036         p += 8;
1037     }
1038
1039     if (page_control == 3) {
1040         /* Saved Values */
1041         scsi_check_condition(r, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED));
1042         return -1;
1043     }
1044
1045     if (page == 0x3f) {
1046         for (page = 0; page <= 0x3e; page++) {
1047             mode_sense_page(s, page, &p, page_control);
1048         }
1049     } else {
1050         ret = mode_sense_page(s, page, &p, page_control);
1051         if (ret == -1) {
1052             return -1;
1053         }
1054     }
1055
1056     buflen = p - outbuf;
1057     /*
1058      * The mode data length field specifies the length in bytes of the
1059      * following data that is available to be transferred. The mode data
1060      * length does not include itself.
1061      */
1062     if (r->req.cmd.buf[0] == MODE_SENSE) {
1063         outbuf[0] = buflen - 1;
1064     } else { /* MODE_SENSE_10 */
1065         outbuf[0] = ((buflen - 2) >> 8) & 0xff;
1066         outbuf[1] = (buflen - 2) & 0xff;
1067     }
1068     return buflen;
1069 }
1070
1071 static int scsi_disk_emulate_read_toc(SCSIRequest *req, uint8_t *outbuf)
1072 {
1073     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1074     int start_track, format, msf, toclen;
1075     uint64_t nb_sectors;
1076
1077     msf = req->cmd.buf[1] & 2;
1078     format = req->cmd.buf[2] & 0xf;
1079     start_track = req->cmd.buf[6];
1080     bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
1081     DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track, format, msf >> 1);
1082     nb_sectors /= s->qdev.blocksize / 512;
1083     switch (format) {
1084     case 0:
1085         toclen = cdrom_read_toc(nb_sectors, outbuf, msf, start_track);
1086         break;
1087     case 1:
1088         /* multi session : only a single session defined */
1089         toclen = 12;
1090         memset(outbuf, 0, 12);
1091         outbuf[1] = 0x0a;
1092         outbuf[2] = 0x01;
1093         outbuf[3] = 0x01;
1094         break;
1095     case 2:
1096         toclen = cdrom_read_toc_raw(nb_sectors, outbuf, msf, start_track);
1097         break;
1098     default:
1099         return -1;
1100     }
1101     return toclen;
1102 }
1103
1104 static int scsi_disk_emulate_start_stop(SCSIDiskReq *r)
1105 {
1106     SCSIRequest *req = &r->req;
1107     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1108     bool start = req->cmd.buf[4] & 1;
1109     bool loej = req->cmd.buf[4] & 2; /* load on start, eject on !start */
1110
1111     if (s->qdev.type == TYPE_ROM && loej) {
1112         if (!start && !s->tray_open && s->tray_locked) {
1113             scsi_check_condition(r,
1114                                  bdrv_is_inserted(s->qdev.conf.bs)
1115                                  ? SENSE_CODE(ILLEGAL_REQ_REMOVAL_PREVENTED)
1116                                  : SENSE_CODE(NOT_READY_REMOVAL_PREVENTED));
1117             return -1;
1118         }
1119
1120         if (s->tray_open != !start) {
1121             bdrv_eject(s->qdev.conf.bs, !start);
1122             s->tray_open = !start;
1123         }
1124     }
1125     return 0;
1126 }
1127
1128 static int scsi_disk_emulate_command(SCSIDiskReq *r)
1129 {
1130     SCSIRequest *req = &r->req;
1131     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1132     uint64_t nb_sectors;
1133     uint8_t *outbuf;
1134     int buflen = 0;
1135
1136     if (!r->iov.iov_base) {
1137         /*
1138          * FIXME: we shouldn't return anything bigger than 4k, but the code
1139          * requires the buffer to be as big as req->cmd.xfer in several
1140          * places.  So, do not allow CDBs with a very large ALLOCATION
1141          * LENGTH.  The real fix would be to modify scsi_read_data and
1142          * dma_buf_read, so that they return data beyond the buflen
1143          * as all zeros.
1144          */
1145         if (req->cmd.xfer > 65536) {
1146             goto illegal_request;
1147         }
1148         r->buflen = MAX(4096, req->cmd.xfer);
1149         r->iov.iov_base = qemu_blockalign(s->qdev.conf.bs, r->buflen);
1150     }
1151
1152     outbuf = r->iov.iov_base;
1153     switch (req->cmd.buf[0]) {
1154     case TEST_UNIT_READY:
1155         assert(!s->tray_open && bdrv_is_inserted(s->qdev.conf.bs));
1156         break;
1157     case INQUIRY:
1158         buflen = scsi_disk_emulate_inquiry(req, outbuf);
1159         if (buflen < 0) {
1160             goto illegal_request;
1161         }
1162         break;
1163     case MODE_SENSE:
1164     case MODE_SENSE_10:
1165         buflen = scsi_disk_emulate_mode_sense(r, outbuf);
1166         if (buflen < 0) {
1167             goto illegal_request;
1168         }
1169         break;
1170     case READ_TOC:
1171         buflen = scsi_disk_emulate_read_toc(req, outbuf);
1172         if (buflen < 0) {
1173             goto illegal_request;
1174         }
1175         break;
1176     case RESERVE:
1177         if (req->cmd.buf[1] & 1) {
1178             goto illegal_request;
1179         }
1180         break;
1181     case RESERVE_10:
1182         if (req->cmd.buf[1] & 3) {
1183             goto illegal_request;
1184         }
1185         break;
1186     case RELEASE:
1187         if (req->cmd.buf[1] & 1) {
1188             goto illegal_request;
1189         }
1190         break;
1191     case RELEASE_10:
1192         if (req->cmd.buf[1] & 3) {
1193             goto illegal_request;
1194         }
1195         break;
1196     case START_STOP:
1197         if (scsi_disk_emulate_start_stop(r) < 0) {
1198             return -1;
1199         }
1200         break;
1201     case ALLOW_MEDIUM_REMOVAL:
1202         s->tray_locked = req->cmd.buf[4] & 1;
1203         bdrv_lock_medium(s->qdev.conf.bs, req->cmd.buf[4] & 1);
1204         break;
1205     case READ_CAPACITY_10:
1206         /* The normal LEN field for this command is zero.  */
1207         memset(outbuf, 0, 8);
1208         bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
1209         if (!nb_sectors) {
1210             scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY));
1211             return -1;
1212         }
1213         if ((req->cmd.buf[8] & 1) == 0 && req->cmd.lba) {
1214             goto illegal_request;
1215         }
1216         nb_sectors /= s->qdev.blocksize / 512;
1217         /* Returned value is the address of the last sector.  */
1218         nb_sectors--;
1219         /* Remember the new size for read/write sanity checking. */
1220         s->qdev.max_lba = nb_sectors;
1221         /* Clip to 2TB, instead of returning capacity modulo 2TB. */
1222         if (nb_sectors > UINT32_MAX) {
1223             nb_sectors = UINT32_MAX;
1224         }
1225         outbuf[0] = (nb_sectors >> 24) & 0xff;
1226         outbuf[1] = (nb_sectors >> 16) & 0xff;
1227         outbuf[2] = (nb_sectors >> 8) & 0xff;
1228         outbuf[3] = nb_sectors & 0xff;
1229         outbuf[4] = 0;
1230         outbuf[5] = 0;
1231         outbuf[6] = s->qdev.blocksize >> 8;
1232         outbuf[7] = 0;
1233         buflen = 8;
1234         break;
1235     case REQUEST_SENSE:
1236         /* Just return "NO SENSE".  */
1237         buflen = scsi_build_sense(NULL, 0, outbuf, r->buflen,
1238                                   (req->cmd.buf[1] & 1) == 0);
1239         break;
1240     case MECHANISM_STATUS:
1241         buflen = scsi_emulate_mechanism_status(s, outbuf);
1242         if (buflen < 0) {
1243             goto illegal_request;
1244         }
1245         break;
1246     case GET_CONFIGURATION:
1247         buflen = scsi_get_configuration(s, outbuf);
1248         if (buflen < 0) {
1249             goto illegal_request;
1250         }
1251         break;
1252     case GET_EVENT_STATUS_NOTIFICATION:
1253         buflen = scsi_get_event_status_notification(s, r, outbuf);
1254         if (buflen < 0) {
1255             goto illegal_request;
1256         }
1257         break;
1258     case READ_DVD_STRUCTURE:
1259         buflen = scsi_read_dvd_structure(s, r, outbuf);
1260         if (buflen < 0) {
1261             goto illegal_request;
1262         }
1263         break;
1264     case SERVICE_ACTION_IN_16:
1265         /* Service Action In subcommands. */
1266         if ((req->cmd.buf[1] & 31) == SAI_READ_CAPACITY_16) {
1267             DPRINTF("SAI READ CAPACITY(16)\n");
1268             memset(outbuf, 0, req->cmd.xfer);
1269             bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
1270             if (!nb_sectors) {
1271                 scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY));
1272                 return -1;
1273             }
1274             if ((req->cmd.buf[14] & 1) == 0 && req->cmd.lba) {
1275                 goto illegal_request;
1276             }
1277             nb_sectors /= s->qdev.blocksize / 512;
1278             /* Returned value is the address of the last sector.  */
1279             nb_sectors--;
1280             /* Remember the new size for read/write sanity checking. */
1281             s->qdev.max_lba = nb_sectors;
1282             outbuf[0] = (nb_sectors >> 56) & 0xff;
1283             outbuf[1] = (nb_sectors >> 48) & 0xff;
1284             outbuf[2] = (nb_sectors >> 40) & 0xff;
1285             outbuf[3] = (nb_sectors >> 32) & 0xff;
1286             outbuf[4] = (nb_sectors >> 24) & 0xff;
1287             outbuf[5] = (nb_sectors >> 16) & 0xff;
1288             outbuf[6] = (nb_sectors >> 8) & 0xff;
1289             outbuf[7] = nb_sectors & 0xff;
1290             outbuf[8] = 0;
1291             outbuf[9] = 0;
1292             outbuf[10] = s->qdev.blocksize >> 8;
1293             outbuf[11] = 0;
1294             outbuf[12] = 0;
1295             outbuf[13] = get_physical_block_exp(&s->qdev.conf);
1296
1297             /* set TPE bit if the format supports discard */
1298             if (s->qdev.conf.discard_granularity) {
1299                 outbuf[14] = 0x80;
1300             }
1301
1302             /* Protection, exponent and lowest lba field left blank. */
1303             buflen = req->cmd.xfer;
1304             break;
1305         }
1306         DPRINTF("Unsupported Service Action In\n");
1307         goto illegal_request;
1308     case VERIFY_10:
1309         break;
1310     default:
1311         scsi_check_condition(r, SENSE_CODE(INVALID_OPCODE));
1312         return -1;
1313     }
1314     buflen = MIN(buflen, req->cmd.xfer);
1315     return buflen;
1316
1317 illegal_request:
1318     if (r->req.status == -1) {
1319         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
1320     }
1321     return -1;
1322 }
1323
1324 /* Execute a scsi command.  Returns the length of the data expected by the
1325    command.  This will be Positive for data transfers from the device
1326    (eg. disk reads), negative for transfers to the device (eg. disk writes),
1327    and zero if the command does not transfer any data.  */
1328
1329 static int32_t scsi_send_command(SCSIRequest *req, uint8_t *buf)
1330 {
1331     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
1332     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1333     int32_t len;
1334     uint8_t command;
1335     int rc;
1336
1337     command = buf[0];
1338     DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", req->lun, req->tag, buf[0]);
1339
1340 #ifdef DEBUG_SCSI
1341     {
1342         int i;
1343         for (i = 1; i < r->req.cmd.len; i++) {
1344             printf(" 0x%02x", buf[i]);
1345         }
1346         printf("\n");
1347     }
1348 #endif
1349
1350     switch (command) {
1351     case INQUIRY:
1352     case MODE_SENSE:
1353     case MODE_SENSE_10:
1354     case RESERVE:
1355     case RESERVE_10:
1356     case RELEASE:
1357     case RELEASE_10:
1358     case START_STOP:
1359     case ALLOW_MEDIUM_REMOVAL:
1360     case GET_CONFIGURATION:
1361     case GET_EVENT_STATUS_NOTIFICATION:
1362     case MECHANISM_STATUS:
1363     case REQUEST_SENSE:
1364         break;
1365
1366     default:
1367         if (s->tray_open || !bdrv_is_inserted(s->qdev.conf.bs)) {
1368             scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
1369             return 0;
1370         }
1371         break;
1372     }
1373
1374     switch (command) {
1375     case TEST_UNIT_READY:
1376     case INQUIRY:
1377     case MODE_SENSE:
1378     case MODE_SENSE_10:
1379     case RESERVE:
1380     case RESERVE_10:
1381     case RELEASE:
1382     case RELEASE_10:
1383     case START_STOP:
1384     case ALLOW_MEDIUM_REMOVAL:
1385     case READ_CAPACITY_10:
1386     case READ_TOC:
1387     case READ_DVD_STRUCTURE:
1388     case GET_CONFIGURATION:
1389     case GET_EVENT_STATUS_NOTIFICATION:
1390     case MECHANISM_STATUS:
1391     case SERVICE_ACTION_IN_16:
1392     case REQUEST_SENSE:
1393     case VERIFY_10:
1394         rc = scsi_disk_emulate_command(r);
1395         if (rc < 0) {
1396             return 0;
1397         }
1398
1399         r->iov.iov_len = rc;
1400         break;
1401     case SYNCHRONIZE_CACHE:
1402         /* The request is used as the AIO opaque value, so add a ref.  */
1403         scsi_req_ref(&r->req);
1404         bdrv_acct_start(s->qdev.conf.bs, &r->acct, 0, BDRV_ACCT_FLUSH);
1405         r->req.aiocb = bdrv_aio_flush(s->qdev.conf.bs, scsi_flush_complete, r);
1406         return 0;
1407     case READ_6:
1408     case READ_10:
1409     case READ_12:
1410     case READ_16:
1411         len = r->req.cmd.xfer / s->qdev.blocksize;
1412         DPRINTF("Read (sector %" PRId64 ", count %d)\n", r->req.cmd.lba, len);
1413         if (r->req.cmd.lba > s->qdev.max_lba) {
1414             goto illegal_lba;
1415         }
1416         r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
1417         r->sector_count = len * (s->qdev.blocksize / 512);
1418         break;
1419     case WRITE_6:
1420     case WRITE_10:
1421     case WRITE_12:
1422     case WRITE_16:
1423     case WRITE_VERIFY_10:
1424     case WRITE_VERIFY_12:
1425     case WRITE_VERIFY_16:
1426         len = r->req.cmd.xfer / s->qdev.blocksize;
1427         DPRINTF("Write %s(sector %" PRId64 ", count %d)\n",
1428                 (command & 0xe) == 0xe ? "And Verify " : "",
1429                 r->req.cmd.lba, len);
1430         if (r->req.cmd.lba > s->qdev.max_lba) {
1431             goto illegal_lba;
1432         }
1433         r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
1434         r->sector_count = len * (s->qdev.blocksize / 512);
1435         break;
1436     case MODE_SELECT:
1437         DPRINTF("Mode Select(6) (len %lu)\n", (long)r->req.cmd.xfer);
1438         /* We don't support mode parameter changes.
1439            Allow the mode parameter header + block descriptors only. */
1440         if (r->req.cmd.xfer > 12) {
1441             goto fail;
1442         }
1443         break;
1444     case MODE_SELECT_10:
1445         DPRINTF("Mode Select(10) (len %lu)\n", (long)r->req.cmd.xfer);
1446         /* We don't support mode parameter changes.
1447            Allow the mode parameter header + block descriptors only. */
1448         if (r->req.cmd.xfer > 16) {
1449             goto fail;
1450         }
1451         break;
1452     case SEEK_10:
1453         DPRINTF("Seek(10) (sector %" PRId64 ")\n", r->req.cmd.lba);
1454         if (r->req.cmd.lba > s->qdev.max_lba) {
1455             goto illegal_lba;
1456         }
1457         break;
1458     case WRITE_SAME_16:
1459         len = r->req.cmd.xfer / s->qdev.blocksize;
1460
1461         DPRINTF("WRITE SAME(16) (sector %" PRId64 ", count %d)\n",
1462                 r->req.cmd.lba, len);
1463
1464         if (r->req.cmd.lba > s->qdev.max_lba) {
1465             goto illegal_lba;
1466         }
1467
1468         /*
1469          * We only support WRITE SAME with the unmap bit set for now.
1470          */
1471         if (!(buf[1] & 0x8)) {
1472             goto fail;
1473         }
1474
1475         rc = bdrv_discard(s->qdev.conf.bs,
1476                           r->req.cmd.lba * (s->qdev.blocksize / 512),
1477                           len * (s->qdev.blocksize / 512));
1478         if (rc < 0) {
1479             /* XXX: better error code ?*/
1480             goto fail;
1481         }
1482
1483         break;
1484     default:
1485         DPRINTF("Unknown SCSI command (%2.2x)\n", buf[0]);
1486         scsi_check_condition(r, SENSE_CODE(INVALID_OPCODE));
1487         return 0;
1488     fail:
1489         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
1490         return 0;
1491     illegal_lba:
1492         scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
1493         return 0;
1494     }
1495     if (r->sector_count == 0 && r->iov.iov_len == 0) {
1496         scsi_req_complete(&r->req, GOOD);
1497     }
1498     len = r->sector_count * 512 + r->iov.iov_len;
1499     if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
1500         return -len;
1501     } else {
1502         if (!r->sector_count) {
1503             r->sector_count = -1;
1504         }
1505         return len;
1506     }
1507 }
1508
1509 static void scsi_disk_reset(DeviceState *dev)
1510 {
1511     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev.qdev, dev);
1512     uint64_t nb_sectors;
1513
1514     scsi_device_purge_requests(&s->qdev, SENSE_CODE(RESET));
1515
1516     bdrv_get_geometry(s->qdev.conf.bs, &nb_sectors);
1517     nb_sectors /= s->qdev.blocksize / 512;
1518     if (nb_sectors) {
1519         nb_sectors--;
1520     }
1521     s->qdev.max_lba = nb_sectors;
1522 }
1523
1524 static void scsi_destroy(SCSIDevice *dev)
1525 {
1526     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1527
1528     scsi_device_purge_requests(&s->qdev, SENSE_CODE(NO_SENSE));
1529     blockdev_mark_auto_del(s->qdev.conf.bs);
1530 }
1531
1532 static void scsi_cd_change_media_cb(void *opaque, bool load)
1533 {
1534     SCSIDiskState *s = opaque;
1535
1536     /*
1537      * When a CD gets changed, we have to report an ejected state and
1538      * then a loaded state to guests so that they detect tray
1539      * open/close and media change events.  Guests that do not use
1540      * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close
1541      * states rely on this behavior.
1542      *
1543      * media_changed governs the state machine used for unit attention
1544      * report.  media_event is used by GET EVENT STATUS NOTIFICATION.
1545      */
1546     s->media_changed = load;
1547     s->tray_open = !load;
1548     s->qdev.unit_attention = SENSE_CODE(UNIT_ATTENTION_NO_MEDIUM);
1549     s->media_event = true;
1550     s->eject_request = false;
1551 }
1552
1553 static void scsi_cd_eject_request_cb(void *opaque, bool force)
1554 {
1555     SCSIDiskState *s = opaque;
1556
1557     s->eject_request = true;
1558     if (force) {
1559         s->tray_locked = false;
1560     }
1561 }
1562
1563 static bool scsi_cd_is_tray_open(void *opaque)
1564 {
1565     return ((SCSIDiskState *)opaque)->tray_open;
1566 }
1567
1568 static bool scsi_cd_is_medium_locked(void *opaque)
1569 {
1570     return ((SCSIDiskState *)opaque)->tray_locked;
1571 }
1572
1573 static const BlockDevOps scsi_cd_block_ops = {
1574     .change_media_cb = scsi_cd_change_media_cb,
1575     .eject_request_cb = scsi_cd_eject_request_cb,
1576     .is_tray_open = scsi_cd_is_tray_open,
1577     .is_medium_locked = scsi_cd_is_medium_locked,
1578 };
1579
1580 static void scsi_disk_unit_attention_reported(SCSIDevice *dev)
1581 {
1582     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1583     if (s->media_changed) {
1584         s->media_changed = false;
1585         s->qdev.unit_attention = SENSE_CODE(MEDIUM_CHANGED);
1586     }
1587 }
1588
1589 static int scsi_initfn(SCSIDevice *dev)
1590 {
1591     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1592     DriveInfo *dinfo;
1593
1594     if (!s->qdev.conf.bs) {
1595         error_report("drive property not set");
1596         return -1;
1597     }
1598
1599     if (!s->removable && !bdrv_is_inserted(s->qdev.conf.bs)) {
1600         error_report("Device needs media, but drive is empty");
1601         return -1;
1602     }
1603
1604     if (!s->serial) {
1605         /* try to fall back to value set with legacy -drive serial=... */
1606         dinfo = drive_get_by_blockdev(s->qdev.conf.bs);
1607         if (*dinfo->serial) {
1608             s->serial = g_strdup(dinfo->serial);
1609         }
1610     }
1611
1612     if (!s->version) {
1613         s->version = g_strdup(QEMU_VERSION);
1614     }
1615
1616     if (bdrv_is_sg(s->qdev.conf.bs)) {
1617         error_report("unwanted /dev/sg*");
1618         return -1;
1619     }
1620
1621     if (s->removable) {
1622         bdrv_set_dev_ops(s->qdev.conf.bs, &scsi_cd_block_ops, s);
1623     }
1624     bdrv_set_buffer_alignment(s->qdev.conf.bs, s->qdev.blocksize);
1625
1626     bdrv_iostatus_enable(s->qdev.conf.bs);
1627     add_boot_device_path(s->qdev.conf.bootindex, &dev->qdev, NULL);
1628     return 0;
1629 }
1630
1631 static int scsi_hd_initfn(SCSIDevice *dev)
1632 {
1633     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1634     s->qdev.blocksize = s->qdev.conf.logical_block_size;
1635     s->qdev.type = TYPE_DISK;
1636     return scsi_initfn(&s->qdev);
1637 }
1638
1639 static int scsi_cd_initfn(SCSIDevice *dev)
1640 {
1641     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1642     s->qdev.blocksize = 2048;
1643     s->qdev.type = TYPE_ROM;
1644     s->removable = true;
1645     return scsi_initfn(&s->qdev);
1646 }
1647
1648 static int scsi_disk_initfn(SCSIDevice *dev)
1649 {
1650     DriveInfo *dinfo;
1651
1652     if (!dev->conf.bs) {
1653         return scsi_initfn(dev);  /* ... and die there */
1654     }
1655
1656     dinfo = drive_get_by_blockdev(dev->conf.bs);
1657     if (dinfo->media_cd) {
1658         return scsi_cd_initfn(dev);
1659     } else {
1660         return scsi_hd_initfn(dev);
1661     }
1662 }
1663
1664 static const SCSIReqOps scsi_disk_reqops = {
1665     .size         = sizeof(SCSIDiskReq),
1666     .free_req     = scsi_free_request,
1667     .send_command = scsi_send_command,
1668     .read_data    = scsi_read_data,
1669     .write_data   = scsi_write_data,
1670     .cancel_io    = scsi_cancel_io,
1671     .get_buf      = scsi_get_buf,
1672     .load_request = scsi_disk_load_request,
1673     .save_request = scsi_disk_save_request,
1674 };
1675
1676 static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun,
1677                                      uint8_t *buf, void *hba_private)
1678 {
1679     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
1680     SCSIRequest *req;
1681
1682     req = scsi_req_alloc(&scsi_disk_reqops, &s->qdev, tag, lun, hba_private);
1683     return req;
1684 }
1685
1686 #ifdef __linux__
1687 static int get_device_type(SCSIDiskState *s)
1688 {
1689     BlockDriverState *bdrv = s->qdev.conf.bs;
1690     uint8_t cmd[16];
1691     uint8_t buf[36];
1692     uint8_t sensebuf[8];
1693     sg_io_hdr_t io_header;
1694     int ret;
1695
1696     memset(cmd, 0, sizeof(cmd));
1697     memset(buf, 0, sizeof(buf));
1698     cmd[0] = INQUIRY;
1699     cmd[4] = sizeof(buf);
1700
1701     memset(&io_header, 0, sizeof(io_header));
1702     io_header.interface_id = 'S';
1703     io_header.dxfer_direction = SG_DXFER_FROM_DEV;
1704     io_header.dxfer_len = sizeof(buf);
1705     io_header.dxferp = buf;
1706     io_header.cmdp = cmd;
1707     io_header.cmd_len = sizeof(cmd);
1708     io_header.mx_sb_len = sizeof(sensebuf);
1709     io_header.sbp = sensebuf;
1710     io_header.timeout = 6000; /* XXX */
1711
1712     ret = bdrv_ioctl(bdrv, SG_IO, &io_header);
1713     if (ret < 0 || io_header.driver_status || io_header.host_status) {
1714         return -1;
1715     }
1716     s->qdev.type = buf[0];
1717     s->removable = (buf[1] & 0x80) != 0;
1718     return 0;
1719 }
1720
1721 static int scsi_block_initfn(SCSIDevice *dev)
1722 {
1723     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
1724     int sg_version;
1725     int rc;
1726
1727     if (!s->qdev.conf.bs) {
1728         error_report("scsi-block: drive property not set");
1729         return -1;
1730     }
1731
1732     /* check we are using a driver managing SG_IO (version 3 and after) */
1733     if (bdrv_ioctl(s->qdev.conf.bs, SG_GET_VERSION_NUM, &sg_version) < 0 ||
1734         sg_version < 30000) {
1735         error_report("scsi-block: scsi generic interface too old");
1736         return -1;
1737     }
1738
1739     /* get device type from INQUIRY data */
1740     rc = get_device_type(s);
1741     if (rc < 0) {
1742         error_report("scsi-block: INQUIRY failed");
1743         return -1;
1744     }
1745
1746     /* Make a guess for the block size, we'll fix it when the guest sends.
1747      * READ CAPACITY.  If they don't, they likely would assume these sizes
1748      * anyway. (TODO: check in /sys).
1749      */
1750     if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM) {
1751         s->qdev.blocksize = 2048;
1752     } else {
1753         s->qdev.blocksize = 512;
1754     }
1755     return scsi_initfn(&s->qdev);
1756 }
1757
1758 static SCSIRequest *scsi_block_new_request(SCSIDevice *d, uint32_t tag,
1759                                            uint32_t lun, uint8_t *buf,
1760                                            void *hba_private)
1761 {
1762     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
1763
1764     switch (buf[0]) {
1765     case READ_6:
1766     case READ_10:
1767     case READ_12:
1768     case READ_16:
1769     case WRITE_6:
1770     case WRITE_10:
1771     case WRITE_12:
1772     case WRITE_16:
1773     case WRITE_VERIFY_10:
1774     case WRITE_VERIFY_12:
1775     case WRITE_VERIFY_16:
1776         /* If we are not using O_DIRECT, we might read stale data from the
1777          * host cache if writes were made using other commands than these
1778          * ones (such as WRITE SAME or EXTENDED COPY, etc.).  So, without
1779          * O_DIRECT everything must go through SG_IO.
1780          */
1781         if (!(s->qdev.conf.bs->open_flags & BDRV_O_NOCACHE)) {
1782             break;
1783         }
1784
1785         /* MMC writing cannot be done via pread/pwrite, because it sometimes
1786          * involves writing beyond the maximum LBA or to negative LBA (lead-in).
1787          * And once you do these writes, reading from the block device is
1788          * unreliable, too.  It is even possible that reads deliver random data
1789          * from the host page cache (this is probably a Linux bug).
1790          *
1791          * We might use scsi_disk_reqops as long as no writing commands are
1792          * seen, but performance usually isn't paramount on optical media.  So,
1793          * just make scsi-block operate the same as scsi-generic for them.
1794          */
1795         if (s->qdev.type == TYPE_ROM) {
1796             break;
1797         }
1798         return scsi_req_alloc(&scsi_disk_reqops, &s->qdev, tag, lun,
1799                               hba_private);
1800     }
1801
1802     return scsi_req_alloc(&scsi_generic_req_ops, &s->qdev, tag, lun,
1803                           hba_private);
1804 }
1805 #endif
1806
1807 #define DEFINE_SCSI_DISK_PROPERTIES()                           \
1808     DEFINE_BLOCK_PROPERTIES(SCSIDiskState, qdev.conf),          \
1809     DEFINE_PROP_STRING("ver",  SCSIDiskState, version),         \
1810     DEFINE_PROP_STRING("serial",  SCSIDiskState, serial)
1811
1812 static Property scsi_hd_properties[] = {
1813     DEFINE_SCSI_DISK_PROPERTIES(),
1814     DEFINE_PROP_BIT("removable", SCSIDiskState, removable, 0, false),
1815     DEFINE_PROP_END_OF_LIST(),
1816 };
1817
1818 static const VMStateDescription vmstate_scsi_disk_state = {
1819     .name = "scsi-disk",
1820     .version_id = 1,
1821     .minimum_version_id = 1,
1822     .minimum_version_id_old = 1,
1823     .fields = (VMStateField[]) {
1824         VMSTATE_SCSI_DEVICE(qdev, SCSIDiskState),
1825         VMSTATE_BOOL(media_changed, SCSIDiskState),
1826         VMSTATE_BOOL(media_event, SCSIDiskState),
1827         VMSTATE_BOOL(eject_request, SCSIDiskState),
1828         VMSTATE_BOOL(tray_open, SCSIDiskState),
1829         VMSTATE_BOOL(tray_locked, SCSIDiskState),
1830         VMSTATE_END_OF_LIST()
1831     }
1832 };
1833
1834 static void scsi_hd_class_initfn(ObjectClass *klass, void *data)
1835 {
1836     DeviceClass *dc = DEVICE_CLASS(klass);
1837     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
1838
1839     sc->init         = scsi_hd_initfn;
1840     sc->destroy      = scsi_destroy;
1841     sc->alloc_req    = scsi_new_request;
1842     sc->unit_attention_reported = scsi_disk_unit_attention_reported;
1843     dc->fw_name = "disk";
1844     dc->desc = "virtual SCSI disk";
1845     dc->reset = scsi_disk_reset;
1846     dc->props = scsi_hd_properties;
1847     dc->vmsd  = &vmstate_scsi_disk_state;
1848 }
1849
1850 static TypeInfo scsi_hd_info = {
1851     .name          = "scsi-hd",
1852     .parent        = TYPE_SCSI_DEVICE,
1853     .instance_size = sizeof(SCSIDiskState),
1854     .class_init    = scsi_hd_class_initfn,
1855 };
1856
1857 static Property scsi_cd_properties[] = {
1858     DEFINE_SCSI_DISK_PROPERTIES(),
1859     DEFINE_PROP_END_OF_LIST(),
1860 };
1861
1862 static void scsi_cd_class_initfn(ObjectClass *klass, void *data)
1863 {
1864     DeviceClass *dc = DEVICE_CLASS(klass);
1865     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
1866
1867     sc->init         = scsi_cd_initfn;
1868     sc->destroy      = scsi_destroy;
1869     sc->alloc_req    = scsi_new_request;
1870     sc->unit_attention_reported = scsi_disk_unit_attention_reported;
1871     dc->fw_name = "disk";
1872     dc->desc = "virtual SCSI CD-ROM";
1873     dc->reset = scsi_disk_reset;
1874     dc->props = scsi_cd_properties;
1875     dc->vmsd  = &vmstate_scsi_disk_state;
1876 }
1877
1878 static TypeInfo scsi_cd_info = {
1879     .name          = "scsi-cd",
1880     .parent        = TYPE_SCSI_DEVICE,
1881     .instance_size = sizeof(SCSIDiskState),
1882     .class_init    = scsi_cd_class_initfn,
1883 };
1884
1885 #ifdef __linux__
1886 static Property scsi_block_properties[] = {
1887     DEFINE_SCSI_DISK_PROPERTIES(),
1888     DEFINE_PROP_END_OF_LIST(),
1889 };
1890
1891 static void scsi_block_class_initfn(ObjectClass *klass, void *data)
1892 {
1893     DeviceClass *dc = DEVICE_CLASS(klass);
1894     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
1895
1896     sc->init         = scsi_block_initfn;
1897     sc->destroy      = scsi_destroy;
1898     sc->alloc_req    = scsi_block_new_request;
1899     dc->fw_name = "disk";
1900     dc->desc = "SCSI block device passthrough";
1901     dc->reset = scsi_disk_reset;
1902     dc->props = scsi_block_properties;
1903     dc->vmsd  = &vmstate_scsi_disk_state;
1904 }
1905
1906 static TypeInfo scsi_block_info = {
1907     .name          = "scsi-block",
1908     .parent        = TYPE_SCSI_DEVICE,
1909     .instance_size = sizeof(SCSIDiskState),
1910     .class_init    = scsi_block_class_initfn,
1911 };
1912 #endif
1913
1914 static Property scsi_disk_properties[] = {
1915     DEFINE_SCSI_DISK_PROPERTIES(),
1916     DEFINE_PROP_BIT("removable", SCSIDiskState, removable, 0, false),
1917     DEFINE_PROP_END_OF_LIST(),
1918 };
1919
1920 static void scsi_disk_class_initfn(ObjectClass *klass, void *data)
1921 {
1922     DeviceClass *dc = DEVICE_CLASS(klass);
1923     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
1924
1925     sc->init         = scsi_disk_initfn;
1926     sc->destroy      = scsi_destroy;
1927     sc->alloc_req    = scsi_new_request;
1928     sc->unit_attention_reported = scsi_disk_unit_attention_reported;
1929     dc->fw_name = "disk";
1930     dc->desc = "virtual SCSI disk or CD-ROM (legacy)";
1931     dc->reset = scsi_disk_reset;
1932     dc->props = scsi_disk_properties;
1933     dc->vmsd  = &vmstate_scsi_disk_state;
1934 }
1935
1936 static TypeInfo scsi_disk_info = {
1937     .name          = "scsi-disk",
1938     .parent        = TYPE_SCSI_DEVICE,
1939     .instance_size = sizeof(SCSIDiskState),
1940     .class_init    = scsi_disk_class_initfn,
1941 };
1942
1943 static void scsi_disk_register_types(void)
1944 {
1945     type_register_static(&scsi_hd_info);
1946     type_register_static(&scsi_cd_info);
1947 #ifdef __linux__
1948     type_register_static(&scsi_block_info);
1949 #endif
1950     type_register_static(&scsi_disk_info);
1951 }
1952
1953 type_init(scsi_disk_register_types)