diff --git a/portlist/portlist_linux_bench_test.go b/portlist/portlist_linux_bench_test.go new file mode 100644 index 000000000..d926a31bb --- /dev/null +++ b/portlist/portlist_linux_bench_test.go @@ -0,0 +1,344 @@ +// Copyright (c) Tailscale Inc & contributors +// SPDX-License-Identifier: BSD-3-Clause + +//go:build linux && !android + +package portlist + +import ( + "fmt" + "net" + "os" + "path/filepath" + "runtime" + "sync" + "syscall" + "testing" +) + +// portFixture creates real sockets in the caller's network namespace. The +// runner invokes this benchmark under `unshare -n`; no host routes or sockets +// are touched. TCP pairs are accepted and held open, so the kernel has both +// LISTEN and ESTABLISHED entries while the poller runs. +type portFixture struct { + closers []net.Conn + listeners []net.Listener + packets []net.PacketConn + expected map[uint16]bool + mu sync.Mutex +} + +func (f *portFixture) close() { + f.mu.Lock() + closers := append([]net.Conn(nil), f.closers...) + f.mu.Unlock() + for _, c := range closers { + if tc, ok := c.(*net.TCPConn); ok { + _ = tc.SetLinger(0) + } + _ = c.Close() + } + for _, ln := range f.listeners { + _ = ln.Close() + } + for _, p := range f.packets { + _ = p.Close() + } +} + +func makePortFixture(t testing.TB, pairs int) *portFixture { + t.Helper() + f := &portFixture{expected: map[uint16]bool{}} + addTCP := func(network, listenAddr string) { + ln, err := net.Listen(network, listenAddr) + if err != nil { + t.Skipf("%s unavailable: %v", network, err) + } + f.listeners = append(f.listeners, ln) + f.expected[uint16(ln.Addr().(*net.TCPAddr).Port)] = true + accepted := make(chan struct{}, pairs) + go func() { + for { + c, err := ln.Accept() + if err != nil { + return + } + f.mu.Lock() + f.closers = append(f.closers, c) + f.mu.Unlock() + accepted <- struct{}{} + } + }() + for i := 0; i < pairs; i++ { + c, err := net.Dial(network, ln.Addr().String()) + if err != nil { + t.Fatalf("dial %s: %v", network, err) + } + f.mu.Lock() + f.closers = append(f.closers, c) + f.mu.Unlock() + } + for i := 0; i < pairs; i++ { + <-accepted + } + } + addTCP("tcp4", "127.0.0.1:0") + addTCP("tcp6", "[::1]:0") + for _, network := range []string{"udp4", "udp6"} { + for _, connected := range []bool{false, true} { + addr := "0.0.0.0:0" + peer := "127.0.0.1:9" + if network == "udp6" { + addr, peer = "[::]:0", "[::1]:9" + } + u, err := net.ListenPacket(network, addr) + if err != nil { + t.Skipf("%s unavailable: %v", network, err) + } + f.packets = append(f.packets, u) + f.expected[uint16(u.LocalAddr().(*net.UDPAddr).Port)] = true + if connected { + c, err := net.Dial(network, peer) + if err != nil { + t.Fatalf("dial %s: %v", network, err) + } + f.closers = append(f.closers, c) + } + } + } + return f +} + +func makeManyPortFixture(t testing.TB, pairs, extra int) *portFixture { + f := makePortFixture(t, pairs) + for i := 0; i < extra; i++ { + ln, err := net.Listen("tcp4", "127.0.0.1:0") + if err != nil { + t.Fatalf("extra listener: %v", err) + } + f.listeners = append(f.listeners, ln) + f.expected[uint16(ln.Addr().(*net.TCPAddr).Port)] = true + } + return f +} + +// pollerFor bypasses Poller's constructor so each implementation can be A/B'd +// in one process while retaining Poll's change detection and metadata path. +func pollerFor(impl osImpl) *Poller { + p := &Poller{IncludeLocalhost: true, os: impl} + p.initOnce.Do(func() {}) + return p +} + +func BenchmarkPortlistBackends(b *testing.B) { + if runtime.GOOS != "linux" { + b.Skip("Linux-only") + } + maybeSkip(b) + factories := []struct { + name string + factory func(bool) *linuxImpl + }{ + {"proc", func(include bool) *linuxImpl { return newLinuxImplWithDiag(include, false) }}, + {"diag", func(include bool) *linuxImpl { return newLinuxImplWithDiag(include, true) }}, + } + // Run both orderings. This matters on a shared machine because the first + // implementation can otherwise receive all cold page/cache effects. + for _, order := range [][]int{{0, 1}, {1, 0}} { + for _, pairs := range []int{0, 100, 500} { + for _, ix := range order { + tc := factories[ix] + b.Run(fmt.Sprintf("order%d/%s/pairs=%d", order[0], tc.name, pairs), func(b *testing.B) { + f := makePortFixture(b, pairs) + defer f.close() + impl := tc.factory(true) + if tc.name == "diag" { + defer impl.Close() + requireDiag(b, impl) + } + p := pollerFor(impl) + defer p.Close() + if _, _, err := p.Poll(); err != nil { + b.Fatal(err) + } // cold metadata pass + b.ReportAllocs() + var before, after syscall.Rusage + syscall.Getrusage(syscall.RUSAGE_SELF, &before) + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, _, err := p.Poll(); err != nil { + b.Fatal(err) + } + if tc.name == "diag" && (impl.diagFD < 0 || impl.diagPermanent) { + b.Fatal("diag benchmark fell back to proc") + } + } + b.StopTimer() + syscall.Getrusage(syscall.RUSAGE_SELF, &after) + used := after.Utime.Nano() + after.Stime.Nano() - before.Utime.Nano() - before.Stime.Nano() + b.ReportMetric(float64(used)/float64(b.N), "cpu-ns/op") + }) + } + } + for _, extra := range []int{16, 64} { + for _, tc := range factories { + b.Run(fmt.Sprintf("order%d/%s/listeners=%d", order[0], tc.name, extra), func(b *testing.B) { + f := makeManyPortFixture(b, 0, extra) + defer f.close() + impl := tc.factory(true) + if tc.name == "diag" { + defer impl.Close() + requireDiag(b, impl) + } + p := pollerFor(impl) + defer p.Close() + if _, _, err := p.Poll(); err != nil { + b.Fatal(err) + } + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + if _, _, err := p.Poll(); err != nil { + b.Fatal(err) + } + if tc.name == "diag" && (impl.diagFD < 0 || impl.diagPermanent) { + b.Fatal("diag listener benchmark fell back to proc") + } + } + }) + } + } + } +} + +// Cold includes construction, the first kernel dump, and first process-name +// attribution. Fixture setup is outside the timer; each iteration constructs a +// fresh poller against the same fixed sockets. +func BenchmarkPortlistCold(b *testing.B) { + maybeSkip(b) + for _, tc := range []struct { + name string + diag bool + }{{"proc", false}, {"diag", true}} { + b.Run(tc.name, func(b *testing.B) { + f := makePortFixture(b, 0) + defer f.close() + if tc.diag { + func() { + probe := newLinuxImplWithDiag(true, true) + defer probe.Close() + requireDiag(b, probe) + }() + } + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + impl := newLinuxImplWithDiag(true, tc.diag) + p := pollerFor(impl) + if _, _, err := p.Poll(); err != nil { + b.Fatal(err) + } + if tc.diag && (impl.diagFD < 0 || impl.diagPermanent) { + b.Fatal("diag cold benchmark fell back to proc") + } + p.Close() + } + }) + } +} + +func TestPortlistBackendParity(t *testing.T) { + maybeSkip(t) + f := makePortFixture(t, 8) + defer f.close() + proc := pollerFor(newLinuxImplWithDiag(true, false)) + defer proc.Close() + diagImpl := newLinuxImplWithDiag(true, true) + defer diagImpl.Close() + requireDiag(t, diagImpl) + diag := pollerFor(diagImpl) + defer diag.Close() + a, _, err := proc.Poll() + if err != nil { + t.Fatal(err) + } + b, _, err := diag.Poll() + if err != nil { + t.Fatal(err) + } + if diagImpl.diagFD < 0 || diagImpl.diagPermanent { + t.Fatal("diag parity poll fell back to proc") + } + // A second pass exercises the warmed inode -> process metadata path. Poll + // returns nil when unchanged, so retain the first result for comparison. + if _, _, err = diag.Poll(); err != nil { + t.Fatal(err) + } + stableFixture := func(in []Port) map[string]bool { + out := map[string]bool{} + for _, p := range in { + if f.expected[p.Port] { + out[fmt.Sprintf("%s/%d", p.Proto, p.Port)] = true + } + } + return out + } + if fmt.Sprint(stableFixture(a)) != fmt.Sprint(stableFixture(b)) { + t.Fatalf("proc/diag mismatch: proc=%v diag=%v", stableFixture(a), stableFixture(b)) + } + full := func(in []Port) map[string]Port { + out := map[string]Port{} + for _, p := range in { + if f.expected[p.Port] { + out[fmt.Sprintf("%s/%d", p.Proto, p.Port)] = p + } + } + return out + } + for k, p := range full(a) { + q, ok := full(b)[k] + if !ok || p.Process != q.Process || p.Pid != q.Pid { + t.Errorf("full parity %s: proc=%+v diag=%+v", k, p, q) + } + if p.Pid != os.Getpid() || p.Process != filepath.Base(os.Args[0]) { + t.Errorf("unexpected fixture owner %s: %+v", k, p) + } + } + if len(full(a)) != len(f.expected) { + t.Fatalf("proc did not report every fixture socket: got %d want %d", len(full(a)), len(f.expected)) + } +} + +func TestPortlistBackendChurn(t *testing.T) { + maybeSkip(t) + for _, diag := range []bool{false, true} { + f := makePortFixture(t, 4) + defer f.close() + li := newLinuxImplWithDiag(true, diag) + defer li.Close() + if diag { + requireDiag(t, li) + } + before, err := li.AppendListeningPorts(nil) + if err != nil { + t.Fatal(err) + } + if diag && (li.diagFD < 0 || li.diagPermanent) { + t.Fatal("diag churn poll fell back to proc") + } + if len(before) == 0 { + t.Fatal("empty initial listing") + } + _ = f.listeners[0].Close() + after, err := li.AppendListeningPorts(nil) + if err != nil { + t.Fatal(err) + } + if diag && (li.diagFD < 0 || li.diagPermanent) { + t.Fatal("diag churn poll fell back to proc") + } + if len(after) >= len(before) { + t.Fatalf("churn did not remove listener: before=%d after=%d", len(before), len(after)) + } + } +} diff --git a/portlist/portlist_linux_integration_test.go b/portlist/portlist_linux_integration_test.go new file mode 100644 index 000000000..4b8244a33 --- /dev/null +++ b/portlist/portlist_linux_integration_test.go @@ -0,0 +1,313 @@ +// Copyright (c) Tailscale Inc & contributors +// SPDX-License-Identifier: BSD-3-Clause + +//go:build linux && !android + +package portlist + +import ( + "errors" + "fmt" + "net" + "os" + "os/exec" + "runtime" + "strings" + "testing" + + "github.com/google/go-cmp/cmp" + "golang.org/x/sys/unix" +) + +// requireDiag verifies the complete diagnostic path before a test relies on +// it. Constructor state alone cannot detect a kernel that lacks one of the +// requested protocol handlers (notably UDP). +func requireDiag(tb testing.TB, li *linuxImpl) { + tb.Helper() + if li.diagPermanent { + tb.Skip("inet_diag unavailable in this environment") + } + if err := li.appendDiagPorts(); err != nil { + if isDiagCapabilityError(err) { + tb.Skipf("inet_diag unavailable in this environment: %v", err) + } + tb.Fatalf("inet_diag capability probe failed: %v", err) + } + if li.diagFD < 0 || li.diagPermanent { + tb.Fatalf("inet_diag capability probe returned without a usable socket: fd=%d permanent=%v", li.diagFD, li.diagPermanent) + } +} + +func TestProcConstructionDoesNotOpenDiagSocket(t *testing.T) { + li := newLinuxImplWithDiag(true, false) + defer li.Close() + if li.diagFD != -1 { + t.Fatalf("proc-only construction opened diagnostic fd %d", li.diagFD) + } +} + +func TestDiagControlledListenerParity(t *testing.T) { + maybeSkip(t) + ln, err := net.Listen("tcp4", "0.0.0.0:0") + if err != nil { + t.Skipf("IPv4 listener unavailable: %v", err) + } + defer ln.Close() + port := uint16(ln.Addr().(*net.TCPAddr).Port) + + proc := newLinuxImplWithDiag(true, false) + defer proc.Close() + diag := newLinuxImplWithDiag(true, true) + defer diag.Close() + requireDiag(t, diag) + + pick := func(li *linuxImpl) Port { + ports, err := li.AppendListeningPorts(nil) + if err != nil { + t.Fatalf("listing ports: %v", err) + } + for _, p := range ports { + if p.Proto == "tcp" && p.Port == port { + return p + } + } + t.Fatalf("controlled TCP listener port %d absent from %+v", port, ports) + return Port{} + } + + gotProc := pick(proc) + gotDiag := pick(diag) + if diff := cmp.Diff(gotDiag, gotProc); diff != "" { + t.Fatalf("diag/proc controlled listener mismatch (-diag +proc):\n%s", diff) + } +} + +func TestDiagLoopbackFalseParity(t *testing.T) { + maybeSkip(t) + ln, err := net.Listen("tcp4", "127.0.0.1:0") + if err != nil { + t.Skipf("IPv4 loopback listener unavailable: %v", err) + } + defer ln.Close() + port := uint16(ln.Addr().(*net.TCPAddr).Port) + + proc := newLinuxImplWithDiag(false, false) + defer proc.Close() + diag := newLinuxImplWithDiag(false, true) + defer diag.Close() + requireDiag(t, diag) + ports := func(li *linuxImpl) []Port { + got, err := li.AppendListeningPorts(nil) + if err != nil { + t.Fatalf("listing ports: %v", err) + } + return got + } + for _, p := range ports(proc) { + if p.Port == port { + t.Fatalf("proc path included localhost port %d with IncludeLocalhost=false", port) + } + } + for _, p := range ports(diag) { + if p.Port == port { + t.Fatalf("diag path included localhost port %d with IncludeLocalhost=false", port) + } + } +} + +func TestDiagFallbackRecovery(t *testing.T) { + maybeSkip(t) + ln, err := net.Listen("tcp4", "0.0.0.0:0") + if err != nil { + t.Fatalf("fixture listener: %v", err) + } + defer ln.Close() + port := uint16(ln.Addr().(*net.TCPAddr).Port) + + li := newLinuxImplWithDiag(true, true) + defer li.Close() + requireDiag(t, li) + if _, err := li.AppendListeningPorts(nil); err != nil { + t.Fatalf("initial diag poll: %v", err) + } + var want Port + for _, p := range li.known { + if p.port.Proto == "tcp" && p.port.Port == port { + want = p.port + } + } + if want.Port == 0 { + t.Fatalf("fixture listener absent from initial diag result") + } + + // Replace the socket atomically with a non-socket while preserving its fd + // number. This makes the transient failure deterministic without leaving a + // close/reopen window in which another descriptor could reuse the number. + badFD, err := unix.Open("/dev/null", unix.O_RDONLY|unix.O_CLOEXEC, 0) + if err != nil { + t.Fatalf("open fallback fixture: %v", err) + } + if err := unix.Dup3(badFD, li.diagFD, 0); err != nil { + unix.Close(badFD) + t.Fatalf("replace diag fixture fd: %v", err) + } + if err := unix.Close(badFD); err != nil { + t.Fatalf("close fallback fixture: %v", err) + } + got, err := li.AppendListeningPorts(nil) + if err != nil { + t.Fatalf("proc fallback poll: %v", err) + } + if li.diagFD != -1 { + t.Fatalf("failed diagnostic socket was not closed after fallback: fd=%d", li.diagFD) + } + var fallback Port + for _, p := range got { + if p.Proto == "tcp" && p.Port == port { + fallback = p + } + } + if diff := cmp.Diff(fallback, want); diff != "" { + t.Fatalf("fallback record mismatch (-fallback +initial):\n%s", diff) + } + + // A transient transport failure must recover on the next poll in the same + // namespace; remaining on proc fallback forever defeats the replacement. + got, err = li.AppendListeningPorts(nil) + if err != nil { + t.Fatalf("recovery poll: %v", err) + } + if li.diagFD < 0 || li.diagPermanent { + t.Fatalf("diag did not recover after fallback: fd=%d permanent=%v", li.diagFD, li.diagPermanent) + } + _ = got +} + +func TestDiagNamespaceMismatchFallback(t *testing.T) { + maybeSkip(t) + const childEnv = "PORTLIST_NAMESPACE_MISMATCH_CHILD=1" + if os.Getenv("PORTLIST_NAMESPACE_MISMATCH_CHILD") != "1" { + cmd := exec.Command(os.Args[0], "-test.run=^TestDiagNamespaceMismatchFallback$", "-test.v") + cmd.Env = append(os.Environ(), childEnv) + out, err := cmd.CombinedOutput() + if err != nil { + t.Fatalf("namespace child failed: %v\n%s", err, out) + } + if strings.Contains(string(out), "--- SKIP:") { + t.Skipf("namespace child skipped: %s", out) + } + t.Logf("namespace child: %s", out) + return + } + + ln, err := net.Listen("tcp4", "0.0.0.0:0") + if err != nil { + t.Skipf("IPv4 listener unavailable: %v", err) + } + defer ln.Close() + port := uint16(ln.Addr().(*net.TCPAddr).Port) + orig, err := unix.Open("/proc/self/ns/net", unix.O_RDONLY|unix.O_CLOEXEC, 0) + if err != nil { + t.Skipf("cannot open original network namespace: %v", err) + } + defer unix.Close(orig) + type result struct { + err error + skip bool + contaminated bool + } + check := func() result { + pinned := newLinuxImplWithDiag(true, true) + defer pinned.Close() + if pinned.diagPermanent { + return result{err: errors.New("inet_diag unavailable in constructor"), skip: true} + } + if err := pinned.appendDiagPorts(); err != nil { + return result{err: err, skip: isDiagCapabilityError(err)} + } + if err := unix.Unshare(unix.CLONE_NEWNET); err != nil { + return result{err: err, skip: errors.Is(err, unix.EPERM) || errors.Is(err, unix.EINVAL) || errors.Is(err, unix.ENOSYS)} + } + var testErr error + // A healthy socket keeps its original namespace even when its caller + // moves. After closing it, reopening in the foreign namespace must be + // refused, leaving the pinned proc files as the complete fallback. + if err := pinned.appendDiagPorts(); err != nil { + testErr = fmt.Errorf("poll pinned socket after namespace switch: %w", err) + } + pinned.closeDiag() + if _, err := pinned.AppendListeningPorts(nil); err != nil { + testErr = fmt.Errorf("fallback after namespace switch: %w", err) + } else if pinned.diagFD != -1 { + testErr = errors.New("reopened diagnostic socket in foreign namespace") + } + li := newLinuxImplWithDiag(true, true) + if !li.diagPermanent { + testErr = errors.New("constructor did not disable inet_diag for differing proc/thread namespaces") + } else { + ports, err := li.AppendListeningPorts(nil) + if err != nil { + testErr = fmt.Errorf("proc fallback after namespace mismatch: %w", err) + } else { + found := false + for _, p := range ports { + if p.Proto == "tcp" && p.Port == port { + found = true + break + } + } + if !found { + testErr = fmt.Errorf("proc fallback lost listener from process-leader namespace: port %d, got %v", port, ports) + } + } + } + li.Close() + // A setns on a locked worker must be undone before the thread is + // returned to the runtime, otherwise a later test can inherit it. + if err := unix.Setns(orig, unix.CLONE_NEWNET); err != nil { + return result{err: fmt.Errorf("restore original network namespace: %w", err), contaminated: true} + } + if err := pinned.appendDiagPorts(); err != nil && testErr == nil { + testErr = fmt.Errorf("reopen in original namespace: %w", err) + } + return result{err: testErr} + } + + // If this test goroutine is already on a non-leader thread, it can switch + // directly. Otherwise hold the leader thread while a locked worker runs the + // check; this makes the two proc namespace views differ deterministically. + runtime.LockOSThread() + if unix.Gettid() != os.Getpid() { + res := check() + if !res.contaminated { + runtime.UnlockOSThread() + } + if res.skip { + t.Skipf("network namespace switching unavailable: %v", res.err) + } + if res.err != nil { + t.Fatal(res.err) + } + return + } + done := make(chan result, 1) + go func() { + runtime.LockOSThread() + res := check() + done <- res + // check restores the worker's namespace before returning. Keep this + // lock until after the result is published so the thread cannot be + // reused in the transient namespace. + if !res.contaminated { + runtime.UnlockOSThread() + } + }() + res := <-done + runtime.UnlockOSThread() + if res.skip { + t.Skipf("network namespace switching unavailable: %v", res.err) + } + if res.err != nil { + t.Fatal(res.err) + } +}