This series makes the passt data structures safe for concurrent access by multiple worker threads, each handling a different queue pair. It builds on the multiqueue series which threads the queue pair parameter through the network stack. The changes fall into four categories: 1. Per-queue-pair data isolation: - Convert packet pools (pool_tap4, pool_tap6) to per-queue-pair arrays - Convert L4 sequence batching arrays (tap4_l4, tap6_l4) similarly - Move flow and TCP timer state out of global/context structures into per-caller parameters 2. Stack-local buffers: - Move static iovec and virtqueue buffers onto the stack in tcp.c, tcp_vu.c, and udp_vu.c so each thread operates on its own copy 3. Locking for remaining shared state: - pthread_mutex on pre-opened socket pools (init_sock_pool4/6) - pthread_rwlock on the flow table, hash table, and free list, with read locks for lookups and write locks for mutations - _Thread_local for flow_new_entry so each thread independently tracks its in-progress allocation - Per-qpair filtering in flow_defer_handler() so each worker only processes its own flows 4. Lock-free flow migration between queue pairs: - When guest steers traffic to a different TX queue, flows migrate lazily using a to_migrate[] array - flow_migrate_mark() records target qpair from tap path (write-once, no lock needed) - flow_migrate_epollfd() completes migration on next socket/timer event by moving fd and updating qpair on the old thread - TCP timers migrate the same way using new tcp_timer_epoll_add() helper Global operations that don't need per-queue-pair handling (tcp_payload_flush, socket pool refills) are guarded to run only on queue pair 0. v2: - Rebase on latest master and multiqueue v6 - Split v1's "flow: Add mutex and per-qpair filtering..." into two patches: - "flow: Add locking, per-qpair filtering, and intermediate state handling" (locking only) - "flow: Add lazy, lock-free flow migration between queue pairs" (migration logic separated) - Changed from simple mutex to pthread_rwlock for flow table (read locks for lookups, write locks for mutations and free-list rebuild) - Updated flow_foreach() and flow_defer_handler() to handle intermediate flow states (NEW, INI, TGT, TYPED) that can be observed between flow_alloc() and FLOW_ACTIVATE() when lock is released - New patch: "tcp: Extract tcp_timer_epoll_add() helper" - factors out epoll registration for timer migration support - flow_migrate_epollfd() now uses tcp_timer_epoll_add() for timer migration v1: - Initial submission Based-on: 20260616125130.1324274-1-lvivier@redhat.com Laurent Vivier (10): tap: Convert packet pools to per-queue-pair arrays for multiqueue tap: Make L4 sequence pools per-qpair for thread safety tcp: Make static buffers stack-local for thread safety udp_vu: Make virtqueue buffers stack-local for thread safety flow: Make flow timer per-caller for thread safety tcp: Make TCP timer state per-caller and guard global tasks tcp: Protect init socket pools with mutex for thread safety tcp: Extract tcp_timer_epoll_add() helper flow: Add locking, per-qpair filtering, and intermediate state handling flow: Add lazy, lock-free flow migration between queue pairs flow.c | 222 ++++++++++++++++++++++++++++++++++++++++++++++----- flow.h | 5 +- flow_table.h | 2 +- icmp.c | 10 ++- passt.c | 37 +++++---- tap.c | 109 ++++++++++++++----------- tap.h | 2 +- tcp.c | 108 ++++++++++++++++++------- tcp.h | 9 +-- tcp_vu.c | 33 +++++--- udp.c | 3 + udp_flow.c | 4 + udp_vu.c | 4 +- vu_common.c | 2 +- 14 files changed, 409 insertions(+), 141 deletions(-) -- 2.54.0