- dev - passt

[PATCH 0/7] vhost-user,tcp: Handle multiple iovec entries per virtqueue element
by Laurent Vivier 25 Mar '26

25 Mar '26

This is the TCP counterpart to the UDP multi-iov series. It converts the TCP vhost-user receive path from direct pointer arithmetic (via vu_eth(), vu_ip(), etc.) to the iov_tail abstraction, removing the assumption that all headers reside in a single contiguous buffer. With this series applied, the TCP path correctly handles virtio-net drivers that provide multiple buffers per virtqueue element (e.g. iPXE provides the vnet header in the first buffer and the frame payload in a second one), matching the support already present in the UDP path. Based-on: 20260323143151.538673-1-lvivier(a)redhat.com Laurent Vivier (7): tcp: pass ipv4h checksum, not a pointer to the checksum tcp: use iov_tail to access headers in tcp_fill_headers() tcp_vu: Use iov_tail helpers to build headers in tcp_vu_prepare() tcp_vu: Support multibuffer frames in tcp_vu_sock_recv() tcp: Use iov_tail to access headers in tcp_prepare_flags() iov: introduce iov_memcopy() tcp_vu: Use iov_tail helpers to build headers in tcp_vu_send_flag() iov.c | 45 +++++++ iov.h | 2 + tcp.c | 180 ++++++++++++++----------- tcp_buf.c | 34 ++--- tcp_internal.h | 9 +- tcp_vu.c | 354 ++++++++++++++++++++++++++++--------------------- vu_common.h | 20 --- 7 files changed, 368 insertions(+), 276 deletions(-) -- 2.53.0

2 14

[PATCH v3 03/25] serialise: Split functions user for serialisation from util.c
by David Gibson 25 Mar '26

25 Mar '26

The read_all_buf() and write_all_buf() functions in util.c are primarily used for serialising data structures to a stream during migraiton. We're going to have further use for such serialisation when we add dynamic configuration updates, where we'll want to share the code with the client program. To make that easier move the functions into a new serialise.c file, and rename thematically. While we're there add some macros for the common idiom of sending all of a given variable using sizeof(). Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- Makefile | 11 ++++--- flow.c | 1 + migrate.c | 1 + pcap.c | 1 + serialise.c | 88 +++++++++++++++++++++++++++++++++++++++++++++++++++++ serialise.h | 14 +++++++++ tcp.c | 1 + util.c | 70 +----------------------------------------- util.h | 2 -- 9 files changed, 113 insertions(+), 76 deletions(-) create mode 100644 serialise.c create mode 100644 serialise.h diff --git a/Makefile b/Makefile index 513dc6c6..5b6891d7 100644 --- a/Makefile +++ b/Makefile @@ -40,8 +40,8 @@ FLAGS += -DDUAL_STACK_SOCKETS=$(DUAL_STACK_SOCKETS) PASST_SRCS = arch.c arp.c checksum.c conf.c dhcp.c dhcpv6.c epoll_ctl.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 migrate.c packet.c passt.c pasta.c pcap.c \ - pif.c repair.c tap.c tcp.c tcp_buf.c tcp_splice.c tcp_vu.c udp.c \ - udp_flow.c udp_vu.c util.c vhost_user.c virtio.c vu_common.c + pif.c repair.c serialise.c tap.c tcp.c tcp_buf.c tcp_splice.c tcp_vu.c \ + udp.c udp_flow.c udp_vu.c util.c vhost_user.c virtio.c vu_common.c QRAP_SRCS = qrap.c PASST_REPAIR_SRCS = passt-repair.c SRCS = $(PASST_SRCS) $(QRAP_SRCS) $(PASST_REPAIR_SRCS) @@ -51,9 +51,10 @@ MANPAGES = passt.1 pasta.1 qrap.1 passt-repair.1 PASST_HEADERS = arch.h arp.h checksum.h conf.h dhcp.h dhcpv6.h epoll_ctl.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 migrate.h ndp.h netlink.h packet.h \ - passt.h pasta.h pcap.h pif.h repair.h siphash.h tap.h tcp.h tcp_buf.h \ - tcp_conn.h tcp_internal.h tcp_splice.h tcp_vu.h udp.h udp_flow.h \ - udp_internal.h udp_vu.h util.h vhost_user.h virtio.h vu_common.h + passt.h pasta.h pcap.h pif.h repair.h serialise.h siphash.h tap.h tcp.h \ + tcp_buf.h tcp_conn.h tcp_internal.h tcp_splice.h tcp_vu.h udp.h \ + udp_flow.h udp_internal.h udp_vu.h util.h vhost_user.h virtio.h \ + vu_common.h HEADERS = $(PASST_HEADERS) seccomp.h C := \#include <sys/random.h>\nint main(){int a=getrandom(0, 0, 0);} diff --git a/flow.c b/flow.c index 4282da2e..25a6f1a3 100644 --- a/flow.c +++ b/flow.c @@ -21,6 +21,7 @@ #include "flow_table.h" #include "repair.h" #include "epoll_ctl.h" +#include "serialise.h" const char *flow_state_str[] = { [FLOW_STATE_FREE] = "FREE", diff --git a/migrate.c b/migrate.c index 1e8858a3..8937b85f 100644 --- a/migrate.c +++ b/migrate.c @@ -24,6 +24,7 @@ #include "migrate.h" #include "repair.h" +#include "serialise.h" /* Magic identifier for migration data */ #define MIGRATE_MAGIC 0xB1BB1D1B0BB1D1B0 diff --git a/pcap.c b/pcap.c index 54fba5c4..a026f17e 100644 --- a/pcap.c +++ b/pcap.c @@ -34,6 +34,7 @@ #include "pcap.h" #include "iov.h" #include "tap.h" +#include "serialise.h" #define PCAP_VERSION_MINOR 4 diff --git a/serialise.c b/serialise.c new file mode 100644 index 00000000..f162eeb6 --- /dev/null +++ b/serialise.c @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +/* PASST - Plug A Simple Socket Transport + * for qemu/UNIX domain socket mode + * + * PASTA - Pack A Subtle Tap Abstraction + * for network namespace/tap device mode + * + * serialise.c - Serialisation of data structures over bytestreams + * + * Copyright Red Hat + * Author: David Gibson <david(a)gibson.dropbear.id.au> + */ + +#include <assert.h> +#include <errno.h> +#include <unistd.h> + +#include "serialise.h" + +/** + * read_all_buf() - Fill a whole buffer from a file descriptor + * @fd: File descriptor + * @buf: Pointer to base of buffer + * @len: Length of buffer + * + * Return: 0 on success, -1 on error (with errno set) + * + * #syscalls read + */ +int read_all_buf(int fd, void *buf, size_t len) +{ + size_t left = len; + char *p = buf; + + while (left) { + ssize_t rc; + + assert(left <= len); + + do + rc = read(fd, p, left); + while ((rc < 0) && errno == EINTR); + + if (rc < 0) + return -1; + + if (rc == 0) { + errno = ENODATA; + return -1; + } + + p += rc; + left -= rc; + } + return 0; +} + +/** + * write_all_buf() - write all of a buffer to an fd + * @fd: File descriptor + * @buf: Pointer to base of buffer + * @len: Length of buffer + * + * Return: 0 on success, -1 on error (with errno set) + * + * #syscalls write + */ +int write_all_buf(int fd, const void *buf, size_t len) +{ + const char *p = buf; + size_t left = len; + + while (left) { + ssize_t rc; + + do + rc = write(fd, p, left); + while ((rc < 0) && errno == EINTR); + + if (rc < 0) + return -1; + + p += rc; + left -= rc; + } + return 0; +} diff --git a/serialise.h b/serialise.h new file mode 100644 index 00000000..92a63e6b --- /dev/null +++ b/serialise.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright Red Hat + * Author: David Gibson <david(a)gibson.dropbear.id.au> + */ + +#ifndef SERIALISE_H +#define SERIALISE_H + +#include <stddef.h> + +int read_all_buf(int fd, void *buf, size_t len); +int write_all_buf(int fd, const void *buf, size_t len); + +#endif /* _SERIALISE_H */ diff --git a/tcp.c b/tcp.c index b1458624..8ea9be84 100644 --- a/tcp.c +++ b/tcp.c @@ -308,6 +308,7 @@ #include "flow.h" #include "repair.h" #include "linux_dep.h" +#include "serialise.h" #include "flow_table.h" #include "tcp_internal.h" diff --git a/util.c b/util.c index 22318c00..faa2c6a4 100644 --- a/util.c +++ b/util.c @@ -37,6 +37,7 @@ #include "pcap.h" #include "epoll_ctl.h" #include "pasta.h" +#include "serialise.h" #ifdef HAS_GETRANDOM #include <sys/random.h> #endif @@ -799,37 +800,6 @@ int do_clone(int (*fn)(void *), char *stack_area, size_t stack_size, int flags, #endif } -/** - * write_all_buf() - write all of a buffer to an fd - * @fd: File descriptor - * @buf: Pointer to base of buffer - * @len: Length of buffer - * - * Return: 0 on success, -1 on error (with errno set) - * - * #syscalls write - */ -int write_all_buf(int fd, const void *buf, size_t len) -{ - const char *p = buf; - size_t left = len; - - while (left) { - ssize_t rc; - - do - rc = write(fd, p, left); - while ((rc < 0) && errno == EINTR); - - if (rc < 0) - return -1; - - p += rc; - left -= rc; - } - return 0; -} - /** * write_remainder() - write the tail of an IO vector to an fd * @fd: File descriptor @@ -866,44 +836,6 @@ int write_remainder(int fd, const struct iovec *iov, size_t iovcnt, size_t skip) return 0; } -/** - * read_all_buf() - Fill a whole buffer from a file descriptor - * @fd: File descriptor - * @buf: Pointer to base of buffer - * @len: Length of buffer - * - * Return: 0 on success, -1 on error (with errno set) - * - * #syscalls read - */ -int read_all_buf(int fd, void *buf, size_t len) -{ - size_t left = len; - char *p = buf; - - while (left) { - ssize_t rc; - - assert(left <= len); - - do - rc = read(fd, p, left); - while ((rc < 0) && errno == EINTR); - - if (rc < 0) - return -1; - - if (rc == 0) { - errno = ENODATA; - return -1; - } - - p += rc; - left -= rc; - } - return 0; -} - /** * read_remainder() - Read the tail of an IO vector from a file descriptor * @fd: File descriptor diff --git a/util.h b/util.h index 2fc5cd74..cb669105 100644 --- a/util.h +++ b/util.h @@ -245,9 +245,7 @@ int fls(unsigned long x); int ilog2(unsigned long x); int write_file(const char *path, const char *buf); intmax_t read_file_integer(const char *path, intmax_t fallback); -int write_all_buf(int fd, const void *buf, size_t len); int write_remainder(int fd, const struct iovec *iov, size_t iovcnt, size_t skip); -int read_all_buf(int fd, void *buf, size_t len); int read_remainder(int fd, const struct iovec *iov, size_t cnt, size_t skip); void close_open_files(int argc, char **argv); bool snprintf_check(char *str, size_t size, const char *format, ...); -- 2.53.0

2 2

[PATCH] tcp: Encode checksum computation flags in a single parameter
by Laurent Vivier 25 Mar '26

25 Mar '26

tcp_fill_headers() takes a pointer to a previously computed IPv4 header checksum to avoid recalculating it when the payload length doesn't change, and a separate bool to skip TCP checksum computation. Replace both parameters with a single uint32_t csum_flags that encodes: - IP4_CSUM (bit 31): compute IPv4 header checksum from scratch - TCP_CSUM (bit 30): compute TCP checksum - IP4_CMASK (low 16 bits): cached IPv4 header checksum value When IP4_CSUM is not set, the cached checksum is extracted from the low 16 bits. This is cleaner than the pointer-based approach, and also avoids a potential dangling pointer issue: a subsequent patch makes tcp_fill_headers() access ip4h via with_header(), which scopes it to a temporary variable, so a pointer to ip4h->check would become invalid after the with_header() block. Suggested-by: David Gibson <david(a)gibson.dropbear.id.au> Signed-off-by: Laurent Vivier <lvivier(a)redhat.com> --- tcp.c | 25 +++++++++++++------------ tcp_buf.c | 24 +++++++++++++----------- tcp_internal.h | 7 +++++-- tcp_vu.c | 28 +++++++++++++++++----------- 4 files changed, 48 insertions(+), 36 deletions(-) diff --git a/tcp.c b/tcp.c index b14586249c4e..14c472226225 100644 --- a/tcp.c +++ b/tcp.c @@ -943,9 +943,10 @@ static void tcp_fill_header(struct tcphdr *th, * @ip6h: Pointer to IPv6 header, or NULL * @th: Pointer to TCP header * @payload: TCP payload - * @ip4_check: IPv4 checksum, if already known + * @csum_flags: TCP_CSUM if TCP checksum must be computed, + * IP4_CSUM if IPv4 checksum must be computed, + * otherwise IPv4 checksum is provided in IP4_CMASK * @seq: Sequence number for this segment - * @no_tcp_csum: Do not set TCP checksum * * Return: frame length (including L2 headers) */ @@ -953,8 +954,7 @@ size_t tcp_fill_headers(const struct ctx *c, struct tcp_tap_conn *conn, struct ethhdr *eh, struct iphdr *ip4h, struct ipv6hdr *ip6h, struct tcphdr *th, struct iov_tail *payload, - const uint16_t *ip4_check, uint32_t seq, - bool no_tcp_csum) + uint32_t csum_flags, uint32_t seq) { const struct flowside *tapside = TAPFLOW(conn); size_t l4len = iov_tail_size(payload) + sizeof(*th); @@ -974,13 +974,14 @@ size_t tcp_fill_headers(const struct ctx *c, struct tcp_tap_conn *conn, ip4h->saddr = src4->s_addr; ip4h->daddr = dst4->s_addr; - if (ip4_check) - ip4h->check = *ip4_check; - else + if (csum_flags & IP4_CSUM) { ip4h->check = csum_ip4_header(l3len, IPPROTO_TCP, *src4, *dst4); + } else { + ip4h->check = csum_flags & IP4_CMASK; + } - if (!no_tcp_csum) { + if (csum_flags & TCP_CSUM) { psum = proto_ipv4_header_psum(l4len, IPPROTO_TCP, *src4, *dst4); } @@ -1000,7 +1001,7 @@ size_t tcp_fill_headers(const struct ctx *c, struct tcp_tap_conn *conn, ip6_set_flow_lbl(ip6h, conn->sock); - if (!no_tcp_csum) { + if (csum_flags & TCP_CSUM) { psum = proto_ipv6_header_psum(l4len, IPPROTO_TCP, &ip6h->saddr, &ip6h->daddr); @@ -1015,10 +1016,10 @@ size_t tcp_fill_headers(const struct ctx *c, struct tcp_tap_conn *conn, tcp_fill_header(th, conn, seq); - if (no_tcp_csum) - th->check = 0; - else + if (csum_flags & TCP_CSUM) tcp_update_csum(psum, th, payload); + else + th->check = 0; return MAX(l3len + sizeof(struct ethhdr), ETH_ZLEN); } diff --git a/tcp_buf.c b/tcp_buf.c index 41965b107567..9c982129bbcf 100644 --- a/tcp_buf.c +++ b/tcp_buf.c @@ -166,14 +166,15 @@ static void tcp_l2_buf_pad(struct iovec *iov) * @c: Execution context * @conn: Connection pointer * @iov: Pointer to an array of iovec of TCP pre-cooked buffers - * @check: Checksum, if already known + * @csum_flags: TCP_CSUM if TCP checksum must be computed, + * IP4_CSUM if IPv4 checksum must be computed, + * otherwise IPv4 checksum is provided in IP4_CMASK * @seq: Sequence number for this segment - * @no_tcp_csum: Do not set TCP checksum */ static void tcp_l2_buf_fill_headers(const struct ctx *c, struct tcp_tap_conn *conn, - struct iovec *iov, const uint16_t *check, - uint32_t seq, bool no_tcp_csum) + struct iovec *iov, uint32_t csum_flags, + uint32_t seq) { struct iov_tail tail = IOV_TAIL(&iov[TCP_IOV_PAYLOAD], 1, 0); struct tcphdr th_storage, *th = IOV_REMOVE_HEADER(&tail, th_storage); @@ -190,8 +191,8 @@ static void tcp_l2_buf_fill_headers(const struct ctx *c, else ip6h = iov[TCP_IOV_IP].iov_base; - l2len = tcp_fill_headers(c, conn, eh, ip4h, ip6h, th, &tail, check, seq, - no_tcp_csum); + l2len = tcp_fill_headers(c, conn, eh, ip4h, ip6h, th, &tail, csum_flags, + seq); tap_hdr_update(taph, l2len); } @@ -233,7 +234,7 @@ int tcp_buf_send_flag(const struct ctx *c, struct tcp_tap_conn *conn, int flags) if (flags & KEEPALIVE) seq--; - tcp_l2_buf_fill_headers(c, conn, iov, NULL, seq, false); + tcp_l2_buf_fill_headers(c, conn, iov, IP4_CSUM | TCP_CSUM, seq); tcp_l2_buf_pad(iov); @@ -270,7 +271,7 @@ static void tcp_data_to_tap(const struct ctx *c, struct tcp_tap_conn *conn, ssize_t dlen, int no_csum, uint32_t seq, bool push) { struct tcp_payload_t *payload; - const uint16_t *check = NULL; + uint32_t check = IP4_CSUM; struct iovec *iov; conn->seq_to_tap = seq + dlen; @@ -279,9 +280,10 @@ static void tcp_data_to_tap(const struct ctx *c, struct tcp_tap_conn *conn, if (CONN_V4(conn)) { if (no_csum) { struct iovec *iov_prev = tcp_l2_iov[tcp_payload_used - 1]; - struct iphdr *iph = iov_prev[TCP_IOV_IP].iov_base; + const struct iphdr *iph = iov_prev[TCP_IOV_IP].iov_base; - check = &iph->check; + /* overwrite IP4_CSUM flag as we set the checksum */ + check = iph->check; } iov[TCP_IOV_IP] = IOV_OF_LVALUE(tcp4_payload_ip[tcp_payload_used]); } else if (CONN_V6(conn)) { @@ -295,7 +297,7 @@ static void tcp_data_to_tap(const struct ctx *c, struct tcp_tap_conn *conn, payload->th.ack = 1; payload->th.psh = push; iov[TCP_IOV_PAYLOAD].iov_len = dlen + sizeof(struct tcphdr); - tcp_l2_buf_fill_headers(c, conn, iov, check, seq, false); + tcp_l2_buf_fill_headers(c, conn, iov, TCP_CSUM | check, seq); tcp_l2_buf_pad(iov); diff --git a/tcp_internal.h b/tcp_internal.h index d9408852571f..525fcbfa48fb 100644 --- a/tcp_internal.h +++ b/tcp_internal.h @@ -183,12 +183,15 @@ void tcp_rst_do(const struct ctx *c, struct tcp_tap_conn *conn); struct tcp_info_linux; +#define IP4_CSUM 0x80000000 +#define IP4_CMASK 0x0000FFFF +#define TCP_CSUM 0x40000000 + size_t tcp_fill_headers(const struct ctx *c, struct tcp_tap_conn *conn, struct ethhdr *eh, struct iphdr *ip4h, struct ipv6hdr *ip6h, struct tcphdr *th, struct iov_tail *payload, - const uint16_t *ip4_check, uint32_t seq, - bool no_tcp_csum); + uint32_t csum_flags, uint32_t seq); int tcp_update_seqack_wnd(const struct ctx *c, struct tcp_tap_conn *conn, bool force_seq, struct tcp_info_linux *tinfo); diff --git a/tcp_vu.c b/tcp_vu.c index dc0e17c0f03f..1afd582aaf95 100644 --- a/tcp_vu.c +++ b/tcp_vu.c @@ -138,7 +138,7 @@ int tcp_vu_send_flag(const struct ctx *c, struct tcp_tap_conn *conn, int flags) seq--; tcp_fill_headers(c, conn, eh, ip4h, ip6h, th, &payload, - NULL, seq, !*c->pcap); + IP4_CSUM | (*c->pcap ? TCP_CSUM : 0), seq); l2len = optlen + hdrlen - VNET_HLEN; vu_pad(&flags_elem[0].in_sg[0], l2len); @@ -280,13 +280,15 @@ static ssize_t tcp_vu_sock_recv(const struct ctx *c, struct vu_virtq *vq, * @conn: Connection pointer * @iov: Pointer to the array of IO vectors * @iov_cnt: Number of entries in @iov - * @check: Checksum, if already known - * @no_tcp_csum: Do not set TCP checksum + * @csum_flags: Pointer to checksum flags (input/output) + * TCP_CSUM if TCP checksum must be computed, + * IP4_CSUM if IPv4 checksum must be computed, + * otherwise IPv4 checksum is provided in IP4_CMASK * @push: Set PSH flag, last segment in a batch */ static void tcp_vu_prepare(const struct ctx *c, struct tcp_tap_conn *conn, struct iovec *iov, size_t iov_cnt, - const uint16_t **check, bool no_tcp_csum, bool push) + uint32_t *csum_flags, bool push) { const struct flowside *toside = TAPFLOW(conn); bool v6 = !(inany_v4(&toside->eaddr) && inany_v4(&toside->oaddr)); @@ -330,9 +332,11 @@ static void tcp_vu_prepare(const struct ctx *c, struct tcp_tap_conn *conn, th->psh = push; tcp_fill_headers(c, conn, eh, ip4h, ip6h, th, &payload, - *check, conn->seq_to_tap, no_tcp_csum); + *csum_flags, conn->seq_to_tap); + + /* Preserve TCP_CSUM, overwrite IP4_CSUM as we set the checksum */ if (ip4h) - *check = &ip4h->check; + *csum_flags = (*csum_flags & TCP_CSUM) | ip4h->check; } /** @@ -348,12 +352,11 @@ int tcp_vu_data_from_sock(const struct ctx *c, struct tcp_tap_conn *conn) uint32_t wnd_scaled = conn->wnd_from_tap << conn->ws_from_tap; struct vu_dev *vdev = c->vdev; struct vu_virtq *vq = &vdev->vq[VHOST_USER_RX_QUEUE]; + uint32_t already_sent, check; ssize_t len, previous_dlen; int i, iov_cnt, head_cnt; size_t hdrlen, fillsize; int v6 = CONN_V6(conn); - uint32_t already_sent; - const uint16_t *check; if (!vu_queue_enabled(vq) || !vu_queue_started(vq)) { debug("Got packet, but RX virtqueue not usable yet"); @@ -440,7 +443,10 @@ int tcp_vu_data_from_sock(const struct ctx *c, struct tcp_tap_conn *conn) */ hdrlen = tcp_vu_hdrlen(v6); - for (i = 0, previous_dlen = -1, check = NULL; i < head_cnt; i++) { + check = IP4_CSUM; + if (*c->pcap) + check |= TCP_CSUM; + for (i = 0, previous_dlen = -1; i < head_cnt; i++) { struct iovec *iov = &elem[head[i]].in_sg[0]; int buf_cnt = head[i + 1] - head[i]; size_t frame_size = iov_size(iov, buf_cnt); @@ -455,10 +461,10 @@ int tcp_vu_data_from_sock(const struct ctx *c, struct tcp_tap_conn *conn) /* The IPv4 header checksum varies only with dlen */ if (previous_dlen != dlen) - check = NULL; + check |= IP4_CSUM; previous_dlen = dlen; - tcp_vu_prepare(c, conn, iov, buf_cnt, &check, !*c->pcap, push); + tcp_vu_prepare(c, conn, iov, buf_cnt, &check, push); /* Pad first/single buffer only, it's at least ETH_ZLEN long */ l2len = dlen + hdrlen - VNET_HLEN; -- 2.53.0

2 1

[PATCH v4 0/5] vhost-user,udp: Handle multiple iovec entries per virtqueue element
by Laurent Vivier 25 Mar '26

25 Mar '26

Some virtio-net drivers (notably iPXE) provide descriptors where the vnet header and the frame payload are in separate buffers, resulting in two iovec entries per virtqueue element. Currently, the RX (host to guest) path assumes a single iovec per element, which triggers: ASSERTION FAILED in virtqueue_map_desc (virtio.c:403): num_sg < max_num_sg This series reworks the UDP vhost-user receive path to support multiple iovec entries per element, fixing the iPXE crash. This series only addresses the UDP path. TCP vhost-user will be updated to use multi-iov elements in a subsequent series. v4: - rebase - replace ASSERT() by assert() v3: - include the series "Decouple iovec management from virtqueues elements" - because of this series, drop: "vu_common: Accept explicit iovec counts in vu_set_element()" "vu_common: Accept explicit iovec count per element in vu_init_elem()" "vu_common: Prepare to use multibuffer with guest RX" "vhost-user,udp: Use 2 iovec entries per element" - drop "vu_common: Pass iov_tail to vu_set_vnethdr()" as the specs insures a buffer is big enough to contain vnet header - introduce "with_header()" and merge "udp: Pass iov_tail to udp_update_hdr4()/udp_update_hdr6()" and "udp_vu: Use iov_tail in udp_vu_prepare()" to use it v2: - add iov_truncate(), iov_memset() - remove iov_tail_truncate() and iov_tail_zero_end() - manage 802.3 minimum frame size Laurent Vivier (5): vhost-user: Centralise Ethernet frame padding in vu_collect(), vu_pad() and vu_flush() udp_vu: Use iov_tail to manage virtqueue buffers udp_vu: Move virtqueue management from udp_vu_sock_recv() to its caller iov: Add IOV_PUT_HEADER() and with_header() to write header data back to iov_tail udp: Pass iov_tail to udp_update_hdr4()/udp_update_hdr6() iov.c | 47 +++++++++++ iov.h | 27 ++++++- tcp_vu.c | 22 ++---- udp.c | 129 ++++++++++++++++-------------- udp_internal.h | 6 +- udp_vu.c | 210 ++++++++++++++++++++++++------------------------- vu_common.c | 76 ++++++++++++------ vu_common.h | 2 +- 8 files changed, 310 insertions(+), 209 deletions(-) -- 2.53.0

2 16

[PATCH v2] Bug 134: message rate limiting
by Anshu Kumari 24 Mar '26

24 Mar '26

Signed-off-by: Anshu Kumari <anskuma(a)redhat.com> --- log.h | 40 ++++++++++++++++++++++++++++++++++++++++ tap.c | 19 ++++++------------- 2 files changed, 46 insertions(+), 13 deletions(-) diff --git a/log.h b/log.h index 6ceb686..2e9286e 100644 --- a/log.h +++ b/log.h @@ -48,6 +48,46 @@ void logmsg_perror(int pri, const char *format, ...) passt_exit(EXIT_FAILURE); \ } while (0) +#define LOG_RATELIMIT_BURST 5 /* Max messages per window per call site */ +#define LOG_RATELIMIT_INTERVAL 1 /* Default rate limit window in seconds */ + +/** + * logmsg_ratelimit() - Rate-limited log message + * @fn: Logging function + * @now: current timestamp + */ +#define logmsg_ratelimit(fn, now, ...) \ + do { \ + static time_t rl_last_; \ + static unsigned int rl_printed_; \ + static unsigned int rl_suppressed_; \ + \ + if ((now)->tv_sec - rl_last_ > LOG_RATELIMIT_INTERVAL) { \ + if (rl_suppressed_) \ + fn("(suppressed %u similar messages)", \ + rl_suppressed_); \ + rl_last_ = (now)->tv_sec; \ + rl_printed_ = 0; \ + rl_suppressed_ = 0; \ + } \ + \ + if (rl_printed_ < LOG_RATELIMIT_BURST) { \ + fn(__VA_ARGS__); \ + rl_printed_++; \ + } else { \ + rl_suppressed_++; \ + } \ + } while (0) + +#define err_ratelimit(now, ...) \ + logmsg_ratelimit(err, now, __VA_ARGS__) +#define warn_ratelimit(now, ...) \ + logmsg_ratelimit(warn, now, __VA_ARGS__) +#define info_ratelimit(now, ...) \ + logmsg_ratelimit(info, now, __VA_ARGS__) +#define debug_ratelimit(now, ...) \ + logmsg_ratelimit(debug, now, __VA_ARGS__) + extern int log_file; extern int log_trace; extern bool log_conf_parsed; diff --git a/tap.c b/tap.c index 1049e02..656b6e9 100644 --- a/tap.c +++ b/tap.c @@ -686,17 +686,8 @@ static bool tap4_is_fragment(const struct iphdr *iph, const struct timespec *now) { if (ntohs(iph->frag_off) & ~IP_DF) { - /* Ratelimit messages */ - static time_t last_message; - static unsigned num_dropped; - - num_dropped++; - if (now->tv_sec - last_message > FRAGMENT_MSG_RATE) { - warn("Can't process IPv4 fragments (%u dropped)", - num_dropped); - last_message = now->tv_sec; - num_dropped = 0; - } + warn_ratelimit(now, + "Can't process IPv4 fragment"); return true; } return false; @@ -1115,8 +1106,10 @@ void tap_add_packet(struct ctx *c, struct iov_tail *data, char bufmac[ETH_ADDRSTRLEN]; memcpy(c->guest_mac, eh->h_source, ETH_ALEN); - debug("New guest MAC address observed: %s", - eth_ntop(c->guest_mac, bufmac, sizeof(bufmac))); + info_ratelimit(now, + "New guest MAC address observed: %s", + eth_ntop(c->guest_mac, bufmac, + sizeof(bufmac))); proto_update_l2_buf(c->guest_mac); } -- 2.53.0

2 1

[PATCH] Bug 134: message rate limiting https://bugs.passt.top/show_bug.cgi?id=134
by Anshu Kumari 24 Mar '26

24 Mar '26

Hi Everyone, Please review patch for Bug 134. Description:- Inorder to rate limit the messages, each logging function uses per-call-site static variables, so each macro expansion tracks its own rate independently. Allows up to LOG_RATELIMIT_BURST messages per window. When a new window starts after suppression, a summary of suppressed messages is logged. Signed-off-by: Anshu Kumari <anskuma(a)redhat.com> --- log.h | 41 +++++++++++++++++++++++++++++++++++++++++ tap.c | 19 ++++++------------- 2 files changed, 47 insertions(+), 13 deletions(-) diff --git a/log.h b/log.h index 6ceb686..e989760 100644 --- a/log.h +++ b/log.h @@ -48,6 +48,47 @@ void logmsg_perror(int pri, const char *format, ...) passt_exit(EXIT_FAILURE); \ } while (0) +#define LOG_RATELIMIT_BURST 5 /* Max messages per window per call site */ +#define LOG_RATELIMIT_INTERVAL 1 /* Default rate limit window in seconds */ + +/** + * logmsg_ratelimit() - Rate-limited log message + * @fn: Logging function + * @now: current timestamp + * @intv: Minimum interval in seconds between allowed messages + */ +#define logmsg_ratelimit(fn, now, intv, ...) \ + do { \ + static time_t _rl_last; \ + static unsigned int _rl_printed; \ + static unsigned int _rl_suppressed; \ + \ + if ((now)->tv_sec - _rl_last > (intv)) { \ + if (_rl_suppressed) \ + fn("(suppressed %u similar messages)", \ + _rl_suppressed); \ + _rl_last = (now)->tv_sec; \ + _rl_printed = 0; \ + _rl_suppressed = 0; \ + } \ + \ + if (_rl_printed < LOG_RATELIMIT_BURST) { \ + fn(__VA_ARGS__); \ + _rl_printed++; \ + } else { \ + _rl_suppressed++; \ + } \ + } while (0) + +#define err_ratelimit(now, intv, ...) \ + logmsg_ratelimit(err, now, intv, __VA_ARGS__) +#define warn_ratelimit(now, intv, ...) \ + logmsg_ratelimit(warn, now, intv, __VA_ARGS__) +#define info_ratelimit(now, intv, ...) \ + logmsg_ratelimit(info, now, intv, __VA_ARGS__) +#define debug_ratelimit(now, intv, ...) \ + logmsg_ratelimit(debug, now, intv, __VA_ARGS__) + extern int log_file; extern int log_trace; extern bool log_conf_parsed; diff --git a/tap.c b/tap.c index 1049e02..0812a8a 100644 --- a/tap.c +++ b/tap.c @@ -686,17 +686,8 @@ static bool tap4_is_fragment(const struct iphdr *iph, const struct timespec *now) { if (ntohs(iph->frag_off) & ~IP_DF) { - /* Ratelimit messages */ - static time_t last_message; - static unsigned num_dropped; - - num_dropped++; - if (now->tv_sec - last_message > FRAGMENT_MSG_RATE) { - warn("Can't process IPv4 fragments (%u dropped)", - num_dropped); - last_message = now->tv_sec; - num_dropped = 0; - } + warn_ratelimit(now, FRAGMENT_MSG_RATE, + "Can't process IPv4 fragment"); return true; } return false; @@ -1115,8 +1106,10 @@ void tap_add_packet(struct ctx *c, struct iov_tail *data, char bufmac[ETH_ADDRSTRLEN]; memcpy(c->guest_mac, eh->h_source, ETH_ALEN); - debug("New guest MAC address observed: %s", - eth_ntop(c->guest_mac, bufmac, sizeof(bufmac))); + info_ratelimit(now, LOG_RATELIMIT_INTERVAL, + "New guest MAC address observed: %s", + eth_ntop(c->guest_mac, bufmac, + sizeof(bufmac))); proto_update_l2_buf(c->guest_mac); } -- 2.53.0

3 3

[PATCH trivial 0/3] tcp_vu: Remove redundant header field assignments
by Laurent Vivier 24 Mar '26

24 Mar '26

tcp_vu_send_flag() and tcp_vu_prepare() set several header fields that are unconditionally overwritten by tcp_fill_headers() or tcp_prepare_flags() shortly after. This series removes: 1. eh->h_proto assignments in both tcp_vu_send_flag() and tcp_vu_prepare(), overwritten by tcp_fill_headers() 2. eh->h_source memcpy in tcp_vu_send_flag(), overwritten by eth_update_mac() called from tcp_fill_headers() 3. th->doff and th->ack assignments in tcp_vu_send_flag(), overwritten by tcp_prepare_flags() Laurent Vivier (3): tcp_vu: Remove redundant eh->h_proto assignments tcp_vu: Remove redundant eh->h_source assignment in tcp_vu_send_flag() tcp_vu: Remove redundant th->doff and th->ack in tcp_vu_send_flag() tcp_vu.c | 11 ----------- 1 file changed, 11 deletions(-) -- 2.53.0

2 6

[PATCH trivial] vu_common: Detach element from virtqueue on invalid TX buffer
by Laurent Vivier 23 Mar '26

23 Mar '26

When vu_queue_pop() succeeds but the element contains no out buffers, we warn and break out of the TX loop. However, vu_queue_pop() already incremented vq->inuse for this element. Since we don't add it to the count of elements to be filled and flushed back to the guest, the inuse counter is left inconsistent. Call vu_queue_detach_element() before breaking to decrement vq->inuse and properly release the element. Signed-off-by: Laurent Vivier <lvivier(a)redhat.com> --- vu_common.c | 1 + 1 file changed, 1 insertion(+) diff --git a/vu_common.c b/vu_common.c index 5f2ce18e5b71..ff8f1c046026 100644 --- a/vu_common.c +++ b/vu_common.c @@ -190,6 +190,7 @@ static void vu_handle_tx(struct vu_dev *vdev, int index, if (elem[count].out_num < 1) { warn("virtio-net transmit queue contains no out buffers"); + vu_queue_detach_element(vq); break; } -- 2.53.0

2 1

[PATCH] vhost_user: Offer VIRTIO_NET_F_GUEST_CSUM
by Laurent Vivier 23 Mar '26

23 Mar '26

According to the virtio-net specification, when the VIRTIO_NET_F_GUEST_CSUM is negotiated, the device can set VIRTIO_NET_HDR_F_DATA_VALID in the virtio-net header to indicate that packet checksums have been validated, allowing the guest to skip verification. Without this feature, the device must provide fully checksummed packets. The vhost-user TCP and UDP paths were unconditionally skipping checksum computation, regardless of whether GUEST_CSUM was negotiated. This went undetected with Linux guests because Linux's virtio-net driver honours VIRTIO_NET_HDR_F_DATA_VALID regardless of whether VIRTIO_NET_F_GUEST_CSUM was negotiated, marking such packets as CHECKSUM_UNNECESSARY and skipping verification. iPXE, however, does not negotiate GUEST_CSUM, ignores the DATA_VALID flag entirely, and always verifies checksums. This caused TCP connections to fail: the SYN-ACK had a zero TCP checksum, iPXE rejected it, and the connection timed out in SYN_RCVD. Adding --pcap happened to mask the bug, because the pcap code path forces checksum computation to ensure correct captures. Offer VIRTIO_NET_F_GUEST_CSUM in the device features, and only skip checksum computation when the guest has actually negotiated it. When GUEST_CSUM is not negotiated, always compute valid checksums as required by the specification. We keep setting VIRTIO_NET_HDR_F_DATA_VALID unconditionally in VU_HEADER: when GUEST_CSUM is negotiated, the flag lets the guest skip checksum verification; when it is not, the spec says the guest should ignore the flags field, so setting it is harmless. Signed-off-by: Laurent Vivier <lvivier(a)redhat.com> --- Notes: Based-on: 20260323165259.1253482-1-lvivier(a)redhat.com tcp_vu.c | 8 ++++++-- udp_vu.c | 6 ++++-- vhost_user.c | 1 + 3 files changed, 11 insertions(+), 4 deletions(-) diff --git a/tcp_vu.c b/tcp_vu.c index 776b47aea18c..2ab56f25a9be 100644 --- a/tcp_vu.c +++ b/tcp_vu.c @@ -172,7 +172,9 @@ int tcp_vu_send_flag(const struct ctx *c, struct tcp_tap_conn *conn, int flags) seq--; payload = IOV_TAIL(flags_elem[0].in_sg, iov_cnt, VNET_HLEN); - tcp_fill_headers(c, conn, CONN_V4(conn), &payload, -1, seq, !*c->pcap); + tcp_fill_headers(c, conn, CONN_V4(conn), &payload, -1, seq, + vu_has_feature(vdev, VIRTIO_NET_F_GUEST_CSUM) && + !*c->pcap); if (*c->pcap) pcap_iov(flags_elem[0].in_sg, iov_cnt, VNET_HLEN); @@ -512,7 +514,9 @@ int tcp_vu_data_from_sock(const struct ctx *c, struct tcp_tap_conn *conn) check = -1; previous_dlen = dlen; - tcp_vu_prepare(c, conn, iov, iov_cnt, &check, !*c->pcap, push); + tcp_vu_prepare(c, conn, iov, iov_cnt, &check, + vu_has_feature(vdev, VIRTIO_NET_F_GUEST_CSUM) && + !*c->pcap, push); if (*c->pcap) pcap_iov(iov, iov_cnt, VNET_HLEN); diff --git a/udp_vu.c b/udp_vu.c index 80391b4f8788..7ed271403481 100644 --- a/udp_vu.c +++ b/udp_vu.c @@ -223,10 +223,12 @@ void udp_vu_sock_to_tap(const struct ctx *c, int s, int n, flow_sidx_t tosidx) vu_set_vnethdr(iov_vu[0].iov_base, elem_used); iov_drop_header(&data, VNET_HLEN); udp_vu_prepare(c, &data, toside); - if (*c->pcap) { + if (!vu_has_feature(vdev, VIRTIO_NET_F_GUEST_CSUM) || + *c->pcap) { udp_vu_csum(toside, &data); - pcap_iov(data.iov, data.cnt, data.off); } + if (*c->pcap) + pcap_iov(data.iov, data.cnt, data.off); vu_flush(vdev, vq, elem, elem_used); } } diff --git a/vhost_user.c b/vhost_user.c index 75665ec6522f..08a7b2d74099 100644 --- a/vhost_user.c +++ b/vhost_user.c @@ -322,6 +322,7 @@ static bool vu_get_features_exec(struct vu_dev *vdev, { uint64_t features = 1ULL << VIRTIO_F_VERSION_1 | + 1ULL << VIRTIO_NET_F_GUEST_CSUM | 1ULL << VIRTIO_NET_F_MRG_RXBUF | 1ULL << VHOST_F_LOG_ALL | 1ULL << VHOST_USER_F_PROTOCOL_FEATURES; -- 2.53.0

2 3

[PATCH v3 01/25] conf: runas can be const
by David Gibson 23 Mar '26

23 Mar '26

Both the runas variable in conf() and the parameter to conf_ugid() can be a const pointer. For some reason cppcheck doesn't catch this now, but does after some upcoming rearrangements for sharing code with the dynamic update tool. Signed-off-by: David Gibson <david(a)gibson.dropbear.id.au> --- conf.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/conf.c b/conf.c index 940fb9e9..b1ebb4a4 100644 --- a/conf.c +++ b/conf.c @@ -1320,7 +1320,7 @@ static int conf_runas(const char *opt, unsigned int *uid, unsigned int *gid) * @uid: User ID, set on success * @gid: Group ID, set on success */ -static void conf_ugid(char *runas, uid_t *uid, gid_t *gid) +static void conf_ugid(const char *runas, uid_t *uid, gid_t *gid) { /* If user has specified --runas, that takes precedence... */ if (runas) { @@ -1561,8 +1561,8 @@ void conf(struct ctx *c, int argc, char **argv) uint8_t prefix_len_from_opt = 0; unsigned int ifi4 = 0, ifi6 = 0; const char *logfile = NULL; + const char *runas = NULL; size_t logsize = 0; - char *runas = NULL; long fd_tap_opt; int name, ret; uid_t uid; -- 2.53.0

1 0