@hienlh/ppm 0.23.6 → 0.23.7

package/src/services/system-metrics/disk-devices-linux.ts

@@ -0,0 +1,156 @@
+/**
+ * Per-disk figures for the Performance page's drive entries, from
+ * `/sys/block/<dev>/stat`. The arithmetic is Mission Center's
+ * (`platform-linux/src/disks/stats.rs`): busy% is iostat's %util, response time
+ * is weighted ticks over completed requests, and throughput is sectors x 512.
+ *
+ * Every device is sampled against its OWN previous sample, so a drive that
+ * appears mid-session reports `available:false` for one tick instead of a spike
+ * measured from zero.
+ */
+import type { DiskMetrics } from "../../types/system-metrics.ts";
+import { readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+
+export const SYS_BLOCK = "/sys/block";
+const SECTOR_BYTES = 512;
+
+/** Mission Center's list, matched on a 2-4 character prefix: virtual devices
+ *  whose counters double-count the real drive underneath, or are not a drive. */
+const IGNORED_PREFIXES = ["loop", "ram", "zram", "fd", "md", "dm", "zd"];
+
+/** `/sys/block/<dev>/stat` field indices. The line has 17 fields since 5.5; the
+ *  discard group (12-16) and flush group (17-18) are absent on older kernels,
+ *  which reads as 0 here rather than as an error. */
+const IDX = {
+  readIos: 0, readSectors: 2, readTicks: 3,
+  writeIos: 4, writeSectors: 6, writeTicks: 7,
+  ioTicks: 9,
+  discardIos: 11, discardTicks: 14,
+  flushIos: 15, flushTicks: 16,
+} as const;
+
+export interface DiskSample {
+  /** Wall clock in seconds — the sysfs stat line carries no timestamp. */
+  atSec: number;
+  readIos: number; readSectors: number; readTicks: number;
+  writeIos: number; writeSectors: number; writeTicks: number;
+  ioTicks: number;
+  discardIos: number; discardTicks: number;
+  flushIos: number; flushTicks: number;
+}
+
+/** Previous sample per device id. */
+export type DiskSampleState = Map<string, DiskSample>;
+
+export function isIgnoredDisk(id: string): boolean {
+  return IGNORED_PREFIXES.some((p) => id.startsWith(p));
+}
+
+/** Whole devices udev would call disks: skips the virtual prefixes and anything
+ *  reporting a zero size (an empty card reader, a detached loop device). */
+export function listDiskDevices(fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs): string[] {
+  const names = fs.list(SYS_BLOCK);
+  if (!names) return [];
+  return names
+    .filter((n) => !isIgnoredDisk(n))
+    .filter((n) => (readNumber(fs, `${SYS_BLOCK}/${n}/size`) ?? 0) > 0)
+    .sort();
+}
+
+export function parseDiskStat(text: string, atSec: number): DiskSample | null {
+  const f = text.trim().split(/\s+/).map(Number);
+  if (f.length < 11 || f.some((v) => !Number.isFinite(v))) return null;
+  const at = (i: number) => f[i] ?? 0;
+  return {
+    atSec,
+    readIos: at(IDX.readIos), readSectors: at(IDX.readSectors), readTicks: at(IDX.readTicks),
+    writeIos: at(IDX.writeIos), writeSectors: at(IDX.writeSectors), writeTicks: at(IDX.writeTicks),
+    ioTicks: at(IDX.ioTicks),
+    discardIos: at(IDX.discardIos), discardTicks: at(IDX.discardTicks),
+    flushIos: at(IDX.flushIos), flushTicks: at(IDX.flushTicks),
+  };
+}
+
+/** NVMe exposes a composite sensor at `device/hwmon<N>/temp1_input`; a SATA drive
+ *  exposes the same path only once `drivetemp` is loaded, which it usually is not
+ *  — hence undefined rather than 0. Millidegrees, one decimal kept. */
+export function readDiskTempC(id: string, fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs): number | undefined {
+  const dir = `${SYS_BLOCK}/${id}/device`;
+  const hwmon = fs.list(dir)?.find((n) => n.startsWith("hwmon"));
+  if (!hwmon) return undefined;
+  const milli = readNumber(fs, `${dir}/${hwmon}/temp1_input`);
+  return milli === undefined ? undefined : Math.round(milli / 100) / 10;
+}
+
+export interface DiskDeviceCollection {
+  disks: DiskMetrics[];
+  next: DiskSampleState;
+}
+
+/** One tick's worth of per-device figures. Devices absent from `prev` report
+ *  `available:false` — totals are still real, they are absolutes. */
+export function collectLinuxDiskDevices(
+  prev: DiskSampleState,
+  fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs,
+  now: () => number = Date.now,
+): DiskDeviceCollection {
+  const atSec = now() / 1000;
+  const next: DiskSampleState = new Map();
+  const disks: DiskMetrics[] = [];
+
+  for (const id of listDiskDevices(fs)) {
+    const text = fs.read(`${SYS_BLOCK}/${id}/stat`);
+    const sample = text ? parseDiskStat(text, atSec) : null;
+    if (!sample) continue;
+    next.set(id, sample);
+    disks.push(toDiskMetrics(id, prev.get(id) ?? null, sample, readDiskTempC(id, fs)));
+  }
+  return { disks, next };
+}
+
+export function toDiskMetrics(
+  id: string,
+  prev: DiskSample | null,
+  next: DiskSample,
+  tempC: number | undefined,
+): DiskMetrics {
+  const base: DiskMetrics = {
+    id,
+    available: false,
+    busyPercent: 0,
+    responseMs: 0,
+    readBps: 0,
+    writeBps: 0,
+    readTotal: next.readSectors * SECTOR_BYTES,
+    writeTotal: next.writeSectors * SECTOR_BYTES,
+    ...(tempC === undefined ? {} : { tempC }),
+  };
+
+  const dt = prev ? next.atSec - prev.atSec : 0;
+  // A device reset (hot-replug reusing the name) walks the counters backwards;
+  // one unavailable tick is the honest answer, not a negative rate.
+  if (!prev || !Number.isFinite(dt) || dt <= 0 || next.ioTicks < prev.ioTicks) return base;
+
+  const ticks = delta(next.readTicks, prev.readTicks) + delta(next.writeTicks, prev.writeTicks)
+    + delta(next.discardTicks, prev.discardTicks) + delta(next.flushTicks, prev.flushTicks);
+  const ios = delta(next.readIos, prev.readIos) + delta(next.writeIos, prev.writeIos)
+    + delta(next.discardIos, prev.discardIos) + delta(next.flushIos, prev.flushIos);
+
+  return {
+    ...base,
+    available: true,
+    busyPercent: round1(Math.min(100, delta(next.ioTicks, prev.ioTicks) / (dt * 10))),
+    responseMs: ios > 0 ? round2(ticks / ios) : 0,
+    readBps: Math.round(delta(next.readSectors, prev.readSectors) * SECTOR_BYTES / dt),
+    writeBps: Math.round(delta(next.writeSectors, prev.writeSectors) * SECTOR_BYTES / dt),
+  };
+}
+
+/** Saturating, as Mission Center's `saturating_sub`: these counters only ever
+ *  grow, so a negative delta is a reset and contributes nothing. */
+function delta(next: number, prev: number): number {
+  return next > prev ? next - prev : 0;
+}
+
+const round1 = (n: number) => Math.round(n * 10) / 10;
+const round2 = (n: number) => Math.round(n * 100) / 100;

package/src/services/system-metrics/disk-inventory-linux.ts

@@ -0,0 +1,150 @@
+/**
+ * Static facts about each whole disk: model, kind, capacity, serial, and which
+ * one carries the root filesystem. Read once per inventory request, not per tick.
+ *
+ * Mission Center gets all of this from udisks2 over D-Bus and SKIPS any drive
+ * udisks2 has no object for, which on a headless or container host is every
+ * drive. PPM reads sysfs plus udev's own database instead, so the list is the
+ * same one the kernel has and needs neither a system bus nor root.
+ */
+import type { DiskInfo, DiskKind } from "../../types/system-hardware.ts";
+import { readAttr, readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+import { readUdevProperties, udevValue } from "./udev-db.ts";
+import { listDiskDevices, SYS_BLOCK } from "./disk-devices-linux.ts";
+import { parseMountInfo, readPartitions } from "./partitions-linux.ts";
+
+const SECTOR_BYTES = 512;
+/** How far to follow `slaves` links from the root filesystem's device down to a
+ *  real drive (partition -> LUKS -> LVM -> RAID is already four). */
+const MAX_SLAVE_DEPTH = 8;
+
+/** The kernel fills SCSI's vendor field with the transport name for a SATA drive,
+ *  so "ATA" is never a manufacturer. Mission Center prints it; PPM drops it. */
+const GENERIC_VENDORS = new Set(["ATA", "SATA", "NVME", "USB", "SCSI"]);
+
+export function readDiskInventory(fs: LinuxFs = realLinuxFs): DiskInfo[] {
+  const systemDisk = findSystemDisk(fs);
+  // Parsed once for the whole inventory rather than per disk: mountinfo is one
+  // file describing every mount on the host, and re-reading it per drive is the
+  // same work times however many drives there are.
+  const mounts = parseMountInfo(fs.read("/proc/self/mountinfo") ?? "");
+  return listDiskDevices(fs).map((id) => readDiskInfo(id, fs, systemDisk === id, mounts));
+}
+
+export function readDiskInfo(
+  id: string,
+  fs: LinuxFs,
+  systemDisk: boolean,
+  mounts = parseMountInfo(fs.read("/proc/self/mountinfo") ?? ""),
+): DiskInfo {
+  const udev = readUdevProperties(blockDeviceKey(id, fs), fs.read);
+  const sectors = readNumber(fs, `${SYS_BLOCK}/${id}/size`) ?? 0;
+  const rpm = Number(udevValue(udev, "ID_ATA_ROTATION_RATE_RPM"));
+
+  return {
+    id,
+    ...optional("model", diskModel(id, fs, udev)),
+    kind: diskKind(id, fs, udev),
+    capacityBytes: sectors * SECTOR_BYTES,
+    systemDisk,
+    removable: readAttr(fs, `${SYS_BLOCK}/${id}/removable`) === "1",
+    ...optional("serial", readAttr(fs, `${SYS_BLOCK}/${id}/device/serial`) ?? udevValue(udev, "ID_SERIAL_SHORT")),
+    ...optional("wwn", diskWwn(id, fs, udev)),
+    ...(Number.isFinite(rpm) && rpm > 0 ? { rotationRpm: rpm } : {}),
+    partitions: readPartitions(id, fs, mounts),
+  };
+}
+
+/** udev keys a block device by `b<major>:<minor>`, which sysfs reports in `dev`. */
+export function blockDeviceKey(id: string, fs: Pick<LinuxFs, "read">): string {
+  return `b${readAttr(fs, `${SYS_BLOCK}/${id}/dev`) ?? ""}`;
+}
+
+/** "vendor model", with the vendor dropped when it is generic or already the
+ *  start of the model — Mission Center's rule plus the ATA case. */
+export function diskModel(id: string, fs: Pick<LinuxFs, "read">, udev: ReadonlyMap<string, string>): string | undefined {
+  const model = readAttr(fs, `${SYS_BLOCK}/${id}/device/model`) ?? udevValue(udev, "ID_MODEL")?.replace(/_/g, " ");
+  const vendor = readAttr(fs, `${SYS_BLOCK}/${id}/device/vendor`);
+  if (!vendor || GENERIC_VENDORS.has(vendor.toUpperCase())) return model;
+  if (!model) return vendor;
+  return model.startsWith(vendor) ? model : `${vendor} ${model}`;
+}
+
+export function diskKind(id: string, fs: Pick<LinuxFs, "read" | "list">, udev: ReadonlyMap<string, string>): DiskKind {
+  if (id.startsWith("nvme")) return "nvme";
+  if (id.startsWith("mmcblk")) return mmcKind(id, fs);
+  if (id.startsWith("sr")) return "optical";
+  const removable = readAttr(fs, `${SYS_BLOCK}/${id}/removable`) === "1";
+  // udisks2 answers MediaCompatibility::Thumb for these; the same drives are the
+  // removable ones on the USB bus, which udev already knows.
+  if (removable && udevValue(udev, "ID_BUS") === "usb") return "thumb";
+  const rotational = readAttr(fs, `${SYS_BLOCK}/${id}/queue/rotational`);
+  if (rotational === "0") return "ssd";
+  if (rotational === "1") return "hdd";
+  return "unknown";
+}
+
+/** The mmc host's `type` attribute is "SD" or "MMC". */
+function mmcKind(id: string, fs: Pick<LinuxFs, "read" | "list">): DiskKind {
+  const index = id.slice("mmcblk".length);
+  const host = `/sys/class/mmc_host/mmc${index}`;
+  for (const entry of fs.list(host) ?? []) {
+    if (!entry.startsWith(`mmc${index}`)) continue;
+    const type = readAttr(fs, `${host}/${entry}/type`);
+    if (type === "SD") return "sd";
+    if (type === "MMC") return "emmc";
+  }
+  return "unknown";
+}
+
+/** NVMe writes `wwid` on the namespace, SATA on the device; udev's `ID_WWN` is
+ *  cleaner than either and is preferred when present. A T10 identifier is built
+ *  by concatenating fixed-width ATA fields, so it arrives padded — the runs are
+ *  collapsed, since the value is shown to a person, not compared byte for byte. */
+function diskWwn(id: string, fs: Pick<LinuxFs, "read">, udev: ReadonlyMap<string, string>): string | undefined {
+  const raw = udevValue(udev, "ID_WWN")
+    ?? readAttr(fs, `${SYS_BLOCK}/${id}/wwid`)
+    ?? readAttr(fs, `${SYS_BLOCK}/${id}/device/wwid`);
+  return raw?.replace(/\s+/g, " ");
+}
+
+/** The drive behind `/`. mountinfo names the SOURCE path (`/dev/nvme0n1p2`), not
+ *  a disk, so it is resolved through sysfs: a partition's parent directory is its
+ *  disk, and a mapper device (LUKS, LVM, RAID) is followed through `slaves`. */
+export function findSystemDisk(fs: LinuxFs): string | undefined {
+  const source = rootMountSource(fs.read("/proc/self/mountinfo") ?? "");
+  if (!source) return undefined;
+  const node = fs.realpath(source) ?? source;
+  return wholeDiskOf(basename(node), fs, 0);
+}
+
+/** The `/` line's source device, or undefined when `/` is not a block mount. */
+export function rootMountSource(mountinfo: string): string | undefined {
+  for (const line of mountinfo.split("\n")) {
+    const fields = line.split(" ");
+    if (fields[4] !== "/") continue;
+    const sep = fields.indexOf("-", 6);
+    const source = sep >= 0 ? fields[sep + 2] : undefined;
+    if (source?.startsWith("/dev/")) return source;
+  }
+  return undefined;
+}
+
+function wholeDiskOf(name: string, fs: LinuxFs, depth: number): string | undefined {
+  if (!name || depth > MAX_SLAVE_DEPTH) return undefined;
+  const real = fs.realpath(`/sys/class/block/${name}`);
+  if (!real) return undefined;
+  if (fs.exists(`${real}/partition`)) return wholeDiskOf(basename(dirname(real)), fs, depth + 1);
+  for (const slave of fs.list(`${real}/slaves`) ?? []) {
+    const disk = wholeDiskOf(slave, fs, depth + 1);
+    if (disk) return disk;
+  }
+  return fs.exists(`${SYS_BLOCK}/${name}`) ? name : undefined;
+}
+
+const basename = (p: string) => p.slice(p.lastIndexOf("/") + 1);
+const dirname = (p: string) => p.slice(0, p.lastIndexOf("/"));
+
+function optional<K extends string>(key: K, value: string | undefined): Partial<Record<K, string>> {
+  return value === undefined ? {} : ({ [key]: value } as Record<K, string>);
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Mission Center's Fan page, from `/sys/class/hwmon`. A chip exposes `fanN_input`
+ * in RPM, an optional `pwmN` (0-255 duty) and often a `tempN_input` with the same
+ * index — Mission Center pairs them by index, which is what the board's own
+ * labelling means.
+ *
+ * Fans reading 0 are kept: a header with nothing plugged into it is information,
+ * and hiding it would make the list change length as a fan spins down.
+ */
+import type { FanMetrics } from "../../types/system-metrics.ts";
+import { readAttr, readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+
+export const HWMON_DIR = "/sys/class/hwmon";
+const PWM_MAX = 255;
+
+export function collectLinuxFans(fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs): FanMetrics[] {
+  const fans: FanMetrics[] = [];
+  for (const chip of (fs.list(HWMON_DIR) ?? []).sort()) {
+    const dir = `${HWMON_DIR}/${chip}`;
+    const name = readAttr(fs, `${dir}/name`) ?? chip;
+    for (const index of fanIndices(fs, dir)) {
+      const rpm = readNumber(fs, `${dir}/fan${index}_input`);
+      if (rpm === undefined) continue;
+      const pwm = readNumber(fs, `${dir}/pwm${index}`);
+      const milliC = readNumber(fs, `${dir}/temp${index}_input`);
+      fans.push({
+        id: `${name}/fan${index}`,
+        label: readAttr(fs, `${dir}/fan${index}_label`) ?? `Fan ${index}`,
+        rpm: Math.max(0, Math.round(rpm)),
+        ...(pwm === undefined ? {} : { pwmPercent: Math.round(pwm / PWM_MAX * 1000) / 10 }),
+        ...(milliC === undefined ? {} : { tempC: Math.round(milliC / 100) / 10 }),
+        ...defined("tempName", readAttr(fs, `${dir}/temp${index}_label`)),
+      });
+    }
+  }
+  return fans;
+}
+
+/** The `N` of every `fanN_input` the chip publishes, ascending. */
+export function fanIndices(fs: Pick<LinuxFs, "list">, dir: string): number[] {
+  const indices: number[] = [];
+  for (const entry of fs.list(dir) ?? []) {
+    const m = /^fan(\d+)_input$/.exec(entry);
+    if (m) indices.push(Number(m[1]));
+  }
+  return indices.sort((a, b) => a - b);
+}
+
+function defined<K extends string, V>(key: K, value: V | undefined): Partial<Record<K, V>> {
+  return value === undefined ? {} : ({ [key]: value } as Record<K, V>);
+}

package/src/services/system-metrics/gpu-api-versions.ts

@@ -0,0 +1,120 @@
+/**
+ * OpenGL and Vulkan versions for the GPU page. Both come from a one-shot tool
+ * and neither ever changes while the machine is up, so the result is cached for
+ * the process lifetime and the tools are never spawned from a tick.
+ *
+ * `eglinfo` is asked with `EGL_PLATFORM=surfaceless`, which is what lets this
+ * answer at all on a headless host or from a systemd unit with no display —
+ * `glxinfo` needs an X connection and would simply fail there.
+ */
+import type { Runner } from "../host-info/spawn-runner.ts";
+import { defaultRunner } from "../host-info/spawn-runner.ts";
+
+/** `env` carries the platform override because the shared `Runner` takes an argv
+ *  and no environment — and without it `eglinfo` needs a display, which a PPM
+ *  started from a systemd unit does not have. */
+export const EGLINFO_ARGV = ["env", "EGL_PLATFORM=surfaceless", "eglinfo"];
+export const VULKANINFO_ARGV = ["vulkaninfo", "--summary"];
+const SPAWN_TIMEOUT_MS = 8000;
+
+export interface GpuApiVersions {
+  /** Highest context the driver offers: "4.6", or "ES 3.2" when that is all. */
+  opengl?: string;
+  /** Vulkan API version, e.g. "1.4.354". */
+  vulkan?: string;
+  /** Mesa's own version, which is the meaningful "driver version" for i915,
+   *  xe and amdgpu — none of those modules publish one in sysfs. */
+  mesa?: string;
+}
+
+/** "OpenGL core profile version string: 4.6 (Core Profile) Mesa 26.2.2" → "4.6".
+ *  A driver with no desktop GL at all reports its ES version instead, which is
+ *  what Mission Center shows for those. */
+export function parseOpenglVersion(text: string): string | undefined {
+  const core = /^OpenGL core profile version(?: string)?:\s*(\d+\.\d+)/m.exec(text);
+  if (core) return core[1];
+  const compat = /^OpenGL version(?: string)?:\s*(\d+\.\d+)/m.exec(text);
+  if (compat) return compat[1];
+  const es = /^OpenGL ES profile version(?: string)?:\s*OpenGL ES (\d+\.\d+)/m.exec(text);
+  return es ? `ES ${es[1]}` : undefined;
+}
+
+/** `vulkaninfo --summary` prints one `apiVersion = 1.4.354` per device; the
+ *  highest is what the machine supports. */
+export function parseVulkanVersion(text: string): string | undefined {
+  const versions = [...text.matchAll(/apiVersion\s*[=:]\s*(?:0x[0-9a-f]+\s*\()?(\d+\.\d+\.\d+)/gi)]
+    .map((m) => m[1]!)
+    .sort(compareVersions);
+  return versions.at(-1);
+}
+
+function compareVersions(a: string, b: string): number {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+/** The Mesa build out of an OpenGL version line: "OpenGL core profile version:
+ *  4.6 (Core Profile) Mesa 26.2.2-arch3.2" -> "Mesa 26.2.2-arch3.2".
+ *
+ *  Anchored to that line on purpose. eglinfo also prints "EGL vendor string: Mesa
+ *  Project" much earlier, so an unanchored search reports the version as
+ *  "Mesa Project" — well-formed, plausible, and wrong. */
+export function parseMesaVersion(text: string): string | undefined {
+  const m = /^OpenGL [^\n]*version(?: string)?:[^\n]*\bMesa ([\w.+-]+)/m.exec(text);
+  return m ? `Mesa ${m[1]}` : undefined;
+}
+
+export interface GpuApiVersionReader {
+  read(): Promise<GpuApiVersions>;
+}
+
+export function createGpuApiVersionReader(run: Runner = defaultRunner): GpuApiVersionReader {
+  let cached: Promise<GpuApiVersions> | null = null;
+  return {
+    read() {
+      // One in-flight promise, reused forever: two windows opening at once must
+      // not spawn `vulkaninfo` twice, and the answer cannot change afterwards.
+      cached ??= probe(run);
+      return cached;
+    },
+  };
+}
+
+async function probe(run: Runner): Promise<GpuApiVersions> {
+  const [gl, vk] = await Promise.all([
+    tryRun(run, EGLINFO_ARGV),
+    tryRun(run, VULKANINFO_ARGV),
+  ]);
+  return {
+    ...(gl ? optional("opengl", parseOpenglVersion(gl)) : {}),
+    ...(gl ? optional("mesa", parseMesaVersion(gl)) : {}),
+    ...(vk ? optional("vulkan", parseVulkanVersion(vk)) : {}),
+  };
+}
+
+/**
+ * A missing tool is not an error worth surfacing — the page hides the row.
+ *
+ * The exit code is deliberately NOT a gate. `eglinfo` sweeps every EGL platform
+ * it knows and exits 1 when any of them fails, which on a headless host means
+ * every run — while still printing a complete, correct surfaceless report to
+ * stdout. Gating on the code threw away 2784 good lines and left the OpenGL row
+ * permanently blank. Output is the signal; the parsers reject anything else.
+ */
+async function tryRun(run: Runner, argv: readonly string[]): Promise<string | null> {
+  try {
+    const r = await run([...argv], SPAWN_TIMEOUT_MS);
+    return !r.timedOut && r.stdout.trim() ? r.stdout : null;
+  } catch {
+    return null;
+  }
+}
+
+function optional<K extends string>(key: K, value: string | undefined): Partial<Record<K, string>> {
+  return value === undefined ? {} : ({ [key]: value } as Record<K, string>);
+}