device_health_probe.cpp

Go to the documentation of this file.

#include "device_health_probe.hpp"
 
#include "disk_reader.hpp"
 
#include <algorithm>
#include <array>
#include <chrono>
 
namespace {
DeviceProbeSample take_sample(DiskReader& reader, uint64_t offset, size_t size) {
    DeviceProbeSample sample;
    sample.offset = offset;
    sample.size = size;
    std::array<unsigned char, 4096> buffer{};
    const size_t to_read = std::min<size_t>(size, buffer.size());
    const auto start = std::chrono::steady_clock::now();
    sample.success = reader.read_at(offset, buffer.data(), to_read);
    sample.latency_ms = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::steady_clock::now() - start).count());
    if (!sample.success) {
        sample.error = "read failed";
    }
    return sample;
}
 
std::string health_to_string(DeviceHealthState state) {
    switch (state) {
        case DeviceHealthState::Healthy: return "Healthy";
        case DeviceHealthState::ReadableWithErrors: return "Readable with errors";
        case DeviceHealthState::PartiallyReadable: return "Partially readable";
        case DeviceHealthState::EnumeratedButUnstable: return "Enumerated but unstable";
        case DeviceHealthState::NotReadable: return "Not readable";
    }
    return "Unknown";
}
}
 
DeviceHealthReport DeviceHealthProbe::probe(const std::string& device_path, CancelCallback cancel_cb) {
    DeviceHealthReport report;
    report.device_path = device_path;
 
    DiskReader reader;
    std::string error;
    report.open_ok = reader.open_readonly(device_path, error);
    if (!report.open_ok) {
        report.summary = "Device could not be opened: " + error;
        report.state = DeviceHealthState::NotReadable;
        return report;
    }
 
    report.total_size = reader.size();
    report.logical_sector_size = reader.logical_sector_size();
    report.size_suspicious = (report.total_size == 0 || report.total_size < 4096);
 
    std::vector<uint64_t> offsets;
    offsets.push_back(0);
    if (report.total_size > (1ull << 20)) offsets.push_back(1ull << 20);
    if (report.total_size > (16ull << 20)) offsets.push_back(16ull << 20);
    if (report.total_size > 0) offsets.push_back(report.total_size / 2);
    if (report.total_size > 4096) offsets.push_back(report.total_size - 4096);
 
    size_t failures = 0;
    size_t slow = 0;
    for (const auto offset : offsets) {
        if (cancel_cb && cancel_cb()) break;
        auto sample = take_sample(reader, offset, 4096);
        if (offset == 0) report.read_lba0_ok = sample.success;
        if (offset + 4096 >= report.total_size) report.read_tail_ok = sample.success;
        if (!sample.success) ++failures;
        if (sample.latency_ms > 250) ++slow;
        report.samples.push_back(std::move(sample));
    }
 
    report.unstable_latency = slow > 1;
    report.intermittent_failures = failures > 0 && failures < report.samples.size();
 
    if (failures == 0 && !report.size_suspicious && !report.unstable_latency) {
        report.state = DeviceHealthState::Healthy;
    } else if (failures == 0 && report.unstable_latency) {
        report.state = DeviceHealthState::EnumeratedButUnstable;
    } else if (failures < report.samples.size() / 2 + 1) {
        report.state = DeviceHealthState::ReadableWithErrors;
    } else if (failures < report.samples.size()) {
        report.state = DeviceHealthState::PartiallyReadable;
    } else {
        report.state = DeviceHealthState::NotReadable;
    }
 
    report.summary = health_to_string(report.state);
    if (report.size_suspicious) report.summary += "; suspicious size";
    if (report.unstable_latency) report.summary += "; unstable latency";
    if (report.intermittent_failures) report.summary += "; intermittent failures";
 
    return report;
}