package roots import ( "bufio" "bytes" "context" "errors" "io/fs" "os" "os/exec" "os/user" "path/filepath" "regexp" "sort" "strconv" "strings" "sync" "syscall" "time" ) // Config locates the Nix state on disk. Tests point it at a fake tree. type Config struct { StoreDir string // /nix/store StateDir string // /nix/var/nix // NixStoreBin is used for --print-roots and --gc. NixStoreBin string // NixBin is used for path-info. NixBin string // NixEnvBin is used to delete profile generations. NixEnvBin string } func DefaultConfig() Config { c := Config{ StoreDir: "/nix/store", StateDir: "/nix/var/nix", NixStoreBin: "nix-store", NixBin: "nix", NixEnvBin: "nix-env", } if v := os.Getenv("NIX_STORE_DIR"); v != "" { c.StoreDir = v } if v := os.Getenv("NIX_STATE_DIR"); v != "" { c.StateDir = v } return c } func (c Config) gcrootsDir() string { return filepath.Join(c.StateDir, "gcroots") } func (c Config) autoDir() string { return filepath.Join(c.StateDir, "gcroots", "auto") } func (c Config) profilesDir() string { return filepath.Join(c.StateDir, "profiles") } func (c Config) inStore(p string) bool { return strings.HasPrefix(p, c.StoreDir+"/") } // storePathOf trims a path inside the store to the top level store path. func (c Config) storePathOf(p string) string { rest := strings.TrimPrefix(p, c.StoreDir+"/") if i := strings.IndexByte(rest, '/'); i >= 0 { rest = rest[:i] } return c.StoreDir + "/" + rest } var protectedLinks = map[string]bool{ "/run/current-system": true, "/run/booted-system": true, } // hiddenPatterns mark roots that nix creates for its own caches. var hiddenPatterns = []string{"/.cache/nix/"} func isHidden(link string) bool { for _, p := range hiddenPatterns { if strings.Contains(link, p) { return true } } return false } var genLinkRe = regexp.MustCompile(`^(.*)-(\d+)-link$`) type scanner struct { cfg Config seen map[string]*Root order []*Root users map[int]string } // Scan finds all persistent roots: the gcroots tree (including indirect // roots registered under auto/) and the profiles tree. Runtime roots are // gathered separately by ScanRuntime because that requires running // nix-store and is slow. func Scan(cfg Config) ([]*Root, error) { s := &scanner{cfg: cfg, seen: map[string]*Root{}, users: map[int]string{}} if err := s.walk(cfg.gcrootsDir(), true); err != nil { return nil, err } // The profiles dir is not required to exist (e.g. in tests). if err := s.walk(cfg.profilesDir(), false); err != nil && !errors.Is(err, fs.ErrNotExist) { return nil, err } for _, r := range s.order { s.classifyProfile(r) s.fillOwner(r) r.Hidden = isHidden(r.Link) } return s.order, nil } // walk visits every symlink below dir. dir itself may be a symlink; paths are // reported under dir rather than its resolved location. func (s *scanner) walk(dir string, isGCRoots bool) error { real, err := filepath.EvalSymlinks(dir) if err != nil { return err } return filepath.WalkDir(real, func(p string, d fs.DirEntry, err error) error { if err != nil { // unreadable subdirectories are skipped, not fatal if d != nil && d.IsDir() && p != real { return fs.SkipDir } if p == real { return err } return nil } if d.Type()&fs.ModeSymlink == 0 { return nil } shown := dir + strings.TrimPrefix(p, real) s.visitLink(shown, p, isGCRoots) return nil }) } func (s *scanner) add(r *Root) { if _, ok := s.seen[r.Link]; ok { return } r.ClosureSize, r.NarSize = -1, -1 s.seen[r.Link] = r s.order = append(s.order, r) } // visitLink mirrors the logic of findRoots in libstore/gc.cc. func (s *scanner) visitLink(shown, real string, isGCRoots bool) { target, err := os.Readlink(real) if err != nil { return } if s.cfg.inStore(target) { s.add(&Root{Link: shown, Target: s.cfg.storePathOf(target), Kind: KindDirect}) return } if !filepath.IsAbs(target) { target = filepath.Join(filepath.Dir(shown), target) } inAuto := isGCRoots && strings.HasPrefix(shown, s.cfg.autoDir()+"/") st, err := os.Lstat(target) if err != nil { if !inAuto { return } if errors.Is(err, fs.ErrNotExist) { s.add(&Root{Link: target, Via: shown, Kind: KindDangling}) } else { s.add(&Root{Link: target, Via: shown, Kind: KindIndirect, Reason: "unreadable: " + errReason(err)}) } return } if st.Mode()&fs.ModeSymlink == 0 { return } target2, err := os.Readlink(target) if err != nil || !s.cfg.inStore(target2) { return } if inAuto { s.add(&Root{Link: target, Via: shown, Target: s.cfg.storePathOf(target2), Kind: KindIndirect}) } else if isGCRoots { // e.g. gcroots/booted-system -> /run/booted-system -> store. // Deleting the gcroots entry is what drops the root. r := &Root{Link: shown, Via: target, Target: s.cfg.storePathOf(target2), Kind: KindDirect} if protectedLinks[target] { r.Protected, r.Reason = true, "points to "+target } s.add(r) } // In the profiles tree, links like system -> system-38-link resolve to a // generation link that is visited on its own. } func errReason(err error) string { var pe *fs.PathError if errors.As(err, &pe) { return pe.Err.Error() } return err.Error() } func (s *scanner) classifyProfile(r *Root) { if r.Kind == KindDangling { return } m := genLinkRe.FindStringSubmatch(r.Link) if m == nil { return } profile := m[1] st, err := os.Lstat(profile) if err != nil || st.Mode()&fs.ModeSymlink == 0 { return } gen, _ := strconv.Atoi(m[2]) r.Kind = KindProfile r.Profile = profile r.Generation = gen if cur, err := os.Readlink(profile); err == nil && filepath.Base(cur) == filepath.Base(r.Link) { r.Current = true r.Protected = true r.Reason = "current generation of " + profile } } func (s *scanner) fillOwner(r *Root) { p := r.Link if r.Kind == KindDangling { p = r.Via } st, err := os.Lstat(p) if err != nil { r.UID = -1 return } r.ModTime = st.ModTime() if sys, ok := st.Sys().(*syscall.Stat_t); ok { r.UID = int(sys.Uid) r.Owner = s.userName(r.UID) } } func (s *scanner) userName(uid int) string { if n, ok := s.users[uid]; ok { return n } n := strconv.Itoa(uid) if u, err := user.LookupId(n); err == nil { n = u.Username } s.users[uid] = n return n } // ScanRuntime returns one root per process that holds store paths alive, // based on `nix-store --gc --print-roots`. Roots that the persistent scan // already found are skipped via known. func ScanRuntime(ctx context.Context, cfg Config, known map[string]bool) ([]*Root, error) { out, err := exec.CommandContext(ctx, cfg.NixStoreBin, "--gc", "--print-roots").Output() if err != nil { return nil, cmdError(err) } return parseRuntime(cfg, out, known), nil } func parseRuntime(cfg Config, out []byte, known map[string]bool) []*Root { type group struct { targets map[string]bool } groups := map[string]*group{} var keys []string sc := bufio.NewScanner(bytes.NewReader(out)) sc.Buffer(make([]byte, 64*1024), 1024*1024) for sc.Scan() { link, target, ok := strings.Cut(sc.Text(), " -> ") if !ok || known[link] { continue } var key string switch { case strings.HasPrefix(link, "{"): key = link case strings.HasPrefix(link, "/proc/"): rest := strings.TrimPrefix(link, "/proc/") if i := strings.IndexByte(rest, '/'); i >= 0 { rest = rest[:i] } key = "/proc/" + rest default: continue } g := groups[key] if g == nil { g = &group{targets: map[string]bool{}} groups[key] = g keys = append(keys, key) } g.targets[target] = true } sort.Strings(keys) var res []*Root for _, k := range keys { g := groups[k] r := &Root{Link: k, Kind: KindRuntime, Count: len(g.targets), ClosureSize: -1, NarSize: -1, UID: -1} if len(g.targets) == 1 { for t := range g.targets { r.Target = t } } if strings.HasPrefix(k, "/proc/") { if b, err := os.ReadFile(k + "/cmdline"); err == nil { r.Command = strings.TrimSpace(strings.ReplaceAll(string(b), "\x00", " ")) } if st, err := os.Stat(k); err == nil { r.ModTime = st.ModTime() if sys, ok := st.Sys().(*syscall.Stat_t); ok { r.UID = int(sys.Uid) if u, err := user.LookupId(strconv.Itoa(r.UID)); err == nil { r.Owner = u.Username } else { r.Owner = strconv.Itoa(r.UID) } } } } res = append(res, r) } return res } func cmdError(err error) error { var ee *exec.ExitError if errors.As(err, &ee) && len(ee.Stderr) > 0 { return errors.New(strings.TrimSpace(string(ee.Stderr))) } return err } // Set is a thread safe, refreshable collection of roots shared by the TUI // and the web server. type Set struct { Cfg Config // refreshMu serialises Refresh so a scan that started before a delete // cannot land after it and resurrect the deleted roots. refreshMu sync.Mutex mu sync.RWMutex roots []*Root scannedAt time.Time runtime bool sizing bool sizesDone int sizesTodo int sizeCache map[string][2]int64 listeners []func() } func NewSet(cfg Config) *Set { return &Set{Cfg: cfg, sizeCache: map[string][2]int64{}} } // OnChange registers a callback invoked (from any goroutine) when roots or // sizes change. func (s *Set) OnChange(f func()) { s.mu.Lock() s.listeners = append(s.listeners, f) s.mu.Unlock() } func (s *Set) notify() { s.mu.RLock() ls := append([]func(){}, s.listeners...) s.mu.RUnlock() for _, f := range ls { f() } } // Snapshot returns copies of the current roots so callers can sort and // filter without locking. func (s *Set) Snapshot() []Root { s.mu.RLock() defer s.mu.RUnlock() out := make([]Root, len(s.roots)) for i, r := range s.roots { out[i] = *r } return out } type Status struct { Total int ScannedAt time.Time Sizing bool SizesDone int SizesTodo int Runtime bool } func (s *Set) Status() Status { s.mu.RLock() defer s.mu.RUnlock() return Status{len(s.roots), s.scannedAt, s.sizing, s.sizesDone, s.sizesTodo, s.runtime} } // SetRuntime toggles whether the next Refresh includes runtime roots. func (s *Set) SetRuntime(on bool) { s.mu.Lock() s.runtime = on s.mu.Unlock() } // Refresh rescans roots and starts computing sizes in the background. func (s *Set) Refresh(ctx context.Context) error { s.refreshMu.Lock() defer s.refreshMu.Unlock() rs, err := Scan(s.Cfg) if err != nil { return err } s.mu.RLock() wantRuntime := s.runtime s.mu.RUnlock() if wantRuntime { known := map[string]bool{} for _, r := range rs { known[r.Link] = true } rt, err := ScanRuntime(ctx, s.Cfg, known) if err != nil { return err } rs = append(rs, rt...) } s.mu.Lock() var todo []string pending := map[string]bool{} for _, r := range rs { if r.Target == "" { continue } if sz, ok := s.sizeCache[r.Target]; ok { r.ClosureSize, r.NarSize = sz[0], sz[1] } else if !pending[r.Target] { pending[r.Target] = true todo = append(todo, r.Target) } } s.roots = rs s.scannedAt = time.Now() s.sizesDone, s.sizesTodo = 0, len(todo) s.sizing = len(todo) > 0 s.mu.Unlock() s.notify() if len(todo) > 0 { go s.computeSizes(ctx, todo) } return nil } func (s *Set) computeSizes(ctx context.Context, paths []string) { QuerySizes(ctx, s.Cfg, paths, func(batch map[string][2]int64, n int) { s.mu.Lock() for p, sz := range batch { s.sizeCache[p] = sz } for _, r := range s.roots { if sz, ok := batch[r.Target]; ok { r.ClosureSize, r.NarSize = sz[0], sz[1] } } s.sizesDone += n s.mu.Unlock() s.notify() }) s.mu.Lock() s.sizing = false s.mu.Unlock() s.notify() } // Remove drops roots from the set after a successful delete, without a full // rescan. func (s *Set) Remove(links map[string]bool) { s.mu.Lock() kept := s.roots[:0:0] for _, r := range s.roots { if !links[r.Link] { kept = append(kept, r) } } s.roots = kept s.mu.Unlock() s.notify() } // Lookup returns the current roots with the given link paths. func (s *Set) Lookup(links []string) []Root { want := map[string]bool{} for _, l := range links { want[l] = true } s.mu.RLock() defer s.mu.RUnlock() var out []Root for _, r := range s.roots { if want[r.Link] { out = append(out, *r) } } return out }