feat: remove chain procs for gpu detection

Use C++ native read of gpu files + nvidia proc for type detection
Nvidia proc also doubles for name detection
Closes caelestia-dots#1615

Author: soramanew

plugin/src/Caelestia/Services/gpu.cpp

@@ -4,40 +4,138 @@
 #include "../Config/serviceconfig.hpp"
 #include "sensorslib.hpp"
 
-#include <cmath>
 #include <qdir.h>
+#include <qdiriterator.h>
 #include <qfile.h>
 #include <qregularexpression.h>
 
 namespace caelestia::services {
 
 namespace {
 
-constexpr const char* kTypeDetectScript =
-    "if command -v nvidia-smi >/dev/null 2>&1 && nvidia-smi -L >/dev/null 2>&1; then echo NVIDIA;"
-    " elif ls /sys/class/drm/card*/device/gpu_busy_percent 2>/dev/null | grep -q .; then echo GENERIC;"
-    " else echo NONE; fi";
+QStringList gpuBusyFiles() {
+    static const QRegularExpression cardRe(QStringLiteral("^card\\d+$"));
 
-constexpr const char* kNameDetectScript = "nvidia-smi --query-gpu=name --format=csv,noheader 2>/dev/null"
-                                          " || glxinfo -B 2>/dev/null | grep 'Device:' | cut -d':' -f2 | cut -d'(' -f1"
-                                          " || lspci 2>/dev/null | grep -i 'vga\\|3d controller\\|display' | head -1";
+    QStringList files;
+    QDirIterator it(QStringLiteral("/sys/class/drm"), QDir::Dirs | QDir::NoDotAndDotDot);
+    while (it.hasNext()) {
+        const QString path = it.next();
+        if (!cardRe.match(it.fileName()).hasMatch()) {
+            continue;
+        }
+        const QString busy = path + QStringLiteral("/device/gpu_busy_percent");
+        if (QFile::exists(busy)) {
+            files << busy;
+        }
+    }
+    return files;
+}
+
+QString cleanName(QString s) {
+    static const QRegularExpression noise(
+        QStringLiteral("\\(R\\)|\\(TM\\)|Graphics"), QRegularExpression::CaseInsensitiveOption);
+    static const QRegularExpression spaces(QStringLiteral("\\s+"));
+    s.replace(noise, QString());
+    s.replace(spaces, QStringLiteral(" "));
+    return s.trimmed();
+}
+
+QString parseNvidiaName(const QByteArray& out) {
+    const QString first = QString::fromUtf8(out).split('\n').value(0).trimmed();
+    return first.isEmpty() ? QString() : cleanName(first);
+}
+
+QString parseGlxinfoName(const QByteArray& out) {
+    const QStringList lines = QString::fromUtf8(out).split('\n');
+    for (const QString& line : lines) {
+        const qsizetype idx = line.indexOf(QStringLiteral("Device:"));
+        if (idx < 0) {
+            continue;
+        }
+
+        QString rest = line.mid(idx + 7);
+        const qsizetype paren = rest.indexOf('(');
+        if (paren >= 0) {
+            rest = rest.left(paren);
+        }
+
+        const QString cleaned = cleanName(rest);
+        if (!cleaned.isEmpty()) {
+            return cleaned;
+        }
+    }
+
+    return QString();
+}
+
+QString parseLspciName(const QByteArray& out) {
+    static const QRegularExpression lineRe(
+        QStringLiteral("vga|3d controller|display"), QRegularExpression::CaseInsensitiveOption);
+
+    const QStringList lines = QString::fromUtf8(out).split('\n');
+    QString match;
+    for (const QString& line : lines) {
+        if (lineRe.match(line).hasMatch()) {
+            match = line;
+            break;
+        }
+    }
+
+    if (match.isEmpty()) {
+        return QString();
+    }
+
+    static const QRegularExpression bracketRe(QStringLiteral("\\[([^\\]]+)\\][^\\[]*$"));
+    const auto bracket = bracketRe.match(match);
+    if (bracket.hasMatch()) {
+        return cleanName(bracket.captured(1));
+    }
+
+    // Split on a colon followed by whitespace so the PCI slot ("00:02.0") is not
+    // mistaken for the class/name separator ("controller: Device").
+    static const QRegularExpression colonRe(QStringLiteral(":\\s+(.+)"));
+    const auto colon = colonRe.match(match);
+    if (colon.hasMatch()) {
+        return cleanName(colon.captured(1));
+    }
+
+    return QString();
+}
+
+struct NameSource {
+    QString program;
+    QStringList args;
+    QString (*parse)(const QByteArray&);
+};
+
+// Name probes in priority order; the first non-empty result wins. The NVIDIA
+// probe is first and doubles as the type probe (see finishNameSource).
+const std::array<NameSource, 3>& nameSources() {
+    static const std::array<NameSource, 3> sources = { {
+        { QStringLiteral("nvidia-smi"), { QStringLiteral("--query-gpu=name"), QStringLiteral("--format=csv,noheader") },
+            &parseNvidiaName },
+        { QStringLiteral("glxinfo"), { QStringLiteral("-B") }, &parseGlxinfoName },
+        { QStringLiteral("lspci"), {}, &parseLspciName },
+    } };
+    return sources;
+}
+
+// Index of the NVIDIA source within nameSources(); its result also drives type.
+constexpr int kNvidiaSource = 0;
 
 } // namespace
 
 Gpu::Gpu(QObject* parent)
     : TickingService(parent) {
+    m_busyFiles = gpuBusyFiles();
+
     auto* svc = caelestia::config::GlobalConfig::instance()->services();
     m_userType = parseType(svc->gpuType());
     QObject::connect(svc, &caelestia::config::ServiceConfig::gpuTypeChanged, this, [this, svc] {
         setUserType(parseType(svc->gpuType()));
     });
 
-    // Detection must run before any ServiceRef appears: callers may gate the ref on
-    // `type !== Gpu.None`, which would otherwise deadlock the detection.
-    if (m_userType == Auto) {
-        detectTypeOnce();
-    }
-    detectNameOnce();
+    detectGpu();
 }
 
 Gpu::Type Gpu::type() const {
@@ -74,6 +172,11 @@ void Gpu::setUserType(Type value) {
     if (type() != prevDerived) {
         Q_EMIT typeChanged();
     }
+
+    // Probe again when switching back to auto
+    if (value == Auto) {
+        detectGpu();
+    }
 }
 
 void Gpu::setAutoType(Type value) {
@@ -115,63 +218,74 @@ void Gpu::tick() {
     }
 }
 
-void Gpu::detectTypeOnce() {
-    if (m_typeProc) {
+void Gpu::detectGpu() {
+    if (m_detecting) {
         return;
     }
-    m_typeProc = new QProcess(this);
-    QObject::connect(m_typeProc, &QProcess::finished, this, [this](int, QProcess::ExitStatus) {
-        const QByteArray out = m_typeProc->readAllStandardOutput().trimmed();
-        if (!out.isEmpty()) {
-            setAutoType(parseType(QString::fromLatin1(out)));
-        }
-        m_typeProc->deleteLater();
-        m_typeProc = nullptr;
+    m_detecting = true;
+
+    // Probe in priority order, stopping at the first result
+    tryNameSource(0);
+}
+
+void Gpu::tryNameSource(int index) {
+    const NameSource& src = nameSources().at(static_cast<std::size_t>(index));
+    runProcess(src.program, src.args, [this, index, parse = src.parse](const QByteArray& out) {
+        finishNameSource(index, parse(out));
     });
-    m_typeProc->start(QStringLiteral("sh"), { QStringLiteral("-c"), QString::fromLatin1(kTypeDetectScript) });
 }
 
-void Gpu::detectNameOnce() {
-    if (m_nameProc) {
+void Gpu::finishNameSource(int index, QString name) {
+    // The NVIDIA name probe doubles as the type probe: a non-empty result means an
+    // NVIDIA GPU is present and queryable. Derive autoType unconditionally (even when
+    // the user pins a type) so a later switch to Auto reads a correct value without
+    // depending on its own re-probe, which is skipped while a probe is in flight.
+    if (index == kNvidiaSource) {
+        setAutoType(!name.isEmpty() ? Nvidia : (m_busyFiles.isEmpty() ? None : Generic));
+    }
+
+    if (!name.isEmpty()) {
+        setName(std::move(name));
+        m_detecting = false;
         return;
     }
-    m_nameProc = new QProcess(this);
-    QObject::connect(m_nameProc, &QProcess::finished, this, [this](int, QProcess::ExitStatus) {
-        const QString output = QString::fromUtf8(m_nameProc->readAllStandardOutput()).trimmed();
-        if (!output.isEmpty()) {
-            const QString lower = output.toLower();
-            if (lower.contains(QStringLiteral("nvidia")) || lower.contains(QStringLiteral("geforce")) ||
-                lower.contains(QStringLiteral("rtx")) || lower.contains(QStringLiteral("gtx")) ||
-                lower.contains(QStringLiteral("rx"))) {
-                setName(cleanName(output));
-            } else {
-                static const QRegularExpression bracketRe(QStringLiteral("\\[([^\\]]+)\\][^\\[]*$"));
-                const auto bracket = bracketRe.match(output);
-                if (bracket.hasMatch()) {
-                    setName(cleanName(bracket.captured(1)));
-                } else {
-                    static const QRegularExpression colonRe(QStringLiteral(":\\s*(.+)"));
-                    const auto colon = colonRe.match(output);
-                    if (colon.hasMatch()) {
-                        setName(cleanName(colon.captured(1)));
-                    }
-                }
-            }
+
+    if (index + 1 < static_cast<int>(nameSources().size())) {
+        tryNameSource(index + 1);
+    } else {
+        m_detecting = false;
+    }
+}
+
+void Gpu::runProcess(const QString& program, const QStringList& args, std::function<void(const QByteArray&)> callback) {
+    auto* proc = new QProcess(this);
+    proc->setStandardErrorFile(QProcess::nullDevice());
+
+    // Deliver the result exactly once, then tear the process down. A crash or a
+    // missing binary yields empty output so the caller can fall through gracefully:
+    // only FailedToStart skips finished(), and a crash reports CrashExit there.
+    const auto finish = [proc, callback = std::move(callback)](const QByteArray& out) {
+        callback(out);
+        proc->deleteLater();
+    };
+
+    QObject::connect(proc, &QProcess::finished, this, [finish, proc](int, QProcess::ExitStatus status) {
+        finish(status == QProcess::NormalExit ? proc->readAllStandardOutput() : QByteArray());
+    });
+    QObject::connect(proc, &QProcess::errorOccurred, this, [finish](QProcess::ProcessError err) {
+        if (err == QProcess::FailedToStart) {
+            finish(QByteArray());
         }
-        m_nameProc->deleteLater();
-        m_nameProc = nullptr;
     });
-    m_nameProc->start(QStringLiteral("sh"), { QStringLiteral("-c"), QString::fromLatin1(kNameDetectScript) });
+
+    proc->start(program, args);
 }
 
 void Gpu::readGenericUsage() {
-    const QStringList paths =
-        QDir(QStringLiteral("/sys/class/drm"))
-            .entryList(QStringList() << QStringLiteral("card*"), QDir::Dirs | QDir::NoDotAndDotDot);
     qreal sum = 0.0;
     int count = 0;
-    for (const QString& card : paths) {
-        QFile f(QStringLiteral("/sys/class/drm/%1/device/gpu_busy_percent").arg(card));
+    for (const QString& path : std::as_const(m_busyFiles)) {
+        QFile f(path);
         if (!f.open(QIODevice::ReadOnly | QIODevice::Text)) {
             continue;
         }
@@ -191,34 +305,33 @@ void Gpu::readGenericUsage() {
 }
 
 void Gpu::startNvidiaUsage() {
-    if (m_nvidiaProc) {
+    if (m_nvidiaQuerying) {
         return;
     }
-    m_nvidiaProc = new QProcess(this);
-    QObject::connect(m_nvidiaProc, &QProcess::finished, this, [this](int, QProcess::ExitStatus) {
-        const QByteArray out = m_nvidiaProc->readAllStandardOutput().trimmed();
-        m_nvidiaProc->deleteLater();
-        m_nvidiaProc = nullptr;
-
-        const QList<QByteArray> parts = out.split(',');
-        if (parts.size() < 2) {
-            return;
-        }
-        bool ok1 = false;
-        bool ok2 = false;
-        const qreal usage = parts.at(0).trimmed().toDouble(&ok1) / 100.0;
-        const qreal temp = parts.at(1).trimmed().toDouble(&ok2);
-        if (ok1 && std::abs(usage - m_percentage) > 0.0001) {
-            m_percentage = usage;
-            Q_EMIT percentageChanged();
-        }
-        if (ok2 && std::abs(temp - m_temperature) > 0.05) {
-            m_temperature = temp;
-            Q_EMIT temperatureChanged();
-        }
-    });
-    m_nvidiaProc->start(QStringLiteral("nvidia-smi"), { QStringLiteral("--query-gpu=utilization.gpu,temperature.gpu"),
-                                                          QStringLiteral("--format=csv,noheader,nounits") });
+    m_nvidiaQuerying = true;
+    runProcess(QStringLiteral("nvidia-smi"),
+        { QStringLiteral("--query-gpu=utilization.gpu,temperature.gpu"),
+            QStringLiteral("--format=csv,noheader,nounits") },
+        [this](const QByteArray& out) {
+            m_nvidiaQuerying = false;
+
+            const QList<QByteArray> parts = out.trimmed().split(',');
+            if (parts.size() < 2) {
+                return;
+            }
+            bool ok1 = false;
+            bool ok2 = false;
+            const qreal usage = parts.at(0).trimmed().toDouble(&ok1) / 100.0;
+            const qreal temp = parts.at(1).trimmed().toDouble(&ok2);
+            if (ok1 && std::abs(usage - m_percentage) > 0.0001) {
+                m_percentage = usage;
+                Q_EMIT percentageChanged();
+            }
+            if (ok2 && std::abs(temp - m_temperature) > 0.05) {
+                m_temperature = temp;
+                Q_EMIT temperatureChanged();
+            }
+        });
 }
 
 void Gpu::readGpuTemperature() {
@@ -244,13 +357,4 @@ Gpu::Type Gpu::parseType(const QString& s) {
     return None;
 }
 
-QString Gpu::cleanName(QString s) {
-    static const QRegularExpression noise(
-        QStringLiteral("\\(R\\)|\\(TM\\)|Graphics"), QRegularExpression::CaseInsensitiveOption);
-    static const QRegularExpression spaces(QStringLiteral("\\s+"));
-    s.replace(noise, QString());
-    s.replace(spaces, QStringLiteral(" "));
-    return s.trimmed();
-}
-
 } // namespace caelestia::services