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 "virtio-blk.h"
17 #include "block_int.h"
22 typedef struct VirtIOBlock
28 char serial_str
[BLOCK_SERIAL_STRLEN
+ 1];
33 static VirtIOBlock
*to_virtio_blk(VirtIODevice
*vdev
)
35 return (VirtIOBlock
*)vdev
;
38 /* store identify data in little endian format
40 static inline void put_le16(uint16_t *p
, unsigned int v
)
45 /* copy to *dst from *src, nul pad dst tail as needed to len bytes
47 static inline void padstr(char *dst
, const char *src
, int len
)
50 *dst
++ = *src
? *src
++ : '\0';
53 /* setup simulated identify data as appropriate for virtio block device
55 * ref: AT Attachment 8 - ATA/ATAPI Command Set (ATA8-ACS)
57 static inline void virtio_identify_template(struct virtio_blk_config
*bc
)
59 uint16_t *p
= &bc
->identify
[0];
60 uint64_t lba_sectors
= bc
->capacity
;
62 memset(p
, 0, sizeof(bc
->identify
));
63 put_le16(p
+ 0, 0x0); /* ATA device */
64 padstr((char *)(p
+ 23), QEMU_VERSION
, 8); /* firmware revision */
65 padstr((char *)(p
+ 27), "QEMU VIRT_BLK", 40); /* model# */
66 put_le16(p
+ 47, 0x80ff); /* max xfer 255 sectors */
67 put_le16(p
+ 49, 0x0b00); /* support IORDY/LBA/DMA */
68 put_le16(p
+ 59, 0x1ff); /* cur xfer 255 sectors */
69 put_le16(p
+ 80, 0x1f0); /* support ATA8/7/6/5/4 */
70 put_le16(p
+ 81, 0x16);
71 put_le16(p
+ 82, 0x400);
72 put_le16(p
+ 83, 0x400);
73 put_le16(p
+ 100, lba_sectors
);
74 put_le16(p
+ 101, lba_sectors
>> 16);
75 put_le16(p
+ 102, lba_sectors
>> 32);
76 put_le16(p
+ 103, lba_sectors
>> 48);
79 typedef struct VirtIOBlockReq
82 VirtQueueElement elem
;
83 struct virtio_blk_inhdr
*in
;
84 struct virtio_blk_outhdr
*out
;
85 struct virtio_scsi_inhdr
*scsi
;
87 struct VirtIOBlockReq
*next
;
90 static void virtio_blk_req_complete(VirtIOBlockReq
*req
, int status
)
92 VirtIOBlock
*s
= req
->dev
;
94 req
->in
->status
= status
;
95 virtqueue_push(s
->vq
, &req
->elem
, req
->qiov
.size
+ sizeof(*req
->in
));
96 virtio_notify(&s
->vdev
, s
->vq
);
101 static int virtio_blk_handle_rw_error(VirtIOBlockReq
*req
, int error
,
104 BlockInterfaceErrorAction action
=
105 drive_get_on_error(req
->dev
->bs
, is_read
);
106 VirtIOBlock
*s
= req
->dev
;
108 if (action
== BLOCK_ERR_IGNORE
)
111 if ((error
== ENOSPC
&& action
== BLOCK_ERR_STOP_ENOSPC
)
112 || action
== BLOCK_ERR_STOP_ANY
) {
117 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
123 static void virtio_blk_rw_complete(void *opaque
, int ret
)
125 VirtIOBlockReq
*req
= opaque
;
128 int is_read
= !(req
->out
->type
& VIRTIO_BLK_T_OUT
);
129 if (virtio_blk_handle_rw_error(req
, -ret
, is_read
))
133 virtio_blk_req_complete(req
, VIRTIO_BLK_S_OK
);
136 static void virtio_blk_flush_complete(void *opaque
, int ret
)
138 VirtIOBlockReq
*req
= opaque
;
140 virtio_blk_req_complete(req
, ret
? VIRTIO_BLK_S_IOERR
: VIRTIO_BLK_S_OK
);
143 static VirtIOBlockReq
*virtio_blk_alloc_request(VirtIOBlock
*s
)
145 VirtIOBlockReq
*req
= qemu_mallocz(sizeof(*req
));
150 static VirtIOBlockReq
*virtio_blk_get_request(VirtIOBlock
*s
)
152 VirtIOBlockReq
*req
= virtio_blk_alloc_request(s
);
155 if (!virtqueue_pop(s
->vq
, &req
->elem
)) {
165 static void virtio_blk_handle_scsi(VirtIOBlockReq
*req
)
167 struct sg_io_hdr hdr
;
173 * We require at least one output segment each for the virtio_blk_outhdr
174 * and the SCSI command block.
176 * We also at least require the virtio_blk_inhdr, the virtio_scsi_inhdr
177 * and the sense buffer pointer in the input segments.
179 if (req
->elem
.out_num
< 2 || req
->elem
.in_num
< 3) {
180 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
185 * No support for bidirection commands yet.
187 if (req
->elem
.out_num
> 2 && req
->elem
.in_num
> 3) {
188 virtio_blk_req_complete(req
, VIRTIO_BLK_S_UNSUPP
);
193 * The scsi inhdr is placed in the second-to-last input segment, just
194 * before the regular inhdr.
196 req
->scsi
= (void *)req
->elem
.in_sg
[req
->elem
.in_num
- 2].iov_base
;
197 size
= sizeof(*req
->in
) + sizeof(*req
->scsi
);
199 memset(&hdr
, 0, sizeof(struct sg_io_hdr
));
200 hdr
.interface_id
= 'S';
201 hdr
.cmd_len
= req
->elem
.out_sg
[1].iov_len
;
202 hdr
.cmdp
= req
->elem
.out_sg
[1].iov_base
;
205 if (req
->elem
.out_num
> 2) {
207 * If there are more than the minimally required 2 output segments
208 * there is write payload starting from the third iovec.
210 hdr
.dxfer_direction
= SG_DXFER_TO_DEV
;
211 hdr
.iovec_count
= req
->elem
.out_num
- 2;
213 for (i
= 0; i
< hdr
.iovec_count
; i
++)
214 hdr
.dxfer_len
+= req
->elem
.out_sg
[i
+ 2].iov_len
;
216 hdr
.dxferp
= req
->elem
.out_sg
+ 2;
218 } else if (req
->elem
.in_num
> 3) {
220 * If we have more than 3 input segments the guest wants to actually
223 hdr
.dxfer_direction
= SG_DXFER_FROM_DEV
;
224 hdr
.iovec_count
= req
->elem
.in_num
- 3;
225 for (i
= 0; i
< hdr
.iovec_count
; i
++)
226 hdr
.dxfer_len
+= req
->elem
.in_sg
[i
].iov_len
;
228 hdr
.dxferp
= req
->elem
.in_sg
;
229 size
+= hdr
.dxfer_len
;
232 * Some SCSI commands don't actually transfer any data.
234 hdr
.dxfer_direction
= SG_DXFER_NONE
;
237 hdr
.sbp
= req
->elem
.in_sg
[req
->elem
.in_num
- 3].iov_base
;
238 hdr
.mx_sb_len
= req
->elem
.in_sg
[req
->elem
.in_num
- 3].iov_len
;
239 size
+= hdr
.mx_sb_len
;
241 ret
= bdrv_ioctl(req
->dev
->bs
, SG_IO
, &hdr
);
243 status
= VIRTIO_BLK_S_UNSUPP
;
245 hdr
.resid
= hdr
.dxfer_len
;
246 } else if (hdr
.status
) {
247 status
= VIRTIO_BLK_S_IOERR
;
249 status
= VIRTIO_BLK_S_OK
;
252 req
->scsi
->errors
= hdr
.status
;
253 req
->scsi
->residual
= hdr
.resid
;
254 req
->scsi
->sense_len
= hdr
.sb_len_wr
;
255 req
->scsi
->data_len
= hdr
.dxfer_len
;
257 virtio_blk_req_complete(req
, status
);
260 static void virtio_blk_handle_scsi(VirtIOBlockReq
*req
)
262 virtio_blk_req_complete(req
, VIRTIO_BLK_S_UNSUPP
);
264 #endif /* __linux__ */
266 static void do_multiwrite(BlockDriverState
*bs
, BlockRequest
*blkreq
,
270 ret
= bdrv_aio_multiwrite(bs
, blkreq
, num_writes
);
273 for (i
= 0; i
< num_writes
; i
++) {
274 if (blkreq
[i
].error
) {
275 virtio_blk_rw_complete(blkreq
[i
].opaque
, -EIO
);
281 static void virtio_blk_handle_flush(BlockRequest
*blkreq
, int *num_writes
,
282 VirtIOBlockReq
*req
, BlockDriverState
**old_bs
)
284 BlockDriverAIOCB
*acb
;
287 * Make sure all outstanding writes are posted to the backing device.
289 if (*old_bs
!= NULL
) {
290 do_multiwrite(*old_bs
, blkreq
, *num_writes
);
293 *old_bs
= req
->dev
->bs
;
295 acb
= bdrv_aio_flush(req
->dev
->bs
, virtio_blk_flush_complete
, req
);
297 virtio_blk_req_complete(req
, VIRTIO_BLK_S_IOERR
);
301 static void virtio_blk_handle_write(BlockRequest
*blkreq
, int *num_writes
,
302 VirtIOBlockReq
*req
, BlockDriverState
**old_bs
)
304 if (req
->dev
->bs
!= *old_bs
|| *num_writes
== 32) {
305 if (*old_bs
!= NULL
) {
306 do_multiwrite(*old_bs
, blkreq
, *num_writes
);
309 *old_bs
= req
->dev
->bs
;
312 blkreq
[*num_writes
].sector
= req
->out
->sector
;
313 blkreq
[*num_writes
].nb_sectors
= req
->qiov
.size
/ 512;
314 blkreq
[*num_writes
].qiov
= &req
->qiov
;
315 blkreq
[*num_writes
].cb
= virtio_blk_rw_complete
;
316 blkreq
[*num_writes
].opaque
= req
;
317 blkreq
[*num_writes
].error
= 0;
322 static void virtio_blk_handle_read(VirtIOBlockReq
*req
)
324 BlockDriverAIOCB
*acb
;
326 acb
= bdrv_aio_readv(req
->dev
->bs
, req
->out
->sector
, &req
->qiov
,
327 req
->qiov
.size
/ 512, virtio_blk_rw_complete
, req
);
329 virtio_blk_rw_complete(req
, -EIO
);
333 typedef struct MultiReqBuffer
{
334 BlockRequest blkreq
[32];
336 BlockDriverState
*old_bs
;
339 static void virtio_blk_handle_request(VirtIOBlockReq
*req
,
342 if (req
->elem
.out_num
< 1 || req
->elem
.in_num
< 1) {
343 fprintf(stderr
, "virtio-blk missing headers\n");
347 if (req
->elem
.out_sg
[0].iov_len
< sizeof(*req
->out
) ||
348 req
->elem
.in_sg
[req
->elem
.in_num
- 1].iov_len
< sizeof(*req
->in
)) {
349 fprintf(stderr
, "virtio-blk header not in correct element\n");
353 req
->out
= (void *)req
->elem
.out_sg
[0].iov_base
;
354 req
->in
= (void *)req
->elem
.in_sg
[req
->elem
.in_num
- 1].iov_base
;
356 if (req
->out
->type
& VIRTIO_BLK_T_FLUSH
) {
357 virtio_blk_handle_flush(mrb
->blkreq
, &mrb
->num_writes
,
359 } else if (req
->out
->type
& VIRTIO_BLK_T_SCSI_CMD
) {
360 virtio_blk_handle_scsi(req
);
361 } else if (req
->out
->type
& VIRTIO_BLK_T_OUT
) {
362 qemu_iovec_init_external(&req
->qiov
, &req
->elem
.out_sg
[1],
363 req
->elem
.out_num
- 1);
364 virtio_blk_handle_write(mrb
->blkreq
, &mrb
->num_writes
,
367 qemu_iovec_init_external(&req
->qiov
, &req
->elem
.in_sg
[0],
368 req
->elem
.in_num
- 1);
369 virtio_blk_handle_read(req
);
373 static void virtio_blk_handle_output(VirtIODevice
*vdev
, VirtQueue
*vq
)
375 VirtIOBlock
*s
= to_virtio_blk(vdev
);
377 MultiReqBuffer mrb
= {
382 while ((req
= virtio_blk_get_request(s
))) {
383 virtio_blk_handle_request(req
, &mrb
);
386 if (mrb
.num_writes
> 0) {
387 do_multiwrite(mrb
.old_bs
, mrb
.blkreq
, mrb
.num_writes
);
391 * FIXME: Want to check for completions before returning to guest mode,
392 * so cached reads and writes are reported as quickly as possible. But
393 * that should be done in the generic block layer.
397 static void virtio_blk_dma_restart_bh(void *opaque
)
399 VirtIOBlock
*s
= opaque
;
400 VirtIOBlockReq
*req
= s
->rq
;
401 MultiReqBuffer mrb
= {
406 qemu_bh_delete(s
->bh
);
412 virtio_blk_handle_request(req
, &mrb
);
416 if (mrb
.num_writes
> 0) {
417 do_multiwrite(mrb
.old_bs
, mrb
.blkreq
, mrb
.num_writes
);
421 static void virtio_blk_dma_restart_cb(void *opaque
, int running
, int reason
)
423 VirtIOBlock
*s
= opaque
;
429 s
->bh
= qemu_bh_new(virtio_blk_dma_restart_bh
, s
);
430 qemu_bh_schedule(s
->bh
);
434 static void virtio_blk_reset(VirtIODevice
*vdev
)
437 * This should cancel pending requests, but can't do nicely until there
438 * are per-device request lists.
443 /* coalesce internal state, copy to pci i/o region 0
445 static void virtio_blk_update_config(VirtIODevice
*vdev
, uint8_t *config
)
447 VirtIOBlock
*s
= to_virtio_blk(vdev
);
448 struct virtio_blk_config blkcfg
;
450 int cylinders
, heads
, secs
;
452 bdrv_get_geometry(s
->bs
, &capacity
);
453 bdrv_get_geometry_hint(s
->bs
, &cylinders
, &heads
, &secs
);
454 memset(&blkcfg
, 0, sizeof(blkcfg
));
455 stq_raw(&blkcfg
.capacity
, capacity
);
456 stl_raw(&blkcfg
.seg_max
, 128 - 2);
457 stw_raw(&blkcfg
.cylinders
, cylinders
);
458 blkcfg
.heads
= heads
;
459 blkcfg
.sectors
= secs
;
461 virtio_identify_template(&blkcfg
);
462 memcpy(&blkcfg
.identify
[VIRTIO_BLK_ID_SN
], s
->serial_str
,
463 VIRTIO_BLK_ID_SN_BYTES
);
464 memcpy(config
, &blkcfg
, s
->config_size
);
467 static uint32_t virtio_blk_get_features(VirtIODevice
*vdev
)
469 VirtIOBlock
*s
= to_virtio_blk(vdev
);
470 uint32_t features
= 0;
472 features
|= (1 << VIRTIO_BLK_F_SEG_MAX
);
473 features
|= (1 << VIRTIO_BLK_F_GEOMETRY
);
475 if (bdrv_enable_write_cache(s
->bs
))
476 features
|= (1 << VIRTIO_BLK_F_WCACHE
);
478 features
|= (1 << VIRTIO_BLK_F_SCSI
);
480 if (strcmp(s
->serial_str
, "0"))
481 features
|= 1 << VIRTIO_BLK_F_IDENTIFY
;
483 if (bdrv_is_read_only(s
->bs
))
484 features
|= 1 << VIRTIO_BLK_F_RO
;
489 static void virtio_blk_save(QEMUFile
*f
, void *opaque
)
491 VirtIOBlock
*s
= opaque
;
492 VirtIOBlockReq
*req
= s
->rq
;
494 virtio_save(&s
->vdev
, f
);
497 qemu_put_sbyte(f
, 1);
498 qemu_put_buffer(f
, (unsigned char*)&req
->elem
, sizeof(req
->elem
));
501 qemu_put_sbyte(f
, 0);
504 static int virtio_blk_load(QEMUFile
*f
, void *opaque
, int version_id
)
506 VirtIOBlock
*s
= opaque
;
511 virtio_load(&s
->vdev
, f
);
512 while (qemu_get_sbyte(f
)) {
513 VirtIOBlockReq
*req
= virtio_blk_alloc_request(s
);
514 qemu_get_buffer(f
, (unsigned char*)&req
->elem
, sizeof(req
->elem
));
522 VirtIODevice
*virtio_blk_init(DeviceState
*dev
, DriveInfo
*dinfo
)
525 int cylinders
, heads
, secs
;
526 static int virtio_blk_id
;
527 char *ps
= (char *)drive_get_serial(dinfo
->bdrv
);
528 size_t size
= strlen(ps
) ? sizeof(struct virtio_blk_config
) :
529 offsetof(struct virtio_blk_config
, _blk_size
);
531 s
= (VirtIOBlock
*)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK
,
533 sizeof(VirtIOBlock
));
535 s
->config_size
= size
;
536 s
->vdev
.get_config
= virtio_blk_update_config
;
537 s
->vdev
.get_features
= virtio_blk_get_features
;
538 s
->vdev
.reset
= virtio_blk_reset
;
542 strncpy(s
->serial_str
, ps
, sizeof(s
->serial_str
));
544 snprintf(s
->serial_str
, sizeof(s
->serial_str
), "0");
545 bdrv_guess_geometry(s
->bs
, &cylinders
, &heads
, &secs
);
546 bdrv_set_geometry_hint(s
->bs
, cylinders
, heads
, secs
);
548 s
->vq
= virtio_add_queue(&s
->vdev
, 128, virtio_blk_handle_output
);
550 qemu_add_vm_change_state_handler(virtio_blk_dma_restart_cb
, s
);
551 register_savevm("virtio-blk", virtio_blk_id
++, 2,
552 virtio_blk_save
, virtio_blk_load
, s
);