@hienlh/ppm 0.23.5 → 0.23.7

package/src/services/system-metrics/gpu-fdinfo-linux.ts

@@ -0,0 +1,253 @@
+/**
+ * Per-process GPU accounting from DRM fdinfo — the same source nvtop and Mission
+ * Center use, and the only one that works for Intel and AMD without root.
+ *
+ * `/proc/<pid>/fdinfo/<fd>` of a DRM file carries cumulative engine busy time in
+ * nanoseconds. Two things make it trickier than a counter read:
+ *
+ *  - walking every fd of every process costs ~140 ms on a desktop with 3000
+ *    threads, which a 2 s tick cannot pay. Only a handful of processes ever hold
+ *    a DRM fd (15 of 558 here), so the full scan runs on a slow cadence and every
+ *    other tick re-reads just those — measured at ~2 ms, a 70x saving.
+ *  - a client's fds are SHARED across its threads and often dup'd, so the same
+ *    counters appear many times; `drm-client-id` identifies the real client and
+ *    is what deduplicates them. Summing without that multiplies a browser's GPU
+ *    use by its thread count.
+ *  - the counter is per engine, so "GPU %" is engine busy over WALL time, not
+ *    over some total — an engine can only ever be busy for the time that passed.
+ */
+import { realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+
+const PROC = "/proc";
+const DRI_PREFIX = "/dev/dri/";
+
+export interface DrmClient {
+  /** PCI address the client is rendering on, e.g. "0000:00:02.0". */
+  pdev: string;
+  /** Unique per open client on that device; the deduplication key with `pdev`. */
+  clientId: string;
+  driver: string;
+  pid: number;
+  /** Engine name ("render", "copy", "video", "video-enhance", "compute") → ns. */
+  engines: Map<string, number>;
+  /** Dedicated (VRAM) bytes this client holds; 0 on an integrated GPU. */
+  vramBytes: number;
+  /** System/GTT bytes this client holds. */
+  sharedBytes: number;
+}
+
+/** One fdinfo file. Null when it is not a DRM fd (the overwhelming majority). */
+export function parseDrmFdinfo(text: string, pid: number): DrmClient | null {
+  let pdev = "";
+  let clientId = "";
+  let driver = "";
+  let vramBytes = 0;
+  let sharedBytes = 0;
+  const engines = new Map<string, number>();
+
+  for (const line of text.split("\n")) {
+    if (!line.startsWith("drm-")) continue;
+    const sep = line.indexOf(":");
+    if (sep < 0) continue;
+    const key = line.slice(0, sep);
+    const value = line.slice(sep + 1).trim();
+
+    if (key === "drm-pdev") pdev = value;
+    else if (key === "drm-client-id") clientId = value;
+    else if (key === "drm-driver") driver = value;
+    else if (key.startsWith("drm-engine-")) {
+      const ns = Number(value.split(/\s+/)[0]);
+      if (Number.isFinite(ns)) engines.set(key.slice("drm-engine-".length), ns);
+    } else if (key.startsWith("drm-total-")) {
+      // `drm-total-vram0`/`-vram` is dedicated; `-system0`/`-gtt` is shared.
+      const region = key.slice("drm-total-".length);
+      const bytes = parseMemoryValue(value);
+      if (region.startsWith("vram")) vramBytes += bytes;
+      else if (region.startsWith("system") || region.startsWith("gtt")) sharedBytes += bytes;
+    }
+  }
+
+  if (!pdev || !clientId) return null;
+  return { pdev, clientId, driver, pid, engines, vramBytes, sharedBytes };
+}
+
+/** fdinfo writes memory as "74920 KiB" (i915) or a bare byte count (amdgpu). */
+export function parseMemoryValue(value: string): number {
+  const [raw, unit] = value.split(/\s+/);
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return 0;
+  switch (unit) {
+    case "KiB": return n * 1024;
+    case "MiB": return n * 1024 ** 2;
+    case "GiB": return n * 1024 ** 3;
+    default: return n;
+  }
+}
+
+/**
+ * Every distinct DRM client on the machine, deduplicated by (pdev, client-id).
+ *
+ * Only fds whose `/proc/<pid>/fd/<n>` link points into `/dev/dri` are read: one
+ * `readlink` beats an `open`+`read`+`close` on every fd of every process, and on
+ * a desktop with ~3000 threads that is the difference between a few ms and a
+ * tick that misses its deadline.
+ */
+export function collectDrmClients(
+  fs: Pick<LinuxFs, "list" | "read" | "readlink"> = realLinuxFs,
+  onlyPids?: readonly number[],
+): DrmClient[] {
+  const byKey = new Map<string, DrmClient>();
+  const candidates = onlyPids ?? (fs.list(PROC) ?? []).map(Number);
+  for (const entry of candidates) {
+    const pid = Number(entry);
+    if (!Number.isInteger(pid) || pid <= 0) continue;
+    for (const fd of fs.list(`${PROC}/${pid}/fd`) ?? []) {
+      if (!fs.readlink(`${PROC}/${pid}/fd/${fd}`)?.startsWith(DRI_PREFIX)) continue;
+      const text = fs.read(`${PROC}/${pid}/fdinfo/${fd}`);
+      if (!text) continue;
+      const client = parseDrmFdinfo(text, pid);
+      if (!client) continue;
+      const key = `${client.pdev}/${client.clientId}`;
+      // The lowest pid holding a client is its owner; a dup in a child would
+      // otherwise attribute the parent's rendering to whichever fd came last.
+      const existing = byKey.get(key);
+      if (!existing || client.pid < existing.pid) byKey.set(key, client);
+    }
+  }
+  return [...byKey.values()];
+}
+
+/** Cumulative engine ns per client, plus the clock they were read at. */
+export interface DrmEngineState {
+  atSec: number;
+  /** "<pdev>/<clientId>" → engine → ns. */
+  byClient: Map<string, Map<string, number>>;
+}
+
+export interface DrmUsage {
+  /** pdev → engine → busy percent over the interval (0-100 per engine). */
+  perDevice: Map<string, Map<string, number>>;
+  /** pid → summed engine percent (clamped 0-100) and memory in MB. */
+  perProcess: Map<number, { gpuPct: number; vramMB: number; sharedMB: number }>;
+  /**
+   * pdev → system/GTT memory its clients hold, MB. This is the ONLY whole-device
+   * memory figure an integrated GPU has: i915 publishes no `mem_info_*` sysfs
+   * attribute, so without it the page can say nothing at all.
+   *
+   * A buffer shared between two clients is counted twice, because fdinfo's
+   * `drm-total-*` is per client and the `drm-shared-*` line does not say WHO it
+   * is shared with. Mission Center sums the same way — measured against it live,
+   * 2.54 GiB here against its 2.52 GiB.
+   */
+  sharedByDevice: Map<string, number>;
+}
+
+export function toEngineState(clients: readonly DrmClient[], atSec: number): DrmEngineState {
+  const byClient = new Map<string, Map<string, number>>();
+  for (const c of clients) byClient.set(`${c.pdev}/${c.clientId}`, c.engines);
+  return { atSec, byClient };
+}
+
+/**
+ * Engine busy over the wall interval. A client that did not exist on the previous
+ * sample contributes nothing this tick — measuring its whole lifetime against one
+ * interval is how a freshly launched window reads as 4000 % GPU.
+ */
+export function computeDrmUsage(
+  prev: DrmEngineState | null,
+  clients: readonly DrmClient[],
+  atSec: number,
+): DrmUsage {
+  const perDevice = new Map<string, Map<string, number>>();
+  const perProcess = new Map<number, { gpuPct: number; vramMB: number; sharedMB: number }>();
+  const sharedByDevice = new Map<string, number>();
+  const dtNs = prev ? (atSec - prev.atSec) * 1e9 : 0;
+
+  for (const c of clients) {
+    const MB = 1024 ** 2;
+    const row = perProcess.get(c.pid) ?? { gpuPct: 0, vramMB: 0, sharedMB: 0 };
+    row.vramMB += c.vramBytes / MB;
+    row.sharedMB += c.sharedBytes / MB;
+    // Every device a client was seen on gets an entry, even at 0 bytes: "this
+    // GPU's clients hold nothing" is a reading, and no entry at all is not.
+    sharedByDevice.set(c.pdev, (sharedByDevice.get(c.pdev) ?? 0) + c.sharedBytes / MB);
+
+    if (dtNs > 0) {
+      const before = prev!.byClient.get(`${c.pdev}/${c.clientId}`);
+      if (before) {
+        const engines = perDevice.get(c.pdev) ?? new Map<string, number>();
+        for (const [engine, ns] of c.engines) {
+          const delta = ns - (before.get(engine) ?? 0);
+          if (delta <= 0) continue;
+          const pct = Math.min(100, delta / dtNs * 100);
+          engines.set(engine, (engines.get(engine) ?? 0) + pct);
+          row.gpuPct += pct;
+        }
+        perDevice.set(c.pdev, engines);
+      }
+    }
+    row.gpuPct = Math.min(100, row.gpuPct);
+    perProcess.set(c.pid, row);
+  }
+
+  // A device's engine can only be busy for the interval that passed.
+  for (const engines of perDevice.values()) {
+    for (const [engine, pct] of engines) engines.set(engine, Math.min(100, round1(pct)));
+  }
+  for (const row of perProcess.values()) {
+    row.gpuPct = round1(row.gpuPct);
+    row.vramMB = round1(row.vramMB);
+    row.sharedMB = round1(row.sharedMB);
+  }
+  for (const [pdev, mb] of sharedByDevice) sharedByDevice.set(pdev, round1(mb));
+  return { perDevice, perProcess, sharedByDevice };
+}
+
+const round1 = (n: number) => Math.round(n * 10) / 10;
+
+// ------------------------------------------------------- stateful collector
+
+/** How long one walk's result is reused. Both the whole-GPU figures and the
+ *  process rows are built from the same tick, so whichever asks first pays for
+ *  the walk and the other reads the same numbers — they can never disagree. */
+export const DRM_MEMO_MS = 1000;
+/** Full `/proc` rescans are this far apart; in between, only the pids already
+ *  known to hold a DRM fd are re-read. A window opened now shows GPU use within
+ *  one rescan rather than immediately, which is the cost of not paying 140 ms
+ *  every 2 s forever. */
+export const DRM_RESCAN_MS = 10_000;
+
+export interface DrmGpuCollector {
+  /** This tick's usage, walking `/proc` at most once per `DRM_MEMO_MS`. */
+  usage(): DrmUsage;
+}
+
+export function createDrmGpuCollector(
+  fs: Pick<LinuxFs, "list" | "read" | "readlink"> = realLinuxFs,
+  now: () => number = Date.now,
+): DrmGpuCollector {
+  let state: DrmEngineState | null = null;
+  let knownPids: number[] = [];
+  let lastFullScanAt = 0;
+  let memo: { at: number; usage: DrmUsage } | null = null;
+
+  return {
+    usage(): DrmUsage {
+      const at = now();
+      if (memo && at - memo.at < DRM_MEMO_MS) return memo.usage;
+
+      const full = knownPids.length === 0 || at - lastFullScanAt >= DRM_RESCAN_MS;
+      const clients = collectDrmClients(fs, full ? undefined : knownPids);
+      if (full) {
+        lastFullScanAt = at;
+        knownPids = [...new Set(clients.map((c) => c.pid))];
+      }
+
+      const atSec = at / 1000;
+      const usage = computeDrmUsage(state, clients, atSec);
+      state = toEngineState(clients, atSec);
+      memo = { at, usage };
+      return usage;
+    },
+  };
+}

package/src/services/system-metrics/hardware-inventory.ts

@@ -0,0 +1,50 @@
+/**
+ * Static hardware facts, served by `GET /api/system/hardware` instead of riding
+ * every 2 s snapshot: a drive's model and capacity do not change, and sending
+ * them 1800 times an hour over a tunnel would be the largest part of the frame.
+ *
+ * Async only because the OpenGL/Vulkan versions come from a one-shot tool; that
+ * result is cached for the process lifetime, so every call after the first is
+ * a handful of small sysfs and udev reads with no cache and no subprocess — a
+ * drive plugged in is visible on the client's next refetch rather than after a TTL.
+ */
+import type { HardwareInventory } from "../../types/system-hardware.ts";
+import type { MetricsPlatform } from "../../types/system-metrics.ts";
+import { toMetricsPlatform } from "./system-metrics-platform.ts";
+import { readDiskInventory } from "./disk-inventory-linux.ts";
+import { attachPartitionUsage } from "./partitions-linux.ts";
+import { readNicInventory } from "./net-inventory-linux.ts";
+import { readCpuInfo } from "./cpu-details-linux.ts";
+import { readMemoryInfo } from "./memory-linux.ts";
+import { listGpuCards, readGpuInfo } from "./gpu-devices-linux.ts";
+import { createGpuApiVersionReader, type GpuApiVersionReader } from "./gpu-api-versions.ts";
+import { realLinuxFs } from "./linux-fs.ts";
+
+const apiVersions = createGpuApiVersionReader();
+
+/** Windows and macOS report no devices yet; the client hides the sections rather
+ *  than showing empty ones, exactly as it does for a host with no GPU. */
+export async function readHardwareInventory(
+  platform: MetricsPlatform = toMetricsPlatform(),
+  now: () => number = Date.now,
+  api: GpuApiVersionReader = apiVersions,
+): Promise<HardwareInventory> {
+  const base = { platform, ts: now(), disks: [], nics: [], gpus: [] } satisfies HardwareInventory;
+  if (platform !== "linux") return base;
+
+  const cpu = readCpuInfo();
+  const versions = await api.read();
+  // statfs per mount, off the event loop and in parallel — see partitions-linux.
+  const disks = readDiskInventory();
+  await attachPartitionUsage(disks);
+  return {
+    ...base,
+    disks,
+    nics: readNicInventory(),
+    memory: readMemoryInfo(),
+    // NVIDIA is deliberately included here: the static facts (name, PCIe link)
+    // come from sysfs for every driver, even where the live figures do not.
+    gpus: listGpuCards(realLinuxFs).map((card) => readGpuInfo(card, versions, realLinuxFs)),
+    ...(cpu ? { cpu } : {}),
+  };
+}

package/src/services/system-metrics/linux-fs.ts

@@ -0,0 +1,43 @@
+/**
+ * Injectable filesystem access for the /proc and /sys collectors, so every parser
+ * is fixture-tested without a real host. Each call returns null instead of
+ * throwing: a device or a process vanishing between a directory listing and the
+ * read is the normal case here, not an error worth a stack trace per tick.
+ */
+import { existsSync, readdirSync, readFileSync, readlinkSync, realpathSync } from "node:fs";
+
+export type FileReader = (path: string) => string | null;
+export type DirLister = (path: string) => string[] | null;
+export type LinkReader = (path: string) => string | null;
+
+export interface LinuxFs {
+  read: FileReader;
+  list: DirLister;
+  /** The link's own target, as written (often relative: `../../devices/...`). */
+  readlink: LinkReader;
+  /** Fully resolved absolute path, or null when it does not resolve. */
+  realpath: LinkReader;
+  exists: (path: string) => boolean;
+}
+
+export const realLinuxFs: LinuxFs = {
+  read: (path) => { try { return readFileSync(path, "utf-8"); } catch { return null; } },
+  list: (path) => { try { return readdirSync(path); } catch { return null; } },
+  readlink: (path) => { try { return readlinkSync(path); } catch { return null; } },
+  realpath: (path) => { try { return realpathSync(path); } catch { return null; } },
+  exists: (path) => existsSync(path),
+};
+
+/** A sysfs attribute as a trimmed string, or undefined when absent or blank. */
+export function readAttr(fs: Pick<LinuxFs, "read">, path: string): string | undefined {
+  const v = fs.read(path)?.trim();
+  return v ? v : undefined;
+}
+
+/** A sysfs attribute as a finite number, or undefined. */
+export function readNumber(fs: Pick<LinuxFs, "read">, path: string): number | undefined {
+  const v = readAttr(fs, path);
+  if (v === undefined) return undefined;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : undefined;
+}

package/src/services/system-metrics/memory-darwin.ts

@@ -0,0 +1,91 @@
+/**
+ * macOS swap, which is the one memory figure the platform publishes and `node:os`
+ * does not.
+ *
+ * Off Linux every swap field was absent, and the memory page renders an absent
+ * field as an em dash — i.e. as the claim "this host's swap cannot be measured".
+ * On a Mac it can: `vm.swapusage` is a single sysctl. On the host this was found
+ * on it read **8047 MB of 9216 MB in use**, which is the most consequential thing
+ * that page could have been saying about the machine and was saying nothing about.
+ *
+ * `vm_stat` is deliberately not used here. It carries page counts but no swap at
+ * all, and the page counts are not needed: `os.freemem()` on darwin agrees with
+ * what `top` calls unused (75 MB against PPM's 124 MB on the same host, sampled
+ * seconds apart), so the cross-platform figure is already the one Activity
+ * Monitor shows. Do not "fix" it against `memory_pressure`, whose free
+ * percentage measures what could be reclaimed under duress and read 56% on a
+ * machine `top` called 31G used.
+ *
+ * The per-tick cost was measured rather than assumed, because this runs on every
+ * tick: **1.33 ms/call**, against the 1.7 ms `/proc/<pid>/io` already costs per
+ * tick on Linux. It stays `spawnSync` because `collectMemory` is synchronous and
+ * making the whole memory step async for one number is the larger change.
+ */
+import type { MemoryMetrics } from "../../types/system-metrics.ts";
+
+type SwapFields = Pick<MemoryMetrics, "swapTotalMB" | "swapUsedMB">;
+
+/** `total = 9216.00M  used = 8047.00M  free = 1169.00M  (encrypted)` */
+const SWAP_RE = /total\s*=\s*([\d.]+)([KMGT])?\b[\s\S]*?used\s*=\s*([\d.]+)([KMGT])?\b/i;
+
+const MB_PER_UNIT: Record<string, number> = { K: 1 / 1024, M: 1, G: 1024, T: 1024 * 1024 };
+
+const round1 = (n: number): number => Math.round(n * 10) / 10;
+
+/**
+ * Pure half, so the format can be tested without a Mac.
+ *
+ * `undefined` rather than zeroes when the text does not parse: a shape this code
+ * does not recognise is a host it did not measure, and 0 would be a claim that
+ * the machine has no swap.
+ */
+export function parseSwapUsage(text: string | null | undefined): SwapFields | undefined {
+  if (!text) return undefined;
+  const m = SWAP_RE.exec(text);
+  if (!m) return undefined;
+
+  const toMB = (value: string, unit: string | undefined): number | null => {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 0) return null;
+    // A bare number is bytes. The format normally carries a suffix, but a swap
+    // file of zero prints as `0.00M` on some releases and `0` on others, and
+    // reading that second form as megabytes would invent 0 MB either way — it
+    // is only correct here because the value is zero.
+    return unit ? n * (MB_PER_UNIT[unit.toUpperCase()] ?? 1) : n / (1024 * 1024);
+  };
+
+  const total = toMB(m[1]!, m[2]);
+  const used = toMB(m[3]!, m[4]);
+  if (total === null || used === null) return undefined;
+
+  return {
+    swapTotalMB: round1(total),
+    // Clamped, because a used figure above the total is not a bigger swap, it is
+    // a sample taken while the file was being resized.
+    swapUsedMB: round1(Math.min(Math.max(used, 0), total)),
+  };
+}
+
+/**
+ * `null` on every platform but darwin, so nothing is spawned where the figure
+ * already comes from `/proc/meminfo` or from CIM.
+ */
+export function readSwapUsage(): string | null {
+  if (process.platform !== "darwin") return null;
+  try {
+    const result = Bun.spawnSync(["sysctl", "-n", "vm.swapusage"], {
+      stdout: "pipe",
+      stderr: "ignore",
+      stdin: "ignore",
+    });
+    if (result.exitCode !== 0) return null;
+    return new TextDecoder().decode(result.stdout);
+  } catch {
+    // `Bun.spawn` raises `Executable not found in $PATH` *synchronously* for a
+    // missing binary rather than reporting it through an exit code, and
+    // `spawnSync` is no different — the same trap `spawn-runner.ts` carries a
+    // comment about. A stripped-down host without `sysctl` gets an em dash, not
+    // a collector that throws mid-tick.
+    return null;
+  }
+}

package/src/services/system-metrics/memory-linux.ts

@@ -0,0 +1,156 @@
+/**
+ * Mission Center's memory page: the composition bar and the figures under it,
+ * all from `/proc/meminfo`, plus the populated slots from the SMBIOS table udev
+ * already decoded into its database (the raw table needs root; this does not).
+ */
+import type { MemoryMetrics } from "../../types/system-metrics.ts";
+import type { MemoryDeviceInfo, MemoryInfo } from "../../types/system-hardware.ts";
+import { realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+import { readUdevProperties, udevValue } from "./udev-db.ts";
+
+/** udev's own name for the SMBIOS record. */
+export const DMI_UDEV_DEVICE = "+dmi:id";
+const MB = 1024 * 1024;
+
+/** Every `Key: N kB` line as BYTES. Values without a unit (the HugePages counts)
+ *  are kept verbatim, which is what they mean. */
+export function parseMeminfo(text: string): Map<string, number> {
+  const out = new Map<string, number>();
+  for (const line of text.split("\n")) {
+    const sep = line.indexOf(":");
+    if (sep < 0) continue;
+    const rest = line.slice(sep + 1).trim();
+    const [rawValue, unit] = rest.split(/\s+/);
+    const n = Number(rawValue);
+    if (!Number.isFinite(n)) continue;
+    out.set(line.slice(0, sep), unit === "kB" ? n * 1024 : n);
+  }
+  return out;
+}
+
+/**
+ * Adds the composition and the swap/commit figures to the cross-platform base.
+ *
+ * The four parts add up to the total EXACTLY and "in use" is exactly the headline
+ * `usedMB` (total - MemAvailable), so the bar and the figure beside it can never
+ * disagree. Standby is the rest of what the kernel would hand back on demand
+ * (MemAvailable - MemFree), and modified is carved out of it rather than added —
+ * a dirty page is also a cached page, so adding the two would overflow the bar.
+ */
+export function enrichMemory(
+  base: MemoryMetrics,
+  text: string | null,
+  zram: ZramTotals | undefined = undefined,
+): MemoryMetrics {
+  if (!text) return base;
+  const m = parseMeminfo(text);
+  const total = m.get("MemTotal");
+  if (total === undefined || total <= 0) return base;
+
+  const get = (k: string) => m.get(k) ?? 0;
+  const free = clamp(get("MemFree"), 0, total);
+  const available = clamp(m.get("MemAvailable") ?? free, free, total);
+  const reclaimable = available - free;
+  const modified = clamp(get("Dirty") + get("Writeback"), 0, reclaimable);
+  const swapTotal = get("SwapTotal");
+
+  return {
+    ...base,
+    inUseBytes: total - available,
+    modifiedBytes: modified,
+    standbyBytes: reclaimable - modified,
+    freeBytes: free,
+    cachedMB: round1(get("Cached") / MB),
+    committedMB: round1(get("Committed_AS") / MB),
+    commitLimitMB: round1(get("CommitLimit") / MB),
+    swapTotalMB: round1(swapTotal / MB),
+    swapUsedMB: round1(Math.max(swapTotal - get("SwapFree"), 0) / MB),
+    ...(zram
+      ? {
+          zramCompressedMB: round1(zram.compressedBytes / MB),
+          zramSavingsMB: round1(zram.savingsBytes / MB),
+        }
+      : {}),
+  };
+}
+
+export interface ZramTotals {
+  compressedBytes: number;
+  savingsBytes: number;
+}
+
+/**
+ * `/sys/block/zram<N>/mm_stat`, summed over every device — a host can have one
+ * per CPU. Undefined when there is no zram at all, which is a different answer
+ * from a zram holding nothing: the Memory page hides the rows in the first case
+ * and shows zeroes in the second.
+ *
+ * Field order (Documentation/admin-guide/blockdev/zram.rst): orig_data_size,
+ * compr_data_size, mem_used_total, mem_limit, mem_used_max, same_pages,
+ * pages_compacted, huge_pages. Savings is orig minus compr, which is what
+ * Mission Center shows — NOT orig minus mem_used_total, which also subtracts
+ * zram's own allocator overhead and reads several percent low.
+ */
+export function readZramTotals(fs: LinuxFs = realLinuxFs): ZramTotals | undefined {
+  const devices = (fs.list("/sys/block") ?? []).filter((n) => /^zram\d+$/.test(n));
+  if (devices.length === 0) return undefined;
+  let compressedBytes = 0;
+  let savingsBytes = 0;
+  let any = false;
+  for (const dev of devices) {
+    const stat = fs.read(`/sys/block/${dev}/mm_stat`)?.trim().split(/\s+/);
+    if (!stat || stat.length < 2) continue;
+    const orig = Number(stat[0]);
+    const compr = Number(stat[1]);
+    if (!Number.isFinite(orig) || !Number.isFinite(compr)) continue;
+    any = true;
+    compressedBytes += compr;
+    savingsBytes += Math.max(0, orig - compr);
+  }
+  return any ? { compressedBytes, savingsBytes } : undefined;
+}
+
+const clamp = (v: number, lo: number, hi: number) => Math.min(Math.max(v, lo), hi);
+
+/** The populated slots, in board order. `MEMORY_DEVICE_<n>_*` is udev's decode of
+ *  SMBIOS type 17; an empty slot has no `SIZE`, so it simply does not appear. */
+export function readMemoryInfo(fs: Pick<LinuxFs, "read"> = realLinuxFs): MemoryInfo {
+  const props = readUdevProperties(DMI_UDEV_DEVICE, fs.read);
+  const devices: MemoryDeviceInfo[] = [];
+
+  for (let i = 0; ; i++) {
+    const prefix = `MEMORY_DEVICE_${i}_`;
+    const locator = udevValue(props, `${prefix}LOCATOR`);
+    const size = Number(udevValue(props, `${prefix}SIZE`));
+    // udev numbers the slots contiguously, so the first gap is the end of the list.
+    if (!locator && !Number.isFinite(size)) break;
+    if (i > 64) break;
+    if (!locator || !Number.isFinite(size) || size <= 0) continue;
+    devices.push({
+      locator,
+      sizeBytes: size,
+      ...defined("bankLocator", udevValue(props, `${prefix}BANK_LOCATOR`)),
+      ...defined("formFactor", udevValue(props, `${prefix}FORM_FACTOR`)),
+      ...defined("ramType", udevValue(props, `${prefix}TYPE`)),
+      ...defined("speedMts", positive(udevValue(props, `${prefix}SPEED_MTS`))),
+      ...defined("manufacturer", udevValue(props, `${prefix}MANUFACTURER`)),
+      ...defined("rank", positive(udevValue(props, `${prefix}RANK`))),
+    });
+  }
+
+  return {
+    devices,
+    ...defined("maxCapacityBytes", positive(udevValue(props, "MEMORY_ARRAY_MAX_CAPACITY"))),
+  };
+}
+
+const round1 = (n: number) => Math.round(n * 10) / 10;
+
+function positive(raw: string | undefined): number | undefined {
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
+function defined<K extends string, V>(key: K, value: V | undefined): Partial<Record<K, V>> {
+  return value === undefined ? {} : ({ [key]: value } as Record<K, V>);
+}