#![allow(
clippy::unwrap_used,
clippy::expect_used,
unused_results,
unused_must_use
)]
use std::ops::ControlFlow;
use std::path::{Path, PathBuf};
use store_io_core::error::{CorruptionKind, Error, Op};
use store_io_engine::{CONTAINER, ScanItem, Store, StoreOptions};
use store_io_sim::{FaultPlan, SimConfig, SimPlatform};
const DIR: &str = "/db";
const BLOCK: u64 = 4096;
fn opts() -> StoreOptions {
StoreOptions {
queues: 2,
buffers_per_class: 8,
append_window: 256 << 12,
..StoreOptions::default()
}
}
fn setup(p: &SimPlatform) -> (Store<SimPlatform>, u32, u64) {
let s = Store::create(p.clone(), Path::new(DIR), opts()).unwrap();
let pages = s.provision_page_region("pages", 1 << 20).unwrap();
let mut data = vec![0u8; 16 * BLOCK as usize];
for (i, b) in data.chunks_mut(BLOCK as usize).enumerate() {
b.fill(i as u8 + 1);
b[..12].copy_from_slice(b"READ-ERR-TST");
}
pages.write_durable(pages.pos(0).unwrap(), &data).unwrap();
let (file, base) = p.with_world(|w| {
let media = w.media_of(&PathBuf::from(DIR), CONTAINER).unwrap();
let at = media
.windows(12)
.position(|x| x == b"READ-ERR-TST")
.unwrap() as u64;
(w.file_id(&PathBuf::from(DIR), CONTAINER).unwrap(), at)
});
(s, file, base)
}
#[test]
fn test_a_non_media_read_error_keeps_its_code_and_is_not_corruption() {
let p = SimPlatform::new(SimConfig::volatile(70));
let (s, _file, _base) = setup(&p);
let pages = s.page_region("pages").unwrap();
let next = p.with_world(|w| w.reads()) + 1;
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
fail_read: Some((next, 22)),
..FaultPlan::default()
};
});
let mut out = vec![0u8; 4 * BLOCK as usize];
let r = pages.read(pages.pos(0).unwrap(), &mut out);
let Err(Error::Io { op, raw, ctx }) = r else {
panic!("expected Io, got {r:?}");
};
assert_eq!(op, Op::Read);
assert_eq!(raw.code, 22);
assert!(ctx.range.is_some());
}
#[test]
fn test_a_media_error_names_the_exact_unreadable_block() {
let p = SimPlatform::new(SimConfig::volatile(71));
let (s, file, base) = setup(&p);
let pages = s.page_region("pages").unwrap();
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
bad_ranges: vec![(file, base + 5 * BLOCK, base + 6 * BLOCK)],
..FaultPlan::default()
};
});
let mut out = vec![0u8; 16 * BLOCK as usize];
let r = pages.read(pages.pos(0).unwrap(), &mut out);
let Err(Error::Corruption { kind, ctx }) = r else {
panic!("expected Corruption, got {r:?}");
};
assert_eq!(kind, CorruptionKind::MediaError);
let range = ctx.range.unwrap();
assert_eq!((range.start, range.end), (5 * BLOCK, 6 * BLOCK));
p.with_world(|w| *w.faults_mut() = FaultPlan::default());
pages.read(pages.pos(0).unwrap(), &mut out).unwrap();
assert_eq!(out[6 * BLOCK as usize + 12], 7);
}
#[test]
fn test_a_media_error_names_the_exact_sector_below_the_store_block() {
let mut cfg = SimConfig::volatile(72);
cfg.logical_block = 512;
let p = SimPlatform::new(cfg);
let s = Store::create(p.clone(), Path::new(DIR), opts()).unwrap();
let pages = s.provision_page_region("pages", 4 << 20).unwrap();
let mut data = vec![0u8; 4 << 20];
data[..12].copy_from_slice(b"READ-ERR-TST");
for (i, b) in data.iter_mut().enumerate().skip(12) {
*b = (i % 249) as u8;
}
pages.write_durable(pages.pos(0).unwrap(), &data).unwrap();
let (file, base) = p.with_world(|w| {
let media = w.media_of(&PathBuf::from(DIR), CONTAINER).unwrap();
let at = media
.windows(12)
.position(|x| x == b"READ-ERR-TST")
.unwrap() as u64;
(w.file_id(&PathBuf::from(DIR), CONTAINER).unwrap(), at)
});
let bad = 5 * BLOCK + 1024;
let deep = (3 << 20) + 512;
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
bad_ranges: vec![
(file, base + bad, base + bad + 512),
(file, base + deep, base + deep + 512),
],
..FaultPlan::default()
};
});
let named = |r: Result<usize, Error>| {
let Err(Error::Corruption { kind, ctx }) = r else {
panic!("expected Corruption, got {r:?}");
};
assert_eq!(kind, CorruptionKind::MediaError);
let range = ctx.range.unwrap();
(range.start, range.end)
};
let mut small = vec![0u8; 16 * BLOCK as usize];
assert_eq!(
named(pages.read(pages.pos(0).unwrap(), &mut small)),
(bad, bad + 512)
);
let mut big = vec![0u8; 2 << 20];
assert_eq!(
named(pages.read(pages.pos(2 << 20).unwrap(), &mut big)),
(deep, deep + 512)
);
let mut unreadable = Vec::new();
let mut delivered = 0u64;
let summary = pages
.scan(0, |item| {
match item {
ScanItem::Data { offset, bytes } => {
let at = offset as usize;
assert!(bytes == &data[at..at + bytes.len()], "wrong bytes at {at}");
delivered += bytes.len() as u64;
}
ScanItem::Unreadable { start, end } => unreadable.push((start, end)),
}
ControlFlow::Continue(())
})
.unwrap();
assert_eq!(unreadable, vec![(bad, bad + 512), (deep, deep + 512)]);
assert_eq!(summary.unreadable, 1024);
assert_eq!(delivered, (4 << 20) - 1024);
}
#[test]
fn test_a_device_refusing_small_reads_never_aborts_the_bisection() {
use store_io_core::class::Missing;
let model = {
let p = SimPlatform::new(SimConfig::volatile(73));
let s = Store::create(p, Path::new(DIR), opts()).unwrap();
s.report().evidence.clone()
};
let mut misaligned = Vec::new();
for reported in [false, true] {
let mut ev = model.clone();
ev.device.logical_block = 512;
ev.device.physical_block = 512;
if reported {
ev.fs.dio_offset_align = 512;
} else {
ev.fs.dio_offset_align = 0;
ev.missing.insert(Missing::DioAlignment);
}
let mut cfg = SimConfig::volatile(74);
cfg.evidence = Some(ev);
let p = SimPlatform::new(cfg);
let (s, file, base) = setup(&p);
let pages = s.page_region("pages").unwrap();
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
bad_ranges: vec![(file, base + 5 * BLOCK + 1024, base + 5 * BLOCK + 1536)],
..FaultPlan::default()
};
});
let mut out = vec![0u8; 16 * BLOCK as usize];
let r = pages.read(pages.pos(0).unwrap(), &mut out);
let Err(Error::Corruption { kind, ctx }) = r else {
panic!("reported={reported}: expected Corruption, got {r:?}");
};
assert_eq!(kind, CorruptionKind::MediaError);
let range = ctx.range.unwrap();
assert_eq!(
(range.start, range.end),
(5 * BLOCK, 6 * BLOCK),
"reported={reported}"
);
let mut bad = Vec::new();
let summary = pages
.scan(0, |item| {
if let ScanItem::Unreadable { start, end } = item {
bad.push((start, end));
}
ControlFlow::Continue(())
})
.unwrap();
assert_eq!(bad, vec![(5 * BLOCK, 6 * BLOCK)], "reported={reported}");
assert_eq!(summary.end, pages.len(), "the scan stopped early");
let mut three = vec![0u8; 3 * BLOCK as usize];
let r = pages.read(pages.pos(3 * BLOCK).unwrap(), &mut three);
let Err(Error::Corruption { kind, ctx }) = r else {
panic!("reported={reported}: 3 blocks: expected Corruption, got {r:?}");
};
assert_eq!(kind, CorruptionKind::MediaError);
let range = ctx.range.unwrap();
assert_eq!((range.start, range.end), (5 * BLOCK, 6 * BLOCK), "3 blocks");
misaligned.push(p.with_world(|w| w.misaligned_reads()));
}
assert_eq!(
misaligned[0], 0,
"split below the block without a reported alignment"
);
assert!(misaligned[1] > 0, "the backstop was never exercised");
}
#[test]
fn test_a_non_media_error_during_open_never_marks_a_region_damaged() {
let p = SimPlatform::new(SimConfig::volatile(75));
drop(setup(&p));
for read_only in [true, false] {
let open = || {
if read_only {
Store::open_readonly(p.clone(), Path::new(DIR), opts())
} else {
Store::open(p.clone(), Path::new(DIR), opts())
}
};
let before = p.with_world(|w| w.reads());
drop(open().unwrap());
let reads = p.with_world(|w| w.reads()) - before;
assert!(reads > 4, "the open made only {reads} reads");
let mut failed = 0;
for k in 1..=reads {
let next = p.with_world(|w| w.reads()) + k;
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
fail_read: Some((next, 22)),
..FaultPlan::default()
};
});
match open() {
Ok(s) => {
assert!(
s.unavailable_regions().is_empty(),
"read_only={read_only}: read {k} marked a region damaged"
);
s.page_region("pages").unwrap();
}
Err(Error::Io { raw, .. }) => {
assert_eq!(raw.code, 22, "read_only={read_only}: read {k}");
failed += 1;
}
Err(e) => panic!("read_only={read_only}: read {k}: {e:?}"),
}
p.with_world(|w| *w.faults_mut() = FaultPlan::default());
}
assert!(
failed > 0,
"read_only={read_only}: no read failure surfaced"
);
}
}
#[test]
fn test_a_media_error_that_does_not_repeat_is_still_reported() {
let p = SimPlatform::new(SimConfig::volatile(76));
let (s, _file, _base) = setup(&p);
let pages = s.page_region("pages").unwrap();
let next = p.with_world(|w| w.reads()) + 1;
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
fail_read: Some((next, 5)),
..FaultPlan::default()
};
});
let mut out = vec![0u8; 4 * BLOCK as usize];
let r = pages.read(pages.pos(0).unwrap(), &mut out);
let Err(Error::Corruption { kind, ctx }) = r else {
panic!("expected Corruption, got {r:?}");
};
assert_eq!(kind, CorruptionKind::MediaError);
let range = ctx.range.unwrap();
assert_eq!((range.start, range.end), (0, 4 * BLOCK));
}
#[test]
fn test_a_one_buffer_pool_still_names_the_exact_unreadable_block() {
let p = SimPlatform::new(SimConfig::volatile(77));
let s = Store::create(
p.clone(),
Path::new(DIR),
StoreOptions {
buffers_per_class: 1,
..opts()
},
)
.unwrap();
let pages = s.provision_page_region("pages", 2 << 20).unwrap();
let mut data = vec![7u8; 1 << 20];
data[..12].copy_from_slice(b"READ-ERR-TST");
pages.write_durable(pages.pos(0).unwrap(), &data).unwrap();
let (file, base) = p.with_world(|w| {
let media = w.media_of(&PathBuf::from(DIR), CONTAINER).unwrap();
let at = media
.windows(12)
.position(|x| x == b"READ-ERR-TST")
.unwrap() as u64;
(w.file_id(&PathBuf::from(DIR), CONTAINER).unwrap(), at)
});
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
bad_ranges: vec![(file, base + 3 * BLOCK, base + 4 * BLOCK)],
..FaultPlan::default()
};
});
let mut out = vec![0u8; 1 << 20];
let r = pages.read(pages.pos(0).unwrap(), &mut out);
let Err(Error::Corruption { kind, ctx }) = r else {
panic!("expected Corruption, got {r:?}");
};
assert_eq!(kind, CorruptionKind::MediaError);
let range = ctx.range.unwrap();
assert_eq!((range.start, range.end), (3 * BLOCK, 4 * BLOCK));
}
#[test]
fn test_a_failed_rescan_still_reports_the_media_error() {
let p = SimPlatform::new(SimConfig::volatile(78));
let (s, file, base) = setup(&p);
let pages = s.page_region("pages").unwrap();
let next = p.with_world(|w| w.reads()) + 1;
p.with_world(|w| {
*w.faults_mut() = FaultPlan {
bad_ranges: vec![(file, base + 2 * BLOCK, base + 3 * BLOCK)],
fail_read: Some((next + 1, 22)),
..FaultPlan::default()
};
});
let mut out = vec![0u8; 4 * BLOCK as usize];
let r = pages.read(pages.pos(0).unwrap(), &mut out);
let Err(Error::Corruption { kind, ctx }) = r else {
panic!("expected Corruption, got {r:?}");
};
assert_eq!(kind, CorruptionKind::MediaError);
let range = ctx.range.unwrap();
assert_eq!((range.start, range.end), (0, 4 * BLOCK));
}