device_enumerator.cpp

Go to the documentation of this file.

#include "device_health_probe.hpp"
#include "device_enumerator.hpp"
 
#include <filesystem>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
 
namespace fs = std::filesystem;
 
namespace {
    std::string trim(const std::string& s) {
        const auto start = s.find_first_not_of(" \t\r\n");
        if (start == std::string::npos) return "";
        const auto end = s.find_last_not_of(" \t\r\n");
        return s.substr(start, end - start + 1);
    }
 
    std::string read_text_file(const fs::path& p) {
        std::ifstream f(p);
        if (!f) return "";
        std::ostringstream ss;
        ss << f.rdbuf();
        return trim(ss.str());
    }
 
    uint64_t read_u64_file(const fs::path& p) {
        std::ifstream f(p);
        uint64_t v = 0;
        if (f) f >> v;
        return v;
    }
 
    bool starts_with(const std::string& s, const std::string& prefix) {
        return s.rfind(prefix, 0) == 0;
    }
 
    bool is_real_disk_name(const std::string& name) {
        return starts_with(name, "sd") ||
               starts_with(name, "nvme") ||
               starts_with(name, "mmcblk") ||
               starts_with(name, "vd") ||
               starts_with(name, "hd") ||
               starts_with(name, "md") ||
               starts_with(name, "dm-") ||
               starts_with(name, "loop");
    }
}
 
std::vector<DeviceInfo> DeviceEnumerator::enumerate_linux_block_devices(bool include_health_probe) {
    std::vector<DeviceInfo> out;
    const fs::path sys_block{"/sys/block"};
 
    if (!fs::exists(sys_block) || !fs::is_directory(sys_block)) {
        return out;
    }
 
    for (const auto& entry : fs::directory_iterator(sys_block)) {
        const auto name = entry.path().filename().string();
        if (!is_real_disk_name(name)) {
            continue;
        }
 
        DeviceInfo d;
        d.name = name;
        d.path = "/dev/" + name;
        d.size_bytes = read_u64_file(entry.path() / "size") * 512ull;
        d.model = read_text_file(entry.path() / "device/model");
        d.transport = read_text_file(entry.path() / "device/subsystem" / "device" / "transport");
        d.type = (starts_with(name, "loop") || starts_with(name, "dm-")) ? "virtual" : "disk";
        d.removable = read_u64_file(entry.path() / "removable") != 0;
 
        if (starts_with(name, "nvme")) {
            d.transport = "NVMe";
        } else if (starts_with(name, "md")) {
            d.transport = "Linux RAID";
        } else if (starts_with(name, "dm-")) {
            d.transport = "Device Mapper";
        } else if (starts_with(name, "loop")) {
            d.transport = "Loop";
        } else if (d.transport.empty()) {
            d.transport = "Block";
        }
 
        if (include_health_probe) {
            const auto health = DeviceHealthProbe::probe(d.path);
            d.degraded = health.state != DeviceHealthState::Healthy;
            d.health_summary = health.summary;
        }
 
        out.push_back(d);
    }
 
    return out;
}