uffd: anchor sockets at short runtime root, not under data dir

Unix domain socket paths cap at 108 bytes (sun_path). Putting the per-
fork socket under <DataDir>/templates/<25-char-cuid>/uffd/<25-char-
cuid>.uffd blew that limit on CI runners where t.TempDir() returns long
prefixes, surfacing as "bind: invalid argument" in
TestFirecrackerForkFromTemplate.

Sockets are ephemeral, so anchoring them at /tmp/h-uffd/<templateID>/
keeps the path well under the limit regardless of how deep DataDir is.
The tracker now also rm -rfs the per-template socket dir on the last
release so we don't leak stale entries.

Author: sjmiller609

lib/instances/uffd.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os"
 	"path/filepath"
 	"sync"
 
@@ -35,8 +36,9 @@ type uffdTracker struct {
 }
 
 type uffdEntry struct {
-	server *uffd.Server
-	forks  map[string]struct{}
+	server    *uffd.Server
+	socketDir string
+	forks     map[string]struct{}
 }
 
 func newUffdTracker() *uffdTracker {
@@ -65,7 +67,7 @@ func (t *uffdTracker) acquireUffdForFork(ctx context.Context, templateID, memFil
 			t.mu.Unlock()
 			return "", fmt.Errorf("uffd: start server for template %s: %w", templateID, err)
 		}
-		entry = &uffdEntry{server: srv, forks: map[string]struct{}{}}
+		entry = &uffdEntry{server: srv, socketDir: socketDir, forks: map[string]struct{}{}}
 		t.entries[templateID] = entry
 	}
 	t.mu.Unlock()
@@ -101,6 +103,7 @@ func (t *uffdTracker) releaseUffdForFork(templateID, forkID string) error {
 	}
 	delete(entry.forks, forkID)
 	srv := entry.server
+	socketDir := entry.socketDir
 	empty := len(entry.forks) == 0
 	if empty {
 		delete(t.entries, templateID)
@@ -115,6 +118,9 @@ func (t *uffdTracker) releaseUffdForFork(templateID, forkID string) error {
 		if err := srv.Close(); err != nil && firstErr == nil {
 			firstErr = err
 		}
+		if socketDir != "" {
+			_ = os.RemoveAll(socketDir)
+		}
 	}
 	return firstErr
 }
@@ -130,8 +136,12 @@ func (t *uffdTracker) maybeCloseEmpty(templateID string) {
 	}
 	delete(t.entries, templateID)
 	srv := entry.server
+	socketDir := entry.socketDir
 	t.mu.Unlock()
 	_ = srv.Close()
+	if socketDir != "" {
+		_ = os.RemoveAll(socketDir)
+	}
 }
 
 // closeAll tears down every server. Called by the manager during
@@ -150,6 +160,9 @@ func (t *uffdTracker) closeAll() error {
 		if err := entry.server.Close(); err != nil && firstErr == nil {
 			firstErr = err
 		}
+		if entry.socketDir != "" {
+			_ = os.RemoveAll(entry.socketDir)
+		}
 	}
 	return firstErr
 }

lib/paths/paths.go

@@ -260,16 +260,26 @@ func (p *Paths) SnapshotGuestDir(snapshotID string) string {
 	return filepath.Join(p.SnapshotDir(snapshotID), "guest")
 }
 
-// TemplateUffdDir returns the directory that holds the per-fork
-// userfaultfd page-server sockets for a template instance. Sockets live
-// in a dedicated subdirectory of the template's instance dir, keyed by
-// the source (template) instance id rather than each fork's id, because
-// Unix domain socket paths are tightly length-limited and one server
-// fans out to many forks.
+// TemplateUffdDir returns the directory that holds a template's per-fork
+// userfaultfd page-server sockets. Sockets cannot live under the data dir
+// because Unix domain socket paths are limited to 108 bytes (sun_path); a
+// deep DataDir + the cuid2 template+fork ids easily blow that. Anchoring
+// at a short, fixed runtime root keeps the absolute path well under the
+// limit (~30 chars for typical ids) regardless of where the data dir lives.
+//
+// Sockets are ephemeral — losing them on reboot is fine; firecracker
+// reconnects on restore.
 func (p *Paths) TemplateUffdDir(templateInstanceID string) string {
-	return filepath.Join(p.InstanceDir(templateInstanceID), "uffd")
+	return filepath.Join(uffdRuntimeRoot(), templateInstanceID)
 }
 
+// uffdRuntimeRoot returns the short root used to hold uffd sockets. It is
+// not configurable on purpose: the only requirement is that it stay short
+// and writable, and /tmp meets both. Tests get isolation from the cuid
+// segment in TemplateUffdDir.
+func uffdRuntimeRoot() string {
+	return filepath.Join("/tmp", "h-uffd")
+}
 
 // Device path methods