portlist: exercise Linux discovery backends with real sockets

Cover process attribution, loopback filtering, socket churn, transport
fallback and recovery, and namespace consistency. Reuse the existing
kernel-regression skip helper for live tests and leave namespace setup
to the caller. Probe all diagnostic handlers before tests depend on them,
skipping known capability failures such as missing UDP diagnostics.

Add warm and cold backend benchmarks with held TCP connections and
listener scaling. Assert that diagnostic polls do not silently fall back.

Updates #10430
Updates #15492

Signed-off-by: JeremiahM37 <[email protected]>
This commit is contained in:
JeremiahM37 authored and Brad Fitzpatrick committed 2026-09-14 19:16:36 -07:00
1 parent 343e2b2817
commit 3dd55d6928
2 files changed
+657

No files matched your search

+344
View File
@@ -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))
}
}
}
+313
View File
@@ -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)
}
}