bad_block_map.cpp

Go to the documentation of this file.

#include "bad_block_map.hpp"
 
#include <algorithm>
 
void BadBlockMap::mark_readable(uint64_t offset, uint64_t length) {
    mark(offset, length, RangeState::Readable);
}
 
void BadBlockMap::mark_bad(uint64_t offset, uint64_t length) {
    mark(offset, length, RangeState::Bad);
}
 
void BadBlockMap::mark_slow(uint64_t offset, uint64_t length) {
    mark(offset, length, RangeState::Slow);
}
 
std::vector<BlockRange> BadBlockMap::readable_ranges() const {
    return filtered(RangeState::Readable);
}
 
std::vector<BlockRange> BadBlockMap::bad_ranges() const {
    return filtered(RangeState::Bad);
}
 
std::vector<BlockRange> BadBlockMap::slow_ranges() const {
    return filtered(RangeState::Slow);
}
 
bool BadBlockMap::is_known_bad(uint64_t offset, uint64_t length) const {
    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;
}
 
void BadBlockMap::merge_adjacent() {
    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);
}
 
void BadBlockMap::mark(uint64_t offset, uint64_t length, RangeState state) {
    if (length == 0) return;
    ranges_.push_back(BlockRange{offset, length, state});
    merge_adjacent();
}
 
std::vector<BlockRange> BadBlockMap::filtered(RangeState state) const {
    std::vector<BlockRange> out;
    for (const auto& range : ranges_) {
        if (range.state == state) out.push_back(range);
    }
    return out;
}