Compare commits

..
Author SHA1 Message Date
Ryan HuberandClaude Opus 5.5 21a7f1b711 overlay/darwin: read the utun with recvmsg_x
tunQueue.Read now takes up to 64 queued packets with one recvmsg_x through
internal/msgx, each into its own 64KiB slot of a buffer allocated once per
queue, and falls back to the readv drain for good when recvmsg_x is refused
or returns a batch intact msghdr_x entries can't produce, or for one Read on
a transient error. Ported from the pipeline bench build's tunRecvX, minus its
env toggle and stats.

With 64 pending packets on the utun this is the remaining send gain: on an
M2 mini, one stream, pipeline + 64 pending reads 4.9 Gbps with recvmsg_x and
2.6 with the readv loop, the same as this branch before this commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 13:27:27 +00:00
Ryan HuberandClaude Opus 5.5 64bec56404 darwin: pipeline listenIn's sends so write batches can form
On darwin, listenIn encrypts into one SendBatch while a sender goroutine
writes the other (batch.SendPipeline). The sender takes whatever built up
during its last write, so writes overlap tun reads and packets queued
behind a write leave in one WriteBatch, which a connected socket sends as
one sendmsg_x. Two batches bound memory; a full producer waits for the
swap rather than dropping. One producer and one sender keep per-peer order
equal to message-counter order.

Everywhere else the branch is a false constant and listenIn is unchanged.
-tags send_pipeline builds the pipeline on any platform, so its tests and
the e2e suite can run through it on linux.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 11:11:48 +00:00
Ryan HuberandClaude Opus 5.5 81f991f1fd overlay/darwin: batch tun writes with sendmsg_x, drain reads, 64 pending packets
tun.WriteBatch writes up to 64 packets per sendmsg_x on the utun control
socket, and Passthrough.Flush hands its lane to it whole through the new
tio.BatchWriter (Caleb Jasik's #1896). Only the darwin tun implements
BatchWriter, so every other platform keeps one Write per packet.

tunQueue.Read drains every packet already queued on the utun, up to 64,
so a burst reaches the send batch together.

xnu lets only one packet wait on a utun control socket by default, so
each read found one packet. The tun now raises
UTUN_OPT_MAX_PENDING_PACKETS to 64, growing SO_RCVBUF to hold that many
packets first; on failure it logs and keeps xnu's default.

Tests: #1896's WriteBatch tests over sendmsg_x and the writev fallback,
the drain tests, the pending-packet setsockopts, and #1906's framing and
zero-alloc Read/Write tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 11:11:48 +00:00
Ryan HuberandClaude Opus 5.5 21075ba32e udp/darwin: batch receives and connected-socket sends with recvmsg_x/sendmsg_x
internal/msgx is the one copy of xnu's private batched socket calls: the
msghdr_x layout, Send/Recv through the raw syscall (EINTR retried) and
Unsupported for the errnos a kernel or sandbox refuses them with.

Every socket the listener owns reads with recvmsg_x: the listener and each
connected socket run their own reader goroutine, and hand whole batches to
ListenOut over a channel. ListenOut runs the EncReader over a batch and
flushes once, so the reader stays single-threaded without a lock that
readers contend on, and the next recvmsg_x overlaps the decrypt of the last
batch. Batch buffers (64 x MTU) come from a per-listener free list that
keeps up to 11; a reader takes one only while its socket is readable, so
idle connected sockets hold none. A batch with a header intact msghdr_x
entries can't produce, or ENOSYS/EPERM/EOPNOTSUPP, switches every reader to
one datagram per read for good.

Connected sockets send runs with sendmsg_x, which xnu batches through the
stack on a connected socket. EAGAIN/ENOBUFS keep #1901's single-datagram
stall handling; a refused sendmsg_x retries the datagram with write and
turns sendmsg_x off once that goes through.

The connected-socket knobs lose their NEBULA_CONNSOCK* environment
overrides and keep #1901's defaults.

Based on Caleb Jasik's #1895 (recvmsg_x) and #1897 (sendmsg_x), and Jack
Doan's internal/msgx shape from #1898.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 11:11:48 +00:00
Caleb JasikandClaude Opus 5.5 37032a22bf udp/darwin: send to busy established peers on connected sockets
On darwin an unconnected sendto runs the address and MAC policy checks
and the EndpointSecurity send check for every datagram, and while
xprotectd throttles it each send takes about 185us, which caps a
tunnel's upload and, through its ACKs, its download. A connected socket
runs those checks once, at connect, and it is the only UDP send that
reports the interface queue's flow control, as ENOBUFS.

Only the current direct remote of an established tunnel is eligible.
udp.EstablishedPeerConn is an optional Conn interface, implemented on
darwin; establishedRemotes refcounts remotes over the main hostmap and
tells each writer on the first and last reference: handshake completion
adds one, deleting or retiring a hostinfo removes it, SetRemote (roaming,
SetRemoteIfPreferred, control, ssh) moves it. Pending and relayed
hostinfos hold none, and a rehandshake's two hostinfos share one.

An eligible peer that Nebula sends NEBULA_CONNSOCK_RUN (64) datagrams to
within NEBULA_CONNSOCK_WINDOW (1s) gets a connected socket: SO_REUSEPORT,
bound to the source address the listener's route to the peer picks on
the listener's port, carrying the listener's IP_BOUND_IF. The peer sees
the same address and port as from the listener, and the socket's reader
delivers through the listener's reader. The listener itself never sets
SO_REUSEPORT (listen routines still do), so no other uid can bind the
port; with a specific listen.host and no routines connected sockets stay
off, since sharing an exact address needs SO_REUSEPORT on both.

All routines listening on one address share one set of connected
sockets: at most NEBULA_CONNSOCKS (8), one per peer, with opens from a
bucket that refills one per NEBULA_CONNSOCK_OPEN_EVERY (1s). A socket
closes when its peer stops being eligible, after NEBULA_CONNSOCK_IDLE
(30s) without traffic, on Rebind (of every routine) and Close, and on an
error that means the connected path is gone. Closing never runs under
the hostmap's or the eligibility lock; the peer can't reopen until the
close finishes. A send that gets ENOBUFS or EAGAIN waits within one
10ms budget shared by every writer since the last send that went
through, then drops; nothing waits in the netpoller without a deadline.
When nothing is eligible or open, a send costs one atomic load before
the listener path.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 09:59:09 +00:00
18 changed files with 2665 additions and 140 deletions

No files matched your search

+10
View File
@@ -432,6 +432,11 @@ func (f *Interface) pinThisThread(i int) {
} }
func (f *Interface) listenIn(queue tio.Queue, i int) { func (f *Interface) listenIn(queue tio.Queue, i int) {
if sendPipelinePlatform {
listenInPipelined(f, queue, i)
return
}
// Pinning this thread (and goroutine) to a single CPU keeps every sendmmsg from this goroutine going through the // Pinning this thread (and goroutine) to a single CPU keeps every sendmmsg from this goroutine going through the
// same TX ring on the nic, so the wire sees per-flow order. Skip entirely when tun.pin_threads is false. // same TX ring on the nic, so the wire sees per-flow order. Skip entirely when tun.pin_threads is false.
if f.pinThreads { if f.pinThreads {
@@ -478,6 +483,11 @@ func (f *Interface) listenIn(queue tio.Queue, i int) {
func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) { func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) {
queued := sb.Len() queued := sb.Len()
written, err := sb.Flush() written, err := sb.Flush()
f.accountSendBatch(queued, written, err, q)
}
// accountSendBatch is flushSendBatch's accounting, also for the writes a send pipeline makes.
func (f *Interface) accountSendBatch(queued, written int, err error, q int) {
if err != nil { if err != nil {
f.l.Error("Failed to write outgoing batch", "error", err, "writer", q) f.l.Error("Failed to write outgoing batch", "error", err, "writer", q)
} }
+58
View File
@@ -0,0 +1,58 @@
//go:build darwin || send_pipeline
package nebula
import (
"github.com/slackhq/nebula/firewall"
"github.com/slackhq/nebula/overlay/batch"
"github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/udp"
)
// sendPipelinePlatform lets listenIn take the pipelined send path. It is on for darwin, and for any platform built
// with -tags send_pipeline so the pipeline's tests (and the e2e suite through it) run on linux too.
const sendPipelinePlatform = true
// listenInPipelined is f.listenIn with the underlay writes moved to a sender goroutine (batch.SendPipeline). This
// goroutine still reads the tun, runs the firewall and encrypts, straight into the pipeline's batch. The sender
// writes whatever has built up each time its previous write returns, so under load the packets read while one
// write is in the kernel leave together in the next one, and the next tun read overlaps the write.
func listenInPipelined(f *Interface, queue tio.Queue, i int) {
if f.pinThreads {
f.pinThisThread(i)
}
rejectBuf := make([]byte, mtu)
arenaSize := batch.SendBatchCap * (udp.MTU + 32)
onWrite := func(queued, written int, err error) {
f.accountSendBatch(queued, written, err, i)
}
p := batch.NewSendPipeline(f.writers[i], batch.SendBatchCap, arenaSize, udp.MaxWriteBatch, onWrite)
defer p.Close()
fwPacket := &firewall.ParsedPacket{}
nb := make([]byte, 12, 12)
conntrackCache := firewall.NewConntrackCacheTicker(f.ctx, f.l, f.conntrackCacheTimeout)
for {
pkts, err := queue.Read()
if err != nil {
// Same shutdown noise handling as listenOut
if !f.closed.Load() && f.ctx.Err() == nil {
f.l.Error("Error while reading outbound packet, closing", "error", err, "reader", i)
f.onFatal(err)
}
break
}
for j, pkt := range pkts {
// One Begin/End per packet holds the batch only briefly, so a sender that finishes a write mid-read
// takes what is ready then. An idle sender is woken once, at the end of the read, to take it whole.
sb := p.Begin()
f.consumeInsidePacket(pkt, fwPacket, nb, sb, rejectBuf, i, conntrackCache.Get())
p.End(j == len(pkts)-1)
}
}
f.l.Debug("overlay reader is done", "reader", i)
}
+89
View File
@@ -0,0 +1,89 @@
//go:build darwin || send_pipeline
package nebula
import (
"context"
"errors"
"net/netip"
"sync"
"testing"
"time"
"github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/test"
"github.com/slackhq/nebula/udp"
"github.com/stretchr/testify/assert"
"go.uber.org/goleak"
)
// scriptedQueue hands out reads from a script, then fails every Read with err.
type scriptedQueue struct {
reads [][]tio.Packet
err error
}
func (q *scriptedQueue) Read() ([]tio.Packet, error) {
if len(q.reads) == 0 {
return nil, q.err
}
r := q.reads[0]
q.reads = q.reads[1:]
return r, nil
}
func (q *scriptedQueue) Write(b []byte) (int, error) { return len(b), nil }
func (q *scriptedQueue) Close() error { return nil }
type countingConn struct {
udp.NoopConn
mu sync.Mutex
batches int
}
func (c *countingConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) {
c.mu.Lock()
c.batches++
c.mu.Unlock()
return len(bufs), nil
}
// TestListenInPipelinedStops pins that the pipelined reader returns when its queue fails, stopping its sender, and
// reports the error as fatal only when the interface isn't shutting down.
func TestListenInPipelinedStops(t *testing.T) {
for _, closing := range []bool{false, true} {
t.Run(map[bool]string{false: "fatal", true: "shutdown"}[closing], func(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
readErr := errors.New("tun gone")
conn := &countingConn{}
// Packets too short to parse are dropped before the firewall, so this reads without a hostmap.
junk := tio.Packet{Bytes: []byte{0x45, 0}}
q := &scriptedQueue{reads: [][]tio.Packet{{junk}, {junk, junk, junk}, {}}, err: readErr}
shutdown := make(chan struct{})
f := &Interface{
ctx: context.Background(),
l: test.NewLogger(),
writers: []udp.Conn{conn},
triggerShutdown: func() { close(shutdown) },
}
f.closed.Store(closing)
done := make(chan struct{})
go func() {
f.listenIn(q, 0)
close(done)
}()
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("listenIn did not return after its queue failed")
}
if closing {
assert.Nil(t, f.fatalErr.Load())
} else {
<-shutdown
assert.Equal(t, readErr, *f.fatalErr.Load())
}
assert.Zero(t, conn.batches, "dropped packets must not be written")
})
}
}
+58
View File
@@ -0,0 +1,58 @@
// Package msgx calls xnu's private batched socket calls, sendmsg_x and recvmsg_x, which move many datagrams per
// syscall. They are not public API, so a kernel or sandbox may refuse them; callers fall back to one datagram per
// syscall when Unsupported reports that.
package msgx
import (
"syscall"
"unsafe"
"golang.org/x/sys/unix"
)
// Batch is the most messages the callers hand one sendmsg_x or recvmsg_x call.
const Batch = 64
// Hdr mirrors xnu's struct msghdr_x (bsd/sys/socket_private.h), which the SDK doesn't ship. recvmsg_x reports each
// message's length in Datalen rather than in its return value.
type Hdr struct {
Name *byte
Namelen uint32
Iov *unix.Iovec
Iovlen int32
Control *byte
Controllen uint32
Flags int32
Datalen uint64
}
// Send passes hdrs to sendmsg_x on fd and returns how many messages the kernel took. EINTR is retried.
func Send(fd uintptr, hdrs []Hdr) (int, syscall.Errno) {
return call(unix.SYS_SENDMSG_X, fd, hdrs)
}
// Recv passes hdrs to recvmsg_x on fd and returns how many messages it filled. EINTR is retried.
func Recv(fd uintptr, hdrs []Hdr) (int, syscall.Errno) {
return call(unix.SYS_RECVMSG_X, fd, hdrs)
}
func call(trap, fd uintptr, hdrs []Hdr) (int, syscall.Errno) {
if len(hdrs) == 0 {
return 0, syscall.EINVAL
}
for {
r, _, errno := unix.Syscall6(trap, fd, uintptr(unsafe.Pointer(&hdrs[0])), uintptr(len(hdrs)), 0, 0, 0)
switch errno {
case 0:
return int(r), 0
case syscall.EINTR:
default:
return 0, errno
}
}
}
// Unsupported reports whether errno means the kernel or a sandbox refuses the private calls.
func Unsupported(errno syscall.Errno) bool {
return errno == syscall.ENOSYS || errno == syscall.EPERM || errno == syscall.EOPNOTSUPP
}
+79
View File
@@ -0,0 +1,79 @@
package msgx
import (
"bytes"
"syscall"
"testing"
"unsafe"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// TestHdrLayout pins Hdr to struct msghdr_x's LP64 layout: 56 bytes, Datalen last at 48.
func TestHdrLayout(t *testing.T) {
var h Hdr
assert.EqualValues(t, 56, unsafe.Sizeof(h))
assert.EqualValues(t, 48, unsafe.Offsetof(h.Datalen))
}
// TestSendRecvRoundTrip sends a batch through sendmsg_x in one call and reads it back through recvmsg_x in one
// call, each message whole, in order, with Datalen set.
func TestSendRecvRoundTrip(t *testing.T) {
fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_DGRAM, 0)
require.NoError(t, err)
t.Cleanup(func() {
_ = unix.Close(fds[0])
_ = unix.Close(fds[1])
})
// A dropped datagram fails the receive instead of hanging it.
require.NoError(t, unix.SetsockoptTimeval(fds[1], unix.SOL_SOCKET, unix.SO_RCVTIMEO, &unix.Timeval{Sec: 2}))
const n = 5
var want [n][]byte
var iovs [n]unix.Iovec
hdrs := make([]Hdr, n)
for i := range n {
want[i] = bytes.Repeat([]byte{byte(i + 1)}, 10+i)
iovs[i] = unix.Iovec{Base: &want[i][0]}
iovs[i].SetLen(len(want[i]))
hdrs[i] = Hdr{Iov: &iovs[i], Iovlen: 1}
}
sent, errno := Send(uintptr(fds[0]), hdrs)
require.Zero(t, errno)
require.Equal(t, n, sent)
var bufs [n + 1][64]byte
var riovs [n + 1]unix.Iovec
rhdrs := make([]Hdr, n+1)
for i := range rhdrs {
riovs[i] = unix.Iovec{Base: &bufs[i][0]}
riovs[i].SetLen(len(bufs[i]))
rhdrs[i] = Hdr{Iov: &riovs[i], Iovlen: 1}
}
got, errno := Recv(uintptr(fds[1]), rhdrs)
require.Zero(t, errno)
require.Equal(t, n, got)
for i := range n {
l := int(rhdrs[i].Datalen)
assert.Equal(t, want[i], bufs[i][:l], "message %d", i)
}
}
// TestEmptyBatch pins that an empty batch is refused before it reaches the kernel.
func TestEmptyBatch(t *testing.T) {
_, errno := Send(0, nil)
assert.Equal(t, syscall.EINVAL, errno)
_, errno = Recv(0, nil)
assert.Equal(t, syscall.EINVAL, errno)
}
func TestUnsupported(t *testing.T) {
for _, e := range []syscall.Errno{syscall.ENOSYS, syscall.EPERM, syscall.EOPNOTSUPP} {
assert.True(t, Unsupported(e), "%v", e)
}
for _, e := range []syscall.Errno{0, syscall.EAGAIN, syscall.ENOBUFS, syscall.EINVAL} {
assert.False(t, Unsupported(e), "%v", e)
}
}
+62
View File
@@ -435,3 +435,65 @@ func testPP(pkt []byte) *firewall.ParsedPacket {
} }
return pp return pp
} }
// fakeTunBatchWriter records each WriteBatch call and each plain Write separately.
type fakeTunBatchWriter struct {
writes [][]byte
batches [][][]byte
}
func (w *fakeTunBatchWriter) Write(p []byte) (int, error) {
w.writes = append(w.writes, bytes.Clone(p))
return len(p), nil
}
func (w *fakeTunBatchWriter) WriteBatch(pkts [][]byte) error {
var b [][]byte
for _, p := range pkts {
b = append(b, bytes.Clone(p))
}
w.batches = append(w.batches, b)
return nil
}
// TestPassthroughUsesWriteBatch pins that a writer implementing tio.BatchWriter gets the whole
// passthrough lane in one WriteBatch per Flush, in order, and no plain Writes; an empty Flush
// makes no call.
func TestPassthroughUsesWriteBatch(t *testing.T) {
w := &fakeTunBatchWriter{}
m := newTestMultiCoalescer(t, w)
k := &keySeq{epoch: 1}
var want [][]byte
for i := range 5 {
icmp := make([]byte, 28)
icmp[0] = 0x45
icmp[3] = 28
icmp[9] = 1
icmp[20] = byte(i)
want = append(want, icmp)
if err := m.Commit(icmp, k.next(), testPP(icmp)); err != nil {
t.Fatal(err)
}
}
if err := m.Flush(); err != nil {
t.Fatal(err)
}
if err := m.Flush(); err != nil {
t.Fatal(err)
}
if len(w.writes) != 0 {
t.Fatalf("got %d plain Writes, want 0", len(w.writes))
}
if len(w.batches) != 1 {
t.Fatalf("got %d WriteBatch calls, want 1", len(w.batches))
}
for i, p := range w.batches[0] {
if !bytes.Equal(p, want[i]) {
t.Fatalf("packet %d: got % x, want % x", i, p, want[i])
}
}
if len(w.batches[0]) != len(want) {
t.Fatalf("got %d packets, want %d", len(w.batches[0]), len(want))
}
}
+17 -6
View File
@@ -2,18 +2,23 @@ package batch
import ( import (
"io" "io"
"github.com/slackhq/nebula/overlay/tio"
) )
// Passthrough is MultiCoalescer's verbatim lane: no batching, packets are written at Flush in the // Passthrough is MultiCoalescer's verbatim lane: no coalescing, packets are written at Flush in the
// order enqueued. // order enqueued, in one WriteBatch when out implements tio.BatchWriter.
type Passthrough struct { type Passthrough struct {
out io.Writer out io.Writer
bw tio.BatchWriter // nil: Flush writes one packet per Write
slots [][]byte slots [][]byte
} }
func NewPassthrough(w io.Writer) *Passthrough { func NewPassthrough(w io.Writer) *Passthrough {
bw, _ := w.(tio.BatchWriter)
return &Passthrough{ return &Passthrough{
out: w, out: w,
bw: bw,
slots: make([][]byte, 0, 128), slots: make([][]byte, 0, 128),
} }
} }
@@ -26,10 +31,16 @@ func (p *Passthrough) enqueue(pkt []byte) error {
func (p *Passthrough) Flush() error { func (p *Passthrough) Flush() error {
var firstErr error var firstErr error
for _, s := range p.slots { if p.bw != nil {
_, err := p.out.Write(s) if len(p.slots) > 0 {
if err != nil && firstErr == nil { firstErr = p.bw.WriteBatch(p.slots)
firstErr = err }
} else {
for _, s := range p.slots {
_, err := p.out.Write(s)
if err != nil && firstErr == nil {
firstErr = err
}
} }
} }
clear(p.slots) clear(p.slots)
+156
View File
@@ -0,0 +1,156 @@
//go:build darwin || send_pipeline
package batch
import (
"sync"
)
// SendPipeline splits encrypt from send. The producer (a tun reader) encrypts packets into one SendBatch while a
// sender goroutine writes the other, and they swap whenever the sender is free. The sender takes everything the
// producer committed since its last take, so packets that arrive during a write leave together in the next
// WriteBatch, and the reader returns to the tun while the kernel is still sending.
//
// The producer holds the batch for one packet at a time (Begin, reserve and commit, End) so the sender can take the
// batch between any two packets, never while a reserved slot is still being written.
//
// Ownership: the producer touches its batch only between Begin and End, and the sender swaps batches only under
// the same lock, so a slot the producer reserved is never sent half written. A batch goes back to the producer
// only after its WriteBatch returned and it was emptied, so no slot is reused before its send completes.
//
// Memory is bounded at two batches. When the producer fills its batch while the sender is still writing the other,
// Begin waits for the swap. That slows the tun reader instead of dropping, as the unpipelined path does.
//
// Order: a single sender writes batches in the order they were filled, each in commit order, so every peer's
// packets leave in the order their message counters were taken.
type SendPipeline struct {
out batchWriter
cap int
maxWrite int
onWrite func(queued, written int, err error)
mu sync.Mutex
cond sync.Cond
cur *SendBatch // the producer's batch, guarded by mu
gen uint64 // swaps so far, guarded by mu
ready chan struct{} // cap 1: cur may have packets for the sender
stop chan struct{}
done chan struct{}
once sync.Once
}
// NewSendPipeline starts a pipeline over two batches of batchCap slots and arenaSize arena bytes each. It writes
// to out at most maxWrite packets per WriteBatch. If onWrite is not nil, it is called on the sender goroutine
// after every WriteBatch with how many packets that call was given, how many went out, and its error. Close stops
// the pipeline.
func NewSendPipeline(out batchWriter, batchCap, arenaSize, maxWrite int, onWrite func(queued, written int, err error)) *SendPipeline {
batchCap = max(batchCap, 1)
p := &SendPipeline{
out: out,
cap: batchCap,
maxWrite: max(maxWrite, 1),
onWrite: onWrite,
cur: NewSendBatch(out, batchCap, arenaSize),
ready: make(chan struct{}, 1),
stop: make(chan struct{}),
done: make(chan struct{}),
}
p.cond.L = &p.mu
go p.run(NewSendBatch(out, batchCap, arenaSize))
return p
}
// Begin returns a batch with room for at least one more packet. The batch stays the producer's until End. If the
// batch is full, Begin first waits for the sender to swap it out. Producer only.
func (p *SendPipeline) Begin() *SendBatch {
p.mu.Lock()
if p.cur.Len() >= p.cap {
g := p.gen
p.wake()
for p.gen == g {
p.cond.Wait()
}
}
return p.cur
}
// End gives up the batch Begin returned. With wake set it also tells the sender the batch has packets for it, which
// the producer does once a run of packets is in (the end of a tun read) rather than per packet, so the sender takes
// the run whole when it is idle. A sender still writing takes the batch when it finishes, woken or not.
func (p *SendPipeline) End(wake bool) {
n := p.cur.Len()
p.mu.Unlock()
if wake && n > 0 {
p.wake()
}
}
func (p *SendPipeline) wake() {
select {
case p.ready <- struct{}{}:
default:
}
}
// Close writes whatever the producer left in its batch, stops the sender, and waits for it. The producer calls it,
// outside Begin/End, once it is done. Safe to call more than once.
func (p *SendPipeline) Close() {
p.once.Do(func() { close(p.stop) })
<-p.done
}
func (p *SendPipeline) run(mine *SendBatch) {
defer close(p.done)
for {
stopping := false
select {
case <-p.ready:
case <-p.stop:
stopping = true
}
// Keep taking whatever the producer committed during the last write, without waiting to be woken, so a
// busy sender goes straight from one write to the next and each write carries everything that built up.
// Once stopping, the producer is done and this writes what it left.
for p.take(&mine) {
p.write(mine)
}
if stopping {
return
}
}
}
// take swaps the producer's batch for the empty *mine if the producer's has packets, and reports whether it did.
func (p *SendPipeline) take(mine **SendBatch) bool {
p.mu.Lock()
defer p.mu.Unlock()
if p.cur.Len() == 0 {
return false
}
*mine, p.cur = p.cur, *mine
p.gen++
p.cond.Broadcast()
return true
}
// write sends b's packets, maxWrite at a time, then empties b.
func (p *SendPipeline) write(b *SendBatch) {
for off := 0; off < len(b.bufs); {
n := min(p.maxWrite, len(b.bufs)-off)
written, err := p.out.WriteBatch(b.bufs[off:off+n], b.dsts[off:off+n])
if p.onWrite != nil {
p.onWrite(n, written, err)
}
off += n
}
b.recycle()
}
// recycle empties b without writing it. SendPipeline uses it because it writes a batch's packets itself.
func (b *SendBatch) recycle() {
clear(b.bufs)
b.bufs = b.bufs[:0]
b.dsts = b.dsts[:0]
b.arena.Reset()
}
+400
View File
@@ -0,0 +1,400 @@
//go:build darwin || send_pipeline
package batch
import (
"encoding/binary"
"errors"
"net/netip"
"sync"
"testing"
"time"
"unsafe"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/goleak"
)
// pipeWriter records every WriteBatch a SendPipeline makes. It checks each packet's bytes against the sequence
// number they carry while the call is in progress, and can hold a call until the test releases it.
type pipeWriter struct {
t *testing.T
mu sync.Mutex
seqs []uint32
dsts []netip.AddrPort
calls []int
inCall [][]byte // the bufs of the call in progress, for overlap checks
gate chan struct{} // if not nil, each call waits for a receive from it
entered chan int // if not nil, each call sends its size here on entry
short int // each call reports this many fewer written
err error
}
func (w *pipeWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
w.mu.Lock()
w.inCall = bufs
w.mu.Unlock()
if w.entered != nil {
w.entered <- len(bufs)
}
if w.gate != nil {
<-w.gate
}
w.mu.Lock()
defer w.mu.Unlock()
for i, b := range bufs {
seq := binary.BigEndian.Uint32(b)
if !checkPkt(b, seq) {
w.t.Errorf("packet %d changed while being sent", seq)
}
w.seqs = append(w.seqs, seq)
w.dsts = append(w.dsts, addrs[i])
}
w.calls = append(w.calls, len(bufs))
w.inCall = nil
return max(len(bufs)-w.short, 0), w.err
}
func (w *pipeWriter) sent() ([]uint32, []netip.AddrPort, []int) {
w.mu.Lock()
defer w.mu.Unlock()
return append([]uint32(nil), w.seqs...), append([]netip.AddrPort(nil), w.dsts...), append([]int(nil), w.calls...)
}
// fillPkt writes seq and a pattern derived from it into b, as the encrypt step writes a slot.
func fillPkt(b []byte, seq uint32) {
binary.BigEndian.PutUint32(b, seq)
for i := 4; i < len(b); i++ {
b[i] = byte(seq) ^ byte(i)
}
}
func checkPkt(b []byte, seq uint32) bool {
if len(b) < 4 || binary.BigEndian.Uint32(b) != seq {
return false
}
for i := 4; i < len(b); i++ {
if b[i] != byte(seq)^byte(i) {
return false
}
}
return true
}
func pktSize(seq uint32) int { return 16 + int(seq%97) }
var testDsts = []netip.AddrPort{
netip.MustParseAddrPort("10.0.0.1:4242"),
netip.MustParseAddrPort("10.0.0.2:4242"),
netip.MustParseAddrPort("[fd00::3]:4242"),
}
// commit adds packet seq to p the way listenIn does: Begin, reserve, encrypt, commit, End.
func commit(p *SendPipeline, seq uint32, last bool) {
sb := p.Begin()
slot := sb.Reserve(pktSize(seq))
fillPkt(slot, seq)
sb.Commit(slot, testDsts[seq%uint32(len(testDsts))])
p.End(last)
}
func TestSendPipelineOrder(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
// A small arena makes the batches grow theirs, and a small maxWrite splits takes across several writes.
p := NewSendPipeline(w, 16, 64, 5, nil)
const n = 20000
seq := uint32(0)
for seq < n {
// Reads of 1 to 40 packets, with an occasional pause so the sender goes idle and is woken.
read := 1 + int(seq*7%40)
for j := 0; j < read && seq < n; j++ {
commit(p, seq, j == read-1 || seq == n-1)
seq++
}
if seq%1000 < 40 {
time.Sleep(50 * time.Microsecond)
}
}
p.Close()
seqs, dsts, calls := w.sent()
require.Len(t, seqs, n)
for i, s := range seqs {
require.Equal(t, uint32(i), s, "packet %d out of order", i)
require.Equal(t, testDsts[s%uint32(len(testDsts))], dsts[i])
}
for _, c := range calls {
assert.LessOrEqual(t, c, 5, "WriteBatch got more than maxWrite")
assert.Positive(t, c)
}
}
func TestSendPipelineConcurrentPeersKeepOrder(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
// A slow writer makes the sender take many packets per write, interleaving the three peers in each batch.
w := &pipeWriter{t: t}
slow := &slowWriter{pipeWriter: w, d: 20 * time.Microsecond}
p := NewSendPipeline(slow, 128, 128*64, 128, nil)
const n = 5000
for i := uint32(0); i < n; i++ {
commit(p, i, i%8 == 7 || i == n-1)
}
p.Close()
seqs, dsts, _ := w.sent()
require.Len(t, seqs, n)
last := map[netip.AddrPort]int64{}
for i, s := range seqs {
prev, ok := last[dsts[i]]
if ok {
require.Greater(t, int64(s), prev, "peer %v went backwards", dsts[i])
}
last[dsts[i]] = int64(s)
}
}
type slowWriter struct {
*pipeWriter
d time.Duration
}
func (s *slowWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
time.Sleep(s.d)
return s.pipeWriter.WriteBatch(bufs, addrs)
}
// TestSendPipelineBackpressureAndReuse holds the sender inside a write and checks that the producer can fill
// exactly one more batch, that none of its slots overlap the packets being written, and that the next Begin waits
// until the write returns.
func TestSendPipelineBackpressureAndReuse(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
const batchCap = 8
w := &pipeWriter{t: t, gate: make(chan struct{}), entered: make(chan int, 16)}
p := NewSendPipeline(w, batchCap, 64, 128, nil)
seq := uint32(0)
for ; seq < batchCap; seq++ {
commit(p, seq, seq == batchCap-1)
}
require.Equal(t, batchCap, <-w.entered, "sender should take the first batch whole")
w.mu.Lock()
inFlight := append([][]byte(nil), w.inCall...)
w.mu.Unlock()
// The second batch fills while the first is being written, in slots that don't touch the first's bytes.
for ; seq < 2*batchCap; seq++ {
sb := p.Begin()
slot := sb.Reserve(pktSize(seq))
for _, b := range inFlight {
assert.False(t, overlaps(slot, b), "slot for packet %d overlaps packet %d, still being sent", seq, binary.BigEndian.Uint32(b))
}
fillPkt(slot, seq)
sb.Commit(slot, testDsts[0])
p.End(true)
}
// Both batches are now spoken for, so the next Begin must wait for the write to return.
begun := make(chan struct{})
go func() {
commit(p, seq, true)
close(begun)
}()
select {
case <-begun:
t.Fatal("Begin returned with both batches in use: the pipeline is not bounded")
case <-time.After(50 * time.Millisecond):
}
for i, b := range inFlight {
assert.True(t, checkPkt(b, uint32(i)), "packet %d was overwritten before its send completed", i)
}
w.gate <- struct{}{} // first write returns; the sender swaps and starts on the second batch
assert.Equal(t, batchCap, <-w.entered)
select {
case <-begun:
case <-time.After(5 * time.Second):
t.Fatal("Begin did not return after the sender freed a batch")
}
w.gate <- struct{}{}
go func() {
for range w.entered {
w.gate <- struct{}{}
}
}()
p.Close()
close(w.entered)
seqs, _, calls := w.sent()
require.Len(t, seqs, 2*batchCap+1)
for i, s := range seqs {
assert.Equal(t, uint32(i), s)
}
assert.Equal(t, []int{batchCap, batchCap, 1}, calls)
}
func overlaps(a, b []byte) bool {
if len(a) == 0 || len(b) == 0 {
return false
}
a0, b0 := uintptr(unsafe.Pointer(&a[0])), uintptr(unsafe.Pointer(&b[0]))
return a0 < b0+uintptr(len(b)) && b0 < a0+uintptr(len(a))
}
// TestSendPipelineBatchesBuildUp checks the point of the pipeline: while one write is in the kernel, everything the
// producer commits leaves together in the next write.
func TestSendPipelineBatchesBuildUp(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t, gate: make(chan struct{}), entered: make(chan int, 16)}
p := NewSendPipeline(w, 128, 128*64, 128, nil)
commit(p, 0, true)
require.Equal(t, 1, <-w.entered)
// Ten one-packet reads while the first write is held.
for i := uint32(1); i <= 10; i++ {
commit(p, i, true)
}
w.gate <- struct{}{}
require.Equal(t, 10, <-w.entered, "packets queued during a write should go out in one WriteBatch")
w.gate <- struct{}{}
p.Close()
_, _, calls := w.sent()
assert.Equal(t, []int{1, 10}, calls)
}
func TestSendPipelineCloseFlushes(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
p := NewSendPipeline(w, 32, 32*64, 128, nil)
// End(false) never wakes the sender, so only Close's final take sends these.
for i := uint32(0); i < 5; i++ {
commit(p, i, false)
}
p.Close()
p.Close() // idempotent
seqs, _, _ := w.sent()
assert.Equal(t, []uint32{0, 1, 2, 3, 4}, seqs)
}
func TestSendPipelineCloseEmpty(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
p := NewSendPipeline(w, 4, 64, 128, nil)
sb := p.Begin()
p.End(true) // nothing committed: no write
assert.Zero(t, sb.Len())
p.Close()
_, _, calls := w.sent()
assert.Empty(t, calls)
}
// TestSendPipelineCloseWaitsForWrite checks that Close returns only after a write in progress has returned, so the
// caller can't free anything the sender still uses.
func TestSendPipelineCloseWaitsForWrite(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t, gate: make(chan struct{}), entered: make(chan int, 4)}
p := NewSendPipeline(w, 4, 64, 128, nil)
commit(p, 0, true)
<-w.entered
commit(p, 1, false)
closed := make(chan struct{})
go func() {
p.Close()
close(closed)
}()
select {
case <-closed:
t.Fatal("Close returned during a write")
case <-time.After(50 * time.Millisecond):
}
w.gate <- struct{}{}
<-w.entered // Close's final take writes packet 1
w.gate <- struct{}{}
select {
case <-closed:
case <-time.After(5 * time.Second):
t.Fatal("Close did not return")
}
seqs, _, _ := w.sent()
assert.Equal(t, []uint32{0, 1}, seqs)
}
func TestSendPipelineOnWriteAndDrops(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
werr := errors.New("boom")
w := &pipeWriter{t: t, short: 1, err: werr}
type call struct {
queued, written int
err error
}
var got []call
p := NewSendPipeline(w, 16, 16*64, 4, func(q, n int, err error) {
got = append(got, call{q, n, err}) // sender goroutine only
})
for i := uint32(0); i < 10; i++ {
commit(p, i, false)
}
p.Close()
assert.Equal(t, []call{{4, 3, werr}, {4, 3, werr}, {2, 1, werr}}, got)
}
// TestSendPipelineStressRace runs a producer against a sender whose writes take varying time, for the race
// detector, and checks nothing is lost, reordered or overwritten.
func TestSendPipelineStressRace(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
jitter := &jitterWriter{pipeWriter: w}
p := NewSendPipeline(jitter, 32, 256, 16, nil)
const n = 50000
for i := uint32(0); i < n; i++ {
commit(p, i, i%3 == 0)
}
p.Close()
seqs, _, _ := w.sent()
require.Len(t, seqs, n)
for i, s := range seqs {
if uint32(i) != s {
t.Fatalf("packet %d arrived at %d", s, i)
}
}
}
type jitterWriter struct {
*pipeWriter
i int
}
func (j *jitterWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
j.i++
if j.i%7 == 0 {
time.Sleep(time.Duration(j.i%5) * 10 * time.Microsecond)
}
return j.pipeWriter.WriteBatch(bufs, addrs)
}
type discardWriter struct{}
func (discardWriter) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) {
return len(bufs), nil
}
// BenchmarkSendPipeline measures a packet through Begin, reserve, commit and End with a writer that costs nothing;
// its allocs/op is the pipeline's steady-state heap cost per packet.
func BenchmarkSendPipeline(b *testing.B) {
p := NewSendPipeline(discardWriter{}, SendBatchCap, SendBatchCap*1500, 128, nil)
defer p.Close()
b.ReportAllocs()
for i := range b.N {
sb := p.Begin()
sb.Commit(sb.Reserve(1400), testDsts[0])
p.End(i%8 == 7)
}
}
+11
View File
@@ -145,3 +145,14 @@ func SupportsGSO(w io.Writer, want GSOProto) (GSOWriter, bool) {
return gw, false return gw, false
} }
} }
// BatchWriter is implemented by Queues that can emit several already-segmented packets in one call.
// Backends without a batched write do not implement it and callers loop over Write.
//
// pkts are borrowed: WriteBatch must not retain them past its return.
// A returned error doesn't say which packets were delivered, so callers must not retry the batch.
// Safe for concurrent use, like Write.
type BatchWriter interface {
io.Writer
WriteBatch(pkts [][]byte) error
}
+404 -9
View File
@@ -8,12 +8,14 @@ import (
"log/slog" "log/slog"
"net/netip" "net/netip"
"os" "os"
"sync"
"sync/atomic" "sync/atomic"
"syscall" "syscall"
"unsafe" "unsafe"
"github.com/gaissmai/bart" "github.com/gaissmai/bart"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/internal/msgx"
"github.com/slackhq/nebula/overlay/tio" "github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/routing" "github.com/slackhq/nebula/routing"
"github.com/slackhq/nebula/util" "github.com/slackhq/nebula/util"
@@ -33,8 +35,23 @@ type tun struct {
// and routes for it. NEPacketTunnelProvider on darwin does this. // and routes for it. NEPacketTunnelProvider on darwin does this.
hostOwned bool hostOwned bool
l *slog.Logger l *slog.Logger
// batchMu guards batch, WriteBatch's sendmsg_x scratch.
batchMu sync.Mutex
batch tunBatch
} }
// tunBatch is WriteBatch's scratch. The kernel reads every entry in place.
type tunBatch struct {
heads [msgx.Batch][4]byte
iovs [msgx.Batch][2]unix.Iovec
hdrs [msgx.Batch]msgx.Hdr
pkts [msgx.Batch][]byte
}
// noTunSendX is set once sendmsg_x is refused on the tun; WriteBatch then writes one packet at a time.
var noTunSendX atomic.Bool
type ifReq struct { type ifReq struct {
Name [unix.IFNAMSIZ]byte Name [unix.IFNAMSIZ]byte
Flags uint16 Flags uint16
@@ -615,16 +632,12 @@ func (t *tun) Write(from []byte) (int, error) {
return 0, syscall.EIO return 0, syscall.EIO
} }
ipVer := from[0] >> 4
var head [4]byte var head [4]byte
switch ipVer { af, err := tunAF(from)
case 4: if err != nil {
head[3] = syscall.AF_INET return 0, err
case 6:
head[3] = syscall.AF_INET6
default:
return 0, fmt.Errorf("unable to determine IP version from packet")
} }
head[3] = af
// Grab rc as a local so the compiler can devirtualize the call and keep the closure on the stack. // Grab rc as a local so the compiler can devirtualize the call and keep the closure on the stack.
rc, err := t.f.SyscallConn() rc, err := t.f.SyscallConn()
@@ -657,6 +670,129 @@ func (t *tun) Write(from []byte) (int, error) {
return n - 4, nil return n - 4, nil
} }
// tunAF returns the utun address-family prefix byte for an IP packet.
func tunAF(pkt []byte) (byte, error) {
switch pkt[0] >> 4 {
case 4:
return syscall.AF_INET, nil
case 6:
return syscall.AF_INET6, nil
default:
return 0, fmt.Errorf("unable to determine IP version from packet")
}
}
// WriteBatch writes pkts to the utun device with sendmsg_x, up to msgx.Batch packets per syscall. utun is a
// connected datagram socket, so xnu takes the batched send path, though it still hands utun each packet on its own:
// this saves syscalls, not per-packet kernel work. Safe for concurrent use.
//
// An empty packet or one with no IP version is skipped and reported, as Write would. A short count goes on with the
// rest; EMSGSIZE, which sendmsg_x returns only when the first packet is past the send buffer, sends that one through
// Write, which reports it. Any other error means the kernel took an unknown prefix and dropped the rest, so it is
// reported rather than retried, which could deliver packets twice. Under mbuf exhaustion sendmsg_x reports packets it
// freed unsent as a short count, so they are lost where writev would have delivered them.
func (t *tun) WriteBatch(pkts [][]byte) error {
if noTunSendX.Load() {
return t.writeEach(pkts)
}
t.batchMu.Lock()
defer t.batchMu.Unlock()
b := &t.batch
var firstErr error
keep := func(err error) {
if err != nil && firstErr == nil {
firstErr = err
}
}
for len(pkts) > 0 {
n := 0
for len(pkts) > 0 && n < msgx.Batch {
p := pkts[0]
pkts = pkts[1:]
if len(p) == 0 {
keep(syscall.EIO)
continue
}
af, err := tunAF(p)
if err != nil {
keep(err)
continue
}
b.heads[n] = [4]byte{3: af}
b.iovs[n] = [2]unix.Iovec{{Base: &b.heads[n][0], Len: 4}, {Base: &p[0], Len: uint64(len(p))}}
b.hdrs[n] = msgx.Hdr{Iov: &b.iovs[n][0], Iovlen: 2}
b.pkts[n] = p
n++
}
for off := 0; off < n; {
sent, err := t.sendmsgX(b.hdrs[off:n])
switch {
case err == nil && sent > 0:
off += sent
case err == nil:
keep(t.writeEach(b.pkts[off:n]))
off = n
case err == unix.EMSGSIZE:
keep(t.writeEach(b.pkts[off : off+1]))
off++
case isUnsupported(err):
if noTunSendX.CompareAndSwap(false, true) {
t.l.Warn("sendmsg_x unavailable on the tun device, writing one packet per syscall", "error", err)
}
keep(t.writeEach(b.pkts[off:n]))
keep(t.writeEach(pkts))
pkts, off = nil, n
default:
keep(err)
off = n
}
}
clear(b.iovs[:n])
clear(b.pkts[:n])
}
return firstErr
}
// sendmsgX hands hdrs to sendmsg_x, waiting while the socket is full, and returns how many the kernel took.
func (t *tun) sendmsgX(hdrs []msgx.Hdr) (int, error) {
rc, err := t.f.SyscallConn()
if err != nil {
return 0, err
}
var sent int
var errno syscall.Errno
err = rc.Write(func(fd uintptr) bool {
sent, errno = msgx.Send(fd, hdrs)
// sendmsg_x reports EAGAIN only when it took nothing; a partial batch returns its count.
return errno != syscall.EAGAIN
})
if err != nil {
return 0, err
}
if errno != 0 {
return 0, errno
}
return sent, nil
}
func isUnsupported(err error) bool {
errno, ok := err.(syscall.Errno)
return ok && msgx.Unsupported(errno)
}
// writeEach writes pkts one at a time with Write.
func (t *tun) writeEach(pkts [][]byte) error {
var firstErr error
for _, p := range pkts {
if _, err := t.Write(p); err != nil && firstErr == nil {
firstErr = err
}
}
return firstErr
}
func (t *tun) Networks() []netip.Prefix { func (t *tun) Networks() []netip.Prefix {
return t.vpnNetworks return t.vpnNetworks
} }
@@ -666,5 +802,264 @@ func (t *tun) Name() string {
} }
func (t *tun) Queues(int) ([]tio.Queue, error) { func (t *tun) Queues(int) ([]tio.Queue, error) {
return []tio.Queue{tio.NewSingleQueue(t, defaultBatchBufSize)}, nil return []tio.Queue{newTunQueue(t)}, nil
}
// tunReadBatch is the most packets one tunQueue.Read returns.
const tunReadBatch = msgx.Batch
// tunRecvXSlot is each recvmsg_x entry's packet buffer. recvmsg_x lays its buffers out before it knows the packet
// sizes, so each gets room for the largest IP packet; the kernel only touches what it writes.
const tunRecvXSlot = defaultBatchBufSize
// tunRecvXStride is how far apart the slots start: 64 byte aligned, and one cache line more than 64KiB so the packet
// starts don't all land in the same cache sets.
const tunRecvXStride = 65536 + 64
// tunQueue is the darwin tun's Queue. Read hands back every packet already queued on the utun, up to tunReadBatch, so
// the caller encrypts and sends them as one batch rather than one per wakeup. It reads them with one recvmsg_x when
// it can and one readv per packet otherwise.
type tunQueue struct {
t *tun
// buf holds the packets Read returns: recvmsg_x's slots, or, for readv, one arena. readv stops once less than
// defaultBatchBufSize of it is left, so every readv has room for the largest packet utun can return.
buf []byte
pkts [tunReadBatch]tio.Packet
// x is the recvmsg_x scratch, nil once recvmsg_x is off for good.
x *tunRecvX
}
// tunRecvX is the recvmsg_x scratch. Entry i scatters its AF prefix into heads[i] and its packet into slot i of the
// queue's buf; the kernel reads and writes every entry in place.
type tunRecvX struct {
heads [tunReadBatch][4]byte
iovs [tunReadBatch][2]unix.Iovec
hdrs [tunReadBatch]msgx.Hdr
}
// newTunQueue returns t's Queue, raising t's pending packet limit first so a read can find more than one.
func newTunQueue(t *tun) *tunQueue {
t.raisePendingPackets()
q := &tunQueue{t: t, buf: make([]byte, tunReadBatch*tunRecvXStride), x: &tunRecvX{}}
x := q.x
for i := range x.hdrs {
x.iovs[i] = [2]unix.Iovec{
{Base: &x.heads[i][0], Len: 4},
{Base: &q.buf[i*tunRecvXStride], Len: tunRecvXSlot},
}
x.hdrs[i] = msgx.Hdr{Iov: &x.iovs[i][0], Iovlen: 2}
}
return q
}
// Read waits for the utun to become readable, then returns the packets queued on it.
func (q *tunQueue) Read() ([]tio.Packet, error) {
if q.x != nil {
if pkts, err, ok := q.readX(); ok {
return pkts, err
}
}
return q.readv()
}
// tunRecvmsgX is msgx.Recv; tests swap it to inject results.
var tunRecvmsgX = msgx.Recv
// readX reads up to tunReadBatch packets with one recvmsg_x. ok is false when the caller should read with readv
// instead: recvmsg_x failed this time, or has been turned off for good. A batch that fails tunRecvXCheck is dropped:
// its packets are off the socket, but their lengths can't be trusted.
func (q *tunQueue) readX() (pkts []tio.Packet, err error, ok bool) {
rc, err := q.t.f.SyscallConn()
if err != nil {
return nil, err, true
}
x := q.x
var n int
var errno syscall.Errno
err = rc.Read(func(fd uintptr) bool {
for i := range x.hdrs {
x.hdrs[i].Flags = 0
x.hdrs[i].Datalen = 0
}
n, errno = tunRecvmsgX(fd, x.hdrs[:])
return errno != unix.EAGAIN
})
if err != nil {
return nil, err, true
}
if tunRecvXRefused(errno) {
q.disableX("unavailable", errno)
return nil, nil, false
}
if errno != 0 {
// recvmsg_x can fail where readv wouldn't (a kernel allocation, say), so let readv read this wakeup and
// report the error if it is real.
return nil, nil, false
}
if cerr := tunRecvXCheck(n, x.hdrs[:], x.heads[:], tunRecvXSlot); cerr != nil {
q.disableX("returned an unexpected batch", cerr)
return nil, nil, false
}
for i := range n {
off := i * tunRecvXStride
end := off + int(x.hdrs[i].Datalen) - 4
q.pkts[i] = tio.Packet{Bytes: q.buf[off:end:end]}
}
// n is 0 at end of file, as readv's short read is.
return q.pkts[:n], nil, true
}
// tunRecvXRefused reports whether a recvmsg_x errno means it will never work here: msgx.Unsupported's refusals, and
// EINVAL and EMSGSIZE, which with the headers newTunQueue builds come only from xnu rejecting their layout.
func tunRecvXRefused(errno syscall.Errno) bool {
return msgx.Unsupported(errno) || errno == unix.EINVAL || errno == unix.EMSGSIZE
}
// disableX turns recvmsg_x off for q for good. readv keeps reading into buf.
func (q *tunQueue) disableX(why string, err error) {
q.x = nil
q.t.l.Warn("recvmsg_x "+why+" on the tun device, reading one packet per syscall", "error", err)
}
// tunRecvXCheck rejects a recvmsg_x batch of n entries that intact msghdr_x entries can't produce, which would mean
// the private layout changed under us: more entries than headers, one past its 4 byte head plus slot byte buffer or
// too short to hold the head, or an AF prefix utun never writes. A slot holds the largest IP packet, so nothing is
// ever truncated; xnu's default recvmsg_x path doesn't report MSG_TRUNC per entry anyway, only its SO_DONTTRUNC path
// does, and that is checked too.
func tunRecvXCheck(n int, hdrs []msgx.Hdr, heads [][4]byte, slot int) error {
if n < 0 || n > len(hdrs) || n > len(heads) {
return fmt.Errorf("returned %d packets for %d headers", n, len(hdrs))
}
for i := range n {
h := &hdrs[i]
if h.Flags&unix.MSG_TRUNC != 0 {
return fmt.Errorf("packet %d came back truncated, flags %#x", i, h.Flags)
}
if h.Datalen < 4 || h.Datalen > uint64(4+slot) {
return fmt.Errorf("packet %d is %d bytes, outside the 4 to %d the buffers allow", i, h.Datalen, 4+slot)
}
switch heads[i] {
case [4]byte{3: syscall.AF_INET}, [4]byte{3: syscall.AF_INET6}:
default:
return fmt.Errorf("packet %d has AF prefix % x", i, heads[i])
}
}
return nil
}
// readv reads packets one readv at a time until the utun would block. An error after at least one packet is dropped
// in favor of returning those packets; a persistent one recurs on the next Read.
func (q *tunQueue) readv() ([]tio.Packet, error) {
rc, err := q.t.f.SyscallConn()
if err != nil {
return nil, err
}
var head [4]byte
n, off := 0, 0
var callErr error
err = rc.Read(func(fd uintptr) bool {
for n < tunReadBatch && len(q.buf)-off >= defaultBatchBufSize {
iovecs := [2]unix.Iovec{
{Base: &head[0], Len: 4},
{Base: &q.buf[off], Len: uint64(len(q.buf) - off)},
}
l, e := tunReadv(int(fd), iovecs[:])
if e != nil {
if errno, ok := e.(syscall.Errno); ok && errno.Temporary() {
// Park on the poller only while there is nothing to hand back.
return n > 0
}
callErr = e
return true
}
if l < 4 {
// A datagram too short to carry the AF prefix, or end of file; stop rather than spin on it.
return true
}
end := off + l - 4
q.pkts[n] = tio.Packet{Bytes: q.buf[off:end:end]}
n++
off = end
}
return true
})
if n > 0 {
return q.pkts[:n], nil
}
if err != nil {
return nil, err
}
return nil, callErr
}
func (q *tunQueue) Write(p []byte) (int, error) { return q.t.Write(p) }
func (q *tunQueue) WriteBatch(pkts [][]byte) error { return q.t.WriteBatch(pkts) }
func (q *tunQueue) Close() error { return q.t.Close() }
// xnu lets one packet wait on a utun control socket by default (if_utun.c utun_ctl_bind): utun_start stops moving
// packets from the interface's send queue to the socket once one is waiting, and resumes only when a read wakes the
// interface's starter thread. So every read finds one packet. tunPendingPackets lets a whole read batch wait
// instead (_UTUN_OPT_MAX_PENDING_PACKETS, bsd/net/if_utun.h, set at SYSPROTO_CONTROL level).
const (
tunPendingPackets = tunReadBatch
_UTUN_OPT_MAX_PENDING_PACKETS = 16
_SYSPROTO_CONTROL = 2
)
// tunSetsockoptInt and tunGetsockoptInt are setsockopt and getsockopt; tests swap them.
var (
tunSetsockoptInt = unix.SetsockoptInt
tunGetsockoptInt = unix.GetsockoptInt
)
// raisePendingPackets lets up to tunPendingPackets packets wait on the utun control socket, first growing its
// receive buffer to hold that many packets and their 4 byte AF prefix: utun drops a packet the buffer has no room
// for, while one over the limit waits in the interface's queue. It sizes for the larger of tun.mtu and the device's
// current MTU. Failures are logged and leave xnu's default; the tun works either way.
func (t *tun) raisePendingPackets() {
if t.f == nil {
return
}
rc, err := t.f.SyscallConn()
if err != nil {
return
}
mtu := max(t.DefaultMTU, t.currentMTU())
_ = rc.Control(func(fd uintptr) {
pending := tunPendingPackets
need := pending * (mtu + 4)
if have, err := tunGetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF); err == nil && have < need {
if err := tunSetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF, need); err != nil {
pending = max(have/(mtu+4), 1)
t.l.Warn("could not grow the tun control socket's receive buffer, capping pending packets",
"error", err, "rcvbuf", have, "wanted", need, "pending", pending)
}
}
if err := tunSetsockoptInt(int(fd), _SYSPROTO_CONTROL, _UTUN_OPT_MAX_PENDING_PACKETS, pending); err != nil {
t.l.Warn("could not raise the tun's pending packet limit, reads will return one packet each",
"error", err, "pending", pending)
}
})
}
// currentMTU is the utun's MTU as the kernel has it now, or 0 if that can't be read. A host-owned device's MTU
// comes from the host, not tun.mtu.
func (t *tun) currentMTU() int {
if t.Device == "" {
return 0
}
s, err := unix.Socket(unix.AF_INET, unix.SOCK_DGRAM, unix.IPPROTO_IP)
if err != nil {
return 0
}
defer unix.Close(s)
ifr, err := unix.IoctlGetIfreqMTU(s, t.Device)
if err != nil {
return 0
}
return int(ifr.MTU)
} }
+637
View File
@@ -0,0 +1,637 @@
//go:build !ios && !e2e_testing
package overlay
import (
"bytes"
"os"
"sync/atomic"
"syscall"
"testing"
"time"
"github.com/slackhq/nebula/internal/msgx"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// newSocketpairTun returns a tun writing to one end of a connected AF_UNIX datagram socketpair, which
// takes sendmsg_x the way a utun control socket does, and the other end's fd for reading back.
// sndbuf is the writer's send buffer, which caps the largest datagram it accepts.
func newSocketpairTun(t *testing.T, sndbuf int) (*tun, int) {
t.Helper()
fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_DGRAM, 0)
require.NoError(t, err)
require.NoError(t, unix.SetsockoptInt(fds[0], unix.SOL_SOCKET, unix.SO_SNDBUF, sndbuf))
require.NoError(t, unix.SetsockoptInt(fds[1], unix.SOL_SOCKET, unix.SO_RCVBUF, 1<<20))
// A dropped datagram fails the read-back instead of hanging it.
require.NoError(t, unix.SetsockoptTimeval(fds[1], unix.SOL_SOCKET, unix.SO_RCVTIMEO, &unix.Timeval{Sec: 2}))
require.NoError(t, unix.SetNonblock(fds[0], true))
f := os.NewFile(uintptr(fds[0]), "socketpair")
t.Cleanup(func() {
_ = f.Close()
_ = unix.Close(fds[1])
})
return &tun{f: f, l: test.NewLogger()}, fds[1]
}
// testTunPkt returns packet i of size bytes, alternating IPv4 and IPv6, and the datagram the utun
// device should receive for it.
func testTunPkt(i, size int) (pkt, wire []byte) {
pkt = make([]byte, size)
pkt[0] = 0x45
af := byte(syscall.AF_INET)
if i%2 == 1 {
pkt[0] = 0x60
af = syscall.AF_INET6
}
pkt[1] = byte(i)
pkt[2] = byte(i >> 8)
return pkt, append([]byte{0, 0, 0, af}, pkt...)
}
// readTunBack asserts r receives exactly want, in order.
func readTunBack(t *testing.T, r int, want [][]byte) {
t.Helper()
buf := make([]byte, 4096)
for i, w := range want {
n, _, err := unix.Recvfrom(r, buf, 0)
require.NoError(t, err, "datagram %d", i)
if !bytes.Equal(w, buf[:n]) {
t.Fatalf("datagram %d: got % x, want % x", i, buf[:n], w)
}
}
_, _, err := unix.Recvfrom(r, buf, unix.MSG_DONTWAIT)
assert.ErrorIs(t, err, unix.EAGAIN, "extra datagrams delivered")
}
// forEachTunWritePath runs fn once over sendmsg_x and once over the per-packet writev fallback.
func forEachTunWritePath(t *testing.T, fn func(t *testing.T, fallback bool)) {
for _, fallback := range []bool{false, true} {
name := "sendmsg_x"
if fallback {
name = "writev"
}
t.Run(name, func(t *testing.T) {
noTunSendX.Store(fallback)
t.Cleanup(func() { noTunSendX.Store(false) })
fn(t, fallback)
})
}
}
// TestTunWriteBatch pins that WriteBatch delivers every packet whole, in order and behind the right
// utun AF prefix, across several sendmsg_x calls, and returns nil.
func TestTunWriteBatch(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
tn, r := newSocketpairTun(t, 1<<20)
var pkts, want [][]byte
for i := range 3*msgx.Batch + 5 {
p, w := testTunPkt(i, 60+i)
pkts = append(pkts, p)
want = append(want, w)
}
require.NoError(t, tn.WriteBatch(pkts))
assert.Equal(t, fallback, noTunSendX.Load())
readTunBack(t, r, want)
})
}
// TestTunWriteBatchSkipsInvalid pins that an empty packet or one with no IP version is skipped
// without shifting the packets after it, and that the first such error is the one reported.
func TestTunWriteBatchSkipsInvalid(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
tn, r := newSocketpairTun(t, 1<<20)
var pkts, want [][]byte
for i := range 20 {
p, w := testTunPkt(i, 60)
pkts = append(pkts, p)
want = append(want, w)
}
pkts = append(pkts[:10], append([][]byte{{0x10, 1, 2}, {}}, pkts[10:]...)...)
err := tn.WriteBatch(pkts)
assert.ErrorContains(t, err, "IP version")
readTunBack(t, r, want)
})
}
// TestTunWriteBatchOversize pins that a packet larger than the socket's send buffer drops only
// itself and is reported, whether sendmsg_x reaches it mid-call (a short count) or first (EMSGSIZE
// for the whole call). The send buffer is 1024 bytes and the oversize packet 2000.
func TestTunWriteBatchOversize(t *testing.T) {
for _, tc := range []struct {
name string
at int
}{
{"mid-call", msgx.Batch + 6},
{"first-in-call", msgx.Batch},
} {
t.Run(tc.name, func(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
tn, r := newSocketpairTun(t, 1024)
var pkts, want [][]byte
for i := range 2*msgx.Batch + 10 {
size := 100
if i == tc.at {
size = 2000
}
p, w := testTunPkt(i, size)
pkts = append(pkts, p)
if i != tc.at {
want = append(want, w)
}
}
err := tn.WriteBatch(pkts)
assert.ErrorIs(t, err, unix.EMSGSIZE)
assert.Equal(t, fallback, noTunSendX.Load())
readTunBack(t, r, want)
})
})
}
}
// forEachTunReadPath runs fn once over recvmsg_x and once over the per-packet readv drain.
func forEachTunReadPath(t *testing.T, fn func(t *testing.T, newQ func(*tun) *tunQueue)) {
for _, recvX := range []bool{true, false} {
name := "recvmsg_x"
if !recvX {
name = "readv"
}
t.Run(name, func(t *testing.T) {
fn(t, func(tn *tun) *tunQueue {
q := newTunQueue(tn)
if !recvX {
q.x = nil
}
return q
})
})
}
}
// writeTunPkts writes n test packets of size bytes to the peer end w and returns the packets the tun should hand back
// for them.
func writeTunPkts(t *testing.T, w, n, size int) [][]byte {
t.Helper()
var want [][]byte
for i := range n {
pkt, wire := testTunPkt(i, size+i)
_, err := unix.Write(w, wire)
require.NoError(t, err)
want = append(want, pkt)
}
return want
}
// newReadTun is newSocketpairTun with the tun's receive buffer big enough for every test burst, since an AF_UNIX
// datagram send is bounded by the receiver's buffer, and the writer's send buffer big enough for the largest IP packet.
func newReadTun(t *testing.T) (*tun, int) {
t.Helper()
tn, w := newSocketpairTun(t, 1<<20)
require.NoError(t, unix.SetsockoptInt(w, unix.SOL_SOCKET, unix.SO_SNDBUF, 1<<18))
rc, err := tn.f.SyscallConn()
require.NoError(t, err)
require.NoError(t, rc.Control(func(fd uintptr) {
require.NoError(t, unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF, 1<<20))
}))
return tn, w
}
// readTunPkts calls q.Read once per entry of sizes, requires each to return that many packets, and returns copies of
// them all.
func readTunPkts(t *testing.T, q *tunQueue, sizes ...int) [][]byte {
t.Helper()
var got [][]byte
for _, size := range sizes {
pkts, err := q.Read()
require.NoError(t, err)
require.Len(t, pkts, size)
for _, p := range pkts {
got = append(got, p.Clone().Bytes)
}
}
return got
}
// stubTunRecvmsgX swaps tunRecvmsgX for fn until the test ends and counts its calls. fn gets the real msgx.Recv to
// delegate to.
func stubTunRecvmsgX(t *testing.T, fn func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno)) *atomic.Int64 {
t.Helper()
sys := tunRecvmsgX
var calls atomic.Int64
tunRecvmsgX = func(fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
calls.Add(1)
return fn(sys, fd, hdrs)
}
t.Cleanup(func() { tunRecvmsgX = sys })
return &calls
}
// TestTunQueueReadDrains pins that Read hands back every queued packet, AF prefix stripped and in order, capped at
// tunReadBatch per call, and doesn't wait for more once the queue is empty.
func TestTunQueueReadDrains(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newReadTun(t)
q := newQ(tn)
want := writeTunPkts(t, w, tunReadBatch+3, 60)
assert.Equal(t, want, readTunPkts(t, q, tunReadBatch, 3))
})
}
// TestTunQueueReadUsesRecvX pins that a burst is read with one recvmsg_x, not one call per packet.
func TestTunQueueReadUsesRecvX(t *testing.T) {
calls := stubTunRecvmsgX(t, func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
return sys(fd, hdrs)
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
want := writeTunPkts(t, w, 10, 60)
assert.Equal(t, want, readTunPkts(t, q, 10))
assert.EqualValues(t, 1, calls.Load())
assert.NotNil(t, q.x)
}
// TestTunQueueReadLargePackets pins that packets up to the largest IP packet come back whole, which on the recvmsg_x
// path means each lands in its own slot and none spills into the next.
func TestTunQueueReadLargePackets(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newReadTun(t)
q := newQ(tn)
var want [][]byte
for i, size := range []int{65535, 1, 9001, 65535} {
pkt, wire := testTunPkt(i, max(size, 3))
pkt, wire = pkt[:size], wire[:4+size]
_, err := unix.Write(w, wire)
require.NoError(t, err)
want = append(want, pkt)
}
assert.Equal(t, want, readTunPkts(t, q, 4))
})
}
// TestTunQueueReadClipsPackets pins that each returned packet's capacity ends at its own bytes, so appending to one
// can't overwrite the next.
func TestTunQueueReadClipsPackets(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newSocketpairTun(t, 1<<20)
q := newQ(tn)
writeTunPkts(t, w, 2, 100)
pkts, err := q.Read()
require.NoError(t, err)
require.Len(t, pkts, 2)
assert.Equal(t, len(pkts[0].Bytes), cap(pkts[0].Bytes))
assert.Equal(t, len(pkts[1].Bytes), cap(pkts[1].Bytes))
})
}
// TestTunQueueReadDoesNotAllocate pins both read paths to zero allocations per Read once the queue exists.
func TestTunQueueReadDoesNotAllocate(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newReadTun(t)
q := newQ(tn)
_, wire := testTunPkt(0, 1300)
allocs := testing.AllocsPerRun(1000, func() {
if _, err := unix.Write(w, wire); err != nil {
t.Fatal(err)
}
if pkts, err := q.Read(); err != nil || len(pkts) != 1 {
t.Fatalf("read %d packets: %v", len(pkts), err)
}
})
assert.Zero(t, allocs)
})
}
// TestTunQueueReadXRefused pins that recvmsg_x being refused turns it off for good, and that the same Read still
// hands back the queued packets through readv.
func TestTunQueueReadXRefused(t *testing.T) {
for _, errno := range []syscall.Errno{unix.ENOSYS, unix.EPERM, unix.EOPNOTSUPP, unix.EINVAL} {
t.Run(errno.Error(), func(t *testing.T) {
calls := stubTunRecvmsgX(t, func(func(uintptr, []msgx.Hdr) (int, syscall.Errno), uintptr, []msgx.Hdr) (int, syscall.Errno) {
return 0, errno
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
want := writeTunPkts(t, w, 5, 60)
assert.Equal(t, want, readTunPkts(t, q, 5))
assert.Nil(t, q.x)
assert.EqualValues(t, 1, calls.Load())
want = writeTunPkts(t, w, 2, 60)
assert.Equal(t, want, readTunPkts(t, q, 2))
assert.EqualValues(t, 1, calls.Load(), "recvmsg_x was tried again after it was refused")
})
}
}
// TestTunQueueReadXTransientError pins that an error from recvmsg_x that doesn't mean it is refused leaves this Read
// to readv but keeps recvmsg_x on for the next.
func TestTunQueueReadXTransientError(t *testing.T) {
var failed atomic.Bool
calls := stubTunRecvmsgX(t, func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
if !failed.Swap(true) {
return 0, unix.ENOBUFS
}
return sys(fd, hdrs)
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
want := writeTunPkts(t, w, 3, 60)
assert.Equal(t, want, readTunPkts(t, q, 3))
assert.NotNil(t, q.x)
assert.EqualValues(t, 1, calls.Load())
want = writeTunPkts(t, w, 2, 60)
assert.Equal(t, want, readTunPkts(t, q, 2))
assert.EqualValues(t, 2, calls.Load(), "recvmsg_x wasn't tried again after a transient error")
}
// TestTunQueueReadXParks pins that EAGAIN from recvmsg_x parks the Read until the utun is readable, rather than
// falling back or returning an empty batch.
func TestTunQueueReadXParks(t *testing.T) {
var failed atomic.Bool
calls := stubTunRecvmsgX(t, func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
if !failed.Swap(true) {
return 0, unix.EAGAIN
}
return sys(fd, hdrs)
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
// A real EAGAIN means nothing is queued, so the packet arrives only once Read has parked. One packet, so the
// wakeup can't split it across Reads.
done := make(chan struct{})
go func() {
defer close(done)
time.Sleep(50 * time.Millisecond)
_, wire := testTunPkt(0, 60)
_, _ = unix.Write(w, wire)
}()
t.Cleanup(func() { <-done })
pkt, _ := testTunPkt(0, 60)
assert.Equal(t, [][]byte{pkt}, readTunPkts(t, q, 1))
assert.NotNil(t, q.x)
// A spurious wakeup costs another EAGAIN, so only a floor.
assert.GreaterOrEqual(t, calls.Load(), int64(2))
}
// TestTunQueueReadXBadBatch pins that a recvmsg_x batch no intact header could produce turns recvmsg_x off for good
// and hands the Read to readv. The stub reports a bad batch without taking any packets, so readv then reads them all.
func TestTunQueueReadXBadBatch(t *testing.T) {
v4 := [4]byte{3: syscall.AF_INET}
for _, tc := range []struct {
name string
mess func(x *tunRecvX) int
}{
{"too many", func(x *tunRecvX) int {
for i := range x.hdrs {
x.hdrs[i].Datalen, x.heads[i] = 64, v4
}
return len(x.hdrs) + 1
}},
{"past the buffer", func(x *tunRecvX) int {
x.hdrs[0].Datalen, x.heads[0] = 4+tunRecvXSlot+1, v4
return 1
}},
{"bad AF prefix", func(x *tunRecvX) int {
x.hdrs[0].Datalen, x.heads[0] = 64, [4]byte{syscall.AF_INET}
return 1
}},
} {
t.Run(tc.name, func(t *testing.T) {
var q *tunQueue
stubTunRecvmsgX(t, func(func(uintptr, []msgx.Hdr) (int, syscall.Errno), uintptr, []msgx.Hdr) (int, syscall.Errno) {
return tc.mess(q.x), 0
})
tn, w := newReadTun(t)
q = newTunQueue(tn)
want := writeTunPkts(t, w, 4, 60)
assert.Equal(t, want, readTunPkts(t, q, 4))
assert.Nil(t, q.x)
})
}
}
// TestTunRecvXCheck pins which recvmsg_x batches tunRecvXCheck accepts.
func TestTunRecvXCheck(t *testing.T) {
const slot = 1000
v4, v6 := [4]byte{3: syscall.AF_INET}, [4]byte{3: syscall.AF_INET6}
good := func() ([]msgx.Hdr, [][4]byte) {
hdrs := make([]msgx.Hdr, 4)
heads := make([][4]byte, 4)
for i := range hdrs {
hdrs[i].Datalen = uint64(4 + 20 + i)
heads[i] = v4
if i%2 == 1 {
heads[i] = v6
}
}
return hdrs, heads
}
for _, tc := range []struct {
name string
n int
mess func(hdrs []msgx.Hdr, heads [][4]byte)
ok bool
}{
{"all", 4, nil, true},
{"none", 0, nil, true},
{"prefix", 2, nil, true},
{"garbage past n is ignored", 2, func(h []msgx.Hdr, hd [][4]byte) { h[3].Datalen, hd[3] = 1<<40, [4]byte{9} }, true},
{"just the AF prefix", 1, func(h []msgx.Hdr, _ [][4]byte) { h[0].Datalen = 4 }, true},
{"fills the slot", 1, func(h []msgx.Hdr, _ [][4]byte) { h[0].Datalen = 4 + slot }, true},
{"more than headers", 5, nil, false},
{"negative", -1, nil, false},
{"past the slot", 2, func(h []msgx.Hdr, _ [][4]byte) { h[1].Datalen = 4 + slot + 1 }, false},
{"shorter than the AF prefix", 1, func(h []msgx.Hdr, _ [][4]byte) { h[0].Datalen = 3 }, false},
{"truncated", 3, func(h []msgx.Hdr, _ [][4]byte) { h[2].Flags = unix.MSG_TRUNC }, false},
{"zero AF prefix", 1, func(_ []msgx.Hdr, hd [][4]byte) { hd[0] = [4]byte{} }, false},
{"host order AF prefix", 1, func(_ []msgx.Hdr, hd [][4]byte) { hd[0] = [4]byte{syscall.AF_INET} }, false},
{"other AF", 2, func(_ []msgx.Hdr, hd [][4]byte) { hd[1] = [4]byte{3: syscall.AF_UNIX} }, false},
} {
t.Run(tc.name, func(t *testing.T) {
hdrs, heads := good()
if tc.mess != nil {
tc.mess(hdrs, heads)
}
err := tunRecvXCheck(tc.n, hdrs, heads, slot)
if tc.ok {
assert.NoError(t, err)
} else {
assert.Error(t, err)
}
})
}
}
// TestTunRecvXRefused pins which recvmsg_x errnos turn it off for good.
func TestTunRecvXRefused(t *testing.T) {
for _, errno := range []syscall.Errno{unix.ENOSYS, unix.EPERM, unix.EOPNOTSUPP, unix.EINVAL, unix.EMSGSIZE} {
assert.True(t, tunRecvXRefused(errno), "%v", errno)
}
for _, errno := range []syscall.Errno{0, unix.EAGAIN, unix.EINTR, unix.ENOBUFS, unix.ENOMEM, unix.EBADF, unix.ENOTCONN} {
assert.False(t, tunRecvXRefused(errno), "%v", errno)
}
}
// TestTunRaisePendingPackets pins that the pending limit is set at SYSPROTO_CONTROL level after the receive buffer is
// grown to hold that many packets of the tun's MTU, and capped to what the buffer holds when it can't grow.
func TestTunRaisePendingPackets(t *testing.T) {
type call struct{ level, opt, value int }
stub := func(t *testing.T, rcvbuf int, failLevel, failOpt int) *[]call {
set, get := tunSetsockoptInt, tunGetsockoptInt
var calls []call
tunSetsockoptInt = func(fd, level, opt, value int) error {
calls = append(calls, call{level, opt, value})
if level == failLevel && opt == failOpt {
return unix.ENOBUFS
}
return nil
}
tunGetsockoptInt = func(fd, level, opt int) (int, error) { return rcvbuf, nil }
t.Cleanup(func() { tunSetsockoptInt, tunGetsockoptInt = set, get })
return &calls
}
for _, tc := range []struct {
name string
rcvbuf int
mtu int
failLevel int
failOpt int
want []call
}{
{"grows rcvbuf first", 1 << 16, 9000, -1, -1, []call{
{unix.SOL_SOCKET, unix.SO_RCVBUF, 64 * 9004},
{2, 16, 64},
}},
{"rcvbuf already big enough", 1 << 20, 1300, -1, -1, []call{{2, 16, 64}}},
{"rcvbuf refused caps pending", 10 * 1304, 1300, unix.SOL_SOCKET, unix.SO_RCVBUF, []call{
{unix.SOL_SOCKET, unix.SO_RCVBUF, 64 * 1304},
{2, 16, 10},
}},
} {
t.Run(tc.name, func(t *testing.T) {
calls := stub(t, tc.rcvbuf, tc.failLevel, tc.failOpt)
tn, _ := newSocketpairTun(t, 1<<20)
tn.DefaultMTU = tc.mtu
_, err := tn.Queues(1)
require.NoError(t, err)
assert.Equal(t, tc.want, *calls)
})
}
}
func TestTun_WriteFraming(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tn := &tun{f: w}
for _, tc := range []struct {
name string
pkt []byte
af byte
}{
// Literal families rather than syscall.AF_*, so a wrong constant in Write can't also fix the expectation.
{"ipv4", []byte{0x45, 1, 2, 3, 4, 5}, 2},
{"ipv6", []byte{0x60, 1, 2, 3, 4, 5}, 30},
} {
t.Run(tc.name, func(t *testing.T) {
n, err := tn.Write(tc.pkt)
require.NoError(t, err)
require.Equal(t, len(tc.pkt), n)
got := make([]byte, 64)
n, err = r.Read(got)
require.NoError(t, err)
require.Equal(t, append([]byte{0, 0, 0, tc.af}, tc.pkt...), got[:n])
})
}
_, err = tn.Write([]byte{0x10, 1, 2, 3})
require.Error(t, err)
_, err = tn.Write([]byte{})
require.ErrorIs(t, err, syscall.EIO)
// The rejected writes must not have put anything on the fd, so the next read sees only this packet.
pkt := []byte{0x45, 9, 9}
_, err = tn.Write(pkt)
require.NoError(t, err)
got := make([]byte, 64)
n, err := r.Read(got)
require.NoError(t, err)
require.Equal(t, append([]byte{0, 0, 0, 2}, pkt...), got[:n])
}
func TestTun_ReadStripsHeader(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tn := &tun{f: r}
pkt := []byte{0x45, 1, 2, 3, 4, 5}
_, err = w.Write(append([]byte{0, 0, 0, syscall.AF_INET}, pkt...))
require.NoError(t, err)
got := make([]byte, 64)
n, err := tn.Read(got)
require.NoError(t, err)
require.Equal(t, pkt, got[:n])
}
func TestTun_ReadShort(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tn := &tun{f: r}
// Fewer bytes than the protocol header is not a packet.
_, err = w.Write([]byte{0, 0})
require.NoError(t, err)
n, err := tn.Read(make([]byte, 64))
require.NoError(t, err)
require.Zero(t, n)
// The next packet reads cleanly only if the short read consumed exactly what was written.
pkt := []byte{0x45, 1, 2, 3}
_, err = w.Write(append([]byte{0, 0, 0, syscall.AF_INET}, pkt...))
require.NoError(t, err)
got := make([]byte, 64)
n, err = tn.Read(got)
require.NoError(t, err)
require.Equal(t, pkt, got[:n])
}
// A heap allocation per packet rarely shows in a short throughput run, only across GC pauses, so
// this pins Read and Write to zero allocations directly.
func TestTun_ReadWriteDoNotAllocate(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tw := &tun{f: w}
tr := &tun{f: r}
pkts := [][]byte{bytes.Repeat([]byte{0x45}, 1300), bytes.Repeat([]byte{0x60}, 1300)}
buf := make([]byte, 1500)
i := 0
allocs := testing.AllocsPerRun(1000, func() {
i++
if _, err := tw.Write(pkts[i%len(pkts)]); err != nil {
t.Fatal(err)
}
if _, err := tr.Read(buf); err != nil {
t.Fatal(err)
}
})
require.Zero(t, allocs)
}
+13
View File
@@ -0,0 +1,13 @@
//go:build !darwin && !send_pipeline
package nebula
import "github.com/slackhq/nebula/overlay/tio"
// sendPipelinePlatform is false off darwin: the pipelined send path (interface_pipeline.go) is darwin only for now,
// and listenIn writes its own batches everywhere else. Being a constant, it removes the branch at compile time.
// Build with -tags send_pipeline to run the pipeline, and its tests, on another platform.
const sendPipelinePlatform = false
// listenInPipelined is a plain function rather than a method so this unreachable stub leaves no trace in the binary.
func listenInPipelined(*Interface, tio.Queue, int) {}
+3 -12
View File
@@ -10,19 +10,10 @@ import (
"time" "time"
) )
// benchConnSocks opens a wildcard listener with ListenOut running, with the connected socket knobs pinned to // benchConnSocks opens a wildcard listener with ListenOut running and cfg applied, and a loopback peer that never
// their defaults and then cfg applied, and a loopback peer that never reads, so its sends cost only the sender. // reads, so its sends cost only the sender.
func benchConnSocks(b *testing.B, s Settings, cfg func(*connSockConfig)) (*StdConn, netip.AddrPort) { func benchConnSocks(b *testing.B, s Settings, cfg func(*connSockConfig)) (*StdConn, netip.AddrPort) {
b.Helper() b.Helper()
for k, v := range map[string]string{
"NEBULA_CONNSOCKS": "8",
"NEBULA_CONNSOCK_RUN": "64",
"NEBULA_CONNSOCK_WINDOW": "1s",
"NEBULA_CONNSOCK_IDLE": "30s",
"NEBULA_CONNSOCK_OPEN_EVERY": "1s",
} {
b.Setenv(k, v)
}
c, err := NewListener(slog.New(slog.DiscardHandler), s) c, err := NewListener(slog.New(slog.DiscardHandler), s)
if err != nil { if err != nil {
b.Fatal(err) b.Fatal(err)
@@ -33,7 +24,7 @@ func benchConnSocks(b *testing.B, s Settings, cfg func(*connSockConfig)) (*StdCo
cfg(&u.socks.cfg) cfg(&u.socks.cfg)
} }
go func() { _ = u.ListenOut(func(netip.AddrPort, []byte) {}, func() {}) }() go func() { _ = u.ListenOut(func(netip.AddrPort, []byte) {}, func() {}) }()
for u.reader.Load() == nil { for !u.listening.Load() {
time.Sleep(time.Millisecond) time.Sleep(time.Millisecond)
} }
pc, err := net.ListenPacket("udp4", "127.0.0.1:0") pc, err := net.ListenPacket("udp4", "127.0.0.1:0")
+101 -65
View File
@@ -12,12 +12,13 @@ import (
"net/netip" "net/netip"
"os" "os"
"slices" "slices"
"strconv"
"sync" "sync"
"sync/atomic" "sync/atomic"
"syscall" "syscall"
"time" "time"
"unsafe"
"github.com/slackhq/nebula/internal/msgx"
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
@@ -52,13 +53,46 @@ type connSock struct {
// parkMu serializes the writes that wait for a full send buffer, since the write deadline bounding each wait // parkMu serializes the writes that wait for a full send buffer, since the write deadline bounding each wait
// is the descriptor's, not the writer's. // is the descriptor's, not the writer's.
parkMu sync.Mutex parkMu sync.Mutex
// sys writes one datagram on the descriptor: writeFd, or a stand-in for the interface in tests. // sys writes bufs on the descriptor and returns how many went out: sendFd, or a stand-in for the interface in
sys func(fd int, b []byte) error // tests.
sys func(fd int, bufs [][]byte, x *sendScratch) (int, error)
} }
func writeFd(fd int, b []byte) error { // sendScratch is the msghdr_x array one sendmsg_x reads.
_, err := syscall.Write(fd, b) type sendScratch struct {
return err hdrs [msgx.Batch]msgx.Hdr
iovs [msgx.Batch]unix.Iovec
}
// noSendX is set once sendmsg_x is refused; connected sockets then write one datagram per syscall.
var noSendX atomic.Bool
// sendFd writes bufs on fd, a lone datagram with write and more with one sendmsg_x, which xnu runs through the stack
// as a batch on a connected socket. It returns how many went out, or none and the errno. sendmsg_x reports EAGAIN,
// ENOBUFS and EMSGSIZE only when it took nothing, and any other error without the count it took, which a connected
// socket gets only on its first datagram, as its peer's unreachable.
func sendFd(fd int, bufs [][]byte, x *sendScratch) (int, error) {
if len(bufs) == 1 {
if _, err := syscall.Write(fd, bufs[0]); err != nil {
return 0, err
}
return 1, nil
}
n := min(len(bufs), msgx.Batch)
for i, b := range bufs[:n] {
x.iovs[i] = unix.Iovec{Base: unsafe.SliceData(b)}
x.iovs[i].SetLen(len(b))
x.hdrs[i] = msgx.Hdr{Iov: &x.iovs[i], Iovlen: 1}
}
sent, errno := msgx.Send(uintptr(fd), x.hdrs[:n])
clear(x.iovs[:n])
if errno != 0 {
return 0, errno
}
if sent == 0 {
return 0, syscall.EAGAIN
}
return sent, nil
} }
// errStallSpent is a write that found the connected socket's stall budget spent, so its datagram is dropped. // errStallSpent is a write that found the connected socket's stall budget spent, so its datagram is dropped.
@@ -67,11 +101,16 @@ var errStallSpent = errors.New("connected socket stall budget spent")
// connSockWriter carries one write through RawConn.Write. They are pooled with fn bound once, since a closure // connSockWriter carries one write through RawConn.Write. They are pooled with fn bound once, since a closure
// passed through the RawConn interface escapes and would allocate on every send. // passed through the RawConn interface escapes and would allocate on every send.
type connSockWriter struct { type connSockWriter struct {
s *connSock s *connSock
b []byte // bufs holds a copy of the datagrams' slice headers rather than the caller's slice, which would escape
park bool // through the pool and cost WriteTo's one-datagram array an allocation per send.
err error bufs [msgx.Batch][]byte
fn func(fd uintptr) bool nbufs int
park bool
n int
err error
fn func(fd uintptr) bool
x sendScratch
} }
var connSockWriters = sync.Pool{New: func() any { var connSockWriters = sync.Pool{New: func() any {
@@ -82,7 +121,7 @@ var connSockWriters = sync.Pool{New: func() any {
func (w *connSockWriter) write(fd uintptr) bool { func (w *connSockWriter) write(fd uintptr) bool {
for { for {
w.err = w.s.sys(int(fd), w.b) w.n, w.err = w.s.sys(int(fd), w.bufs[:w.nbufs], &w.x)
switch { switch {
case w.err == syscall.EINTR: case w.err == syscall.EINTR:
case w.err == syscall.EAGAIN && w.park: case w.err == syscall.EAGAIN && w.park:
@@ -93,28 +132,28 @@ func (w *connSockWriter) write(fd uintptr) bool {
} }
} }
// try writes b on s once and returns nil, the write's errno, os.ErrDeadlineExceeded, or net.ErrClosed. With park // try writes bufs on s once and returns how many went out, or none and the write's errno,
// set, EAGAIN waits in the netpoller until the socket is writable or the write deadline passes; without it, EAGAIN // os.ErrDeadlineExceeded, or net.ErrClosed. With park set, EAGAIN waits in the netpoller until the socket is
// is returned. // writable or the write deadline passes; without it, EAGAIN is returned.
func (s *connSock) try(b []byte, park bool) error { func (s *connSock) try(bufs [][]byte, park bool) (int, error) {
w := connSockWriters.Get().(*connSockWriter) w := connSockWriters.Get().(*connSockWriter)
w.s, w.b, w.park = s, b, park w.s, w.nbufs, w.park = s, copy(w.bufs[:], bufs), park
rerr := s.rc.Write(w.fn) rerr := s.rc.Write(w.fn)
err := w.err n, err := w.n, w.err
*w = connSockWriter{fn: w.fn} clear(w.bufs[:w.nbufs])
w.s, w.nbufs, w.n, w.err = nil, 0, 0, nil
connSockWriters.Put(w) connSockWriters.Put(w)
switch { switch {
case rerr == nil: case rerr == nil:
return err return n, err
case errors.Is(rerr, os.ErrDeadlineExceeded): case errors.Is(rerr, os.ErrDeadlineExceeded):
return os.ErrDeadlineExceeded return 0, os.ErrDeadlineExceeded
default: default:
return net.ErrClosed return 0, net.ErrClosed
} }
} }
// connSockConfig holds the knobs. connSockConfigFromEnv reads all but backoff and enobufsMax from the environment, // connSockConfig holds the knobs, which tests change.
// so one binary can be tuned without a rebuild.
type connSockConfig struct { type connSockConfig struct {
// max is how many connected sockets the listen routines may have open at once; 0 turns connected sockets off. // max is how many connected sockets the listen routines may have open at once; 0 turns connected sockets off.
max int max int
@@ -135,8 +174,8 @@ type connSockConfig struct {
enobufsMax time.Duration enobufsMax time.Duration
} }
func connSockConfigFromEnv() connSockConfig { func defaultConnSockConfig() connSockConfig {
c := connSockConfig{ return connSockConfig{
max: 8, max: 8,
run: 64, run: 64,
window: time.Second, window: time.Second,
@@ -145,22 +184,6 @@ func connSockConfigFromEnv() connSockConfig {
openEvery: time.Second, openEvery: time.Second,
enobufsMax: 10 * time.Millisecond, enobufsMax: 10 * time.Millisecond,
} }
if v, err := strconv.Atoi(os.Getenv("NEBULA_CONNSOCKS")); err == nil {
c.max = v
}
if v, err := strconv.Atoi(os.Getenv("NEBULA_CONNSOCK_RUN")); err == nil && v > 0 {
c.run = v
}
if v, err := time.ParseDuration(os.Getenv("NEBULA_CONNSOCK_WINDOW")); err == nil && v > 0 {
c.window = v
}
if v, err := time.ParseDuration(os.Getenv("NEBULA_CONNSOCK_IDLE")); err == nil && v > 0 {
c.idle = v
}
if v, err := time.ParseDuration(os.Getenv("NEBULA_CONNSOCK_OPEN_EVERY")); err == nil && v > 0 {
c.openEvery = v
}
return c
} }
// connSockGroups holds the connSocks that the listen routines bound to one address share, so the limits, the // connSockGroups holds the connSocks that the listen routines bound to one address share, so the limits, the
@@ -182,7 +205,7 @@ func joinConnSocks(u *StdConn, la netip.AddrPort, s Settings) *connSocks {
cs.mu.Unlock() cs.mu.Unlock()
return cs return cs
} }
cs := &connSocks{cfg: connSockConfigFromEnv(), key: la, members: []*StdConn{u}, clock: monoNow, sleep: time.Sleep} cs := &connSocks{cfg: defaultConnSockConfig(), key: la, members: []*StdConn{u}, clock: monoNow, sleep: time.Sleep}
if cs.cfg.max > 0 && !u.listenHost.IsUnspecified() && !s.Multi { if cs.cfg.max > 0 && !u.listenHost.IsUnspecified() && !s.Multi {
// A connected socket on a specific listen.host binds the listener's own address, which xnu allows only when // A connected socket on a specific listen.host binds the listener's own address, which xnu allows only when
// both sockets set SO_REUSEPORT, and a listener with it lets another uid bind a dual-stack wildcard on the // both sockets set SO_REUSEPORT, and a listener with it lets another uid bind a dual-stack wildcard on the
@@ -433,7 +456,7 @@ func (u *StdConn) connSockRun(p *connSockPeer, dst netip.AddrPort, bufs [][]byte
// one out. // one out.
func (u *StdConn) maybeOpenConnSock(p *connSockPeer, dst netip.AddrPort, n int) *connSock { func (u *StdConn) maybeOpenConnSock(p *connSockPeer, dst netip.AddrPort, n int) *connSock {
cs := u.socks cs := u.socks
if n <= 0 || u.reader.Load() == nil || int(cs.reserved.Load()) >= cs.cfg.max || !p.busy(cs.clock(), n, &cs.cfg) { if n <= 0 || !u.listening.Load() || int(cs.reserved.Load()) >= cs.cfg.max || !p.busy(cs.clock(), n, &cs.cfg) {
return nil return nil
} }
cs.mu.Lock() cs.mu.Lock()
@@ -527,7 +550,7 @@ func (u *StdConn) dialConnSock(p *connSockPeer, dst netip.AddrPort) (*connSock,
_ = uc.Close() _ = uc.Close()
return nil, err return nil, err
} }
s := &connSock{dst: dst, peer: p, conn: uc, rc: rc, sys: writeFd} s := &connSock{dst: dst, peer: p, conn: uc, rc: rc, sys: sendFd}
s.used.Store(u.socks.clock()) s.used.Store(u.socks.clock())
return s, nil return s, nil
} }
@@ -677,7 +700,7 @@ func connSockDead(errno syscall.Errno) bool {
// the 09-25 probes. // the 09-25 probes.
const enobufsWait = 50 * time.Microsecond const enobufsWait = 50 * time.Microsecond
// connSockWrite writes bufs on s, one datagram per write. A full socket buffer parks the caller in the netpoller // connSockWrite writes bufs on s, up to msgx.Batch datagrams per sendmsg_x. A full socket buffer parks the caller in the netpoller
// until the socket is writable, and a flow-controlled interface makes it wait out ENOBUFS, so a busy link slows // until the socket is writable, and a flow-controlled interface makes it wait out ENOBUFS, so a busy link slows
// the tun reader instead of dropping. Once the connected socket has waited cfg.enobufsMax without a send going // the tun reader instead of dropping. Once the connected socket has waited cfg.enobufsMax without a send going
// through, either one drops the datagram instead, and a dropped datagram counts as sent, as the listener's // through, either one drops the datagram instead, and a dropped datagram counts as sent, as the listener's
@@ -691,15 +714,30 @@ func (u *StdConn) connSockWrite(s *connSock, bufs [][]byte) (sent int, errno sys
s.used.Store(cs.clock()) s.used.Store(cs.clock())
} }
}() }()
probe := false
for sent < len(bufs) { for sent < len(bufs) {
err := s.try(bufs[sent], false) n := 1
if !noSendX.Load() && !probe {
n = len(bufs) - sent
}
k, err := s.try(bufs[sent:sent+n], false)
if errno, ok := err.(syscall.Errno); ok && n > 1 && msgx.Unsupported(errno) {
// EPERM may be the datagram's own fault, so sendmsg_x is off for good only once a plain write of the same
// datagram goes through.
probe = true
continue
}
if probe && err == nil && noSendX.CompareAndSwap(false, true) {
u.l.Warn("sendmsg_x unavailable, writing one datagram per syscall")
}
probe = false
if err == syscall.EAGAIN || err == os.ErrDeadlineExceeded { if err == syscall.EAGAIN || err == os.ErrDeadlineExceeded {
// os.ErrDeadlineExceeded here is another writer's parked deadline, passed but not yet cleared. // os.ErrDeadlineExceeded here is another writer's parked deadline, passed but not yet cleared.
err = u.parkedWrite(s, bufs[sent]) k, err = u.parkedWrite(s, bufs[sent:sent+1])
} }
switch err { switch err {
case nil: case nil:
sent++ sent += k
if s.stallAt.Load() != 0 { if s.stallAt.Load() != 0 {
s.stallAt.Store(0) s.stallAt.Store(0)
s.dropping.Store(false) s.dropping.Store(false)
@@ -731,23 +769,23 @@ func (u *StdConn) connSockWrite(s *connSock, bufs [][]byte) (sent int, errno sys
// parkedWrite writes b after EAGAIN, parked in the netpoller for what is left of s's stall budget, and returns // parkedWrite writes b after EAGAIN, parked in the netpoller for what is left of s's stall budget, and returns
// errStallSpent once none is. golang/go#73919: a darwin UDP write parked on EAGAIN can wait forever for a // errStallSpent once none is. golang/go#73919: a darwin UDP write parked on EAGAIN can wait forever for a
// writability event that never comes, so the wait always has a deadline. // writability event that never comes, so the wait always has a deadline.
func (u *StdConn) parkedWrite(s *connSock, b []byte) error { func (u *StdConn) parkedWrite(s *connSock, b [][]byte) (int, error) {
cs := u.socks cs := u.socks
s.parkMu.Lock() s.parkMu.Lock()
defer s.parkMu.Unlock() defer s.parkMu.Unlock()
left := cs.cfg.enobufsMax - s.stalledFor(cs.clock()) left := cs.cfg.enobufsMax - s.stalledFor(cs.clock())
if left <= 0 { if left <= 0 {
return errStallSpent return 0, errStallSpent
} }
if err := s.conn.SetWriteDeadline(time.Now().Add(left)); err != nil { if err := s.conn.SetWriteDeadline(time.Now().Add(left)); err != nil {
return net.ErrClosed return 0, net.ErrClosed
} }
err := s.try(b, true) n, err := s.try(b, true)
_ = s.conn.SetWriteDeadline(time.Time{}) _ = s.conn.SetWriteDeadline(time.Time{})
if err == os.ErrDeadlineExceeded { if err == os.ErrDeadlineExceeded {
return errStallSpent return 0, errStallSpent
} }
return err return n, err
} }
// dropStalled logs the first datagram a stall drops. // dropStalled logs the first datagram a stall drops.
@@ -772,14 +810,13 @@ func (s *connSock) stalledFor(now int64) time.Duration {
return time.Duration(now - at) return time.Duration(now - at)
} }
// readConnSock delivers a connected socket's datagrams through the listener's reader, serialized with ListenOut, // readConnSock hands a connected socket's batches to ListenOut until the connected socket is closed. Any receive
// until the connected socket is closed. Any receive error closes it: a connected socket reports its peer's // error closes it: a connected socket reports its peer's unreachables here, and retrying an unexpected error could
// unreachables here, and retrying an unexpected error could spin. // spin.
func (u *StdConn) readConnSock(s *connSock) { func (u *StdConn) readConnSock(s *connSock) {
rd := u.reader.Load() r := u.newBatchReader(s.conn, s.rc)
buf := make([]byte, MTU)
for { for {
n, from, err := s.conn.ReadFromUDPAddrPort(buf) b, err := u.read(r)
if err != nil { if err != nil {
if errors.Is(err, net.ErrClosed) { if errors.Is(err, net.ErrClosed) {
return return
@@ -795,9 +832,8 @@ func (u *StdConn) readConnSock(s *connSock) {
return return
} }
s.used.Store(u.socks.clock()) s.used.Store(u.socks.clock())
u.readMu.Lock() if !u.deliver(b) {
rd.r(netip.AddrPortFrom(from.Addr().Unmap(), from.Port()), buf[:n:n]) return
rd.flush() }
u.readMu.Unlock()
} }
} }
+33 -28
View File
@@ -20,19 +20,9 @@ import (
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
// newConnSockListener opens a listener with the connected socket knobs pinned to their defaults, so NEBULA_* // newConnSockListener opens a listener, applies cfg to its connected socket knobs, and starts ListenOut with r.
// variables in the environment can't change what a test sees, applies cfg, and starts ListenOut with r.
func newConnSockListener(t *testing.T, s Settings, h slog.Handler, r EncReader, cfg ...func(*connSockConfig)) *StdConn { func newConnSockListener(t *testing.T, s Settings, h slog.Handler, r EncReader, cfg ...func(*connSockConfig)) *StdConn {
t.Helper() t.Helper()
for k, v := range map[string]string{
"NEBULA_CONNSOCKS": "8",
"NEBULA_CONNSOCK_RUN": "64",
"NEBULA_CONNSOCK_WINDOW": "1s",
"NEBULA_CONNSOCK_IDLE": "30s",
"NEBULA_CONNSOCK_OPEN_EVERY": "1s",
} {
t.Setenv(k, v)
}
if h == nil { if h == nil {
h = slog.DiscardHandler h = slog.DiscardHandler
} }
@@ -47,10 +37,25 @@ func newConnSockListener(t *testing.T, s Settings, h slog.Handler, r EncReader,
f(&u.socks.cfg) f(&u.socks.cfg)
} }
go func() { _ = u.ListenOut(r, func() {}) }() go func() { _ = u.ListenOut(r, func() {}) }()
require.Eventually(t, func() bool { return u.reader.Load() != nil }, 5*time.Second, time.Millisecond) require.Eventually(t, func() bool { return u.listening.Load() }, 5*time.Second, time.Millisecond)
return u return u
} }
// oneAtATime stands in for sendFd with f, which writes one datagram, so a test can fail chosen datagrams.
func oneAtATime(f func(fd int, b []byte) error) func(int, [][]byte, *sendScratch) (int, error) {
return func(fd int, bufs [][]byte, _ *sendScratch) (int, error) {
if err := f(fd, bufs[0]); err != nil {
return 0, err
}
return 1, nil
}
}
func writeFd(fd int, b []byte) error {
_, err := syscall.Write(fd, b)
return err
}
func listen(s string) Settings { return Settings{Listen: netip.MustParseAddrPort(s)} } func listen(s string) Settings { return Settings{Listen: netip.MustParseAddrPort(s)} }
// run builds n datagrams to dst. // run builds n datagrams to dst.
@@ -282,10 +287,10 @@ func TestConnSocksSharedAcrossRoutines(t *testing.T) {
s1 := u1.connSockFor(a) s1 := u1.connSockFor(a)
require.NotNil(t, s1) require.NotNil(t, s1)
var sends atomic.Int64 var sends atomic.Int64
s1.sys = func(fd int, b []byte) error { s1.sys = oneAtATime(func(fd int, b []byte) error {
sends.Add(1) sends.Add(1)
return writeFd(fd, b) return writeFd(fd, b)
} })
require.NoError(t, u0.WriteTo([]byte("via u0"), a)) require.NoError(t, u0.WriteTo([]byte("via u0"), a))
readFrom(t, peerA, 1) readFrom(t, peerA, 1)
assert.EqualValues(t, 1, sends.Load(), "routine 0 didn't send on routine 1's connected socket") assert.EqualValues(t, 1, sends.Load(), "routine 0 didn't send on routine 1's connected socket")
@@ -566,10 +571,10 @@ func TestConnSocksWriteBatchMixedDestinations(t *testing.T) {
peerB, b := newEstablishedPeer(t, u, "udp4", "127.0.0.1:0") peerB, b := newEstablishedPeer(t, u, "udp4", "127.0.0.1:0")
peerC, c := newPeer(t, "udp4", "127.0.0.1:0") peerC, c := newPeer(t, "udp4", "127.0.0.1:0")
var onSock atomic.Int64 var onSock atomic.Int64
s.sys = func(fd int, b []byte) error { s.sys = oneAtATime(func(fd int, b []byte) error {
onSock.Add(1) onSock.Add(1)
return writeFd(fd, b) return writeFd(fd, b)
} })
var bufs [][]byte var bufs [][]byte
var addrs []netip.AddrPort var addrs []netip.AddrPort
@@ -598,12 +603,12 @@ func TestConnSocksWriteBatchMixedDestinations(t *testing.T) {
func TestConnSocksWriteError(t *testing.T) { func TestConnSocksWriteError(t *testing.T) {
u := newConnSockListener(t, listen("0.0.0.0:0"), nil, nil) u := newConnSockListener(t, listen("0.0.0.0:0"), nil, nil)
s, peer := openConnSock(t, u) s, peer := openConnSock(t, u)
s.sys = func(fd int, b []byte) error { s.sys = oneAtATime(func(fd int, b []byte) error {
if string(b) == "bad" { if string(b) == "bad" {
return syscall.EMSGSIZE return syscall.EMSGSIZE
} }
return writeFd(fd, b) return writeFd(fd, b)
} })
bufs := [][]byte{[]byte("ok0"), []byte("bad"), []byte("ok2")} bufs := [][]byte{[]byte("ok0"), []byte("bad"), []byte("ok2")}
n, err := u.WriteBatch(bufs, []netip.AddrPort{s.dst, s.dst, s.dst}) n, err := u.WriteBatch(bufs, []netip.AddrPort{s.dst, s.dst, s.dst})
require.NoError(t, err) require.NoError(t, err)
@@ -621,12 +626,12 @@ func TestConnSocksWriteBatchFallsBackMidRun(t *testing.T) {
u := newConnSockListener(t, listen("0.0.0.0:0"), nil, nil) u := newConnSockListener(t, listen("0.0.0.0:0"), nil, nil)
s, peer := openConnSock(t, u) s, peer := openConnSock(t, u)
var calls atomic.Int64 var calls atomic.Int64
s.sys = func(fd int, b []byte) error { s.sys = oneAtATime(func(fd int, b []byte) error {
if calls.Add(1) > 2 { if calls.Add(1) > 2 {
return fail return fail
} }
return writeFd(fd, b) return writeFd(fd, b)
} })
bufs, addrs := run(s.dst, 5, "r") bufs, addrs := run(s.dst, 5, "r")
n, err := u.WriteBatch(bufs, addrs) n, err := u.WriteBatch(bufs, addrs)
require.NoError(t, err) require.NoError(t, err)
@@ -673,12 +678,12 @@ func TestConnSockWriteENOBUFS(t *testing.T) {
now.Add(int64(d)) now.Add(int64(d))
} }
var enobufs atomic.Bool var enobufs atomic.Bool
s.sys = func(fd int, b []byte) error { s.sys = oneAtATime(func(fd int, b []byte) error {
if enobufs.Load() { if enobufs.Load() {
return syscall.ENOBUFS return syscall.ENOBUFS
} }
return writeFd(fd, b) return writeFd(fd, b)
} })
perStall := int(u.socks.cfg.enobufsMax / enobufsWait) perStall := int(u.socks.cfg.enobufsMax / enobufsWait)
bufs, _ := run(s.dst, 3, "q") bufs, _ := run(s.dst, 3, "q")
@@ -718,13 +723,13 @@ func TestConnSockWriteENOBUFSConcurrentWriters(t *testing.T) {
// Datagrams starting with 'e' get ENOBUFS while enobufs is set; the rest go out. // Datagrams starting with 'e' get ENOBUFS while enobufs is set; the rest go out.
var enobufs atomic.Bool var enobufs atomic.Bool
var wrote atomic.Int64 var wrote atomic.Int64
s.sys = func(fd int, b []byte) error { s.sys = oneAtATime(func(fd int, b []byte) error {
if b[0] == 'e' && enobufs.Load() { if b[0] == 'e' && enobufs.Load() {
return syscall.ENOBUFS return syscall.ENOBUFS
} }
wrote.Add(1) wrote.Add(1)
return writeFd(fd, b) return writeFd(fd, b)
} })
write := func(tag string, done chan<- int) { write := func(tag string, done chan<- int) {
sent, _, _ := u.connSockWrite(s, [][]byte{[]byte(tag)}) sent, _, _ := u.connSockWrite(s, [][]byte{[]byte(tag)})
done <- sent done <- sent
@@ -782,12 +787,12 @@ func TestConnSockWriteEAGAINBounded(t *testing.T) {
s, peer := openConnSock(t, u) s, peer := openConnSock(t, u)
var eagain atomic.Bool var eagain atomic.Bool
eagain.Store(true) eagain.Store(true)
s.sys = func(fd int, b []byte) error { s.sys = oneAtATime(func(fd int, b []byte) error {
if eagain.Load() { if eagain.Load() {
return syscall.EAGAIN return syscall.EAGAIN
} }
return writeFd(fd, b) return writeFd(fd, b)
} })
budget := u.socks.cfg.enobufsMax budget := u.socks.cfg.enobufsMax
start := time.Now() start := time.Now()
@@ -853,12 +858,12 @@ func TestConnSockWriteDoesNotBlockClose(t *testing.T) {
<-wake <-wake
} }
var gone atomic.Bool var gone atomic.Bool
s.sys = func(fd int, b []byte) error { s.sys = oneAtATime(func(fd int, b []byte) error {
if gone.Load() { if gone.Load() {
return writeFd(fd, b) return writeFd(fd, b)
} }
return syscall.ENOBUFS return syscall.ENOBUFS
} })
done := make(chan bool) done := make(chan bool)
go func() { go func() {
bufs, _ := run(s.dst, 1, "q") bufs, _ := run(s.dst, 1, "q")
+190 -20
View File
@@ -10,12 +10,12 @@ import (
"log/slog" "log/slog"
"net" "net"
"net/netip" "net/netip"
"sync"
"sync/atomic" "sync/atomic"
"syscall" "syscall"
"unsafe" "unsafe"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/internal/msgx"
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
@@ -31,15 +31,13 @@ type StdConn struct {
// rc reaches the listener's descriptor for another listen routine's Rebind. // rc reaches the listener's descriptor for another listen routine's Rebind.
rc syscall.RawConn rc syscall.RawConn
socks *connSocks socks *connSocks
// reader is ListenOut's reader, which connected socket readers share; readMu serializes them, since an // listening is set once ListenOut runs. The listener's and every connected socket's readers hand their batches
// EncReader isn't safe for concurrent use. // to it on rx, so the EncReader runs on ListenOut's goroutine alone; done closes when ListenOut returns.
reader atomic.Pointer[readerPair] listening atomic.Bool
readMu sync.Mutex rx chan *rxBatch
} done chan struct{}
// free holds the batches ListenOut has delivered, for the readers to fill again.
type readerPair struct { free chan *rxBatch
r EncReader
flush func()
} }
var _ Conn = &StdConn{} var _ Conn = &StdConn{}
@@ -53,7 +51,8 @@ func NewListener(l *slog.Logger, s Settings) (Conn, error) {
} }
if uc, ok := pc.(*net.UDPConn); ok { if uc, ok := pc.(*net.UDPConn); ok {
c := &StdConn{UDPConn: uc, l: l, listenHost: s.Listen.Addr()} c := &StdConn{UDPConn: uc, l: l, listenHost: s.Listen.Addr(), rx: make(chan *rxBatch, 1), done: make(chan struct{}),
free: make(chan *rxBatch, rxBatchesKept)}
rc, err := uc.SyscallConn() rc, err := uc.SyscallConn()
if err != nil { if err != nil {
@@ -247,14 +246,176 @@ func NewUDPStatsEmitter(udpConns []Conn) func() {
return func() {} return func() {}
} }
// ListenOut delivers the batches that the listener's reader and the connected sockets' readers hand it.
func (u *StdConn) ListenOut(r EncReader, flush func()) error { func (u *StdConn) ListenOut(r EncReader, flush func()) error {
buffer := make([]byte, MTU) defer close(u.done)
u.reader.Store(&readerPair{r: r, flush: flush}) u.listening.Store(true)
u.startConnSocks() u.startConnSocks()
errc := make(chan error, 1)
go func() { errc <- u.readListener() }()
for { for {
// Just read one packet at a time select {
n, rua, err := u.ReadFromUDPAddrPort(buffer) case b := <-u.rx:
for i := range b.n {
r(b.addrs[i], b.pkts[i])
}
flush()
u.putBatch(b)
case err := <-errc:
return err
}
}
}
// rxBatch is one recvmsg_x batch: n datagrams in pkts, from addrs. A reader takes one only while its socket is
// readable, so an idle connected socket holds none.
type rxBatch struct {
n int
pkts [msgx.Batch][]byte
addrs [msgx.Batch]netip.AddrPort
buf []byte
names [msgx.Batch]unix.RawSockaddrInet6
iovs [msgx.Batch]unix.Iovec
hdrs [msgx.Batch]msgx.Hdr
}
// rxBatchesKept is how many batches a listener keeps for reuse: one being delivered and one queued, plus one for
// each socket reading at once, the listener and up to 8 connected sockets. Each is msgx.Batch*MTU, about 576KB.
const rxBatchesKept = 11
func (u *StdConn) getBatch() *rxBatch {
select {
case b := <-u.free:
return b
default:
}
b := &rxBatch{buf: make([]byte, msgx.Batch*MTU)}
for i := range b.hdrs {
b.iovs[i].Base = &b.buf[i*MTU]
b.iovs[i].SetLen(MTU)
b.hdrs[i] = msgx.Hdr{Name: (*byte)(unsafe.Pointer(&b.names[i])), Iov: &b.iovs[i], Iovlen: 1}
}
return b
}
func (u *StdConn) putBatch(b *rxBatch) {
select {
case u.free <- b:
default:
}
}
// noRecvX is set once recvmsg_x is refused or misbehaves; every reader then reads one datagram per syscall.
var noRecvX atomic.Bool
// parse checks the n entries recvmsg_x filled and sets pkts and addrs from them. It rejects a batch that intact
// msghdr_x entries can't produce, which is how a change to xnu's private struct layout would show up.
func (b *rxBatch) parse(n int) error {
if n > len(b.hdrs) {
return fmt.Errorf("returned %d datagrams for %d headers", n, len(b.hdrs))
}
for i := range n {
h := &b.hdrs[i]
if h.Datalen > MTU {
return fmt.Errorf("datagram %d is %d bytes, past the %d byte buffer", i, h.Datalen, MTU)
}
sa := &b.names[i]
switch {
case sa.Family == unix.AF_INET && h.Namelen == unix.SizeofSockaddrInet4:
sa4 := (*unix.RawSockaddrInet4)(unsafe.Pointer(sa))
b.addrs[i] = netip.AddrPortFrom(netip.AddrFrom4(sa4.Addr), binary.BigEndian.Uint16((*[2]byte)(unsafe.Pointer(&sa4.Port))[:]))
case sa.Family == unix.AF_INET6 && h.Namelen == unix.SizeofSockaddrInet6:
b.addrs[i] = netip.AddrPortFrom(netip.AddrFrom16(sa.Addr).Unmap(), binary.BigEndian.Uint16((*[2]byte)(unsafe.Pointer(&sa.Port))[:]))
default:
return fmt.Errorf("datagram %d has address family %d with length %d", i, sa.Family, h.Namelen)
}
b.pkts[i] = b.buf[i*MTU : i*MTU+int(h.Datalen) : i*MTU+int(h.Datalen)]
}
b.n = n
return nil
}
// batchReader reads one socket in batches. Its fn is bound once, since a closure passed through the RawConn
// interface escapes and would allocate on every read.
type batchReader struct {
u *StdConn
conn *net.UDPConn
rc syscall.RawConn
b *rxBatch
errno syscall.Errno
fn func(fd uintptr) bool
}
func (u *StdConn) newBatchReader(conn *net.UDPConn, rc syscall.RawConn) *batchReader {
r := &batchReader{u: u, conn: conn, rc: rc}
r.fn = r.recv
return r
}
func (r *batchReader) recv(fd uintptr) bool {
b := r.u.getBatch()
for i := range b.hdrs {
b.hdrs[i].Namelen = unix.SizeofSockaddrInet6
b.hdrs[i].Flags = 0
b.hdrs[i].Datalen = 0
}
n, errno := msgx.Recv(fd, b.hdrs[:])
if errno == unix.EAGAIN {
r.u.putBatch(b)
return false
}
b.n, r.b, r.errno = n, b, errno
return true
}
// read returns the next batch: up to msgx.Batch datagrams from one recvmsg_x, or one datagram once recvmsg_x is off.
func (u *StdConn) read(r *batchReader) (*rxBatch, error) {
if !noRecvX.Load() {
r.b = nil
err := r.rc.Read(r.fn)
b := r.b
switch {
case err != nil:
if b != nil {
u.putBatch(b)
}
return nil, err
case r.errno == 0:
perr := b.parse(b.n)
if perr == nil {
return b, nil
}
// The batch was read through a layout the kernel no longer writes, so none of it is trustworthy.
u.disableRecvX("returned an unexpected header", perr)
case msgx.Unsupported(r.errno):
u.disableRecvX("unavailable", r.errno)
default:
u.putBatch(b)
return nil, r.errno
}
u.putBatch(b)
}
b := u.getBatch()
n, from, err := r.conn.ReadFromUDPAddrPort(b.buf[:MTU])
if err != nil {
u.putBatch(b)
return nil, err
}
b.n, b.pkts[0], b.addrs[0] = 1, b.buf[:n:n], netip.AddrPortFrom(from.Addr().Unmap(), from.Port())
return b, nil
}
func (u *StdConn) disableRecvX(why string, err error) {
if noRecvX.CompareAndSwap(false, true) {
u.l.Warn("recvmsg_x "+why+", reading one datagram per syscall", "error", err)
}
}
// readListener hands the listener's batches to ListenOut until the listener closes.
func (u *StdConn) readListener() error {
r := u.newBatchReader(u.UDPConn, u.rc)
for {
b, err := u.read(r)
if err != nil { if err != nil {
if errors.Is(err, net.ErrClosed) { if errors.Is(err, net.ErrClosed) {
return err return err
@@ -262,11 +423,20 @@ func (u *StdConn) ListenOut(r EncReader, flush func()) error {
u.l.Error("unexpected udp socket receive error", "error", err) u.l.Error("unexpected udp socket receive error", "error", err)
continue continue
} }
if !u.deliver(b) {
return net.ErrClosed
}
}
}
u.readMu.Lock() // deliver hands b to ListenOut, and reports false once ListenOut has returned.
r(netip.AddrPortFrom(rua.Addr().Unmap(), rua.Port()), buffer[:n:n]) func (u *StdConn) deliver(b *rxBatch) bool {
flush() select {
u.readMu.Unlock() case u.rx <- b:
return true
case <-u.done:
u.putBatch(b)
return false
} }
} }
+344
View File
@@ -0,0 +1,344 @@
//go:build !e2e_testing
package udp
import (
"bytes"
"fmt"
"log/slog"
"net"
"net/netip"
"sync"
"syscall"
"testing"
"time"
"unsafe"
"github.com/slackhq/nebula/internal/msgx"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// A burst larger than msgx.Batch arrives whole, with each datagram's own bytes and source address, and
// flush runs once per recvmsg_x batch rather than once per datagram.
func TestListenOutBatchesBurst(t *testing.T) {
for _, tc := range []struct{ name, listen string }{
{"v4", "127.0.0.1"},
{"v6", "::1"},
} {
t.Run(tc.name, func(t *testing.T) {
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.AddrPortFrom(netip.MustParseAddr(tc.listen), 0)})
require.NoError(t, err)
la, err := c.LocalAddr()
require.NoError(t, err)
tx, err := net.Dial("udp", la.String())
require.NoError(t, err)
defer tx.Close()
txAddr := netip.MustParseAddrPort(tx.LocalAddr().String())
const total = msgx.Batch*3 + 7
var mu sync.Mutex
var got []string
var froms []netip.AddrPort
flushes := 0
// Queued before the reader starts, so recvmsg_x sees full batches.
for i := 0; i < total; i++ {
_, err := tx.Write([]byte(fmt.Sprintf("pkt-%03d", i)))
require.NoError(t, err)
}
done := make(chan struct{})
go func() {
_ = c.ListenOut(func(addr netip.AddrPort, payload []byte) {
mu.Lock()
got = append(got, string(payload))
froms = append(froms, addr)
mu.Unlock()
}, func() {
mu.Lock()
flushes++
mu.Unlock()
})
close(done)
}()
require.Eventually(t, func() bool {
mu.Lock()
defer mu.Unlock()
return len(got) == total
}, 5*time.Second, 10*time.Millisecond)
require.NoError(t, c.Close())
<-done
for i, p := range got {
assert.Equal(t, fmt.Sprintf("pkt-%03d", i), p)
assert.Equal(t, txAddr, froms[i])
}
assert.Equal(t, (total+msgx.Batch-1)/msgx.Batch, flushes)
})
}
}
// Once recvmsg_x is off, every datagram still arrives, one per batch.
func TestListenOutSingleFallback(t *testing.T) {
noRecvX.Store(true)
t.Cleanup(func() { noRecvX.Store(false) })
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0")})
require.NoError(t, err)
la, err := c.LocalAddr()
require.NoError(t, err)
tx, err := net.Dial("udp", la.String())
require.NoError(t, err)
defer tx.Close()
txAddr := netip.MustParseAddrPort(tx.LocalAddr().String())
const total = 5
for i := 0; i < total; i++ {
_, err := tx.Write([]byte(fmt.Sprintf("pkt-%03d", i)))
require.NoError(t, err)
}
var mu sync.Mutex
var got []string
flushes := 0
done := make(chan struct{})
go func() {
_ = c.ListenOut(func(addr netip.AddrPort, payload []byte) {
assert.Equal(t, txAddr, addr)
mu.Lock()
got = append(got, string(payload))
mu.Unlock()
}, func() {
mu.Lock()
flushes++
mu.Unlock()
})
close(done)
}()
require.Eventually(t, func() bool {
mu.Lock()
defer mu.Unlock()
return len(got) == total
}, 5*time.Second, 10*time.Millisecond)
require.NoError(t, c.Close())
<-done
for i, p := range got {
assert.Equal(t, fmt.Sprintf("pkt-%03d", i), p)
}
assert.Equal(t, total, flushes)
}
func TestRxBatchParse(t *testing.T) {
valid := func() *rxBatch {
b := (&StdConn{}).getBatch()
b.hdrs[0].Namelen, b.hdrs[0].Datalen = unix.SizeofSockaddrInet4, 1
b.names[0].Family = unix.AF_INET
sa4 := (*unix.RawSockaddrInet4)(unsafe.Pointer(&b.names[0]))
sa4.Addr = [4]byte{10, 0, 0, 1}
sa4.Port = 0x0110 // 4097 in network order
b.hdrs[1].Namelen, b.hdrs[1].Datalen = unix.SizeofSockaddrInet6, MTU
b.names[1].Family = unix.AF_INET6
b.names[1].Addr = netip.MustParseAddr("::ffff:10.0.0.2").As16()
b.names[1].Port = 0x0210
return b
}
b := valid()
require.NoError(t, b.parse(2))
assert.Equal(t, 2, b.n)
assert.Equal(t, netip.MustParseAddrPort("10.0.0.1:4097"), b.addrs[0])
assert.Equal(t, netip.MustParseAddrPort("10.0.0.2:4098"), b.addrs[1], "v4-mapped sources arrive unmapped")
assert.Len(t, b.pkts[0], 1)
assert.Equal(t, 1, cap(b.pkts[0]))
assert.Len(t, b.pkts[1], MTU)
require.NoError(t, valid().parse(0))
for _, tc := range []struct {
name string
n int
mutate func(*rxBatch)
}{
{"count past headers", msgx.Batch + 1, func(*rxBatch) {}},
{"datalen past buffer", 2, func(b *rxBatch) { b.hdrs[1].Datalen = MTU + 1 }},
{"unknown family", 2, func(b *rxBatch) { b.names[0].Family = unix.AF_UNIX }},
{"family and length disagree", 2, func(b *rxBatch) { b.hdrs[0].Namelen = unix.SizeofSockaddrInet6 }},
} {
t.Run(tc.name, func(t *testing.T) {
b := valid()
tc.mutate(b)
assert.Error(t, b.parse(tc.n))
})
}
}
func TestMsghdrXKernelRoundTrip(t *testing.T) {
for _, v6 := range []bool{false, true} {
t.Run(fmt.Sprintf("v6=%v", v6), func(t *testing.T) {
// Loopback delivery goes through the dlil input thread, so the settle gives all three time to
// queue and come back from one call, which is what exercises the stride.
got := recvmsgXRoundTrip(t, v6, []int{1, 300, 1400}, 4, 50*time.Millisecond)
assert.Equal(t, 3, got, "largest batch from one recvmsg_x call")
})
}
}
// Any burst, of any datagram lengths up to the kernel's maxdgram, into any number of headers, comes back in order
// with every entry's fields intact, and headers past the returned count untouched.
func FuzzMsghdrXKernelRoundTrip(f *testing.F) {
f.Add(false, uint8(3), []byte{0, 1, 1, 44, 5, 120})
f.Add(true, uint8(0), []byte{0, 0, 0x23, 0x29}) // one empty datagram, then one at MTU
f.Add(false, uint8(1), []byte{0x23, 0x2a, 0x24, 0x00, 0}) // past MTU: cut to MTU, no MSG_TRUNC
f.Add(true, uint8(msgx.Batch-1), bytes.Repeat([]byte{0x05, 0xdc}, msgx.Batch))
f.Fuzz(func(t *testing.T, v6 bool, spare uint8, sizes []byte) {
// Two bytes per datagram, big-endian, folded into [0, maxdgram].
var lens []int
for i := 0; i+1 < len(sizes) && len(lens) < msgx.Batch; i += 2 {
lens = append(lens, (int(sizes[i])<<8|int(sizes[i+1]))%(maxDgram+1))
}
if len(lens) == 0 {
return
}
recvmsgXRoundTrip(t, v6, lens, 1+int(spare)%msgx.Batch, time.Millisecond)
})
}
// maxDgram is darwin's default net.inet.udp.maxdgram, the largest datagram a loopback sender may write.
const maxDgram = 9216
// recvmsgXRoundTrip sends one datagram per entry of lens to a fresh loopback socket, drains them with recvmsg_x
// into nh headers, and checks every field the kernel writes. Neighboring datagrams differ in sender, length and
// fill byte, so no field can pass by reading a neighbor's value. It returns the largest batch one call returned.
func recvmsgXRoundTrip(t *testing.T, v6 bool, lens []int, nh int, settle time.Duration) int {
t.Helper()
network, lo := "udp4", netip.MustParseAddr("127.0.0.1")
if v6 {
network, lo = "udp6", netip.IPv6Loopback()
}
rx, err := net.ListenUDP(network, net.UDPAddrFromAddrPort(netip.AddrPortFrom(lo, 0)))
require.NoError(t, err)
defer rx.Close()
txs := make([]*net.UDPConn, 3)
for i := range txs {
txs[i], err = net.DialUDP(network, nil, rx.LocalAddr().(*net.UDPAddr))
require.NoError(t, err)
defer txs[i].Close()
}
senders := make([]netip.AddrPort, len(lens))
for i, l := range lens {
tx := txs[i%len(txs)]
senders[i] = tx.LocalAddr().(*net.UDPAddr).AddrPort()
_, err := tx.Write(bytes.Repeat([]byte{byte(i + 1)}, l))
require.NoError(t, err)
}
time.Sleep(settle)
// Namelen goes in as the v6 size on both families, so the v4 size coming back proves the kernel wrote it.
const sentinel = 0xa5a5a5a5a5a5a5a5
wantNamelen := uint32(unix.SizeofSockaddrInet4)
if v6 {
wantNamelen = unix.SizeofSockaddrInet6
}
bufs := make([][]byte, nh)
names := make([]unix.RawSockaddrInet6, nh)
iovs := make([]unix.Iovec, nh)
hdrs := make([]msgx.Hdr, nh)
for i := range hdrs {
bufs[i] = make([]byte, MTU)
iovs[i].Base = &bufs[i][0]
iovs[i].SetLen(MTU)
}
// A datagram dropped on loopback would otherwise block rc.Read forever.
require.NoError(t, rx.SetReadDeadline(time.Now().Add(5*time.Second)))
rc, err := rx.SyscallConn()
require.NoError(t, err)
largest := 0
for next := 0; next < len(lens); {
for i := range hdrs {
clear(bufs[i])
hdrs[i] = msgx.Hdr{
Name: (*byte)(unsafe.Pointer(&names[i])),
Namelen: unix.SizeofSockaddrInet6,
Iov: &iovs[i],
Iovlen: 1,
Flags: -1,
Datalen: sentinel,
}
}
var n int
var errno syscall.Errno
require.NoError(t, rc.Read(func(fd uintptr) bool {
n, errno = msgx.Recv(fd, hdrs)
return errno != unix.EAGAIN
}), "received %d of %d datagrams", next, len(lens))
require.Zero(t, errno)
require.Positive(t, n)
require.LessOrEqual(t, n, min(nh, len(lens)-next))
largest = max(largest, n)
b := &rxBatch{buf: make([]byte, n*MTU)}
copy(b.hdrs[:], hdrs[:n])
copy(b.names[:], names[:n])
require.NoError(t, b.parse(n), "ListenOut would fall back on this batch")
for i := range n {
d := next + i
h := &hdrs[i]
want := min(lens[d], MTU)
require.EqualValues(t, want, h.Datalen, "datagram %d Datalen", d)
require.Equal(t, wantNamelen, h.Namelen, "datagram %d Namelen", d)
require.Equal(t, senders[d], b.addrs[i], "datagram %d sender", d)
// Flags goes in as -1 and must come back 0. xnu's list receive (soreceive_m_list) never sets
// MSG_TRUNC, so a datagram past MTU arrives silently cut to MTU, as recvfrom through net.UDPConn does.
require.Zero(t, h.Flags, "datagram %d Flags", d)
require.Equal(t, bytes.Repeat([]byte{byte(d + 1)}, want), bufs[i][:want], "datagram %d payload", d)
if want < MTU {
require.Zero(t, bufs[i][want], "datagram %d wrote past Datalen", d)
}
}
for i := n; i < nh; i++ {
require.EqualValues(t, uint64(sentinel), hdrs[i].Datalen, "spare header %d Datalen", i)
require.EqualValues(t, unix.SizeofSockaddrInet6, hdrs[i].Namelen, "spare header %d Namelen", i)
}
next += n
}
return largest
}
// Once a listener has batches to reuse, reading one allocates nothing, on recvmsg_x or on the fallback.
func TestReadDoesNotAllocate(t *testing.T) {
for _, single := range []bool{false, true} {
t.Run(fmt.Sprintf("single=%v", single), func(t *testing.T) {
noRecvX.Store(single)
t.Cleanup(func() { noRecvX.Store(false) })
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0")})
require.NoError(t, err)
t.Cleanup(func() { _ = c.Close() })
u := c.(*StdConn)
la, err := c.LocalAddr()
require.NoError(t, err)
tx, err := net.DialUDP("udp4", nil, net.UDPAddrFromAddrPort(la))
require.NoError(t, err)
t.Cleanup(func() { _ = tx.Close() })
r := u.newBatchReader(u.UDPConn, u.rc)
pkt := []byte("steady")
allocs := testing.AllocsPerRun(100, func() {
if _, err := tx.Write(pkt); err != nil {
t.Fatal(err)
}
b, err := u.read(r)
if err != nil || b.n != 1 {
t.Fatalf("read %v: %v", b, err)
}
u.putBatch(b)
})
assert.Zero(t, allocs)
})
}
}