On Fri, Jun 21, 2024 at 04:56:36PM +0200, Laurent Vivier wrote:

Needs a commit message.

...
  Signed-off-by: Laurent Vivier
<lvivier(a)redhat.com>
 ---
  packet.c | 75 +++++++++++++++++++++++++++++++-------------------------
  packet.h | 14 ++---------
  2 files changed, 43 insertions(+), 46 deletions(-)
 
 diff --git a/packet.c b/packet.c
 index ccfc84607709..af2a539a1794 100644
 --- a/packet.c
 +++ b/packet.c
 @@ -22,6 +22,36 @@
  #include "util.h"
  #include "log.h"
 
Function comment, please.

...
  +static int packet_check_range(const struct pool *p,
size_t offset, size_t len,
 +			      const char *start, const char *func, int line)
 +{
 +	if (start < p->buf) {
 +		if (func) {
 +			trace("add packet start %p before buffer start %p, "
 +			      "%s:%i", (void *)start, (void *)p->buf, func, line);
 +		}
 +		return -1; 
Pre-existing, but I wonder if these should be assert()s.  Are there
any cases where we'd hit this path that don't indicate a bug in the
caller?

...
  +	}
 +
 +	if (start + len + offset > p->buf + p->buf_size) { 
Also pre-existing, but I wonder if we should check for overflow of
(Start + len + offset).

...
  +		if (func) {
 +			trace("packet offset plus length %lu from size %lu, "
 +			      "%s:%i", start - p->buf + len + offset,
 +			      p->buf_size, func, line);
 +		}
 +		return -1;
 +	}
 +
 +#if UINTPTR_MAX == UINT64_MAX
 +	if ((uintptr_t)start - (uintptr_t)p->buf > UINT32_MAX) { 
I don't think this check is relevant any more if we're going to iovecs
- this was just because the offset in struct desc was only 32-bit.

...
  +		trace("add packet start %p, buffer start %p,
%s:%i",
 +		      (void *)start, (void *)p->buf, func, line);
 +		return -1;
 +	}
 +#endif
 +
 +	return 0;
 +}
  /**
   * packet_add_do() - Add data as packet descriptor to given pool
   * @p:		Existing pool
 @@ -41,34 +71,16 @@ void packet_add_do(struct pool *p, size_t len, const char *start,
  		return;
  	}
  
 -	if (start < p->buf) {
 -		trace("add packet start %p before buffer start %p, %s:%i",
 -		      (void *)start, (void *)p->buf, func, line);
 +	if (packet_check_range(p, 0, len, start, func, line))
  		return;
 -	}
 -
 -	if (start + len > p->buf + p->buf_size) {
 -		trace("add packet start %p, length: %zu, buffer end %p, %s:%i",
 -		      (void *)start, len, (void *)(p->buf + p->buf_size),
 -		      func, line);
 -		return;
 -	}
  
  	if (len > UINT16_MAX) {
  		trace("add packet length %zu, %s:%i", len, func, line);
  		return;
  	}
  
 -#if UINTPTR_MAX == UINT64_MAX
 -	if ((uintptr_t)start - (uintptr_t)p->buf > UINT32_MAX) {
 -		trace("add packet start %p, buffer start %p, %s:%i",
 -		      (void *)start, (void *)p->buf, func, line);
 -		return;
 -	}
 -#endif
 -
 -	p->pkt[idx].offset = start - p->buf;
 -	p->pkt[idx].len = len;
 +	p->pkt[idx].iov_base = (void *)start;
 +	p->pkt[idx].iov_len = len;
  
  	p->count++;
  }
 @@ -104,28 +116,23 @@ void *packet_get_do(const struct pool *p, size_t idx, size_t
offset,
  		return NULL;
  	}
  
 -	if (p->pkt[idx].offset + len + offset > p->buf_size) {
 +	if (len + offset > p->pkt[idx].iov_len) {
  		if (func) {
 -			trace("packet offset plus length %zu from size %zu, "
 -			      "%s:%i", p->pkt[idx].offset + len + offset,
 -			      p->buf_size, func, line);
 +			trace("data length %zu, offset %zu from length %zu, "
 +			      "%s:%i", len, offset, p->pkt[idx].iov_len,
 +			      func, line); 
I'm not sure either the old or new message is particularly descriptive
here :/

...
   		}
  		return NULL;
  	}
  
 -	if (len + offset > p->pkt[idx].len) {
 -		if (func) {
 -			trace("data length %zu, offset %zu from length %u, "
 -			      "%s:%i", len, offset, p->pkt[idx].len,
 -			      func, line);
 -		}
 +	if (packet_check_range(p, offset, len, p->pkt[idx].iov_base,
 +			       func, line)) 
Ah.. right..  in this case we certainly don't want ASSERT()s in
packet_check_range().  Still wonder if that would make more sense for
the packet add case, however.

A couple of other points:
 * You've effectively switched the order of the two different tests here
   (one range checking against the entire buffer, one range checking
   against a single packet).  Any reason for that?
 * Do we actually need the entire-buffer check here on the _get()
   side?  Isn't it enough to ensure that packets lie within the buffer
   when they're inserted?  Pre-existing, again, AFAICT.

...
   		return NULL;
 -	}
  
  	if (left)
 -		*left = p->pkt[idx].len - offset - len;
 +		*left = p->pkt[idx].iov_len - offset - len;
  
 -	return p->buf + p->pkt[idx].offset + offset;
 +	return (char *)p->pkt[idx].iov_base + offset;
  }
  
  /**
 diff --git a/packet.h b/packet.h
 index a784b07bbed5..8377dcf678bb 100644
 --- a/packet.h
 +++ b/packet.h
 @@ -6,16 +6,6 @@
  #ifndef PACKET_H
  #define PACKET_H
  
 -/**
 - * struct desc - Generic offset-based descriptor within buffer
 - * @offset:	Offset of descriptor relative to buffer start, 32-bit limit
 - * @len:	Length of descriptor, host order, 16-bit limit
 - */
 -struct desc {
 -	uint32_t offset;
 -	uint16_t len;
 -};
 -
  /**
   * struct pool - Generic pool of packets stored in a buffer
   * @buf:	Buffer storing packet descriptors
 @@ -29,7 +19,7 @@ struct pool {
  	size_t buf_size;
  	size_t size;
  	size_t count;
 -	struct desc pkt[1];
 +	struct iovec pkt[1];
  };
  
  void packet_add_do(struct pool *p, size_t len, const char *start,
 @@ -54,7 +44,7 @@ struct _name ## _t {							\
  	size_t buf_size;						\
  	size_t size;							\
  	size_t count;							\
 -	struct desc pkt[_size];						\
 +	struct iovec pkt[_size];					\
  }
  
  #define PACKET_POOL_INIT_NOCAST(_size, _buf, _buf_size)			\ 
-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

On Thu, Jul 04, 2024 at 05:52:09PM +0200, Laurent Vivier wrote:
...
  On 24/06/2024 04:48, David Gibson wrote:
  On Fri, Jun 21, 2024 at 04:56:36PM +0200, Laurent
Vivier wrote:
 
 Needs a commit message.
 
 > Signed-off-by: Laurent Vivier <lvivier(a)redhat.com>
 > ---
 >   packet.c | 75 +++++++++++++++++++++++++++++++-------------------------
 >   packet.h | 14 ++---------
 >   2 files changed, 43 insertions(+), 46 deletions(-)
 > 
 > diff --git a/packet.c b/packet.c
 > index ccfc84607709..af2a539a1794 100644
 > --- a/packet.c
 > +++ b/packet.c 
 ...
 
  +	}
 +
 +	if (start + len + offset > p->buf + p->buf_size) { 
 
 Also pre-existing, but I wonder if we should check for overflow of
 (Start + len + offset). 
 
 Originally, I didn't want to change the existing behaviour. Only to move
 code, and to use a common function for packet_add_do() and packet_get_do().
 But if you think it should be better I can update the code for that: 
Well, I think we should be more careful here, but as you say I don't
think it necessarily belongs as part of this series.

...
 
 
  +		if (func) {
 +			trace("packet offset plus length %lu from size %lu, "
 +			      "%s:%i", start - p->buf + len + offset,
 +			      p->buf_size, func, line);
 +		}
 +		return -1;
 +	}
 +
 +#if UINTPTR_MAX == UINT64_MAX
 +	if ((uintptr_t)start - (uintptr_t)p->buf > UINT32_MAX) { 
 
 I don't think this check is relevant any more if we're going to iovecs
 - this was just because the offset in struct desc was only 32-bit. 
 
 I agree.
 
  
  +		trace("add packet start %p, buffer start
%p, %s:%i",
 +		      (void *)start, (void *)p->buf, func, line);
 +		return -1;
 +	}
 +#endif
 +
 +	return 0;
 +}
   /**
    * packet_add_do() - Add data as packet descriptor to given pool
    * @p:		Existing pool
 @@ -41,34 +71,16 @@ void packet_add_do(struct pool *p, size_t len, const char *start,
   		return;
   	}
 -	if (start < p->buf) {
 -		trace("add packet start %p before buffer start %p, %s:%i",
 -		      (void *)start, (void *)p->buf, func, line);
 +	if (packet_check_range(p, 0, len, start, func, line))
   		return;
 -	}
 -
 -	if (start + len > p->buf + p->buf_size) {
 -		trace("add packet start %p, length: %zu, buffer end %p, %s:%i",
 -		      (void *)start, len, (void *)(p->buf + p->buf_size),
 -		      func, line);
 -		return;
 -	}
   	if (len > UINT16_MAX) {
   		trace("add packet length %zu, %s:%i", len, func, line);
   		return;
   	}
 -#if UINTPTR_MAX == UINT64_MAX
 -	if ((uintptr_t)start - (uintptr_t)p->buf > UINT32_MAX) {
 -		trace("add packet start %p, buffer start %p, %s:%i",
 -		      (void *)start, (void *)p->buf, func, line);
 -		return;
 -	}
 -#endif
 -
 -	p->pkt[idx].offset = start - p->buf;
 -	p->pkt[idx].len = len;
 +	p->pkt[idx].iov_base = (void *)start;
 +	p->pkt[idx].iov_len = len;
   	p->count++;
   }
 @@ -104,28 +116,23 @@ void *packet_get_do(const struct pool *p, size_t idx, size_t
offset,
   		return NULL;
   	}
 -	if (p->pkt[idx].offset + len + offset > p->buf_size) {
 +	if (len + offset > p->pkt[idx].iov_len) {
   		if (func) {
 -			trace("packet offset plus length %zu from size %zu, "
 -			      "%s:%i", p->pkt[idx].offset + len + offset,
 -			      p->buf_size, func, line);
 +			trace("data length %zu, offset %zu from length %zu, "
 +			      "%s:%i", len, offset, p->pkt[idx].iov_len,
 +			      func, line); 
 
 I'm not sure either the old or new message is particularly descriptive
 here :/ 
 
 I think the func and line parameters will help to understand the problem,
 and the others why the trace is triggered. 
Hmm, yeah, I guess so.

...
 
  
    		}
   		return NULL;
   	}
 -	if (len + offset > p->pkt[idx].len) {
 -		if (func) {
 -			trace("data length %zu, offset %zu from length %u, "
 -			      "%s:%i", len, offset, p->pkt[idx].len,
 -			      func, line);
 -		}
 +	if (packet_check_range(p, offset, len, p->pkt[idx].iov_base,
 +			       func, line)) 
 
 Ah.. right..  in this case we certainly don't want ASSERT()s in
 packet_check_range().  Still wonder if that would make more sense for
 the packet add case, however.
 
 A couple of other points:
   * You've effectively switched the order of the two different tests here
     (one range checking against the entire buffer, one range checking
     against a single packet).  Any reason for that? 
 
 The idea is to check the parameters are valid before checking the buffer is valid.

Ok, makes sense.

...
 
    * Do we
actually need the entire-buffer check here on the _get()
     side?  Isn't it enough to ensure that packets lie within the buffer
     when they're inserted?  Pre-existing, again, AFAICT. 
 
 I wanted to keep the idea introduced in bb708111833e ("treewide: Packet
 abstraction with mandatory boundary checks") and checking we don't read
 outside of the buffer. 
Hm, ok.

-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

On Fri, Jun 21, 2024 at 04:56:37PM +0200, Laurent Vivier wrote:
...
  Add virtio.c and virtio.h that define the functions
needed
 to manage virtqueues.
 
 Signed-off-by: Laurent Vivier <lvivier(a)redhat.com>
 ---
  Makefile |   4 +-
  util.h   |  11 ++
  virtio.c | 446 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
  virtio.h | 123 +++++++++++++++
  4 files changed, 582 insertions(+), 2 deletions(-)
  create mode 100644 virtio.c
  create mode 100644 virtio.h
 
 diff --git a/Makefile b/Makefile
 index 09fc461d087e..39613a7cf1f2 100644
 --- a/Makefile
 +++ b/Makefile
 @@ -47,7 +47,7 @@ FLAGS += -DDUAL_STACK_SOCKETS=$(DUAL_STACK_SOCKETS)
  PASST_SRCS = arch.c arp.c checksum.c conf.c dhcp.c dhcpv6.c flow.c fwd.c \
  	icmp.c igmp.c inany.c iov.c ip.c isolation.c lineread.c log.c mld.c \
  	ndp.c netlink.c packet.c passt.c pasta.c pcap.c pif.c tap.c tcp.c \
 -	tcp_buf.c tcp_splice.c udp.c util.c
 +	tcp_buf.c tcp_splice.c udp.c util.c virtio.c
  QRAP_SRCS = qrap.c
  SRCS = $(PASST_SRCS) $(QRAP_SRCS)
  
 @@ -57,7 +57,7 @@ PASST_HEADERS = arch.h arp.h checksum.h conf.h dhcp.h dhcpv6.h flow.h
fwd.h \
  	flow_table.h icmp.h icmp_flow.h inany.h iov.h ip.h isolation.h \
  	lineread.h log.h ndp.h netlink.h packet.h passt.h pasta.h pcap.h pif.h \
  	siphash.h tap.h tcp.h tcp_buf.h tcp_conn.h tcp_internal.h tcp_splice.h \
 -	udp.h util.h
 +	udp.h util.h virtio.h
  HEADERS = $(PASST_HEADERS) seccomp.h
  
  C := \#include <linux/tcp.h>\nstruct tcp_info x = { .tcpi_snd_wnd = 0 };
 diff --git a/util.h b/util.h
 index eebb027be487..56c4e2e7b4fe 100644
 --- a/util.h
 +++ b/util.h
 @@ -48,6 +48,9 @@
  #define ROUND_DOWN(x, y)	((x) & ~((y) - 1))
  #define ROUND_UP(x, y)		(((x) + (y) - 1) & ~((y) - 1))
  
 +#define ALIGN_DOWN(n, m)	((n) / (m) * (m))
 +#define ALIGN_UP(n, m)		ALIGN_DOWN((n) + (m) - 1, (m))
 +
  #define MAX_FROM_BITS(n)	(((1U << (n)) - 1))
  
  #define BIT(n)			(1UL << (n))
 @@ -116,6 +119,14 @@
  #define	htonl_constant(x)	(__bswap_constant_32(x))
  #endif
  
 +static inline void barrier(void) { __asm__ __volatile__("" :::
"memory"); }
 +#define smp_mb()		do { barrier(); __atomic_thread_fence(__ATOMIC_SEQ_CST); } while (0)
 +#define smp_mb_release()	do { barrier(); __atomic_thread_fence(__ATOMIC_RELEASE); }
while (0)
 +#define smp_mb_acquire()	do { barrier(); __atomic_thread_fence(__ATOMIC_ACQUIRE); }
while (0)
 +
 +#define smp_wmb()	smp_mb_release()
 +#define smp_rmb()	smp_mb_acquire()
 +
  #define NS_FN_STACK_SIZE	(RLIMIT_STACK_VAL * 1024 / 8)
  int do_clone(int (*fn)(void *), char *stack_area, size_t stack_size, int flags,
  	     void *arg);
 diff --git a/virtio.c b/virtio.c
 new file mode 100644
 index 000000000000..50ec8b5119ed
 --- /dev/null
 +++ b/virtio.c
 @@ -0,0 +1,446 @@
 +// SPDX-License-Identifier: GPL-2.0-or-later
 + 
Needs an actual "Copyright" invocation as well as the SPDX stuff.
Which, yes, is a bit fiddly given that it's largely taken from qemu.

...
  +/* some parts copied from QEMU
subprojects/libvhost-user/libvhost-user.c */ 
So, there are obvious stylistic differences between this and the rest
of the passt code for that reason.  As I think I said on an earlier
draft, I think we need to go fully one way or the other: either a)
rewrite this entirely in passt style or b) change the whole thing so
little that it's trivial to pull in new versions from qemu.  This
seems to be somewhere in the middle.

...
  +
 +#include <stddef.h>
 +#include <endian.h>
 +#include <string.h>
 +#include <errno.h>
 +#include <sys/eventfd.h>
 +#include <sys/socket.h>
 +
 +#include "util.h"
 +#include "virtio.h"
 +
 +#define VIRTQUEUE_MAX_SIZE 1024
 +
 +/* Translate guest physical address to our virtual address.  */
 +static void *vu_gpa_to_va(VuDev *dev, uint64_t *plen, uint64_t guest_addr)
 +{
 +	unsigned int i;
 +
 +	if (*plen == 0)
 +		return NULL;
 +
 +	/* Find matching memory region.  */
 +	for (i = 0; i < dev->nregions; i++) {
 +		const VuDevRegion *r = &dev->regions[i];
 +
 +		if ((guest_addr >= r->gpa) && (guest_addr < (r->gpa +
r->size))) {
 +			if ((guest_addr + *plen) > (r->gpa + r->size))
 +				*plen = r->gpa + r->size - guest_addr;
 +			/* NOLINTNEXTLINE(performance-no-int-to-ptr) */
 +			return (void *)(guest_addr - r->gpa + r->mmap_addr + r->mmap_offset);
 +		}
 +	}
 +
 +	return NULL;
 +}
 +
 +static inline uint16_t vring_avail_flags(const VuVirtq *vq)
 +{
 +	return le16toh(vq->vring.avail->flags);
 +}
 +
 +static inline uint16_t vring_avail_idx(VuVirtq *vq)
 +{
 +	vq->shadow_avail_idx = le16toh(vq->vring.avail->idx);
 +
 +	return vq->shadow_avail_idx;
 +}
 +
 +static inline uint16_t vring_avail_ring(const VuVirtq *vq, int i)
 +{
 +	return le16toh(vq->vring.avail->ring[i]);
 +}
 +
 +static inline uint16_t vring_get_used_event(const VuVirtq *vq)
 +{
 +	return vring_avail_ring(vq, vq->vring.num);
 +}
 +
 +static bool virtqueue_get_head(VuDev *dev, const VuVirtq *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. */
 +	if (*head >= vq->vring.num) {
 +		vu_panic(dev, "Guest says index %u is available", *head);
 +		return false;
 +	}
 +
 +	return true;
 +}
 +
 +static int
 +virtqueue_read_indirect_desc(VuDev *dev, struct vring_desc *desc,
 +			     uint64_t addr, size_t len)
 +{
 +	uint64_t read_len;
 +
 +	if (len > (VIRTQUEUE_MAX_SIZE * sizeof(struct vring_desc)))
 +		return -1;
 +
 +	if (len == 0)
 +		return -1;
 +
 +	while (len) {
 +		const struct vring_desc *ori_desc;
 +
 +		read_len = len;
 +		ori_desc = vu_gpa_to_va(dev, &read_len, addr);
 +		if (!ori_desc)
 +			return -1;
 +
 +		memcpy(desc, ori_desc, read_len);
 +		len -= read_len;
 +		addr += read_len;
 +		desc += read_len;
 +	}
 +
 +	return 0;
 +}
 +
 +enum {
 +	VIRTQUEUE_READ_DESC_ERROR = -1,
 +	VIRTQUEUE_READ_DESC_DONE = 0,   /* end of chain */
 +	VIRTQUEUE_READ_DESC_MORE = 1,   /* more buffers in chain */
 +};
 +
 +static int
 +virtqueue_read_next_desc(VuDev *dev, const struct vring_desc *desc,
 +			 int i, unsigned int max, unsigned int *next)
 +{
 +	/* If this descriptor says it doesn't chain, we're done. */
 +	if (!(le16toh(desc[i].flags) & VRING_DESC_F_NEXT))
 +		return VIRTQUEUE_READ_DESC_DONE;
 +
 +	/* Check they're not leading us off end of descriptors. */
 +	*next = le16toh(desc[i].next);
 +	/* Make sure compiler knows to grab that: we don't want it changing! */
 +	smp_wmb();
 +
 +	if (*next >= max) {
 +		vu_panic(dev, "Desc next is %u", *next);
 +		return VIRTQUEUE_READ_DESC_ERROR;
 +	}
 +
 +	return VIRTQUEUE_READ_DESC_MORE;
 +}
 +
 +bool vu_queue_empty(const VuDev *dev, VuVirtq *vq)
 +{
 +	if (dev->broken ||
 +		!vq->vring.avail) {
 +		return true;
 +	}
 +
 +	if (vq->shadow_avail_idx != vq->last_avail_idx)
 +		return false;
 +
 +	return vring_avail_idx(vq) == vq->last_avail_idx;
 +}
 +
 +static bool vring_notify(const VuDev *dev, VuVirtq *vq)
 +{
 +	uint16_t old, new;
 +	bool v;
 +
 +	/* We need to expose used array entries before checking used event. */
 +	smp_mb();
 +
 +	/* Always notify when queue is empty (when feature acknowledge) */
 +	if (vu_has_feature(dev, VIRTIO_F_NOTIFY_ON_EMPTY) &&
 +		!vq->inuse && vu_queue_empty(dev, vq)) {
 +		return true;
 +	}
 +
 +	if (!vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX))
 +		return !(vring_avail_flags(vq) & VRING_AVAIL_F_NO_INTERRUPT);
 +
 +	v = vq->signalled_used_valid;
 +	vq->signalled_used_valid = true;
 +	old = vq->signalled_used;
 +	new = vq->signalled_used = vq->used_idx;
 +	return !v || vring_need_event(vring_get_used_event(vq), new, old);
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +void vu_queue_notify(VuDev *dev, VuVirtq *vq)
 +{
 +	if (dev->broken || !vq->vring.avail)
 +		return;
 +
 +	if (!vring_notify(dev, vq)) {
 +		debug("skipped notify...");
 +		return;
 +	}
 +
 +	if (eventfd_write(vq->call_fd, 1) < 0)
 +		vu_panic(dev, "Error writing eventfd: %s", strerror(errno));
 +}
 +
 +static inline void vring_set_avail_event(VuVirtq *vq, uint16_t val)
 +{
 +	uint16_t val_le = htole16(val);
 +
 +	if (!vq->notification)
 +		return;
 +
 +	memcpy(&vq->vring.used->ring[vq->vring.num], &val_le,
sizeof(uint16_t));
 +}
 +
 +static bool virtqueue_map_desc(VuDev *dev,
 +			       unsigned int *p_num_sg, struct iovec *iov,
 +			       unsigned int max_num_sg,
 +			       uint64_t pa, size_t sz)
 +{
 +	unsigned int num_sg = *p_num_sg;
 +
 +	ASSERT(num_sg <= max_num_sg);
 +
 +	if (!sz) {
 +		vu_panic(dev, "virtio: zero sized buffers are not allowed");
 +		return false;
 +	}
 +
 +	while (sz) {
 +		uint64_t len = sz;
 +
 +		if (num_sg == max_num_sg) {
 +			vu_panic(dev, "virtio: too many descriptors in indirect table");
 +			return false;
 +		}
 +
 +		iov[num_sg].iov_base = vu_gpa_to_va(dev, &len, pa);
 +		if (iov[num_sg].iov_base == NULL) {
 +			vu_panic(dev, "virtio: invalid address for buffers");
 +			return false;
 +		}
 +		iov[num_sg].iov_len = len;
 +		num_sg++;
 +		sz -= len;
 +		pa += len;
 +	}
 +
 +	*p_num_sg = num_sg;
 +	return true;
 +}
 +
 +static int
 +vu_queue_map_desc(VuDev *dev, VuVirtq *vq, unsigned int idx,
 +		  VuVirtqElement *elem)
 +{
 +	const struct vring_desc *desc = vq->vring.desc;
 +	struct vring_desc desc_buf[VIRTQUEUE_MAX_SIZE];
 +	unsigned int out_num = 0, in_num = 0;
 +	unsigned int max = vq->vring.num;
 +	unsigned int i = idx;
 +	uint64_t read_len;
 +	int rc;
 +
 +	if (le16toh(desc[i].flags) & VRING_DESC_F_INDIRECT) {
 +		unsigned int desc_len;
 +		uint64_t desc_addr;
 +
 +		if (le32toh(desc[i].len) % sizeof(struct vring_desc)) {
 +			vu_panic(dev, "Invalid size for indirect buffer table");
 +			return -1;
 +		}
 +
 +		/* loop over the indirect descriptor table */
 +		desc_addr = le64toh(desc[i].addr);
 +		desc_len = le32toh(desc[i].len);
 +		max = desc_len / sizeof(struct vring_desc);
 +		read_len = desc_len;
 +		desc = vu_gpa_to_va(dev, &read_len, desc_addr);
 +		if (desc && read_len != desc_len) {
 +			/* Failed to use zero copy */
 +			desc = NULL;
 +			if (!virtqueue_read_indirect_desc(dev, desc_buf, desc_addr, desc_len))
 +				desc = desc_buf;
 +		}
 +		if (!desc) {
 +			vu_panic(dev, "Invalid indirect buffer table");
 +			return -1;
 +		}
 +		i = 0;
 +	}
 +
 +	/* Collect all the descriptors */
 +	do {
 +		if (le16toh(desc[i].flags) & VRING_DESC_F_WRITE) {
 +			if (!virtqueue_map_desc(dev, &in_num, elem->in_sg,
 +						elem->in_num,
 +						le64toh(desc[i].addr),
 +						le32toh(desc[i].len))) {
 +				return -1;
 +			}
 +		} else {
 +			if (in_num) {
 +				vu_panic(dev, "Incorrect order for descriptors");
 +				return -1;
 +			}
 +			if (!virtqueue_map_desc(dev, &out_num, elem->out_sg,
 +						elem->out_num,
 +						le64toh(desc[i].addr),
 +						le32toh(desc[i].len))) {
 +				return -1;
 +			}
 +		}
 +
 +		/* If we've got too many, that implies a descriptor loop. */
 +		if ((in_num + out_num) > max) {
 +			vu_panic(dev, "Looped descriptor");
 +			return -1;
 +		}
 +		rc = virtqueue_read_next_desc(dev, desc, i, max, &i);
 +	} while (rc == VIRTQUEUE_READ_DESC_MORE);
 +
 +	if (rc == VIRTQUEUE_READ_DESC_ERROR) {
 +		vu_panic(dev, "read descriptor error");
 +		return -1;
 +	}
 +
 +	elem->index = idx;
 +	elem->in_num = in_num;
 +	elem->out_num = out_num;
 +
 +	return 0;
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +int vu_queue_pop(VuDev *dev, VuVirtq *vq, VuVirtqElement *elem)
 +{
 +	unsigned int head;
 +	int ret;
 +
 +	if (dev->broken || !vq->vring.avail)
 +		return -1;
 +
 +	if (vu_queue_empty(dev, vq))
 +		return -1;
 +
 +	/*
 +	 * Needed after virtio_queue_empty(), see comment in
 +	 * virtqueue_num_heads().
 +	 */
 +	smp_rmb();
 +
 +	if (vq->inuse >= vq->vring.num) {
 +		vu_panic(dev, "Virtqueue size exceeded");
 +		return -1;
 +	}
 +
 +	if (!virtqueue_get_head(dev, vq, vq->last_avail_idx++, &head))
 +		return -1;
 +
 +	if (vu_has_feature(dev, VIRTIO_RING_F_EVENT_IDX))
 +		vring_set_avail_event(vq, vq->last_avail_idx);
 +
 +	ret = vu_queue_map_desc(dev, vq, head, elem);
 +
 +	if (ret < 0)
 +		return ret;
 +
 +	vq->inuse++;
 +
 +	return 0;
 +}
 +
 +void vu_queue_detach_element(VuDev *dev, VuVirtq *vq,
 +			     unsigned int index, size_t len)
 +{
 +	(void)dev;
 +	(void)index;
 +	(void)len;
 +
 +	vq->inuse--;
 +	/* unmap, when DMA support is added */
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +void vu_queue_unpop(VuDev *dev, VuVirtq *vq, unsigned int index, size_t len)
 +{
 +	vq->last_avail_idx--;
 +	vu_queue_detach_element(dev, vq, index, len);
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +bool vu_queue_rewind(VuDev *dev, VuVirtq *vq, unsigned int num)
 +{
 +	(void)dev;
 +	if (num > vq->inuse)
 +		return false;
 +
 +	vq->last_avail_idx -= num;
 +	vq->inuse -= num;
 +	return true;
 +}
 +
 +static inline void vring_used_write(VuVirtq *vq,
 +				    const struct vring_used_elem *uelem, int i)
 +{
 +	struct vring_used *used = vq->vring.used;
 +
 +	used->ring[i] = *uelem;
 +}
 +
 +void vu_queue_fill_by_index(const VuDev *dev, VuVirtq *vq, unsigned int index,
 +			    unsigned int len, unsigned int idx)
 +{
 +	struct vring_used_elem uelem;
 +
 +	if (dev->broken || !vq->vring.avail)
 +		return;
 +
 +	idx = (idx + vq->used_idx) % vq->vring.num;
 +
 +	uelem.id = htole32(index);
 +	uelem.len = htole32(len);
 +	vring_used_write(vq, &uelem, idx);
 +}
 +
 +void vu_queue_fill(const VuDev *dev, VuVirtq *vq, const VuVirtqElement *elem,
 +		   unsigned int len, unsigned int idx)
 +{
 +	vu_queue_fill_by_index(dev, vq, elem->index, len, idx);
 +}
 +
 +static inline void vring_used_idx_set(VuVirtq *vq, uint16_t val)
 +{
 +	vq->vring.used->idx = htole16(val);
 +
 +	vq->used_idx = val;
 +}
 +
 +void vu_queue_flush(const VuDev *dev, VuVirtq *vq, unsigned int count)
 +{
 +	uint16_t old, new;
 +
 +	if (dev->broken || !vq->vring.avail)
 +		return;
 +
 +	/* Make sure buffer is written before we update index. */
 +	smp_wmb();
 +
 +	old = vq->used_idx;
 +	new = old + count;
 +	vring_used_idx_set(vq, new);
 +	vq->inuse -= count;
 +	if ((int16_t)(new - vq->signalled_used) < (uint16_t)(new - old))
 +		vq->signalled_used_valid = false;
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +void vu_queue_push(const VuDev *dev, VuVirtq *vq,
 +		   const VuVirtqElement *elem, unsigned int len)
 +{
 +	vu_queue_fill(dev, vq, elem, len, 0);
 +	vu_queue_flush(dev, vq, 1);
 +}
 +
 diff --git a/virtio.h b/virtio.h
 new file mode 100644
 index 000000000000..61398bb432bc
 --- /dev/null
 +++ b/virtio.h
 @@ -0,0 +1,123 @@
 +// SPDX-License-Identifier: GPL-2.0-or-later
 +//
 +/* come parts copied from QEMU subprojects/libvhost-user/libvhost-user.h */
 +
 +#ifndef VIRTIO_H
 +#define VIRTIO_H
 +
 +#include <stdbool.h>
 +#include <linux/vhost_types.h>
 +
 +#define VIRTQUEUE_MAX_SIZE 1024
 +
 +#define vu_panic(vdev, ...)		\
 +	do {				\
 +		(vdev)->broken = true;	\
 +		err( __VA_ARGS__ );	\ 
Wouldn't it be simpler to just use die() in place of vu_panic().  This
is trying to keep the program running even if the vu device is broken,
but if our channel to the guest is broken, I don't think passt is
really worth saving.

...
  +	} while (0)
 +
 +typedef struct VuRing {
 +	unsigned int num;
 +	struct vring_desc *desc;
 +	struct vring_avail *avail;
 +	struct vring_used *used;
 +	uint64_t log_guest_addr;
 +	uint32_t flags;
 +} VuRing;
 +
 +typedef struct VuVirtq {
 +	VuRing vring;
 +
 +	/* Next head to pop */
 +	uint16_t last_avail_idx;
 +
 +	/* Last avail_idx read from VQ. */
 +	uint16_t shadow_avail_idx;
 +
 +	uint16_t used_idx;
 +
 +	/* Last used index value we have signalled on */
 +	uint16_t signalled_used;
 +
 +	/* Last used index value we have signalled on */
 +	bool signalled_used_valid;
 +
 +	bool notification;
 +
 +	unsigned int inuse;
 +
 +	int call_fd;
 +	int kick_fd;
 +	int err_fd;
 +	unsigned int enable;
 +	bool started;
 +
 +	/* Guest addresses of our ring */
 +	struct vhost_vring_addr vra;
 +} VuVirtq;
 +
 +typedef struct VuDevRegion {
 +	uint64_t gpa;
 +	uint64_t size;
 +	uint64_t qva;
 +	uint64_t mmap_offset;
 +	uint64_t mmap_addr;
 +} VuDevRegion;
 +
 +#define VHOST_USER_MAX_QUEUES 2
 +
 +/*
 + * Set a reasonable maximum number of ram slots, which will be supported by
 + * any architecture.
 + */
 +#define VHOST_USER_MAX_RAM_SLOTS 32
 +
 +typedef struct VuDev {
 +	uint32_t nregions;
 +	VuDevRegion regions[VHOST_USER_MAX_RAM_SLOTS];
 +	VuVirtq vq[VHOST_USER_MAX_QUEUES];
 +	uint64_t features;
 +	uint64_t protocol_features;
 +	bool broken;
 +	int hdrlen;
 +} VuDev;
 +
 +typedef struct VuVirtqElement {
 +	unsigned int index;
 +	unsigned int out_num;
 +	unsigned int in_num;
 +	struct iovec *in_sg;
 +	struct iovec *out_sg;
 +} VuVirtqElement;
 +
 +static inline bool has_feature(uint64_t features, unsigned int fbit)
 +{
 +	return !!(features & (1ULL << fbit));
 +}
 +
 +static inline bool vu_has_feature(const VuDev *vdev, unsigned int fbit)
 +{
 +	return has_feature(vdev->features, fbit);
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +static inline bool vu_has_protocol_feature(const VuDev *vdev, unsigned int fbit)
 +{
 +	return has_feature(vdev->protocol_features, fbit);
 +}
 +
 +bool vu_queue_empty(const VuDev *dev, VuVirtq *vq);
 +void vu_queue_notify(VuDev *dev, VuVirtq *vq);
 +int vu_queue_pop(VuDev *dev, VuVirtq *vq, VuVirtqElement *elem);
 +void vu_queue_detach_element(VuDev *dev, VuVirtq *vq, unsigned int index, size_t len);
 +void vu_queue_unpop(VuDev *dev, VuVirtq *vq, unsigned int index, size_t len);
 +bool vu_queue_rewind(VuDev *dev, VuVirtq *vq, unsigned int num);
 +
 +void vu_queue_fill_by_index(const VuDev *dev, VuVirtq *vq, unsigned int index,
 +			    unsigned int len, unsigned int idx);
 +void vu_queue_fill(const VuDev *dev, VuVirtq *vq, const VuVirtqElement *elem,
 +		   unsigned int len, unsigned int idx);
 +void vu_queue_flush(const VuDev *dev, VuVirtq *vq, unsigned int count);
 +void vu_queue_push(const VuDev *dev, VuVirtq *vq, const VuVirtqElement *elem,
 +		   unsigned int len);
 +#endif /* VIRTIO_H */ 
-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

On Fri, Jul 05, 2024 at 05:06:12PM +0200, Laurent Vivier wrote:
...
  On 24/06/2024 04:56, David Gibson wrote:
  On Fri, Jun 21, 2024 at 04:56:37PM +0200, Laurent
Vivier wrote:
 > Add virtio.c and virtio.h that define the functions needed
 > to manage virtqueues.
 > 
 > Signed-off-by: Laurent Vivier <lvivier(a)redhat.com>
 > ---
 >   Makefile |   4 +-
 >   util.h   |  11 ++
 >   virtio.c | 446 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 >   virtio.h | 123 +++++++++++++++
 >   4 files changed, 582 insertions(+), 2 deletions(-)
 >   create mode 100644 virtio.c
 >   create mode 100644 virtio.h
 >  
 ...
 
  diff
--git a/virtio.c b/virtio.c
 new file mode 100644
 index 000000000000..50ec8b5119ed
 --- /dev/null
 +++ b/virtio.c
 @@ -0,0 +1,446 @@
 +// SPDX-License-Identifier: GPL-2.0-or-later
 + 
 
 Needs an actual "Copyright" invocation as well as the SPDX stuff.
 Which, yes, is a bit fiddly given that it's largely taken from qemu. 
 
 I'm updating that 
Ok.

...
 
 
  +/* some parts copied from QEMU
subprojects/libvhost-user/libvhost-user.c */ 
 
 So, there are obvious stylistic differences between this and the rest
 of the passt code for that reason.  As I think I said on an earlier
 draft, I think we need to go fully one way or the other: either a)
 rewrite this entirely in passt style or b) change the whole thing so
 little that it's trivial to pull in new versions from qemu.  This
 seems to be somewhere in the middle. 
 
 As the orignal code in QEMU don't change a lot I chose to update it to match
 passt coding style. I'm adding the function headers. What else is missing? 
From memory:
  - No braces for one line blocks
  - snake_case instead of CamelCase
  - Don't use typedefs for structures or unions
  - Tabs instead of spaces

...
  ...
 
  diff
--git a/virtio.h b/virtio.h
 new file mode 100644
 index 000000000000..61398bb432bc
 --- /dev/null
 +++ b/virtio.h
 @@ -0,0 +1,123 @@
 +// SPDX-License-Identifier: GPL-2.0-or-later
 +//
 +/* come parts copied from QEMU subprojects/libvhost-user/libvhost-user.h */
 +
 +#ifndef VIRTIO_H
 +#define VIRTIO_H
 +
 +#include <stdbool.h>
 +#include <linux/vhost_types.h>
 +
 +#define VIRTQUEUE_MAX_SIZE 1024
 +
 +#define vu_panic(vdev, ...)		\
 +	do {				\
 +		(vdev)->broken = true;	\
 +		err( __VA_ARGS__ );	\ 
 
 Wouldn't it be simpler to just use die() in place of vu_panic().  This
 is trying to keep the program running even if the vu device is broken,
 but if our channel to the guest is broken, I don't think passt is
 really worth saving.
  
 
 I agree.
 
 Thanks,
 Laurent
  
-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

On Fri, Jun 21, 2024 at 04:56:38PM +0200, Laurent Vivier wrote:
...
  Add vhost_user.c and vhost_user.h that define the
functions needed
 to implement vhost-user backend.
 
 Signed-off-by: Laurent Vivier <lvivier(a)redhat.com> 
I'm a little confused by this patch.  The commit message seems to
suggest that like the previous patch it's basically just a code import
from qemu.  However...

[snip]
...
  diff --git a/passt.c b/passt.c
 index a5e2c5a8e151..9d21c545b9cf 100644
 --- a/passt.c
 +++ b/passt.c
 @@ -73,6 +73,8 @@ char *epoll_type_str[] = {
  	[EPOLL_TYPE_TAP_PASTA]		= "/dev/net/tun device",
  	[EPOLL_TYPE_TAP_PASST]		= "connected qemu socket",
  	[EPOLL_TYPE_TAP_LISTEN]		= "listening qemu socket",
 +	[EPOLL_TYPE_VHOST_CMD]		= "vhost-user command socket",
 +	[EPOLL_TYPE_VHOST_KICK]		= "vhost-user kick socket", 
... we also have real changes to passt specific code.  It's not very
obvious to me what the boundaries of that are.

...
   };
  static_assert(ARRAY_SIZE(epoll_type_str) == EPOLL_NUM_TYPES,
  	      "epoll_type_str[] doesn't match enum epoll_type");
 diff --git a/passt.h b/passt.h
 index 46d073a2a6fd..af10d0bfe4ef 100644
 --- a/passt.h
 +++ b/passt.h
 @@ -22,6 +22,7 @@ union epoll_ref;
  #include "fwd.h"
  #include "tcp.h"
  #include "udp.h"
 +#include "vhost_user.h"
  
  /**
   * enum epoll_type - Different types of fds we poll over
 @@ -51,6 +52,10 @@ enum epoll_type {
  	EPOLL_TYPE_TAP_PASST,
  	/* socket listening for qemu socket connections */
  	EPOLL_TYPE_TAP_LISTEN,
 +	/* vhost-user command socket */
 +	EPOLL_TYPE_VHOST_CMD,
 +	/* vhost-user kick event socket */
 +	EPOLL_TYPE_VHOST_KICK,
  
  	EPOLL_NUM_TYPES,
  };
 @@ -224,6 +229,7 @@ struct ip6_ctx {
   * @no_map_gw:		Don't map connections, untracked UDP to gateway to host
   * @low_wmem:		Low probed net.core.wmem_max
   * @low_rmem:		Low probed net.core.rmem_max
 + * @vdev:		vhost-user device
   */
  struct ctx {
  	enum passt_modes mode;
 @@ -288,6 +294,8 @@ struct ctx {
  
  	int low_wmem;
  	int low_rmem;
 +
 +	struct VuDev vdev;
  };
  
  void proto_update_l2_buf(const unsigned char *eth_d,
 diff --git a/tap.c b/tap.c
 index c9aeff19f177..be272d25b642 100644
 --- a/tap.c
 +++ b/tap.c
 @@ -977,7 +977,7 @@ void tap_add_packet(struct ctx *c, ssize_t l2len, char *p)
   * tap_sock_reset() - Handle closing or failure of connect AF_UNIX socket
   * @c:		Execution context
   */
 -static void tap_sock_reset(struct ctx *c)
 +void tap_sock_reset(struct ctx *c)
  {
  	if (c->one_off) {
  		info("Client closed connection, exiting");
 @@ -1296,6 +1296,23 @@ static void tap_sock_tun_init(struct ctx *c)
  	epoll_ctl(c->epollfd, EPOLL_CTL_ADD, c->fd_tap, &ev);
  }
  
 +void tap_sock_update_buf(void *base, size_t size)
 +{
 +	int i;
 +
 +	pool_tap4_storage.buf = base;
 +	pool_tap4_storage.buf_size = size;
 +	pool_tap6_storage.buf = base;
 +	pool_tap6_storage.buf_size = size;
 +
 +	for (i = 0; i < TAP_SEQS; i++) {
 +		tap4_l4[i].p.buf = base;
 +		tap4_l4[i].p.buf_size = size;
 +		tap6_l4[i].p.buf = base;
 +		tap6_l4[i].p.buf_size = size;
 +	}
 +}
 +
  /**
   * tap_sock_init() - Create and set up AF_UNIX socket or tuntap file descriptor
   * @c:		Execution context
 diff --git a/tap.h b/tap.h
 index d496bd0e4b99..3b2dde41ae8d 100644
 --- a/tap.h
 +++ b/tap.h
 @@ -69,6 +69,8 @@ void tap_handler_pasta(struct ctx *c, uint32_t events,
  void tap_handler_passt(struct ctx *c, uint32_t events,
  		       const struct timespec *now);
  int tap_sock_unix_open(char *sock_path);
 +void tap_sock_reset(struct ctx *c);
 +void tap_sock_update_buf(void *base, size_t size);
  void tap_sock_init(struct ctx *c);
  void tap_flush_pools(void);
  void tap_handler(struct ctx *c, const struct timespec *now);
 diff --git a/vhost_user.c b/vhost_user.c
 new file mode 100644
 index 000000000000..4ac0a3e53499
 --- /dev/null
 +++ b/vhost_user.c
 @@ -0,0 +1,1083 @@
 +// SPDX-License-Identifier: GPL-2.0-or-later
 +
 +/* some parts from QEMU subprojects/libvhost-user/libvhost-user.c */
 +
 +#include <errno.h>
 +#include <fcntl.h>
 +#include <stdlib.h>
 +#include <stdio.h>
 +#include <stdint.h>
 +#include <stddef.h>
 +#include <string.h>
 +#include <assert.h>
 +#include <stdbool.h>
 +#include <inttypes.h>
 +#include <time.h>
 +#include <net/ethernet.h>
 +#include <netinet/in.h>
 +#include <sys/epoll.h>
 +#include <sys/eventfd.h>
 +#include <sys/mman.h>
 +#include <linux/vhost_types.h>
 +#include <linux/virtio_net.h>
 +
 +#include "util.h"
 +#include "passt.h"
 +#include "tap.h"
 +#include "vhost_user.h"
 +
 +#define VHOST_USER_VERSION 1
 +
 +/* cppcheck-suppress unusedFunction */
 +void vu_print_capabilities(void)
 +{
 +	printf("{\n");
 +	printf("  \"type\": \"net\"\n");
 +	printf("}\n");
 +	exit(EXIT_SUCCESS);
 +}
 +
 +static const char *
 +vu_request_to_string(unsigned int req)
 +{
 +	if (req < VHOST_USER_MAX) {
 +#define REQ(req) [req] = #req
 +		static const char * const vu_request_str[] = {
 +			REQ(VHOST_USER_NONE),
 +			REQ(VHOST_USER_GET_FEATURES),
 +			REQ(VHOST_USER_SET_FEATURES),
 +			REQ(VHOST_USER_SET_OWNER),
 +			REQ(VHOST_USER_RESET_OWNER),
 +			REQ(VHOST_USER_SET_MEM_TABLE),
 +			REQ(VHOST_USER_SET_LOG_BASE),
 +			REQ(VHOST_USER_SET_LOG_FD),
 +			REQ(VHOST_USER_SET_VRING_NUM),
 +			REQ(VHOST_USER_SET_VRING_ADDR),
 +			REQ(VHOST_USER_SET_VRING_BASE),
 +			REQ(VHOST_USER_GET_VRING_BASE),
 +			REQ(VHOST_USER_SET_VRING_KICK),
 +			REQ(VHOST_USER_SET_VRING_CALL),
 +			REQ(VHOST_USER_SET_VRING_ERR),
 +			REQ(VHOST_USER_GET_PROTOCOL_FEATURES),
 +			REQ(VHOST_USER_SET_PROTOCOL_FEATURES),
 +			REQ(VHOST_USER_GET_QUEUE_NUM),
 +			REQ(VHOST_USER_SET_VRING_ENABLE),
 +			REQ(VHOST_USER_SEND_RARP),
 +			REQ(VHOST_USER_NET_SET_MTU),
 +			REQ(VHOST_USER_SET_BACKEND_REQ_FD),
 +			REQ(VHOST_USER_IOTLB_MSG),
 +			REQ(VHOST_USER_SET_VRING_ENDIAN),
 +			REQ(VHOST_USER_GET_CONFIG),
 +			REQ(VHOST_USER_SET_CONFIG),
 +			REQ(VHOST_USER_POSTCOPY_ADVISE),
 +			REQ(VHOST_USER_POSTCOPY_LISTEN),
 +			REQ(VHOST_USER_POSTCOPY_END),
 +			REQ(VHOST_USER_GET_INFLIGHT_FD),
 +			REQ(VHOST_USER_SET_INFLIGHT_FD),
 +			REQ(VHOST_USER_GPU_SET_SOCKET),
 +			REQ(VHOST_USER_VRING_KICK),
 +			REQ(VHOST_USER_GET_MAX_MEM_SLOTS),
 +			REQ(VHOST_USER_ADD_MEM_REG),
 +			REQ(VHOST_USER_REM_MEM_REG),
 +			REQ(VHOST_USER_MAX),
 +		};
 +#undef REQ
 +		return vu_request_str[req];
 +	}
 +
 +	return "unknown";
 +}
 +
 +/* Translate qemu virtual address to our virtual address.  */ 
Now that this code is not in qemu, it's not very clear what either of
these "virtual addresses" is.

...
  +static void *qva_to_va(VuDev *dev, uint64_t
qemu_addr)
 +{
 +	unsigned int i;
 +
 +	/* Find matching memory region.  */
 +	for (i = 0; i < dev->nregions; i++) {
 +		const VuDevRegion *r = &dev->regions[i];
 +
 +		if ((qemu_addr >= r->qva) && (qemu_addr < (r->qva + r->size)))
{
 +			/* NOLINTNEXTLINE(performance-no-int-to-ptr) */
 +			return (void *)(qemu_addr - r->qva + r->mmap_addr +
 +					r->mmap_offset);
 +		}
 +	}
 +
 +	return NULL;
 +}
 +
 +static void
 +vmsg_close_fds(const VhostUserMsg *vmsg)
 +{
 +	int i;
 +
 +	for (i = 0; i < vmsg->fd_num; i++)
 +		close(vmsg->fds[i]);
 +}
 +
 +static void vu_remove_watch(VuDev *vdev, int fd)
 +{
 +	const struct ctx *c = (struct ctx *) ((char *)vdev -
 +					      offsetof(struct ctx, vdev));
 +
 +	epoll_ctl(c->epollfd, EPOLL_CTL_DEL, fd, NULL);
 +}
 +
 +/* Set reply payload.u64 and clear request flags and fd_num */
 +static void vmsg_set_reply_u64(struct VhostUserMsg *vmsg, uint64_t val)
 +{
 +	vmsg->hdr.flags = 0; /* defaults will be set by vu_send_reply() */
 +	vmsg->hdr.size = sizeof(vmsg->payload.u64);
 +	vmsg->payload.u64 = val;
 +	vmsg->fd_num = 0;
 +}
 +
 +static ssize_t vu_message_read_default(VuDev *dev, int conn_fd, struct VhostUserMsg
*vmsg)
 +{
 +	char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS *
 +		     sizeof(int))] = { 0 };
 +	struct iovec iov = {
 +		.iov_base = (char *)vmsg,
 +		.iov_len = VHOST_USER_HDR_SIZE,
 +	};
 +	struct msghdr msg = {
 +		.msg_iov = &iov,
 +		.msg_iovlen = 1,
 +		.msg_control = control,
 +		.msg_controllen = sizeof(control),
 +	};
 +	size_t fd_size;
 +	struct cmsghdr *cmsg;
 +	ssize_t ret, sz_payload;
 +
 +	ret = recvmsg(conn_fd, &msg, MSG_DONTWAIT);
 +	if (ret < 0) {
 +		if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)
 +			return 0;
 +		vu_panic(dev, "Error while recvmsg: %s", strerror(errno));
 +		goto out;
 +	}
 +
 +	vmsg->fd_num = 0;
 +	for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
 +	     cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 +		if (cmsg->cmsg_level == SOL_SOCKET &&
 +		    cmsg->cmsg_type == SCM_RIGHTS) {
 +			fd_size = cmsg->cmsg_len - CMSG_LEN(0);
 +			vmsg->fd_num = fd_size / sizeof(int);
 +			memcpy(vmsg->fds, CMSG_DATA(cmsg), fd_size);
 +			break;
 +		}
 +	}
 +
 +	sz_payload = vmsg->hdr.size;
 +	if ((size_t)sz_payload > sizeof(vmsg->payload)) {
 +		vu_panic(dev,
 +			 "Error: too big message request: %d, size: vmsg->size: %zd, "
 +			 "while sizeof(vmsg->payload) = %zu",
 +			 vmsg->hdr.request, sz_payload, sizeof(vmsg->payload));
 +		goto out;
 +	}
 +
 +	if (sz_payload) {
 +		do {
 +			ret = recv(conn_fd, &vmsg->payload, sz_payload, 0);
 +		} while (ret < 0 && (errno == EINTR || errno == EAGAIN));
 +
 +		if (ret < sz_payload) {
 +			vu_panic(dev, "Error while reading: %s", strerror(errno));
 +			goto out;
 +		}
 +	}
 +
 +	return 1;
 +out:
 +	vmsg_close_fds(vmsg);
 +
 +	return -ECONNRESET;
 +}
 +
 +static int vu_message_write(VuDev *dev, int conn_fd, struct VhostUserMsg *vmsg)
 +{
 +	int rc;
 +	const uint8_t *p = (uint8_t *)vmsg;
 +	char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = { 0 };
 +	struct iovec iov = {
 +		.iov_base = (char *)vmsg,
 +		.iov_len = VHOST_USER_HDR_SIZE,
 +	};
 +	struct msghdr msg = {
 +		.msg_iov = &iov,
 +		.msg_iovlen = 1,
 +		.msg_control = control,
 +	};
 +
 +	memset(control, 0, sizeof(control));
 +	assert(vmsg->fd_num <= VHOST_MEMORY_BASELINE_NREGIONS);
 +	if (vmsg->fd_num > 0) {
 +		size_t fdsize = vmsg->fd_num * sizeof(int);
 +		struct cmsghdr *cmsg;
 +
 +		msg.msg_controllen = CMSG_SPACE(fdsize);
 +		cmsg = CMSG_FIRSTHDR(&msg);
 +		cmsg->cmsg_len = CMSG_LEN(fdsize);
 +		cmsg->cmsg_level = SOL_SOCKET;
 +		cmsg->cmsg_type = SCM_RIGHTS;
 +		memcpy(CMSG_DATA(cmsg), vmsg->fds, fdsize);
 +	} else {
 +		msg.msg_controllen = 0;
 +	}
 +
 +	do {
 +		rc = sendmsg(conn_fd, &msg, 0);
 +	} while (rc < 0 && (errno == EINTR || errno == EAGAIN));
 +
 +	if (vmsg->hdr.size) {
 +		do {
 +			if (vmsg->data)
 +				rc = write(conn_fd, vmsg->data, vmsg->hdr.size);
 +			else
 +				rc = write(conn_fd, p + VHOST_USER_HDR_SIZE, vmsg->hdr.size);
 +		} while (rc < 0 && (errno == EINTR || errno == EAGAIN));
 +	}
 +
 +	if (rc <= 0) {
 +		vu_panic(dev, "Error while writing: %s", strerror(errno));
 +		return false;
 +	}
 +
 +	return true;
 +}
 +
 +static int vu_send_reply(VuDev *dev, int conn_fd, struct VhostUserMsg *msg)
 +{
 +	msg->hdr.flags &= ~VHOST_USER_VERSION_MASK;
 +	msg->hdr.flags |= VHOST_USER_VERSION;
 +	msg->hdr.flags |= VHOST_USER_REPLY_MASK;
 +
 +	return vu_message_write(dev, conn_fd, msg);
 +}
 +
 +static bool vu_get_features_exec(struct VhostUserMsg *msg)
 +{
 +	uint64_t features =
 +		1ULL << VIRTIO_F_VERSION_1 |
 +		1ULL << VIRTIO_NET_F_MRG_RXBUF |
 +		1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
 +
 +	vmsg_set_reply_u64(msg, features);
 +
 +	debug("Sending back to guest u64: 0x%016"PRIx64, msg->payload.u64);
 +
 +	return true;
 +}
 +
 +static void
 +vu_set_enable_all_rings(VuDev *vdev, bool enabled)
 +{
 +	uint16_t i;
 +
 +	for (i = 0; i < VHOST_USER_MAX_QUEUES; i++)
 +		vdev->vq[i].enable = enabled;
 +}
 +
 +static bool
 +vu_set_features_exec(VuDev *vdev, struct VhostUserMsg *msg)
 +{
 +	debug("u64: 0x%016"PRIx64, msg->payload.u64);
 +
 +	vdev->features = msg->payload.u64;
 +	if (!vu_has_feature(vdev, VIRTIO_F_VERSION_1)) {
 +		/*
 +		 * We only support devices conforming to VIRTIO 1.0 or
 +		 * later
 +		 */
 +		vu_panic(vdev, "virtio legacy devices aren't supported by passt");
 +		return false;
 +	}
 +
 +	if (!vu_has_feature(vdev, VHOST_USER_F_PROTOCOL_FEATURES))
 +		vu_set_enable_all_rings(vdev, true);
 +
 +	/* virtio-net features */
 +
 +	if (vu_has_feature(vdev, VIRTIO_F_VERSION_1) ||
 +	    vu_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF)) {
 +		vdev->hdrlen = sizeof(struct virtio_net_hdr_mrg_rxbuf);
 +	} else {
 +		vdev->hdrlen = sizeof(struct virtio_net_hdr);
 +	}
 +
 +	return false;
 +}
 +
 +static bool
 +vu_set_owner_exec(void)
 +{
 +	return false;
 +}
 +
 +static bool map_ring(VuDev *vdev, VuVirtq *vq)
 +{
 +	vq->vring.desc = qva_to_va(vdev, vq->vra.desc_user_addr);
 +	vq->vring.used = qva_to_va(vdev, vq->vra.used_user_addr);
 +	vq->vring.avail = qva_to_va(vdev, vq->vra.avail_user_addr);
 +
 +	debug("Setting virtq addresses:");
 +	debug("    vring_desc  at %p", (void *)vq->vring.desc);
 +	debug("    vring_used  at %p", (void *)vq->vring.used);
 +	debug("    vring_avail at %p", (void *)vq->vring.avail);
 +
 +	return !(vq->vring.desc && vq->vring.used &&
vq->vring.avail);
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +int vu_packet_check_range(void *buf, size_t offset, size_t len, const char *start,
 +			  const char *func, int line)
 +{
 +	VuDevRegion *dev_region;
 +
 +	for (dev_region = buf; dev_region->mmap_addr; dev_region++) {
 +		/* NOLINTNEXTLINE(performance-no-int-to-ptr) */
 +		char *m = (char *)dev_region->mmap_addr;
 +
 +		if (m <= start &&
 +		    start + offset + len < m + dev_region->mmap_offset +
 +					       dev_region->size)
 +			return 0;
 +	}
 +	if (func)
 +		trace("cannot find region, %s:%i", func, line);
 +
 +	return -1;
 +}
 +
 +/*
 + * #syscalls:passt mmap munmap
 + */
 +
 +static bool vu_set_mem_table_exec(VuDev *vdev,
 +				  struct VhostUserMsg *msg)
 +{
 +	unsigned int i;
 +	struct VhostUserMemory m = msg->payload.memory, *memory = &m;
 +
 +	for (i = 0; i < vdev->nregions; i++) {
 +		VuDevRegion *r = &vdev->regions[i];
 +		/* NOLINTNEXTLINE(performance-no-int-to-ptr) */
 +		void *mm = (void *)r->mmap_addr;
 +
 +		if (mm)
 +			munmap(mm, r->size + r->mmap_offset);
 +	}
 +	vdev->nregions = memory->nregions;
 +
 +	debug("Nregions: %u", memory->nregions);
 +	for (i = 0; i < vdev->nregions; i++) {
 +		void *mmap_addr;
 +		VhostUserMemory_region *msg_region = &memory->regions[i];
 +		VuDevRegion *dev_region = &vdev->regions[i];
 +
 +		debug("Region %d", i);
 +		debug("    guest_phys_addr: 0x%016"PRIx64,
 +		      msg_region->guest_phys_addr);
 +		debug("    memory_size:     0x%016"PRIx64,
 +		      msg_region->memory_size);
 +		debug("    userspace_addr   0x%016"PRIx64,
 +		      msg_region->userspace_addr);
 +		debug("    mmap_offset      0x%016"PRIx64,
 +		      msg_region->mmap_offset);
 +
 +		dev_region->gpa = msg_region->guest_phys_addr;
 +		dev_region->size = msg_region->memory_size;
 +		dev_region->qva = msg_region->userspace_addr;
 +		dev_region->mmap_offset = msg_region->mmap_offset;
 +
 +		/* We don't use offset argument of mmap() since the
 +		 * mapped address has to be page aligned, and we use huge
 +		 * pages.
 +		 */
 +		mmap_addr = mmap(0, dev_region->size + dev_region->mmap_offset,
 +				 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE,
 +				 msg->fds[i], 0);
 +
 +		if (mmap_addr == MAP_FAILED) {
 +			vu_panic(vdev, "region mmap error: %s", strerror(errno));
 +		} else {
 +			dev_region->mmap_addr = (uint64_t)(uintptr_t)mmap_addr;
 +			debug("    mmap_addr:       0x%016"PRIx64,
 +			      dev_region->mmap_addr);
 +		}
 +
 +		close(msg->fds[i]);
 +	}
 +
 +	for (i = 0; i < VHOST_USER_MAX_QUEUES; i++) {
 +		if (vdev->vq[i].vring.desc) {
 +			if (map_ring(vdev, &vdev->vq[i]))
 +				vu_panic(vdev, "remapping queue %d during setmemtable", i);
 +		}
 +	}
 +
 +	/* XXX */
 +	ASSERT(vdev->nregions < VHOST_USER_MAX_RAM_SLOTS - 1);
 +	vdev->regions[vdev->nregions].mmap_addr = 0; /* mark EOF for
vu_packet_check_range() */
 +
 +	tap_sock_update_buf(vdev->regions, 0);
 +
 +	return false;
 +}
 +
 +static bool vu_set_vring_num_exec(VuDev *vdev,
 +				  struct VhostUserMsg *msg)
 +{
 +	unsigned int idx = msg->payload.state.index;
 +	unsigned int num = msg->payload.state.num;
 +
 +	debug("State.index: %u", idx);
 +	debug("State.num:   %u", num);
 +	vdev->vq[idx].vring.num = num;
 +
 +	return false;
 +}
 +
 +static bool vu_set_vring_addr_exec(VuDev *vdev,
 +				   struct VhostUserMsg *msg)
 +{
 +	struct vhost_vring_addr addr = msg->payload.addr, *vra = &addr;
 +	VuVirtq *vq = &vdev->vq[vra->index];
 +
 +	debug("vhost_vring_addr:");
 +	debug("    index:  %d", vra->index);
 +	debug("    flags:  %d", vra->flags);
 +	debug("    desc_user_addr:   0x%016" PRIx64,
(uint64_t)vra->desc_user_addr);
 +	debug("    used_user_addr:   0x%016" PRIx64,
(uint64_t)vra->used_user_addr);
 +	debug("    avail_user_addr:  0x%016" PRIx64,
(uint64_t)vra->avail_user_addr);
 +	debug("    log_guest_addr:   0x%016" PRIx64,
(uint64_t)vra->log_guest_addr);
 +
 +	vq->vra = *vra;
 +	vq->vring.flags = vra->flags;
 +	vq->vring.log_guest_addr = vra->log_guest_addr;
 +
 +	if (map_ring(vdev, vq)) {
 +		vu_panic(vdev, "Invalid vring_addr message");
 +		return false;
 +	}
 +
 +	vq->used_idx = le16toh(vq->vring.used->idx);
 +
 +	if (vq->last_avail_idx != vq->used_idx) {
 +		debug("Last avail index != used index: %u != %u",
 +		      vq->last_avail_idx, vq->used_idx);
 +	}
 +
 +	return false;
 +}
 +
 +static bool vu_set_vring_base_exec(VuDev *vdev,
 +				   struct VhostUserMsg *msg)
 +{
 +	unsigned int idx = msg->payload.state.index;
 +	unsigned int num = msg->payload.state.num;
 +
 +	debug("State.index: %u", idx);
 +	debug("State.num:   %u", num);
 +	vdev->vq[idx].shadow_avail_idx = vdev->vq[idx].last_avail_idx = num;
 +
 +	return false;
 +}
 +
 +static bool vu_get_vring_base_exec(VuDev *vdev,
 +				   struct VhostUserMsg *msg)
 +{
 +	unsigned int idx = msg->payload.state.index;
 +
 +	debug("State.index: %u", idx);
 +	msg->payload.state.num = vdev->vq[idx].last_avail_idx;
 +	msg->hdr.size = sizeof(msg->payload.state);
 +
 +	vdev->vq[idx].started = false;
 +
 +	if (vdev->vq[idx].call_fd != -1) {
 +		close(vdev->vq[idx].call_fd);
 +		vdev->vq[idx].call_fd = -1;
 +	}
 +	if (vdev->vq[idx].kick_fd != -1) {
 +		vu_remove_watch(vdev,  vdev->vq[idx].kick_fd);
 +		close(vdev->vq[idx].kick_fd);
 +		vdev->vq[idx].kick_fd = -1;
 +	}
 +
 +	return true;
 +}
 +
 +static void vu_set_watch(VuDev *vdev, int fd)
 +{
 +	const struct ctx *c = (struct ctx *)
 +			      ((char *)vdev - offsetof(struct ctx, vdev));
 +	union epoll_ref ref = { .type = EPOLL_TYPE_VHOST_KICK, .fd = fd };
 +	struct epoll_event ev = { 0 };
 +
 +	ev.data.u64 = ref.u64;
 +	ev.events = EPOLLIN;
 +	epoll_ctl(c->epollfd, EPOLL_CTL_ADD, fd, &ev);
 +}
 +
 +static int vu_wait_queue(const VuVirtq *vq)
 +{
 +	eventfd_t kick_data;
 +	ssize_t rc;
 +	int status;
 +
 +	/* wait the kernel to put new entries in the queue */
 +
 +	status = fcntl(vq->kick_fd, F_GETFL);
 +	if (status == -1)
 +		return -1;
 +
 +	fcntl(vq->kick_fd, F_SETFL, status & ~O_NONBLOCK);
 +	rc =  eventfd_read(vq->kick_fd, &kick_data);
 +	fcntl(vq->kick_fd, F_SETFL, status);
 +	if (rc == -1)
 +		return -1;
 +
 +	return 0;
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +int vu_send(const struct ctx *c, const void *buf, size_t size)
 +{
 +	VuDev *vdev = (VuDev *)&c->vdev;
 +	size_t hdrlen = vdev->hdrlen;
 +	VuVirtq *vq = &vdev->vq[VHOST_USER_RX_QUEUE];
 +	VuVirtqElement elem[VIRTQUEUE_MAX_SIZE];
 +	struct iovec in_sg[VIRTQUEUE_MAX_SIZE];
 +	size_t lens[VIRTQUEUE_MAX_SIZE];
 +	size_t offset;
 +	int i, j;
 +	__virtio16 *num_buffers_ptr;
 +	int in_sg_count;
 +
 +	debug("vu_send size %zu hdrlen %zu", size, hdrlen);
 +
 +	if (!vu_queue_enabled(vq) || !vu_queue_started(vq)) {
 +		err("Got packet, but no available descriptors on RX virtq.");
 +		return 0;
 +	}
 +
 +	offset = 0;
 +	i = 0;
 +	num_buffers_ptr = NULL;
 +	in_sg_count = 0;
 +	while (offset < size) {
 +		size_t len;
 +		int total;
 +		int ret;
 +
 +		total = 0;
 +
 +		if (i == ARRAY_SIZE(elem) ||
 +		    in_sg_count == ARRAY_SIZE(in_sg)) {
 +			err("virtio-net unexpected long buffer chain");
 +			goto err;
 +		}
 +
 +		elem[i].out_num = 0;
 +		elem[i].out_sg = NULL;
 +		elem[i].in_num = ARRAY_SIZE(in_sg) - in_sg_count;
 +		elem[i].in_sg = &in_sg[in_sg_count];
 +
 +		ret = vu_queue_pop(vdev, vq, &elem[i]);
 +		if (ret < 0) {
 +			if (!vdev->broken) {
 +				if (vu_wait_queue(vq) != -1)
 +					continue;
 +			}
 +			if (i) {
 +				err("virtio-net unexpected empty queue: "
 +				    "i %d mergeable %d offset %zd, size %zd, "
 +				    "features 0x%" PRIx64,
 +				    i, vu_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF),
 +				    offset, size, vdev->features);
 +			}
 +			offset = -1;
 +			goto err;
 +		}
 +		in_sg_count += elem[i].in_num;
 +
 +		if (elem[i].in_num < 1) {
 +			err("virtio-net receive queue contains no in buffers");
 +			vu_queue_detach_element(vdev, vq, elem[i].index, 0);
 +			offset = -1;
 +			goto err;
 +		}
 +
 +		if (i == 0) {
 +			struct virtio_net_hdr hdr = {
 +				.flags = VIRTIO_NET_HDR_F_DATA_VALID,
 +				.gso_type = VIRTIO_NET_HDR_GSO_NONE,
 +			};
 +
 +			ASSERT(offset == 0);
 +			ASSERT(elem[i].in_sg[0].iov_len >= hdrlen);
 +
 +			len = iov_from_buf(elem[i].in_sg, elem[i].in_num, 0,
 +					   &hdr, sizeof(hdr));
 +
 +			num_buffers_ptr = (__virtio16 *)((char *)elem[i].in_sg[0].iov_base +
 +							 len);
 +
 +			total += hdrlen;
 +		}
 +
 +		len = iov_from_buf(elem[i].in_sg, elem[i].in_num, total, (char *)buf + offset,
 +				   size - offset);
 +
 +		total += len;
 +		offset += len;
 +
 +		/* If buffers can't be merged, at this point we
 +		 * must have consumed the complete packet.
 +		 * Otherwise, drop it.
 +		 */
 +		if (!vu_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF) && offset < size) {
 +			vu_queue_unpop(vdev, vq, elem[i].index, total);
 +			goto err;
 +		}
 +
 +	lens[i] = total;
 +		i++;
 +	}
 +
 +	if (num_buffers_ptr && vu_has_feature(vdev, VIRTIO_NET_F_MRG_RXBUF))
 +		*num_buffers_ptr = htole16(i);
 +
 +	for (j = 0; j < i; j++) {
 +		debug("filling total %zd idx %d", lens[j], j);
 +		vu_queue_fill(vdev, vq, &elem[j], lens[j], j);
 +	}
 +
 +	vu_queue_flush(vdev, vq, i);
 +	vu_queue_notify(vdev, vq);
 +
 +	debug("sent %zu", offset);
 +
 +	return offset;
 +err:
 +	for (j = 0; j < i; j++)
 +		vu_queue_detach_element(vdev, vq, elem[j].index, lens[j]);
 +
 +	return offset;
 +}
 +
 +static void vu_handle_tx(VuDev *vdev, int index)
 +{
 +	struct ctx *c = (struct ctx *) ((char *)vdev - offsetof(struct ctx, vdev));
 +	VuVirtq *vq = &vdev->vq[index];
 +	int hdrlen = vdev->hdrlen;
 +	struct timespec now;
 +	VuVirtqElement  elem[VIRTQUEUE_MAX_SIZE];
 +	struct iovec out_sg[VIRTQUEUE_MAX_SIZE];
 +	int out_sg_count;
 +
 +	int count;
 +
 +	if (index % 2 != VHOST_USER_TX_QUEUE) {
 +		debug("index %d is not an TX queue", index);
 +		return;
 +	}
 +
 +	clock_gettime(CLOCK_MONOTONIC, &now);
 +
 +	tap_flush_pools();
 +
 +	count = 0;
 +	out_sg_count = 0;
 +	while (1) {
 +		int ret;
 +
 +		ASSERT(index == VHOST_USER_TX_QUEUE);
 +
 +		elem[count].out_num = 1;
 +		elem[count].out_sg = &out_sg[out_sg_count];
 +		elem[count].in_num = 0;
 +		elem[count].in_sg = NULL;
 +		ret = vu_queue_pop(vdev, vq, &elem[count]);
 +		if (ret < 0)
 +			break;
 +		out_sg_count += elem[count].out_num;
 +
 +		if (elem[count].out_num < 1) {
 +			debug("virtio-net header not in first element");
 +			break;
 +		}
 +		ASSERT(elem[count].out_num == 1);
 +
 +		tap_add_packet(c, elem[count].out_sg[0].iov_len - hdrlen,
 +			       (char *)elem[count].out_sg[0].iov_base + hdrlen);
 +		count++;
 +	}
 +	tap_handler(c, &now);
 +
 +	if (count) {
 +		int i;
 +
 +		for (i = 0; i < count; i++)
 +			vu_queue_fill(vdev, vq, &elem[i], 0, i);
 +		vu_queue_flush(vdev, vq, count);
 +		vu_queue_notify(vdev, vq);
 +	}
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +void vu_kick_cb(struct ctx *c, union epoll_ref ref)
 +{
 +	VuDev *vdev = &c->vdev;
 +	eventfd_t kick_data;
 +	ssize_t rc;
 +	int idx;
 +
 +	for (idx = 0; idx < VHOST_USER_MAX_QUEUES; idx++)
 +		if (c->vdev.vq[idx].kick_fd == ref.fd)
 +			break;
 +
 +	if (idx == VHOST_USER_MAX_QUEUES)
 +		return;
 +
 +	rc =  eventfd_read(ref.fd, &kick_data);
 +	if (rc == -1) {
 +		vu_panic(vdev, "kick eventfd_read(): %s", strerror(errno));
 +		vu_remove_watch(vdev, ref.fd);
 +	} else {
 +		debug("Got kick_data: %016"PRIx64" idx:%d",
 +		      kick_data, idx);
 +		if (idx % 2 == VHOST_USER_TX_QUEUE)
 +			vu_handle_tx(vdev, idx);
 +	}
 +}
 +
 +static bool vu_check_queue_msg_file(VuDev *vdev, struct VhostUserMsg *msg)
 +{
 +	int idx = msg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
 +	bool nofd = msg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
 +
 +	if (idx >= VHOST_USER_MAX_QUEUES) {
 +		vmsg_close_fds(msg);
 +		vu_panic(vdev, "Invalid queue index: %u", idx);
 +		return false;
 +	}
 +
 +	if (nofd) {
 +		vmsg_close_fds(msg);
 +		return true;
 +	}
 +
 +	if (msg->fd_num != 1) {
 +		vmsg_close_fds(msg);
 +		vu_panic(vdev, "Invalid fds in request: %d", msg->hdr.request);
 +		return false;
 +	}
 +
 +	return true;
 +}
 +
 +static bool vu_set_vring_kick_exec(VuDev *vdev,
 +				   struct VhostUserMsg *msg)
 +{
 +	int idx = msg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
 +	bool nofd = msg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
 +
 +	debug("u64: 0x%016"PRIx64, msg->payload.u64);
 +
 +	if (!vu_check_queue_msg_file(vdev, msg))
 +		return false;
 +
 +	if (vdev->vq[idx].kick_fd != -1) {
 +		vu_remove_watch(vdev, vdev->vq[idx].kick_fd);
 +		close(vdev->vq[idx].kick_fd);
 +		vdev->vq[idx].kick_fd = -1;
 +	}
 +
 +	/* cppcheck-suppress redundantAssignment */
 +	vdev->vq[idx].kick_fd = nofd ? -1 : msg->fds[0];
 +	debug("Got kick_fd: %d for vq: %d", vdev->vq[idx].kick_fd, idx);
 +
 +	vdev->vq[idx].started = true;
 +
 +	if (vdev->vq[idx].kick_fd != -1 && idx % 2 == VHOST_USER_TX_QUEUE) {
 +		vu_set_watch(vdev, vdev->vq[idx].kick_fd);
 +		debug("Waiting for kicks on fd: %d for vq: %d",
 +		      vdev->vq[idx].kick_fd, idx);
 +	}
 +
 +	return false;
 +}
 +
 +static bool vu_set_vring_call_exec(VuDev *vdev,
 +				   struct VhostUserMsg *msg)
 +{
 +	int idx = msg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
 +	bool nofd = msg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
 +
 +	debug("u64: 0x%016"PRIx64, msg->payload.u64);
 +
 +	if (!vu_check_queue_msg_file(vdev, msg))
 +		return false;
 +
 +	if (vdev->vq[idx].call_fd != -1) {
 +		close(vdev->vq[idx].call_fd);
 +		vdev->vq[idx].call_fd = -1;
 +	}
 +
 +	/* cppcheck-suppress redundantAssignment */
 +	vdev->vq[idx].call_fd = nofd ? -1 : msg->fds[0];
 +
 +	/* in case of I/O hang after reconnecting */
 +	if (vdev->vq[idx].call_fd != -1)
 +		eventfd_write(msg->fds[0], 1);
 +
 +	debug("Got call_fd: %d for vq: %d", vdev->vq[idx].call_fd, idx);
 +
 +	return false;
 +}
 +
 +static bool vu_set_vring_err_exec(VuDev *vdev,
 +				  struct VhostUserMsg *msg)
 +{
 +	int idx = msg->payload.u64 & VHOST_USER_VRING_IDX_MASK;
 +	bool nofd = msg->payload.u64 & VHOST_USER_VRING_NOFD_MASK;
 +
 +	debug("u64: 0x%016"PRIx64, msg->payload.u64);
 +
 +	if (!vu_check_queue_msg_file(vdev, msg))
 +		return false;
 +
 +	if (vdev->vq[idx].err_fd != -1) {
 +		close(vdev->vq[idx].err_fd);
 +		vdev->vq[idx].err_fd = -1;
 +	}
 +
 +	/* cppcheck-suppress redundantAssignment */
 +	vdev->vq[idx].err_fd = nofd ? -1 : msg->fds[0];
 +
 +	return false;
 +}
 +
 +static bool vu_get_protocol_features_exec(struct VhostUserMsg *msg)
 +{
 +	uint64_t features = 1ULL << VHOST_USER_PROTOCOL_F_REPLY_ACK;
 +
 +	vmsg_set_reply_u64(msg, features);
 +
 +	return true;
 +}
 +
 +static bool vu_set_protocol_features_exec(VuDev *vdev, struct VhostUserMsg *msg)
 +{
 +	uint64_t features = msg->payload.u64;
 +
 +	debug("u64: 0x%016"PRIx64, features);
 +
 +	vdev->protocol_features = msg->payload.u64;
 +
 +	if (vu_has_protocol_feature(vdev,
 +				    VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS) &&
 +	    (!vu_has_protocol_feature(vdev, VHOST_USER_PROTOCOL_F_BACKEND_REQ) ||
 +	     !vu_has_protocol_feature(vdev, VHOST_USER_PROTOCOL_F_REPLY_ACK))) {
 +		/*
 +		 * The use case for using messages for kick/call is simulation, to make
 +		 * the kick and call synchronous. To actually get that behaviour, both
 +		 * of the other features are required.
 +		 * Theoretically, one could use only kick messages, or do them without
 +		 * having F_REPLY_ACK, but too many (possibly pending) messages on the
 +		 * socket will eventually cause the master to hang, to avoid this in
 +		 * scenarios where not desired enforce that the settings are in a way
 +		 * that actually enables the simulation case.
 +		 */
 +		vu_panic(vdev,
 +			 "F_IN_BAND_NOTIFICATIONS requires F_BACKEND_REQ && F_REPLY_ACK");
 +		return false;
 +	}
 +
 +	return false;
 +}
 +
 +
 +static bool vu_get_queue_num_exec(struct VhostUserMsg *msg)
 +{
 +	vmsg_set_reply_u64(msg, VHOST_USER_MAX_QUEUES);
 +	return true;
 +}
 +
 +static bool vu_set_vring_enable_exec(VuDev *vdev, struct VhostUserMsg *msg)
 +{
 +	unsigned int idx = msg->payload.state.index;
 +	unsigned int enable = msg->payload.state.num;
 +
 +	debug("State.index:  %u", idx);
 +	debug("State.enable: %u", enable);
 +
 +	if (idx >= VHOST_USER_MAX_QUEUES) {
 +		vu_panic(vdev, "Invalid vring_enable index: %u", idx);
 +		return false;
 +	}
 +
 +	vdev->vq[idx].enable = enable;
 +	return false;
 +}
 +
 +/* cppcheck-suppress unusedFunction */
 +void vu_init(struct ctx *c)
 +{
 +	int i;
 +
 +	c->vdev.hdrlen = 0;
 +	for (i = 0; i < VHOST_USER_MAX_QUEUES; i++)
 +		c->vdev.vq[i] = (VuVirtq){
 +			.call_fd = -1,
 +			.kick_fd = -1,
 +			.err_fd = -1,
 +			.notification = true,
 +		};
 +}
 +
 +static void vu_cleanup(VuDev *vdev)
 +{
 +	unsigned int i;
 +
 +	for (i = 0; i < VHOST_USER_MAX_QUEUES; i++) {
 +		VuVirtq *vq = &vdev->vq[i];
 +
 +		vq->started = false;
 +		vq->notification = true;
 +
 +		if (vq->call_fd != -1) {
 +			close(vq->call_fd);
 +			vq->call_fd = -1;
 +		}
 +		if (vq->err_fd != -1) {
 +			close(vq->err_fd);
 +			vq->err_fd = -1;
 +		}
 +		if (vq->kick_fd != -1) {
 +			vu_remove_watch(vdev,  vq->kick_fd);
 +			close(vq->kick_fd);
 +			vq->kick_fd = -1;
 +		}
 +
 +		vq->vring.desc = 0;
 +		vq->vring.used = 0;
 +		vq->vring.avail = 0;
 +	}
 +	vdev->hdrlen = 0;
 +
 +	for (i = 0; i < vdev->nregions; i++) {
 +		const VuDevRegion *r = &vdev->regions[i];
 +		/* NOLINTNEXTLINE(performance-no-int-to-ptr) */
 +		void *m = (void *)r->mmap_addr;
 +
 +		if (m)
 +			munmap(m, r->size + r->mmap_offset);
 +	}
 +	vdev->nregions = 0;
 +}
 +
 +/**
 + * tap_handler_vu() - Packet handler for vhost-user
 + * @c:		Execution context
 + * @events:	epoll events
 + */
 +/* cppcheck-suppress unusedFunction */
 +void tap_handler_vu(struct ctx *c, uint32_t events)
 +{
 +	VuDev *dev = &c->vdev;
 +	struct VhostUserMsg msg = { 0 };
 +	bool need_reply, reply_requested;
 +	int ret;
 +
 +	if (events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)) {
 +		tap_sock_reset(c);
 +		return;
 +	}
 +
 +
 +	ret = vu_message_read_default(dev, c->fd_tap, &msg);
 +	if (ret <= 0) {
 +		if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)
 +			tap_sock_reset(c);
 +		return;
 +	}
 +	debug("================ Vhost user message ================");
 +	debug("Request: %s (%d)", vu_request_to_string(msg.hdr.request),
 +		msg.hdr.request);
 +	debug("Flags:   0x%x", msg.hdr.flags);
 +	debug("Size:    %u", msg.hdr.size);
 +
 +	need_reply = msg.hdr.flags & VHOST_USER_NEED_REPLY_MASK;
 +	switch (msg.hdr.request) {
 +	case VHOST_USER_GET_FEATURES:
 +		reply_requested = vu_get_features_exec(&msg);
 +		break;
 +	case VHOST_USER_SET_FEATURES:
 +		reply_requested = vu_set_features_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_GET_PROTOCOL_FEATURES:
 +		reply_requested = vu_get_protocol_features_exec(&msg);
 +		break;
 +	case VHOST_USER_SET_PROTOCOL_FEATURES:
 +		reply_requested = vu_set_protocol_features_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_GET_QUEUE_NUM:
 +		reply_requested = vu_get_queue_num_exec(&msg);
 +		break;
 +	case VHOST_USER_SET_OWNER:
 +		reply_requested = vu_set_owner_exec();
 +		break;
 +	case VHOST_USER_SET_MEM_TABLE:
 +		reply_requested = vu_set_mem_table_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_SET_VRING_NUM:
 +		reply_requested = vu_set_vring_num_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_SET_VRING_ADDR:
 +		reply_requested = vu_set_vring_addr_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_SET_VRING_BASE:
 +		reply_requested = vu_set_vring_base_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_GET_VRING_BASE:
 +		reply_requested = vu_get_vring_base_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_SET_VRING_KICK:
 +		reply_requested = vu_set_vring_kick_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_SET_VRING_CALL:
 +		reply_requested = vu_set_vring_call_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_SET_VRING_ERR:
 +		reply_requested = vu_set_vring_err_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_SET_VRING_ENABLE:
 +		reply_requested = vu_set_vring_enable_exec(dev, &msg);
 +		break;
 +	case VHOST_USER_NONE:
 +		vu_cleanup(dev);
 +		return;
 +	default:
 +		vu_panic(dev, "Unhandled request: %d", msg.hdr.request);
 +		return;
 +	}
 +
 +	if (!reply_requested && need_reply) {
 +		msg.payload.u64 = 0;
 +		msg.hdr.flags = 0;
 +		msg.hdr.size = sizeof(msg.payload.u64);
 +		msg.fd_num = 0;
 +		reply_requested = true;
 +	}
 +
 +	if (reply_requested)
 +		vu_send_reply(dev, c->fd_tap, &msg);
 +	free(msg.data);
 +}
 diff --git a/vhost_user.h b/vhost_user.h
 new file mode 100644
 index 000000000000..c6edc49a3bb9
 --- /dev/null
 +++ b/vhost_user.h
 @@ -0,0 +1,137 @@
 +// SPDX-License-Identifier: GPL-2.0-or-later
 +
 +/* some parts from subprojects/libvhost-user/libvhost-user.h */
 +
 +#ifndef VHOST_USER_H
 +#define VHOST_USER_H
 +
 +#include "virtio.h"
 +#include "iov.h"
 +
 +#define VHOST_USER_F_PROTOCOL_FEATURES 30
 +
 +#define VHOST_MEMORY_BASELINE_NREGIONS 8
 +
 +enum vhost_user_protocol_feature {
 +	VHOST_USER_PROTOCOL_F_MQ = 0,
 +	VHOST_USER_PROTOCOL_F_LOG_SHMFD = 1,
 +	VHOST_USER_PROTOCOL_F_RARP = 2,
 +	VHOST_USER_PROTOCOL_F_REPLY_ACK = 3,
 +	VHOST_USER_PROTOCOL_F_NET_MTU = 4,
 +	VHOST_USER_PROTOCOL_F_BACKEND_REQ = 5,
 +	VHOST_USER_PROTOCOL_F_CROSS_ENDIAN = 6,
 +	VHOST_USER_PROTOCOL_F_CRYPTO_SESSION = 7,
 +	VHOST_USER_PROTOCOL_F_PAGEFAULT = 8,
 +	VHOST_USER_PROTOCOL_F_CONFIG = 9,
 +	VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD = 10,
 +	VHOST_USER_PROTOCOL_F_HOST_NOTIFIER = 11,
 +	VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD = 12,
 +	VHOST_USER_PROTOCOL_F_INBAND_NOTIFICATIONS = 14,
 +	VHOST_USER_PROTOCOL_F_CONFIGURE_MEM_SLOTS = 15,
 +
 +	VHOST_USER_PROTOCOL_F_MAX
 +};
 +
 +enum vhost_user_request {
 +	VHOST_USER_NONE = 0,
 +	VHOST_USER_GET_FEATURES = 1,
 +	VHOST_USER_SET_FEATURES = 2,
 +	VHOST_USER_SET_OWNER = 3,
 +	VHOST_USER_RESET_OWNER = 4,
 +	VHOST_USER_SET_MEM_TABLE = 5,
 +	VHOST_USER_SET_LOG_BASE = 6,
 +	VHOST_USER_SET_LOG_FD = 7,
 +	VHOST_USER_SET_VRING_NUM = 8,
 +	VHOST_USER_SET_VRING_ADDR = 9,
 +	VHOST_USER_SET_VRING_BASE = 10,
 +	VHOST_USER_GET_VRING_BASE = 11,
 +	VHOST_USER_SET_VRING_KICK = 12,
 +	VHOST_USER_SET_VRING_CALL = 13,
 +	VHOST_USER_SET_VRING_ERR = 14,
 +	VHOST_USER_GET_PROTOCOL_FEATURES = 15,
 +	VHOST_USER_SET_PROTOCOL_FEATURES = 16,
 +	VHOST_USER_GET_QUEUE_NUM = 17,
 +	VHOST_USER_SET_VRING_ENABLE = 18,
 +	VHOST_USER_SEND_RARP = 19,
 +	VHOST_USER_NET_SET_MTU = 20,
 +	VHOST_USER_SET_BACKEND_REQ_FD = 21,
 +	VHOST_USER_IOTLB_MSG = 22,
 +	VHOST_USER_SET_VRING_ENDIAN = 23,
 +	VHOST_USER_GET_CONFIG = 24,
 +	VHOST_USER_SET_CONFIG = 25,
 +	VHOST_USER_CREATE_CRYPTO_SESSION = 26,
 +	VHOST_USER_CLOSE_CRYPTO_SESSION = 27,
 +	VHOST_USER_POSTCOPY_ADVISE  = 28,
 +	VHOST_USER_POSTCOPY_LISTEN  = 29,
 +	VHOST_USER_POSTCOPY_END     = 30,
 +	VHOST_USER_GET_INFLIGHT_FD = 31,
 +	VHOST_USER_SET_INFLIGHT_FD = 32,
 +	VHOST_USER_GPU_SET_SOCKET = 33,
 +	VHOST_USER_VRING_KICK = 35,
 +	VHOST_USER_GET_MAX_MEM_SLOTS = 36,
 +	VHOST_USER_ADD_MEM_REG = 37,
 +	VHOST_USER_REM_MEM_REG = 38,
 +	VHOST_USER_MAX
 +};
 +
 +typedef struct {
 +	enum vhost_user_request request;
 +
 +#define VHOST_USER_VERSION_MASK     0x3
 +#define VHOST_USER_REPLY_MASK       (0x1 << 2)
 +#define VHOST_USER_NEED_REPLY_MASK  (0x1 << 3)
 +	uint32_t flags;
 +	uint32_t size; /* the following payload size */
 +} __attribute__ ((__packed__)) vhost_user_header;
 +
 +typedef struct VhostUserMemory_region {
 +	uint64_t guest_phys_addr;
 +	uint64_t memory_size;
 +	uint64_t userspace_addr;
 +	uint64_t mmap_offset;
 +} VhostUserMemory_region;
 +
 +struct VhostUserMemory {
 +	uint32_t nregions;
 +	uint32_t padding;
 +	struct VhostUserMemory_region regions[VHOST_MEMORY_BASELINE_NREGIONS];
 +};
 +
 +typedef union {
 +#define VHOST_USER_VRING_IDX_MASK   0xff
 +#define VHOST_USER_VRING_NOFD_MASK  (0x1 << 8)
 +	uint64_t u64;
 +	struct vhost_vring_state state;
 +	struct vhost_vring_addr addr;
 +	struct VhostUserMemory memory;
 +} vhost_user_payload;
 +
 +typedef struct VhostUserMsg {
 +	vhost_user_header hdr;
 +	vhost_user_payload payload;
 +
 +	int fds[VHOST_MEMORY_BASELINE_NREGIONS];
 +	int fd_num;
 +	uint8_t *data;
 +} __attribute__ ((__packed__)) VhostUserMsg;
 +#define VHOST_USER_HDR_SIZE sizeof(vhost_user_header)
 +
 +#define VHOST_USER_RX_QUEUE 0
 +#define VHOST_USER_TX_QUEUE 1
 +
 +static inline bool vu_queue_enabled(const VuVirtq *vq)
 +{
 +	return vq->enable;
 +}
 +
 +static inline bool vu_queue_started(const VuVirtq *vq)
 +{
 +	return vq->started;
 +}
 +
 +int vu_send(const struct ctx *c, const void *buf, size_t size);
 +void vu_print_capabilities(void);
 +void vu_init(struct ctx *c);
 +void vu_kick_cb(struct ctx *c, union epoll_ref ref);
 +void tap_handler_vu(struct ctx *c, uint32_t events);
 +#endif /* VHOST_USER_H */
 diff --git a/virtio.c b/virtio.c
 index 50ec8b5119ed..5d58e56204b3 100644
 --- a/virtio.c
 +++ b/virtio.c
 @@ -169,7 +169,6 @@ static bool vring_notify(const VuDev *dev, VuVirtq *vq)
  	return !v || vring_need_event(vring_get_used_event(vq), new, old);
  }
  
 -/* cppcheck-suppress unusedFunction */
  void vu_queue_notify(VuDev *dev, VuVirtq *vq)
  {
  	if (dev->broken || !vq->vring.avail)
 @@ -313,7 +312,6 @@ vu_queue_map_desc(VuDev *dev, VuVirtq *vq, unsigned int idx,
  	return 0;
  }
  
 -/* cppcheck-suppress unusedFunction */
  int vu_queue_pop(VuDev *dev, VuVirtq *vq, VuVirtqElement *elem)
  {
  	unsigned int head;
 @@ -363,7 +361,6 @@ void vu_queue_detach_element(VuDev *dev, VuVirtq *vq,
  	/* unmap, when DMA support is added */
  }
  
 -/* cppcheck-suppress unusedFunction */
  void vu_queue_unpop(VuDev *dev, VuVirtq *vq, unsigned int index, size_t len)
  {
  	vq->last_avail_idx--;
 diff --git a/virtio.h b/virtio.h
 index 61398bb432bc..f4a9f0c23804 100644
 --- a/virtio.h
 +++ b/virtio.h
 @@ -100,7 +100,6 @@ static inline bool vu_has_feature(const VuDev *vdev, unsigned int
fbit)
  	return has_feature(vdev->features, fbit);
  }
  
 -/* cppcheck-suppress unusedFunction */
  static inline bool vu_has_protocol_feature(const VuDev *vdev, unsigned int fbit)
  {
  	return has_feature(vdev->protocol_features, fbit); 
-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson

On Fri, Jun 21, 2024 at 04:56:39PM +0200, Laurent Vivier wrote:
...
  Add a function that count how many buffers from a
given
 iovec list we need to contain a given number of bytes.
 It also provides how many bytes are used in the last
 buffer if it is not fully filled. 
Isn't this equivalent to the iov_skip_bytes() function we already have?

...
  
 Signed-off-by: Laurent Vivier <lvivier(a)redhat.com>
 ---
  iov.c | 35 +++++++++++++++++++++++++++++++++++
  iov.h |  2 ++
  2 files changed, 37 insertions(+)
 
 diff --git a/iov.c b/iov.c
 index 3741db21790f..793788b5d2bc 100644
 --- a/iov.c
 +++ b/iov.c
 @@ -155,3 +155,38 @@ size_t iov_size(const struct iovec *iov, size_t iov_cnt)
  
  	return len;
  }
 +
 +/**
 + * iov_count - Calculate the number of I/O vectors and the size of
 + *             the last one to store a given number of bytes.
 + *
 + * @iov:       Pointer to the array of struct iovec describing the
 + *             scatter/gather I/O vector.
 + * @iov_cnt:   Number of elements in the iov array.
 + * @size:      number of bytes we need to store in iovec
 + * @last_iov_length: output parameter, length used in the last iovec
 + * 		if return value is 0, this output parameter is
 + * 		undefined.
 + *
 + * Returns:	The number of iovec needed to store @size bytes.
 + */
 +/* cppcheck-suppress unusedFunction */
 +size_t iov_count(const struct iovec *iov, size_t iov_cnt,
 +                 size_t size, size_t *last_iov_length)
 +{
 +	size_t n = 0;
 +
 +	while (size && n < iov_cnt) {
 +		if (size <= iov[n].iov_len) {
 +			*last_iov_length = size;
 +			return n + 1;
 +		}
 +		size -= iov[n].iov_len;
 +		n++;
 +	}
 +
 +	if (n > 0)
 +		*last_iov_length = iov[n - 1].iov_len;
 +
 +	return n;
 +}
 diff --git a/iov.h b/iov.h
 index a9e1722713b3..0fa456d7051b 100644
 --- a/iov.h
 +++ b/iov.h
 @@ -28,4 +28,6 @@ size_t iov_from_buf(const struct iovec *iov, size_t iov_cnt,
  size_t iov_to_buf(const struct iovec *iov, size_t iov_cnt,
                    size_t offset, void *buf, size_t bytes);
  size_t iov_size(const struct iovec *iov, size_t iov_cnt);
 +size_t iov_count(const struct iovec *iov, size_t iov_cnt,
 +		 size_t size, size_t *last_iov_length);
  #endif /* IOVEC_H */ 
-- 
David Gibson (he or they)	| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you, not the other way
				| around.
http://www.ozlabs.org/~dgibson