Compare commits

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

No files matched your search

-12
View File
@@ -7,18 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased] ## [Unreleased]
### Fixed
- `create-tunnel -address <ip:port>` panicked on a nil RemoteList and, over the ssh debug server, took nebula
down with it. A hostinfo returned by StartHandshake had no RemoteList until the handshake loop's first
pass attached one, and `create-tunnel -address` set the remote before that. The list is now attached when
the handshake starts, so a pending hostinfo never exists without one.
- A firewall rule with `group: []`, `groups:` with no value, or a `groups` entry that isn't a string, such as
`groups: [1, 2]`, no longer crashes Nebula on startup or reload. A null `group` or `groups` means none was
provided. An unquoted int or bool group, such as `group: 7`, is still read as a string but logs a warning to
quote it, since YAML has already turned a value like `007` into `7`. A float, a date, an empty array, a null
entry, a nested array, or a map is rejected with an error.
## [1.11.1] - 2026-08-21 ## [1.11.1] - 2026-08-21
See the [v1.11.1](https://github.com/slackhq/nebula/milestone/30?closed=1) milestone for a complete list of changes. See the [v1.11.1](https://github.com/slackhq/nebula/milestone/30?closed=1) milestone for a complete list of changes.
+4 -2
View File
@@ -174,8 +174,10 @@ func (cm *connectionManager) doTrafficCheck(localIndex uint32, p, nb, out []byte
switch decision { switch decision {
case deleteTunnel: case deleteTunnel:
// Local delete only, clearing the lighthouse cache if this was the last hostinfo for the vpn addr if cm.hostMap.DeleteHostInfo(hostinfo) {
cm.intf.closeTunnel(hostinfo) // Only clearing the lighthouse cache if this is the last hostinfo for this vpn ip in the hostmap
cm.intf.lightHouse.DeleteVpnAddrs(hostinfo.vpnAddrs)
}
case closeTunnel: case closeTunnel:
cm.intf.sendCloseTunnel(hostinfo) cm.intf.sendCloseTunnel(hostinfo)
-3
View File
@@ -7,7 +7,6 @@ import (
"testing" "testing"
"time" "time"
"github.com/rcrowley/go-metrics"
"github.com/slackhq/nebula/cert" "github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/overlay/overlaytest" "github.com/slackhq/nebula/overlay/overlaytest"
@@ -22,8 +21,6 @@ func newTestLighthouse() *LightHouse {
l: test.NewLogger(), l: test.NewLogger(),
addrMap: map[netip.Addr]*RemoteList{}, addrMap: map[netip.Addr]*RemoteList{},
queryChan: make(chan netip.Addr, 10), queryChan: make(chan netip.Addr, 10),
// Nothing drains queryChan here, so an 11th query is dropped.
queryDropped: metrics.NilCounter{},
} }
lighthouses := []netip.Addr{} lighthouses := []netip.Addr{}
staticList := map[netip.Addr]struct{}{} staticList := map[netip.Addr]struct{}{}
+2 -1
View File
@@ -203,7 +203,8 @@ 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. // unlikely to help. Say so instead of silently carrying on as if we rebound. Only the first writer is 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
@@ -0,0 +1,90 @@
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
@@ -0,0 +1,173 @@
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())
}
+2 -2
View File
@@ -410,8 +410,8 @@ logging:
#try_interval: 100ms #try_interval: 100ms
#retries: 20 #retries: 20
# query_buffer is the size of the buffer channel for querying lighthouses, drops are recorded in the lighthouse.query.dropped metric. # query_buffer is the size of the buffer channel for querying lighthouses
#query_buffer: 1024 #query_buffer: 64
# trigger_buffer is the size of the buffer channel for quickly sending handshakes # trigger_buffer is the size of the buffer channel for quickly sending handshakes
# after receiving the response for lighthouse queries # after receiving the response for lighthouse queries
+17 -65
View File
@@ -967,54 +967,33 @@ func convertRule(l *slog.Logger, p any, table string, i int) (rule, error) {
r.CAName = toString("ca_name", m) r.CAName = toString("ca_name", m)
r.CASha = toString("ca_sha", m) r.CASha = toString("ca_sha", m)
// A null value, `group:` with nothing after it, is the same as no group // Make sure group isn't an array
var singleGroup string if v, ok := m["group"].([]any); ok {
if g, ok := m["group"]; ok && g != nil { if len(v) > 1 {
// Make sure group isn't an array return r, errors.New("group should contain a single value, an array with more than one entry was provided")
v, isArray := g.([]any)
if isArray {
if len(v) > 1 {
return r, errors.New("group should contain a single value, an array with more than one entry was provided")
}
if len(v) == 0 {
return r, errors.New("group should contain a single value, an empty array was provided")
}
g = v[0]
} }
var err error l.Warn("group was an array with a single value, converting to simple value",
singleGroup, err = groupName(l, g, table, i) "table", table,
if err != nil { "rule", i,
return r, fmt.Errorf("group should contain a single value, %w", err) )
} m["group"] = v[0]
if isArray {
l.Warn("group was an array with a single value, converting to simple value",
"table", table,
"rule", i,
)
}
} }
// A null value, `groups:` with nothing after it, is the same as no groups singleGroup := toString("group", m)
if rg, ok := m["groups"]; ok && rg != nil {
if rg, ok := m["groups"]; ok {
switch reflect.TypeOf(rg).Kind() { switch reflect.TypeOf(rg).Kind() {
case reflect.Slice: case reflect.Slice:
v := reflect.ValueOf(rg) v := reflect.ValueOf(rg)
r.Groups = make([]string, v.Len()) r.Groups = make([]string, v.Len())
for gi := 0; gi < v.Len(); gi++ { for i := 0; i < v.Len(); i++ {
name, err := groupName(l, v.Index(gi).Interface(), table, i) r.Groups[i] = v.Index(i).Interface().(string)
if err != nil {
return r, fmt.Errorf("groups entry #%d should contain a single value, %w", gi, err)
}
r.Groups[gi] = name
} }
case reflect.String:
r.Groups = []string{rg.(string)}
default: default:
name, err := groupName(l, rg, table, i) r.Groups = []string{fmt.Sprintf("%v", rg)}
if err != nil {
return r, fmt.Errorf("groups should contain an array or a single value, %w", err)
}
r.Groups = []string{name}
} }
} }
@@ -1030,33 +1009,6 @@ func convertRule(l *slog.Logger, p any, table string, i int) (rule, error) {
return r, nil return r, nil
} }
// groupName reads a group name from config. YAML has already parsed an unquoted value by the time we see it, so `007`
// arrives as 7, `1.10` as 1.1, and a date as a time.Time, and the text that was written is gone. Strings are used as
// is. Ints and bools are converted so `group: 7` keeps working, with a warning to quote them. Anything else would
// become a name that may not match what was written, or matches nothing like "<nil>" or "map[a:b]", so it is rejected.
func groupName(l *slog.Logger, v any, table string, i int) (string, error) {
if v == nil {
return "", errors.New("a null was provided")
}
switch reflect.TypeOf(v).Kind() {
case reflect.String:
return reflect.ValueOf(v).String(), nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Bool:
l.Warn("group was not a string and should be quoted to match as written",
"table", table,
"rule", i,
"group", v,
)
return fmt.Sprintf("%v", v), nil
case reflect.Slice, reflect.Array:
return "", errors.New("an array was provided")
case reflect.Map:
return "", errors.New("a map was provided")
}
return "", fmt.Errorf("%v was read as a %T, quote it to use it as a group name", v, v)
}
// sanity returns an error if the rule would be evaluated in a way that would short-circuit a configured check on a wildcard value // sanity returns an error if the rule would be evaluated in a way that would short-circuit a configured check on a wildcard value
// rules are evaluated as "port AND proto AND (ca_sha OR ca_name) AND (host OR group OR groups OR cidr) AND local_cidr" // rules are evaluated as "port AND proto AND (ca_sha OR ca_name) AND (host OR group OR groups OR cidr) AND local_cidr"
func (r *rule) sanity() error { func (r *rule) sanity() error {
-50
View File
@@ -1439,56 +1439,6 @@ func TestAddFirewallRulesFromConfig(t *testing.T) {
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf)) require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
assert.Equal(t, addRuleCall{incoming: true, proto: firewall.ProtoAny, startPort: 1, endPort: 1, groups: []string{"a", "b"}, ip: "", localIp: ""}, mf.lastCall) assert.Equal(t, addRuleCall{incoming: true, proto: firewall.ProtoAny, startPort: 1, endPort: 1, groups: []string{"a", "b"}, ip: "", localIp: ""}, mf.lastCall)
// Test group and groups values that used to crash or become a group that matches nothing: an empty array,
// a null, an array, or a map is rejected
badGroups := []struct {
key string
value any
err string
}{
{"group", []any{}, "group should contain a single value, an empty array was provided"},
{"group", []any{nil}, "group should contain a single value, a null was provided"},
{"group", []any{[]any{"a"}}, "group should contain a single value, an array was provided"},
{"group", map[string]any{"a": "b"}, "group should contain a single value, a map was provided"},
{"groups", []any{nil}, "groups entry #0 should contain a single value, a null was provided"},
{"groups", []any{"a", []any{"b"}}, "groups entry #1 should contain a single value, an array was provided"},
{"groups", []any{map[string]any{"a": "b"}}, "groups entry #0 should contain a single value, a map was provided"},
{"groups", map[string]any{"a": "b"}, "groups should contain an array or a single value, a map was provided"},
{"group", 1.1, "group should contain a single value, 1.1 was read as a float64, quote it to use it as a group name"},
{"group", []any{1.1}, "group should contain a single value, 1.1 was read as a float64, quote it to use it as a group name"},
{"groups", []any{"a", 1.1}, "groups entry #1 should contain a single value, 1.1 was read as a float64, quote it to use it as a group name"},
{"groups", time.Date(2001, 12, 14, 0, 0, 0, 0, time.UTC), "groups should contain an array or a single value, 2001-12-14 00:00:00 +0000 UTC was read as a time.Time, quote it to use it as a group name"},
}
for _, tc := range badGroups {
conf = config.NewC(test.NewLogger())
mf = &mockFirewall{}
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", tc.key: tc.value}}}
require.EqualError(t, AddFirewallRulesFromConfig(l, true, conf, mf), "firewall.inbound rule #0; "+tc.err, "%s: %v", tc.key, tc.value)
}
// Test int and bool groups entries are read as strings
conf = config.NewC(test.NewLogger())
mf = &mockFirewall{}
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", "groups": []any{1, true}}}}
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
assert.Equal(t, []string{"1", "true"}, mf.lastCall.groups)
conf = config.NewC(test.NewLogger())
mf = &mockFirewall{}
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", "group": 1}}}
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
assert.Equal(t, []string{"1"}, mf.lastCall.groups)
// Test a null group or groups is the same as not providing it
for _, key := range []string{"group", "groups"} {
conf = config.NewC(test.NewLogger())
mf = &mockFirewall{}
conf.Settings["firewall"] = map[string]any{"inbound": []any{map[string]any{"port": "1", "proto": "any", key: nil, "host": "a"}}}
require.NoError(t, AddFirewallRulesFromConfig(l, true, conf, mf))
assert.Empty(t, mf.lastCall.groups)
assert.Equal(t, "a", mf.lastCall.host)
}
// Test Add error // Test Add error
conf = config.NewC(test.NewLogger()) conf = config.NewC(test.NewLogger())
mf = &mockFirewall{} mf = &mockFirewall{}
+5 -18
View File
@@ -31,7 +31,6 @@ package nebula
import ( import (
"bufio" "bufio"
"context"
"fmt" "fmt"
"net" "net"
"strconv" "strconv"
@@ -52,29 +51,17 @@ type graphiteConfigExport struct {
Percentiles []float64 // Percentiles to export from timers and histograms Percentiles []float64 // Percentiles to export from timers and histograms
} }
// graphiteTimeout bounds one submission, the connect and the write together. An export is a few KB, a host that can't
// take that in this long isn't going to.
const graphiteTimeout = 30 * time.Second
// graphiteOnce performs a single submission to Graphite, returning a non-nil // graphiteOnce performs a single submission to Graphite, returning a non-nil
// error if it could not connect or write all of it within timeout. It gives up // error on failed connections.
// as soon as ctx is done. func graphiteOnce(c graphiteConfigExport) error {
func graphiteOnce(ctx context.Context, c graphiteConfigExport, timeout time.Duration) error {
now := time.Now().Unix() now := time.Now().Unix()
du := float64(c.DurationUnit) du := float64(c.DurationUnit)
flushSeconds := float64(c.FlushInterval) / float64(time.Second) flushSeconds := float64(c.FlushInterval) / float64(time.Second)
deadline := time.Now().Add(timeout) conn, err := net.DialTCP("tcp", nil, c.Addr)
d := net.Dialer{Deadline: deadline}
conn, err := d.DialContext(ctx, "tcp", c.Addr.String())
if err != nil { if err != nil {
return err return err
} }
defer conn.Close() defer conn.Close()
if err := conn.SetDeadline(deadline); err != nil {
return err
}
stop := context.AfterFunc(ctx, func() { _ = conn.Close() })
defer stop()
w := bufio.NewWriter(conn) w := bufio.NewWriter(conn)
c.Registry.Each(func(name string, i any) { c.Registry.Each(func(name string, i any) {
switch metric := i.(type) { switch metric := i.(type) {
@@ -124,7 +111,7 @@ func graphiteOnce(ctx context.Context, c graphiteConfigExport, timeout time.Dura
fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", c.Prefix, name, t.Rate15(), now) fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", c.Prefix, name, t.Rate15(), now)
fmt.Fprintf(w, "%s.%s.mean-rate %.2f %d\n", c.Prefix, name, t.RateMean(), now) fmt.Fprintf(w, "%s.%s.mean-rate %.2f %d\n", c.Prefix, name, t.RateMean(), now)
} }
w.Flush()
}) })
// A failed write sticks, so this reports the first one return nil
return w.Flush()
} }
-315
View File
@@ -1,315 +0,0 @@
package nebula
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"net"
"strings"
"sync"
"testing"
"time"
"github.com/rcrowley/go-metrics"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// graphiteHost accepts connections and hands each one to the test
type graphiteHost struct {
ln net.Listener
conns chan net.Conn
mu sync.Mutex
closed bool
open []net.Conn
}
// newGraphiteHost accepts connections for the test. A non-zero window shrinks each connection's receive buffer, so a
// sender that is not read from blocks after a little whatever the host's TCP tuning. Only for tests that need a stall,
// a small window makes reading very slow on Linux.
func newGraphiteHost(t *testing.T, window int) *graphiteHost {
t.Helper()
ln, err := net.Listen("tcp", "127.0.0.1:0")
require.NoError(t, err)
h := &graphiteHost{ln: ln, conns: make(chan net.Conn, 8)}
done := make(chan struct{})
t.Cleanup(func() {
_ = ln.Close()
h.mu.Lock()
h.closed = true
for _, c := range h.open {
_ = c.Close()
}
h.mu.Unlock()
close(done)
})
go func() {
for {
c, err := ln.Accept()
if err != nil {
return
}
h.mu.Lock()
if h.closed {
h.mu.Unlock()
_ = c.Close()
return
}
h.open = append(h.open, c)
h.mu.Unlock()
if tc, ok := c.(*net.TCPConn); ok && window > 0 {
_ = tc.SetReadBuffer(window)
}
select {
case h.conns <- c:
case <-done:
return
}
}
}()
return h
}
func (h *graphiteHost) addr(t *testing.T) *net.TCPAddr {
a, err := net.ResolveTCPAddr("tcp", h.ln.Addr().String())
require.NoError(t, err)
return a
}
// readExport reads what one send wrote, bounded so a send that never finishes fails the test rather than hanging it
func readExport(t *testing.T, c net.Conn) []byte {
t.Helper()
require.NoError(t, c.SetReadDeadline(time.Now().Add(10*time.Second)))
b, err := io.ReadAll(c)
require.NoError(t, err)
return b
}
func (h *graphiteHost) next(t *testing.T, wait time.Duration) net.Conn {
t.Helper()
select {
case c := <-h.conns:
return c
case <-time.After(wait):
t.Fatal("no connection")
return nil
}
}
// lockedBuffer is a log destination a test can read while the code under test writes to it from another goroutine
type lockedBuffer struct {
mu sync.Mutex
buf bytes.Buffer
}
func (b *lockedBuffer) Write(p []byte) (int, error) {
b.mu.Lock()
defer b.mu.Unlock()
return b.buf.Write(p)
}
func (b *lockedBuffer) String() string {
b.mu.Lock()
defer b.mu.Unlock()
return b.buf.String()
}
func testGraphiteConfig(addr *net.TCPAddr, r metrics.Registry) graphiteConfigExport {
return graphiteConfigExport{Addr: addr, Registry: r, FlushInterval: time.Second, DurationUnit: time.Nanosecond, Prefix: "nebula"}
}
// Enough metrics that one export overflows the socket buffers on any platform, so a send to a host that stops
// reading blocks
func bigGraphiteRegistry(r metrics.Registry, t *testing.T) {
for i := range 200000 {
name := fmt.Sprintf("big.gauge.%d", i)
metrics.GetOrRegisterGauge(name, r).Update(int64(i))
t.Cleanup(func() { r.Unregister(name) })
}
}
func TestGraphiteOnce_sends(t *testing.T) {
r := metrics.NewRegistry()
metrics.GetOrRegisterGauge("g", r).Update(7)
metrics.GetOrRegisterCounter("c", r).Inc(3)
h := newGraphiteHost(t, 0)
require.NoError(t, graphiteOnce(t.Context(), testGraphiteConfig(h.addr(t), r), time.Minute))
b := readExport(t, h.next(t, 5*time.Second))
assert.Contains(t, string(b), "nebula.g.value 7 ")
assert.Contains(t, string(b), "nebula.c.count 3 ")
assert.Contains(t, string(b), "nebula.c.count_ps 3.00 ")
}
// A host that accepts and never reads is given up on, and the failed write is reported
func TestGraphiteOnce_stalledHostTimesOut(t *testing.T) {
r := metrics.NewRegistry()
bigGraphiteRegistry(r, t)
h := newGraphiteHost(t, 4096)
done := make(chan error, 1)
cfg := testGraphiteConfig(h.addr(t), r)
go func() { done <- graphiteOnce(t.Context(), cfg, 300*time.Millisecond) }()
h.next(t, 5*time.Second) // accepted, never read
select {
case err := <-done:
require.Error(t, err)
case <-time.After(10 * time.Second):
t.Fatal("the send did not give up on a host that stopped reading")
}
}
// The timeout covers the whole send, a host that keeps reading but too slowly is still given up on
func TestGraphiteOnce_timeoutCoversTheWholeSend(t *testing.T) {
r := metrics.NewRegistry()
bigGraphiteRegistry(r, t)
h := newGraphiteHost(t, 0)
done := make(chan error, 1)
start := time.Now()
cfg := testGraphiteConfig(h.addr(t), r)
go func() { done <- graphiteOnce(t.Context(), cfg, 500*time.Millisecond) }()
c := h.next(t, 5*time.Second)
stopReading := make(chan struct{})
defer close(stopReading)
// 32KB every 10ms keeps every write well inside the timeout, the whole export takes seconds
go func() {
buf := make([]byte, 32<<10)
for {
select {
case <-stopReading:
return
case <-time.After(10 * time.Millisecond):
}
if _, err := c.Read(buf); err != nil {
return
}
}
}()
select {
case err := <-done:
require.Error(t, err)
assert.Less(t, time.Since(start), 5*time.Second)
case <-time.After(10 * time.Second):
t.Fatal("a host that kept reading slowly held the send past its timeout")
}
}
func TestGraphiteOnce_cancelledCtxDoesNotConnect(t *testing.T) {
h := newGraphiteHost(t, 0)
ctx, cancel := context.WithCancel(t.Context())
cancel()
require.Error(t, graphiteOnce(ctx, testGraphiteConfig(h.addr(t), metrics.NewRegistry()), time.Minute))
select {
case <-h.conns:
t.Fatal("connected on a cancelled ctx")
case <-time.After(200 * time.Millisecond):
}
}
// A stop or reload abandons a stuck send rather than waiting out its timeout
func TestGraphiteOnce_cancelAbandonsSend(t *testing.T) {
r := metrics.NewRegistry()
bigGraphiteRegistry(r, t)
h := newGraphiteHost(t, 4096)
ctx, cancel := context.WithCancel(t.Context())
done := make(chan error, 1)
cfg := testGraphiteConfig(h.addr(t), r)
go func() { done <- graphiteOnce(ctx, cfg, time.Minute) }()
h.next(t, 5*time.Second)
select {
case err := <-done:
t.Fatalf("the send should be stuck on a host that is not reading, it ended with %v", err)
case <-time.After(200 * time.Millisecond):
}
cancel()
select {
case err := <-done:
require.Error(t, err)
case <-time.After(5 * time.Second):
t.Fatal("the send is still stuck after its ctx was cancelled")
}
}
// buildRuntime hands graphite the configured prefix and interval
func TestStatsServer_graphiteExportUsesConfig(t *testing.T) {
const name = "graphite.wiring.test"
metrics.GetOrRegisterCounter(name, nil).Inc(8)
t.Cleanup(func() { metrics.DefaultRegistry.Unregister(name) })
h := newGraphiteHost(t, 0)
s, c := newTestStatsServer(t)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "4s", "prefix": "pfx", "host": h.ln.Addr().String()})
cfg, err := loadStatsConfig(c)
require.NoError(t, err)
s.runMu.Lock()
fns, _ := s.buildRuntime(t.Context(), cfg)
s.runMu.Unlock()
for _, fn := range fns {
fn()
}
b := readExport(t, h.next(t, 5*time.Second))
assert.Contains(t, string(b), "pfx."+name+".count 8 ")
assert.Contains(t, string(b), "pfx."+name+".count_ps 2.00 ")
}
func TestStatsServer_graphiteFailureIsLogged(t *testing.T) {
logs := &lockedBuffer{}
s, c := newTestStatsServer(t)
s.l = test.NewLoggerWithOutput(logs)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": "127.0.0.1:" + freeTCPPort(t)})
cfg, err := loadStatsConfig(c)
require.NoError(t, err)
s.runMu.Lock()
fns, _ := s.buildRuntime(t.Context(), cfg)
s.runMu.Unlock()
for _, fn := range fns {
fn()
}
assert.Contains(t, logs.String(), "Graphite export failed")
}
// Stop abandons the running export, so it goes through Start rather than handing buildRuntime a ctx, and a stop is
// not logged as a failure
func TestStatsServer_stopAbandonsGraphiteSend(t *testing.T) {
bigGraphiteRegistry(metrics.DefaultRegistry, t)
h := newGraphiteHost(t, 4096)
logs := &lockedBuffer{}
s, c := newTestStatsServer(t)
s.l = test.NewLoggerWithOutput(logs)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "50ms", "host": h.ln.Addr().String()})
require.NoError(t, s.reload(c, true))
started := make(chan struct{})
go func() {
s.Start()
close(started)
}()
stuck := h.next(t, 30*time.Second)
s.Stop()
select {
case <-started:
case <-time.After(5 * time.Second):
t.Fatal("Start did not return after Stop")
}
// A closed sender resets the connection once it sees this, one still sending just buffers it. Either way the
// read below doesn't have to drain the export through the small window to find out
_, err := stuck.Write([]byte("x"))
require.NoError(t, err)
require.NoError(t, stuck.SetReadDeadline(time.Now().Add(10*time.Second)))
n, err := io.Copy(io.Discard, stuck)
var ne net.Error
if errors.As(err, &ne) && ne.Timeout() {
t.Fatalf("the send kept the connection after Stop, read %d bytes", n)
}
assert.Less(t, n, int64(1<<20), "the send kept going after Stop")
// The capture loop logs on its own goroutine after Start has returned, give it the chance
assert.Never(t, func() bool { return strings.Contains(logs.String(), "Graphite export failed") }, 500*time.Millisecond, 10*time.Millisecond, "a stop is not a failure")
}
+12 -9
View File
@@ -54,8 +54,7 @@ type HandshakeConfig struct {
} }
type HandshakeManager struct { type HandshakeManager struct {
// Mutex for interacting with the vpnIps and indexes maps. // Mutex for interacting with the vpnIps and indexes maps
// Lock order is hostmap, then this lock, then the lighthouse, then a RemoteList.
sync.RWMutex sync.RWMutex
vpnIps map[netip.Addr]*HandshakeHostInfo vpnIps map[netip.Addr]*HandshakeHostInfo
@@ -260,6 +259,14 @@ func (hm *HandshakeManager) handleOutbound(vpnIp netip.Addr, lighthouseTriggered
"style": header.SubTypeName(header.Handshake, hh.machine.Subtype()), "style": header.SubTypeName(header.Handshake, hh.machine.Subtype()),
} }
// Get a remotes object if we don't already have one.
// This is mainly to protect us as this should never be the case
// NB ^ This comment doesn't jive. It's how the thing gets initialized.
// It's the common path. Should it update every time, in case a future LH query/queries give us more info?
if hostinfo.remotes == nil {
hostinfo.remotes = hm.lightHouse.QueryCache([]netip.Addr{vpnIp})
}
remotes := hostinfo.remotes.CopyAddrs(hm.mainHostMap.GetPreferredRanges()) remotes := hostinfo.remotes.CopyAddrs(hm.mainHostMap.GetPreferredRanges())
remotesHaveChanged := !slices.Equal(remotes, hh.lastRemotes) remotesHaveChanged := !slices.Equal(remotes, hh.lastRemotes)
@@ -364,9 +371,6 @@ func (hm *HandshakeManager) StartHandshake(vpnAddr netip.Addr, cacheCb func(*Han
hostinfo := &HostInfo{ hostinfo := &HostInfo{
vpnAddrs: []netip.Addr{vpnAddr}, vpnAddrs: []netip.Addr{vpnAddr},
HandshakePacket: make(map[uint8][]byte, 0), HandshakePacket: make(map[uint8][]byte, 0),
// Attached here so a pending hostinfo never exists without one: SetRemote dereferences
// it, and create-tunnel -address can reach SetRemote before the handshake loop runs.
remotes: hm.lightHouse.QueryCache([]netip.Addr{vpnAddr}),
relayState: RelayState{ relayState: RelayState{
relays: nil, relays: nil,
relayForByAddr: map[netip.Addr]*Relay{}, relayForByAddr: map[netip.Addr]*Relay{},
@@ -942,14 +946,13 @@ func (hm *HandshakeManager) continueHandshake(via ViaSender, hh *HandshakeHostIn
hm.DeleteHostInfo(hostinfo) hm.DeleteHostInfo(hostinfo)
hm.StartHandshake(hostinfo.vpnAddrs[0], func(newHH *HandshakeHostInfo) { hm.StartHandshake(hostinfo.vpnAddrs[0], func(newHH *HandshakeHostInfo) {
newHH.hostinfo.remotes = hostinfo.remotes
newHH.hostinfo.remotes.BlockRemote(via) newHH.hostinfo.remotes.BlockRemote(via)
newHH.packetStore = hh.packetStore newHH.packetStore = hh.packetStore
hh.packetStore = []*cachedPacket{} hh.packetStore = []*cachedPacket{}
hostinfo.vpnAddrs = vpnAddrs
f.sendCloseTunnel(hostinfo)
}) })
// sendCloseTunnel may take the hostmap lock, so it must not run under the handshake
// manager lock that StartHandshake holds around the callback.
hostinfo.vpnAddrs = vpnAddrs
f.sendCloseTunnel(hostinfo)
return return
} }
+2 -68
View File
@@ -11,7 +11,6 @@ import (
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
"github.com/slackhq/nebula/udp" "github.com/slackhq/nebula/udp"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
) )
func Test_NewHandshakeManagerVpnIp(t *testing.T) { func Test_NewHandshakeManagerVpnIp(t *testing.T) {
@@ -43,6 +42,8 @@ func Test_NewHandshakeManagerVpnIp(t *testing.T) {
i2 := blah.StartHandshake(ip, nil) i2 := blah.StartHandshake(ip, nil)
assert.Same(t, i, i2) assert.Same(t, i, i2)
i.remotes = NewRemoteList([]netip.Addr{}, nil)
// Adding something to pending should not affect the main hostmap // Adding something to pending should not affect the main hostmap
assert.Empty(t, mainHM.Hosts) assert.Empty(t, mainHM.Hosts)
@@ -234,70 +235,3 @@ func TestHandleIncomingDispatch(t *testing.T) {
assert.Empty(t, hm.indexes, "orphan stage-2 must not create state") assert.Empty(t, hm.indexes, "orphan stage-2 must not create state")
}) })
} }
// Test_PendingHandshakeHasRemotes covers create-tunnel -address: a pending hostinfo must already
// carry its RemoteList when StartHandshake runs its callback, so SetRemote there, before the
// handshake loop has run, is safe and the address becomes one the handshake is sent to.
func Test_PendingHandshakeHasRemotes(t *testing.T) {
l := test.NewLogger()
mainHM := newHostMap(l)
preferredRanges := []netip.Prefix{}
mainHM.preferredRanges.Store(&preferredRanges)
hm := NewHandshakeManager(l, mainHM, newTestLighthouse(), &udp.NoopConn{}, defaultHandshakeConfig)
vpnIp := netip.MustParseAddr("172.1.1.2")
remote := netip.MustParseAddrPort("192.168.1.9:4242")
hi := hm.StartHandshake(vpnIp, func(hh *HandshakeHostInfo) {
require.NotNil(t, hh.hostinfo.remotes, "a pending handshake must never be without its RemoteList")
hh.hostinfo.SetRemote(remote)
})
assert.Contains(t, hi.remotes.CopyAddrs(preferredRanges), remote, "the handshake must be sent to the supplied remote")
assert.Equal(t, remote, hi.GetRemote())
// A RemoteList keeps one learned address per host, so a second remote replaces the
// first — the same behaviour change-remote has on an established tunnel.
other := netip.MustParseAddrPort("192.168.1.10:4242")
hi.SetRemote(other)
assert.Equal(t, []netip.AddrPort{other}, hi.remotes.CopyAddrs(preferredRanges))
assert.Equal(t, other, hi.GetRemote())
}
// newRemotesRaceFixture builds a handshake manager with an established tunnel to vpnAddr whose
// RemoteList is the lighthouse's cached list, the state every teardown-during-handshake race starts from.
func newRemotesRaceFixture(t *testing.T, vpnAddr netip.Addr) (*HandshakeManager, *Interface, *HostInfo) {
t.Helper()
l := test.NewLogger()
mainHM := newHostMap(l)
preferredRanges := []netip.Prefix{}
mainHM.preferredRanges.Store(&preferredRanges)
lh := newTestLighthouse()
hm := NewHandshakeManager(l, mainHM, lh, &udp.NoopConn{}, defaultHandshakeConfig)
f := &Interface{hostMap: mainHM, lightHouse: lh, handshakeManager: hm, l: l}
hm.f = f
established := &HostInfo{
vpnAddrs: []netip.Addr{vpnAddr},
localIndexId: 1,
remoteIndexId: 101,
remotes: lh.QueryCache([]netip.Addr{vpnAddr}),
HandshakePacket: map[uint8][]byte{},
}
mainHM.Lock()
mainHM.unlockedAddHostInfo(established, f)
mainHM.Unlock()
return hm, f, established
}
// With no handshake pending, tearing down the last tunnel still evicts the list.
func Test_CloseTunnelEvictsWithoutPendingHandshake(t *testing.T) {
vpnAddr := netip.MustParseAddr("172.1.1.2")
_, f, established := newRemotesRaceFixture(t, vpnAddr)
f.closeTunnel(established)
assert.NotContains(t, f.hostMap.Hosts, vpnAddr)
assert.NotContains(t, f.lightHouse.addrMap, vpnAddr)
}
+17 -1
View File
@@ -69,7 +69,9 @@ 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]
l *slog.Logger // established hears about each hostinfo that joins or leaves the hostmap; nil when no conn wants to know.
established *establishedRemotes
l *slog.Logger
} }
// For synchronization, treat the pointed-to Relay struct as immutable. To edit the Relay // For synchronization, treat the pointed-to Relay struct as immutable. To edit the Relay
@@ -276,6 +278,11 @@ 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 {
@@ -516,6 +523,7 @@ 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",
@@ -662,6 +670,7 @@ 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
@@ -842,6 +851,13 @@ 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()
}
} }
} }
+9 -16
View File
@@ -10,7 +10,6 @@ import (
"github.com/slackhq/nebula/firewall" "github.com/slackhq/nebula/firewall"
"github.com/slackhq/nebula/header" "github.com/slackhq/nebula/header"
"github.com/slackhq/nebula/iputil" "github.com/slackhq/nebula/iputil"
"github.com/slackhq/nebula/logging"
"github.com/slackhq/nebula/noiseutil" "github.com/slackhq/nebula/noiseutil"
"github.com/slackhq/nebula/overlay/batch" "github.com/slackhq/nebula/overlay/batch"
"github.com/slackhq/nebula/overlay/tio" "github.com/slackhq/nebula/overlay/tio"
@@ -518,9 +517,7 @@ func (f *Interface) SendVia(via *HostInfo, relay *Relay, ad, nb, out []byte, noc
err = f.writers[q].WriteTo(toSend, via.GetRemote()) err = f.writers[q].WriteTo(toSend, via.GetRemote())
if err != nil { if err != nil {
if l, ok := logging.RateLimited(f.l, f.udpRelayTxErrLimiter); ok { via.logger(f.l).Info("Failed to WriteTo in sendVia", "error", err)
via.logger(l).Info("Failed to WriteTo in sendVia", "error", err)
}
} }
} }
@@ -585,22 +582,18 @@ func (f *Interface) sendNoMetrics(t header.MessageType, st header.MessageSubType
if remote.IsValid() { if remote.IsValid() {
err = f.writers[q].WriteTo(out, remote) err = f.writers[q].WriteTo(out, remote)
if err != nil { if err != nil {
if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok { hostinfo.logger(f.l).Error("Failed to write outgoing packet",
hostinfo.logger(l).Error("Failed to write outgoing packet", "error", err,
"error", err, "udpAddr", remote,
"udpAddr", remote, )
)
}
} }
} else if hr := hostinfo.GetRemote(); hr.IsValid() { } else if hr := hostinfo.GetRemote(); hr.IsValid() {
err = f.writers[q].WriteTo(out, hr) err = f.writers[q].WriteTo(out, hr)
if err != nil { if err != nil {
if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok { hostinfo.logger(f.l).Error("Failed to write outgoing packet",
hostinfo.logger(l).Error("Failed to write outgoing packet", "error", err,
"error", err, "udpAddr", hr,
"udpAddr", hr, )
)
}
} }
} else { } else {
// Try to send via a relay // Try to send via a relay
+28 -18
View File
@@ -24,7 +24,6 @@ import (
"github.com/slackhq/nebula/overlay" "github.com/slackhq/nebula/overlay"
"github.com/slackhq/nebula/overlay/batch" "github.com/slackhq/nebula/overlay/batch"
"github.com/slackhq/nebula/overlay/tio" "github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/ratelimit"
"github.com/slackhq/nebula/udp" "github.com/slackhq/nebula/udp"
) )
@@ -125,9 +124,6 @@ type Interface struct {
batchers []*batch.MultiCoalescer batchers []*batch.MultiCoalescer
wg sync.WaitGroup wg sync.WaitGroup
udpTxErrLimiter *ratelimit.Limiter // udp direct transmit error log limiter
udpRelayTxErrLimiter *ratelimit.Limiter // udp relay transmit error log limiter
// fatalErr holds the first unexpected reader error that caused shutdown. // fatalErr holds the first unexpected reader error that caused shutdown.
// nil means "no fatal error" (yet) // nil means "no fatal error" (yet)
fatalErr atomic.Pointer[error] fatalErr atomic.Pointer[error]
@@ -202,15 +198,6 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
return nil, errors.New("no connection manager") return nil, errors.New("no connection manager")
} }
udpTxErrLimiter, err := ratelimit.New(1, time.Second)
if err != nil {
return nil, err
}
udpRelayTxErrLimiter, err := ratelimit.New(1, time.Second)
if err != nil {
return nil, err
}
if c.routines <= 1 { if c.routines <= 1 {
c.PinThreads = false //pinning is not useful unless there's more than one tun reader c.PinThreads = false //pinning is not useful unless there's more than one tun reader
} }
@@ -243,8 +230,6 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
conntrackCacheTimeout: c.ConntrackCacheTimeout, conntrackCacheTimeout: c.ConntrackCacheTimeout,
cpuAffinity: c.CpuAffinity, cpuAffinity: c.CpuAffinity,
pinThreads: c.PinThreads, pinThreads: c.PinThreads,
udpTxErrLimiter: udpTxErrLimiter,
udpRelayTxErrLimiter: udpRelayTxErrLimiter,
metricHandshakes: metrics.GetOrRegisterHistogram("handshakes", nil, metrics.NewExpDecaySample(1028, 0.015)), metricHandshakes: metrics.GetOrRegisterHistogram("handshakes", nil, metrics.NewExpDecaySample(1028, 0.015)),
metricTxDropped: metrics.GetOrRegisterCounter("udp.tx.dropped", nil), metricTxDropped: metrics.GetOrRegisterCounter("udp.tx.dropped", nil),
@@ -447,6 +432,11 @@ func (f *Interface) pinThisThread(i int) {
} }
func (f *Interface) listenIn(queue tio.Queue, i int) { func (f *Interface) listenIn(queue tio.Queue, i int) {
if sendPipelinePlatform {
listenInPipelined(f, queue, i)
return
}
// Pinning this thread (and goroutine) to a single CPU keeps every sendmmsg from this goroutine going through the // Pinning this thread (and goroutine) to a single CPU keeps every sendmmsg from this goroutine going through the
// same TX ring on the nic, so the wire sees per-flow order. Skip entirely when tun.pin_threads is false. // same TX ring on the nic, so the wire sees per-flow order. Skip entirely when tun.pin_threads is false.
if f.pinThreads { if f.pinThreads {
@@ -493,6 +483,11 @@ func (f *Interface) listenIn(queue tio.Queue, i int) {
func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) { func (f *Interface) flushSendBatch(sb *batch.SendBatch, q int) {
queued := sb.Len() queued := sb.Len()
written, err := sb.Flush() written, err := sb.Flush()
f.accountSendBatch(queued, written, err, q)
}
// accountSendBatch is flushSendBatch's accounting, also for the writes a send pipeline makes.
func (f *Interface) accountSendBatch(queued, written int, err error, q int) {
if err != nil { if err != nil {
f.l.Error("Failed to write outgoing batch", "error", err, "writer", q) f.l.Error("Failed to write outgoing batch", "error", err, "writer", q)
} }
@@ -639,15 +634,17 @@ func (f *Interface) reloadMisc(c *config.C) {
} }
} }
// statsEmitter updates the interface's gauges, the stats server runs it on its capture loop. func (f *Interface) emitStats(ctx context.Context, i time.Duration) {
func (f *Interface) statsEmitter() func() { ticker := time.NewTicker(i)
defer ticker.Stop()
udpStats := udp.NewUDPStatsEmitter(f.writers) udpStats := udp.NewUDPStatsEmitter(f.writers)
certExpirationGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil) certExpirationGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil)
certInitiatingVersion := metrics.GetOrRegisterGauge("certificate.initiating_version", nil) certInitiatingVersion := metrics.GetOrRegisterGauge("certificate.initiating_version", nil)
certMaxVersion := metrics.GetOrRegisterGauge("certificate.max_version", nil) certMaxVersion := metrics.GetOrRegisterGauge("certificate.max_version", nil)
return func() { emit := func() {
f.firewall.EmitStats() f.firewall.EmitStats()
f.handshakeManager.EmitStats() f.handshakeManager.EmitStats()
udpStats() udpStats()
@@ -664,6 +661,19 @@ func (f *Interface) statsEmitter() func() {
certMaxVersion.Update(int64(certState.v1Cert.Version())) certMaxVersion.Update(int64(certState.v1Cert.Version()))
} }
} }
// Prime gauges so a Prometheus scrape that lands before the first tick
// sees real values instead of the zero defaults (issue #907).
emit()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
emit()
}
}
} }
func (f *Interface) GetHostInfo(vpnIp netip.Addr) *HostInfo { func (f *Interface) GetHostInfo(vpnIp netip.Addr) *HostInfo {
+14 -5
View File
@@ -3,6 +3,7 @@
package nebula package nebula
import ( import (
"context"
"net/netip" "net/netip"
"testing" "testing"
"time" "time"
@@ -17,8 +18,11 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
// Priming before the first tick (issue #907) is Start's job, see TestStatsServer_Start_primes. // Test_emitStats_primesGauges covers issue #907: a Prometheus scrape that
func Test_statsEmitter_setsGauges(t *testing.T) { // landed before the first ticker fire used to read 0 for the cert gauges.
// emitStats now primes the gauges before entering the ticker loop. We assert
// the gauge is zero before the first call and non-zero after.
func Test_emitStats_primesGauges(t *testing.T) {
defer metrics.DefaultRegistry.UnregisterAll() defer metrics.DefaultRegistry.UnregisterAll()
l := test.NewLogger() l := test.NewLogger()
@@ -52,12 +56,17 @@ func Test_statsEmitter_setsGauges(t *testing.T) {
ifce.pki.cs.Store(cs) ifce.pki.cs.Store(cs)
ttlGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil) ttlGauge := metrics.GetOrRegisterGauge("certificate.ttl_seconds", nil)
require.Zero(t, ttlGauge.Value(), "gauge should be zero before the emitter runs") require.Zero(t, ttlGauge.Value(), "gauge should be zero before emitStats runs")
ifce.statsEmitter()() // Pre-cancel the context so emitStats returns after priming the gauges
// without ever reading from ticker.C. The one hour interval is just a
// belt-and-suspenders, the test does not expect the ticker to fire.
ctx, cancel := context.WithCancel(context.Background())
cancel()
ifce.emitStats(ctx, time.Hour)
ttl := ttlGauge.Value() ttl := ttlGauge.Value()
assert.Positive(t, ttl, "ttl gauge should be set by one run of the emitter") assert.Positive(t, ttl, "ttl gauge should be primed by emitStats before its first tick")
assert.LessOrEqual(t, ttl, int64(3600)) assert.LessOrEqual(t, ttl, int64(3600))
assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.initiating_version", nil).Value()) assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.initiating_version", nil).Value())
assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.max_version", nil).Value()) assert.Equal(t, int64(cert.Version1), metrics.GetOrRegisterGauge("certificate.max_version", nil).Value())
+58
View File
@@ -0,0 +1,58 @@
//go:build darwin || send_pipeline
package nebula
import (
"github.com/slackhq/nebula/firewall"
"github.com/slackhq/nebula/overlay/batch"
"github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/udp"
)
// sendPipelinePlatform lets listenIn take the pipelined send path. It is on for darwin, and for any platform built
// with -tags send_pipeline so the pipeline's tests (and the e2e suite through it) run on linux too.
const sendPipelinePlatform = true
// listenInPipelined is f.listenIn with the underlay writes moved to a sender goroutine (batch.SendPipeline). This
// goroutine still reads the tun, runs the firewall and encrypts, straight into the pipeline's batch. The sender
// writes whatever has built up each time its previous write returns, so under load the packets read while one
// write is in the kernel leave together in the next one, and the next tun read overlaps the write.
func listenInPipelined(f *Interface, queue tio.Queue, i int) {
if f.pinThreads {
f.pinThisThread(i)
}
rejectBuf := make([]byte, mtu)
arenaSize := batch.SendBatchCap * (udp.MTU + 32)
onWrite := func(queued, written int, err error) {
f.accountSendBatch(queued, written, err, i)
}
p := batch.NewSendPipeline(f.writers[i], batch.SendBatchCap, arenaSize, udp.MaxWriteBatch, onWrite)
defer p.Close()
fwPacket := &firewall.ParsedPacket{}
nb := make([]byte, 12, 12)
conntrackCache := firewall.NewConntrackCacheTicker(f.ctx, f.l, f.conntrackCacheTimeout)
for {
pkts, err := queue.Read()
if err != nil {
// Same shutdown noise handling as listenOut
if !f.closed.Load() && f.ctx.Err() == nil {
f.l.Error("Error while reading outbound packet, closing", "error", err, "reader", i)
f.onFatal(err)
}
break
}
for j, pkt := range pkts {
// One Begin/End per packet holds the batch only briefly, so a sender that finishes a write mid-read
// takes what is ready then. An idle sender is woken once, at the end of the read, to take it whole.
sb := p.Begin()
f.consumeInsidePacket(pkt, fwPacket, nb, sb, rejectBuf, i, conntrackCache.Get())
p.End(j == len(pkts)-1)
}
}
f.l.Debug("overlay reader is done", "reader", i)
}
+89
View File
@@ -0,0 +1,89 @@
//go:build darwin || send_pipeline
package nebula
import (
"context"
"errors"
"net/netip"
"sync"
"testing"
"time"
"github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/test"
"github.com/slackhq/nebula/udp"
"github.com/stretchr/testify/assert"
"go.uber.org/goleak"
)
// scriptedQueue hands out reads from a script, then fails every Read with err.
type scriptedQueue struct {
reads [][]tio.Packet
err error
}
func (q *scriptedQueue) Read() ([]tio.Packet, error) {
if len(q.reads) == 0 {
return nil, q.err
}
r := q.reads[0]
q.reads = q.reads[1:]
return r, nil
}
func (q *scriptedQueue) Write(b []byte) (int, error) { return len(b), nil }
func (q *scriptedQueue) Close() error { return nil }
type countingConn struct {
udp.NoopConn
mu sync.Mutex
batches int
}
func (c *countingConn) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) {
c.mu.Lock()
c.batches++
c.mu.Unlock()
return len(bufs), nil
}
// TestListenInPipelinedStops pins that the pipelined reader returns when its queue fails, stopping its sender, and
// reports the error as fatal only when the interface isn't shutting down.
func TestListenInPipelinedStops(t *testing.T) {
for _, closing := range []bool{false, true} {
t.Run(map[bool]string{false: "fatal", true: "shutdown"}[closing], func(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
readErr := errors.New("tun gone")
conn := &countingConn{}
// Packets too short to parse are dropped before the firewall, so this reads without a hostmap.
junk := tio.Packet{Bytes: []byte{0x45, 0}}
q := &scriptedQueue{reads: [][]tio.Packet{{junk}, {junk, junk, junk}, {}}, err: readErr}
shutdown := make(chan struct{})
f := &Interface{
ctx: context.Background(),
l: test.NewLogger(),
writers: []udp.Conn{conn},
triggerShutdown: func() { close(shutdown) },
}
f.closed.Store(closing)
done := make(chan struct{})
go func() {
f.listenIn(q, 0)
close(done)
}()
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("listenIn did not return after its queue failed")
}
if closing {
assert.Nil(t, f.fatalErr.Load())
} else {
<-shutdown
assert.Equal(t, readErr, *f.fatalErr.Load())
}
assert.Zero(t, conn.batches, "dropped packets must not be written")
})
}
}
+58
View File
@@ -0,0 +1,58 @@
// Package msgx calls xnu's private batched socket calls, sendmsg_x and recvmsg_x, which move many datagrams per
// syscall. They are not public API, so a kernel or sandbox may refuse them; callers fall back to one datagram per
// syscall when Unsupported reports that.
package msgx
import (
"syscall"
"unsafe"
"golang.org/x/sys/unix"
)
// Batch is the most messages the callers hand one sendmsg_x or recvmsg_x call.
const Batch = 64
// Hdr mirrors xnu's struct msghdr_x (bsd/sys/socket_private.h), which the SDK doesn't ship. recvmsg_x reports each
// message's length in Datalen rather than in its return value.
type Hdr struct {
Name *byte
Namelen uint32
Iov *unix.Iovec
Iovlen int32
Control *byte
Controllen uint32
Flags int32
Datalen uint64
}
// Send passes hdrs to sendmsg_x on fd and returns how many messages the kernel took. EINTR is retried.
func Send(fd uintptr, hdrs []Hdr) (int, syscall.Errno) {
return call(unix.SYS_SENDMSG_X, fd, hdrs)
}
// Recv passes hdrs to recvmsg_x on fd and returns how many messages it filled. EINTR is retried.
func Recv(fd uintptr, hdrs []Hdr) (int, syscall.Errno) {
return call(unix.SYS_RECVMSG_X, fd, hdrs)
}
func call(trap, fd uintptr, hdrs []Hdr) (int, syscall.Errno) {
if len(hdrs) == 0 {
return 0, syscall.EINVAL
}
for {
r, _, errno := unix.Syscall6(trap, fd, uintptr(unsafe.Pointer(&hdrs[0])), uintptr(len(hdrs)), 0, 0, 0)
switch errno {
case 0:
return int(r), 0
case syscall.EINTR:
default:
return 0, errno
}
}
}
// Unsupported reports whether errno means the kernel or a sandbox refuses the private calls.
func Unsupported(errno syscall.Errno) bool {
return errno == syscall.ENOSYS || errno == syscall.EPERM || errno == syscall.EOPNOTSUPP
}
+79
View File
@@ -0,0 +1,79 @@
package msgx
import (
"bytes"
"syscall"
"testing"
"unsafe"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// TestHdrLayout pins Hdr to struct msghdr_x's LP64 layout: 56 bytes, Datalen last at 48.
func TestHdrLayout(t *testing.T) {
var h Hdr
assert.EqualValues(t, 56, unsafe.Sizeof(h))
assert.EqualValues(t, 48, unsafe.Offsetof(h.Datalen))
}
// TestSendRecvRoundTrip sends a batch through sendmsg_x in one call and reads it back through recvmsg_x in one
// call, each message whole, in order, with Datalen set.
func TestSendRecvRoundTrip(t *testing.T) {
fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_DGRAM, 0)
require.NoError(t, err)
t.Cleanup(func() {
_ = unix.Close(fds[0])
_ = unix.Close(fds[1])
})
// A dropped datagram fails the receive instead of hanging it.
require.NoError(t, unix.SetsockoptTimeval(fds[1], unix.SOL_SOCKET, unix.SO_RCVTIMEO, &unix.Timeval{Sec: 2}))
const n = 5
var want [n][]byte
var iovs [n]unix.Iovec
hdrs := make([]Hdr, n)
for i := range n {
want[i] = bytes.Repeat([]byte{byte(i + 1)}, 10+i)
iovs[i] = unix.Iovec{Base: &want[i][0]}
iovs[i].SetLen(len(want[i]))
hdrs[i] = Hdr{Iov: &iovs[i], Iovlen: 1}
}
sent, errno := Send(uintptr(fds[0]), hdrs)
require.Zero(t, errno)
require.Equal(t, n, sent)
var bufs [n + 1][64]byte
var riovs [n + 1]unix.Iovec
rhdrs := make([]Hdr, n+1)
for i := range rhdrs {
riovs[i] = unix.Iovec{Base: &bufs[i][0]}
riovs[i].SetLen(len(bufs[i]))
rhdrs[i] = Hdr{Iov: &riovs[i], Iovlen: 1}
}
got, errno := Recv(uintptr(fds[1]), rhdrs)
require.Zero(t, errno)
require.Equal(t, n, got)
for i := range n {
l := int(rhdrs[i].Datalen)
assert.Equal(t, want[i], bufs[i][:l], "message %d", i)
}
}
// TestEmptyBatch pins that an empty batch is refused before it reaches the kernel.
func TestEmptyBatch(t *testing.T) {
_, errno := Send(0, nil)
assert.Equal(t, syscall.EINVAL, errno)
_, errno = Recv(0, nil)
assert.Equal(t, syscall.EINVAL, errno)
}
func TestUnsupported(t *testing.T) {
for _, e := range []syscall.Errno{syscall.ENOSYS, syscall.EPERM, syscall.EOPNOTSUPP} {
assert.True(t, Unsupported(e), "%v", e)
}
for _, e := range []syscall.Errno{0, syscall.EAGAIN, syscall.ENOBUFS, syscall.EINVAL} {
assert.False(t, Unsupported(e), "%v", e)
}
}
+5 -28
View File
@@ -15,7 +15,6 @@ import (
"time" "time"
"github.com/gaissmai/bart" "github.com/gaissmai/bart"
"github.com/rcrowley/go-metrics"
"github.com/slackhq/nebula/cert" "github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/header" "github.com/slackhq/nebula/header"
@@ -82,8 +81,6 @@ type LightHouse struct {
updateTrigger chan struct{} updateTrigger chan struct{}
queryChan chan netip.Addr queryChan chan netip.Addr
// queryDropped counts queries QueryServer dropped because queryChan was full.
queryDropped metrics.Counter
calculatedRemotes atomic.Pointer[bart.Table[[]*calculatedRemote]] // Maps VpnAddr to []*calculatedRemote calculatedRemotes atomic.Pointer[bart.Table[[]*calculatedRemote]] // Maps VpnAddr to []*calculatedRemote
@@ -119,8 +116,7 @@ func NewLightHouseFromConfig(ctx context.Context, l *slog.Logger, c *config.C, c
nebulaPort: nebulaPort, nebulaPort: nebulaPort,
punchy: p, punchy: p,
updateTrigger: make(chan struct{}, 1), updateTrigger: make(chan struct{}, 1),
queryChan: make(chan netip.Addr, c.GetUint32("handshakes.query_buffer", 1024)), queryChan: make(chan netip.Addr, c.GetUint32("handshakes.query_buffer", 64)),
queryDropped: metrics.GetOrRegisterCounter("lighthouse.query.dropped", nil),
l: l, l: l,
} }
h.localAddrsFn = func(al *LocalAllowList) []netip.Addr { h.localAddrsFn = func(al *LocalAllowList) []netip.Addr {
@@ -359,13 +355,7 @@ func (lh *LightHouse) reload(c *config.C, initial bool) error {
} }
} }
// am_relay decides whether relay.relays applies to us at all if initial || c.HasChanged("relay.relays") {
if initial || c.HasChanged("relay.relays") || c.HasChanged("relay.am_relay") {
var before []netip.Addr
if !initial {
before = lh.GetRelaysForMe()
}
switch c.GetBool("relay.am_relay", false) { switch c.GetBool("relay.am_relay", false) {
case true: case true:
// Relays aren't allowed to specify other relays // Relays aren't allowed to specify other relays
@@ -390,11 +380,6 @@ func (lh *LightHouse) reload(c *config.C, initial bool) error {
} }
lh.relaysForMe.Store(&relaysForMe) lh.relaysForMe.Store(&relaysForMe)
} }
// Tell the lighthouses now rather than at the next interval, but only when what we advertise changed
if !initial && !slices.Equal(before, lh.GetRelaysForMe()) {
lh.TriggerUpdate()
}
} }
return nil return nil
@@ -527,19 +512,14 @@ func (lh *LightHouse) Query(vpnAddr netip.Addr) *RemoteList {
return nil return nil
} }
// QueryServer is asynchronous and non-blocking, no reply should be expected. // QueryServer is asynchronous so no reply should be expected
// If the query channel is full, the query is dropped.
func (lh *LightHouse) QueryServer(vpnAddr netip.Addr) { func (lh *LightHouse) QueryServer(vpnAddr netip.Addr) {
// Don't put lighthouse addrs in the query channel because we can't query lighthouses about lighthouses // Don't put lighthouse addrs in the query channel because we can't query lighthouses about lighthouses
if lh.amLighthouse || lh.IsLighthouseAddr(vpnAddr) { if lh.amLighthouse || lh.IsLighthouseAddr(vpnAddr) {
return return
} }
select { lh.queryChan <- vpnAddr
case lh.queryChan <- vpnAddr:
default:
lh.queryDropped.Inc(1)
}
} }
func (lh *LightHouse) QueryCache(vpnAddrs []netip.Addr) *RemoteList { func (lh *LightHouse) QueryCache(vpnAddrs []netip.Addr) *RemoteList {
@@ -1255,13 +1235,10 @@ func (lhh *LightHouseHandler) handleHostQuery(n *NebulaMeta, fromVpnAddrs []neti
// sendHostPunchNotification signals the other side to punch some zero byte udp packets // sendHostPunchNotification signals the other side to punch some zero byte udp packets
func (lhh *LightHouseHandler) sendHostPunchNotification(n *NebulaMeta, fromVpnAddrs []netip.Addr, punchNotifDest netip.Addr, w EncWriter) { func (lhh *LightHouseHandler) sendHostPunchNotification(n *NebulaMeta, fromVpnAddrs []netip.Addr, punchNotifDest netip.Addr, w EncWriter) {
whereToPunch := fromVpnAddrs[0] whereToPunch := fromVpnAddrs[0]
// Resolve the target before taking the querier's RemoteList lock below. GetHostInfo takes the
// hostmap lock, and the hostmap is taken before the lighthouse, which is taken before a
// RemoteList, so looking it up inside the callback would deadlock.
targetHI := lhh.lh.ifce.GetHostInfo(punchNotifDest)
found, ln, err := lhh.lh.queryAndPrepMessage(whereToPunch, func(c *cache) (int, error) { found, ln, err := lhh.lh.queryAndPrepMessage(whereToPunch, func(c *cache) (int, error) {
n = lhh.resetMeta() n = lhh.resetMeta()
n.Type = NebulaMeta_HostPunchNotification n.Type = NebulaMeta_HostPunchNotification
targetHI := lhh.lh.ifce.GetHostInfo(punchNotifDest)
var useVersion cert.Version var useVersion cert.Version
if targetHI == nil { if targetHI == nil {
useVersion = lhh.lh.ifce.GetCertState().initiatingVersion useVersion = lhh.lh.ifce.GetCertState().initiatingVersion
-202
View File
@@ -6,16 +6,13 @@ import (
"errors" "errors"
"fmt" "fmt"
"net/netip" "net/netip"
"sync"
"testing" "testing"
"time"
"github.com/gaissmai/bart" "github.com/gaissmai/bart"
"github.com/slackhq/nebula/cert" "github.com/slackhq/nebula/cert"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/header" "github.com/slackhq/nebula/header"
"github.com/slackhq/nebula/test" "github.com/slackhq/nebula/test"
"github.com/slackhq/nebula/udp"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"go.yaml.in/yaml/v3" "go.yaml.in/yaml/v3"
@@ -798,202 +795,3 @@ func TestLightHouse_logLocalAddrsErr(t *testing.T) {
lh.logLocalAddrsErr(errors.New("something else")) lh.logLocalAddrsErr(errors.New("something else"))
assert.Contains(t, out.String(), "level=WARN") assert.Contains(t, out.String(), "level=WARN")
} }
// heldEncWriter holds the query worker in its first GetHostInfo until release closes.
type heldEncWriter struct {
mockEncWriter
once sync.Once
held chan struct{}
release chan struct{}
}
func (w *heldEncWriter) GetHostInfo(netip.Addr) *HostInfo {
w.once.Do(func() { close(w.held) })
<-w.release
return nil
}
// QueryServer never waits on the query worker, since the packet readers call it and nothing drains the channel at
// shutdown; a query that finds the channel full is dropped and counted. The worker is held on its first query so the
// channel fills.
func TestLighthouse_QueryServerDoesNotBlock(t *testing.T) {
l := test.NewLogger()
cs := testCertState(netip.MustParsePrefix("10.128.0.1/16"))
lh1 := "10.128.0.2"
c := config.NewC(l)
c.Settings["lighthouse"] = map[string]any{"hosts": []any{lh1}}
c.Settings["static_host_map"] = map[string]any{lh1: []any{"1.1.1.1:4242"}}
c.Settings["handshakes"] = map[string]any{"query_buffer": 1}
lh, err := NewLightHouseFromConfig(t.Context(), l, c, cs, nil, nil)
require.NoError(t, err)
w := &heldEncWriter{held: make(chan struct{}), release: make(chan struct{})}
lh.ifce = w
t.Cleanup(func() { close(w.release) })
lh.QueryServer(netip.MustParseAddr("10.128.0.10"))
select {
case <-w.held:
case <-time.After(5 * time.Second):
t.Fatal("the query worker never took the first query")
}
dropped := lh.queryDropped.Count()
done := make(chan struct{})
go func() {
lh.QueryServer(netip.MustParseAddr("10.128.0.11"))
lh.QueryServer(netip.MustParseAddr("10.128.0.12"))
close(done)
}()
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("QueryServer blocked on a full query channel")
}
assert.EqualValues(t, 1, lh.queryDropped.Count()-dropped)
}
// hostmapEncWriter answers GetHostInfo from a real hostmap, the way Interface does.
type hostmapEncWriter struct {
mockEncWriter
hm *HostMap
}
func (w *hostmapEncWriter) GetHostInfo(a netip.Addr) *HostInfo { return w.hm.QueryVpnAddr(a) }
func (w *hostmapEncWriter) GetCertState() *CertState {
return &CertState{initiatingVersion: cert.Version1}
}
// A lighthouse runs four paths that each hold one lock while waiting for the next: CheckAndComplete
// holds the hostmap and takes the handshake manager, StartHandshake holds the handshake manager and
// takes the lighthouse, a host update holds the lighthouse and takes the sender's RemoteList, and a
// punch notification holds the querier's RemoteList while it resolves the target. If that last step
// reaches the hostmap under the RemoteList lock, the four deadlock. Drive them all at once.
func TestLighthouse_PunchNotificationDoesNotCloseLockCycle(t *testing.T) {
l := test.NewLogger()
myVpnNet := netip.MustParsePrefix("10.128.0.1/24")
c := config.NewC(l)
c.Settings["lighthouse"] = map[string]any{"am_lighthouse": true}
c.Settings["listen"] = map[string]any{"port": 4242}
lh, err := NewLightHouseFromConfig(t.Context(), l, c, testCertState(myVpnNet), nil, nil)
require.NoError(t, err)
mainHM := newHostMap(l)
pr := []netip.Prefix{}
mainHM.preferredRanges.Store(&pr)
lh.ifce = &hostmapEncWriter{hm: mainHM}
hm := NewHandshakeManager(l, mainHM, lh, &udp.NoopConn{}, defaultHandshakeConfig)
f := &Interface{hostMap: mainHM, lightHouse: lh, handshakeManager: hm, l: l}
hm.f = f
peer := netip.MustParseAddr("10.128.0.2")
peerUdp := netip.MustParseAddrPort("10.0.0.2:4242")
target := netip.MustParseAddr("10.128.0.3")
targetUdp := netip.MustParseAddrPort("10.0.0.3:4242")
outbound := netip.MustParseAddr("10.128.0.4")
inbound := netip.MustParseAddr("10.128.0.5")
seed := lh.NewRequestHandler()
newLHHostUpdate(peerUdp, peer, []netip.AddrPort{peerUdp}, seed)
newLHHostUpdate(targetUdp, target, []netip.AddrPort{targetUdp}, seed)
stop := make(chan struct{})
var wg sync.WaitGroup
loop := func(body func()) {
defer wg.Done()
for {
select {
case <-stop:
return
default:
body()
}
}
}
wg.Add(4)
// Outbound handshakes keep starting and being dropped.
go loop(func() {
hm.DeleteHostInfo(hm.StartHandshake(outbound, nil))
})
// Inbound handshakes keep completing and being torn down.
var idx uint32
go loop(func() {
idx++
hi := &HostInfo{
vpnAddrs: []netip.Addr{inbound},
localIndexId: idx,
remoteIndexId: idx,
remotes: lh.QueryCache([]netip.Addr{inbound}),
HandshakePacket: map[uint8][]byte{handshakePacketStage0: {byte(idx)}},
}
if _, err := hm.CheckAndComplete(hi, handshakePacketStage0, f); err == nil {
mainHM.DeleteHostInfo(hi)
}
})
// The peer keeps sending host updates.
updates := lh.NewRequestHandler()
go loop(func() {
newLHHostUpdate(peerUdp, peer, []netip.AddrPort{peerUdp}, updates)
})
// The same peer keeps querying for the target, which ends in a punch notification.
queries := lh.NewRequestHandler()
go loop(func() {
sendLHHostRequest(peerUdp, peer, target, queries, nil)
})
time.Sleep(time.Second)
close(stop)
done := make(chan struct{})
go func() { wg.Wait(); close(done) }()
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("deadlock: the lighthouse paths never finished after stop was signalled")
}
}
func TestLighthouse_reloadRelaysTriggersUpdate(t *testing.T) {
l := test.NewLogger()
c := config.NewC(l)
base := "lighthouse:\n am_lighthouse: true\nlisten:\n port: 4242\n"
require.NoError(t, c.LoadString(base+"relay:\n relays: [10.128.0.5]\n"))
lh, err := NewLightHouseFromConfig(t.Context(), l, c, testCertState(netip.MustParsePrefix("10.128.0.1/24")), nil, nil)
require.NoError(t, err)
assert.Empty(t, lh.updateTrigger)
require.NoError(t, c.ReloadConfigString(base+"relay:\n relays: [10.128.0.6]\n"))
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.6")}, lh.GetRelaysForMe())
require.Len(t, lh.updateTrigger, 1)
<-lh.updateTrigger
// The config changed but what we advertise did not, a bad entry is skipped
require.NoError(t, c.ReloadConfigString(base+"relay:\n relays: [10.128.0.6, nope]\n"))
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.6")}, lh.GetRelaysForMe())
assert.Empty(t, lh.updateTrigger)
}
func TestLighthouse_reloadAmRelayAlone(t *testing.T) {
l := test.NewLogger()
c := config.NewC(l)
base := "lighthouse:\n am_lighthouse: true\nlisten:\n port: 4242\nrelay:\n relays: [10.128.0.5]\n"
require.NoError(t, c.LoadString(base+" am_relay: false\n"))
lh, err := NewLightHouseFromConfig(t.Context(), l, c, testCertState(netip.MustParsePrefix("10.128.0.1/24")), nil, nil)
require.NoError(t, err)
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.5")}, lh.GetRelaysForMe())
// Relays aren't allowed to have relays, flipping am_relay alone must drop them and tell the lighthouses
require.NoError(t, c.ReloadConfigString(base+" am_relay: true\n"))
assert.Empty(t, lh.GetRelaysForMe())
require.Len(t, lh.updateTrigger, 1)
<-lh.updateTrigger
require.NoError(t, c.ReloadConfigString(base+" am_relay: false\n"))
assert.Equal(t, []netip.Addr{netip.MustParseAddr("10.128.0.5")}, lh.GetRelaysForMe())
require.Len(t, lh.updateTrigger, 1)
}
-31
View File
@@ -1,31 +0,0 @@
package logging
import "log/slog"
// RateLimiter is what RateLimited needs from a rate limiter, such as a *ratelimit.Limiter.
// Allow reports whether this call may proceed, and how many calls were denied since the last one that did.
type RateLimiter interface {
Allow() (denied uint64, ok bool)
}
// RateLimited checks lim before anything is built.
// When allowed it returns l, with a "suppressed" count attached if lim denied calls since its last allowed one.
// A nil lim allows everything.
//
// if l, ok := logging.RateLimited(f.l, f.udpTxErrLimiter); ok {
// hostinfo.logger(l).Error("Failed to write outgoing packet", "error", err)
// }
func RateLimited(l *slog.Logger, lim RateLimiter) (*slog.Logger, bool) {
if lim == nil {
return l, true
}
denied, ok := lim.Allow()
if !ok {
return nil, false
}
if denied > 0 {
return l.With("suppressed", denied), true
}
return l, true
}
-106
View File
@@ -1,106 +0,0 @@
package logging
import (
"bytes"
"errors"
"io"
"log/slog"
"net/netip"
"strings"
"testing"
"time"
"github.com/slackhq/nebula/ratelimit"
)
type fakeLimiter struct {
denied uint64
ok bool
}
func (f fakeLimiter) Allow() (uint64, bool) { return f.denied, f.ok }
func TestRateLimited(t *testing.T) {
var buf bytes.Buffer
base := NewLogger(&buf)
if l, ok := RateLimited(base, fakeLimiter{ok: false}); ok || l != nil {
t.Fatalf("denied call: ok=%v logger=%v", ok, l)
}
if l, ok := RateLimited(base, fakeLimiter{ok: true}); !ok || l != base {
t.Fatal("nothing denied should hand back the same logger")
}
if l, ok := RateLimited(base, nil); !ok || l != base {
t.Fatal("a nil limiter should allow with the same logger")
}
l, ok := RateLimited(base, fakeLimiter{denied: 7, ok: true})
if !ok {
t.Fatal("allowed call denied")
}
l.Info("hello", "k", "v")
if !strings.Contains(buf.String(), "suppressed=7") {
t.Fatalf("want suppressed=7, got %q", buf.String())
}
}
// The benchmarks compare a log line through slog directly against the same line behind RateLimited: logged with
// nothing denied, denied, and logged after denials.
var (
benchErr = errors.New("sendto: no buffer space available")
benchAddr = netip.MustParseAddrPort("192.0.2.1:4242")
)
func benchLogger() *slog.Logger {
return NewLogger(io.Discard).With("localIndex", 1234, "remoteIndex", 5678)
}
func BenchmarkRateLimitedBaseline(b *testing.B) {
lg := benchLogger()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
lg.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
}
}
func BenchmarkRateLimitedAllowed(b *testing.B) {
lg, lim := benchLogger(), mustLimiter(b, 1, 0)
b.ReportAllocs()
for i := 0; i < b.N; i++ {
if l, ok := RateLimited(lg, lim); ok {
l.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
}
}
}
func BenchmarkRateLimitedDenied(b *testing.B) {
lg, lim := benchLogger(), mustLimiter(b, 1, time.Hour)
lim.Allow()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
if l, ok := RateLimited(lg, lim); ok {
l.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
}
}
}
func BenchmarkRateLimitedAfterDenied(b *testing.B) {
lg, lim := benchLogger(), fakeLimiter{denied: 5, ok: true}
b.ReportAllocs()
for i := 0; i < b.N; i++ {
if l, ok := RateLimited(lg, lim); ok {
l.Error("Failed to write outgoing packet", "error", benchErr, "udpAddr", benchAddr)
}
}
}
func mustLimiter(b *testing.B, burst int, every time.Duration) *ratelimit.Limiter {
l, err := ratelimit.New(burst, every)
if err != nil {
b.Fatal(err)
}
return l
}
+4 -5
View File
@@ -213,6 +213,7 @@ 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)
@@ -300,7 +301,6 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
} }
var ifce *Interface var ifce *Interface
var emitStats func()
if !configTest { if !configTest {
ifce, err = NewInterface(ctx, ifConfig) ifce, err = NewInterface(ctx, ifConfig)
if err != nil { if err != nil {
@@ -319,12 +319,9 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
go handshakeManager.Run(ctx) go handshakeManager.Run(ctx)
punchy.Start(ctx, ifce, hostMap, lightHouse) punchy.Start(ctx, ifce, hostMap, lightHouse)
// On the stats server's loop, so the gauges follow the interval it accepted
emitStats = ifce.statsEmitter()
} }
stats, err := newStatsServerFromConfig(ctx, l, c, buildVersion, configTest, emitStats) stats, err := newStatsServerFromConfig(ctx, l, c, buildVersion, configTest)
if err != nil { if err != nil {
return nil, util.ContextualizeIfNeeded("Failed to start stats emitter", err) return nil, util.ContextualizeIfNeeded("Failed to start stats emitter", err)
} }
@@ -333,6 +330,8 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
return nil, nil return nil, nil
} }
go ifce.emitStats(ctx, c.GetDuration("stats.interval", time.Second*10))
attachCommands(l, c, ssh, ifce) attachCommands(l, c, ssh, ifce)
networkChanges := udp.NewNetworkChangeMonitor(ctx, l, c) networkChanges := udp.NewNetworkChangeMonitor(ctx, l, c)
+4 -9
View File
@@ -263,16 +263,11 @@ func (f *Interface) handleOutsideRelayPacket(hostinfo *HostInfo, via ViaSender,
// closeTunnel closes a tunnel locally, it does not send a closeTunnel packet to the remote // closeTunnel closes a tunnel locally, it does not send a closeTunnel packet to the remote
func (f *Interface) closeTunnel(hostInfo *HostInfo) { func (f *Interface) closeTunnel(hostInfo *HostInfo) {
// Hold the hostmap lock across both the delete and the lighthouse eviction, final := f.hostMap.DeleteHostInfo(hostInfo)
// to avoid a race with handshake completion. if final {
f.hostMap.Lock() // We no longer have any tunnels with this vpn addr, clear learned lighthouse state to lower memory usage
defer f.hostMap.Unlock() f.lightHouse.DeleteVpnAddrs(hostInfo.vpnAddrs)
if !f.hostMap.unlockedDeleteHostInfo(hostInfo) {
return
} }
// We no longer have any tunnels with this vpn addr, clear learned lighthouse state to lower memory usage
f.lightHouse.DeleteVpnAddrs(hostInfo.vpnAddrs)
} }
// sendCloseTunnel is a helper function to send a proper close tunnel packet to a remote // sendCloseTunnel is a helper function to send a proper close tunnel packet to a remote
+62
View File
@@ -435,3 +435,65 @@ func testPP(pkt []byte) *firewall.ParsedPacket {
} }
return pp return pp
} }
// fakeTunBatchWriter records each WriteBatch call and each plain Write separately.
type fakeTunBatchWriter struct {
writes [][]byte
batches [][][]byte
}
func (w *fakeTunBatchWriter) Write(p []byte) (int, error) {
w.writes = append(w.writes, bytes.Clone(p))
return len(p), nil
}
func (w *fakeTunBatchWriter) WriteBatch(pkts [][]byte) error {
var b [][]byte
for _, p := range pkts {
b = append(b, bytes.Clone(p))
}
w.batches = append(w.batches, b)
return nil
}
// TestPassthroughUsesWriteBatch pins that a writer implementing tio.BatchWriter gets the whole
// passthrough lane in one WriteBatch per Flush, in order, and no plain Writes; an empty Flush
// makes no call.
func TestPassthroughUsesWriteBatch(t *testing.T) {
w := &fakeTunBatchWriter{}
m := newTestMultiCoalescer(t, w)
k := &keySeq{epoch: 1}
var want [][]byte
for i := range 5 {
icmp := make([]byte, 28)
icmp[0] = 0x45
icmp[3] = 28
icmp[9] = 1
icmp[20] = byte(i)
want = append(want, icmp)
if err := m.Commit(icmp, k.next(), testPP(icmp)); err != nil {
t.Fatal(err)
}
}
if err := m.Flush(); err != nil {
t.Fatal(err)
}
if err := m.Flush(); err != nil {
t.Fatal(err)
}
if len(w.writes) != 0 {
t.Fatalf("got %d plain Writes, want 0", len(w.writes))
}
if len(w.batches) != 1 {
t.Fatalf("got %d WriteBatch calls, want 1", len(w.batches))
}
for i, p := range w.batches[0] {
if !bytes.Equal(p, want[i]) {
t.Fatalf("packet %d: got % x, want % x", i, p, want[i])
}
}
if len(w.batches[0]) != len(want) {
t.Fatalf("got %d packets, want %d", len(w.batches[0]), len(want))
}
}
+17 -6
View File
@@ -2,18 +2,23 @@ package batch
import ( import (
"io" "io"
"github.com/slackhq/nebula/overlay/tio"
) )
// Passthrough is MultiCoalescer's verbatim lane: no batching, packets are written at Flush in the // Passthrough is MultiCoalescer's verbatim lane: no coalescing, packets are written at Flush in the
// order enqueued. // order enqueued, in one WriteBatch when out implements tio.BatchWriter.
type Passthrough struct { type Passthrough struct {
out io.Writer out io.Writer
bw tio.BatchWriter // nil: Flush writes one packet per Write
slots [][]byte slots [][]byte
} }
func NewPassthrough(w io.Writer) *Passthrough { func NewPassthrough(w io.Writer) *Passthrough {
bw, _ := w.(tio.BatchWriter)
return &Passthrough{ return &Passthrough{
out: w, out: w,
bw: bw,
slots: make([][]byte, 0, 128), slots: make([][]byte, 0, 128),
} }
} }
@@ -26,10 +31,16 @@ func (p *Passthrough) enqueue(pkt []byte) error {
func (p *Passthrough) Flush() error { func (p *Passthrough) Flush() error {
var firstErr error var firstErr error
for _, s := range p.slots { if p.bw != nil {
_, err := p.out.Write(s) if len(p.slots) > 0 {
if err != nil && firstErr == nil { firstErr = p.bw.WriteBatch(p.slots)
firstErr = err }
} else {
for _, s := range p.slots {
_, err := p.out.Write(s)
if err != nil && firstErr == nil {
firstErr = err
}
} }
} }
clear(p.slots) clear(p.slots)
+156
View File
@@ -0,0 +1,156 @@
//go:build darwin || send_pipeline
package batch
import (
"sync"
)
// SendPipeline splits encrypt from send. The producer (a tun reader) encrypts packets into one SendBatch while a
// sender goroutine writes the other, and they swap whenever the sender is free. The sender takes everything the
// producer committed since its last take, so packets that arrive during a write leave together in the next
// WriteBatch, and the reader returns to the tun while the kernel is still sending.
//
// The producer holds the batch for one packet at a time (Begin, reserve and commit, End) so the sender can take the
// batch between any two packets, never while a reserved slot is still being written.
//
// Ownership: the producer touches its batch only between Begin and End, and the sender swaps batches only under
// the same lock, so a slot the producer reserved is never sent half written. A batch goes back to the producer
// only after its WriteBatch returned and it was emptied, so no slot is reused before its send completes.
//
// Memory is bounded at two batches. When the producer fills its batch while the sender is still writing the other,
// Begin waits for the swap. That slows the tun reader instead of dropping, as the unpipelined path does.
//
// Order: a single sender writes batches in the order they were filled, each in commit order, so every peer's
// packets leave in the order their message counters were taken.
type SendPipeline struct {
out batchWriter
cap int
maxWrite int
onWrite func(queued, written int, err error)
mu sync.Mutex
cond sync.Cond
cur *SendBatch // the producer's batch, guarded by mu
gen uint64 // swaps so far, guarded by mu
ready chan struct{} // cap 1: cur may have packets for the sender
stop chan struct{}
done chan struct{}
once sync.Once
}
// NewSendPipeline starts a pipeline over two batches of batchCap slots and arenaSize arena bytes each. It writes
// to out at most maxWrite packets per WriteBatch. If onWrite is not nil, it is called on the sender goroutine
// after every WriteBatch with how many packets that call was given, how many went out, and its error. Close stops
// the pipeline.
func NewSendPipeline(out batchWriter, batchCap, arenaSize, maxWrite int, onWrite func(queued, written int, err error)) *SendPipeline {
batchCap = max(batchCap, 1)
p := &SendPipeline{
out: out,
cap: batchCap,
maxWrite: max(maxWrite, 1),
onWrite: onWrite,
cur: NewSendBatch(out, batchCap, arenaSize),
ready: make(chan struct{}, 1),
stop: make(chan struct{}),
done: make(chan struct{}),
}
p.cond.L = &p.mu
go p.run(NewSendBatch(out, batchCap, arenaSize))
return p
}
// Begin returns a batch with room for at least one more packet. The batch stays the producer's until End. If the
// batch is full, Begin first waits for the sender to swap it out. Producer only.
func (p *SendPipeline) Begin() *SendBatch {
p.mu.Lock()
if p.cur.Len() >= p.cap {
g := p.gen
p.wake()
for p.gen == g {
p.cond.Wait()
}
}
return p.cur
}
// End gives up the batch Begin returned. With wake set it also tells the sender the batch has packets for it, which
// the producer does once a run of packets is in (the end of a tun read) rather than per packet, so the sender takes
// the run whole when it is idle. A sender still writing takes the batch when it finishes, woken or not.
func (p *SendPipeline) End(wake bool) {
n := p.cur.Len()
p.mu.Unlock()
if wake && n > 0 {
p.wake()
}
}
func (p *SendPipeline) wake() {
select {
case p.ready <- struct{}{}:
default:
}
}
// Close writes whatever the producer left in its batch, stops the sender, and waits for it. The producer calls it,
// outside Begin/End, once it is done. Safe to call more than once.
func (p *SendPipeline) Close() {
p.once.Do(func() { close(p.stop) })
<-p.done
}
func (p *SendPipeline) run(mine *SendBatch) {
defer close(p.done)
for {
stopping := false
select {
case <-p.ready:
case <-p.stop:
stopping = true
}
// Keep taking whatever the producer committed during the last write, without waiting to be woken, so a
// busy sender goes straight from one write to the next and each write carries everything that built up.
// Once stopping, the producer is done and this writes what it left.
for p.take(&mine) {
p.write(mine)
}
if stopping {
return
}
}
}
// take swaps the producer's batch for the empty *mine if the producer's has packets, and reports whether it did.
func (p *SendPipeline) take(mine **SendBatch) bool {
p.mu.Lock()
defer p.mu.Unlock()
if p.cur.Len() == 0 {
return false
}
*mine, p.cur = p.cur, *mine
p.gen++
p.cond.Broadcast()
return true
}
// write sends b's packets, maxWrite at a time, then empties b.
func (p *SendPipeline) write(b *SendBatch) {
for off := 0; off < len(b.bufs); {
n := min(p.maxWrite, len(b.bufs)-off)
written, err := p.out.WriteBatch(b.bufs[off:off+n], b.dsts[off:off+n])
if p.onWrite != nil {
p.onWrite(n, written, err)
}
off += n
}
b.recycle()
}
// recycle empties b without writing it. SendPipeline uses it because it writes a batch's packets itself.
func (b *SendBatch) recycle() {
clear(b.bufs)
b.bufs = b.bufs[:0]
b.dsts = b.dsts[:0]
b.arena.Reset()
}
+400
View File
@@ -0,0 +1,400 @@
//go:build darwin || send_pipeline
package batch
import (
"encoding/binary"
"errors"
"net/netip"
"sync"
"testing"
"time"
"unsafe"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/goleak"
)
// pipeWriter records every WriteBatch a SendPipeline makes. It checks each packet's bytes against the sequence
// number they carry while the call is in progress, and can hold a call until the test releases it.
type pipeWriter struct {
t *testing.T
mu sync.Mutex
seqs []uint32
dsts []netip.AddrPort
calls []int
inCall [][]byte // the bufs of the call in progress, for overlap checks
gate chan struct{} // if not nil, each call waits for a receive from it
entered chan int // if not nil, each call sends its size here on entry
short int // each call reports this many fewer written
err error
}
func (w *pipeWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
w.mu.Lock()
w.inCall = bufs
w.mu.Unlock()
if w.entered != nil {
w.entered <- len(bufs)
}
if w.gate != nil {
<-w.gate
}
w.mu.Lock()
defer w.mu.Unlock()
for i, b := range bufs {
seq := binary.BigEndian.Uint32(b)
if !checkPkt(b, seq) {
w.t.Errorf("packet %d changed while being sent", seq)
}
w.seqs = append(w.seqs, seq)
w.dsts = append(w.dsts, addrs[i])
}
w.calls = append(w.calls, len(bufs))
w.inCall = nil
return max(len(bufs)-w.short, 0), w.err
}
func (w *pipeWriter) sent() ([]uint32, []netip.AddrPort, []int) {
w.mu.Lock()
defer w.mu.Unlock()
return append([]uint32(nil), w.seqs...), append([]netip.AddrPort(nil), w.dsts...), append([]int(nil), w.calls...)
}
// fillPkt writes seq and a pattern derived from it into b, as the encrypt step writes a slot.
func fillPkt(b []byte, seq uint32) {
binary.BigEndian.PutUint32(b, seq)
for i := 4; i < len(b); i++ {
b[i] = byte(seq) ^ byte(i)
}
}
func checkPkt(b []byte, seq uint32) bool {
if len(b) < 4 || binary.BigEndian.Uint32(b) != seq {
return false
}
for i := 4; i < len(b); i++ {
if b[i] != byte(seq)^byte(i) {
return false
}
}
return true
}
func pktSize(seq uint32) int { return 16 + int(seq%97) }
var testDsts = []netip.AddrPort{
netip.MustParseAddrPort("10.0.0.1:4242"),
netip.MustParseAddrPort("10.0.0.2:4242"),
netip.MustParseAddrPort("[fd00::3]:4242"),
}
// commit adds packet seq to p the way listenIn does: Begin, reserve, encrypt, commit, End.
func commit(p *SendPipeline, seq uint32, last bool) {
sb := p.Begin()
slot := sb.Reserve(pktSize(seq))
fillPkt(slot, seq)
sb.Commit(slot, testDsts[seq%uint32(len(testDsts))])
p.End(last)
}
func TestSendPipelineOrder(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
// A small arena makes the batches grow theirs, and a small maxWrite splits takes across several writes.
p := NewSendPipeline(w, 16, 64, 5, nil)
const n = 20000
seq := uint32(0)
for seq < n {
// Reads of 1 to 40 packets, with an occasional pause so the sender goes idle and is woken.
read := 1 + int(seq*7%40)
for j := 0; j < read && seq < n; j++ {
commit(p, seq, j == read-1 || seq == n-1)
seq++
}
if seq%1000 < 40 {
time.Sleep(50 * time.Microsecond)
}
}
p.Close()
seqs, dsts, calls := w.sent()
require.Len(t, seqs, n)
for i, s := range seqs {
require.Equal(t, uint32(i), s, "packet %d out of order", i)
require.Equal(t, testDsts[s%uint32(len(testDsts))], dsts[i])
}
for _, c := range calls {
assert.LessOrEqual(t, c, 5, "WriteBatch got more than maxWrite")
assert.Positive(t, c)
}
}
func TestSendPipelineConcurrentPeersKeepOrder(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
// A slow writer makes the sender take many packets per write, interleaving the three peers in each batch.
w := &pipeWriter{t: t}
slow := &slowWriter{pipeWriter: w, d: 20 * time.Microsecond}
p := NewSendPipeline(slow, 128, 128*64, 128, nil)
const n = 5000
for i := uint32(0); i < n; i++ {
commit(p, i, i%8 == 7 || i == n-1)
}
p.Close()
seqs, dsts, _ := w.sent()
require.Len(t, seqs, n)
last := map[netip.AddrPort]int64{}
for i, s := range seqs {
prev, ok := last[dsts[i]]
if ok {
require.Greater(t, int64(s), prev, "peer %v went backwards", dsts[i])
}
last[dsts[i]] = int64(s)
}
}
type slowWriter struct {
*pipeWriter
d time.Duration
}
func (s *slowWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
time.Sleep(s.d)
return s.pipeWriter.WriteBatch(bufs, addrs)
}
// TestSendPipelineBackpressureAndReuse holds the sender inside a write and checks that the producer can fill
// exactly one more batch, that none of its slots overlap the packets being written, and that the next Begin waits
// until the write returns.
func TestSendPipelineBackpressureAndReuse(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
const batchCap = 8
w := &pipeWriter{t: t, gate: make(chan struct{}), entered: make(chan int, 16)}
p := NewSendPipeline(w, batchCap, 64, 128, nil)
seq := uint32(0)
for ; seq < batchCap; seq++ {
commit(p, seq, seq == batchCap-1)
}
require.Equal(t, batchCap, <-w.entered, "sender should take the first batch whole")
w.mu.Lock()
inFlight := append([][]byte(nil), w.inCall...)
w.mu.Unlock()
// The second batch fills while the first is being written, in slots that don't touch the first's bytes.
for ; seq < 2*batchCap; seq++ {
sb := p.Begin()
slot := sb.Reserve(pktSize(seq))
for _, b := range inFlight {
assert.False(t, overlaps(slot, b), "slot for packet %d overlaps packet %d, still being sent", seq, binary.BigEndian.Uint32(b))
}
fillPkt(slot, seq)
sb.Commit(slot, testDsts[0])
p.End(true)
}
// Both batches are now spoken for, so the next Begin must wait for the write to return.
begun := make(chan struct{})
go func() {
commit(p, seq, true)
close(begun)
}()
select {
case <-begun:
t.Fatal("Begin returned with both batches in use: the pipeline is not bounded")
case <-time.After(50 * time.Millisecond):
}
for i, b := range inFlight {
assert.True(t, checkPkt(b, uint32(i)), "packet %d was overwritten before its send completed", i)
}
w.gate <- struct{}{} // first write returns; the sender swaps and starts on the second batch
assert.Equal(t, batchCap, <-w.entered)
select {
case <-begun:
case <-time.After(5 * time.Second):
t.Fatal("Begin did not return after the sender freed a batch")
}
w.gate <- struct{}{}
go func() {
for range w.entered {
w.gate <- struct{}{}
}
}()
p.Close()
close(w.entered)
seqs, _, calls := w.sent()
require.Len(t, seqs, 2*batchCap+1)
for i, s := range seqs {
assert.Equal(t, uint32(i), s)
}
assert.Equal(t, []int{batchCap, batchCap, 1}, calls)
}
func overlaps(a, b []byte) bool {
if len(a) == 0 || len(b) == 0 {
return false
}
a0, b0 := uintptr(unsafe.Pointer(&a[0])), uintptr(unsafe.Pointer(&b[0]))
return a0 < b0+uintptr(len(b)) && b0 < a0+uintptr(len(a))
}
// TestSendPipelineBatchesBuildUp checks the point of the pipeline: while one write is in the kernel, everything the
// producer commits leaves together in the next write.
func TestSendPipelineBatchesBuildUp(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t, gate: make(chan struct{}), entered: make(chan int, 16)}
p := NewSendPipeline(w, 128, 128*64, 128, nil)
commit(p, 0, true)
require.Equal(t, 1, <-w.entered)
// Ten one-packet reads while the first write is held.
for i := uint32(1); i <= 10; i++ {
commit(p, i, true)
}
w.gate <- struct{}{}
require.Equal(t, 10, <-w.entered, "packets queued during a write should go out in one WriteBatch")
w.gate <- struct{}{}
p.Close()
_, _, calls := w.sent()
assert.Equal(t, []int{1, 10}, calls)
}
func TestSendPipelineCloseFlushes(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
p := NewSendPipeline(w, 32, 32*64, 128, nil)
// End(false) never wakes the sender, so only Close's final take sends these.
for i := uint32(0); i < 5; i++ {
commit(p, i, false)
}
p.Close()
p.Close() // idempotent
seqs, _, _ := w.sent()
assert.Equal(t, []uint32{0, 1, 2, 3, 4}, seqs)
}
func TestSendPipelineCloseEmpty(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
p := NewSendPipeline(w, 4, 64, 128, nil)
sb := p.Begin()
p.End(true) // nothing committed: no write
assert.Zero(t, sb.Len())
p.Close()
_, _, calls := w.sent()
assert.Empty(t, calls)
}
// TestSendPipelineCloseWaitsForWrite checks that Close returns only after a write in progress has returned, so the
// caller can't free anything the sender still uses.
func TestSendPipelineCloseWaitsForWrite(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t, gate: make(chan struct{}), entered: make(chan int, 4)}
p := NewSendPipeline(w, 4, 64, 128, nil)
commit(p, 0, true)
<-w.entered
commit(p, 1, false)
closed := make(chan struct{})
go func() {
p.Close()
close(closed)
}()
select {
case <-closed:
t.Fatal("Close returned during a write")
case <-time.After(50 * time.Millisecond):
}
w.gate <- struct{}{}
<-w.entered // Close's final take writes packet 1
w.gate <- struct{}{}
select {
case <-closed:
case <-time.After(5 * time.Second):
t.Fatal("Close did not return")
}
seqs, _, _ := w.sent()
assert.Equal(t, []uint32{0, 1}, seqs)
}
func TestSendPipelineOnWriteAndDrops(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
werr := errors.New("boom")
w := &pipeWriter{t: t, short: 1, err: werr}
type call struct {
queued, written int
err error
}
var got []call
p := NewSendPipeline(w, 16, 16*64, 4, func(q, n int, err error) {
got = append(got, call{q, n, err}) // sender goroutine only
})
for i := uint32(0); i < 10; i++ {
commit(p, i, false)
}
p.Close()
assert.Equal(t, []call{{4, 3, werr}, {4, 3, werr}, {2, 1, werr}}, got)
}
// TestSendPipelineStressRace runs a producer against a sender whose writes take varying time, for the race
// detector, and checks nothing is lost, reordered or overwritten.
func TestSendPipelineStressRace(t *testing.T) {
defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
w := &pipeWriter{t: t}
jitter := &jitterWriter{pipeWriter: w}
p := NewSendPipeline(jitter, 32, 256, 16, nil)
const n = 50000
for i := uint32(0); i < n; i++ {
commit(p, i, i%3 == 0)
}
p.Close()
seqs, _, _ := w.sent()
require.Len(t, seqs, n)
for i, s := range seqs {
if uint32(i) != s {
t.Fatalf("packet %d arrived at %d", s, i)
}
}
}
type jitterWriter struct {
*pipeWriter
i int
}
func (j *jitterWriter) WriteBatch(bufs [][]byte, addrs []netip.AddrPort) (int, error) {
j.i++
if j.i%7 == 0 {
time.Sleep(time.Duration(j.i%5) * 10 * time.Microsecond)
}
return j.pipeWriter.WriteBatch(bufs, addrs)
}
type discardWriter struct{}
func (discardWriter) WriteBatch(bufs [][]byte, _ []netip.AddrPort) (int, error) {
return len(bufs), nil
}
// BenchmarkSendPipeline measures a packet through Begin, reserve, commit and End with a writer that costs nothing;
// its allocs/op is the pipeline's steady-state heap cost per packet.
func BenchmarkSendPipeline(b *testing.B) {
p := NewSendPipeline(discardWriter{}, SendBatchCap, SendBatchCap*1500, 128, nil)
defer p.Close()
b.ReportAllocs()
for i := range b.N {
sb := p.Begin()
sb.Commit(sb.Reserve(1400), testDsts[0])
p.End(i%8 == 7)
}
}
-57
View File
@@ -1,57 +0,0 @@
//go:build !e2e_testing
package overlay
import (
"fmt"
"log/slog"
"golang.org/x/sys/windows"
"golang.org/x/sys/windows/registry"
)
var tcpipInterfaceKeys = []string{
`SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces`,
`SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters\Interfaces`,
}
// disableDNSRegistration prevents publishing overlay addresses in the host's
// DNS records, where clients outside the overlay cannot reach them.
// Failures are non-fatal so registry access cannot prevent tunnel creation.
func disableDNSRegistration(l *slog.Logger, guid windows.GUID) {
id := guid.String()
for _, base := range tcpipInterfaceKeys {
path := base + `\` + id
if err := setDNSRegistrationValues(path); err != nil {
l.Warn("Failed to disable DNS registration on the tun adapter", "error", err, "key", path)
continue
}
l.Debug("Disabled DNS registration on the tun adapter", "key", path)
}
}
func setDNSRegistrationValues(path string) error {
// The stack may not have created the adapter's interface key yet.
k, _, err := registry.CreateKey(registry.LOCAL_MACHINE, path, registry.SET_VALUE)
if err != nil {
return fmt.Errorf("open HKLM\\%s: %w", path, err)
}
defer k.Close()
// Neither RegistrationEnabled nor DisableDynamicUpdate alone reliably
// prevents registration, so all three settings are required.
values := []struct {
name string
data uint32
}{
{"RegistrationEnabled", 0},
{"DisableDynamicUpdate", 1},
{"MaxNumberOfAddressesToRegister", 0},
}
for _, v := range values {
if err := k.SetDWordValue(v.name, v.data); err != nil {
return fmt.Errorf("set %s: %w", v.name, err)
}
}
return nil
}
+11
View File
@@ -145,3 +145,14 @@ func SupportsGSO(w io.Writer, want GSOProto) (GSOWriter, bool) {
return gw, false return gw, false
} }
} }
// BatchWriter is implemented by Queues that can emit several already-segmented packets in one call.
// Backends without a batched write do not implement it and callers loop over Write.
//
// pkts are borrowed: WriteBatch must not retain them past its return.
// A returned error doesn't say which packets were delivered, so callers must not retry the batch.
// Safe for concurrent use, like Write.
type BatchWriter interface {
io.Writer
WriteBatch(pkts [][]byte) error
}
+404 -9
View File
@@ -8,12 +8,14 @@ import (
"log/slog" "log/slog"
"net/netip" "net/netip"
"os" "os"
"sync"
"sync/atomic" "sync/atomic"
"syscall" "syscall"
"unsafe" "unsafe"
"github.com/gaissmai/bart" "github.com/gaissmai/bart"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/internal/msgx"
"github.com/slackhq/nebula/overlay/tio" "github.com/slackhq/nebula/overlay/tio"
"github.com/slackhq/nebula/routing" "github.com/slackhq/nebula/routing"
"github.com/slackhq/nebula/util" "github.com/slackhq/nebula/util"
@@ -33,8 +35,23 @@ type tun struct {
// and routes for it. NEPacketTunnelProvider on darwin does this. // and routes for it. NEPacketTunnelProvider on darwin does this.
hostOwned bool hostOwned bool
l *slog.Logger l *slog.Logger
// batchMu guards batch, WriteBatch's sendmsg_x scratch.
batchMu sync.Mutex
batch tunBatch
} }
// tunBatch is WriteBatch's scratch. The kernel reads every entry in place.
type tunBatch struct {
heads [msgx.Batch][4]byte
iovs [msgx.Batch][2]unix.Iovec
hdrs [msgx.Batch]msgx.Hdr
pkts [msgx.Batch][]byte
}
// noTunSendX is set once sendmsg_x is refused on the tun; WriteBatch then writes one packet at a time.
var noTunSendX atomic.Bool
type ifReq struct { type ifReq struct {
Name [unix.IFNAMSIZ]byte Name [unix.IFNAMSIZ]byte
Flags uint16 Flags uint16
@@ -615,16 +632,12 @@ func (t *tun) Write(from []byte) (int, error) {
return 0, syscall.EIO return 0, syscall.EIO
} }
ipVer := from[0] >> 4
var head [4]byte var head [4]byte
switch ipVer { af, err := tunAF(from)
case 4: if err != nil {
head[3] = syscall.AF_INET return 0, err
case 6:
head[3] = syscall.AF_INET6
default:
return 0, fmt.Errorf("unable to determine IP version from packet")
} }
head[3] = af
// Grab rc as a local so the compiler can devirtualize the call and keep the closure on the stack. // Grab rc as a local so the compiler can devirtualize the call and keep the closure on the stack.
rc, err := t.f.SyscallConn() rc, err := t.f.SyscallConn()
@@ -657,6 +670,129 @@ func (t *tun) Write(from []byte) (int, error) {
return n - 4, nil return n - 4, nil
} }
// tunAF returns the utun address-family prefix byte for an IP packet.
func tunAF(pkt []byte) (byte, error) {
switch pkt[0] >> 4 {
case 4:
return syscall.AF_INET, nil
case 6:
return syscall.AF_INET6, nil
default:
return 0, fmt.Errorf("unable to determine IP version from packet")
}
}
// WriteBatch writes pkts to the utun device with sendmsg_x, up to msgx.Batch packets per syscall. utun is a
// connected datagram socket, so xnu takes the batched send path, though it still hands utun each packet on its own:
// this saves syscalls, not per-packet kernel work. Safe for concurrent use.
//
// An empty packet or one with no IP version is skipped and reported, as Write would. A short count goes on with the
// rest; EMSGSIZE, which sendmsg_x returns only when the first packet is past the send buffer, sends that one through
// Write, which reports it. Any other error means the kernel took an unknown prefix and dropped the rest, so it is
// reported rather than retried, which could deliver packets twice. Under mbuf exhaustion sendmsg_x reports packets it
// freed unsent as a short count, so they are lost where writev would have delivered them.
func (t *tun) WriteBatch(pkts [][]byte) error {
if noTunSendX.Load() {
return t.writeEach(pkts)
}
t.batchMu.Lock()
defer t.batchMu.Unlock()
b := &t.batch
var firstErr error
keep := func(err error) {
if err != nil && firstErr == nil {
firstErr = err
}
}
for len(pkts) > 0 {
n := 0
for len(pkts) > 0 && n < msgx.Batch {
p := pkts[0]
pkts = pkts[1:]
if len(p) == 0 {
keep(syscall.EIO)
continue
}
af, err := tunAF(p)
if err != nil {
keep(err)
continue
}
b.heads[n] = [4]byte{3: af}
b.iovs[n] = [2]unix.Iovec{{Base: &b.heads[n][0], Len: 4}, {Base: &p[0], Len: uint64(len(p))}}
b.hdrs[n] = msgx.Hdr{Iov: &b.iovs[n][0], Iovlen: 2}
b.pkts[n] = p
n++
}
for off := 0; off < n; {
sent, err := t.sendmsgX(b.hdrs[off:n])
switch {
case err == nil && sent > 0:
off += sent
case err == nil:
keep(t.writeEach(b.pkts[off:n]))
off = n
case err == unix.EMSGSIZE:
keep(t.writeEach(b.pkts[off : off+1]))
off++
case isUnsupported(err):
if noTunSendX.CompareAndSwap(false, true) {
t.l.Warn("sendmsg_x unavailable on the tun device, writing one packet per syscall", "error", err)
}
keep(t.writeEach(b.pkts[off:n]))
keep(t.writeEach(pkts))
pkts, off = nil, n
default:
keep(err)
off = n
}
}
clear(b.iovs[:n])
clear(b.pkts[:n])
}
return firstErr
}
// sendmsgX hands hdrs to sendmsg_x, waiting while the socket is full, and returns how many the kernel took.
func (t *tun) sendmsgX(hdrs []msgx.Hdr) (int, error) {
rc, err := t.f.SyscallConn()
if err != nil {
return 0, err
}
var sent int
var errno syscall.Errno
err = rc.Write(func(fd uintptr) bool {
sent, errno = msgx.Send(fd, hdrs)
// sendmsg_x reports EAGAIN only when it took nothing; a partial batch returns its count.
return errno != syscall.EAGAIN
})
if err != nil {
return 0, err
}
if errno != 0 {
return 0, errno
}
return sent, nil
}
func isUnsupported(err error) bool {
errno, ok := err.(syscall.Errno)
return ok && msgx.Unsupported(errno)
}
// writeEach writes pkts one at a time with Write.
func (t *tun) writeEach(pkts [][]byte) error {
var firstErr error
for _, p := range pkts {
if _, err := t.Write(p); err != nil && firstErr == nil {
firstErr = err
}
}
return firstErr
}
func (t *tun) Networks() []netip.Prefix { func (t *tun) Networks() []netip.Prefix {
return t.vpnNetworks return t.vpnNetworks
} }
@@ -666,5 +802,264 @@ func (t *tun) Name() string {
} }
func (t *tun) Queues(int) ([]tio.Queue, error) { func (t *tun) Queues(int) ([]tio.Queue, error) {
return []tio.Queue{tio.NewSingleQueue(t, defaultBatchBufSize)}, nil return []tio.Queue{newTunQueue(t)}, nil
}
// tunReadBatch is the most packets one tunQueue.Read returns.
const tunReadBatch = msgx.Batch
// tunRecvXSlot is each recvmsg_x entry's packet buffer. recvmsg_x lays its buffers out before it knows the packet
// sizes, so each gets room for the largest IP packet; the kernel only touches what it writes.
const tunRecvXSlot = defaultBatchBufSize
// tunRecvXStride is how far apart the slots start: 64 byte aligned, and one cache line more than 64KiB so the packet
// starts don't all land in the same cache sets.
const tunRecvXStride = 65536 + 64
// tunQueue is the darwin tun's Queue. Read hands back every packet already queued on the utun, up to tunReadBatch, so
// the caller encrypts and sends them as one batch rather than one per wakeup. It reads them with one recvmsg_x when
// it can and one readv per packet otherwise.
type tunQueue struct {
t *tun
// buf holds the packets Read returns: recvmsg_x's slots, or, for readv, one arena. readv stops once less than
// defaultBatchBufSize of it is left, so every readv has room for the largest packet utun can return.
buf []byte
pkts [tunReadBatch]tio.Packet
// x is the recvmsg_x scratch, nil once recvmsg_x is off for good.
x *tunRecvX
}
// tunRecvX is the recvmsg_x scratch. Entry i scatters its AF prefix into heads[i] and its packet into slot i of the
// queue's buf; the kernel reads and writes every entry in place.
type tunRecvX struct {
heads [tunReadBatch][4]byte
iovs [tunReadBatch][2]unix.Iovec
hdrs [tunReadBatch]msgx.Hdr
}
// newTunQueue returns t's Queue, raising t's pending packet limit first so a read can find more than one.
func newTunQueue(t *tun) *tunQueue {
t.raisePendingPackets()
q := &tunQueue{t: t, buf: make([]byte, tunReadBatch*tunRecvXStride), x: &tunRecvX{}}
x := q.x
for i := range x.hdrs {
x.iovs[i] = [2]unix.Iovec{
{Base: &x.heads[i][0], Len: 4},
{Base: &q.buf[i*tunRecvXStride], Len: tunRecvXSlot},
}
x.hdrs[i] = msgx.Hdr{Iov: &x.iovs[i][0], Iovlen: 2}
}
return q
}
// Read waits for the utun to become readable, then returns the packets queued on it.
func (q *tunQueue) Read() ([]tio.Packet, error) {
if q.x != nil {
if pkts, err, ok := q.readX(); ok {
return pkts, err
}
}
return q.readv()
}
// tunRecvmsgX is msgx.Recv; tests swap it to inject results.
var tunRecvmsgX = msgx.Recv
// readX reads up to tunReadBatch packets with one recvmsg_x. ok is false when the caller should read with readv
// instead: recvmsg_x failed this time, or has been turned off for good. A batch that fails tunRecvXCheck is dropped:
// its packets are off the socket, but their lengths can't be trusted.
func (q *tunQueue) readX() (pkts []tio.Packet, err error, ok bool) {
rc, err := q.t.f.SyscallConn()
if err != nil {
return nil, err, true
}
x := q.x
var n int
var errno syscall.Errno
err = rc.Read(func(fd uintptr) bool {
for i := range x.hdrs {
x.hdrs[i].Flags = 0
x.hdrs[i].Datalen = 0
}
n, errno = tunRecvmsgX(fd, x.hdrs[:])
return errno != unix.EAGAIN
})
if err != nil {
return nil, err, true
}
if tunRecvXRefused(errno) {
q.disableX("unavailable", errno)
return nil, nil, false
}
if errno != 0 {
// recvmsg_x can fail where readv wouldn't (a kernel allocation, say), so let readv read this wakeup and
// report the error if it is real.
return nil, nil, false
}
if cerr := tunRecvXCheck(n, x.hdrs[:], x.heads[:], tunRecvXSlot); cerr != nil {
q.disableX("returned an unexpected batch", cerr)
return nil, nil, false
}
for i := range n {
off := i * tunRecvXStride
end := off + int(x.hdrs[i].Datalen) - 4
q.pkts[i] = tio.Packet{Bytes: q.buf[off:end:end]}
}
// n is 0 at end of file, as readv's short read is.
return q.pkts[:n], nil, true
}
// tunRecvXRefused reports whether a recvmsg_x errno means it will never work here: msgx.Unsupported's refusals, and
// EINVAL and EMSGSIZE, which with the headers newTunQueue builds come only from xnu rejecting their layout.
func tunRecvXRefused(errno syscall.Errno) bool {
return msgx.Unsupported(errno) || errno == unix.EINVAL || errno == unix.EMSGSIZE
}
// disableX turns recvmsg_x off for q for good. readv keeps reading into buf.
func (q *tunQueue) disableX(why string, err error) {
q.x = nil
q.t.l.Warn("recvmsg_x "+why+" on the tun device, reading one packet per syscall", "error", err)
}
// tunRecvXCheck rejects a recvmsg_x batch of n entries that intact msghdr_x entries can't produce, which would mean
// the private layout changed under us: more entries than headers, one past its 4 byte head plus slot byte buffer or
// too short to hold the head, or an AF prefix utun never writes. A slot holds the largest IP packet, so nothing is
// ever truncated; xnu's default recvmsg_x path doesn't report MSG_TRUNC per entry anyway, only its SO_DONTTRUNC path
// does, and that is checked too.
func tunRecvXCheck(n int, hdrs []msgx.Hdr, heads [][4]byte, slot int) error {
if n < 0 || n > len(hdrs) || n > len(heads) {
return fmt.Errorf("returned %d packets for %d headers", n, len(hdrs))
}
for i := range n {
h := &hdrs[i]
if h.Flags&unix.MSG_TRUNC != 0 {
return fmt.Errorf("packet %d came back truncated, flags %#x", i, h.Flags)
}
if h.Datalen < 4 || h.Datalen > uint64(4+slot) {
return fmt.Errorf("packet %d is %d bytes, outside the 4 to %d the buffers allow", i, h.Datalen, 4+slot)
}
switch heads[i] {
case [4]byte{3: syscall.AF_INET}, [4]byte{3: syscall.AF_INET6}:
default:
return fmt.Errorf("packet %d has AF prefix % x", i, heads[i])
}
}
return nil
}
// readv reads packets one readv at a time until the utun would block. An error after at least one packet is dropped
// in favor of returning those packets; a persistent one recurs on the next Read.
func (q *tunQueue) readv() ([]tio.Packet, error) {
rc, err := q.t.f.SyscallConn()
if err != nil {
return nil, err
}
var head [4]byte
n, off := 0, 0
var callErr error
err = rc.Read(func(fd uintptr) bool {
for n < tunReadBatch && len(q.buf)-off >= defaultBatchBufSize {
iovecs := [2]unix.Iovec{
{Base: &head[0], Len: 4},
{Base: &q.buf[off], Len: uint64(len(q.buf) - off)},
}
l, e := tunReadv(int(fd), iovecs[:])
if e != nil {
if errno, ok := e.(syscall.Errno); ok && errno.Temporary() {
// Park on the poller only while there is nothing to hand back.
return n > 0
}
callErr = e
return true
}
if l < 4 {
// A datagram too short to carry the AF prefix, or end of file; stop rather than spin on it.
return true
}
end := off + l - 4
q.pkts[n] = tio.Packet{Bytes: q.buf[off:end:end]}
n++
off = end
}
return true
})
if n > 0 {
return q.pkts[:n], nil
}
if err != nil {
return nil, err
}
return nil, callErr
}
func (q *tunQueue) Write(p []byte) (int, error) { return q.t.Write(p) }
func (q *tunQueue) WriteBatch(pkts [][]byte) error { return q.t.WriteBatch(pkts) }
func (q *tunQueue) Close() error { return q.t.Close() }
// xnu lets one packet wait on a utun control socket by default (if_utun.c utun_ctl_bind): utun_start stops moving
// packets from the interface's send queue to the socket once one is waiting, and resumes only when a read wakes the
// interface's starter thread. So every read finds one packet. tunPendingPackets lets a whole read batch wait
// instead (_UTUN_OPT_MAX_PENDING_PACKETS, bsd/net/if_utun.h, set at SYSPROTO_CONTROL level).
const (
tunPendingPackets = tunReadBatch
_UTUN_OPT_MAX_PENDING_PACKETS = 16
_SYSPROTO_CONTROL = 2
)
// tunSetsockoptInt and tunGetsockoptInt are setsockopt and getsockopt; tests swap them.
var (
tunSetsockoptInt = unix.SetsockoptInt
tunGetsockoptInt = unix.GetsockoptInt
)
// raisePendingPackets lets up to tunPendingPackets packets wait on the utun control socket, first growing its
// receive buffer to hold that many packets and their 4 byte AF prefix: utun drops a packet the buffer has no room
// for, while one over the limit waits in the interface's queue. It sizes for the larger of tun.mtu and the device's
// current MTU. Failures are logged and leave xnu's default; the tun works either way.
func (t *tun) raisePendingPackets() {
if t.f == nil {
return
}
rc, err := t.f.SyscallConn()
if err != nil {
return
}
mtu := max(t.DefaultMTU, t.currentMTU())
_ = rc.Control(func(fd uintptr) {
pending := tunPendingPackets
need := pending * (mtu + 4)
if have, err := tunGetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF); err == nil && have < need {
if err := tunSetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF, need); err != nil {
pending = max(have/(mtu+4), 1)
t.l.Warn("could not grow the tun control socket's receive buffer, capping pending packets",
"error", err, "rcvbuf", have, "wanted", need, "pending", pending)
}
}
if err := tunSetsockoptInt(int(fd), _SYSPROTO_CONTROL, _UTUN_OPT_MAX_PENDING_PACKETS, pending); err != nil {
t.l.Warn("could not raise the tun's pending packet limit, reads will return one packet each",
"error", err, "pending", pending)
}
})
}
// currentMTU is the utun's MTU as the kernel has it now, or 0 if that can't be read. A host-owned device's MTU
// comes from the host, not tun.mtu.
func (t *tun) currentMTU() int {
if t.Device == "" {
return 0
}
s, err := unix.Socket(unix.AF_INET, unix.SOCK_DGRAM, unix.IPPROTO_IP)
if err != nil {
return 0
}
defer unix.Close(s)
ifr, err := unix.IoctlGetIfreqMTU(s, t.Device)
if err != nil {
return 0
}
return int(ifr.MTU)
} }
+637
View File
@@ -0,0 +1,637 @@
//go:build !ios && !e2e_testing
package overlay
import (
"bytes"
"os"
"sync/atomic"
"syscall"
"testing"
"time"
"github.com/slackhq/nebula/internal/msgx"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// newSocketpairTun returns a tun writing to one end of a connected AF_UNIX datagram socketpair, which
// takes sendmsg_x the way a utun control socket does, and the other end's fd for reading back.
// sndbuf is the writer's send buffer, which caps the largest datagram it accepts.
func newSocketpairTun(t *testing.T, sndbuf int) (*tun, int) {
t.Helper()
fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_DGRAM, 0)
require.NoError(t, err)
require.NoError(t, unix.SetsockoptInt(fds[0], unix.SOL_SOCKET, unix.SO_SNDBUF, sndbuf))
require.NoError(t, unix.SetsockoptInt(fds[1], unix.SOL_SOCKET, unix.SO_RCVBUF, 1<<20))
// A dropped datagram fails the read-back instead of hanging it.
require.NoError(t, unix.SetsockoptTimeval(fds[1], unix.SOL_SOCKET, unix.SO_RCVTIMEO, &unix.Timeval{Sec: 2}))
require.NoError(t, unix.SetNonblock(fds[0], true))
f := os.NewFile(uintptr(fds[0]), "socketpair")
t.Cleanup(func() {
_ = f.Close()
_ = unix.Close(fds[1])
})
return &tun{f: f, l: test.NewLogger()}, fds[1]
}
// testTunPkt returns packet i of size bytes, alternating IPv4 and IPv6, and the datagram the utun
// device should receive for it.
func testTunPkt(i, size int) (pkt, wire []byte) {
pkt = make([]byte, size)
pkt[0] = 0x45
af := byte(syscall.AF_INET)
if i%2 == 1 {
pkt[0] = 0x60
af = syscall.AF_INET6
}
pkt[1] = byte(i)
pkt[2] = byte(i >> 8)
return pkt, append([]byte{0, 0, 0, af}, pkt...)
}
// readTunBack asserts r receives exactly want, in order.
func readTunBack(t *testing.T, r int, want [][]byte) {
t.Helper()
buf := make([]byte, 4096)
for i, w := range want {
n, _, err := unix.Recvfrom(r, buf, 0)
require.NoError(t, err, "datagram %d", i)
if !bytes.Equal(w, buf[:n]) {
t.Fatalf("datagram %d: got % x, want % x", i, buf[:n], w)
}
}
_, _, err := unix.Recvfrom(r, buf, unix.MSG_DONTWAIT)
assert.ErrorIs(t, err, unix.EAGAIN, "extra datagrams delivered")
}
// forEachTunWritePath runs fn once over sendmsg_x and once over the per-packet writev fallback.
func forEachTunWritePath(t *testing.T, fn func(t *testing.T, fallback bool)) {
for _, fallback := range []bool{false, true} {
name := "sendmsg_x"
if fallback {
name = "writev"
}
t.Run(name, func(t *testing.T) {
noTunSendX.Store(fallback)
t.Cleanup(func() { noTunSendX.Store(false) })
fn(t, fallback)
})
}
}
// TestTunWriteBatch pins that WriteBatch delivers every packet whole, in order and behind the right
// utun AF prefix, across several sendmsg_x calls, and returns nil.
func TestTunWriteBatch(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
tn, r := newSocketpairTun(t, 1<<20)
var pkts, want [][]byte
for i := range 3*msgx.Batch + 5 {
p, w := testTunPkt(i, 60+i)
pkts = append(pkts, p)
want = append(want, w)
}
require.NoError(t, tn.WriteBatch(pkts))
assert.Equal(t, fallback, noTunSendX.Load())
readTunBack(t, r, want)
})
}
// TestTunWriteBatchSkipsInvalid pins that an empty packet or one with no IP version is skipped
// without shifting the packets after it, and that the first such error is the one reported.
func TestTunWriteBatchSkipsInvalid(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
tn, r := newSocketpairTun(t, 1<<20)
var pkts, want [][]byte
for i := range 20 {
p, w := testTunPkt(i, 60)
pkts = append(pkts, p)
want = append(want, w)
}
pkts = append(pkts[:10], append([][]byte{{0x10, 1, 2}, {}}, pkts[10:]...)...)
err := tn.WriteBatch(pkts)
assert.ErrorContains(t, err, "IP version")
readTunBack(t, r, want)
})
}
// TestTunWriteBatchOversize pins that a packet larger than the socket's send buffer drops only
// itself and is reported, whether sendmsg_x reaches it mid-call (a short count) or first (EMSGSIZE
// for the whole call). The send buffer is 1024 bytes and the oversize packet 2000.
func TestTunWriteBatchOversize(t *testing.T) {
for _, tc := range []struct {
name string
at int
}{
{"mid-call", msgx.Batch + 6},
{"first-in-call", msgx.Batch},
} {
t.Run(tc.name, func(t *testing.T) {
forEachTunWritePath(t, func(t *testing.T, fallback bool) {
tn, r := newSocketpairTun(t, 1024)
var pkts, want [][]byte
for i := range 2*msgx.Batch + 10 {
size := 100
if i == tc.at {
size = 2000
}
p, w := testTunPkt(i, size)
pkts = append(pkts, p)
if i != tc.at {
want = append(want, w)
}
}
err := tn.WriteBatch(pkts)
assert.ErrorIs(t, err, unix.EMSGSIZE)
assert.Equal(t, fallback, noTunSendX.Load())
readTunBack(t, r, want)
})
})
}
}
// forEachTunReadPath runs fn once over recvmsg_x and once over the per-packet readv drain.
func forEachTunReadPath(t *testing.T, fn func(t *testing.T, newQ func(*tun) *tunQueue)) {
for _, recvX := range []bool{true, false} {
name := "recvmsg_x"
if !recvX {
name = "readv"
}
t.Run(name, func(t *testing.T) {
fn(t, func(tn *tun) *tunQueue {
q := newTunQueue(tn)
if !recvX {
q.x = nil
}
return q
})
})
}
}
// writeTunPkts writes n test packets of size bytes to the peer end w and returns the packets the tun should hand back
// for them.
func writeTunPkts(t *testing.T, w, n, size int) [][]byte {
t.Helper()
var want [][]byte
for i := range n {
pkt, wire := testTunPkt(i, size+i)
_, err := unix.Write(w, wire)
require.NoError(t, err)
want = append(want, pkt)
}
return want
}
// newReadTun is newSocketpairTun with the tun's receive buffer big enough for every test burst, since an AF_UNIX
// datagram send is bounded by the receiver's buffer, and the writer's send buffer big enough for the largest IP packet.
func newReadTun(t *testing.T) (*tun, int) {
t.Helper()
tn, w := newSocketpairTun(t, 1<<20)
require.NoError(t, unix.SetsockoptInt(w, unix.SOL_SOCKET, unix.SO_SNDBUF, 1<<18))
rc, err := tn.f.SyscallConn()
require.NoError(t, err)
require.NoError(t, rc.Control(func(fd uintptr) {
require.NoError(t, unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF, 1<<20))
}))
return tn, w
}
// readTunPkts calls q.Read once per entry of sizes, requires each to return that many packets, and returns copies of
// them all.
func readTunPkts(t *testing.T, q *tunQueue, sizes ...int) [][]byte {
t.Helper()
var got [][]byte
for _, size := range sizes {
pkts, err := q.Read()
require.NoError(t, err)
require.Len(t, pkts, size)
for _, p := range pkts {
got = append(got, p.Clone().Bytes)
}
}
return got
}
// stubTunRecvmsgX swaps tunRecvmsgX for fn until the test ends and counts its calls. fn gets the real msgx.Recv to
// delegate to.
func stubTunRecvmsgX(t *testing.T, fn func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno)) *atomic.Int64 {
t.Helper()
sys := tunRecvmsgX
var calls atomic.Int64
tunRecvmsgX = func(fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
calls.Add(1)
return fn(sys, fd, hdrs)
}
t.Cleanup(func() { tunRecvmsgX = sys })
return &calls
}
// TestTunQueueReadDrains pins that Read hands back every queued packet, AF prefix stripped and in order, capped at
// tunReadBatch per call, and doesn't wait for more once the queue is empty.
func TestTunQueueReadDrains(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newReadTun(t)
q := newQ(tn)
want := writeTunPkts(t, w, tunReadBatch+3, 60)
assert.Equal(t, want, readTunPkts(t, q, tunReadBatch, 3))
})
}
// TestTunQueueReadUsesRecvX pins that a burst is read with one recvmsg_x, not one call per packet.
func TestTunQueueReadUsesRecvX(t *testing.T) {
calls := stubTunRecvmsgX(t, func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
return sys(fd, hdrs)
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
want := writeTunPkts(t, w, 10, 60)
assert.Equal(t, want, readTunPkts(t, q, 10))
assert.EqualValues(t, 1, calls.Load())
assert.NotNil(t, q.x)
}
// TestTunQueueReadLargePackets pins that packets up to the largest IP packet come back whole, which on the recvmsg_x
// path means each lands in its own slot and none spills into the next.
func TestTunQueueReadLargePackets(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newReadTun(t)
q := newQ(tn)
var want [][]byte
for i, size := range []int{65535, 1, 9001, 65535} {
pkt, wire := testTunPkt(i, max(size, 3))
pkt, wire = pkt[:size], wire[:4+size]
_, err := unix.Write(w, wire)
require.NoError(t, err)
want = append(want, pkt)
}
assert.Equal(t, want, readTunPkts(t, q, 4))
})
}
// TestTunQueueReadClipsPackets pins that each returned packet's capacity ends at its own bytes, so appending to one
// can't overwrite the next.
func TestTunQueueReadClipsPackets(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newSocketpairTun(t, 1<<20)
q := newQ(tn)
writeTunPkts(t, w, 2, 100)
pkts, err := q.Read()
require.NoError(t, err)
require.Len(t, pkts, 2)
assert.Equal(t, len(pkts[0].Bytes), cap(pkts[0].Bytes))
assert.Equal(t, len(pkts[1].Bytes), cap(pkts[1].Bytes))
})
}
// TestTunQueueReadDoesNotAllocate pins both read paths to zero allocations per Read once the queue exists.
func TestTunQueueReadDoesNotAllocate(t *testing.T) {
forEachTunReadPath(t, func(t *testing.T, newQ func(*tun) *tunQueue) {
tn, w := newReadTun(t)
q := newQ(tn)
_, wire := testTunPkt(0, 1300)
allocs := testing.AllocsPerRun(1000, func() {
if _, err := unix.Write(w, wire); err != nil {
t.Fatal(err)
}
if pkts, err := q.Read(); err != nil || len(pkts) != 1 {
t.Fatalf("read %d packets: %v", len(pkts), err)
}
})
assert.Zero(t, allocs)
})
}
// TestTunQueueReadXRefused pins that recvmsg_x being refused turns it off for good, and that the same Read still
// hands back the queued packets through readv.
func TestTunQueueReadXRefused(t *testing.T) {
for _, errno := range []syscall.Errno{unix.ENOSYS, unix.EPERM, unix.EOPNOTSUPP, unix.EINVAL} {
t.Run(errno.Error(), func(t *testing.T) {
calls := stubTunRecvmsgX(t, func(func(uintptr, []msgx.Hdr) (int, syscall.Errno), uintptr, []msgx.Hdr) (int, syscall.Errno) {
return 0, errno
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
want := writeTunPkts(t, w, 5, 60)
assert.Equal(t, want, readTunPkts(t, q, 5))
assert.Nil(t, q.x)
assert.EqualValues(t, 1, calls.Load())
want = writeTunPkts(t, w, 2, 60)
assert.Equal(t, want, readTunPkts(t, q, 2))
assert.EqualValues(t, 1, calls.Load(), "recvmsg_x was tried again after it was refused")
})
}
}
// TestTunQueueReadXTransientError pins that an error from recvmsg_x that doesn't mean it is refused leaves this Read
// to readv but keeps recvmsg_x on for the next.
func TestTunQueueReadXTransientError(t *testing.T) {
var failed atomic.Bool
calls := stubTunRecvmsgX(t, func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
if !failed.Swap(true) {
return 0, unix.ENOBUFS
}
return sys(fd, hdrs)
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
want := writeTunPkts(t, w, 3, 60)
assert.Equal(t, want, readTunPkts(t, q, 3))
assert.NotNil(t, q.x)
assert.EqualValues(t, 1, calls.Load())
want = writeTunPkts(t, w, 2, 60)
assert.Equal(t, want, readTunPkts(t, q, 2))
assert.EqualValues(t, 2, calls.Load(), "recvmsg_x wasn't tried again after a transient error")
}
// TestTunQueueReadXParks pins that EAGAIN from recvmsg_x parks the Read until the utun is readable, rather than
// falling back or returning an empty batch.
func TestTunQueueReadXParks(t *testing.T) {
var failed atomic.Bool
calls := stubTunRecvmsgX(t, func(sys func(uintptr, []msgx.Hdr) (int, syscall.Errno), fd uintptr, hdrs []msgx.Hdr) (int, syscall.Errno) {
if !failed.Swap(true) {
return 0, unix.EAGAIN
}
return sys(fd, hdrs)
})
tn, w := newReadTun(t)
q := newTunQueue(tn)
// A real EAGAIN means nothing is queued, so the packet arrives only once Read has parked. One packet, so the
// wakeup can't split it across Reads.
done := make(chan struct{})
go func() {
defer close(done)
time.Sleep(50 * time.Millisecond)
_, wire := testTunPkt(0, 60)
_, _ = unix.Write(w, wire)
}()
t.Cleanup(func() { <-done })
pkt, _ := testTunPkt(0, 60)
assert.Equal(t, [][]byte{pkt}, readTunPkts(t, q, 1))
assert.NotNil(t, q.x)
// A spurious wakeup costs another EAGAIN, so only a floor.
assert.GreaterOrEqual(t, calls.Load(), int64(2))
}
// TestTunQueueReadXBadBatch pins that a recvmsg_x batch no intact header could produce turns recvmsg_x off for good
// and hands the Read to readv. The stub reports a bad batch without taking any packets, so readv then reads them all.
func TestTunQueueReadXBadBatch(t *testing.T) {
v4 := [4]byte{3: syscall.AF_INET}
for _, tc := range []struct {
name string
mess func(x *tunRecvX) int
}{
{"too many", func(x *tunRecvX) int {
for i := range x.hdrs {
x.hdrs[i].Datalen, x.heads[i] = 64, v4
}
return len(x.hdrs) + 1
}},
{"past the buffer", func(x *tunRecvX) int {
x.hdrs[0].Datalen, x.heads[0] = 4+tunRecvXSlot+1, v4
return 1
}},
{"bad AF prefix", func(x *tunRecvX) int {
x.hdrs[0].Datalen, x.heads[0] = 64, [4]byte{syscall.AF_INET}
return 1
}},
} {
t.Run(tc.name, func(t *testing.T) {
var q *tunQueue
stubTunRecvmsgX(t, func(func(uintptr, []msgx.Hdr) (int, syscall.Errno), uintptr, []msgx.Hdr) (int, syscall.Errno) {
return tc.mess(q.x), 0
})
tn, w := newReadTun(t)
q = newTunQueue(tn)
want := writeTunPkts(t, w, 4, 60)
assert.Equal(t, want, readTunPkts(t, q, 4))
assert.Nil(t, q.x)
})
}
}
// TestTunRecvXCheck pins which recvmsg_x batches tunRecvXCheck accepts.
func TestTunRecvXCheck(t *testing.T) {
const slot = 1000
v4, v6 := [4]byte{3: syscall.AF_INET}, [4]byte{3: syscall.AF_INET6}
good := func() ([]msgx.Hdr, [][4]byte) {
hdrs := make([]msgx.Hdr, 4)
heads := make([][4]byte, 4)
for i := range hdrs {
hdrs[i].Datalen = uint64(4 + 20 + i)
heads[i] = v4
if i%2 == 1 {
heads[i] = v6
}
}
return hdrs, heads
}
for _, tc := range []struct {
name string
n int
mess func(hdrs []msgx.Hdr, heads [][4]byte)
ok bool
}{
{"all", 4, nil, true},
{"none", 0, nil, true},
{"prefix", 2, nil, true},
{"garbage past n is ignored", 2, func(h []msgx.Hdr, hd [][4]byte) { h[3].Datalen, hd[3] = 1<<40, [4]byte{9} }, true},
{"just the AF prefix", 1, func(h []msgx.Hdr, _ [][4]byte) { h[0].Datalen = 4 }, true},
{"fills the slot", 1, func(h []msgx.Hdr, _ [][4]byte) { h[0].Datalen = 4 + slot }, true},
{"more than headers", 5, nil, false},
{"negative", -1, nil, false},
{"past the slot", 2, func(h []msgx.Hdr, _ [][4]byte) { h[1].Datalen = 4 + slot + 1 }, false},
{"shorter than the AF prefix", 1, func(h []msgx.Hdr, _ [][4]byte) { h[0].Datalen = 3 }, false},
{"truncated", 3, func(h []msgx.Hdr, _ [][4]byte) { h[2].Flags = unix.MSG_TRUNC }, false},
{"zero AF prefix", 1, func(_ []msgx.Hdr, hd [][4]byte) { hd[0] = [4]byte{} }, false},
{"host order AF prefix", 1, func(_ []msgx.Hdr, hd [][4]byte) { hd[0] = [4]byte{syscall.AF_INET} }, false},
{"other AF", 2, func(_ []msgx.Hdr, hd [][4]byte) { hd[1] = [4]byte{3: syscall.AF_UNIX} }, false},
} {
t.Run(tc.name, func(t *testing.T) {
hdrs, heads := good()
if tc.mess != nil {
tc.mess(hdrs, heads)
}
err := tunRecvXCheck(tc.n, hdrs, heads, slot)
if tc.ok {
assert.NoError(t, err)
} else {
assert.Error(t, err)
}
})
}
}
// TestTunRecvXRefused pins which recvmsg_x errnos turn it off for good.
func TestTunRecvXRefused(t *testing.T) {
for _, errno := range []syscall.Errno{unix.ENOSYS, unix.EPERM, unix.EOPNOTSUPP, unix.EINVAL, unix.EMSGSIZE} {
assert.True(t, tunRecvXRefused(errno), "%v", errno)
}
for _, errno := range []syscall.Errno{0, unix.EAGAIN, unix.EINTR, unix.ENOBUFS, unix.ENOMEM, unix.EBADF, unix.ENOTCONN} {
assert.False(t, tunRecvXRefused(errno), "%v", errno)
}
}
// TestTunRaisePendingPackets pins that the pending limit is set at SYSPROTO_CONTROL level after the receive buffer is
// grown to hold that many packets of the tun's MTU, and capped to what the buffer holds when it can't grow.
func TestTunRaisePendingPackets(t *testing.T) {
type call struct{ level, opt, value int }
stub := func(t *testing.T, rcvbuf int, failLevel, failOpt int) *[]call {
set, get := tunSetsockoptInt, tunGetsockoptInt
var calls []call
tunSetsockoptInt = func(fd, level, opt, value int) error {
calls = append(calls, call{level, opt, value})
if level == failLevel && opt == failOpt {
return unix.ENOBUFS
}
return nil
}
tunGetsockoptInt = func(fd, level, opt int) (int, error) { return rcvbuf, nil }
t.Cleanup(func() { tunSetsockoptInt, tunGetsockoptInt = set, get })
return &calls
}
for _, tc := range []struct {
name string
rcvbuf int
mtu int
failLevel int
failOpt int
want []call
}{
{"grows rcvbuf first", 1 << 16, 9000, -1, -1, []call{
{unix.SOL_SOCKET, unix.SO_RCVBUF, 64 * 9004},
{2, 16, 64},
}},
{"rcvbuf already big enough", 1 << 20, 1300, -1, -1, []call{{2, 16, 64}}},
{"rcvbuf refused caps pending", 10 * 1304, 1300, unix.SOL_SOCKET, unix.SO_RCVBUF, []call{
{unix.SOL_SOCKET, unix.SO_RCVBUF, 64 * 1304},
{2, 16, 10},
}},
} {
t.Run(tc.name, func(t *testing.T) {
calls := stub(t, tc.rcvbuf, tc.failLevel, tc.failOpt)
tn, _ := newSocketpairTun(t, 1<<20)
tn.DefaultMTU = tc.mtu
_, err := tn.Queues(1)
require.NoError(t, err)
assert.Equal(t, tc.want, *calls)
})
}
}
func TestTun_WriteFraming(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tn := &tun{f: w}
for _, tc := range []struct {
name string
pkt []byte
af byte
}{
// Literal families rather than syscall.AF_*, so a wrong constant in Write can't also fix the expectation.
{"ipv4", []byte{0x45, 1, 2, 3, 4, 5}, 2},
{"ipv6", []byte{0x60, 1, 2, 3, 4, 5}, 30},
} {
t.Run(tc.name, func(t *testing.T) {
n, err := tn.Write(tc.pkt)
require.NoError(t, err)
require.Equal(t, len(tc.pkt), n)
got := make([]byte, 64)
n, err = r.Read(got)
require.NoError(t, err)
require.Equal(t, append([]byte{0, 0, 0, tc.af}, tc.pkt...), got[:n])
})
}
_, err = tn.Write([]byte{0x10, 1, 2, 3})
require.Error(t, err)
_, err = tn.Write([]byte{})
require.ErrorIs(t, err, syscall.EIO)
// The rejected writes must not have put anything on the fd, so the next read sees only this packet.
pkt := []byte{0x45, 9, 9}
_, err = tn.Write(pkt)
require.NoError(t, err)
got := make([]byte, 64)
n, err := r.Read(got)
require.NoError(t, err)
require.Equal(t, append([]byte{0, 0, 0, 2}, pkt...), got[:n])
}
func TestTun_ReadStripsHeader(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tn := &tun{f: r}
pkt := []byte{0x45, 1, 2, 3, 4, 5}
_, err = w.Write(append([]byte{0, 0, 0, syscall.AF_INET}, pkt...))
require.NoError(t, err)
got := make([]byte, 64)
n, err := tn.Read(got)
require.NoError(t, err)
require.Equal(t, pkt, got[:n])
}
func TestTun_ReadShort(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tn := &tun{f: r}
// Fewer bytes than the protocol header is not a packet.
_, err = w.Write([]byte{0, 0})
require.NoError(t, err)
n, err := tn.Read(make([]byte, 64))
require.NoError(t, err)
require.Zero(t, n)
// The next packet reads cleanly only if the short read consumed exactly what was written.
pkt := []byte{0x45, 1, 2, 3}
_, err = w.Write(append([]byte{0, 0, 0, syscall.AF_INET}, pkt...))
require.NoError(t, err)
got := make([]byte, 64)
n, err = tn.Read(got)
require.NoError(t, err)
require.Equal(t, pkt, got[:n])
}
// A heap allocation per packet rarely shows in a short throughput run, only across GC pauses, so
// this pins Read and Write to zero allocations directly.
func TestTun_ReadWriteDoNotAllocate(t *testing.T) {
r, w, err := os.Pipe()
require.NoError(t, err)
defer r.Close()
defer w.Close()
tw := &tun{f: w}
tr := &tun{f: r}
pkts := [][]byte{bytes.Repeat([]byte{0x45}, 1300), bytes.Repeat([]byte{0x60}, 1300)}
buf := make([]byte, 1500)
i := 0
allocs := testing.AllocsPerRun(1000, func() {
i++
if _, err := tw.Write(pkts[i%len(pkts)]); err != nil {
t.Fatal(err)
}
if _, err := tr.Read(buf); err != nil {
t.Fatal(err)
}
})
require.Zero(t, allocs)
}
+1 -10
View File
@@ -253,15 +253,6 @@ func (t *tun) reload(c *config.C, initial bool) error {
return nil return nil
} }
// Only the mtu changed. The routes are the same, parse them again so the ones without their own mtu pick up the
// new default. Without this an mtu change would remove them all
if !routeChange {
_, routes, err = getAllRoutesFromConfig(c, t.vpnNetworks, true)
if err != nil {
return err
}
}
routeTree, err := makeRouteTree(t.l, routes, true) routeTree, err := makeRouteTree(t.l, routes, true)
if err != nil { if err != nil {
return err return err
@@ -283,7 +274,7 @@ func (t *tun) reload(c *config.C, initial bool) error {
routes[i].MTU = newDefaultMTU routes[i].MTU = newDefaultMTU
} }
if r.MTU > newMaxMTU { if r.MTU > t.MaxMTU {
newMaxMTU = r.MTU newMaxMTU = r.MTU
} }
} }
-56
View File
@@ -1,56 +0,0 @@
//go:build !e2e_testing
package overlay
import (
"net/netip"
"testing"
"github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/routing"
"github.com/slackhq/nebula/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// Only tun.mtu changes. The system calls fail without a real device, what matters is the routes nebula keeps
func TestReloadMTUOnlyKeepsRoutes(t *testing.T) {
routes := " unsafe_routes:\n - route: 192.168.100.0/24\n via: 10.1.0.1\n"
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString("tun:\n mtu: 1300\n"+routes))
tn := &tun{
l: test.NewLogger(),
vpnNetworks: []netip.Prefix{netip.MustParsePrefix("10.1.0.2/24")},
ioctlFd: ^uintptr(0),
routesFromSystem: map[netip.Prefix]routing.Gateways{},
}
require.NoError(t, tn.reload(c, true))
require.NoError(t, c.ReloadConfigString("tun:\n mtu: 1400\n"+routes))
_ = tn.reload(c, false)
got := *tn.Routes.Load()
require.Len(t, got, 1)
assert.Equal(t, netip.MustParsePrefix("192.168.100.0/24"), got[0].Cidr)
assert.Equal(t, 1400, got[0].MTU)
assert.Equal(t, 1400, tn.DefaultMTU)
}
// The device mtu has to fit the largest route mtu, wherever it sits in the list
func TestReloadMaxMTUIsTheLargestRoute(t *testing.T) {
c := config.NewC(test.NewLogger())
require.NoError(t, c.LoadString("tun:\n mtu: 1300\n unsafe_routes:\n"+
" - route: 192.168.100.0/24\n via: 10.1.0.1\n mtu: 1500\n"+
" - route: 192.168.101.0/24\n via: 10.1.0.1\n mtu: 1400\n"))
tn := &tun{
l: test.NewLogger(),
vpnNetworks: []netip.Prefix{netip.MustParsePrefix("10.1.0.2/24")},
ioctlFd: ^uintptr(0),
routesFromSystem: map[netip.Prefix]routing.Gateways{},
}
require.NoError(t, tn.reload(c, true))
assert.Equal(t, 1500, tn.MaxMTU)
assert.Equal(t, 1300, tn.DefaultMTU)
}
-3
View File
@@ -104,9 +104,6 @@ func newTun(c *config.C, l *slog.Logger, vpnNetworks []netip.Prefix, _ bool) (*w
} }
t.tun = tunDevice.(*wintun.NativeTun) t.tun = tunDevice.(*wintun.NativeTun)
// Disable registration before Activate assigns addresses and triggers it.
disableDNSRegistration(l, *guid)
c.RegisterReloadCallback(func(c *config.C) { c.RegisterReloadCallback(func(c *config.C) {
err := t.reload(c, false) err := t.reload(c, false)
if err != nil { if err != nil {
-91
View File
@@ -1,91 +0,0 @@
package ratelimit
import (
"fmt"
"math"
"sync/atomic"
"time"
)
// Limiter is a token bucket: `burst` calls are allowed at once, then one more per `every`.
// It counts the calls it denies and hands that count to the next allowed call.
//
// The budget belongs to the Limiter instance.
// Every Allow that returns true spends from it, whatever the caller then does.
//
// Time follows Go's monotonic clock.
//
// Create one Limiter for each thing you want to limit,
// sharing one between unrelated events lets the noisy one starve the quiet one.
//
// Check Allow before doing the work being limited, so a denied call stays cheap:
//
// if denied, ok := probeLimiter.Allow(); ok {
// sendProbe()
// probesDenied.Inc(int64(denied))
// }
//
// For log lines use logging.RateLimited, which attaches the denied count to the logger as "suppressed".
type Limiter struct {
every int64
slack int64
tat atomic.Int64
denied atomic.Uint64
}
// maxSpan bounds `burst` * `every` to half of int64, leaving the other half for process uptime so the bucket
// math can't overflow.
const maxSpan = math.MaxInt64 / 2
// New returns a Limiter allowing `burst` calls at once and one more per `every`.
// A `burst` under 1 is 1, and an `every` of 0 or less never limits.
// It returns an error if `burst` * `every` is over about 146 years.
func New(burst int, every time.Duration) (*Limiter, error) {
l := &Limiter{}
if every > 0 {
burst = max(burst, 1)
if int64(burst) > maxSpan/int64(every) {
return nil, fmt.Errorf("ratelimit: burst %d * every %v is too long", burst, every)
}
l.every = int64(every)
l.slack = int64(burst-1) * l.every
}
return l, nil
}
var monoStart = time.Now()
func monoNow() int64 { return int64(time.Since(monoStart)) }
// Allow reports whether this call is allowed.
// If a token is available it spends it and returns the calls denied since the last allowed one, and true.
// Otherwise it returns 0 and false, and counts the denial.
// A nil Limiter allows everything.
func (l *Limiter) Allow() (uint64, bool) {
if l == nil {
return 0, true
}
return l.allow(monoNow())
}
// allow is Allow at a given monotonic time.
func (l *Limiter) allow(now int64) (uint64, bool) {
// Concurrent Allow calls read the clock before racing for the bucket, so one can see a time another already spent
// past and be denied. An unlimited Limiter must never deny, so it skips the bucket.
if l.every == 0 {
return 0, true
}
for {
tat := l.tat.Load()
next := max(tat, now)
if next-now > l.slack {
l.denied.Add(1)
return 0, false
}
if l.tat.CompareAndSwap(tat, next+l.every) {
return l.denied.Swap(0), true
}
}
}
-264
View File
@@ -1,264 +0,0 @@
package ratelimit
import (
"math"
"sync"
"sync/atomic"
"testing"
"time"
)
func mustLimiter(t testing.TB, burst int, every time.Duration) *Limiter {
t.Helper()
l, err := New(burst, every)
if err != nil {
t.Fatal(err)
}
return l
}
func TestLimiterBurstAndRefill(t *testing.T) {
l, now := mustLimiter(t, 3, time.Second), int64(0)
for i := 0; i < 3; i++ {
if n, ok := l.allow(now); !ok || n != 0 {
t.Fatalf("burst line %d: ok=%v denied=%d", i, ok, n)
}
}
for i := 0; i < 5; i++ {
if _, ok := l.allow(now); ok {
t.Fatalf("line %d past the burst logged", i)
}
}
now += int64(time.Second)
if n, ok := l.allow(now); !ok || n != 5 {
t.Fatalf("after one refill: ok=%v denied=%d, want true 5", ok, n)
}
if _, ok := l.allow(now); ok {
t.Fatal("one refill earned more than one line")
}
// A long quiet spell refills to burst, not past it, and the count reported above does not carry over.
now += int64(time.Hour)
for i, want := range []uint64{1, 0, 0} {
if n, ok := l.allow(now); !ok || n != want {
t.Fatalf("refilled line %d: ok=%v denied=%d, want true %d", i, ok, n, want)
}
}
if _, ok := l.allow(now); ok {
t.Fatal("bucket refilled past burst")
}
}
func TestLimiterBounds(t *testing.T) {
for _, every := range []time.Duration{0, -time.Second} {
l := mustLimiter(t, 1, every)
for i := 0; i < 100; i++ {
if _, ok := l.allow(0); !ok {
t.Fatalf("every=%v limited line %d", every, i)
}
}
}
l := mustLimiter(t, 0, time.Second)
if _, ok := l.allow(0); !ok {
t.Fatal("burst 0 should allow one line")
}
if _, ok := l.allow(0); ok {
t.Fatal("burst 0 should allow only one line")
}
}
func TestLimiterOverflow(t *testing.T) {
for _, c := range []struct {
burst int
every time.Duration
}{
{math.MaxInt, time.Second},
{1, math.MaxInt64},
{2, maxSpan/2 + 1},
} {
if _, err := New(c.burst, c.every); err == nil {
t.Fatalf("burst %d every %d should not fit", c.burst, c.every)
}
}
l := mustLimiter(t, 2, maxSpan/2)
for i := 0; i < 2; i++ {
if _, ok := l.allow(0); !ok {
t.Fatalf("the largest span should allow its burst, denied call %d", i)
}
}
if _, ok := l.allow(0); ok {
t.Fatal("the largest span allowed past its burst")
}
}
// Concurrent callers read the clock at slightly different times, which must not limit a Limiter that never limits.
func TestLimiterUnlimitedConcurrent(t *testing.T) {
l := mustLimiter(t, 1, 0)
var denied atomic.Int64
var wg sync.WaitGroup
for i := 0; i < 16; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for j := 0; j < 10000; j++ {
if _, ok := l.Allow(); !ok {
denied.Add(1)
}
}
}()
}
wg.Wait()
if got := denied.Load(); got != 0 {
t.Fatalf("denied %d lines", got)
}
}
func TestLimiterNil(t *testing.T) {
var l *Limiter
for i := 0; i < 10; i++ {
if _, ok := l.Allow(); !ok {
t.Fatal("nil limiter limited")
}
}
}
func TestLimiterConcurrent(t *testing.T) {
l := mustLimiter(t, 10, time.Hour)
var allowed atomic.Int64
var reported atomic.Uint64
var wg sync.WaitGroup
for i := 0; i < 16; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for j := 0; j < 1000; j++ {
if n, ok := l.allow(0); ok {
allowed.Add(1)
reported.Add(n)
}
}
}()
}
wg.Wait()
if got := allowed.Load(); got != 10 {
t.Fatalf("allowed %d lines, want the burst of 10", got)
}
// An allowed call that lands after some denials reports them, so the rest are still pending.
if got := reported.Load() + l.denied.Load(); got != 16*1000-10 {
t.Fatalf("denied %d, want %d", got, 16*1000-10)
}
}
func BenchmarkAllowAllowed(b *testing.B) {
l := mustLimiter(b, 1, time.Nanosecond)
b.ReportAllocs()
for i := 0; i < b.N; i++ {
l.tat.Store(0)
l.Allow()
}
}
func BenchmarkAllowDenied(b *testing.B) {
l := mustLimiter(b, 1, time.Hour)
l.Allow()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
l.Allow()
}
}
func BenchmarkAllowDeniedParallel(b *testing.B) {
l := mustLimiter(b, 1, time.Hour)
l.Allow()
b.ReportAllocs()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
l.Allow()
}
})
}
// FuzzLimiter checks the bucket against its exact definition over arbitrary call timings.
// A call is denied if and only if some allowed call a would leave too many calls for the time since a:
// (allowed calls since a, plus this one) * every > burst * every + (now - a).
// Every denied call must also be reported exactly once, by a later allowed call or still pending.
func FuzzLimiter(f *testing.F) {
f.Add(uint8(3), uint16(1000), []byte{0, 0, 0, 0, 16, 0, 0, 200, 1, 1, 1, 15, 17, 0})
f.Add(uint8(1), uint16(1), []byte{0, 16, 15, 16, 0, 255, 0, 0})
f.Fuzz(func(t *testing.T, burst uint8, everyUs uint16, steps []byte) {
if len(steps) > 512 {
steps = steps[:512]
}
b := int64(burst%16) + 1
every := int64(everyUs%1000+1) * int64(time.Microsecond)
l := mustLimiter(t, int(b), time.Duration(every))
var now int64
var allowedAt []int64
var denied, reported uint64
for _, s := range steps {
// Each step advances by a sixteenth of every, so timings land on and around the refill.
now += int64(s) * every / 16
over := false
for i, a := range allowedAt {
if int64(len(allowedAt)-i+1)*every > b*every+now-a {
over = true
break
}
}
n, ok := l.allow(now)
if ok == over {
t.Fatalf("at %d with %d allowed before: ok=%v, the definition says %v", now, len(allowedAt), ok, !over)
}
if !ok {
denied++
continue
}
reported += n
allowedAt = append(allowedAt, now)
}
if got := reported + l.denied.Load(); got != denied {
t.Fatalf("reported %d denied calls, made %d", got, denied)
}
})
}
// Concurrent callers on the real clock must account for every denied call exactly once.
func TestLimiterDeniedConservedConcurrent(t *testing.T) {
l := mustLimiter(t, 4, time.Microsecond)
var denied, reported atomic.Uint64
var wg sync.WaitGroup
for i := 0; i < 16; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for j := 0; j < 20000; j++ {
if n, ok := l.Allow(); ok {
reported.Add(n)
} else {
denied.Add(1)
}
}
}()
}
wg.Wait()
if denied.Load() == 0 {
t.Fatal("nothing was denied, the test proves nothing")
}
if got := reported.Load() + l.denied.Load(); got != denied.Load() {
t.Fatalf("reported %d denied calls, made %d", got, denied.Load())
}
}
+13
View File
@@ -0,0 +1,13 @@
//go:build !darwin && !send_pipeline
package nebula
import "github.com/slackhq/nebula/overlay/tio"
// sendPipelinePlatform is false off darwin: the pipelined send path (interface_pipeline.go) is darwin only for now,
// and listenIn writes its own batches everywhere else. Being a constant, it removes the branch at compile time.
// Build with -tags send_pipeline to run the pipeline, and its tests, on another platform.
const sendPipelinePlatform = false
// listenInPipelined is a plain function rather than a method so this unreachable stub leaves no trace in the binary.
func listenInPipelined(*Interface, tio.Queue, int) {}
+4 -8
View File
@@ -684,14 +684,10 @@ func sshCreateTunnel(ifce *Interface, fs any, a []string, w sshd.StringWriter) e
} }
} }
// Set the remote from the callback, which StartHandshake runs under the handshake manager lock hostInfo = ifce.handshakeManager.StartHandshake(vpnAddr, nil)
// before the hostinfo reaches the handshake loop or the static-host trigger, so the address is if addr.IsValid() {
// in the RemoteList before the first handshake is sent. hostInfo.SetRemote(addr)
ifce.handshakeManager.StartHandshake(vpnAddr, func(hh *HandshakeHostInfo) { }
if addr.IsValid() {
hh.hostinfo.SetRemote(addr)
}
})
return w.WriteLine("Created") return w.WriteLine("Created")
} }
+21 -45
View File
@@ -38,11 +38,6 @@ type statsServer struct {
runMu sync.Mutex runMu sync.Mutex
runCfg *statsConfig runCfg *statsConfig
run *statsRuntime // non-nil while a runtime is live run *statsRuntime // non-nil while a runtime is live
// Closed when the last runtime's capture loop has returned. Stop waits on it so nothing captures once it returns,
// and a reload's new runtime never overlaps the old one, go-metrics keeps its GC capture state in unguarded globals
loopDone chan struct{}
// See newStatsServerFromConfig, never changes after it
emitStats func()
} }
// statsRuntime is the live state owned by a single Start invocation. Start // statsRuntime is the live state owned by a single Start invocation. Start
@@ -87,16 +82,12 @@ type promConfig struct {
// //
// Start is safe to call unconditionally: it no-ops when stats are disabled. // Start is safe to call unconditionally: it no-ops when stats are disabled.
// The returned pointer is always non-nil, even on error. // The returned pointer is always non-nil, even on error.
// func newStatsServerFromConfig(ctx context.Context, l *slog.Logger, c *config.C, buildVersion string, configTest bool) (*statsServer, error) {
// emitStats, if set, updates metrics on every capture, ahead of the exporters so each export sees what it just set. It
// is fixed here, before the reload callback exists, so every runtime has it.
func newStatsServerFromConfig(ctx context.Context, l *slog.Logger, c *config.C, buildVersion string, configTest bool, emitStats func()) (*statsServer, error) {
s := &statsServer{ s := &statsServer{
l: l, l: l,
ctx: ctx, ctx: ctx,
buildVersion: buildVersion, buildVersion: buildVersion,
configTest: configTest, configTest: configTest,
emitStats: emitStats,
} }
c.RegisterReloadCallback(func(c *config.C) { c.RegisterReloadCallback(func(c *config.C) {
@@ -129,6 +120,7 @@ func (s *statsServer) reload(c *config.C, initial bool) error {
s.runMu.Lock() s.runMu.Lock()
sameCfg := s.runCfg != nil && *s.runCfg == newCfg sameCfg := s.runCfg != nil && *s.runCfg == newCfg
s.runCfg = &newCfg s.runCfg = &newCfg
running := s.run != nil
s.runMu.Unlock() s.runMu.Unlock()
s.enabled.Store(enabled) s.enabled.Store(enabled)
@@ -137,8 +129,9 @@ func (s *statsServer) reload(c *config.C, initial bool) error {
return nil return nil
} }
// Even with nothing running, a runtime whose listener failed can still be finishing its last pass if running {
s.Stop() s.Stop()
}
if enabled && !s.configTest { if enabled && !s.configTest {
go s.Start() go s.Start()
} }
@@ -160,19 +153,13 @@ func (s *statsServer) Start() {
return return
} }
cfg := *s.runCfg cfg := *s.runCfg
captureFns, listener := s.buildRuntime(cfg)
runCtx, cancel := context.WithCancel(s.ctx) runCtx, cancel := context.WithCancel(s.ctx)
captureFns, listener := s.buildRuntime(runCtx, cfg)
rt := &statsRuntime{cancel: cancel, listener: listener} rt := &statsRuntime{cancel: cancel, listener: listener}
s.run = rt s.run = rt
done := make(chan struct{})
s.loopDone = done
s.runMu.Unlock() s.runMu.Unlock()
// Prime before serving, so a scrape that lands before the first tick sees real values instead of zeros (issue #907) go captureStatsLoop(runCtx, cfg.interval, captureFns)
for _, fn := range captureFns {
fn()
}
go captureStatsLoop(runCtx, cfg.interval, captureFns, done)
cleanExit := true cleanExit := true
if listener == nil { if listener == nil {
@@ -231,32 +218,26 @@ func (s *statsServer) serveListener(listener *http.Server) bool {
// Stop tears down the active runtime, if any. Idempotent. // Stop tears down the active runtime, if any. Idempotent.
func (s *statsServer) Stop() { func (s *statsServer) Stop() {
// Held until the last pass is done, a Start that slipped in after s.run cleared would capture alongside it
s.runMu.Lock() s.runMu.Lock()
defer s.runMu.Unlock()
rt := s.run rt := s.run
s.run = nil s.run = nil
if rt != nil { s.runMu.Unlock()
rt.cancel() if rt == nil {
if rt.listener != nil { return
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
if err := rt.listener.Shutdown(shutdownCtx); err != nil {
s.l.Warn("Failed to shut down prometheus stats listener", "error", err)
}
cancel()
}
} }
// Nothing captures once Stop returns. The last runtime is cancelled by now, whoever cleared it, so this is at most rt.cancel()
// the pass it was in. Nothing in a pass takes runMu if rt.listener != nil {
if s.loopDone != nil { shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
<-s.loopDone if err := rt.listener.Shutdown(shutdownCtx); err != nil {
s.l.Warn("Failed to shut down prometheus stats listener", "error", err)
}
cancel()
} }
} }
// buildRuntime produces the capture functions and, for prometheus, an un-served // buildRuntime produces the capture functions and, for prometheus, an un-served
// http.Server from cfg. cfg has already been validated by loadStatsConfig. // http.Server from cfg. cfg has already been validated by loadStatsConfig.
// A graphite send in progress is abandoned when ctx is done. func (s *statsServer) buildRuntime(cfg statsConfig) ([]func(), *http.Server) {
func (s *statsServer) buildRuntime(ctx context.Context, cfg statsConfig) ([]func(), *http.Server) {
// rcrowley/go-metrics guards these registrations with a private sync.Once, // rcrowley/go-metrics guards these registrations with a private sync.Once,
// so subsequent reloads are no-ops. // so subsequent reloads are no-ops.
metrics.RegisterDebugGCStats(metrics.DefaultRegistry) metrics.RegisterDebugGCStats(metrics.DefaultRegistry)
@@ -266,9 +247,6 @@ func (s *statsServer) buildRuntime(ctx context.Context, cfg statsConfig) ([]func
func() { metrics.CaptureDebugGCStatsOnce(metrics.DefaultRegistry) }, func() { metrics.CaptureDebugGCStatsOnce(metrics.DefaultRegistry) },
func() { metrics.CaptureRuntimeMemStatsOnce(metrics.DefaultRegistry) }, func() { metrics.CaptureRuntimeMemStatsOnce(metrics.DefaultRegistry) },
} }
if s.emitStats != nil {
captureFns = append(captureFns, s.emitStats)
}
switch cfg.typ { switch cfg.typ {
case "graphite": case "graphite":
@@ -284,7 +262,7 @@ func (s *statsServer) buildRuntime(ctx context.Context, cfg statsConfig) ([]func
Percentiles: []float64{0.5, 0.75, 0.95, 0.99, 0.999}, Percentiles: []float64{0.5, 0.75, 0.95, 0.99, 0.999},
} }
captureFns = append(captureFns, func() { captureFns = append(captureFns, func() {
if err := graphiteOnce(ctx, gcfg, graphiteTimeout); err != nil && ctx.Err() == nil { if err := graphiteOnce(gcfg); err != nil {
s.l.Error("Graphite export failed", "error", err) s.l.Error("Graphite export failed", "error", err)
} }
}) })
@@ -331,10 +309,8 @@ func (s *statsServer) buildRuntime(ctx context.Context, cfg statsConfig) ([]func
return captureFns, nil return captureFns, nil
} }
// captureStatsLoop runs each fn on every tick of d until ctx is cancelled, then // captureStatsLoop runs each fn on every tick of d until ctx is cancelled.
// closes done. func captureStatsLoop(ctx context.Context, d time.Duration, fns []func()) {
func captureStatsLoop(ctx context.Context, d time.Duration, fns []func(), done chan struct{}) {
defer close(done)
t := time.NewTicker(d) t := time.NewTicker(d)
defer t.Stop() defer t.Stop()
for { for {
+30 -295
View File
@@ -2,18 +2,13 @@ package nebula
import ( import (
"context" "context"
"fmt"
"io" "io"
"log/slog" "log/slog"
"net" "net"
"net/http"
"net/http/httptest"
"strconv" "strconv"
"sync/atomic"
"testing" "testing"
"time" "time"
"github.com/rcrowley/go-metrics"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
@@ -115,14 +110,15 @@ func TestStatsServer_reload_initial_prometheus(t *testing.T) {
} }
func TestStatsServer_Start_graphite_blocksUntilStop(t *testing.T) { func TestStatsServer_Start_graphite_blocksUntilStop(t *testing.T) {
h := newGraphiteHost(t, 0) sink := newGraphiteSink(t)
defer sink.Close()
s, c := newTestStatsServer(t) s, c := newTestStatsServer(t)
setStatsConfig(c, map[string]any{ setStatsConfig(c, map[string]any{
"type": "graphite", "type": "graphite",
"interval": "1s", "interval": "1s",
"protocol": "tcp", "protocol": "tcp",
"host": h.ln.Addr().String(), "host": sink.Addr(),
"prefix": "test", "prefix": "test",
}) })
require.NoError(t, s.reload(c, true)) require.NoError(t, s.reload(c, true))
@@ -375,19 +371,35 @@ func waitForListening(t *testing.T, addr string) {
}) })
} }
// stopAtCleanup returns the ctx to build *s with, and stops it when the test ends. Cancelling first turns away a Start // graphiteSink is a minimal TCP accept-and-discard server so graphiteOnce
// a reload spawned that hasn't run yet, then Stop waits out the last pass, so nothing captures into the next test // calls in tests don't spam error logs or wedge on connection refused.
func stopAtCleanup(t *testing.T, s **statsServer) context.Context { type graphiteSink struct {
ctx, cancel := context.WithCancel(context.Background()) ln net.Listener
t.Cleanup(func() {
cancel()
if *s != nil {
(*s).Stop()
}
})
return ctx
} }
func newGraphiteSink(t *testing.T) *graphiteSink {
t.Helper()
ln, err := net.Listen("tcp", "127.0.0.1:0")
require.NoError(t, err)
g := &graphiteSink{ln: ln}
go func() {
for {
conn, err := ln.Accept()
if err != nil {
return
}
go func(c net.Conn) {
_, _ = io.Copy(io.Discard, c)
_ = c.Close()
}(conn)
}
}()
return g
}
func (g *graphiteSink) Addr() string { return g.ln.Addr().String() }
func (g *graphiteSink) Close() { _ = g.ln.Close() }
func freeTCPPort(t *testing.T) string { func freeTCPPort(t *testing.T) string {
t.Helper() t.Helper()
ln, err := net.Listen("tcp", "127.0.0.1:0") ln, err := net.Listen("tcp", "127.0.0.1:0")
@@ -396,280 +408,3 @@ func freeTCPPort(t *testing.T) string {
require.NoError(t, ln.Close()) require.NoError(t, ln.Close())
return strconv.Itoa(port) return strconv.Itoa(port)
} }
// Each export has to see what emitStats set in the same pass
func TestStatsServer_emitStatsRunsBeforeExport(t *testing.T) {
defer metrics.DefaultRegistry.Unregister("emitter.order.test")
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
setStatsConfig(c, map[string]any{
"type": "prometheus",
"interval": "1s",
"listen": "127.0.0.1:0",
"path": "/metrics",
})
gauge := metrics.GetOrRegisterGauge("emitter.order.test", nil)
s, err := newStatsServerFromConfig(t.Context(), l, c, "", false, func() { gauge.Update(42) })
require.NoError(t, err)
s.runMu.Lock()
fns, srv := s.buildRuntime(t.Context(), *s.runCfg)
s.runMu.Unlock()
require.NotNil(t, srv)
for _, fn := range fns {
fn()
}
rec := httptest.NewRecorder()
srv.Handler.ServeHTTP(rec, httptest.NewRequest("GET", "/metrics", nil))
assert.Contains(t, rec.Body.String(), "emitter_order_test 42")
}
// A scrape that lands the moment the listener is up already sees what emitStats set (issue #907)
func TestStatsServer_Start_primesBeforeServing(t *testing.T) {
defer metrics.DefaultRegistry.Unregister("prime.before.serving")
port := freeTCPPort(t)
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
setStatsConfig(c, map[string]any{
"type": "prometheus",
"interval": "1h",
"listen": "127.0.0.1:" + port,
"path": "/metrics",
})
gauge := metrics.GetOrRegisterGauge("prime.before.serving", nil)
// The pause would let a listener that came up before the prime serve the zero value
var s *statsServer
ctx := stopAtCleanup(t, &s)
s, err := newStatsServerFromConfig(ctx, l, c, "", false, func() {
time.Sleep(200 * time.Millisecond)
gauge.Update(42)
})
require.NoError(t, err)
go s.Start()
waitForListening(t, "127.0.0.1:"+port)
resp, err := http.Get("http://127.0.0.1:" + port + "/metrics")
require.NoError(t, err)
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
require.NoError(t, err)
assert.Contains(t, string(body), "prime_before_serving 42")
}
// Start captures once before the first tick, the interval here is an hour
func TestStatsServer_Start_primes(t *testing.T) {
ln, err := net.Listen("tcp", "127.0.0.1:0")
require.NoError(t, err)
defer ln.Close()
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": ln.Addr().String()})
primed := make(chan struct{}, 1)
var s *statsServer
ctx := stopAtCleanup(t, &s)
s, err = newStatsServerFromConfig(ctx, l, c, "", false, func() {
select {
case primed <- struct{}{}:
default:
}
})
require.NoError(t, err)
go s.Start()
select {
case <-primed:
case <-time.After(5 * time.Second):
t.Fatal("nothing was captured before the first tick")
}
}
// Graphite has to ship what emitStats set in the same pass, not the pass before
func TestStatsServer_emitStatsRunsBeforeGraphiteExport(t *testing.T) {
defer metrics.DefaultRegistry.Unregister("emitter.graphite.test")
ln, err := net.Listen("tcp", "127.0.0.1:0")
require.NoError(t, err)
defer ln.Close()
received := make(chan string, 1)
go func() {
conn, err := ln.Accept()
if err != nil {
return
}
defer conn.Close()
b, _ := io.ReadAll(conn)
received <- string(b)
}()
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": ln.Addr().String()})
gauge := metrics.GetOrRegisterGauge("emitter.graphite.test", nil)
s, err := newStatsServerFromConfig(t.Context(), l, c, "", false, func() { gauge.Update(42) })
require.NoError(t, err)
s.runMu.Lock()
fns, _ := s.buildRuntime(t.Context(), *s.runCfg)
s.runMu.Unlock()
for _, fn := range fns {
fn()
}
select {
case body := <-received:
assert.Contains(t, body, ".emitter.graphite.test.value 42 ")
case <-time.After(5 * time.Second):
t.Fatal("graphite sent nothing")
}
}
// stats.interval reloads, and the runtime a reload starts still has emitStats
func TestStatsServer_reloadMovesTheInterval(t *testing.T) {
var passes atomic.Int64
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
// Nothing listens here, each export fails at once
host := "127.0.0.1:" + freeTCPPort(t)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": host})
var s *statsServer
ctx := stopAtCleanup(t, &s)
s, err := newStatsServerFromConfig(ctx, l, c, "", false, func() { passes.Add(1) })
require.NoError(t, err)
go s.Start()
waitFor(t, func() bool { return passes.Load() == 1 })
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "20ms", "host": host})
require.NoError(t, s.reload(c, false))
waitFor(t, func() bool { return passes.Load() >= 6 })
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": host})
require.NoError(t, s.reload(c, false))
// The reload's Stop waited out the 20ms loop. The new runtime's prime may land either side of this read, it is the
// only pass left to come
stopped := passes.Load()
time.Sleep(300 * time.Millisecond)
assert.LessOrEqual(t, passes.Load()-stopped, int64(1), "the 20ms loop kept running after the reload")
}
// A reload's new runtime never captures while the old one is still in a pass, go-metrics keeps its GC capture state
// in unguarded globals
func TestStatsServer_reloadWaitsForTheLastPass(t *testing.T) {
var active, most atomic.Int64
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
host := "127.0.0.1:" + freeTCPPort(t)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "10ms", "host": host})
var s *statsServer
ctx := stopAtCleanup(t, &s)
s, err := newStatsServerFromConfig(ctx, l, c, "", false, func() {
n := active.Add(1)
for {
m := most.Load()
if n <= m || most.CompareAndSwap(m, n) {
break
}
}
// Long enough that a reload almost always lands mid pass
time.Sleep(50 * time.Millisecond)
active.Add(-1)
})
require.NoError(t, err)
go s.Start()
for i := range 6 {
setStatsConfig(c, map[string]any{"type": "graphite", "interval": fmt.Sprintf("%dms", 11-i%2), "host": host})
require.NoError(t, s.reload(c, false))
time.Sleep(30 * time.Millisecond)
}
assert.Equal(t, int64(1), most.Load())
}
// Nothing captures once Stop returns, a pass in progress is waited out
func TestStatsServer_Stop_waitsForThePass(t *testing.T) {
var inPass atomic.Bool
entered := make(chan struct{}, 1)
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": "127.0.0.1:" + freeTCPPort(t)})
var s *statsServer
ctx := stopAtCleanup(t, &s)
s, err := newStatsServerFromConfig(ctx, l, c, "", false, func() {
inPass.Store(true)
select {
case entered <- struct{}{}:
default:
}
time.Sleep(100 * time.Millisecond)
inPass.Store(false)
})
require.NoError(t, err)
go s.Start()
select {
case <-entered:
case <-time.After(5 * time.Second):
t.Fatal("never captured")
}
s.Stop()
assert.False(t, inPass.Load(), "Stop returned with a pass still running")
}
// A Start that arrives while Stop waits out the last pass doesn't capture alongside it
func TestStatsServer_Start_duringStopWaitsForThePass(t *testing.T) {
var active, most atomic.Int64
entered := make(chan struct{}, 1)
l := slog.New(slog.DiscardHandler)
c := config.NewC(l)
setStatsConfig(c, map[string]any{"type": "graphite", "interval": "1h", "host": "127.0.0.1:" + freeTCPPort(t)})
var s *statsServer
ctx := stopAtCleanup(t, &s)
s, err := newStatsServerFromConfig(ctx, l, c, "", false, func() {
n := active.Add(1)
for {
m := most.Load()
if n <= m || most.CompareAndSwap(m, n) {
break
}
}
select {
case entered <- struct{}{}:
default:
}
time.Sleep(200 * time.Millisecond)
active.Add(-1)
})
require.NoError(t, err)
go s.Start()
select {
case <-entered:
case <-time.After(5 * time.Second):
t.Fatal("never captured")
}
stopped := make(chan struct{})
go func() {
s.Stop()
close(stopped)
}()
// Stop holds runMu for its whole wait, the next Start has to arrive after it took it
waitFor(t, func() bool {
if s.runMu.TryLock() {
s.runMu.Unlock()
return false
}
return true
})
go s.Start()
select {
case <-stopped:
case <-time.After(5 * time.Second):
t.Fatal("Stop did not return")
}
waitFor(t, func() bool { return len(entered) == 1 })
assert.Equal(t, int64(1), most.Load(), "a Start captured alongside the pass Stop was waiting out")
}
+8
View File
@@ -48,6 +48,14 @@ 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
@@ -0,0 +1,106 @@
//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
@@ -0,0 +1,839 @@
//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
@@ -0,0 +1,6 @@
//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
@@ -0,0 +1,6 @@
//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
+285 -18
View File
@@ -10,10 +10,12 @@ import (
"log/slog" "log/slog"
"net" "net"
"net/netip" "net/netip"
"sync/atomic"
"syscall" "syscall"
"unsafe" "unsafe"
"github.com/slackhq/nebula/config" "github.com/slackhq/nebula/config"
"github.com/slackhq/nebula/internal/msgx"
"golang.org/x/sys/unix" "golang.org/x/sys/unix"
) )
@@ -22,9 +24,24 @@ type StdConn struct {
isV4 bool isV4 bool
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.
listenHost netip.Addr
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)
@@ -34,12 +51,14 @@ 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} c := &StdConn{UDPConn: uc, l: l, listenHost: s.Listen.Addr(), rx: make(chan *rxBatch, 1), done: make(chan struct{}),
free: make(chan *rxBatch, rxBatchesKept)}
rc, err := uc.SyscallConn() rc, err := uc.SyscallConn()
if err != nil { if err != nil {
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
@@ -53,6 +72,8 @@ 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
} }
@@ -89,6 +110,19 @@ 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
@@ -141,15 +175,47 @@ func (u *StdConn) WriteTo(b []byte, ap netip.AddrPort) error {
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. // An un-sendable destination costs its own packet, never the ones behind it in the batch.
// TODO: WriteTo maps EWOULDBLOCK to an error, so a full send buffer // TODO: writeTo maps EWOULDBLOCK to an error, so a full listener send buffer
// silently drops the rest of a burst (linux blocks instead). Poll for // silently drops those packets (linux blocks instead). Poll for
// writability on EAGAIN before giving up on the remainder. // writability on EAGAIN before giving up on them.
written := 0 written := 0
for i, b := range bufs { t := u.socks.table.Load()
if err := u.WriteTo(b, addrs[i]); err == nil { if t == nil {
written++ for i, b := range bufs {
} else { if err := u.writeTo(b, addrs[i]); err == nil {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err) written++
} else {
u.l.Debug("failed to write packet in batch", "udpAddr", addrs[i], "error", err)
}
}
return written, nil
}
for off := 0; off < len(bufs); {
// A run of datagrams to one peer goes out together, on its connected socket if it has or earns one.
dst := addrs[off]
end := off + 1
for end < len(bufs) && addrs[end] == dst {
end++
}
if p := (*t)[dst]; p != nil {
for off < end {
sent, err := u.connSockRun(p, dst, bufs[off:end])
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 return written, nil
@@ -180,12 +246,176 @@ func NewUDPStatsEmitter(udpConns []Conn) func() {
return func() {} return func() {}
} }
// ListenOut delivers the batches that the listener's reader and the connected sockets' readers hand it.
func (u *StdConn) ListenOut(r EncReader, flush func()) error { func (u *StdConn) ListenOut(r EncReader, flush func()) error {
buffer := make([]byte, MTU) defer close(u.done)
u.listening.Store(true)
u.startConnSocks()
errc := make(chan error, 1)
go func() { errc <- u.readListener() }()
for { for {
// Just read one packet at a time select {
n, rua, err := u.ReadFromUDPAddrPort(buffer) case b := <-u.rx:
for i := range b.n {
r(b.addrs[i], b.pkts[i])
}
flush()
u.putBatch(b)
case err := <-errc:
return err
}
}
}
// rxBatch is one recvmsg_x batch: n datagrams in pkts, from addrs. A reader takes one only while its socket is
// readable, so an idle connected socket holds none.
type rxBatch struct {
n int
pkts [msgx.Batch][]byte
addrs [msgx.Batch]netip.AddrPort
buf []byte
names [msgx.Batch]unix.RawSockaddrInet6
iovs [msgx.Batch]unix.Iovec
hdrs [msgx.Batch]msgx.Hdr
}
// rxBatchesKept is how many batches a listener keeps for reuse: one being delivered and one queued, plus one for
// each socket reading at once, the listener and up to 8 connected sockets. Each is msgx.Batch*MTU, about 576KB.
const rxBatchesKept = 11
func (u *StdConn) getBatch() *rxBatch {
select {
case b := <-u.free:
return b
default:
}
b := &rxBatch{buf: make([]byte, msgx.Batch*MTU)}
for i := range b.hdrs {
b.iovs[i].Base = &b.buf[i*MTU]
b.iovs[i].SetLen(MTU)
b.hdrs[i] = msgx.Hdr{Name: (*byte)(unsafe.Pointer(&b.names[i])), Iov: &b.iovs[i], Iovlen: 1}
}
return b
}
func (u *StdConn) putBatch(b *rxBatch) {
select {
case u.free <- b:
default:
}
}
// noRecvX is set once recvmsg_x is refused or misbehaves; every reader then reads one datagram per syscall.
var noRecvX atomic.Bool
// parse checks the n entries recvmsg_x filled and sets pkts and addrs from them. It rejects a batch that intact
// msghdr_x entries can't produce, which is how a change to xnu's private struct layout would show up.
func (b *rxBatch) parse(n int) error {
if n > len(b.hdrs) {
return fmt.Errorf("returned %d datagrams for %d headers", n, len(b.hdrs))
}
for i := range n {
h := &b.hdrs[i]
if h.Datalen > MTU {
return fmt.Errorf("datagram %d is %d bytes, past the %d byte buffer", i, h.Datalen, MTU)
}
sa := &b.names[i]
switch {
case sa.Family == unix.AF_INET && h.Namelen == unix.SizeofSockaddrInet4:
sa4 := (*unix.RawSockaddrInet4)(unsafe.Pointer(sa))
b.addrs[i] = netip.AddrPortFrom(netip.AddrFrom4(sa4.Addr), binary.BigEndian.Uint16((*[2]byte)(unsafe.Pointer(&sa4.Port))[:]))
case sa.Family == unix.AF_INET6 && h.Namelen == unix.SizeofSockaddrInet6:
b.addrs[i] = netip.AddrPortFrom(netip.AddrFrom16(sa.Addr).Unmap(), binary.BigEndian.Uint16((*[2]byte)(unsafe.Pointer(&sa.Port))[:]))
default:
return fmt.Errorf("datagram %d has address family %d with length %d", i, sa.Family, h.Namelen)
}
b.pkts[i] = b.buf[i*MTU : i*MTU+int(h.Datalen) : i*MTU+int(h.Datalen)]
}
b.n = n
return nil
}
// batchReader reads one socket in batches. Its fn is bound once, since a closure passed through the RawConn
// interface escapes and would allocate on every read.
type batchReader struct {
u *StdConn
conn *net.UDPConn
rc syscall.RawConn
b *rxBatch
errno syscall.Errno
fn func(fd uintptr) bool
}
func (u *StdConn) newBatchReader(conn *net.UDPConn, rc syscall.RawConn) *batchReader {
r := &batchReader{u: u, conn: conn, rc: rc}
r.fn = r.recv
return r
}
func (r *batchReader) recv(fd uintptr) bool {
b := r.u.getBatch()
for i := range b.hdrs {
b.hdrs[i].Namelen = unix.SizeofSockaddrInet6
b.hdrs[i].Flags = 0
b.hdrs[i].Datalen = 0
}
n, errno := msgx.Recv(fd, b.hdrs[:])
if errno == unix.EAGAIN {
r.u.putBatch(b)
return false
}
b.n, r.b, r.errno = n, b, errno
return true
}
// read returns the next batch: up to msgx.Batch datagrams from one recvmsg_x, or one datagram once recvmsg_x is off.
func (u *StdConn) read(r *batchReader) (*rxBatch, error) {
if !noRecvX.Load() {
r.b = nil
err := r.rc.Read(r.fn)
b := r.b
switch {
case err != nil:
if b != nil {
u.putBatch(b)
}
return nil, err
case r.errno == 0:
perr := b.parse(b.n)
if perr == nil {
return b, nil
}
// The batch was read through a layout the kernel no longer writes, so none of it is trustworthy.
u.disableRecvX("returned an unexpected header", perr)
case msgx.Unsupported(r.errno):
u.disableRecvX("unavailable", r.errno)
default:
u.putBatch(b)
return nil, r.errno
}
u.putBatch(b)
}
b := u.getBatch()
n, from, err := r.conn.ReadFromUDPAddrPort(b.buf[:MTU])
if err != nil {
u.putBatch(b)
return nil, err
}
b.n, b.pkts[0], b.addrs[0] = 1, b.buf[:n:n], netip.AddrPortFrom(from.Addr().Unmap(), from.Port())
return b, nil
}
func (u *StdConn) disableRecvX(why string, err error) {
if noRecvX.CompareAndSwap(false, true) {
u.l.Warn("recvmsg_x "+why+", reading one datagram per syscall", "error", err)
}
}
// readListener hands the listener's batches to ListenOut until the listener closes.
func (u *StdConn) readListener() error {
r := u.newBatchReader(u.UDPConn, u.rc)
for {
b, err := u.read(r)
if err != nil { if err != nil {
if errors.Is(err, net.ErrClosed) { if errors.Is(err, net.ErrClosed) {
return err return err
@@ -193,19 +423,39 @@ func (u *StdConn) ListenOut(r EncReader, flush func()) error {
u.l.Error("unexpected udp socket receive error", "error", err) u.l.Error("unexpected udp socket receive error", "error", err)
continue continue
} }
if !u.deliver(b) {
r(netip.AddrPortFrom(rua.Addr().Unmap(), rua.Port()), buffer[:n:n]) return net.ErrClosed
flush() }
} }
} }
// deliver hands b to ListenOut, and reports false once ListenOut has returned.
func (u *StdConn) deliver(b *rxBatch) bool {
select {
case u.rx <- b:
return true
case <-u.done:
u.putBatch(b)
return false
}
}
// Close closes the connected sockets of every listen routine, then the listener.
func (u *StdConn) Close() error {
u.stopConnSocks()
return u.UDPConn.Close()
}
func (u *StdConn) SupportsMultipleReaders() bool { func (u *StdConn) SupportsMultipleReaders() bool {
return false return false
} }
// 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. // this way on its own, which is what strands us after the underlying network changes. Control.RebindUDPServer
// 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 {
@@ -213,6 +463,23 @@ 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 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 serr
}
+344
View File
@@ -0,0 +1,344 @@
//go:build !e2e_testing
package udp
import (
"bytes"
"fmt"
"log/slog"
"net"
"net/netip"
"sync"
"syscall"
"testing"
"time"
"unsafe"
"github.com/slackhq/nebula/internal/msgx"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
// A burst larger than msgx.Batch arrives whole, with each datagram's own bytes and source address, and
// flush runs once per recvmsg_x batch rather than once per datagram.
func TestListenOutBatchesBurst(t *testing.T) {
for _, tc := range []struct{ name, listen string }{
{"v4", "127.0.0.1"},
{"v6", "::1"},
} {
t.Run(tc.name, func(t *testing.T) {
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.AddrPortFrom(netip.MustParseAddr(tc.listen), 0)})
require.NoError(t, err)
la, err := c.LocalAddr()
require.NoError(t, err)
tx, err := net.Dial("udp", la.String())
require.NoError(t, err)
defer tx.Close()
txAddr := netip.MustParseAddrPort(tx.LocalAddr().String())
const total = msgx.Batch*3 + 7
var mu sync.Mutex
var got []string
var froms []netip.AddrPort
flushes := 0
// Queued before the reader starts, so recvmsg_x sees full batches.
for i := 0; i < total; i++ {
_, err := tx.Write([]byte(fmt.Sprintf("pkt-%03d", i)))
require.NoError(t, err)
}
done := make(chan struct{})
go func() {
_ = c.ListenOut(func(addr netip.AddrPort, payload []byte) {
mu.Lock()
got = append(got, string(payload))
froms = append(froms, addr)
mu.Unlock()
}, func() {
mu.Lock()
flushes++
mu.Unlock()
})
close(done)
}()
require.Eventually(t, func() bool {
mu.Lock()
defer mu.Unlock()
return len(got) == total
}, 5*time.Second, 10*time.Millisecond)
require.NoError(t, c.Close())
<-done
for i, p := range got {
assert.Equal(t, fmt.Sprintf("pkt-%03d", i), p)
assert.Equal(t, txAddr, froms[i])
}
assert.Equal(t, (total+msgx.Batch-1)/msgx.Batch, flushes)
})
}
}
// Once recvmsg_x is off, every datagram still arrives, one per batch.
func TestListenOutSingleFallback(t *testing.T) {
noRecvX.Store(true)
t.Cleanup(func() { noRecvX.Store(false) })
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0")})
require.NoError(t, err)
la, err := c.LocalAddr()
require.NoError(t, err)
tx, err := net.Dial("udp", la.String())
require.NoError(t, err)
defer tx.Close()
txAddr := netip.MustParseAddrPort(tx.LocalAddr().String())
const total = 5
for i := 0; i < total; i++ {
_, err := tx.Write([]byte(fmt.Sprintf("pkt-%03d", i)))
require.NoError(t, err)
}
var mu sync.Mutex
var got []string
flushes := 0
done := make(chan struct{})
go func() {
_ = c.ListenOut(func(addr netip.AddrPort, payload []byte) {
assert.Equal(t, txAddr, addr)
mu.Lock()
got = append(got, string(payload))
mu.Unlock()
}, func() {
mu.Lock()
flushes++
mu.Unlock()
})
close(done)
}()
require.Eventually(t, func() bool {
mu.Lock()
defer mu.Unlock()
return len(got) == total
}, 5*time.Second, 10*time.Millisecond)
require.NoError(t, c.Close())
<-done
for i, p := range got {
assert.Equal(t, fmt.Sprintf("pkt-%03d", i), p)
}
assert.Equal(t, total, flushes)
}
func TestRxBatchParse(t *testing.T) {
valid := func() *rxBatch {
b := (&StdConn{}).getBatch()
b.hdrs[0].Namelen, b.hdrs[0].Datalen = unix.SizeofSockaddrInet4, 1
b.names[0].Family = unix.AF_INET
sa4 := (*unix.RawSockaddrInet4)(unsafe.Pointer(&b.names[0]))
sa4.Addr = [4]byte{10, 0, 0, 1}
sa4.Port = 0x0110 // 4097 in network order
b.hdrs[1].Namelen, b.hdrs[1].Datalen = unix.SizeofSockaddrInet6, MTU
b.names[1].Family = unix.AF_INET6
b.names[1].Addr = netip.MustParseAddr("::ffff:10.0.0.2").As16()
b.names[1].Port = 0x0210
return b
}
b := valid()
require.NoError(t, b.parse(2))
assert.Equal(t, 2, b.n)
assert.Equal(t, netip.MustParseAddrPort("10.0.0.1:4097"), b.addrs[0])
assert.Equal(t, netip.MustParseAddrPort("10.0.0.2:4098"), b.addrs[1], "v4-mapped sources arrive unmapped")
assert.Len(t, b.pkts[0], 1)
assert.Equal(t, 1, cap(b.pkts[0]))
assert.Len(t, b.pkts[1], MTU)
require.NoError(t, valid().parse(0))
for _, tc := range []struct {
name string
n int
mutate func(*rxBatch)
}{
{"count past headers", msgx.Batch + 1, func(*rxBatch) {}},
{"datalen past buffer", 2, func(b *rxBatch) { b.hdrs[1].Datalen = MTU + 1 }},
{"unknown family", 2, func(b *rxBatch) { b.names[0].Family = unix.AF_UNIX }},
{"family and length disagree", 2, func(b *rxBatch) { b.hdrs[0].Namelen = unix.SizeofSockaddrInet6 }},
} {
t.Run(tc.name, func(t *testing.T) {
b := valid()
tc.mutate(b)
assert.Error(t, b.parse(tc.n))
})
}
}
func TestMsghdrXKernelRoundTrip(t *testing.T) {
for _, v6 := range []bool{false, true} {
t.Run(fmt.Sprintf("v6=%v", v6), func(t *testing.T) {
// Loopback delivery goes through the dlil input thread, so the settle gives all three time to
// queue and come back from one call, which is what exercises the stride.
got := recvmsgXRoundTrip(t, v6, []int{1, 300, 1400}, 4, 50*time.Millisecond)
assert.Equal(t, 3, got, "largest batch from one recvmsg_x call")
})
}
}
// Any burst, of any datagram lengths up to the kernel's maxdgram, into any number of headers, comes back in order
// with every entry's fields intact, and headers past the returned count untouched.
func FuzzMsghdrXKernelRoundTrip(f *testing.F) {
f.Add(false, uint8(3), []byte{0, 1, 1, 44, 5, 120})
f.Add(true, uint8(0), []byte{0, 0, 0x23, 0x29}) // one empty datagram, then one at MTU
f.Add(false, uint8(1), []byte{0x23, 0x2a, 0x24, 0x00, 0}) // past MTU: cut to MTU, no MSG_TRUNC
f.Add(true, uint8(msgx.Batch-1), bytes.Repeat([]byte{0x05, 0xdc}, msgx.Batch))
f.Fuzz(func(t *testing.T, v6 bool, spare uint8, sizes []byte) {
// Two bytes per datagram, big-endian, folded into [0, maxdgram].
var lens []int
for i := 0; i+1 < len(sizes) && len(lens) < msgx.Batch; i += 2 {
lens = append(lens, (int(sizes[i])<<8|int(sizes[i+1]))%(maxDgram+1))
}
if len(lens) == 0 {
return
}
recvmsgXRoundTrip(t, v6, lens, 1+int(spare)%msgx.Batch, time.Millisecond)
})
}
// maxDgram is darwin's default net.inet.udp.maxdgram, the largest datagram a loopback sender may write.
const maxDgram = 9216
// recvmsgXRoundTrip sends one datagram per entry of lens to a fresh loopback socket, drains them with recvmsg_x
// into nh headers, and checks every field the kernel writes. Neighboring datagrams differ in sender, length and
// fill byte, so no field can pass by reading a neighbor's value. It returns the largest batch one call returned.
func recvmsgXRoundTrip(t *testing.T, v6 bool, lens []int, nh int, settle time.Duration) int {
t.Helper()
network, lo := "udp4", netip.MustParseAddr("127.0.0.1")
if v6 {
network, lo = "udp6", netip.IPv6Loopback()
}
rx, err := net.ListenUDP(network, net.UDPAddrFromAddrPort(netip.AddrPortFrom(lo, 0)))
require.NoError(t, err)
defer rx.Close()
txs := make([]*net.UDPConn, 3)
for i := range txs {
txs[i], err = net.DialUDP(network, nil, rx.LocalAddr().(*net.UDPAddr))
require.NoError(t, err)
defer txs[i].Close()
}
senders := make([]netip.AddrPort, len(lens))
for i, l := range lens {
tx := txs[i%len(txs)]
senders[i] = tx.LocalAddr().(*net.UDPAddr).AddrPort()
_, err := tx.Write(bytes.Repeat([]byte{byte(i + 1)}, l))
require.NoError(t, err)
}
time.Sleep(settle)
// Namelen goes in as the v6 size on both families, so the v4 size coming back proves the kernel wrote it.
const sentinel = 0xa5a5a5a5a5a5a5a5
wantNamelen := uint32(unix.SizeofSockaddrInet4)
if v6 {
wantNamelen = unix.SizeofSockaddrInet6
}
bufs := make([][]byte, nh)
names := make([]unix.RawSockaddrInet6, nh)
iovs := make([]unix.Iovec, nh)
hdrs := make([]msgx.Hdr, nh)
for i := range hdrs {
bufs[i] = make([]byte, MTU)
iovs[i].Base = &bufs[i][0]
iovs[i].SetLen(MTU)
}
// A datagram dropped on loopback would otherwise block rc.Read forever.
require.NoError(t, rx.SetReadDeadline(time.Now().Add(5*time.Second)))
rc, err := rx.SyscallConn()
require.NoError(t, err)
largest := 0
for next := 0; next < len(lens); {
for i := range hdrs {
clear(bufs[i])
hdrs[i] = msgx.Hdr{
Name: (*byte)(unsafe.Pointer(&names[i])),
Namelen: unix.SizeofSockaddrInet6,
Iov: &iovs[i],
Iovlen: 1,
Flags: -1,
Datalen: sentinel,
}
}
var n int
var errno syscall.Errno
require.NoError(t, rc.Read(func(fd uintptr) bool {
n, errno = msgx.Recv(fd, hdrs)
return errno != unix.EAGAIN
}), "received %d of %d datagrams", next, len(lens))
require.Zero(t, errno)
require.Positive(t, n)
require.LessOrEqual(t, n, min(nh, len(lens)-next))
largest = max(largest, n)
b := &rxBatch{buf: make([]byte, n*MTU)}
copy(b.hdrs[:], hdrs[:n])
copy(b.names[:], names[:n])
require.NoError(t, b.parse(n), "ListenOut would fall back on this batch")
for i := range n {
d := next + i
h := &hdrs[i]
want := min(lens[d], MTU)
require.EqualValues(t, want, h.Datalen, "datagram %d Datalen", d)
require.Equal(t, wantNamelen, h.Namelen, "datagram %d Namelen", d)
require.Equal(t, senders[d], b.addrs[i], "datagram %d sender", d)
// Flags goes in as -1 and must come back 0. xnu's list receive (soreceive_m_list) never sets
// MSG_TRUNC, so a datagram past MTU arrives silently cut to MTU, as recvfrom through net.UDPConn does.
require.Zero(t, h.Flags, "datagram %d Flags", d)
require.Equal(t, bytes.Repeat([]byte{byte(d + 1)}, want), bufs[i][:want], "datagram %d payload", d)
if want < MTU {
require.Zero(t, bufs[i][want], "datagram %d wrote past Datalen", d)
}
}
for i := n; i < nh; i++ {
require.EqualValues(t, uint64(sentinel), hdrs[i].Datalen, "spare header %d Datalen", i)
require.EqualValues(t, unix.SizeofSockaddrInet6, hdrs[i].Namelen, "spare header %d Namelen", i)
}
next += n
}
return largest
}
// Once a listener has batches to reuse, reading one allocates nothing, on recvmsg_x or on the fallback.
func TestReadDoesNotAllocate(t *testing.T) {
for _, single := range []bool{false, true} {
t.Run(fmt.Sprintf("single=%v", single), func(t *testing.T) {
noRecvX.Store(single)
t.Cleanup(func() { noRecvX.Store(false) })
c, err := NewListener(slog.New(slog.DiscardHandler), Settings{Listen: netip.MustParseAddrPort("127.0.0.1:0")})
require.NoError(t, err)
t.Cleanup(func() { _ = c.Close() })
u := c.(*StdConn)
la, err := c.LocalAddr()
require.NoError(t, err)
tx, err := net.DialUDP("udp4", nil, net.UDPAddrFromAddrPort(la))
require.NoError(t, err)
t.Cleanup(func() { _ = tx.Close() })
r := u.newBatchReader(u.UDPConn, u.rc)
pkt := []byte("steady")
allocs := testing.AllocsPerRun(100, func() {
if _, err := tx.Write(pkt); err != nil {
t.Fatal(err)
}
b, err := u.read(r)
if err != nil || b.n != 1 {
t.Fatalf("read %v: %v", b, err)
}
u.putBatch(b)
})
assert.Zero(t, allocs)
})
}
}