[PATCH 1/1] Virtio block device support

Hollis Blanchard
2008-11-26T18:11:54Z

From: Anthony Liguori <aliguori@us.ibm.com>

This has been posted before but I believe it now has addressed all outstanding
concerns. I'd like to apply it if there are no objections.

This patch adds virtio-blk support to QEMU. virtio-blk is a paravirtual disk
controller that can achieve good performance when using KVM.

Since virtio is based on a scatter/gather API, we don't have a linear buffer
for each request. This forces us to allocate a linear buffer since the current
block driver API does not have a scatter/gather operation. This allocation
can never exceed the maximum data limit on the ring queue so it isn't
unbounded.

posix-aio cannot support a scatter/gather asynchronous operation so we'll need
to introduce our own thread pool to eliminate this limitation. There is work
underway to do this.

Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
---
Makefile.target | 2 +-
hw/pc.c | 12 ++
hw/pc.h | 4 +
hw/virtio-blk.c | 303 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
sysemu.h | 2 +-
vl.c | 4 +
6 files changed, 325 insertions(+), 2 deletions(-)
create mode 100644 hw/virtio-blk.c

diff --git a/Makefile.target b/Makefile.target
index f7fc3a2..773b615 100644
--- a/Makefile.target
+++ b/Makefile.target
@@ -588,7 +588,7 @@ endif #CONFIG_BSD_USER
ifndef CONFIG_USER_ONLY

OBJS=vl.o osdep.o monitor.o pci.o loader.o isa_mmio.o machine.o
-OBJS+=fw_cfg.o virtio.o
+OBJS+=fw_cfg.o virtio.o virtio-blk.o
ifdef CONFIG_KVM
OBJS+=kvm.o kvm-all.o
endif
diff --git a/hw/pc.c b/hw/pc.c
index 1486b68..8651e49 100644
--- a/hw/pc.c
+++ b/hw/pc.c
@@ -1092,6 +1092,18 @@ static void pc_init1(ram_addr_t ram_size, int vga_ram_size,
}
}
}
+
+ /* Add virtio block devices */
+ if (pci_enabled) {
+ int index;
+ int unit_id = 0;
+
+ while ((index = drive_get_index(IF_VIRTIO, 0, unit_id)) != -1) {
+ virtio_blk_init(pci_bus, 0x1AF4, 0x1001,
+ drives_table[index].bdrv);
+ unit_id++;
+ }
+ }
}

static void pc_init_pci(ram_addr_t ram_size, int vga_ram_size,
diff --git a/hw/pc.h b/hw/pc.h
index f156b9e..edbc5e8 100644
--- a/hw/pc.h
+++ b/hw/pc.h
@@ -152,4 +152,8 @@ void pci_piix4_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn,

void isa_ne2000_init(int base, qemu_irq irq, NICInfo *nd);

+/* virtio-blk.c */
+void *virtio_blk_init(PCIBus *bus, uint16_t vendor, uint16_t device,
+ BlockDriverState *bs);
+
#endif
diff --git a/hw/virtio-blk.c b/hw/virtio-blk.c
new file mode 100644
index 0000000..da87b66
--- /dev/null
+++ b/hw/virtio-blk.c
@@ -0,0 +1,303 @@
+/*
+ * Virtio Block Device
+ *
+ * Copyright IBM, Corp. 2007
+ *
+ * Authors:
+ * Anthony Liguori <aliguori@us.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2. See
+ * the COPYING file in the top-level directory.
+ *
+ */
+
+#include "virtio.h"
+#include "block.h"
+#include "block_int.h"
+#include "pc.h"
+
+/* from Linux's linux/virtio_blk.h */
+
+/* The ID for virtio_block */
+#define VIRTIO_ID_BLOCK 2
+
+/* Feature bits */
+#define VIRTIO_BLK_F_BARRIER 0 /* Does host support barriers? */
+#define VIRTIO_BLK_F_SIZE_MAX 1 /* Indicates maximum segment size */
+#define VIRTIO_BLK_F_SEG_MAX 2 /* Indicates maximum # of segments */
+#define VIRTIO_BLK_F_GEOMETRY 4 /* Indicates support of legacy geometry */
+
+struct virtio_blk_config
+{
+ uint64_t capacity;
+ uint32_t size_max;
+ uint32_t seg_max;
+ uint16_t cylinders;
+ uint8_t heads;
+ uint8_t sectors;
+} __attribute__((packed));
+
+/* These two define direction. */
+#define VIRTIO_BLK_T_IN 0
+#define VIRTIO_BLK_T_OUT 1
+
+/* This bit says it's a scsi command, not an actual read or write. */
+#define VIRTIO_BLK_T_SCSI_CMD 2
+
+/* Barrier before this op. */
+#define VIRTIO_BLK_T_BARRIER 0x80000000
+
+/* This is the first element of the read scatter-gather list. */
+struct virtio_blk_outhdr
+{
+ /* VIRTIO_BLK_T* */
+ uint32_t type;
+ /* io priority. */
+ uint32_t ioprio;
+ /* Sector (ie. 512 byte offset) */
+ uint64_t sector;
+};
+
+#define VIRTIO_BLK_S_OK 0
+#define VIRTIO_BLK_S_IOERR 1
+#define VIRTIO_BLK_S_UNSUPP 2
+
+/* This is the first element of the write scatter-gather list */
+struct virtio_blk_inhdr
+{
+ unsigned char status;
+};
+
+typedef struct VirtIOBlock
+{
+ VirtIODevice vdev;
+ BlockDriverState *bs;
+ VirtQueue *vq;
+} VirtIOBlock;
+
+static VirtIOBlock *to_virtio_blk(VirtIODevice *vdev)
+{
+ return (VirtIOBlock *)vdev;
+}
+
+typedef struct VirtIOBlockReq
+{
+ VirtIOBlock *dev;
+ VirtQueueElement elem;
+ struct virtio_blk_inhdr *in;
+ struct virtio_blk_outhdr *out;
+ size_t size;
+ uint8_t *buffer;
+} VirtIOBlockReq;
+
+static void virtio_blk_rw_complete(void *opaque, int ret)
+{
+ VirtIOBlockReq *req = opaque;
+ VirtIOBlock *s = req->dev;
+
+ /* Copy read data to the guest */
+ if (!ret && !(req->out->type & VIRTIO_BLK_T_OUT)) {
+ size_t offset = 0;
+ int i;
+
+ for (i = 0; i < req->elem.in_num - 1; i++) {
+ size_t len;
+
+ /* Be pretty defensive wrt malicious guests */
+ len = MIN(req->elem.in_sg[i].iov_len,
+ req->size - offset);
+
+ memcpy(req->elem.in_sg[i].iov_base,
+ req->buffer + offset,
+ len);
+ offset += len;
+ }
+ }
+
+ req->in->status = ret ? VIRTIO_BLK_S_IOERR : VIRTIO_BLK_S_OK;
+ virtqueue_push(s->vq, &req->elem, req->size + sizeof(*req->in));
+ virtio_notify(&s->vdev, s->vq);
+
+ qemu_free(req->buffer);
+ qemu_free(req);
+}
+
+static VirtIOBlockReq *virtio_blk_get_request(VirtIOBlock *s)
+{
+ VirtIOBlockReq *req;
+
+ req = qemu_mallocz(sizeof(*req));
+ if (req == NULL)
+ return NULL;
+
+ req->dev = s;
+ if (!virtqueue_pop(s->vq, &req->elem)) {
+ qemu_free(req);
+ return NULL;
+ }
+
+ return req;
+}
+
+static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
+{
+ VirtIOBlock *s = to_virtio_blk(vdev);
+ VirtIOBlockReq *req;
+
+ while ((req = virtio_blk_get_request(s))) {
+ int i;
+
+ if (req->elem.out_num < 1 || req->elem.in_num < 1) {
+ fprintf(stderr, "virtio-blk missing headers\n");
+ exit(1);
+ }
+
+ if (req->elem.out_sg[0].iov_len < sizeof(*req->out) ||
+ req->elem.in_sg[req->elem.in_num - 1].iov_len < sizeof(*req->in)) {
+ fprintf(stderr, "virtio-blk header not in correct element\n");
+ exit(1);
+ }
+
+ req->out = (void *)req->elem.out_sg[0].iov_base;
+ req->in = (void *)req->elem.in_sg[req->elem.in_num - 1].iov_base;
+
+ if (req->out->type & VIRTIO_BLK_T_SCSI_CMD) {
+ unsigned int len = sizeof(*req->in);
+
+ req->in->status = VIRTIO_BLK_S_UNSUPP;
+ virtqueue_push(vq, &req->elem, len);
+ virtio_notify(vdev, vq);
+ qemu_free(req);
+ } else if (req->out->type & VIRTIO_BLK_T_OUT) {
+ size_t offset;
+
+ for (i = 1; i < req->elem.out_num; i++)
+ req->size += req->elem.out_sg[i].iov_len;
+
+ req->buffer = qemu_memalign(512, req->size);
+ if (req->buffer == NULL) {
+ qemu_free(req);
+ break;
+ }
+
+ /* We copy the data from the SG list to avoid splitting up the request. This helps
+ performance a lot until we can pass full sg lists as AIO operations */
+ offset = 0;
+ for (i = 1; i < req->elem.out_num; i++) {
+ size_t len;
+
+ len = MIN(req->elem.out_sg[i].iov_len,
+ req->size - offset);
+ memcpy(req->buffer + offset,
+ req->elem.out_sg[i].iov_base,
+ len);
+ offset += len;
+ }
+
+ bdrv_aio_write(s->bs, req->out->sector,
+ req->buffer,
+ req->size / 512,
+ virtio_blk_rw_complete,
+ req);
+ } else {
+ for (i = 0; i < req->elem.in_num - 1; i++)
+ req->size += req->elem.in_sg[i].iov_len;
+
+ req->buffer = qemu_memalign(512, req->size);
+ if (req->buffer == NULL) {
+ qemu_free(req);
+ break;
+ }
+
+ bdrv_aio_read(s->bs, req->out->sector,
+ req->buffer,
+ req->size / 512,
+ virtio_blk_rw_complete,
+ req);
+ }
+ }
+ /*
+ * FIXME: Want to check for completions before returning to guest mode,
+ * so cached reads and writes are reported as quickly as possible. But
+ * that should be done in the generic block layer.
+ */
+}
+
+static void virtio_blk_reset(VirtIODevice *vdev)
+{
+ /*
+ * This should cancel pending requests, but can't do nicely until there
+ * are per-device request lists.
+ */
+ qemu_aio_flush();
+}
+
+static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
+{
+ VirtIOBlock *s = to_virtio_blk(vdev);
+ struct virtio_blk_config blkcfg;
+ uint64_t capacity;
+ int cylinders, heads, secs;
+
+ bdrv_get_geometry(s->bs, &capacity);
+ bdrv_get_geometry_hint(s->bs, &cylinders, &heads, &secs);
+ stq_raw(&blkcfg.capacity, capacity);
+ stl_raw(&blkcfg.seg_max, 128 - 2);
+ stw_raw(&blkcfg.cylinders, cylinders);
+ blkcfg.heads = heads;
+ blkcfg.sectors = secs;
+ memcpy(config, &blkcfg, sizeof(blkcfg));
+}
+
+static uint32_t virtio_blk_get_features(VirtIODevice *vdev)
+{
+ return (1 << VIRTIO_BLK_F_SEG_MAX | 1 << VIRTIO_BLK_F_GEOMETRY);
+}
+
+static void virtio_blk_save(QEMUFile *f, void *opaque)
+{
+ VirtIOBlock *s = opaque;
+ virtio_save(&s->vdev, f);
+}
+
+static int virtio_blk_load(QEMUFile *f, void *opaque, int version_id)
+{
+ VirtIOBlock *s = opaque;
+
+ if (version_id != 1)
+ return -EINVAL;
+
+ virtio_load(&s->vdev, f);
+
+ return 0;
+}
+
+void *virtio_blk_init(PCIBus *bus, uint16_t vendor, uint16_t device,
+ BlockDriverState *bs)
+{
+ VirtIOBlock *s;
+ int cylinders, heads, secs;
+ static int virtio_blk_id;
+
+ s = (VirtIOBlock *)virtio_init_pci(bus, "virtio-blk", vendor, device,
+ 0, VIRTIO_ID_BLOCK,
+ 0x01, 0x80, 0x00,
+ sizeof(struct virtio_blk_config), sizeof(VirtIOBlock));
+ if (!s)
+ return NULL;
+
+ s->vdev.get_config = virtio_blk_update_config;
+ s->vdev.get_features = virtio_blk_get_features;
+ s->vdev.reset = virtio_blk_reset;
+ s->bs = bs;
+
+ bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs);
+ bdrv_set_geometry_hint(s->bs, cylinders, heads, secs);
+
+ s->vq = virtio_add_queue(&s->vdev, 128, virtio_blk_handle_output);
+
+ register_savevm("virtio-blk", virtio_blk_id++, 1,
+ virtio_blk_save, virtio_blk_load, s);
+
+ return s;
+}
diff --git a/sysemu.h b/sysemu.h
index f72ec96..94cffaf 100644
--- a/sysemu.h
+++ b/sysemu.h
@@ -123,7 +123,7 @@ extern unsigned int nb_prom_envs;
#endif

typedef enum {
- IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD
+ IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD, IF_VIRTIO
} BlockInterfaceType;

typedef struct DriveInfo {
diff --git a/vl.c b/vl.c
index e4edf20..33a6fec 100644
--- a/vl.c
+++ b/vl.c
@@ -2267,6 +2267,9 @@ static int drive_init(struct drive_opt *arg, int snapshot,
} else if (!strcmp(buf, "sd")) {
type = IF_SD;
max_devs = 0;
+ } else if (!strcmp(buf, "virtio")) {
+ type = IF_VIRTIO;
+ max_devs = 0;
} else {
fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
return -1;
@@ -2474,6 +2477,7 @@ static int drive_init(struct drive_opt *arg, int snapshot,
break;
case IF_PFLASH:
case IF_MTD:
+ case IF_VIRTIO:
break;
}
if (!file[0])
--
1.5.6.5