RescueImager Class Reference

#include <rescue_imager.hpp>

Public Types
using	ProgressCallback = std::function<void(uint64_t, uint64_t)>
using	CancelCallback = std::function<bool()>

Static Public Member Functions
static bool	create_image (const std::string &device_path, const std::string &image_path, RescueImageReport &report, std::string &error, ProgressCallback progress_cb={}, CancelCallback cancel_cb={})

Detailed Description

Definition at line 20 of file rescue_imager.hpp.

Member Typedef Documentation

CancelCallback

using RescueImager::CancelCallback = std::function<bool()>

Definition at line 23 of file rescue_imager.hpp.

ProgressCallback

using RescueImager::ProgressCallback = std::function<void(uint64_t, uint64_t)>

Definition at line 22 of file rescue_imager.hpp.

Member Function Documentation

create_image()

bool RescueImager::create_image ( const std::string & device_path, const std::string & image_path, RescueImageReport & report, std::string & error, ProgressCallback progress_cb = {}, CancelCallback cancel_cb = {} )

static

Definition at line 9 of file rescue_imager.cpp.

                                                          {
    report = {};
    report.image_path = image_path;
    report.map_path = image_path + ".badblocks.txt";
 
    FaultTolerantReader reader;
    reader.set_cancel_callback(cancel_cb);
    std::string open_error;
    if (!reader.open(device_path, open_error)) {
        error = open_error;
        return false;
    }
 
    const uint64_t total = reader.size();
    report.bytes_requested = total;
 
    fs::create_directories(fs::path(image_path).parent_path());
    std::ofstream out(image_path, std::ios::binary);
    if (!out) {
        error = "unable to create rescue image";
        return false;
    }
 
    std::vector<unsigned char> buffer(1024 * 1024);
    for (uint64_t offset = 0; offset < total; offset += buffer.size()) {
        if (cancel_cb && cancel_cb()) {
            error = "cancelled";
            return false;
        }
 
        const size_t chunk = static_cast<size_t>(std::min<uint64_t>(buffer.size(), total - offset));
        std::fill(buffer.begin(), buffer.begin() + static_cast<std::ptrdiff_t>(chunk), 0);
        auto rr = reader.read_rescue(offset, buffer.data(), chunk);
        out.write(reinterpret_cast<const char*>(buffer.data()), static_cast<std::streamsize>(chunk));
        if (!out) {
            error = "write error during rescue imaging";
            return false;
        }
        report.bytes_written += rr.bytes_read;
        if (progress_cb) progress_cb(offset + chunk, total);
    }
 
    std::ofstream map_out(report.map_path, std::ios::binary);
    if (!map_out) {
        error = "unable to create bad block map";
        return false;
    }
 
    reader.bad_block_map().merge_adjacent();
    const auto bad = reader.bad_block_map().bad_ranges();
    report.bad_ranges = bad.size();
    for (const auto& range : bad) {
        map_out << range.offset << '\t' << range.length << '\t' << "bad" << '\n';
    }
    for (const auto& range : reader.bad_block_map().slow_ranges()) {
        map_out << range.offset << '\t' << range.length << '\t' << "slow" << '\n';
    }
 
    report.logs.push_back("Rescue image completed");
    report.logs.push_back("Bytes written: " + std::to_string(report.bytes_written));
    report.logs.push_back("Bad ranges: " + std::to_string(report.bad_ranges));
    return true;
}

References FaultTolerantReader::bad_block_map(), BadBlockMap::bad_ranges(), RescueImageReport::bad_ranges, RescueImageReport::bytes_requested, RescueImageReport::bytes_written, RescueImageReport::image_path, RescueImageReport::logs, RescueImageReport::map_path, BadBlockMap::merge_adjacent(), FaultTolerantReader::open(), FaultTolerantReader::read_rescue(), FaultTolerantReader::set_cancel_callback(), FaultTolerantReader::size(), and BadBlockMap::slow_ranges().

Referenced by RecoveryExporter::create_rescue_image().

---

The documentation for this class was generated from the following files:

• BastionGuard/thirdparty/bastionguard-recovery-data/src/rescue_imager.hpp
• BastionGuard/thirdparty/bastionguard-recovery-data/src/rescue_imager.cpp