4 * Copyright IBM, Corp. 2007
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
14 #include "qemu-common.h"
16 #include "qemu/error-report.h"
18 #include "hw/block/block.h"
19 #include "sysemu/block-backend.h"
20 #include "sysemu/blockdev.h"
21 #include "hw/virtio/virtio-blk.h"
22 #include "dataplane/virtio-blk.h"
23 #include "migration/migration.h"
24 #include "block/scsi.h"
28 #include "hw/virtio/virtio-bus.h"
29 #include "hw/virtio/virtio-access.h"
31 VirtIOBlockReq
*virtio_blk_alloc_request(VirtIOBlock
*s
)
33 VirtIOBlockReq
*req
= g_slice_new(VirtIOBlockReq
);
40 void virtio_blk_free_request(VirtIOBlockReq
*req
)
43 g_slice_free(VirtIOBlockReq
, req
);
47 static void virtio_blk_complete_request(VirtIOBlockReq
*req
,
50 VirtIOBlock
*s
= req
->dev
;
51 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
53 trace_virtio_blk_req_complete(req
, status
);
55 stb_p(&req
->in
->status
, status
);
56 virtqueue_push(s
->vq
, &req
->elem
, req
->qiov
.size
+ sizeof(*req
->in
));
57 virtio_notify(vdev
, s
->vq
);
60 static void virtio_blk_req_complete(VirtIOBlockReq
*req
, unsigned char status
)
62 req
->dev
->complete_request(req
, status
);
65 static int virtio_blk_handle_rw_error(VirtIOBlockReq
*req
, int error
,
68 BlockErrorAction action
= blk_get_error_action(req
->dev
->blk
,
70 VirtIOBlock
*s
= req
->dev
;
72 if (action
== BLOCK_ERROR_ACTION_STOP
) {
75 } else if (action
== BLOCK_ERROR_ACTION_REPORT
) {
76 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
77 block_acct_done(blk_get_stats(s
->blk
), &req
->acct
);
78 virtio_blk_free_request(req
);
81 blk_error_action(s
->blk
, action
, is_read
, error
);
82 return action
!= BLOCK_ERROR_ACTION_IGNORE
;
85 static void virtio_blk_rw_complete(void *opaque
, int ret
)
87 VirtIOBlockReq
*req
= opaque
;
89 trace_virtio_blk_rw_complete(req
, ret
);
92 int p
= virtio_ldl_p(VIRTIO_DEVICE(req
->dev
), &req
->out
.type
);
93 bool is_read
= !(p
& VIRTIO_BLK_T_OUT
);
94 if (virtio_blk_handle_rw_error(req
, -ret
, is_read
))
98 virtio_blk_req_complete(req
, VIRTIO_BLK_S_OK
);
99 block_acct_done(blk_get_stats(req
->dev
->blk
), &req
->acct
);
100 virtio_blk_free_request(req
);
103 static void virtio_blk_flush_complete(void *opaque
, int ret
)
105 VirtIOBlockReq
*req
= opaque
;
108 if (virtio_blk_handle_rw_error(req
, -ret
, 0)) {
113 virtio_blk_req_complete(req
, VIRTIO_BLK_S_OK
);
114 block_acct_done(blk_get_stats(req
->dev
->blk
), &req
->acct
);
115 virtio_blk_free_request(req
);
122 struct sg_io_hdr hdr
;
123 } VirtIOBlockIoctlReq
;
125 static void virtio_blk_ioctl_complete(void *opaque
, int status
)
127 VirtIOBlockIoctlReq
*ioctl_req
= opaque
;
128 VirtIOBlockReq
*req
= ioctl_req
->req
;
129 VirtIODevice
*vdev
= VIRTIO_DEVICE(req
->dev
);
130 struct virtio_scsi_inhdr
*scsi
;
131 struct sg_io_hdr
*hdr
;
133 scsi
= (void *)req
->elem
.in_sg
[req
->elem
.in_num
- 2].iov_base
;
136 status
= VIRTIO_BLK_S_UNSUPP
;
137 virtio_stl_p(vdev
, &scsi
->errors
, 255);
141 hdr
= &ioctl_req
->hdr
;
143 * From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi)
144 * clear the masked_status field [hence status gets cleared too, see
145 * block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED
146 * status has occurred. However they do set DRIVER_SENSE in driver_status
147 * field. Also a (sb_len_wr > 0) indicates there is a sense buffer.
149 if (hdr
->status
== 0 && hdr
->sb_len_wr
> 0) {
150 hdr
->status
= CHECK_CONDITION
;
153 virtio_stl_p(vdev
, &scsi
->errors
,
154 hdr
->status
| (hdr
->msg_status
<< 8) |
155 (hdr
->host_status
<< 16) | (hdr
->driver_status
<< 24));
156 virtio_stl_p(vdev
, &scsi
->residual
, hdr
->resid
);
157 virtio_stl_p(vdev
, &scsi
->sense_len
, hdr
->sb_len_wr
);
158 virtio_stl_p(vdev
, &scsi
->data_len
, hdr
->dxfer_len
);
161 virtio_blk_req_complete(req
, status
);
162 virtio_blk_free_request(req
);
168 static VirtIOBlockReq
*virtio_blk_get_request(VirtIOBlock
*s
)
170 VirtIOBlockReq
*req
= virtio_blk_alloc_request(s
);
172 if (!virtqueue_pop(s
->vq
, &req
->elem
)) {
173 virtio_blk_free_request(req
);
180 static int virtio_blk_handle_scsi_req(VirtIOBlockReq
*req
)
182 int status
= VIRTIO_BLK_S_OK
;
183 struct virtio_scsi_inhdr
*scsi
= NULL
;
184 VirtIODevice
*vdev
= VIRTIO_DEVICE(req
->dev
);
185 VirtQueueElement
*elem
= &req
->elem
;
186 VirtIOBlock
*blk
= req
->dev
;
190 VirtIOBlockIoctlReq
*ioctl_req
;
194 * We require at least one output segment each for the virtio_blk_outhdr
195 * and the SCSI command block.
197 * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
198 * and the sense buffer pointer in the input segments.
200 if (elem
->out_num
< 2 || elem
->in_num
< 3) {
201 status
= VIRTIO_BLK_S_IOERR
;
206 * The scsi inhdr is placed in the second-to-last input segment, just
207 * before the regular inhdr.
209 scsi
= (void *)elem
->in_sg
[elem
->in_num
- 2].iov_base
;
211 if (!blk
->conf
.scsi
) {
212 status
= VIRTIO_BLK_S_UNSUPP
;
217 * No support for bidirection commands yet.
219 if (elem
->out_num
> 2 && elem
->in_num
> 3) {
220 status
= VIRTIO_BLK_S_UNSUPP
;
225 ioctl_req
= g_new0(VirtIOBlockIoctlReq
, 1);
226 ioctl_req
->req
= req
;
227 ioctl_req
->hdr
.interface_id
= 'S';
228 ioctl_req
->hdr
.cmd_len
= elem
->out_sg
[1].iov_len
;
229 ioctl_req
->hdr
.cmdp
= elem
->out_sg
[1].iov_base
;
230 ioctl_req
->hdr
.dxfer_len
= 0;
232 if (elem
->out_num
> 2) {
234 * If there are more than the minimally required 2 output segments
235 * there is write payload starting from the third iovec.
237 ioctl_req
->hdr
.dxfer_direction
= SG_DXFER_TO_DEV
;
238 ioctl_req
->hdr
.iovec_count
= elem
->out_num
- 2;
240 for (i
= 0; i
< ioctl_req
->hdr
.iovec_count
; i
++) {
241 ioctl_req
->hdr
.dxfer_len
+= elem
->out_sg
[i
+ 2].iov_len
;
244 ioctl_req
->hdr
.dxferp
= elem
->out_sg
+ 2;
246 } else if (elem
->in_num
> 3) {
248 * If we have more than 3 input segments the guest wants to actually
251 ioctl_req
->hdr
.dxfer_direction
= SG_DXFER_FROM_DEV
;
252 ioctl_req
->hdr
.iovec_count
= elem
->in_num
- 3;
253 for (i
= 0; i
< ioctl_req
->hdr
.iovec_count
; i
++) {
254 ioctl_req
->hdr
.dxfer_len
+= elem
->in_sg
[i
].iov_len
;
257 ioctl_req
->hdr
.dxferp
= elem
->in_sg
;
260 * Some SCSI commands don't actually transfer any data.
262 ioctl_req
->hdr
.dxfer_direction
= SG_DXFER_NONE
;
265 ioctl_req
->hdr
.sbp
= elem
->in_sg
[elem
->in_num
- 3].iov_base
;
266 ioctl_req
->hdr
.mx_sb_len
= elem
->in_sg
[elem
->in_num
- 3].iov_len
;
268 blk_aio_ioctl(blk
->blk
, SG_IO
, &ioctl_req
->hdr
,
269 virtio_blk_ioctl_complete
, ioctl_req
);
276 /* Just put anything nonzero so that the ioctl fails in the guest. */
278 virtio_stl_p(vdev
, &scsi
->errors
, 255);
283 static void virtio_blk_handle_scsi(VirtIOBlockReq
*req
)
287 status
= virtio_blk_handle_scsi_req(req
);
288 if (status
!= -EINPROGRESS
) {
289 virtio_blk_req_complete(req
, status
);
290 virtio_blk_free_request(req
);
294 void virtio_submit_multiwrite(BlockBackend
*blk
, MultiReqBuffer
*mrb
)
298 if (!mrb
->num_writes
) {
302 ret
= blk_aio_multiwrite(blk
, mrb
->blkreq
, mrb
->num_writes
);
304 for (i
= 0; i
< mrb
->num_writes
; i
++) {
305 if (mrb
->blkreq
[i
].error
) {
306 virtio_blk_rw_complete(mrb
->blkreq
[i
].opaque
, -EIO
);
314 static void virtio_blk_handle_flush(VirtIOBlockReq
*req
, MultiReqBuffer
*mrb
)
316 block_acct_start(blk_get_stats(req
->dev
->blk
), &req
->acct
, 0,
320 * Make sure all outstanding writes are posted to the backing device.
322 virtio_submit_multiwrite(req
->dev
->blk
, mrb
);
323 blk_aio_flush(req
->dev
->blk
, virtio_blk_flush_complete
, req
);
326 static bool virtio_blk_sect_range_ok(VirtIOBlock
*dev
,
327 uint64_t sector
, size_t size
)
329 uint64_t nb_sectors
= size
>> BDRV_SECTOR_BITS
;
330 uint64_t total_sectors
;
332 if (sector
& dev
->sector_mask
) {
335 if (size
% dev
->conf
.conf
.logical_block_size
) {
338 blk_get_geometry(dev
->blk
, &total_sectors
);
339 if (sector
> total_sectors
|| nb_sectors
> total_sectors
- sector
) {
345 static void virtio_blk_handle_write(VirtIOBlockReq
*req
, MultiReqBuffer
*mrb
)
347 BlockRequest
*blkreq
;
350 sector
= virtio_ldq_p(VIRTIO_DEVICE(req
->dev
), &req
->out
.sector
);
352 trace_virtio_blk_handle_write(req
, sector
, req
->qiov
.size
/ 512);
354 if (!virtio_blk_sect_range_ok(req
->dev
, sector
, req
->qiov
.size
)) {
355 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
356 virtio_blk_free_request(req
);
360 block_acct_start(blk_get_stats(req
->dev
->blk
), &req
->acct
, req
->qiov
.size
,
363 if (mrb
->num_writes
== 32) {
364 virtio_submit_multiwrite(req
->dev
->blk
, mrb
);
367 blkreq
= &mrb
->blkreq
[mrb
->num_writes
];
368 blkreq
->sector
= sector
;
369 blkreq
->nb_sectors
= req
->qiov
.size
/ BDRV_SECTOR_SIZE
;
370 blkreq
->qiov
= &req
->qiov
;
371 blkreq
->cb
= virtio_blk_rw_complete
;
372 blkreq
->opaque
= req
;
378 static void virtio_blk_handle_read(VirtIOBlockReq
*req
)
382 sector
= virtio_ldq_p(VIRTIO_DEVICE(req
->dev
), &req
->out
.sector
);
384 trace_virtio_blk_handle_read(req
, sector
, req
->qiov
.size
/ 512);
386 if (!virtio_blk_sect_range_ok(req
->dev
, sector
, req
->qiov
.size
)) {
387 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
388 virtio_blk_free_request(req
);
392 block_acct_start(blk_get_stats(req
->dev
->blk
), &req
->acct
, req
->qiov
.size
,
394 blk_aio_readv(req
->dev
->blk
, sector
, &req
->qiov
,
395 req
->qiov
.size
/ BDRV_SECTOR_SIZE
,
396 virtio_blk_rw_complete
, req
);
399 void virtio_blk_handle_request(VirtIOBlockReq
*req
, MultiReqBuffer
*mrb
)
402 struct iovec
*in_iov
= req
->elem
.in_sg
;
403 struct iovec
*iov
= req
->elem
.out_sg
;
404 unsigned in_num
= req
->elem
.in_num
;
405 unsigned out_num
= req
->elem
.out_num
;
407 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
408 error_report("virtio-blk missing headers");
412 if (unlikely(iov_to_buf(iov
, out_num
, 0, &req
->out
,
413 sizeof(req
->out
)) != sizeof(req
->out
))) {
414 error_report("virtio-blk request outhdr too short");
418 iov_discard_front(&iov
, &out_num
, sizeof(req
->out
));
421 in_iov
[in_num
- 1].iov_len
< sizeof(struct virtio_blk_inhdr
)) {
422 error_report("virtio-blk request inhdr too short");
426 req
->in
= (void *)in_iov
[in_num
- 1].iov_base
427 + in_iov
[in_num
- 1].iov_len
428 - sizeof(struct virtio_blk_inhdr
);
429 iov_discard_back(in_iov
, &in_num
, sizeof(struct virtio_blk_inhdr
));
431 type
= virtio_ldl_p(VIRTIO_DEVICE(req
->dev
), &req
->out
.type
);
433 if (type
& VIRTIO_BLK_T_FLUSH
) {
434 virtio_blk_handle_flush(req
, mrb
);
435 } else if (type
& VIRTIO_BLK_T_SCSI_CMD
) {
436 virtio_blk_handle_scsi(req
);
437 } else if (type
& VIRTIO_BLK_T_GET_ID
) {
438 VirtIOBlock
*s
= req
->dev
;
441 * NB: per existing s/n string convention the string is
442 * terminated by '\0' only when shorter than buffer.
444 const char *serial
= s
->conf
.serial
? s
->conf
.serial
: "";
445 size_t size
= MIN(strlen(serial
) + 1,
446 MIN(iov_size(in_iov
, in_num
),
447 VIRTIO_BLK_ID_BYTES
));
448 iov_from_buf(in_iov
, in_num
, 0, serial
, size
);
449 virtio_blk_req_complete(req
, VIRTIO_BLK_S_OK
);
450 virtio_blk_free_request(req
);
451 } else if (type
& VIRTIO_BLK_T_OUT
) {
452 qemu_iovec_init_external(&req
->qiov
, iov
, out_num
);
453 virtio_blk_handle_write(req
, mrb
);
454 } else if (type
== VIRTIO_BLK_T_IN
|| type
== VIRTIO_BLK_T_BARRIER
) {
455 /* VIRTIO_BLK_T_IN is 0, so we can't just & it. */
456 qemu_iovec_init_external(&req
->qiov
, in_iov
, in_num
);
457 virtio_blk_handle_read(req
);
459 virtio_blk_req_complete(req
, VIRTIO_BLK_S_UNSUPP
);
460 virtio_blk_free_request(req
);
464 static void virtio_blk_handle_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
466 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
468 MultiReqBuffer mrb
= {
472 /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
473 * dataplane here instead of waiting for .set_status().
476 virtio_blk_data_plane_start(s
->dataplane
);
480 while ((req
= virtio_blk_get_request(s
))) {
481 virtio_blk_handle_request(req
, &mrb
);
484 virtio_submit_multiwrite(s
->blk
, &mrb
);
487 * FIXME: Want to check for completions before returning to guest mode,
488 * so cached reads and writes are reported as quickly as possible. But
489 * that should be done in the generic block layer.
493 static void virtio_blk_dma_restart_bh(void *opaque
)
495 VirtIOBlock
*s
= opaque
;
496 VirtIOBlockReq
*req
= s
->rq
;
497 MultiReqBuffer mrb
= {
501 qemu_bh_delete(s
->bh
);
507 VirtIOBlockReq
*next
= req
->next
;
508 virtio_blk_handle_request(req
, &mrb
);
512 virtio_submit_multiwrite(s
->blk
, &mrb
);
515 static void virtio_blk_dma_restart_cb(void *opaque
, int running
,
518 VirtIOBlock
*s
= opaque
;
525 s
->bh
= aio_bh_new(blk_get_aio_context(s
->conf
.conf
.blk
),
526 virtio_blk_dma_restart_bh
, s
);
527 qemu_bh_schedule(s
->bh
);
531 static void virtio_blk_reset(VirtIODevice
*vdev
)
533 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
536 virtio_blk_data_plane_stop(s
->dataplane
);
540 * This should cancel pending requests, but can't do nicely until there
541 * are per-device request lists.
544 blk_set_enable_write_cache(s
->blk
, s
->original_wce
);
547 /* coalesce internal state, copy to pci i/o region 0
549 static void virtio_blk_update_config(VirtIODevice
*vdev
, uint8_t *config
)
551 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
552 BlockConf
*conf
= &s
->conf
.conf
;
553 struct virtio_blk_config blkcfg
;
555 int blk_size
= conf
->logical_block_size
;
557 blk_get_geometry(s
->blk
, &capacity
);
558 memset(&blkcfg
, 0, sizeof(blkcfg
));
559 virtio_stq_p(vdev
, &blkcfg
.capacity
, capacity
);
560 virtio_stl_p(vdev
, &blkcfg
.seg_max
, 128 - 2);
561 virtio_stw_p(vdev
, &blkcfg
.cylinders
, conf
->cyls
);
562 virtio_stl_p(vdev
, &blkcfg
.blk_size
, blk_size
);
563 virtio_stw_p(vdev
, &blkcfg
.min_io_size
, conf
->min_io_size
/ blk_size
);
564 virtio_stw_p(vdev
, &blkcfg
.opt_io_size
, conf
->opt_io_size
/ blk_size
);
565 blkcfg
.heads
= conf
->heads
;
567 * We must ensure that the block device capacity is a multiple of
568 * the logical block size. If that is not the case, let's use
569 * sector_mask to adopt the geometry to have a correct picture.
570 * For those devices where the capacity is ok for the given geometry
571 * we don't touch the sector value of the geometry, since some devices
572 * (like s390 dasd) need a specific value. Here the capacity is already
573 * cyls*heads*secs*blk_size and the sector value is not block size
574 * divided by 512 - instead it is the amount of blk_size blocks
575 * per track (cylinder).
577 if (blk_getlength(s
->blk
) / conf
->heads
/ conf
->secs
% blk_size
) {
578 blkcfg
.sectors
= conf
->secs
& ~s
->sector_mask
;
580 blkcfg
.sectors
= conf
->secs
;
583 blkcfg
.physical_block_exp
= get_physical_block_exp(conf
);
584 blkcfg
.alignment_offset
= 0;
585 blkcfg
.wce
= blk_enable_write_cache(s
->blk
);
586 memcpy(config
, &blkcfg
, sizeof(struct virtio_blk_config
));
589 static void virtio_blk_set_config(VirtIODevice
*vdev
, const uint8_t *config
)
591 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
592 struct virtio_blk_config blkcfg
;
594 memcpy(&blkcfg
, config
, sizeof(blkcfg
));
596 aio_context_acquire(blk_get_aio_context(s
->blk
));
597 blk_set_enable_write_cache(s
->blk
, blkcfg
.wce
!= 0);
598 aio_context_release(blk_get_aio_context(s
->blk
));
601 static uint32_t virtio_blk_get_features(VirtIODevice
*vdev
, uint32_t features
)
603 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
605 features
|= (1 << VIRTIO_BLK_F_SEG_MAX
);
606 features
|= (1 << VIRTIO_BLK_F_GEOMETRY
);
607 features
|= (1 << VIRTIO_BLK_F_TOPOLOGY
);
608 features
|= (1 << VIRTIO_BLK_F_BLK_SIZE
);
609 features
|= (1 << VIRTIO_BLK_F_SCSI
);
611 if (s
->conf
.config_wce
) {
612 features
|= (1 << VIRTIO_BLK_F_CONFIG_WCE
);
614 if (blk_enable_write_cache(s
->blk
)) {
615 features
|= (1 << VIRTIO_BLK_F_WCE
);
617 if (blk_is_read_only(s
->blk
)) {
618 features
|= 1 << VIRTIO_BLK_F_RO
;
624 static void virtio_blk_set_status(VirtIODevice
*vdev
, uint8_t status
)
626 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
629 if (s
->dataplane
&& !(status
& (VIRTIO_CONFIG_S_DRIVER
|
630 VIRTIO_CONFIG_S_DRIVER_OK
))) {
631 virtio_blk_data_plane_stop(s
->dataplane
);
634 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
638 features
= vdev
->guest_features
;
640 /* A guest that supports VIRTIO_BLK_F_CONFIG_WCE must be able to send
641 * cache flushes. Thus, the "auto writethrough" behavior is never
642 * necessary for guests that support the VIRTIO_BLK_F_CONFIG_WCE feature.
643 * Leaving it enabled would break the following sequence:
645 * Guest started with "-drive cache=writethrough"
646 * Guest sets status to 0
647 * Guest sets DRIVER bit in status field
648 * Guest reads host features (WCE=0, CONFIG_WCE=1)
649 * Guest writes guest features (WCE=0, CONFIG_WCE=1)
650 * Guest writes 1 to the WCE configuration field (writeback mode)
651 * Guest sets DRIVER_OK bit in status field
653 * s->blk would erroneously be placed in writethrough mode.
655 if (!(features
& (1 << VIRTIO_BLK_F_CONFIG_WCE
))) {
656 aio_context_acquire(blk_get_aio_context(s
->blk
));
657 blk_set_enable_write_cache(s
->blk
,
658 !!(features
& (1 << VIRTIO_BLK_F_WCE
)));
659 aio_context_release(blk_get_aio_context(s
->blk
));
663 static void virtio_blk_save(QEMUFile
*f
, void *opaque
)
665 VirtIODevice
*vdev
= VIRTIO_DEVICE(opaque
);
667 virtio_save(vdev
, f
);
670 static void virtio_blk_save_device(VirtIODevice
*vdev
, QEMUFile
*f
)
672 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
673 VirtIOBlockReq
*req
= s
->rq
;
676 qemu_put_sbyte(f
, 1);
677 qemu_put_buffer(f
, (unsigned char *)&req
->elem
,
678 sizeof(VirtQueueElement
));
681 qemu_put_sbyte(f
, 0);
684 static int virtio_blk_load(QEMUFile
*f
, void *opaque
, int version_id
)
686 VirtIOBlock
*s
= opaque
;
687 VirtIODevice
*vdev
= VIRTIO_DEVICE(s
);
692 return virtio_load(vdev
, f
, version_id
);
695 static int virtio_blk_load_device(VirtIODevice
*vdev
, QEMUFile
*f
,
698 VirtIOBlock
*s
= VIRTIO_BLK(vdev
);
700 while (qemu_get_sbyte(f
)) {
701 VirtIOBlockReq
*req
= virtio_blk_alloc_request(s
);
702 qemu_get_buffer(f
, (unsigned char *)&req
->elem
,
703 sizeof(VirtQueueElement
));
707 virtqueue_map_sg(req
->elem
.in_sg
, req
->elem
.in_addr
,
708 req
->elem
.in_num
, 1);
709 virtqueue_map_sg(req
->elem
.out_sg
, req
->elem
.out_addr
,
710 req
->elem
.out_num
, 0);
716 static void virtio_blk_resize(void *opaque
)
718 VirtIODevice
*vdev
= VIRTIO_DEVICE(opaque
);
720 virtio_notify_config(vdev
);
723 static const BlockDevOps virtio_block_ops
= {
724 .resize_cb
= virtio_blk_resize
,
727 /* Disable dataplane thread during live migration since it does not
728 * update the dirty memory bitmap yet.
730 static void virtio_blk_migration_state_changed(Notifier
*notifier
, void *data
)
732 VirtIOBlock
*s
= container_of(notifier
, VirtIOBlock
,
733 migration_state_notifier
);
734 MigrationState
*mig
= data
;
737 if (migration_in_setup(mig
)) {
741 virtio_blk_data_plane_destroy(s
->dataplane
);
743 } else if (migration_has_finished(mig
) ||
744 migration_has_failed(mig
)) {
748 blk_drain_all(); /* complete in-flight non-dataplane requests */
749 virtio_blk_data_plane_create(VIRTIO_DEVICE(s
), &s
->conf
,
750 &s
->dataplane
, &err
);
752 error_report("%s", error_get_pretty(err
));
758 static void virtio_blk_device_realize(DeviceState
*dev
, Error
**errp
)
760 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
761 VirtIOBlock
*s
= VIRTIO_BLK(dev
);
762 VirtIOBlkConf
*conf
= &s
->conf
;
764 static int virtio_blk_id
;
766 if (!conf
->conf
.blk
) {
767 error_setg(errp
, "drive property not set");
770 if (!blk_is_inserted(conf
->conf
.blk
)) {
771 error_setg(errp
, "Device needs media, but drive is empty");
775 blkconf_serial(&conf
->conf
, &conf
->serial
);
776 s
->original_wce
= blk_enable_write_cache(conf
->conf
.blk
);
777 blkconf_geometry(&conf
->conf
, NULL
, 65535, 255, 255, &err
);
779 error_propagate(errp
, err
);
783 virtio_init(vdev
, "virtio-blk", VIRTIO_ID_BLOCK
,
784 sizeof(struct virtio_blk_config
));
786 s
->blk
= conf
->conf
.blk
;
788 s
->sector_mask
= (s
->conf
.conf
.logical_block_size
/ BDRV_SECTOR_SIZE
) - 1;
790 s
->vq
= virtio_add_queue(vdev
, 128, virtio_blk_handle_output
);
791 s
->complete_request
= virtio_blk_complete_request
;
792 virtio_blk_data_plane_create(vdev
, conf
, &s
->dataplane
, &err
);
794 error_propagate(errp
, err
);
795 virtio_cleanup(vdev
);
798 s
->migration_state_notifier
.notify
= virtio_blk_migration_state_changed
;
799 add_migration_state_change_notifier(&s
->migration_state_notifier
);
801 s
->change
= qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb
, s
);
802 register_savevm(dev
, "virtio-blk", virtio_blk_id
++, 2,
803 virtio_blk_save
, virtio_blk_load
, s
);
804 blk_set_dev_ops(s
->blk
, &virtio_block_ops
, s
);
805 blk_set_guest_block_size(s
->blk
, s
->conf
.conf
.logical_block_size
);
807 blk_iostatus_enable(s
->blk
);
810 static void virtio_blk_device_unrealize(DeviceState
*dev
, Error
**errp
)
812 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
813 VirtIOBlock
*s
= VIRTIO_BLK(dev
);
815 remove_migration_state_change_notifier(&s
->migration_state_notifier
);
816 virtio_blk_data_plane_destroy(s
->dataplane
);
818 qemu_del_vm_change_state_handler(s
->change
);
819 unregister_savevm(dev
, "virtio-blk", s
);
820 blockdev_mark_auto_del(s
->blk
);
821 virtio_cleanup(vdev
);
824 static void virtio_blk_instance_init(Object
*obj
)
826 VirtIOBlock
*s
= VIRTIO_BLK(obj
);
828 object_property_add_link(obj
, "iothread", TYPE_IOTHREAD
,
829 (Object
**)&s
->conf
.iothread
,
830 qdev_prop_allow_set_link_before_realize
,
831 OBJ_PROP_LINK_UNREF_ON_RELEASE
, NULL
);
832 device_add_bootindex_property(obj
, &s
->conf
.conf
.bootindex
,
833 "bootindex", "/disk@0,0",
837 static Property virtio_blk_properties
[] = {
838 DEFINE_BLOCK_PROPERTIES(VirtIOBlock
, conf
.conf
),
839 DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock
, conf
.conf
),
840 DEFINE_PROP_STRING("serial", VirtIOBlock
, conf
.serial
),
841 DEFINE_PROP_BIT("config-wce", VirtIOBlock
, conf
.config_wce
, 0, true),
843 DEFINE_PROP_BIT("scsi", VirtIOBlock
, conf
.scsi
, 0, true),
845 DEFINE_PROP_BIT("x-data-plane", VirtIOBlock
, conf
.data_plane
, 0, false),
846 DEFINE_PROP_END_OF_LIST(),
849 static void virtio_blk_class_init(ObjectClass
*klass
, void *data
)
851 DeviceClass
*dc
= DEVICE_CLASS(klass
);
852 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
854 dc
->props
= virtio_blk_properties
;
855 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
856 vdc
->realize
= virtio_blk_device_realize
;
857 vdc
->unrealize
= virtio_blk_device_unrealize
;
858 vdc
->get_config
= virtio_blk_update_config
;
859 vdc
->set_config
= virtio_blk_set_config
;
860 vdc
->get_features
= virtio_blk_get_features
;
861 vdc
->set_status
= virtio_blk_set_status
;
862 vdc
->reset
= virtio_blk_reset
;
863 vdc
->save
= virtio_blk_save_device
;
864 vdc
->load
= virtio_blk_load_device
;
867 static const TypeInfo virtio_device_info
= {
868 .name
= TYPE_VIRTIO_BLK
,
869 .parent
= TYPE_VIRTIO_DEVICE
,
870 .instance_size
= sizeof(VirtIOBlock
),
871 .instance_init
= virtio_blk_instance_init
,
872 .class_init
= virtio_blk_class_init
,
875 static void virtio_register_types(void)
877 type_register_static(&virtio_device_info
);
880 type_init(virtio_register_types
)