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