Move the goamd64_capable/goamd64_compiled logic out of tsweb/varz into a new util/cpucaps package so that a future hostinfo extension can share it, and extend it to all supported platforms. The host GOAMD64 level is now computed from CPUID feature bits via x/sys/cpu rather than by parsing /proc/cpuinfo, which removes the linux/amd64 restriction and all file I/O. CPUID is also what the Go runtime checks at startup, so it directly answers the question the metric asks: could this machine run a binary built at a higher level. Four flags required by the runtime checks have no x/sys/cpu field: LAHF/SAHF (v2) and MOVBE, LZCNT and F16C (v3). We report a level when all of its other flags are present. That is exact on real hardware: LAHF/SAHF exists on every 64-bit CPU that also has SSE4.2, and MOVBE/LZCNT/F16C exist on every CPU that also has AVX2, BMI2 and FMA (Haswell and Zen onwards). A linux/amd64 test cross-checks the CPUID result against the exact /proc/cpuinfo flag lists, so a test run on any machine where the assumption fails, or where the kernel's view diverges from CPUID (e.g. clearcpuid=), reports the difference. Add a Caps bitmask of the CPU capabilities that Go's runtime and standard library dispatch on, normalized across amd64 and arm64: AES, CLMUL/PMULL, SHA2, SHA512, CRC32, ADX and LSE, plus the vector capabilities not implied by the GOAMD64 level: AVX, AVX2, AVX512 (the v4 F+BW+CD+DQ+VL subset), VAES, VPCLMULQDQ and GFNI. Detection is lazy and reads only x/sys/cpu globals and build info; there is no init-time work and no new dependency. Coverage includes all key client platforms: linux, windows, darwin, freebsd, android (via the linux auxv/MRS path in x/sys/cpu) and ios (via the darwin sysctl path). x/sys/cpu has no arm64 detection on FreeBSD, so read ID_AA64ISAR0_EL1 directly; the FreeBSD kernel emulates EL0 reads of the ID registers, and Go's runtime already depends on that emulation on this platform. The whole feature is behind a new cpucaps feature tag. Building with ts_omit_cpucaps removes the varz metrics and all detection code following the tka stub pattern: the detection functions compile to stubs returning zero inside the package itself, so future importers cannot reintroduce the code by forgetting a build tag, and the Caps type stays available for decoding recorded values. A tailscaled dependency test enforces the omission, and the generated buildfeatures.HasCPUCaps const is available for the later hostinfo extension. tsweb/varz metric names are unchanged. gauge_goamd64_capable values only change on machines where /proc/cpuinfo disagrees with CPUID. Updates #21002 Signed-off-by: James Tucker <[email protected]>
tsnet
Package tsnet embeds a Tailscale node directly into a Go program, allowing it to join a tailnet and accept or dial connections without running a separate tailscaled daemon or requiring any system-level configuration.
Overview
Normally, Tailscale runs as a background system service (tailscaled) that manages a virtual network interface for the whole machine. tsnet takes a different approach: it runs a fully self-contained Tailscale node inside your process using a userspace TCP/IP stack (gVisor). This means:
- No root privileges required.
- No system daemons to install or manage.
- Multiple independent Tailscale nodes can run within a single binary.
- The node's Tailscale identity and state are stored in a directory you control.
The core type is Server, which represents one embedded Tailscale node. Calling Server.Listen or Server.Dial routes traffic exclusively over the tailnet. The standard library's net.Listener and net.Conn interfaces are returned, so any existing Go HTTP server, gRPC server, or other net-based code works without modification.
Usage
import "tailscale.com/tsnet"
s := &tsnet.Server{
Hostname: "my-service",
AuthKey: os.Getenv("TS_AUTHKEY"),
}
defer s.Close()
ln, err := s.Listen("tcp", ":80")
if err != nil {
log.Fatal(err)
}
log.Fatal(http.Serve(ln, myHandler))
On first run, if no Server.AuthKey is provided and the node is not already enrolled, the server logs an authentication URL. Open it in a browser to add the node to your tailnet.
Authentication
A Server authenticates using, in order of precedence:
-
The TS_AUTHKEY environment variable.
-
The TS_AUTH_KEY environment variable.
-
An OAuth client secret (Server.ClientSecret or TS_CLIENT_SECRET), used to mint an auth key.
-
Workload identity federation (Server.ClientID plus Server.IDToken or Server.Audience). Available only if the program imports the feature:
import _ "tailscale.com/feature/identityfederation"
The feature is not linked by default to keep the AWS SDK and other cloud-provider dependencies out of programs that don't use workload identity federation.
-
An interactive login URL printed to Server.UserLogf.
If the node is already enrolled (state found in Server.Store), the auth key is ignored unless TSNET_FORCE_LOGIN=1 is set.
Identifying callers
Use the WhoIs method on the client returned by Server.LocalClient to identify who is making a request:
lc, _ := srv.LocalClient()
http.Serve(ln, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
who, err := lc.WhoIs(r.Context(), r.RemoteAddr)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
fmt.Fprintf(w, "Hello, %s!", who.UserProfile.LoginName)
}))
Tailscale Funnel
Server.ListenFunnel exposes your service on the public internet. Tailscale Funnel currently supports TCP on ports 443, 8443, and 10000. HTTPS must be enabled in the Tailscale admin console.
ln, err := srv.ListenFunnel("tcp", ":443")
// ln is a TLS listener; connections can come from anywhere on the
// internet as well as from your tailnet.
// To restrict to public traffic only:
ln, err = srv.ListenFunnel("tcp", ":443", tsnet.FunnelOnly())
Tailscale Services
Server.ListenService advertises the node as a host for a named Tailscale Service. The node must use a tag-based identity. To advertise multiple ports, call ListenService once per port.
srv.AdvertiseTags = []string{"tag:myservice"}
ln, err := srv.ListenService("svc:my-service", tsnet.ServiceModeHTTP{
HTTPS: true,
Port: 443,
})
log.Printf("Listening on https://%s", ln.FQDN)
Using an exit node
A tsnet node can route its Server.Dial traffic to non-tailnet addresses through an exit node. Select the exit node by setting the ExitNodeID pref via Server.LocalClient:
lc, _ := srv.LocalClient()
_, err := lc.EditPrefs(ctx, &ipn.MaskedPrefs{
Prefs: ipn.Prefs{ExitNodeID: "nodeid"},
ExitNodeIDSet: true,
})
Dials of addresses outside the tailnet then go through the exit node. Dials within the tailnet are unaffected.
Running multiple nodes in one process
Each Server instance is an independent node. Give each a unique Server.Dir and Server.Hostname:
for _, name := range []string{"frontend", "backend"} {
srv := &tsnet.Server{
Hostname: name,
Dir: filepath.Join(baseDir, name),
AuthKey: os.Getenv("TS_AUTHKEY"),
Ephemeral: true,
}
srv.Start()
}