wok rev 698
qemu: add virtio support
| author | Pascal Bellard <pascal.bellard@slitaz.org> |
|---|---|
| date | Mon Apr 28 11:41:08 2008 +0000 (2008-04-28) |
| parents | 41832070af28 |
| children | 036b1f427445 |
| files | qemu/receipt qemu/stuff/virtio.u |
line diff
1.1 --- a/qemu/receipt Sun Apr 27 12:33:42 2008 +0200 1.2 +++ b/qemu/receipt Mon Apr 28 11:41:08 2008 +0000 1.3 @@ -15,6 +15,7 @@ 1.4 compile_rules() 1.5 { 1.6 cd $src 1.7 + patch -p1 < ../stuff/virtio.u 1.8 #./configure --prefix=/usr --enable-alsa --disable-gfx-check \ 1.9 1.10 ./configure --prefix=/usr --enable-alsa \
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 2.2 +++ b/qemu/stuff/virtio.u Mon Apr 28 11:41:08 2008 +0000 2.3 @@ -0,0 +1,1076 @@ 2.4 +Index: qemu-0.9.1/Makefile.target 2.5 +=================================================================== 2.6 +--- qemu-0.9.1.orig/Makefile.target 2008-01-06 19:38:41.000000000 +0000 2.7 ++++ qemu-0.9.1/Makefile.target 2008-02-07 13:36:23.000000000 +0000 2.8 +@@ -436,6 +436,9 @@ 2.9 + VL_OBJS += pcnet.o 2.10 + VL_OBJS += rtl8139.o 2.11 + 2.12 ++# virtio devices 2.13 ++VL_OBJS += virtio.o 2.14 ++ 2.15 + ifeq ($(TARGET_BASE_ARCH), i386) 2.16 + # Hardware support 2.17 + VL_OBJS+= ide.o pckbd.o ps2.o vga.o $(SOUND_HW) dma.o 2.18 +Index: qemu-0.9.1/hw/virtio.c 2.19 +=================================================================== 2.20 +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 2.21 ++++ qemu-0.9.1/hw/virtio.c 2008-02-07 13:36:23.000000000 +0000 2.22 +@@ -0,0 +1,422 @@ 2.23 ++/* 2.24 ++ * Virtio Support 2.25 ++ * 2.26 ++ * Copyright IBM, Corp. 2007 2.27 ++ * 2.28 ++ * Authors: 2.29 ++ * Anthony Liguori <address@hidden> 2.30 ++ * 2.31 ++ * This work is licensed under the terms of the GNU GPL, version 2. See 2.32 ++ * the COPYING file in the top-level directory. 2.33 ++ * 2.34 ++ */ 2.35 ++ 2.36 ++#include <inttypes.h> 2.37 ++#include <err.h> 2.38 ++ 2.39 ++#include "virtio.h" 2.40 ++#include "sysemu.h" 2.41 ++ 2.42 ++/* from Linux's linux/virtio_pci.h */ 2.43 ++ 2.44 ++/* A 32-bit r/o bitmask of the features supported by the host */ 2.45 ++#define VIRTIO_PCI_HOST_FEATURES 0 2.46 ++ 2.47 ++/* A 32-bit r/w bitmask of features activated by the guest */ 2.48 ++#define VIRTIO_PCI_GUEST_FEATURES 4 2.49 ++ 2.50 ++/* A 32-bit r/w PFN for the currently selected queue */ 2.51 ++#define VIRTIO_PCI_QUEUE_PFN 8 2.52 ++ 2.53 ++/* A 16-bit r/o queue size for the currently selected queue */ 2.54 ++#define VIRTIO_PCI_QUEUE_NUM 12 2.55 ++ 2.56 ++/* A 16-bit r/w queue selector */ 2.57 ++#define VIRTIO_PCI_QUEUE_SEL 14 2.58 ++ 2.59 ++/* A 16-bit r/w queue notifier */ 2.60 ++#define VIRTIO_PCI_QUEUE_NOTIFY 16 2.61 ++ 2.62 ++/* An 8-bit device status register. */ 2.63 ++#define VIRTIO_PCI_STATUS 18 2.64 ++ 2.65 ++/* An 8-bit r/o interrupt status register. Reading the value will return the 2.66 ++ * current contents of the ISR and will also clear it. This is effectively 2.67 ++ * a read-and-acknowledge. */ 2.68 ++#define VIRTIO_PCI_ISR 19 2.69 ++ 2.70 ++#define VIRTIO_PCI_CONFIG 20 2.71 ++ 2.72 ++/* QEMU doesn't strictly need write barriers since everything runs in 2.73 ++ * lock-step. We'll leave the calls to wmb() in though to make it obvious for 2.74 ++ * KVM or if kqemu gets SMP support. 2.75 ++ */ 2.76 ++#define wmb() do { } while (0) 2.77 ++ 2.78 ++/* virt queue functions */ 2.79 ++ 2.80 ++static void virtqueue_init(VirtQueue *vq, void *p) 2.81 ++{ 2.82 ++ vq->vring.desc = p; 2.83 ++ vq->vring.avail = p + vq->vring.num * sizeof(VRingDesc); 2.84 ++ vq->vring.used = (void *)TARGET_PAGE_ALIGN((unsigned long)&vq->vring.avail->ring[vq->vring.num]); 2.85 ++} 2.86 ++ 2.87 ++static unsigned virtqueue_next_desc(VirtQueue *vq, unsigned int i) 2.88 ++{ 2.89 ++ unsigned int next; 2.90 ++ 2.91 ++ /* If this descriptor says it doesn't chain, we're done. */ 2.92 ++ if (!(vq->vring.desc[i].flags & VRING_DESC_F_NEXT)) 2.93 ++ return vq->vring.num; 2.94 ++ 2.95 ++ /* Check they're not leading us off end of descriptors. */ 2.96 ++ next = vq->vring.desc[i].next; 2.97 ++ /* Make sure compiler knows to grab that: we don't want it changing! */ 2.98 ++ wmb(); 2.99 ++ 2.100 ++ if (next >= vq->vring.num) 2.101 ++ errx(1, "Desc next is %u", next); 2.102 ++ 2.103 ++ return next; 2.104 ++} 2.105 ++ 2.106 ++void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem, 2.107 ++ unsigned int len) 2.108 ++{ 2.109 ++ VRingUsedElem *used; 2.110 ++ 2.111 ++ /* Get a pointer to the next entry in the used ring. */ 2.112 ++ used = &vq->vring.used->ring[vq->vring.used->idx % vq->vring.num]; 2.113 ++ used->id = elem->index; 2.114 ++ used->len = len; 2.115 ++ /* Make sure buffer is written before we update index. */ 2.116 ++ wmb(); 2.117 ++ vq->vring.used->idx++; 2.118 ++} 2.119 ++ 2.120 ++int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem) 2.121 ++{ 2.122 ++ unsigned int i, head; 2.123 ++ unsigned int position; 2.124 ++ 2.125 ++ /* Check it isn't doing very strange things with descriptor numbers. */ 2.126 ++ if ((uint16_t)(vq->vring.avail->idx - vq->last_avail_idx) > vq->vring.num) 2.127 ++ errx(1, "Guest moved used index from %u to %u", 2.128 ++ vq->last_avail_idx, vq->vring.avail->idx); 2.129 ++ 2.130 ++ /* If there's nothing new since last we looked, return invalid. */ 2.131 ++ if (vq->vring.avail->idx == vq->last_avail_idx) 2.132 ++ return 0; 2.133 ++ 2.134 ++ /* Grab the next descriptor number they're advertising, and increment 2.135 ++ * the index we've seen. */ 2.136 ++ head = vq->vring.avail->ring[vq->last_avail_idx++ % vq->vring.num]; 2.137 ++ 2.138 ++ /* If their number is silly, that's a fatal mistake. */ 2.139 ++ if (head >= vq->vring.num) 2.140 ++ errx(1, "Guest says index %u is available", head); 2.141 ++ 2.142 ++ /* When we start there are none of either input nor output. */ 2.143 ++ position = elem->out_num = elem->in_num = 0; 2.144 ++ 2.145 ++ i = head; 2.146 ++ do { 2.147 ++ struct iovec *sg; 2.148 ++ 2.149 ++ if ((vq->vring.desc[i].addr + vq->vring.desc[i].len) > ram_size) 2.150 ++ errx(1, "Guest sent invalid pointer"); 2.151 ++ 2.152 ++ if (vq->vring.desc[i].flags & VRING_DESC_F_WRITE) 2.153 ++ sg = &elem->in_sg[elem->in_num++]; 2.154 ++ else 2.155 ++ sg = &elem->out_sg[elem->out_num++]; 2.156 ++ 2.157 ++ /* Grab the first descriptor, and check it's OK. */ 2.158 ++ sg->iov_len = vq->vring.desc[i].len; 2.159 ++ sg->iov_base = phys_ram_base + vq->vring.desc[i].addr; 2.160 ++ 2.161 ++ /* If we've got too many, that implies a descriptor loop. */ 2.162 ++ if ((elem->in_num + elem->out_num) > vq->vring.num) 2.163 ++ errx(1, "Looped descriptor"); 2.164 ++ } while ((i = virtqueue_next_desc(vq, i)) != vq->vring.num); 2.165 ++ 2.166 ++ elem->index = head; 2.167 ++ 2.168 ++ return elem->in_num + elem->out_num; 2.169 ++} 2.170 ++ 2.171 ++/* virtio device */ 2.172 ++ 2.173 ++static VirtIODevice *to_virtio_device(PCIDevice *pci_dev) 2.174 ++{ 2.175 ++ return (VirtIODevice *)pci_dev; 2.176 ++} 2.177 ++ 2.178 ++static void virtio_update_irq(VirtIODevice *vdev) 2.179 ++{ 2.180 ++ qemu_set_irq(vdev->pci_dev.irq[0], vdev->isr & 1); 2.181 ++} 2.182 ++ 2.183 ++static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val) 2.184 ++{ 2.185 ++ VirtIODevice *vdev = to_virtio_device(opaque); 2.186 ++ ram_addr_t pa; 2.187 ++ 2.188 ++ addr -= vdev->addr; 2.189 ++ 2.190 ++ switch (addr) { 2.191 ++ case VIRTIO_PCI_GUEST_FEATURES: 2.192 ++ if (vdev->set_features) 2.193 ++ vdev->set_features(vdev, val); 2.194 ++ vdev->features = val; 2.195 ++ break; 2.196 ++ case VIRTIO_PCI_QUEUE_PFN: 2.197 ++ pa = (ram_addr_t)val << TARGET_PAGE_BITS; 2.198 ++ vdev->vq[vdev->queue_sel].pfn = val; 2.199 ++ if (pa == 0) { 2.200 ++ vdev->vq[vdev->queue_sel].vring.desc = NULL; 2.201 ++ vdev->vq[vdev->queue_sel].vring.avail = NULL; 2.202 ++ vdev->vq[vdev->queue_sel].vring.used = NULL; 2.203 ++ } else if (pa < (ram_size - TARGET_PAGE_SIZE)) { 2.204 ++ virtqueue_init(&vdev->vq[vdev->queue_sel], phys_ram_base + pa); 2.205 ++ /* FIXME if pa == 0, deal with device tear down */ 2.206 ++ } 2.207 ++ break; 2.208 ++ case VIRTIO_PCI_QUEUE_SEL: 2.209 ++ if (val < VIRTIO_PCI_QUEUE_MAX) 2.210 ++ vdev->queue_sel = val; 2.211 ++ break; 2.212 ++ case VIRTIO_PCI_QUEUE_NOTIFY: 2.213 ++ if (val < VIRTIO_PCI_QUEUE_MAX && vdev->vq[val].vring.desc) 2.214 ++ vdev->vq[val].handle_output(vdev, &vdev->vq[val]); 2.215 ++ break; 2.216 ++ case VIRTIO_PCI_STATUS: 2.217 ++ vdev->status = val & 0xFF; 2.218 ++ break; 2.219 ++ } 2.220 ++} 2.221 ++ 2.222 ++static uint32_t virtio_ioport_read(void *opaque, uint32_t addr) 2.223 ++{ 2.224 ++ VirtIODevice *vdev = to_virtio_device(opaque); 2.225 ++ uint32_t ret = 0xFFFFFFFF; 2.226 ++ 2.227 ++ addr -= vdev->addr; 2.228 ++ 2.229 ++ switch (addr) { 2.230 ++ case VIRTIO_PCI_HOST_FEATURES: 2.231 ++ ret = vdev->get_features(vdev); 2.232 ++ break; 2.233 ++ case VIRTIO_PCI_GUEST_FEATURES: 2.234 ++ ret = vdev->features; 2.235 ++ break; 2.236 ++ case VIRTIO_PCI_QUEUE_PFN: 2.237 ++ ret = vdev->vq[vdev->queue_sel].pfn; 2.238 ++ break; 2.239 ++ case VIRTIO_PCI_QUEUE_NUM: 2.240 ++ ret = vdev->vq[vdev->queue_sel].vring.num; 2.241 ++ break; 2.242 ++ case VIRTIO_PCI_QUEUE_SEL: 2.243 ++ ret = vdev->queue_sel; 2.244 ++ break; 2.245 ++ case VIRTIO_PCI_STATUS: 2.246 ++ ret = vdev->status; 2.247 ++ break; 2.248 ++ case VIRTIO_PCI_ISR: 2.249 ++ /* reading from the ISR also clears it. */ 2.250 ++ ret = vdev->isr; 2.251 ++ vdev->isr = 0; 2.252 ++ virtio_update_irq(vdev); 2.253 ++ break; 2.254 ++ default: 2.255 ++ break; 2.256 ++ } 2.257 ++ 2.258 ++ return ret; 2.259 ++} 2.260 ++ 2.261 ++static uint32_t virtio_config_readb(void *opaque, uint32_t addr) 2.262 ++{ 2.263 ++ VirtIODevice *vdev = opaque; 2.264 ++ uint8_t val; 2.265 ++ 2.266 ++ addr -= vdev->addr + VIRTIO_PCI_CONFIG; 2.267 ++ if (addr > (vdev->config_len - sizeof(val))) 2.268 ++ return (uint32_t)-1; 2.269 ++ 2.270 ++ memcpy(&val, vdev->config + addr, sizeof(val)); 2.271 ++ return val; 2.272 ++} 2.273 ++ 2.274 ++static uint32_t virtio_config_readw(void *opaque, uint32_t addr) 2.275 ++{ 2.276 ++ VirtIODevice *vdev = opaque; 2.277 ++ uint16_t val; 2.278 ++ 2.279 ++ addr -= vdev->addr + VIRTIO_PCI_CONFIG; 2.280 ++ if (addr > (vdev->config_len - sizeof(val))) 2.281 ++ return (uint32_t)-1; 2.282 ++ 2.283 ++ memcpy(&val, vdev->config + addr, sizeof(val)); 2.284 ++ return val; 2.285 ++} 2.286 ++ 2.287 ++static uint32_t virtio_config_readl(void *opaque, uint32_t addr) 2.288 ++{ 2.289 ++ VirtIODevice *vdev = opaque; 2.290 ++ uint32_t val; 2.291 ++ 2.292 ++ addr -= vdev->addr + VIRTIO_PCI_CONFIG; 2.293 ++ if (addr > (vdev->config_len - sizeof(val))) 2.294 ++ return (uint32_t)-1; 2.295 ++ 2.296 ++ memcpy(&val, vdev->config + addr, sizeof(val)); 2.297 ++ return val; 2.298 ++} 2.299 ++ 2.300 ++static void virtio_config_writeb(void *opaque, uint32_t addr, uint32_t data) 2.301 ++{ 2.302 ++ VirtIODevice *vdev = opaque; 2.303 ++ uint8_t val = data; 2.304 ++ 2.305 ++ addr -= vdev->addr + VIRTIO_PCI_CONFIG; 2.306 ++ if (addr > (vdev->config_len - sizeof(val))) 2.307 ++ return; 2.308 ++ 2.309 ++ memcpy(vdev->config + addr, &val, sizeof(val)); 2.310 ++} 2.311 ++ 2.312 ++static void virtio_config_writew(void *opaque, uint32_t addr, uint32_t data) 2.313 ++{ 2.314 ++ VirtIODevice *vdev = opaque; 2.315 ++ uint16_t val = data; 2.316 ++ 2.317 ++ addr -= vdev->addr + VIRTIO_PCI_CONFIG; 2.318 ++ if (addr > (vdev->config_len - sizeof(val))) 2.319 ++ return; 2.320 ++ 2.321 ++ memcpy(vdev->config + addr, &val, sizeof(val)); 2.322 ++} 2.323 ++ 2.324 ++static void virtio_config_writel(void *opaque, uint32_t addr, uint32_t data) 2.325 ++{ 2.326 ++ VirtIODevice *vdev = opaque; 2.327 ++ uint32_t val = data; 2.328 ++ 2.329 ++ addr -= vdev->addr + VIRTIO_PCI_CONFIG; 2.330 ++ if (addr > (vdev->config_len - sizeof(val))) 2.331 ++ return; 2.332 ++ 2.333 ++ memcpy(vdev->config + addr, &val, sizeof(val)); 2.334 ++} 2.335 ++ 2.336 ++static void virtio_map(PCIDevice *pci_dev, int region_num, 2.337 ++ uint32_t addr, uint32_t size, int type) 2.338 ++{ 2.339 ++ VirtIODevice *vdev = to_virtio_device(pci_dev); 2.340 ++ int i; 2.341 ++ 2.342 ++ vdev->addr = addr; 2.343 ++ for (i = 0; i < 3; i++) { 2.344 ++ register_ioport_write(addr, 20, 1 << i, virtio_ioport_write, vdev); 2.345 ++ register_ioport_read(addr, 20, 1 << i, virtio_ioport_read, vdev); 2.346 ++ } 2.347 ++ 2.348 ++ if (vdev->config_len) { 2.349 ++ register_ioport_write(addr + 20, vdev->config_len, 1, 2.350 ++ virtio_config_writeb, vdev); 2.351 ++ register_ioport_write(addr + 20, vdev->config_len, 2, 2.352 ++ virtio_config_writew, vdev); 2.353 ++ register_ioport_write(addr + 20, vdev->config_len, 4, 2.354 ++ virtio_config_writel, vdev); 2.355 ++ register_ioport_read(addr + 20, vdev->config_len, 1, 2.356 ++ virtio_config_readb, vdev); 2.357 ++ register_ioport_read(addr + 20, vdev->config_len, 2, 2.358 ++ virtio_config_readw, vdev); 2.359 ++ register_ioport_read(addr + 20, vdev->config_len, 4, 2.360 ++ virtio_config_readl, vdev); 2.361 ++ 2.362 ++ vdev->update_config(vdev, vdev->config); 2.363 ++ } 2.364 ++} 2.365 ++ 2.366 ++VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size, 2.367 ++ void (*handle_output)(VirtIODevice *, VirtQueue *)) 2.368 ++{ 2.369 ++ int i; 2.370 ++ 2.371 ++ for (i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) { 2.372 ++ if (vdev->vq[i].vring.num == 0) 2.373 ++ break; 2.374 ++ } 2.375 ++ 2.376 ++ if (i == VIRTIO_PCI_QUEUE_MAX || queue_size > VIRTQUEUE_MAX_SIZE) 2.377 ++ abort(); 2.378 ++ 2.379 ++ vdev->vq[i].vring.num = queue_size; 2.380 ++ vdev->vq[i].handle_output = handle_output; 2.381 ++ vdev->vq[i].index = i; 2.382 ++ 2.383 ++ return &vdev->vq[i]; 2.384 ++} 2.385 ++ 2.386 ++void virtio_notify(VirtIODevice *vdev, VirtQueue *vq) 2.387 ++{ 2.388 ++ if (vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT) 2.389 ++ return; 2.390 ++ 2.391 ++ vdev->isr = 1; 2.392 ++ virtio_update_irq(vdev); 2.393 ++} 2.394 ++ 2.395 ++VirtIODevice *virtio_init_pci(PCIBus *bus, const char *name, 2.396 ++ uint16_t vendor, uint16_t device, 2.397 ++ uint16_t subvendor, uint16_t subdevice, 2.398 ++ uint8_t class_code, uint8_t subclass_code, 2.399 ++ uint8_t pif, size_t config_size, 2.400 ++ size_t struct_size) 2.401 ++{ 2.402 ++ VirtIODevice *vdev; 2.403 ++ PCIDevice *pci_dev; 2.404 ++ uint8_t *config; 2.405 ++ 2.406 ++ pci_dev = pci_register_device(bus, name, struct_size, 2.407 ++ -1, NULL, NULL); 2.408 ++ vdev = to_virtio_device(pci_dev); 2.409 ++ 2.410 ++ vdev->status = 0; 2.411 ++ vdev->isr = 0; 2.412 ++ vdev->queue_sel = 0; 2.413 ++ memset(vdev->vq, 0, sizeof(vdev->vq)); 2.414 ++ 2.415 ++ config = pci_dev->config; 2.416 ++ config[0x00] = vendor & 0xFF; 2.417 ++ config[0x01] = (vendor >> 8) & 0xFF; 2.418 ++ config[0x02] = device & 0xFF; 2.419 ++ config[0x03] = (device >> 8) & 0xFF; 2.420 ++ 2.421 ++ config[0x09] = pif; 2.422 ++ config[0x0a] = subclass_code; 2.423 ++ config[0x0b] = class_code; 2.424 ++ config[0x0e] = 0x00; 2.425 ++ 2.426 ++ config[0x2c] = subvendor & 0xFF; 2.427 ++ config[0x2d] = (subvendor >> 8) & 0xFF; 2.428 ++ config[0x2e] = subdevice & 0xFF; 2.429 ++ config[0x2f] = (subdevice >> 8) & 0xFF; 2.430 ++ 2.431 ++ config[0x3d] = 1; 2.432 ++ 2.433 ++ vdev->name = name; 2.434 ++ vdev->config_len = config_size; 2.435 ++ if (vdev->config_len) 2.436 ++ vdev->config = qemu_mallocz(config_size); 2.437 ++ else 2.438 ++ vdev->config = NULL; 2.439 ++ 2.440 ++ pci_register_io_region(pci_dev, 0, 20 + config_size, PCI_ADDRESS_SPACE_IO, 2.441 ++ virtio_map); 2.442 ++ 2.443 ++ return vdev; 2.444 ++} 2.445 +Index: qemu-0.9.1/hw/virtio.h 2.446 +=================================================================== 2.447 +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 2.448 ++++ qemu-0.9.1/hw/virtio.h 2008-02-07 13:36:23.000000000 +0000 2.449 +@@ -0,0 +1,143 @@ 2.450 ++/* 2.451 ++ * Virtio Support 2.452 ++ * 2.453 ++ * Copyright IBM, Corp. 2007 2.454 ++ * 2.455 ++ * Authors: 2.456 ++ * Anthony Liguori <address@hidden> 2.457 ++ * 2.458 ++ * This work is licensed under the terms of the GNU GPL, version 2. See 2.459 ++ * the COPYING file in the top-level directory. 2.460 ++ * 2.461 ++ */ 2.462 ++ 2.463 ++#ifndef _QEMU_VIRTIO_H 2.464 ++#define _QEMU_VIRTIO_H 2.465 ++ 2.466 ++#include <sys/uio.h> 2.467 ++#include "hw.h" 2.468 ++#include "pci.h" 2.469 ++ 2.470 ++/* from Linux's linux/virtio_config.h */ 2.471 ++ 2.472 ++/* Status byte for guest to report progress, and synchronize features. */ 2.473 ++/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */ 2.474 ++#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1 2.475 ++/* We have found a driver for the device. */ 2.476 ++#define VIRTIO_CONFIG_S_DRIVER 2 2.477 ++/* Driver has used its parts of the config, and is happy */ 2.478 ++#define VIRTIO_CONFIG_S_DRIVER_OK 4 2.479 ++/* We've given up on this device. */ 2.480 ++#define VIRTIO_CONFIG_S_FAILED 0x80 2.481 ++ 2.482 ++/* from Linux's linux/virtio_ring.h */ 2.483 ++ 2.484 ++/* This marks a buffer as continuing via the next field. */ 2.485 ++#define VRING_DESC_F_NEXT 1 2.486 ++/* This marks a buffer as write-only (otherwise read-only). */ 2.487 ++#define VRING_DESC_F_WRITE 2 2.488 ++ 2.489 ++/* This means don't notify other side when buffer added. */ 2.490 ++#define VRING_USED_F_NO_NOTIFY 1 2.491 ++/* This means don't interrupt guest when buffer consumed. */ 2.492 ++#define VRING_AVAIL_F_NO_INTERRUPT 1 2.493 ++ 2.494 ++typedef struct VirtQueue VirtQueue; 2.495 ++typedef struct VirtIODevice VirtIODevice; 2.496 ++ 2.497 ++typedef struct VRingDesc 2.498 ++{ 2.499 ++ uint64_t addr; 2.500 ++ uint32_t len; 2.501 ++ uint16_t flags; 2.502 ++ uint16_t next; 2.503 ++} VRingDesc; 2.504 ++ 2.505 ++typedef struct VRingAvail 2.506 ++{ 2.507 ++ uint16_t flags; 2.508 ++ uint16_t idx; 2.509 ++ uint16_t ring[0]; 2.510 ++} VRingAvail; 2.511 ++ 2.512 ++typedef struct VRingUsedElem 2.513 ++{ 2.514 ++ uint32_t id; 2.515 ++ uint32_t len; 2.516 ++} VRingUsedElem; 2.517 ++ 2.518 ++typedef struct VRingUsed 2.519 ++{ 2.520 ++ uint16_t flags; 2.521 ++ uint16_t idx; 2.522 ++ VRingUsedElem ring[0]; 2.523 ++} VRingUsed; 2.524 ++ 2.525 ++typedef struct VRing 2.526 ++{ 2.527 ++ unsigned int num; 2.528 ++ VRingDesc *desc; 2.529 ++ VRingAvail *avail; 2.530 ++ VRingUsed *used; 2.531 ++} VRing; 2.532 ++ 2.533 ++struct VirtQueue 2.534 ++{ 2.535 ++ VRing vring; 2.536 ++ uint32_t pfn; 2.537 ++ uint16_t last_avail_idx; 2.538 ++ void (*handle_output)(VirtIODevice *vdev, VirtQueue *vq); 2.539 ++ int index; 2.540 ++}; 2.541 ++ 2.542 ++#define VIRTQUEUE_MAX_SIZE 1024 2.543 ++ 2.544 ++typedef struct VirtQueueElement 2.545 ++{ 2.546 ++ unsigned int index; 2.547 ++ unsigned int out_num; 2.548 ++ unsigned int in_num; 2.549 ++ struct iovec in_sg[VIRTQUEUE_MAX_SIZE]; 2.550 ++ struct iovec out_sg[VIRTQUEUE_MAX_SIZE]; 2.551 ++} VirtQueueElement; 2.552 ++ 2.553 ++#define VIRTIO_PCI_QUEUE_MAX 16 2.554 ++ 2.555 ++struct VirtIODevice 2.556 ++{ 2.557 ++ PCIDevice pci_dev; 2.558 ++ const char *name; 2.559 ++ uint32_t addr; 2.560 ++ uint16_t vendor; 2.561 ++ uint16_t device; 2.562 ++ uint8_t status; 2.563 ++ uint8_t isr; 2.564 ++ uint16_t queue_sel; 2.565 ++ uint32_t features; 2.566 ++ size_t config_len; 2.567 ++ void *config; 2.568 ++ uint32_t (*get_features)(VirtIODevice *vdev); 2.569 ++ void (*set_features)(VirtIODevice *vdev, uint32_t val); 2.570 ++ void (*update_config)(VirtIODevice *vdev, uint8_t *config); 2.571 ++ VirtQueue vq[VIRTIO_PCI_QUEUE_MAX]; 2.572 ++}; 2.573 ++ 2.574 ++VirtIODevice *virtio_init_pci(PCIBus *bus, const char *name, 2.575 ++ uint16_t vendor, uint16_t device, 2.576 ++ uint16_t subvendor, uint16_t subdevice, 2.577 ++ uint8_t class_code, uint8_t subclass_code, 2.578 ++ uint8_t pif, size_t config_size, 2.579 ++ size_t struct_size); 2.580 ++ 2.581 ++VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size, 2.582 ++ void (*handle_output)(VirtIODevice *, 2.583 ++ VirtQueue *)); 2.584 ++ 2.585 ++void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem, 2.586 ++ unsigned int len); 2.587 ++ 2.588 ++int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem); 2.589 ++ 2.590 ++void virtio_notify(VirtIODevice *vdev, VirtQueue *vq); 2.591 ++ 2.592 ++#endif 2.593 +Index: qemu-0.9.1/Makefile.target 2.594 +=================================================================== 2.595 +--- qemu-0.9.1.orig/Makefile.target 2008-02-07 13:36:23.000000000 +0000 2.596 ++++ qemu-0.9.1/Makefile.target 2008-02-07 13:36:37.000000000 +0000 2.597 +@@ -437,7 +437,7 @@ 2.598 + VL_OBJS += rtl8139.o 2.599 + 2.600 + # virtio devices 2.601 +-VL_OBJS += virtio.o 2.602 ++VL_OBJS += virtio.o virtio-net.o 2.603 + 2.604 + ifeq ($(TARGET_BASE_ARCH), i386) 2.605 + # Hardware support 2.606 +Index: qemu-0.9.1/hw/pc.h 2.607 +=================================================================== 2.608 +--- qemu-0.9.1.orig/hw/pc.h 2008-01-06 19:38:42.000000000 +0000 2.609 ++++ qemu-0.9.1/hw/pc.h 2008-02-07 13:36:37.000000000 +0000 2.610 +@@ -142,4 +142,9 @@ 2.611 + 2.612 + void isa_ne2000_init(int base, qemu_irq irq, NICInfo *nd); 2.613 + 2.614 ++/* virtio-net.c */ 2.615 ++ 2.616 ++void *virtio_net_init(PCIBus *bus, NICInfo *nd, int devfn); 2.617 ++ 2.618 ++ 2.619 + #endif 2.620 +Index: qemu-0.9.1/hw/pci.c 2.621 +=================================================================== 2.622 +--- qemu-0.9.1.orig/hw/pci.c 2008-01-06 19:38:42.000000000 +0000 2.623 ++++ qemu-0.9.1/hw/pci.c 2008-02-07 13:36:37.000000000 +0000 2.624 +@@ -25,6 +25,7 @@ 2.625 + #include "pci.h" 2.626 + #include "console.h" 2.627 + #include "net.h" 2.628 ++#include "pc.h" 2.629 + 2.630 + //#define DEBUG_PCI 2.631 + 2.632 +@@ -638,9 +639,11 @@ 2.633 + pci_rtl8139_init(bus, nd, devfn); 2.634 + } else if (strcmp(nd->model, "pcnet") == 0) { 2.635 + pci_pcnet_init(bus, nd, devfn); 2.636 ++ } else if (strcmp(nd->model, "virtio") == 0) { 2.637 ++ virtio_net_init(bus, nd, devfn); 2.638 + } else if (strcmp(nd->model, "?") == 0) { 2.639 + fprintf(stderr, "qemu: Supported PCI NICs: i82551 i82557b i82559er" 2.640 +- " ne2k_pci pcnet rtl8139\n"); 2.641 ++ " ne2k_pci pcnet rtl8139 virtio\n"); 2.642 + exit (1); 2.643 + } else { 2.644 + fprintf(stderr, "qemu: Unsupported NIC: %s\n", nd->model); 2.645 +Index: qemu-0.9.1/hw/virtio-net.c 2.646 +=================================================================== 2.647 +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 2.648 ++++ qemu-0.9.1/hw/virtio-net.c 2008-02-07 13:36:37.000000000 +0000 2.649 +@@ -0,0 +1,178 @@ 2.650 ++/* 2.651 ++ * Virtio Network Device 2.652 ++ * 2.653 ++ * Copyright IBM, Corp. 2007 2.654 ++ * 2.655 ++ * Authors: 2.656 ++ * Anthony Liguori <address@hidden> 2.657 ++ * 2.658 ++ * This work is licensed under the terms of the GNU GPL, version 2. See 2.659 ++ * the COPYING file in the top-level directory. 2.660 ++ * 2.661 ++ */ 2.662 ++ 2.663 ++#include "virtio.h" 2.664 ++#include "net.h" 2.665 ++#include "pc.h" 2.666 ++ 2.667 ++/* from Linux's virtio_net.h */ 2.668 ++ 2.669 ++/* The ID for virtio_net */ 2.670 ++#define VIRTIO_ID_NET 1 2.671 ++ 2.672 ++/* The feature bitmap for virtio net */ 2.673 ++#define VIRTIO_NET_F_NO_CSUM 0 2.674 ++#define VIRTIO_NET_F_TSO4 1 2.675 ++#define VIRTIO_NET_F_UFO 2 2.676 ++#define VIRTIO_NET_F_TSO4_ECN 3 2.677 ++#define VIRTIO_NET_F_TSO6 4 2.678 ++#define VIRTIO_NET_F_MAC 5 2.679 ++ 2.680 ++/* The config defining mac address (6 bytes) */ 2.681 ++struct virtio_net_config 2.682 ++{ 2.683 ++ uint8_t mac[6]; 2.684 ++} __attribute__((packed)); 2.685 ++ 2.686 ++/* This is the first element of the scatter-gather list. If you don't 2.687 ++ * specify GSO or CSUM features, you can simply ignore the header. */ 2.688 ++struct virtio_net_hdr 2.689 ++{ 2.690 ++#define VIRTIO_NET_HDR_F_NEEDS_CSUM 1 // Use csum_start, csum_offset 2.691 ++ uint8_t flags; 2.692 ++#define VIRTIO_NET_HDR_GSO_NONE 0 // Not a GSO frame 2.693 ++#define VIRTIO_NET_HDR_GSO_TCPV4 1 // GSO frame, IPv4 TCP (TSO) 2.694 ++/* FIXME: Do we need this? If they said they can handle ECN, do they care? */ 2.695 ++#define VIRTIO_NET_HDR_GSO_TCPV4_ECN 2 // GSO frame, IPv4 TCP w/ ECN 2.696 ++#define VIRTIO_NET_HDR_GSO_UDP 3 // GSO frame, IPv4 UDP (UFO) 2.697 ++#define VIRTIO_NET_HDR_GSO_TCPV6 4 // GSO frame, IPv6 TCP 2.698 ++ uint8_t gso_type; 2.699 ++ uint16_t gso_size; 2.700 ++ uint16_t csum_start; 2.701 ++ uint16_t csum_offset; 2.702 ++}; 2.703 ++ 2.704 ++typedef struct VirtIONet 2.705 ++{ 2.706 ++ VirtIODevice vdev; 2.707 ++ uint8_t mac[6]; 2.708 ++ VirtQueue *rx_vq; 2.709 ++ VirtQueue *tx_vq; 2.710 ++ VLANClientState *vc; 2.711 ++ int can_receive; 2.712 ++} VirtIONet; 2.713 ++ 2.714 ++static VirtIONet *to_virtio_net(VirtIODevice *vdev) 2.715 ++{ 2.716 ++ return (VirtIONet *)vdev; 2.717 ++} 2.718 ++ 2.719 ++static void virtio_net_update_config(VirtIODevice *vdev, uint8_t *config) 2.720 ++{ 2.721 ++ VirtIONet *n = to_virtio_net(vdev); 2.722 ++ struct virtio_net_config netcfg; 2.723 ++ 2.724 ++ memcpy(netcfg.mac, n->mac, 6); 2.725 ++ memcpy(config, &netcfg, sizeof(netcfg)); 2.726 ++} 2.727 ++ 2.728 ++static uint32_t virtio_net_get_features(VirtIODevice *vdev) 2.729 ++{ 2.730 ++ return (1 << VIRTIO_NET_F_MAC); 2.731 ++} 2.732 ++ 2.733 ++/* RX */ 2.734 ++ 2.735 ++static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq) 2.736 ++{ 2.737 ++ VirtIONet *n = to_virtio_net(vdev); 2.738 ++ n->can_receive = 1; 2.739 ++} 2.740 ++ 2.741 ++static int virtio_net_can_receive(void *opaque) 2.742 ++{ 2.743 ++ VirtIONet *n = opaque; 2.744 ++ 2.745 ++ return (n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK) && n->can_receive; 2.746 ++} 2.747 ++ 2.748 ++static void virtio_net_receive(void *opaque, const uint8_t *buf, int size) 2.749 ++{ 2.750 ++ VirtIONet *n = opaque; 2.751 ++ VirtQueueElement elem; 2.752 ++ struct virtio_net_hdr *hdr; 2.753 ++ int offset, i; 2.754 ++ 2.755 ++ /* FIXME: the drivers really need to set their status better */ 2.756 ++ if (n->rx_vq->vring.avail == NULL) { 2.757 ++ n->can_receive = 0; 2.758 ++ return; 2.759 ++ } 2.760 ++ 2.761 ++ if (virtqueue_pop(n->rx_vq, &elem) == 0) { 2.762 ++ /* wait until the guest adds some rx bufs */ 2.763 ++ n->can_receive = 0; 2.764 ++ return; 2.765 ++ } 2.766 ++ 2.767 ++ hdr = (void *)elem.in_sg[0].iov_base; 2.768 ++ hdr->flags = 0; 2.769 ++ hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE; 2.770 ++ 2.771 ++ /* copy in packet. ugh */ 2.772 ++ offset = 0; 2.773 ++ i = 1; 2.774 ++ while (offset < size && i < elem.in_num) { 2.775 ++ int len = MIN(elem.in_sg[i].iov_len, size - offset); 2.776 ++ memcpy(elem.in_sg[i].iov_base, buf + offset, len); 2.777 ++ offset += len; 2.778 ++ i++; 2.779 ++ } 2.780 ++ 2.781 ++ /* signal other side */ 2.782 ++ virtqueue_push(n->rx_vq, &elem, sizeof(*hdr) + offset); 2.783 ++ virtio_notify(&n->vdev, n->rx_vq); 2.784 ++} 2.785 ++ 2.786 ++/* TX */ 2.787 ++static void virtio_net_handle_tx(VirtIODevice *vdev, VirtQueue *vq) 2.788 ++{ 2.789 ++ VirtIONet *n = to_virtio_net(vdev); 2.790 ++ VirtQueueElement elem; 2.791 ++ 2.792 ++ while (virtqueue_pop(vq, &elem)) { 2.793 ++ int i; 2.794 ++ size_t len = 0; 2.795 ++ 2.796 ++ /* ignore the header for now */ 2.797 ++ for (i = 1; i < elem.out_num; i++) { 2.798 ++ qemu_send_packet(n->vc, elem.out_sg[i].iov_base, 2.799 ++ elem.out_sg[i].iov_len); 2.800 ++ len += elem.out_sg[i].iov_len; 2.801 ++ } 2.802 ++ 2.803 ++ virtqueue_push(vq, &elem, sizeof(struct virtio_net_hdr) + len); 2.804 ++ virtio_notify(&n->vdev, vq); 2.805 ++ } 2.806 ++} 2.807 ++ 2.808 ++void *virtio_net_init(PCIBus *bus, NICInfo *nd, int devfn) 2.809 ++{ 2.810 ++ VirtIONet *n; 2.811 ++ 2.812 ++ n = (VirtIONet *)virtio_init_pci(bus, "virtio-net", 6900, 0x1000, 2.813 ++ 0, VIRTIO_ID_NET, 2.814 ++ 0x02, 0x00, 0x00, 2.815 ++ 6, sizeof(VirtIONet)); 2.816 ++ 2.817 ++ n->vdev.update_config = virtio_net_update_config; 2.818 ++ n->vdev.get_features = virtio_net_get_features; 2.819 ++ n->rx_vq = virtio_add_queue(&n->vdev, 512, virtio_net_handle_rx); 2.820 ++ n->tx_vq = virtio_add_queue(&n->vdev, 128, virtio_net_handle_tx); 2.821 ++ n->can_receive = 0; 2.822 ++ memcpy(n->mac, nd->macaddr, 6); 2.823 ++ n->vc = qemu_new_vlan_client(nd->vlan, virtio_net_receive, 2.824 ++ virtio_net_can_receive, n); 2.825 ++ 2.826 ++ return &n->vdev; 2.827 ++} 2.828 +Index: qemu-0.9.1/Makefile.target 2.829 +=================================================================== 2.830 +--- qemu-0.9.1.orig/Makefile.target 2008-02-07 13:36:37.000000000 +0000 2.831 ++++ qemu-0.9.1/Makefile.target 2008-02-07 13:38:53.000000000 +0000 2.832 +@@ -437,7 +437,7 @@ 2.833 + VL_OBJS += rtl8139.o 2.834 + 2.835 + # virtio devices 2.836 +-VL_OBJS += virtio.o virtio-net.o 2.837 ++VL_OBJS += virtio.o virtio-net.o virtio-blk.o 2.838 + 2.839 + ifeq ($(TARGET_BASE_ARCH), i386) 2.840 + # Hardware support 2.841 +Index: qemu-0.9.1/hw/pc.c 2.842 +=================================================================== 2.843 +--- qemu-0.9.1.orig/hw/pc.c 2008-01-06 19:38:42.000000000 +0000 2.844 ++++ qemu-0.9.1/hw/pc.c 2008-02-07 13:38:53.000000000 +0000 2.845 +@@ -1008,6 +1008,18 @@ 2.846 + } 2.847 + } 2.848 + } 2.849 ++ 2.850 ++ /* Add virtio block devices */ 2.851 ++ if (pci_enabled) { 2.852 ++ int index; 2.853 ++ int unit_id = 0; 2.854 ++ 2.855 ++ while ((index = drive_get_index(IF_VIRTIO, 0, unit_id)) != -1) { 2.856 ++ virtio_blk_init(pci_bus, 0x5002, 0x2258, 2.857 ++ drives_table[index].bdrv); 2.858 ++ unit_id++; 2.859 ++ } 2.860 ++ } 2.861 + } 2.862 + 2.863 + static void pc_init_pci(int ram_size, int vga_ram_size, 2.864 +Index: qemu-0.9.1/hw/pc.h 2.865 +=================================================================== 2.866 +--- qemu-0.9.1.orig/hw/pc.h 2008-02-07 13:36:37.000000000 +0000 2.867 ++++ qemu-0.9.1/hw/pc.h 2008-02-07 13:38:53.000000000 +0000 2.868 +@@ -147,4 +147,8 @@ 2.869 + void *virtio_net_init(PCIBus *bus, NICInfo *nd, int devfn); 2.870 + 2.871 + 2.872 ++/* virtio-blk.h */ 2.873 ++void *virtio_blk_init(PCIBus *bus, uint16_t vendor, uint16_t device, 2.874 ++ BlockDriverState *bs); 2.875 ++ 2.876 + #endif 2.877 +Index: qemu-0.9.1/hw/virtio-blk.c 2.878 +=================================================================== 2.879 +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 2.880 ++++ qemu-0.9.1/hw/virtio-blk.c 2008-02-07 13:38:53.000000000 +0000 2.881 +@@ -0,0 +1,163 @@ 2.882 ++/* 2.883 ++ * Virtio Block Device 2.884 ++ * 2.885 ++ * Copyright IBM, Corp. 2007 2.886 ++ * 2.887 ++ * Authors: 2.888 ++ * Anthony Liguori <address@hidden> 2.889 ++ * 2.890 ++ * This work is licensed under the terms of the GNU GPL, version 2. See 2.891 ++ * the COPYING file in the top-level directory. 2.892 ++ * 2.893 ++ */ 2.894 ++ 2.895 ++#include "virtio.h" 2.896 ++#include "block.h" 2.897 ++#include "pc.h" 2.898 ++ 2.899 ++/* from Linux's linux/virtio_blk.h */ 2.900 ++ 2.901 ++/* The ID for virtio_block */ 2.902 ++#define VIRTIO_ID_BLOCK 2 2.903 ++ 2.904 ++/* Feature bits */ 2.905 ++#define VIRTIO_BLK_F_BARRIER 0 /* Does host support barriers? */ 2.906 ++#define VIRTIO_BLK_F_SIZE_MAX 1 /* Indicates maximum segment size */ 2.907 ++#define VIRTIO_BLK_F_SEG_MAX 2 /* Indicates maximum # of segments */ 2.908 ++ 2.909 ++struct virtio_blk_config 2.910 ++{ 2.911 ++ uint64_t capacity; 2.912 ++ uint32_t size_max; 2.913 ++ uint32_t seg_max; 2.914 ++}; 2.915 ++ 2.916 ++/* These two define direction. */ 2.917 ++#define VIRTIO_BLK_T_IN 0 2.918 ++#define VIRTIO_BLK_T_OUT 1 2.919 ++ 2.920 ++/* This bit says it's a scsi command, not an actual read or write. */ 2.921 ++#define VIRTIO_BLK_T_SCSI_CMD 2 2.922 ++ 2.923 ++/* Barrier before this op. */ 2.924 ++#define VIRTIO_BLK_T_BARRIER 0x80000000 2.925 ++ 2.926 ++/* This is the first element of the read scatter-gather list. */ 2.927 ++struct virtio_blk_outhdr 2.928 ++{ 2.929 ++ /* VIRTIO_BLK_T* */ 2.930 ++ uint32_t type; 2.931 ++ /* io priority. */ 2.932 ++ uint32_t ioprio; 2.933 ++ /* Sector (ie. 512 byte offset) */ 2.934 ++ uint64_t sector; 2.935 ++ /* Where to put reply. */ 2.936 ++ uint64_t id; 2.937 ++}; 2.938 ++ 2.939 ++#define VIRTIO_BLK_S_OK 0 2.940 ++#define VIRTIO_BLK_S_IOERR 1 2.941 ++#define VIRTIO_BLK_S_UNSUPP 2 2.942 ++ 2.943 ++/* This is the first element of the write scatter-gather list */ 2.944 ++struct virtio_blk_inhdr 2.945 ++{ 2.946 ++ unsigned char status; 2.947 ++}; 2.948 ++ 2.949 ++typedef struct VirtIOBlock 2.950 ++{ 2.951 ++ VirtIODevice vdev; 2.952 ++ BlockDriverState *bs; 2.953 ++} VirtIOBlock; 2.954 ++ 2.955 ++static VirtIOBlock *to_virtio_blk(VirtIODevice *vdev) 2.956 ++{ 2.957 ++ return (VirtIOBlock *)vdev; 2.958 ++} 2.959 ++ 2.960 ++static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq) 2.961 ++{ 2.962 ++ VirtIOBlock *s = to_virtio_blk(vdev); 2.963 ++ VirtQueueElement elem; 2.964 ++ unsigned int count; 2.965 ++ 2.966 ++ while ((count = virtqueue_pop(vq, &elem)) != 0) { 2.967 ++ struct virtio_blk_inhdr *in; 2.968 ++ struct virtio_blk_outhdr *out; 2.969 ++ unsigned int wlen; 2.970 ++ off_t off; 2.971 ++ int i; 2.972 ++ 2.973 ++ out = (void *)elem.out_sg[0].iov_base; 2.974 ++ in = (void *)elem.in_sg[elem.in_num - 1].iov_base; 2.975 ++ off = out->sector; 2.976 ++ 2.977 ++ if (out->type & VIRTIO_BLK_T_SCSI_CMD) { 2.978 ++ wlen = sizeof(*in); 2.979 ++ in->status = VIRTIO_BLK_S_UNSUPP; 2.980 ++ } else if (out->type & VIRTIO_BLK_T_OUT) { 2.981 ++ wlen = sizeof(*in); 2.982 ++ 2.983 ++ for (i = 1; i < elem.out_num; i++) { 2.984 ++ bdrv_write(s->bs, off, 2.985 ++ elem.out_sg[i].iov_base, 2.986 ++ elem.out_sg[i].iov_len / 512); 2.987 ++ off += elem.out_sg[i].iov_len / 512; 2.988 ++ } 2.989 ++ 2.990 ++ in->status = VIRTIO_BLK_S_OK; 2.991 ++ } else { 2.992 ++ wlen = sizeof(*in); 2.993 ++ 2.994 ++ for (i = 0; i < elem.in_num - 1; i++) { 2.995 ++ bdrv_read(s->bs, off, 2.996 ++ elem.in_sg[i].iov_base, 2.997 ++ elem.in_sg[i].iov_len / 512); 2.998 ++ off += elem.in_sg[i].iov_len / 512; 2.999 ++ wlen += elem.in_sg[i].iov_len; 2.1000 ++ } 2.1001 ++ 2.1002 ++ in->status = VIRTIO_BLK_S_OK; 2.1003 ++ } 2.1004 ++ 2.1005 ++ virtqueue_push(vq, &elem, wlen); 2.1006 ++ virtio_notify(vdev, vq); 2.1007 ++ } 2.1008 ++} 2.1009 ++ 2.1010 ++static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config) 2.1011 ++{ 2.1012 ++ VirtIOBlock *s = to_virtio_blk(vdev); 2.1013 ++ struct virtio_blk_config blkcfg; 2.1014 ++ int64_t capacity; 2.1015 ++ 2.1016 ++ bdrv_get_geometry(s->bs, &capacity); 2.1017 ++ blkcfg.capacity = capacity; 2.1018 ++ blkcfg.seg_max = 128 - 2; 2.1019 ++ memcpy(config, &blkcfg, sizeof(blkcfg)); 2.1020 ++} 2.1021 ++ 2.1022 ++static uint32_t virtio_blk_get_features(VirtIODevice *vdev) 2.1023 ++{ 2.1024 ++ return (1 << VIRTIO_BLK_F_SEG_MAX); 2.1025 ++} 2.1026 ++ 2.1027 ++void *virtio_blk_init(PCIBus *bus, uint16_t vendor, uint16_t device, 2.1028 ++ BlockDriverState *bs) 2.1029 ++{ 2.1030 ++ VirtIOBlock *s; 2.1031 ++ 2.1032 ++ s = (VirtIOBlock *)virtio_init_pci(bus, "virtio-blk", 6900, 0x1001, 2.1033 ++ 0, VIRTIO_ID_BLOCK, 2.1034 ++ 0x01, 0x80, 0x00, 2.1035 ++ 16, sizeof(VirtIOBlock)); 2.1036 ++ 2.1037 ++ s->vdev.update_config = virtio_blk_update_config; 2.1038 ++ s->vdev.get_features = virtio_blk_get_features; 2.1039 ++ s->bs = bs; 2.1040 ++ 2.1041 ++ virtio_add_queue(&s->vdev, 128, virtio_blk_handle_output); 2.1042 ++ 2.1043 ++ return &s->vdev; 2.1044 ++} 2.1045 +Index: qemu-0.9.1/sysemu.h 2.1046 +=================================================================== 2.1047 +--- qemu-0.9.1.orig/sysemu.h 2008-01-06 19:38:42.000000000 +0000 2.1048 ++++ qemu-0.9.1/sysemu.h 2008-02-07 13:38:53.000000000 +0000 2.1049 +@@ -117,7 +117,7 @@ 2.1050 + #endif 2.1051 + 2.1052 + typedef enum { 2.1053 +- IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD 2.1054 ++ IF_IDE, IF_SCSI, IF_FLOPPY, IF_PFLASH, IF_MTD, IF_SD, IF_VIRTIO 2.1055 + } BlockInterfaceType; 2.1056 + 2.1057 + typedef struct DriveInfo { 2.1058 +Index: qemu-0.9.1/vl.c 2.1059 +=================================================================== 2.1060 +--- qemu-0.9.1.orig/vl.c 2008-01-06 19:38:42.000000000 +0000 2.1061 ++++ qemu-0.9.1/vl.c 2008-02-07 13:40:52.000000000 +0000 2.1062 +@@ -4953,6 +4953,9 @@ 2.1063 + } else if (!strcmp(buf, "sd")) { 2.1064 + type = IF_SD; 2.1065 + max_devs = 0; 2.1066 ++ } else if (!strcmp(buf, "virtio")) { 2.1067 ++ type = IF_VIRTIO; 2.1068 ++ max_devs = 0; 2.1069 + } else { 2.1070 + fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf); 2.1071 + return -1; 2.1072 +@@ -5141,6 +5144,7 @@ 2.1073 + break; 2.1074 + case IF_PFLASH: 2.1075 + case IF_MTD: 2.1076 ++ case IF_VIRTIO: 2.1077 + break; 2.1078 + } 2.1079 + if (!file[0])