mirror of
https://github.com/slackhq/nebula.git
synced 2026-11-17 23:36:52 +01:00
split tun setup and tun IO
This commit is contained in:
1 parent
10e1924489
commit
2ff4852551
5 files changed
+395
-413
No files matched your search
@@ -0,0 +1,338 @@
|
||||
//go:build darwin && !ios
|
||||
|
||||
package tio
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"os"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"syscall"
|
||||
"unsafe"
|
||||
|
||||
"golang.org/x/sys/unix"
|
||||
)
|
||||
|
||||
// tunMaxPacket is the largest packet utun can return at any device MTU.
|
||||
const tunMaxPacket = 65535
|
||||
|
||||
// tunReadBatch is the most packets one Utun.Read returns.
|
||||
const tunReadBatch = 64
|
||||
|
||||
// tunReadArena is Utun's receive buffer. Draining stops once less than tunMaxPacket of it is left,
|
||||
// so every readv has room for the largest packet utun can return.
|
||||
const tunReadArena = 4 * tunMaxPacket
|
||||
|
||||
// tunWriteBatch is how many packets one sendmsg_x call may carry.
|
||||
const tunWriteBatch = 64
|
||||
|
||||
// Utun is a darwin utun control socket as a Queue. Every packet crosses the socket behind a 4 byte
|
||||
// address family prefix, which Read strips and the writes add.
|
||||
//
|
||||
// The fd lives in the runtime poller, so Close wakes a Read parked on it; darwin needs no QueueSet
|
||||
// shutdown fd.
|
||||
type Utun struct {
|
||||
f *os.File
|
||||
l *slog.Logger
|
||||
|
||||
// readBuf and readRet are Read's scratch, owned by the single reader.
|
||||
readBuf []byte
|
||||
readRet [tunReadBatch]Packet
|
||||
|
||||
// noSendmsgX is set once sendmsg_x is refused; WriteBatch then writes one packet at a time.
|
||||
noSendmsgX atomic.Bool
|
||||
batchMu sync.Mutex
|
||||
batch tunBatch
|
||||
}
|
||||
|
||||
// tunBatch is WriteBatch's scratch, guarded by Utun.batchMu. The kernel reads every entry in place.
|
||||
type tunBatch struct {
|
||||
heads [tunWriteBatch][4]byte
|
||||
iovs [tunWriteBatch][2]unix.Iovec
|
||||
hdrs [tunWriteBatch]msghdrX
|
||||
pkts [tunWriteBatch][]byte
|
||||
}
|
||||
|
||||
// msghdrX mirrors xnu's struct msghdr_x (bsd/sys/socket_private.h).
|
||||
// Keep in sync with msghdrX in udp/udp_darwin.go.
|
||||
type msghdrX struct {
|
||||
Name *byte
|
||||
Namelen uint32
|
||||
Iov *unix.Iovec
|
||||
Iovlen int32
|
||||
Control *byte
|
||||
Controllen uint32
|
||||
Flags int32
|
||||
Datalen uint64
|
||||
}
|
||||
|
||||
// NewUtun wraps a utun control socket fd and makes it non-blocking.
|
||||
// On failure it does NOT close fd: the caller owns fd until NewUtun succeeds, after which Close closes it.
|
||||
func NewUtun(fd int, l *slog.Logger) (*Utun, error) {
|
||||
// Before os.NewFile, which only hands a non-blocking fd to the runtime poller.
|
||||
if err := unix.SetNonblock(fd, true); err != nil {
|
||||
return nil, fmt.Errorf("failed to set the tun fd to non-blocking mode: %w", err)
|
||||
}
|
||||
return &Utun{
|
||||
f: os.NewFile(uintptr(fd), "utun"),
|
||||
l: l,
|
||||
readBuf: make([]byte, tunReadArena),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// tunWritev and tunReadv are linkname'd to x/sys/unix's libc-routed writev/readv stubs so the
|
||||
// calls go through libSystem's pinned trampoline. A raw syscall.Syscall(SYS_WRITEV/SYS_READV, ...)
|
||||
// on darwin/arm64 emits an SVC #0x80 trap (see $GOROOT/src/syscall/asm_darwin_arm64.s), the path
|
||||
// Apple keeps warning they will eventually disallow. We pull the low-level stubs instead of calling
|
||||
// unix.Writev/unix.Readv because those take [][]byte and rebuild the []Iovec every call, which
|
||||
// heap-allocates the header; linkname'ing the stubs lets us hand them our own stack-allocated
|
||||
// iovecs. See golang/go#78049.
|
||||
|
||||
//go:linkname tunWritev golang.org/x/sys/unix.writev
|
||||
//go:noescape
|
||||
func tunWritev(fd int, iovecs []unix.Iovec) (n int, err error)
|
||||
|
||||
//go:linkname tunReadv golang.org/x/sys/unix.readv
|
||||
//go:noescape
|
||||
func tunReadv(fd int, iovecs []unix.Iovec) (n int, err error)
|
||||
|
||||
// Read waits for the utun to become readable, then reads packets until it would block, up to
|
||||
// tunReadBatch, so the caller encrypts and sends them as one batch rather than one per wakeup. Each
|
||||
// packet is read with its AF prefix scattered away, so the payload lands directly in readBuf.
|
||||
// An error after at least one packet is dropped in favor of returning those packets; a persistent
|
||||
// one recurs on the next Read.
|
||||
func (u *Utun) Read() ([]Packet, error) {
|
||||
rc, err := u.f.SyscallConn()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var head [4]byte
|
||||
n, off := 0, 0
|
||||
var callErr error
|
||||
err = rc.Read(func(fd uintptr) bool {
|
||||
for n < tunReadBatch && len(u.readBuf)-off >= tunMaxPacket {
|
||||
iovecs := [2]unix.Iovec{
|
||||
{Base: &head[0], Len: 4},
|
||||
{Base: &u.readBuf[off], Len: uint64(len(u.readBuf) - off)},
|
||||
}
|
||||
l, e := tunReadv(int(fd), iovecs[:])
|
||||
if e != nil {
|
||||
if errno, ok := e.(syscall.Errno); ok && errno.Temporary() {
|
||||
// Park on the poller only while there is nothing to hand back.
|
||||
return n > 0
|
||||
}
|
||||
callErr = e
|
||||
return true
|
||||
}
|
||||
if l < 4 {
|
||||
// A datagram too short to carry the AF prefix, or end of file; stop rather than spin on it.
|
||||
return true
|
||||
}
|
||||
end := off + l - 4
|
||||
u.readRet[n] = Packet{Bytes: u.readBuf[off:end:end]}
|
||||
n++
|
||||
off = end
|
||||
}
|
||||
return true
|
||||
})
|
||||
if n > 0 {
|
||||
return u.readRet[:n], nil
|
||||
}
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return nil, callErr
|
||||
}
|
||||
|
||||
// Write pushes one IP packet onto the utun device. Safe for concurrent use:
|
||||
// the AF prefix and iovecs are per-call stack state, and the fd write itself
|
||||
// serializes on the runtime's fd mutex (see the Queue contract in tio.go).
|
||||
func (u *Utun) Write(from []byte) (int, error) {
|
||||
if len(from) == 0 {
|
||||
return 0, syscall.EIO
|
||||
}
|
||||
|
||||
var head [4]byte
|
||||
af, err := tunAF(from)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
head[3] = af
|
||||
|
||||
// Grab rc as a local so the compiler can devirtualize the call and keep the closure on the stack.
|
||||
rc, err := u.f.SyscallConn()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
var n int
|
||||
var callErr error
|
||||
err = rc.Write(func(fd uintptr) bool {
|
||||
iovecs := []unix.Iovec{
|
||||
{Base: &head[0], Len: 4},
|
||||
{Base: &from[0], Len: uint64(len(from))},
|
||||
}
|
||||
n, callErr = tunWritev(int(fd), iovecs)
|
||||
// Type-assert to syscall.Errno so the EAGAIN/EWOULDBLOCK/EINTR check doesn't box the errno
|
||||
// constants into error interfaces on every call.
|
||||
if errno, ok := callErr.(syscall.Errno); ok && errno.Temporary() {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
})
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if callErr != nil {
|
||||
return 0, callErr
|
||||
}
|
||||
|
||||
return n - 4, nil
|
||||
}
|
||||
|
||||
// tunAF returns the utun address-family prefix byte for an IP packet.
|
||||
func tunAF(pkt []byte) (byte, error) {
|
||||
switch pkt[0] >> 4 {
|
||||
case 4:
|
||||
return syscall.AF_INET, nil
|
||||
case 6:
|
||||
return syscall.AF_INET6, nil
|
||||
default:
|
||||
return 0, fmt.Errorf("unable to determine IP version from packet")
|
||||
}
|
||||
}
|
||||
|
||||
// WriteBatch writes pkts to the utun device with sendmsg_x, xnu's private batched sendmsg, up to
|
||||
// tunWriteBatch packets per syscall. The kernel still hands each packet to utun on its own, so this
|
||||
// saves syscalls, not per-packet kernel work. Safe for concurrent use.
|
||||
//
|
||||
// An empty packet or one with no IP version is skipped and reported, as Write would. Any other
|
||||
// error from sendmsg_x means the kernel took an unknown prefix of that call and dropped the rest, so
|
||||
// it is reported rather than retried, which could deliver packets twice.
|
||||
//
|
||||
// Under mbuf exhaustion, sendmsg_x silently drops packets that writev would have delivered: the
|
||||
// kernel counts each packet as sent once it is copied in, and when a later allocation fails it
|
||||
// frees that prefix unsent and returns its length as a short count, which is indistinguishable
|
||||
// from a real one.
|
||||
func (u *Utun) WriteBatch(pkts [][]byte) error {
|
||||
if u.noSendmsgX.Load() {
|
||||
return u.writeEach(pkts)
|
||||
}
|
||||
|
||||
u.batchMu.Lock()
|
||||
defer u.batchMu.Unlock()
|
||||
b := &u.batch
|
||||
var firstErr error
|
||||
for len(pkts) > 0 {
|
||||
n := 0
|
||||
for len(pkts) > 0 && n < tunWriteBatch {
|
||||
p := pkts[0]
|
||||
pkts = pkts[1:]
|
||||
var af byte
|
||||
err := error(syscall.EIO)
|
||||
if len(p) > 0 {
|
||||
af, err = tunAF(p)
|
||||
}
|
||||
if err != nil {
|
||||
if firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
continue
|
||||
}
|
||||
b.heads[n] = [4]byte{3: af}
|
||||
b.iovs[n] = [2]unix.Iovec{
|
||||
{Base: &b.heads[n][0], Len: 4},
|
||||
{Base: &p[0], Len: uint64(len(p))},
|
||||
}
|
||||
b.hdrs[n] = msghdrX{Iov: &b.iovs[n][0], Iovlen: 2}
|
||||
b.pkts[n] = p
|
||||
n++
|
||||
}
|
||||
if n == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
for off := 0; off < n; {
|
||||
sent, err := u.sendmsgX(off, n)
|
||||
switch {
|
||||
case err == nil && sent > 0:
|
||||
// The kernel stops early without an error on a packet larger than the socket's send
|
||||
// buffer, or when sending a later packet fails with ENOBUFS; resend the remainder.
|
||||
off += sent
|
||||
case err == nil:
|
||||
if werr := u.writeEach(b.pkts[off:n]); werr != nil && firstErr == nil {
|
||||
firstErr = werr
|
||||
}
|
||||
off = n
|
||||
case err == unix.EMSGSIZE:
|
||||
// Only the first packet being larger than the socket's send buffer fails the whole call,
|
||||
// before the kernel takes any; Write reports that one and the rest go out in the next call.
|
||||
if werr := u.writeEach(b.pkts[off : off+1]); werr != nil && firstErr == nil {
|
||||
firstErr = werr
|
||||
}
|
||||
off++
|
||||
case err == unix.ENOSYS || err == unix.EPERM || err == unix.EOPNOTSUPP:
|
||||
// sendmsg_x is private API: fall back to writev if a kernel or sandbox refuses it.
|
||||
if u.noSendmsgX.CompareAndSwap(false, true) {
|
||||
u.l.Warn("sendmsg_x unavailable on the tun device, writing one packet per syscall", "error", err)
|
||||
}
|
||||
if werr := u.writeEach(b.pkts[off:n]); werr != nil && firstErr == nil {
|
||||
firstErr = werr
|
||||
}
|
||||
clear(b.iovs[:n])
|
||||
clear(b.pkts[:n])
|
||||
if werr := u.writeEach(pkts); werr != nil && firstErr == nil {
|
||||
firstErr = werr
|
||||
}
|
||||
return firstErr
|
||||
default:
|
||||
if firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
off = n
|
||||
}
|
||||
}
|
||||
clear(b.iovs[:n])
|
||||
clear(b.pkts[:n])
|
||||
}
|
||||
return firstErr
|
||||
}
|
||||
|
||||
// sendmsgX hands entries off through n-1 of u.batch to sendmsg_x and returns how many the kernel took.
|
||||
func (u *Utun) sendmsgX(off, n int) (int, error) {
|
||||
rc, err := u.f.SyscallConn()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
var sent uintptr
|
||||
var errno syscall.Errno
|
||||
err = rc.Write(func(fd uintptr) bool {
|
||||
sent, _, errno = unix.Syscall6(unix.SYS_SENDMSG_X, fd, uintptr(unsafe.Pointer(&u.batch.hdrs[off])), uintptr(n-off), 0, 0, 0)
|
||||
// sendmsg_x reports EAGAIN only when it took nothing; a partial batch returns its count.
|
||||
return !errno.Temporary()
|
||||
})
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if errno != 0 {
|
||||
return 0, errno
|
||||
}
|
||||
return int(sent), nil
|
||||
}
|
||||
|
||||
// writeEach writes pkts one at a time with Write.
|
||||
func (u *Utun) writeEach(pkts [][]byte) error {
|
||||
var firstErr error
|
||||
for _, p := range pkts {
|
||||
if _, err := u.Write(p); err != nil && firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
}
|
||||
return firstErr
|
||||
}
|
||||
|
||||
func (u *Utun) Close() error {
|
||||
return u.f.Close()
|
||||
}
|
||||
Reference in new issue
Block a user