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/osdep.h"
32 #include "qemu/units.h"
33 #include "qapi/error.h"
34 #include "qemu/error-report.h"
35 #include "hw/scsi/scsi.h"
36 #include "hw/scsi/emulation.h"
37 #include "scsi/constants.h"
38 #include "sysemu/sysemu.h"
39 #include "sysemu/block-backend.h"
40 #include "sysemu/blockdev.h"
41 #include "hw/block/block.h"
42 #include "sysemu/dma.h"
43 #include "qemu/cutils.h"
49 #define SCSI_WRITE_SAME_MAX (512 * KiB)
50 #define SCSI_DMA_BUF_SIZE (128 * KiB)
51 #define SCSI_MAX_INQUIRY_LEN 256
52 #define SCSI_MAX_MODE_LEN 256
54 #define DEFAULT_DISCARD_GRANULARITY (4 * KiB)
55 #define DEFAULT_MAX_UNMAP_SIZE (1 * GiB)
56 #define DEFAULT_MAX_IO_SIZE INT_MAX /* 2 GB - 1 block */
58 #define TYPE_SCSI_DISK_BASE "scsi-disk-base"
60 #define SCSI_DISK_BASE(obj) \
61 OBJECT_CHECK(SCSIDiskState, (obj), TYPE_SCSI_DISK_BASE)
62 #define SCSI_DISK_BASE_CLASS(klass) \
63 OBJECT_CLASS_CHECK(SCSIDiskClass, (klass), TYPE_SCSI_DISK_BASE)
64 #define SCSI_DISK_BASE_GET_CLASS(obj) \
65 OBJECT_GET_CLASS(SCSIDiskClass, (obj), TYPE_SCSI_DISK_BASE)
67 typedef struct SCSIDiskClass
{
68 SCSIDeviceClass parent_class
;
70 DMAIOFunc
*dma_writev
;
71 bool (*need_fua_emulation
)(SCSICommand
*cmd
);
74 typedef struct SCSIDiskReq
{
76 /* Both sector and sector_count are in terms of qemu 512 byte blocks. */
78 uint32_t sector_count
;
81 bool need_fua_emulation
;
85 unsigned char *status
;
88 #define SCSI_DISK_F_REMOVABLE 0
89 #define SCSI_DISK_F_DPOFUA 1
90 #define SCSI_DISK_F_NO_REMOVABLE_DEVOPS 2
92 typedef struct SCSIDiskState
100 uint64_t max_unmap_size
;
101 uint64_t max_io_size
;
111 * 0x0000 - rotation rate not reported
112 * 0x0001 - non-rotating medium (SSD)
113 * 0x0002-0x0400 - reserved
114 * 0x0401-0xffe - rotations per minute
117 uint16_t rotation_rate
;
120 static bool scsi_handle_rw_error(SCSIDiskReq
*r
, int error
, bool acct_failed
);
122 static void scsi_free_request(SCSIRequest
*req
)
124 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
126 qemu_vfree(r
->iov
.iov_base
);
129 /* Helper function for command completion with sense. */
130 static void scsi_check_condition(SCSIDiskReq
*r
, SCSISense sense
)
132 DPRINTF("Command complete tag=0x%x sense=%d/%d/%d\n",
133 r
->req
.tag
, sense
.key
, sense
.asc
, sense
.ascq
);
134 scsi_req_build_sense(&r
->req
, sense
);
135 scsi_req_complete(&r
->req
, CHECK_CONDITION
);
138 static void scsi_init_iovec(SCSIDiskReq
*r
, size_t size
)
140 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
142 if (!r
->iov
.iov_base
) {
144 r
->iov
.iov_base
= blk_blockalign(s
->qdev
.conf
.blk
, r
->buflen
);
146 r
->iov
.iov_len
= MIN(r
->sector_count
* 512, r
->buflen
);
147 qemu_iovec_init_external(&r
->qiov
, &r
->iov
, 1);
150 static void scsi_disk_save_request(QEMUFile
*f
, SCSIRequest
*req
)
152 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
154 qemu_put_be64s(f
, &r
->sector
);
155 qemu_put_be32s(f
, &r
->sector_count
);
156 qemu_put_be32s(f
, &r
->buflen
);
158 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
159 qemu_put_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
160 } else if (!req
->retry
) {
161 uint32_t len
= r
->iov
.iov_len
;
162 qemu_put_be32s(f
, &len
);
163 qemu_put_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
168 static void scsi_disk_load_request(QEMUFile
*f
, SCSIRequest
*req
)
170 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
172 qemu_get_be64s(f
, &r
->sector
);
173 qemu_get_be32s(f
, &r
->sector_count
);
174 qemu_get_be32s(f
, &r
->buflen
);
176 scsi_init_iovec(r
, r
->buflen
);
177 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
178 qemu_get_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
179 } else if (!r
->req
.retry
) {
181 qemu_get_be32s(f
, &len
);
182 r
->iov
.iov_len
= len
;
183 assert(r
->iov
.iov_len
<= r
->buflen
);
184 qemu_get_buffer(f
, r
->iov
.iov_base
, r
->iov
.iov_len
);
188 qemu_iovec_init_external(&r
->qiov
, &r
->iov
, 1);
191 static bool scsi_disk_req_check_error(SCSIDiskReq
*r
, int ret
, bool acct_failed
)
193 if (r
->req
.io_canceled
) {
194 scsi_req_cancel_complete(&r
->req
);
198 if (ret
< 0 || (r
->status
&& *r
->status
)) {
199 return scsi_handle_rw_error(r
, -ret
, acct_failed
);
205 static void scsi_aio_complete(void *opaque
, int ret
)
207 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
208 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
210 assert(r
->req
.aiocb
!= NULL
);
212 aio_context_acquire(blk_get_aio_context(s
->qdev
.conf
.blk
));
213 if (scsi_disk_req_check_error(r
, ret
, true)) {
217 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
218 scsi_req_complete(&r
->req
, GOOD
);
221 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
222 scsi_req_unref(&r
->req
);
225 static bool scsi_is_cmd_fua(SCSICommand
*cmd
)
227 switch (cmd
->buf
[0]) {
234 return (cmd
->buf
[1] & 8) != 0;
239 case WRITE_VERIFY_10
:
240 case WRITE_VERIFY_12
:
241 case WRITE_VERIFY_16
:
251 static void scsi_write_do_fua(SCSIDiskReq
*r
)
253 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
255 assert(r
->req
.aiocb
== NULL
);
256 assert(!r
->req
.io_canceled
);
258 if (r
->need_fua_emulation
) {
259 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
261 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_aio_complete
, r
);
265 scsi_req_complete(&r
->req
, GOOD
);
266 scsi_req_unref(&r
->req
);
269 static void scsi_dma_complete_noio(SCSIDiskReq
*r
, int ret
)
271 assert(r
->req
.aiocb
== NULL
);
272 if (scsi_disk_req_check_error(r
, ret
, false)) {
276 r
->sector
+= r
->sector_count
;
278 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
279 scsi_write_do_fua(r
);
282 scsi_req_complete(&r
->req
, GOOD
);
286 scsi_req_unref(&r
->req
);
289 static void scsi_dma_complete(void *opaque
, int ret
)
291 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
292 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
294 assert(r
->req
.aiocb
!= NULL
);
297 aio_context_acquire(blk_get_aio_context(s
->qdev
.conf
.blk
));
299 block_acct_failed(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
301 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
303 scsi_dma_complete_noio(r
, ret
);
304 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
307 static void scsi_read_complete(void * opaque
, int ret
)
309 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
310 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
313 assert(r
->req
.aiocb
!= NULL
);
315 aio_context_acquire(blk_get_aio_context(s
->qdev
.conf
.blk
));
316 if (scsi_disk_req_check_error(r
, ret
, true)) {
320 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
321 DPRINTF("Data ready tag=0x%x len=%zd\n", r
->req
.tag
, r
->qiov
.size
);
323 n
= r
->qiov
.size
/ 512;
325 r
->sector_count
-= n
;
326 scsi_req_data(&r
->req
, r
->qiov
.size
);
329 scsi_req_unref(&r
->req
);
330 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
333 /* Actually issue a read to the block device. */
334 static void scsi_do_read(SCSIDiskReq
*r
, int ret
)
336 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
337 SCSIDiskClass
*sdc
= (SCSIDiskClass
*) object_get_class(OBJECT(s
));
339 assert (r
->req
.aiocb
== NULL
);
340 if (scsi_disk_req_check_error(r
, ret
, false)) {
344 /* The request is used as the AIO opaque value, so add a ref. */
345 scsi_req_ref(&r
->req
);
348 dma_acct_start(s
->qdev
.conf
.blk
, &r
->acct
, r
->req
.sg
, BLOCK_ACCT_READ
);
349 r
->req
.resid
-= r
->req
.sg
->size
;
350 r
->req
.aiocb
= dma_blk_io(blk_get_aio_context(s
->qdev
.conf
.blk
),
351 r
->req
.sg
, r
->sector
<< BDRV_SECTOR_BITS
,
353 sdc
->dma_readv
, r
, scsi_dma_complete
, r
,
354 DMA_DIRECTION_FROM_DEVICE
);
356 scsi_init_iovec(r
, SCSI_DMA_BUF_SIZE
);
357 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
358 r
->qiov
.size
, BLOCK_ACCT_READ
);
359 r
->req
.aiocb
= sdc
->dma_readv(r
->sector
<< BDRV_SECTOR_BITS
, &r
->qiov
,
360 scsi_read_complete
, r
, r
);
364 scsi_req_unref(&r
->req
);
367 static void scsi_do_read_cb(void *opaque
, int ret
)
369 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
370 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
372 assert (r
->req
.aiocb
!= NULL
);
375 aio_context_acquire(blk_get_aio_context(s
->qdev
.conf
.blk
));
377 block_acct_failed(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
379 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
381 scsi_do_read(opaque
, ret
);
382 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
385 /* Read more data from scsi device into buffer. */
386 static void scsi_read_data(SCSIRequest
*req
)
388 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
389 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
392 DPRINTF("Read sector_count=%d\n", r
->sector_count
);
393 if (r
->sector_count
== 0) {
394 /* This also clears the sense buffer for REQUEST SENSE. */
395 scsi_req_complete(&r
->req
, GOOD
);
399 /* No data transfer may already be in progress */
400 assert(r
->req
.aiocb
== NULL
);
402 /* The request is used as the AIO opaque value, so add a ref. */
403 scsi_req_ref(&r
->req
);
404 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
405 DPRINTF("Data transfer direction invalid\n");
406 scsi_read_complete(r
, -EINVAL
);
410 if (!blk_is_available(req
->dev
->conf
.blk
)) {
411 scsi_read_complete(r
, -ENOMEDIUM
);
417 if (first
&& r
->need_fua_emulation
) {
418 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
420 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_do_read_cb
, r
);
427 * scsi_handle_rw_error has two return values. False means that the error
428 * must be ignored, true means that the error has been processed and the
429 * caller should not do anything else for this request. Note that
430 * scsi_handle_rw_error always manages its reference counts, independent
431 * of the return value.
433 static bool scsi_handle_rw_error(SCSIDiskReq
*r
, int error
, bool acct_failed
)
435 bool is_read
= (r
->req
.cmd
.mode
== SCSI_XFER_FROM_DEV
);
436 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
437 BlockErrorAction action
= blk_get_error_action(s
->qdev
.conf
.blk
,
440 if (action
== BLOCK_ERROR_ACTION_REPORT
) {
442 block_acct_failed(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
446 /* A passthrough command has run and has produced sense data; check
447 * whether the error has to be handled by the guest or should rather
450 assert(r
->status
&& *r
->status
);
451 error
= scsi_sense_buf_to_errno(r
->req
.sense
, sizeof(r
->req
.sense
));
452 if (error
== ECANCELED
|| error
== EAGAIN
|| error
== ENOTCONN
||
454 /* These errors are handled by guest. */
455 scsi_req_complete(&r
->req
, *r
->status
);
460 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
463 scsi_check_condition(r
, SENSE_CODE(TARGET_FAILURE
));
466 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
469 scsi_check_condition(r
, SENSE_CODE(SPACE_ALLOC_FAILED
));
472 scsi_check_condition(r
, SENSE_CODE(IO_ERROR
));
477 blk_error_action(s
->qdev
.conf
.blk
, action
, is_read
, error
);
478 if (action
== BLOCK_ERROR_ACTION_IGNORE
) {
479 scsi_req_complete(&r
->req
, 0);
483 if (action
== BLOCK_ERROR_ACTION_STOP
) {
484 scsi_req_retry(&r
->req
);
489 static void scsi_write_complete_noio(SCSIDiskReq
*r
, int ret
)
493 assert (r
->req
.aiocb
== NULL
);
494 if (scsi_disk_req_check_error(r
, ret
, false)) {
498 n
= r
->qiov
.size
/ 512;
500 r
->sector_count
-= n
;
501 if (r
->sector_count
== 0) {
502 scsi_write_do_fua(r
);
505 scsi_init_iovec(r
, SCSI_DMA_BUF_SIZE
);
506 DPRINTF("Write complete tag=0x%x more=%zd\n", r
->req
.tag
, r
->qiov
.size
);
507 scsi_req_data(&r
->req
, r
->qiov
.size
);
511 scsi_req_unref(&r
->req
);
514 static void scsi_write_complete(void * opaque
, int ret
)
516 SCSIDiskReq
*r
= (SCSIDiskReq
*)opaque
;
517 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
519 assert (r
->req
.aiocb
!= NULL
);
522 aio_context_acquire(blk_get_aio_context(s
->qdev
.conf
.blk
));
524 block_acct_failed(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
526 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
528 scsi_write_complete_noio(r
, ret
);
529 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
532 static void scsi_write_data(SCSIRequest
*req
)
534 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
535 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
536 SCSIDiskClass
*sdc
= (SCSIDiskClass
*) object_get_class(OBJECT(s
));
538 /* No data transfer may already be in progress */
539 assert(r
->req
.aiocb
== NULL
);
541 /* The request is used as the AIO opaque value, so add a ref. */
542 scsi_req_ref(&r
->req
);
543 if (r
->req
.cmd
.mode
!= SCSI_XFER_TO_DEV
) {
544 DPRINTF("Data transfer direction invalid\n");
545 scsi_write_complete_noio(r
, -EINVAL
);
549 if (!r
->req
.sg
&& !r
->qiov
.size
) {
550 /* Called for the first time. Ask the driver to send us more data. */
552 scsi_write_complete_noio(r
, 0);
555 if (!blk_is_available(req
->dev
->conf
.blk
)) {
556 scsi_write_complete_noio(r
, -ENOMEDIUM
);
560 if (r
->req
.cmd
.buf
[0] == VERIFY_10
|| r
->req
.cmd
.buf
[0] == VERIFY_12
||
561 r
->req
.cmd
.buf
[0] == VERIFY_16
) {
563 scsi_dma_complete_noio(r
, 0);
565 scsi_write_complete_noio(r
, 0);
571 dma_acct_start(s
->qdev
.conf
.blk
, &r
->acct
, r
->req
.sg
, BLOCK_ACCT_WRITE
);
572 r
->req
.resid
-= r
->req
.sg
->size
;
573 r
->req
.aiocb
= dma_blk_io(blk_get_aio_context(s
->qdev
.conf
.blk
),
574 r
->req
.sg
, r
->sector
<< BDRV_SECTOR_BITS
,
576 sdc
->dma_writev
, r
, scsi_dma_complete
, r
,
577 DMA_DIRECTION_TO_DEVICE
);
579 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
580 r
->qiov
.size
, BLOCK_ACCT_WRITE
);
581 r
->req
.aiocb
= sdc
->dma_writev(r
->sector
<< BDRV_SECTOR_BITS
, &r
->qiov
,
582 scsi_write_complete
, r
, r
);
586 /* Return a pointer to the data buffer. */
587 static uint8_t *scsi_get_buf(SCSIRequest
*req
)
589 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
591 return (uint8_t *)r
->iov
.iov_base
;
594 static int scsi_disk_emulate_vpd_page(SCSIRequest
*req
, uint8_t *outbuf
)
596 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
597 uint8_t page_code
= req
->cmd
.buf
[2];
598 int start
, buflen
= 0;
600 outbuf
[buflen
++] = s
->qdev
.type
& 0x1f;
601 outbuf
[buflen
++] = page_code
;
602 outbuf
[buflen
++] = 0x00;
603 outbuf
[buflen
++] = 0x00;
607 case 0x00: /* Supported page codes, mandatory */
609 DPRINTF("Inquiry EVPD[Supported pages] "
610 "buffer size %zd\n", req
->cmd
.xfer
);
611 outbuf
[buflen
++] = 0x00; /* list of supported pages (this page) */
613 outbuf
[buflen
++] = 0x80; /* unit serial number */
615 outbuf
[buflen
++] = 0x83; /* device identification */
616 if (s
->qdev
.type
== TYPE_DISK
) {
617 outbuf
[buflen
++] = 0xb0; /* block limits */
618 outbuf
[buflen
++] = 0xb1; /* block device characteristics */
619 outbuf
[buflen
++] = 0xb2; /* thin provisioning */
623 case 0x80: /* Device serial number, optional */
628 DPRINTF("Inquiry (EVPD[Serial number] not supported\n");
632 l
= strlen(s
->serial
);
637 DPRINTF("Inquiry EVPD[Serial number] "
638 "buffer size %zd\n", req
->cmd
.xfer
);
639 memcpy(outbuf
+ buflen
, s
->serial
, l
);
644 case 0x83: /* Device identification page, mandatory */
646 int id_len
= s
->device_id
? MIN(strlen(s
->device_id
), 255 - 8) : 0;
648 DPRINTF("Inquiry EVPD[Device identification] "
649 "buffer size %zd\n", req
->cmd
.xfer
);
652 outbuf
[buflen
++] = 0x2; /* ASCII */
653 outbuf
[buflen
++] = 0; /* not officially assigned */
654 outbuf
[buflen
++] = 0; /* reserved */
655 outbuf
[buflen
++] = id_len
; /* length of data following */
656 memcpy(outbuf
+ buflen
, s
->device_id
, id_len
);
661 outbuf
[buflen
++] = 0x1; /* Binary */
662 outbuf
[buflen
++] = 0x3; /* NAA */
663 outbuf
[buflen
++] = 0; /* reserved */
664 outbuf
[buflen
++] = 8;
665 stq_be_p(&outbuf
[buflen
], s
->qdev
.wwn
);
669 if (s
->qdev
.port_wwn
) {
670 outbuf
[buflen
++] = 0x61; /* SAS / Binary */
671 outbuf
[buflen
++] = 0x93; /* PIV / Target port / NAA */
672 outbuf
[buflen
++] = 0; /* reserved */
673 outbuf
[buflen
++] = 8;
674 stq_be_p(&outbuf
[buflen
], s
->qdev
.port_wwn
);
679 outbuf
[buflen
++] = 0x61; /* SAS / Binary */
681 /* PIV/Target port/relative target port */
682 outbuf
[buflen
++] = 0x94;
684 outbuf
[buflen
++] = 0; /* reserved */
685 outbuf
[buflen
++] = 4;
686 stw_be_p(&outbuf
[buflen
+ 2], s
->port_index
);
691 case 0xb0: /* block limits */
693 SCSIBlockLimits bl
= {};
695 if (s
->qdev
.type
== TYPE_ROM
) {
696 DPRINTF("Inquiry (EVPD[%02X] not supported for CDROM\n",
702 s
->qdev
.conf
.discard_granularity
/ s
->qdev
.blocksize
;
704 s
->qdev
.conf
.min_io_size
/ s
->qdev
.blocksize
;
706 s
->qdev
.conf
.opt_io_size
/ s
->qdev
.blocksize
;
707 bl
.max_unmap_sectors
=
708 s
->max_unmap_size
/ s
->qdev
.blocksize
;
710 s
->max_io_size
/ s
->qdev
.blocksize
;
711 /* 255 descriptors fit in 4 KiB with an 8-byte header */
712 bl
.max_unmap_descr
= 255;
714 if (s
->qdev
.type
== TYPE_DISK
) {
715 int max_transfer_blk
= blk_get_max_transfer(s
->qdev
.conf
.blk
);
716 int max_io_sectors_blk
=
717 max_transfer_blk
/ s
->qdev
.blocksize
;
720 MIN_NON_ZERO(max_io_sectors_blk
, bl
.max_io_sectors
);
722 buflen
+= scsi_emulate_block_limits(outbuf
+ buflen
, &bl
);
725 case 0xb1: /* block device characteristics */
728 outbuf
[4] = (s
->rotation_rate
>> 8) & 0xff;
729 outbuf
[5] = s
->rotation_rate
& 0xff;
730 outbuf
[6] = 0; /* PRODUCT TYPE */
731 outbuf
[7] = 0; /* WABEREQ | WACEREQ | NOMINAL FORM FACTOR */
732 outbuf
[8] = 0; /* VBULS */
735 case 0xb2: /* thin provisioning */
739 outbuf
[5] = 0xe0; /* unmap & write_same 10/16 all supported */
740 outbuf
[6] = s
->qdev
.conf
.discard_granularity
? 2 : 1;
748 assert(buflen
- start
<= 255);
749 outbuf
[start
- 1] = buflen
- start
;
753 static int scsi_disk_emulate_inquiry(SCSIRequest
*req
, uint8_t *outbuf
)
755 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
758 if (req
->cmd
.buf
[1] & 0x1) {
759 /* Vital product data */
760 return scsi_disk_emulate_vpd_page(req
, outbuf
);
763 /* Standard INQUIRY data */
764 if (req
->cmd
.buf
[2] != 0) {
769 buflen
= req
->cmd
.xfer
;
770 if (buflen
> SCSI_MAX_INQUIRY_LEN
) {
771 buflen
= SCSI_MAX_INQUIRY_LEN
;
774 outbuf
[0] = s
->qdev
.type
& 0x1f;
775 outbuf
[1] = (s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) ? 0x80 : 0;
777 strpadcpy((char *) &outbuf
[16], 16, s
->product
, ' ');
778 strpadcpy((char *) &outbuf
[8], 8, s
->vendor
, ' ');
780 memset(&outbuf
[32], 0, 4);
781 memcpy(&outbuf
[32], s
->version
, MIN(4, strlen(s
->version
)));
783 * We claim conformance to SPC-3, which is required for guests
784 * to ask for modern features like READ CAPACITY(16) or the
785 * block characteristics VPD page by default. Not all of SPC-3
786 * is actually implemented, but we're good enough.
788 outbuf
[2] = s
->qdev
.default_scsi_version
;
789 outbuf
[3] = 2 | 0x10; /* Format 2, HiSup */
792 outbuf
[4] = buflen
- 5; /* Additional Length = (Len - 1) - 4 */
794 /* If the allocation length of CDB is too small,
795 the additional length is not adjusted */
799 /* Sync data transfer and TCQ. */
800 outbuf
[7] = 0x10 | (req
->bus
->info
->tcq
? 0x02 : 0);
804 static inline bool media_is_dvd(SCSIDiskState
*s
)
807 if (s
->qdev
.type
!= TYPE_ROM
) {
810 if (!blk_is_available(s
->qdev
.conf
.blk
)) {
813 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
814 return nb_sectors
> CD_MAX_SECTORS
;
817 static inline bool media_is_cd(SCSIDiskState
*s
)
820 if (s
->qdev
.type
!= TYPE_ROM
) {
823 if (!blk_is_available(s
->qdev
.conf
.blk
)) {
826 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
827 return nb_sectors
<= CD_MAX_SECTORS
;
830 static int scsi_read_disc_information(SCSIDiskState
*s
, SCSIDiskReq
*r
,
833 uint8_t type
= r
->req
.cmd
.buf
[1] & 7;
835 if (s
->qdev
.type
!= TYPE_ROM
) {
839 /* Types 1/2 are only defined for Blu-Ray. */
841 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
845 memset(outbuf
, 0, 34);
847 outbuf
[2] = 0xe; /* last session complete, disc finalized */
848 outbuf
[3] = 1; /* first track on disc */
849 outbuf
[4] = 1; /* # of sessions */
850 outbuf
[5] = 1; /* first track of last session */
851 outbuf
[6] = 1; /* last track of last session */
852 outbuf
[7] = 0x20; /* unrestricted use */
853 outbuf
[8] = 0x00; /* CD-ROM or DVD-ROM */
854 /* 9-10-11: most significant byte corresponding bytes 4-5-6 */
855 /* 12-23: not meaningful for CD-ROM or DVD-ROM */
856 /* 24-31: disc bar code */
857 /* 32: disc application code */
858 /* 33: number of OPC tables */
863 static int scsi_read_dvd_structure(SCSIDiskState
*s
, SCSIDiskReq
*r
,
866 static const int rds_caps_size
[5] = {
873 uint8_t media
= r
->req
.cmd
.buf
[1];
874 uint8_t layer
= r
->req
.cmd
.buf
[6];
875 uint8_t format
= r
->req
.cmd
.buf
[7];
878 if (s
->qdev
.type
!= TYPE_ROM
) {
882 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
886 if (format
!= 0xff) {
887 if (!blk_is_available(s
->qdev
.conf
.blk
)) {
888 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
891 if (media_is_cd(s
)) {
892 scsi_check_condition(r
, SENSE_CODE(INCOMPATIBLE_FORMAT
));
895 if (format
>= ARRAY_SIZE(rds_caps_size
)) {
898 size
= rds_caps_size
[format
];
899 memset(outbuf
, 0, size
);
904 /* Physical format information */
909 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
911 outbuf
[4] = 1; /* DVD-ROM, part version 1 */
912 outbuf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
913 outbuf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
914 outbuf
[7] = 0; /* default densities */
916 stl_be_p(&outbuf
[12], (nb_sectors
>> 2) - 1); /* end sector */
917 stl_be_p(&outbuf
[16], (nb_sectors
>> 2) - 1); /* l0 end sector */
921 case 0x01: /* DVD copyright information, all zeros */
924 case 0x03: /* BCA information - invalid field for no BCA info */
927 case 0x04: /* DVD disc manufacturing information, all zeros */
930 case 0xff: { /* List capabilities */
933 for (i
= 0; i
< ARRAY_SIZE(rds_caps_size
); i
++) {
934 if (!rds_caps_size
[i
]) {
938 outbuf
[size
+ 1] = 0x40; /* Not writable, readable */
939 stw_be_p(&outbuf
[size
+ 2], rds_caps_size
[i
]);
949 /* Size of buffer, not including 2 byte size field */
950 stw_be_p(outbuf
, size
- 2);
957 static int scsi_event_status_media(SCSIDiskState
*s
, uint8_t *outbuf
)
959 uint8_t event_code
, media_status
;
963 media_status
= MS_TRAY_OPEN
;
964 } else if (blk_is_inserted(s
->qdev
.conf
.blk
)) {
965 media_status
= MS_MEDIA_PRESENT
;
968 /* Event notification descriptor */
969 event_code
= MEC_NO_CHANGE
;
970 if (media_status
!= MS_TRAY_OPEN
) {
971 if (s
->media_event
) {
972 event_code
= MEC_NEW_MEDIA
;
973 s
->media_event
= false;
974 } else if (s
->eject_request
) {
975 event_code
= MEC_EJECT_REQUESTED
;
976 s
->eject_request
= false;
980 outbuf
[0] = event_code
;
981 outbuf
[1] = media_status
;
983 /* These fields are reserved, just clear them. */
989 static int scsi_get_event_status_notification(SCSIDiskState
*s
, SCSIDiskReq
*r
,
993 uint8_t *buf
= r
->req
.cmd
.buf
;
994 uint8_t notification_class_request
= buf
[4];
995 if (s
->qdev
.type
!= TYPE_ROM
) {
998 if ((buf
[1] & 1) == 0) {
1004 outbuf
[0] = outbuf
[1] = 0;
1005 outbuf
[3] = 1 << GESN_MEDIA
; /* supported events */
1006 if (notification_class_request
& (1 << GESN_MEDIA
)) {
1007 outbuf
[2] = GESN_MEDIA
;
1008 size
+= scsi_event_status_media(s
, &outbuf
[size
]);
1012 stw_be_p(outbuf
, size
- 4);
1016 static int scsi_get_configuration(SCSIDiskState
*s
, uint8_t *outbuf
)
1020 if (s
->qdev
.type
!= TYPE_ROM
) {
1024 if (media_is_dvd(s
)) {
1025 current
= MMC_PROFILE_DVD_ROM
;
1026 } else if (media_is_cd(s
)) {
1027 current
= MMC_PROFILE_CD_ROM
;
1029 current
= MMC_PROFILE_NONE
;
1032 memset(outbuf
, 0, 40);
1033 stl_be_p(&outbuf
[0], 36); /* Bytes after the data length field */
1034 stw_be_p(&outbuf
[6], current
);
1035 /* outbuf[8] - outbuf[19]: Feature 0 - Profile list */
1036 outbuf
[10] = 0x03; /* persistent, current */
1037 outbuf
[11] = 8; /* two profiles */
1038 stw_be_p(&outbuf
[12], MMC_PROFILE_DVD_ROM
);
1039 outbuf
[14] = (current
== MMC_PROFILE_DVD_ROM
);
1040 stw_be_p(&outbuf
[16], MMC_PROFILE_CD_ROM
);
1041 outbuf
[18] = (current
== MMC_PROFILE_CD_ROM
);
1042 /* outbuf[20] - outbuf[31]: Feature 1 - Core feature */
1043 stw_be_p(&outbuf
[20], 1);
1044 outbuf
[22] = 0x08 | 0x03; /* version 2, persistent, current */
1046 stl_be_p(&outbuf
[24], 1); /* SCSI */
1047 outbuf
[28] = 1; /* DBE = 1, mandatory */
1048 /* outbuf[32] - outbuf[39]: Feature 3 - Removable media feature */
1049 stw_be_p(&outbuf
[32], 3);
1050 outbuf
[34] = 0x08 | 0x03; /* version 2, persistent, current */
1052 outbuf
[36] = 0x39; /* tray, load=1, eject=1, unlocked at powerup, lock=1 */
1053 /* TODO: Random readable, CD read, DVD read, drive serial number,
1058 static int scsi_emulate_mechanism_status(SCSIDiskState
*s
, uint8_t *outbuf
)
1060 if (s
->qdev
.type
!= TYPE_ROM
) {
1063 memset(outbuf
, 0, 8);
1064 outbuf
[5] = 1; /* CD-ROM */
1068 static int mode_sense_page(SCSIDiskState
*s
, int page
, uint8_t **p_outbuf
,
1071 static const int mode_sense_valid
[0x3f] = {
1072 [MODE_PAGE_HD_GEOMETRY
] = (1 << TYPE_DISK
),
1073 [MODE_PAGE_FLEXIBLE_DISK_GEOMETRY
] = (1 << TYPE_DISK
),
1074 [MODE_PAGE_CACHING
] = (1 << TYPE_DISK
) | (1 << TYPE_ROM
),
1075 [MODE_PAGE_R_W_ERROR
] = (1 << TYPE_DISK
) | (1 << TYPE_ROM
),
1076 [MODE_PAGE_AUDIO_CTL
] = (1 << TYPE_ROM
),
1077 [MODE_PAGE_CAPABILITIES
] = (1 << TYPE_ROM
),
1080 uint8_t *p
= *p_outbuf
+ 2;
1083 if ((mode_sense_valid
[page
] & (1 << s
->qdev
.type
)) == 0) {
1088 * If Changeable Values are requested, a mask denoting those mode parameters
1089 * that are changeable shall be returned. As we currently don't support
1090 * parameter changes via MODE_SELECT all bits are returned set to zero.
1091 * The buffer was already menset to zero by the caller of this function.
1093 * The offsets here are off by two compared to the descriptions in the
1094 * SCSI specs, because those include a 2-byte header. This is unfortunate,
1095 * but it is done so that offsets are consistent within our implementation
1096 * of MODE SENSE and MODE SELECT. MODE SELECT has to deal with both
1097 * 2-byte and 4-byte headers.
1100 case MODE_PAGE_HD_GEOMETRY
:
1102 if (page_control
== 1) { /* Changeable Values */
1105 /* if a geometry hint is available, use it */
1106 p
[0] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
1107 p
[1] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1108 p
[2] = s
->qdev
.conf
.cyls
& 0xff;
1109 p
[3] = s
->qdev
.conf
.heads
& 0xff;
1110 /* Write precomp start cylinder, disabled */
1111 p
[4] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
1112 p
[5] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1113 p
[6] = s
->qdev
.conf
.cyls
& 0xff;
1114 /* Reduced current start cylinder, disabled */
1115 p
[7] = (s
->qdev
.conf
.cyls
>> 16) & 0xff;
1116 p
[8] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1117 p
[9] = s
->qdev
.conf
.cyls
& 0xff;
1118 /* Device step rate [ns], 200ns */
1121 /* Landing zone cylinder */
1125 /* Medium rotation rate [rpm], 5400 rpm */
1126 p
[18] = (5400 >> 8) & 0xff;
1127 p
[19] = 5400 & 0xff;
1130 case MODE_PAGE_FLEXIBLE_DISK_GEOMETRY
:
1132 if (page_control
== 1) { /* Changeable Values */
1135 /* Transfer rate [kbit/s], 5Mbit/s */
1138 /* if a geometry hint is available, use it */
1139 p
[2] = s
->qdev
.conf
.heads
& 0xff;
1140 p
[3] = s
->qdev
.conf
.secs
& 0xff;
1141 p
[4] = s
->qdev
.blocksize
>> 8;
1142 p
[6] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1143 p
[7] = s
->qdev
.conf
.cyls
& 0xff;
1144 /* Write precomp start cylinder, disabled */
1145 p
[8] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1146 p
[9] = s
->qdev
.conf
.cyls
& 0xff;
1147 /* Reduced current start cylinder, disabled */
1148 p
[10] = (s
->qdev
.conf
.cyls
>> 8) & 0xff;
1149 p
[11] = s
->qdev
.conf
.cyls
& 0xff;
1150 /* Device step rate [100us], 100us */
1153 /* Device step pulse width [us], 1us */
1155 /* Device head settle delay [100us], 100us */
1158 /* Motor on delay [0.1s], 0.1s */
1160 /* Motor off delay [0.1s], 0.1s */
1162 /* Medium rotation rate [rpm], 5400 rpm */
1163 p
[26] = (5400 >> 8) & 0xff;
1164 p
[27] = 5400 & 0xff;
1167 case MODE_PAGE_CACHING
:
1169 if (page_control
== 1 || /* Changeable Values */
1170 blk_enable_write_cache(s
->qdev
.conf
.blk
)) {
1175 case MODE_PAGE_R_W_ERROR
:
1177 if (page_control
== 1) { /* Changeable Values */
1180 p
[0] = 0x80; /* Automatic Write Reallocation Enabled */
1181 if (s
->qdev
.type
== TYPE_ROM
) {
1182 p
[1] = 0x20; /* Read Retry Count */
1186 case MODE_PAGE_AUDIO_CTL
:
1190 case MODE_PAGE_CAPABILITIES
:
1192 if (page_control
== 1) { /* Changeable Values */
1196 p
[0] = 0x3b; /* CD-R & CD-RW read */
1197 p
[1] = 0; /* Writing not supported */
1198 p
[2] = 0x7f; /* Audio, composite, digital out,
1199 mode 2 form 1&2, multi session */
1200 p
[3] = 0xff; /* CD DA, DA accurate, RW supported,
1201 RW corrected, C2 errors, ISRC,
1203 p
[4] = 0x2d | (s
->tray_locked
? 2 : 0);
1204 /* Locking supported, jumper present, eject, tray */
1205 p
[5] = 0; /* no volume & mute control, no
1207 p
[6] = (50 * 176) >> 8; /* 50x read speed */
1208 p
[7] = (50 * 176) & 0xff;
1209 p
[8] = 2 >> 8; /* Two volume levels */
1211 p
[10] = 2048 >> 8; /* 2M buffer */
1212 p
[11] = 2048 & 0xff;
1213 p
[12] = (16 * 176) >> 8; /* 16x read speed current */
1214 p
[13] = (16 * 176) & 0xff;
1215 p
[16] = (16 * 176) >> 8; /* 16x write speed */
1216 p
[17] = (16 * 176) & 0xff;
1217 p
[18] = (16 * 176) >> 8; /* 16x write speed current */
1218 p
[19] = (16 * 176) & 0xff;
1225 assert(length
< 256);
1226 (*p_outbuf
)[0] = page
;
1227 (*p_outbuf
)[1] = length
;
1228 *p_outbuf
+= length
+ 2;
1232 static int scsi_disk_emulate_mode_sense(SCSIDiskReq
*r
, uint8_t *outbuf
)
1234 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1235 uint64_t nb_sectors
;
1237 int page
, buflen
, ret
, page_control
;
1239 uint8_t dev_specific_param
;
1241 dbd
= (r
->req
.cmd
.buf
[1] & 0x8) != 0;
1242 page
= r
->req
.cmd
.buf
[2] & 0x3f;
1243 page_control
= (r
->req
.cmd
.buf
[2] & 0xc0) >> 6;
1244 DPRINTF("Mode Sense(%d) (page %d, xfer %zd, page_control %d)\n",
1245 (r
->req
.cmd
.buf
[0] == MODE_SENSE
) ? 6 : 10, page
, r
->req
.cmd
.xfer
, page_control
);
1246 memset(outbuf
, 0, r
->req
.cmd
.xfer
);
1249 if (s
->qdev
.type
== TYPE_DISK
) {
1250 dev_specific_param
= s
->features
& (1 << SCSI_DISK_F_DPOFUA
) ? 0x10 : 0;
1251 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
1252 dev_specific_param
|= 0x80; /* Readonly. */
1255 /* MMC prescribes that CD/DVD drives have no block descriptors,
1256 * and defines no device-specific parameter. */
1257 dev_specific_param
= 0x00;
1261 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1262 p
[1] = 0; /* Default media type. */
1263 p
[2] = dev_specific_param
;
1264 p
[3] = 0; /* Block descriptor length. */
1266 } else { /* MODE_SENSE_10 */
1267 p
[2] = 0; /* Default media type. */
1268 p
[3] = dev_specific_param
;
1269 p
[6] = p
[7] = 0; /* Block descriptor length. */
1273 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
1274 if (!dbd
&& nb_sectors
) {
1275 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1276 outbuf
[3] = 8; /* Block descriptor length */
1277 } else { /* MODE_SENSE_10 */
1278 outbuf
[7] = 8; /* Block descriptor length */
1280 nb_sectors
/= (s
->qdev
.blocksize
/ 512);
1281 if (nb_sectors
> 0xffffff) {
1284 p
[0] = 0; /* media density code */
1285 p
[1] = (nb_sectors
>> 16) & 0xff;
1286 p
[2] = (nb_sectors
>> 8) & 0xff;
1287 p
[3] = nb_sectors
& 0xff;
1288 p
[4] = 0; /* reserved */
1289 p
[5] = 0; /* bytes 5-7 are the sector size in bytes */
1290 p
[6] = s
->qdev
.blocksize
>> 8;
1295 if (page_control
== 3) {
1297 scsi_check_condition(r
, SENSE_CODE(SAVING_PARAMS_NOT_SUPPORTED
));
1302 for (page
= 0; page
<= 0x3e; page
++) {
1303 mode_sense_page(s
, page
, &p
, page_control
);
1306 ret
= mode_sense_page(s
, page
, &p
, page_control
);
1312 buflen
= p
- outbuf
;
1314 * The mode data length field specifies the length in bytes of the
1315 * following data that is available to be transferred. The mode data
1316 * length does not include itself.
1318 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
1319 outbuf
[0] = buflen
- 1;
1320 } else { /* MODE_SENSE_10 */
1321 outbuf
[0] = ((buflen
- 2) >> 8) & 0xff;
1322 outbuf
[1] = (buflen
- 2) & 0xff;
1327 static int scsi_disk_emulate_read_toc(SCSIRequest
*req
, uint8_t *outbuf
)
1329 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1330 int start_track
, format
, msf
, toclen
;
1331 uint64_t nb_sectors
;
1333 msf
= req
->cmd
.buf
[1] & 2;
1334 format
= req
->cmd
.buf
[2] & 0xf;
1335 start_track
= req
->cmd
.buf
[6];
1336 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
1337 DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track
, format
, msf
>> 1);
1338 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1341 toclen
= cdrom_read_toc(nb_sectors
, outbuf
, msf
, start_track
);
1344 /* multi session : only a single session defined */
1346 memset(outbuf
, 0, 12);
1352 toclen
= cdrom_read_toc_raw(nb_sectors
, outbuf
, msf
, start_track
);
1360 static int scsi_disk_emulate_start_stop(SCSIDiskReq
*r
)
1362 SCSIRequest
*req
= &r
->req
;
1363 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1364 bool start
= req
->cmd
.buf
[4] & 1;
1365 bool loej
= req
->cmd
.buf
[4] & 2; /* load on start, eject on !start */
1366 int pwrcnd
= req
->cmd
.buf
[4] & 0xf0;
1369 /* eject/load only happens for power condition == 0 */
1373 if ((s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) && loej
) {
1374 if (!start
&& !s
->tray_open
&& s
->tray_locked
) {
1375 scsi_check_condition(r
,
1376 blk_is_inserted(s
->qdev
.conf
.blk
)
1377 ? SENSE_CODE(ILLEGAL_REQ_REMOVAL_PREVENTED
)
1378 : SENSE_CODE(NOT_READY_REMOVAL_PREVENTED
));
1382 if (s
->tray_open
!= !start
) {
1383 blk_eject(s
->qdev
.conf
.blk
, !start
);
1384 s
->tray_open
= !start
;
1390 static void scsi_disk_emulate_read_data(SCSIRequest
*req
)
1392 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1393 int buflen
= r
->iov
.iov_len
;
1396 DPRINTF("Read buf_len=%d\n", buflen
);
1399 scsi_req_data(&r
->req
, buflen
);
1403 /* This also clears the sense buffer for REQUEST SENSE. */
1404 scsi_req_complete(&r
->req
, GOOD
);
1407 static int scsi_disk_check_mode_select(SCSIDiskState
*s
, int page
,
1408 uint8_t *inbuf
, int inlen
)
1410 uint8_t mode_current
[SCSI_MAX_MODE_LEN
];
1411 uint8_t mode_changeable
[SCSI_MAX_MODE_LEN
];
1413 int len
, expected_len
, changeable_len
, i
;
1415 /* The input buffer does not include the page header, so it is
1418 expected_len
= inlen
+ 2;
1419 if (expected_len
> SCSI_MAX_MODE_LEN
) {
1424 memset(mode_current
, 0, inlen
+ 2);
1425 len
= mode_sense_page(s
, page
, &p
, 0);
1426 if (len
< 0 || len
!= expected_len
) {
1430 p
= mode_changeable
;
1431 memset(mode_changeable
, 0, inlen
+ 2);
1432 changeable_len
= mode_sense_page(s
, page
, &p
, 1);
1433 assert(changeable_len
== len
);
1435 /* Check that unchangeable bits are the same as what MODE SENSE
1438 for (i
= 2; i
< len
; i
++) {
1439 if (((mode_current
[i
] ^ inbuf
[i
- 2]) & ~mode_changeable
[i
]) != 0) {
1446 static void scsi_disk_apply_mode_select(SCSIDiskState
*s
, int page
, uint8_t *p
)
1449 case MODE_PAGE_CACHING
:
1450 blk_set_enable_write_cache(s
->qdev
.conf
.blk
, (p
[0] & 4) != 0);
1458 static int mode_select_pages(SCSIDiskReq
*r
, uint8_t *p
, int len
, bool change
)
1460 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1463 int page
, subpage
, page_len
;
1465 /* Parse both possible formats for the mode page headers. */
1469 goto invalid_param_len
;
1472 page_len
= lduw_be_p(&p
[2]);
1477 goto invalid_param_len
;
1488 if (page_len
> len
) {
1489 goto invalid_param_len
;
1493 if (scsi_disk_check_mode_select(s
, page
, p
, page_len
) < 0) {
1497 scsi_disk_apply_mode_select(s
, page
, p
);
1506 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM
));
1510 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1514 static void scsi_disk_emulate_mode_select(SCSIDiskReq
*r
, uint8_t *inbuf
)
1516 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1518 int cmd
= r
->req
.cmd
.buf
[0];
1519 int len
= r
->req
.cmd
.xfer
;
1520 int hdr_len
= (cmd
== MODE_SELECT
? 4 : 8);
1524 /* We only support PF=1, SP=0. */
1525 if ((r
->req
.cmd
.buf
[1] & 0x11) != 0x10) {
1529 if (len
< hdr_len
) {
1530 goto invalid_param_len
;
1533 bd_len
= (cmd
== MODE_SELECT
? p
[3] : lduw_be_p(&p
[6]));
1537 goto invalid_param_len
;
1539 if (bd_len
!= 0 && bd_len
!= 8) {
1546 /* Ensure no change is made if there is an error! */
1547 for (pass
= 0; pass
< 2; pass
++) {
1548 if (mode_select_pages(r
, p
, len
, pass
== 1) < 0) {
1553 if (!blk_enable_write_cache(s
->qdev
.conf
.blk
)) {
1554 /* The request is used as the AIO opaque value, so add a ref. */
1555 scsi_req_ref(&r
->req
);
1556 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
1558 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_aio_complete
, r
);
1562 scsi_req_complete(&r
->req
, GOOD
);
1566 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM
));
1570 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1574 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1577 static inline bool check_lba_range(SCSIDiskState
*s
,
1578 uint64_t sector_num
, uint32_t nb_sectors
)
1581 * The first line tests that no overflow happens when computing the last
1582 * sector. The second line tests that the last accessed sector is in
1585 * Careful, the computations should not underflow for nb_sectors == 0,
1586 * and a 0-block read to the first LBA beyond the end of device is
1589 return (sector_num
<= sector_num
+ nb_sectors
&&
1590 sector_num
+ nb_sectors
<= s
->qdev
.max_lba
+ 1);
1593 typedef struct UnmapCBData
{
1599 static void scsi_unmap_complete(void *opaque
, int ret
);
1601 static void scsi_unmap_complete_noio(UnmapCBData
*data
, int ret
)
1603 SCSIDiskReq
*r
= data
->r
;
1604 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1605 uint64_t sector_num
;
1606 uint32_t nb_sectors
;
1608 assert(r
->req
.aiocb
== NULL
);
1609 if (scsi_disk_req_check_error(r
, ret
, false)) {
1613 if (data
->count
> 0) {
1614 sector_num
= ldq_be_p(&data
->inbuf
[0]);
1615 nb_sectors
= ldl_be_p(&data
->inbuf
[8]) & 0xffffffffULL
;
1616 if (!check_lba_range(s
, sector_num
, nb_sectors
)) {
1617 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
1621 r
->req
.aiocb
= blk_aio_pdiscard(s
->qdev
.conf
.blk
,
1622 sector_num
* s
->qdev
.blocksize
,
1623 nb_sectors
* s
->qdev
.blocksize
,
1624 scsi_unmap_complete
, data
);
1630 scsi_req_complete(&r
->req
, GOOD
);
1633 scsi_req_unref(&r
->req
);
1637 static void scsi_unmap_complete(void *opaque
, int ret
)
1639 UnmapCBData
*data
= opaque
;
1640 SCSIDiskReq
*r
= data
->r
;
1641 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1643 assert(r
->req
.aiocb
!= NULL
);
1644 r
->req
.aiocb
= NULL
;
1646 aio_context_acquire(blk_get_aio_context(s
->qdev
.conf
.blk
));
1647 scsi_unmap_complete_noio(data
, ret
);
1648 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
1651 static void scsi_disk_emulate_unmap(SCSIDiskReq
*r
, uint8_t *inbuf
)
1653 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1655 int len
= r
->req
.cmd
.xfer
;
1658 /* Reject ANCHOR=1. */
1659 if (r
->req
.cmd
.buf
[1] & 0x1) {
1664 goto invalid_param_len
;
1666 if (len
< lduw_be_p(&p
[0]) + 2) {
1667 goto invalid_param_len
;
1669 if (len
< lduw_be_p(&p
[2]) + 8) {
1670 goto invalid_param_len
;
1672 if (lduw_be_p(&p
[2]) & 15) {
1673 goto invalid_param_len
;
1676 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
1677 scsi_check_condition(r
, SENSE_CODE(WRITE_PROTECTED
));
1681 data
= g_new0(UnmapCBData
, 1);
1683 data
->inbuf
= &p
[8];
1684 data
->count
= lduw_be_p(&p
[2]) >> 4;
1686 /* The matching unref is in scsi_unmap_complete, before data is freed. */
1687 scsi_req_ref(&r
->req
);
1688 scsi_unmap_complete_noio(data
, 0);
1692 scsi_check_condition(r
, SENSE_CODE(INVALID_PARAM_LEN
));
1696 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1699 typedef struct WriteSameCBData
{
1707 static void scsi_write_same_complete(void *opaque
, int ret
)
1709 WriteSameCBData
*data
= opaque
;
1710 SCSIDiskReq
*r
= data
->r
;
1711 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
1713 assert(r
->req
.aiocb
!= NULL
);
1714 r
->req
.aiocb
= NULL
;
1715 aio_context_acquire(blk_get_aio_context(s
->qdev
.conf
.blk
));
1716 if (scsi_disk_req_check_error(r
, ret
, true)) {
1720 block_acct_done(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
);
1722 data
->nb_sectors
-= data
->iov
.iov_len
/ 512;
1723 data
->sector
+= data
->iov
.iov_len
/ 512;
1724 data
->iov
.iov_len
= MIN(data
->nb_sectors
* 512, data
->iov
.iov_len
);
1725 if (data
->iov
.iov_len
) {
1726 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
1727 data
->iov
.iov_len
, BLOCK_ACCT_WRITE
);
1728 /* Reinitialize qiov, to handle unaligned WRITE SAME request
1729 * where final qiov may need smaller size */
1730 qemu_iovec_init_external(&data
->qiov
, &data
->iov
, 1);
1731 r
->req
.aiocb
= blk_aio_pwritev(s
->qdev
.conf
.blk
,
1732 data
->sector
<< BDRV_SECTOR_BITS
,
1734 scsi_write_same_complete
, data
);
1735 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
1739 scsi_req_complete(&r
->req
, GOOD
);
1742 scsi_req_unref(&r
->req
);
1743 qemu_vfree(data
->iov
.iov_base
);
1745 aio_context_release(blk_get_aio_context(s
->qdev
.conf
.blk
));
1748 static void scsi_disk_emulate_write_same(SCSIDiskReq
*r
, uint8_t *inbuf
)
1750 SCSIRequest
*req
= &r
->req
;
1751 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1752 uint32_t nb_sectors
= scsi_data_cdb_xfer(r
->req
.cmd
.buf
);
1753 WriteSameCBData
*data
;
1757 /* Fail if PBDATA=1 or LBDATA=1 or ANCHOR=1. */
1758 if (nb_sectors
== 0 || (req
->cmd
.buf
[1] & 0x16)) {
1759 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1763 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
1764 scsi_check_condition(r
, SENSE_CODE(WRITE_PROTECTED
));
1767 if (!check_lba_range(s
, r
->req
.cmd
.lba
, nb_sectors
)) {
1768 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
1772 if ((req
->cmd
.buf
[1] & 0x1) || buffer_is_zero(inbuf
, s
->qdev
.blocksize
)) {
1773 int flags
= (req
->cmd
.buf
[1] & 0x8) ? BDRV_REQ_MAY_UNMAP
: 0;
1775 /* The request is used as the AIO opaque value, so add a ref. */
1776 scsi_req_ref(&r
->req
);
1777 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
1778 nb_sectors
* s
->qdev
.blocksize
,
1780 r
->req
.aiocb
= blk_aio_pwrite_zeroes(s
->qdev
.conf
.blk
,
1781 r
->req
.cmd
.lba
* s
->qdev
.blocksize
,
1782 nb_sectors
* s
->qdev
.blocksize
,
1783 flags
, scsi_aio_complete
, r
);
1787 data
= g_new0(WriteSameCBData
, 1);
1789 data
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
1790 data
->nb_sectors
= nb_sectors
* (s
->qdev
.blocksize
/ 512);
1791 data
->iov
.iov_len
= MIN(data
->nb_sectors
* 512, SCSI_WRITE_SAME_MAX
);
1792 data
->iov
.iov_base
= buf
= blk_blockalign(s
->qdev
.conf
.blk
,
1794 qemu_iovec_init_external(&data
->qiov
, &data
->iov
, 1);
1796 for (i
= 0; i
< data
->iov
.iov_len
; i
+= s
->qdev
.blocksize
) {
1797 memcpy(&buf
[i
], inbuf
, s
->qdev
.blocksize
);
1800 scsi_req_ref(&r
->req
);
1801 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
,
1802 data
->iov
.iov_len
, BLOCK_ACCT_WRITE
);
1803 r
->req
.aiocb
= blk_aio_pwritev(s
->qdev
.conf
.blk
,
1804 data
->sector
<< BDRV_SECTOR_BITS
,
1806 scsi_write_same_complete
, data
);
1809 static void scsi_disk_emulate_write_data(SCSIRequest
*req
)
1811 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1813 if (r
->iov
.iov_len
) {
1814 int buflen
= r
->iov
.iov_len
;
1815 DPRINTF("Write buf_len=%d\n", buflen
);
1817 scsi_req_data(&r
->req
, buflen
);
1821 switch (req
->cmd
.buf
[0]) {
1823 case MODE_SELECT_10
:
1824 /* This also clears the sense buffer for REQUEST SENSE. */
1825 scsi_disk_emulate_mode_select(r
, r
->iov
.iov_base
);
1829 scsi_disk_emulate_unmap(r
, r
->iov
.iov_base
);
1835 if (r
->req
.status
== -1) {
1836 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
1842 scsi_disk_emulate_write_same(r
, r
->iov
.iov_base
);
1850 static int32_t scsi_disk_emulate_command(SCSIRequest
*req
, uint8_t *buf
)
1852 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
1853 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
1854 uint64_t nb_sectors
;
1858 switch (req
->cmd
.buf
[0]) {
1867 case ALLOW_MEDIUM_REMOVAL
:
1868 case GET_CONFIGURATION
:
1869 case GET_EVENT_STATUS_NOTIFICATION
:
1870 case MECHANISM_STATUS
:
1875 if (!blk_is_available(s
->qdev
.conf
.blk
)) {
1876 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
1883 * FIXME: we shouldn't return anything bigger than 4k, but the code
1884 * requires the buffer to be as big as req->cmd.xfer in several
1885 * places. So, do not allow CDBs with a very large ALLOCATION
1886 * LENGTH. The real fix would be to modify scsi_read_data and
1887 * dma_buf_read, so that they return data beyond the buflen
1890 if (req
->cmd
.xfer
> 65536) {
1891 goto illegal_request
;
1893 r
->buflen
= MAX(4096, req
->cmd
.xfer
);
1895 if (!r
->iov
.iov_base
) {
1896 r
->iov
.iov_base
= blk_blockalign(s
->qdev
.conf
.blk
, r
->buflen
);
1899 buflen
= req
->cmd
.xfer
;
1900 outbuf
= r
->iov
.iov_base
;
1901 memset(outbuf
, 0, r
->buflen
);
1902 switch (req
->cmd
.buf
[0]) {
1903 case TEST_UNIT_READY
:
1904 assert(blk_is_available(s
->qdev
.conf
.blk
));
1907 buflen
= scsi_disk_emulate_inquiry(req
, outbuf
);
1909 goto illegal_request
;
1914 buflen
= scsi_disk_emulate_mode_sense(r
, outbuf
);
1916 goto illegal_request
;
1920 buflen
= scsi_disk_emulate_read_toc(req
, outbuf
);
1922 goto illegal_request
;
1926 if (req
->cmd
.buf
[1] & 1) {
1927 goto illegal_request
;
1931 if (req
->cmd
.buf
[1] & 3) {
1932 goto illegal_request
;
1936 if (req
->cmd
.buf
[1] & 1) {
1937 goto illegal_request
;
1941 if (req
->cmd
.buf
[1] & 3) {
1942 goto illegal_request
;
1946 if (scsi_disk_emulate_start_stop(r
) < 0) {
1950 case ALLOW_MEDIUM_REMOVAL
:
1951 s
->tray_locked
= req
->cmd
.buf
[4] & 1;
1952 blk_lock_medium(s
->qdev
.conf
.blk
, req
->cmd
.buf
[4] & 1);
1954 case READ_CAPACITY_10
:
1955 /* The normal LEN field for this command is zero. */
1956 memset(outbuf
, 0, 8);
1957 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
1959 scsi_check_condition(r
, SENSE_CODE(LUN_NOT_READY
));
1962 if ((req
->cmd
.buf
[8] & 1) == 0 && req
->cmd
.lba
) {
1963 goto illegal_request
;
1965 nb_sectors
/= s
->qdev
.blocksize
/ 512;
1966 /* Returned value is the address of the last sector. */
1968 /* Remember the new size for read/write sanity checking. */
1969 s
->qdev
.max_lba
= nb_sectors
;
1970 /* Clip to 2TB, instead of returning capacity modulo 2TB. */
1971 if (nb_sectors
> UINT32_MAX
) {
1972 nb_sectors
= UINT32_MAX
;
1974 outbuf
[0] = (nb_sectors
>> 24) & 0xff;
1975 outbuf
[1] = (nb_sectors
>> 16) & 0xff;
1976 outbuf
[2] = (nb_sectors
>> 8) & 0xff;
1977 outbuf
[3] = nb_sectors
& 0xff;
1980 outbuf
[6] = s
->qdev
.blocksize
>> 8;
1984 /* Just return "NO SENSE". */
1985 buflen
= scsi_convert_sense(NULL
, 0, outbuf
, r
->buflen
,
1986 (req
->cmd
.buf
[1] & 1) == 0);
1988 goto illegal_request
;
1991 case MECHANISM_STATUS
:
1992 buflen
= scsi_emulate_mechanism_status(s
, outbuf
);
1994 goto illegal_request
;
1997 case GET_CONFIGURATION
:
1998 buflen
= scsi_get_configuration(s
, outbuf
);
2000 goto illegal_request
;
2003 case GET_EVENT_STATUS_NOTIFICATION
:
2004 buflen
= scsi_get_event_status_notification(s
, r
, outbuf
);
2006 goto illegal_request
;
2009 case READ_DISC_INFORMATION
:
2010 buflen
= scsi_read_disc_information(s
, r
, outbuf
);
2012 goto illegal_request
;
2015 case READ_DVD_STRUCTURE
:
2016 buflen
= scsi_read_dvd_structure(s
, r
, outbuf
);
2018 goto illegal_request
;
2021 case SERVICE_ACTION_IN_16
:
2022 /* Service Action In subcommands. */
2023 if ((req
->cmd
.buf
[1] & 31) == SAI_READ_CAPACITY_16
) {
2024 DPRINTF("SAI READ CAPACITY(16)\n");
2025 memset(outbuf
, 0, req
->cmd
.xfer
);
2026 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
2028 scsi_check_condition(r
, SENSE_CODE(LUN_NOT_READY
));
2031 if ((req
->cmd
.buf
[14] & 1) == 0 && req
->cmd
.lba
) {
2032 goto illegal_request
;
2034 nb_sectors
/= s
->qdev
.blocksize
/ 512;
2035 /* Returned value is the address of the last sector. */
2037 /* Remember the new size for read/write sanity checking. */
2038 s
->qdev
.max_lba
= nb_sectors
;
2039 outbuf
[0] = (nb_sectors
>> 56) & 0xff;
2040 outbuf
[1] = (nb_sectors
>> 48) & 0xff;
2041 outbuf
[2] = (nb_sectors
>> 40) & 0xff;
2042 outbuf
[3] = (nb_sectors
>> 32) & 0xff;
2043 outbuf
[4] = (nb_sectors
>> 24) & 0xff;
2044 outbuf
[5] = (nb_sectors
>> 16) & 0xff;
2045 outbuf
[6] = (nb_sectors
>> 8) & 0xff;
2046 outbuf
[7] = nb_sectors
& 0xff;
2049 outbuf
[10] = s
->qdev
.blocksize
>> 8;
2052 outbuf
[13] = get_physical_block_exp(&s
->qdev
.conf
);
2054 /* set TPE bit if the format supports discard */
2055 if (s
->qdev
.conf
.discard_granularity
) {
2059 /* Protection, exponent and lowest lba field left blank. */
2062 DPRINTF("Unsupported Service Action In\n");
2063 goto illegal_request
;
2064 case SYNCHRONIZE_CACHE
:
2065 /* The request is used as the AIO opaque value, so add a ref. */
2066 scsi_req_ref(&r
->req
);
2067 block_acct_start(blk_get_stats(s
->qdev
.conf
.blk
), &r
->acct
, 0,
2069 r
->req
.aiocb
= blk_aio_flush(s
->qdev
.conf
.blk
, scsi_aio_complete
, r
);
2072 DPRINTF("Seek(10) (sector %" PRId64
")\n", r
->req
.cmd
.lba
);
2073 if (r
->req
.cmd
.lba
> s
->qdev
.max_lba
) {
2078 DPRINTF("Mode Select(6) (len %lu)\n", (unsigned long)r
->req
.cmd
.xfer
);
2080 case MODE_SELECT_10
:
2081 DPRINTF("Mode Select(10) (len %lu)\n", (unsigned long)r
->req
.cmd
.xfer
);
2084 DPRINTF("Unmap (len %lu)\n", (unsigned long)r
->req
.cmd
.xfer
);
2089 DPRINTF("Verify (bytchk %d)\n", (req
->cmd
.buf
[1] >> 1) & 3);
2090 if (req
->cmd
.buf
[1] & 6) {
2091 goto illegal_request
;
2096 DPRINTF("WRITE SAME %d (len %lu)\n",
2097 req
->cmd
.buf
[0] == WRITE_SAME_10
? 10 : 16,
2098 (unsigned long)r
->req
.cmd
.xfer
);
2101 DPRINTF("Unknown SCSI command (%2.2x=%s)\n", buf
[0],
2102 scsi_command_name(buf
[0]));
2103 scsi_check_condition(r
, SENSE_CODE(INVALID_OPCODE
));
2106 assert(!r
->req
.aiocb
);
2107 r
->iov
.iov_len
= MIN(r
->buflen
, req
->cmd
.xfer
);
2108 if (r
->iov
.iov_len
== 0) {
2109 scsi_req_complete(&r
->req
, GOOD
);
2111 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
2112 assert(r
->iov
.iov_len
== req
->cmd
.xfer
);
2113 return -r
->iov
.iov_len
;
2115 return r
->iov
.iov_len
;
2119 if (r
->req
.status
== -1) {
2120 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
2125 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
2129 /* Execute a scsi command. Returns the length of the data expected by the
2130 command. This will be Positive for data transfers from the device
2131 (eg. disk reads), negative for transfers to the device (eg. disk writes),
2132 and zero if the command does not transfer any data. */
2134 static int32_t scsi_disk_dma_command(SCSIRequest
*req
, uint8_t *buf
)
2136 SCSIDiskReq
*r
= DO_UPCAST(SCSIDiskReq
, req
, req
);
2137 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
2138 SCSIDiskClass
*sdc
= (SCSIDiskClass
*) object_get_class(OBJECT(s
));
2144 if (!blk_is_available(s
->qdev
.conf
.blk
)) {
2145 scsi_check_condition(r
, SENSE_CODE(NO_MEDIUM
));
2149 len
= scsi_data_cdb_xfer(r
->req
.cmd
.buf
);
2155 DPRINTF("Read (sector %" PRId64
", count %u)\n", r
->req
.cmd
.lba
, len
);
2156 /* Protection information is not supported. For SCSI versions 2 and
2157 * older (as determined by snooping the guest's INQUIRY commands),
2158 * there is no RD/WR/VRPROTECT, so skip this check in these versions.
2160 if (s
->qdev
.scsi_version
> 2 && (r
->req
.cmd
.buf
[1] & 0xe0)) {
2161 goto illegal_request
;
2163 if (!check_lba_range(s
, r
->req
.cmd
.lba
, len
)) {
2166 r
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
2167 r
->sector_count
= len
* (s
->qdev
.blocksize
/ 512);
2173 case WRITE_VERIFY_10
:
2174 case WRITE_VERIFY_12
:
2175 case WRITE_VERIFY_16
:
2176 if (blk_is_read_only(s
->qdev
.conf
.blk
)) {
2177 scsi_check_condition(r
, SENSE_CODE(WRITE_PROTECTED
));
2180 DPRINTF("Write %s(sector %" PRId64
", count %u)\n",
2181 (command
& 0xe) == 0xe ? "And Verify " : "",
2182 r
->req
.cmd
.lba
, len
);
2187 /* We get here only for BYTCHK == 0x01 and only for scsi-block.
2188 * As far as DMA is concerned, we can treat it the same as a write;
2189 * scsi_block_do_sgio will send VERIFY commands.
2191 if (s
->qdev
.scsi_version
> 2 && (r
->req
.cmd
.buf
[1] & 0xe0)) {
2192 goto illegal_request
;
2194 if (!check_lba_range(s
, r
->req
.cmd
.lba
, len
)) {
2197 r
->sector
= r
->req
.cmd
.lba
* (s
->qdev
.blocksize
/ 512);
2198 r
->sector_count
= len
* (s
->qdev
.blocksize
/ 512);
2203 scsi_check_condition(r
, SENSE_CODE(INVALID_FIELD
));
2206 scsi_check_condition(r
, SENSE_CODE(LBA_OUT_OF_RANGE
));
2209 r
->need_fua_emulation
= sdc
->need_fua_emulation(&r
->req
.cmd
);
2210 if (r
->sector_count
== 0) {
2211 scsi_req_complete(&r
->req
, GOOD
);
2213 assert(r
->iov
.iov_len
== 0);
2214 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
2215 return -r
->sector_count
* 512;
2217 return r
->sector_count
* 512;
2221 static void scsi_disk_reset(DeviceState
*dev
)
2223 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
.qdev
, dev
);
2224 uint64_t nb_sectors
;
2226 scsi_device_purge_requests(&s
->qdev
, SENSE_CODE(RESET
));
2228 blk_get_geometry(s
->qdev
.conf
.blk
, &nb_sectors
);
2229 nb_sectors
/= s
->qdev
.blocksize
/ 512;
2233 s
->qdev
.max_lba
= nb_sectors
;
2234 /* reset tray statuses */
2238 s
->qdev
.scsi_version
= s
->qdev
.default_scsi_version
;
2241 static void scsi_disk_resize_cb(void *opaque
)
2243 SCSIDiskState
*s
= opaque
;
2245 /* SPC lists this sense code as available only for
2246 * direct-access devices.
2248 if (s
->qdev
.type
== TYPE_DISK
) {
2249 scsi_device_report_change(&s
->qdev
, SENSE_CODE(CAPACITY_CHANGED
));
2253 static void scsi_cd_change_media_cb(void *opaque
, bool load
, Error
**errp
)
2255 SCSIDiskState
*s
= opaque
;
2258 * When a CD gets changed, we have to report an ejected state and
2259 * then a loaded state to guests so that they detect tray
2260 * open/close and media change events. Guests that do not use
2261 * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close
2262 * states rely on this behavior.
2264 * media_changed governs the state machine used for unit attention
2265 * report. media_event is used by GET EVENT STATUS NOTIFICATION.
2267 s
->media_changed
= load
;
2268 s
->tray_open
= !load
;
2269 scsi_device_set_ua(&s
->qdev
, SENSE_CODE(UNIT_ATTENTION_NO_MEDIUM
));
2270 s
->media_event
= true;
2271 s
->eject_request
= false;
2274 static void scsi_cd_eject_request_cb(void *opaque
, bool force
)
2276 SCSIDiskState
*s
= opaque
;
2278 s
->eject_request
= true;
2280 s
->tray_locked
= false;
2284 static bool scsi_cd_is_tray_open(void *opaque
)
2286 return ((SCSIDiskState
*)opaque
)->tray_open
;
2289 static bool scsi_cd_is_medium_locked(void *opaque
)
2291 return ((SCSIDiskState
*)opaque
)->tray_locked
;
2294 static const BlockDevOps scsi_disk_removable_block_ops
= {
2295 .change_media_cb
= scsi_cd_change_media_cb
,
2296 .eject_request_cb
= scsi_cd_eject_request_cb
,
2297 .is_tray_open
= scsi_cd_is_tray_open
,
2298 .is_medium_locked
= scsi_cd_is_medium_locked
,
2300 .resize_cb
= scsi_disk_resize_cb
,
2303 static const BlockDevOps scsi_disk_block_ops
= {
2304 .resize_cb
= scsi_disk_resize_cb
,
2307 static void scsi_disk_unit_attention_reported(SCSIDevice
*dev
)
2309 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2310 if (s
->media_changed
) {
2311 s
->media_changed
= false;
2312 scsi_device_set_ua(&s
->qdev
, SENSE_CODE(MEDIUM_CHANGED
));
2316 static void scsi_realize(SCSIDevice
*dev
, Error
**errp
)
2318 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2320 if (!s
->qdev
.conf
.blk
) {
2321 error_setg(errp
, "drive property not set");
2325 if (!(s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) &&
2326 !blk_is_inserted(s
->qdev
.conf
.blk
)) {
2327 error_setg(errp
, "Device needs media, but drive is empty");
2331 blkconf_blocksizes(&s
->qdev
.conf
);
2333 if (s
->qdev
.conf
.logical_block_size
>
2334 s
->qdev
.conf
.physical_block_size
) {
2336 "logical_block_size > physical_block_size not supported");
2340 if (dev
->type
== TYPE_DISK
) {
2341 if (!blkconf_geometry(&dev
->conf
, NULL
, 65535, 255, 255, errp
)) {
2345 if (!blkconf_apply_backend_options(&dev
->conf
,
2346 blk_is_read_only(s
->qdev
.conf
.blk
),
2347 dev
->type
== TYPE_DISK
, errp
)) {
2351 if (s
->qdev
.conf
.discard_granularity
== -1) {
2352 s
->qdev
.conf
.discard_granularity
=
2353 MAX(s
->qdev
.conf
.logical_block_size
, DEFAULT_DISCARD_GRANULARITY
);
2357 s
->version
= g_strdup(qemu_hw_version());
2360 s
->vendor
= g_strdup("QEMU");
2362 if (!s
->device_id
) {
2364 s
->device_id
= g_strdup_printf("%.20s", s
->serial
);
2366 const char *str
= blk_name(s
->qdev
.conf
.blk
);
2368 s
->device_id
= g_strdup(str
);
2373 if (blk_is_sg(s
->qdev
.conf
.blk
)) {
2374 error_setg(errp
, "unwanted /dev/sg*");
2378 if ((s
->features
& (1 << SCSI_DISK_F_REMOVABLE
)) &&
2379 !(s
->features
& (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS
))) {
2380 blk_set_dev_ops(s
->qdev
.conf
.blk
, &scsi_disk_removable_block_ops
, s
);
2382 blk_set_dev_ops(s
->qdev
.conf
.blk
, &scsi_disk_block_ops
, s
);
2384 blk_set_guest_block_size(s
->qdev
.conf
.blk
, s
->qdev
.blocksize
);
2386 blk_iostatus_enable(s
->qdev
.conf
.blk
);
2389 static void scsi_hd_realize(SCSIDevice
*dev
, Error
**errp
)
2391 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2392 AioContext
*ctx
= NULL
;
2393 /* can happen for devices without drive. The error message for missing
2394 * backend will be issued in scsi_realize
2396 if (s
->qdev
.conf
.blk
) {
2397 ctx
= blk_get_aio_context(s
->qdev
.conf
.blk
);
2398 aio_context_acquire(ctx
);
2399 blkconf_blocksizes(&s
->qdev
.conf
);
2401 s
->qdev
.blocksize
= s
->qdev
.conf
.logical_block_size
;
2402 s
->qdev
.type
= TYPE_DISK
;
2404 s
->product
= g_strdup("QEMU HARDDISK");
2406 scsi_realize(&s
->qdev
, errp
);
2408 aio_context_release(ctx
);
2412 static void scsi_cd_realize(SCSIDevice
*dev
, Error
**errp
)
2414 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2418 if (!dev
->conf
.blk
) {
2419 /* Anonymous BlockBackend for an empty drive. As we put it into
2420 * dev->conf, qdev takes care of detaching on unplug. */
2421 dev
->conf
.blk
= blk_new(0, BLK_PERM_ALL
);
2422 ret
= blk_attach_dev(dev
->conf
.blk
, &dev
->qdev
);
2426 ctx
= blk_get_aio_context(dev
->conf
.blk
);
2427 aio_context_acquire(ctx
);
2428 s
->qdev
.blocksize
= 2048;
2429 s
->qdev
.type
= TYPE_ROM
;
2430 s
->features
|= 1 << SCSI_DISK_F_REMOVABLE
;
2432 s
->product
= g_strdup("QEMU CD-ROM");
2434 scsi_realize(&s
->qdev
, errp
);
2435 aio_context_release(ctx
);
2438 static void scsi_disk_realize(SCSIDevice
*dev
, Error
**errp
)
2441 Error
*local_err
= NULL
;
2443 if (!dev
->conf
.blk
) {
2444 scsi_realize(dev
, &local_err
);
2446 error_propagate(errp
, local_err
);
2450 dinfo
= blk_legacy_dinfo(dev
->conf
.blk
);
2451 if (dinfo
&& dinfo
->media_cd
) {
2452 scsi_cd_realize(dev
, errp
);
2454 scsi_hd_realize(dev
, errp
);
2458 static const SCSIReqOps scsi_disk_emulate_reqops
= {
2459 .size
= sizeof(SCSIDiskReq
),
2460 .free_req
= scsi_free_request
,
2461 .send_command
= scsi_disk_emulate_command
,
2462 .read_data
= scsi_disk_emulate_read_data
,
2463 .write_data
= scsi_disk_emulate_write_data
,
2464 .get_buf
= scsi_get_buf
,
2467 static const SCSIReqOps scsi_disk_dma_reqops
= {
2468 .size
= sizeof(SCSIDiskReq
),
2469 .free_req
= scsi_free_request
,
2470 .send_command
= scsi_disk_dma_command
,
2471 .read_data
= scsi_read_data
,
2472 .write_data
= scsi_write_data
,
2473 .get_buf
= scsi_get_buf
,
2474 .load_request
= scsi_disk_load_request
,
2475 .save_request
= scsi_disk_save_request
,
2478 static const SCSIReqOps
*const scsi_disk_reqops_dispatch
[256] = {
2479 [TEST_UNIT_READY
] = &scsi_disk_emulate_reqops
,
2480 [INQUIRY
] = &scsi_disk_emulate_reqops
,
2481 [MODE_SENSE
] = &scsi_disk_emulate_reqops
,
2482 [MODE_SENSE_10
] = &scsi_disk_emulate_reqops
,
2483 [START_STOP
] = &scsi_disk_emulate_reqops
,
2484 [ALLOW_MEDIUM_REMOVAL
] = &scsi_disk_emulate_reqops
,
2485 [READ_CAPACITY_10
] = &scsi_disk_emulate_reqops
,
2486 [READ_TOC
] = &scsi_disk_emulate_reqops
,
2487 [READ_DVD_STRUCTURE
] = &scsi_disk_emulate_reqops
,
2488 [READ_DISC_INFORMATION
] = &scsi_disk_emulate_reqops
,
2489 [GET_CONFIGURATION
] = &scsi_disk_emulate_reqops
,
2490 [GET_EVENT_STATUS_NOTIFICATION
] = &scsi_disk_emulate_reqops
,
2491 [MECHANISM_STATUS
] = &scsi_disk_emulate_reqops
,
2492 [SERVICE_ACTION_IN_16
] = &scsi_disk_emulate_reqops
,
2493 [REQUEST_SENSE
] = &scsi_disk_emulate_reqops
,
2494 [SYNCHRONIZE_CACHE
] = &scsi_disk_emulate_reqops
,
2495 [SEEK_10
] = &scsi_disk_emulate_reqops
,
2496 [MODE_SELECT
] = &scsi_disk_emulate_reqops
,
2497 [MODE_SELECT_10
] = &scsi_disk_emulate_reqops
,
2498 [UNMAP
] = &scsi_disk_emulate_reqops
,
2499 [WRITE_SAME_10
] = &scsi_disk_emulate_reqops
,
2500 [WRITE_SAME_16
] = &scsi_disk_emulate_reqops
,
2501 [VERIFY_10
] = &scsi_disk_emulate_reqops
,
2502 [VERIFY_12
] = &scsi_disk_emulate_reqops
,
2503 [VERIFY_16
] = &scsi_disk_emulate_reqops
,
2505 [READ_6
] = &scsi_disk_dma_reqops
,
2506 [READ_10
] = &scsi_disk_dma_reqops
,
2507 [READ_12
] = &scsi_disk_dma_reqops
,
2508 [READ_16
] = &scsi_disk_dma_reqops
,
2509 [WRITE_6
] = &scsi_disk_dma_reqops
,
2510 [WRITE_10
] = &scsi_disk_dma_reqops
,
2511 [WRITE_12
] = &scsi_disk_dma_reqops
,
2512 [WRITE_16
] = &scsi_disk_dma_reqops
,
2513 [WRITE_VERIFY_10
] = &scsi_disk_dma_reqops
,
2514 [WRITE_VERIFY_12
] = &scsi_disk_dma_reqops
,
2515 [WRITE_VERIFY_16
] = &scsi_disk_dma_reqops
,
2518 static SCSIRequest
*scsi_new_request(SCSIDevice
*d
, uint32_t tag
, uint32_t lun
,
2519 uint8_t *buf
, void *hba_private
)
2521 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2523 const SCSIReqOps
*ops
;
2527 ops
= scsi_disk_reqops_dispatch
[command
];
2529 ops
= &scsi_disk_emulate_reqops
;
2531 req
= scsi_req_alloc(ops
, &s
->qdev
, tag
, lun
, hba_private
);
2534 DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun
, tag
, buf
[0]);
2537 for (i
= 1; i
< scsi_cdb_length(buf
); i
++) {
2538 printf(" 0x%02x", buf
[i
]);
2548 static int get_device_type(SCSIDiskState
*s
)
2554 memset(cmd
, 0, sizeof(cmd
));
2555 memset(buf
, 0, sizeof(buf
));
2557 cmd
[4] = sizeof(buf
);
2559 ret
= scsi_SG_IO_FROM_DEV(s
->qdev
.conf
.blk
, cmd
, sizeof(cmd
),
2564 s
->qdev
.type
= buf
[0];
2565 if (buf
[1] & 0x80) {
2566 s
->features
|= 1 << SCSI_DISK_F_REMOVABLE
;
2571 static void scsi_block_realize(SCSIDevice
*dev
, Error
**errp
)
2573 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, dev
);
2578 if (!s
->qdev
.conf
.blk
) {
2579 error_setg(errp
, "drive property not set");
2583 if (s
->rotation_rate
) {
2584 error_report_once("rotation_rate is specified for scsi-block but is "
2585 "not implemented. This option is deprecated and will "
2586 "be removed in a future version");
2589 ctx
= blk_get_aio_context(s
->qdev
.conf
.blk
);
2590 aio_context_acquire(ctx
);
2592 /* check we are using a driver managing SG_IO (version 3 and after) */
2593 rc
= blk_ioctl(s
->qdev
.conf
.blk
, SG_GET_VERSION_NUM
, &sg_version
);
2595 error_setg_errno(errp
, -rc
, "cannot get SG_IO version number");
2597 error_append_hint(errp
, "Is this a SCSI device?\n");
2601 if (sg_version
< 30000) {
2602 error_setg(errp
, "scsi generic interface too old");
2606 /* get device type from INQUIRY data */
2607 rc
= get_device_type(s
);
2609 error_setg(errp
, "INQUIRY failed");
2613 /* Make a guess for the block size, we'll fix it when the guest sends.
2614 * READ CAPACITY. If they don't, they likely would assume these sizes
2615 * anyway. (TODO: check in /sys).
2617 if (s
->qdev
.type
== TYPE_ROM
|| s
->qdev
.type
== TYPE_WORM
) {
2618 s
->qdev
.blocksize
= 2048;
2620 s
->qdev
.blocksize
= 512;
2623 /* Makes the scsi-block device not removable by using HMP and QMP eject
2626 s
->features
|= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS
);
2628 scsi_realize(&s
->qdev
, errp
);
2629 scsi_generic_read_device_inquiry(&s
->qdev
);
2632 aio_context_release(ctx
);
2635 typedef struct SCSIBlockReq
{
2637 sg_io_hdr_t io_header
;
2639 /* Selected bytes of the original CDB, copied into our own CDB. */
2640 uint8_t cmd
, cdb1
, group_number
;
2642 /* CDB passed to SG_IO. */
2646 static BlockAIOCB
*scsi_block_do_sgio(SCSIBlockReq
*req
,
2647 int64_t offset
, QEMUIOVector
*iov
,
2649 BlockCompletionFunc
*cb
, void *opaque
)
2651 sg_io_hdr_t
*io_header
= &req
->io_header
;
2652 SCSIDiskReq
*r
= &req
->req
;
2653 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
2654 int nb_logical_blocks
;
2658 /* This is not supported yet. It can only happen if the guest does
2659 * reads and writes that are not aligned to one logical sectors
2660 * _and_ cover multiple MemoryRegions.
2662 assert(offset
% s
->qdev
.blocksize
== 0);
2663 assert(iov
->size
% s
->qdev
.blocksize
== 0);
2665 io_header
->interface_id
= 'S';
2667 /* The data transfer comes from the QEMUIOVector. */
2668 io_header
->dxfer_direction
= direction
;
2669 io_header
->dxfer_len
= iov
->size
;
2670 io_header
->dxferp
= (void *)iov
->iov
;
2671 io_header
->iovec_count
= iov
->niov
;
2672 assert(io_header
->iovec_count
== iov
->niov
); /* no overflow! */
2674 /* Build a new CDB with the LBA and length patched in, in case
2675 * DMA helpers split the transfer in multiple segments. Do not
2676 * build a CDB smaller than what the guest wanted, and only build
2677 * a larger one if strictly necessary.
2679 io_header
->cmdp
= req
->cdb
;
2680 lba
= offset
/ s
->qdev
.blocksize
;
2681 nb_logical_blocks
= io_header
->dxfer_len
/ s
->qdev
.blocksize
;
2683 if ((req
->cmd
>> 5) == 0 && lba
<= 0x1ffff) {
2685 stl_be_p(&req
->cdb
[0], lba
| (req
->cmd
<< 24));
2686 req
->cdb
[4] = nb_logical_blocks
;
2688 io_header
->cmd_len
= 6;
2689 } else if ((req
->cmd
>> 5) <= 1 && lba
<= 0xffffffffULL
) {
2691 req
->cdb
[0] = (req
->cmd
& 0x1f) | 0x20;
2692 req
->cdb
[1] = req
->cdb1
;
2693 stl_be_p(&req
->cdb
[2], lba
);
2694 req
->cdb
[6] = req
->group_number
;
2695 stw_be_p(&req
->cdb
[7], nb_logical_blocks
);
2697 io_header
->cmd_len
= 10;
2698 } else if ((req
->cmd
>> 5) != 4 && lba
<= 0xffffffffULL
) {
2700 req
->cdb
[0] = (req
->cmd
& 0x1f) | 0xA0;
2701 req
->cdb
[1] = req
->cdb1
;
2702 stl_be_p(&req
->cdb
[2], lba
);
2703 stl_be_p(&req
->cdb
[6], nb_logical_blocks
);
2704 req
->cdb
[10] = req
->group_number
;
2706 io_header
->cmd_len
= 12;
2709 req
->cdb
[0] = (req
->cmd
& 0x1f) | 0x80;
2710 req
->cdb
[1] = req
->cdb1
;
2711 stq_be_p(&req
->cdb
[2], lba
);
2712 stl_be_p(&req
->cdb
[10], nb_logical_blocks
);
2713 req
->cdb
[14] = req
->group_number
;
2715 io_header
->cmd_len
= 16;
2718 /* The rest is as in scsi-generic.c. */
2719 io_header
->mx_sb_len
= sizeof(r
->req
.sense
);
2720 io_header
->sbp
= r
->req
.sense
;
2721 io_header
->timeout
= UINT_MAX
;
2722 io_header
->usr_ptr
= r
;
2723 io_header
->flags
|= SG_FLAG_DIRECT_IO
;
2725 aiocb
= blk_aio_ioctl(s
->qdev
.conf
.blk
, SG_IO
, io_header
, cb
, opaque
);
2726 assert(aiocb
!= NULL
);
2730 static bool scsi_block_no_fua(SCSICommand
*cmd
)
2735 static BlockAIOCB
*scsi_block_dma_readv(int64_t offset
,
2737 BlockCompletionFunc
*cb
, void *cb_opaque
,
2740 SCSIBlockReq
*r
= opaque
;
2741 return scsi_block_do_sgio(r
, offset
, iov
,
2742 SG_DXFER_FROM_DEV
, cb
, cb_opaque
);
2745 static BlockAIOCB
*scsi_block_dma_writev(int64_t offset
,
2747 BlockCompletionFunc
*cb
, void *cb_opaque
,
2750 SCSIBlockReq
*r
= opaque
;
2751 return scsi_block_do_sgio(r
, offset
, iov
,
2752 SG_DXFER_TO_DEV
, cb
, cb_opaque
);
2755 static bool scsi_block_is_passthrough(SCSIDiskState
*s
, uint8_t *buf
)
2761 /* Check if BYTCHK == 0x01 (data-out buffer contains data
2762 * for the number of logical blocks specified in the length
2763 * field). For other modes, do not use scatter/gather operation.
2765 if ((buf
[1] & 6) == 2) {
2778 case WRITE_VERIFY_10
:
2779 case WRITE_VERIFY_12
:
2780 case WRITE_VERIFY_16
:
2781 /* MMC writing cannot be done via DMA helpers, because it sometimes
2782 * involves writing beyond the maximum LBA or to negative LBA (lead-in).
2783 * We might use scsi_block_dma_reqops as long as no writing commands are
2784 * seen, but performance usually isn't paramount on optical media. So,
2785 * just make scsi-block operate the same as scsi-generic for them.
2787 if (s
->qdev
.type
!= TYPE_ROM
) {
2800 static int32_t scsi_block_dma_command(SCSIRequest
*req
, uint8_t *buf
)
2802 SCSIBlockReq
*r
= (SCSIBlockReq
*)req
;
2803 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, req
->dev
);
2805 r
->cmd
= req
->cmd
.buf
[0];
2806 switch (r
->cmd
>> 5) {
2809 r
->cdb1
= r
->group_number
= 0;
2813 r
->cdb1
= req
->cmd
.buf
[1];
2814 r
->group_number
= req
->cmd
.buf
[6];
2818 r
->cdb1
= req
->cmd
.buf
[1];
2819 r
->group_number
= req
->cmd
.buf
[10];
2823 r
->cdb1
= req
->cmd
.buf
[1];
2824 r
->group_number
= req
->cmd
.buf
[14];
2830 /* Protection information is not supported. For SCSI versions 2 and
2831 * older (as determined by snooping the guest's INQUIRY commands),
2832 * there is no RD/WR/VRPROTECT, so skip this check in these versions.
2834 if (s
->qdev
.scsi_version
> 2 && (req
->cmd
.buf
[1] & 0xe0)) {
2835 scsi_check_condition(&r
->req
, SENSE_CODE(INVALID_FIELD
));
2839 r
->req
.status
= &r
->io_header
.status
;
2840 return scsi_disk_dma_command(req
, buf
);
2843 static const SCSIReqOps scsi_block_dma_reqops
= {
2844 .size
= sizeof(SCSIBlockReq
),
2845 .free_req
= scsi_free_request
,
2846 .send_command
= scsi_block_dma_command
,
2847 .read_data
= scsi_read_data
,
2848 .write_data
= scsi_write_data
,
2849 .get_buf
= scsi_get_buf
,
2850 .load_request
= scsi_disk_load_request
,
2851 .save_request
= scsi_disk_save_request
,
2854 static SCSIRequest
*scsi_block_new_request(SCSIDevice
*d
, uint32_t tag
,
2855 uint32_t lun
, uint8_t *buf
,
2858 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2860 if (scsi_block_is_passthrough(s
, buf
)) {
2861 return scsi_req_alloc(&scsi_generic_req_ops
, &s
->qdev
, tag
, lun
,
2864 return scsi_req_alloc(&scsi_block_dma_reqops
, &s
->qdev
, tag
, lun
,
2869 static int scsi_block_parse_cdb(SCSIDevice
*d
, SCSICommand
*cmd
,
2870 uint8_t *buf
, void *hba_private
)
2872 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, d
);
2874 if (scsi_block_is_passthrough(s
, buf
)) {
2875 return scsi_bus_parse_cdb(&s
->qdev
, cmd
, buf
, hba_private
);
2877 return scsi_req_parse_cdb(&s
->qdev
, cmd
, buf
);
2884 BlockAIOCB
*scsi_dma_readv(int64_t offset
, QEMUIOVector
*iov
,
2885 BlockCompletionFunc
*cb
, void *cb_opaque
,
2888 SCSIDiskReq
*r
= opaque
;
2889 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
2890 return blk_aio_preadv(s
->qdev
.conf
.blk
, offset
, iov
, 0, cb
, cb_opaque
);
2894 BlockAIOCB
*scsi_dma_writev(int64_t offset
, QEMUIOVector
*iov
,
2895 BlockCompletionFunc
*cb
, void *cb_opaque
,
2898 SCSIDiskReq
*r
= opaque
;
2899 SCSIDiskState
*s
= DO_UPCAST(SCSIDiskState
, qdev
, r
->req
.dev
);
2900 return blk_aio_pwritev(s
->qdev
.conf
.blk
, offset
, iov
, 0, cb
, cb_opaque
);
2903 static void scsi_disk_base_class_initfn(ObjectClass
*klass
, void *data
)
2905 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2906 SCSIDiskClass
*sdc
= SCSI_DISK_BASE_CLASS(klass
);
2908 dc
->fw_name
= "disk";
2909 dc
->reset
= scsi_disk_reset
;
2910 sdc
->dma_readv
= scsi_dma_readv
;
2911 sdc
->dma_writev
= scsi_dma_writev
;
2912 sdc
->need_fua_emulation
= scsi_is_cmd_fua
;
2915 static const TypeInfo scsi_disk_base_info
= {
2916 .name
= TYPE_SCSI_DISK_BASE
,
2917 .parent
= TYPE_SCSI_DEVICE
,
2918 .class_init
= scsi_disk_base_class_initfn
,
2919 .instance_size
= sizeof(SCSIDiskState
),
2920 .class_size
= sizeof(SCSIDiskClass
),
2924 #define DEFINE_SCSI_DISK_PROPERTIES() \
2925 DEFINE_BLOCK_PROPERTIES(SCSIDiskState, qdev.conf), \
2926 DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf), \
2927 DEFINE_PROP_STRING("ver", SCSIDiskState, version), \
2928 DEFINE_PROP_STRING("serial", SCSIDiskState, serial), \
2929 DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor), \
2930 DEFINE_PROP_STRING("product", SCSIDiskState, product), \
2931 DEFINE_PROP_STRING("device_id", SCSIDiskState, device_id)
2934 static Property scsi_hd_properties
[] = {
2935 DEFINE_SCSI_DISK_PROPERTIES(),
2936 DEFINE_PROP_BIT("removable", SCSIDiskState
, features
,
2937 SCSI_DISK_F_REMOVABLE
, false),
2938 DEFINE_PROP_BIT("dpofua", SCSIDiskState
, features
,
2939 SCSI_DISK_F_DPOFUA
, false),
2940 DEFINE_PROP_UINT64("wwn", SCSIDiskState
, qdev
.wwn
, 0),
2941 DEFINE_PROP_UINT64("port_wwn", SCSIDiskState
, qdev
.port_wwn
, 0),
2942 DEFINE_PROP_UINT16("port_index", SCSIDiskState
, port_index
, 0),
2943 DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState
, max_unmap_size
,
2944 DEFAULT_MAX_UNMAP_SIZE
),
2945 DEFINE_PROP_UINT64("max_io_size", SCSIDiskState
, max_io_size
,
2946 DEFAULT_MAX_IO_SIZE
),
2947 DEFINE_PROP_UINT16("rotation_rate", SCSIDiskState
, rotation_rate
, 0),
2948 DEFINE_PROP_INT32("scsi_version", SCSIDiskState
, qdev
.default_scsi_version
,
2950 DEFINE_BLOCK_CHS_PROPERTIES(SCSIDiskState
, qdev
.conf
),
2951 DEFINE_PROP_END_OF_LIST(),
2954 static const VMStateDescription vmstate_scsi_disk_state
= {
2955 .name
= "scsi-disk",
2957 .minimum_version_id
= 1,
2958 .fields
= (VMStateField
[]) {
2959 VMSTATE_SCSI_DEVICE(qdev
, SCSIDiskState
),
2960 VMSTATE_BOOL(media_changed
, SCSIDiskState
),
2961 VMSTATE_BOOL(media_event
, SCSIDiskState
),
2962 VMSTATE_BOOL(eject_request
, SCSIDiskState
),
2963 VMSTATE_BOOL(tray_open
, SCSIDiskState
),
2964 VMSTATE_BOOL(tray_locked
, SCSIDiskState
),
2965 VMSTATE_END_OF_LIST()
2969 static void scsi_hd_class_initfn(ObjectClass
*klass
, void *data
)
2971 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2972 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
2974 sc
->realize
= scsi_hd_realize
;
2975 sc
->alloc_req
= scsi_new_request
;
2976 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
2977 dc
->desc
= "virtual SCSI disk";
2978 dc
->props
= scsi_hd_properties
;
2979 dc
->vmsd
= &vmstate_scsi_disk_state
;
2982 static const TypeInfo scsi_hd_info
= {
2984 .parent
= TYPE_SCSI_DISK_BASE
,
2985 .class_init
= scsi_hd_class_initfn
,
2988 static Property scsi_cd_properties
[] = {
2989 DEFINE_SCSI_DISK_PROPERTIES(),
2990 DEFINE_PROP_UINT64("wwn", SCSIDiskState
, qdev
.wwn
, 0),
2991 DEFINE_PROP_UINT64("port_wwn", SCSIDiskState
, qdev
.port_wwn
, 0),
2992 DEFINE_PROP_UINT16("port_index", SCSIDiskState
, port_index
, 0),
2993 DEFINE_PROP_UINT64("max_io_size", SCSIDiskState
, max_io_size
,
2994 DEFAULT_MAX_IO_SIZE
),
2995 DEFINE_PROP_INT32("scsi_version", SCSIDiskState
, qdev
.default_scsi_version
,
2997 DEFINE_PROP_END_OF_LIST(),
3000 static void scsi_cd_class_initfn(ObjectClass
*klass
, void *data
)
3002 DeviceClass
*dc
= DEVICE_CLASS(klass
);
3003 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
3005 sc
->realize
= scsi_cd_realize
;
3006 sc
->alloc_req
= scsi_new_request
;
3007 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
3008 dc
->desc
= "virtual SCSI CD-ROM";
3009 dc
->props
= scsi_cd_properties
;
3010 dc
->vmsd
= &vmstate_scsi_disk_state
;
3013 static const TypeInfo scsi_cd_info
= {
3015 .parent
= TYPE_SCSI_DISK_BASE
,
3016 .class_init
= scsi_cd_class_initfn
,
3020 static Property scsi_block_properties
[] = {
3021 DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState
, qdev
.conf
), \
3022 DEFINE_PROP_DRIVE("drive", SCSIDiskState
, qdev
.conf
.blk
),
3023 DEFINE_PROP_BOOL("share-rw", SCSIDiskState
, qdev
.conf
.share_rw
, false),
3024 DEFINE_PROP_UINT16("rotation_rate", SCSIDiskState
, rotation_rate
, 0),
3025 DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState
, max_unmap_size
,
3026 DEFAULT_MAX_UNMAP_SIZE
),
3027 DEFINE_PROP_UINT64("max_io_size", SCSIDiskState
, max_io_size
,
3028 DEFAULT_MAX_IO_SIZE
),
3029 DEFINE_PROP_INT32("scsi_version", SCSIDiskState
, qdev
.default_scsi_version
,
3031 DEFINE_PROP_END_OF_LIST(),
3034 static void scsi_block_class_initfn(ObjectClass
*klass
, void *data
)
3036 DeviceClass
*dc
= DEVICE_CLASS(klass
);
3037 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
3038 SCSIDiskClass
*sdc
= SCSI_DISK_BASE_CLASS(klass
);
3040 sc
->realize
= scsi_block_realize
;
3041 sc
->alloc_req
= scsi_block_new_request
;
3042 sc
->parse_cdb
= scsi_block_parse_cdb
;
3043 sdc
->dma_readv
= scsi_block_dma_readv
;
3044 sdc
->dma_writev
= scsi_block_dma_writev
;
3045 sdc
->need_fua_emulation
= scsi_block_no_fua
;
3046 dc
->desc
= "SCSI block device passthrough";
3047 dc
->props
= scsi_block_properties
;
3048 dc
->vmsd
= &vmstate_scsi_disk_state
;
3051 static const TypeInfo scsi_block_info
= {
3052 .name
= "scsi-block",
3053 .parent
= TYPE_SCSI_DISK_BASE
,
3054 .class_init
= scsi_block_class_initfn
,
3058 static Property scsi_disk_properties
[] = {
3059 DEFINE_SCSI_DISK_PROPERTIES(),
3060 DEFINE_PROP_BIT("removable", SCSIDiskState
, features
,
3061 SCSI_DISK_F_REMOVABLE
, false),
3062 DEFINE_PROP_BIT("dpofua", SCSIDiskState
, features
,
3063 SCSI_DISK_F_DPOFUA
, false),
3064 DEFINE_PROP_UINT64("wwn", SCSIDiskState
, qdev
.wwn
, 0),
3065 DEFINE_PROP_UINT64("port_wwn", SCSIDiskState
, qdev
.port_wwn
, 0),
3066 DEFINE_PROP_UINT16("port_index", SCSIDiskState
, port_index
, 0),
3067 DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState
, max_unmap_size
,
3068 DEFAULT_MAX_UNMAP_SIZE
),
3069 DEFINE_PROP_UINT64("max_io_size", SCSIDiskState
, max_io_size
,
3070 DEFAULT_MAX_IO_SIZE
),
3071 DEFINE_PROP_INT32("scsi_version", SCSIDiskState
, qdev
.default_scsi_version
,
3073 DEFINE_PROP_END_OF_LIST(),
3076 static void scsi_disk_class_initfn(ObjectClass
*klass
, void *data
)
3078 DeviceClass
*dc
= DEVICE_CLASS(klass
);
3079 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
3081 sc
->realize
= scsi_disk_realize
;
3082 sc
->alloc_req
= scsi_new_request
;
3083 sc
->unit_attention_reported
= scsi_disk_unit_attention_reported
;
3084 dc
->fw_name
= "disk";
3085 dc
->desc
= "virtual SCSI disk or CD-ROM (legacy)";
3086 dc
->reset
= scsi_disk_reset
;
3087 dc
->props
= scsi_disk_properties
;
3088 dc
->vmsd
= &vmstate_scsi_disk_state
;
3091 static const TypeInfo scsi_disk_info
= {
3092 .name
= "scsi-disk",
3093 .parent
= TYPE_SCSI_DISK_BASE
,
3094 .class_init
= scsi_disk_class_initfn
,
3097 static void scsi_disk_register_types(void)
3099 type_register_static(&scsi_disk_base_info
);
3100 type_register_static(&scsi_hd_info
);
3101 type_register_static(&scsi_cd_info
);
3103 type_register_static(&scsi_block_info
);
3105 type_register_static(&scsi_disk_info
);
3108 type_init(scsi_disk_register_types
)