2 * SCSI Device emulation
4 * Copyright (c) 2006 CodeSourcery.
5 * Based on code by Fabrice Bellard
7 * Written by Paul Brook
9 * 2009-Dec-12 Artyom Tarasenko : implemented stamdard inquiry for the case
10 * when the allocation length of CDB is smaller
12 * 2009-Oct-13 Artyom Tarasenko : implemented the block descriptor in the
13 * MODE SENSE response.
15 * This code is licensed under the LGPL.
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.
25 #define DPRINTF(fmt, ...) \
26 do { printf("scsi-disk: " fmt , ## __VA_ARGS__); } while (0)
28 #define DPRINTF(fmt, ...) do {} while(0)
31 #include "qemu-common.h"
32 #include "qemu-error.h"
34 #include "scsi-defs.h"
37 #include "hw/block-common.h"
44 #define SCSI_DMA_BUF_SIZE 131072
45 #define SCSI_MAX_INQUIRY_LEN 256
46 #define SCSI_MAX_MODE_LEN 256
48 typedef struct SCSIDiskState SCSIDiskState
;
50 typedef struct SCSIDiskReq
{
52 /* Both sector and sector_count are in terms of qemu 512 byte blocks. */
54 uint32_t sector_count
;
62 #define SCSI_DISK_F_REMOVABLE 0
63 #define SCSI_DISK_F_DPOFUA 1
82 static int scsi_handle_rw_error(SCSIDiskReq
*r
, int error
);
84 static void scsi_free_request(SCSIRequest
*req
)
86 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
88 if (r
->iov
.iov_base
) {
89 qemu_vfree(r
->iov
.iov_base
);
93 /* Helper function for command completion with sense. */
94 static void scsi_check_condition(SCSIDiskReq
*r
, SCSISense sense
)
96 DPRINTF("Command complete tag=0x%x sense=%d/%d/%d\n",
97 r
->req
.tag
, sense
.key
, sense
.asc
, sense
.ascq
);
98 scsi_req_build_sense(&r
->req
, sense
);
99 scsi_req_complete(&r
->req
, CHECK_CONDITION
);
102 /* Cancel a pending data transfer. */
103 static void scsi_cancel_io(SCSIRequest
*req
)
105 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
107 DPRINTF("Cancel tag=0x%x\n", req
->tag
);
109 bdrv_aio_cancel(r
->req
.aiocb
);
111 /* This reference was left in by scsi_*_data. We take ownership of
112 * it the moment scsi_req_cancel is called, independent of whether
113 * bdrv_aio_cancel completes the request or not. */
114 scsi_req_unref(&r
->req
);
119 static uint32_t scsi_init_iovec(SCSIDiskReq
*r
, size_t size
)
121 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
123 if (!r
->iov
.iov_base
) {
125 r
->iov
.iov_base
= qemu_blockalign(s
->qdev
.conf
.bs
, r
->buflen
);
127 r
->iov
.iov_len
= MIN(r
->sector_count
* 512, r
->buflen
);
128 qemu_iovec_init_external(&r
->qiov
, &r
->iov
, 1);
129 return r
->qiov
.size
/ 512;
132 static void scsi_disk_save_request(QEMUFile
*f
, SCSIRequest
*req
)
134 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
136 qemu_put_be64s(f
, &r
->sector
);
137 qemu_put_be32s(f
, &r
->sector_count
);
138 qemu_put_be32s(f
, &r
->buflen
);
140 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
141 qemu_put_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
142 } else if (!req
->retry
) {
143 uint32_t len
= r
->iov
.iov_len
;
144 qemu_put_be32s(f
, &len
);
145 qemu_put_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
150 static void scsi_disk_load_request(QEMUFile
*f
, SCSIRequest
*req
)
152 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
154 qemu_get_be64s(f
, &r
->sector
);
155 qemu_get_be32s(f
, &r
->sector_count
);
156 qemu_get_be32s(f
, &r
->buflen
);
158 scsi_init_iovec(r
, r
->buflen
);
159 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
160 qemu_get_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
161 } else if (!r
->req
.retry
) {
163 qemu_get_be32s(f
, &len
);
164 r
->iov
.iov_len
= len
;
165 assert(r
->iov
.iov_len
<= r
->buflen
);
166 qemu_get_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
170 qemu_iovec_init_external(&r
->qiov
, &r
->iov
, 1);
173 static void scsi_aio_complete(void *opaque
, int ret
)
175 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
176 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
178 bdrv_acct_done(s
->qdev
.conf
.bs
, &r
->acct
);
181 if (scsi_handle_rw_error(r
, -ret
)) {
186 scsi_req_complete(&r
->req
, GOOD
);
189 if (!r
->req
.io_canceled
) {
190 scsi_req_unref(&r
->req
);
194 static bool scsi_is_cmd_fua(SCSICommand
*cmd
)
196 switch (cmd
->buf
[0]) {
203 return (cmd
->buf
[1] & 8) != 0;
208 case WRITE_VERIFY_10
:
209 case WRITE_VERIFY_12
:
210 case WRITE_VERIFY_16
:
220 static void scsi_write_do_fua(SCSIDiskReq
*r
)
222 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
224 if (scsi_is_cmd_fua(&r
->req
.cmd
)) {
225 bdrv_acct_start(s
->qdev
.conf
.bs
, &r
->acct
, 0, BDRV_ACCT_FLUSH
);
226 r
->req
.aiocb
= bdrv_aio_flush(s
->qdev
.conf
.bs
, scsi_aio_complete
, r
);
230 scsi_req_complete(&r
->req
, GOOD
);
231 if (!r
->req
.io_canceled
) {
232 scsi_req_unref(&r
->req
);
236 static void scsi_dma_complete(void *opaque
, int ret
)
238 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
239 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
241 if (r
->req
.aiocb
!= NULL
) {
243 bdrv_acct_done(s
->qdev
.conf
.bs
, &r
->acct
);
247 if (scsi_handle_rw_error(r
, -ret
)) {
252 r
->sector
+= r
->sector_count
;
254 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
255 scsi_write_do_fua(r
);
258 scsi_req_complete(&r
->req
, GOOD
);
262 if (!r
->req
.io_canceled
) {
263 scsi_req_unref(&r
->req
);
267 static void scsi_read_complete(void * opaque
, int ret
)
269 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
270 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
273 if (r
->req
.aiocb
!= NULL
) {
275 bdrv_acct_done(s
->qdev
.conf
.bs
, &r
->acct
);
279 if (scsi_handle_rw_error(r
, -ret
)) {
284 DPRINTF("Data ready tag=0x%x len=%zd\n", r
->req
.tag
, r
->qiov
.size
);
286 n
= r
->qiov
.size
/ 512;
288 r
->sector_count
-= n
;
289 scsi_req_data(&r
->req
, r
->qiov
.size
);
292 if (!r
->req
.io_canceled
) {
293 scsi_req_unref(&r
->req
);
297 /* Actually issue a read to the block device. */
298 static void scsi_do_read(void *opaque
, int ret
)
300 SCSIDiskReq
*r
= opaque
;
301 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
304 if (r
->req
.aiocb
!= NULL
) {
306 bdrv_acct_done(s
->qdev
.conf
.bs
, &r
->acct
);
310 if (scsi_handle_rw_error(r
, -ret
)) {
315 if (r
->req
.io_canceled
) {
319 /* The request is used as the AIO opaque value, so add a ref. */
320 scsi_req_ref(&r
->req
);
323 dma_acct_start(s
->qdev
.conf
.bs
, &r
->acct
, r
->req
.sg
, BDRV_ACCT_READ
);
324 r
->req
.resid
-= r
->req
.sg
->size
;
325 r
->req
.aiocb
= dma_bdrv_read(s
->qdev
.conf
.bs
, r
->req
.sg
, r
->sector
,
326 scsi_dma_complete
, r
);
328 n
= scsi_init_iovec(r
, SCSI_DMA_BUF_SIZE
);
329 bdrv_acct_start(s
->qdev
.conf
.bs
, &r
->acct
, n
* BDRV_SECTOR_SIZE
, BDRV_ACCT_READ
);
330 r
->req
.aiocb
= bdrv_aio_readv(s
->qdev
.conf
.bs
, r
->sector
, &r
->qiov
, n
,
331 scsi_read_complete
, r
);
335 if (!r
->req
.io_canceled
) {
336 scsi_req_unref(&r
->req
);
340 /* Read more data from scsi device into buffer. */
341 static void scsi_read_data(SCSIRequest
*req
)
343 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
344 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
347 DPRINTF("Read sector_count=%d\n", r
->sector_count
);
348 if (r
->sector_count
== 0) {
349 /* This also clears the sense buffer for REQUEST SENSE. */
350 scsi_req_complete(&r
->req
, GOOD
);
354 /* No data transfer may already be in progress */
355 assert(r
->req
.aiocb
== NULL
);
357 /* The request is used as the AIO opaque value, so add a ref. */
358 scsi_req_ref(&r
->req
);
359 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
360 DPRINTF("Data transfer direction invalid\n");
361 scsi_read_complete(r
, -EINVAL
);
366 scsi_read_complete(r
, -ENOMEDIUM
);
372 if (first
&& scsi_is_cmd_fua(&r
->req
.cmd
)) {
373 bdrv_acct_start(s
->qdev
.conf
.bs
, &r
->acct
, 0, BDRV_ACCT_FLUSH
);
374 r
->req
.aiocb
= bdrv_aio_flush(s
->qdev
.conf
.bs
, scsi_do_read
, r
);
381 * scsi_handle_rw_error has two return values. 0 means that the error
382 * must be ignored, 1 means that the error has been processed and the
383 * caller should not do anything else for this request. Note that
384 * scsi_handle_rw_error always manages its reference counts, independent
385 * of the return value.
387 static int scsi_handle_rw_error(SCSIDiskReq
*r
, int error
)
389 int is_read
= (r
->req
.cmd
.xfer
== SCSI_XFER_FROM_DEV
);
390 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
391 BlockErrorAction action
= bdrv_get_on_error(s
->qdev
.conf
.bs
, is_read
);
393 if (action
== BLOCK_ERR_IGNORE
) {
394 bdrv_emit_qmp_error_event(s
->qdev
.conf
.bs
, BDRV_ACTION_IGNORE
, is_read
);
398 if ((error
== ENOSPC
&& action
== BLOCK_ERR_STOP_ENOSPC
)
399 || action
== BLOCK_ERR_STOP_ANY
) {
401 bdrv_emit_qmp_error_event(s
->qdev
.conf
.bs
, BDRV_ACTION_STOP
, is_read
);
402 vm_stop(RUN_STATE_IO_ERROR
);
403 bdrv_iostatus_set_err(s
->qdev
.conf
.bs
, error
);
404 scsi_req_retry(&r
->req
);
408 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
411 scsi_check_condition(r
, SENSE_CODE(TARGET_FAILURE
));
414 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
417 scsi_check_condition(r
, SENSE_CODE(IO_ERROR
));
420 bdrv_emit_qmp_error_event(s
->qdev
.conf
.bs
, BDRV_ACTION_REPORT
, is_read
);
425 static void scsi_write_complete(void * opaque
, int ret
)
427 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
428 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
431 if (r
->req
.aiocb
!= NULL
) {
433 bdrv_acct_done(s
->qdev
.conf
.bs
, &r
->acct
);
437 if (scsi_handle_rw_error(r
, -ret
)) {
442 n
= r
->qiov
.size
/ 512;
444 r
->sector_count
-= n
;
445 if (r
->sector_count
== 0) {
446 scsi_write_do_fua(r
);
449 scsi_init_iovec(r
, SCSI_DMA_BUF_SIZE
);
450 DPRINTF("Write complete tag=0x%x more=%d\n", r
->req
.tag
, r
->qiov
.size
);
451 scsi_req_data(&r
->req
, r
->qiov
.size
);
455 if (!r
->req
.io_canceled
) {
456 scsi_req_unref(&r
->req
);
460 static void scsi_write_data(SCSIRequest
*req
)
462 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
463 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
466 /* No data transfer may already be in progress */
467 assert(r
->req
.aiocb
== NULL
);
469 /* The request is used as the AIO opaque value, so add a ref. */
470 scsi_req_ref(&r
->req
);
471 if (r
->req
.cmd
.mode
!= SCSI_XFER_TO_DEV
) {
472 DPRINTF("Data transfer direction invalid\n");
473 scsi_write_complete(r
, -EINVAL
);
477 if (!r
->req
.sg
&& !r
->qiov
.size
) {
478 /* Called for the first time. Ask the driver to send us more data. */
480 scsi_write_complete(r
, 0);
484 scsi_write_complete(r
, -ENOMEDIUM
);
488 if (r
->req
.cmd
.buf
[0] == VERIFY_10
|| r
->req
.cmd
.buf
[0] == VERIFY_12
||
489 r
->req
.cmd
.buf
[0] == VERIFY_16
) {
491 scsi_dma_complete(r
, 0);
493 scsi_write_complete(r
, 0);
499 dma_acct_start(s
->qdev
.conf
.bs
, &r
->acct
, r
->req
.sg
, BDRV_ACCT_WRITE
);
500 r
->req
.resid
-= r
->req
.sg
->size
;
501 r
->req
.aiocb
= dma_bdrv_write(s
->qdev
.conf
.bs
, r
->req
.sg
, r
->sector
,
502 scsi_dma_complete
, r
);
504 n
= r
->qiov
.size
/ 512;
505 bdrv_acct_start(s
->qdev
.conf
.bs
, &r
->acct
, n
* BDRV_SECTOR_SIZE
, BDRV_ACCT_WRITE
);
506 r
->req
.aiocb
= bdrv_aio_writev(s
->qdev
.conf
.bs
, r
->sector
, &r
->qiov
, n
,
507 scsi_write_complete
, r
);
511 /* Return a pointer to the data buffer. */
512 static uint8_t *scsi_get_buf(SCSIRequest
*req
)
514 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
516 return (uint8_t *)r
->iov
.iov_base
;
519 static int scsi_disk_emulate_inquiry(SCSIRequest
*req
, uint8_t *outbuf
)
521 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
525 if (req
->cmd
.buf
[1] & 0x1) {
526 /* Vital product data */
527 uint8_t page_code
= req
->cmd
.buf
[2];
529 outbuf
[buflen
++] = s
->qdev
.type
& 0x1f;
530 outbuf
[buflen
++] = page_code
; // this page
531 outbuf
[buflen
++] = 0x00;
532 outbuf
[buflen
++] = 0x00;
536 case 0x00: /* Supported page codes, mandatory */
538 DPRINTF("Inquiry EVPD[Supported pages] "
539 "buffer size %zd\n", req
->cmd
.xfer
);
540 outbuf
[buflen
++] = 0x00; // list of supported pages (this page)
542 outbuf
[buflen
++] = 0x80; // unit serial number
544 outbuf
[buflen
++] = 0x83; // device identification
545 if (s
->qdev
.type
== TYPE_DISK
) {
546 outbuf
[buflen
++] = 0xb0; // block limits
547 outbuf
[buflen
++] = 0xb2; // thin provisioning
551 case 0x80: /* Device serial number, optional */
556 DPRINTF("Inquiry (EVPD[Serial number] not supported\n");
560 l
= strlen(s
->serial
);
565 DPRINTF("Inquiry EVPD[Serial number] "
566 "buffer size %zd\n", req
->cmd
.xfer
);
567 memcpy(outbuf
+buflen
, s
->serial
, l
);
572 case 0x83: /* Device identification page, mandatory */
574 const char *str
= s
->serial
?: bdrv_get_device_name(s
->qdev
.conf
.bs
);
575 int max_len
= s
->serial
? 20 : 255 - 8;
576 int id_len
= strlen(str
);
578 if (id_len
> max_len
) {
581 DPRINTF("Inquiry EVPD[Device identification] "
582 "buffer size %zd\n", req
->cmd
.xfer
);
584 outbuf
[buflen
++] = 0x2; // ASCII
585 outbuf
[buflen
++] = 0; // not officially assigned
586 outbuf
[buflen
++] = 0; // reserved
587 outbuf
[buflen
++] = id_len
; // length of data following
588 memcpy(outbuf
+buflen
, str
, id_len
);
592 outbuf
[buflen
++] = 0x1; // Binary
593 outbuf
[buflen
++] = 0x3; // NAA
594 outbuf
[buflen
++] = 0; // reserved
595 outbuf
[buflen
++] = 8;
596 stq_be_p(&outbuf
[buflen
], s
->wwn
);
601 case 0xb0: /* block limits */
603 unsigned int unmap_sectors
=
604 s
->qdev
.conf
.discard_granularity
/ s
->qdev
.blocksize
;
605 unsigned int min_io_size
=
606 s
->qdev
.conf
.min_io_size
/ s
->qdev
.blocksize
;
607 unsigned int opt_io_size
=
608 s
->qdev
.conf
.opt_io_size
/ s
->qdev
.blocksize
;
610 if (s
->qdev
.type
== TYPE_ROM
) {
611 DPRINTF("Inquiry (EVPD[%02X] not supported for CDROM\n",
615 /* required VPD size with unmap support */
617 memset(outbuf
+ 4, 0, buflen
- 4);
619 /* optimal transfer length granularity */
620 outbuf
[6] = (min_io_size
>> 8) & 0xff;
621 outbuf
[7] = min_io_size
& 0xff;
623 /* optimal transfer length */
624 outbuf
[12] = (opt_io_size
>> 24) & 0xff;
625 outbuf
[13] = (opt_io_size
>> 16) & 0xff;
626 outbuf
[14] = (opt_io_size
>> 8) & 0xff;
627 outbuf
[15] = opt_io_size
& 0xff;
629 /* optimal unmap granularity */
630 outbuf
[28] = (unmap_sectors
>> 24) & 0xff;
631 outbuf
[29] = (unmap_sectors
>> 16) & 0xff;
632 outbuf
[30] = (unmap_sectors
>> 8) & 0xff;
633 outbuf
[31] = unmap_sectors
& 0xff;
636 case 0xb2: /* thin provisioning */
640 outbuf
[5] = 0x60; /* write_same 10/16 supported */
641 outbuf
[6] = s
->qdev
.conf
.discard_granularity
? 2 : 1;
649 assert(buflen
- start
<= 255);
650 outbuf
[start
- 1] = buflen
- start
;
654 /* Standard INQUIRY data */
655 if (req
->cmd
.buf
[2] != 0) {
660 buflen
= req
->cmd
.xfer
;
661 if (buflen
> SCSI_MAX_INQUIRY_LEN
) {
662 buflen
= SCSI_MAX_INQUIRY_LEN
;
664 memset(outbuf
, 0, buflen
);
666 outbuf
[0] = s
->qdev
.type
& 0x1f;
667 outbuf
[1] = (s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) ? 0x80 : 0;
669 strpadcpy((char *) &outbuf
[16], 16, s
->product
, ' ');
670 strpadcpy((char *) &outbuf
[8], 8, s
->vendor
, ' ');
672 memset(&outbuf
[32], 0, 4);
673 memcpy(&outbuf
[32], s
->version
, MIN(4, strlen(s
->version
)));
675 * We claim conformance to SPC-3, which is required for guests
676 * to ask for modern features like READ CAPACITY(16) or the
677 * block characteristics VPD page by default. Not all of SPC-3
678 * is actually implemented, but we're good enough.
681 outbuf
[3] = 2; /* Format 2 */
684 outbuf
[4] = buflen
- 5; /* Additional Length = (Len - 1) - 4 */
686 /* If the allocation length of CDB is too small,
687 the additional length is not adjusted */
691 /* Sync data transfer and TCQ. */
692 outbuf
[7] = 0x10 | (req
->bus
->info
->tcq
? 0x02 : 0);
696 static inline bool media_is_dvd(SCSIDiskState
*s
)
699 if (s
->qdev
.type
!= TYPE_ROM
) {
702 if (!bdrv_is_inserted(s
->qdev
.conf
.bs
)) {
705 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
706 return nb_sectors
> CD_MAX_SECTORS
;
709 static inline bool media_is_cd(SCSIDiskState
*s
)
712 if (s
->qdev
.type
!= TYPE_ROM
) {
715 if (!bdrv_is_inserted(s
->qdev
.conf
.bs
)) {
718 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
719 return nb_sectors
<= CD_MAX_SECTORS
;
722 static int scsi_read_disc_information(SCSIDiskState
*s
, SCSIDiskReq
*r
,
725 uint8_t type
= r
->req
.cmd
.buf
[1] & 7;
727 if (s
->qdev
.type
!= TYPE_ROM
) {
731 /* Types 1/2 are only defined for Blu-Ray. */
733 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
737 memset(outbuf
, 0, 34);
739 outbuf
[2] = 0xe; /* last session complete, disc finalized */
740 outbuf
[3] = 1; /* first track on disc */
741 outbuf
[4] = 1; /* # of sessions */
742 outbuf
[5] = 1; /* first track of last session */
743 outbuf
[6] = 1; /* last track of last session */
744 outbuf
[7] = 0x20; /* unrestricted use */
745 outbuf
[8] = 0x00; /* CD-ROM or DVD-ROM */
746 /* 9-10-11: most significant byte corresponding bytes 4-5-6 */
747 /* 12-23: not meaningful for CD-ROM or DVD-ROM */
748 /* 24-31: disc bar code */
749 /* 32: disc application code */
750 /* 33: number of OPC tables */
755 static int scsi_read_dvd_structure(SCSIDiskState
*s
, SCSIDiskReq
*r
,
758 static const int rds_caps_size
[5] = {
765 uint8_t media
= r
->req
.cmd
.buf
[1];
766 uint8_t layer
= r
->req
.cmd
.buf
[6];
767 uint8_t format
= r
->req
.cmd
.buf
[7];
770 if (s
->qdev
.type
!= TYPE_ROM
) {
774 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
778 if (format
!= 0xff) {
779 if (s
->tray_open
|| !bdrv_is_inserted(s
->qdev
.conf
.bs
)) {
780 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
783 if (media_is_cd(s
)) {
784 scsi_check_condition(r
, SENSE_CODE(INCOMPATIBLE_FORMAT
));
787 if (format
>= ARRAY_SIZE(rds_caps_size
)) {
790 size
= rds_caps_size
[format
];
791 memset(outbuf
, 0, size
);
796 /* Physical format information */
801 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
803 outbuf
[4] = 1; /* DVD-ROM, part version 1 */
804 outbuf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
805 outbuf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
806 outbuf
[7] = 0; /* default densities */
808 stl_be_p(&outbuf
[12], (nb_sectors
>> 2) - 1); /* end sector */
809 stl_be_p(&outbuf
[16], (nb_sectors
>> 2) - 1); /* l0 end sector */
813 case 0x01: /* DVD copyright information, all zeros */
816 case 0x03: /* BCA information - invalid field for no BCA info */
819 case 0x04: /* DVD disc manufacturing information, all zeros */
822 case 0xff: { /* List capabilities */
825 for (i
= 0; i
< ARRAY_SIZE(rds_caps_size
); i
++) {
826 if (!rds_caps_size
[i
]) {
830 outbuf
[size
+ 1] = 0x40; /* Not writable, readable */
831 stw_be_p(&outbuf
[size
+ 2], rds_caps_size
[i
]);
841 /* Size of buffer, not including 2 byte size field */
842 stw_be_p(outbuf
, size
- 2);
849 static int scsi_event_status_media(SCSIDiskState
*s
, uint8_t *outbuf
)
851 uint8_t event_code
, media_status
;
855 media_status
= MS_TRAY_OPEN
;
856 } else if (bdrv_is_inserted(s
->qdev
.conf
.bs
)) {
857 media_status
= MS_MEDIA_PRESENT
;
860 /* Event notification descriptor */
861 event_code
= MEC_NO_CHANGE
;
862 if (media_status
!= MS_TRAY_OPEN
) {
863 if (s
->media_event
) {
864 event_code
= MEC_NEW_MEDIA
;
865 s
->media_event
= false;
866 } else if (s
->eject_request
) {
867 event_code
= MEC_EJECT_REQUESTED
;
868 s
->eject_request
= false;
872 outbuf
[0] = event_code
;
873 outbuf
[1] = media_status
;
875 /* These fields are reserved, just clear them. */
881 static int scsi_get_event_status_notification(SCSIDiskState
*s
, SCSIDiskReq
*r
,
885 uint8_t *buf
= r
->req
.cmd
.buf
;
886 uint8_t notification_class_request
= buf
[4];
887 if (s
->qdev
.type
!= TYPE_ROM
) {
890 if ((buf
[1] & 1) == 0) {
896 outbuf
[0] = outbuf
[1] = 0;
897 outbuf
[3] = 1 << GESN_MEDIA
; /* supported events */
898 if (notification_class_request
& (1 << GESN_MEDIA
)) {
899 outbuf
[2] = GESN_MEDIA
;
900 size
+= scsi_event_status_media(s
, &outbuf
[size
]);
904 stw_be_p(outbuf
, size
- 4);
908 static int scsi_get_configuration(SCSIDiskState
*s
, uint8_t *outbuf
)
912 if (s
->qdev
.type
!= TYPE_ROM
) {
915 current
= media_is_dvd(s
) ? MMC_PROFILE_DVD_ROM
: MMC_PROFILE_CD_ROM
;
916 memset(outbuf
, 0, 40);
917 stl_be_p(&outbuf
[0], 36); /* Bytes after the data length field */
918 stw_be_p(&outbuf
[6], current
);
919 /* outbuf[8] - outbuf[19]: Feature 0 - Profile list */
920 outbuf
[10] = 0x03; /* persistent, current */
921 outbuf
[11] = 8; /* two profiles */
922 stw_be_p(&outbuf
[12], MMC_PROFILE_DVD_ROM
);
923 outbuf
[14] = (current
== MMC_PROFILE_DVD_ROM
);
924 stw_be_p(&outbuf
[16], MMC_PROFILE_CD_ROM
);
925 outbuf
[18] = (current
== MMC_PROFILE_CD_ROM
);
926 /* outbuf[20] - outbuf[31]: Feature 1 - Core feature */
927 stw_be_p(&outbuf
[20], 1);
928 outbuf
[22] = 0x08 | 0x03; /* version 2, persistent, current */
930 stl_be_p(&outbuf
[24], 1); /* SCSI */
931 outbuf
[28] = 1; /* DBE = 1, mandatory */
932 /* outbuf[32] - outbuf[39]: Feature 3 - Removable media feature */
933 stw_be_p(&outbuf
[32], 3);
934 outbuf
[34] = 0x08 | 0x03; /* version 2, persistent, current */
936 outbuf
[36] = 0x39; /* tray, load=1, eject=1, unlocked at powerup, lock=1 */
937 /* TODO: Random readable, CD read, DVD read, drive serial number,
942 static int scsi_emulate_mechanism_status(SCSIDiskState
*s
, uint8_t *outbuf
)
944 if (s
->qdev
.type
!= TYPE_ROM
) {
947 memset(outbuf
, 0, 8);
948 outbuf
[5] = 1; /* CD-ROM */
952 static int mode_sense_page(SCSIDiskState
*s
, int page
, uint8_t **p_outbuf
,
955 static const int mode_sense_valid
[0x3f] = {
956 [MODE_PAGE_HD_GEOMETRY
] = (1 << TYPE_DISK
),
957 [MODE_PAGE_FLEXIBLE_DISK_GEOMETRY
] = (1 << TYPE_DISK
),
958 [MODE_PAGE_CACHING
] = (1 << TYPE_DISK
) | (1 << TYPE_ROM
),
959 [MODE_PAGE_R_W_ERROR
] = (1 << TYPE_DISK
) | (1 << TYPE_ROM
),
960 [MODE_PAGE_AUDIO_CTL
] = (1 << TYPE_ROM
),
961 [MODE_PAGE_CAPABILITIES
] = (1 << TYPE_ROM
),
964 uint8_t *p
= *p_outbuf
+ 2;
967 if ((mode_sense_valid
[page
] & (1 << s
->qdev
.type
)) == 0) {
972 * If Changeable Values are requested, a mask denoting those mode parameters
973 * that are changeable shall be returned. As we currently don't support
974 * parameter changes via MODE_SELECT all bits are returned set to zero.
975 * The buffer was already menset to zero by the caller of this function.
977 * The offsets here are off by two compared to the descriptions in the
978 * SCSI specs, because those include a 2-byte header. This is unfortunate,
979 * but it is done so that offsets are consistent within our implementation
980 * of MODE SENSE and MODE SELECT. MODE SELECT has to deal with both
981 * 2-byte and 4-byte headers.
984 case MODE_PAGE_HD_GEOMETRY
:
986 if (page_control
== 1) { /* Changeable Values */
989 /* if a geometry hint is available, use it */
990 p
[0] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
991 p
[1] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
992 p
[2] = s
->qdev
.conf
.cyls
& 0xff;
993 p
[3] = s
->qdev
.conf
.heads
& 0xff;
994 /* Write precomp start cylinder, disabled */
995 p
[4] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
996 p
[5] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
997 p
[6] = s
->qdev
.conf
.cyls
& 0xff;
998 /* Reduced current start cylinder, disabled */
999 p
[7] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
1000 p
[8] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1001 p
[9] = s
->qdev
.conf
.cyls
& 0xff;
1002 /* Device step rate [ns], 200ns */
1005 /* Landing zone cylinder */
1009 /* Medium rotation rate [rpm], 5400 rpm */
1010 p
[18] = (5400 >> 8) & 0xff;
1011 p
[19] = 5400 & 0xff;
1014 case MODE_PAGE_FLEXIBLE_DISK_GEOMETRY
:
1016 if (page_control
== 1) { /* Changeable Values */
1019 /* Transfer rate [kbit/s], 5Mbit/s */
1022 /* if a geometry hint is available, use it */
1023 p
[2] = s
->qdev
.conf
.heads
& 0xff;
1024 p
[3] = s
->qdev
.conf
.secs
& 0xff;
1025 p
[4] = s
->qdev
.blocksize
>> 8;
1026 p
[6] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1027 p
[7] = s
->qdev
.conf
.cyls
& 0xff;
1028 /* Write precomp start cylinder, disabled */
1029 p
[8] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1030 p
[9] = s
->qdev
.conf
.cyls
& 0xff;
1031 /* Reduced current start cylinder, disabled */
1032 p
[10] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1033 p
[11] = s
->qdev
.conf
.cyls
& 0xff;
1034 /* Device step rate [100us], 100us */
1037 /* Device step pulse width [us], 1us */
1039 /* Device head settle delay [100us], 100us */
1042 /* Motor on delay [0.1s], 0.1s */
1044 /* Motor off delay [0.1s], 0.1s */
1046 /* Medium rotation rate [rpm], 5400 rpm */
1047 p
[26] = (5400 >> 8) & 0xff;
1048 p
[27] = 5400 & 0xff;
1051 case MODE_PAGE_CACHING
:
1053 if (page_control
== 1 || /* Changeable Values */
1054 bdrv_enable_write_cache(s
->qdev
.conf
.bs
)) {
1059 case MODE_PAGE_R_W_ERROR
:
1061 if (page_control
== 1) { /* Changeable Values */
1064 p
[0] = 0x80; /* Automatic Write Reallocation Enabled */
1065 if (s
->qdev
.type
== TYPE_ROM
) {
1066 p
[1] = 0x20; /* Read Retry Count */
1070 case MODE_PAGE_AUDIO_CTL
:
1074 case MODE_PAGE_CAPABILITIES
:
1076 if (page_control
== 1) { /* Changeable Values */
1080 p
[0] = 0x3b; /* CD-R & CD-RW read */
1081 p
[1] = 0; /* Writing not supported */
1082 p
[2] = 0x7f; /* Audio, composite, digital out,
1083 mode 2 form 1&2, multi session */
1084 p
[3] = 0xff; /* CD DA, DA accurate, RW supported,
1085 RW corrected, C2 errors, ISRC,
1087 p
[4] = 0x2d | (s
->tray_locked
? 2 : 0);
1088 /* Locking supported, jumper present, eject, tray */
1089 p
[5] = 0; /* no volume & mute control, no
1091 p
[6] = (50 * 176) >> 8; /* 50x read speed */
1092 p
[7] = (50 * 176) & 0xff;
1093 p
[8] = 2 >> 8; /* Two volume levels */
1095 p
[10] = 2048 >> 8; /* 2M buffer */
1096 p
[11] = 2048 & 0xff;
1097 p
[12] = (16 * 176) >> 8; /* 16x read speed current */
1098 p
[13] = (16 * 176) & 0xff;
1099 p
[16] = (16 * 176) >> 8; /* 16x write speed */
1100 p
[17] = (16 * 176) & 0xff;
1101 p
[18] = (16 * 176) >> 8; /* 16x write speed current */
1102 p
[19] = (16 * 176) & 0xff;
1109 assert(length
< 256);
1110 (*p_outbuf
)[0] = page
;
1111 (*p_outbuf
)[1] = length
;
1112 *p_outbuf
+= length
+ 2;
1116 static int scsi_disk_emulate_mode_sense(SCSIDiskReq
*r
, uint8_t *outbuf
)
1118 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1119 uint64_t nb_sectors
;
1121 int page
, buflen
, ret
, page_control
;
1123 uint8_t dev_specific_param
;
1125 dbd
= (r
->req
.cmd
.buf
[1] & 0x8) != 0;
1126 page
= r
->req
.cmd
.buf
[2] & 0x3f;
1127 page_control
= (r
->req
.cmd
.buf
[2] & 0xc0) >> 6;
1128 DPRINTF("Mode Sense(%d) (page %d, xfer %zd, page_control %d)\n",
1129 (r
->req
.cmd
.buf
[0] == MODE_SENSE
) ? 6 : 10, page
, r
->req
.cmd
.xfer
, page_control
);
1130 memset(outbuf
, 0, r
->req
.cmd
.xfer
);
1133 if (s
->qdev
.type
== TYPE_DISK
) {
1134 dev_specific_param
= s
->features
& (1 << SCSI_DISK_F_DPOFUA
) ? 0x10 : 0;
1135 if (bdrv_is_read_only(s
->qdev
.conf
.bs
)) {
1136 dev_specific_param
|= 0x80; /* Readonly. */
1139 /* MMC prescribes that CD/DVD drives have no block descriptors,
1140 * and defines no device-specific parameter. */
1141 dev_specific_param
= 0x00;
1145 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1146 p
[1] = 0; /* Default media type. */
1147 p
[2] = dev_specific_param
;
1148 p
[3] = 0; /* Block descriptor length. */
1150 } else { /* MODE_SENSE_10 */
1151 p
[2] = 0; /* Default media type. */
1152 p
[3] = dev_specific_param
;
1153 p
[6] = p
[7] = 0; /* Block descriptor length. */
1157 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
1158 if (!dbd
&& nb_sectors
) {
1159 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1160 outbuf
[3] = 8; /* Block descriptor length */
1161 } else { /* MODE_SENSE_10 */
1162 outbuf
[7] = 8; /* Block descriptor length */
1164 nb_sectors
/= (s
->qdev
.blocksize
/ 512);
1165 if (nb_sectors
> 0xffffff) {
1168 p
[0] = 0; /* media density code */
1169 p
[1] = (nb_sectors
>> 16) & 0xff;
1170 p
[2] = (nb_sectors
>> 8) & 0xff;
1171 p
[3] = nb_sectors
& 0xff;
1172 p
[4] = 0; /* reserved */
1173 p
[5] = 0; /* bytes 5-7 are the sector size in bytes */
1174 p
[6] = s
->qdev
.blocksize
>> 8;
1179 if (page_control
== 3) {
1181 scsi_check_condition(r
, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED
));
1186 for (page
= 0; page
<= 0x3e; page
++) {
1187 mode_sense_page(s
, page
, &p
, page_control
);
1190 ret
= mode_sense_page(s
, page
, &p
, page_control
);
1196 buflen
= p
- outbuf
;
1198 * The mode data length field specifies the length in bytes of the
1199 * following data that is available to be transferred. The mode data
1200 * length does not include itself.
1202 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1203 outbuf
[0] = buflen
- 1;
1204 } else { /* MODE_SENSE_10 */
1205 outbuf
[0] = ((buflen
- 2) >> 8) & 0xff;
1206 outbuf
[1] = (buflen
- 2) & 0xff;
1211 static int scsi_disk_emulate_read_toc(SCSIRequest
*req
, uint8_t *outbuf
)
1213 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1214 int start_track
, format
, msf
, toclen
;
1215 uint64_t nb_sectors
;
1217 msf
= req
->cmd
.buf
[1] & 2;
1218 format
= req
->cmd
.buf
[2] & 0xf;
1219 start_track
= req
->cmd
.buf
[6];
1220 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
1221 DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track
, format
, msf
>> 1);
1222 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1225 toclen
= cdrom_read_toc(nb_sectors
, outbuf
, msf
, start_track
);
1228 /* multi session : only a single session defined */
1230 memset(outbuf
, 0, 12);
1236 toclen
= cdrom_read_toc_raw(nb_sectors
, outbuf
, msf
, start_track
);
1244 static int scsi_disk_emulate_start_stop(SCSIDiskReq
*r
)
1246 SCSIRequest
*req
= &r
->req
;
1247 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1248 bool start
= req
->cmd
.buf
[4] & 1;
1249 bool loej
= req
->cmd
.buf
[4] & 2; /* load on start, eject on !start */
1251 if (s
->qdev
.type
== TYPE_ROM
&& loej
) {
1252 if (!start
&& !s
->tray_open
&& s
->tray_locked
) {
1253 scsi_check_condition(r
,
1254 bdrv_is_inserted(s
->qdev
.conf
.bs
)
1255 ? SENSE_CODE(ILLEGAL_REQ_REMOVAL_PREVENTED
)
1256 : SENSE_CODE(NOT_READY_REMOVAL_PREVENTED
));
1260 if (s
->tray_open
!= !start
) {
1261 bdrv_eject(s
->qdev
.conf
.bs
, !start
);
1262 s
->tray_open
= !start
;
1268 static void scsi_disk_emulate_read_data(SCSIRequest
*req
)
1270 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1271 int buflen
= r
->iov
.iov_len
;
1274 DPRINTF("Read buf_len=%zd\n", buflen
);
1277 scsi_req_data(&r
->req
, buflen
);
1281 /* This also clears the sense buffer for REQUEST SENSE. */
1282 scsi_req_complete(&r
->req
, GOOD
);
1285 static int scsi_disk_check_mode_select(SCSIDiskState
*s
, int page
,
1286 uint8_t *inbuf
, int inlen
)
1288 uint8_t mode_current
[SCSI_MAX_MODE_LEN
];
1289 uint8_t mode_changeable
[SCSI_MAX_MODE_LEN
];
1291 int len
, expected_len
, changeable_len
, i
;
1293 /* The input buffer does not include the page header, so it is
1296 expected_len
= inlen
+ 2;
1297 if (expected_len
> SCSI_MAX_MODE_LEN
) {
1302 memset(mode_current
, 0, inlen
+ 2);
1303 len
= mode_sense_page(s
, page
, &p
, 0);
1304 if (len
< 0 || len
!= expected_len
) {
1308 p
= mode_changeable
;
1309 memset(mode_changeable
, 0, inlen
+ 2);
1310 changeable_len
= mode_sense_page(s
, page
, &p
, 1);
1311 assert(changeable_len
== len
);
1313 /* Check that unchangeable bits are the same as what MODE SENSE
1316 for (i
= 2; i
< len
; i
++) {
1317 if (((mode_current
[i
] ^ inbuf
[i
- 2]) & ~mode_changeable
[i
]) != 0) {
1324 static void scsi_disk_apply_mode_select(SCSIDiskState
*s
, int page
, uint8_t *p
)
1327 case MODE_PAGE_CACHING
:
1328 bdrv_set_enable_write_cache(s
->qdev
.conf
.bs
, (p
[0] & 4) != 0);
1336 static int mode_select_pages(SCSIDiskReq
*r
, uint8_t *p
, int len
, bool change
)
1338 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1341 int page
, subpage
, page_len
;
1343 /* Parse both possible formats for the mode page headers. */
1347 goto invalid_param_len
;
1350 page_len
= lduw_be_p(&p
[2]);
1355 goto invalid_param_len
;
1366 if (page_len
> len
) {
1367 goto invalid_param_len
;
1371 if (scsi_disk_check_mode_select(s
, page
, p
, page_len
) < 0) {
1375 scsi_disk_apply_mode_select(s
, page
, p
);
1384 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM
));
1388 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1392 static void scsi_disk_emulate_mode_select(SCSIDiskReq
*r
, uint8_t *inbuf
)
1395 int cmd
= r
->req
.cmd
.buf
[0];
1396 int len
= r
->req
.cmd
.xfer
;
1397 int hdr_len
= (cmd
== MODE_SELECT
? 4 : 8);
1401 /* We only support PF=1, SP=0. */
1402 if ((r
->req
.cmd
.buf
[1] & 0x11) != 0x10) {
1406 if (len
< hdr_len
) {
1407 goto invalid_param_len
;
1410 bd_len
= (cmd
== MODE_SELECT
? p
[3] : lduw_be_p(&p
[6]));
1414 goto invalid_param_len
;
1416 if (bd_len
!= 0 && bd_len
!= 8) {
1423 /* Ensure no change is made if there is an error! */
1424 for (pass
= 0; pass
< 2; pass
++) {
1425 if (mode_select_pages(r
, p
, len
, pass
== 1) < 0) {
1430 scsi_req_complete(&r
->req
, GOOD
);
1434 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM
));
1438 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1442 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1446 static void scsi_disk_emulate_write_data(SCSIRequest
*req
)
1448 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1450 if (r
->iov
.iov_len
) {
1451 int buflen
= r
->iov
.iov_len
;
1452 DPRINTF("Write buf_len=%zd\n", buflen
);
1454 scsi_req_data(&r
->req
, buflen
);
1458 switch (req
->cmd
.buf
[0]) {
1460 case MODE_SELECT_10
:
1461 /* This also clears the sense buffer for REQUEST SENSE. */
1462 scsi_disk_emulate_mode_select(r
, r
->iov
.iov_base
);
1470 static int32_t scsi_disk_emulate_command(SCSIRequest
*req
, uint8_t *buf
)
1472 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1473 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1474 uint64_t nb_sectors
;
1478 switch (req
->cmd
.buf
[0]) {
1487 case ALLOW_MEDIUM_REMOVAL
:
1488 case GET_CONFIGURATION
:
1489 case GET_EVENT_STATUS_NOTIFICATION
:
1490 case MECHANISM_STATUS
:
1495 if (s
->tray_open
|| !bdrv_is_inserted(s
->qdev
.conf
.bs
)) {
1496 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
1502 if (!r
->iov
.iov_base
) {
1504 * FIXME: we shouldn't return anything bigger than 4k, but the code
1505 * requires the buffer to be as big as req->cmd.xfer in several
1506 * places. So, do not allow CDBs with a very large ALLOCATION
1507 * LENGTH. The real fix would be to modify scsi_read_data and
1508 * dma_buf_read, so that they return data beyond the buflen
1511 if (req
->cmd
.xfer
> 65536) {
1512 goto illegal_request
;
1514 r
->buflen
= MAX(4096, req
->cmd
.xfer
);
1515 r
->iov
.iov_base
= qemu_blockalign(s
->qdev
.conf
.bs
, r
->buflen
);
1518 buflen
= req
->cmd
.xfer
;
1519 outbuf
= r
->iov
.iov_base
;
1520 switch (req
->cmd
.buf
[0]) {
1521 case TEST_UNIT_READY
:
1522 assert(!s
->tray_open
&& bdrv_is_inserted(s
->qdev
.conf
.bs
));
1525 buflen
= scsi_disk_emulate_inquiry(req
, outbuf
);
1527 goto illegal_request
;
1532 buflen
= scsi_disk_emulate_mode_sense(r
, outbuf
);
1534 goto illegal_request
;
1538 buflen
= scsi_disk_emulate_read_toc(req
, outbuf
);
1540 goto illegal_request
;
1544 if (req
->cmd
.buf
[1] & 1) {
1545 goto illegal_request
;
1549 if (req
->cmd
.buf
[1] & 3) {
1550 goto illegal_request
;
1554 if (req
->cmd
.buf
[1] & 1) {
1555 goto illegal_request
;
1559 if (req
->cmd
.buf
[1] & 3) {
1560 goto illegal_request
;
1564 if (scsi_disk_emulate_start_stop(r
) < 0) {
1568 case ALLOW_MEDIUM_REMOVAL
:
1569 s
->tray_locked
= req
->cmd
.buf
[4] & 1;
1570 bdrv_lock_medium(s
->qdev
.conf
.bs
, req
->cmd
.buf
[4] & 1);
1572 case READ_CAPACITY_10
:
1573 /* The normal LEN field for this command is zero. */
1574 memset(outbuf
, 0, 8);
1575 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
1577 scsi_check_condition(r
, SENSE_CODE(LUN_NOT_READY
));
1580 if ((req
->cmd
.buf
[8] & 1) == 0 && req
->cmd
.lba
) {
1581 goto illegal_request
;
1583 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1584 /* Returned value is the address of the last sector. */
1586 /* Remember the new size for read/write sanity checking. */
1587 s
->qdev
.max_lba
= nb_sectors
;
1588 /* Clip to 2TB, instead of returning capacity modulo 2TB. */
1589 if (nb_sectors
> UINT32_MAX
) {
1590 nb_sectors
= UINT32_MAX
;
1592 outbuf
[0] = (nb_sectors
>> 24) & 0xff;
1593 outbuf
[1] = (nb_sectors
>> 16) & 0xff;
1594 outbuf
[2] = (nb_sectors
>> 8) & 0xff;
1595 outbuf
[3] = nb_sectors
& 0xff;
1598 outbuf
[6] = s
->qdev
.blocksize
>> 8;
1603 /* Just return "NO SENSE". */
1604 buflen
= scsi_build_sense(NULL
, 0, outbuf
, r
->buflen
,
1605 (req
->cmd
.buf
[1] & 1) == 0);
1607 case MECHANISM_STATUS
:
1608 buflen
= scsi_emulate_mechanism_status(s
, outbuf
);
1610 goto illegal_request
;
1613 case GET_CONFIGURATION
:
1614 buflen
= scsi_get_configuration(s
, outbuf
);
1616 goto illegal_request
;
1619 case GET_EVENT_STATUS_NOTIFICATION
:
1620 buflen
= scsi_get_event_status_notification(s
, r
, outbuf
);
1622 goto illegal_request
;
1625 case READ_DISC_INFORMATION
:
1626 buflen
= scsi_read_disc_information(s
, r
, outbuf
);
1628 goto illegal_request
;
1631 case READ_DVD_STRUCTURE
:
1632 buflen
= scsi_read_dvd_structure(s
, r
, outbuf
);
1634 goto illegal_request
;
1637 case SERVICE_ACTION_IN_16
:
1638 /* Service Action In subcommands. */
1639 if ((req
->cmd
.buf
[1] & 31) == SAI_READ_CAPACITY_16
) {
1640 DPRINTF("SAI READ CAPACITY(16)\n");
1641 memset(outbuf
, 0, req
->cmd
.xfer
);
1642 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
1644 scsi_check_condition(r
, SENSE_CODE(LUN_NOT_READY
));
1647 if ((req
->cmd
.buf
[14] & 1) == 0 && req
->cmd
.lba
) {
1648 goto illegal_request
;
1650 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1651 /* Returned value is the address of the last sector. */
1653 /* Remember the new size for read/write sanity checking. */
1654 s
->qdev
.max_lba
= nb_sectors
;
1655 outbuf
[0] = (nb_sectors
>> 56) & 0xff;
1656 outbuf
[1] = (nb_sectors
>> 48) & 0xff;
1657 outbuf
[2] = (nb_sectors
>> 40) & 0xff;
1658 outbuf
[3] = (nb_sectors
>> 32) & 0xff;
1659 outbuf
[4] = (nb_sectors
>> 24) & 0xff;
1660 outbuf
[5] = (nb_sectors
>> 16) & 0xff;
1661 outbuf
[6] = (nb_sectors
>> 8) & 0xff;
1662 outbuf
[7] = nb_sectors
& 0xff;
1665 outbuf
[10] = s
->qdev
.blocksize
>> 8;
1668 outbuf
[13] = get_physical_block_exp(&s
->qdev
.conf
);
1670 /* set TPE bit if the format supports discard */
1671 if (s
->qdev
.conf
.discard_granularity
) {
1675 /* Protection, exponent and lowest lba field left blank. */
1676 buflen
= req
->cmd
.xfer
;
1679 DPRINTF("Unsupported Service Action In\n");
1680 goto illegal_request
;
1681 case SYNCHRONIZE_CACHE
:
1682 /* The request is used as the AIO opaque value, so add a ref. */
1683 scsi_req_ref(&r
->req
);
1684 bdrv_acct_start(s
->qdev
.conf
.bs
, &r
->acct
, 0, BDRV_ACCT_FLUSH
);
1685 r
->req
.aiocb
= bdrv_aio_flush(s
->qdev
.conf
.bs
, scsi_aio_complete
, r
);
1688 DPRINTF("Seek(10) (sector %" PRId64
")\n", r
->req
.cmd
.lba
);
1689 if (r
->req
.cmd
.lba
> s
->qdev
.max_lba
) {
1694 DPRINTF("Mode Select(6) (len %lu)\n", (long)r
->req
.cmd
.xfer
);
1696 case MODE_SELECT_10
:
1697 DPRINTF("Mode Select(10) (len %lu)\n", (long)r
->req
.cmd
.xfer
);
1700 nb_sectors
= lduw_be_p(&req
->cmd
.buf
[7]);
1703 nb_sectors
= ldl_be_p(&req
->cmd
.buf
[10]) & 0xffffffffULL
;
1705 if (r
->req
.cmd
.lba
> s
->qdev
.max_lba
) {
1710 * We only support WRITE SAME with the unmap bit set for now.
1712 if (!(req
->cmd
.buf
[1] & 0x8)) {
1713 goto illegal_request
;
1716 /* The request is used as the AIO opaque value, so add a ref. */
1717 scsi_req_ref(&r
->req
);
1718 r
->req
.aiocb
= bdrv_aio_discard(s
->qdev
.conf
.bs
,
1719 r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512),
1720 nb_sectors
* (s
->qdev
.blocksize
/ 512),
1721 scsi_aio_complete
, r
);
1724 DPRINTF("Unknown SCSI command (%2.2x)\n", buf
[0]);
1725 scsi_check_condition(r
, SENSE_CODE(INVALID_OPCODE
));
1728 assert(!r
->req
.aiocb
);
1729 r
->iov
.iov_len
= MIN(buflen
, req
->cmd
.xfer
);
1730 if (r
->iov
.iov_len
== 0) {
1731 scsi_req_complete(&r
->req
, GOOD
);
1733 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
1734 assert(r
->iov
.iov_len
== req
->cmd
.xfer
);
1735 return -r
->iov
.iov_len
;
1737 return r
->iov
.iov_len
;
1741 if (r
->req
.status
== -1) {
1742 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1747 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
1751 /* Execute a scsi command. Returns the length of the data expected by the
1752 command. This will be Positive for data transfers from the device
1753 (eg. disk reads), negative for transfers to the device (eg. disk writes),
1754 and zero if the command does not transfer any data. */
1756 static int32_t scsi_disk_dma_command(SCSIRequest
*req
, uint8_t *buf
)
1758 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1759 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1765 if (s
->tray_open
|| !bdrv_is_inserted(s
->qdev
.conf
.bs
)) {
1766 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
1775 len
= r
->req
.cmd
.xfer
/ s
->qdev
.blocksize
;
1776 DPRINTF("Read (sector %" PRId64
", count %d)\n", r
->req
.cmd
.lba
, len
);
1777 if (r
->req
.cmd
.buf
[1] & 0xe0) {
1778 goto illegal_request
;
1780 if (r
->req
.cmd
.lba
> s
->qdev
.max_lba
) {
1783 r
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
1784 r
->sector_count
= len
* (s
->qdev
.blocksize
/ 512);
1793 case WRITE_VERIFY_10
:
1794 case WRITE_VERIFY_12
:
1795 case WRITE_VERIFY_16
:
1796 len
= r
->req
.cmd
.xfer
/ s
->qdev
.blocksize
;
1797 DPRINTF("Write %s(sector %" PRId64
", count %d)\n",
1798 (command
& 0xe) == 0xe ? "And Verify " : "",
1799 r
->req
.cmd
.lba
, len
);
1800 if (r
->req
.cmd
.buf
[1] & 0xe0) {
1801 goto illegal_request
;
1803 if (r
->req
.cmd
.lba
> s
->qdev
.max_lba
) {
1806 r
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
1807 r
->sector_count
= len
* (s
->qdev
.blocksize
/ 512);
1812 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1815 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
1818 if (r
->sector_count
== 0) {
1819 scsi_req_complete(&r
->req
, GOOD
);
1821 assert(r
->iov
.iov_len
== 0);
1822 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
1823 return -r
->sector_count
* 512;
1825 return r
->sector_count
* 512;
1829 static void scsi_disk_reset(DeviceState
*dev
)
1831 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
.qdev
, dev
);
1832 uint64_t nb_sectors
;
1834 scsi_device_purge_requests(&s
->qdev
, SENSE_CODE(RESET
));
1836 bdrv_get_geometry(s
->qdev
.conf
.bs
, &nb_sectors
);
1837 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1841 s
->qdev
.max_lba
= nb_sectors
;
1844 static void scsi_destroy(SCSIDevice
*dev
)
1846 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
1848 scsi_device_purge_requests(&s
->qdev
, SENSE_CODE(NO_SENSE
));
1849 blockdev_mark_auto_del(s
->qdev
.conf
.bs
);
1852 static void scsi_cd_change_media_cb(void *opaque
, bool load
)
1854 SCSIDiskState
*s
= opaque
;
1857 * When a CD gets changed, we have to report an ejected state and
1858 * then a loaded state to guests so that they detect tray
1859 * open/close and media change events. Guests that do not use
1860 * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close
1861 * states rely on this behavior.
1863 * media_changed governs the state machine used for unit attention
1864 * report. media_event is used by GET EVENT STATUS NOTIFICATION.
1866 s
->media_changed
= load
;
1867 s
->tray_open
= !load
;
1868 s
->qdev
.unit_attention
= SENSE_CODE(UNIT_ATTENTION_NO_MEDIUM
);
1869 s
->media_event
= true;
1870 s
->eject_request
= false;
1873 static void scsi_cd_eject_request_cb(void *opaque
, bool force
)
1875 SCSIDiskState
*s
= opaque
;
1877 s
->eject_request
= true;
1879 s
->tray_locked
= false;
1883 static bool scsi_cd_is_tray_open(void *opaque
)
1885 return ((SCSIDiskState
*)opaque
)->tray_open
;
1888 static bool scsi_cd_is_medium_locked(void *opaque
)
1890 return ((SCSIDiskState
*)opaque
)->tray_locked
;
1893 static const BlockDevOps scsi_cd_block_ops
= {
1894 .change_media_cb
= scsi_cd_change_media_cb
,
1895 .eject_request_cb
= scsi_cd_eject_request_cb
,
1896 .is_tray_open
= scsi_cd_is_tray_open
,
1897 .is_medium_locked
= scsi_cd_is_medium_locked
,
1900 static void scsi_disk_unit_attention_reported(SCSIDevice
*dev
)
1902 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
1903 if (s
->media_changed
) {
1904 s
->media_changed
= false;
1905 s
->qdev
.unit_attention
= SENSE_CODE(MEDIUM_CHANGED
);
1909 static int scsi_initfn(SCSIDevice
*dev
)
1911 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
1913 if (!s
->qdev
.conf
.bs
) {
1914 error_report("drive property not set");
1918 if (!(s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) &&
1919 !bdrv_is_inserted(s
->qdev
.conf
.bs
)) {
1920 error_report("Device needs media, but drive is empty");
1924 blkconf_serial(&s
->qdev
.conf
, &s
->serial
);
1925 if (blkconf_geometry(&dev
->conf
, NULL
, 65535, 255, 255) < 0) {
1930 s
->version
= g_strdup(qemu_get_version());
1933 s
->vendor
= g_strdup("QEMU");
1936 if (bdrv_is_sg(s
->qdev
.conf
.bs
)) {
1937 error_report("unwanted /dev/sg*");
1941 if (s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) {
1942 bdrv_set_dev_ops(s
->qdev
.conf
.bs
, &scsi_cd_block_ops
, s
);
1944 bdrv_set_buffer_alignment(s
->qdev
.conf
.bs
, s
->qdev
.blocksize
);
1946 bdrv_iostatus_enable(s
->qdev
.conf
.bs
);
1947 add_boot_device_path(s
->qdev
.conf
.bootindex
, &dev
->qdev
, NULL
);
1951 static int scsi_hd_initfn(SCSIDevice
*dev
)
1953 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
1954 s
->qdev
.blocksize
= s
->qdev
.conf
.logical_block_size
;
1955 s
->qdev
.type
= TYPE_DISK
;
1957 s
->product
= g_strdup("QEMU HARDDISK");
1959 return scsi_initfn(&s
->qdev
);
1962 static int scsi_cd_initfn(SCSIDevice
*dev
)
1964 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
1965 s
->qdev
.blocksize
= 2048;
1966 s
->qdev
.type
= TYPE_ROM
;
1967 s
->features
|= 1 << SCSI_DISK_F_REMOVABLE
;
1969 s
->product
= g_strdup("QEMU CD-ROM");
1971 return scsi_initfn(&s
->qdev
);
1974 static int scsi_disk_initfn(SCSIDevice
*dev
)
1978 if (!dev
->conf
.bs
) {
1979 return scsi_initfn(dev
); /* ... and die there */
1982 dinfo
= drive_get_by_blockdev(dev
->conf
.bs
);
1983 if (dinfo
->media_cd
) {
1984 return scsi_cd_initfn(dev
);
1986 return scsi_hd_initfn(dev
);
1990 static const SCSIReqOps scsi_disk_emulate_reqops
= {
1991 .size
= sizeof(SCSIDiskReq
),
1992 .free_req
= scsi_free_request
,
1993 .send_command
= scsi_disk_emulate_command
,
1994 .read_data
= scsi_disk_emulate_read_data
,
1995 .write_data
= scsi_disk_emulate_write_data
,
1996 .get_buf
= scsi_get_buf
,
1999 static const SCSIReqOps scsi_disk_dma_reqops
= {
2000 .size
= sizeof(SCSIDiskReq
),
2001 .free_req
= scsi_free_request
,
2002 .send_command
= scsi_disk_dma_command
,
2003 .read_data
= scsi_read_data
,
2004 .write_data
= scsi_write_data
,
2005 .cancel_io
= scsi_cancel_io
,
2006 .get_buf
= scsi_get_buf
,
2007 .load_request
= scsi_disk_load_request
,
2008 .save_request
= scsi_disk_save_request
,
2011 static const SCSIReqOps
*const scsi_disk_reqops_dispatch
[256] = {
2012 [TEST_UNIT_READY
] = &scsi_disk_emulate_reqops
,
2013 [INQUIRY
] = &scsi_disk_emulate_reqops
,
2014 [MODE_SENSE
] = &scsi_disk_emulate_reqops
,
2015 [MODE_SENSE_10
] = &scsi_disk_emulate_reqops
,
2016 [START_STOP
] = &scsi_disk_emulate_reqops
,
2017 [ALLOW_MEDIUM_REMOVAL
] = &scsi_disk_emulate_reqops
,
2018 [READ_CAPACITY_10
] = &scsi_disk_emulate_reqops
,
2019 [READ_TOC
] = &scsi_disk_emulate_reqops
,
2020 [READ_DVD_STRUCTURE
] = &scsi_disk_emulate_reqops
,
2021 [READ_DISC_INFORMATION
] = &scsi_disk_emulate_reqops
,
2022 [GET_CONFIGURATION
] = &scsi_disk_emulate_reqops
,
2023 [GET_EVENT_STATUS_NOTIFICATION
] = &scsi_disk_emulate_reqops
,
2024 [MECHANISM_STATUS
] = &scsi_disk_emulate_reqops
,
2025 [SERVICE_ACTION_IN_16
] = &scsi_disk_emulate_reqops
,
2026 [REQUEST_SENSE
] = &scsi_disk_emulate_reqops
,
2027 [SYNCHRONIZE_CACHE
] = &scsi_disk_emulate_reqops
,
2028 [SEEK_10
] = &scsi_disk_emulate_reqops
,
2029 [MODE_SELECT
] = &scsi_disk_emulate_reqops
,
2030 [MODE_SELECT_10
] = &scsi_disk_emulate_reqops
,
2031 [WRITE_SAME_10
] = &scsi_disk_emulate_reqops
,
2032 [WRITE_SAME_16
] = &scsi_disk_emulate_reqops
,
2034 [READ_6
] = &scsi_disk_dma_reqops
,
2035 [READ_10
] = &scsi_disk_dma_reqops
,
2036 [READ_12
] = &scsi_disk_dma_reqops
,
2037 [READ_16
] = &scsi_disk_dma_reqops
,
2038 [VERIFY_10
] = &scsi_disk_dma_reqops
,
2039 [VERIFY_12
] = &scsi_disk_dma_reqops
,
2040 [VERIFY_16
] = &scsi_disk_dma_reqops
,
2041 [WRITE_6
] = &scsi_disk_dma_reqops
,
2042 [WRITE_10
] = &scsi_disk_dma_reqops
,
2043 [WRITE_12
] = &scsi_disk_dma_reqops
,
2044 [WRITE_16
] = &scsi_disk_dma_reqops
,
2045 [WRITE_VERIFY_10
] = &scsi_disk_dma_reqops
,
2046 [WRITE_VERIFY_12
] = &scsi_disk_dma_reqops
,
2047 [WRITE_VERIFY_16
] = &scsi_disk_dma_reqops
,
2050 static SCSIRequest
*scsi_new_request(SCSIDevice
*d
, uint32_t tag
, uint32_t lun
,
2051 uint8_t *buf
, void *hba_private
)
2053 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2055 const SCSIReqOps
*ops
;
2059 DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun
, buf
[0]);
2062 for (i
= 1; i
< r
->req
.cmd
.len
; i
++) {
2063 printf(" 0x%02x", buf
[i
]);
2070 ops
= scsi_disk_reqops_dispatch
[command
];
2072 ops
= &scsi_disk_emulate_reqops
;
2074 req
= scsi_req_alloc(ops
, &s
->qdev
, tag
, lun
, hba_private
);
2079 static int get_device_type(SCSIDiskState
*s
)
2081 BlockDriverState
*bdrv
= s
->qdev
.conf
.bs
;
2084 uint8_t sensebuf
[8];
2085 sg_io_hdr_t io_header
;
2088 memset(cmd
, 0, sizeof(cmd
));
2089 memset(buf
, 0, sizeof(buf
));
2091 cmd
[4] = sizeof(buf
);
2093 memset(&io_header
, 0, sizeof(io_header
));
2094 io_header
.interface_id
= 'S';
2095 io_header
.dxfer_direction
= SG_DXFER_FROM_DEV
;
2096 io_header
.dxfer_len
= sizeof(buf
);
2097 io_header
.dxferp
= buf
;
2098 io_header
.cmdp
= cmd
;
2099 io_header
.cmd_len
= sizeof(cmd
);
2100 io_header
.mx_sb_len
= sizeof(sensebuf
);
2101 io_header
.sbp
= sensebuf
;
2102 io_header
.timeout
= 6000; /* XXX */
2104 ret
= bdrv_ioctl(bdrv
, SG_IO
, &io_header
);
2105 if (ret
< 0 || io_header
.driver_status
|| io_header
.host_status
) {
2108 s
->qdev
.type
= buf
[0];
2109 if (buf
[1] & 0x80) {
2110 s
->features
|= 1 << SCSI_DISK_F_REMOVABLE
;
2115 static int scsi_block_initfn(SCSIDevice
*dev
)
2117 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2121 if (!s
->qdev
.conf
.bs
) {
2122 error_report("scsi-block: drive property not set");
2126 /* check we are using a driver managing SG_IO (version 3 and after) */
2127 if (bdrv_ioctl(s
->qdev
.conf
.bs
, SG_GET_VERSION_NUM
, &sg_version
) < 0 ||
2128 sg_version
< 30000) {
2129 error_report("scsi-block: scsi generic interface too old");
2133 /* get device type from INQUIRY data */
2134 rc
= get_device_type(s
);
2136 error_report("scsi-block: INQUIRY failed");
2140 /* Make a guess for the block size, we'll fix it when the guest sends.
2141 * READ CAPACITY. If they don't, they likely would assume these sizes
2142 * anyway. (TODO: check in /sys).
2144 if (s
->qdev
.type
== TYPE_ROM
|| s
->qdev
.type
== TYPE_WORM
) {
2145 s
->qdev
.blocksize
= 2048;
2147 s
->qdev
.blocksize
= 512;
2149 return scsi_initfn(&s
->qdev
);
2152 static SCSIRequest
*scsi_block_new_request(SCSIDevice
*d
, uint32_t tag
,
2153 uint32_t lun
, uint8_t *buf
,
2156 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2170 case WRITE_VERIFY_10
:
2171 case WRITE_VERIFY_12
:
2172 case WRITE_VERIFY_16
:
2173 /* If we are not using O_DIRECT, we might read stale data from the
2174 * host cache if writes were made using other commands than these
2175 * ones (such as WRITE SAME or EXTENDED COPY, etc.). So, without
2176 * O_DIRECT everything must go through SG_IO.
2178 if (bdrv_get_flags(s
->qdev
.conf
.bs
) & BDRV_O_NOCACHE
) {
2182 /* MMC writing cannot be done via pread/pwrite, because it sometimes
2183 * involves writing beyond the maximum LBA or to negative LBA (lead-in).
2184 * And once you do these writes, reading from the block device is
2185 * unreliable, too. It is even possible that reads deliver random data
2186 * from the host page cache (this is probably a Linux bug).
2188 * We might use scsi_disk_dma_reqops as long as no writing commands are
2189 * seen, but performance usually isn't paramount on optical media. So,
2190 * just make scsi-block operate the same as scsi-generic for them.
2192 if (s
->qdev
.type
!= TYPE_ROM
) {
2193 return scsi_req_alloc(&scsi_disk_dma_reqops
, &s
->qdev
, tag
, lun
,
2198 return scsi_req_alloc(&scsi_generic_req_ops
, &s
->qdev
, tag
, lun
,
2203 #define DEFINE_SCSI_DISK_PROPERTIES() \
2204 DEFINE_BLOCK_PROPERTIES(SCSIDiskState, qdev.conf), \
2205 DEFINE_PROP_STRING("ver", SCSIDiskState, version), \
2206 DEFINE_PROP_STRING("serial", SCSIDiskState, serial), \
2207 DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor), \
2208 DEFINE_PROP_STRING("product", SCSIDiskState, product)
2210 static Property scsi_hd_properties
[] = {
2211 DEFINE_SCSI_DISK_PROPERTIES(),
2212 DEFINE_PROP_BIT("removable", SCSIDiskState
, features
,
2213 SCSI_DISK_F_REMOVABLE
, false),
2214 DEFINE_PROP_BIT("dpofua", SCSIDiskState
, features
,
2215 SCSI_DISK_F_DPOFUA
, false),
2216 DEFINE_PROP_HEX64("wwn", SCSIDiskState
, wwn
, 0),
2217 DEFINE_BLOCK_CHS_PROPERTIES(SCSIDiskState
, qdev
.conf
),
2218 DEFINE_PROP_END_OF_LIST(),
2221 static const VMStateDescription vmstate_scsi_disk_state
= {
2222 .name
= "scsi-disk",
2224 .minimum_version_id
= 1,
2225 .minimum_version_id_old
= 1,
2226 .fields
= (VMStateField
[]) {
2227 VMSTATE_SCSI_DEVICE(qdev
, SCSIDiskState
),
2228 VMSTATE_BOOL(media_changed
, SCSIDiskState
),
2229 VMSTATE_BOOL(media_event
, SCSIDiskState
),
2230 VMSTATE_BOOL(eject_request
, SCSIDiskState
),
2231 VMSTATE_BOOL(tray_open
, SCSIDiskState
),
2232 VMSTATE_BOOL(tray_locked
, SCSIDiskState
),
2233 VMSTATE_END_OF_LIST()
2237 static void scsi_hd_class_initfn(ObjectClass
*klass
, void *data
)
2239 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2240 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2242 sc
->init
= scsi_hd_initfn
;
2243 sc
->destroy
= scsi_destroy
;
2244 sc
->alloc_req
= scsi_new_request
;
2245 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
2246 dc
->fw_name
= "disk";
2247 dc
->desc
= "virtual SCSI disk";
2248 dc
->reset
= scsi_disk_reset
;
2249 dc
->props
= scsi_hd_properties
;
2250 dc
->vmsd
= &vmstate_scsi_disk_state
;
2253 static TypeInfo scsi_hd_info
= {
2255 .parent
= TYPE_SCSI_DEVICE
,
2256 .instance_size
= sizeof(SCSIDiskState
),
2257 .class_init
= scsi_hd_class_initfn
,
2260 static Property scsi_cd_properties
[] = {
2261 DEFINE_SCSI_DISK_PROPERTIES(),
2262 DEFINE_PROP_HEX64("wwn", SCSIDiskState
, wwn
, 0),
2263 DEFINE_PROP_END_OF_LIST(),
2266 static void scsi_cd_class_initfn(ObjectClass
*klass
, void *data
)
2268 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2269 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2271 sc
->init
= scsi_cd_initfn
;
2272 sc
->destroy
= scsi_destroy
;
2273 sc
->alloc_req
= scsi_new_request
;
2274 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
2275 dc
->fw_name
= "disk";
2276 dc
->desc
= "virtual SCSI CD-ROM";
2277 dc
->reset
= scsi_disk_reset
;
2278 dc
->props
= scsi_cd_properties
;
2279 dc
->vmsd
= &vmstate_scsi_disk_state
;
2282 static TypeInfo scsi_cd_info
= {
2284 .parent
= TYPE_SCSI_DEVICE
,
2285 .instance_size
= sizeof(SCSIDiskState
),
2286 .class_init
= scsi_cd_class_initfn
,
2290 static Property scsi_block_properties
[] = {
2291 DEFINE_PROP_DRIVE("drive", SCSIDiskState
, qdev
.conf
.bs
),
2292 DEFINE_PROP_END_OF_LIST(),
2295 static void scsi_block_class_initfn(ObjectClass
*klass
, void *data
)
2297 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2298 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2300 sc
->init
= scsi_block_initfn
;
2301 sc
->destroy
= scsi_destroy
;
2302 sc
->alloc_req
= scsi_block_new_request
;
2303 dc
->fw_name
= "disk";
2304 dc
->desc
= "SCSI block device passthrough";
2305 dc
->reset
= scsi_disk_reset
;
2306 dc
->props
= scsi_block_properties
;
2307 dc
->vmsd
= &vmstate_scsi_disk_state
;
2310 static TypeInfo scsi_block_info
= {
2311 .name
= "scsi-block",
2312 .parent
= TYPE_SCSI_DEVICE
,
2313 .instance_size
= sizeof(SCSIDiskState
),
2314 .class_init
= scsi_block_class_initfn
,
2318 static Property scsi_disk_properties
[] = {
2319 DEFINE_SCSI_DISK_PROPERTIES(),
2320 DEFINE_PROP_BIT("removable", SCSIDiskState
, features
,
2321 SCSI_DISK_F_REMOVABLE
, false),
2322 DEFINE_PROP_BIT("dpofua", SCSIDiskState
, features
,
2323 SCSI_DISK_F_DPOFUA
, false),
2324 DEFINE_PROP_HEX64("wwn", SCSIDiskState
, wwn
, 0),
2325 DEFINE_PROP_END_OF_LIST(),
2328 static void scsi_disk_class_initfn(ObjectClass
*klass
, void *data
)
2330 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2331 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2333 sc
->init
= scsi_disk_initfn
;
2334 sc
->destroy
= scsi_destroy
;
2335 sc
->alloc_req
= scsi_new_request
;
2336 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
2337 dc
->fw_name
= "disk";
2338 dc
->desc
= "virtual SCSI disk or CD-ROM (legacy)";
2339 dc
->reset
= scsi_disk_reset
;
2340 dc
->props
= scsi_disk_properties
;
2341 dc
->vmsd
= &vmstate_scsi_disk_state
;
2344 static TypeInfo scsi_disk_info
= {
2345 .name
= "scsi-disk",
2346 .parent
= TYPE_SCSI_DEVICE
,
2347 .instance_size
= sizeof(SCSIDiskState
),
2348 .class_init
= scsi_disk_class_initfn
,
2351 static void scsi_disk_register_types(void)
2353 type_register_static(&scsi_hd_info
);
2354 type_register_static(&scsi_cd_info
);
2356 type_register_static(&scsi_block_info
);
2358 type_register_static(&scsi_disk_info
);
2361 type_init(scsi_disk_register_types
)