RAID (0/1/4/5/6/10/linear, mdadm 0.90 e 1.x, degradado) e LVM2 remontados no disco virtual
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Lucas RayanandClaude Sonnet 5.5 committed
1 parent
c014526761
commit
5d45273e0d
11 files changed
+1777
-6
No files matched your search
@@ -0,0 +1,508 @@
|
||||
//! LVM2: lê o rótulo do volume físico (PV) e o texto de metadados, e remonta os volumes
|
||||
//! lógicos (lineares, em faixas, espelhados e RAID 0/1/5/6/10 do LVM).
|
||||
|
||||
use crate::raid::{Layout, Level, Member, RaidParams, RaidSource};
|
||||
use crate::source::{read_vec, Source};
|
||||
use std::collections::BTreeMap;
|
||||
use std::io;
|
||||
use std::sync::Arc;
|
||||
|
||||
const MDA_MAGIC: &[u8; 16] = b" LVM2 x[5A%r0N*>";
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct PvInfo {
|
||||
/// UUID de 32 caracteres, sem hífens.
|
||||
pub uuid: String,
|
||||
pub size: u64,
|
||||
pub seqno: u64,
|
||||
pub vg_name: String,
|
||||
pub text: String,
|
||||
}
|
||||
|
||||
/// Lê rótulo + metadados de um PV.
|
||||
pub fn read_pv(src: &dyn Source) -> Option<PvInfo> {
|
||||
let head = read_vec(src, 0, 2048).ok()?;
|
||||
if head.len() < 2048 {
|
||||
return None;
|
||||
}
|
||||
let sector = (0..4).find(|&s| &head[s * 512..s * 512 + 8] == b"LABELONE")?;
|
||||
let lab = &head[sector * 512..(sector + 1) * 512];
|
||||
if &lab[24..32] != b"LVM2 001" {
|
||||
return None;
|
||||
}
|
||||
let off = u32::from_le_bytes(lab[20..24].try_into().ok()?) as usize;
|
||||
let pv = lab.get(off..)?;
|
||||
let uuid = String::from_utf8_lossy(pv.get(..32)?).to_string();
|
||||
let size = u64::from_le_bytes(pv.get(32..40)?.try_into().ok()?);
|
||||
// Lista de áreas de dados, depois de áreas de metadados; cada lista termina em (0,0).
|
||||
let mut o = 40;
|
||||
let rd = |o: usize| -> Option<(u64, u64)> {
|
||||
Some((
|
||||
u64::from_le_bytes(pv.get(o..o + 8)?.try_into().ok()?),
|
||||
u64::from_le_bytes(pv.get(o + 8..o + 16)?.try_into().ok()?),
|
||||
))
|
||||
};
|
||||
loop {
|
||||
let (a, b) = rd(o)?;
|
||||
o += 16;
|
||||
if a == 0 && b == 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let mut mdas = vec![];
|
||||
loop {
|
||||
let (a, b) = rd(o)?;
|
||||
o += 16;
|
||||
if a == 0 && b == 0 {
|
||||
break;
|
||||
}
|
||||
mdas.push((a, b));
|
||||
}
|
||||
let mut best: Option<PvInfo> = None;
|
||||
for (mda_off, mda_size) in mdas {
|
||||
let Ok(h) = read_vec(src, mda_off, 512) else { continue };
|
||||
if h.len() < 512 || &h[4..20] != MDA_MAGIC {
|
||||
continue;
|
||||
}
|
||||
// raw_locn[0]
|
||||
let loc_off = u64::from_le_bytes(h[40..48].try_into().unwrap());
|
||||
let loc_size = u64::from_le_bytes(h[48..56].try_into().unwrap());
|
||||
if loc_size == 0 || loc_size > 16 << 20 || mda_size < 1024 {
|
||||
continue;
|
||||
}
|
||||
let mut text = vec![];
|
||||
if loc_off + loc_size <= mda_size {
|
||||
if let Ok(t) = read_vec(src, mda_off + loc_off, loc_size as usize) {
|
||||
text = t;
|
||||
}
|
||||
} else {
|
||||
// O texto dá a volta no anel.
|
||||
let first = mda_size - loc_off;
|
||||
if let (Ok(a), Ok(b)) = (
|
||||
read_vec(src, mda_off + loc_off, first as usize),
|
||||
read_vec(src, mda_off + 512, (loc_size - first) as usize),
|
||||
) {
|
||||
text = [a, b].concat();
|
||||
}
|
||||
}
|
||||
let s = String::from_utf8_lossy(&text).trim_end_matches('\0').to_string();
|
||||
let Some(tree) = parse(&s) else { continue };
|
||||
let Some((vg_name, vg)) = tree.sections.iter().find(|(_, sec)| sec.values.contains_key("extent_size")) else { continue };
|
||||
let seqno = vg.int("seqno").unwrap_or(0);
|
||||
let cand = PvInfo { uuid: uuid.clone(), size, seqno, vg_name: vg_name.clone(), text: s.clone() };
|
||||
if best.as_ref().map(|b| cand.seqno > b.seqno).unwrap_or(true) {
|
||||
best = Some(cand);
|
||||
}
|
||||
}
|
||||
best
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ texto
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum Val {
|
||||
Int(i64),
|
||||
Str(String),
|
||||
List(Vec<Val>),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct Section {
|
||||
pub values: BTreeMap<String, Val>,
|
||||
/// Subseções na ordem do arquivo.
|
||||
pub sections: Vec<(String, Section)>,
|
||||
}
|
||||
|
||||
impl Section {
|
||||
pub fn int(&self, k: &str) -> Option<u64> {
|
||||
match self.values.get(k)? {
|
||||
Val::Int(i) => Some(*i as u64),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn str(&self, k: &str) -> Option<&str> {
|
||||
match self.values.get(k)? {
|
||||
Val::Str(s) => Some(s),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn list(&self, k: &str) -> Option<&[Val]> {
|
||||
match self.values.get(k)? {
|
||||
Val::List(l) => Some(l),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
pub fn sub(&self, name: &str) -> Option<&Section> {
|
||||
self.sections.iter().find(|(n, _)| n == name).map(|(_, s)| s)
|
||||
}
|
||||
}
|
||||
|
||||
struct Lexer<'a> {
|
||||
b: &'a [u8],
|
||||
i: usize,
|
||||
}
|
||||
|
||||
impl Lexer<'_> {
|
||||
fn skip(&mut self) {
|
||||
loop {
|
||||
while self.i < self.b.len() && (self.b[self.i].is_ascii_whitespace() || self.b[self.i] == b',') {
|
||||
self.i += 1;
|
||||
}
|
||||
if self.i < self.b.len() && self.b[self.i] == b'#' {
|
||||
while self.i < self.b.len() && self.b[self.i] != b'\n' {
|
||||
self.i += 1;
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
fn ident(&mut self) -> Option<String> {
|
||||
self.skip();
|
||||
let s = self.i;
|
||||
while self.i < self.b.len() && !self.b[self.i].is_ascii_whitespace() && !matches!(self.b[self.i], b'=' | b'{' | b'}' | b'[' | b']' | b'"' | b'#') {
|
||||
self.i += 1;
|
||||
}
|
||||
(self.i > s).then(|| String::from_utf8_lossy(&self.b[s..self.i]).to_string())
|
||||
}
|
||||
fn value(&mut self) -> Option<Val> {
|
||||
self.skip();
|
||||
match *self.b.get(self.i)? {
|
||||
b'"' => {
|
||||
self.i += 1;
|
||||
let s = self.i;
|
||||
while self.i < self.b.len() && self.b[self.i] != b'"' {
|
||||
if self.b[self.i] == b'\\' {
|
||||
self.i += 1;
|
||||
}
|
||||
self.i += 1;
|
||||
}
|
||||
let v = String::from_utf8_lossy(&self.b[s..self.i.min(self.b.len())]).to_string();
|
||||
self.i += 1;
|
||||
Some(Val::Str(v))
|
||||
}
|
||||
b'[' => {
|
||||
self.i += 1;
|
||||
let mut l = vec![];
|
||||
loop {
|
||||
self.skip();
|
||||
if *self.b.get(self.i)? == b']' {
|
||||
self.i += 1;
|
||||
break;
|
||||
}
|
||||
l.push(self.value()?);
|
||||
}
|
||||
Some(Val::List(l))
|
||||
}
|
||||
_ => {
|
||||
let s = self.i;
|
||||
while self.i < self.b.len() && (self.b[self.i].is_ascii_digit() || self.b[self.i] == b'-') {
|
||||
self.i += 1;
|
||||
}
|
||||
if self.i == s {
|
||||
return None;
|
||||
}
|
||||
std::str::from_utf8(&self.b[s..self.i]).ok()?.parse().ok().map(Val::Int)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn section(&mut self, top: bool) -> Option<Section> {
|
||||
let mut sec = Section::default();
|
||||
loop {
|
||||
self.skip();
|
||||
if self.i >= self.b.len() {
|
||||
return top.then_some(sec);
|
||||
}
|
||||
if self.b[self.i] == b'}' {
|
||||
self.i += 1;
|
||||
return (!top).then_some(sec);
|
||||
}
|
||||
let name = self.ident()?;
|
||||
self.skip();
|
||||
match *self.b.get(self.i)? {
|
||||
b'=' => {
|
||||
self.i += 1;
|
||||
let v = self.value()?;
|
||||
sec.values.insert(name, v);
|
||||
}
|
||||
b'{' => {
|
||||
self.i += 1;
|
||||
let s = self.section(false)?;
|
||||
sec.sections.push((name, s));
|
||||
}
|
||||
_ => return None,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(text: &str) -> Option<Section> {
|
||||
Lexer { b: text.as_bytes(), i: 0 }.section(true)
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------- montagem
|
||||
|
||||
fn dashed(u: &str) -> String {
|
||||
if u.len() != 32 {
|
||||
return u.to_string();
|
||||
}
|
||||
format!("{}-{}-{}-{}-{}-{}-{}", &u[0..6], &u[6..10], &u[10..14], &u[14..18], &u[18..22], &u[22..26], &u[26..32])
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
enum Map {
|
||||
/// Lê de `src` a partir de `base` (linear).
|
||||
Linear { src: Option<Arc<dyn Source>>, base: u64 },
|
||||
Striped { srcs: Vec<(Option<Arc<dyn Source>>, u64)>, stripe: u64 },
|
||||
Mirror { legs: Vec<(Option<Arc<dyn Source>>, u64)> },
|
||||
Raid(Arc<RaidSource>),
|
||||
}
|
||||
|
||||
struct Seg {
|
||||
start: u64,
|
||||
len: u64,
|
||||
map: Map,
|
||||
}
|
||||
|
||||
pub struct LvSource {
|
||||
segs: Vec<Seg>,
|
||||
size: u64,
|
||||
}
|
||||
|
||||
impl Source for LvSource {
|
||||
fn size(&self) -> u64 {
|
||||
self.size
|
||||
}
|
||||
fn read_at(&self, offset: u64, buf: &mut [u8]) -> io::Result<usize> {
|
||||
if offset >= self.size || buf.is_empty() {
|
||||
return Ok(0);
|
||||
}
|
||||
let want = buf.len().min((self.size - offset) as usize);
|
||||
let mut done = 0;
|
||||
while done < want {
|
||||
let pos = offset + done as u64;
|
||||
let i = self.segs.partition_point(|s| s.start + s.len <= pos);
|
||||
let Some(s) = self.segs.get(i) else { break };
|
||||
let rel = pos - s.start;
|
||||
let mut n = ((s.len - rel) as usize).min(want - done);
|
||||
let dst = &mut buf[done..done + n];
|
||||
match &s.map {
|
||||
Map::Linear { src, base } => match src {
|
||||
Some(src) => n = read_full(src.as_ref(), base + rel, dst)?,
|
||||
None => dst.fill(0),
|
||||
},
|
||||
Map::Striped { srcs, stripe } => {
|
||||
let ns = srcs.len() as u64;
|
||||
let (idx, within) = (rel / stripe, rel % stripe);
|
||||
n = n.min((stripe - within) as usize);
|
||||
let (src, base) = &srcs[(idx % ns) as usize];
|
||||
let off = base + (idx / ns) * stripe + within;
|
||||
match src {
|
||||
Some(src) => n = read_full(src.as_ref(), off, &mut dst[..n])?,
|
||||
None => dst[..n].fill(0),
|
||||
}
|
||||
}
|
||||
Map::Mirror { legs } => {
|
||||
let mut ok = false;
|
||||
for (src, base) in legs {
|
||||
if let Some(src) = src {
|
||||
if let Ok(g) = read_full(src.as_ref(), base + rel, dst) {
|
||||
n = g;
|
||||
ok = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if !ok {
|
||||
dst.fill(0);
|
||||
}
|
||||
}
|
||||
Map::Raid(r) => n = read_full(r.as_ref(), rel, dst)?,
|
||||
}
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
done += n;
|
||||
}
|
||||
Ok(done)
|
||||
}
|
||||
}
|
||||
|
||||
fn read_full(src: &dyn Source, off: u64, buf: &mut [u8]) -> io::Result<usize> {
|
||||
let mut got = 0;
|
||||
while got < buf.len() {
|
||||
let n = src.read_at(off + got as u64, &mut buf[got..])?;
|
||||
if n == 0 {
|
||||
buf[got..].fill(0);
|
||||
return Ok(buf.len());
|
||||
}
|
||||
got += n;
|
||||
}
|
||||
Ok(got)
|
||||
}
|
||||
|
||||
pub struct VgResult {
|
||||
pub name: String,
|
||||
pub lvs: Vec<(String, Arc<dyn Source>)>,
|
||||
pub warnings: Vec<String>,
|
||||
}
|
||||
|
||||
fn mk_stripes(list: &[Val]) -> Vec<(String, u64)> {
|
||||
let mut out = vec![];
|
||||
for pair in list.chunks(2) {
|
||||
if let [Val::Str(n), Val::Int(e)] = pair {
|
||||
out.push((n.clone(), *e as u64));
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
struct Ctx<'a> {
|
||||
ext: u64,
|
||||
pvs: BTreeMap<String, (Option<Arc<dyn Source>>, u64)>, // nome -> (origem, pe_start em bytes)
|
||||
lvs: &'a Section,
|
||||
cache: BTreeMap<String, Option<Arc<dyn Source>>>,
|
||||
warnings: Vec<String>,
|
||||
}
|
||||
|
||||
impl Ctx<'_> {
|
||||
fn build(&mut self, name: &str, depth: u32) -> Option<Arc<dyn Source>> {
|
||||
if let Some(c) = self.cache.get(name) {
|
||||
return c.clone();
|
||||
}
|
||||
if depth > 6 {
|
||||
return None;
|
||||
}
|
||||
let lv = self.lvs.sub(name)?.clone();
|
||||
let nsegs = lv.int("segment_count").unwrap_or(0);
|
||||
let mut segs: Vec<Seg> = vec![];
|
||||
for i in 1..=nsegs {
|
||||
let Some(seg) = lv.sub(&format!("segment{i}")) else {
|
||||
self.warnings.push(format!("{name}: segmento {i} ausente"));
|
||||
return None;
|
||||
};
|
||||
let start = seg.int("start_extent").unwrap_or(0) * self.ext;
|
||||
let len = seg.int("extent_count").unwrap_or(0) * self.ext;
|
||||
let ty = seg.str("type").unwrap_or("").to_string();
|
||||
let map = match ty.as_str() {
|
||||
"striped" => {
|
||||
let st = mk_stripes(seg.list("stripes").unwrap_or(&[]));
|
||||
let srcs: Vec<(Option<Arc<dyn Source>>, u64)> = st
|
||||
.iter()
|
||||
.map(|(pv, e)| match self.pvs.get(pv) {
|
||||
Some((s, pe)) => (s.clone(), pe + e * self.ext),
|
||||
None => (None, 0),
|
||||
})
|
||||
.collect();
|
||||
if srcs.iter().any(|(s, _)| s.is_none()) {
|
||||
self.warnings.push(format!("{name}: falta um volume físico; as áreas dele aparecem zeradas"));
|
||||
}
|
||||
if srcs.len() == 1 {
|
||||
let (src, base) = srcs.into_iter().next().unwrap();
|
||||
Map::Linear { src, base }
|
||||
} else {
|
||||
Map::Striped { srcs, stripe: seg.int("stripe_size").unwrap_or(128) * 512 }
|
||||
}
|
||||
}
|
||||
"mirror" => {
|
||||
let st = mk_stripes(seg.list("mirrors").unwrap_or(&[]));
|
||||
let legs = st
|
||||
.iter()
|
||||
.filter_map(|(pv, e)| self.pvs.get(pv).map(|(s, pe)| (s.clone(), pe + e * self.ext)))
|
||||
.collect();
|
||||
Map::Mirror { legs }
|
||||
}
|
||||
t if t.starts_with("raid") => {
|
||||
let raids = seg.list("raids").unwrap_or(&[]);
|
||||
let imgs: Vec<String> = raids.iter().filter_map(|v| if let Val::Str(s) = v { Some(s.clone()) } else { None }).collect();
|
||||
// Pares (rimage, rmeta) ou lista só de imagens.
|
||||
let data_lvs: Vec<&String> = imgs.iter().filter(|n| n.contains("_rimage_")).collect();
|
||||
let mut members: Vec<Option<Member>> = vec![];
|
||||
for n in &data_lvs {
|
||||
members.push(self.build(n, depth + 1).map(|src| Member { src, data_offset: 0 }));
|
||||
}
|
||||
let chunk = seg.int("stripe_size").unwrap_or(128) * 512;
|
||||
let (level, layout) = match t {
|
||||
"raid1" => (Level::R1, Layout::LeftSymmetric),
|
||||
"raid0" | "raid0_meta" => (Level::R0, Layout::LeftSymmetric),
|
||||
"raid4" | "raid5_n" => (Level::R4, Layout::ParityLast),
|
||||
"raid5" | "raid5_ls" => (Level::R5, Layout::LeftSymmetric),
|
||||
"raid5_la" => (Level::R5, Layout::LeftAsymmetric),
|
||||
"raid5_rs" => (Level::R5, Layout::RightSymmetric),
|
||||
"raid5_ra" => (Level::R5, Layout::RightAsymmetric),
|
||||
"raid6" | "raid6_zr" | "raid6_ls_6" => (Level::R6, Layout::LeftSymmetric),
|
||||
"raid6_nr" => (Level::R6, Layout::LeftAsymmetric),
|
||||
"raid6_nc" | "raid6_n_6" => (Level::R6, Layout::ParityLast),
|
||||
"raid10" => (Level::R10, Layout::LeftSymmetric),
|
||||
other => {
|
||||
self.warnings.push(format!("{name}: tipo {other} não suportado"));
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let mut p = RaidParams::simple(level, chunk.max(512), layout, members);
|
||||
p.near = 2;
|
||||
p.far = 1;
|
||||
match RaidSource::new(p) {
|
||||
Ok(r) => Map::Raid(Arc::new(r)),
|
||||
Err(e) => {
|
||||
self.warnings.push(format!("{name}: {e}"));
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
other => {
|
||||
self.warnings.push(format!("{name}: tipo de segmento \"{other}\" não suportado"));
|
||||
return None;
|
||||
}
|
||||
};
|
||||
segs.push(Seg { start, len, map });
|
||||
}
|
||||
segs.sort_by_key(|s| s.start);
|
||||
let size = segs.iter().map(|s| s.start + s.len).max().unwrap_or(0);
|
||||
let src: Arc<dyn Source> = Arc::new(LvSource { segs, size });
|
||||
self.cache.insert(name.to_string(), Some(src.clone()));
|
||||
Some(src)
|
||||
}
|
||||
}
|
||||
|
||||
/// Monta os volumes lógicos de cada grupo de volumes presente nos PVs fornecidos.
|
||||
pub fn assemble_vgs(pvs: Vec<(Arc<dyn Source>, PvInfo)>) -> Vec<VgResult> {
|
||||
let mut by_vg: BTreeMap<String, Vec<(Arc<dyn Source>, PvInfo)>> = BTreeMap::new();
|
||||
for (s, p) in pvs {
|
||||
by_vg.entry(p.vg_name.clone()).or_default().push((s, p));
|
||||
}
|
||||
let mut out = vec![];
|
||||
for (vg_name, list) in by_vg {
|
||||
let newest = list.iter().max_by_key(|(_, p)| p.seqno).unwrap();
|
||||
let Some(tree) = parse(&newest.1.text) else { continue };
|
||||
let Some(vg) = tree.sub(&vg_name) else { continue };
|
||||
let ext = vg.int("extent_size").unwrap_or(8192) * 512;
|
||||
let mut pvmap = BTreeMap::new();
|
||||
let mut warnings = vec![];
|
||||
if let Some(pvsec) = vg.sub("physical_volumes") {
|
||||
for (pvname, def) in &pvsec.sections {
|
||||
let id = def.str("id").unwrap_or("").to_string();
|
||||
let found = list.iter().find(|(_, p)| dashed(&p.uuid) == id).map(|(s, _)| s.clone());
|
||||
if found.is_none() {
|
||||
warnings.push(format!("volume físico {pvname} ({id}) não foi fornecido"));
|
||||
}
|
||||
pvmap.insert(pvname.clone(), (found, def.int("pe_start").unwrap_or(2048) * 512));
|
||||
}
|
||||
}
|
||||
let Some(lvsec) = vg.sub("logical_volumes") else { continue };
|
||||
let mut ctx = Ctx { ext, pvs: pvmap, lvs: lvsec, cache: BTreeMap::new(), warnings };
|
||||
let mut lvs = vec![];
|
||||
for (name, def) in &lvsec.sections {
|
||||
// Imagens internas do RAID e metadados não são volumes de usuário.
|
||||
let hidden = def.list("status").map(|l| !l.iter().any(|v| matches!(v, Val::Str(s) if s == "VISIBLE"))).unwrap_or(false);
|
||||
if hidden {
|
||||
continue;
|
||||
}
|
||||
if let Some(src) = ctx.build(name, 0) {
|
||||
lvs.push((name.clone(), src));
|
||||
}
|
||||
}
|
||||
out.push(VgResult { name: vg_name, lvs, warnings: ctx.warnings });
|
||||
}
|
||||
out
|
||||
}
|
||||
Reference in new issue
Block a user