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