onyx/Packages/OnyxKit/Sources/MetricsProvider/SMCReader.swift

import Foundation
import IOKit
import OSLog

private let log = Logger(subsystem: "com.scarriffleservices.onyx", category: "SMC")

/// Liest Werte aus dem System Management Controller. **Ausschließlich lesend.**
///
/// Es gibt hier bewusst keinen Schreibpfad. Lüfterdrehzahl und Ladegrenze
/// verlangen root und gehören in den privilegierten Helfer aus Phase 6 — nicht
/// in einen Typ, der im normalen App-Prozess läuft und von jedem Widget
/// erreichbar ist.
///
/// Die Struktur und die Erkenntnisse stammen aus `docs/spikes/A-smc.md`, gemessen
/// auf Mac17,9. Wichtigster Punkt von dort: **alle Mehrbyte-Werte sind
/// little-endian.** Der verbreitete Beispielcode nimmt big-endian an — er
/// stammt aus der Intel-Ära und liefert auf Apple Silicon Unsinn.
public final class SMCReader: @unchecked Sendable {

    // MARK: - Aufbau des AppleSMC-UserClients

    private struct Version { var major: UInt8 = 0; var minor: UInt8 = 0
                             var build: UInt8 = 0; var reserved: UInt8 = 0
                             var release: UInt16 = 0 }
    private struct PLimitData { var version: UInt16 = 0; var length: UInt16 = 0
                                var cpuPLimit: UInt32 = 0; var gpuPLimit: UInt32 = 0
                                var memPLimit: UInt32 = 0 }
    private struct KeyInfo { var dataSize: UInt32 = 0; var dataType: UInt32 = 0
                             var dataAttributes: UInt8 = 0 }

    private struct Param {
        var key: UInt32 = 0
        var vers = Version()
        var pLimitData = PLimitData()
        var keyInfo = KeyInfo()
        var padding: UInt16 = 0
        var result: UInt8 = 0
        var status: UInt8 = 0
        var data8: UInt8 = 0
        var data32: UInt32 = 0
        var bytes: (UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8,
                    UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8,
                    UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8,
                    UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8) =
            (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
    }

    private static let handleYPCEvent: UInt32 = 2
    private static let readKey: UInt8 = 5
    private static let getKeyInfo: UInt8 = 9

    private var connection: io_connect_t = 0
    private let lock = NSLock()

    public init?() {
        let service = IOServiceGetMatchingService(kIOMainPortDefault,
                                                  IOServiceMatching("AppleSMC"))
        guard service != 0 else {
            log.error("AppleSMC nicht gefunden — Sensoren bleiben leer")
            return nil
        }
        defer { IOObjectRelease(service) }
        guard IOServiceOpen(service, mach_task_self_, 0, &connection) == kIOReturnSuccess else {
            log.error("AppleSMC nicht zu öffnen")
            return nil
        }
    }

    deinit { if connection != 0 { IOServiceClose(connection) } }

    // MARK: - Lesen

    /// Ein `flt`-Wert (Lüfterdrehzahl, Temperatur, Leistung).
    public func float(_ key: String) -> Double? {
        guard let value = read(key), value.type == "flt ", value.bytes.count >= 4 else { return nil }
        // Little-endian, siehe Klassenkommentar.
        let bits = UInt32(value.bytes[3]) << 24 | UInt32(value.bytes[2]) << 16
                 | UInt32(value.bytes[1]) << 8 | UInt32(value.bytes[0])
        return Double(Float(bitPattern: bits))
    }

    /// Ein vorzeichenloser Ganzzahlwert beliebiger Breite.
    public func integer(_ key: String) -> UInt64? {
        guard let value = read(key) else { return nil }
        var result: UInt64 = 0
        for (index, byte) in value.bytes.prefix(8).enumerated() {
            result |= UInt64(byte) << (8 * index)   // little-endian
        }
        return result
    }

    public func exists(_ key: String) -> Bool { read(key) != nil }

    private struct Value { let type: String; let bytes: [UInt8] }

    private func read(_ key: String) -> Value? {
        lock.lock()
        defer { lock.unlock() }

        var info = Param()
        info.key = Self.fourCC(key)
        info.data8 = Self.getKeyInfo
        guard let described = call(info) else { return nil }

        var command = Param()
        command.key = Self.fourCC(key)
        command.keyInfo = described.keyInfo
        command.data8 = Self.readKey
        guard let output = call(command) else { return nil }

        let size = Int(min(described.keyInfo.dataSize, 32))
        let all = withUnsafeBytes(of: output.bytes) { Array($0) }
        return Value(type: Self.fourCCString(described.keyInfo.dataType),
                     bytes: Array(all.prefix(size)))
    }

    private func call(_ input: Param) -> Param? {
        var input = input
        var output = Param()
        var size = MemoryLayout<Param>.stride

        let result = IOConnectCallStructMethod(connection, Self.handleYPCEvent,
                                               &input, MemoryLayout<Param>.stride,
                                               &output, &size)
        // Ein nicht vorhandener Key meldet sich über `result` und ist kein
        // Fehler: welche Keys es gibt, unterscheidet sich je nach Modell.
        guard result == kIOReturnSuccess, output.result == 0 else { return nil }
        return output
    }

    private static func fourCC(_ string: String) -> UInt32 {
        var value: UInt32 = 0
        for character in string.utf8.prefix(4) { value = value << 8 | UInt32(character) }
        return value
    }

    private static func fourCCString(_ value: UInt32) -> String {
        let bytes = [UInt8((value >> 24) & 0xFF), UInt8((value >> 16) & 0xFF),
                     UInt8((value >> 8) & 0xFF), UInt8(value & 0xFF)]
        return String(bytes: bytes, encoding: .ascii) ?? "????"
    }
}