Detecção automática de parâmetros de RAID sem metadados e montagem integrada
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Lucas RayanandClaude Sonnet 5.5 committed
1 parent
5d45273e0d
commit
b8dfe21fd7
9 files changed
+503
-1
No files matched your search
@@ -0,0 +1,227 @@
|
||||
//! Descobre sozinho nível, ordem dos discos, tamanho de faixa e layout de um RAID sem
|
||||
//! metadados, testando as combinações e medindo a coerência do sistema de arquivos que sai.
|
||||
|
||||
use crate::partition;
|
||||
use crate::raid::{Layout, Level, Member, RaidParams, RaidSource};
|
||||
use crate::source::{read_vec, MemSource, Source};
|
||||
use crate::types::FsKind;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Candidate {
|
||||
pub level: Level,
|
||||
pub chunk: u64,
|
||||
pub layout: Layout,
|
||||
/// Índices dos membros fornecidos, na ordem do array.
|
||||
pub order: Vec<usize>,
|
||||
pub score: f64,
|
||||
}
|
||||
|
||||
impl Candidate {
|
||||
pub fn params(&self, members: &[Arc<dyn Source>]) -> RaidParams {
|
||||
RaidParams::simple(
|
||||
self.level,
|
||||
self.chunk,
|
||||
self.layout,
|
||||
self.order.iter().map(|&i| Some(Member { src: members[i].clone(), data_offset: 0 })).collect(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
const PREFIX: u64 = 24 << 20;
|
||||
const CHUNKS: [u64; 9] = [4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576];
|
||||
|
||||
fn permutations(n: usize) -> Vec<Vec<usize>> {
|
||||
fn rec(cur: &mut Vec<usize>, used: &mut Vec<bool>, n: usize, out: &mut Vec<Vec<usize>>) {
|
||||
if cur.len() == n {
|
||||
out.push(cur.clone());
|
||||
return;
|
||||
}
|
||||
for i in 0..n {
|
||||
if !used[i] {
|
||||
used[i] = true;
|
||||
cur.push(i);
|
||||
rec(cur, used, n, out);
|
||||
cur.pop();
|
||||
used[i] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut out = vec![];
|
||||
rec(&mut vec![], &mut vec![false; n], n, &mut out);
|
||||
out
|
||||
}
|
||||
|
||||
fn ntfs_score(src: &dyn Source, start: u64) -> f64 {
|
||||
let Ok(b) = read_vec(src, start, 512) else { return 0.0 };
|
||||
if b.len() < 512 || &b[3..11] != b"NTFS " {
|
||||
return 0.0;
|
||||
}
|
||||
let bps = u16::from_le_bytes([b[11], b[12]]) as u64;
|
||||
let spc = b[13] as u64;
|
||||
let mft = u64::from_le_bytes(b[0x30..0x38].try_into().unwrap());
|
||||
let rs = b[0x40] as i8;
|
||||
let rec = if rs > 0 { rs as u64 * bps * spc } else { 1u64 << (-rs) };
|
||||
if bps == 0 || spc == 0 || rec == 0 || rec > 65536 {
|
||||
return 0.0;
|
||||
}
|
||||
let mft_off = start + mft * bps * spc;
|
||||
let (mut ok, mut total) = (0, 0);
|
||||
for k in [0u64, 1, 2, 3, 5, 11, 16, 24, 40, 100, 250, 600, 1500, 3000, 6000, 12000, 24000, 50000] {
|
||||
let off = mft_off + k * rec;
|
||||
if off + rec > src.size() {
|
||||
break;
|
||||
}
|
||||
let Ok(r) = read_vec(src, off, 64) else { continue };
|
||||
if r.len() < 64 {
|
||||
continue;
|
||||
}
|
||||
// Registros além do fim do MFT estão zerados: não contam contra.
|
||||
if r.iter().all(|&x| x == 0) {
|
||||
continue;
|
||||
}
|
||||
total += 1;
|
||||
if &r[..4] == b"FILE" && u32::from_le_bytes(r[0x2C..0x30].try_into().unwrap()) as u64 == k {
|
||||
ok += 1;
|
||||
}
|
||||
}
|
||||
if total == 0 {
|
||||
1.0
|
||||
} else {
|
||||
1.0 + 10.0 * ok as f64 / total as f64
|
||||
}
|
||||
}
|
||||
|
||||
/// Coerência do volume que começa em `start`.
|
||||
fn volume_score(src: &dyn Source, start: u64, fs: FsKind) -> f64 {
|
||||
match fs {
|
||||
FsKind::Ntfs => ntfs_score(src, start),
|
||||
FsKind::Ext => crate::fs::ext::consistency_score(src, start).unwrap_or(0.5),
|
||||
FsKind::Unknown => 0.0,
|
||||
_ => 1.0,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn fs_score(src: &dyn Source) -> f64 {
|
||||
let layout = partition::analyze(src, false);
|
||||
let mut best = 0.0f64;
|
||||
for p in &layout.partitions {
|
||||
best = best.max(volume_score(src, p.start, p.fs) + if p.fs != FsKind::Unknown { 0.5 } else { 0.0 });
|
||||
}
|
||||
best
|
||||
}
|
||||
|
||||
fn first_sector_plausible(src: &dyn Source) -> bool {
|
||||
let Ok(b) = read_vec(src, 0, 4096) else { return false };
|
||||
b.len() >= 1100 && ((b[510] == 0x55 && b[511] == 0xAA) || partition::detect_fs_in(&b).is_some())
|
||||
}
|
||||
|
||||
/// Testa as combinações e devolve as melhores (maior pontuação primeiro).
|
||||
pub fn detect(members: &[Arc<dyn Source>], cancelled: &(dyn Fn() -> bool + Sync)) -> Vec<Candidate> {
|
||||
let n = members.len();
|
||||
if n < 2 {
|
||||
return vec![];
|
||||
}
|
||||
// Trabalha sobre um prefixo em memória de cada disco.
|
||||
let cached: Vec<Arc<dyn Source>> = members
|
||||
.iter()
|
||||
.map(|m| {
|
||||
let len = m.size().min(PREFIX) as usize;
|
||||
Arc::new(MemSource(read_vec(m.as_ref(), 0, len).unwrap_or_default())) as Arc<dyn Source>
|
||||
})
|
||||
.collect();
|
||||
let min_len = cached.iter().map(|c| c.size()).min().unwrap_or(0);
|
||||
if min_len < 1 << 20 {
|
||||
return vec![];
|
||||
}
|
||||
let mut out: Vec<Candidate> = vec![];
|
||||
|
||||
// RAID 1: cópias idênticas.
|
||||
let probe = |s: &Arc<dyn Source>| read_vec(s.as_ref(), 0, 1 << 20).unwrap_or_default();
|
||||
let first = probe(&cached[0]);
|
||||
if first.iter().any(|&x| x != 0) && cached.iter().skip(1).all(|c| probe(c) == first) {
|
||||
let c = Candidate { level: Level::R1, chunk: 65536, layout: Layout::LeftSymmetric, order: (0..n).collect(), score: fs_score(cached[0].as_ref()) + 1.0 };
|
||||
out.push(c);
|
||||
}
|
||||
|
||||
// RAID 5/4 satisfaz "XOR de todos os discos = 0" em toda faixa.
|
||||
let sample = 4usize << 20;
|
||||
let bufs: Vec<Vec<u8>> = cached.iter().map(|c| read_vec(c.as_ref(), 0, sample).unwrap_or_default()).collect();
|
||||
let mut xor_zero = 0usize;
|
||||
let mut nonzero_rows = 0usize;
|
||||
for blk in 0..sample / 4096 {
|
||||
let mut any = false;
|
||||
let mut z = true;
|
||||
for i in 0..4096 {
|
||||
let mut x = 0u8;
|
||||
for b in &bufs {
|
||||
x ^= b[blk * 4096 + i];
|
||||
any |= b[blk * 4096 + i] != 0;
|
||||
}
|
||||
if x != 0 {
|
||||
z = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if any {
|
||||
nonzero_rows += 1;
|
||||
if z {
|
||||
xor_zero += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let parity5 = nonzero_rows > 8 && xor_zero * 100 >= nonzero_rows * 95;
|
||||
|
||||
let mut levels: Vec<Level> = vec![];
|
||||
if parity5 && n >= 3 {
|
||||
levels.push(Level::R5);
|
||||
} else {
|
||||
levels.push(Level::R0);
|
||||
if n >= 4 {
|
||||
levels.push(Level::R6);
|
||||
}
|
||||
}
|
||||
let ok_first: Vec<bool> = cached.iter().map(|c| first_sector_plausible(c.as_ref())).collect();
|
||||
let any_first = ok_first.iter().any(|&b| b);
|
||||
let perms = permutations(n);
|
||||
for level in levels {
|
||||
let layouts: Vec<Layout> = if matches!(level, Level::R0) { vec![Layout::LeftSymmetric] } else { Layout::all_raid5().to_vec() };
|
||||
for &chunk in &CHUNKS {
|
||||
for layout in &layouts {
|
||||
for order in &perms {
|
||||
if cancelled() {
|
||||
return finish(out);
|
||||
}
|
||||
let cand = Candidate { level, chunk, layout: *layout, order: order.clone(), score: 0.0 };
|
||||
let params = cand.params(&cached);
|
||||
let Ok(r) = RaidSource::new(params) else { continue };
|
||||
// O primeiro setor do volume precisa estar num disco que o tenha.
|
||||
if any_first {
|
||||
let mut b = [0u8; 512];
|
||||
let _ = r.read_at(0, &mut b);
|
||||
let m0 = order.iter().position(|&i| {
|
||||
let mut c = [0u8; 512];
|
||||
let _ = cached[i].read_at(0, &mut c);
|
||||
c == b
|
||||
});
|
||||
match m0 {
|
||||
Some(p) if ok_first[order[p]] => {}
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
let score = fs_score(&r);
|
||||
if score > 0.0 {
|
||||
out.push(Candidate { score, ..cand });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
finish(out)
|
||||
}
|
||||
|
||||
fn finish(mut out: Vec<Candidate>) -> Vec<Candidate> {
|
||||
out.sort_by(|a, b| b.score.partial_cmp(&a.score).unwrap_or(std::cmp::Ordering::Equal));
|
||||
out.truncate(10);
|
||||
out
|
||||
}
|
||||
Reference in new issue
Block a user