virtio.c 18.3 KB
Newer Older
A
aliguori 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Virtio Support
 *
 * 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 <inttypes.h>

#include "virtio.h"
#include "sysemu.h"

19 20 21 22
/* The alignment to use between consumer and producer parts of vring.
 * x86 pagesize again. */
#define VIRTIO_PCI_VRING_ALIGN         4096

A
aliguori 已提交
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
/* QEMU doesn't strictly need write barriers since everything runs in
 * lock-step.  We'll leave the calls to wmb() in though to make it obvious for
 * KVM or if kqemu gets SMP support.
 */
#define wmb() do { } while (0)

typedef struct VRingDesc
{
    uint64_t addr;
    uint32_t len;
    uint16_t flags;
    uint16_t next;
} VRingDesc;

typedef struct VRingAvail
{
    uint16_t flags;
    uint16_t idx;
    uint16_t ring[0];
} VRingAvail;

typedef struct VRingUsedElem
{
    uint32_t id;
    uint32_t len;
} VRingUsedElem;

typedef struct VRingUsed
{
    uint16_t flags;
    uint16_t idx;
    VRingUsedElem ring[0];
} VRingUsed;

typedef struct VRing
{
    unsigned int num;
    target_phys_addr_t desc;
    target_phys_addr_t avail;
    target_phys_addr_t used;
} VRing;

struct VirtQueue
{
    VRing vring;
P
Paul Brook 已提交
68
    target_phys_addr_t pa;
A
aliguori 已提交
69 70
    uint16_t last_avail_idx;
    int inuse;
71
    uint16_t vector;
A
aliguori 已提交
72 73 74 75 76 77
    void (*handle_output)(VirtIODevice *vdev, VirtQueue *vq);
};

#define VIRTIO_PCI_QUEUE_MAX        16

/* virt queue functions */
P
Paul Brook 已提交
78
static void virtqueue_init(VirtQueue *vq)
A
aliguori 已提交
79
{
P
Paul Brook 已提交
80 81
    target_phys_addr_t pa = vq->pa;

A
aliguori 已提交
82 83
    vq->vring.desc = pa;
    vq->vring.avail = pa + vq->vring.num * sizeof(VRingDesc);
84 85 86
    vq->vring.used = vring_align(vq->vring.avail +
                                 offsetof(VRingAvail, ring[vq->vring.num]),
                                 VIRTIO_PCI_VRING_ALIGN);
A
aliguori 已提交
87 88
}

89
static inline uint64_t vring_desc_addr(target_phys_addr_t desc_pa, int i)
A
aliguori 已提交
90 91
{
    target_phys_addr_t pa;
92
    pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, addr);
A
aliguori 已提交
93 94 95
    return ldq_phys(pa);
}

96
static inline uint32_t vring_desc_len(target_phys_addr_t desc_pa, int i)
A
aliguori 已提交
97 98
{
    target_phys_addr_t pa;
99
    pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, len);
A
aliguori 已提交
100 101 102
    return ldl_phys(pa);
}

103
static inline uint16_t vring_desc_flags(target_phys_addr_t desc_pa, int i)
A
aliguori 已提交
104 105
{
    target_phys_addr_t pa;
106
    pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, flags);
A
aliguori 已提交
107 108 109
    return lduw_phys(pa);
}

110
static inline uint16_t vring_desc_next(target_phys_addr_t desc_pa, int i)
A
aliguori 已提交
111 112
{
    target_phys_addr_t pa;
113
    pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, next);
A
aliguori 已提交
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
    return lduw_phys(pa);
}

static inline uint16_t vring_avail_flags(VirtQueue *vq)
{
    target_phys_addr_t pa;
    pa = vq->vring.avail + offsetof(VRingAvail, flags);
    return lduw_phys(pa);
}

static inline uint16_t vring_avail_idx(VirtQueue *vq)
{
    target_phys_addr_t pa;
    pa = vq->vring.avail + offsetof(VRingAvail, idx);
    return lduw_phys(pa);
}

static inline uint16_t vring_avail_ring(VirtQueue *vq, int i)
{
    target_phys_addr_t pa;
    pa = vq->vring.avail + offsetof(VRingAvail, ring[i]);
    return lduw_phys(pa);
}

static inline void vring_used_ring_id(VirtQueue *vq, int i, uint32_t val)
{
    target_phys_addr_t pa;
    pa = vq->vring.used + offsetof(VRingUsed, ring[i].id);
    stl_phys(pa, val);
}

static inline void vring_used_ring_len(VirtQueue *vq, int i, uint32_t val)
{
    target_phys_addr_t pa;
    pa = vq->vring.used + offsetof(VRingUsed, ring[i].len);
    stl_phys(pa, val);
}

static uint16_t vring_used_idx(VirtQueue *vq)
{
    target_phys_addr_t pa;
    pa = vq->vring.used + offsetof(VRingUsed, idx);
    return lduw_phys(pa);
}

static inline void vring_used_idx_increment(VirtQueue *vq, uint16_t val)
{
    target_phys_addr_t pa;
    pa = vq->vring.used + offsetof(VRingUsed, idx);
    stw_phys(pa, vring_used_idx(vq) + val);
}

static inline void vring_used_flags_set_bit(VirtQueue *vq, int mask)
{
    target_phys_addr_t pa;
    pa = vq->vring.used + offsetof(VRingUsed, flags);
    stw_phys(pa, lduw_phys(pa) | mask);
}

static inline void vring_used_flags_unset_bit(VirtQueue *vq, int mask)
{
    target_phys_addr_t pa;
    pa = vq->vring.used + offsetof(VRingUsed, flags);
    stw_phys(pa, lduw_phys(pa) & ~mask);
}

void virtio_queue_set_notification(VirtQueue *vq, int enable)
{
    if (enable)
        vring_used_flags_unset_bit(vq, VRING_USED_F_NO_NOTIFY);
    else
        vring_used_flags_set_bit(vq, VRING_USED_F_NO_NOTIFY);
}

int virtio_queue_ready(VirtQueue *vq)
{
    return vq->vring.avail != 0;
}

int virtio_queue_empty(VirtQueue *vq)
{
    return vring_avail_idx(vq) == vq->last_avail_idx;
}

void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
                    unsigned int len, unsigned int idx)
{
    unsigned int offset;
    int i;

    offset = 0;
    for (i = 0; i < elem->in_num; i++) {
        size_t size = MIN(len - offset, elem->in_sg[i].iov_len);

208 209 210
        cpu_physical_memory_unmap(elem->in_sg[i].iov_base,
                                  elem->in_sg[i].iov_len,
                                  1, size);
A
aliguori 已提交
211

212
        offset += elem->in_sg[i].iov_len;
A
aliguori 已提交
213 214
    }

215 216 217 218 219
    for (i = 0; i < elem->out_num; i++)
        cpu_physical_memory_unmap(elem->out_sg[i].iov_base,
                                  elem->out_sg[i].iov_len,
                                  0, elem->out_sg[i].iov_len);

A
aliguori 已提交
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
    idx = (idx + vring_used_idx(vq)) % vq->vring.num;

    /* Get a pointer to the next entry in the used ring. */
    vring_used_ring_id(vq, idx, elem->index);
    vring_used_ring_len(vq, idx, len);
}

void virtqueue_flush(VirtQueue *vq, unsigned int count)
{
    /* Make sure buffer is written before we update index. */
    wmb();
    vring_used_idx_increment(vq, count);
    vq->inuse -= count;
}

void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,
                    unsigned int len)
{
    virtqueue_fill(vq, elem, len, 0);
    virtqueue_flush(vq, 1);
}

static int virtqueue_num_heads(VirtQueue *vq, unsigned int idx)
{
    uint16_t num_heads = vring_avail_idx(vq) - idx;

    /* Check it isn't doing very strange things with descriptor numbers. */
A
aliguori 已提交
247 248 249 250 251
    if (num_heads > vq->vring.num) {
        fprintf(stderr, "Guest moved used index from %u to %u",
                idx, vring_avail_idx(vq));
        exit(1);
    }
A
aliguori 已提交
252 253 254 255 256 257 258 259 260 261 262 263 264

    return num_heads;
}

static unsigned int virtqueue_get_head(VirtQueue *vq, unsigned int idx)
{
    unsigned int head;

    /* Grab the next descriptor number they're advertising, and increment
     * the index we've seen. */
    head = vring_avail_ring(vq, idx % vq->vring.num);

    /* If their number is silly, that's a fatal mistake. */
A
aliguori 已提交
265 266 267 268
    if (head >= vq->vring.num) {
        fprintf(stderr, "Guest says index %u is available", head);
        exit(1);
    }
A
aliguori 已提交
269 270 271 272

    return head;
}

273 274
static unsigned virtqueue_next_desc(target_phys_addr_t desc_pa,
                                    unsigned int i, unsigned int max)
A
aliguori 已提交
275 276 277 278
{
    unsigned int next;

    /* If this descriptor says it doesn't chain, we're done. */
279 280
    if (!(vring_desc_flags(desc_pa, i) & VRING_DESC_F_NEXT))
        return max;
A
aliguori 已提交
281 282

    /* Check they're not leading us off end of descriptors. */
283
    next = vring_desc_next(desc_pa, i);
A
aliguori 已提交
284 285 286
    /* Make sure compiler knows to grab that: we don't want it changing! */
    wmb();

287
    if (next >= max) {
A
aliguori 已提交
288 289 290
        fprintf(stderr, "Desc next is %u", next);
        exit(1);
    }
A
aliguori 已提交
291 292 293 294 295 296

    return next;
}

int virtqueue_avail_bytes(VirtQueue *vq, int in_bytes, int out_bytes)
{
297 298
    unsigned int idx;
    int total_bufs, in_total, out_total;
A
aliguori 已提交
299 300 301

    idx = vq->last_avail_idx;

302
    total_bufs = in_total = out_total = 0;
A
aliguori 已提交
303
    while (virtqueue_num_heads(vq, idx)) {
304 305
        unsigned int max, num_bufs, indirect = 0;
        target_phys_addr_t desc_pa;
A
aliguori 已提交
306 307
        int i;

308 309
        max = vq->vring.num;
        num_bufs = total_bufs;
A
aliguori 已提交
310
        i = virtqueue_get_head(vq, idx++);
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
        desc_pa = vq->vring.desc;

        if (vring_desc_flags(desc_pa, i) & VRING_DESC_F_INDIRECT) {
            if (vring_desc_len(desc_pa, i) % sizeof(VRingDesc)) {
                fprintf(stderr, "Invalid size for indirect buffer table\n");
                exit(1);
            }

            /* If we've got too many, that implies a descriptor loop. */
            if (num_bufs >= max) {
                fprintf(stderr, "Looped descriptor");
                exit(1);
            }

            /* loop over the indirect descriptor table */
            indirect = 1;
            max = vring_desc_len(desc_pa, i) / sizeof(VRingDesc);
            num_bufs = i = 0;
            desc_pa = vring_desc_addr(desc_pa, i);
        }

A
aliguori 已提交
332 333
        do {
            /* If we've got too many, that implies a descriptor loop. */
334
            if (++num_bufs > max) {
A
aliguori 已提交
335 336 337
                fprintf(stderr, "Looped descriptor");
                exit(1);
            }
A
aliguori 已提交
338

339
            if (vring_desc_flags(desc_pa, i) & VRING_DESC_F_WRITE) {
A
aliguori 已提交
340
                if (in_bytes > 0 &&
341
                    (in_total += vring_desc_len(desc_pa, i)) >= in_bytes)
A
aliguori 已提交
342 343 344
                    return 1;
            } else {
                if (out_bytes > 0 &&
345
                    (out_total += vring_desc_len(desc_pa, i)) >= out_bytes)
A
aliguori 已提交
346 347
                    return 1;
            }
348
        } while ((i = virtqueue_next_desc(desc_pa, i, max)) != max);
349 350 351 352 353

        if (!indirect)
            total_bufs = num_bufs;
        else
            total_bufs++;
A
aliguori 已提交
354 355 356 357 358 359 360
    }

    return 0;
}

int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem)
{
361 362
    unsigned int i, head, max;
    target_phys_addr_t desc_pa = vq->vring.desc;
363
    target_phys_addr_t len;
A
aliguori 已提交
364 365 366 367 368 369 370

    if (!virtqueue_num_heads(vq, vq->last_avail_idx))
        return 0;

    /* When we start there are none of either input nor output. */
    elem->out_num = elem->in_num = 0;

371 372
    max = vq->vring.num;

A
aliguori 已提交
373
    i = head = virtqueue_get_head(vq, vq->last_avail_idx++);
374 375 376 377 378 379 380 381 382 383 384 385 386

    if (vring_desc_flags(desc_pa, i) & VRING_DESC_F_INDIRECT) {
        if (vring_desc_len(desc_pa, i) % sizeof(VRingDesc)) {
            fprintf(stderr, "Invalid size for indirect buffer table\n");
            exit(1);
        }

        /* loop over the indirect descriptor table */
        max = vring_desc_len(desc_pa, i) / sizeof(VRingDesc);
        desc_pa = vring_desc_addr(desc_pa, i);
        i = 0;
    }

A
aliguori 已提交
387 388
    do {
        struct iovec *sg;
389
        int is_write = 0;
A
aliguori 已提交
390

391 392
        if (vring_desc_flags(desc_pa, i) & VRING_DESC_F_WRITE) {
            elem->in_addr[elem->in_num] = vring_desc_addr(desc_pa, i);
A
aliguori 已提交
393
            sg = &elem->in_sg[elem->in_num++];
394
            is_write = 1;
A
aliguori 已提交
395 396 397 398
        } else
            sg = &elem->out_sg[elem->out_num++];

        /* Grab the first descriptor, and check it's OK. */
399
        sg->iov_len = vring_desc_len(desc_pa, i);
400
        len = sg->iov_len;
A
aliguori 已提交
401

402 403
        sg->iov_base = cpu_physical_memory_map(vring_desc_addr(desc_pa, i),
                                               &len, is_write);
404 405 406

        if (sg->iov_base == NULL || len != sg->iov_len) {
            fprintf(stderr, "virtio: trying to map MMIO memory\n");
A
aliguori 已提交
407 408
            exit(1);
        }
A
aliguori 已提交
409 410

        /* If we've got too many, that implies a descriptor loop. */
411
        if ((elem->in_num + elem->out_num) > max) {
A
aliguori 已提交
412 413 414
            fprintf(stderr, "Looped descriptor");
            exit(1);
        }
415
    } while ((i = virtqueue_next_desc(desc_pa, i, max)) != max);
A
aliguori 已提交
416 417 418 419 420 421 422 423 424

    elem->index = head;

    vq->inuse++;

    return elem->in_num + elem->out_num;
}

/* virtio device */
425 426 427 428 429 430
static void virtio_notify_vector(VirtIODevice *vdev, uint16_t vector)
{
    if (vdev->binding->notify) {
        vdev->binding->notify(vdev->binding_opaque, vector);
    }
}
A
aliguori 已提交
431

P
Paul Brook 已提交
432
void virtio_update_irq(VirtIODevice *vdev)
A
aliguori 已提交
433
{
434
    virtio_notify_vector(vdev, VIRTIO_NO_VECTOR);
A
aliguori 已提交
435 436
}

P
Paul Brook 已提交
437
void virtio_reset(void *opaque)
A
aliguori 已提交
438 439 440 441 442 443 444 445 446 447 448
{
    VirtIODevice *vdev = opaque;
    int i;

    if (vdev->reset)
        vdev->reset(vdev);

    vdev->features = 0;
    vdev->queue_sel = 0;
    vdev->status = 0;
    vdev->isr = 0;
449 450
    vdev->config_vector = VIRTIO_NO_VECTOR;
    virtio_notify_vector(vdev, vdev->config_vector);
A
aliguori 已提交
451 452 453 454 455 456

    for(i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) {
        vdev->vq[i].vring.desc = 0;
        vdev->vq[i].vring.avail = 0;
        vdev->vq[i].vring.used = 0;
        vdev->vq[i].last_avail_idx = 0;
P
Paul Brook 已提交
457
        vdev->vq[i].pa = 0;
458
        vdev->vq[i].vector = VIRTIO_NO_VECTOR;
A
aliguori 已提交
459 460 461
    }
}

P
Paul Brook 已提交
462
uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr)
A
aliguori 已提交
463 464 465 466 467 468 469 470 471 472 473 474
{
    uint8_t val;

    vdev->get_config(vdev, vdev->config);

    if (addr > (vdev->config_len - sizeof(val)))
        return (uint32_t)-1;

    memcpy(&val, vdev->config + addr, sizeof(val));
    return val;
}

P
Paul Brook 已提交
475
uint32_t virtio_config_readw(VirtIODevice *vdev, uint32_t addr)
A
aliguori 已提交
476 477 478 479 480 481 482 483 484 485 486 487
{
    uint16_t val;

    vdev->get_config(vdev, vdev->config);

    if (addr > (vdev->config_len - sizeof(val)))
        return (uint32_t)-1;

    memcpy(&val, vdev->config + addr, sizeof(val));
    return val;
}

P
Paul Brook 已提交
488
uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr)
A
aliguori 已提交
489 490 491 492 493 494 495 496 497 498 499 500
{
    uint32_t val;

    vdev->get_config(vdev, vdev->config);

    if (addr > (vdev->config_len - sizeof(val)))
        return (uint32_t)-1;

    memcpy(&val, vdev->config + addr, sizeof(val));
    return val;
}

P
Paul Brook 已提交
501
void virtio_config_writeb(VirtIODevice *vdev, uint32_t addr, uint32_t data)
A
aliguori 已提交
502 503 504 505 506 507 508 509 510 511 512 513
{
    uint8_t val = data;

    if (addr > (vdev->config_len - sizeof(val)))
        return;

    memcpy(vdev->config + addr, &val, sizeof(val));

    if (vdev->set_config)
        vdev->set_config(vdev, vdev->config);
}

P
Paul Brook 已提交
514
void virtio_config_writew(VirtIODevice *vdev, uint32_t addr, uint32_t data)
A
aliguori 已提交
515 516 517 518 519 520 521 522 523 524 525 526
{
    uint16_t val = data;

    if (addr > (vdev->config_len - sizeof(val)))
        return;

    memcpy(vdev->config + addr, &val, sizeof(val));

    if (vdev->set_config)
        vdev->set_config(vdev, vdev->config);
}

P
Paul Brook 已提交
527
void virtio_config_writel(VirtIODevice *vdev, uint32_t addr, uint32_t data)
A
aliguori 已提交
528 529 530 531 532 533 534 535 536 537 538 539
{
    uint32_t val = data;

    if (addr > (vdev->config_len - sizeof(val)))
        return;

    memcpy(vdev->config + addr, &val, sizeof(val));

    if (vdev->set_config)
        vdev->set_config(vdev, vdev->config);
}

P
Paul Brook 已提交
540
void virtio_queue_set_addr(VirtIODevice *vdev, int n, target_phys_addr_t addr)
A
aliguori 已提交
541
{
542 543
    vdev->vq[n].pa = addr;
    virtqueue_init(&vdev->vq[n]);
P
Paul Brook 已提交
544 545 546 547 548 549 550 551 552 553 554
}

target_phys_addr_t virtio_queue_get_addr(VirtIODevice *vdev, int n)
{
    return vdev->vq[n].pa;
}

int virtio_queue_get_num(VirtIODevice *vdev, int n)
{
    return vdev->vq[n].vring.num;
}
A
aliguori 已提交
555

P
Paul Brook 已提交
556 557 558 559
void virtio_queue_notify(VirtIODevice *vdev, int n)
{
    if (n < VIRTIO_PCI_QUEUE_MAX && vdev->vq[n].vring.desc) {
        vdev->vq[n].handle_output(vdev, &vdev->vq[n]);
A
aliguori 已提交
560 561 562
    }
}

563 564 565 566 567 568 569 570 571 572 573 574
uint16_t virtio_queue_vector(VirtIODevice *vdev, int n)
{
    return n < VIRTIO_PCI_QUEUE_MAX ? vdev->vq[n].vector :
        VIRTIO_NO_VECTOR;
}

void virtio_queue_set_vector(VirtIODevice *vdev, int n, uint16_t vector)
{
    if (n < VIRTIO_PCI_QUEUE_MAX)
        vdev->vq[n].vector = vector;
}

A
aliguori 已提交
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
                            void (*handle_output)(VirtIODevice *, VirtQueue *))
{
    int i;

    for (i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) {
        if (vdev->vq[i].vring.num == 0)
            break;
    }

    if (i == VIRTIO_PCI_QUEUE_MAX || queue_size > VIRTQUEUE_MAX_SIZE)
        abort();

    vdev->vq[i].vring.num = queue_size;
    vdev->vq[i].handle_output = handle_output;

    return &vdev->vq[i];
}

void virtio_notify(VirtIODevice *vdev, VirtQueue *vq)
{
596 597 598 599
    /* Always notify when queue is empty (when feature acknowledge) */
    if ((vring_avail_flags(vq) & VRING_AVAIL_F_NO_INTERRUPT) &&
        (!(vdev->features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY)) ||
         (vq->inuse || vring_avail_idx(vq) != vq->last_avail_idx)))
A
aliguori 已提交
600 601 602
        return;

    vdev->isr |= 0x01;
603
    virtio_notify_vector(vdev, vq->vector);
A
aliguori 已提交
604 605 606 607
}

void virtio_notify_config(VirtIODevice *vdev)
{
608 609 610
    if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))
        return;

A
aliguori 已提交
611
    vdev->isr |= 0x03;
612
    virtio_notify_vector(vdev, vdev->config_vector);
A
aliguori 已提交
613 614 615 616 617 618
}

void virtio_save(VirtIODevice *vdev, QEMUFile *f)
{
    int i;

619 620
    if (vdev->binding->save_config)
        vdev->binding->save_config(vdev->binding_opaque, f);
A
aliguori 已提交
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640

    qemu_put_8s(f, &vdev->status);
    qemu_put_8s(f, &vdev->isr);
    qemu_put_be16s(f, &vdev->queue_sel);
    qemu_put_be32s(f, &vdev->features);
    qemu_put_be32(f, vdev->config_len);
    qemu_put_buffer(f, vdev->config, vdev->config_len);

    for (i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) {
        if (vdev->vq[i].vring.num == 0)
            break;
    }

    qemu_put_be32(f, i);

    for (i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) {
        if (vdev->vq[i].vring.num == 0)
            break;

        qemu_put_be32(f, vdev->vq[i].vring.num);
P
Paul Brook 已提交
641
        qemu_put_be64(f, vdev->vq[i].pa);
A
aliguori 已提交
642
        qemu_put_be16s(f, &vdev->vq[i].last_avail_idx);
643 644
        if (vdev->binding->save_queue)
            vdev->binding->save_queue(vdev->binding_opaque, i, f);
A
aliguori 已提交
645 646 647
    }
}

648
int virtio_load(VirtIODevice *vdev, QEMUFile *f)
A
aliguori 已提交
649
{
650
    int num, i, ret;
A
aliguori 已提交
651

652 653 654 655 656
    if (vdev->binding->load_config) {
        ret = vdev->binding->load_config(vdev->binding_opaque, f);
        if (ret)
            return ret;
    }
A
aliguori 已提交
657 658 659 660 661 662 663 664 665 666 667 668

    qemu_get_8s(f, &vdev->status);
    qemu_get_8s(f, &vdev->isr);
    qemu_get_be16s(f, &vdev->queue_sel);
    qemu_get_be32s(f, &vdev->features);
    vdev->config_len = qemu_get_be32(f);
    qemu_get_buffer(f, vdev->config, vdev->config_len);

    num = qemu_get_be32(f);

    for (i = 0; i < num; i++) {
        vdev->vq[i].vring.num = qemu_get_be32(f);
P
Paul Brook 已提交
669
        vdev->vq[i].pa = qemu_get_be64(f);
A
aliguori 已提交
670 671
        qemu_get_be16s(f, &vdev->vq[i].last_avail_idx);

P
Paul Brook 已提交
672 673
        if (vdev->vq[i].pa) {
            virtqueue_init(&vdev->vq[i]);
A
aliguori 已提交
674
        }
675 676 677 678
        if (vdev->binding->load_queue) {
            ret = vdev->binding->load_queue(vdev->binding_opaque, i, f);
            if (ret)
                return ret;
679
        }
A
aliguori 已提交
680 681
    }

682
    virtio_notify_vector(vdev, VIRTIO_NO_VECTOR);
683
    return 0;
A
aliguori 已提交
684 685
}

686 687 688 689 690 691 692
void virtio_cleanup(VirtIODevice *vdev)
{
    if (vdev->config)
        qemu_free(vdev->config);
    qemu_free(vdev->vq);
}

P
Paul Brook 已提交
693 694
VirtIODevice *virtio_common_init(const char *name, uint16_t device_id,
                                 size_t config_size, size_t struct_size)
A
aliguori 已提交
695 696 697
{
    VirtIODevice *vdev;

P
Paul Brook 已提交
698
    vdev = qemu_mallocz(struct_size);
A
aliguori 已提交
699

P
Paul Brook 已提交
700
    vdev->device_id = device_id;
A
aliguori 已提交
701 702 703
    vdev->status = 0;
    vdev->isr = 0;
    vdev->queue_sel = 0;
704
    vdev->config_vector = VIRTIO_NO_VECTOR;
A
aliguori 已提交
705 706 707 708 709 710 711 712 713 714 715
    vdev->vq = qemu_mallocz(sizeof(VirtQueue) * VIRTIO_PCI_QUEUE_MAX);

    vdev->name = name;
    vdev->config_len = config_size;
    if (vdev->config_len)
        vdev->config = qemu_mallocz(config_size);
    else
        vdev->config = NULL;

    return vdev;
}
P
Paul Brook 已提交
716 717 718 719 720 721 722

void virtio_bind_device(VirtIODevice *vdev, const VirtIOBindings *binding,
                        void *opaque)
{
    vdev->binding = binding;
    vdev->binding_opaque = opaque;
}