mantle/system/nproc: account for page cache in cgroup available memory

The cgroup available memory calculation used memory.current (total
cgroup usage) directly, which includes page cache (file-backed memory).
Since inactive page cache is reclaimable by the kernel under memory
pressure, it should not count as unavailable. This caused GetCurrentMemAvailableMiB()
to significantly underestimate available memory, making QEMU instance
scheduling overly conservative.

Read the "inactive_file" field from /sys/fs/cgroup/memory.stat, which
reports the page cache size that can be reclaimed easily in bytes, and
subtract it from current usage before computing available memory. The
effective formula becomes:

  available = limit - (current - inactive_file)

This mirrors how /proc/meminfo computes MemAvailable by considering
reclaimable caches.

A new helper getCgroupMemoryStatField() is added for parsing individual
fields from memory.stat, returning 0 gracefully if the file or field is
absent.

Written-by: <anthropic/claude-opus-4.6>

Author: dustymabe

mantle/system/nproc.go

@@ -176,7 +176,15 @@ func getCgroupMemoryLimitMiB() (uint, error) {
 }
 
 // getCgroupMemoryAvailableMiB returns the available memory within the
-// cgroup v2 in MiB (limit - current usage), or math.MaxUint if no limit.
+// cgroup v2 in MiB, or math.MaxUint if no limit is set. It computes
+// available memory as: limit - (current - inactive_file) where inactive_file
+// is not actively used file caches that can be evicted if needed.
+// (current - inactive_file) is similar to the "workingSet" calculation over in [1].
+// More context on this also in [2]. This is similar to how /proc/meminfo computes
+// MemAvailable by considering reclaimable caches.
+//
+// [1] https://github.com/kubernetes/kubernetes/blob/ac10370ad2aebde82c2d268dd80d08df0ffc2532/test/e2e/node/node_problem_detector.go#L290-L344
+// [2] https://github.com/kata-containers/kata-containers/issues/10280
 func getCgroupMemoryAvailableMiB() (uint, error) {
 	maxBuf, err := os.ReadFile("/sys/fs/cgroup/memory.max")
 	if os.IsNotExist(err) {
@@ -200,8 +208,57 @@ func getCgroupMemoryAvailableMiB() (uint, error) {
 	if err != nil {
 		return 0, fmt.Errorf("invalid memory.current value: %w", err)
 	}
-	if current >= limit {
+
+	// Read inactive_file size from memory.stat to exclude reclaimable
+	// file-backed memory from the usage calculation.
+	inactiveFile, err := getCgroupMemoryStatField("inactive_file")
+	if err != nil {
+		return 0, err
+	}
+
+	// Subtract the inactive_file size from the memory.current. This
+	// cache should always be less than the memory.current but add
+	// a check and do nothing just in case.
+	usage := current
+	if inactiveFile < usage {
+		usage -= inactiveFile
+	}
+
+	// This also shouldn't happen, but in case the usage is larger
+	// than the limit let's just return that there's 0 available memory.
+	if usage >= limit {
+		return 0, nil
+	}
+	return uint((limit - usage) / (1024 * 1024)), nil
+}
+
+// getCgroupMemoryStatField reads a specific field from
+// /sys/fs/cgroup/memory.stat and returns its value in bytes.
+// The file contains key-value pairs like "file 123456789".
+// Returns 0 if the file does not exist or the field is not found.
+func getCgroupMemoryStatField(field string) (uint64, error) {
+	f, err := os.Open("/sys/fs/cgroup/memory.stat")
+	if os.IsNotExist(err) {
 		return 0, nil
+	} else if err != nil {
+		return 0, fmt.Errorf("reading memory.stat: %w", err)
+	}
+	defer f.Close()
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		parts := strings.Fields(scanner.Text())
+		if len(parts) == 2 && parts[0] == field {
+			val, err := strconv.ParseUint(parts[1], 10, 64)
+			if err != nil {
+				return 0, fmt.Errorf("parsing memory.stat field %s: %w", field, err)
+			}
+			return val, nil
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return 0, fmt.Errorf("scanning memory.stat: %w", err)
 	}
-	return uint((limit - current) / (1024 * 1024)), nil
+	// Field not found; return 0 so callers degrade gracefully.
+	return 0, nil
 }