Compare commits

..
Author SHA1 Message Date
JackDoan fd29ebdacd use a trampoline to get to the spicy _x functions 2026-09-25 13:01:50 -05:00
JackDoan 2ff4852551 split tun setup and tun IO 2026-09-25 12:26:07 -05:00
Caleb JasikandClaude Opus 5.5 10e1924489 udp/darwin: batch sends with sendmsg_x
WriteBatch hands up to 64 datagrams to one sendmsg_x call instead of
one sendto each. The socket is unconnected, so xnu still runs every
message through sendit, per-send MAC checks included; the saving is the
syscall crossings.

xnu's per-message loop stops at the first message that fails. For
EWOULDBLOCK, ENOBUFS and EMSGSIZE it reports how many went out, or the
errno alone when none did; for any other error it returns only the
errno, with the messages before it already sent. So each call carries
one run of datagrams to a single destination, and nothing is resent
after the kernel may have taken it. A datagram that fails on its own
account (a full interface queue, an oversize packet) goes to sendto,
which delivers or reports it, so it costs only itself, as without
batching; a refused destination costs its run. ENOSYS/EOPNOTSUPP, or
EPERM/EINVAL on a datagram sendto then delivers, switch the socket
back to sendto for good.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 16:10:26 -05:00
Caleb JasikandClaude Opus 5.5 4d191f805f overlay/darwin: drain several tun packets per read wakeup
The darwin tun returned one packet per Read, and listenIn flushes its
UDP send batch after every Read, so each outbound packet went to the
underlay as its own batch. tunQueue.Read now keeps calling readv until
the utun would block, up to tunReadBatch packets, so a burst reaches the
send batch together.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 12:44:00 -05:00
Caleb JasikandClaude Opus 5.5 61947ff1c2 overlay/darwin: batch tun writes with sendmsg_x
Passthrough.Flush hands its whole lane to a new tio.BatchWriter in one
WriteBatch call when the queue implements it, and NewSingleQueue
exposes WriteBatch when its source does. On darwin, tun.WriteBatch
writes up to 64 packets per sendmsg_x on the utun control socket,
which is a connected datagram socket, so xnu takes the batched
sendit_x path rather than one sendit per message. utun registers no
send_list handler, so the kernel still passes each packet to utun on
its own: this saves syscalls and fd locking, not per-packet kernel work.

Error handling follows what sendmsg_x reports:

- A short count with no error (a packet past the send buffer
  mid-call, or a later send failing with ENOBUFS): the remainder goes
  out in the next sendmsg_x.
- EMSGSIZE: only returned when the first packet is too large, before
  the kernel takes any, so that packet alone goes through Write, which
  reports it, and the rest are batched again.
- ENOSYS, EPERM, EOPNOTSUPP: sendmsg_x is private API, so WriteBatch
  logs once and falls back to writev per packet for good.
- Anything else: sendmsg_x returns the error without the count it
  took, so the call is reported rather than retried, which could
  deliver packets twice.

One loss mode has no userspace fix. sendit_x counts each packet as
sent once it is copied into an mbuf; if a later allocation fails, it
frees the copied prefix unsent, returns its length, and sendmsg_x
drops the ENOBUFS because the count is nonzero. That looks exactly
like a real short count, so under mbuf exhaustion WriteBatch silently
drops packets that writev would have delivered.

The iOS tun path (tun_ios.go) is unchanged.

Inside a macOS Network Extension, download goes from 640 to 832 Mbps
against the recvmsg_x change alone in three paired rounds, at 15% less
CPU per Mbps; the likely cause is that its utun charges more per write
than a raw one. Raw dnclient already runs download near line rate,
and there the CPU difference is within noise.

TestTunWriteBatch* round-trip through a connected AF_UNIX datagram
socketpair, which takes sendmsg_x the same way, over both the batched
and the fallback path: order, AF prefixes, skipped invalid packets,
and an oversize packet mid-call and first-in-call. Dropping Namelen
from msghdrX fails them. Mutation testing with gremlins leaves only
equivalent survivors in WriteBatch, plus which error is reported first
when several fail.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 10:04:03 -05:00
Caleb JasikandClaude Opus 5.5 a33a6356c6 udp/darwin: batch receives with recvmsg_x
ListenOut drains the socket with recvmsg_x, xnu's private batched
recvmsg (SYS_RECVMSG_X, bsd/sys/socket_private.h), up to 64 datagrams
per syscall, and calls flush once per batch instead of once per packet.
Each msghdr_x carries its own sockaddr, so this works on the shared
unconnected socket. The send side stays on sendto: xnu only batches
sendmsg_x through the stack on connected sockets, and on an unconnected
socket like this one it falls back to one sendit per message, with
msg_name documented as unsupported.

recvmsg_x is private, so ListenOut falls back to one
ReadFromUDPAddrPort per datagram, logging once, if the kernel or a
sandbox refuses it (ENOSYS, EPERM, EOPNOTSUPP) or if a batch comes back
in a shape intact msghdr_x entries can't produce: more datagrams than
headers, a length past MTU, or a sender that isn't a matching
AF_INET/AF_INET6 sockaddr. That batch is dropped rather than delivered. IPv6 sources now arrive without their
zone, matching the Linux recvmmsg path; WriteTo already drops it.

macOS raw dnclient to a Windows peer on the same gigabit LAN, iperf3
10 s, median of 3 alternating rounds against 7cfa47d:

  download, 1/4/8 streams  606/600/604 -> 869/873/863 Mbps
  download CPU             ~159% -> ~123%
  upload                   340 -> 323 Mbps
  UDP 500M loss            0.32% -> 0.31%

Download is now close to the 902 Mbps the LAN gives without a tunnel.

TestMsghdrXKernelRoundTrip and FuzzMsghdrXKernelRoundTrip pin msghdrX
against the kernel's struct msghdr_x, which the SDK doesn't ship: they
round-trip bursts through recvmsg_x on loopback and check every field
the kernel writes. recvmsg_x never reports MSG_TRUNC (soreceive_m_list
doesn't set it), so a datagram past MTU arrives cut to MTU with Flags
0, the same as ReadFromUDP. TestListenOutSingleFallback covers the
fallback loop, TestCheckMsghdrX the shape check, and the round trip
asserts the check accepts every batch the kernel returns.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-23 16:30:55 -05:00
31 changed files with 1176 additions and 4548 deletions

No files matched your search

+1 -2
View File
@@ -203,8 +203,7 @@ func (c *Control) RebindUDPServer() {
} }
// A failure here means we are likely still pinned to the interface we came up on, so the rest of this is // A failure here means we are likely still pinned to the interface we came up on, so the rest of this is
// unlikely to help. Say so instead of silently carrying on as if we rebound. Only the first writer is rebound; // unlikely to help. Say so instead of silently carrying on as if we rebound.
// darwin's Rebind clears every listen routine's listener.
if err := c.f.outside.Rebind(); err != nil { if err := c.f.outside.Rebind(); err != nil {
c.l.Error("Failed to rebind udp socket", "error", err) c.l.Error("Failed to rebind udp socket", "error", err)
} }
-90
View File
@@ -1,90 +0,0 @@
package nebula
import (
"net/netip"
"sync"
"github.com/slackhq/nebula/udp"
)
// establishedRemotes tells the udp conns that implement udp.EstablishedPeerConn which addresses are the current
// direct remote of at least one established tunnel. A hostinfo holds a reference on its remote while it is in the
// main hostmap, and SetRemote moves the reference; a relayed tunnel has no direct remote and holds none.
type establishedRemotes struct {
mu sync.Mutex
conns []udp.EstablishedPeerConn
refs map[netip.AddrPort]int
}
// newEstablishedRemotes returns nil when no conn wants to know, which every method accepts.
func newEstablishedRemotes(conns []udp.Conn) *establishedRemotes {
var pc []udp.EstablishedPeerConn
for _, c := range conns {
if p, ok := c.(udp.EstablishedPeerConn); ok {
pc = append(pc, p)
}
}
if len(pc) == 0 {
return nil
}
return &establishedRemotes{conns: pc, refs: map[netip.AddrPort]int{}}
}
// add makes hostinfo hold a reference on its remote, as it joins the main hostmap. A hostinfo holds references in
// one establishedRemotes at a time, so an add while it is in another is ignored.
func (e *establishedRemotes) add(hostinfo *HostInfo) {
if e == nil {
return
}
e.mu.Lock()
defer e.mu.Unlock()
if !hostinfo.establishedIn.CompareAndSwap(nil, e) && hostinfo.establishedIn.Load() != e {
return
}
e.syncLocked(hostinfo)
}
// remove drops hostinfo's reference, as it leaves the main hostmap.
func (e *establishedRemotes) remove(hostinfo *HostInfo) {
if e == nil {
return
}
e.mu.Lock()
defer e.mu.Unlock()
if hostinfo.establishedIn.CompareAndSwap(e, nil) {
e.syncLocked(hostinfo)
}
}
// syncLocked moves hostinfo's reference to the remote it should hold now: its current remote while it is
// established, none otherwise. Reading both under mu makes the last call win however add, remove and SetRemote
// interleave. Only the establishedRemotes that hostinfo is in, or has just left, may call it, since
// hostinfo.establishedRemote is a reference in that one's refs.
func (e *establishedRemotes) syncLocked(hostinfo *HostInfo) {
var want netip.AddrPort
if hostinfo.establishedIn.Load() == e {
want = hostinfo.GetRemote()
}
held := hostinfo.establishedRemote
if want == held {
return
}
if held.IsValid() {
e.refs[held]--
if e.refs[held] == 0 {
delete(e.refs, held)
for _, c := range e.conns {
c.SetEstablishedPeer(held, false)
}
}
}
if want.IsValid() {
e.refs[want]++
if e.refs[want] == 1 {
for _, c := range e.conns {
c.SetEstablishedPeer(want, true)
}
}
}
hostinfo.establishedRemote = want
}
-173
View File
@@ -1,173 +0,0 @@
package nebula
import (
"net/netip"
"sync"
"testing"
"github.com/slackhq/nebula/test"
"github.com/slackhq/nebula/udp"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// establishedPeerConn records which destinations the hostmap has told it are established peers, and fails the test
// on a call that doesn't change anything, which would mean a reference count went wrong.
type establishedPeerConn struct {
udp.NoopConn
t *testing.T
mu sync.Mutex
peers map[netip.AddrPort]bool
}
func (c *establishedPeerConn) SetEstablishedPeer(dst netip.AddrPort, established bool) {
c.mu.Lock()
defer c.mu.Unlock()
assert.NotEqual(c.t, established, c.peers[dst], "SetEstablishedPeer(%v, %v) repeated", dst, established)
if established {
c.peers[dst] = true
} else {
delete(c.peers, dst)
}
}
func (c *establishedPeerConn) established() []netip.AddrPort {
c.mu.Lock()
defer c.mu.Unlock()
var out []netip.AddrPort
for dst := range c.peers {
out = append(out, dst)
}
return out
}
// newEstablishedTestHostMap returns a hostmap whose conns are a recording conn and one that doesn't track peers.
func newEstablishedTestHostMap(t *testing.T) (*HostMap, *establishedPeerConn) {
hm := newHostMap(test.NewLogger())
hm.preferredRanges.Store(&[]netip.Prefix{netip.MustParsePrefix("192.168.0.0/16")})
c := &establishedPeerConn{t: t, peers: map[netip.AddrPort]bool{}}
hm.established = newEstablishedRemotes([]udp.Conn{c, udp.NoopConn{}})
require.NotNil(t, hm.established)
return hm, c
}
func newEstablishedTestHostInfo(vpnAddr netip.Addr, index uint32) *HostInfo {
return &HostInfo{
vpnAddrs: []netip.Addr{vpnAddr},
localIndexId: index,
remotes: NewRemoteList([]netip.Addr{vpnAddr}, nil),
}
}
func TestNewEstablishedRemotesWithoutTrackingConns(t *testing.T) {
assert.Nil(t, newEstablishedRemotes([]udp.Conn{udp.NoopConn{}}))
}
// A conn hears about a remote while at least one hostinfo in the main hostmap has it as its direct remote: from
// the add, through roaming and SetRemoteIfPreferred, until the last such hostinfo is deleted or retired by
// MaxHostInfosPerVpnIp. Pending and relayed hostinfos never count.
func TestHostMap_EstablishedRemotes(t *testing.T) {
hm, c := newEstablishedTestHostMap(t)
f := &Interface{}
a := netip.MustParseAddr("10.0.0.1")
r1 := netip.MustParseAddrPort("203.0.113.1:4242")
r2 := netip.MustParseAddrPort("203.0.113.2:4242")
r3 := netip.MustParseAddrPort("192.168.1.3:4242")
// A pending hostinfo, as a handshake sets its remote, isn't established.
h1 := newEstablishedTestHostInfo(a, 1)
h1.SetRemote(r1)
assert.Empty(t, c.established())
// Handshake completion adds it to the main hostmap.
hm.unlockedAddHostInfo(h1, f)
assert.ElementsMatch(t, []netip.AddrPort{r1}, c.established())
// A relayed tunnel has no direct remote.
relayed := newEstablishedTestHostInfo(netip.MustParseAddr("10.0.0.2"), 2)
hm.unlockedAddHostInfo(relayed, f)
assert.ElementsMatch(t, []netip.AddrPort{r1}, c.established())
// A rehandshake's new hostinfo shares the remote, which stays established until both are gone.
h3 := newEstablishedTestHostInfo(a, 3)
h3.SetRemote(r1)
hm.unlockedAddHostInfo(h3, f)
hm.DeleteHostInfo(h1)
assert.ElementsMatch(t, []netip.AddrPort{r1}, c.established())
// Roaming moves the reference.
h3.SetRemote(r2)
assert.ElementsMatch(t, []netip.AddrPort{r2}, c.established())
require.True(t, h3.SetRemoteIfPreferred(hm, ViaSender{UdpAddr: r3}))
assert.ElementsMatch(t, []netip.AddrPort{r3}, c.established())
// A relayed tunnel that hears from its peer directly roams onto a direct remote.
relayed.SetRemote(r1)
assert.ElementsMatch(t, []netip.AddrPort{r1, r3}, c.established())
hm.DeleteHostInfo(relayed)
// A deleted hostinfo lets go, and a SetRemote after that changes nothing.
hm.DeleteHostInfo(h3)
assert.Empty(t, c.established())
h3.SetRemote(r2)
assert.Empty(t, c.established())
hm.DeleteHostInfo(h3)
// Adding past MaxHostInfosPerVpnIp retires the oldest hostinfo and its remote.
var hs []*HostInfo
for i := range MaxHostInfosPerVpnIp + 1 {
h := newEstablishedTestHostInfo(a, uint32(10+i))
h.SetRemote(netip.AddrPortFrom(netip.MustParseAddr("198.51.100.1"), uint16(1000+i)))
hm.unlockedAddHostInfo(h, f)
hs = append(hs, h)
}
assert.Len(t, c.established(), MaxHostInfosPerVpnIp)
assert.NotContains(t, c.established(), hs[0].GetRemote())
}
// Roaming on the receive path races tunnel teardown on the connection manager; whatever the order, a deleted
// hostinfo holds no reference.
func TestHostMap_EstablishedRemotesRoamRacesDelete(t *testing.T) {
hm, c := newEstablishedTestHostMap(t)
f := &Interface{}
a := netip.MustParseAddr("10.0.0.1")
for i := range 200 {
h := newEstablishedTestHostInfo(a, uint32(i+1))
h.SetRemote(netip.MustParseAddrPort("203.0.113.1:4242"))
hm.Lock()
hm.unlockedAddHostInfo(h, f)
hm.Unlock()
var wg sync.WaitGroup
wg.Go(func() { h.SetRemote(netip.AddrPortFrom(netip.MustParseAddr("203.0.113.2"), uint16(i+1))) })
wg.Go(func() { hm.DeleteHostInfo(h) })
wg.Wait()
require.Empty(t, c.established(), "round %d", i)
}
}
// A hostinfo holds its reference in the first tracking hostmap it joins; another's add and delete of it change
// nothing, so neither hostmap's counts go wrong.
func TestHostMap_EstablishedRemotesSingleOwner(t *testing.T) {
hm1, c1 := newEstablishedTestHostMap(t)
hm2, c2 := newEstablishedTestHostMap(t)
f := &Interface{}
r := netip.MustParseAddrPort("203.0.113.1:4242")
h := newEstablishedTestHostInfo(netip.MustParseAddr("10.0.0.1"), 1)
h.SetRemote(r)
hm1.unlockedAddHostInfo(h, f)
hm2.unlockedAddHostInfo(h, f)
assert.ElementsMatch(t, []netip.AddrPort{r}, c1.established())
assert.Empty(t, c2.established())
hm2.DeleteHostInfo(h)
assert.Equal(t, map[netip.AddrPort]int{r: 1}, hm1.established.refs)
assert.Empty(t, hm2.established.refs)
assert.ElementsMatch(t, []netip.AddrPort{r}, c1.established())
hm1.DeleteHostInfo(h)
assert.Empty(t, hm1.established.refs)
assert.Empty(t, hm2.established.refs)
assert.Empty(t, c1.established())
assert.Empty(t, c2.established())
}
-16
View File
@@ -69,8 +69,6 @@ type HostMap struct {
Hosts map[netip.Addr]*HostInfo Hosts map[netip.Addr]*HostInfo
moreHosts map[netip.Addr][]*HostInfo moreHosts map[netip.Addr][]*HostInfo
preferredRanges atomic.Pointer[[]netip.Prefix] preferredRanges atomic.Pointer[[]netip.Prefix]
// established hears about each hostinfo that joins or leaves the hostmap; nil when no conn wants to know.
established *establishedRemotes
l *slog.Logger l *slog.Logger
} }
@@ -278,11 +276,6 @@ type HostInfo struct {
// This value will be behind against actual tunnel utilization in the hot path. // This value will be behind against actual tunnel utilization in the hot path.
// This should only be used by the ConnectionManagers ticker routine. // This should only be used by the ConnectionManagers ticker routine.
lastUsed time.Time lastUsed time.Time
// establishedIn is set while the hostinfo is in a main hostmap whose conns track established remotes, and
// establishedRemote is the remote it holds a reference on there, guarded by establishedIn's mu.
establishedIn atomic.Pointer[establishedRemotes]
establishedRemote netip.AddrPort
} }
type ViaSender struct { type ViaSender struct {
@@ -523,7 +516,6 @@ func (hm *HostMap) unlockedDeleteHostInfo(hostinfo *HostInfo) bool {
if len(hm.Indexes) == 0 { if len(hm.Indexes) == 0 {
hm.Indexes = map[uint32]*HostInfo{} hm.Indexes = map[uint32]*HostInfo{}
} }
hm.established.remove(hostinfo)
if hm.l.Enabled(context.Background(), slog.LevelDebug) { if hm.l.Enabled(context.Background(), slog.LevelDebug) {
hm.l.Debug("Hostmap hostInfo deleted", hm.l.Debug("Hostmap hostInfo deleted",
@@ -670,7 +662,6 @@ func (hm *HostMap) unlockedAddHostInfo(hostinfo *HostInfo, f *Interface) {
hm.Indexes[hostinfo.localIndexId] = hostinfo hm.Indexes[hostinfo.localIndexId] = hostinfo
hm.RemoteIndexes[hostinfo.remoteIndexId] = hostinfo hm.RemoteIndexes[hostinfo.remoteIndexId] = hostinfo
hm.established.add(hostinfo)
hostinfo.markOut(f.rebindEpoch.Load()) hostinfo.markOut(f.rebindEpoch.Load())
if f.connectionManager != nil { // f.connectionManager is only nil in some unit tests if f.connectionManager != nil { // f.connectionManager is only nil in some unit tests
@@ -851,13 +842,6 @@ func (i *HostInfo) SetRemote(remote netip.AddrPort) {
if i.GetRemote() != remote { if i.GetRemote() != remote {
i.remote.Store(&remote) i.remote.Store(&remote)
i.remotes.LearnRemote(i.vpnAddrs[0], remote) i.remotes.LearnRemote(i.vpnAddrs[0], remote)
if e := i.establishedIn.Load(); e != nil {
e.mu.Lock()
if i.establishedIn.Load() == e {
e.syncLocked(i)
}
e.mu.Unlock()
}
} }
} }
-10
View File
@@ -432,11 +432,6 @@ 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 {
@@ -483,11 +478,6 @@ 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
@@ -1,58 +0,0 @@
//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
@@ -1,89 +0,0 @@
//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")
})
}
}
+5
View File
@@ -0,0 +1,5 @@
// Package msgx calls xnu's private batched socket calls, sendmsg_x and recvmsg_x, through libSystem.
//
// The calls are not public API, so the package never links them: it looks them up with dlsym on first use.
// The package is darwin-only, and on iOS Available is always false, so App Store builds keep to public API.
package msgx
+16
View File
@@ -0,0 +1,16 @@
package msgx
import "golang.org/x/sys/unix"
// 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
}
+57 -38
View File
@@ -1,58 +1,77 @@
// Package msgx calls xnu's private batched socket calls, sendmsg_x and recvmsg_x, which move many datagrams per //go:build !ios
// 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 package msgx
import ( import (
"sync"
"syscall" "syscall"
"unsafe" "unsafe"
"golang.org/x/sys/unix"
) )
// Batch is the most messages the callers hand one sendmsg_x or recvmsg_x call. // dlsym is public libSystem API, imported the way x/sys/unix imports its libSystem stubs. The local name is
const Batch = 64 // distinct from runtime/race's dlsym import.
//
//go:cgo_import_dynamic msgx_dlsym dlsym "/usr/lib/libSystem.B.dylib"
// Hdr mirrors xnu's struct msghdr_x (bsd/sys/socket_private.h), which the SDK doesn't ship. recvmsg_x reports each // dlsymTrampolineAddr is the address of msgx_darwin.s's jump to dlsym.
// message's length in Datalen rather than in its return value. var dlsymTrampolineAddr uintptr
type Hdr struct {
Name *byte // syscall6X calls the C function at fn on the system stack and returns errno when it returns a 64-bit -1.
Namelen uint32 // It is how x/sys/unix calls libSystem, and the runtime keeps it linkable for that.
Iov *unix.Iovec //
Iovlen int32 //go:linkname syscall6X syscall.syscall6X
Control *byte func syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
Controllen uint32
Flags int32 // rtldDefault is dlfcn.h's RTLD_DEFAULT, ((void *)-2): search every image loaded in the process.
Datalen uint64 const rtldDefault = ^uintptr(1)
var (
sendmsgXName = []byte("sendmsg_x\x00")
recvmsgXName = []byte("recvmsg_x\x00")
)
type funcs struct {
sendmsgX uintptr
recvmsgX uintptr
} }
// Send passes hdrs to sendmsg_x on fd and returns how many messages the kernel took. EINTR is retried. var resolve = sync.OnceValue(func() funcs {
func Send(fd uintptr, hdrs []Hdr) (int, syscall.Errno) { return funcs{sendmsgX: lookup(sendmsgXName), recvmsgX: lookup(recvmsgXName)}
return call(unix.SYS_SENDMSG_X, fd, hdrs) })
// lookup returns the address of the NUL-terminated C symbol name, or 0 when no loaded image exports it.
func lookup(name []byte) uintptr {
p, _, _ := syscall6X(dlsymTrampolineAddr, rtldDefault, uintptr(unsafe.Pointer(&name[0])), 0, 0, 0, 0)
return p
} }
// Recv passes hdrs to recvmsg_x on fd and returns how many messages it filled. EINTR is retried. // Available reports whether libSystem exports both sendmsg_x and recvmsg_x. When it is false, Send and Recv
func Recv(fd uintptr, hdrs []Hdr) (int, syscall.Errno) { // return ENOSYS.
return call(unix.SYS_RECVMSG_X, fd, hdrs) func Available() bool {
f := resolve()
return f.sendmsgX != 0 && f.recvmsgX != 0
} }
func call(trap, fd uintptr, hdrs []Hdr) (int, syscall.Errno) { // Send passes hdrs to sendmsg_x on fd and returns how many messages the kernel took.
func Send(fd uintptr, hdrs []Hdr, flags int) (int, syscall.Errno) {
return call(resolve().sendmsgX, fd, hdrs, flags)
}
// Recv passes hdrs to recvmsg_x on fd and returns how many messages it filled.
func Recv(fd uintptr, hdrs []Hdr, flags int) (int, syscall.Errno) {
return call(resolve().recvmsgX, fd, hdrs, flags)
}
func call(fn, fd uintptr, hdrs []Hdr, flags int) (int, syscall.Errno) {
if fn == 0 {
return 0, syscall.ENOSYS
}
if len(hdrs) == 0 { if len(hdrs) == 0 {
return 0, syscall.EINVAL return 0, syscall.EINVAL
} }
for { r, _, errno := syscall6X(fn, fd, uintptr(unsafe.Pointer(&hdrs[0])), uintptr(len(hdrs)), uintptr(flags), 0, 0)
r, _, errno := unix.Syscall6(trap, fd, uintptr(unsafe.Pointer(&hdrs[0])), uintptr(len(hdrs)), 0, 0, 0) if errno != 0 {
switch errno {
case 0:
return int(r), 0
case syscall.EINTR:
default:
return 0, errno return 0, errno
} }
} return int(r), 0
}
// 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
} }
+9
View File
@@ -0,0 +1,9 @@
//go:build !ios
#include "textflag.h"
// The same trampoline shape x/sys/unix uses for its libSystem stubs; it assembles for amd64 and arm64 alike.
TEXT msgx_dlsym_trampoline<>(SB),NOSPLIT,$0-0
JMP msgx_dlsym(SB)
GLOBL ·dlsymTrampolineAddr(SB), RODATA, $8
DATA ·dlsymTrampolineAddr(SB)/8, $msgx_dlsym_trampoline<>(SB)
+11 -21
View File
@@ -1,25 +1,24 @@
//go:build !ios
package msgx package msgx
import ( import (
"bytes" "bytes"
"syscall" "syscall"
"testing" "testing"
"unsafe"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
// TestHdrLayout pins Hdr to struct msghdr_x's LP64 layout: 56 bytes, Datalen last at 48. // TestAvailable pins that dlsym finds both calls in this macOS's libSystem, so the batched paths are live.
func TestHdrLayout(t *testing.T) { func TestAvailable(t *testing.T) {
var h Hdr assert.True(t, Available())
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 // TestSendRecvRoundTrip pins the libSystem calling path end to end: a batch goes out through sendmsg_x in one
// call, each message whole, in order, with Datalen set. // call and comes back through recvmsg_x in one call, each message whole, in order, with Datalen set.
func TestSendRecvRoundTrip(t *testing.T) { func TestSendRecvRoundTrip(t *testing.T) {
fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_DGRAM, 0) fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_DGRAM, 0)
require.NoError(t, err) require.NoError(t, err)
@@ -40,7 +39,7 @@ func TestSendRecvRoundTrip(t *testing.T) {
iovs[i].SetLen(len(want[i])) iovs[i].SetLen(len(want[i]))
hdrs[i] = Hdr{Iov: &iovs[i], Iovlen: 1} hdrs[i] = Hdr{Iov: &iovs[i], Iovlen: 1}
} }
sent, errno := Send(uintptr(fds[0]), hdrs) sent, errno := Send(uintptr(fds[0]), hdrs, 0)
require.Zero(t, errno) require.Zero(t, errno)
require.Equal(t, n, sent) require.Equal(t, n, sent)
@@ -52,7 +51,7 @@ func TestSendRecvRoundTrip(t *testing.T) {
riovs[i].SetLen(len(bufs[i])) riovs[i].SetLen(len(bufs[i]))
rhdrs[i] = Hdr{Iov: &riovs[i], Iovlen: 1} rhdrs[i] = Hdr{Iov: &riovs[i], Iovlen: 1}
} }
got, errno := Recv(uintptr(fds[1]), rhdrs) got, errno := Recv(uintptr(fds[1]), rhdrs, 0)
require.Zero(t, errno) require.Zero(t, errno)
require.Equal(t, n, got) require.Equal(t, n, got)
for i := range n { for i := range n {
@@ -63,17 +62,8 @@ func TestSendRecvRoundTrip(t *testing.T) {
// TestEmptyBatch pins that an empty batch is refused before it reaches the kernel. // TestEmptyBatch pins that an empty batch is refused before it reaches the kernel.
func TestEmptyBatch(t *testing.T) { func TestEmptyBatch(t *testing.T) {
_, errno := Send(0, nil) _, errno := Send(0, nil, 0)
assert.Equal(t, syscall.EINVAL, errno) assert.Equal(t, syscall.EINVAL, errno)
_, errno = Recv(0, nil) _, errno = Recv(0, nil, 0)
assert.Equal(t, syscall.EINVAL, errno) 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)
}
}
+12
View File
@@ -0,0 +1,12 @@
package msgx
import "syscall"
// Available is always false on iOS, so App Store builds never look up private symbols.
func Available() bool { return false }
// Send always returns ENOSYS on iOS.
func Send(uintptr, []Hdr, int) (int, syscall.Errno) { return 0, syscall.ENOSYS }
// Recv always returns ENOSYS on iOS.
func Recv(uintptr, []Hdr, int) (int, syscall.Errno) { return 0, syscall.ENOSYS }
-1
View File
@@ -213,7 +213,6 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
} }
hostMap := NewHostMapFromConfig(l, c) hostMap := NewHostMapFromConfig(l, c)
hostMap.established = newEstablishedRemotes(udpConns)
punchy := NewPunchyFromConfig(l, c, udpConns[0]) punchy := NewPunchyFromConfig(l, c, udpConns[0])
connManager := newConnectionManagerFromConfig(l, c, hostMap, punchy) connManager := newConnectionManagerFromConfig(l, c, hostMap, punchy)
lightHouse, err := NewLightHouseFromConfig(ctx, l, c, pki.getCertState(), udpConns[0], punchy) lightHouse, err := NewLightHouseFromConfig(ctx, l, c, pki.getCertState(), udpConns[0], punchy)
-156
View File
@@ -1,156 +0,0 @@
//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
@@ -1,400 +0,0 @@
//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)
}
}
+328
View File
@@ -0,0 +1,328 @@
//go:build darwin && !ios
package tio
import (
"fmt"
"log/slog"
"os"
"sync"
"sync/atomic"
"syscall"
_ "unsafe" // for go:linkname
"github.com/slackhq/nebula/internal/msgx"
"golang.org/x/sys/unix"
)
// tunMaxPacket is the largest packet utun can return at any device MTU.
const tunMaxPacket = 65535
// tunReadBatch is the most packets one Utun.Read returns.
const tunReadBatch = 64
// tunReadArena is Utun's receive buffer. Draining stops once less than tunMaxPacket of it is left,
// so every readv has room for the largest packet utun can return.
const tunReadArena = 4 * tunMaxPacket
// tunWriteBatch is how many packets one sendmsg_x call may carry.
const tunWriteBatch = 64
// Utun is a darwin utun control socket as a Queue. Every packet crosses the socket behind a 4 byte
// address family prefix, which Read strips and the writes add.
//
// The fd lives in the runtime poller, so Close wakes a Read parked on it; darwin needs no QueueSet
// shutdown fd.
type Utun struct {
f *os.File
l *slog.Logger
// readBuf and readRet are Read's scratch, owned by the single reader.
readBuf []byte
readRet [tunReadBatch]Packet
// noSendmsgX is set when libSystem lacks sendmsg_x or the kernel refuses it; WriteBatch then writes one packet at a time.
noSendmsgX atomic.Bool
batchMu sync.Mutex
batch tunBatch
}
// tunBatch is WriteBatch's scratch, guarded by Utun.batchMu. The kernel reads every entry in place.
type tunBatch struct {
heads [tunWriteBatch][4]byte
iovs [tunWriteBatch][2]unix.Iovec
hdrs [tunWriteBatch]msgx.Hdr
pkts [tunWriteBatch][]byte
}
// NewUtun wraps a utun control socket fd and makes it non-blocking.
// On failure it does NOT close fd: the caller owns fd until NewUtun succeeds, after which Close closes it.
func NewUtun(fd int, l *slog.Logger) (*Utun, error) {
// Before os.NewFile, which only hands a non-blocking fd to the runtime poller.
if err := unix.SetNonblock(fd, true); err != nil {
return nil, fmt.Errorf("failed to set the tun fd to non-blocking mode: %w", err)
}
u := &Utun{
f: os.NewFile(uintptr(fd), "utun"),
l: l,
readBuf: make([]byte, tunReadArena),
}
u.noSendmsgX.Store(!msgx.Available())
return u, nil
}
// tunWritev and tunReadv are linkname'd to x/sys/unix's libc-routed writev/readv stubs so the
// calls go through libSystem's pinned trampoline. A raw syscall.Syscall(SYS_WRITEV/SYS_READV, ...)
// on darwin/arm64 emits an SVC #0x80 trap (see $GOROOT/src/syscall/asm_darwin_arm64.s), the path
// Apple keeps warning they will eventually disallow. We pull the low-level stubs instead of calling
// unix.Writev/unix.Readv because those take [][]byte and rebuild the []Iovec every call, which
// heap-allocates the header; linkname'ing the stubs lets us hand them our own stack-allocated
// iovecs. See golang/go#78049.
//go:linkname tunWritev golang.org/x/sys/unix.writev
//go:noescape
func tunWritev(fd int, iovecs []unix.Iovec) (n int, err error)
//go:linkname tunReadv golang.org/x/sys/unix.readv
//go:noescape
func tunReadv(fd int, iovecs []unix.Iovec) (n int, err error)
// Read waits for the utun to become readable, then reads packets until it would block, up to
// tunReadBatch, so the caller encrypts and sends them as one batch rather than one per wakeup. Each
// packet is read with its AF prefix scattered away, so the payload lands directly in readBuf.
// An error after at least one packet is dropped in favor of returning those packets; a persistent
// one recurs on the next Read.
func (u *Utun) Read() ([]Packet, error) {
rc, err := u.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(u.readBuf)-off >= tunMaxPacket {
iovecs := [2]unix.Iovec{
{Base: &head[0], Len: 4},
{Base: &u.readBuf[off], Len: uint64(len(u.readBuf) - 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
u.readRet[n] = Packet{Bytes: u.readBuf[off:end:end]}
n++
off = end
}
return true
})
if n > 0 {
return u.readRet[:n], nil
}
if err != nil {
return nil, err
}
return nil, callErr
}
// Write pushes one IP packet onto the utun device. Safe for concurrent use:
// the AF prefix and iovecs are per-call stack state, and the fd write itself
// serializes on the runtime's fd mutex (see the Queue contract in tio.go).
func (u *Utun) Write(from []byte) (int, error) {
if len(from) == 0 {
return 0, syscall.EIO
}
var head [4]byte
af, err := tunAF(from)
if err != nil {
return 0, err
}
head[3] = af
// Grab rc as a local so the compiler can devirtualize the call and keep the closure on the stack.
rc, err := u.f.SyscallConn()
if err != nil {
return 0, err
}
var n int
var callErr error
err = rc.Write(func(fd uintptr) bool {
iovecs := []unix.Iovec{
{Base: &head[0], Len: 4},
{Base: &from[0], Len: uint64(len(from))},
}
n, callErr = tunWritev(int(fd), iovecs)
// Type-assert to syscall.Errno so the EAGAIN/EWOULDBLOCK/EINTR check doesn't box the errno
// constants into error interfaces on every call.
if errno, ok := callErr.(syscall.Errno); ok && errno.Temporary() {
return false
}
return true
})
if err != nil {
return 0, err
}
if callErr != nil {
return 0, callErr
}
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, xnu's private batched sendmsg, up to
// tunWriteBatch packets per syscall. The kernel still hands each packet to utun on its own, so 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. Any other
// error from sendmsg_x means the kernel took an unknown prefix of that call and dropped the rest, so
// it is reported rather than retried, which could deliver packets twice.
//
// Under mbuf exhaustion, sendmsg_x silently drops packets that writev would have delivered: the
// kernel counts each packet as sent once it is copied in, and when a later allocation fails it
// frees that prefix unsent and returns its length as a short count, which is indistinguishable
// from a real one.
func (u *Utun) WriteBatch(pkts [][]byte) error {
if u.noSendmsgX.Load() {
return u.writeEach(pkts)
}
u.batchMu.Lock()
defer u.batchMu.Unlock()
b := &u.batch
var firstErr error
for len(pkts) > 0 {
n := 0
for len(pkts) > 0 && n < tunWriteBatch {
p := pkts[0]
pkts = pkts[1:]
var af byte
err := error(syscall.EIO)
if len(p) > 0 {
af, err = tunAF(p)
}
if err != nil {
if firstErr == nil {
firstErr = 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++
}
if n == 0 {
continue
}
for off := 0; off < n; {
sent, err := u.sendmsgX(off, n)
switch {
case err == nil && sent > 0:
// The kernel stops early without an error on a packet larger than the socket's send
// buffer, or when sending a later packet fails with ENOBUFS; resend the remainder.
off += sent
case err == nil:
if werr := u.writeEach(b.pkts[off:n]); werr != nil && firstErr == nil {
firstErr = werr
}
off = n
case err == unix.EMSGSIZE:
// Only the first packet being larger than the socket's send buffer fails the whole call,
// before the kernel takes any; Write reports that one and the rest go out in the next call.
if werr := u.writeEach(b.pkts[off : off+1]); werr != nil && firstErr == nil {
firstErr = werr
}
off++
case err == unix.ENOSYS || err == unix.EPERM || err == unix.EOPNOTSUPP:
// sendmsg_x is private API: fall back to writev if a kernel or sandbox refuses it.
if u.noSendmsgX.CompareAndSwap(false, true) {
u.l.Warn("sendmsg_x unavailable on the tun device, writing one packet per syscall", "error", err)
}
if werr := u.writeEach(b.pkts[off:n]); werr != nil && firstErr == nil {
firstErr = werr
}
clear(b.iovs[:n])
clear(b.pkts[:n])
if werr := u.writeEach(pkts); werr != nil && firstErr == nil {
firstErr = werr
}
return firstErr
default:
if firstErr == nil {
firstErr = err
}
off = n
}
}
clear(b.iovs[:n])
clear(b.pkts[:n])
}
return firstErr
}
// sendmsgX hands entries off through n-1 of u.batch to sendmsg_x and returns how many the kernel took.
func (u *Utun) sendmsgX(off, n int) (int, error) {
rc, err := u.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, u.batch.hdrs[off:n], 0)
// sendmsg_x reports EAGAIN only when it took nothing; a partial batch returns its count.
return !errno.Temporary()
})
if err != nil {
return 0, err
}
if errno != 0 {
return 0, errno
}
return sent, nil
}
// writeEach writes pkts one at a time with Write.
func (u *Utun) writeEach(pkts [][]byte) error {
var firstErr error
for _, p := range pkts {
if _, err := u.Write(p); err != nil && firstErr == nil {
firstErr = err
}
}
return firstErr
}
func (u *Utun) Close() error {
return u.f.Close()
}
+198
View File
@@ -0,0 +1,198 @@
//go:build darwin && !ios
package tio
import (
"bytes"
"log/slog"
"syscall"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// newSocketpairUtun returns a Utun over 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 the test to use.
// sndbuf is the Utun's send buffer, which caps the largest datagram it accepts.
func newSocketpairUtun(t *testing.T, sndbuf int) (*Utun, 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))
// An AF_UNIX datagram send is bounded by the receiver's buffer, so size both ends' for the tests.
require.NoError(t, unix.SetsockoptInt(fds[0], unix.SOL_SOCKET, unix.SO_RCVBUF, 1<<20))
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}))
u, err := NewUtun(fds[0], slog.New(slog.DiscardHandler))
if err != nil {
_ = unix.Close(fds[0])
_ = unix.Close(fds[1])
t.Fatal(err)
}
t.Cleanup(func() {
_ = u.Close()
_ = unix.Close(fds[1])
})
return u, 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) { fn(t, fallback) })
}
}
// TestUtunWriteBatch 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 TestUtunWriteBatch(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
u, r := newSocketpairUtun(t, 1<<20)
u.noSendmsgX.Store(fallback)
var pkts, want [][]byte
for i := range 3*tunWriteBatch + 5 {
p, w := testTunPkt(i, 60+i)
pkts = append(pkts, p)
want = append(want, w)
}
require.NoError(t, u.WriteBatch(pkts))
assert.Equal(t, fallback, u.noSendmsgX.Load())
readTunBack(t, r, want)
})
}
// TestUtunWriteBatchSkipsInvalid 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 TestUtunWriteBatchSkipsInvalid(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
u, r := newSocketpairUtun(t, 1<<20)
u.noSendmsgX.Store(fallback)
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 := u.WriteBatch(pkts)
assert.ErrorContains(t, err, "IP version")
readTunBack(t, r, want)
})
}
// TestUtunWriteBatchOversize 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 TestUtunWriteBatchOversize(t *testing.T) {
for _, tc := range []struct {
name string
at int
}{
{"mid-call", tunWriteBatch + 6},
{"first-in-call", tunWriteBatch},
} {
t.Run(tc.name, func(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
u, r := newSocketpairUtun(t, 1024)
u.noSendmsgX.Store(fallback)
var pkts, want [][]byte
for i := range 2*tunWriteBatch + 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 := u.WriteBatch(pkts)
assert.ErrorIs(t, err, unix.EMSGSIZE)
assert.Equal(t, fallback, u.noSendmsgX.Load())
readTunBack(t, r, want)
})
})
}
}
// TestUtunReadDrains 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 TestUtunReadDrains(t *testing.T) {
u, w := newSocketpairUtun(t, 1<<20)
total := tunReadBatch + 3
var want [][]byte
for i := range total {
pkt, wire := testTunPkt(i, 60+i)
_, err := unix.Write(w, wire)
require.NoError(t, err)
want = append(want, pkt)
}
var got [][]byte
for _, size := range []int{tunReadBatch, 3} {
pkts, err := u.Read()
require.NoError(t, err)
require.Len(t, pkts, size)
for _, p := range pkts {
got = append(got, p.Clone().Bytes)
}
}
assert.Equal(t, want, got)
}
// TestUtunReadClipsPackets pins that each returned packet's capacity ends at its own bytes, so
// appending to one can't overwrite the next.
func TestUtunReadClipsPackets(t *testing.T) {
u, w := newSocketpairUtun(t, 1<<20)
for i := range 2 {
_, wire := testTunPkt(i, 100)
_, err := unix.Write(w, wire)
require.NoError(t, err)
}
pkts, err := u.Read()
require.NoError(t, err)
require.Len(t, pkts, 2)
assert.Equal(t, len(pkts[0].Bytes), cap(pkts[0].Bytes))
}
+12 -510
View File
@@ -7,15 +7,11 @@ import (
"fmt" "fmt"
"log/slog" "log/slog"
"net/netip" "net/netip"
"os"
"sync"
"sync/atomic" "sync/atomic"
"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"
@@ -24,7 +20,7 @@ import (
) )
type tun struct { type tun struct {
f *os.File queue *tio.Utun
Device string Device string
vpnNetworks []netip.Prefix vpnNetworks []netip.Prefix
DefaultMTU int DefaultMTU int
@@ -35,23 +31,8 @@ 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
@@ -134,13 +115,13 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*t
return nil, fmt.Errorf("failed to retrieve tun name: %w", err) return nil, fmt.Errorf("failed to retrieve tun name: %w", err)
} }
err = unix.SetNonblock(fd, true) queue, err := tio.NewUtun(fd, l)
if err != nil { if err != nil {
return nil, fmt.Errorf("SetNonblock: %v", err) return nil, err
} }
t := &tun{ t := &tun{
f: os.NewFile(uintptr(fd), ""), queue: queue,
Device: name, Device: name,
vpnNetworks: vpnNetworks, vpnNetworks: vpnNetworks,
DefaultMTU: c.GetInt("tun.mtu", DefaultMTU), DefaultMTU: c.GetInt("tun.mtu", DefaultMTU),
@@ -173,15 +154,15 @@ func (t *tun) deviceBytes() (o [16]byte) {
// network extension is handed its device. Everything about moving packets is shared with newTun, // network extension is handed its device. Everything about moving packets is shared with newTun,
// only the setup differs: the host owns addressing and routing here. // only the setup differs: the host owns addressing and routing here.
func newTunFromFd(c *config.C, l *slog.Logger, deviceFd int, vpnNetworks []netip.Prefix) (*tun, error) { func newTunFromFd(c *config.C, l *slog.Logger, deviceFd int, vpnNetworks []netip.Prefix) (*tun, error) {
if err := unix.SetNonblock(deviceFd, true); err != nil { queue, err := tio.NewUtun(deviceFd, l)
if err != nil {
// We own the fd from the moment it is handed to us // We own the fd from the moment it is handed to us
_ = unix.Close(deviceFd) _ = unix.Close(deviceFd)
return nil, fmt.Errorf("failed to set the tun fd to non-blocking mode: %w", err) return nil, err
} }
file := os.NewFile(uintptr(deviceFd), "/dev/tun")
t := &tun{ t := &tun{
f: file, queue: queue,
Device: utunNameFromFd(deviceFd), Device: utunNameFromFd(deviceFd),
vpnNetworks: vpnNetworks, vpnNetworks: vpnNetworks,
DefaultMTU: c.GetInt("tun.mtu", DefaultMTU), DefaultMTU: c.GetInt("tun.mtu", DefaultMTU),
@@ -190,7 +171,7 @@ func newTunFromFd(c *config.C, l *slog.Logger, deviceFd int, vpnNetworks []netip
} }
if err := t.reload(c, true); err != nil { if err := t.reload(c, true); err != nil {
_ = file.Close() _ = queue.Close()
return nil, err return nil, err
} }
@@ -214,8 +195,8 @@ func utunNameFromFd(fd int) string {
} }
func (t *tun) Close() error { func (t *tun) Close() error {
if t.f != nil { if t.queue != nil {
return t.f.Close() return t.queue.Close()
} }
return nil return nil
} }
@@ -573,226 +554,6 @@ func delRoute(prefix netip.Prefix, gateway netroute.Addr) error {
return nil return nil
} }
// tunWritev and tunReadv are linkname'd to x/sys/unix's libc-routed writev/readv stubs so the
// calls go through libSystem's pinned trampoline. A raw syscall.Syscall(SYS_WRITEV/SYS_READV, ...)
// on darwin/arm64 emits an SVC #0x80 trap (see $GOROOT/src/syscall/asm_darwin_arm64.s), the path
// Apple keeps warning they will eventually disallow. We pull the low-level stubs instead of calling
// unix.Writev/unix.Readv because those take [][]byte and rebuild the []Iovec every call, which
// heap-allocates the header; linkname'ing the stubs lets us hand them our own stack-allocated
// iovecs. See golang/go#78049.
//go:linkname tunWritev golang.org/x/sys/unix.writev
//go:noescape
func tunWritev(fd int, iovecs []unix.Iovec) (n int, err error)
//go:linkname tunReadv golang.org/x/sys/unix.readv
//go:noescape
func tunReadv(fd int, iovecs []unix.Iovec) (n int, err error)
// Read pulls one IP packet off the utun device, scattering the 4 byte protocol header away from
// the packet so the payload lands directly in to.
func (t *tun) Read(to []byte) (int, error) {
var head [4]byte
rc, err := t.f.SyscallConn()
if err != nil {
return 0, err
}
var n int
var callErr error
err = rc.Read(func(fd uintptr) bool {
iovecs := []unix.Iovec{
{Base: &head[0], Len: 4},
{Base: &to[0], Len: uint64(len(to))},
}
n, callErr = tunReadv(int(fd), iovecs)
if errno, ok := callErr.(syscall.Errno); ok && errno.Temporary() {
return false
}
return true
})
if err != nil {
return 0, err
}
if callErr != nil {
return 0, callErr
}
if n < 4 {
return 0, nil
}
return n - 4, nil
}
// Write pushes one IP packet onto the utun device. Safe for concurrent use:
// the AF prefix and iovecs are per-call stack state, and the fd write itself
// serializes on the runtime's fd mutex (see the Queue contract in tio.go).
func (t *tun) Write(from []byte) (int, error) {
if len(from) == 0 {
return 0, syscall.EIO
}
var head [4]byte
af, err := tunAF(from)
if err != nil {
return 0, err
}
head[3] = af
// Grab rc as a local so the compiler can devirtualize the call and keep the closure on the stack.
rc, err := t.f.SyscallConn()
if err != nil {
return 0, err
}
var n int
var callErr error
err = rc.Write(func(fd uintptr) bool {
iovecs := []unix.Iovec{
{Base: &head[0], Len: 4},
{Base: &from[0], Len: uint64(len(from))},
}
n, callErr = tunWritev(int(fd), iovecs)
// Type-assert to syscall.Errno so the EAGAIN/EWOULDBLOCK/EINTR check doesn't box the errno
// constants into error interfaces on every call.
if errno, ok := callErr.(syscall.Errno); ok && errno.Temporary() {
return false
}
return true
})
if err != nil {
return 0, err
}
if callErr != nil {
return 0, callErr
}
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
} }
@@ -802,264 +563,5 @@ func (t *tun) Name() string {
} }
func (t *tun) Queues(int) ([]tio.Queue, error) { func (t *tun) Queues(int) ([]tio.Queue, error) {
return []tio.Queue{newTunQueue(t)}, nil return []tio.Queue{t.queue}, 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
@@ -1,637 +0,0 @@
//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
@@ -1,13 +0,0 @@
//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) {}
-8
View File
@@ -48,14 +48,6 @@ type Conn interface {
Close() error Close() error
} }
// EstablishedPeerConn is a Conn that treats the remotes of established tunnels differently from other
// destinations, as darwin's gives busy ones connected sockets.
type EstablishedPeerConn interface {
// SetEstablishedPeer reports whether dst is the current remote of at least one established tunnel. Calls for
// one dst must not race each other.
SetEstablishedPeer(dst netip.AddrPort, established bool)
}
type NoopConn struct{} type NoopConn struct{}
func (NoopConn) Rebind() error { func (NoopConn) Rebind() error {
-106
View File
@@ -1,106 +0,0 @@
//go:build !e2e_testing
package udp
import (
"log/slog"
"net"
"net/netip"
"testing"
"time"
)
// benchConnSocks opens a wildcard listener with ListenOut running and cfg applied, and a loopback peer that never
// reads, so its sends cost only the sender.
func benchConnSocks(b *testing.B, s Settings, cfg func(*connSockConfig)) (*StdConn, netip.AddrPort) {
b.Helper()
c, err := NewListener(slog.New(slog.DiscardHandler), s)
if err != nil {
b.Fatal(err)
}
b.Cleanup(func() { _ = c.Close() })
u := c.(*StdConn)
if cfg != nil {
cfg(&u.socks.cfg)
}
go func() { _ = u.ListenOut(func(netip.AddrPort, []byte) {}, func() {}) }()
for !u.listening.Load() {
time.Sleep(time.Millisecond)
}
pc, err := net.ListenPacket("udp4", "127.0.0.1:0")
if err != nil {
b.Fatal(err)
}
b.Cleanup(func() { _ = pc.Close() })
return u, pc.LocalAddr().(*net.UDPAddr).AddrPort()
}
// BenchmarkConnSockWriteTo measures one WriteTo of a full-size datagram down each path: the listener with
// connected sockets off, to a destination that is no tunnel's remote while another is, to an established peer
// that never gets busy, and on a connected socket.
func BenchmarkConnSockWriteTo(b *testing.B) {
pkt := make([]byte, 1400)
cases := []struct {
name string
cfg func(*connSockConfig)
setup func(b *testing.B, u *StdConn, dst netip.AddrPort)
}{
{name: "listener/off", cfg: func(c *connSockConfig) { c.max = 0 }},
{name: "listener/ineligible", setup: func(b *testing.B, u *StdConn, dst netip.AddrPort) {
u.SetEstablishedPeer(netip.AddrPortFrom(dst.Addr(), dst.Port()+1), true)
}},
{name: "listener/eligible-not-busy", cfg: func(c *connSockConfig) { c.run = 1 << 30 },
setup: func(b *testing.B, u *StdConn, dst netip.AddrPort) { u.SetEstablishedPeer(dst, true) }},
{name: "connected", setup: func(b *testing.B, u *StdConn, dst netip.AddrPort) {
u.SetEstablishedPeer(dst, true)
for range u.socks.cfg.run {
_ = u.WriteTo(pkt, dst)
}
if u.connSockFor(dst) == nil {
b.Fatal("no connected socket")
}
}},
}
for _, c := range cases {
b.Run(c.name, func(b *testing.B) {
u, dst := benchConnSocks(b, Settings{Listen: netip.MustParseAddrPort("0.0.0.0:0")}, c.cfg)
if c.setup != nil {
c.setup(b, u, dst)
}
b.ReportAllocs()
b.ResetTimer()
for range b.N {
_ = u.WriteTo(pkt, dst)
}
})
}
}
// BenchmarkConnSockDispatch measures what WriteTo adds before the listener's sendto, without the syscall: a v4
// listener refuses a v6 destination before sending, with connected sockets off or with another peer established.
func BenchmarkConnSockDispatch(b *testing.B) {
pkt := make([]byte, 1400)
dst := netip.MustParseAddrPort("[::1]:4242")
for _, c := range []struct {
name string
cfg func(*connSockConfig)
establish bool
}{
{name: "off", cfg: func(c *connSockConfig) { c.max = 0 }},
{name: "ineligible", establish: true},
} {
b.Run(c.name, func(b *testing.B) {
u, peer := benchConnSocks(b, Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0"), Multi: true}, c.cfg)
if c.establish {
u.SetEstablishedPeer(peer, true)
}
b.ReportAllocs()
b.ResetTimer()
for range b.N {
if u.WriteTo(pkt, dst) == nil {
b.Fatal("sent a v6 datagram on a v4 listener")
}
}
})
}
}
-839
View File
@@ -1,839 +0,0 @@
//go:build !e2e_testing
package udp
import (
"context"
"errors"
"fmt"
"log/slog"
"maps"
"net"
"net/netip"
"os"
"slices"
"sync"
"sync/atomic"
"syscall"
"time"
"unsafe"
"github.com/slackhq/nebula/internal/msgx"
"golang.org/x/sys/unix"
)
// A connected socket is a UDP socket connected to one busy peer, on the listener's port and bound to the source
// address the listener's route to that peer picks, so the peer sees the same address and port from either. A send
// on a connected socket skips the per-datagram address and MAC policy checks, and the EndpointSecurity send check
// that xprotectd can hold every unconnected sendto on, and it is the only UDP send that reports the interface
// queue's flow control, as ENOBUFS. A connected socket wins xnu's lookup for its peer's datagrams; it never sees
// anyone else's.
//
// A connected socket sets SO_REUSEPORT and binds a specific address beside a wildcard listener, which sets
// SO_REUSEPORT only for listen routines. xnu refuses a wildcard SO_REUSEPORT bind beside a holder without the
// option, and refuses another uid's bind to an address a socket holds specifically, so no other user can join the
// port while connected sockets open and close: uid nobody got EADDRINUSE on every bind against a root listener
// with connected sockets in the 09-25 probes. A connected socket is closed, never disconnected, because xnu widens
// a disconnected socket's local address to the wildcard.
//
// Only the current remote of an established tunnel may get one: Nebula names those with SetEstablishedPeer, so an
// unauthenticated sender can't earn a connected socket by drawing replies such as recv_error or handshake
// responses.
type connSock struct {
dst netip.AddrPort
peer *connSockPeer
conn *net.UDPConn
rc syscall.RawConn
// used is the monotonic time in nanoseconds of the connected socket's last send or receive.
used atomic.Int64
// stallAt is the monotonic time of the first ENOBUFS or EAGAIN since a send last went through, or 0, and
// dropping is set once that stall has dropped a datagram, so each stall logs its drops once.
stallAt atomic.Int64
dropping atomic.Bool
// 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.
parkMu sync.Mutex
// sys writes bufs on the descriptor and returns how many went out: sendFd, or a stand-in for the interface in
// tests.
sys func(fd int, bufs [][]byte, x *sendScratch) (int, error)
}
// sendScratch is the msghdr_x array one sendmsg_x reads.
type sendScratch struct {
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.
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
// passed through the RawConn interface escapes and would allocate on every send.
type connSockWriter struct {
s *connSock
// bufs holds a copy of the datagrams' slice headers rather than the caller's slice, which would escape
// through the pool and cost WriteTo's one-datagram array an allocation per send.
bufs [msgx.Batch][]byte
nbufs int
park bool
n int
err error
fn func(fd uintptr) bool
x sendScratch
}
var connSockWriters = sync.Pool{New: func() any {
w := &connSockWriter{}
w.fn = w.write
return w
}}
func (w *connSockWriter) write(fd uintptr) bool {
for {
w.n, w.err = w.s.sys(int(fd), w.bufs[:w.nbufs], &w.x)
switch {
case w.err == syscall.EINTR:
case w.err == syscall.EAGAIN && w.park:
return false
default:
return true
}
}
}
// try writes bufs on s once and returns how many went out, or none and the write's errno,
// os.ErrDeadlineExceeded, or net.ErrClosed. With park set, EAGAIN waits in the netpoller until the socket is
// writable or the write deadline passes; without it, EAGAIN is returned.
func (s *connSock) try(bufs [][]byte, park bool) (int, error) {
w := connSockWriters.Get().(*connSockWriter)
w.s, w.nbufs, w.park = s, copy(w.bufs[:], bufs), park
rerr := s.rc.Write(w.fn)
n, err := w.n, w.err
clear(w.bufs[:w.nbufs])
w.s, w.nbufs, w.n, w.err = nil, 0, 0, nil
connSockWriters.Put(w)
switch {
case rerr == nil:
return n, err
case errors.Is(rerr, os.ErrDeadlineExceeded):
return 0, os.ErrDeadlineExceeded
default:
return 0, net.ErrClosed
}
}
// connSockConfig holds the knobs, which tests change.
type connSockConfig struct {
// max is how many connected sockets the listen routines may have open at once; 0 turns connected sockets off.
max int
// run is how many datagrams to one destination within one window earn it a connected socket. darwin's tun
// hands over one packet per read, so a peer's sends arrive one WriteTo or one-datagram batch at a time and
// busyness has to be counted across calls.
run int
window time.Duration
// idle closes a connected socket after it has neither sent nor received for this long.
idle time.Duration
// backoff keeps a destination whose connected socket failed on the listener for this long.
backoff time.Duration
// openEvery is how often the open bucket earns back an open once max are spent, which bounds connected socket
// churn however fast senders earn connected sockets and errors close them.
openEvery time.Duration
// enobufsMax is how long a connected socket's sends may wait out ENOBUFS without one going through before they
// drop instead, so a suspended interface costs one write per datagram rather than stalling the tun reader.
enobufsMax time.Duration
}
func defaultConnSockConfig() connSockConfig {
return connSockConfig{
max: 8,
run: 64,
window: time.Second,
idle: 30 * time.Second,
backoff: 30 * time.Second,
openEvery: time.Second,
enobufsMax: 10 * time.Millisecond,
}
}
// connSockGroups holds the connSocks that the listen routines bound to one address share, so the limits, the
// connected sockets and Rebind cover every routine, and a peer has at most one connected socket.
var connSockGroups = struct {
sync.Mutex
m map[netip.AddrPort]*connSocks
}{m: map[netip.AddrPort]*connSocks{}}
// joinConnSocks returns the connSocks u shares with the other listen routines bound to la, and makes it for the
// first.
func joinConnSocks(u *StdConn, la netip.AddrPort, s Settings) *connSocks {
g := &connSockGroups
g.Lock()
defer g.Unlock()
if cs := g.m[la]; s.Multi && cs != nil {
cs.mu.Lock()
cs.members = append(cs.members, u)
cs.mu.Unlock()
return cs
}
cs := &connSocks{cfg: defaultConnSockConfig(), key: la, members: []*StdConn{u}, clock: monoNow, sleep: time.Sleep}
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
// both sockets set SO_REUSEPORT, and a listener with it lets another uid bind a dual-stack wildcard on the
// port.
cs.off.Store(true)
u.l.Debug("connected sockets: off for a specific listen.host", "addr", s.Listen)
}
if s.Multi {
g.m[la] = cs
}
return cs
}
type connSocks struct {
cfg connSockConfig
// key is the listeners' bound address, which connSockGroups files this under.
key netip.AddrPort
// off keeps connected sockets from opening, when the listener's address can't be shared with them.
off atomic.Bool
// table maps each destination that is the remote of an established tunnel, and that a connected socket could
// reach, to its peer; it is nil when there are none, so a send with nothing to consider costs one load. Every
// send reads it without a lock, and mu guards copying it. An open that holds mu and still finds its peer here
// can't outlive the tunnel.
table atomic.Pointer[map[netip.AddrPort]*connSockPeer]
// reserved counts the connected sockets that are open, opening or closing, against cfg.max; mu guards changing it.
reserved atomic.Int32
mu sync.Mutex
closed bool
// members are the listen routines' listeners that share these connected sockets.
members []*StdConn
// pending holds each destination whose connected socket is opening or closing, and not on its peer. xnu
// refuses to connect a 4-tuple that is still bound, so a destination in pending can't open another.
pending map[netip.AddrPort]struct{}
// rebinds counts Rebinds, so an open that copied the listener's interface before one is discarded.
rebinds uint64
// closers tracks the goroutines that close detached connected sockets.
closers sync.WaitGroup
// done stops the reaper; it is made when ListenOut starts the connected sockets.
done chan struct{}
// opens bounds connected socket opens to cfg.max at once and one per cfg.openEvery after.
opens gcra
// logs bounds connected socket log lines at info or warn; see connSockLogBurst.
logs gcra
// clock returns monotonic nanoseconds and sleep waits out ENOBUFS: monoNow and time.Sleep, or stand-ins in
// tests.
clock func() int64
sleep func(time.Duration)
// dialHook and closeHook, when set, run just before an open's dials and a close's Close, outside mu; tests
// use them to hold an open or close in flight.
dialHook, closeHook func(dst netip.AddrPort)
}
// connSockPeer is what connSocks keeps about an established tunnel's remote: its connected socket, how busy it is,
// and how long a failed connected socket keeps it on the listener.
type connSockPeer struct {
sock atomic.Pointer[connSock]
// windowMu guards start, the monotonic time the current window began, and n, the datagrams sent in it, so a
// window's reset and its counts can't interleave with another sender's.
windowMu sync.Mutex
start int64
n int
// retryAt is the monotonic time before which a peer whose connected socket failed stays on the listener;
// connSocks.mu guards it.
retryAt int64
}
// busy counts n more datagrams to p and reports whether it has now sent cfg.run within one window. A busy peer's
// count starts over, so a peer that can't get a connected socket retries at most once per cfg.run sends.
func (p *connSockPeer) busy(now int64, n int, cfg *connSockConfig) bool {
p.windowMu.Lock()
defer p.windowMu.Unlock()
if time.Duration(now-p.start) > cfg.window {
p.start, p.n = now, 0
}
p.n += n
if p.n < cfg.run {
return false
}
p.n = 0
return true
}
// connSockLogBurst and connSockLogEvery size the bucket that lets connected socket opens, closes and failures log
// at info or warn; past it they log at debug, so churn can't flood the log.
const (
connSockLogBurst = 32
connSockLogEvery = 10 * time.Second
)
var monoStart = time.Now()
func monoNow() int64 { return int64(time.Since(monoStart)) }
// gcra is a token bucket kept as the monotonic time it is next full (the generic cell rate algorithm), so it needs
// no refill tick.
type gcra struct{ tat int64 }
// take spends a token from a bucket of burst that earns one back per every, and reports whether there was one to
// spend.
func (g *gcra) take(now int64, burst int, every time.Duration) bool {
e := int64(every)
tat := max(g.tat, now)
if tat-now > int64(burst-1)*e {
return false
}
g.tat = tat + e
return true
}
// logLevelLocked returns level while the log bucket has a token, and debug once it is spent.
func (cs *connSocks) logLevelLocked(level slog.Level) slog.Level {
if cs.logs.take(cs.clock(), connSockLogBurst, connSockLogEvery) {
return level
}
return slog.LevelDebug
}
// startConnSocks starts the idle reaper.
func (u *StdConn) startConnSocks() {
cs := u.socks
cs.mu.Lock()
defer cs.mu.Unlock()
if cs.closed || cs.done != nil || cs.cfg.max <= 0 || cs.off.Load() {
return
}
cs.done = make(chan struct{})
go u.reapConnSocks(cs.done)
}
// stopConnSocks closes every connected socket and keeps new ones from opening, once any listen routine's listener
// closes, as they do together at shutdown. It returns once their descriptors are closed.
func (u *StdConn) stopConnSocks() {
cs := u.socks
cs.mu.Lock()
cs.members = slices.DeleteFunc(cs.members, func(m *StdConn) bool { return m == u })
if !cs.closed {
cs.closed = true
if cs.done != nil {
close(cs.done)
}
u.detachAllLocked("close")
}
cs.mu.Unlock()
connSockGroups.Lock()
if connSockGroups.m[cs.key] == cs {
delete(connSockGroups.m, cs.key)
}
connSockGroups.Unlock()
cs.closers.Wait()
}
// siblings returns the other listen routines' listeners.
func (cs *connSocks) siblings(u *StdConn) []*StdConn {
cs.mu.Lock()
defer cs.mu.Unlock()
return slices.DeleteFunc(slices.Clone(cs.members), func(m *StdConn) bool { return m == u })
}
// connSockFor returns dst's connected socket, or nil.
func (u *StdConn) connSockFor(dst netip.AddrPort) *connSock {
if p := u.socks.peer(dst); p != nil {
return p.sock.Load()
}
return nil
}
func (cs *connSocks) peer(dst netip.AddrPort) *connSockPeer {
if t := cs.table.Load(); t != nil {
return (*t)[dst]
}
return nil
}
// SetEstablishedPeer makes dst eligible for a connected socket while it is the remote of an established tunnel,
// and closes the one it has once it no longer is. Nebula calls it for every listen routine under the hostmap's
// write lock, so repeats are no-ops and it makes no syscalls: the descriptor is closed by another goroutine.
func (u *StdConn) SetEstablishedPeer(dst netip.AddrPort, established bool) {
cs := u.socks
if cs.cfg.max <= 0 || cs.off.Load() || !u.connSockable(dst) {
return
}
cs.mu.Lock()
defer cs.mu.Unlock()
t := cs.table.Load()
p := cs.peer(dst)
if cs.closed || (p != nil) == established {
return
}
next := map[netip.AddrPort]*connSockPeer{}
if t != nil {
next = maps.Clone(*t)
}
if established {
p = &connSockPeer{start: cs.clock()}
next[dst] = p
} else {
delete(next, dst)
if s := p.sock.Load(); s != nil {
u.detachLocked(s, "tunnel gone", false)
}
}
cs.storeTableLocked(next)
}
// storeTableLocked publishes t, or nil for an empty one.
func (cs *connSocks) storeTableLocked(t map[netip.AddrPort]*connSockPeer) {
if len(t) == 0 {
cs.table.Store(nil)
return
}
cs.table.Store(&t)
}
// connSockable reports whether a connected socket to dst could send what the listener would. A v4 listener can't
// reach a v6 destination at all, and a connected socket bound to a specific listen.host must share its family.
func (u *StdConn) connSockable(dst netip.AddrPort) bool {
if !dst.IsValid() || dst.Port() == 0 {
return false
}
if u.isV4 {
return dst.Addr().Is4()
}
return u.listenHost.IsUnspecified() || u.listenHost.Unmap().Is4() == dst.Addr().Unmap().Is4()
}
// connSockRun sends bufs, all to p's destination, on p's connected socket, opening one if they make p busy. It
// returns how many went out; when that is short of len(bufs), err is the failure of bufs[sent], or nil to leave
// bufs[sent:] to the listener.
func (u *StdConn) connSockRun(p *connSockPeer, dst netip.AddrPort, bufs [][]byte) (sent int, err error) {
s := p.sock.Load()
if s == nil {
if s = u.maybeOpenConnSock(p, dst, len(bufs)); s == nil {
return 0, nil
}
}
sent, errno, closed := u.connSockWrite(s, bufs)
switch {
case sent == len(bufs):
case connSockDead(errno):
u.closeConnSock(s, errno.Error(), true)
case !closed:
return sent, &net.OpError{Op: "write", Err: errno}
}
return sent, nil
}
// maybeOpenConnSock counts n datagrams to p, and opens a connected socket to it once it is busy and nothing rules
// one out.
func (u *StdConn) maybeOpenConnSock(p *connSockPeer, dst netip.AddrPort, n int) *connSock {
cs := u.socks
if n <= 0 || !u.listening.Load() || int(cs.reserved.Load()) >= cs.cfg.max || !p.busy(cs.clock(), n, &cs.cfg) {
return nil
}
cs.mu.Lock()
if cs.closed || cs.peer(dst) != p {
cs.mu.Unlock()
return nil
}
if s := p.sock.Load(); s != nil {
cs.mu.Unlock()
return s
}
now := cs.clock()
if _, ok := cs.pending[dst]; ok || int(cs.reserved.Load()) >= cs.cfg.max || now < p.retryAt ||
!cs.opens.take(now, cs.cfg.max, cs.cfg.openEvery) {
cs.mu.Unlock()
return nil
}
if cs.pending == nil {
cs.pending = map[netip.AddrPort]struct{}{}
}
cs.pending[dst] = struct{}{}
cs.reserved.Add(1)
rebinds := cs.rebinds
cs.mu.Unlock()
if cs.dialHook != nil {
cs.dialHook(dst)
}
s, err := u.dialConnSock(p, dst)
cs.mu.Lock()
if err != nil {
delete(cs.pending, dst)
cs.reserved.Add(-1)
p.retryAt = cs.clock() + int64(cs.cfg.backoff)
level := cs.logLevelLocked(slog.LevelWarn)
cs.mu.Unlock()
u.l.Log(context.Background(), level, "connected socket: open failed, staying on the listener", "udpAddr", dst, "error", err)
return nil
}
if cs.closed || cs.rebinds != rebinds || cs.peer(dst) != p {
// The tunnel went away, or a Rebind or shutdown ran, while the socket was opening; it stays in pending until
// it is closed.
cs.mu.Unlock()
u.finishClose(s)
u.l.Debug("connected socket: discarded, its tunnel or route changed while it opened", "udpAddr", dst)
return nil
}
delete(cs.pending, dst)
p.sock.Store(s)
go u.readConnSock(s)
level := cs.logLevelLocked(slog.LevelInfo)
cs.mu.Unlock()
u.l.Log(context.Background(), level, "connected socket: opened", "udpAddr", dst, "local", s.conn.LocalAddr(), "open", cs.reserved.Load())
return s
}
// dialConnSock opens a socket on the listener's port with SO_REUSEPORT, bound to the configured listen.host or,
// for a wildcard listener, to the source address the route to dst picks, and connected to dst. It carries the
// listener's IP_BOUND_IF, so both route the same way.
func (u *StdConn) dialConnSock(p *connSockPeer, dst netip.AddrPort) (*connSock, error) {
raddr := net.UDPAddrFromAddrPort(netip.AddrPortFrom(dst.Addr().Unmap(), dst.Port()))
network := "udp6"
if raddr.IP.To4() != nil {
network = "udp4"
}
ifindex, err := u.boundIf()
if err != nil {
return nil, err
}
local := &net.UDPAddr{IP: u.listenHost.AsSlice(), Zone: u.listenHost.Zone()}
if u.listenHost.IsUnspecified() {
// A connected socket gets the source address xnu would pick for an unconnected send to dst.
d := net.Dialer{Control: connSockControl(false, ifindex)}
probe, err := d.Dial(network, raddr.String())
if err != nil {
return nil, err
}
local = probe.LocalAddr().(*net.UDPAddr)
_ = probe.Close()
}
local.Port = int(u.port)
d := net.Dialer{LocalAddr: local, Control: connSockControl(true, ifindex)}
c, err := d.Dial(network, raddr.String())
if err != nil {
return nil, err
}
uc := c.(*net.UDPConn)
rc, err := uc.SyscallConn()
if err != nil {
_ = uc.Close()
return nil, err
}
s := &connSock{dst: dst, peer: p, conn: uc, rc: rc, sys: sendFd}
s.used.Store(u.socks.clock())
return s, nil
}
// connSockControl sets SO_REUSEPORT when reuse is set, and IP_BOUND_IF or IPV6_BOUND_IF when ifindex isn't 0,
// before the socket binds.
func connSockControl(reuse bool, ifindex int) func(network, address string, c syscall.RawConn) error {
return func(network, _ string, c syscall.RawConn) error {
var serr error
err := c.Control(func(fd uintptr) {
if reuse {
serr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
}
if serr == nil && ifindex != 0 {
if network == "udp4" {
serr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_BOUND_IF, ifindex)
} else {
serr = unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_BOUND_IF, ifindex)
}
}
})
if err != nil {
return err
}
return serr
}
}
// boundIf returns the interface index the listener is scoped to, or 0. An error keeps the peer on the listener,
// since a connected socket opened without the listener's scope could route out an interface the listener can't.
func (u *StdConn) boundIf() (int, error) {
level, opt := unix.IPPROTO_IPV6, unix.IPV6_BOUND_IF
if u.isV4 {
level, opt = unix.IPPROTO_IP, unix.IP_BOUND_IF
}
v, err := unix.GetsockoptInt(int(u.sysFd), level, opt)
if err != nil {
return 0, fmt.Errorf("reading the listener's bound interface: %w", err)
}
return v, nil
}
// closeConnSock closes s if it is still open. With backoff set, the peer stays on the listener until the backoff
// runs out.
func (u *StdConn) closeConnSock(s *connSock, why string, backoff bool) {
u.socks.mu.Lock()
u.detachLocked(s, why, backoff)
u.socks.mu.Unlock()
}
// detachLocked takes s off its peer, if it is still there, and closes it on another goroutine, since callers such
// as SetEstablishedPeer hold locks that no socket syscall should run under. s.dst stays in pending until the close
// completes.
func (u *StdConn) detachLocked(s *connSock, why string, backoff bool) {
cs := u.socks
if !s.peer.sock.CompareAndSwap(s, nil) {
return
}
if backoff {
s.peer.retryAt = cs.clock() + int64(cs.cfg.backoff)
}
if cs.pending == nil {
cs.pending = map[netip.AddrPort]struct{}{}
}
cs.pending[s.dst] = struct{}{}
level := cs.logLevelLocked(slog.LevelInfo)
cs.closers.Add(1)
go func() {
defer cs.closers.Done()
open := u.finishClose(s)
u.l.Log(context.Background(), level, "connected socket: closed", "udpAddr", s.dst, "reason", why, "open", open)
}()
}
// finishClose closes s, whose destination is in pending, then lets the destination open again, and returns how
// many connected sockets are left. Closing waits only for a write already in a syscall: a write parked on a full
// buffer is woken, and one waiting out ENOBUFS holds no reference on the descriptor.
func (u *StdConn) finishClose(s *connSock) int32 {
cs := u.socks
if cs.closeHook != nil {
cs.closeHook(s.dst)
}
_ = s.conn.Close()
cs.mu.Lock()
defer cs.mu.Unlock()
delete(cs.pending, s.dst)
return cs.reserved.Add(-1)
}
// detachAllLocked detaches every connected socket, for a network change or shutdown.
func (u *StdConn) detachAllLocked(why string) {
if t := u.socks.table.Load(); t != nil {
for _, p := range *t {
if s := p.sock.Load(); s != nil {
u.detachLocked(s, why, false)
}
}
}
}
// closeConnSocks detaches every connected socket and discards the ones still opening, for a network change.
func (u *StdConn) closeConnSocks(why string) {
u.socks.mu.Lock()
u.socks.rebinds++
u.detachAllLocked(why)
u.socks.mu.Unlock()
}
func (u *StdConn) reapConnSocks(done <-chan struct{}) {
cs := u.socks
idle := cs.cfg.idle
tick := time.NewTicker(max(min(idle/4, 5*time.Second), time.Millisecond))
defer tick.Stop()
for {
select {
case <-done:
return
case <-tick.C:
}
t := cs.table.Load()
if t == nil {
continue
}
now := cs.clock()
for _, p := range *t {
if s := p.sock.Load(); s != nil && time.Duration(now-s.used.Load()) > idle {
u.closeConnSock(s, "idle", false)
}
}
}
}
// connSockDead reports whether a connected socket send or receive error means the connected path to the peer is
// gone, so its traffic belongs back on the listener. A connected UDP socket reports a peer's ICMP unreachable as
// ECONNREFUSED on its next call, which the unconnected listener never sees.
func connSockDead(errno syscall.Errno) bool {
switch errno {
case unix.ECONNREFUSED, unix.EHOSTUNREACH, unix.EHOSTDOWN, unix.ENETUNREACH, unix.ENETDOWN,
unix.EADDRNOTAVAIL, unix.EPIPE, unix.ENOTCONN, unix.EDESTADDRREQ:
return true
}
return false
}
// enobufsWait is how long a connected socket send sleeps when the interface queue is flow controlled. The kernel
// posts no wakeup when the advisory lifts, so this polls; 50us kept a gigabit link full without spinning a core in
// the 09-25 probes.
const enobufsWait = 50 * time.Microsecond
// 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
// 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
// unreported interface drops do; it never falls back to the listener, which would reorder it. closed reports that
// the connected socket was closed before bufs[sent] went out; any other error stops the run and is returned with
// how many went out.
func (u *StdConn) connSockWrite(s *connSock, bufs [][]byte) (sent int, errno syscall.Errno, closed bool) {
cs := u.socks
defer func() {
if sent > 0 {
s.used.Store(cs.clock())
}
}()
probe := false
for sent < len(bufs) {
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 {
// os.ErrDeadlineExceeded here is another writer's parked deadline, passed but not yet cleared.
k, err = u.parkedWrite(s, bufs[sent:sent+1])
}
switch err {
case nil:
sent += k
if s.stallAt.Load() != 0 {
s.stallAt.Store(0)
s.dropping.Store(false)
}
continue
case errStallSpent:
u.dropStalled(s)
sent++
continue
}
errno, ok := err.(syscall.Errno)
if !ok {
return sent, 0, true
}
if errno != syscall.ENOBUFS {
return sent, errno, false
}
// The wait holds no reference on the descriptor, so a close doesn't wait for it.
if s.stalledFor(cs.clock()) < cs.cfg.enobufsMax {
cs.sleep(enobufsWait)
} else {
u.dropStalled(s)
sent++
}
}
return sent, 0, false
}
// 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
// writability event that never comes, so the wait always has a deadline.
func (u *StdConn) parkedWrite(s *connSock, b [][]byte) (int, error) {
cs := u.socks
s.parkMu.Lock()
defer s.parkMu.Unlock()
left := cs.cfg.enobufsMax - s.stalledFor(cs.clock())
if left <= 0 {
return 0, errStallSpent
}
if err := s.conn.SetWriteDeadline(time.Now().Add(left)); err != nil {
return 0, net.ErrClosed
}
n, err := s.try(b, true)
_ = s.conn.SetWriteDeadline(time.Time{})
if err == os.ErrDeadlineExceeded {
return 0, errStallSpent
}
return n, err
}
// dropStalled logs the first datagram a stall drops.
func (u *StdConn) dropStalled(s *connSock) {
if !s.dropping.Swap(true) {
u.l.Debug("connected socket: sends stalled, dropping datagrams until one goes through", "udpAddr", s.dst)
}
}
// stalledFor records an ENOBUFS or EAGAIN on s at now and returns how long its sends have stalled: since the first
// ENOBUFS or EAGAIN after a send last went through. Every writer measures from that one time, so concurrent writers
// spend the budget no faster than one, and a send going through ends the stall for every writer, including one
// asleep in it.
func (s *connSock) stalledFor(now int64) time.Duration {
if s.stallAt.CompareAndSwap(0, now) {
return 0
}
at := s.stallAt.Load()
if at == 0 {
return 0
}
return time.Duration(now - at)
}
// readConnSock hands a connected socket's batches to ListenOut until the connected socket is closed. Any receive
// error closes it: a connected socket reports its peer's unreachables here, and retrying an unexpected error could
// spin.
func (u *StdConn) readConnSock(s *connSock) {
r := u.newBatchReader(s.conn, s.rc)
for {
b, err := u.read(r)
if err != nil {
if errors.Is(err, net.ErrClosed) {
return
}
why := err.Error()
var errno syscall.Errno
if errors.As(err, &errno) && connSockDead(errno) {
why = errno.Error()
} else {
u.l.Warn("connected socket: unexpected receive error", "udpAddr", s.dst, "error", err)
}
u.closeConnSock(s, why, true)
return
}
s.used.Store(u.socks.clock())
if !u.deliver(b) {
return
}
}
}
File diff suppressed because it is too large. Load diff
-6
View File
@@ -1,6 +0,0 @@
//go:build !race && !e2e_testing
package udp
// raceEnabled reports a -race build, whose sync.Pool drops a random share of what is put back.
const raceEnabled = false
-6
View File
@@ -1,6 +0,0 @@
//go:build race && !e2e_testing
package udp
// raceEnabled reports a -race build, whose sync.Pool drops a random share of what is put back.
const raceEnabled = true
+256 -266
View File
@@ -25,23 +25,11 @@ type StdConn struct {
sysFd uintptr sysFd uintptr
l *slog.Logger l *slog.Logger
// listenHost and port are the configured address and the bound port, which a connected socket shares. noSendmsgX atomic.Bool
listenHost netip.Addr sb *sendScratch
port uint16
// rc reaches the listener's descriptor for another listen routine's Rebind.
rc syscall.RawConn
socks *connSocks
// listening is set once ListenOut runs. The listener's and every connected socket's readers hand their batches
// to it on rx, so the EncReader runs on ListenOut's goroutine alone; done closes when ListenOut returns.
listening atomic.Bool
rx chan *rxBatch
done chan struct{}
// free holds the batches ListenOut has delivered, for the readers to fill again.
free chan *rxBatch
} }
var _ Conn = &StdConn{} var _ Conn = &StdConn{}
var _ EstablishedPeerConn = &StdConn{}
func NewListener(l *slog.Logger, s Settings) (Conn, error) { func NewListener(l *slog.Logger, s Settings) (Conn, error) {
lc := NewListenConfig(s.Multi) lc := NewListenConfig(s.Multi)
@@ -51,14 +39,13 @@ 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(), rx: make(chan *rxBatch, 1), done: make(chan struct{}), c := &StdConn{UDPConn: uc, l: l}
free: make(chan *rxBatch, rxBatchesKept)} c.noSendmsgX.Store(!msgx.Available())
rc, err := uc.SyscallConn() rc, err := uc.SyscallConn()
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to open udp socket: %w", err) return nil, fmt.Errorf("failed to open udp socket: %w", err)
} }
c.rc = rc
err = rc.Control(func(fd uintptr) { err = rc.Control(func(fd uintptr) {
c.sysFd = fd c.sysFd = fd
@@ -72,8 +59,6 @@ func NewListener(l *slog.Logger, s Settings) (Conn, error) {
return nil, err return nil, err
} }
c.isV4 = la.Addr().Is4() c.isV4 = la.Addr().Is4()
c.port = la.Port()
c.socks = joinConnSocks(c, la, s)
return c, nil return c, nil
} }
@@ -110,19 +95,6 @@ func NewListenConfig(multi bool) net.ListenConfig {
func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen int32) (err error) func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen int32) (err error)
func (u *StdConn) WriteTo(b []byte, ap netip.AddrPort) error { func (u *StdConn) WriteTo(b []byte, ap netip.AddrPort) error {
if t := u.socks.table.Load(); t != nil {
if p := (*t)[ap]; p != nil {
bufs := [1][]byte{b}
if sent, err := u.connSockRun(p, ap, bufs[:]); sent == 1 || err != nil {
return err
}
}
}
return u.writeTo(b, ap)
}
// writeTo sends b through the listener.
func (u *StdConn) writeTo(b []byte, ap netip.AddrPort) error {
var sa unsafe.Pointer var sa unsafe.Pointer
var addrLen int32 var addrLen int32
@@ -173,52 +145,163 @@ func (u *StdConn) writeTo(b []byte, ap netip.AddrPort) error {
} }
} }
// sendBatch is how many datagrams one sendmsg_x call may carry.
const sendBatch = 64
// sendScratch is WriteBatch's scratch. The kernel reads every entry in place.
type sendScratch struct {
names [sendBatch]unix.RawSockaddrInet6
iovs [sendBatch]unix.Iovec
hdrs [sendBatch]msgx.Hdr
// idx maps each entry back to its index in WriteBatch's bufs.
idx [sendBatch]int
}
// WriteBatch sends bufs with sendmsg_x, darwin's private batched sendmsg, so one syscall carries up to
// sendBatch datagrams. On this unconnected socket xnu still runs each message through sendit, so the
// saving is the syscall crossings, not the per-send policy checks.
//
// xnu's per-message loop stops at the first message that fails. For the errors in sentNothing it reports
// how many went out; for any other it returns only the errno, with the messages before it already sent.
// Each call therefore carries one run of datagrams to the same destination: a destination the kernel
// refuses fails on its first datagram, so a failed call costs that run and nothing else, and no datagram
// is ever resent after the kernel may have taken it.
//
// TODO: WriteTo maps EWOULDBLOCK to an error, so a full send buffer
// silently drops the rest of a burst (linux blocks instead). Poll for
// writability on EAGAIN before giving up on the remainder.
func (u *StdConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) { func (u *StdConn) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
// An un-sendable destination costs its own packet, never the ones behind it in the batch. if u.noSendmsgX.Load() {
// TODO: writeTo maps EWOULDBLOCK to an error, so a full listener send buffer return u.writeEach(bufs, addrs), nil
// silently drops those packets (linux blocks instead). Poll for }
// writability on EAGAIN before giving up on them. if u.sb == nil {
u.sb = new(sendScratch)
}
b := u.sb
written := 0
for i := 0; i < len(bufs); {
n := 0
for ; i < len(bufs) && n < sendBatch; i++ {
namelen, err := u.putSockaddr(&b.names[n], addrs[i])
if err != nil {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err)
continue
}
b.iovs[n] = unix.Iovec{}
if len(bufs[i]) > 0 {
b.iovs[n].Base = &bufs[i][0]
b.iovs[n].SetLen(len(bufs[i]))
}
b.hdrs[n] = msgx.Hdr{Name: (*byte)(unsafe.Pointer(&b.names[n])), Namelen: namelen, Iov: &b.iovs[n], Iovlen: 1}
b.idx[n] = i
n++
}
for off := 0; off < n; {
dst := addrs[b.idx[off]]
end := off + 1
for end < n && addrs[b.idx[end]] == dst {
end++
}
sent, errno := u.sendmsgX(off, end)
switch {
case errno == 0 && sent > 0:
written += sent
off += sent
continue
case sentNothing(errno):
// The datagram at off failed on its own account. sendto delivers or reports it, as without
// batching, and the rest of the run goes back to sendmsg_x.
j := b.idx[off]
written += u.writeEach(bufs[j:j+1], addrs[j:j+1])
off++
continue
case errno == 0:
case errno == unix.ENOSYS || errno == unix.EOPNOTSUPP:
u.fallBack(errno)
case errno == unix.EPERM || errno == unix.EINVAL:
// Either can refuse one destination, but a datagram that sendto delivers was refused by
// sendmsg_x itself, as a sandbox or an older kernel would.
j := b.idx[off]
if u.writeEach(bufs[j:j+1], addrs[j:j+1]) == 0 {
off = end
continue
}
written++
off++
u.fallBack(errno)
default:
u.l.Debug("failed to write packets in batch", "udpAddr", dst, "packets", end-off, "error", errno)
off = end
continue
}
// The kernel took nothing from this call, so the rest can go out one datagram at a time.
for _, j := range b.idx[off:n] {
written += u.writeEach(bufs[j:j+1], addrs[j:j+1])
}
off = n
if u.noSendmsgX.Load() {
clear(b.iovs[:n])
return written + u.writeEach(bufs[i:], addrs[i:]), nil
}
}
clear(b.iovs[:n])
}
return written, nil
}
// sendmsgX hands entries off through end-1 of u.sb to sendmsg_x and returns how many the kernel took.
// The socket is non-blocking, so a full send buffer returns EAGAIN rather than waiting.
func (u *StdConn) sendmsgX(off, end int) (int, syscall.Errno) {
for {
sent, errno := msgx.Send(u.sysFd, u.sb.hdrs[off:end], 0)
if errno == unix.EINTR {
continue
}
return sent, errno
}
}
// sentNothing reports whether sendmsg_x failing with errno means no datagram went out: once any has, xnu
// turns these errors into a short count instead.
func sentNothing(errno syscall.Errno) bool {
return errno == unix.EWOULDBLOCK || errno == unix.ENOBUFS || errno == unix.EMSGSIZE
}
// fallBack switches WriteBatch to one sendto per datagram for the life of the socket.
func (u *StdConn) fallBack(errno syscall.Errno) {
if u.noSendmsgX.CompareAndSwap(false, true) {
u.l.Warn("sendmsg_x unavailable, sending one datagram per syscall", "error", errno)
}
}
// writeEach sends bufs one at a time with WriteTo and returns how many were written.
func (u *StdConn) writeEach(bufs [][]byte, addrs []netip.AddrPort) int {
written := 0 written := 0
t := u.socks.table.Load()
if t == nil {
for i, b := range bufs { for i, b := range bufs {
if err := u.writeTo(b, addrs[i]); err == nil { if err := u.WriteTo(b, addrs[i]); err == nil {
written++ written++
} else { } else {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err) u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err)
} }
} }
return written, nil return written
}
// putSockaddr writes ap into sa in the socket's address family, as WriteTo would, and returns its length.
func (u *StdConn) putSockaddr(sa *unix.RawSockaddrInet6, ap netip.AddrPort) (uint32, error) {
if u.isV4 {
if ap.Addr().Is6() {
return 0, ErrInvalidIPv6RemoteForSocket
} }
for off := 0; off < len(bufs); { sa4 := (*unix.RawSockaddrInet4)(unsafe.Pointer(sa))
// A run of datagrams to one peer goes out together, on its connected socket if it has or earns one. *sa4 = unix.RawSockaddrInet4{Family: unix.AF_INET, Addr: ap.Addr().As4()}
dst := addrs[off] binary.BigEndian.PutUint16((*[2]byte)(unsafe.Pointer(&sa4.Port))[:], ap.Port())
end := off + 1 return unix.SizeofSockaddrInet4, nil
for end < len(bufs) && addrs[end] == dst {
end++
} }
if p := (*t)[dst]; p != nil { *sa = unix.RawSockaddrInet6{Family: unix.AF_INET6, Addr: ap.Addr().As16()}
for off < end { binary.BigEndian.PutUint16((*[2]byte)(unsafe.Pointer(&sa.Port))[:], ap.Port())
sent, err := u.connSockRun(p, dst, bufs[off:end]) return unix.SizeofSockaddrInet6, nil
written += sent
off += sent
if err == nil {
break
}
u.l.Debug("failed to write packet in batch", "udpAddr", dst, "error", err)
off++
}
}
// The listener sends what no connected socket took.
for ; off < end; off++ {
if err := u.writeTo(bufs[off], dst); err == nil {
written++
} else {
u.l.Debug("failed to write packet in batch", "udpAddr", dst, "error", err)
}
}
}
return written, nil
} }
func (u *StdConn) LocalAddr() (netip.AddrPort, error) { func (u *StdConn) LocalAddr() (netip.AddrPort, error) {
@@ -246,176 +329,45 @@ 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. // recvBatch is how many datagrams one recvmsg_x call may return.
const recvBatch = 64
// ListenOut drains the socket with recvmsg_x, darwin's private batched recvmsg, so one syscall reads
// up to recvBatch datagrams instead of one.
func (u *StdConn) ListenOut(r EncReader, flush func()) error { func (u *StdConn) ListenOut(r EncReader, flush func()) error {
defer close(u.done) if !msgx.Available() {
u.listening.Store(true) return u.listenOutSingle(r, flush)
u.startConnSocks()
errc := make(chan error, 1)
go func() { errc <- u.readListener() }()
for {
select {
case b := <-u.rx:
for i := range b.n {
r(b.addrs[i], b.pkts[i])
} }
flush() rc, err := u.UDPConn.SyscallConn()
u.putBatch(b) if err != nil {
case err := <-errc:
return err return err
} }
}
}
// rxBatch is one recvmsg_x batch: n datagrams in pkts, from addrs. A reader takes one only while its socket is bufs := make([][]byte, recvBatch)
// readable, so an idle connected socket holds none. names := make([]unix.RawSockaddrInet6, recvBatch)
type rxBatch struct { iovs := make([]unix.Iovec, recvBatch)
n int hdrs := make([]msgx.Hdr, recvBatch)
pkts [msgx.Batch][]byte for i := range hdrs {
addrs [msgx.Batch]netip.AddrPort bufs[i] = make([]byte, MTU)
buf []byte iovs[i].Base = &bufs[i][0]
names [msgx.Batch]unix.RawSockaddrInet6 iovs[i].SetLen(MTU)
iovs [msgx.Batch]unix.Iovec hdrs[i].Iov = &iovs[i]
hdrs [msgx.Batch]msgx.Hdr hdrs[i].Iovlen = 1
} hdrs[i].Name = (*byte)(unsafe.Pointer(&names[i]))
}
// 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 { for {
b, err := u.read(r) var n int
var errno syscall.Errno
err := rc.Read(func(fd uintptr) bool {
for i := range hdrs {
hdrs[i].Namelen = unix.SizeofSockaddrInet6
hdrs[i].Flags = 0
hdrs[i].Datalen = 0
}
n, errno = msgx.Recv(fd, hdrs, 0)
return errno != unix.EAGAIN
})
if err != nil { if err != nil {
if errors.Is(err, net.ErrClosed) { if errors.Is(err, net.ErrClosed) {
return err return err
@@ -423,27 +375,85 @@ func (u *StdConn) readListener() 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) { if errno == unix.ENOSYS || errno == unix.EPERM || errno == unix.EOPNOTSUPP {
return net.ErrClosed // recvmsg_x is private, so a kernel or sandbox may refuse it.
u.l.Warn("recvmsg_x unavailable, reading one datagram per syscall", "error", errno)
return u.listenOutSingle(r, flush)
} }
if errno != 0 {
if errno != unix.EINTR {
u.l.Error("unexpected udp socket receive error", "error", errno)
}
continue
}
if err := checkMsghdrX(hdrs, names, n); err != nil {
// The batch was read through a layout the kernel no longer writes, so none of it is trustworthy.
u.l.Warn("recvmsg_x returned an unexpected header, reading one datagram per syscall", "error", err)
return u.listenOutSingle(r, flush)
}
for i := 0; i < n; i++ {
addr, ok := sockaddrToAddrPort(&names[i])
if !ok {
continue
}
l := int(hdrs[i].Datalen)
r(addr, bufs[i][:l:l])
}
flush()
} }
} }
// deliver hands b to ListenOut, and reports false once ListenOut has returned. // checkMsghdrX rejects a recvmsg_x result that intact msghdr_x entries can't produce, which is how a change
func (u *StdConn) deliver(b *rxBatch) bool { // to xnu's private struct layout would show up.
select { func checkMsghdrX(hdrs []msgx.Hdr, names []unix.RawSockaddrInet6, n int) error {
case u.rx <- b: if n > len(hdrs) {
return true return fmt.Errorf("returned %d datagrams for %d headers", n, len(hdrs))
case <-u.done: }
u.putBatch(b) for i := range n {
return false if hdrs[i].Datalen > MTU {
return fmt.Errorf("datagram %d is %d bytes, past the %d byte buffer", i, hdrs[i].Datalen, MTU)
}
switch {
case names[i].Family == unix.AF_INET && hdrs[i].Namelen == unix.SizeofSockaddrInet4:
case names[i].Family == unix.AF_INET6 && hdrs[i].Namelen == unix.SizeofSockaddrInet6:
default:
return fmt.Errorf("datagram %d has address family %d with length %d", i, names[i].Family, hdrs[i].Namelen)
}
}
return nil
}
// listenOutSingle reads one datagram per recvfrom and flushes after each, for when recvmsg_x is refused or misbehaves.
func (u *StdConn) listenOutSingle(r EncReader, flush func()) error {
buffer := make([]byte, MTU)
for {
n, rua, err := u.ReadFromUDPAddrPort(buffer)
if err != nil {
if errors.Is(err, net.ErrClosed) {
return err
}
u.l.Error("unexpected udp socket receive error", "error", err)
continue
}
r(netip.AddrPortFrom(rua.Addr().Unmap(), rua.Port()), buffer[:n:n])
flush()
} }
} }
// Close closes the connected sockets of every listen routine, then the listener. func sockaddrToAddrPort(sa *unix.RawSockaddrInet6) (netip.AddrPort, bool) {
func (u *StdConn) Close() error { switch sa.Family {
u.stopConnSocks() case unix.AF_INET:
return u.UDPConn.Close() sa4 := (*unix.RawSockaddrInet4)(unsafe.Pointer(sa))
port := binary.BigEndian.Uint16((*[2]byte)(unsafe.Pointer(&sa4.Port))[:])
return netip.AddrPortFrom(netip.AddrFrom4(sa4.Addr), port), true
case unix.AF_INET6:
port := binary.BigEndian.Uint16((*[2]byte)(unsafe.Pointer(&sa.Port))[:])
return netip.AddrPortFrom(netip.AddrFrom16(sa.Addr).Unmap(), port), true
}
return netip.AddrPort{}, false
} }
func (u *StdConn) SupportsMultipleReaders() bool { func (u *StdConn) SupportsMultipleReaders() bool {
@@ -452,10 +462,7 @@ func (u *StdConn) SupportsMultipleReaders() bool {
// Rebind clears the interface the kernel scoped this socket to, so that sends are routed against the current // Rebind clears the interface the kernel scoped this socket to, so that sends are routed against the current
// routing table instead of the interface we happened to be on when the socket was created. Darwin pins sockets // routing table instead of the interface we happened to be on when the socket was created. Darwin pins sockets
// this way on its own, which is what strands us after the underlying network changes. Control.RebindUDPServer // this way on its own, which is what strands us after the underlying network changes.
// rebinds only the first writer, so this clears the other listen routines' listeners too. Connected sockets are
// closed after the listeners are cleared, and later ones copy the cleared scope and pick their source addresses
// afresh.
func (u *StdConn) Rebind() error { func (u *StdConn) Rebind() error {
var err error var err error
if u.isV4 { if u.isV4 {
@@ -463,23 +470,6 @@ func (u *StdConn) Rebind() error {
} else { } else {
err = syscall.SetsockoptInt(int(u.sysFd), syscall.IPPROTO_IPV6, syscall.IPV6_BOUND_IF, 0) err = syscall.SetsockoptInt(int(u.sysFd), syscall.IPPROTO_IPV6, syscall.IPV6_BOUND_IF, 0)
} }
for _, m := range u.socks.siblings(u) {
err = errors.Join(err, m.clearBoundIf())
}
u.closeConnSocks("rebind")
return err
}
// clearBoundIf clears the interface the listener is scoped to through its RawConn, which fails on a listener that
// closed concurrently instead of reaching whatever reused its descriptor number.
func (u *StdConn) clearBoundIf() error {
level, opt := syscall.IPPROTO_IPV6, syscall.IPV6_BOUND_IF
if u.isV4 {
level, opt = syscall.IPPROTO_IP, syscall.IP_BOUND_IF
}
var serr error
if err := u.rc.Control(func(fd uintptr) { serr = syscall.SetsockoptInt(int(fd), level, opt, 0) }); err != nil {
return err return err
}
return serr
} }
+85
View File
@@ -0,0 +1,85 @@
//go:build !e2e_testing
package udp
import (
"log/slog"
"net"
"net/netip"
"sync"
"sync/atomic"
"testing"
)
// BenchmarkListenOut measures the receive path on loopback: senders flood datagrams sized like a full tunnel
// packet, and each op is one datagram delivered to the reader. There are enough senders that the reader, not the
// senders, sets the pace. flushes/pkt is 1 when every receive is its own syscall and falls as receives batch. The
// senders share the machine, so ns/op is only comparable between runs on the same host.
func BenchmarkListenOut(b *testing.B) {
for _, tc := range []struct{ name, listen string }{
{"v4", "127.0.0.1"},
{"v6", "::1"},
} {
b.Run(tc.name, func(b *testing.B) {
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.AddrPortFrom(netip.MustParseAddr(tc.listen), 0)})
if err != nil {
b.Fatal(err)
}
la, err := c.LocalAddr()
if err != nil {
b.Fatal(err)
}
const size, senders = 1300, 4
txs := make([]net.Conn, senders)
for i := range txs {
if txs[i], err = net.Dial("udp", la.String()); err != nil {
b.Fatal(err)
}
defer txs[i].Close()
}
target := int64(b.N)
var got, flushes atomic.Int64
reached := make(chan struct{})
done := make(chan struct{})
go func() {
_ = c.ListenOut(func(netip.AddrPort, []byte) {
if got.Add(1) == target {
close(reached)
}
}, func() { flushes.Add(1) })
close(done)
}()
// Writes fail with ENOBUFS while the send queue is full; the flood only has to keep the receiver busy.
stop := make(chan struct{})
var sent sync.WaitGroup
for _, tx := range txs {
sent.Go(func() {
payload := make([]byte, size)
for {
select {
case <-stop:
return
default:
_, _ = tx.Write(payload)
}
}
})
}
b.SetBytes(size)
b.ResetTimer()
<-reached
b.StopTimer()
close(stop)
sent.Wait()
if err := c.Close(); err != nil {
b.Fatal(err)
}
<-done
b.ReportMetric(float64(flushes.Load())/float64(got.Load()), "flushes/pkt")
})
}
}
+36 -78
View File
@@ -20,7 +20,7 @@ import (
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
// A burst larger than msgx.Batch arrives whole, with each datagram's own bytes and source address, and // A burst larger than recvBatch arrives whole, with each datagram's own bytes and source address, and
// flush runs once per recvmsg_x batch rather than once per datagram. // flush runs once per recvmsg_x batch rather than once per datagram.
func TestListenOutBatchesBurst(t *testing.T) { func TestListenOutBatchesBurst(t *testing.T) {
for _, tc := range []struct{ name, listen string }{ for _, tc := range []struct{ name, listen string }{
@@ -38,7 +38,7 @@ func TestListenOutBatchesBurst(t *testing.T) {
defer tx.Close() defer tx.Close()
txAddr := netip.MustParseAddrPort(tx.LocalAddr().String()) txAddr := netip.MustParseAddrPort(tx.LocalAddr().String())
const total = msgx.Batch*3 + 7 const total = recvBatch*3 + 7
var mu sync.Mutex var mu sync.Mutex
var got []string var got []string
var froms []netip.AddrPort var froms []netip.AddrPort
@@ -77,15 +77,16 @@ func TestListenOutBatchesBurst(t *testing.T) {
assert.Equal(t, fmt.Sprintf("pkt-%03d", i), p) assert.Equal(t, fmt.Sprintf("pkt-%03d", i), p)
assert.Equal(t, txAddr, froms[i]) assert.Equal(t, txAddr, froms[i])
} }
assert.Equal(t, (total+msgx.Batch-1)/msgx.Batch, flushes) assert.Equal(t, (total+recvBatch-1)/recvBatch, flushes)
}) })
} }
} }
// Once recvmsg_x is off, every datagram still arrives, one per batch. // msgx.Hdr round-trips through xnu's recvmsg_x on a loopback socket, v4 and v6. The kernel reads Name, Namelen,
// Iov and Iovlen from each entry and writes Namelen, Flags and Datalen back, so a field at the wrong offset or a
// wrong stride between entries shows up as a wrong length, sender, or payload.
// TestListenOutSingleFallback pins the path ListenOut takes when the kernel refuses recvmsg_x.
func TestListenOutSingleFallback(t *testing.T) { 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")}) c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0")})
require.NoError(t, err) require.NoError(t, err)
la, err := c.LocalAddr() la, err := c.LocalAddr()
@@ -106,7 +107,7 @@ func TestListenOutSingleFallback(t *testing.T) {
flushes := 0 flushes := 0
done := make(chan struct{}) done := make(chan struct{})
go func() { go func() {
_ = c.ListenOut(func(addr netip.AddrPort, payload []byte) { _ = c.(*StdConn).listenOutSingle(func(addr netip.AddrPort, payload []byte) {
assert.Equal(t, txAddr, addr) assert.Equal(t, txAddr, addr)
mu.Lock() mu.Lock()
got = append(got, string(payload)) got = append(got, string(payload))
@@ -133,45 +134,35 @@ func TestListenOutSingleFallback(t *testing.T) {
assert.Equal(t, total, flushes) assert.Equal(t, total, flushes)
} }
func TestRxBatchParse(t *testing.T) { func TestCheckMsghdrX(t *testing.T) {
valid := func() *rxBatch { valid := func() ([]msgx.Hdr, []unix.RawSockaddrInet6) {
b := (&StdConn{}).getBatch() hdrs := make([]msgx.Hdr, 2)
b.hdrs[0].Namelen, b.hdrs[0].Datalen = unix.SizeofSockaddrInet4, 1 names := make([]unix.RawSockaddrInet6, 2)
b.names[0].Family = unix.AF_INET hdrs[0].Namelen, hdrs[0].Datalen = unix.SizeofSockaddrInet4, 1
sa4 := (*unix.RawSockaddrInet4)(unsafe.Pointer(&b.names[0])) names[0].Family = unix.AF_INET
sa4.Addr = [4]byte{10, 0, 0, 1} hdrs[1].Namelen, hdrs[1].Datalen = unix.SizeofSockaddrInet6, MTU
sa4.Port = 0x0110 // 4097 in network order names[1].Family = unix.AF_INET6
b.hdrs[1].Namelen, b.hdrs[1].Datalen = unix.SizeofSockaddrInet6, MTU return hdrs, names
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() hdrs, names := valid()
require.NoError(t, b.parse(2)) require.NoError(t, checkMsghdrX(hdrs, names, 2))
assert.Equal(t, 2, b.n) require.NoError(t, checkMsghdrX(hdrs, names, 0))
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 { for _, tc := range []struct {
name string name string
n int n int
mutate func(*rxBatch) mutate func([]msgx.Hdr, []unix.RawSockaddrInet6)
}{ }{
{"count past headers", msgx.Batch + 1, func(*rxBatch) {}}, {"count past headers", 3, func([]msgx.Hdr, []unix.RawSockaddrInet6) {}},
{"datalen past buffer", 2, func(b *rxBatch) { b.hdrs[1].Datalen = MTU + 1 }}, {"datalen past buffer", 2, func(h []msgx.Hdr, _ []unix.RawSockaddrInet6) { h[1].Datalen = MTU + 1 }},
{"unknown family", 2, func(b *rxBatch) { b.names[0].Family = unix.AF_UNIX }}, {"unknown family", 2, func(_ []msgx.Hdr, a []unix.RawSockaddrInet6) { a[0].Family = unix.AF_UNIX }},
{"family and length disagree", 2, func(b *rxBatch) { b.hdrs[0].Namelen = unix.SizeofSockaddrInet6 }}, {"family and length disagree", 2, func(h []msgx.Hdr, _ []unix.RawSockaddrInet6) { h[0].Namelen = unix.SizeofSockaddrInet6 }},
} { } {
t.Run(tc.name, func(t *testing.T) { t.Run(tc.name, func(t *testing.T) {
b := valid() hdrs, names := valid()
tc.mutate(b) tc.mutate(hdrs, names)
assert.Error(t, b.parse(tc.n)) assert.Error(t, checkMsghdrX(hdrs, names, tc.n))
}) })
} }
} }
@@ -193,18 +184,18 @@ func FuzzMsghdrXKernelRoundTrip(f *testing.F) {
f.Add(false, uint8(3), []byte{0, 1, 1, 44, 5, 120}) 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(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(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.Add(true, uint8(recvBatch-1), bytes.Repeat([]byte{0x05, 0xdc}, recvBatch))
f.Fuzz(func(t *testing.T, v6 bool, spare uint8, sizes []byte) { f.Fuzz(func(t *testing.T, v6 bool, spare uint8, sizes []byte) {
// Two bytes per datagram, big-endian, folded into [0, maxdgram]. // Two bytes per datagram, big-endian, folded into [0, maxdgram].
var lens []int var lens []int
for i := 0; i+1 < len(sizes) && len(lens) < msgx.Batch; i += 2 { for i := 0; i+1 < len(sizes) && len(lens) < recvBatch; i += 2 {
lens = append(lens, (int(sizes[i])<<8|int(sizes[i+1]))%(maxDgram+1)) lens = append(lens, (int(sizes[i])<<8|int(sizes[i+1]))%(maxDgram+1))
} }
if len(lens) == 0 { if len(lens) == 0 {
return return
} }
recvmsgXRoundTrip(t, v6, lens, 1+int(spare)%msgx.Batch, time.Millisecond) recvmsgXRoundTrip(t, v6, lens, 1+int(spare)%recvBatch, time.Millisecond)
}) })
} }
@@ -275,17 +266,14 @@ func recvmsgXRoundTrip(t *testing.T, v6 bool, lens []int, nh int, settle time.Du
var n int var n int
var errno syscall.Errno var errno syscall.Errno
require.NoError(t, rc.Read(func(fd uintptr) bool { require.NoError(t, rc.Read(func(fd uintptr) bool {
n, errno = msgx.Recv(fd, hdrs) n, errno = msgx.Recv(fd, hdrs[:nh], 0)
return errno != unix.EAGAIN return errno != unix.EAGAIN
}), "received %d of %d datagrams", next, len(lens)) }), "received %d of %d datagrams", next, len(lens))
require.Zero(t, errno) require.Zero(t, errno)
require.Positive(t, n) require.Positive(t, n)
require.LessOrEqual(t, n, min(nh, len(lens)-next)) require.LessOrEqual(t, n, min(nh, len(lens)-next))
largest = max(largest, n) largest = max(largest, n)
b := &rxBatch{buf: make([]byte, n*MTU)} require.NoError(t, checkMsghdrX(hdrs[:nh], names[:nh], n), "ListenOut would fall back on this batch")
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 { for i := range n {
d := next + i d := next + i
@@ -293,7 +281,9 @@ func recvmsgXRoundTrip(t *testing.T, v6 bool, lens []int, nh int, settle time.Du
want := min(lens[d], MTU) want := min(lens[d], MTU)
require.EqualValues(t, want, h.Datalen, "datagram %d Datalen", d) require.EqualValues(t, want, h.Datalen, "datagram %d Datalen", d)
require.Equal(t, wantNamelen, h.Namelen, "datagram %d Namelen", d) require.Equal(t, wantNamelen, h.Namelen, "datagram %d Namelen", d)
require.Equal(t, senders[d], b.addrs[i], "datagram %d sender", d) from, ok := sockaddrToAddrPort(&names[i])
require.True(t, ok, "datagram %d family %d", d, names[i].Family)
require.Equal(t, senders[d], from, "datagram %d sender", d)
// Flags goes in as -1 and must come back 0. xnu's list receive (soreceive_m_list) never sets // 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. // 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.Zero(t, h.Flags, "datagram %d Flags", d)
@@ -310,35 +300,3 @@ func recvmsgXRoundTrip(t *testing.T, v6 bool, lens []int, nh int, settle time.Du
} }
return largest 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)
})
}
}
+150
View File
@@ -0,0 +1,150 @@
//go:build !e2e_testing
package udp
import (
"fmt"
"log/slog"
"net"
"net/netip"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// recvAll reads n datagrams from pc, or fails the test after a second without one.
func recvAll(t *testing.T, pc net.PacketConn, n int) []string {
t.Helper()
var got []string
buf := make([]byte, 64)
for len(got) < n {
require.NoError(t, pc.SetReadDeadline(time.Now().Add(time.Second)))
l, _, err := pc.ReadFrom(buf)
require.NoError(t, err, "after %d of %d datagrams", len(got), n)
got = append(got, string(buf[:l]))
}
return got
}
// A batch longer than sendBatch reaches each peer whole and in order through sendmsg_x, without falling
// back to sendto: a run to one peer that spans two calls, then datagrams alternating between peers.
func TestWriteBatchSendsEachToItsPeer(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)
defer c.Close()
var peers [2]net.PacketConn
var dsts [2]netip.AddrPort
for i := range peers {
peers[i], err = net.ListenPacket("udp", net.JoinHostPort(tc.listen, "0"))
require.NoError(t, err)
defer peers[i].Close()
dsts[i] = netip.MustParseAddrPort(peers[i].LocalAddr().String())
}
const total = sendBatch*2 + 5
bufs := make([][]byte, total)
addrs := make([]netip.AddrPort, total)
var want [2][]string
for i := range bufs {
bufs[i] = fmt.Appendf(nil, "pkt-%03d", i)
p := i % 2
if i < sendBatch+6 {
p = 0
}
addrs[i] = dsts[p]
want[p] = append(want[p], string(bufs[i]))
}
n, err := c.WriteBatch(bufs, addrs)
require.NoError(t, err)
assert.Equal(t, total, n)
assert.False(t, c.(*StdConn).noSendmsgX.Load(), "fell back to sendto")
for i := range peers {
assert.Equal(t, want[i], recvAll(t, peers[i], len(want[i])))
}
})
}
}
// Destinations that can't be sent to cost only their own packets: an IPv6 peer on an IPv4 socket is
// skipped before the call, and a broadcast address without SO_BROADCAST is refused by the kernel
// mid-batch. Neither stops the packets around it, delivers any twice, or turns sendmsg_x off.
func TestWriteBatchSkipsUnsendableDestinations(t *testing.T) {
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0")})
require.NoError(t, err)
defer c.Close()
peer, err := net.ListenPacket("udp", "127.0.0.1:0")
require.NoError(t, err)
defer peer.Close()
good := netip.MustParseAddrPort(peer.LocalAddr().String())
bcast := netip.AddrPortFrom(netip.MustParseAddr("255.255.255.255"), good.Port())
v6 := netip.MustParseAddrPort("[::1]:4242")
addrs := []netip.AddrPort{good, bcast, bcast, good, v6, good, bcast}
bufs := make([][]byte, len(addrs))
for i := range bufs {
bufs[i] = fmt.Appendf(nil, "pkt-%d", i)
}
n, err := c.WriteBatch(bufs, addrs)
require.NoError(t, err)
assert.Equal(t, 3, n)
assert.False(t, c.(*StdConn).noSendmsgX.Load(), "fell back to sendto")
assert.Equal(t, []string{"pkt-0", "pkt-3", "pkt-5"}, recvAll(t, peer, 3))
require.NoError(t, peer.SetReadDeadline(time.Now().Add(100*time.Millisecond)))
_, _, err = peer.ReadFrom(make([]byte, 64))
assert.Error(t, err, "a datagram arrived twice")
}
// A datagram the kernel refuses as its own fault (EMSGSIZE here, as ENOBUFS would be under a full
// interface queue) costs only itself, whether it fails after others in the same call (a short count) or
// first (the errno alone): the rest of its run still arrives, in order, and sendmsg_x stays on.
func TestWriteBatchLosesOnlyTheFailedDatagram(t *testing.T) {
for _, tc := range []struct {
name string
big int
}{
{"mid-call", 2},
{"first", 0},
} {
t.Run(tc.name, func(t *testing.T) {
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0")})
require.NoError(t, err)
defer c.Close()
peer, err := net.ListenPacket("udp", "127.0.0.1:0")
require.NoError(t, err)
defer peer.Close()
dst := netip.MustParseAddrPort(peer.LocalAddr().String())
bufs := make([][]byte, 5)
addrs := make([]netip.AddrPort, len(bufs))
var want []string
for i := range bufs {
addrs[i] = dst
if i == tc.big {
// Past the 65535-byte IP datagram limit, so the kernel can only refuse it.
bufs[i] = make([]byte, 70000)
continue
}
bufs[i] = fmt.Appendf(nil, "pkt-%d", i)
want = append(want, string(bufs[i]))
}
n, err := c.WriteBatch(bufs, addrs)
require.NoError(t, err)
assert.Equal(t, len(want), n)
assert.False(t, c.(*StdConn).noSendmsgX.Load(), "fell back to sendto")
assert.Equal(t, want, recvAll(t, peer, len(want)))
})
}
}