mirror of
https://github.com/tailscale/tailscale.git
synced 2026-11-20 00:31:17 -08:00
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:
1 parent
343e2b2817
commit
3dd55d6928
2 files changed
+657
No files matched your search
@@ -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))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user