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"
15 #include "qemu-error.h"
18 #include "virtio-blk.h"
19 #include "scsi-defs.h"
24 typedef struct VirtIOBlock
33 unsigned short sector_mask
;
37 static VirtIOBlock
*to_virtio_blk(VirtIODevice
*vdev
)
39 return (VirtIOBlock
*)vdev
;
42 typedef struct VirtIOBlockReq
45 VirtQueueElement elem
;
46 struct virtio_blk_inhdr
*in
;
47 struct virtio_blk_outhdr
*out
;
48 struct virtio_scsi_inhdr
*scsi
;
50 struct VirtIOBlockReq
*next
;
54 static void virtio_blk_req_complete(VirtIOBlockReq
*req
, int status
)
56 VirtIOBlock
*s
= req
->dev
;
58 trace_virtio_blk_req_complete(req
, status
);
60 stb_p(&req
->in
->status
, status
);
61 virtqueue_push(s
->vq
, &req
->elem
, req
->qiov
.size
+ sizeof(*req
->in
));
62 virtio_notify(&s
->vdev
, s
->vq
);
65 static int virtio_blk_handle_rw_error(VirtIOBlockReq
*req
, int error
,
68 BlockErrorAction action
= bdrv_get_on_error(req
->dev
->bs
, is_read
);
69 VirtIOBlock
*s
= req
->dev
;
71 if (action
== BLOCK_ERR_IGNORE
) {
72 bdrv_emit_qmp_error_event(s
->bs
, BDRV_ACTION_IGNORE
, is_read
);
76 if ((error
== ENOSPC
&& action
== BLOCK_ERR_STOP_ENOSPC
)
77 || action
== BLOCK_ERR_STOP_ANY
) {
80 bdrv_emit_qmp_error_event(s
->bs
, BDRV_ACTION_STOP
, is_read
);
81 vm_stop(RUN_STATE_IO_ERROR
);
82 bdrv_iostatus_set_err(s
->bs
, error
);
84 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
85 bdrv_acct_done(s
->bs
, &req
->acct
);
87 bdrv_emit_qmp_error_event(s
->bs
, BDRV_ACTION_REPORT
, is_read
);
93 static void virtio_blk_rw_complete(void *opaque
, int ret
)
95 VirtIOBlockReq
*req
= opaque
;
97 trace_virtio_blk_rw_complete(req
, ret
);
100 int is_read
= !(ldl_p(&req
->out
->type
) & VIRTIO_BLK_T_OUT
);
101 if (virtio_blk_handle_rw_error(req
, -ret
, is_read
))
105 virtio_blk_req_complete(req
, VIRTIO_BLK_S_OK
);
106 bdrv_acct_done(req
->dev
->bs
, &req
->acct
);
110 static void virtio_blk_flush_complete(void *opaque
, int ret
)
112 VirtIOBlockReq
*req
= opaque
;
115 if (virtio_blk_handle_rw_error(req
, -ret
, 0)) {
120 virtio_blk_req_complete(req
, VIRTIO_BLK_S_OK
);
121 bdrv_acct_done(req
->dev
->bs
, &req
->acct
);
125 static VirtIOBlockReq
*virtio_blk_alloc_request(VirtIOBlock
*s
)
127 VirtIOBlockReq
*req
= g_malloc(sizeof(*req
));
134 static VirtIOBlockReq
*virtio_blk_get_request(VirtIOBlock
*s
)
136 VirtIOBlockReq
*req
= virtio_blk_alloc_request(s
);
139 if (!virtqueue_pop(s
->vq
, &req
->elem
)) {
148 static void virtio_blk_handle_scsi(VirtIOBlockReq
*req
)
151 int status
= VIRTIO_BLK_S_OK
;
155 * We require at least one output segment each for the virtio_blk_outhdr
156 * and the SCSI command block.
158 * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
159 * and the sense buffer pointer in the input segments.
161 if (req
->elem
.out_num
< 2 || req
->elem
.in_num
< 3) {
162 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
168 * The scsi inhdr is placed in the second-to-last input segment, just
169 * before the regular inhdr.
171 req
->scsi
= (void *)req
->elem
.in_sg
[req
->elem
.in_num
- 2].iov_base
;
173 if (!req
->dev
->blk
->scsi
) {
174 status
= VIRTIO_BLK_S_UNSUPP
;
179 * No support for bidirection commands yet.
181 if (req
->elem
.out_num
> 2 && req
->elem
.in_num
> 3) {
182 status
= VIRTIO_BLK_S_UNSUPP
;
187 struct sg_io_hdr hdr
;
188 memset(&hdr
, 0, sizeof(struct sg_io_hdr
));
189 hdr
.interface_id
= 'S';
190 hdr
.cmd_len
= req
->elem
.out_sg
[1].iov_len
;
191 hdr
.cmdp
= req
->elem
.out_sg
[1].iov_base
;
194 if (req
->elem
.out_num
> 2) {
196 * If there are more than the minimally required 2 output segments
197 * there is write payload starting from the third iovec.
199 hdr
.dxfer_direction
= SG_DXFER_TO_DEV
;
200 hdr
.iovec_count
= req
->elem
.out_num
- 2;
202 for (i
= 0; i
< hdr
.iovec_count
; i
++)
203 hdr
.dxfer_len
+= req
->elem
.out_sg
[i
+ 2].iov_len
;
205 hdr
.dxferp
= req
->elem
.out_sg
+ 2;
207 } else if (req
->elem
.in_num
> 3) {
209 * If we have more than 3 input segments the guest wants to actually
212 hdr
.dxfer_direction
= SG_DXFER_FROM_DEV
;
213 hdr
.iovec_count
= req
->elem
.in_num
- 3;
214 for (i
= 0; i
< hdr
.iovec_count
; i
++)
215 hdr
.dxfer_len
+= req
->elem
.in_sg
[i
].iov_len
;
217 hdr
.dxferp
= req
->elem
.in_sg
;
220 * Some SCSI commands don't actually transfer any data.
222 hdr
.dxfer_direction
= SG_DXFER_NONE
;
225 hdr
.sbp
= req
->elem
.in_sg
[req
->elem
.in_num
- 3].iov_base
;
226 hdr
.mx_sb_len
= req
->elem
.in_sg
[req
->elem
.in_num
- 3].iov_len
;
228 ret
= bdrv_ioctl(req
->dev
->bs
, SG_IO
, &hdr
);
230 status
= VIRTIO_BLK_S_UNSUPP
;
235 * From SCSI-Generic-HOWTO: "Some lower level drivers (e.g. ide-scsi)
236 * clear the masked_status field [hence status gets cleared too, see
237 * block/scsi_ioctl.c] even when a CHECK_CONDITION or COMMAND_TERMINATED
238 * status has occurred. However they do set DRIVER_SENSE in driver_status
239 * field. Also a (sb_len_wr > 0) indicates there is a sense buffer.
241 if (hdr
.status
== 0 && hdr
.sb_len_wr
> 0) {
242 hdr
.status
= CHECK_CONDITION
;
245 stl_p(&req
->scsi
->errors
,
246 hdr
.status
| (hdr
.msg_status
<< 8) |
247 (hdr
.host_status
<< 16) | (hdr
.driver_status
<< 24));
248 stl_p(&req
->scsi
->residual
, hdr
.resid
);
249 stl_p(&req
->scsi
->sense_len
, hdr
.sb_len_wr
);
250 stl_p(&req
->scsi
->data_len
, hdr
.dxfer_len
);
252 virtio_blk_req_complete(req
, status
);
259 /* Just put anything nonzero so that the ioctl fails in the guest. */
260 stl_p(&req
->scsi
->errors
, 255);
261 virtio_blk_req_complete(req
, status
);
265 typedef struct MultiReqBuffer
{
266 BlockRequest blkreq
[32];
267 unsigned int num_writes
;
270 static void virtio_submit_multiwrite(BlockDriverState
*bs
, MultiReqBuffer
*mrb
)
274 if (!mrb
->num_writes
) {
278 ret
= bdrv_aio_multiwrite(bs
, mrb
->blkreq
, mrb
->num_writes
);
280 for (i
= 0; i
< mrb
->num_writes
; i
++) {
281 if (mrb
->blkreq
[i
].error
) {
282 virtio_blk_rw_complete(mrb
->blkreq
[i
].opaque
, -EIO
);
290 static void virtio_blk_handle_flush(VirtIOBlockReq
*req
, MultiReqBuffer
*mrb
)
292 bdrv_acct_start(req
->dev
->bs
, &req
->acct
, 0, BDRV_ACCT_FLUSH
);
295 * Make sure all outstanding writes are posted to the backing device.
297 virtio_submit_multiwrite(req
->dev
->bs
, mrb
);
298 bdrv_aio_flush(req
->dev
->bs
, virtio_blk_flush_complete
, req
);
301 static void virtio_blk_handle_write(VirtIOBlockReq
*req
, MultiReqBuffer
*mrb
)
303 BlockRequest
*blkreq
;
306 sector
= ldq_p(&req
->out
->sector
);
308 bdrv_acct_start(req
->dev
->bs
, &req
->acct
, req
->qiov
.size
, BDRV_ACCT_WRITE
);
310 trace_virtio_blk_handle_write(req
, sector
, req
->qiov
.size
/ 512);
312 if (sector
& req
->dev
->sector_mask
) {
313 virtio_blk_rw_complete(req
, -EIO
);
316 if (req
->qiov
.size
% req
->dev
->conf
->logical_block_size
) {
317 virtio_blk_rw_complete(req
, -EIO
);
321 if (mrb
->num_writes
== 32) {
322 virtio_submit_multiwrite(req
->dev
->bs
, mrb
);
325 blkreq
= &mrb
->blkreq
[mrb
->num_writes
];
326 blkreq
->sector
= sector
;
327 blkreq
->nb_sectors
= req
->qiov
.size
/ BDRV_SECTOR_SIZE
;
328 blkreq
->qiov
= &req
->qiov
;
329 blkreq
->cb
= virtio_blk_rw_complete
;
330 blkreq
->opaque
= req
;
336 static void virtio_blk_handle_read(VirtIOBlockReq
*req
)
340 sector
= ldq_p(&req
->out
->sector
);
342 bdrv_acct_start(req
->dev
->bs
, &req
->acct
, req
->qiov
.size
, BDRV_ACCT_READ
);
344 trace_virtio_blk_handle_read(req
, sector
, req
->qiov
.size
/ 512);
346 if (sector
& req
->dev
->sector_mask
) {
347 virtio_blk_rw_complete(req
, -EIO
);
350 if (req
->qiov
.size
% req
->dev
->conf
->logical_block_size
) {
351 virtio_blk_rw_complete(req
, -EIO
);
354 bdrv_aio_readv(req
->dev
->bs
, sector
, &req
->qiov
,
355 req
->qiov
.size
/ BDRV_SECTOR_SIZE
,
356 virtio_blk_rw_complete
, req
);
359 static void virtio_blk_handle_request(VirtIOBlockReq
*req
,
364 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
365 error_report("virtio-blk missing headers");
369 if (req
->elem
.out_sg
[0].iov_len
< sizeof(*req
->out
) ||
370 req
->elem
.in_sg
[req
->elem
.in_num
- 1].iov_len
< sizeof(*req
->in
)) {
371 error_report("virtio-blk header not in correct element");
375 req
->out
= (void *)req
->elem
.out_sg
[0].iov_base
;
376 req
->in
= (void *)req
->elem
.in_sg
[req
->elem
.in_num
- 1].iov_base
;
378 type
= ldl_p(&req
->out
->type
);
380 if (type
& VIRTIO_BLK_T_FLUSH
) {
381 virtio_blk_handle_flush(req
, mrb
);
382 } else if (type
& VIRTIO_BLK_T_SCSI_CMD
) {
383 virtio_blk_handle_scsi(req
);
384 } else if (type
& VIRTIO_BLK_T_GET_ID
) {
385 VirtIOBlock
*s
= req
->dev
;
388 * NB: per existing s/n string convention the string is
389 * terminated by '\0' only when shorter than buffer.
391 strncpy(req
->elem
.in_sg
[0].iov_base
,
392 s
->blk
->serial
? s
->blk
->serial
: "",
393 MIN(req
->elem
.in_sg
[0].iov_len
, VIRTIO_BLK_ID_BYTES
));
394 virtio_blk_req_complete(req
, VIRTIO_BLK_S_OK
);
396 } else if (type
& VIRTIO_BLK_T_OUT
) {
397 qemu_iovec_init_external(&req
->qiov
, &req
->elem
.out_sg
[1],
398 req
->elem
.out_num
- 1);
399 virtio_blk_handle_write(req
, mrb
);
401 qemu_iovec_init_external(&req
->qiov
, &req
->elem
.in_sg
[0],
402 req
->elem
.in_num
- 1);
403 virtio_blk_handle_read(req
);
407 static void virtio_blk_handle_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
409 VirtIOBlock
*s
= to_virtio_blk(vdev
);
411 MultiReqBuffer mrb
= {
415 while ((req
= virtio_blk_get_request(s
))) {
416 virtio_blk_handle_request(req
, &mrb
);
419 virtio_submit_multiwrite(s
->bs
, &mrb
);
422 * FIXME: Want to check for completions before returning to guest mode,
423 * so cached reads and writes are reported as quickly as possible. But
424 * that should be done in the generic block layer.
428 static void virtio_blk_dma_restart_bh(void *opaque
)
430 VirtIOBlock
*s
= opaque
;
431 VirtIOBlockReq
*req
= s
->rq
;
432 MultiReqBuffer mrb
= {
436 qemu_bh_delete(s
->bh
);
442 virtio_blk_handle_request(req
, &mrb
);
446 virtio_submit_multiwrite(s
->bs
, &mrb
);
449 static void virtio_blk_dma_restart_cb(void *opaque
, int running
,
452 VirtIOBlock
*s
= opaque
;
458 s
->bh
= qemu_bh_new(virtio_blk_dma_restart_bh
, s
);
459 qemu_bh_schedule(s
->bh
);
463 static void virtio_blk_reset(VirtIODevice
*vdev
)
466 * This should cancel pending requests, but can't do nicely until there
467 * are per-device request lists.
472 /* coalesce internal state, copy to pci i/o region 0
474 static void virtio_blk_update_config(VirtIODevice
*vdev
, uint8_t *config
)
476 VirtIOBlock
*s
= to_virtio_blk(vdev
);
477 struct virtio_blk_config blkcfg
;
479 int cylinders
, heads
, secs
;
480 int blk_size
= s
->conf
->logical_block_size
;
482 bdrv_get_geometry(s
->bs
, &capacity
);
483 bdrv_get_geometry_hint(s
->bs
, &cylinders
, &heads
, &secs
);
484 memset(&blkcfg
, 0, sizeof(blkcfg
));
485 stq_raw(&blkcfg
.capacity
, capacity
);
486 stl_raw(&blkcfg
.seg_max
, 128 - 2);
487 stw_raw(&blkcfg
.cylinders
, cylinders
);
488 stl_raw(&blkcfg
.blk_size
, blk_size
);
489 stw_raw(&blkcfg
.min_io_size
, s
->conf
->min_io_size
/ blk_size
);
490 stw_raw(&blkcfg
.opt_io_size
, s
->conf
->opt_io_size
/ blk_size
);
491 blkcfg
.heads
= heads
;
492 blkcfg
.sectors
= secs
& ~s
->sector_mask
;
494 blkcfg
.physical_block_exp
= get_physical_block_exp(s
->conf
);
495 blkcfg
.alignment_offset
= 0;
496 memcpy(config
, &blkcfg
, sizeof(struct virtio_blk_config
));
499 static uint32_t virtio_blk_get_features(VirtIODevice
*vdev
, uint32_t features
)
501 VirtIOBlock
*s
= to_virtio_blk(vdev
);
503 features
|= (1 << VIRTIO_BLK_F_SEG_MAX
);
504 features
|= (1 << VIRTIO_BLK_F_GEOMETRY
);
505 features
|= (1 << VIRTIO_BLK_F_TOPOLOGY
);
506 features
|= (1 << VIRTIO_BLK_F_BLK_SIZE
);
507 features
|= (1 << VIRTIO_BLK_F_SCSI
);
509 if (bdrv_enable_write_cache(s
->bs
))
510 features
|= (1 << VIRTIO_BLK_F_WCACHE
);
512 if (bdrv_is_read_only(s
->bs
))
513 features
|= 1 << VIRTIO_BLK_F_RO
;
518 static void virtio_blk_save(QEMUFile
*f
, void *opaque
)
520 VirtIOBlock
*s
= opaque
;
521 VirtIOBlockReq
*req
= s
->rq
;
523 virtio_save(&s
->vdev
, f
);
526 qemu_put_sbyte(f
, 1);
527 qemu_put_buffer(f
, (unsigned char*)&req
->elem
, sizeof(req
->elem
));
530 qemu_put_sbyte(f
, 0);
533 static int virtio_blk_load(QEMUFile
*f
, void *opaque
, int version_id
)
535 VirtIOBlock
*s
= opaque
;
541 ret
= virtio_load(&s
->vdev
, f
);
546 while (qemu_get_sbyte(f
)) {
547 VirtIOBlockReq
*req
= virtio_blk_alloc_request(s
);
548 qemu_get_buffer(f
, (unsigned char*)&req
->elem
, sizeof(req
->elem
));
552 virtqueue_map_sg(req
->elem
.in_sg
, req
->elem
.in_addr
,
553 req
->elem
.in_num
, 1);
554 virtqueue_map_sg(req
->elem
.out_sg
, req
->elem
.out_addr
,
555 req
->elem
.out_num
, 0);
561 static void virtio_blk_resize(void *opaque
)
563 VirtIOBlock
*s
= opaque
;
565 virtio_notify_config(&s
->vdev
);
568 static const BlockDevOps virtio_block_ops
= {
569 .resize_cb
= virtio_blk_resize
,
572 VirtIODevice
*virtio_blk_init(DeviceState
*dev
, VirtIOBlkConf
*blk
)
575 int cylinders
, heads
, secs
;
576 static int virtio_blk_id
;
580 error_report("drive property not set");
583 if (!bdrv_is_inserted(blk
->conf
.bs
)) {
584 error_report("Device needs media, but drive is empty");
589 /* try to fall back to value set with legacy -drive serial=... */
590 dinfo
= drive_get_by_blockdev(blk
->conf
.bs
);
591 if (*dinfo
->serial
) {
592 blk
->serial
= strdup(dinfo
->serial
);
596 s
= (VirtIOBlock
*)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK
,
597 sizeof(struct virtio_blk_config
),
598 sizeof(VirtIOBlock
));
600 s
->vdev
.get_config
= virtio_blk_update_config
;
601 s
->vdev
.get_features
= virtio_blk_get_features
;
602 s
->vdev
.reset
= virtio_blk_reset
;
603 s
->bs
= blk
->conf
.bs
;
604 s
->conf
= &blk
->conf
;
607 s
->sector_mask
= (s
->conf
->logical_block_size
/ BDRV_SECTOR_SIZE
) - 1;
608 bdrv_guess_geometry(s
->bs
, &cylinders
, &heads
, &secs
);
610 s
->vq
= virtio_add_queue(&s
->vdev
, 128, virtio_blk_handle_output
);
612 qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb
, s
);
614 register_savevm(dev
, "virtio-blk", virtio_blk_id
++, 2,
615 virtio_blk_save
, virtio_blk_load
, s
);
616 bdrv_set_dev_ops(s
->bs
, &virtio_block_ops
, s
);
617 bdrv_set_buffer_alignment(s
->bs
, s
->conf
->logical_block_size
);
619 bdrv_iostatus_enable(s
->bs
);
620 add_boot_device_path(s
->conf
->bootindex
, dev
, "/disk@0,0");
625 void virtio_blk_exit(VirtIODevice
*vdev
)
627 VirtIOBlock
*s
= to_virtio_blk(vdev
);
628 unregister_savevm(s
->qdev
, "virtio-blk", s
);
629 blockdev_mark_auto_del(s
->bs
);
630 virtio_cleanup(vdev
);