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-report.h"
33 #include "hw/scsi/scsi.h"
34 #include "block/scsi.h"
35 #include "sysemu/sysemu.h"
36 #include "sysemu/block-backend.h"
37 #include "sysemu/blockdev.h"
38 #include "hw/block/block.h"
39 #include "sysemu/dma.h"
45 #define SCSI_WRITE_SAME_MAX 524288
46 #define SCSI_DMA_BUF_SIZE 131072
47 #define SCSI_MAX_INQUIRY_LEN 256
48 #define SCSI_MAX_MODE_LEN 256
50 #define DEFAULT_DISCARD_GRANULARITY 4096
51 #define DEFAULT_MAX_UNMAP_SIZE (1 << 30) /* 1 GB */
52 #define DEFAULT_MAX_IO_SIZE INT_MAX /* 2 GB - 1 block */
54 typedef struct SCSIDiskState SCSIDiskState
;
56 typedef struct SCSIDiskReq
{
58 /* Both sector and sector_count are in terms of qemu 512 byte blocks. */
60 uint32_t sector_count
;
68 #define SCSI_DISK_F_REMOVABLE 0
69 #define SCSI_DISK_F_DPOFUA 1
70 #define SCSI_DISK_F_NO_REMOVABLE_DEVOPS 2
82 uint64_t max_unmap_size
;
93 static int scsi_handle_rw_error(SCSIDiskReq
*r
, int error
);
95 static void scsi_free_request(SCSIRequest
*req
)
97 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
99 qemu_vfree(r
->iov
.iov_base
);
102 /* Helper function for command completion with sense. */
103 static void scsi_check_condition(SCSIDiskReq
*r
, SCSISense sense
)
105 DPRINTF("Command complete tag=0x%x sense=%d/%d/%d\n",
106 r
->req
.tag
, sense
.key
, sense
.asc
, sense
.ascq
);
107 scsi_req_build_sense(&r
->req
, sense
);
108 scsi_req_complete(&r
->req
, CHECK_CONDITION
);
111 static uint32_t scsi_init_iovec(SCSIDiskReq
*r
, size_t size
)
113 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
115 if (!r
->iov
.iov_base
) {
117 r
->iov
.iov_base
= blk_blockalign(s
->qdev
.conf
.blk
, r
->buflen
);
119 r
->iov
.iov_len
= MIN(r
->sector_count
* 512, r
->buflen
);
120 qemu_iovec_init_external(&r
->qiov
, &r
->iov
, 1);
121 return r
->qiov
.size
/ 512;
124 static void scsi_disk_save_request(QEMUFile
*f
, SCSIRequest
*req
)
126 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
128 qemu_put_be64s(f
, &r
->sector
);
129 qemu_put_be32s(f
, &r
->sector_count
);
130 qemu_put_be32s(f
, &r
->buflen
);
132 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
133 qemu_put_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
134 } else if (!req
->retry
) {
135 uint32_t len
= r
->iov
.iov_len
;
136 qemu_put_be32s(f
, &len
);
137 qemu_put_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
142 static void scsi_disk_load_request(QEMUFile
*f
, SCSIRequest
*req
)
144 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
146 qemu_get_be64s(f
, &r
->sector
);
147 qemu_get_be32s(f
, &r
->sector_count
);
148 qemu_get_be32s(f
, &r
->buflen
);
150 scsi_init_iovec(r
, r
->buflen
);
151 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
152 qemu_get_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
153 } else if (!r
->req
.retry
) {
155 qemu_get_be32s(f
, &len
);
156 r
->iov
.iov_len
= len
;
157 assert(r
->iov
.iov_len
<= r
->buflen
);
158 qemu_get_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
162 qemu_iovec_init_external(&r
->qiov
, &r
->iov
, 1);
165 static void scsi_aio_complete(void *opaque
, int ret
)
167 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
168 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
170 assert(r
->req
.aiocb
!= NULL
);
172 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
173 if (r
->req
.io_canceled
) {
174 scsi_req_cancel_complete(&r
->req
);
179 if (scsi_handle_rw_error(r
, -ret
)) {
184 scsi_req_complete(&r
->req
, GOOD
);
187 scsi_req_unref(&r
->req
);
190 static bool scsi_is_cmd_fua(SCSICommand
*cmd
)
192 switch (cmd
->buf
[0]) {
199 return (cmd
->buf
[1] & 8) != 0;
204 case WRITE_VERIFY_10
:
205 case WRITE_VERIFY_12
:
206 case WRITE_VERIFY_16
:
216 static void scsi_write_do_fua(SCSIDiskReq
*r
)
218 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
220 if (r
->req
.io_canceled
) {
221 scsi_req_cancel_complete(&r
->req
);
225 if (scsi_is_cmd_fua(&r
->req
.cmd
)) {
226 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
228 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_aio_complete
, r
);
232 scsi_req_complete(&r
->req
, GOOD
);
235 scsi_req_unref(&r
->req
);
238 static void scsi_dma_complete_noio(void *opaque
, int ret
)
240 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
241 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
243 if (r
->req
.aiocb
!= NULL
) {
245 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
247 if (r
->req
.io_canceled
) {
248 scsi_req_cancel_complete(&r
->req
);
253 if (scsi_handle_rw_error(r
, -ret
)) {
258 r
->sector
+= r
->sector_count
;
260 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
261 scsi_write_do_fua(r
);
264 scsi_req_complete(&r
->req
, GOOD
);
268 scsi_req_unref(&r
->req
);
271 static void scsi_dma_complete(void *opaque
, int ret
)
273 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
275 assert(r
->req
.aiocb
!= NULL
);
276 scsi_dma_complete_noio(opaque
, ret
);
279 static void scsi_read_complete(void * opaque
, int ret
)
281 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
282 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
285 assert(r
->req
.aiocb
!= NULL
);
287 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
288 if (r
->req
.io_canceled
) {
289 scsi_req_cancel_complete(&r
->req
);
294 if (scsi_handle_rw_error(r
, -ret
)) {
299 DPRINTF("Data ready tag=0x%x len=%zd\n", r
->req
.tag
, r
->qiov
.size
);
301 n
= r
->qiov
.size
/ 512;
303 r
->sector_count
-= n
;
304 scsi_req_data(&r
->req
, r
->qiov
.size
);
307 scsi_req_unref(&r
->req
);
310 /* Actually issue a read to the block device. */
311 static void scsi_do_read(void *opaque
, int ret
)
313 SCSIDiskReq
*r
= opaque
;
314 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
317 if (r
->req
.aiocb
!= NULL
) {
319 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
321 if (r
->req
.io_canceled
) {
322 scsi_req_cancel_complete(&r
->req
);
327 if (scsi_handle_rw_error(r
, -ret
)) {
332 /* The request is used as the AIO opaque value, so add a ref. */
333 scsi_req_ref(&r
->req
);
336 dma_acct_start(s
->qdev
.conf
.blk
, &r
->acct
, r
->req
.sg
, BLOCK_ACCT_READ
);
337 r
->req
.resid
-= r
->req
.sg
->size
;
338 r
->req
.aiocb
= dma_blk_read(s
->qdev
.conf
.blk
, r
->req
.sg
, r
->sector
,
339 scsi_dma_complete
, r
);
341 n
= scsi_init_iovec(r
, SCSI_DMA_BUF_SIZE
);
342 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
343 n
* BDRV_SECTOR_SIZE
, BLOCK_ACCT_READ
);
344 r
->req
.aiocb
= blk_aio_readv(s
->qdev
.conf
.blk
, r
->sector
, &r
->qiov
, n
,
345 scsi_read_complete
, r
);
349 scsi_req_unref(&r
->req
);
352 /* Read more data from scsi device into buffer. */
353 static void scsi_read_data(SCSIRequest
*req
)
355 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
356 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
359 DPRINTF("Read sector_count=%d\n", r
->sector_count
);
360 if (r
->sector_count
== 0) {
361 /* This also clears the sense buffer for REQUEST SENSE. */
362 scsi_req_complete(&r
->req
, GOOD
);
366 /* No data transfer may already be in progress */
367 assert(r
->req
.aiocb
== NULL
);
369 /* The request is used as the AIO opaque value, so add a ref. */
370 scsi_req_ref(&r
->req
);
371 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
372 DPRINTF("Data transfer direction invalid\n");
373 scsi_read_complete(r
, -EINVAL
);
378 scsi_read_complete(r
, -ENOMEDIUM
);
384 if (first
&& scsi_is_cmd_fua(&r
->req
.cmd
)) {
385 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
387 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_do_read
, r
);
394 * scsi_handle_rw_error has two return values. 0 means that the error
395 * must be ignored, 1 means that the error has been processed and the
396 * caller should not do anything else for this request. Note that
397 * scsi_handle_rw_error always manages its reference counts, independent
398 * of the return value.
400 static int scsi_handle_rw_error(SCSIDiskReq
*r
, int error
)
402 bool is_read
= (r
->req
.cmd
.mode
== SCSI_XFER_FROM_DEV
);
403 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
404 BlockErrorAction action
= blk_get_error_action(s
->qdev
.conf
.blk
,
407 if (action
== BLOCK_ERROR_ACTION_REPORT
) {
410 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
413 scsi_check_condition(r
, SENSE_CODE(TARGET_FAILURE
));
416 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
419 scsi_check_condition(r
, SENSE_CODE(SPACE_ALLOC_FAILED
));
422 scsi_check_condition(r
, SENSE_CODE(IO_ERROR
));
426 blk_error_action(s
->qdev
.conf
.blk
, action
, is_read
, error
);
427 if (action
== BLOCK_ERROR_ACTION_STOP
) {
428 scsi_req_retry(&r
->req
);
430 return action
!= BLOCK_ERROR_ACTION_IGNORE
;
433 static void scsi_write_complete(void * opaque
, int ret
)
435 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
436 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
439 if (r
->req
.aiocb
!= NULL
) {
441 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
443 if (r
->req
.io_canceled
) {
444 scsi_req_cancel_complete(&r
->req
);
449 if (scsi_handle_rw_error(r
, -ret
)) {
454 n
= r
->qiov
.size
/ 512;
456 r
->sector_count
-= n
;
457 if (r
->sector_count
== 0) {
458 scsi_write_do_fua(r
);
461 scsi_init_iovec(r
, SCSI_DMA_BUF_SIZE
);
462 DPRINTF("Write complete tag=0x%x more=%zd\n", r
->req
.tag
, r
->qiov
.size
);
463 scsi_req_data(&r
->req
, r
->qiov
.size
);
467 scsi_req_unref(&r
->req
);
470 static void scsi_write_data(SCSIRequest
*req
)
472 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
473 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
476 /* No data transfer may already be in progress */
477 assert(r
->req
.aiocb
== NULL
);
479 /* The request is used as the AIO opaque value, so add a ref. */
480 scsi_req_ref(&r
->req
);
481 if (r
->req
.cmd
.mode
!= SCSI_XFER_TO_DEV
) {
482 DPRINTF("Data transfer direction invalid\n");
483 scsi_write_complete(r
, -EINVAL
);
487 if (!r
->req
.sg
&& !r
->qiov
.size
) {
488 /* Called for the first time. Ask the driver to send us more data. */
490 scsi_write_complete(r
, 0);
494 scsi_write_complete(r
, -ENOMEDIUM
);
498 if (r
->req
.cmd
.buf
[0] == VERIFY_10
|| r
->req
.cmd
.buf
[0] == VERIFY_12
||
499 r
->req
.cmd
.buf
[0] == VERIFY_16
) {
501 scsi_dma_complete_noio(r
, 0);
503 scsi_write_complete(r
, 0);
509 dma_acct_start(s
->qdev
.conf
.blk
, &r
->acct
, r
->req
.sg
, BLOCK_ACCT_WRITE
);
510 r
->req
.resid
-= r
->req
.sg
->size
;
511 r
->req
.aiocb
= dma_blk_write(s
->qdev
.conf
.blk
, r
->req
.sg
, r
->sector
,
512 scsi_dma_complete
, r
);
514 n
= r
->qiov
.size
/ 512;
515 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
516 n
* BDRV_SECTOR_SIZE
, BLOCK_ACCT_WRITE
);
517 r
->req
.aiocb
= blk_aio_writev(s
->qdev
.conf
.blk
, r
->sector
, &r
->qiov
, n
,
518 scsi_write_complete
, r
);
522 /* Return a pointer to the data buffer. */
523 static uint8_t *scsi_get_buf(SCSIRequest
*req
)
525 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
527 return (uint8_t *)r
->iov
.iov_base
;
530 static int scsi_disk_emulate_inquiry(SCSIRequest
*req
, uint8_t *outbuf
)
532 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
536 if (req
->cmd
.buf
[1] & 0x1) {
537 /* Vital product data */
538 uint8_t page_code
= req
->cmd
.buf
[2];
540 outbuf
[buflen
++] = s
->qdev
.type
& 0x1f;
541 outbuf
[buflen
++] = page_code
; // this page
542 outbuf
[buflen
++] = 0x00;
543 outbuf
[buflen
++] = 0x00;
547 case 0x00: /* Supported page codes, mandatory */
549 DPRINTF("Inquiry EVPD[Supported pages] "
550 "buffer size %zd\n", req
->cmd
.xfer
);
551 outbuf
[buflen
++] = 0x00; // list of supported pages (this page)
553 outbuf
[buflen
++] = 0x80; // unit serial number
555 outbuf
[buflen
++] = 0x83; // device identification
556 if (s
->qdev
.type
== TYPE_DISK
) {
557 outbuf
[buflen
++] = 0xb0; // block limits
558 outbuf
[buflen
++] = 0xb2; // thin provisioning
562 case 0x80: /* Device serial number, optional */
567 DPRINTF("Inquiry (EVPD[Serial number] not supported\n");
571 l
= strlen(s
->serial
);
576 DPRINTF("Inquiry EVPD[Serial number] "
577 "buffer size %zd\n", req
->cmd
.xfer
);
578 memcpy(outbuf
+buflen
, s
->serial
, l
);
583 case 0x83: /* Device identification page, mandatory */
585 const char *str
= s
->serial
?: blk_name(s
->qdev
.conf
.blk
);
586 int max_len
= s
->serial
? 20 : 255 - 8;
587 int id_len
= strlen(str
);
589 if (id_len
> max_len
) {
592 DPRINTF("Inquiry EVPD[Device identification] "
593 "buffer size %zd\n", req
->cmd
.xfer
);
595 outbuf
[buflen
++] = 0x2; // ASCII
596 outbuf
[buflen
++] = 0; // not officially assigned
597 outbuf
[buflen
++] = 0; // reserved
598 outbuf
[buflen
++] = id_len
; // length of data following
599 memcpy(outbuf
+buflen
, str
, id_len
);
603 outbuf
[buflen
++] = 0x1; // Binary
604 outbuf
[buflen
++] = 0x3; // NAA
605 outbuf
[buflen
++] = 0; // reserved
606 outbuf
[buflen
++] = 8;
607 stq_be_p(&outbuf
[buflen
], s
->wwn
);
612 outbuf
[buflen
++] = 0x61; // SAS / Binary
613 outbuf
[buflen
++] = 0x93; // PIV / Target port / NAA
614 outbuf
[buflen
++] = 0; // reserved
615 outbuf
[buflen
++] = 8;
616 stq_be_p(&outbuf
[buflen
], s
->port_wwn
);
621 outbuf
[buflen
++] = 0x61; // SAS / Binary
622 outbuf
[buflen
++] = 0x94; // PIV / Target port / relative target port
623 outbuf
[buflen
++] = 0; // reserved
624 outbuf
[buflen
++] = 4;
625 stw_be_p(&outbuf
[buflen
+ 2], s
->port_index
);
630 case 0xb0: /* block limits */
632 unsigned int unmap_sectors
=
633 s
->qdev
.conf
.discard_granularity
/ s
->qdev
.blocksize
;
634 unsigned int min_io_size
=
635 s
->qdev
.conf
.min_io_size
/ s
->qdev
.blocksize
;
636 unsigned int opt_io_size
=
637 s
->qdev
.conf
.opt_io_size
/ s
->qdev
.blocksize
;
638 unsigned int max_unmap_sectors
=
639 s
->max_unmap_size
/ s
->qdev
.blocksize
;
640 unsigned int max_io_sectors
=
641 s
->max_io_size
/ s
->qdev
.blocksize
;
643 if (s
->qdev
.type
== TYPE_ROM
) {
644 DPRINTF("Inquiry (EVPD[%02X] not supported for CDROM\n",
648 /* required VPD size with unmap support */
650 memset(outbuf
+ 4, 0, buflen
- 4);
652 outbuf
[4] = 0x1; /* wsnz */
654 /* optimal transfer length granularity */
655 outbuf
[6] = (min_io_size
>> 8) & 0xff;
656 outbuf
[7] = min_io_size
& 0xff;
658 /* maximum transfer length */
659 outbuf
[8] = (max_io_sectors
>> 24) & 0xff;
660 outbuf
[9] = (max_io_sectors
>> 16) & 0xff;
661 outbuf
[10] = (max_io_sectors
>> 8) & 0xff;
662 outbuf
[11] = max_io_sectors
& 0xff;
664 /* optimal transfer length */
665 outbuf
[12] = (opt_io_size
>> 24) & 0xff;
666 outbuf
[13] = (opt_io_size
>> 16) & 0xff;
667 outbuf
[14] = (opt_io_size
>> 8) & 0xff;
668 outbuf
[15] = opt_io_size
& 0xff;
670 /* max unmap LBA count, default is 1GB */
671 outbuf
[20] = (max_unmap_sectors
>> 24) & 0xff;
672 outbuf
[21] = (max_unmap_sectors
>> 16) & 0xff;
673 outbuf
[22] = (max_unmap_sectors
>> 8) & 0xff;
674 outbuf
[23] = max_unmap_sectors
& 0xff;
676 /* max unmap descriptors, 255 fit in 4 kb with an 8-byte header. */
682 /* optimal unmap granularity */
683 outbuf
[28] = (unmap_sectors
>> 24) & 0xff;
684 outbuf
[29] = (unmap_sectors
>> 16) & 0xff;
685 outbuf
[30] = (unmap_sectors
>> 8) & 0xff;
686 outbuf
[31] = unmap_sectors
& 0xff;
688 /* max write same size */
694 outbuf
[40] = (max_io_sectors
>> 24) & 0xff;
695 outbuf
[41] = (max_io_sectors
>> 16) & 0xff;
696 outbuf
[42] = (max_io_sectors
>> 8) & 0xff;
697 outbuf
[43] = max_io_sectors
& 0xff;
700 case 0xb2: /* thin provisioning */
704 outbuf
[5] = 0xe0; /* unmap & write_same 10/16 all supported */
705 outbuf
[6] = s
->qdev
.conf
.discard_granularity
? 2 : 1;
713 assert(buflen
- start
<= 255);
714 outbuf
[start
- 1] = buflen
- start
;
718 /* Standard INQUIRY data */
719 if (req
->cmd
.buf
[2] != 0) {
724 buflen
= req
->cmd
.xfer
;
725 if (buflen
> SCSI_MAX_INQUIRY_LEN
) {
726 buflen
= SCSI_MAX_INQUIRY_LEN
;
729 outbuf
[0] = s
->qdev
.type
& 0x1f;
730 outbuf
[1] = (s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) ? 0x80 : 0;
732 strpadcpy((char *) &outbuf
[16], 16, s
->product
, ' ');
733 strpadcpy((char *) &outbuf
[8], 8, s
->vendor
, ' ');
735 memset(&outbuf
[32], 0, 4);
736 memcpy(&outbuf
[32], s
->version
, MIN(4, strlen(s
->version
)));
738 * We claim conformance to SPC-3, which is required for guests
739 * to ask for modern features like READ CAPACITY(16) or the
740 * block characteristics VPD page by default. Not all of SPC-3
741 * is actually implemented, but we're good enough.
744 outbuf
[3] = 2 | 0x10; /* Format 2, HiSup */
747 outbuf
[4] = buflen
- 5; /* Additional Length = (Len - 1) - 4 */
749 /* If the allocation length of CDB is too small,
750 the additional length is not adjusted */
754 /* Sync data transfer and TCQ. */
755 outbuf
[7] = 0x10 | (req
->bus
->info
->tcq
? 0x02 : 0);
759 static inline bool media_is_dvd(SCSIDiskState
*s
)
762 if (s
->qdev
.type
!= TYPE_ROM
) {
765 if (!blk_is_inserted(s
->qdev
.conf
.blk
)) {
771 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
772 return nb_sectors
> CD_MAX_SECTORS
;
775 static inline bool media_is_cd(SCSIDiskState
*s
)
778 if (s
->qdev
.type
!= TYPE_ROM
) {
781 if (!blk_is_inserted(s
->qdev
.conf
.blk
)) {
787 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
788 return nb_sectors
<= CD_MAX_SECTORS
;
791 static int scsi_read_disc_information(SCSIDiskState
*s
, SCSIDiskReq
*r
,
794 uint8_t type
= r
->req
.cmd
.buf
[1] & 7;
796 if (s
->qdev
.type
!= TYPE_ROM
) {
800 /* Types 1/2 are only defined for Blu-Ray. */
802 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
806 memset(outbuf
, 0, 34);
808 outbuf
[2] = 0xe; /* last session complete, disc finalized */
809 outbuf
[3] = 1; /* first track on disc */
810 outbuf
[4] = 1; /* # of sessions */
811 outbuf
[5] = 1; /* first track of last session */
812 outbuf
[6] = 1; /* last track of last session */
813 outbuf
[7] = 0x20; /* unrestricted use */
814 outbuf
[8] = 0x00; /* CD-ROM or DVD-ROM */
815 /* 9-10-11: most significant byte corresponding bytes 4-5-6 */
816 /* 12-23: not meaningful for CD-ROM or DVD-ROM */
817 /* 24-31: disc bar code */
818 /* 32: disc application code */
819 /* 33: number of OPC tables */
824 static int scsi_read_dvd_structure(SCSIDiskState
*s
, SCSIDiskReq
*r
,
827 static const int rds_caps_size
[5] = {
834 uint8_t media
= r
->req
.cmd
.buf
[1];
835 uint8_t layer
= r
->req
.cmd
.buf
[6];
836 uint8_t format
= r
->req
.cmd
.buf
[7];
839 if (s
->qdev
.type
!= TYPE_ROM
) {
843 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
847 if (format
!= 0xff) {
848 if (s
->tray_open
|| !blk_is_inserted(s
->qdev
.conf
.blk
)) {
849 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
852 if (media_is_cd(s
)) {
853 scsi_check_condition(r
, SENSE_CODE(INCOMPATIBLE_FORMAT
));
856 if (format
>= ARRAY_SIZE(rds_caps_size
)) {
859 size
= rds_caps_size
[format
];
860 memset(outbuf
, 0, size
);
865 /* Physical format information */
870 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
872 outbuf
[4] = 1; /* DVD-ROM, part version 1 */
873 outbuf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
874 outbuf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
875 outbuf
[7] = 0; /* default densities */
877 stl_be_p(&outbuf
[12], (nb_sectors
>> 2) - 1); /* end sector */
878 stl_be_p(&outbuf
[16], (nb_sectors
>> 2) - 1); /* l0 end sector */
882 case 0x01: /* DVD copyright information, all zeros */
885 case 0x03: /* BCA information - invalid field for no BCA info */
888 case 0x04: /* DVD disc manufacturing information, all zeros */
891 case 0xff: { /* List capabilities */
894 for (i
= 0; i
< ARRAY_SIZE(rds_caps_size
); i
++) {
895 if (!rds_caps_size
[i
]) {
899 outbuf
[size
+ 1] = 0x40; /* Not writable, readable */
900 stw_be_p(&outbuf
[size
+ 2], rds_caps_size
[i
]);
910 /* Size of buffer, not including 2 byte size field */
911 stw_be_p(outbuf
, size
- 2);
918 static int scsi_event_status_media(SCSIDiskState
*s
, uint8_t *outbuf
)
920 uint8_t event_code
, media_status
;
924 media_status
= MS_TRAY_OPEN
;
925 } else if (blk_is_inserted(s
->qdev
.conf
.blk
)) {
926 media_status
= MS_MEDIA_PRESENT
;
929 /* Event notification descriptor */
930 event_code
= MEC_NO_CHANGE
;
931 if (media_status
!= MS_TRAY_OPEN
) {
932 if (s
->media_event
) {
933 event_code
= MEC_NEW_MEDIA
;
934 s
->media_event
= false;
935 } else if (s
->eject_request
) {
936 event_code
= MEC_EJECT_REQUESTED
;
937 s
->eject_request
= false;
941 outbuf
[0] = event_code
;
942 outbuf
[1] = media_status
;
944 /* These fields are reserved, just clear them. */
950 static int scsi_get_event_status_notification(SCSIDiskState
*s
, SCSIDiskReq
*r
,
954 uint8_t *buf
= r
->req
.cmd
.buf
;
955 uint8_t notification_class_request
= buf
[4];
956 if (s
->qdev
.type
!= TYPE_ROM
) {
959 if ((buf
[1] & 1) == 0) {
965 outbuf
[0] = outbuf
[1] = 0;
966 outbuf
[3] = 1 << GESN_MEDIA
; /* supported events */
967 if (notification_class_request
& (1 << GESN_MEDIA
)) {
968 outbuf
[2] = GESN_MEDIA
;
969 size
+= scsi_event_status_media(s
, &outbuf
[size
]);
973 stw_be_p(outbuf
, size
- 4);
977 static int scsi_get_configuration(SCSIDiskState
*s
, uint8_t *outbuf
)
981 if (s
->qdev
.type
!= TYPE_ROM
) {
985 if (media_is_dvd(s
)) {
986 current
= MMC_PROFILE_DVD_ROM
;
987 } else if (media_is_cd(s
)) {
988 current
= MMC_PROFILE_CD_ROM
;
990 current
= MMC_PROFILE_NONE
;
993 memset(outbuf
, 0, 40);
994 stl_be_p(&outbuf
[0], 36); /* Bytes after the data length field */
995 stw_be_p(&outbuf
[6], current
);
996 /* outbuf[8] - outbuf[19]: Feature 0 - Profile list */
997 outbuf
[10] = 0x03; /* persistent, current */
998 outbuf
[11] = 8; /* two profiles */
999 stw_be_p(&outbuf
[12], MMC_PROFILE_DVD_ROM
);
1000 outbuf
[14] = (current
== MMC_PROFILE_DVD_ROM
);
1001 stw_be_p(&outbuf
[16], MMC_PROFILE_CD_ROM
);
1002 outbuf
[18] = (current
== MMC_PROFILE_CD_ROM
);
1003 /* outbuf[20] - outbuf[31]: Feature 1 - Core feature */
1004 stw_be_p(&outbuf
[20], 1);
1005 outbuf
[22] = 0x08 | 0x03; /* version 2, persistent, current */
1007 stl_be_p(&outbuf
[24], 1); /* SCSI */
1008 outbuf
[28] = 1; /* DBE = 1, mandatory */
1009 /* outbuf[32] - outbuf[39]: Feature 3 - Removable media feature */
1010 stw_be_p(&outbuf
[32], 3);
1011 outbuf
[34] = 0x08 | 0x03; /* version 2, persistent, current */
1013 outbuf
[36] = 0x39; /* tray, load=1, eject=1, unlocked at powerup, lock=1 */
1014 /* TODO: Random readable, CD read, DVD read, drive serial number,
1019 static int scsi_emulate_mechanism_status(SCSIDiskState
*s
, uint8_t *outbuf
)
1021 if (s
->qdev
.type
!= TYPE_ROM
) {
1024 memset(outbuf
, 0, 8);
1025 outbuf
[5] = 1; /* CD-ROM */
1029 static int mode_sense_page(SCSIDiskState
*s
, int page
, uint8_t **p_outbuf
,
1032 static const int mode_sense_valid
[0x3f] = {
1033 [MODE_PAGE_HD_GEOMETRY
] = (1 << TYPE_DISK
),
1034 [MODE_PAGE_FLEXIBLE_DISK_GEOMETRY
] = (1 << TYPE_DISK
),
1035 [MODE_PAGE_CACHING
] = (1 << TYPE_DISK
) | (1 << TYPE_ROM
),
1036 [MODE_PAGE_R_W_ERROR
] = (1 << TYPE_DISK
) | (1 << TYPE_ROM
),
1037 [MODE_PAGE_AUDIO_CTL
] = (1 << TYPE_ROM
),
1038 [MODE_PAGE_CAPABILITIES
] = (1 << TYPE_ROM
),
1041 uint8_t *p
= *p_outbuf
+ 2;
1044 if ((mode_sense_valid
[page
] & (1 << s
->qdev
.type
)) == 0) {
1049 * If Changeable Values are requested, a mask denoting those mode parameters
1050 * that are changeable shall be returned. As we currently don't support
1051 * parameter changes via MODE_SELECT all bits are returned set to zero.
1052 * The buffer was already menset to zero by the caller of this function.
1054 * The offsets here are off by two compared to the descriptions in the
1055 * SCSI specs, because those include a 2-byte header. This is unfortunate,
1056 * but it is done so that offsets are consistent within our implementation
1057 * of MODE SENSE and MODE SELECT. MODE SELECT has to deal with both
1058 * 2-byte and 4-byte headers.
1061 case MODE_PAGE_HD_GEOMETRY
:
1063 if (page_control
== 1) { /* Changeable Values */
1066 /* if a geometry hint is available, use it */
1067 p
[0] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
1068 p
[1] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1069 p
[2] = s
->qdev
.conf
.cyls
& 0xff;
1070 p
[3] = s
->qdev
.conf
.heads
& 0xff;
1071 /* Write precomp start cylinder, disabled */
1072 p
[4] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
1073 p
[5] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1074 p
[6] = s
->qdev
.conf
.cyls
& 0xff;
1075 /* Reduced current start cylinder, disabled */
1076 p
[7] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
1077 p
[8] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1078 p
[9] = s
->qdev
.conf
.cyls
& 0xff;
1079 /* Device step rate [ns], 200ns */
1082 /* Landing zone cylinder */
1086 /* Medium rotation rate [rpm], 5400 rpm */
1087 p
[18] = (5400 >> 8) & 0xff;
1088 p
[19] = 5400 & 0xff;
1091 case MODE_PAGE_FLEXIBLE_DISK_GEOMETRY
:
1093 if (page_control
== 1) { /* Changeable Values */
1096 /* Transfer rate [kbit/s], 5Mbit/s */
1099 /* if a geometry hint is available, use it */
1100 p
[2] = s
->qdev
.conf
.heads
& 0xff;
1101 p
[3] = s
->qdev
.conf
.secs
& 0xff;
1102 p
[4] = s
->qdev
.blocksize
>> 8;
1103 p
[6] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1104 p
[7] = s
->qdev
.conf
.cyls
& 0xff;
1105 /* Write precomp start cylinder, disabled */
1106 p
[8] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1107 p
[9] = s
->qdev
.conf
.cyls
& 0xff;
1108 /* Reduced current start cylinder, disabled */
1109 p
[10] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1110 p
[11] = s
->qdev
.conf
.cyls
& 0xff;
1111 /* Device step rate [100us], 100us */
1114 /* Device step pulse width [us], 1us */
1116 /* Device head settle delay [100us], 100us */
1119 /* Motor on delay [0.1s], 0.1s */
1121 /* Motor off delay [0.1s], 0.1s */
1123 /* Medium rotation rate [rpm], 5400 rpm */
1124 p
[26] = (5400 >> 8) & 0xff;
1125 p
[27] = 5400 & 0xff;
1128 case MODE_PAGE_CACHING
:
1130 if (page_control
== 1 || /* Changeable Values */
1131 blk_enable_write_cache(s
->qdev
.conf
.blk
)) {
1136 case MODE_PAGE_R_W_ERROR
:
1138 if (page_control
== 1) { /* Changeable Values */
1141 p
[0] = 0x80; /* Automatic Write Reallocation Enabled */
1142 if (s
->qdev
.type
== TYPE_ROM
) {
1143 p
[1] = 0x20; /* Read Retry Count */
1147 case MODE_PAGE_AUDIO_CTL
:
1151 case MODE_PAGE_CAPABILITIES
:
1153 if (page_control
== 1) { /* Changeable Values */
1157 p
[0] = 0x3b; /* CD-R & CD-RW read */
1158 p
[1] = 0; /* Writing not supported */
1159 p
[2] = 0x7f; /* Audio, composite, digital out,
1160 mode 2 form 1&2, multi session */
1161 p
[3] = 0xff; /* CD DA, DA accurate, RW supported,
1162 RW corrected, C2 errors, ISRC,
1164 p
[4] = 0x2d | (s
->tray_locked
? 2 : 0);
1165 /* Locking supported, jumper present, eject, tray */
1166 p
[5] = 0; /* no volume & mute control, no
1168 p
[6] = (50 * 176) >> 8; /* 50x read speed */
1169 p
[7] = (50 * 176) & 0xff;
1170 p
[8] = 2 >> 8; /* Two volume levels */
1172 p
[10] = 2048 >> 8; /* 2M buffer */
1173 p
[11] = 2048 & 0xff;
1174 p
[12] = (16 * 176) >> 8; /* 16x read speed current */
1175 p
[13] = (16 * 176) & 0xff;
1176 p
[16] = (16 * 176) >> 8; /* 16x write speed */
1177 p
[17] = (16 * 176) & 0xff;
1178 p
[18] = (16 * 176) >> 8; /* 16x write speed current */
1179 p
[19] = (16 * 176) & 0xff;
1186 assert(length
< 256);
1187 (*p_outbuf
)[0] = page
;
1188 (*p_outbuf
)[1] = length
;
1189 *p_outbuf
+= length
+ 2;
1193 static int scsi_disk_emulate_mode_sense(SCSIDiskReq
*r
, uint8_t *outbuf
)
1195 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1196 uint64_t nb_sectors
;
1198 int page
, buflen
, ret
, page_control
;
1200 uint8_t dev_specific_param
;
1202 dbd
= (r
->req
.cmd
.buf
[1] & 0x8) != 0;
1203 page
= r
->req
.cmd
.buf
[2] & 0x3f;
1204 page_control
= (r
->req
.cmd
.buf
[2] & 0xc0) >> 6;
1205 DPRINTF("Mode Sense(%d) (page %d, xfer %zd, page_control %d)\n",
1206 (r
->req
.cmd
.buf
[0] == MODE_SENSE
) ? 6 : 10, page
, r
->req
.cmd
.xfer
, page_control
);
1207 memset(outbuf
, 0, r
->req
.cmd
.xfer
);
1210 if (s
->qdev
.type
== TYPE_DISK
) {
1211 dev_specific_param
= s
->features
& (1 << SCSI_DISK_F_DPOFUA
) ? 0x10 : 0;
1212 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
1213 dev_specific_param
|= 0x80; /* Readonly. */
1216 /* MMC prescribes that CD/DVD drives have no block descriptors,
1217 * and defines no device-specific parameter. */
1218 dev_specific_param
= 0x00;
1222 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1223 p
[1] = 0; /* Default media type. */
1224 p
[2] = dev_specific_param
;
1225 p
[3] = 0; /* Block descriptor length. */
1227 } else { /* MODE_SENSE_10 */
1228 p
[2] = 0; /* Default media type. */
1229 p
[3] = dev_specific_param
;
1230 p
[6] = p
[7] = 0; /* Block descriptor length. */
1234 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
1235 if (!dbd
&& nb_sectors
) {
1236 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1237 outbuf
[3] = 8; /* Block descriptor length */
1238 } else { /* MODE_SENSE_10 */
1239 outbuf
[7] = 8; /* Block descriptor length */
1241 nb_sectors
/= (s
->qdev
.blocksize
/ 512);
1242 if (nb_sectors
> 0xffffff) {
1245 p
[0] = 0; /* media density code */
1246 p
[1] = (nb_sectors
>> 16) & 0xff;
1247 p
[2] = (nb_sectors
>> 8) & 0xff;
1248 p
[3] = nb_sectors
& 0xff;
1249 p
[4] = 0; /* reserved */
1250 p
[5] = 0; /* bytes 5-7 are the sector size in bytes */
1251 p
[6] = s
->qdev
.blocksize
>> 8;
1256 if (page_control
== 3) {
1258 scsi_check_condition(r
, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED
));
1263 for (page
= 0; page
<= 0x3e; page
++) {
1264 mode_sense_page(s
, page
, &p
, page_control
);
1267 ret
= mode_sense_page(s
, page
, &p
, page_control
);
1273 buflen
= p
- outbuf
;
1275 * The mode data length field specifies the length in bytes of the
1276 * following data that is available to be transferred. The mode data
1277 * length does not include itself.
1279 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1280 outbuf
[0] = buflen
- 1;
1281 } else { /* MODE_SENSE_10 */
1282 outbuf
[0] = ((buflen
- 2) >> 8) & 0xff;
1283 outbuf
[1] = (buflen
- 2) & 0xff;
1288 static int scsi_disk_emulate_read_toc(SCSIRequest
*req
, uint8_t *outbuf
)
1290 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1291 int start_track
, format
, msf
, toclen
;
1292 uint64_t nb_sectors
;
1294 msf
= req
->cmd
.buf
[1] & 2;
1295 format
= req
->cmd
.buf
[2] & 0xf;
1296 start_track
= req
->cmd
.buf
[6];
1297 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
1298 DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track
, format
, msf
>> 1);
1299 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1302 toclen
= cdrom_read_toc(nb_sectors
, outbuf
, msf
, start_track
);
1305 /* multi session : only a single session defined */
1307 memset(outbuf
, 0, 12);
1313 toclen
= cdrom_read_toc_raw(nb_sectors
, outbuf
, msf
, start_track
);
1321 static int scsi_disk_emulate_start_stop(SCSIDiskReq
*r
)
1323 SCSIRequest
*req
= &r
->req
;
1324 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1325 bool start
= req
->cmd
.buf
[4] & 1;
1326 bool loej
= req
->cmd
.buf
[4] & 2; /* load on start, eject on !start */
1327 int pwrcnd
= req
->cmd
.buf
[4] & 0xf0;
1330 /* eject/load only happens for power condition == 0 */
1334 if ((s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) && loej
) {
1335 if (!start
&& !s
->tray_open
&& s
->tray_locked
) {
1336 scsi_check_condition(r
,
1337 blk_is_inserted(s
->qdev
.conf
.blk
)
1338 ? SENSE_CODE(ILLEGAL_REQ_REMOVAL_PREVENTED
)
1339 : SENSE_CODE(NOT_READY_REMOVAL_PREVENTED
));
1343 if (s
->tray_open
!= !start
) {
1344 blk_eject(s
->qdev
.conf
.blk
, !start
);
1345 s
->tray_open
= !start
;
1351 static void scsi_disk_emulate_read_data(SCSIRequest
*req
)
1353 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1354 int buflen
= r
->iov
.iov_len
;
1357 DPRINTF("Read buf_len=%d\n", buflen
);
1360 scsi_req_data(&r
->req
, buflen
);
1364 /* This also clears the sense buffer for REQUEST SENSE. */
1365 scsi_req_complete(&r
->req
, GOOD
);
1368 static int scsi_disk_check_mode_select(SCSIDiskState
*s
, int page
,
1369 uint8_t *inbuf
, int inlen
)
1371 uint8_t mode_current
[SCSI_MAX_MODE_LEN
];
1372 uint8_t mode_changeable
[SCSI_MAX_MODE_LEN
];
1374 int len
, expected_len
, changeable_len
, i
;
1376 /* The input buffer does not include the page header, so it is
1379 expected_len
= inlen
+ 2;
1380 if (expected_len
> SCSI_MAX_MODE_LEN
) {
1385 memset(mode_current
, 0, inlen
+ 2);
1386 len
= mode_sense_page(s
, page
, &p
, 0);
1387 if (len
< 0 || len
!= expected_len
) {
1391 p
= mode_changeable
;
1392 memset(mode_changeable
, 0, inlen
+ 2);
1393 changeable_len
= mode_sense_page(s
, page
, &p
, 1);
1394 assert(changeable_len
== len
);
1396 /* Check that unchangeable bits are the same as what MODE SENSE
1399 for (i
= 2; i
< len
; i
++) {
1400 if (((mode_current
[i
] ^ inbuf
[i
- 2]) & ~mode_changeable
[i
]) != 0) {
1407 static void scsi_disk_apply_mode_select(SCSIDiskState
*s
, int page
, uint8_t *p
)
1410 case MODE_PAGE_CACHING
:
1411 blk_set_enable_write_cache(s
->qdev
.conf
.blk
, (p
[0] & 4) != 0);
1419 static int mode_select_pages(SCSIDiskReq
*r
, uint8_t *p
, int len
, bool change
)
1421 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1424 int page
, subpage
, page_len
;
1426 /* Parse both possible formats for the mode page headers. */
1430 goto invalid_param_len
;
1433 page_len
= lduw_be_p(&p
[2]);
1438 goto invalid_param_len
;
1449 if (page_len
> len
) {
1450 goto invalid_param_len
;
1454 if (scsi_disk_check_mode_select(s
, page
, p
, page_len
) < 0) {
1458 scsi_disk_apply_mode_select(s
, page
, p
);
1467 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM
));
1471 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1475 static void scsi_disk_emulate_mode_select(SCSIDiskReq
*r
, uint8_t *inbuf
)
1477 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1479 int cmd
= r
->req
.cmd
.buf
[0];
1480 int len
= r
->req
.cmd
.xfer
;
1481 int hdr_len
= (cmd
== MODE_SELECT
? 4 : 8);
1485 /* We only support PF=1, SP=0. */
1486 if ((r
->req
.cmd
.buf
[1] & 0x11) != 0x10) {
1490 if (len
< hdr_len
) {
1491 goto invalid_param_len
;
1494 bd_len
= (cmd
== MODE_SELECT
? p
[3] : lduw_be_p(&p
[6]));
1498 goto invalid_param_len
;
1500 if (bd_len
!= 0 && bd_len
!= 8) {
1507 /* Ensure no change is made if there is an error! */
1508 for (pass
= 0; pass
< 2; pass
++) {
1509 if (mode_select_pages(r
, p
, len
, pass
== 1) < 0) {
1514 if (!blk_enable_write_cache(s
->qdev
.conf
.blk
)) {
1515 /* The request is used as the AIO opaque value, so add a ref. */
1516 scsi_req_ref(&r
->req
);
1517 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
1519 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_aio_complete
, r
);
1523 scsi_req_complete(&r
->req
, GOOD
);
1527 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM
));
1531 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1535 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1538 static inline bool check_lba_range(SCSIDiskState
*s
,
1539 uint64_t sector_num
, uint32_t nb_sectors
)
1542 * The first line tests that no overflow happens when computing the last
1543 * sector. The second line tests that the last accessed sector is in
1546 * Careful, the computations should not underflow for nb_sectors == 0,
1547 * and a 0-block read to the first LBA beyond the end of device is
1550 return (sector_num
<= sector_num
+ nb_sectors
&&
1551 sector_num
+ nb_sectors
<= s
->qdev
.max_lba
+ 1);
1554 typedef struct UnmapCBData
{
1560 static void scsi_unmap_complete(void *opaque
, int ret
)
1562 UnmapCBData
*data
= opaque
;
1563 SCSIDiskReq
*r
= data
->r
;
1564 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1565 uint64_t sector_num
;
1566 uint32_t nb_sectors
;
1568 r
->req
.aiocb
= NULL
;
1569 if (r
->req
.io_canceled
) {
1570 scsi_req_cancel_complete(&r
->req
);
1575 if (scsi_handle_rw_error(r
, -ret
)) {
1580 if (data
->count
> 0) {
1581 sector_num
= ldq_be_p(&data
->inbuf
[0]);
1582 nb_sectors
= ldl_be_p(&data
->inbuf
[8]) & 0xffffffffULL
;
1583 if (!check_lba_range(s
, sector_num
, nb_sectors
)) {
1584 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
1588 r
->req
.aiocb
= blk_aio_discard(s
->qdev
.conf
.blk
,
1589 sector_num
* (s
->qdev
.blocksize
/ 512),
1590 nb_sectors
* (s
->qdev
.blocksize
/ 512),
1591 scsi_unmap_complete
, data
);
1597 scsi_req_complete(&r
->req
, GOOD
);
1600 scsi_req_unref(&r
->req
);
1604 static void scsi_disk_emulate_unmap(SCSIDiskReq
*r
, uint8_t *inbuf
)
1606 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1608 int len
= r
->req
.cmd
.xfer
;
1611 /* Reject ANCHOR=1. */
1612 if (r
->req
.cmd
.buf
[1] & 0x1) {
1617 goto invalid_param_len
;
1619 if (len
< lduw_be_p(&p
[0]) + 2) {
1620 goto invalid_param_len
;
1622 if (len
< lduw_be_p(&p
[2]) + 8) {
1623 goto invalid_param_len
;
1625 if (lduw_be_p(&p
[2]) & 15) {
1626 goto invalid_param_len
;
1629 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
1630 scsi_check_condition(r
, SENSE_CODE(WRITE_PROTECTED
));
1634 data
= g_new0(UnmapCBData
, 1);
1636 data
->inbuf
= &p
[8];
1637 data
->count
= lduw_be_p(&p
[2]) >> 4;
1639 /* The matching unref is in scsi_unmap_complete, before data is freed. */
1640 scsi_req_ref(&r
->req
);
1641 scsi_unmap_complete(data
, 0);
1645 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1649 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1652 typedef struct WriteSameCBData
{
1660 static void scsi_write_same_complete(void *opaque
, int ret
)
1662 WriteSameCBData
*data
= opaque
;
1663 SCSIDiskReq
*r
= data
->r
;
1664 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1666 assert(r
->req
.aiocb
!= NULL
);
1667 r
->req
.aiocb
= NULL
;
1668 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
1669 if (r
->req
.io_canceled
) {
1670 scsi_req_cancel_complete(&r
->req
);
1675 if (scsi_handle_rw_error(r
, -ret
)) {
1680 data
->nb_sectors
-= data
->iov
.iov_len
/ 512;
1681 data
->sector
+= data
->iov
.iov_len
/ 512;
1682 data
->iov
.iov_len
= MIN(data
->nb_sectors
* 512, data
->iov
.iov_len
);
1683 if (data
->iov
.iov_len
) {
1684 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
1685 data
->iov
.iov_len
, BLOCK_ACCT_WRITE
);
1686 r
->req
.aiocb
= blk_aio_writev(s
->qdev
.conf
.blk
, data
->sector
,
1687 &data
->qiov
, data
->iov
.iov_len
/ 512,
1688 scsi_write_same_complete
, data
);
1692 scsi_req_complete(&r
->req
, GOOD
);
1695 scsi_req_unref(&r
->req
);
1696 qemu_vfree(data
->iov
.iov_base
);
1700 static void scsi_disk_emulate_write_same(SCSIDiskReq
*r
, uint8_t *inbuf
)
1702 SCSIRequest
*req
= &r
->req
;
1703 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1704 uint32_t nb_sectors
= scsi_data_cdb_xfer(r
->req
.cmd
.buf
);
1705 WriteSameCBData
*data
;
1709 /* Fail if PBDATA=1 or LBDATA=1 or ANCHOR=1. */
1710 if (nb_sectors
== 0 || (req
->cmd
.buf
[1] & 0x16)) {
1711 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1715 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
1716 scsi_check_condition(r
, SENSE_CODE(WRITE_PROTECTED
));
1719 if (!check_lba_range(s
, r
->req
.cmd
.lba
, nb_sectors
)) {
1720 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
1724 if (buffer_is_zero(inbuf
, s
->qdev
.blocksize
)) {
1725 int flags
= (req
->cmd
.buf
[1] & 0x8) ? BDRV_REQ_MAY_UNMAP
: 0;
1727 /* The request is used as the AIO opaque value, so add a ref. */
1728 scsi_req_ref(&r
->req
);
1729 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
1730 nb_sectors
* s
->qdev
.blocksize
,
1732 r
->req
.aiocb
= blk_aio_write_zeroes(s
->qdev
.conf
.blk
,
1733 r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512),
1734 nb_sectors
* (s
->qdev
.blocksize
/ 512),
1735 flags
, scsi_aio_complete
, r
);
1739 data
= g_new0(WriteSameCBData
, 1);
1741 data
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
1742 data
->nb_sectors
= nb_sectors
* (s
->qdev
.blocksize
/ 512);
1743 data
->iov
.iov_len
= MIN(data
->nb_sectors
* 512, SCSI_WRITE_SAME_MAX
);
1744 data
->iov
.iov_base
= buf
= blk_blockalign(s
->qdev
.conf
.blk
,
1746 qemu_iovec_init_external(&data
->qiov
, &data
->iov
, 1);
1748 for (i
= 0; i
< data
->iov
.iov_len
; i
+= s
->qdev
.blocksize
) {
1749 memcpy(&buf
[i
], inbuf
, s
->qdev
.blocksize
);
1752 scsi_req_ref(&r
->req
);
1753 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
1754 data
->iov
.iov_len
, BLOCK_ACCT_WRITE
);
1755 r
->req
.aiocb
= blk_aio_writev(s
->qdev
.conf
.blk
, data
->sector
,
1756 &data
->qiov
, data
->iov
.iov_len
/ 512,
1757 scsi_write_same_complete
, data
);
1760 static void scsi_disk_emulate_write_data(SCSIRequest
*req
)
1762 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1764 if (r
->iov
.iov_len
) {
1765 int buflen
= r
->iov
.iov_len
;
1766 DPRINTF("Write buf_len=%d\n", buflen
);
1768 scsi_req_data(&r
->req
, buflen
);
1772 switch (req
->cmd
.buf
[0]) {
1774 case MODE_SELECT_10
:
1775 /* This also clears the sense buffer for REQUEST SENSE. */
1776 scsi_disk_emulate_mode_select(r
, r
->iov
.iov_base
);
1780 scsi_disk_emulate_unmap(r
, r
->iov
.iov_base
);
1786 if (r
->req
.status
== -1) {
1787 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1793 scsi_disk_emulate_write_same(r
, r
->iov
.iov_base
);
1801 static int32_t scsi_disk_emulate_command(SCSIRequest
*req
, uint8_t *buf
)
1803 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1804 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1805 uint64_t nb_sectors
;
1809 switch (req
->cmd
.buf
[0]) {
1818 case ALLOW_MEDIUM_REMOVAL
:
1819 case GET_CONFIGURATION
:
1820 case GET_EVENT_STATUS_NOTIFICATION
:
1821 case MECHANISM_STATUS
:
1826 if (s
->tray_open
|| !blk_is_inserted(s
->qdev
.conf
.blk
)) {
1827 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
1834 * FIXME: we shouldn't return anything bigger than 4k, but the code
1835 * requires the buffer to be as big as req->cmd.xfer in several
1836 * places. So, do not allow CDBs with a very large ALLOCATION
1837 * LENGTH. The real fix would be to modify scsi_read_data and
1838 * dma_buf_read, so that they return data beyond the buflen
1841 if (req
->cmd
.xfer
> 65536) {
1842 goto illegal_request
;
1844 r
->buflen
= MAX(4096, req
->cmd
.xfer
);
1846 if (!r
->iov
.iov_base
) {
1847 r
->iov
.iov_base
= blk_blockalign(s
->qdev
.conf
.blk
, r
->buflen
);
1850 buflen
= req
->cmd
.xfer
;
1851 outbuf
= r
->iov
.iov_base
;
1852 memset(outbuf
, 0, r
->buflen
);
1853 switch (req
->cmd
.buf
[0]) {
1854 case TEST_UNIT_READY
:
1855 assert(!s
->tray_open
&& blk_is_inserted(s
->qdev
.conf
.blk
));
1858 buflen
= scsi_disk_emulate_inquiry(req
, outbuf
);
1860 goto illegal_request
;
1865 buflen
= scsi_disk_emulate_mode_sense(r
, outbuf
);
1867 goto illegal_request
;
1871 buflen
= scsi_disk_emulate_read_toc(req
, outbuf
);
1873 goto illegal_request
;
1877 if (req
->cmd
.buf
[1] & 1) {
1878 goto illegal_request
;
1882 if (req
->cmd
.buf
[1] & 3) {
1883 goto illegal_request
;
1887 if (req
->cmd
.buf
[1] & 1) {
1888 goto illegal_request
;
1892 if (req
->cmd
.buf
[1] & 3) {
1893 goto illegal_request
;
1897 if (scsi_disk_emulate_start_stop(r
) < 0) {
1901 case ALLOW_MEDIUM_REMOVAL
:
1902 s
->tray_locked
= req
->cmd
.buf
[4] & 1;
1903 blk_lock_medium(s
->qdev
.conf
.blk
, req
->cmd
.buf
[4] & 1);
1905 case READ_CAPACITY_10
:
1906 /* The normal LEN field for this command is zero. */
1907 memset(outbuf
, 0, 8);
1908 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
1910 scsi_check_condition(r
, SENSE_CODE(LUN_NOT_READY
));
1913 if ((req
->cmd
.buf
[8] & 1) == 0 && req
->cmd
.lba
) {
1914 goto illegal_request
;
1916 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1917 /* Returned value is the address of the last sector. */
1919 /* Remember the new size for read/write sanity checking. */
1920 s
->qdev
.max_lba
= nb_sectors
;
1921 /* Clip to 2TB, instead of returning capacity modulo 2TB. */
1922 if (nb_sectors
> UINT32_MAX
) {
1923 nb_sectors
= UINT32_MAX
;
1925 outbuf
[0] = (nb_sectors
>> 24) & 0xff;
1926 outbuf
[1] = (nb_sectors
>> 16) & 0xff;
1927 outbuf
[2] = (nb_sectors
>> 8) & 0xff;
1928 outbuf
[3] = nb_sectors
& 0xff;
1931 outbuf
[6] = s
->qdev
.blocksize
>> 8;
1935 /* Just return "NO SENSE". */
1936 buflen
= scsi_build_sense(NULL
, 0, outbuf
, r
->buflen
,
1937 (req
->cmd
.buf
[1] & 1) == 0);
1939 goto illegal_request
;
1942 case MECHANISM_STATUS
:
1943 buflen
= scsi_emulate_mechanism_status(s
, outbuf
);
1945 goto illegal_request
;
1948 case GET_CONFIGURATION
:
1949 buflen
= scsi_get_configuration(s
, outbuf
);
1951 goto illegal_request
;
1954 case GET_EVENT_STATUS_NOTIFICATION
:
1955 buflen
= scsi_get_event_status_notification(s
, r
, outbuf
);
1957 goto illegal_request
;
1960 case READ_DISC_INFORMATION
:
1961 buflen
= scsi_read_disc_information(s
, r
, outbuf
);
1963 goto illegal_request
;
1966 case READ_DVD_STRUCTURE
:
1967 buflen
= scsi_read_dvd_structure(s
, r
, outbuf
);
1969 goto illegal_request
;
1972 case SERVICE_ACTION_IN_16
:
1973 /* Service Action In subcommands. */
1974 if ((req
->cmd
.buf
[1] & 31) == SAI_READ_CAPACITY_16
) {
1975 DPRINTF("SAI READ CAPACITY(16)\n");
1976 memset(outbuf
, 0, req
->cmd
.xfer
);
1977 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
1979 scsi_check_condition(r
, SENSE_CODE(LUN_NOT_READY
));
1982 if ((req
->cmd
.buf
[14] & 1) == 0 && req
->cmd
.lba
) {
1983 goto illegal_request
;
1985 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1986 /* Returned value is the address of the last sector. */
1988 /* Remember the new size for read/write sanity checking. */
1989 s
->qdev
.max_lba
= nb_sectors
;
1990 outbuf
[0] = (nb_sectors
>> 56) & 0xff;
1991 outbuf
[1] = (nb_sectors
>> 48) & 0xff;
1992 outbuf
[2] = (nb_sectors
>> 40) & 0xff;
1993 outbuf
[3] = (nb_sectors
>> 32) & 0xff;
1994 outbuf
[4] = (nb_sectors
>> 24) & 0xff;
1995 outbuf
[5] = (nb_sectors
>> 16) & 0xff;
1996 outbuf
[6] = (nb_sectors
>> 8) & 0xff;
1997 outbuf
[7] = nb_sectors
& 0xff;
2000 outbuf
[10] = s
->qdev
.blocksize
>> 8;
2003 outbuf
[13] = get_physical_block_exp(&s
->qdev
.conf
);
2005 /* set TPE bit if the format supports discard */
2006 if (s
->qdev
.conf
.discard_granularity
) {
2010 /* Protection, exponent and lowest lba field left blank. */
2013 DPRINTF("Unsupported Service Action In\n");
2014 goto illegal_request
;
2015 case SYNCHRONIZE_CACHE
:
2016 /* The request is used as the AIO opaque value, so add a ref. */
2017 scsi_req_ref(&r
->req
);
2018 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
2020 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_aio_complete
, r
);
2023 DPRINTF("Seek(10) (sector %" PRId64
")\n", r
->req
.cmd
.lba
);
2024 if (r
->req
.cmd
.lba
> s
->qdev
.max_lba
) {
2029 DPRINTF("Mode Select(6) (len %lu)\n", (long)r
->req
.cmd
.xfer
);
2031 case MODE_SELECT_10
:
2032 DPRINTF("Mode Select(10) (len %lu)\n", (long)r
->req
.cmd
.xfer
);
2035 DPRINTF("Unmap (len %lu)\n", (long)r
->req
.cmd
.xfer
);
2040 DPRINTF("Verify (bytchk %d)\n", (req
->cmd
.buf
[1] >> 1) & 3);
2041 if (req
->cmd
.buf
[1] & 6) {
2042 goto illegal_request
;
2047 DPRINTF("WRITE SAME %d (len %lu)\n",
2048 req
->cmd
.buf
[0] == WRITE_SAME_10
? 10 : 16,
2049 (long)r
->req
.cmd
.xfer
);
2052 DPRINTF("Unknown SCSI command (%2.2x=%s)\n", buf
[0],
2053 scsi_command_name(buf
[0]));
2054 scsi_check_condition(r
, SENSE_CODE(INVALID_OPCODE
));
2057 assert(!r
->req
.aiocb
);
2058 r
->iov
.iov_len
= MIN(r
->buflen
, req
->cmd
.xfer
);
2059 if (r
->iov
.iov_len
== 0) {
2060 scsi_req_complete(&r
->req
, GOOD
);
2062 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
2063 assert(r
->iov
.iov_len
== req
->cmd
.xfer
);
2064 return -r
->iov
.iov_len
;
2066 return r
->iov
.iov_len
;
2070 if (r
->req
.status
== -1) {
2071 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
2076 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
2080 /* Execute a scsi command. Returns the length of the data expected by the
2081 command. This will be Positive for data transfers from the device
2082 (eg. disk reads), negative for transfers to the device (eg. disk writes),
2083 and zero if the command does not transfer any data. */
2085 static int32_t scsi_disk_dma_command(SCSIRequest
*req
, uint8_t *buf
)
2087 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
2088 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
2094 if (s
->tray_open
|| !blk_is_inserted(s
->qdev
.conf
.blk
)) {
2095 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
2099 len
= scsi_data_cdb_xfer(r
->req
.cmd
.buf
);
2105 DPRINTF("Read (sector %" PRId64
", count %u)\n", r
->req
.cmd
.lba
, len
);
2106 if (r
->req
.cmd
.buf
[1] & 0xe0) {
2107 goto illegal_request
;
2109 if (!check_lba_range(s
, r
->req
.cmd
.lba
, len
)) {
2112 r
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
2113 r
->sector_count
= len
* (s
->qdev
.blocksize
/ 512);
2119 case WRITE_VERIFY_10
:
2120 case WRITE_VERIFY_12
:
2121 case WRITE_VERIFY_16
:
2122 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
2123 scsi_check_condition(r
, SENSE_CODE(WRITE_PROTECTED
));
2126 DPRINTF("Write %s(sector %" PRId64
", count %u)\n",
2127 (command
& 0xe) == 0xe ? "And Verify " : "",
2128 r
->req
.cmd
.lba
, len
);
2129 if (r
->req
.cmd
.buf
[1] & 0xe0) {
2130 goto illegal_request
;
2132 if (!check_lba_range(s
, r
->req
.cmd
.lba
, len
)) {
2135 r
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
2136 r
->sector_count
= len
* (s
->qdev
.blocksize
/ 512);
2141 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
2144 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
2147 if (r
->sector_count
== 0) {
2148 scsi_req_complete(&r
->req
, GOOD
);
2150 assert(r
->iov
.iov_len
== 0);
2151 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
2152 return -r
->sector_count
* 512;
2154 return r
->sector_count
* 512;
2158 static void scsi_disk_reset(DeviceState
*dev
)
2160 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
.qdev
, dev
);
2161 uint64_t nb_sectors
;
2163 scsi_device_purge_requests(&s
->qdev
, SENSE_CODE(RESET
));
2165 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
2166 nb_sectors
/= s
->qdev
.blocksize
/ 512;
2170 s
->qdev
.max_lba
= nb_sectors
;
2171 /* reset tray statuses */
2176 static void scsi_disk_resize_cb(void *opaque
)
2178 SCSIDiskState
*s
= opaque
;
2180 /* SPC lists this sense code as available only for
2181 * direct-access devices.
2183 if (s
->qdev
.type
== TYPE_DISK
) {
2184 scsi_device_report_change(&s
->qdev
, SENSE_CODE(CAPACITY_CHANGED
));
2188 static void scsi_cd_change_media_cb(void *opaque
, bool load
)
2190 SCSIDiskState
*s
= opaque
;
2193 * When a CD gets changed, we have to report an ejected state and
2194 * then a loaded state to guests so that they detect tray
2195 * open/close and media change events. Guests that do not use
2196 * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close
2197 * states rely on this behavior.
2199 * media_changed governs the state machine used for unit attention
2200 * report. media_event is used by GET EVENT STATUS NOTIFICATION.
2202 s
->media_changed
= load
;
2203 s
->tray_open
= !load
;
2204 scsi_device_set_ua(&s
->qdev
, SENSE_CODE(UNIT_ATTENTION_NO_MEDIUM
));
2205 s
->media_event
= true;
2206 s
->eject_request
= false;
2209 static void scsi_cd_eject_request_cb(void *opaque
, bool force
)
2211 SCSIDiskState
*s
= opaque
;
2213 s
->eject_request
= true;
2215 s
->tray_locked
= false;
2219 static bool scsi_cd_is_tray_open(void *opaque
)
2221 return ((SCSIDiskState
*)opaque
)->tray_open
;
2224 static bool scsi_cd_is_medium_locked(void *opaque
)
2226 return ((SCSIDiskState
*)opaque
)->tray_locked
;
2229 static const BlockDevOps scsi_disk_removable_block_ops
= {
2230 .change_media_cb
= scsi_cd_change_media_cb
,
2231 .eject_request_cb
= scsi_cd_eject_request_cb
,
2232 .is_tray_open
= scsi_cd_is_tray_open
,
2233 .is_medium_locked
= scsi_cd_is_medium_locked
,
2235 .resize_cb
= scsi_disk_resize_cb
,
2238 static const BlockDevOps scsi_disk_block_ops
= {
2239 .resize_cb
= scsi_disk_resize_cb
,
2242 static void scsi_disk_unit_attention_reported(SCSIDevice
*dev
)
2244 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2245 if (s
->media_changed
) {
2246 s
->media_changed
= false;
2247 scsi_device_set_ua(&s
->qdev
, SENSE_CODE(MEDIUM_CHANGED
));
2251 static void scsi_realize(SCSIDevice
*dev
, Error
**errp
)
2253 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2256 if (!s
->qdev
.conf
.blk
) {
2257 error_setg(errp
, "drive property not set");
2261 if (!(s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) &&
2262 !blk_is_inserted(s
->qdev
.conf
.blk
)) {
2263 error_setg(errp
, "Device needs media, but drive is empty");
2267 blkconf_serial(&s
->qdev
.conf
, &s
->serial
);
2268 blkconf_blocksizes(&s
->qdev
.conf
);
2269 if (dev
->type
== TYPE_DISK
) {
2270 blkconf_geometry(&dev
->conf
, NULL
, 65535, 255, 255, &err
);
2272 error_propagate(errp
, err
);
2277 if (s
->qdev
.conf
.discard_granularity
== -1) {
2278 s
->qdev
.conf
.discard_granularity
=
2279 MAX(s
->qdev
.conf
.logical_block_size
, DEFAULT_DISCARD_GRANULARITY
);
2283 s
->version
= g_strdup(qemu_get_version());
2286 s
->vendor
= g_strdup("QEMU");
2289 if (blk_is_sg(s
->qdev
.conf
.blk
)) {
2290 error_setg(errp
, "unwanted /dev/sg*");
2294 if ((s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) &&
2295 !(s
->features
& (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS
))) {
2296 blk_set_dev_ops(s
->qdev
.conf
.blk
, &scsi_disk_removable_block_ops
, s
);
2298 blk_set_dev_ops(s
->qdev
.conf
.blk
, &scsi_disk_block_ops
, s
);
2300 blk_set_guest_block_size(s
->qdev
.conf
.blk
, s
->qdev
.blocksize
);
2302 blk_iostatus_enable(s
->qdev
.conf
.blk
);
2305 static void scsi_hd_realize(SCSIDevice
*dev
, Error
**errp
)
2307 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2308 /* can happen for devices without drive. The error message for missing
2309 * backend will be issued in scsi_realize
2311 if (s
->qdev
.conf
.blk
) {
2312 blkconf_blocksizes(&s
->qdev
.conf
);
2314 s
->qdev
.blocksize
= s
->qdev
.conf
.logical_block_size
;
2315 s
->qdev
.type
= TYPE_DISK
;
2317 s
->product
= g_strdup("QEMU HARDDISK");
2319 scsi_realize(&s
->qdev
, errp
);
2322 static void scsi_cd_realize(SCSIDevice
*dev
, Error
**errp
)
2324 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2325 s
->qdev
.blocksize
= 2048;
2326 s
->qdev
.type
= TYPE_ROM
;
2327 s
->features
|= 1 << SCSI_DISK_F_REMOVABLE
;
2329 s
->product
= g_strdup("QEMU CD-ROM");
2331 scsi_realize(&s
->qdev
, errp
);
2334 static void scsi_disk_realize(SCSIDevice
*dev
, Error
**errp
)
2337 Error
*local_err
= NULL
;
2339 if (!dev
->conf
.blk
) {
2340 scsi_realize(dev
, &local_err
);
2342 error_propagate(errp
, local_err
);
2346 dinfo
= blk_legacy_dinfo(dev
->conf
.blk
);
2347 if (dinfo
&& dinfo
->media_cd
) {
2348 scsi_cd_realize(dev
, errp
);
2350 scsi_hd_realize(dev
, errp
);
2354 static const SCSIReqOps scsi_disk_emulate_reqops
= {
2355 .size
= sizeof(SCSIDiskReq
),
2356 .free_req
= scsi_free_request
,
2357 .send_command
= scsi_disk_emulate_command
,
2358 .read_data
= scsi_disk_emulate_read_data
,
2359 .write_data
= scsi_disk_emulate_write_data
,
2360 .get_buf
= scsi_get_buf
,
2363 static const SCSIReqOps scsi_disk_dma_reqops
= {
2364 .size
= sizeof(SCSIDiskReq
),
2365 .free_req
= scsi_free_request
,
2366 .send_command
= scsi_disk_dma_command
,
2367 .read_data
= scsi_read_data
,
2368 .write_data
= scsi_write_data
,
2369 .get_buf
= scsi_get_buf
,
2370 .load_request
= scsi_disk_load_request
,
2371 .save_request
= scsi_disk_save_request
,
2374 static const SCSIReqOps
*const scsi_disk_reqops_dispatch
[256] = {
2375 [TEST_UNIT_READY
] = &scsi_disk_emulate_reqops
,
2376 [INQUIRY
] = &scsi_disk_emulate_reqops
,
2377 [MODE_SENSE
] = &scsi_disk_emulate_reqops
,
2378 [MODE_SENSE_10
] = &scsi_disk_emulate_reqops
,
2379 [START_STOP
] = &scsi_disk_emulate_reqops
,
2380 [ALLOW_MEDIUM_REMOVAL
] = &scsi_disk_emulate_reqops
,
2381 [READ_CAPACITY_10
] = &scsi_disk_emulate_reqops
,
2382 [READ_TOC
] = &scsi_disk_emulate_reqops
,
2383 [READ_DVD_STRUCTURE
] = &scsi_disk_emulate_reqops
,
2384 [READ_DISC_INFORMATION
] = &scsi_disk_emulate_reqops
,
2385 [GET_CONFIGURATION
] = &scsi_disk_emulate_reqops
,
2386 [GET_EVENT_STATUS_NOTIFICATION
] = &scsi_disk_emulate_reqops
,
2387 [MECHANISM_STATUS
] = &scsi_disk_emulate_reqops
,
2388 [SERVICE_ACTION_IN_16
] = &scsi_disk_emulate_reqops
,
2389 [REQUEST_SENSE
] = &scsi_disk_emulate_reqops
,
2390 [SYNCHRONIZE_CACHE
] = &scsi_disk_emulate_reqops
,
2391 [SEEK_10
] = &scsi_disk_emulate_reqops
,
2392 [MODE_SELECT
] = &scsi_disk_emulate_reqops
,
2393 [MODE_SELECT_10
] = &scsi_disk_emulate_reqops
,
2394 [UNMAP
] = &scsi_disk_emulate_reqops
,
2395 [WRITE_SAME_10
] = &scsi_disk_emulate_reqops
,
2396 [WRITE_SAME_16
] = &scsi_disk_emulate_reqops
,
2397 [VERIFY_10
] = &scsi_disk_emulate_reqops
,
2398 [VERIFY_12
] = &scsi_disk_emulate_reqops
,
2399 [VERIFY_16
] = &scsi_disk_emulate_reqops
,
2401 [READ_6
] = &scsi_disk_dma_reqops
,
2402 [READ_10
] = &scsi_disk_dma_reqops
,
2403 [READ_12
] = &scsi_disk_dma_reqops
,
2404 [READ_16
] = &scsi_disk_dma_reqops
,
2405 [WRITE_6
] = &scsi_disk_dma_reqops
,
2406 [WRITE_10
] = &scsi_disk_dma_reqops
,
2407 [WRITE_12
] = &scsi_disk_dma_reqops
,
2408 [WRITE_16
] = &scsi_disk_dma_reqops
,
2409 [WRITE_VERIFY_10
] = &scsi_disk_dma_reqops
,
2410 [WRITE_VERIFY_12
] = &scsi_disk_dma_reqops
,
2411 [WRITE_VERIFY_16
] = &scsi_disk_dma_reqops
,
2414 static SCSIRequest
*scsi_new_request(SCSIDevice
*d
, uint32_t tag
, uint32_t lun
,
2415 uint8_t *buf
, void *hba_private
)
2417 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2419 const SCSIReqOps
*ops
;
2423 ops
= scsi_disk_reqops_dispatch
[command
];
2425 ops
= &scsi_disk_emulate_reqops
;
2427 req
= scsi_req_alloc(ops
, &s
->qdev
, tag
, lun
, hba_private
);
2430 DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun
, tag
, buf
[0]);
2433 for (i
= 1; i
< scsi_cdb_length(buf
); i
++) {
2434 printf(" 0x%02x", buf
[i
]);
2444 static int get_device_type(SCSIDiskState
*s
)
2448 uint8_t sensebuf
[8];
2449 sg_io_hdr_t io_header
;
2452 memset(cmd
, 0, sizeof(cmd
));
2453 memset(buf
, 0, sizeof(buf
));
2455 cmd
[4] = sizeof(buf
);
2457 memset(&io_header
, 0, sizeof(io_header
));
2458 io_header
.interface_id
= 'S';
2459 io_header
.dxfer_direction
= SG_DXFER_FROM_DEV
;
2460 io_header
.dxfer_len
= sizeof(buf
);
2461 io_header
.dxferp
= buf
;
2462 io_header
.cmdp
= cmd
;
2463 io_header
.cmd_len
= sizeof(cmd
);
2464 io_header
.mx_sb_len
= sizeof(sensebuf
);
2465 io_header
.sbp
= sensebuf
;
2466 io_header
.timeout
= 6000; /* XXX */
2468 ret
= blk_ioctl(s
->qdev
.conf
.blk
, SG_IO
, &io_header
);
2469 if (ret
< 0 || io_header
.driver_status
|| io_header
.host_status
) {
2472 s
->qdev
.type
= buf
[0];
2473 if (buf
[1] & 0x80) {
2474 s
->features
|= 1 << SCSI_DISK_F_REMOVABLE
;
2479 static void scsi_block_realize(SCSIDevice
*dev
, Error
**errp
)
2481 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2485 if (!s
->qdev
.conf
.blk
) {
2486 error_setg(errp
, "drive property not set");
2490 /* check we are using a driver managing SG_IO (version 3 and after) */
2491 rc
= blk_ioctl(s
->qdev
.conf
.blk
, SG_GET_VERSION_NUM
, &sg_version
);
2493 error_setg(errp
, "cannot get SG_IO version number: %s. "
2494 "Is this a SCSI device?",
2498 if (sg_version
< 30000) {
2499 error_setg(errp
, "scsi generic interface too old");
2503 /* get device type from INQUIRY data */
2504 rc
= get_device_type(s
);
2506 error_setg(errp
, "INQUIRY failed");
2510 /* Make a guess for the block size, we'll fix it when the guest sends.
2511 * READ CAPACITY. If they don't, they likely would assume these sizes
2512 * anyway. (TODO: check in /sys).
2514 if (s
->qdev
.type
== TYPE_ROM
|| s
->qdev
.type
== TYPE_WORM
) {
2515 s
->qdev
.blocksize
= 2048;
2517 s
->qdev
.blocksize
= 512;
2520 /* Makes the scsi-block device not removable by using HMP and QMP eject
2523 s
->features
|= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS
);
2525 scsi_realize(&s
->qdev
, errp
);
2528 static bool scsi_block_is_passthrough(SCSIDiskState
*s
, uint8_t *buf
)
2542 case WRITE_VERIFY_10
:
2543 case WRITE_VERIFY_12
:
2544 case WRITE_VERIFY_16
:
2545 /* If we are not using O_DIRECT, we might read stale data from the
2546 * host cache if writes were made using other commands than these
2547 * ones (such as WRITE SAME or EXTENDED COPY, etc.). So, without
2548 * O_DIRECT everything must go through SG_IO.
2550 if (!(blk_get_flags(s
->qdev
.conf
.blk
) & BDRV_O_NOCACHE
)) {
2554 /* MMC writing cannot be done via pread/pwrite, because it sometimes
2555 * involves writing beyond the maximum LBA or to negative LBA (lead-in).
2556 * And once you do these writes, reading from the block device is
2557 * unreliable, too. It is even possible that reads deliver random data
2558 * from the host page cache (this is probably a Linux bug).
2560 * We might use scsi_disk_dma_reqops as long as no writing commands are
2561 * seen, but performance usually isn't paramount on optical media. So,
2562 * just make scsi-block operate the same as scsi-generic for them.
2564 if (s
->qdev
.type
!= TYPE_ROM
) {
2577 static SCSIRequest
*scsi_block_new_request(SCSIDevice
*d
, uint32_t tag
,
2578 uint32_t lun
, uint8_t *buf
,
2581 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2583 if (scsi_block_is_passthrough(s
, buf
)) {
2584 return scsi_req_alloc(&scsi_generic_req_ops
, &s
->qdev
, tag
, lun
,
2587 return scsi_req_alloc(&scsi_disk_dma_reqops
, &s
->qdev
, tag
, lun
,
2592 static int scsi_block_parse_cdb(SCSIDevice
*d
, SCSICommand
*cmd
,
2593 uint8_t *buf
, void *hba_private
)
2595 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2597 if (scsi_block_is_passthrough(s
, buf
)) {
2598 return scsi_bus_parse_cdb(&s
->qdev
, cmd
, buf
, hba_private
);
2600 return scsi_req_parse_cdb(&s
->qdev
, cmd
, buf
);
2606 #define DEFINE_SCSI_DISK_PROPERTIES() \
2607 DEFINE_BLOCK_PROPERTIES(SCSIDiskState, qdev.conf), \
2608 DEFINE_PROP_STRING("ver", SCSIDiskState, version), \
2609 DEFINE_PROP_STRING("serial", SCSIDiskState, serial), \
2610 DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor), \
2611 DEFINE_PROP_STRING("product", SCSIDiskState, product)
2613 static Property scsi_hd_properties
[] = {
2614 DEFINE_SCSI_DISK_PROPERTIES(),
2615 DEFINE_PROP_BIT("removable", SCSIDiskState
, features
,
2616 SCSI_DISK_F_REMOVABLE
, false),
2617 DEFINE_PROP_BIT("dpofua", SCSIDiskState
, features
,
2618 SCSI_DISK_F_DPOFUA
, false),
2619 DEFINE_PROP_UINT64("wwn", SCSIDiskState
, wwn
, 0),
2620 DEFINE_PROP_UINT64("port_wwn", SCSIDiskState
, port_wwn
, 0),
2621 DEFINE_PROP_UINT16("port_index", SCSIDiskState
, port_index
, 0),
2622 DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState
, max_unmap_size
,
2623 DEFAULT_MAX_UNMAP_SIZE
),
2624 DEFINE_PROP_UINT64("max_io_size", SCSIDiskState
, max_io_size
,
2625 DEFAULT_MAX_IO_SIZE
),
2626 DEFINE_BLOCK_CHS_PROPERTIES(SCSIDiskState
, qdev
.conf
),
2627 DEFINE_PROP_END_OF_LIST(),
2630 static const VMStateDescription vmstate_scsi_disk_state
= {
2631 .name
= "scsi-disk",
2633 .minimum_version_id
= 1,
2634 .fields
= (VMStateField
[]) {
2635 VMSTATE_SCSI_DEVICE(qdev
, SCSIDiskState
),
2636 VMSTATE_BOOL(media_changed
, SCSIDiskState
),
2637 VMSTATE_BOOL(media_event
, SCSIDiskState
),
2638 VMSTATE_BOOL(eject_request
, SCSIDiskState
),
2639 VMSTATE_BOOL(tray_open
, SCSIDiskState
),
2640 VMSTATE_BOOL(tray_locked
, SCSIDiskState
),
2641 VMSTATE_END_OF_LIST()
2645 static void scsi_hd_class_initfn(ObjectClass
*klass
, void *data
)
2647 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2648 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2650 sc
->realize
= scsi_hd_realize
;
2651 sc
->alloc_req
= scsi_new_request
;
2652 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
2653 dc
->fw_name
= "disk";
2654 dc
->desc
= "virtual SCSI disk";
2655 dc
->reset
= scsi_disk_reset
;
2656 dc
->props
= scsi_hd_properties
;
2657 dc
->vmsd
= &vmstate_scsi_disk_state
;
2660 static const TypeInfo scsi_hd_info
= {
2662 .parent
= TYPE_SCSI_DEVICE
,
2663 .instance_size
= sizeof(SCSIDiskState
),
2664 .class_init
= scsi_hd_class_initfn
,
2667 static Property scsi_cd_properties
[] = {
2668 DEFINE_SCSI_DISK_PROPERTIES(),
2669 DEFINE_PROP_UINT64("wwn", SCSIDiskState
, wwn
, 0),
2670 DEFINE_PROP_UINT64("port_wwn", SCSIDiskState
, port_wwn
, 0),
2671 DEFINE_PROP_UINT16("port_index", SCSIDiskState
, port_index
, 0),
2672 DEFINE_PROP_UINT64("max_io_size", SCSIDiskState
, max_io_size
,
2673 DEFAULT_MAX_IO_SIZE
),
2674 DEFINE_PROP_END_OF_LIST(),
2677 static void scsi_cd_class_initfn(ObjectClass
*klass
, void *data
)
2679 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2680 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2682 sc
->realize
= scsi_cd_realize
;
2683 sc
->alloc_req
= scsi_new_request
;
2684 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
2685 dc
->fw_name
= "disk";
2686 dc
->desc
= "virtual SCSI CD-ROM";
2687 dc
->reset
= scsi_disk_reset
;
2688 dc
->props
= scsi_cd_properties
;
2689 dc
->vmsd
= &vmstate_scsi_disk_state
;
2692 static const TypeInfo scsi_cd_info
= {
2694 .parent
= TYPE_SCSI_DEVICE
,
2695 .instance_size
= sizeof(SCSIDiskState
),
2696 .class_init
= scsi_cd_class_initfn
,
2700 static Property scsi_block_properties
[] = {
2701 DEFINE_PROP_DRIVE("drive", SCSIDiskState
, qdev
.conf
.blk
),
2702 DEFINE_PROP_END_OF_LIST(),
2705 static void scsi_block_class_initfn(ObjectClass
*klass
, void *data
)
2707 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2708 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2710 sc
->realize
= scsi_block_realize
;
2711 sc
->alloc_req
= scsi_block_new_request
;
2712 sc
->parse_cdb
= scsi_block_parse_cdb
;
2713 dc
->fw_name
= "disk";
2714 dc
->desc
= "SCSI block device passthrough";
2715 dc
->reset
= scsi_disk_reset
;
2716 dc
->props
= scsi_block_properties
;
2717 dc
->vmsd
= &vmstate_scsi_disk_state
;
2720 static const TypeInfo scsi_block_info
= {
2721 .name
= "scsi-block",
2722 .parent
= TYPE_SCSI_DEVICE
,
2723 .instance_size
= sizeof(SCSIDiskState
),
2724 .class_init
= scsi_block_class_initfn
,
2728 static Property scsi_disk_properties
[] = {
2729 DEFINE_SCSI_DISK_PROPERTIES(),
2730 DEFINE_PROP_BIT("removable", SCSIDiskState
, features
,
2731 SCSI_DISK_F_REMOVABLE
, false),
2732 DEFINE_PROP_BIT("dpofua", SCSIDiskState
, features
,
2733 SCSI_DISK_F_DPOFUA
, false),
2734 DEFINE_PROP_UINT64("wwn", SCSIDiskState
, wwn
, 0),
2735 DEFINE_PROP_UINT64("port_wwn", SCSIDiskState
, port_wwn
, 0),
2736 DEFINE_PROP_UINT16("port_index", SCSIDiskState
, port_index
, 0),
2737 DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState
, max_unmap_size
,
2738 DEFAULT_MAX_UNMAP_SIZE
),
2739 DEFINE_PROP_UINT64("max_io_size", SCSIDiskState
, max_io_size
,
2740 DEFAULT_MAX_IO_SIZE
),
2741 DEFINE_PROP_END_OF_LIST(),
2744 static void scsi_disk_class_initfn(ObjectClass
*klass
, void *data
)
2746 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2747 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2749 sc
->realize
= scsi_disk_realize
;
2750 sc
->alloc_req
= scsi_new_request
;
2751 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
2752 dc
->fw_name
= "disk";
2753 dc
->desc
= "virtual SCSI disk or CD-ROM (legacy)";
2754 dc
->reset
= scsi_disk_reset
;
2755 dc
->props
= scsi_disk_properties
;
2756 dc
->vmsd
= &vmstate_scsi_disk_state
;
2759 static const TypeInfo scsi_disk_info
= {
2760 .name
= "scsi-disk",
2761 .parent
= TYPE_SCSI_DEVICE
,
2762 .instance_size
= sizeof(SCSIDiskState
),
2763 .class_init
= scsi_disk_class_initfn
,
2766 static void scsi_disk_register_types(void)
2768 type_register_static(&scsi_hd_info
);
2769 type_register_static(&scsi_cd_info
);
2771 type_register_static(&scsi_block_info
);
2773 type_register_static(&scsi_disk_info
);
2776 type_init(scsi_disk_register_types
)