store_io_engine/
report.rs1use store_io_core::RegionId;
4use store_io_core::error::CorruptionKind;
5use store_io_format::meta::RegionKind;
6
7use crate::store::StoreReport;
8
9impl core::fmt::Display for StoreReport {
10 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
11 let d = &self.decision;
12 writeln!(f, "volume {}", self.volume)?;
13 writeln!(
14 f,
15 "io {} ({})",
16 self.io.interface, self.io.reason
17 )?;
18 writeln!(f, "class {}", d.class)?;
19 writeln!(f, "label {}", d.label)?;
20 writeln!(f, "durable open {:?}", d.durable_open)?;
21 if d.power_safe_candidate {
22 writeln!(
23 f,
24 "note device reports no volatile cache; health unreadable (power-safe candidate)"
25 )?;
26 }
27 for r in d.reasons.iter() {
28 writeln!(f, "reason {r}")?;
29 }
30 for m in d.missing.iter() {
31 writeln!(f, "missing {m}")?;
32 }
33 writeln!(f, "flush execution inline (leader)")?;
34 writeln!(f, "block size {}", self.block_size)?;
35 writeln!(f, "table capacity {} regions", self.table_capacity)?;
36 writeln!(f, "filesystem {:?}", self.evidence.fs.kind)?;
37 writeln!(f, "bus {:?}", self.evidence.device.bus)?;
38 writeln!(f, "internal {:?}", self.evidence.device.internal)?;
39 if let Some(m) = &self.evidence.device.model {
40 writeln!(f, "model {m}")?;
41 }
42 for u in &self.unavailable {
43 writeln!(
44 f,
45 "unavailable region {:?} (id {}, {:?}): {}",
46 u.name,
47 u.id.get(),
48 u.kind,
49 u.reason
50 )?;
51 }
52 writeln!(f, "format {}", self.format)?;
53 if self.format == store_io_format::slot::FORMAT_2 {
54 write!(f, "{}", self.metadata)?;
55 }
56 write!(
57 f,
58 "mode {}",
59 if self.read_only {
60 "read-only"
61 } else {
62 "read-write"
63 }
64 )
65 }
66}
67
68#[derive(Debug, Clone, Copy, PartialEq, Eq)]
73#[non_exhaustive]
74pub enum Unavailable {
75 ContainerShort {
77 needed: u64,
79 actual: u64,
81 },
82 HeaderUnreadable,
84 HeaderInvalid,
86 HeaderMismatch,
88 HeaderReleased,
90 EntryInvalid,
93 ExtentsInvalid,
96 Overlaps,
98 NameTaken,
100}
101
102impl Unavailable {
103 #[must_use]
105 pub fn corruption_kind(&self) -> CorruptionKind {
106 match self {
107 Self::ContainerShort { .. } => CorruptionKind::Truncated,
108 Self::HeaderUnreadable => CorruptionKind::HeaderCrc,
109 Self::HeaderInvalid
110 | Self::HeaderMismatch
111 | Self::HeaderReleased
112 | Self::EntryInvalid
113 | Self::ExtentsInvalid
114 | Self::Overlaps
115 | Self::NameTaken => CorruptionKind::Metadata,
116 }
117 }
118}
119
120impl core::fmt::Display for Unavailable {
121 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
122 match self {
123 Self::ContainerShort { needed, actual } => write!(
124 f,
125 "the container holds {actual} bytes but the region needs {needed}"
126 ),
127 Self::HeaderUnreadable => f.write_str("neither copy of its header is valid"),
128 Self::HeaderInvalid => f.write_str("its header holds impossible values"),
129 Self::HeaderMismatch => f.write_str("its header belongs to another region or kind"),
130 Self::HeaderReleased => {
131 f.write_str("its header says released while the table says ready")
132 }
133 Self::EntryInvalid => f.write_str("its table entry holds impossible values"),
134 Self::ExtentsInvalid => f.write_str("its extents do not match its table entry"),
135 Self::Overlaps => f.write_str("a newer region overlaps it"),
136 Self::NameTaken => f.write_str("a newer region has its name"),
137 }
138 }
139}
140
141#[derive(Debug, Clone, PartialEq, Eq)]
144#[non_exhaustive]
145pub enum Repair {
146 EntryReleased {
150 region: UnavailableRegion,
152 },
153 InvalidEntryReleased {
156 page: u32,
158 seq: u32,
160 },
161 PageAccepted {
164 page: u32,
166 },
167}
168
169#[derive(Debug, Clone, PartialEq, Eq)]
171pub struct UnavailableRegion {
172 pub name: String,
174 pub id: RegionId,
176 pub kind: RegionKind,
178 pub reason: Unavailable,
180}