use store_io_core::error::{Capability, Error, ErrorContext, Op};
use store_io_core::id::{RegionId, VolumeId};
use store_io_format::judge::{self, PairVerdict, SlotVerdict, Standing};
use store_io_format::meta::VolumeMeta;
use store_io_format::meta2::{
PageHeader, RawEntry, VOLUME_META2_LEN, VolumeMeta2, decode_page, encode_page, entries_per_page,
};
use store_io_format::slot::{FORMAT_2, SlotIndex, SlotStatus};
use store_io_platform::Platform;
use crate::domain::Domain;
use crate::exec::Lane;
use crate::layout::Layout;
use crate::slots::{PairAt, PairRead, plan_next, read_pair, read_pairs, reread_failed, write_slot};
use crate::store::*;
pub const MAX_REGION_CAPACITY: u32 = 1 << 22;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum SlotDamage {
Older,
InFlight,
Damage,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct DamagedSlot {
pub page: Option<u32>,
pub slot_b: bool,
pub damage: SlotDamage,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct MetadataReport {
pub clean_close: bool,
pub stale_pages: Vec<u32>,
pub lost_pages: Vec<u32>,
pub volume_stale: bool,
pub healed: Option<Healed>,
pub frozen: bool,
pub read_only_reason: Option<&'static str>,
pub retried_reads: u32,
pub damaged_slots: Vec<DamagedSlot>,
pub invalid_entries: Vec<(u32, u32)>,
pub extra_extents: Vec<(RegionId, (u64, u64))>,
pub superseded: Vec<RegionId>,
pub shares_reserved: Vec<RegionId>,
pub stale_page_agreement: Vec<(u32, bool)>,
pub lost_header_writes: Vec<RegionId>,
pub truncated: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum Healed {
VolumeRecord,
Page(u32),
}
impl core::fmt::Display for MetadataReport {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let yes = |b: bool| if b { "yes" } else { "no" };
writeln!(f, "clean close {}", yes(self.clean_close))?;
if self.volume_stale {
writeln!(f, "volume record stale")?;
}
if !self.stale_pages.is_empty() {
writeln!(f, "stale pages {:?}", self.stale_pages)?;
}
if !self.lost_pages.is_empty() {
writeln!(f, "lost pages {:?}", self.lost_pages)?;
}
if let Some(h) = self.healed {
writeln!(f, "healed {h:?}")?;
}
if self.frozen {
writeln!(f, "allocation frozen")?;
}
if let Some(r) = self.read_only_reason {
writeln!(f, "read-only {r}")?;
}
if self.retried_reads > 0 {
writeln!(f, "retried reads {}", self.retried_reads)?;
}
for d in &self.damaged_slots {
let pair = d
.page
.map_or_else(|| "volume record".to_owned(), |p| format!("page {p}"));
let slot = if d.slot_b { 'B' } else { 'A' };
let what = match d.damage {
SlotDamage::Older => "an older copy, damaged",
SlotDamage::InFlight => "the write in flight",
SlotDamage::Damage => "damage",
};
writeln!(f, "damaged slot {pair} {slot}: {what}")?;
}
if !self.invalid_entries.is_empty() {
writeln!(f, "invalid entries {:?}", self.invalid_entries)?;
}
for (id, (off, len)) in &self.extra_extents {
writeln!(f, "extra extent region {id}: {len} bytes at {off}")?;
}
if !self.superseded.is_empty() {
writeln!(f, "superseded {:?}", self.superseded)?;
}
if !self.shares_reserved.is_empty() {
writeln!(f, "shares reserved {:?}", self.shares_reserved)?;
}
for (p, agrees) in &self.stale_page_agreement {
let word = if *agrees { "agree" } else { "disagree" };
writeln!(f, "stale page {p} headers {word} with entries")?;
}
if !self.lost_header_writes.is_empty() {
writeln!(f, "lost header {:?}", self.lost_header_writes)?;
}
if self.truncated {
writeln!(f, "(lists cut at 256 items)")?;
}
Ok(())
}
}
pub(crate) const fn page_object(p: u32) -> u64 {
(1u64 << 61) | p as u64
}
pub(crate) fn pair_page(volume: VolumeId, l: &Layout, p: u32) -> PairAt {
let (a, b) = l.page_slots(p);
PairAt {
volume: *volume.as_bytes(),
object: page_object(p),
a,
b,
log2: l.log2_table,
format: FORMAT_2,
numbered: true,
}
}
#[derive(Debug, Clone)]
pub(crate) struct Page2 {
pub(crate) pair: PairRead,
pub(crate) standing: Standing,
pub(crate) header: Option<PageHeader>,
pub(crate) entries: Vec<RawEntry>,
}
#[derive(Debug, Clone)]
pub(crate) struct Meta2 {
pub(crate) volume: VolumeMeta2,
pub(crate) pages: Vec<Page2>,
pub(crate) free: crate::footprint::FreeMap,
pub(crate) usage: Vec<(u32, u64, u64)>,
pub(crate) reserved_names: Vec<store_io_format::meta::RegionName>,
pub(crate) cut_short: bool,
pub(crate) allocated: Vec<(u64, u64)>,
pub(crate) claims: Vec<Claim>,
pub(crate) marked: u64,
pub(crate) holds: Vec<Hold>,
pub(crate) stale_extra: Vec<(usize, u64, (u64, u64))>,
}
pub(crate) const SEQ_MARGIN: u32 = 1 << 12;
impl Page2 {
pub(crate) fn raise_next_seq(&mut self) {
if let Some(h) = self.header.as_mut() {
h.next_seq = h.next_seq.saturating_add(SEQ_MARGIN);
}
}
pub(crate) fn meta_seq(&self) -> u64 {
self.pair
.report
.winner_info()
.and_then(|(i, _)| self.pair.facts[usize::from(i.as_u8())])
.and_then(|f| f.numbered)
.map_or(0, |n| n.meta_seq)
}
pub(crate) fn ahead(&self) -> impl Iterator<Item = (u32, u64)> + '_ {
let ms = self.meta_seq();
self.entries
.iter()
.filter(move |e| e.footprint_seq > ms)
.map(|e| (e.seq, e.footprint_seq))
}
}
#[derive(Debug, Clone)]
pub(crate) struct Hold {
pub(crate) page: usize,
pub(crate) seq: u32,
pub(crate) span: Option<(u64, u64)>,
pub(crate) usage: Option<(u32, u64, u64)>,
pub(crate) name: Option<store_io_format::meta::RegionName>,
pub(crate) short: bool,
pub(crate) footprint_seq: u64,
pub(crate) own: Vec<(u64, u64)>,
pub(crate) demoted: Option<(store_io_format::meta::RegionName, Vec<(u64, u64)>)>,
pub(crate) entry_name: Option<store_io_format::meta::RegionName>,
}
impl Hold {
pub(crate) fn id(&self) -> u64 {
((self.page as u64) << 32) | u64::from(self.seq)
}
}
#[derive(Debug, Clone)]
pub(crate) struct Claim {
pub(crate) page: usize,
pub(crate) seq: u32,
pub(crate) name: store_io_format::meta::RegionName,
}
impl Meta2 {
pub(crate) fn mark(&mut self, ranges: &[(u64, u64)], len: u64) {
self.allocated.extend_from_slice(ranges);
self.marked += ranges.iter().map(|r| r.1).sum::<u64>();
self.rebuild_free(len);
}
pub(crate) fn unmark(&mut self, ranges: &[(u64, u64)], len: u64) {
for r in ranges {
if let Some(i) = self.allocated.iter().position(|a| a == r) {
let _gone = self.allocated.swap_remove(i);
}
}
let bytes = ranges.iter().map(|r| r.1).sum::<u64>();
debug_assert!(self.marked >= bytes, "unmarked more than was marked");
self.marked = self.marked.saturating_sub(bytes);
self.rebuild_free(len);
}
pub(crate) fn settle(&mut self, bytes: u64) {
debug_assert!(self.marked >= bytes, "settled more than was marked");
self.marked = self.marked.saturating_sub(bytes);
}
pub(crate) fn rebuild_free(&mut self, len: u64) {
let mut all = self.allocated.clone();
self.free = crate::footprint::FreeMap::complement(self.volume.table_end(), len, &mut all);
}
}
pub(crate) fn next_meta_seq_of(meta: &Meta) -> Result<u64, Error> {
let v2 = meta.v2.as_deref().ok_or_else(corrupt)?;
next_meta_seq(&meta.volume_pair, &v2.pages, None)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn write_page<P: Platform>(
q: &mut Lane<P::Queue>,
file: &P::File,
pool: &store_io_buf::BufPool,
layout: &Layout,
volume: VolumeId,
policy: &Policy,
domain: &Domain,
meta: &mut Meta,
p: usize,
payload: &[u8],
meta_seq: u64,
owner_generation: u64,
) -> Result<(), Error> {
let v2 = meta.v2.as_deref_mut().ok_or_else(corrupt)?;
let page = v2.pages.get_mut(p).ok_or_else(corrupt)?;
if page.standing != Standing::Confirmed {
return Err(Error::NotWritten {
cause: store_io_core::error::NotWrittenCause::Frozen,
ctx: ErrorContext::default(),
});
}
let pi = u32::try_from(p).map_err(|_| corrupt())?;
let decoded = decode_page(payload, pi, entries_per_page(layout.log2_table))
.map(|d| (d.header, d.entries().collect::<Vec<_>>()))
.map_err(|_| corrupt())?;
let ahead: Vec<(u32, u64)> = page.ahead().collect();
if let Some(kept) = decoded
.1
.iter()
.find(|e| ahead.contains(&(e.seq, e.footprint_seq)))
{
return Err(Error::NotWritten {
cause: store_io_core::error::NotWrittenCause::Frozen,
ctx: ErrorContext {
region: Some(store_io_core::id::RegionId::from_raw(
(u64::from(pi) << 32) | u64::from(kept.seq),
)),
..ErrorContext::default()
},
});
}
let mut next = plan_next(&page.pair, payload, owner_generation)?;
next.meta_seq = meta_seq;
let at = pair_page(volume, layout, pi);
page.pair = durable_slot::<P>(q, file, pool, &at, &page.pair, &next, policy, domain)?;
page.header = Some(decoded.0);
page.entries = decoded.1;
Ok(())
}
fn numbered(pair: &PairRead, slot: SlotIndex) -> Option<u64> {
let i = usize::from(slot.as_u8());
let status = if slot == SlotIndex::A {
pair.report.a
} else {
pair.report.b
};
match status {
SlotStatus::Valid(info) => Some(info.meta_seq),
SlotStatus::BadPayloadCrc => pair.facts[i].and_then(|f| f.numbered).map(|n| n.meta_seq),
_ => None,
}
}
fn next_meta_seq(
volume: &PairRead,
pages: &[Page2],
over: Option<(usize, SlotIndex)>,
) -> Result<u64, Error> {
let pairs = core::iter::once(volume).chain(pages.iter().map(|p| &p.pair));
let mut max = 0u64;
for (i, pair) in pairs.enumerate() {
for slot in [SlotIndex::A, SlotIndex::B] {
if over == Some((i, slot)) {
continue;
}
if let Some(v) = numbered(pair, slot) {
max = max.max(v);
}
}
}
max.checked_add(1).ok_or(Error::Unsupported {
what: Capability::FormatVersion,
})
}
fn page_payload(p: u32) -> Result<Vec<u8>, Error> {
let mut buf = vec![0u8; store_io_format::meta2::PAGE_HEADER_LEN];
let n = encode_page(
&mut buf,
&PageHeader {
page_index: p,
next_seq: 0,
count: 0,
},
&[],
)
.map_err(|_| meta_err())?;
buf.truncate(n);
Ok(buf)
}
fn volume_payload(vm: &VolumeMeta2) -> Result<[u8; VOLUME_META2_LEN], Error> {
let mut buf = [0u8; VOLUME_META2_LEN];
let _n = vm.encode(&mut buf).map_err(|_| meta_err())?;
Ok(buf)
}
pub(crate) fn layout_for(log2_block: u8, log2_table: u8, capacity: u32) -> Layout {
let e = u32::from(entries_per_page(log2_table)).max(1);
let pages = capacity
.min(MAX_REGION_CAPACITY)
.div_ceil(e)
.clamp(1, store_io_format::meta2::MAX_TABLE_PAGES - 1);
Layout {
log2_block,
log2_table,
format: FORMAT_2,
pages,
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn create_metadata<P: Platform>(
platform: &P,
file: &P::File,
q: &mut Lane<P::Queue>,
pool: &store_io_buf::BufPool,
layout: &Layout,
volume: VolumeId,
created_unix_s: u64,
) -> Result<Meta, Error> {
let allocate = |len: u64| {
platform
.allocate(file, len)
.map_err(|e| space_err(Op::Allocate, e, 0))
};
allocate(if layout.pages == 1 {
layout.data_start()
} else {
layout.page_slots(0).1
})?;
let mut pages = Vec::with_capacity(layout.pages as usize);
for p in 0..layout.pages {
if p == 1 {
full_flush(platform, file)?;
allocate(layout.data_start())?;
}
let payload = page_payload(p)?;
let mut next = plan_next(&PairRead::blank(), &payload, 1)?;
next.meta_seq = u64::from(p) + 1;
let w = write_slot(q, file, pool, &pair_page(volume, layout, p), &next, false)?;
pages.push(Page2 {
pair: PairRead::blank().after(w),
standing: Standing::Confirmed,
header: Some(PageHeader {
page_index: p,
next_seq: 0,
count: 0,
}),
entries: Vec::new(),
});
}
full_flush(platform, file)?;
let vm = VolumeMeta2 {
base: VolumeMeta {
log2_block_size: layout.log2_block,
log2_table_slot_size: layout.log2_table,
device_index: 0,
owner_generation: 1,
table_offset: 2 * layout.block(),
created_unix_s,
features: 0,
},
table_pages: layout.pages,
entries_per_page: entries_per_page(layout.log2_table),
clean_close: false,
flags: 0,
};
let vbuf = volume_payload(&vm)?;
let mut next = plan_next(&PairRead::blank(), &vbuf, 1)?;
next.meta_seq = u64::from(layout.pages) + 1;
let w = write_slot(q, file, pool, &pair_volume(volume, layout), &next, false)?;
full_flush(platform, file)?;
Ok(Meta {
volume: vm.base,
volume_pair: PairRead::blank().after(w),
table_pair: PairRead::blank(),
next_region_id: 0,
entries: Vec::new(),
container_len: layout.data_start(),
v2: Some(Box::new(Meta2 {
volume: vm,
pages,
free: crate::footprint::FreeMap::complement(
layout.data_start(),
layout.data_start(),
&mut [],
),
usage: Vec::new(),
reserved_names: Vec::new(),
cut_short: false,
allocated: Vec::new(),
claims: Vec::new(),
marked: 0,
holds: Vec::new(),
stale_extra: Vec::new(),
})),
unavailable: Vec::new(),
repairs: Vec::new(),
})
}
fn full_flush<P: Platform>(platform: &P, file: &P::File) -> Result<(), Error> {
platform
.flush_all(file)
.map_err(|e| Error::DurabilityUnknown {
op: Op::FlushAll,
raw: Some(e),
ctx: ErrorContext::default(),
})
}
pub(crate) struct Opened {
pub(crate) meta: Meta,
pub(crate) owner_generation: u64,
pub(crate) read_only: bool,
pub(crate) report: MetadataReport,
pub(crate) regions: Vec<std::sync::Arc<LiveRegion>>,
pub(crate) unavailable: Vec<UnavailableRegion>,
}
pub(crate) fn decode_volume(bytes: &[u8]) -> Result<VolumeMeta2, Error> {
if bytes.len() > VOLUME_META2_LEN {
return Err(Error::Unsupported {
what: Capability::FormatVersion,
});
}
let vm = VolumeMeta2::decode(bytes).map_err(|e| match e {
store_io_format::meta::MetaError::Field("features" | "flags") => Error::Unsupported {
what: Capability::FormatVersion,
},
_ => corrupt(),
})?;
if vm.table_pages > max_table_pages(vm.base.log2_table_slot_size) {
return Err(Error::Unsupported {
what: Capability::FormatVersion,
});
}
Ok(vm)
}
pub(crate) fn max_table_pages(log2_table: u8) -> u32 {
layout_for(12, log2_table, MAX_REGION_CAPACITY).pages
}
pub(crate) fn read_retried<Q: store_io_platform::Queue>(
q: &mut Lane<Q>,
file: &Q::File,
pool: &store_io_buf::BufPool,
at: &PairAt,
retried: &mut u32,
) -> Result<PairRead, Error> {
let first = read_pair(q, file, pool, at)?;
let (pair, again) = reread_failed(q, file, pool, at, first)?;
*retried += u32::from(again);
Ok(pair)
}
pub(crate) fn read_all_retried<Q: store_io_platform::Queue>(
q: &mut Lane<Q>,
file: &Q::File,
pool: &store_io_buf::BufPool,
ats: &[PairAt],
retried: &mut u32,
) -> Result<Vec<PairRead>, Error> {
let first = read_pairs(q, file, pool, ats, usize::MAX)?;
let mut out = Vec::with_capacity(first.len());
for (at, pair) in ats.iter().zip(first) {
let (pair, again) = reread_failed(q, file, pool, at, pair)?;
*retried += u32::from(again);
out.push(pair);
}
Ok(out)
}
fn judge_read(p: &PairRead) -> judge::PairRead {
judge::PairRead {
a: judge::SlotRead {
status: p.report.a,
facts: p.facts[0],
},
b: judge::SlotRead {
status: p.report.b,
facts: p.facts[1],
},
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn open_metadata<P: Platform>(
file: &P::File,
q: &mut Lane<P::Queue>,
pool: &store_io_buf::BufPool,
layout: &Layout,
volume: VolumeId,
mut vm: VolumeMeta2,
mut volume_pair: PairRead,
container_len: u64,
read_only: bool,
policy: &Policy,
append_window: u64,
header_queue: &mut dyn FnMut() -> Option<(P::Queue, usize)>,
) -> Result<Opened, Error> {
if layout.data_start() > container_len {
return Err(corrupt());
}
let mut retried = 0u32;
let (again, reread) = reread_failed(q, file, pool, &pair_volume(volume, layout), volume_pair)?;
volume_pair = again;
if reread {
retried += 1;
vm = decode_volume(&crate::open::winner_payload(&volume_pair)?)?;
if vm.table_pages != layout.pages
|| vm.base.log2_block_size != layout.log2_block
|| vm.base.log2_table_slot_size != layout.log2_table
{
return Err(corrupt());
}
}
let mut pages = Vec::with_capacity(layout.pages as usize);
for p in 0..layout.pages {
let at = pair_page(volume, layout, p);
let pair = read_retried(q, file, pool, &at, &mut retried)?;
pages.push(Page2 {
pair,
standing: Standing::Lost,
header: None,
entries: Vec::new(),
});
}
let reads: Vec<judge::PairRead> = core::iter::once(&volume_pair)
.chain(pages.iter().map(|p| &p.pair))
.map(judge_read)
.collect();
let mut verdicts = vec![
PairVerdict {
standing: Standing::Lost,
winner: None,
a: SlotVerdict::Damage,
b: SlotVerdict::Damage,
};
reads.len()
];
let j = judge::judge(&reads, vm.clean_close, &mut verdicts).map_err(|_| corrupt())?;
if j.refused {
return Err(Error::Unsupported {
what: Capability::FormatVersion,
});
}
let mut report = MetadataReport {
clean_close: j.clean,
volume_stale: verdicts[0].standing != Standing::Confirmed,
retried_reads: retried,
..MetadataReport::default()
};
let mut decode_lost = false;
for (i, page) in pages.iter_mut().enumerate() {
let p = i as u32;
let mut standing = verdicts[i + 1].standing;
if standing != Standing::Lost {
match page.pair.payload.as_deref().map(|b| {
decode_page(b, p, entries_per_page(layout.log2_table))
.map(|d| (d.header, d.entries().collect::<Vec<_>>()))
}) {
Some(Ok((h, entries))) => {
page.header = Some(h);
page.entries = entries;
if standing == Standing::Unconfirmed || page.pair.possibly_accepted() {
page.raise_next_seq();
}
}
_ => {
standing = Standing::Lost;
decode_lost = true;
}
}
}
page.standing = standing;
}
let mut to_heal = j.heal;
if let Some((pair, _)) = to_heal {
if pair > 0 && (decode_lost || pages[pair - 1].ahead().next().is_some()) {
to_heal = None;
if pages[pair - 1].standing == Standing::Confirmed {
pages[pair - 1].standing = Standing::Unconfirmed;
verdicts[pair].standing = Standing::Unconfirmed;
}
}
}
for (i, v) in verdicts.iter().enumerate() {
let page = i.checked_sub(1).map(|p| p as u32);
let lost_late = page.is_some_and(|p| pages[p as usize].standing == Standing::Lost)
&& v.standing != Standing::Lost;
for (slot_b, verdict) in [(false, v.a), (true, v.b)] {
let damage = match verdict {
SlotVerdict::OlderDamaged => SlotDamage::Older,
SlotVerdict::InFlight if to_heal.is_some_and(|(h, _)| h == i) => {
SlotDamage::InFlight
}
SlotVerdict::InFlight | SlotVerdict::Damage => SlotDamage::Damage,
SlotVerdict::Winner if lost_late => SlotDamage::Damage,
SlotVerdict::Winner | SlotVerdict::Nothing => continue,
};
report.damaged_slots.push(DamagedSlot {
page,
slot_b,
damage,
});
}
}
for (i, page) in pages.iter().enumerate() {
match page.standing {
Standing::Unconfirmed => report.stale_pages.push(i as u32),
Standing::Lost | Standing::Refused => report.lost_pages.push(i as u32),
Standing::Confirmed => {}
}
}
report.frozen = !report.stale_pages.is_empty() || !report.lost_pages.is_empty();
let foreign = core::iter::once(&volume_pair)
.chain(pages.iter().map(|p| &p.pair))
.any(|p| p.report.winner_info().is_some_and(|(_, i)| !i.writable()));
let mut meta = Meta {
volume: vm.base,
volume_pair,
table_pair: PairRead::blank(),
next_region_id: 0,
entries: Vec::new(),
container_len,
v2: Some(Box::new(Meta2 {
volume: vm,
pages,
free: crate::footprint::FreeMap::default(),
usage: Vec::new(),
reserved_names: Vec::new(),
cut_short: false,
allocated: Vec::new(),
claims: Vec::new(),
marked: 0,
holds: Vec::new(),
stale_extra: Vec::new(),
})),
unavailable: Vec::new(),
repairs: Vec::new(),
};
let regions = {
let v2 = meta.v2.as_deref().ok_or_else(corrupt)?;
crate::open2::check_regions(
q,
file,
pool,
layout,
volume,
v2,
container_len,
append_window,
&mut report,
header_queue,
)?
};
if let Some(v2) = meta.v2.as_deref_mut() {
v2.free = regions.free;
v2.usage = regions.usage;
v2.reserved_names = regions.reserved_names;
v2.cut_short = regions.cut_short;
v2.allocated = regions.allocated;
v2.holds = regions.holds;
v2.stale_extra = regions.stale_extra;
}
let read_only = read_only || {
report.read_only_reason = if !j.writable {
Some("the volume record is damaged and a table page holds a damaged copy")
} else if foreign {
Some("the metadata carries a feature this version may read but not write")
} else {
regions.read_only_reason
};
report.read_only_reason.is_some()
};
if read_only {
return Ok(Opened {
meta,
owner_generation: 0,
read_only,
report,
regions: regions.live,
unavailable: regions.unavailable,
});
}
let og = vm
.base
.owner_generation
.checked_add(1)
.ok_or_else(corrupt)?;
let domain = Domain::new();
if let Some((pair, slot)) = to_heal {
heal::<P>(
q, file, pool, layout, volume, policy, &domain, &mut meta, pair, slot, og,
)?;
report.healed = Some(if pair == 0 {
Healed::VolumeRecord
} else {
Healed::Page(pair as u32 - 1)
});
}
write_volume::<P>(
q, file, pool, layout, volume, policy, &domain, &mut meta, og, false,
)?;
Ok(Opened {
meta,
owner_generation: og,
read_only,
report,
regions: regions.live,
unavailable: regions.unavailable,
})
}
#[allow(clippy::too_many_arguments)]
fn heal<P: Platform>(
q: &mut Lane<P::Queue>,
file: &P::File,
pool: &store_io_buf::BufPool,
layout: &Layout,
volume: VolumeId,
policy: &Policy,
domain: &Domain,
meta: &mut Meta,
pair: usize,
slot: SlotIndex,
og: u64,
) -> Result<(), Error> {
let v2 = meta.v2.as_mut().ok_or_else(corrupt)?;
let (at, prev) = if pair == 0 {
(pair_volume(volume, layout), &meta.volume_pair)
} else {
let p = u32::try_from(pair - 1).map_err(|_| corrupt())?;
(pair_page(volume, layout, p), &v2.pages[pair - 1].pair)
};
let payload = prev.payload.clone().ok_or_else(corrupt)?;
let mut next = plan_next(prev, &payload, og)?;
if next.index != slot {
return Err(corrupt());
}
let own = prev.facts[usize::from(slot.as_u8())]
.and_then(|f| f.numbered)
.map(|n| n.meta_seq);
next.meta_seq = match own {
Some(m) => m,
None => next_meta_seq(&meta.volume_pair, &v2.pages, Some((pair, slot)))?,
};
let healed = durable_slot::<P>(q, file, pool, &at, prev, &next, policy, domain)?;
if pair == 0 {
meta.volume_pair = healed;
} else {
v2.pages[pair - 1].pair = healed;
v2.pages[pair - 1].standing = Standing::Confirmed;
}
Ok(())
}
pub(crate) fn page_range(layout: &Layout, p: u32) -> store_io_core::error::ByteRange {
let (a, b) = layout.page_slots(p);
store_io_core::error::ByteRange {
start: a.min(b),
end: a.max(b) + (1u64 << layout.log2_table),
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn accept_page<P: Platform>(
q: &mut Lane<P::Queue>,
file: &P::File,
pool: &store_io_buf::BufPool,
layout: &Layout,
volume: VolumeId,
policy: &Policy,
domain: &Domain,
meta: &mut Meta,
p: usize,
og: u64,
) -> Result<(), Error> {
let meta_seq = next_meta_seq_of(meta)?;
let v2 = meta.v2.as_mut().ok_or_else(corrupt)?;
let page = v2.pages.get_mut(p).ok_or_else(corrupt)?;
let at = pair_page(volume, layout, u32::try_from(p).map_err(|_| corrupt())?);
let payload = page.pair.payload.clone().ok_or_else(corrupt)?;
let mut next = plan_next(&page.pair, &payload, og)?;
next.meta_seq = meta_seq;
let _written = durable_slot::<P>(q, file, pool, &at, &page.pair, &next, policy, domain)?;
let mut retried = 0;
let back = read_retried(q, file, pool, &at, &mut retried).and_then(|back| {
if back.twin {
Ok(back)
} else {
Err(Error::Corruption {
kind: store_io_core::error::CorruptionKind::MediaError,
ctx: ErrorContext {
range: Some(page_range(layout, u32::try_from(p).map_err(|_| corrupt())?)),
..ErrorContext::default()
},
})
}
});
match back {
Ok(back) => {
page.pair = back;
page.standing = Standing::Confirmed;
Ok(())
}
Err(e) => {
domain.poison(store_io_core::error::FirstCause {
op: Some(store_io_core::error::Op::Read),
raw: None,
});
Err(e)
}
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn write_volume<P: Platform>(
q: &mut Lane<P::Queue>,
file: &P::File,
pool: &store_io_buf::BufPool,
layout: &Layout,
volume: VolumeId,
policy: &Policy,
domain: &Domain,
meta: &mut Meta,
owner_generation: u64,
clean_close: bool,
) -> Result<(), Error> {
let v2 = meta.v2.as_mut().ok_or_else(corrupt)?;
let mut vm = v2.volume;
vm.base.owner_generation = owner_generation;
vm.clean_close = clean_close;
let vbuf = volume_payload(&vm)?;
let mut next = plan_next(&meta.volume_pair, &vbuf, owner_generation)?;
next.meta_seq = next_meta_seq(&meta.volume_pair, &v2.pages, Some((0, next.index)))?;
let at = pair_volume(volume, layout);
meta.volume_pair =
durable_slot::<P>(q, file, pool, &at, &meta.volume_pair, &next, policy, domain)?;
v2.volume = vm;
meta.volume = vm.base;
Ok(())
}
impl<P: Platform> Drop for Inner<P> {
fn drop(&mut self) {
if self.read_only
|| self.domain.poisoned().is_some()
|| self.meta.is_poisoned()
|| std::thread::panicking()
{
return;
}
let mut meta = lock_meta(&self.meta);
if meta.v2.is_none() {
return;
}
let mut q = self.queues.get(0);
let _closed = write_volume::<P>(
&mut q,
&self.file,
&self.pool,
&self.layout,
self.volume,
&self.policy,
&self.domain,
&mut meta,
self.owner_generation,
true,
);
}
}
#[cfg(all(test, not(loom)))]
mod tests {
#![allow(clippy::unwrap_used)]
use super::*;
fn record(log2_table: u8, table_pages: u32) -> Vec<u8> {
let vm = VolumeMeta2 {
base: VolumeMeta {
log2_block_size: 12,
log2_table_slot_size: log2_table,
device_index: 0,
owner_generation: 1,
table_offset: 2 << 12,
created_unix_s: 0,
features: 0,
},
table_pages,
entries_per_page: entries_per_page(log2_table),
clean_close: true,
flags: 0,
};
volume_payload(&vm).unwrap().to_vec()
}
#[test]
fn test_a_volume_record_past_the_largest_table_is_unsupported() {
for log2_table in 12..=16u8 {
let max = max_table_pages(log2_table);
let real = layout_for(12, log2_table, MAX_REGION_CAPACITY).pages;
assert_eq!(max, real);
assert!(max > 1 && max < store_io_format::meta2::MAX_TABLE_PAGES - 1);
assert!(decode_volume(&record(log2_table, max)).is_ok());
for hostile in [max + 1, store_io_format::meta2::MAX_TABLE_PAGES - 1] {
assert!(
matches!(
decode_volume(&record(log2_table, hostile)),
Err(Error::Unsupported {
what: Capability::FormatVersion,
})
),
"{log2_table}: {hostile} pages"
);
}
}
}
}