hw/scsi/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 #include "qemu/osdep.h"
  23 #include "qemu/units.h"
  24 #include "qapi/error.h"
  25 #include "qemu/error-report.h"
  26 #include "qemu/main-loop.h"
  27 #include "qemu/module.h"
  28 #include "hw/scsi/scsi.h"
  29 #include "migration/qemu-file-types.h"
  30 #include "migration/vmstate.h"
  31 #include "hw/scsi/emulation.h"
  32 #include "scsi/constants.h"
  33 #include "sysemu/sysemu.h"
  34 #include "sysemu/block-backend.h"
  35 #include "sysemu/blockdev.h"
  36 #include "hw/block/block.h"
  37 #include "sysemu/dma.h"
  38 #include "qemu/cutils.h"
  39 #include "trace.h"
  40
  41 #ifdef __linux
  42 #include <scsi/sg.h>
  43 #endif
  44
  45 #define SCSI_WRITE_SAME_MAX         (512 * KiB)
  46 #define SCSI_DMA_BUF_SIZE           (128 * KiB)
  47 #define SCSI_MAX_INQUIRY_LEN        256
  48 #define SCSI_MAX_MODE_LEN           256
  49
  50 #define DEFAULT_DISCARD_GRANULARITY (4 * KiB)
  51 #define DEFAULT_MAX_UNMAP_SIZE      (1 * GiB)
  52 #define DEFAULT_MAX_IO_SIZE         INT_MAX     /* 2 GB - 1 block */
  53
  54 #define TYPE_SCSI_DISK_BASE         "scsi-disk-base"
  55
  56 #define SCSI_DISK_BASE(obj) \
  57      OBJECT_CHECK(SCSIDiskState, (obj), TYPE_SCSI_DISK_BASE)
  58 #define SCSI_DISK_BASE_CLASS(klass) \
  59      OBJECT_CLASS_CHECK(SCSIDiskClass, (klass), TYPE_SCSI_DISK_BASE)
  60 #define SCSI_DISK_BASE_GET_CLASS(obj) \
  61      OBJECT_GET_CLASS(SCSIDiskClass, (obj), TYPE_SCSI_DISK_BASE)
  62
  63 typedef struct SCSIDiskClass {
  64     SCSIDeviceClass parent_class;
  65     DMAIOFunc       *dma_readv;
  66     DMAIOFunc       *dma_writev;
  67     bool            (*need_fua_emulation)(SCSICommand *cmd);
  68     void            (*update_sense)(SCSIRequest *r);
  69 } SCSIDiskClass;
  70
  71 typedef struct SCSIDiskReq {
  72     SCSIRequest req;
  73     /* Both sector and sector_count are in terms of qemu 512 byte blocks.  */
  74     uint64_t sector;
  75     uint32_t sector_count;
  76     uint32_t buflen;
  77     bool started;
  78     bool need_fua_emulation;
  79     struct iovec iov;
  80     QEMUIOVector qiov;
  81     BlockAcctCookie acct;
  82     unsigned char *status;
  83 } SCSIDiskReq;
  84
  85 #define SCSI_DISK_F_REMOVABLE             0
  86 #define SCSI_DISK_F_DPOFUA                1
  87 #define SCSI_DISK_F_NO_REMOVABLE_DEVOPS   2
  88
  89 typedef struct SCSIDiskState
  90 {
  91     SCSIDevice qdev;
  92     uint32_t features;
  93     bool media_changed;
  94     bool media_event;
  95     bool eject_request;
  96     uint16_t port_index;
  97     uint64_t max_unmap_size;
  98     uint64_t max_io_size;
  99     QEMUBH *bh;
 100     char *version;
 101     char *serial;
 102     char *vendor;
 103     char *product;
 104     char *device_id;
 105     bool tray_open;
 106     bool tray_locked;
 107     /*
 108      * 0x0000        - rotation rate not reported
 109      * 0x0001        - non-rotating medium (SSD)
 110      * 0x0002-0x0400 - reserved
 111      * 0x0401-0xffe  - rotations per minute
 112      * 0xffff        - reserved
 113      */
 114     uint16_t rotation_rate;
 115 } SCSIDiskState;
 116
 117 static bool scsi_handle_rw_error(SCSIDiskReq *r, int error, bool acct_failed);
 118
 119 static void scsi_free_request(SCSIRequest *req)
 120 {
 121     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 122
 123     qemu_vfree(r->iov.iov_base);
 124 }
 125
 126 /* Helper function for command completion with sense.  */
 127 static void scsi_check_condition(SCSIDiskReq *r, SCSISense sense)
 128 {
 129     trace_scsi_disk_check_condition(r->req.tag, sense.key, sense.asc,
 130                                     sense.ascq);
 131     scsi_req_build_sense(&r->req, sense);
 132     scsi_req_complete(&r->req, CHECK_CONDITION);
 133 }
 134
 135 static void scsi_init_iovec(SCSIDiskReq *r, size_t size)
 136 {
 137     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 138
 139     if (!r->iov.iov_base) {
 140         r->buflen = size;
 141         r->iov.iov_base = blk_blockalign(s->qdev.conf.blk, r->buflen);
 142     }
 143     r->iov.iov_len = MIN(r->sector_count * 512, r->buflen);
 144     qemu_iovec_init_external(&r->qiov, &r->iov, 1);
 145 }
 146
 147 static void scsi_disk_save_request(QEMUFile *f, SCSIRequest *req)
 148 {
 149     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 150
 151     qemu_put_be64s(f, &r->sector);
 152     qemu_put_be32s(f, &r->sector_count);
 153     qemu_put_be32s(f, &r->buflen);
 154     if (r->buflen) {
 155         if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
 156             qemu_put_buffer(f, r->iov.iov_base, r->iov.iov_len);
 157         } else if (!req->retry) {
 158             uint32_t len = r->iov.iov_len;
 159             qemu_put_be32s(f, &len);
 160             qemu_put_buffer(f, r->iov.iov_base, r->iov.iov_len);
 161         }
 162     }
 163 }
 164
 165 static void scsi_disk_load_request(QEMUFile *f, SCSIRequest *req)
 166 {
 167     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 168
 169     qemu_get_be64s(f, &r->sector);
 170     qemu_get_be32s(f, &r->sector_count);
 171     qemu_get_be32s(f, &r->buflen);
 172     if (r->buflen) {
 173         scsi_init_iovec(r, r->buflen);
 174         if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
 175             qemu_get_buffer(f, r->iov.iov_base, r->iov.iov_len);
 176         } else if (!r->req.retry) {
 177             uint32_t len;
 178             qemu_get_be32s(f, &len);
 179             r->iov.iov_len = len;
 180             assert(r->iov.iov_len <= r->buflen);
 181             qemu_get_buffer(f, r->iov.iov_base, r->iov.iov_len);
 182         }
 183     }
 184
 185     qemu_iovec_init_external(&r->qiov, &r->iov, 1);
 186 }
 187
 188 static bool scsi_disk_req_check_error(SCSIDiskReq *r, int ret, bool acct_failed)
 189 {
 190     if (r->req.io_canceled) {
 191         scsi_req_cancel_complete(&r->req);
 192         return true;
 193     }
 194
 195     if (ret < 0 || (r->status && *r->status)) {
 196         return scsi_handle_rw_error(r, -ret, acct_failed);
 197     }
 198
 199     return false;
 200 }
 201
 202 static void scsi_aio_complete(void *opaque, int ret)
 203 {
 204     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 205     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 206
 207     assert(r->req.aiocb != NULL);
 208     r->req.aiocb = NULL;
 209     aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
 210     if (scsi_disk_req_check_error(r, ret, true)) {
 211         goto done;
 212     }
 213
 214     block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
 215     scsi_req_complete(&r->req, GOOD);
 216
 217 done:
 218     aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 219     scsi_req_unref(&r->req);
 220 }
 221
 222 static bool scsi_is_cmd_fua(SCSICommand *cmd)
 223 {
 224     switch (cmd->buf[0]) {
 225     case READ_10:
 226     case READ_12:
 227     case READ_16:
 228     case WRITE_10:
 229     case WRITE_12:
 230     case WRITE_16:
 231         return (cmd->buf[1] & 8) != 0;
 232
 233     case VERIFY_10:
 234     case VERIFY_12:
 235     case VERIFY_16:
 236     case WRITE_VERIFY_10:
 237     case WRITE_VERIFY_12:
 238     case WRITE_VERIFY_16:
 239         return true;
 240
 241     case READ_6:
 242     case WRITE_6:
 243     default:
 244         return false;
 245     }
 246 }
 247
 248 static void scsi_write_do_fua(SCSIDiskReq *r)
 249 {
 250     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 251
 252     assert(r->req.aiocb == NULL);
 253     assert(!r->req.io_canceled);
 254
 255     if (r->need_fua_emulation) {
 256         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0,
 257                          BLOCK_ACCT_FLUSH);
 258         r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r);
 259         return;
 260     }
 261
 262     scsi_req_complete(&r->req, GOOD);
 263     scsi_req_unref(&r->req);
 264 }
 265
 266 static void scsi_dma_complete_noio(SCSIDiskReq *r, int ret)
 267 {
 268     assert(r->req.aiocb == NULL);
 269     if (scsi_disk_req_check_error(r, ret, false)) {
 270         goto done;
 271     }
 272
 273     r->sector += r->sector_count;
 274     r->sector_count = 0;
 275     if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
 276         scsi_write_do_fua(r);
 277         return;
 278     } else {
 279         scsi_req_complete(&r->req, GOOD);
 280     }
 281
 282 done:
 283     scsi_req_unref(&r->req);
 284 }
 285
 286 static void scsi_dma_complete(void *opaque, int ret)
 287 {
 288     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 289     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 290
 291     assert(r->req.aiocb != NULL);
 292     r->req.aiocb = NULL;
 293
 294     aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
 295     if (ret < 0) {
 296         block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
 297     } else {
 298         block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
 299     }
 300     scsi_dma_complete_noio(r, ret);
 301     aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 302 }
 303
 304 static void scsi_read_complete_noio(SCSIDiskReq *r, int ret)
 305 {
 306     uint32_t n;
 307
 308     assert(r->req.aiocb == NULL);
 309     if (scsi_disk_req_check_error(r, ret, false)) {
 310         goto done;
 311     }
 312
 313     n = r->qiov.size / 512;
 314     r->sector += n;
 315     r->sector_count -= n;
 316     scsi_req_data(&r->req, r->qiov.size);
 317
 318 done:
 319     scsi_req_unref(&r->req);
 320 }
 321
 322 static void scsi_read_complete(void *opaque, int ret)
 323 {
 324     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 325     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 326
 327     assert(r->req.aiocb != NULL);
 328     r->req.aiocb = NULL;
 329
 330     aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
 331     if (ret < 0) {
 332         block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
 333     } else {
 334         block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
 335         trace_scsi_disk_read_complete(r->req.tag, r->qiov.size);
 336     }
 337     scsi_read_complete_noio(r, ret);
 338     aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 339 }
 340
 341 /* Actually issue a read to the block device.  */
 342 static void scsi_do_read(SCSIDiskReq *r, int ret)
 343 {
 344     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 345     SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s));
 346
 347     assert (r->req.aiocb == NULL);
 348     if (scsi_disk_req_check_error(r, ret, false)) {
 349         goto done;
 350     }
 351
 352     /* The request is used as the AIO opaque value, so add a ref.  */
 353     scsi_req_ref(&r->req);
 354
 355     if (r->req.sg) {
 356         dma_acct_start(s->qdev.conf.blk, &r->acct, r->req.sg, BLOCK_ACCT_READ);
 357         r->req.resid -= r->req.sg->size;
 358         r->req.aiocb = dma_blk_io(blk_get_aio_context(s->qdev.conf.blk),
 359                                   r->req.sg, r->sector << BDRV_SECTOR_BITS,
 360                                   BDRV_SECTOR_SIZE,
 361                                   sdc->dma_readv, r, scsi_dma_complete, r,
 362                                   DMA_DIRECTION_FROM_DEVICE);
 363     } else {
 364         scsi_init_iovec(r, SCSI_DMA_BUF_SIZE);
 365         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct,
 366                          r->qiov.size, BLOCK_ACCT_READ);
 367         r->req.aiocb = sdc->dma_readv(r->sector << BDRV_SECTOR_BITS, &r->qiov,
 368                                       scsi_read_complete, r, r);
 369     }
 370
 371 done:
 372     scsi_req_unref(&r->req);
 373 }
 374
 375 static void scsi_do_read_cb(void *opaque, int ret)
 376 {
 377     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 378     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 379
 380     assert (r->req.aiocb != NULL);
 381     r->req.aiocb = NULL;
 382
 383     aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
 384     if (ret < 0) {
 385         block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
 386     } else {
 387         block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
 388     }
 389     scsi_do_read(opaque, ret);
 390     aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 391 }
 392
 393 /* Read more data from scsi device into buffer.  */
 394 static void scsi_read_data(SCSIRequest *req)
 395 {
 396     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 397     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 398     bool first;
 399
 400     trace_scsi_disk_read_data_count(r->sector_count);
 401     if (r->sector_count == 0) {
 402         /* This also clears the sense buffer for REQUEST SENSE.  */
 403         scsi_req_complete(&r->req, GOOD);
 404         return;
 405     }
 406
 407     /* No data transfer may already be in progress */
 408     assert(r->req.aiocb == NULL);
 409
 410     /* The request is used as the AIO opaque value, so add a ref.  */
 411     scsi_req_ref(&r->req);
 412     if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
 413         trace_scsi_disk_read_data_invalid();
 414         scsi_read_complete_noio(r, -EINVAL);
 415         return;
 416     }
 417
 418     if (!blk_is_available(req->dev->conf.blk)) {
 419         scsi_read_complete_noio(r, -ENOMEDIUM);
 420         return;
 421     }
 422
 423     first = !r->started;
 424     r->started = true;
 425     if (first && r->need_fua_emulation) {
 426         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0,
 427                          BLOCK_ACCT_FLUSH);
 428         r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_do_read_cb, r);
 429     } else {
 430         scsi_do_read(r, 0);
 431     }
 432 }
 433
 434 /*
 435  * scsi_handle_rw_error has two return values.  False means that the error
 436  * must be ignored, true means that the error has been processed and the
 437  * caller should not do anything else for this request.  Note that
 438  * scsi_handle_rw_error always manages its reference counts, independent
 439  * of the return value.
 440  */
 441 static bool scsi_handle_rw_error(SCSIDiskReq *r, int error, bool acct_failed)
 442 {
 443     bool is_read = (r->req.cmd.mode == SCSI_XFER_FROM_DEV);
 444     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 445     SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s));
 446     BlockErrorAction action = blk_get_error_action(s->qdev.conf.blk,
 447                                                    is_read, error);
 448
 449     if (action == BLOCK_ERROR_ACTION_REPORT) {
 450         if (acct_failed) {
 451             block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
 452         }
 453         switch (error) {
 454         case 0:
 455             /* A passthrough command has run and has produced sense data; check
 456              * whether the error has to be handled by the guest or should rather
 457              * pause the host.
 458              */
 459             assert(r->status && *r->status);
 460             if (scsi_sense_buf_is_guest_recoverable(r->req.sense, sizeof(r->req.sense))) {
 461                 /* These errors are handled by guest. */
 462                 sdc->update_sense(&r->req);
 463                 scsi_req_complete(&r->req, *r->status);
 464                 return true;
 465             }
 466             error = scsi_sense_buf_to_errno(r->req.sense, sizeof(r->req.sense));
 467             break;
 468         case ENOMEDIUM:
 469             scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
 470             break;
 471         case ENOMEM:
 472             scsi_check_condition(r, SENSE_CODE(TARGET_FAILURE));
 473             break;
 474         case EINVAL:
 475             scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
 476             break;
 477         case ENOSPC:
 478             scsi_check_condition(r, SENSE_CODE(SPACE_ALLOC_FAILED));
 479             break;
 480         default:
 481             scsi_check_condition(r, SENSE_CODE(IO_ERROR));
 482             break;
 483         }
 484     }
 485
 486     blk_error_action(s->qdev.conf.blk, action, is_read, error);
 487     if (action == BLOCK_ERROR_ACTION_IGNORE) {
 488         scsi_req_complete(&r->req, 0);
 489         return true;
 490     }
 491
 492     if (action == BLOCK_ERROR_ACTION_STOP) {
 493         scsi_req_retry(&r->req);
 494     }
 495     return true;
 496 }
 497
 498 static void scsi_write_complete_noio(SCSIDiskReq *r, int ret)
 499 {
 500     uint32_t n;
 501
 502     assert (r->req.aiocb == NULL);
 503     if (scsi_disk_req_check_error(r, ret, false)) {
 504         goto done;
 505     }
 506
 507     n = r->qiov.size / 512;
 508     r->sector += n;
 509     r->sector_count -= n;
 510     if (r->sector_count == 0) {
 511         scsi_write_do_fua(r);
 512         return;
 513     } else {
 514         scsi_init_iovec(r, SCSI_DMA_BUF_SIZE);
 515         trace_scsi_disk_write_complete_noio(r->req.tag, r->qiov.size);
 516         scsi_req_data(&r->req, r->qiov.size);
 517     }
 518
 519 done:
 520     scsi_req_unref(&r->req);
 521 }
 522
 523 static void scsi_write_complete(void * opaque, int ret)
 524 {
 525     SCSIDiskReq *r = (SCSIDiskReq *)opaque;
 526     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 527
 528     assert (r->req.aiocb != NULL);
 529     r->req.aiocb = NULL;
 530
 531     aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
 532     if (ret < 0) {
 533         block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
 534     } else {
 535         block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
 536     }
 537     scsi_write_complete_noio(r, ret);
 538     aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 539 }
 540
 541 static void scsi_write_data(SCSIRequest *req)
 542 {
 543     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 544     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 545     SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s));
 546
 547     /* No data transfer may already be in progress */
 548     assert(r->req.aiocb == NULL);
 549
 550     /* The request is used as the AIO opaque value, so add a ref.  */
 551     scsi_req_ref(&r->req);
 552     if (r->req.cmd.mode != SCSI_XFER_TO_DEV) {
 553         trace_scsi_disk_write_data_invalid();
 554         scsi_write_complete_noio(r, -EINVAL);
 555         return;
 556     }
 557
 558     if (!r->req.sg && !r->qiov.size) {
 559         /* Called for the first time.  Ask the driver to send us more data.  */
 560         r->started = true;
 561         scsi_write_complete_noio(r, 0);
 562         return;
 563     }
 564     if (!blk_is_available(req->dev->conf.blk)) {
 565         scsi_write_complete_noio(r, -ENOMEDIUM);
 566         return;
 567     }
 568
 569     if (r->req.cmd.buf[0] == VERIFY_10 || r->req.cmd.buf[0] == VERIFY_12 ||
 570         r->req.cmd.buf[0] == VERIFY_16) {
 571         if (r->req.sg) {
 572             scsi_dma_complete_noio(r, 0);
 573         } else {
 574             scsi_write_complete_noio(r, 0);
 575         }
 576         return;
 577     }
 578
 579     if (r->req.sg) {
 580         dma_acct_start(s->qdev.conf.blk, &r->acct, r->req.sg, BLOCK_ACCT_WRITE);
 581         r->req.resid -= r->req.sg->size;
 582         r->req.aiocb = dma_blk_io(blk_get_aio_context(s->qdev.conf.blk),
 583                                   r->req.sg, r->sector << BDRV_SECTOR_BITS,
 584                                   BDRV_SECTOR_SIZE,
 585                                   sdc->dma_writev, r, scsi_dma_complete, r,
 586                                   DMA_DIRECTION_TO_DEVICE);
 587     } else {
 588         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct,
 589                          r->qiov.size, BLOCK_ACCT_WRITE);
 590         r->req.aiocb = sdc->dma_writev(r->sector << BDRV_SECTOR_BITS, &r->qiov,
 591                                        scsi_write_complete, r, r);
 592     }
 593 }
 594
 595 /* Return a pointer to the data buffer.  */
 596 static uint8_t *scsi_get_buf(SCSIRequest *req)
 597 {
 598     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
 599
 600     return (uint8_t *)r->iov.iov_base;
 601 }
 602
 603 static int scsi_disk_emulate_vpd_page(SCSIRequest *req, uint8_t *outbuf)
 604 {
 605     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
 606     uint8_t page_code = req->cmd.buf[2];
 607     int start, buflen = 0;
 608
 609     outbuf[buflen++] = s->qdev.type & 0x1f;
 610     outbuf[buflen++] = page_code;
 611     outbuf[buflen++] = 0x00;
 612     outbuf[buflen++] = 0x00;
 613     start = buflen;
 614
 615     switch (page_code) {
 616     case 0x00: /* Supported page codes, mandatory */
 617     {
 618         trace_scsi_disk_emulate_vpd_page_00(req->cmd.xfer);
 619         outbuf[buflen++] = 0x00; /* list of supported pages (this page) */
 620         if (s->serial) {
 621             outbuf[buflen++] = 0x80; /* unit serial number */
 622         }
 623         outbuf[buflen++] = 0x83; /* device identification */
 624         if (s->qdev.type == TYPE_DISK) {
 625             outbuf[buflen++] = 0xb0; /* block limits */
 626             outbuf[buflen++] = 0xb1; /* block device characteristics */
 627             outbuf[buflen++] = 0xb2; /* thin provisioning */
 628         }
 629         break;
 630     }
 631     case 0x80: /* Device serial number, optional */
 632     {
 633         int l;
 634
 635         if (!s->serial) {
 636             trace_scsi_disk_emulate_vpd_page_80_not_supported();
 637             return -1;
 638         }
 639
 640         l = strlen(s->serial);
 641         if (l > 36) {
 642             l = 36;
 643         }
 644
 645         trace_scsi_disk_emulate_vpd_page_80(req->cmd.xfer);
 646         memcpy(outbuf + buflen, s->serial, l);
 647         buflen += l;
 648         break;
 649     }
 650
 651     case 0x83: /* Device identification page, mandatory */
 652     {
 653         int id_len = s->device_id ? MIN(strlen(s->device_id), 255 - 8) : 0;
 654
 655         trace_scsi_disk_emulate_vpd_page_83(req->cmd.xfer);
 656
 657         if (id_len) {
 658             outbuf[buflen++] = 0x2; /* ASCII */
 659             outbuf[buflen++] = 0;   /* not officially assigned */
 660             outbuf[buflen++] = 0;   /* reserved */
 661             outbuf[buflen++] = id_len; /* length of data following */
 662             memcpy(outbuf + buflen, s->device_id, id_len);
 663             buflen += id_len;
 664         }
 665
 666         if (s->qdev.wwn) {
 667             outbuf[buflen++] = 0x1; /* Binary */
 668             outbuf[buflen++] = 0x3; /* NAA */
 669             outbuf[buflen++] = 0;   /* reserved */
 670             outbuf[buflen++] = 8;
 671             stq_be_p(&outbuf[buflen], s->qdev.wwn);
 672             buflen += 8;
 673         }
 674
 675         if (s->qdev.port_wwn) {
 676             outbuf[buflen++] = 0x61; /* SAS / Binary */
 677             outbuf[buflen++] = 0x93; /* PIV / Target port / NAA */
 678             outbuf[buflen++] = 0;    /* reserved */
 679             outbuf[buflen++] = 8;
 680             stq_be_p(&outbuf[buflen], s->qdev.port_wwn);
 681             buflen += 8;
 682         }
 683
 684         if (s->port_index) {
 685             outbuf[buflen++] = 0x61; /* SAS / Binary */
 686
 687             /* PIV/Target port/relative target port */
 688             outbuf[buflen++] = 0x94;
 689
 690             outbuf[buflen++] = 0;    /* reserved */
 691             outbuf[buflen++] = 4;
 692             stw_be_p(&outbuf[buflen + 2], s->port_index);
 693             buflen += 4;
 694         }
 695         break;
 696     }
 697     case 0xb0: /* block limits */
 698     {
 699         SCSIBlockLimits bl = {};
 700
 701         if (s->qdev.type == TYPE_ROM) {
 702             trace_scsi_disk_emulate_vpd_page_b0_not_supported();
 703             return -1;
 704         }
 705         bl.wsnz = 1;
 706         bl.unmap_sectors =
 707             s->qdev.conf.discard_granularity / s->qdev.blocksize;
 708         bl.min_io_size =
 709             s->qdev.conf.min_io_size / s->qdev.blocksize;
 710         bl.opt_io_size =
 711             s->qdev.conf.opt_io_size / s->qdev.blocksize;
 712         bl.max_unmap_sectors =
 713             s->max_unmap_size / s->qdev.blocksize;
 714         bl.max_io_sectors =
 715             s->max_io_size / s->qdev.blocksize;
 716         /* 255 descriptors fit in 4 KiB with an 8-byte header */
 717         bl.max_unmap_descr = 255;
 718
 719         if (s->qdev.type == TYPE_DISK) {
 720             int max_transfer_blk = blk_get_max_transfer(s->qdev.conf.blk);
 721             int max_io_sectors_blk =
 722                 max_transfer_blk / s->qdev.blocksize;
 723
 724             bl.max_io_sectors =
 725                 MIN_NON_ZERO(max_io_sectors_blk, bl.max_io_sectors);
 726         }
 727         buflen += scsi_emulate_block_limits(outbuf + buflen, &bl);
 728         break;
 729     }
 730     case 0xb1: /* block device characteristics */
 731     {
 732         buflen = 0x40;
 733         outbuf[4] = (s->rotation_rate >> 8) & 0xff;
 734         outbuf[5] = s->rotation_rate & 0xff;
 735         outbuf[6] = 0; /* PRODUCT TYPE */
 736         outbuf[7] = 0; /* WABEREQ | WACEREQ | NOMINAL FORM FACTOR */
 737         outbuf[8] = 0; /* VBULS */
 738         break;
 739     }
 740     case 0xb2: /* thin provisioning */
 741     {
 742         buflen = 8;
 743         outbuf[4] = 0;
 744         outbuf[5] = 0xe0; /* unmap & write_same 10/16 all supported */
 745         outbuf[6] = s->qdev.conf.discard_granularity ? 2 : 1;
 746         outbuf[7] = 0;
 747         break;
 748     }
 749     default:
 750         return -1;
 751     }
 752     /* done with EVPD */
 753     assert(buflen - start <= 255);
 754     outbuf[start - 1] = buflen - start;
 755     return buflen;
 756 }
 757
 758 static int scsi_disk_emulate_inquiry(SCSIRequest *req, uint8_t *outbuf)
 759 {
 760     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
 761     int buflen = 0;
 762
 763     if (req->cmd.buf[1] & 0x1) {
 764         /* Vital product data */
 765         return scsi_disk_emulate_vpd_page(req, outbuf);
 766     }
 767
 768     /* Standard INQUIRY data */
 769     if (req->cmd.buf[2] != 0) {
 770         return -1;
 771     }
 772
 773     /* PAGE CODE == 0 */
 774     buflen = req->cmd.xfer;
 775     if (buflen > SCSI_MAX_INQUIRY_LEN) {
 776         buflen = SCSI_MAX_INQUIRY_LEN;
 777     }
 778
 779     outbuf[0] = s->qdev.type & 0x1f;
 780     outbuf[1] = (s->features & (1 << SCSI_DISK_F_REMOVABLE)) ? 0x80 : 0;
 781
 782     strpadcpy((char *) &outbuf[16], 16, s->product, ' ');
 783     strpadcpy((char *) &outbuf[8], 8, s->vendor, ' ');
 784
 785     memset(&outbuf[32], 0, 4);
 786     memcpy(&outbuf[32], s->version, MIN(4, strlen(s->version)));
 787     /*
 788      * We claim conformance to SPC-3, which is required for guests
 789      * to ask for modern features like READ CAPACITY(16) or the
 790      * block characteristics VPD page by default.  Not all of SPC-3
 791      * is actually implemented, but we're good enough.
 792      */
 793     outbuf[2] = s->qdev.default_scsi_version;
 794     outbuf[3] = 2 | 0x10; /* Format 2, HiSup */
 795
 796     if (buflen > 36) {
 797         outbuf[4] = buflen - 5; /* Additional Length = (Len - 1) - 4 */
 798     } else {
 799         /* If the allocation length of CDB is too small,
 800                the additional length is not adjusted */
 801         outbuf[4] = 36 - 5;
 802     }
 803
 804     /* Sync data transfer and TCQ.  */
 805     outbuf[7] = 0x10 | (req->bus->info->tcq ? 0x02 : 0);
 806     return buflen;
 807 }
 808
 809 static inline bool media_is_dvd(SCSIDiskState *s)
 810 {
 811     uint64_t nb_sectors;
 812     if (s->qdev.type != TYPE_ROM) {
 813         return false;
 814     }
 815     if (!blk_is_available(s->qdev.conf.blk)) {
 816         return false;
 817     }
 818     blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
 819     return nb_sectors > CD_MAX_SECTORS;
 820 }
 821
 822 static inline bool media_is_cd(SCSIDiskState *s)
 823 {
 824     uint64_t nb_sectors;
 825     if (s->qdev.type != TYPE_ROM) {
 826         return false;
 827     }
 828     if (!blk_is_available(s->qdev.conf.blk)) {
 829         return false;
 830     }
 831     blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
 832     return nb_sectors <= CD_MAX_SECTORS;
 833 }
 834
 835 static int scsi_read_disc_information(SCSIDiskState *s, SCSIDiskReq *r,
 836                                       uint8_t *outbuf)
 837 {
 838     uint8_t type = r->req.cmd.buf[1] & 7;
 839
 840     if (s->qdev.type != TYPE_ROM) {
 841         return -1;
 842     }
 843
 844     /* Types 1/2 are only defined for Blu-Ray.  */
 845     if (type != 0) {
 846         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
 847         return -1;
 848     }
 849
 850     memset(outbuf, 0, 34);
 851     outbuf[1] = 32;
 852     outbuf[2] = 0xe; /* last session complete, disc finalized */
 853     outbuf[3] = 1;   /* first track on disc */
 854     outbuf[4] = 1;   /* # of sessions */
 855     outbuf[5] = 1;   /* first track of last session */
 856     outbuf[6] = 1;   /* last track of last session */
 857     outbuf[7] = 0x20; /* unrestricted use */
 858     outbuf[8] = 0x00; /* CD-ROM or DVD-ROM */
 859     /* 9-10-11: most significant byte corresponding bytes 4-5-6 */
 860     /* 12-23: not meaningful for CD-ROM or DVD-ROM */
 861     /* 24-31: disc bar code */
 862     /* 32: disc application code */
 863     /* 33: number of OPC tables */
 864
 865     return 34;
 866 }
 867
 868 static int scsi_read_dvd_structure(SCSIDiskState *s, SCSIDiskReq *r,
 869                                    uint8_t *outbuf)
 870 {
 871     static const int rds_caps_size[5] = {
 872         [0] = 2048 + 4,
 873         [1] = 4 + 4,
 874         [3] = 188 + 4,
 875         [4] = 2048 + 4,
 876     };
 877
 878     uint8_t media = r->req.cmd.buf[1];
 879     uint8_t layer = r->req.cmd.buf[6];
 880     uint8_t format = r->req.cmd.buf[7];
 881     int size = -1;
 882
 883     if (s->qdev.type != TYPE_ROM) {
 884         return -1;
 885     }
 886     if (media != 0) {
 887         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
 888         return -1;
 889     }
 890
 891     if (format != 0xff) {
 892         if (!blk_is_available(s->qdev.conf.blk)) {
 893             scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
 894             return -1;
 895         }
 896         if (media_is_cd(s)) {
 897             scsi_check_condition(r, SENSE_CODE(INCOMPATIBLE_FORMAT));
 898             return -1;
 899         }
 900         if (format >= ARRAY_SIZE(rds_caps_size)) {
 901             return -1;
 902         }
 903         size = rds_caps_size[format];
 904         memset(outbuf, 0, size);
 905     }
 906
 907     switch (format) {
 908     case 0x00: {
 909         /* Physical format information */
 910         uint64_t nb_sectors;
 911         if (layer != 0) {
 912             goto fail;
 913         }
 914         blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
 915
 916         outbuf[4] = 1;   /* DVD-ROM, part version 1 */
 917         outbuf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
 918         outbuf[6] = 1;   /* one layer, read-only (per MMC-2 spec) */
 919         outbuf[7] = 0;   /* default densities */
 920
 921         stl_be_p(&outbuf[12], (nb_sectors >> 2) - 1); /* end sector */
 922         stl_be_p(&outbuf[16], (nb_sectors >> 2) - 1); /* l0 end sector */
 923         break;
 924     }
 925
 926     case 0x01: /* DVD copyright information, all zeros */
 927         break;
 928
 929     case 0x03: /* BCA information - invalid field for no BCA info */
 930         return -1;
 931
 932     case 0x04: /* DVD disc manufacturing information, all zeros */
 933         break;
 934
 935     case 0xff: { /* List capabilities */
 936         int i;
 937         size = 4;
 938         for (i = 0; i < ARRAY_SIZE(rds_caps_size); i++) {
 939             if (!rds_caps_size[i]) {
 940                 continue;
 941             }
 942             outbuf[size] = i;
 943             outbuf[size + 1] = 0x40; /* Not writable, readable */
 944             stw_be_p(&outbuf[size + 2], rds_caps_size[i]);
 945             size += 4;
 946         }
 947         break;
 948      }
 949
 950     default:
 951         return -1;
 952     }
 953
 954     /* Size of buffer, not including 2 byte size field */
 955     stw_be_p(outbuf, size - 2);
 956     return size;
 957
 958 fail:
 959     return -1;
 960 }
 961
 962 static int scsi_event_status_media(SCSIDiskState *s, uint8_t *outbuf)
 963 {
 964     uint8_t event_code, media_status;
 965
 966     media_status = 0;
 967     if (s->tray_open) {
 968         media_status = MS_TRAY_OPEN;
 969     } else if (blk_is_inserted(s->qdev.conf.blk)) {
 970         media_status = MS_MEDIA_PRESENT;
 971     }
 972
 973     /* Event notification descriptor */
 974     event_code = MEC_NO_CHANGE;
 975     if (media_status != MS_TRAY_OPEN) {
 976         if (s->media_event) {
 977             event_code = MEC_NEW_MEDIA;
 978             s->media_event = false;
 979         } else if (s->eject_request) {
 980             event_code = MEC_EJECT_REQUESTED;
 981             s->eject_request = false;
 982         }
 983     }
 984
 985     outbuf[0] = event_code;
 986     outbuf[1] = media_status;
 987
 988     /* These fields are reserved, just clear them. */
 989     outbuf[2] = 0;
 990     outbuf[3] = 0;
 991     return 4;
 992 }
 993
 994 static int scsi_get_event_status_notification(SCSIDiskState *s, SCSIDiskReq *r,
 995                                               uint8_t *outbuf)
 996 {
 997     int size;
 998     uint8_t *buf = r->req.cmd.buf;
 999     uint8_t notification_class_request = buf[4];
1000     if (s->qdev.type != TYPE_ROM) {
1001         return -1;
1002     }
1003     if ((buf[1] & 1) == 0) {
1004         /* asynchronous */
1005         return -1;
1006     }
1007
1008     size = 4;
1009     outbuf[0] = outbuf[1] = 0;
1010     outbuf[3] = 1 << GESN_MEDIA; /* supported events */
1011     if (notification_class_request & (1 << GESN_MEDIA)) {
1012         outbuf[2] = GESN_MEDIA;
1013         size += scsi_event_status_media(s, &outbuf[size]);
1014     } else {
1015         outbuf[2] = 0x80;
1016     }
1017     stw_be_p(outbuf, size - 4);
1018     return size;
1019 }
1020
1021 static int scsi_get_configuration(SCSIDiskState *s, uint8_t *outbuf)
1022 {
1023     int current;
1024
1025     if (s->qdev.type != TYPE_ROM) {
1026         return -1;
1027     }
1028
1029     if (media_is_dvd(s)) {
1030         current = MMC_PROFILE_DVD_ROM;
1031     } else if (media_is_cd(s)) {
1032         current = MMC_PROFILE_CD_ROM;
1033     } else {
1034         current = MMC_PROFILE_NONE;
1035     }
1036
1037     memset(outbuf, 0, 40);
1038     stl_be_p(&outbuf[0], 36); /* Bytes after the data length field */
1039     stw_be_p(&outbuf[6], current);
1040     /* outbuf[8] - outbuf[19]: Feature 0 - Profile list */
1041     outbuf[10] = 0x03; /* persistent, current */
1042     outbuf[11] = 8; /* two profiles */
1043     stw_be_p(&outbuf[12], MMC_PROFILE_DVD_ROM);
1044     outbuf[14] = (current == MMC_PROFILE_DVD_ROM);
1045     stw_be_p(&outbuf[16], MMC_PROFILE_CD_ROM);
1046     outbuf[18] = (current == MMC_PROFILE_CD_ROM);
1047     /* outbuf[20] - outbuf[31]: Feature 1 - Core feature */
1048     stw_be_p(&outbuf[20], 1);
1049     outbuf[22] = 0x08 | 0x03; /* version 2, persistent, current */
1050     outbuf[23] = 8;
1051     stl_be_p(&outbuf[24], 1); /* SCSI */
1052     outbuf[28] = 1; /* DBE = 1, mandatory */
1053     /* outbuf[32] - outbuf[39]: Feature 3 - Removable media feature */
1054     stw_be_p(&outbuf[32], 3);
1055     outbuf[34] = 0x08 | 0x03; /* version 2, persistent, current */
1056     outbuf[35] = 4;
1057     outbuf[36] = 0x39; /* tray, load=1, eject=1, unlocked at powerup, lock=1 */
1058     /* TODO: Random readable, CD read, DVD read, drive serial number,
1059        power management */
1060     return 40;
1061 }
1062
1063 static int scsi_emulate_mechanism_status(SCSIDiskState *s, uint8_t *outbuf)
1064 {
1065     if (s->qdev.type != TYPE_ROM) {
1066         return -1;
1067     }
1068     memset(outbuf, 0, 8);
1069     outbuf[5] = 1; /* CD-ROM */
1070     return 8;
1071 }
1072
1073 static int mode_sense_page(SCSIDiskState *s, int page, uint8_t **p_outbuf,
1074                            int page_control)
1075 {
1076     static const int mode_sense_valid[0x3f] = {
1077         [MODE_PAGE_HD_GEOMETRY]            = (1 << TYPE_DISK),
1078         [MODE_PAGE_FLEXIBLE_DISK_GEOMETRY] = (1 << TYPE_DISK),
1079         [MODE_PAGE_CACHING]                = (1 << TYPE_DISK) | (1 << TYPE_ROM),
1080         [MODE_PAGE_R_W_ERROR]              = (1 << TYPE_DISK) | (1 << TYPE_ROM),
1081         [MODE_PAGE_AUDIO_CTL]              = (1 << TYPE_ROM),
1082         [MODE_PAGE_CAPABILITIES]           = (1 << TYPE_ROM),
1083     };
1084
1085     uint8_t *p = *p_outbuf + 2;
1086     int length;
1087
1088     if ((mode_sense_valid[page] & (1 << s->qdev.type)) == 0) {
1089         return -1;
1090     }
1091
1092     /*
1093      * If Changeable Values are requested, a mask denoting those mode parameters
1094      * that are changeable shall be returned. As we currently don't support
1095      * parameter changes via MODE_SELECT all bits are returned set to zero.
1096      * The buffer was already menset to zero by the caller of this function.
1097      *
1098      * The offsets here are off by two compared to the descriptions in the
1099      * SCSI specs, because those include a 2-byte header.  This is unfortunate,
1100      * but it is done so that offsets are consistent within our implementation
1101      * of MODE SENSE and MODE SELECT.  MODE SELECT has to deal with both
1102      * 2-byte and 4-byte headers.
1103      */
1104     switch (page) {
1105     case MODE_PAGE_HD_GEOMETRY:
1106         length = 0x16;
1107         if (page_control == 1) { /* Changeable Values */
1108             break;
1109         }
1110         /* if a geometry hint is available, use it */
1111         p[0] = (s->qdev.conf.cyls >> 16) & 0xff;
1112         p[1] = (s->qdev.conf.cyls >> 8) & 0xff;
1113         p[2] = s->qdev.conf.cyls & 0xff;
1114         p[3] = s->qdev.conf.heads & 0xff;
1115         /* Write precomp start cylinder, disabled */
1116         p[4] = (s->qdev.conf.cyls >> 16) & 0xff;
1117         p[5] = (s->qdev.conf.cyls >> 8) & 0xff;
1118         p[6] = s->qdev.conf.cyls & 0xff;
1119         /* Reduced current start cylinder, disabled */
1120         p[7] = (s->qdev.conf.cyls >> 16) & 0xff;
1121         p[8] = (s->qdev.conf.cyls >> 8) & 0xff;
1122         p[9] = s->qdev.conf.cyls & 0xff;
1123         /* Device step rate [ns], 200ns */
1124         p[10] = 0;
1125         p[11] = 200;
1126         /* Landing zone cylinder */
1127         p[12] = 0xff;
1128         p[13] =  0xff;
1129         p[14] = 0xff;
1130         /* Medium rotation rate [rpm], 5400 rpm */
1131         p[18] = (5400 >> 8) & 0xff;
1132         p[19] = 5400 & 0xff;
1133         break;
1134
1135     case MODE_PAGE_FLEXIBLE_DISK_GEOMETRY:
1136         length = 0x1e;
1137         if (page_control == 1) { /* Changeable Values */
1138             break;
1139         }
1140         /* Transfer rate [kbit/s], 5Mbit/s */
1141         p[0] = 5000 >> 8;
1142         p[1] = 5000 & 0xff;
1143         /* if a geometry hint is available, use it */
1144         p[2] = s->qdev.conf.heads & 0xff;
1145         p[3] = s->qdev.conf.secs & 0xff;
1146         p[4] = s->qdev.blocksize >> 8;
1147         p[6] = (s->qdev.conf.cyls >> 8) & 0xff;
1148         p[7] = s->qdev.conf.cyls & 0xff;
1149         /* Write precomp start cylinder, disabled */
1150         p[8] = (s->qdev.conf.cyls >> 8) & 0xff;
1151         p[9] = s->qdev.conf.cyls & 0xff;
1152         /* Reduced current start cylinder, disabled */
1153         p[10] = (s->qdev.conf.cyls >> 8) & 0xff;
1154         p[11] = s->qdev.conf.cyls & 0xff;
1155         /* Device step rate [100us], 100us */
1156         p[12] = 0;
1157         p[13] = 1;
1158         /* Device step pulse width [us], 1us */
1159         p[14] = 1;
1160         /* Device head settle delay [100us], 100us */
1161         p[15] = 0;
1162         p[16] = 1;
1163         /* Motor on delay [0.1s], 0.1s */
1164         p[17] = 1;
1165         /* Motor off delay [0.1s], 0.1s */
1166         p[18] = 1;
1167         /* Medium rotation rate [rpm], 5400 rpm */
1168         p[26] = (5400 >> 8) & 0xff;
1169         p[27] = 5400 & 0xff;
1170         break;
1171
1172     case MODE_PAGE_CACHING:
1173         length = 0x12;
1174         if (page_control == 1 || /* Changeable Values */
1175             blk_enable_write_cache(s->qdev.conf.blk)) {
1176             p[0] = 4; /* WCE */
1177         }
1178         break;
1179
1180     case MODE_PAGE_R_W_ERROR:
1181         length = 10;
1182         if (page_control == 1) { /* Changeable Values */
1183             break;
1184         }
1185         p[0] = 0x80; /* Automatic Write Reallocation Enabled */
1186         if (s->qdev.type == TYPE_ROM) {
1187             p[1] = 0x20; /* Read Retry Count */
1188         }
1189         break;
1190
1191     case MODE_PAGE_AUDIO_CTL:
1192         length = 14;
1193         break;
1194
1195     case MODE_PAGE_CAPABILITIES:
1196         length = 0x14;
1197         if (page_control == 1) { /* Changeable Values */
1198             break;
1199         }
1200
1201         p[0] = 0x3b; /* CD-R & CD-RW read */
1202         p[1] = 0; /* Writing not supported */
1203         p[2] = 0x7f; /* Audio, composite, digital out,
1204                         mode 2 form 1&2, multi session */
1205         p[3] = 0xff; /* CD DA, DA accurate, RW supported,
1206                         RW corrected, C2 errors, ISRC,
1207                         UPC, Bar code */
1208         p[4] = 0x2d | (s->tray_locked ? 2 : 0);
1209         /* Locking supported, jumper present, eject, tray */
1210         p[5] = 0; /* no volume & mute control, no
1211                      changer */
1212         p[6] = (50 * 176) >> 8; /* 50x read speed */
1213         p[7] = (50 * 176) & 0xff;
1214         p[8] = 2 >> 8; /* Two volume levels */
1215         p[9] = 2 & 0xff;
1216         p[10] = 2048 >> 8; /* 2M buffer */
1217         p[11] = 2048 & 0xff;
1218         p[12] = (16 * 176) >> 8; /* 16x read speed current */
1219         p[13] = (16 * 176) & 0xff;
1220         p[16] = (16 * 176) >> 8; /* 16x write speed */
1221         p[17] = (16 * 176) & 0xff;
1222         p[18] = (16 * 176) >> 8; /* 16x write speed current */
1223         p[19] = (16 * 176) & 0xff;
1224         break;
1225
1226     default:
1227         return -1;
1228     }
1229
1230     assert(length < 256);
1231     (*p_outbuf)[0] = page;
1232     (*p_outbuf)[1] = length;
1233     *p_outbuf += length + 2;
1234     return length + 2;
1235 }
1236
1237 static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf)
1238 {
1239     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
1240     uint64_t nb_sectors;
1241     bool dbd;
1242     int page, buflen, ret, page_control;
1243     uint8_t *p;
1244     uint8_t dev_specific_param;
1245
1246     dbd = (r->req.cmd.buf[1] & 0x8) != 0;
1247     page = r->req.cmd.buf[2] & 0x3f;
1248     page_control = (r->req.cmd.buf[2] & 0xc0) >> 6;
1249
1250     trace_scsi_disk_emulate_mode_sense((r->req.cmd.buf[0] == MODE_SENSE) ? 6 :
1251                                        10, page, r->req.cmd.xfer, page_control);
1252     memset(outbuf, 0, r->req.cmd.xfer);
1253     p = outbuf;
1254
1255     if (s->qdev.type == TYPE_DISK) {
1256         dev_specific_param = s->features & (1 << SCSI_DISK_F_DPOFUA) ? 0x10 : 0;
1257         if (blk_is_read_only(s->qdev.conf.blk)) {
1258             dev_specific_param |= 0x80; /* Readonly.  */
1259         }
1260     } else {
1261         /* MMC prescribes that CD/DVD drives have no block descriptors,
1262          * and defines no device-specific parameter.  */
1263         dev_specific_param = 0x00;
1264         dbd = true;
1265     }
1266
1267     if (r->req.cmd.buf[0] == MODE_SENSE) {
1268         p[1] = 0; /* Default media type.  */
1269         p[2] = dev_specific_param;
1270         p[3] = 0; /* Block descriptor length.  */
1271         p += 4;
1272     } else { /* MODE_SENSE_10 */
1273         p[2] = 0; /* Default media type.  */
1274         p[3] = dev_specific_param;
1275         p[6] = p[7] = 0; /* Block descriptor length.  */
1276         p += 8;
1277     }
1278
1279     blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
1280     if (!dbd && nb_sectors) {
1281         if (r->req.cmd.buf[0] == MODE_SENSE) {
1282             outbuf[3] = 8; /* Block descriptor length  */
1283         } else { /* MODE_SENSE_10 */
1284             outbuf[7] = 8; /* Block descriptor length  */
1285         }
1286         nb_sectors /= (s->qdev.blocksize / 512);
1287         if (nb_sectors > 0xffffff) {
1288             nb_sectors = 0;
1289         }
1290         p[0] = 0; /* media density code */
1291         p[1] = (nb_sectors >> 16) & 0xff;
1292         p[2] = (nb_sectors >> 8) & 0xff;
1293         p[3] = nb_sectors & 0xff;
1294         p[4] = 0; /* reserved */
1295         p[5] = 0; /* bytes 5-7 are the sector size in bytes */
1296         p[6] = s->qdev.blocksize >> 8;
1297         p[7] = 0;
1298         p += 8;
1299     }
1300
1301     if (page_control == 3) {
1302         /* Saved Values */
1303         scsi_check_condition(r, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED));
1304         return -1;
1305     }
1306
1307     if (page == 0x3f) {
1308         for (page = 0; page <= 0x3e; page++) {
1309             mode_sense_page(s, page, &p, page_control);
1310         }
1311     } else {
1312         ret = mode_sense_page(s, page, &p, page_control);
1313         if (ret == -1) {
1314             return -1;
1315         }
1316     }
1317
1318     buflen = p - outbuf;
1319     /*
1320      * The mode data length field specifies the length in bytes of the
1321      * following data that is available to be transferred. The mode data
1322      * length does not include itself.
1323      */
1324     if (r->req.cmd.buf[0] == MODE_SENSE) {
1325         outbuf[0] = buflen - 1;
1326     } else { /* MODE_SENSE_10 */
1327         outbuf[0] = ((buflen - 2) >> 8) & 0xff;
1328         outbuf[1] = (buflen - 2) & 0xff;
1329     }
1330     return buflen;
1331 }
1332
1333 static int scsi_disk_emulate_read_toc(SCSIRequest *req, uint8_t *outbuf)
1334 {
1335     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1336     int start_track, format, msf, toclen;
1337     uint64_t nb_sectors;
1338
1339     msf = req->cmd.buf[1] & 2;
1340     format = req->cmd.buf[2] & 0xf;
1341     start_track = req->cmd.buf[6];
1342     blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
1343     trace_scsi_disk_emulate_read_toc(start_track, format, msf >> 1);
1344     nb_sectors /= s->qdev.blocksize / 512;
1345     switch (format) {
1346     case 0:
1347         toclen = cdrom_read_toc(nb_sectors, outbuf, msf, start_track);
1348         break;
1349     case 1:
1350         /* multi session : only a single session defined */
1351         toclen = 12;
1352         memset(outbuf, 0, 12);
1353         outbuf[1] = 0x0a;
1354         outbuf[2] = 0x01;
1355         outbuf[3] = 0x01;
1356         break;
1357     case 2:
1358         toclen = cdrom_read_toc_raw(nb_sectors, outbuf, msf, start_track);
1359         break;
1360     default:
1361         return -1;
1362     }
1363     return toclen;
1364 }
1365
1366 static int scsi_disk_emulate_start_stop(SCSIDiskReq *r)
1367 {
1368     SCSIRequest *req = &r->req;
1369     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1370     bool start = req->cmd.buf[4] & 1;
1371     bool loej = req->cmd.buf[4] & 2; /* load on start, eject on !start */
1372     int pwrcnd = req->cmd.buf[4] & 0xf0;
1373
1374     if (pwrcnd) {
1375         /* eject/load only happens for power condition == 0 */
1376         return 0;
1377     }
1378
1379     if ((s->features & (1 << SCSI_DISK_F_REMOVABLE)) && loej) {
1380         if (!start && !s->tray_open && s->tray_locked) {
1381             scsi_check_condition(r,
1382                                  blk_is_inserted(s->qdev.conf.blk)
1383                                  ? SENSE_CODE(ILLEGAL_REQ_REMOVAL_PREVENTED)
1384                                  : SENSE_CODE(NOT_READY_REMOVAL_PREVENTED));
1385             return -1;
1386         }
1387
1388         if (s->tray_open != !start) {
1389             blk_eject(s->qdev.conf.blk, !start);
1390             s->tray_open = !start;
1391         }
1392     }
1393     return 0;
1394 }
1395
1396 static void scsi_disk_emulate_read_data(SCSIRequest *req)
1397 {
1398     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
1399     int buflen = r->iov.iov_len;
1400
1401     if (buflen) {
1402         trace_scsi_disk_emulate_read_data(buflen);
1403         r->iov.iov_len = 0;
1404         r->started = true;
1405         scsi_req_data(&r->req, buflen);
1406         return;
1407     }
1408
1409     /* This also clears the sense buffer for REQUEST SENSE.  */
1410     scsi_req_complete(&r->req, GOOD);
1411 }
1412
1413 static int scsi_disk_check_mode_select(SCSIDiskState *s, int page,
1414                                        uint8_t *inbuf, int inlen)
1415 {
1416     uint8_t mode_current[SCSI_MAX_MODE_LEN];
1417     uint8_t mode_changeable[SCSI_MAX_MODE_LEN];
1418     uint8_t *p;
1419     int len, expected_len, changeable_len, i;
1420
1421     /* The input buffer does not include the page header, so it is
1422      * off by 2 bytes.
1423      */
1424     expected_len = inlen + 2;
1425     if (expected_len > SCSI_MAX_MODE_LEN) {
1426         return -1;
1427     }
1428
1429     p = mode_current;
1430     memset(mode_current, 0, inlen + 2);
1431     len = mode_sense_page(s, page, &p, 0);
1432     if (len < 0 || len != expected_len) {
1433         return -1;
1434     }
1435
1436     p = mode_changeable;
1437     memset(mode_changeable, 0, inlen + 2);
1438     changeable_len = mode_sense_page(s, page, &p, 1);
1439     assert(changeable_len == len);
1440
1441     /* Check that unchangeable bits are the same as what MODE SENSE
1442      * would return.
1443      */
1444     for (i = 2; i < len; i++) {
1445         if (((mode_current[i] ^ inbuf[i - 2]) & ~mode_changeable[i]) != 0) {
1446             return -1;
1447         }
1448     }
1449     return 0;
1450 }
1451
1452 static void scsi_disk_apply_mode_select(SCSIDiskState *s, int page, uint8_t *p)
1453 {
1454     switch (page) {
1455     case MODE_PAGE_CACHING:
1456         blk_set_enable_write_cache(s->qdev.conf.blk, (p[0] & 4) != 0);
1457         break;
1458
1459     default:
1460         break;
1461     }
1462 }
1463
1464 static int mode_select_pages(SCSIDiskReq *r, uint8_t *p, int len, bool change)
1465 {
1466     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
1467
1468     while (len > 0) {
1469         int page, subpage, page_len;
1470
1471         /* Parse both possible formats for the mode page headers.  */
1472         page = p[0] & 0x3f;
1473         if (p[0] & 0x40) {
1474             if (len < 4) {
1475                 goto invalid_param_len;
1476             }
1477             subpage = p[1];
1478             page_len = lduw_be_p(&p[2]);
1479             p += 4;
1480             len -= 4;
1481         } else {
1482             if (len < 2) {
1483                 goto invalid_param_len;
1484             }
1485             subpage = 0;
1486             page_len = p[1];
1487             p += 2;
1488             len -= 2;
1489         }
1490
1491         if (subpage) {
1492             goto invalid_param;
1493         }
1494         if (page_len > len) {
1495             goto invalid_param_len;
1496         }
1497
1498         if (!change) {
1499             if (scsi_disk_check_mode_select(s, page, p, page_len) < 0) {
1500                 goto invalid_param;
1501             }
1502         } else {
1503             scsi_disk_apply_mode_select(s, page, p);
1504         }
1505
1506         p += page_len;
1507         len -= page_len;
1508     }
1509     return 0;
1510
1511 invalid_param:
1512     scsi_check_condition(r, SENSE_CODE(INVALID_PARAM));
1513     return -1;
1514
1515 invalid_param_len:
1516     scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN));
1517     return -1;
1518 }
1519
1520 static void scsi_disk_emulate_mode_select(SCSIDiskReq *r, uint8_t *inbuf)
1521 {
1522     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
1523     uint8_t *p = inbuf;
1524     int cmd = r->req.cmd.buf[0];
1525     int len = r->req.cmd.xfer;
1526     int hdr_len = (cmd == MODE_SELECT ? 4 : 8);
1527     int bd_len;
1528     int pass;
1529
1530     /* We only support PF=1, SP=0.  */
1531     if ((r->req.cmd.buf[1] & 0x11) != 0x10) {
1532         goto invalid_field;
1533     }
1534
1535     if (len < hdr_len) {
1536         goto invalid_param_len;
1537     }
1538
1539     bd_len = (cmd == MODE_SELECT ? p[3] : lduw_be_p(&p[6]));
1540     len -= hdr_len;
1541     p += hdr_len;
1542     if (len < bd_len) {
1543         goto invalid_param_len;
1544     }
1545     if (bd_len != 0 && bd_len != 8) {
1546         goto invalid_param;
1547     }
1548
1549     len -= bd_len;
1550     p += bd_len;
1551
1552     /* Ensure no change is made if there is an error!  */
1553     for (pass = 0; pass < 2; pass++) {
1554         if (mode_select_pages(r, p, len, pass == 1) < 0) {
1555             assert(pass == 0);
1556             return;
1557         }
1558     }
1559     if (!blk_enable_write_cache(s->qdev.conf.blk)) {
1560         /* The request is used as the AIO opaque value, so add a ref.  */
1561         scsi_req_ref(&r->req);
1562         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0,
1563                          BLOCK_ACCT_FLUSH);
1564         r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r);
1565         return;
1566     }
1567
1568     scsi_req_complete(&r->req, GOOD);
1569     return;
1570
1571 invalid_param:
1572     scsi_check_condition(r, SENSE_CODE(INVALID_PARAM));
1573     return;
1574
1575 invalid_param_len:
1576     scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN));
1577     return;
1578
1579 invalid_field:
1580     scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
1581 }
1582
1583 static inline bool check_lba_range(SCSIDiskState *s,
1584                                    uint64_t sector_num, uint32_t nb_sectors)
1585 {
1586     /*
1587      * The first line tests that no overflow happens when computing the last
1588      * sector.  The second line tests that the last accessed sector is in
1589      * range.
1590      *
1591      * Careful, the computations should not underflow for nb_sectors == 0,
1592      * and a 0-block read to the first LBA beyond the end of device is
1593      * valid.
1594      */
1595     return (sector_num <= sector_num + nb_sectors &&
1596             sector_num + nb_sectors <= s->qdev.max_lba + 1);
1597 }
1598
1599 typedef struct UnmapCBData {
1600     SCSIDiskReq *r;
1601     uint8_t *inbuf;
1602     int count;
1603 } UnmapCBData;
1604
1605 static void scsi_unmap_complete(void *opaque, int ret);
1606
1607 static void scsi_unmap_complete_noio(UnmapCBData *data, int ret)
1608 {
1609     SCSIDiskReq *r = data->r;
1610     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
1611     uint64_t sector_num;
1612     uint32_t nb_sectors;
1613
1614     assert(r->req.aiocb == NULL);
1615     if (scsi_disk_req_check_error(r, ret, false)) {
1616         goto done;
1617     }
1618
1619     if (data->count > 0) {
1620         sector_num = ldq_be_p(&data->inbuf[0]);
1621         nb_sectors = ldl_be_p(&data->inbuf[8]) & 0xffffffffULL;
1622         if (!check_lba_range(s, sector_num, nb_sectors)) {
1623             scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
1624             goto done;
1625         }
1626
1627         r->req.aiocb = blk_aio_pdiscard(s->qdev.conf.blk,
1628                                         sector_num * s->qdev.blocksize,
1629                                         nb_sectors * s->qdev.blocksize,
1630                                         scsi_unmap_complete, data);
1631         data->count--;
1632         data->inbuf += 16;
1633         return;
1634     }
1635
1636     scsi_req_complete(&r->req, GOOD);
1637
1638 done:
1639     scsi_req_unref(&r->req);
1640     g_free(data);
1641 }
1642
1643 static void scsi_unmap_complete(void *opaque, int ret)
1644 {
1645     UnmapCBData *data = opaque;
1646     SCSIDiskReq *r = data->r;
1647     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
1648
1649     assert(r->req.aiocb != NULL);
1650     r->req.aiocb = NULL;
1651
1652     aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
1653     scsi_unmap_complete_noio(data, ret);
1654     aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
1655 }
1656
1657 static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf)
1658 {
1659     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
1660     uint8_t *p = inbuf;
1661     int len = r->req.cmd.xfer;
1662     UnmapCBData *data;
1663
1664     /* Reject ANCHOR=1.  */
1665     if (r->req.cmd.buf[1] & 0x1) {
1666         goto invalid_field;
1667     }
1668
1669     if (len < 8) {
1670         goto invalid_param_len;
1671     }
1672     if (len < lduw_be_p(&p[0]) + 2) {
1673         goto invalid_param_len;
1674     }
1675     if (len < lduw_be_p(&p[2]) + 8) {
1676         goto invalid_param_len;
1677     }
1678     if (lduw_be_p(&p[2]) & 15) {
1679         goto invalid_param_len;
1680     }
1681
1682     if (blk_is_read_only(s->qdev.conf.blk)) {
1683         scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED));
1684         return;
1685     }
1686
1687     data = g_new0(UnmapCBData, 1);
1688     data->r = r;
1689     data->inbuf = &p[8];
1690     data->count = lduw_be_p(&p[2]) >> 4;
1691
1692     /* The matching unref is in scsi_unmap_complete, before data is freed.  */
1693     scsi_req_ref(&r->req);
1694     scsi_unmap_complete_noio(data, 0);
1695     return;
1696
1697 invalid_param_len:
1698     scsi_check_condition(r, SENSE_CODE(INVALID_PARAM_LEN));
1699     return;
1700
1701 invalid_field:
1702     scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
1703 }
1704
1705 typedef struct WriteSameCBData {
1706     SCSIDiskReq *r;
1707     int64_t sector;
1708     int nb_sectors;
1709     QEMUIOVector qiov;
1710     struct iovec iov;
1711 } WriteSameCBData;
1712
1713 static void scsi_write_same_complete(void *opaque, int ret)
1714 {
1715     WriteSameCBData *data = opaque;
1716     SCSIDiskReq *r = data->r;
1717     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
1718
1719     assert(r->req.aiocb != NULL);
1720     r->req.aiocb = NULL;
1721     aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
1722     if (scsi_disk_req_check_error(r, ret, true)) {
1723         goto done;
1724     }
1725
1726     block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
1727
1728     data->nb_sectors -= data->iov.iov_len / 512;
1729     data->sector += data->iov.iov_len / 512;
1730     data->iov.iov_len = MIN(data->nb_sectors * 512, data->iov.iov_len);
1731     if (data->iov.iov_len) {
1732         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct,
1733                          data->iov.iov_len, BLOCK_ACCT_WRITE);
1734         /* Reinitialize qiov, to handle unaligned WRITE SAME request
1735          * where final qiov may need smaller size */
1736         qemu_iovec_init_external(&data->qiov, &data->iov, 1);
1737         r->req.aiocb = blk_aio_pwritev(s->qdev.conf.blk,
1738                                        data->sector << BDRV_SECTOR_BITS,
1739                                        &data->qiov, 0,
1740                                        scsi_write_same_complete, data);
1741         aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
1742         return;
1743     }
1744
1745     scsi_req_complete(&r->req, GOOD);
1746
1747 done:
1748     scsi_req_unref(&r->req);
1749     qemu_vfree(data->iov.iov_base);
1750     g_free(data);
1751     aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
1752 }
1753
1754 static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf)
1755 {
1756     SCSIRequest *req = &r->req;
1757     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1758     uint32_t nb_sectors = scsi_data_cdb_xfer(r->req.cmd.buf);
1759     WriteSameCBData *data;
1760     uint8_t *buf;
1761     int i;
1762
1763     /* Fail if PBDATA=1 or LBDATA=1 or ANCHOR=1.  */
1764     if (nb_sectors == 0 || (req->cmd.buf[1] & 0x16)) {
1765         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
1766         return;
1767     }
1768
1769     if (blk_is_read_only(s->qdev.conf.blk)) {
1770         scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED));
1771         return;
1772     }
1773     if (!check_lba_range(s, r->req.cmd.lba, nb_sectors)) {
1774         scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
1775         return;
1776     }
1777
1778     if ((req->cmd.buf[1] & 0x1) || buffer_is_zero(inbuf, s->qdev.blocksize)) {
1779         int flags = (req->cmd.buf[1] & 0x8) ? BDRV_REQ_MAY_UNMAP : 0;
1780
1781         /* The request is used as the AIO opaque value, so add a ref.  */
1782         scsi_req_ref(&r->req);
1783         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct,
1784                          nb_sectors * s->qdev.blocksize,
1785                         BLOCK_ACCT_WRITE);
1786         r->req.aiocb = blk_aio_pwrite_zeroes(s->qdev.conf.blk,
1787                                 r->req.cmd.lba * s->qdev.blocksize,
1788                                 nb_sectors * s->qdev.blocksize,
1789                                 flags, scsi_aio_complete, r);
1790         return;
1791     }
1792
1793     data = g_new0(WriteSameCBData, 1);
1794     data->r = r;
1795     data->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
1796     data->nb_sectors = nb_sectors * (s->qdev.blocksize / 512);
1797     data->iov.iov_len = MIN(data->nb_sectors * 512, SCSI_WRITE_SAME_MAX);
1798     data->iov.iov_base = buf = blk_blockalign(s->qdev.conf.blk,
1799                                               data->iov.iov_len);
1800     qemu_iovec_init_external(&data->qiov, &data->iov, 1);
1801
1802     for (i = 0; i < data->iov.iov_len; i += s->qdev.blocksize) {
1803         memcpy(&buf[i], inbuf, s->qdev.blocksize);
1804     }
1805
1806     scsi_req_ref(&r->req);
1807     block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct,
1808                      data->iov.iov_len, BLOCK_ACCT_WRITE);
1809     r->req.aiocb = blk_aio_pwritev(s->qdev.conf.blk,
1810                                    data->sector << BDRV_SECTOR_BITS,
1811                                    &data->qiov, 0,
1812                                    scsi_write_same_complete, data);
1813 }
1814
1815 static void scsi_disk_emulate_write_data(SCSIRequest *req)
1816 {
1817     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
1818
1819     if (r->iov.iov_len) {
1820         int buflen = r->iov.iov_len;
1821         trace_scsi_disk_emulate_write_data(buflen);
1822         r->iov.iov_len = 0;
1823         scsi_req_data(&r->req, buflen);
1824         return;
1825     }
1826
1827     switch (req->cmd.buf[0]) {
1828     case MODE_SELECT:
1829     case MODE_SELECT_10:
1830         /* This also clears the sense buffer for REQUEST SENSE.  */
1831         scsi_disk_emulate_mode_select(r, r->iov.iov_base);
1832         break;
1833
1834     case UNMAP:
1835         scsi_disk_emulate_unmap(r, r->iov.iov_base);
1836         break;
1837
1838     case VERIFY_10:
1839     case VERIFY_12:
1840     case VERIFY_16:
1841         if (r->req.status == -1) {
1842             scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
1843         }
1844         break;
1845
1846     case WRITE_SAME_10:
1847     case WRITE_SAME_16:
1848         scsi_disk_emulate_write_same(r, r->iov.iov_base);
1849         break;
1850
1851     default:
1852         abort();
1853     }
1854 }
1855
1856 static int32_t scsi_disk_emulate_command(SCSIRequest *req, uint8_t *buf)
1857 {
1858     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
1859     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
1860     uint64_t nb_sectors;
1861     uint8_t *outbuf;
1862     int buflen;
1863
1864     switch (req->cmd.buf[0]) {
1865     case INQUIRY:
1866     case MODE_SENSE:
1867     case MODE_SENSE_10:
1868     case RESERVE:
1869     case RESERVE_10:
1870     case RELEASE:
1871     case RELEASE_10:
1872     case START_STOP:
1873     case ALLOW_MEDIUM_REMOVAL:
1874     case GET_CONFIGURATION:
1875     case GET_EVENT_STATUS_NOTIFICATION:
1876     case MECHANISM_STATUS:
1877     case REQUEST_SENSE:
1878         break;
1879
1880     default:
1881         if (!blk_is_available(s->qdev.conf.blk)) {
1882             scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
1883             return 0;
1884         }
1885         break;
1886     }
1887
1888     /*
1889      * FIXME: we shouldn't return anything bigger than 4k, but the code
1890      * requires the buffer to be as big as req->cmd.xfer in several
1891      * places.  So, do not allow CDBs with a very large ALLOCATION
1892      * LENGTH.  The real fix would be to modify scsi_read_data and
1893      * dma_buf_read, so that they return data beyond the buflen
1894      * as all zeros.
1895      */
1896     if (req->cmd.xfer > 65536) {
1897         goto illegal_request;
1898     }
1899     r->buflen = MAX(4096, req->cmd.xfer);
1900
1901     if (!r->iov.iov_base) {
1902         r->iov.iov_base = blk_blockalign(s->qdev.conf.blk, r->buflen);
1903     }
1904
1905     buflen = req->cmd.xfer;
1906     outbuf = r->iov.iov_base;
1907     memset(outbuf, 0, r->buflen);
1908     switch (req->cmd.buf[0]) {
1909     case TEST_UNIT_READY:
1910         assert(blk_is_available(s->qdev.conf.blk));
1911         break;
1912     case INQUIRY:
1913         buflen = scsi_disk_emulate_inquiry(req, outbuf);
1914         if (buflen < 0) {
1915             goto illegal_request;
1916         }
1917         break;
1918     case MODE_SENSE:
1919     case MODE_SENSE_10:
1920         buflen = scsi_disk_emulate_mode_sense(r, outbuf);
1921         if (buflen < 0) {
1922             goto illegal_request;
1923         }
1924         break;
1925     case READ_TOC:
1926         buflen = scsi_disk_emulate_read_toc(req, outbuf);
1927         if (buflen < 0) {
1928             goto illegal_request;
1929         }
1930         break;
1931     case RESERVE:
1932         if (req->cmd.buf[1] & 1) {
1933             goto illegal_request;
1934         }
1935         break;
1936     case RESERVE_10:
1937         if (req->cmd.buf[1] & 3) {
1938             goto illegal_request;
1939         }
1940         break;
1941     case RELEASE:
1942         if (req->cmd.buf[1] & 1) {
1943             goto illegal_request;
1944         }
1945         break;
1946     case RELEASE_10:
1947         if (req->cmd.buf[1] & 3) {
1948             goto illegal_request;
1949         }
1950         break;
1951     case START_STOP:
1952         if (scsi_disk_emulate_start_stop(r) < 0) {
1953             return 0;
1954         }
1955         break;
1956     case ALLOW_MEDIUM_REMOVAL:
1957         s->tray_locked = req->cmd.buf[4] & 1;
1958         blk_lock_medium(s->qdev.conf.blk, req->cmd.buf[4] & 1);
1959         break;
1960     case READ_CAPACITY_10:
1961         /* The normal LEN field for this command is zero.  */
1962         memset(outbuf, 0, 8);
1963         blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
1964         if (!nb_sectors) {
1965             scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY));
1966             return 0;
1967         }
1968         if ((req->cmd.buf[8] & 1) == 0 && req->cmd.lba) {
1969             goto illegal_request;
1970         }
1971         nb_sectors /= s->qdev.blocksize / 512;
1972         /* Returned value is the address of the last sector.  */
1973         nb_sectors--;
1974         /* Remember the new size for read/write sanity checking. */
1975         s->qdev.max_lba = nb_sectors;
1976         /* Clip to 2TB, instead of returning capacity modulo 2TB. */
1977         if (nb_sectors > UINT32_MAX) {
1978             nb_sectors = UINT32_MAX;
1979         }
1980         outbuf[0] = (nb_sectors >> 24) & 0xff;
1981         outbuf[1] = (nb_sectors >> 16) & 0xff;
1982         outbuf[2] = (nb_sectors >> 8) & 0xff;
1983         outbuf[3] = nb_sectors & 0xff;
1984         outbuf[4] = 0;
1985         outbuf[5] = 0;
1986         outbuf[6] = s->qdev.blocksize >> 8;
1987         outbuf[7] = 0;
1988         break;
1989     case REQUEST_SENSE:
1990         /* Just return "NO SENSE".  */
1991         buflen = scsi_convert_sense(NULL, 0, outbuf, r->buflen,
1992                                     (req->cmd.buf[1] & 1) == 0);
1993         if (buflen < 0) {
1994             goto illegal_request;
1995         }
1996         break;
1997     case MECHANISM_STATUS:
1998         buflen = scsi_emulate_mechanism_status(s, outbuf);
1999         if (buflen < 0) {
2000             goto illegal_request;
2001         }
2002         break;
2003     case GET_CONFIGURATION:
2004         buflen = scsi_get_configuration(s, outbuf);
2005         if (buflen < 0) {
2006             goto illegal_request;
2007         }
2008         break;
2009     case GET_EVENT_STATUS_NOTIFICATION:
2010         buflen = scsi_get_event_status_notification(s, r, outbuf);
2011         if (buflen < 0) {
2012             goto illegal_request;
2013         }
2014         break;
2015     case READ_DISC_INFORMATION:
2016         buflen = scsi_read_disc_information(s, r, outbuf);
2017         if (buflen < 0) {
2018             goto illegal_request;
2019         }
2020         break;
2021     case READ_DVD_STRUCTURE:
2022         buflen = scsi_read_dvd_structure(s, r, outbuf);
2023         if (buflen < 0) {
2024             goto illegal_request;
2025         }
2026         break;
2027     case SERVICE_ACTION_IN_16:
2028         /* Service Action In subcommands. */
2029         if ((req->cmd.buf[1] & 31) == SAI_READ_CAPACITY_16) {
2030             trace_scsi_disk_emulate_command_SAI_16();
2031             memset(outbuf, 0, req->cmd.xfer);
2032             blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
2033             if (!nb_sectors) {
2034                 scsi_check_condition(r, SENSE_CODE(LUN_NOT_READY));
2035                 return 0;
2036             }
2037             if ((req->cmd.buf[14] & 1) == 0 && req->cmd.lba) {
2038                 goto illegal_request;
2039             }
2040             nb_sectors /= s->qdev.blocksize / 512;
2041             /* Returned value is the address of the last sector.  */
2042             nb_sectors--;
2043             /* Remember the new size for read/write sanity checking. */
2044             s->qdev.max_lba = nb_sectors;
2045             outbuf[0] = (nb_sectors >> 56) & 0xff;
2046             outbuf[1] = (nb_sectors >> 48) & 0xff;
2047             outbuf[2] = (nb_sectors >> 40) & 0xff;
2048             outbuf[3] = (nb_sectors >> 32) & 0xff;
2049             outbuf[4] = (nb_sectors >> 24) & 0xff;
2050             outbuf[5] = (nb_sectors >> 16) & 0xff;
2051             outbuf[6] = (nb_sectors >> 8) & 0xff;
2052             outbuf[7] = nb_sectors & 0xff;
2053             outbuf[8] = 0;
2054             outbuf[9] = 0;
2055             outbuf[10] = s->qdev.blocksize >> 8;
2056             outbuf[11] = 0;
2057             outbuf[12] = 0;
2058             outbuf[13] = get_physical_block_exp(&s->qdev.conf);
2059
2060             /* set TPE bit if the format supports discard */
2061             if (s->qdev.conf.discard_granularity) {
2062                 outbuf[14] = 0x80;
2063             }
2064
2065             /* Protection, exponent and lowest lba field left blank. */
2066             break;
2067         }
2068         trace_scsi_disk_emulate_command_SAI_unsupported();
2069         goto illegal_request;
2070     case SYNCHRONIZE_CACHE:
2071         /* The request is used as the AIO opaque value, so add a ref.  */
2072         scsi_req_ref(&r->req);
2073         block_acct_start(blk_get_stats(s->qdev.conf.blk), &r->acct, 0,
2074                          BLOCK_ACCT_FLUSH);
2075         r->req.aiocb = blk_aio_flush(s->qdev.conf.blk, scsi_aio_complete, r);
2076         return 0;
2077     case SEEK_10:
2078         trace_scsi_disk_emulate_command_SEEK_10(r->req.cmd.lba);
2079         if (r->req.cmd.lba > s->qdev.max_lba) {
2080             goto illegal_lba;
2081         }
2082         break;
2083     case MODE_SELECT:
2084         trace_scsi_disk_emulate_command_MODE_SELECT(r->req.cmd.xfer);
2085         break;
2086     case MODE_SELECT_10:
2087         trace_scsi_disk_emulate_command_MODE_SELECT_10(r->req.cmd.xfer);
2088         break;
2089     case UNMAP:
2090         trace_scsi_disk_emulate_command_UNMAP(r->req.cmd.xfer);
2091         break;
2092     case VERIFY_10:
2093     case VERIFY_12:
2094     case VERIFY_16:
2095         trace_scsi_disk_emulate_command_VERIFY((req->cmd.buf[1] >> 1) & 3);
2096         if (req->cmd.buf[1] & 6) {
2097             goto illegal_request;
2098         }
2099         break;
2100     case WRITE_SAME_10:
2101     case WRITE_SAME_16:
2102         trace_scsi_disk_emulate_command_WRITE_SAME(
2103                 req->cmd.buf[0] == WRITE_SAME_10 ? 10 : 16, r->req.cmd.xfer);
2104         break;
2105     default:
2106         trace_scsi_disk_emulate_command_UNKNOWN(buf[0],
2107                                                 scsi_command_name(buf[0]));
2108         scsi_check_condition(r, SENSE_CODE(INVALID_OPCODE));
2109         return 0;
2110     }
2111     assert(!r->req.aiocb);
2112     r->iov.iov_len = MIN(r->buflen, req->cmd.xfer);
2113     if (r->iov.iov_len == 0) {
2114         scsi_req_complete(&r->req, GOOD);
2115     }
2116     if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
2117         assert(r->iov.iov_len == req->cmd.xfer);
2118         return -r->iov.iov_len;
2119     } else {
2120         return r->iov.iov_len;
2121     }
2122
2123 illegal_request:
2124     if (r->req.status == -1) {
2125         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
2126     }
2127     return 0;
2128
2129 illegal_lba:
2130     scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
2131     return 0;
2132 }
2133
2134 /* Execute a scsi command.  Returns the length of the data expected by the
2135    command.  This will be Positive for data transfers from the device
2136    (eg. disk reads), negative for transfers to the device (eg. disk writes),
2137    and zero if the command does not transfer any data.  */
2138
2139 static int32_t scsi_disk_dma_command(SCSIRequest *req, uint8_t *buf)
2140 {
2141     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
2142     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
2143     SCSIDiskClass *sdc = (SCSIDiskClass *) object_get_class(OBJECT(s));
2144     uint32_t len;
2145     uint8_t command;
2146
2147     command = buf[0];
2148
2149     if (!blk_is_available(s->qdev.conf.blk)) {
2150         scsi_check_condition(r, SENSE_CODE(NO_MEDIUM));
2151         return 0;
2152     }
2153
2154     len = scsi_data_cdb_xfer(r->req.cmd.buf);
2155     switch (command) {
2156     case READ_6:
2157     case READ_10:
2158     case READ_12:
2159     case READ_16:
2160         trace_scsi_disk_dma_command_READ(r->req.cmd.lba, len);
2161         /* Protection information is not supported.  For SCSI versions 2 and
2162          * older (as determined by snooping the guest's INQUIRY commands),
2163          * there is no RD/WR/VRPROTECT, so skip this check in these versions.
2164          */
2165         if (s->qdev.scsi_version > 2 && (r->req.cmd.buf[1] & 0xe0)) {
2166             goto illegal_request;
2167         }
2168         if (!check_lba_range(s, r->req.cmd.lba, len)) {
2169             goto illegal_lba;
2170         }
2171         r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
2172         r->sector_count = len * (s->qdev.blocksize / 512);
2173         break;
2174     case WRITE_6:
2175     case WRITE_10:
2176     case WRITE_12:
2177     case WRITE_16:
2178     case WRITE_VERIFY_10:
2179     case WRITE_VERIFY_12:
2180     case WRITE_VERIFY_16:
2181         if (blk_is_read_only(s->qdev.conf.blk)) {
2182             scsi_check_condition(r, SENSE_CODE(WRITE_PROTECTED));
2183             return 0;
2184         }
2185         trace_scsi_disk_dma_command_WRITE(
2186                 (command & 0xe) == 0xe ? "And Verify " : "",
2187                 r->req.cmd.lba, len);
2188         /* fall through */
2189     case VERIFY_10:
2190     case VERIFY_12:
2191     case VERIFY_16:
2192         /* We get here only for BYTCHK == 0x01 and only for scsi-block.
2193          * As far as DMA is concerned, we can treat it the same as a write;
2194          * scsi_block_do_sgio will send VERIFY commands.
2195          */
2196         if (s->qdev.scsi_version > 2 && (r->req.cmd.buf[1] & 0xe0)) {
2197             goto illegal_request;
2198         }
2199         if (!check_lba_range(s, r->req.cmd.lba, len)) {
2200             goto illegal_lba;
2201         }
2202         r->sector = r->req.cmd.lba * (s->qdev.blocksize / 512);
2203         r->sector_count = len * (s->qdev.blocksize / 512);
2204         break;
2205     default:
2206         abort();
2207     illegal_request:
2208         scsi_check_condition(r, SENSE_CODE(INVALID_FIELD));
2209         return 0;
2210     illegal_lba:
2211         scsi_check_condition(r, SENSE_CODE(LBA_OUT_OF_RANGE));
2212         return 0;
2213     }
2214     r->need_fua_emulation = sdc->need_fua_emulation(&r->req.cmd);
2215     if (r->sector_count == 0) {
2216         scsi_req_complete(&r->req, GOOD);
2217     }
2218     assert(r->iov.iov_len == 0);
2219     if (r->req.cmd.mode == SCSI_XFER_TO_DEV) {
2220         return -r->sector_count * 512;
2221     } else {
2222         return r->sector_count * 512;
2223     }
2224 }
2225
2226 static void scsi_disk_reset(DeviceState *dev)
2227 {
2228     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev.qdev, dev);
2229     uint64_t nb_sectors;
2230
2231     scsi_device_purge_requests(&s->qdev, SENSE_CODE(RESET));
2232
2233     blk_get_geometry(s->qdev.conf.blk, &nb_sectors);
2234     nb_sectors /= s->qdev.blocksize / 512;
2235     if (nb_sectors) {
2236         nb_sectors--;
2237     }
2238     s->qdev.max_lba = nb_sectors;
2239     /* reset tray statuses */
2240     s->tray_locked = 0;
2241     s->tray_open = 0;
2242
2243     s->qdev.scsi_version = s->qdev.default_scsi_version;
2244 }
2245
2246 static void scsi_disk_resize_cb(void *opaque)
2247 {
2248     SCSIDiskState *s = opaque;
2249
2250     /* SPC lists this sense code as available only for
2251      * direct-access devices.
2252      */
2253     if (s->qdev.type == TYPE_DISK) {
2254         scsi_device_report_change(&s->qdev, SENSE_CODE(CAPACITY_CHANGED));
2255     }
2256 }
2257
2258 static void scsi_cd_change_media_cb(void *opaque, bool load, Error **errp)
2259 {
2260     SCSIDiskState *s = opaque;
2261
2262     /*
2263      * When a CD gets changed, we have to report an ejected state and
2264      * then a loaded state to guests so that they detect tray
2265      * open/close and media change events.  Guests that do not use
2266      * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close
2267      * states rely on this behavior.
2268      *
2269      * media_changed governs the state machine used for unit attention
2270      * report.  media_event is used by GET EVENT STATUS NOTIFICATION.
2271      */
2272     s->media_changed = load;
2273     s->tray_open = !load;
2274     scsi_device_set_ua(&s->qdev, SENSE_CODE(UNIT_ATTENTION_NO_MEDIUM));
2275     s->media_event = true;
2276     s->eject_request = false;
2277 }
2278
2279 static void scsi_cd_eject_request_cb(void *opaque, bool force)
2280 {
2281     SCSIDiskState *s = opaque;
2282
2283     s->eject_request = true;
2284     if (force) {
2285         s->tray_locked = false;
2286     }
2287 }
2288
2289 static bool scsi_cd_is_tray_open(void *opaque)
2290 {
2291     return ((SCSIDiskState *)opaque)->tray_open;
2292 }
2293
2294 static bool scsi_cd_is_medium_locked(void *opaque)
2295 {
2296     return ((SCSIDiskState *)opaque)->tray_locked;
2297 }
2298
2299 static const BlockDevOps scsi_disk_removable_block_ops = {
2300     .change_media_cb = scsi_cd_change_media_cb,
2301     .eject_request_cb = scsi_cd_eject_request_cb,
2302     .is_tray_open = scsi_cd_is_tray_open,
2303     .is_medium_locked = scsi_cd_is_medium_locked,
2304
2305     .resize_cb = scsi_disk_resize_cb,
2306 };
2307
2308 static const BlockDevOps scsi_disk_block_ops = {
2309     .resize_cb = scsi_disk_resize_cb,
2310 };
2311
2312 static void scsi_disk_unit_attention_reported(SCSIDevice *dev)
2313 {
2314     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
2315     if (s->media_changed) {
2316         s->media_changed = false;
2317         scsi_device_set_ua(&s->qdev, SENSE_CODE(MEDIUM_CHANGED));
2318     }
2319 }
2320
2321 static void scsi_realize(SCSIDevice *dev, Error **errp)
2322 {
2323     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
2324     bool read_only;
2325
2326     if (!s->qdev.conf.blk) {
2327         error_setg(errp, "drive property not set");
2328         return;
2329     }
2330
2331     if (!(s->features & (1 << SCSI_DISK_F_REMOVABLE)) &&
2332         !blk_is_inserted(s->qdev.conf.blk)) {
2333         error_setg(errp, "Device needs media, but drive is empty");
2334         return;
2335     }
2336
2337     blkconf_blocksizes(&s->qdev.conf);
2338
2339     if (s->qdev.conf.logical_block_size >
2340         s->qdev.conf.physical_block_size) {
2341         error_setg(errp,
2342                    "logical_block_size > physical_block_size not supported");
2343         return;
2344     }
2345
2346     if (blk_get_aio_context(s->qdev.conf.blk) != qemu_get_aio_context() &&
2347         !s->qdev.hba_supports_iothread)
2348     {
2349         error_setg(errp, "HBA does not support iothreads");
2350         return;
2351     }
2352
2353     if (dev->type == TYPE_DISK) {
2354         if (!blkconf_geometry(&dev->conf, NULL, 65535, 255, 255, errp)) {
2355             return;
2356         }
2357     }
2358
2359     read_only = blk_is_read_only(s->qdev.conf.blk);
2360     if (dev->type == TYPE_ROM) {
2361         read_only = true;
2362     }
2363
2364     if (!blkconf_apply_backend_options(&dev->conf, read_only,
2365                                        dev->type == TYPE_DISK, errp)) {
2366         return;
2367     }
2368
2369     if (s->qdev.conf.discard_granularity == -1) {
2370         s->qdev.conf.discard_granularity =
2371             MAX(s->qdev.conf.logical_block_size, DEFAULT_DISCARD_GRANULARITY);
2372     }
2373
2374     if (!s->version) {
2375         s->version = g_strdup(qemu_hw_version());
2376     }
2377     if (!s->vendor) {
2378         s->vendor = g_strdup("QEMU");
2379     }
2380     if (!s->device_id) {
2381         if (s->serial) {
2382             s->device_id = g_strdup_printf("%.20s", s->serial);
2383         } else {
2384             const char *str = blk_name(s->qdev.conf.blk);
2385             if (str && *str) {
2386                 s->device_id = g_strdup(str);
2387             }
2388         }
2389     }
2390
2391     if (blk_is_sg(s->qdev.conf.blk)) {
2392         error_setg(errp, "unwanted /dev/sg*");
2393         return;
2394     }
2395
2396     if ((s->features & (1 << SCSI_DISK_F_REMOVABLE)) &&
2397             !(s->features & (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS))) {
2398         blk_set_dev_ops(s->qdev.conf.blk, &scsi_disk_removable_block_ops, s);
2399     } else {
2400         blk_set_dev_ops(s->qdev.conf.blk, &scsi_disk_block_ops, s);
2401     }
2402     blk_set_guest_block_size(s->qdev.conf.blk, s->qdev.blocksize);
2403
2404     blk_iostatus_enable(s->qdev.conf.blk);
2405 }
2406
2407 static void scsi_hd_realize(SCSIDevice *dev, Error **errp)
2408 {
2409     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
2410     AioContext *ctx = NULL;
2411     /* can happen for devices without drive. The error message for missing
2412      * backend will be issued in scsi_realize
2413      */
2414     if (s->qdev.conf.blk) {
2415         ctx = blk_get_aio_context(s->qdev.conf.blk);
2416         aio_context_acquire(ctx);
2417         blkconf_blocksizes(&s->qdev.conf);
2418     }
2419     s->qdev.blocksize = s->qdev.conf.logical_block_size;
2420     s->qdev.type = TYPE_DISK;
2421     if (!s->product) {
2422         s->product = g_strdup("QEMU HARDDISK");
2423     }
2424     scsi_realize(&s->qdev, errp);
2425     if (ctx) {
2426         aio_context_release(ctx);
2427     }
2428 }
2429
2430 static void scsi_cd_realize(SCSIDevice *dev, Error **errp)
2431 {
2432     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
2433     AioContext *ctx;
2434     int ret;
2435
2436     if (!dev->conf.blk) {
2437         /* Anonymous BlockBackend for an empty drive. As we put it into
2438          * dev->conf, qdev takes care of detaching on unplug. */
2439         dev->conf.blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
2440         ret = blk_attach_dev(dev->conf.blk, &dev->qdev);
2441         assert(ret == 0);
2442     }
2443
2444     ctx = blk_get_aio_context(dev->conf.blk);
2445     aio_context_acquire(ctx);
2446     s->qdev.blocksize = 2048;
2447     s->qdev.type = TYPE_ROM;
2448     s->features |= 1 << SCSI_DISK_F_REMOVABLE;
2449     if (!s->product) {
2450         s->product = g_strdup("QEMU CD-ROM");
2451     }
2452     scsi_realize(&s->qdev, errp);
2453     aio_context_release(ctx);
2454 }
2455
2456 static void scsi_disk_realize(SCSIDevice *dev, Error **errp)
2457 {
2458     DriveInfo *dinfo;
2459     Error *local_err = NULL;
2460
2461     if (!dev->conf.blk) {
2462         scsi_realize(dev, &local_err);
2463         assert(local_err);
2464         error_propagate(errp, local_err);
2465         return;
2466     }
2467
2468     dinfo = blk_legacy_dinfo(dev->conf.blk);
2469     if (dinfo && dinfo->media_cd) {
2470         scsi_cd_realize(dev, errp);
2471     } else {
2472         scsi_hd_realize(dev, errp);
2473     }
2474 }
2475
2476 static const SCSIReqOps scsi_disk_emulate_reqops = {
2477     .size         = sizeof(SCSIDiskReq),
2478     .free_req     = scsi_free_request,
2479     .send_command = scsi_disk_emulate_command,
2480     .read_data    = scsi_disk_emulate_read_data,
2481     .write_data   = scsi_disk_emulate_write_data,
2482     .get_buf      = scsi_get_buf,
2483 };
2484
2485 static const SCSIReqOps scsi_disk_dma_reqops = {
2486     .size         = sizeof(SCSIDiskReq),
2487     .free_req     = scsi_free_request,
2488     .send_command = scsi_disk_dma_command,
2489     .read_data    = scsi_read_data,
2490     .write_data   = scsi_write_data,
2491     .get_buf      = scsi_get_buf,
2492     .load_request = scsi_disk_load_request,
2493     .save_request = scsi_disk_save_request,
2494 };
2495
2496 static const SCSIReqOps *const scsi_disk_reqops_dispatch[256] = {
2497     [TEST_UNIT_READY]                 = &scsi_disk_emulate_reqops,
2498     [INQUIRY]                         = &scsi_disk_emulate_reqops,
2499     [MODE_SENSE]                      = &scsi_disk_emulate_reqops,
2500     [MODE_SENSE_10]                   = &scsi_disk_emulate_reqops,
2501     [START_STOP]                      = &scsi_disk_emulate_reqops,
2502     [ALLOW_MEDIUM_REMOVAL]            = &scsi_disk_emulate_reqops,
2503     [READ_CAPACITY_10]                = &scsi_disk_emulate_reqops,
2504     [READ_TOC]                        = &scsi_disk_emulate_reqops,
2505     [READ_DVD_STRUCTURE]              = &scsi_disk_emulate_reqops,
2506     [READ_DISC_INFORMATION]           = &scsi_disk_emulate_reqops,
2507     [GET_CONFIGURATION]               = &scsi_disk_emulate_reqops,
2508     [GET_EVENT_STATUS_NOTIFICATION]   = &scsi_disk_emulate_reqops,
2509     [MECHANISM_STATUS]                = &scsi_disk_emulate_reqops,
2510     [SERVICE_ACTION_IN_16]            = &scsi_disk_emulate_reqops,
2511     [REQUEST_SENSE]                   = &scsi_disk_emulate_reqops,
2512     [SYNCHRONIZE_CACHE]               = &scsi_disk_emulate_reqops,
2513     [SEEK_10]                         = &scsi_disk_emulate_reqops,
2514     [MODE_SELECT]                     = &scsi_disk_emulate_reqops,
2515     [MODE_SELECT_10]                  = &scsi_disk_emulate_reqops,
2516     [UNMAP]                           = &scsi_disk_emulate_reqops,
2517     [WRITE_SAME_10]                   = &scsi_disk_emulate_reqops,
2518     [WRITE_SAME_16]                   = &scsi_disk_emulate_reqops,
2519     [VERIFY_10]                       = &scsi_disk_emulate_reqops,
2520     [VERIFY_12]                       = &scsi_disk_emulate_reqops,
2521     [VERIFY_16]                       = &scsi_disk_emulate_reqops,
2522
2523     [READ_6]                          = &scsi_disk_dma_reqops,
2524     [READ_10]                         = &scsi_disk_dma_reqops,
2525     [READ_12]                         = &scsi_disk_dma_reqops,
2526     [READ_16]                         = &scsi_disk_dma_reqops,
2527     [WRITE_6]                         = &scsi_disk_dma_reqops,
2528     [WRITE_10]                        = &scsi_disk_dma_reqops,
2529     [WRITE_12]                        = &scsi_disk_dma_reqops,
2530     [WRITE_16]                        = &scsi_disk_dma_reqops,
2531     [WRITE_VERIFY_10]                 = &scsi_disk_dma_reqops,
2532     [WRITE_VERIFY_12]                 = &scsi_disk_dma_reqops,
2533     [WRITE_VERIFY_16]                 = &scsi_disk_dma_reqops,
2534 };
2535
2536 static void scsi_disk_new_request_dump(uint32_t lun, uint32_t tag, uint8_t *buf)
2537 {
2538     int i;
2539     int len = scsi_cdb_length(buf);
2540     char *line_buffer, *p;
2541
2542     line_buffer = g_malloc(len * 5 + 1);
2543
2544     for (i = 0, p = line_buffer; i < len; i++) {
2545         p += sprintf(p, " 0x%02x", buf[i]);
2546     }
2547     trace_scsi_disk_new_request(lun, tag, line_buffer);
2548
2549     g_free(line_buffer);
2550 }
2551
2552 static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun,
2553                                      uint8_t *buf, void *hba_private)
2554 {
2555     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
2556     SCSIRequest *req;
2557     const SCSIReqOps *ops;
2558     uint8_t command;
2559
2560     command = buf[0];
2561     ops = scsi_disk_reqops_dispatch[command];
2562     if (!ops) {
2563         ops = &scsi_disk_emulate_reqops;
2564     }
2565     req = scsi_req_alloc(ops, &s->qdev, tag, lun, hba_private);
2566
2567     if (trace_event_get_state_backends(TRACE_SCSI_DISK_NEW_REQUEST)) {
2568         scsi_disk_new_request_dump(lun, tag, buf);
2569     }
2570
2571     return req;
2572 }
2573
2574 #ifdef __linux__
2575 static int get_device_type(SCSIDiskState *s)
2576 {
2577     uint8_t cmd[16];
2578     uint8_t buf[36];
2579     int ret;
2580
2581     memset(cmd, 0, sizeof(cmd));
2582     memset(buf, 0, sizeof(buf));
2583     cmd[0] = INQUIRY;
2584     cmd[4] = sizeof(buf);
2585
2586     ret = scsi_SG_IO_FROM_DEV(s->qdev.conf.blk, cmd, sizeof(cmd),
2587                               buf, sizeof(buf));
2588     if (ret < 0) {
2589         return -1;
2590     }
2591     s->qdev.type = buf[0];
2592     if (buf[1] & 0x80) {
2593         s->features |= 1 << SCSI_DISK_F_REMOVABLE;
2594     }
2595     return 0;
2596 }
2597
2598 static void scsi_block_realize(SCSIDevice *dev, Error **errp)
2599 {
2600     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
2601     AioContext *ctx;
2602     int sg_version;
2603     int rc;
2604
2605     if (!s->qdev.conf.blk) {
2606         error_setg(errp, "drive property not set");
2607         return;
2608     }
2609
2610     if (s->rotation_rate) {
2611         error_report_once("rotation_rate is specified for scsi-block but is "
2612                           "not implemented. This option is deprecated and will "
2613                           "be removed in a future version");
2614     }
2615
2616     ctx = blk_get_aio_context(s->qdev.conf.blk);
2617     aio_context_acquire(ctx);
2618
2619     /* check we are using a driver managing SG_IO (version 3 and after) */
2620     rc = blk_ioctl(s->qdev.conf.blk, SG_GET_VERSION_NUM, &sg_version);
2621     if (rc < 0) {
2622         error_setg_errno(errp, -rc, "cannot get SG_IO version number");
2623         if (rc != -EPERM) {
2624             error_append_hint(errp, "Is this a SCSI device?\n");
2625         }
2626         goto out;
2627     }
2628     if (sg_version < 30000) {
2629         error_setg(errp, "scsi generic interface too old");
2630         goto out;
2631     }
2632
2633     /* get device type from INQUIRY data */
2634     rc = get_device_type(s);
2635     if (rc < 0) {
2636         error_setg(errp, "INQUIRY failed");
2637         goto out;
2638     }
2639
2640     /* Make a guess for the block size, we'll fix it when the guest sends.
2641      * READ CAPACITY.  If they don't, they likely would assume these sizes
2642      * anyway. (TODO: check in /sys).
2643      */
2644     if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM) {
2645         s->qdev.blocksize = 2048;
2646     } else {
2647         s->qdev.blocksize = 512;
2648     }
2649
2650     /* Makes the scsi-block device not removable by using HMP and QMP eject
2651      * command.
2652      */
2653     s->features |= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS);
2654
2655     scsi_realize(&s->qdev, errp);
2656     scsi_generic_read_device_inquiry(&s->qdev);
2657
2658 out:
2659     aio_context_release(ctx);
2660 }
2661
2662 typedef struct SCSIBlockReq {
2663     SCSIDiskReq req;
2664     sg_io_hdr_t io_header;
2665
2666     /* Selected bytes of the original CDB, copied into our own CDB.  */
2667     uint8_t cmd, cdb1, group_number;
2668
2669     /* CDB passed to SG_IO.  */
2670     uint8_t cdb[16];
2671 } SCSIBlockReq;
2672
2673 static BlockAIOCB *scsi_block_do_sgio(SCSIBlockReq *req,
2674                                       int64_t offset, QEMUIOVector *iov,
2675                                       int direction,
2676                                       BlockCompletionFunc *cb, void *opaque)
2677 {
2678     sg_io_hdr_t *io_header = &req->io_header;
2679     SCSIDiskReq *r = &req->req;
2680     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
2681     int nb_logical_blocks;
2682     uint64_t lba;
2683     BlockAIOCB *aiocb;
2684
2685     /* This is not supported yet.  It can only happen if the guest does
2686      * reads and writes that are not aligned to one logical sectors
2687      * _and_ cover multiple MemoryRegions.
2688      */
2689     assert(offset % s->qdev.blocksize == 0);
2690     assert(iov->size % s->qdev.blocksize == 0);
2691
2692     io_header->interface_id = 'S';
2693
2694     /* The data transfer comes from the QEMUIOVector.  */
2695     io_header->dxfer_direction = direction;
2696     io_header->dxfer_len = iov->size;
2697     io_header->dxferp = (void *)iov->iov;
2698     io_header->iovec_count = iov->niov;
2699     assert(io_header->iovec_count == iov->niov); /* no overflow! */
2700
2701     /* Build a new CDB with the LBA and length patched in, in case
2702      * DMA helpers split the transfer in multiple segments.  Do not
2703      * build a CDB smaller than what the guest wanted, and only build
2704      * a larger one if strictly necessary.
2705      */
2706     io_header->cmdp = req->cdb;
2707     lba = offset / s->qdev.blocksize;
2708     nb_logical_blocks = io_header->dxfer_len / s->qdev.blocksize;
2709
2710     if ((req->cmd >> 5) == 0 && lba <= 0x1ffff) {
2711         /* 6-byte CDB */
2712         stl_be_p(&req->cdb[0], lba | (req->cmd << 24));
2713         req->cdb[4] = nb_logical_blocks;
2714         req->cdb[5] = 0;
2715         io_header->cmd_len = 6;
2716     } else if ((req->cmd >> 5) <= 1 && lba <= 0xffffffffULL) {
2717         /* 10-byte CDB */
2718         req->cdb[0] = (req->cmd & 0x1f) | 0x20;
2719         req->cdb[1] = req->cdb1;
2720         stl_be_p(&req->cdb[2], lba);
2721         req->cdb[6] = req->group_number;
2722         stw_be_p(&req->cdb[7], nb_logical_blocks);
2723         req->cdb[9] = 0;
2724         io_header->cmd_len = 10;
2725     } else if ((req->cmd >> 5) != 4 && lba <= 0xffffffffULL) {
2726         /* 12-byte CDB */
2727         req->cdb[0] = (req->cmd & 0x1f) | 0xA0;
2728         req->cdb[1] = req->cdb1;
2729         stl_be_p(&req->cdb[2], lba);
2730         stl_be_p(&req->cdb[6], nb_logical_blocks);
2731         req->cdb[10] = req->group_number;
2732         req->cdb[11] = 0;
2733         io_header->cmd_len = 12;
2734     } else {
2735         /* 16-byte CDB */
2736         req->cdb[0] = (req->cmd & 0x1f) | 0x80;
2737         req->cdb[1] = req->cdb1;
2738         stq_be_p(&req->cdb[2], lba);
2739         stl_be_p(&req->cdb[10], nb_logical_blocks);
2740         req->cdb[14] = req->group_number;
2741         req->cdb[15] = 0;
2742         io_header->cmd_len = 16;
2743     }
2744
2745     /* The rest is as in scsi-generic.c.  */
2746     io_header->mx_sb_len = sizeof(r->req.sense);
2747     io_header->sbp = r->req.sense;
2748     io_header->timeout = UINT_MAX;
2749     io_header->usr_ptr = r;
2750     io_header->flags |= SG_FLAG_DIRECT_IO;
2751
2752     aiocb = blk_aio_ioctl(s->qdev.conf.blk, SG_IO, io_header, cb, opaque);
2753     assert(aiocb != NULL);
2754     return aiocb;
2755 }
2756
2757 static bool scsi_block_no_fua(SCSICommand *cmd)
2758 {
2759     return false;
2760 }
2761
2762 static BlockAIOCB *scsi_block_dma_readv(int64_t offset,
2763                                         QEMUIOVector *iov,
2764                                         BlockCompletionFunc *cb, void *cb_opaque,
2765                                         void *opaque)
2766 {
2767     SCSIBlockReq *r = opaque;
2768     return scsi_block_do_sgio(r, offset, iov,
2769                               SG_DXFER_FROM_DEV, cb, cb_opaque);
2770 }
2771
2772 static BlockAIOCB *scsi_block_dma_writev(int64_t offset,
2773                                          QEMUIOVector *iov,
2774                                          BlockCompletionFunc *cb, void *cb_opaque,
2775                                          void *opaque)
2776 {
2777     SCSIBlockReq *r = opaque;
2778     return scsi_block_do_sgio(r, offset, iov,
2779                               SG_DXFER_TO_DEV, cb, cb_opaque);
2780 }
2781
2782 static bool scsi_block_is_passthrough(SCSIDiskState *s, uint8_t *buf)
2783 {
2784     switch (buf[0]) {
2785     case VERIFY_10:
2786     case VERIFY_12:
2787     case VERIFY_16:
2788         /* Check if BYTCHK == 0x01 (data-out buffer contains data
2789          * for the number of logical blocks specified in the length
2790          * field).  For other modes, do not use scatter/gather operation.
2791          */
2792         if ((buf[1] & 6) == 2) {
2793             return false;
2794         }
2795         break;
2796
2797     case READ_6:
2798     case READ_10:
2799     case READ_12:
2800     case READ_16:
2801     case WRITE_6:
2802     case WRITE_10:
2803     case WRITE_12:
2804     case WRITE_16:
2805     case WRITE_VERIFY_10:
2806     case WRITE_VERIFY_12:
2807     case WRITE_VERIFY_16:
2808         /* MMC writing cannot be done via DMA helpers, because it sometimes
2809          * involves writing beyond the maximum LBA or to negative LBA (lead-in).
2810          * We might use scsi_block_dma_reqops as long as no writing commands are
2811          * seen, but performance usually isn't paramount on optical media.  So,
2812          * just make scsi-block operate the same as scsi-generic for them.
2813          */
2814         if (s->qdev.type != TYPE_ROM) {
2815             return false;
2816         }
2817         break;
2818
2819     default:
2820         break;
2821     }
2822
2823     return true;
2824 }
2825
2826
2827 static int32_t scsi_block_dma_command(SCSIRequest *req, uint8_t *buf)
2828 {
2829     SCSIBlockReq *r = (SCSIBlockReq *)req;
2830     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
2831
2832     r->cmd = req->cmd.buf[0];
2833     switch (r->cmd >> 5) {
2834     case 0:
2835         /* 6-byte CDB.  */
2836         r->cdb1 = r->group_number = 0;
2837         break;
2838     case 1:
2839         /* 10-byte CDB.  */
2840         r->cdb1 = req->cmd.buf[1];
2841         r->group_number = req->cmd.buf[6];
2842         break;
2843     case 4:
2844         /* 12-byte CDB.  */
2845         r->cdb1 = req->cmd.buf[1];
2846         r->group_number = req->cmd.buf[10];
2847         break;
2848     case 5:
2849         /* 16-byte CDB.  */
2850         r->cdb1 = req->cmd.buf[1];
2851         r->group_number = req->cmd.buf[14];
2852         break;
2853     default:
2854         abort();
2855     }
2856
2857     /* Protection information is not supported.  For SCSI versions 2 and
2858      * older (as determined by snooping the guest's INQUIRY commands),
2859      * there is no RD/WR/VRPROTECT, so skip this check in these versions.
2860      */
2861     if (s->qdev.scsi_version > 2 && (req->cmd.buf[1] & 0xe0)) {
2862         scsi_check_condition(&r->req, SENSE_CODE(INVALID_FIELD));
2863         return 0;
2864     }
2865
2866     r->req.status = &r->io_header.status;
2867     return scsi_disk_dma_command(req, buf);
2868 }
2869
2870 static const SCSIReqOps scsi_block_dma_reqops = {
2871     .size         = sizeof(SCSIBlockReq),
2872     .free_req     = scsi_free_request,
2873     .send_command = scsi_block_dma_command,
2874     .read_data    = scsi_read_data,
2875     .write_data   = scsi_write_data,
2876     .get_buf      = scsi_get_buf,
2877     .load_request = scsi_disk_load_request,
2878     .save_request = scsi_disk_save_request,
2879 };
2880
2881 static SCSIRequest *scsi_block_new_request(SCSIDevice *d, uint32_t tag,
2882                                            uint32_t lun, uint8_t *buf,
2883                                            void *hba_private)
2884 {
2885     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
2886
2887     if (scsi_block_is_passthrough(s, buf)) {
2888         return scsi_req_alloc(&scsi_generic_req_ops, &s->qdev, tag, lun,
2889                               hba_private);
2890     } else {
2891         return scsi_req_alloc(&scsi_block_dma_reqops, &s->qdev, tag, lun,
2892                               hba_private);
2893     }
2894 }
2895
2896 static int scsi_block_parse_cdb(SCSIDevice *d, SCSICommand *cmd,
2897                                   uint8_t *buf, void *hba_private)
2898 {
2899     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
2900
2901     if (scsi_block_is_passthrough(s, buf)) {
2902         return scsi_bus_parse_cdb(&s->qdev, cmd, buf, hba_private);
2903     } else {
2904         return scsi_req_parse_cdb(&s->qdev, cmd, buf);
2905     }
2906 }
2907
2908 static void scsi_block_update_sense(SCSIRequest *req)
2909 {
2910     SCSIDiskReq *r = DO_UPCAST(SCSIDiskReq, req, req);
2911     SCSIBlockReq *br = DO_UPCAST(SCSIBlockReq, req, r);
2912     r->req.sense_len = MIN(br->io_header.sb_len_wr, sizeof(r->req.sense));
2913 }
2914 #endif
2915
2916 static
2917 BlockAIOCB *scsi_dma_readv(int64_t offset, QEMUIOVector *iov,
2918                            BlockCompletionFunc *cb, void *cb_opaque,
2919                            void *opaque)
2920 {
2921     SCSIDiskReq *r = opaque;
2922     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
2923     return blk_aio_preadv(s->qdev.conf.blk, offset, iov, 0, cb, cb_opaque);
2924 }
2925
2926 static
2927 BlockAIOCB *scsi_dma_writev(int64_t offset, QEMUIOVector *iov,
2928                             BlockCompletionFunc *cb, void *cb_opaque,
2929                             void *opaque)
2930 {
2931     SCSIDiskReq *r = opaque;
2932     SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
2933     return blk_aio_pwritev(s->qdev.conf.blk, offset, iov, 0, cb, cb_opaque);
2934 }
2935
2936 static void scsi_disk_base_class_initfn(ObjectClass *klass, void *data)
2937 {
2938     DeviceClass *dc = DEVICE_CLASS(klass);
2939     SCSIDiskClass *sdc = SCSI_DISK_BASE_CLASS(klass);
2940
2941     dc->fw_name = "disk";
2942     dc->reset = scsi_disk_reset;
2943     sdc->dma_readv = scsi_dma_readv;
2944     sdc->dma_writev = scsi_dma_writev;
2945     sdc->need_fua_emulation = scsi_is_cmd_fua;
2946 }
2947
2948 static const TypeInfo scsi_disk_base_info = {
2949     .name          = TYPE_SCSI_DISK_BASE,
2950     .parent        = TYPE_SCSI_DEVICE,
2951     .class_init    = scsi_disk_base_class_initfn,
2952     .instance_size = sizeof(SCSIDiskState),
2953     .class_size    = sizeof(SCSIDiskClass),
2954     .abstract      = true,
2955 };
2956
2957 #define DEFINE_SCSI_DISK_PROPERTIES()                                   \
2958     DEFINE_PROP_DRIVE_IOTHREAD("drive", SCSIDiskState, qdev.conf.blk),  \
2959     DEFINE_BLOCK_PROPERTIES_BASE(SCSIDiskState, qdev.conf),             \
2960     DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf),            \
2961     DEFINE_PROP_STRING("ver", SCSIDiskState, version),                  \
2962     DEFINE_PROP_STRING("serial", SCSIDiskState, serial),                \
2963     DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor),                \
2964     DEFINE_PROP_STRING("product", SCSIDiskState, product),              \
2965     DEFINE_PROP_STRING("device_id", SCSIDiskState, device_id)
2966
2967
2968 static Property scsi_hd_properties[] = {
2969     DEFINE_SCSI_DISK_PROPERTIES(),
2970     DEFINE_PROP_BIT("removable", SCSIDiskState, features,
2971                     SCSI_DISK_F_REMOVABLE, false),
2972     DEFINE_PROP_BIT("dpofua", SCSIDiskState, features,
2973                     SCSI_DISK_F_DPOFUA, false),
2974     DEFINE_PROP_UINT64("wwn", SCSIDiskState, qdev.wwn, 0),
2975     DEFINE_PROP_UINT64("port_wwn", SCSIDiskState, qdev.port_wwn, 0),
2976     DEFINE_PROP_UINT16("port_index", SCSIDiskState, port_index, 0),
2977     DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState, max_unmap_size,
2978                        DEFAULT_MAX_UNMAP_SIZE),
2979     DEFINE_PROP_UINT64("max_io_size", SCSIDiskState, max_io_size,
2980                        DEFAULT_MAX_IO_SIZE),
2981     DEFINE_PROP_UINT16("rotation_rate", SCSIDiskState, rotation_rate, 0),
2982     DEFINE_PROP_INT32("scsi_version", SCSIDiskState, qdev.default_scsi_version,
2983                       5),
2984     DEFINE_BLOCK_CHS_PROPERTIES(SCSIDiskState, qdev.conf),
2985     DEFINE_PROP_END_OF_LIST(),
2986 };
2987
2988 static const VMStateDescription vmstate_scsi_disk_state = {
2989     .name = "scsi-disk",
2990     .version_id = 1,
2991     .minimum_version_id = 1,
2992     .fields = (VMStateField[]) {
2993         VMSTATE_SCSI_DEVICE(qdev, SCSIDiskState),
2994         VMSTATE_BOOL(media_changed, SCSIDiskState),
2995         VMSTATE_BOOL(media_event, SCSIDiskState),
2996         VMSTATE_BOOL(eject_request, SCSIDiskState),
2997         VMSTATE_BOOL(tray_open, SCSIDiskState),
2998         VMSTATE_BOOL(tray_locked, SCSIDiskState),
2999         VMSTATE_END_OF_LIST()
3000     }
3001 };
3002
3003 static void scsi_hd_class_initfn(ObjectClass *klass, void *data)
3004 {
3005     DeviceClass *dc = DEVICE_CLASS(klass);
3006     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
3007
3008     sc->realize      = scsi_hd_realize;
3009     sc->alloc_req    = scsi_new_request;
3010     sc->unit_attention_reported = scsi_disk_unit_attention_reported;
3011     dc->desc = "virtual SCSI disk";
3012     dc->props = scsi_hd_properties;
3013     dc->vmsd  = &vmstate_scsi_disk_state;
3014 }
3015
3016 static const TypeInfo scsi_hd_info = {
3017     .name          = "scsi-hd",
3018     .parent        = TYPE_SCSI_DISK_BASE,
3019     .class_init    = scsi_hd_class_initfn,
3020 };
3021
3022 static Property scsi_cd_properties[] = {
3023     DEFINE_SCSI_DISK_PROPERTIES(),
3024     DEFINE_PROP_UINT64("wwn", SCSIDiskState, qdev.wwn, 0),
3025     DEFINE_PROP_UINT64("port_wwn", SCSIDiskState, qdev.port_wwn, 0),
3026     DEFINE_PROP_UINT16("port_index", SCSIDiskState, port_index, 0),
3027     DEFINE_PROP_UINT64("max_io_size", SCSIDiskState, max_io_size,
3028                        DEFAULT_MAX_IO_SIZE),
3029     DEFINE_PROP_INT32("scsi_version", SCSIDiskState, qdev.default_scsi_version,
3030                       5),
3031     DEFINE_PROP_END_OF_LIST(),
3032 };
3033
3034 static void scsi_cd_class_initfn(ObjectClass *klass, void *data)
3035 {
3036     DeviceClass *dc = DEVICE_CLASS(klass);
3037     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
3038
3039     sc->realize      = scsi_cd_realize;
3040     sc->alloc_req    = scsi_new_request;
3041     sc->unit_attention_reported = scsi_disk_unit_attention_reported;
3042     dc->desc = "virtual SCSI CD-ROM";
3043     dc->props = scsi_cd_properties;
3044     dc->vmsd  = &vmstate_scsi_disk_state;
3045 }
3046
3047 static const TypeInfo scsi_cd_info = {
3048     .name          = "scsi-cd",
3049     .parent        = TYPE_SCSI_DISK_BASE,
3050     .class_init    = scsi_cd_class_initfn,
3051 };
3052
3053 #ifdef __linux__
3054 static Property scsi_block_properties[] = {
3055     DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf),         \
3056     DEFINE_PROP_DRIVE("drive", SCSIDiskState, qdev.conf.blk),
3057     DEFINE_PROP_BOOL("share-rw", SCSIDiskState, qdev.conf.share_rw, false),
3058     DEFINE_PROP_UINT16("rotation_rate", SCSIDiskState, rotation_rate, 0),
3059     DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState, max_unmap_size,
3060                        DEFAULT_MAX_UNMAP_SIZE),
3061     DEFINE_PROP_UINT64("max_io_size", SCSIDiskState, max_io_size,
3062                        DEFAULT_MAX_IO_SIZE),
3063     DEFINE_PROP_INT32("scsi_version", SCSIDiskState, qdev.default_scsi_version,
3064                       -1),
3065     DEFINE_PROP_END_OF_LIST(),
3066 };
3067
3068 static void scsi_block_class_initfn(ObjectClass *klass, void *data)
3069 {
3070     DeviceClass *dc = DEVICE_CLASS(klass);
3071     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
3072     SCSIDiskClass *sdc = SCSI_DISK_BASE_CLASS(klass);
3073
3074     sc->realize      = scsi_block_realize;
3075     sc->alloc_req    = scsi_block_new_request;
3076     sc->parse_cdb    = scsi_block_parse_cdb;
3077     sdc->dma_readv   = scsi_block_dma_readv;
3078     sdc->dma_writev  = scsi_block_dma_writev;
3079     sdc->update_sense = scsi_block_update_sense;
3080     sdc->need_fua_emulation = scsi_block_no_fua;
3081     dc->desc = "SCSI block device passthrough";
3082     dc->props = scsi_block_properties;
3083     dc->vmsd  = &vmstate_scsi_disk_state;
3084 }
3085
3086 static const TypeInfo scsi_block_info = {
3087     .name          = "scsi-block",
3088     .parent        = TYPE_SCSI_DISK_BASE,
3089     .class_init    = scsi_block_class_initfn,
3090 };
3091 #endif
3092
3093 static Property scsi_disk_properties[] = {
3094     DEFINE_SCSI_DISK_PROPERTIES(),
3095     DEFINE_PROP_BIT("removable", SCSIDiskState, features,
3096                     SCSI_DISK_F_REMOVABLE, false),
3097     DEFINE_PROP_BIT("dpofua", SCSIDiskState, features,
3098                     SCSI_DISK_F_DPOFUA, false),
3099     DEFINE_PROP_UINT64("wwn", SCSIDiskState, qdev.wwn, 0),
3100     DEFINE_PROP_UINT64("port_wwn", SCSIDiskState, qdev.port_wwn, 0),
3101     DEFINE_PROP_UINT16("port_index", SCSIDiskState, port_index, 0),
3102     DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState, max_unmap_size,
3103                        DEFAULT_MAX_UNMAP_SIZE),
3104     DEFINE_PROP_UINT64("max_io_size", SCSIDiskState, max_io_size,
3105                        DEFAULT_MAX_IO_SIZE),
3106     DEFINE_PROP_INT32("scsi_version", SCSIDiskState, qdev.default_scsi_version,
3107                       5),
3108     DEFINE_PROP_END_OF_LIST(),
3109 };
3110
3111 static void scsi_disk_class_initfn(ObjectClass *klass, void *data)
3112 {
3113     DeviceClass *dc = DEVICE_CLASS(klass);
3114     SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
3115
3116     sc->realize      = scsi_disk_realize;
3117     sc->alloc_req    = scsi_new_request;
3118     sc->unit_attention_reported = scsi_disk_unit_attention_reported;
3119     dc->fw_name = "disk";
3120     dc->desc = "virtual SCSI disk or CD-ROM (legacy)";
3121     dc->reset = scsi_disk_reset;
3122     dc->props = scsi_disk_properties;
3123     dc->vmsd  = &vmstate_scsi_disk_state;
3124 }
3125
3126 static const TypeInfo scsi_disk_info = {
3127     .name          = "scsi-disk",
3128     .parent        = TYPE_SCSI_DISK_BASE,
3129     .class_init    = scsi_disk_class_initfn,
3130 };
3131
3132 static void scsi_disk_register_types(void)
3133 {
3134     type_register_static(&scsi_disk_base_info);
3135     type_register_static(&scsi_hd_info);
3136     type_register_static(&scsi_cd_info);
3137 #ifdef __linux__
3138     type_register_static(&scsi_block_info);
3139 #endif
3140     type_register_static(&scsi_disk_info);
3141 }
3142
3143 type_init(scsi_disk_register_types)