BadBlockMap Class Reference

#include <bad_block_map.hpp>

Public Member Functions
void	mark_readable (uint64_t offset, uint64_t length)
void	mark_bad (uint64_t offset, uint64_t length)
void	mark_slow (uint64_t offset, uint64_t length)
std::vector< BlockRange >	readable_ranges () const
std::vector< BlockRange >	bad_ranges () const
std::vector< BlockRange >	slow_ranges () const
bool	is_known_bad (uint64_t offset, uint64_t length) const
void	merge_adjacent ()

Private Member Functions
void	mark (uint64_t offset, uint64_t length, RangeState state)
std::vector< BlockRange >	filtered (RangeState state) const

Private Attributes
std::vector< BlockRange >	ranges_

Detailed Description

Definition at line 18 of file bad_block_map.hpp.

Member Function Documentation

bad_ranges()

std::vector< BlockRange > BadBlockMap::bad_ranges

(

)

const

Definition at line 21 of file bad_block_map.cpp.

                                                    {
    return filtered(RangeState::Bad);
}

References Bad, and filtered().

Referenced by RescueImager::create_image().

filtered()

std::vector< BlockRange > BadBlockMap::filtered ( RangeState state ) const

private

Definition at line 79 of file bad_block_map.cpp.

                                                                  {
    std::vector<BlockRange> out;
    for (const auto& range : ranges_) {
        if (range.state == state) out.push_back(range);
    }
    return out;
}

References ranges_.

Referenced by bad_ranges(), readable_ranges(), and slow_ranges().

is_known_bad()

bool BadBlockMap::is_known_bad	(	uint64_t	offset,
		uint64_t	length ) const

Definition at line 29 of file bad_block_map.cpp.

                                                                     {
    const uint64_t end = offset + length;
    for (const auto& range : ranges_) {
        if (range.state != RangeState::Bad) continue;
        const uint64_t range_end = range.offset + range.length;
        if (offset < range_end && end > range.offset) {
            return true;
        }
    }
    return false;
}

References Bad, and ranges_.

mark()

void BadBlockMap::mark ( uint64_t offset, uint64_t length, RangeState state )

private

Definition at line 73 of file bad_block_map.cpp.

                                                                         {
    if (length == 0) return;
    ranges_.push_back(BlockRange{offset, length, state});
    merge_adjacent();
}

References merge_adjacent(), and ranges_.

Referenced by mark_bad(), mark_readable(), and mark_slow().

mark_bad()

void BadBlockMap::mark_bad	(	uint64_t	offset,
		uint64_t	length )

Definition at line 9 of file bad_block_map.cpp.

                                                           {
    mark(offset, length, RangeState::Bad);
}

References Bad, and mark().

Referenced by FaultTolerantReader::read_rescue_recursive().

mark_readable()

void BadBlockMap::mark_readable	(	uint64_t	offset,
		uint64_t	length )

Definition at line 5 of file bad_block_map.cpp.

                                                                {
    mark(offset, length, RangeState::Readable);
}

References mark(), and Readable.

Referenced by FaultTolerantReader::read_at(), and FaultTolerantReader::read_rescue_recursive().

mark_slow()

void BadBlockMap::mark_slow	(	uint64_t	offset,
		uint64_t	length )

Definition at line 13 of file bad_block_map.cpp.

                                                            {
    mark(offset, length, RangeState::Slow);
}

References mark(), and Slow.

Referenced by FaultTolerantReader::read_rescue_recursive().

merge_adjacent()

void BadBlockMap::merge_adjacent

(

)

Definition at line 41 of file bad_block_map.cpp.

                                 {
    if (ranges_.empty()) return;
 
    std::sort(ranges_.begin(), ranges_.end(), [](const BlockRange& a, const BlockRange& b) {
        if (a.state != b.state) return static_cast<int>(a.state) < static_cast<int>(b.state);
        return a.offset < b.offset;
    });
 
    std::vector<BlockRange> merged;
    merged.reserve(ranges_.size());
    merged.push_back(ranges_.front());
 
    for (size_t i = 1; i < ranges_.size(); ++i) {
        auto& last = merged.back();
        const auto& current = ranges_[i];
        const uint64_t last_end = last.offset + last.length;
 
        if (last.state == current.state && current.offset <= last_end) {
            const uint64_t new_end = std::max<uint64_t>(last_end, current.offset + current.length);
            last.length = new_end - last.offset;
        } else {
            merged.push_back(current);
        }
    }
 
    std::sort(merged.begin(), merged.end(), [](const BlockRange& a, const BlockRange& b) {
        return a.offset < b.offset;
    });
 
    ranges_.swap(merged);
}

References ranges_.

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

readable_ranges()

std::vector< BlockRange > BadBlockMap::readable_ranges

(

)

const

Definition at line 17 of file bad_block_map.cpp.

                                                         {
    return filtered(RangeState::Readable);
}

References filtered(), and Readable.

slow_ranges()

std::vector< BlockRange > BadBlockMap::slow_ranges

(

)

const

Definition at line 25 of file bad_block_map.cpp.

                                                     {
    return filtered(RangeState::Slow);
}

References filtered(), and Slow.

Referenced by RescueImager::create_image().

Member Data Documentation

ranges_

std::vector<BlockRange> BadBlockMap::ranges_

private

Definition at line 35 of file bad_block_map.hpp.

Referenced by filtered(), is_known_bad(), mark(), and merge_adjacent().

---

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

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