FaultTolerantReader Class Reference

#include <fault_tolerant_reader.hpp>

Public Types
using	CancelCallback = std::function<bool()>

Public Member Functions
	FaultTolerantReader ()=default
bool	open (const std::string &path, std::string &error)
void	close ()
bool	is_open () const
uint64_t	size () const
uint32_t	logical_sector_size () const
const std::string &	path () const
void	set_config (const FaultTolerantReaderConfig &cfg)
void	set_cancel_callback (CancelCallback cb)
ReadResult	read_at (uint64_t offset, void *buffer, size_t size)
ReadResult	read_rescue (uint64_t offset, void *buffer, size_t size)
const BadBlockMap &	bad_block_map () const
BadBlockMap &	bad_block_map ()

Private Member Functions
ReadResult	read_rescue_recursive (uint64_t offset, unsigned char *buffer, size_t size)

Private Attributes
DiskReader	reader_
FaultTolerantReaderConfig	config_
CancelCallback	cancel_cb_
BadBlockMap	bad_map_
std::mutex	mutex_

Detailed Description

Definition at line 27 of file fault_tolerant_reader.hpp.

Member Typedef Documentation

CancelCallback

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

Definition at line 29 of file fault_tolerant_reader.hpp.

Constructor & Destructor Documentation

FaultTolerantReader()

FaultTolerantReader::FaultTolerantReader ( )

default

References bad_block_map(), close(), is_open(), logical_sector_size(), open(), path(), read_at(), read_rescue(), read_rescue_recursive(), set_cancel_callback(), set_config(), and size().

Member Function Documentation

bad_block_map() [1/2]

BadBlockMap & FaultTolerantReader::bad_block_map

(

)

Definition at line 67 of file fault_tolerant_reader.cpp.

                                                {
    return bad_map_;
}

References bad_map_.

bad_block_map() [2/2]

const BadBlockMap & FaultTolerantReader::bad_block_map

(

)

const

Definition at line 63 of file fault_tolerant_reader.cpp.

                                                            {
    return bad_map_;
}

References bad_map_.

Referenced by RescueImager::create_image(), and FaultTolerantReader().

close()

void FaultTolerantReader::close

(

)

Definition at line 11 of file fault_tolerant_reader.cpp.

                                {
    std::scoped_lock lock(mutex_);
    reader_.close();
    bad_map_ = {};
}

References bad_map_, DiskReader::close(), mutex_, and reader_.

Referenced by FaultTolerantReader().

is_open()

bool FaultTolerantReader::is_open

(

)

const

Definition at line 17 of file fault_tolerant_reader.cpp.

                                        {
    return reader_.is_open();
}

References DiskReader::is_open(), and reader_.

Referenced by FaultTolerantReader().

logical_sector_size()

uint32_t FaultTolerantReader::logical_sector_size

(

)

const

Definition at line 25 of file fault_tolerant_reader.cpp.

                                                        {
    return reader_.logical_sector_size();
}

References DiskReader::logical_sector_size(), and reader_.

Referenced by FaultTolerantReader().

open()

bool FaultTolerantReader::open	(	const std::string &	path,
		std::string &	error )

Definition at line 7 of file fault_tolerant_reader.cpp.

                                                                      {
    return reader_.open_readonly(path, error);
}

References DiskReader::open_readonly(), path(), and reader_.

Referenced by RescueImager::create_image(), and FaultTolerantReader().

path()

const std::string & FaultTolerantReader::path

(

)

const

Definition at line 29 of file fault_tolerant_reader.cpp.

                                                 {
    return reader_.path();
}

References DiskReader::path(), and reader_.

Referenced by FaultTolerantReader(), and open().

read_at()

ReadResult FaultTolerantReader::read_at	(	uint64_t	offset,
		void *	buffer,
		size_t	size )

Definition at line 41 of file fault_tolerant_reader.cpp.

                                                                                  {
    std::scoped_lock lock(mutex_);
    ReadResult result;
    if (cancel_cb_ && cancel_cb_()) {
        result.error = "cancelled";
        return result;
    }
    result.success = reader_.read_at(offset, buffer, size);
    result.bytes_read = result.success ? size : 0;
    if (result.success) {
        bad_map_.mark_readable(offset, size);
    } else {
        result.error = "read failed";
    }
    return result;
}

References bad_map_, ReadResult::bytes_read, cancel_cb_, ReadResult::error, BadBlockMap::mark_readable(), mutex_, DiskReader::read_at(), reader_, size(), and ReadResult::success.

Referenced by FaultTolerantReader().

read_rescue()

ReadResult FaultTolerantReader::read_rescue	(	uint64_t	offset,
		void *	buffer,
		size_t	size )

Definition at line 58 of file fault_tolerant_reader.cpp.

                                                                                      {
    std::scoped_lock lock(mutex_);
    return read_rescue_recursive(offset, static_cast<unsigned char*>(buffer), size);
}

References mutex_, read_rescue_recursive(), and size().

Referenced by RescueImager::create_image(), and FaultTolerantReader().

read_rescue_recursive()

ReadResult FaultTolerantReader::read_rescue_recursive ( uint64_t offset, unsigned char * buffer, size_t size )

private

Definition at line 71 of file fault_tolerant_reader.cpp.

                                                                                                         {
    ReadResult result;
    if (size == 0) {
        result.success = true;
        return result;
    }
    if (cancel_cb_ && cancel_cb_()) {
        result.error = "cancelled";
        return result;
    }
 
    const auto start = std::chrono::steady_clock::now();
    for (int attempt = 0; attempt < std::max(1, config_.max_retries); ++attempt) {
        if (reader_.read_at(offset, buffer, size)) {
            result.success = true;
            result.bytes_read = size;
            bad_map_.mark_readable(offset, size);
            const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::steady_clock::now() - start).count();
            if (config_.mark_slow_ranges && elapsed > 250) {
                bad_map_.mark_slow(offset, size);
            }
            return result;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(25 * (attempt + 1)));
    }
 
    if (size <= config_.min_chunk_size) {
        bad_map_.mark_bad(offset, size);
        result.error = "unreadable range";
        return result;
    }
 
    const size_t left_size = size / 2;
    const size_t right_size = size - left_size;
    auto left = read_rescue_recursive(offset, buffer, left_size);
    auto right = read_rescue_recursive(offset + left_size, buffer + left_size, right_size);
 
    result.bytes_read = left.bytes_read + right.bytes_read;
    result.partial = result.bytes_read > 0 && result.bytes_read < size;
    result.success = (result.bytes_read == size);
    if (!result.success && result.partial) {
        result.error = "partial read";
    } else if (!result.success) {
        result.error = left.error.empty() ? right.error : left.error;
    }
    return result;
}

References bad_map_, ReadResult::bytes_read, cancel_cb_, config_, ReadResult::error, BadBlockMap::mark_bad(), BadBlockMap::mark_readable(), BadBlockMap::mark_slow(), FaultTolerantReaderConfig::mark_slow_ranges, FaultTolerantReaderConfig::max_retries, FaultTolerantReaderConfig::min_chunk_size, ReadResult::partial, DiskReader::read_at(), read_rescue_recursive(), reader_, size(), and ReadResult::success.

Referenced by FaultTolerantReader(), read_rescue(), and read_rescue_recursive().

set_cancel_callback()

void FaultTolerantReader::set_cancel_callback

(

CancelCallback

cb

)

Definition at line 37 of file fault_tolerant_reader.cpp.

                                                               {
    cancel_cb_ = std::move(cb);
}

References cancel_cb_.

Referenced by RescueImager::create_image(), and FaultTolerantReader().

set_config()

void FaultTolerantReader::set_config

(

const FaultTolerantReaderConfig &

cfg

)

Definition at line 33 of file fault_tolerant_reader.cpp.

                                                                         {
    config_ = cfg;
}

References config_.

Referenced by FaultTolerantReader().

size()

uint64_t FaultTolerantReader::size

(

)

const

Definition at line 21 of file fault_tolerant_reader.cpp.

                                         {
    return reader_.size();
}

References reader_, and DiskReader::size().

Referenced by RescueImager::create_image(), FaultTolerantReader(), read_at(), read_rescue(), and read_rescue_recursive().

Member Data Documentation

bad_map_

BadBlockMap FaultTolerantReader::bad_map_

private

Definition at line 56 of file fault_tolerant_reader.hpp.

Referenced by bad_block_map(), bad_block_map(), close(), read_at(), and read_rescue_recursive().

cancel_cb_

CancelCallback FaultTolerantReader::cancel_cb_

private

Definition at line 55 of file fault_tolerant_reader.hpp.

Referenced by read_at(), read_rescue_recursive(), and set_cancel_callback().

config_

FaultTolerantReaderConfig FaultTolerantReader::config_

private

Definition at line 54 of file fault_tolerant_reader.hpp.

Referenced by read_rescue_recursive(), and set_config().

mutex_

std::mutex FaultTolerantReader::mutex_

mutableprivate

Definition at line 57 of file fault_tolerant_reader.hpp.

Referenced by close(), read_at(), and read_rescue().

reader_

DiskReader FaultTolerantReader::reader_

private

Definition at line 53 of file fault_tolerant_reader.hpp.

Referenced by close(), is_open(), logical_sector_size(), open(), path(), read_at(), read_rescue_recursive(), and size().

---

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

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