trcc-linux 9.7.5__tar.gz → 9.7.7__tar.gz

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.7.5
+Version: 9.7.7
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme
@@ -182,6 +182,8 @@ Then **unplug and replug the USB cable** and run `trcc gui`.
 
 > `pipx` not installed? `sudo apt install pipx` (Debian/Ubuntu), `sudo dnf install pipx` (Fedora), `sudo pacman -S python-pipx` (Arch). See the **[Install Guide](doc/GUIDE_INSTALL.md)** for your distro.
 
+> **NVIDIA GPU metrics?** The app detects your card and offers to install the sensor reader on first launch (it installs into your environment automatically). To add it upfront instead: `pipx install "trcc-linux[nvidia]"`.
+
 ### Automatic (git clone)
 
 ```bash
@@ -308,7 +310,7 @@ Set the angle to **90°** (or 270°) in the GUI, then open **Cloud Themes** —
 | **Multi-device** | Per-device config, auto-detect, multi-device with device selection |
 | **Security** | udev rules, polkit policy, SELinux support, no root required after setup |
 
-**Under the hood**: 147 source files, ~49K lines of Python, 5799 tests across 96 test files in 9 directories. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
+**Under the hood**: 223 source files, ~71K lines of Python, 1783 tests across 104 test files. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
 
 ### What we do better than Windows TRCC
 

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/README.md

@@ -108,6 +108,8 @@ Then **unplug and replug the USB cable** and run `trcc gui`.
 
 > `pipx` not installed? `sudo apt install pipx` (Debian/Ubuntu), `sudo dnf install pipx` (Fedora), `sudo pacman -S python-pipx` (Arch). See the **[Install Guide](doc/GUIDE_INSTALL.md)** for your distro.
 
+> **NVIDIA GPU metrics?** The app detects your card and offers to install the sensor reader on first launch (it installs into your environment automatically). To add it upfront instead: `pipx install "trcc-linux[nvidia]"`.
+
 ### Automatic (git clone)
 
 ```bash
@@ -234,7 +236,7 @@ Set the angle to **90°** (or 270°) in the GUI, then open **Cloud Themes** —
 | **Multi-device** | Per-device config, auto-detect, multi-device with device selection |
 | **Security** | udev rules, polkit policy, SELinux support, no root required after setup |
 
-**Under the hood**: 147 source files, ~49K lines of Python, 5799 tests across 96 test files in 9 directories. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
+**Under the hood**: 223 source files, ~71K lines of Python, 1783 tests across 104 test files. Hexagonal architecture with strict dependency injection — GUI, CLI, and API all talk to the same core services. 6 USB protocols reverse-engineered from the Windows C# app.
 
 ### What we do better than Windows TRCC
 

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.7.5"
+version = "9.7.7"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -136,6 +136,9 @@ artifacts = [
     "**/assets/**/*.service",
     "**/assets/**/*.policy",
     "**/assets/**/*.svg",
+    # Privileged MCHBAR timing reader (no extension) — distro packages install
+    # it to /usr/bin/trcc-imc; shipped here so it's in the sdist/wheel too.
+    "**/assets/trcc-imc",
     # SELinux policy source — `trcc system setup` builds + loads it on Fedora
     # so source/pip installs can pass the USB/SCSI ioctls (packages ship the
     # compiled .pp via the rpm).

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/__main__.py

@@ -100,7 +100,7 @@ if sys.platform == 'win32':
 
 try:
     # Auto-launch GUI when invoked as trcc-gui.exe (windowed PyInstaller build)
-    if os.path.basename(sys.executable).lower().startswith('trcc-gui'):
+    if Path(sys.executable).name.lower().startswith('trcc-gui'):
         from trcc.ui.cli.main import gui
         sys.exit(gui() or 0)
     # Everything else goes through the shared entry so python -m trcc and

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.7.5"
+__version__ = "9.7.7"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/device/led.py

@@ -4,10 +4,12 @@ HID 64-byte report transport.  Shares the Type 2 DA/DB/DC/DD magic with
 HID LCD devices, but LED packets use cmd=2 with per-LED RGB payload.
 
 Payload shape passed to send():
-    LedPayload(colors=[(r,g,b), ...], is_on=None, global_on=True, brightness=100)
+    LedPayload(colors=[(r,g,b), ...], is_on=None, global_on=True)
 
-Color scaling matches FormLED.cs SendHidVal:
-    scaled = channel * (brightness/100) * 0.4
+Colours arrive already brightness-baked by the service layer
+(``led_effects.apply_brightness``).  The wire is pure transport — it
+applies only the FormLED hardware perceptual scale, never brightness:
+    scaled = channel * 0.4          # FormLED.cs SendHidVal, sans brightness
 """
 from __future__ import annotations
 
@@ -348,7 +350,6 @@ class Led(Device[BulkTransport]):
                     colors=remapped_colors,
                     is_on=remapped_is_on,
                     global_on=payload.global_on,
-                    brightness=payload.brightness,
                 )
 
         packet = self._build_packet(payload)
@@ -409,15 +410,17 @@ class Led(Device[BulkTransport]):
         payload_len = count * 3
         header = cls._build_header(payload_len)
 
-        brightness = max(0, min(100, payload.brightness)) / 100.0
+        # Pure transport: the colours arrive already brightness-baked by the
+        # service (apply_brightness); the wire applies only the FormLED
+        # hardware perceptual scale + the on/off mask, never brightness.
         body = bytearray(payload_len)
         for i, (r, g, b) in enumerate(payload.colors):
             on = payload.global_on and (
                 payload.is_on[i] if payload.is_on is not None else True
             )
             if on:
-                body[i * 3] = min(255, max(0, int(r * brightness * _COLOR_SCALE)))
-                body[i * 3 + 1] = min(255, max(0, int(g * brightness * _COLOR_SCALE)))
-                body[i * 3 + 2] = min(255, max(0, int(b * brightness * _COLOR_SCALE)))
+                body[i * 3] = min(255, max(0, int(r * _COLOR_SCALE)))
+                body[i * 3 + 1] = min(255, max(0, int(g * _COLOR_SCALE)))
+                body[i * 3 + 2] = min(255, max(0, int(b * _COLOR_SCALE)))
             # else: stays 0,0,0 (off)
         return header + bytes(body)

trcc_linux-9.7.7/src/trcc/adapters/diagnostics/adapter.py

@@ -0,0 +1,73 @@
+"""Concrete ``Diagnostics`` port — wraps the diagnostics functions.
+
+The health/doctor/debug-report/gpu-reader logic already lives as module-level
+functions that consume the ``Platform`` port.  This adapter binds them to one
+platform instance and exposes them through the core ``Diagnostics`` ABC, so core
+Commands + the quickstart service depend on the port, never on these modules.
+
+The probe functions are called **module-qualified** (``_health.foo()``) rather
+than imported by name so a test can ``monkeypatch.setattr`` the module attribute
+and have the adapter see it — the attribute resolves at call time.
+"""
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from ...core.diagnostics import DoctorResult, GpuReaderState, HealthReport
+from ...core.ports import Diagnostics, Platform
+from ..sensors import nvml as _nvml
+from . import debug_report as _debug_report
+from . import doctor as _doctor
+from . import health as _health
+
+log = logging.getLogger(__name__)
+
+
+class DiagnosticsAdapter(Diagnostics):
+    """Platform-bound diagnostics, exposed through the core port."""
+
+    def __init__(self, platform: Platform) -> None:
+        self._platform = platform
+
+    def health(self) -> HealthReport:
+        log.info("DiagnosticsAdapter.health")
+        return _health.run_health_checks(self._platform)
+
+    def doctor(self) -> DoctorResult:
+        log.info("DiagnosticsAdapter.doctor")
+        return _doctor.run_doctor(self._platform)
+
+    def render_doctor(self, report: HealthReport) -> str:
+        log.info("DiagnosticsAdapter.render_doctor: %d check(s)", len(report.checks))
+        return _doctor.render_doctor_output(report)
+
+    def debug_report(self, log_tail_lines: int) -> str:
+        log.info("DiagnosticsAdapter.debug_report: log_tail_lines=%d", log_tail_lines)
+        return _debug_report.build_debug_report(
+            self._platform, log_tail_lines=log_tail_lines,
+        ).render_text()
+
+    def write_debug_report(self, rendered: str, path: Path) -> Path:
+        log.info("DiagnosticsAdapter.write_debug_report: path=%s", path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(rendered, encoding="utf-8")
+        return path
+
+    def package_manager(self) -> str | None:
+        pm = _health.detect_package_manager()
+        log.info("DiagnosticsAdapter.package_manager: %s", pm)
+        return pm
+
+    def gpu_reader_state(self) -> GpuReaderState:
+        reader_installed, initialized, _ = _nvml.nvml_init_state()
+        present = _health.nvidia_gpu_present()
+        log.info(
+            "DiagnosticsAdapter.gpu_reader_state: present=%s installed=%s init=%s",
+            present, reader_installed, initialized,
+        )
+        return GpuReaderState(
+            nvidia_present=present,
+            reader_installed=reader_installed,
+            initialized=initialized,
+        )

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/diagnostics/doctor.py

@@ -7,27 +7,15 @@ sit on top of the same ``HealthCheckResult`` data.
 from __future__ import annotations
 
 import logging
-from dataclasses import dataclass
 
+from ...core.diagnostics import DoctorResult, HealthReport
 from ...core.ports import Platform
-from .health import HealthReport, run_health_checks
+from .health import run_health_checks
 
 log = logging.getLogger(__name__)
 
-
-@dataclass(frozen=True, slots=True)
-class DoctorResult:
-    """What the doctor decided.
-
-    ``exit_code`` is 0 when nothing FAILed, 1 otherwise — wraps the
-    standard "broken / not broken" CLI convention so scripts can branch.
-    """
-    report: HealthReport
-    exit_code: int
-
-    @property
-    def is_healthy(self) -> bool:
-        return self.exit_code == 0
+# ``DoctorResult`` moved to ``core.diagnostics`` (pure data); re-exported here.
+__all__ = ["DoctorResult", "render_doctor_output", "run_doctor"]
 
 
 def run_doctor(platform: Platform) -> DoctorResult:

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/diagnostics/health.py

@@ -21,48 +21,26 @@ import logging
 import shutil
 import subprocess
 import sys
-from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal
 
+from ...core.diagnostics import HealthCheckResult, HealthReport, Severity
 from ...core.ports import Paths, Platform
 from ..sensors.nvml import NVML_RELOAD_HINT, nvml_init_state
 
 log = logging.getLogger(__name__)
 
-
-Severity = Literal["OK", "WARN", "FAIL"]
-
-
-@dataclass(frozen=True, slots=True)
-class HealthCheckResult:
-    """One check's outcome — name, severity, message, optional fix hint."""
-    name: str
-    severity: Severity
-    message: str
-    fix_hint: str = ""
-
-
-@dataclass(frozen=True, slots=True)
-class HealthReport:
-    """The full set of checks plus a one-line summary."""
-    checks: list[HealthCheckResult] = field(default_factory=list)
-
-    @property
-    def worst_severity(self) -> Severity:
-        if any(c.severity == "FAIL" for c in self.checks):
-            return "FAIL"
-        if any(c.severity == "WARN" for c in self.checks):
-            return "WARN"
-        return "OK"
-
-    @property
-    def fail_count(self) -> int:
-        return sum(1 for c in self.checks if c.severity == "FAIL")
-
-    @property
-    def warn_count(self) -> int:
-        return sum(1 for c in self.checks if c.severity == "WARN")
+# DTOs moved to ``core.diagnostics`` (pure data the Diagnostics port speaks);
+# re-exported here so existing ``from ...health import HealthReport`` keeps working.
+__all__ = [
+    "HealthCheckResult",
+    "HealthReport",
+    "Severity",
+    "detect_package_manager",
+    "nvidia_gpu_present",
+    "package_install_hint",
+    "quick_subprocess",
+    "run_health_checks",
+]
 
 
 # =========================================================================

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/infra/sysinfo_config.py

@@ -62,10 +62,10 @@ _PANEL_ROW_BINDINGS: dict[tuple[int, int], str] = {
     (3, 1): "memory:percent",
     (3, 2): "memory:used",
     (3, 3): "memory:available",
-    # Disk panel (category_id=4) — ``disk:0:temp`` requires SMART; aggregator
-    # currently doesn't ship a SMART source, so the row stays unbound until
-    # a SmartDisk source lands.
-    (4, 0): "disk:0:temp",
+    # Disk panel (category_id=4) — ``disk:temp`` is the hottest drive's temp,
+    # published by the per-OS DiskSource (Linux hwmon nvme/drivetemp, Windows
+    # LHM storage).  Boxes whose drives expose no temp sensor stay unbound (--).
+    (4, 0): "disk:temp",
     (4, 1): "disk:activity",
     (4, 2): "disk:read",
     (4, 3): "disk:write",

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/render/qt.py

@@ -380,6 +380,24 @@ class QtRenderer(Renderer):
         ).copy()  # .copy() detaches from input buffer
         return qimg.convertToFormat(QImage.Format.Format_ARGB32)
 
+    # ── Fonts ─────────────────────────────────────────────────────────
+
+    def list_fonts(self) -> list[str]:
+        """Enumerate installed font families via the Qt font database.
+
+        ``__init__`` already brought up a ``QGuiApplication`` (so
+        ``QFontDatabase.families()`` won't abort the process); call the
+        idempotent guard again defensively, then read the families.
+        """
+        _ensure_qt_app()
+        try:
+            families = sorted(QFontDatabase.families())
+        except RuntimeError as e:
+            log.warning("QtRenderer.list_fonts: QFontDatabase error: %s", e)
+            return []
+        log.info("QtRenderer.list_fonts: %d families", len(families))
+        return families
+
     # ── Convenience: QPixmap export for GUI preview ───────────────────
 
     @staticmethod

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/repo/data_install.py

@@ -35,7 +35,7 @@ from typing import Protocol
 
 from ...core._safe import is_safe_zip_member
 from ...core.errors import HttpFetchError, TrccError
-from ...core.ports import HttpFetcher
+from ...core.ports import DataInstaller, HttpFetcher
 
 log = logging.getLogger(__name__)
 
@@ -120,11 +120,11 @@ class SevenZipExtractor:
 
 
 # =========================================================================
-# DataInstaller — public adapter, DI'd into the service layer
+# HttpDataInstaller — concrete DataInstaller port, DI'd into the service layer
 # =========================================================================
 
 
-class DataInstaller:
+class HttpDataInstaller(DataInstaller):
     """Downloads + extracts per-resolution archives from GitHub.
 
     Construct with an ``HttpFetcher`` (the existing adapter from

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/sensors/_lhm.py

@@ -28,7 +28,7 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
-from ...core.ports import CpuSource, GpuSource
+from ...core.ports import CpuSource, DiskSource, GpuSource
 
 log = logging.getLogger(__name__)
 
@@ -56,6 +56,7 @@ _TYPE_DATA = "Data"              # MemUsed/MemAvailable in GB
 # helper matches via ``startswith("Gpu")``.
 _HW_CPU = "Cpu"
 _HW_GPU_PREFIX = "Gpu"
+_HW_STORAGE = "Storage"
 
 
 def _probe_wmi_namespace() -> Any:
@@ -586,3 +587,86 @@ def discover_lhm_gpus(
     except Exception:
         log.debug("LHM GPU enumeration failed", exc_info=True)
     return out
+
+
+# =========================================================================
+# LhmDisk — one per LHM-detected Storage row (NVMe / SATA SSD / HDD)
+# =========================================================================
+
+
+class LhmDisk(DiskSource):
+    """Storage temperature via LHM — one per ``Storage`` Hardware row.
+
+    LHM's storage tree (``HardwareType == "Storage"``) carries a
+    ``Temperature`` sensor per drive — the same WMI shape as the GPU
+    temp, so this is :class:`LhmGpu`'s temperature path narrowed to the
+    one reading the model's ``disk_temp`` slot needs.  Returns ``None``
+    when LHM isn't running or the drive has no temp sensor yet.
+    """
+
+    def __init__(
+        self,
+        hardware_identifier: str,
+        display_name: str,
+        *,
+        handle_factory: Callable[[], Any] = _default_handle_factory,
+    ) -> None:
+        # Defer the handle to first read (born on the reading thread's
+        # apartment, #131); identity is the apartment-agnostic LHM identifier.
+        self._handle_factory = handle_factory
+        self._id = hardware_identifier
+        self._display_name = display_name
+
+    @property
+    def key(self) -> str:
+        # LHM storage identifiers look like "/nvme/0" or "/hdd/0" — flatten to
+        # a stable per-drive key ("lhm:nvme:0").
+        ident = self._id.lower().lstrip("/").replace("/", ":")
+        return f"lhm:{ident}"
+
+    @property
+    def name(self) -> str:
+        return self._display_name
+
+    def _row(self, ns: Any) -> Any | None:
+        if ns is None:
+            return None
+        try:
+            rows = list(ns.Hardware(Identifier=self._id))
+        except Exception:
+            return None
+        return rows[0] if rows else None
+
+    def temp(self) -> float | None:
+        ns = self._handle_factory()
+        if (row := self._row(ns)) is None:
+            return None
+        return _max_value(_sensors_for(ns, row, _TYPE_TEMP))
+
+
+def discover_lhm_disks(
+    *,
+    handle_factory: Callable[[], Any] = _default_handle_factory,
+) -> list[DiskSource]:
+    """Enumerate storage devices LHM is currently reporting on.
+
+    Returns ``[]`` when LHM isn't running.  The aggregator folds the hottest
+    into ``disk:temp``; multiple drives each get their own source.
+    """
+    log.info("discover_lhm_disks: called")
+    ns = handle_factory()
+    if ns is None:
+        return []
+    out: list[DiskSource] = []
+    try:
+        for hw in ns.Hardware():
+            if str(hw.HardwareType) != _HW_STORAGE:
+                continue
+            out.append(LhmDisk(
+                hardware_identifier=str(hw.Identifier),
+                display_name=str(hw.Name),
+                handle_factory=handle_factory,
+            ))
+    except Exception:
+        log.debug("LHM disk enumeration failed", exc_info=True)
+    return out

{trcc_linux-9.7.5 → trcc_linux-9.7.7}/src/trcc/adapters/sensors/aggregator.py

@@ -7,7 +7,7 @@ the normalized keys overlays use:
     gpu:primary:temp | gpu:0:temp | gpu:nvidia:0:temp | gpu:amd:0:temp
     memory:used | memory:available | memory:total | memory:percent
     fan:cpu:rpm | fan:gpu:percent | fan:<key>:rpm
-    disk:read | disk:write | disk:activity
+    disk:temp | disk:read | disk:write | disk:activity
     net:up | net:down | net:total_up | net:total_down
     time:{hour,minute,second} | date:{year,month,day,dow}
 
@@ -28,6 +28,8 @@ from contextlib import AbstractContextManager, nullcontext
 from ...core.models import MIN_REFRESH_INTERVAL_S, SensorReading
 from ...core.ports import (
     CpuSource,
+    DiskSource,
+    DramSource,
     FanSource,
     GpuSource,
     MemorySource,
@@ -35,7 +37,10 @@ from ...core.ports import (
 )
 from .hwmon import (
     HwmonCpu,
+    SpdClock,
     discover_amd_gpus,
+    discover_disk_temp,
+    discover_dram_temp,
     discover_fans,
     discover_intel_gpus,
     find_cpu_temp_device,
@@ -71,6 +76,8 @@ def _memory_keys() -> list[tuple[str, str, str]]:
         ("memory:available", "memory", "MB"),
         ("memory:total", "memory", "MB"),
         ("memory:percent", "memory", "%"),
+        ("memory:temp", "temperature", "°C"),
+        ("memory:clock", "clock", "MHz"),
     ]
 
 
@@ -88,6 +95,7 @@ def _gpu_reading_keys(prefix: str) -> list[tuple[str, str, str]]:
 
 def _io_keys() -> list[tuple[str, str, str]]:
     return [
+        ("disk:temp", "temperature", "°C"),
         ("disk:read", "disk_io", "MB/s"),
         ("disk:write", "disk_io", "MB/s"),
         ("disk:activity", "disk_io", "%"),
@@ -125,12 +133,18 @@ class BaselineSensors(SensorEnumerator):
                  memory: MemorySource | None = None,
                  gpus: list[GpuSource] | None = None,
                  fans: list[FanSource] | None = None,
+                 disks: list[DiskSource] | None = None,
+                 dram: list[DramSource] | None = None,
+                 spd_clock: SpdClock | None = None,
                  thread_context: Callable[[], AbstractContextManager[None]]
                      = nullcontext) -> None:
         self._cpu = cpu or PsutilCpu()
         self._memory = memory or PsutilMemory()
         self._gpus: list[GpuSource] = gpus if gpus is not None else discover_nvidia_gpus()
         self._fans: list[FanSource] = fans or []
+        self._disks: list[DiskSource] = disks or []
+        self._dram: list[DramSource] = dram or []
+        self._spd_clock = spd_clock
         # Per-thread OS setup the poll thread enters before touching OS
         # sensor APIs (Windows → COM apartment for WMI; others → no-op).
         # Injected as a narrow callable so this OS-neutral aggregator never
@@ -352,6 +366,30 @@ class BaselineSensors(SensorEnumerator):
             _store(r, f"fan:{fan.key}:percent",
                    self._read(fan.percent, f"fan:{fan.key}:percent"))
 
+        # Disk temperature — one DiskSource per drive; the model carries a
+        # single ``disk_temp`` slot, so collapse to the HOTTEST drive (the one
+        # most likely to throttle), mirroring cpu_temp = hottest socket.
+        disk_temps = [
+            t for disk in self._disks
+            if (t := self._read(disk.temp, f"disk:{disk.key}:temp")) is not None
+        ]
+        if disk_temps:
+            _store(r, "disk:temp", max(disk_temps))
+
+        # DRAM temperature — one DramSource per DIMM; the model carries a single
+        # ``mem_temp`` slot, so collapse to the HOTTEST module, mirroring disk.
+        dram_temps = [
+            t for d in self._dram
+            if (t := self._read(d.temp, f"memory:{d.key}:temp")) is not None
+        ]
+        if dram_temps:
+            _store(r, "memory:temp", max(dram_temps))
+
+        # Memory channel clock — static SPD nameplate (cached at construction).
+        if self._spd_clock is not None:
+            _store(r, "memory:clock",
+                   self._read(self._spd_clock.clock, "memory:clock"))
+
         # IO + time
         try:
             self._io.poll(r)
@@ -399,8 +437,13 @@ def build_linux_sensors() -> BaselineSensors:
     gpus.extend(discover_amd_gpus(hwmon_devices))
     gpus.extend(discover_intel_gpus(hwmon_devices))
     fans = discover_fans(hwmon_devices)
-    log.info("Linux sensors: cpu_temp=%s, gpus=%d, fans=%d",
+    disks = discover_disk_temp(hwmon_devices)
+    dram = discover_dram_temp(hwmon_devices)
+    spd_clock = SpdClock()
+    log.info("Linux sensors: cpu_temp=%s, gpus=%d, fans=%d, disks=%d, dram=%d, "
+             "mem_clock=%s",
              "yes" if cpu.temp() is not None else "no",
-             len(gpus), len(fans))
+             len(gpus), len(fans), len(disks), len(dram), spd_clock.clock())
     return BaselineSensors(cpu=cpu, memory=PsutilMemory(),
-                           gpus=gpus, fans=fans)
+                           gpus=gpus, fans=fans, disks=disks, dram=dram,
+                           spd_clock=spd_clock)