From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1LDMcB-0006ti-CL for qemu-devel@nongnu.org; Thu, 18 Dec 2008 12:24:47 -0500 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1LDMc6-0006mM-Pz for qemu-devel@nongnu.org; Thu, 18 Dec 2008 12:24:46 -0500 Received: from [199.232.76.173] (port=51156 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1LDMc6-0006lj-1O for qemu-devel@nongnu.org; Thu, 18 Dec 2008 12:24:42 -0500 Received: from mail05.svc.cra.dublin.eircom.net ([159.134.118.21]:46422) by monty-python.gnu.org with smtp (Exim 4.60) (envelope-from ) id 1LDMc5-0003Iy-F4 for qemu-devel@nongnu.org; Thu, 18 Dec 2008 12:24:41 -0500 From: Mark McLoughlin Date: Thu, 18 Dec 2008 17:24:37 +0000 Message-Id: <1229621078-25563-2-git-send-email-markmc@redhat.com> In-Reply-To: <1229621078-25563-1-git-send-email-markmc@redhat.com> References: <1229621078-25563-1-git-send-email-markmc@redhat.com> Subject: [Qemu-devel] [PATCH 1/2] virtio: make vring_desc_*() take phys addrs Reply-To: qemu-devel@nongnu.org List-Id: qemu-devel.nongnu.org List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: Mark McLoughlin Change the vring descriptor helpers to take the physical address of the descriptor table rather than a virtqueue. This is needed in order to allow these helpers to be used with an indirect descriptor table. Signed-off-by: Mark McLoughlin --- hw/virtio.c | 62 ++++++++++++++++++++++++++++++++-------------------------- 1 files changed, 34 insertions(+), 28 deletions(-) diff --git a/hw/virtio.c b/hw/virtio.c index dba80f8..e997a5e 100644 --- a/hw/virtio.c +++ b/hw/virtio.c @@ -159,31 +159,31 @@ static void virtqueue_init(VirtQueue *vq, target_phys_addr_t pa) VIRTIO_PCI_VRING_ALIGN); } -static inline uint64_t vring_desc_addr(VirtQueue *vq, int i) +static inline uint64_t vring_desc_addr(target_phys_addr_t desc_pa, int i) { target_phys_addr_t pa; - pa = vq->vring.desc + sizeof(VRingDesc) * i + offsetof(VRingDesc, addr); + pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, addr); return ldq_phys(pa); } -static inline uint32_t vring_desc_len(VirtQueue *vq, int i) +static inline uint32_t vring_desc_len(target_phys_addr_t desc_pa, int i) { target_phys_addr_t pa; - pa = vq->vring.desc + sizeof(VRingDesc) * i + offsetof(VRingDesc, len); + pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, len); return ldl_phys(pa); } -static inline uint16_t vring_desc_flags(VirtQueue *vq, int i) +static inline uint16_t vring_desc_flags(target_phys_addr_t desc_pa, int i) { target_phys_addr_t pa; - pa = vq->vring.desc + sizeof(VRingDesc) * i + offsetof(VRingDesc, flags); + pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, flags); return lduw_phys(pa); } -static inline uint16_t vring_desc_next(VirtQueue *vq, int i) +static inline uint16_t vring_desc_next(target_phys_addr_t desc_pa, int i) { target_phys_addr_t pa; - pa = vq->vring.desc + sizeof(VRingDesc) * i + offsetof(VRingDesc, next); + pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, next); return lduw_phys(pa); } @@ -356,20 +356,21 @@ static unsigned int virtqueue_get_head(VirtQueue *vq, unsigned int idx) return head; } -static unsigned virtqueue_next_desc(VirtQueue *vq, unsigned int i) +static unsigned virtqueue_next_desc(target_phys_addr_t desc_pa, + unsigned int i, unsigned int max) { unsigned int next; /* If this descriptor says it doesn't chain, we're done. */ - if (!(vring_desc_flags(vq, i) & VRING_DESC_F_NEXT)) - return vq->vring.num; + if (!(vring_desc_flags(desc_pa, i) & VRING_DESC_F_NEXT)) + return max; /* Check they're not leading us off end of descriptors. */ - next = vring_desc_next(vq, i); + next = vring_desc_next(desc_pa, i); /* Make sure compiler knows to grab that: we don't want it changing! */ wmb(); - if (next >= vq->vring.num) { + if (next >= max) { fprintf(stderr, "Desc next is %u", next); exit(1); } @@ -379,10 +380,12 @@ static unsigned virtqueue_next_desc(VirtQueue *vq, unsigned int i) int virtqueue_avail_bytes(VirtQueue *vq, int in_bytes, int out_bytes) { - unsigned int idx; + target_phys_addr_t desc_pa = vq->vring.desc; + unsigned int idx, max; int num_bufs, in_total, out_total; idx = vq->last_avail_idx; + max = vq->vring.num; num_bufs = in_total = out_total = 0; while (virtqueue_num_heads(vq, idx)) { @@ -391,21 +394,21 @@ int virtqueue_avail_bytes(VirtQueue *vq, int in_bytes, int out_bytes) i = virtqueue_get_head(vq, idx++); do { /* If we've got too many, that implies a descriptor loop. */ - if (++num_bufs > vq->vring.num) { + if (++num_bufs > max) { fprintf(stderr, "Looped descriptor"); exit(1); } - if (vring_desc_flags(vq, i) & VRING_DESC_F_WRITE) { + if (vring_desc_flags(desc_pa, i) & VRING_DESC_F_WRITE) { if (in_bytes > 0 && - (in_total += vring_desc_len(vq, i)) >= in_bytes) + (in_total += vring_desc_len(desc_pa, i)) >= in_bytes) return 1; } else { if (out_bytes > 0 && - (out_total += vring_desc_len(vq, i)) >= out_bytes) + (out_total += vring_desc_len(desc_pa, i)) >= out_bytes) return 1; } - } while ((i = virtqueue_next_desc(vq, i)) != vq->vring.num); + } while ((i = virtqueue_next_desc(desc_pa, i, max)) != max); } return 0; @@ -413,7 +416,8 @@ int virtqueue_avail_bytes(VirtQueue *vq, int in_bytes, int out_bytes) int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem) { - unsigned int i, head; + target_phys_addr_t desc_pa = vq->vring.desc; + unsigned int i, head, max; if (!virtqueue_num_heads(vq, vq->last_avail_idx)) return 0; @@ -421,21 +425,23 @@ int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem) /* When we start there are none of either input nor output. */ elem->out_num = elem->in_num = 0; + max = vq->vring.num; + i = head = virtqueue_get_head(vq, vq->last_avail_idx++); do { struct iovec *sg; - if (vring_desc_flags(vq, i) & VRING_DESC_F_WRITE) { - elem->in_addr[elem->in_num] = vring_desc_addr(vq, i); + if (vring_desc_flags(desc_pa, i) & VRING_DESC_F_WRITE) { + elem->in_addr[elem->in_num] = vring_desc_addr(desc_pa, i); sg = &elem->in_sg[elem->in_num++]; } else sg = &elem->out_sg[elem->out_num++]; /* Grab the first descriptor, and check it's OK. */ - sg->iov_len = vring_desc_len(vq, i); + sg->iov_len = vring_desc_len(desc_pa, i); #ifdef VIRTIO_ZERO_COPY - sg->iov_base = virtio_map_gpa(vring_desc_addr(vq, i), sg->iov_len); + sg->iov_base = virtio_map_gpa(vring_desc_addr(desc_pa, i), sg->iov_len); #else /* cap individual scatter element size to prevent unbounded allocations of memory from the guest. Practically speaking, no virtio driver @@ -448,8 +454,8 @@ int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem) sg->iov_base = qemu_malloc(sg->iov_len); if (sg->iov_base && - !(vring_desc_flags(vq, i) & VRING_DESC_F_WRITE)) { - cpu_physical_memory_read(vring_desc_addr(vq, i), + !(vring_desc_flags(desc_pa, i) & VRING_DESC_F_WRITE)) { + cpu_physical_memory_read(vring_desc_addr(desc_pa, i), sg->iov_base, sg->iov_len); } @@ -460,11 +466,11 @@ int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem) } /* If we've got too many, that implies a descriptor loop. */ - if ((elem->in_num + elem->out_num) > vq->vring.num) { + if ((elem->in_num + elem->out_num) > max) { fprintf(stderr, "Looped descriptor"); exit(1); } - } while ((i = virtqueue_next_desc(vq, i)) != vq->vring.num); + } while ((i = virtqueue_next_desc(desc_pa, i, max)) != max); elem->index = head; -- 1.6.0.5