mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-16 09:06:52 +01:00
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
5bcceac53c | ||
|
|
afbdc87ed9 |
No files matched your search
@@ -14,7 +14,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: Build
|
||||
@@ -40,7 +40,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: Build
|
||||
@@ -83,7 +83,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
# GitHub holds ARNs, not credentials, and ARNs outlive a rotation
|
||||
|
||||
@@ -34,7 +34,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: add hashicorp source
|
||||
@@ -66,7 +66,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: add hashicorp source
|
||||
@@ -92,7 +92,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
# WSL2 + Ubuntu so the smoke can run a real linux peer with its own
|
||||
|
||||
@@ -22,7 +22,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: Smoke Docker
|
||||
@@ -51,7 +51,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: build
|
||||
|
||||
@@ -22,7 +22,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: Install goimports
|
||||
@@ -42,7 +42,7 @@ jobs:
|
||||
- name: golangci-lint
|
||||
uses: golangci/golangci-lint-action@v9
|
||||
with:
|
||||
version: v2.12
|
||||
version: v2.14
|
||||
|
||||
test:
|
||||
name: Test ${{ matrix.name }}
|
||||
@@ -87,7 +87,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: Build
|
||||
@@ -132,7 +132,7 @@ jobs:
|
||||
|
||||
- uses: actions/setup-go@v7
|
||||
with:
|
||||
go-version: '1.26'
|
||||
go-version: '1.27'
|
||||
check-latest: true
|
||||
|
||||
- name: Build ${{ matrix.name }}
|
||||
|
||||
@@ -1,75 +0,0 @@
|
||||
//go:build linux && !android && !e2e_testing
|
||||
|
||||
package cpupick
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"strconv"
|
||||
"unsafe"
|
||||
|
||||
"golang.org/x/sys/unix"
|
||||
)
|
||||
|
||||
// Avoid removes cpus from the affinity of every thread of the process, for use at startup. New threads inherit
|
||||
// their parent's mask, so it repeats until a pass finds nothing left to change; a thread that exits meanwhile is
|
||||
// skipped. Every mask is checked before any is changed. With apply false it only validates, for configuration tests.
|
||||
// This affects the entire process, including other users of an embedded Nebula. Not wired up yet: tun.avoid_cpus
|
||||
// only steers Default for now.
|
||||
func Avoid(cpus []int, apply bool) error {
|
||||
const capacity = int(unsafe.Sizeof(unix.CPUSet{})) * 8
|
||||
for _, cpu := range cpus {
|
||||
if cpu < 0 || cpu >= capacity {
|
||||
return fmt.Errorf("CPU %d is out of range", cpu)
|
||||
}
|
||||
}
|
||||
if len(cpus) == 0 {
|
||||
return nil
|
||||
}
|
||||
for {
|
||||
masks, err := avoidingMasks(cpus)
|
||||
if err != nil || !apply || len(masks) == 0 {
|
||||
return err
|
||||
}
|
||||
for tid, mask := range masks {
|
||||
if err := unix.SchedSetaffinity(tid, &mask); err != nil && !errors.Is(err, unix.ESRCH) {
|
||||
return fmt.Errorf("set thread %d affinity: %w", tid, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// avoidingMasks returns the mask without cpus of every thread whose mask has any of them.
|
||||
func avoidingMasks(cpus []int) (map[int]unix.CPUSet, error) {
|
||||
entries, err := os.ReadDir("/proc/self/task")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
masks := make(map[int]unix.CPUSet, len(entries))
|
||||
for _, entry := range entries {
|
||||
tid, err := strconv.Atoi(entry.Name())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var mask unix.CPUSet
|
||||
err = unix.SchedGetaffinity(tid, &mask)
|
||||
if errors.Is(err, unix.ESRCH) {
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read thread %d affinity: %w", tid, err)
|
||||
}
|
||||
next := mask
|
||||
for _, cpu := range cpus {
|
||||
next.Clear(cpu)
|
||||
}
|
||||
if next.Count() == 0 {
|
||||
return nil, fmt.Errorf("avoid_cpus leaves thread %d with no allowed CPU", tid)
|
||||
}
|
||||
if next != mask {
|
||||
masks[tid] = next
|
||||
}
|
||||
}
|
||||
return masks, nil
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
//go:build linux && !android && !e2e_testing
|
||||
|
||||
package cpupick
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"os/exec"
|
||||
"runtime"
|
||||
"strconv"
|
||||
"sync"
|
||||
"testing"
|
||||
"unsafe"
|
||||
|
||||
"github.com/slackhq/nebula/util"
|
||||
"github.com/stretchr/testify/require"
|
||||
"golang.org/x/sys/unix"
|
||||
)
|
||||
|
||||
// TestAvoid changes the affinity of the whole process, so it runs in a child, leaving the test runner untouched.
|
||||
func TestAvoid(t *testing.T) {
|
||||
if os.Getenv("NEBULA_CPUPICK_AVOID_TEST") != "1" {
|
||||
exe, err := os.Executable()
|
||||
require.NoError(t, err)
|
||||
cmd := exec.Command(exe, "-test.run=^TestAvoid$", "-test.v")
|
||||
cmd.Env = append(os.Environ(), "NEBULA_CPUPICK_AVOID_TEST=1")
|
||||
out, err := cmd.CombinedOutput()
|
||||
require.NoError(t, err, "%s", out)
|
||||
return
|
||||
}
|
||||
allowed, err := util.AllowedCPUs()
|
||||
require.NoError(t, err)
|
||||
if len(allowed) < 2 {
|
||||
t.Skip("requires at least two allowed CPUs")
|
||||
}
|
||||
cpu := allowed[0]
|
||||
release := make(chan struct{})
|
||||
var wg sync.WaitGroup
|
||||
// lockThreads occupies 8 OS threads until release, so the runtime has to start more
|
||||
lockThreads := func() {
|
||||
var ready sync.WaitGroup
|
||||
for range 8 {
|
||||
ready.Add(1)
|
||||
wg.Go(func() {
|
||||
runtime.LockOSThread()
|
||||
ready.Done()
|
||||
<-release
|
||||
})
|
||||
}
|
||||
ready.Wait()
|
||||
}
|
||||
lockThreads()
|
||||
|
||||
require.NoError(t, Avoid([]int{cpu}, false))
|
||||
after, err := util.AllowedCPUs()
|
||||
require.NoError(t, err)
|
||||
require.Equal(t, allowed, after, "configuration check must not mutate affinity")
|
||||
require.Error(t, Avoid(allowed, true), "must reject an empty mask before applying")
|
||||
require.NoError(t, Avoid([]int{cpu, cpu}, true))
|
||||
requireAvoided(t, cpu, allowed)
|
||||
// Existing threads stay locked while new ones inherit the restriction
|
||||
lockThreads()
|
||||
requireAvoided(t, cpu, allowed)
|
||||
close(release)
|
||||
wg.Wait()
|
||||
}
|
||||
|
||||
// requireAvoided checks no thread may run on cpu, and every thread still may on some CPU of allowed only.
|
||||
func requireAvoided(t *testing.T, cpu int, allowed []int) {
|
||||
t.Helper()
|
||||
entries, err := os.ReadDir("/proc/self/task")
|
||||
require.NoError(t, err)
|
||||
for _, entry := range entries {
|
||||
tid, err := strconv.Atoi(entry.Name())
|
||||
require.NoError(t, err)
|
||||
var mask unix.CPUSet
|
||||
err = unix.SchedGetaffinity(tid, &mask)
|
||||
if err == unix.ESRCH {
|
||||
continue
|
||||
}
|
||||
require.NoError(t, err)
|
||||
require.False(t, mask.IsSet(cpu), "thread %d", tid)
|
||||
require.Positive(t, mask.Count())
|
||||
for id := range len(mask) * 64 {
|
||||
if mask.IsSet(id) {
|
||||
require.Contains(t, allowed, id, "must not widen the inherited mask")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestAvoidRange checks the bounds of unix.CPUSet, whose words are 32 bits wide on 32-bit platforms.
|
||||
func TestAvoidRange(t *testing.T) {
|
||||
capacity := int(unsafe.Sizeof(unix.CPUSet{})) * 8
|
||||
require.NoError(t, Avoid([]int{capacity - 1}, false))
|
||||
require.EqualError(t, Avoid([]int{capacity}, false), fmt.Sprintf("CPU %d is out of range", capacity))
|
||||
require.EqualError(t, Avoid([]int{-1}, false), "CPU -1 is out of range")
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
//go:build !linux || android || e2e_testing
|
||||
|
||||
package cpupick
|
||||
|
||||
import "errors"
|
||||
|
||||
// Avoid is unsupported outside Linux: there is no thread affinity API to restrict.
|
||||
func Avoid(_ []int, _ bool) error { return errors.ErrUnsupported }
|
||||
+6
-17
@@ -16,15 +16,10 @@
|
||||
// across distinct physical cores when the topology permits, CPU 0's physical
|
||||
// core demoted to last resort, and the order rotated by a stable per-instance
|
||||
// key so co-located instances spread instead of stacking.
|
||||
//
|
||||
// CPUs the operator asked to keep readers off (tun.avoid_cpus, typically the
|
||||
// underlay NIC's receive IRQ CPUs) are removed from the allowed set before
|
||||
// any of that, so no rule can bring one back.
|
||||
package cpupick
|
||||
|
||||
import (
|
||||
"log/slog"
|
||||
"slices"
|
||||
|
||||
"github.com/slackhq/nebula/util"
|
||||
)
|
||||
@@ -62,17 +57,12 @@ func flatTopology(cpus []int) topology {
|
||||
// Default computes the pin order for `routines` tun readers. key is any
|
||||
// stable per-instance value; the bound UDP port is ideal — distinct across
|
||||
// co-located instances, stable across restarts so benchmark runs stay
|
||||
// comparable. avoid lists CPUs never to return, matched literally. Returns
|
||||
// nil when there is nothing useful to say (no affinity support on this
|
||||
// platform, lookup failure, avoid covering every allowed CPU); callers keep
|
||||
// their existing fallback spread.
|
||||
func Default(routines int, key uint64, avoid []int, l *slog.Logger) []int {
|
||||
// comparable. Returns nil when there is nothing useful to say (no affinity
|
||||
// support on this platform, lookup failure); callers keep their existing
|
||||
// fallback spread.
|
||||
func Default(routines int, key uint64, l *slog.Logger) []int {
|
||||
allowed, err := util.AllowedCPUs()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
allowed = slices.DeleteFunc(allowed, func(c int) bool { return slices.Contains(avoid, c) })
|
||||
if len(allowed) == 0 {
|
||||
if err != nil || len(allowed) == 0 {
|
||||
return nil
|
||||
}
|
||||
perf, signal := perfCPUs(allowed)
|
||||
@@ -87,8 +77,7 @@ func Default(routines int, key uint64, avoid []int, l *slog.Logger) []int {
|
||||
if l != nil {
|
||||
l.Info("chose default pin CPUs for tun readers",
|
||||
"cpus", cpus[:min(routines, len(cpus))],
|
||||
"perfSignal", signal,
|
||||
"avoided", avoid)
|
||||
"perfSignal", signal)
|
||||
}
|
||||
return cpus
|
||||
}
|
||||
|
||||
@@ -1,35 +0,0 @@
|
||||
//go:build linux && !android && !e2e_testing
|
||||
|
||||
package cpupick
|
||||
|
||||
import (
|
||||
"slices"
|
||||
"testing"
|
||||
|
||||
"github.com/slackhq/nebula/util"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestDefaultSkipsAvoided(t *testing.T) {
|
||||
allowed, err := util.AllowedCPUs()
|
||||
require.NoError(t, err)
|
||||
if len(allowed) < 2 {
|
||||
t.Skip("requires at least two allowed CPUs")
|
||||
}
|
||||
avoid := allowed[:len(allowed)/2]
|
||||
for key := range uint64(16) {
|
||||
got := Default(len(allowed), key, avoid, nil)
|
||||
require.NotEmpty(t, got)
|
||||
for _, cpu := range got {
|
||||
assert.NotContains(t, avoid, cpu, "key %d", key)
|
||||
assert.Contains(t, allowed, cpu, "key %d", key)
|
||||
}
|
||||
}
|
||||
assert.Nil(t, Default(2, 0, allowed, nil), "avoiding everything leaves nothing to suggest")
|
||||
|
||||
// Without avoid every allowed CPU stays in play
|
||||
got := Default(len(allowed), 0, nil, nil)
|
||||
slices.Sort(got)
|
||||
assert.Equal(t, allowed, got)
|
||||
}
|
||||
@@ -295,15 +295,6 @@ tun:
|
||||
# - 2
|
||||
# - 4
|
||||
|
||||
# Linux only. avoid_cpus lists CPU IDs the tun readers are never pinned to, exactly as listed (SMT siblings are not
|
||||
# added for you). The default pin selection skips them, and a cpu_affinity entry naming one is rejected like any
|
||||
# other invalid entry. Other threads are not restricted, and the setting does nothing with pin_threads: false. An
|
||||
# invalid list, or one covering every allowed CPU, is ignored with a warning. Not reloadable. To keep Nebula off the
|
||||
# underlay NIC's receive IRQ CPUs, find them in /proc/interrupts and /proc/irq/<IRQ>/effective_affinity_list, add
|
||||
# their SMT siblings from /sys/devices/system/cpu/cpu<N>/topology/thread_siblings_list if you want those kept clear
|
||||
# too, and revisit the list when IRQ placement changes.
|
||||
#avoid_cpus: []
|
||||
|
||||
# Route based MTU overrides, you have known vpn ip paths that can support larger MTUs you can increase/decrease them here
|
||||
routes:
|
||||
#- mtu: 8800
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
module github.com/slackhq/nebula
|
||||
|
||||
go 1.26.0
|
||||
go 1.27.2
|
||||
|
||||
require (
|
||||
dario.cat/mergo v1.0.2
|
||||
@@ -33,7 +33,7 @@ require (
|
||||
golang.zx2c4.com/wireguard/windows v1.0.1
|
||||
google.golang.org/protobuf v1.36.12
|
||||
gopkg.in/yaml.v3 v3.0.1
|
||||
gvisor.dev/gvisor v0.0.0-20240423190808-9d7a357edefe
|
||||
gvisor.dev/gvisor v0.0.0-20261014193016-04d31b385980
|
||||
)
|
||||
|
||||
require (
|
||||
@@ -45,5 +45,6 @@ require (
|
||||
github.com/prometheus/common v0.70.1 // indirect
|
||||
github.com/prometheus/procfs v0.21.1 // indirect
|
||||
github.com/vishvananda/netns v0.0.5 // indirect
|
||||
golang.org/x/time v0.5.0 // indirect
|
||||
golang.org/x/exp v0.0.0-20250711185948-6ae5c78190dc // indirect
|
||||
golang.org/x/time v0.15.0 // indirect
|
||||
)
|
||||
@@ -157,6 +157,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh
|
||||
golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
|
||||
golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
|
||||
golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
|
||||
golang.org/x/exp v0.0.0-20250711185948-6ae5c78190dc h1:TS73t7x3KarrNd5qAipmspBDS1rkMcgVG/fS1aRb4Rc=
|
||||
golang.org/x/exp v0.0.0-20250711185948-6ae5c78190dc/go.mod h1:A+z0yzpGtvnG90cToK5n2tu8UJVP2XUATh+r+sfOOOc=
|
||||
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
|
||||
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
|
||||
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
|
||||
@@ -203,8 +205,8 @@ golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
|
||||
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
|
||||
golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
|
||||
golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
|
||||
golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
|
||||
golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
|
||||
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
|
||||
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
|
||||
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
|
||||
@@ -243,5 +245,5 @@ gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
|
||||
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
gvisor.dev/gvisor v0.0.0-20240423190808-9d7a357edefe h1:fre4i6mv4iBuz5lCMOzHD1rH1ljqHWSICFmZRbbgp3g=
|
||||
gvisor.dev/gvisor v0.0.0-20240423190808-9d7a357edefe/go.mod h1:sxc3Uvk/vHcd3tj7/DHVBoR5wvWT/MmRq2pj7HRJnwU=
|
||||
gvisor.dev/gvisor v0.0.0-20261014193016-04d31b385980 h1:ribyrTYQ/QYeUIs8x8bVLYwGyepa7RnHLqJzegT5YYk=
|
||||
gvisor.dev/gvisor v0.0.0-20261014193016-04d31b385980/go.mod h1:pK/dapF5Bf3KGW7/kd5CI5IC4lYh9FMFY1qETAIGLXk=
|
||||
+1
-9
@@ -60,9 +60,6 @@ type InterfaceConfig struct {
|
||||
// shorter lists than `routines` cycle. Empty list keeps the default
|
||||
// pin-to-(i % NumCPU) behavior. Only consulted when PinThreads is true.
|
||||
CpuAffinity []int
|
||||
// AvoidCPUs (tun.avoid_cpus) lists CPUs the default pin spread skips when
|
||||
// CpuAffinity is empty. Only consulted when PinThreads is true.
|
||||
AvoidCPUs []int
|
||||
// PinThreads controls whether each TUN reader OS thread is pinned to a
|
||||
// single CPU (via tun.pin_threads, default true). Pinning keeps each
|
||||
// goroutine's sendmmsg on one XPS-selected NIC TX ring so per-flow
|
||||
@@ -98,8 +95,6 @@ type Interface struct {
|
||||
// Empty falls back to the default pin-to-(allowed CPU) behavior.
|
||||
// Only consulted when pinThreads is true.
|
||||
cpuAffinity []int
|
||||
// avoidCPUs are removed from that fallback spread, unless they would empty it.
|
||||
avoidCPUs []int
|
||||
// pinThreads controls whether listenIn pins each TUN reader OS thread to
|
||||
// a CPU at all (tun.pin_threads, default true). When false, threads are
|
||||
// left free to migrate as on stock nebula.
|
||||
@@ -252,7 +247,6 @@ func NewInterface(ctx context.Context, c *InterfaceConfig) (*Interface, error) {
|
||||
connectionManager: c.connectionManager,
|
||||
conntrackCacheTimeout: c.ConntrackCacheTimeout,
|
||||
cpuAffinity: c.CpuAffinity,
|
||||
avoidCPUs: c.AvoidCPUs,
|
||||
pinThreads: c.PinThreads,
|
||||
udpTxErrLimiter: udpTxErrLimiter,
|
||||
udpRelayTxErrLimiter: udpRelayTxErrLimiter,
|
||||
@@ -443,14 +437,12 @@ func (f *Interface) pinThisThread(i int) {
|
||||
var cpu int
|
||||
if n := len(f.cpuAffinity); n > 0 {
|
||||
// Explicit tun.cpu_affinity list wins; parseCpuAffinity already
|
||||
// validated the entries against the allowed CPU set and tun.avoid_cpus.
|
||||
// validated the entries against the allowed CPU set.
|
||||
cpu = f.cpuAffinity[i%n]
|
||||
} else if allowed, err := util.AllowedCPUs(); err == nil && len(allowed) > 0 {
|
||||
// Default: spread queues across the CPUs we're actually allowed to
|
||||
// run on. Under a cpuset/taskset mask these aren't 0..NumCPU-1, so
|
||||
// i % NumCPU would pick unrunnable IDs and every pin would fail.
|
||||
// parseAvoidCPUs already dropped an avoid list that covers them all.
|
||||
allowed = slices.DeleteFunc(allowed, func(c int) bool { return slices.Contains(f.avoidCPUs, c) })
|
||||
cpu = allowed[i%len(allowed)]
|
||||
} else {
|
||||
cpu = i % runtime.NumCPU()
|
||||
|
||||
@@ -7,7 +7,6 @@ import (
|
||||
"github.com/slackhq/nebula/cert"
|
||||
"github.com/slackhq/nebula/config"
|
||||
"github.com/slackhq/nebula/test"
|
||||
"github.com/slackhq/nebula/util"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
@@ -119,22 +118,3 @@ func TestReloadFirewall_NoChange(t *testing.T) {
|
||||
|
||||
assert.Same(t, fw, f.firewall, "firewall should not have been replaced")
|
||||
}
|
||||
|
||||
// TestPinThisThreadFallbackSkipsAvoided covers the single reader, which never goes through cpupick: its fallback
|
||||
// spread over the allowed set must still skip tun.avoid_cpus.
|
||||
func TestPinThisThreadFallbackSkipsAvoided(t *testing.T) {
|
||||
allowed, err := util.AllowedCPUs()
|
||||
require.NoError(t, err)
|
||||
if len(allowed) < 2 {
|
||||
t.Skip("requires at least two allowed CPUs")
|
||||
}
|
||||
f := &Interface{l: test.NewLogger(), pinThreads: true, avoidCPUs: []int{allowed[0]}}
|
||||
got := make(chan []int)
|
||||
go func() {
|
||||
// The pin leaves this goroutine locked to its thread, so the runtime discards the thread when it returns.
|
||||
f.pinThisThread(0)
|
||||
cpus, _ := util.AllowedCPUs()
|
||||
got <- cpus
|
||||
}()
|
||||
assert.Equal(t, []int{allowed[1]}, <-got)
|
||||
}
|
||||
@@ -243,19 +243,11 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
||||
}
|
||||
|
||||
pinThreads := c.GetBool("tun.pin_threads", true)
|
||||
avoidCPUs := parseAvoidCPUs(c, l)
|
||||
if len(avoidCPUs) > 0 && !pinThreads {
|
||||
l.Warn("tun.avoid_cpus has no effect with tun.pin_threads disabled")
|
||||
}
|
||||
// Keeping every thread of the process off avoidCPUs, not just the pinned readers, is parked for now:
|
||||
//if err := cpupick.Avoid(avoidCPUs, !configTest); err != nil && !errors.Is(err, errors.ErrUnsupported) {
|
||||
// return nil, fmt.Errorf("tun.avoid_cpus: %w", err)
|
||||
//}
|
||||
cpuAffinity := parseCpuAffinity(c, l, routines, avoidCPUs)
|
||||
cpuAffinity := parseCpuAffinity(c, l, routines)
|
||||
if pinThreads && routines > 1 && len(cpuAffinity) == 0 && !configTest {
|
||||
// The operator didn't choose pin CPUs, so pick a default set that
|
||||
// prefers performance cores, skips tun.avoid_cpus and doesn't stack
|
||||
// co-located instances onto allowed[0].
|
||||
// prefers performance cores and doesn't stack co-located instances
|
||||
// onto allowed[0].
|
||||
|
||||
// key is used to seed the spreading of routines->cores.
|
||||
// use PID if you want to ensure many different Nebulas in VMs or containers land on different cores
|
||||
@@ -278,7 +270,7 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
||||
l.Warn("tun.pin_threads_key is invalid, using PID")
|
||||
}
|
||||
|
||||
cpuAffinity = cpupick.Default(routines, key, avoidCPUs, l)
|
||||
cpuAffinity = cpupick.Default(routines, key, l)
|
||||
}
|
||||
|
||||
ifConfig := &InterfaceConfig{
|
||||
@@ -303,7 +295,6 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
||||
punchy: punchy,
|
||||
ConntrackCacheTimeout: conntrackCacheTimeout,
|
||||
CpuAffinity: cpuAffinity,
|
||||
AvoidCPUs: avoidCPUs,
|
||||
PinThreads: pinThreads,
|
||||
l: l,
|
||||
}
|
||||
@@ -372,10 +363,8 @@ func Main(c *config.C, configTest bool, buildVersion string, l *slog.Logger, dev
|
||||
// mask (util.AllowedCPUs) rather than 0..NumCPU-1: under a cgroup cpuset or
|
||||
// taskset the runnable IDs are frequently not that contiguous range, and
|
||||
// pinning to an unrunnable ID always fails. If the allowed set can't be
|
||||
// determined we fall back to a plain non-negative check. An entry listed in
|
||||
// avoid (tun.avoid_cpus) contradicts the operator's own config and is treated
|
||||
// the same as any other invalid entry.
|
||||
func parseCpuAffinity(c *config.C, l *slog.Logger, routines int, avoid []int) []int {
|
||||
// determined we fall back to a plain non-negative check.
|
||||
func parseCpuAffinity(c *config.C, l *slog.Logger, routines int) []int {
|
||||
raw := c.Get("tun.cpu_affinity")
|
||||
if raw == nil {
|
||||
return nil
|
||||
@@ -418,11 +407,6 @@ func parseCpuAffinity(c *config.C, l *slog.Logger, routines int, avoid []int) []
|
||||
"index", i, "cpu", cpu, "allowed", allowed)
|
||||
return nil
|
||||
}
|
||||
if slices.Contains(avoid, cpu) {
|
||||
l.Warn("tun.cpu_affinity entry is listed in tun.avoid_cpus; ignoring affinity",
|
||||
"index", i, "cpu", cpu)
|
||||
return nil
|
||||
}
|
||||
cpus = append(cpus, cpu)
|
||||
}
|
||||
if len(cpus) != routines {
|
||||
@@ -432,36 +416,6 @@ func parseCpuAffinity(c *config.C, l *slog.Logger, routines int, avoid []int) []
|
||||
return cpus
|
||||
}
|
||||
|
||||
// parseAvoidCPUs reads tun.avoid_cpus, a list of CPU IDs the tun readers must not be pinned to. IDs outside the
|
||||
// allowed set are accepted, since one config may serve differently shaped hosts. Like tun.cpu_affinity, an invalid
|
||||
// list is a warning and is ignored entirely, as is one covering every allowed CPU, which would leave nowhere to pin.
|
||||
func parseAvoidCPUs(c *config.C, l *slog.Logger) []int {
|
||||
raw := c.Get("tun.avoid_cpus")
|
||||
if raw == nil {
|
||||
return nil
|
||||
}
|
||||
values, ok := raw.([]any)
|
||||
if !ok {
|
||||
l.Warn("tun.avoid_cpus must be a list of integers; ignoring", "value", raw)
|
||||
return nil
|
||||
}
|
||||
cpus := make([]int, 0, len(values))
|
||||
for i, value := range values {
|
||||
cpu, ok := value.(int)
|
||||
if !ok || cpu < 0 {
|
||||
l.Warn("tun.avoid_cpus entry not a non-negative integer; ignoring avoid_cpus", "index", i, "value", value)
|
||||
return nil
|
||||
}
|
||||
cpus = append(cpus, cpu)
|
||||
}
|
||||
if allowed, err := util.AllowedCPUs(); err == nil && len(allowed) > 0 &&
|
||||
!slices.ContainsFunc(allowed, func(cpu int) bool { return !slices.Contains(cpus, cpu) }) {
|
||||
l.Warn("tun.avoid_cpus covers every allowed CPU; ignoring avoid_cpus", "cpus", cpus, "allowed", allowed)
|
||||
return nil
|
||||
}
|
||||
return cpus
|
||||
}
|
||||
|
||||
func moduleVersion() string {
|
||||
info, ok := debug.ReadBuildInfo()
|
||||
if !ok {
|
||||
|
||||
+5
-36
@@ -32,7 +32,7 @@ func TestParseCpuAffinity(t *testing.T) {
|
||||
}
|
||||
|
||||
// unset -> nil (listenIn falls back to spreading across the allowed set)
|
||||
assert.Nil(t, parseCpuAffinity(newConfig(nil), l, 1, nil))
|
||||
assert.Nil(t, parseCpuAffinity(newConfig(nil), l, 1))
|
||||
|
||||
// Pick a CPU we're actually allowed to run on so a valid list survives
|
||||
// validation regardless of the host's affinity mask.
|
||||
@@ -43,50 +43,19 @@ func TestParseCpuAffinity(t *testing.T) {
|
||||
}
|
||||
|
||||
// valid list -> parsed through unchanged
|
||||
assert.Equal(t, []int{validCPU, validCPU}, parseCpuAffinity(newConfig([]any{validCPU, validCPU}), l, 2, nil))
|
||||
assert.Equal(t, []int{validCPU, validCPU}, parseCpuAffinity(newConfig([]any{validCPU, validCPU}), l, 2))
|
||||
|
||||
// a negative entry is out of range on every platform -> disables the override
|
||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, -1}), l, 2, nil))
|
||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, -1}), l, 2))
|
||||
|
||||
// a non-integer entry -> disables the override
|
||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, "not-a-cpu"}), l, 2, nil))
|
||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU, "not-a-cpu"}), l, 2))
|
||||
|
||||
// a CPU id outside the allowed set -> disables the override. Only assertable
|
||||
// where we can enumerate the allowed set (e.g. linux); 1<<20 is far beyond
|
||||
// any representable CPU id so it can never be in the mask.
|
||||
if len(allowed) > 0 {
|
||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{1 << 20}), l, 1, nil))
|
||||
}
|
||||
|
||||
// an entry also listed in tun.avoid_cpus -> disables the override
|
||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{validCPU}), l, 1, []int{validCPU}))
|
||||
}
|
||||
|
||||
func TestParseAvoidCPUs(t *testing.T) {
|
||||
l := test.NewLogger()
|
||||
for _, tc := range []struct {
|
||||
value any
|
||||
want []int
|
||||
}{
|
||||
{nil, nil}, {[]any{}, []int{}}, {[]any{1, 1 << 20}, []int{1, 1 << 20}},
|
||||
{"auto", nil}, {"1,2", nil}, {[]any{-1}, nil}, {[]any{1.5}, nil}, {[]any{1, "2"}, nil},
|
||||
} {
|
||||
c := config.NewC(l)
|
||||
if tc.value != nil {
|
||||
c.Settings["tun"] = map[string]any{"avoid_cpus": tc.value}
|
||||
}
|
||||
assert.Equal(t, tc.want, parseAvoidCPUs(c, l), "%v", tc.value)
|
||||
}
|
||||
|
||||
// avoiding every allowed CPU leaves nowhere to pin; only checkable where the allowed set is known
|
||||
if allowed, _ := util.AllowedCPUs(); len(allowed) > 0 {
|
||||
all := make([]any, len(allowed))
|
||||
for i, cpu := range allowed {
|
||||
all[i] = cpu
|
||||
}
|
||||
c := config.NewC(l)
|
||||
c.Settings["tun"] = map[string]any{"avoid_cpus": all}
|
||||
assert.Nil(t, parseAvoidCPUs(c, l))
|
||||
assert.Nil(t, parseCpuAffinity(newConfig([]any{1 << 20}), l, 1))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+96
-3
@@ -552,13 +552,17 @@ func (t *tun) setDefaultRoute(cidr netip.Prefix) error {
|
||||
if cidr.Addr().Is6() {
|
||||
nr.Priority = 256
|
||||
}
|
||||
err := netlink.RouteReplace(&nr)
|
||||
held, err := t.otherLinkRoutes()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = t.replaceRoute(&nr, held)
|
||||
if err != nil {
|
||||
t.l.Warn("Failed to set default route MTU, retrying", "error", err, "cidr", cidr)
|
||||
//retry twice more -- on some systems there appears to be a race condition where if we set routes too soon, netlink says `invalid argument`
|
||||
for range 2 {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
err = netlink.RouteReplace(&nr)
|
||||
err = t.replaceRoute(&nr, held)
|
||||
if err == nil {
|
||||
break
|
||||
} else {
|
||||
@@ -578,6 +582,15 @@ func (t *tun) setDefaultRoute(cidr netip.Prefix) error {
|
||||
}
|
||||
|
||||
func (t *tun) addRoutes(logErrors bool) error {
|
||||
held, err := t.otherLinkRoutes()
|
||||
if err != nil {
|
||||
if logErrors {
|
||||
t.l.Error("Failed to add routes", "error", err)
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
// Path routes
|
||||
routes := *t.Routes.Load()
|
||||
for _, r := range routes {
|
||||
@@ -602,7 +615,7 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
nr.Priority = r.Metric
|
||||
}
|
||||
|
||||
err := netlink.RouteReplace(&nr)
|
||||
err := t.replaceRoute(&nr, held)
|
||||
if err != nil {
|
||||
retErr := util.NewContextualError("Failed to add route", map[string]any{"route": r}, err)
|
||||
if logErrors {
|
||||
@@ -618,6 +631,86 @@ func (t *tun) addRoutes(logErrors bool) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// ip6RoutePrioUser is the metric the kernel gives an IPv6 route added without one
|
||||
const ip6RoutePrioUser = 1024
|
||||
|
||||
// routeKey is where the main table files a route. Replacing a route replaces the first one with the same key, whatever
|
||||
// device it is on
|
||||
type routeKey struct {
|
||||
dst netip.Prefix
|
||||
priority int
|
||||
}
|
||||
|
||||
func routeKeyOf(dst *net.IPNet, family, priority int) (routeKey, bool) {
|
||||
var p netip.Prefix
|
||||
if dst == nil {
|
||||
// A default route
|
||||
if family == unix.AF_INET6 {
|
||||
p = netip.PrefixFrom(netip.IPv6Unspecified(), 0)
|
||||
} else {
|
||||
p = netip.PrefixFrom(netip.IPv4Unspecified(), 0)
|
||||
}
|
||||
} else {
|
||||
addr, ok := netip.AddrFromSlice(dst.IP)
|
||||
if !ok {
|
||||
return routeKey{}, false
|
||||
}
|
||||
ones, _ := dst.Mask.Size()
|
||||
p = netip.PrefixFrom(addr.Unmap(), ones).Masked()
|
||||
}
|
||||
if priority == 0 && p.Addr().Is6() {
|
||||
priority = ip6RoutePrioUser
|
||||
}
|
||||
return routeKey{dst: p, priority: priority}, true
|
||||
}
|
||||
|
||||
// otherLinkRoutes returns the keys of the main table routes that are not on our device
|
||||
func (t *tun) otherLinkRoutes() (map[routeKey]struct{}, error) {
|
||||
routes, err := netlink.RouteListFiltered(netlink.FAMILY_ALL, &netlink.Route{Table: unix.RT_TABLE_MAIN}, netlink.RT_FILTER_TABLE)
|
||||
// An interrupted dump may miss a route, which then gets replaced like it always used to be
|
||||
if err != nil && !errors.Is(err, netlink.ErrDumpInterrupted) {
|
||||
return nil, fmt.Errorf("failed to list the system routes: %w", err)
|
||||
}
|
||||
held := make(map[routeKey]struct{}, len(routes))
|
||||
for _, r := range routes {
|
||||
if r.LinkIndex == t.deviceIndex {
|
||||
continue
|
||||
}
|
||||
if k, ok := routeKeyOf(r.Dst, r.Family, r.Priority); ok {
|
||||
held[k] = struct{}{}
|
||||
}
|
||||
}
|
||||
return held, nil
|
||||
}
|
||||
|
||||
// replaceRoute puts nr in the main table in place of our own route with its key. Replacing would take the route of
|
||||
// another device holding that key, so ours goes in behind it instead. Theirs keeps routing and the kernel falls back
|
||||
// to ours once theirs is removed, like when leaving the lan that had it. A different metric decides which one wins.
|
||||
func (t *tun) replaceRoute(nr *netlink.Route, held map[routeKey]struct{}) error {
|
||||
family := unix.AF_INET6
|
||||
if nr.Dst.IP.To4() != nil {
|
||||
family = unix.AF_INET
|
||||
}
|
||||
k, ok := routeKeyOf(nr.Dst, family, nr.Priority)
|
||||
if _, taken := held[k]; !ok || !taken {
|
||||
return netlink.RouteReplace(nr)
|
||||
}
|
||||
|
||||
// Appending doesn't update a route that is already ours, it adds a second one
|
||||
ours := netlink.Route{
|
||||
LinkIndex: nr.LinkIndex,
|
||||
Dst: nr.Dst,
|
||||
Scope: nr.Scope,
|
||||
Table: nr.Table,
|
||||
Priority: k.priority,
|
||||
}
|
||||
if err := netlink.RouteDel(&ours); err != nil && !errors.Is(err, unix.ESRCH) {
|
||||
return err
|
||||
}
|
||||
t.l.Warn("Another interface already routes this destination at the same metric, our route is used once theirs is removed", "destination", k.dst, "metric", k.priority)
|
||||
return netlink.RouteAppend(nr)
|
||||
}
|
||||
|
||||
func (t *tun) removeRoutes(routes []Route) {
|
||||
for _, r := range routes {
|
||||
if !r.Install {
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
//go:build linux && !android && !e2e_testing
|
||||
|
||||
package overlay
|
||||
|
||||
import (
|
||||
"net"
|
||||
"net/netip"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/DefinedNet/netlink"
|
||||
"github.com/slackhq/nebula/config"
|
||||
"github.com/slackhq/nebula/test"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"golang.org/x/sys/unix"
|
||||
)
|
||||
|
||||
// An unsafe_route with the same destination and metric as a lan's route must not replace it. Ours waits behind theirs
|
||||
// and takes over when the lan goes away. Run as root, or unprivileged with `unshare -rn`.
|
||||
func TestTunRouteLeavesAnotherDevicesRoute(t *testing.T) {
|
||||
if os.Geteuid() != 0 {
|
||||
t.Skip("creating links and adding routes needs root")
|
||||
}
|
||||
|
||||
lan := &netlink.Veth{LinkAttrs: netlink.LinkAttrs{Name: "nebrt0"}, PeerName: "nebrt1"}
|
||||
require.NoError(t, netlink.LinkAdd(lan))
|
||||
t.Cleanup(func() { _ = netlink.LinkDel(lan) })
|
||||
peer, err := netlink.LinkByName("nebrt1")
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, netlink.LinkSetUp(lan))
|
||||
require.NoError(t, netlink.LinkSetUp(peer))
|
||||
|
||||
lanAddrs := []*netlink.Addr{
|
||||
{IPNet: &net.IPNet{IP: net.ParseIP("198.51.100.5"), Mask: net.CIDRMask(24, 32)}},
|
||||
{IPNet: &net.IPNet{IP: net.ParseIP("2001:db8:1::5"), Mask: net.CIDRMask(64, 128)}, Flags: unix.IFA_F_NODAD},
|
||||
}
|
||||
for _, a := range lanAddrs {
|
||||
require.NoError(t, netlink.AddrAdd(lan, a))
|
||||
}
|
||||
|
||||
l := test.NewLogger()
|
||||
c := config.NewC(l)
|
||||
// The kernel puts a v4 lan route at metric 0, our default, and a v6 one at 256
|
||||
require.NoError(t, c.LoadString(`
|
||||
tun:
|
||||
dev: nebrt2
|
||||
unsafe_routes:
|
||||
- route: 198.51.100.0/24
|
||||
via: 10.250.0.2
|
||||
- route: 2001:db8:1::/64
|
||||
via: fd00:250::2
|
||||
metric: 256
|
||||
`))
|
||||
tn, err := newTun(c, l, []netip.Prefix{netip.MustParsePrefix("10.250.0.1/24"), netip.MustParsePrefix("fd00:250::1/64")}, false)
|
||||
require.NoError(t, err)
|
||||
t.Cleanup(func() { _ = tn.Close() })
|
||||
require.NoError(t, tn.Activate())
|
||||
|
||||
via := func(dst string) int {
|
||||
routes, err := netlink.RouteGet(net.ParseIP(dst))
|
||||
require.NoError(t, err)
|
||||
require.NotEmpty(t, routes)
|
||||
return routes[0].LinkIndex
|
||||
}
|
||||
devices := func(dst string) []int {
|
||||
_, n, err := net.ParseCIDR(dst)
|
||||
require.NoError(t, err)
|
||||
routes, err := netlink.RouteListFiltered(netlink.FAMILY_ALL, &netlink.Route{Dst: n}, netlink.RT_FILTER_DST)
|
||||
require.NoError(t, err)
|
||||
var out []int
|
||||
for _, r := range routes {
|
||||
out = append(out, r.LinkIndex)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
for _, dst := range []string{"198.51.100.0/24", "2001:db8:1::/64"} {
|
||||
assert.ElementsMatch(t, []int{lan.Index, tn.deviceIndex}, devices(dst), dst)
|
||||
}
|
||||
assert.Equal(t, lan.Index, via("198.51.100.9"))
|
||||
assert.Equal(t, lan.Index, via("2001:db8:1::9"))
|
||||
|
||||
// Leaving the lan
|
||||
for _, a := range lanAddrs {
|
||||
require.NoError(t, netlink.AddrDel(lan, a))
|
||||
}
|
||||
assert.Equal(t, tn.deviceIndex, via("198.51.100.9"))
|
||||
assert.Equal(t, tn.deviceIndex, via("2001:db8:1::9"))
|
||||
|
||||
// Dropping the unsafe_routes removes only ours
|
||||
for _, a := range lanAddrs {
|
||||
require.NoError(t, netlink.AddrAdd(lan, a))
|
||||
}
|
||||
require.NoError(t, c.ReloadConfigString("tun:\n dev: nebrt2\n"))
|
||||
for _, dst := range []string{"198.51.100.0/24", "2001:db8:1::/64"} {
|
||||
assert.Equal(t, []int{lan.Index}, devices(dst), dst)
|
||||
}
|
||||
}
|
||||
|
||||
// The route for our own vpn network is replaced to set its mtu, which must not take a lan's route for the same network
|
||||
func TestTunVpnNetworkLeavesAnotherDevicesRoute(t *testing.T) {
|
||||
if os.Geteuid() != 0 {
|
||||
t.Skip("creating links and adding routes needs root")
|
||||
}
|
||||
|
||||
lan := &netlink.Veth{LinkAttrs: netlink.LinkAttrs{Name: "nebrt0"}, PeerName: "nebrt1"}
|
||||
require.NoError(t, netlink.LinkAdd(lan))
|
||||
t.Cleanup(func() { _ = netlink.LinkDel(lan) })
|
||||
require.NoError(t, netlink.LinkSetUp(lan))
|
||||
require.NoError(t, netlink.AddrAdd(lan, &netlink.Addr{IPNet: &net.IPNet{IP: net.ParseIP("10.250.0.5"), Mask: net.CIDRMask(24, 32)}}))
|
||||
|
||||
l := test.NewLogger()
|
||||
c := config.NewC(l)
|
||||
require.NoError(t, c.LoadString("tun:\n dev: nebrt2\n"))
|
||||
tn, err := newTun(c, l, []netip.Prefix{netip.MustParsePrefix("10.250.0.1/24")}, false)
|
||||
require.NoError(t, err)
|
||||
t.Cleanup(func() { _ = tn.Close() })
|
||||
require.NoError(t, tn.Activate())
|
||||
|
||||
_, n, err := net.ParseCIDR("10.250.0.0/24")
|
||||
require.NoError(t, err)
|
||||
routes, err := netlink.RouteListFiltered(netlink.FAMILY_V4, &netlink.Route{Dst: n}, netlink.RT_FILTER_DST)
|
||||
require.NoError(t, err)
|
||||
var devices []int
|
||||
for _, r := range routes {
|
||||
devices = append(devices, r.LinkIndex)
|
||||
if r.LinkIndex == tn.deviceIndex {
|
||||
assert.Equal(t, tn.DefaultMTU, r.MTU, "ours still carries the mtu")
|
||||
}
|
||||
}
|
||||
assert.ElementsMatch(t, []int{lan.Index, tn.deviceIndex}, devices)
|
||||
}
|
||||
Reference in new issue
Block a user