From 965fbb6e8fe2a2a9cba1584d3d860379b6204f51 Mon Sep 17 00:00:00 2001 From: Ming-Hung Tsai Date: Tue, 11 May 2021 20:41:30 +0800 Subject: [PATCH] [all] Apply cargo fmt, and fix clippy warnings --- src/bin/cache_check.rs | 2 +- src/bin/thin_check.rs | 11 +++-- src/bin/thin_explore.rs | 18 ++++---- src/cache/check.rs | 79 ++++++++++++++++++++-------------- src/cache/dump.rs | 21 ++++++--- src/cache/hint.rs | 1 - src/checksum.rs | 5 ++- src/pdata/array.rs | 17 ++++---- src/pdata/array_walker.rs | 26 ++++++----- src/pdata/bitset.rs | 14 +++--- src/pdata/btree.rs | 5 ++- src/pdata/btree_builder.rs | 14 +++--- src/pdata/btree_walker.rs | 5 +-- src/pdata/space_map_checker.rs | 30 +++++++++---- src/pdata/space_map_disk.rs | 2 +- src/thin/check.rs | 21 ++++----- src/thin/dump.rs | 9 ++-- src/thin/restore.rs | 4 +- src/thin/superblock.rs | 6 +-- 19 files changed, 166 insertions(+), 124 deletions(-) diff --git a/src/bin/cache_check.rs b/src/bin/cache_check.rs index 2c70358..94355dc 100644 --- a/src/bin/cache_check.rs +++ b/src/bin/cache_check.rs @@ -6,8 +6,8 @@ use clap::{App, Arg}; use std::path::Path; use std::sync::Arc; -use thinp::report::*; use thinp::cache::check::{check, CacheCheckOptions}; +use thinp::report::*; //------------------------------------------ diff --git a/src/bin/thin_check.rs b/src/bin/thin_check.rs index b607c58..307b439 100644 --- a/src/bin/thin_check.rs +++ b/src/bin/thin_check.rs @@ -106,14 +106,19 @@ fn main() { let engine: Arc; if matches.is_present("ASYNC_IO") { - engine = Arc::new(AsyncIoEngine::new(&input_file, MAX_CONCURRENT_IO, false).expect("unable to open input file")); + engine = Arc::new( + AsyncIoEngine::new(&input_file, MAX_CONCURRENT_IO, false) + .expect("unable to open input file"), + ); } else { let nr_threads = std::cmp::max(8, num_cpus::get() * 2); - engine = Arc::new(SyncIoEngine::new(&input_file, nr_threads, false).expect("unable to open input file")); + engine = Arc::new( + SyncIoEngine::new(&input_file, nr_threads, false).expect("unable to open input file"), + ); } let opts = ThinCheckOptions { - engine: engine, + engine, sb_only: matches.is_present("SB_ONLY"), skip_mappings: matches.is_present("SKIP_MAPPINGS"), ignore_non_fatal: matches.is_present("IGNORE_NON_FATAL"), diff --git a/src/bin/thin_explore.rs b/src/bin/thin_explore.rs index 356cea6..c4918fd 100644 --- a/src/bin/thin_explore.rs +++ b/src/bin/thin_explore.rs @@ -75,15 +75,13 @@ impl Events { let ignore_exit_key = ignore_exit_key.clone(); thread::spawn(move || { let stdin = io::stdin(); - for evt in stdin.keys() { - if let Ok(key) = evt { - if let Err(err) = tx.send(Event::Input(key)) { - eprintln!("{}", err); - return; - } - if !ignore_exit_key.load(Ordering::Relaxed) && key == config.exit_key { - return; - } + for key in stdin.keys().flatten() { + if let Err(err) = tx.send(Event::Input(key)) { + eprintln!("{}", err); + return; + } + if !ignore_exit_key.load(Ordering::Relaxed) && key == config.exit_key { + return; } } }) @@ -91,8 +89,8 @@ impl Events { Events { rx, - ignore_exit_key, input_handle, + ignore_exit_key, } } diff --git a/src/cache/check.rs b/src/cache/check.rs index d8b5caa..15b129a 100644 --- a/src/cache/check.rs +++ b/src/cache/check.rs @@ -41,17 +41,26 @@ mod format1 { impl MappingChecker { pub fn new(nr_origin_blocks: Option) -> MappingChecker { MappingChecker { - nr_origin_blocks: if let Some(n) = nr_origin_blocks {n} else {MAX_ORIGIN_BLOCKS}, + nr_origin_blocks: if let Some(n) = nr_origin_blocks { + n + } else { + MAX_ORIGIN_BLOCKS + }, seen_oblocks: Mutex::new(BTreeSet::new()), } } fn check_flags(&self, m: &Mapping) -> array::Result<()> { if (m.flags & !(MappingFlags::Valid as u32 | MappingFlags::Dirty as u32)) != 0 { - return Err(array::value_err(format!("unknown flags in mapping: {}", m.flags))); + return Err(array::value_err(format!( + "unknown flags in mapping: {}", + m.flags + ))); } if !m.is_valid() && m.is_dirty() { - return Err(array::value_err(format!("dirty bit found on an unmapped block"))); + return Err(array::value_err( + "dirty bit found on an unmapped block".to_string(), + )); } Ok(()) } @@ -59,16 +68,18 @@ mod format1 { fn check_oblock(&self, m: &Mapping) -> array::Result<()> { if !m.is_valid() { if m.oblock > 0 { - return Err(array::value_err(format!("invalid block is mapped"))); + return Err(array::value_err("invalid block is mapped".to_string())); } return Ok(()); } if m.oblock >= self.nr_origin_blocks { - return Err(array::value_err(format!("mapping beyond end of the origin device"))); + return Err(array::value_err( + "mapping beyond end of the origin device".to_string(), + )); } let mut seen_oblocks = self.seen_oblocks.lock().unwrap(); if seen_oblocks.contains(&m.oblock) { - return Err(array::value_err(format!("origin block already mapped"))); + return Err(array::value_err("origin block already mapped".to_string())); } seen_oblocks.insert(m.oblock); Ok(()) @@ -93,12 +104,8 @@ mod format1 { // FIXME: duplicate to BTreeWalker::build_aggregrate() match errs.len() { 0 => Ok(()), - 1 => { - Err(errs[0].clone()) - } - _ => { - Err(array::aggregate_error(errs)) - } + 1 => Err(errs[0].clone()), + _ => Err(array::aggregate_error(errs)), } } } @@ -120,7 +127,11 @@ mod format2 { impl MappingChecker { pub fn new(nr_origin_blocks: Option, dirty_bits: CheckedBitSet) -> MappingChecker { MappingChecker { - nr_origin_blocks: if let Some(n) = nr_origin_blocks {n} else {MAX_ORIGIN_BLOCKS}, + nr_origin_blocks: if let Some(n) = nr_origin_blocks { + n + } else { + MAX_ORIGIN_BLOCKS + }, inner: Mutex::new(Inner { seen_oblocks: BTreeSet::new(), dirty_bits, @@ -130,10 +141,15 @@ mod format2 { fn check_flags(&self, m: &Mapping, dirty_bit: Option) -> array::Result<()> { if (m.flags & !(MappingFlags::Valid as u32)) != 0 { - return Err(array::value_err(format!("unknown flags in mapping: {}", m.flags))); + return Err(array::value_err(format!( + "unknown flags in mapping: {}", + m.flags + ))); } if !m.is_valid() && dirty_bit.is_some() && dirty_bit.unwrap() { - return Err(array::value_err(format!("dirty bit found on an unmapped block"))); + return Err(array::value_err( + "dirty bit found on an unmapped block".to_string(), + )); } Ok(()) } @@ -141,15 +157,17 @@ mod format2 { fn check_oblock(&self, m: &Mapping, seen_oblocks: &mut BTreeSet) -> array::Result<()> { if !m.is_valid() { if m.oblock > 0 { - return Err(array::value_err(format!("invalid mapped block"))); + return Err(array::value_err("invalid mapped block".to_string())); } return Ok(()); } if m.oblock >= self.nr_origin_blocks { - return Err(array::value_err(format!("mapping beyond end of the origin device"))); + return Err(array::value_err( + "mapping beyond end of the origin device".to_string(), + )); } if seen_oblocks.contains(&m.oblock) { - return Err(array::value_err(format!("origin block already mapped"))); + return Err(array::value_err("origin block already mapped".to_string())); } seen_oblocks.insert(m.oblock); @@ -166,7 +184,8 @@ mod format2 { for i in 0..b.header.nr_entries { let m = b.values[i as usize]; - if let Err(e) = self.check_flags(&m, inner.dirty_bits.contains(begin + i as usize)) { + if let Err(e) = self.check_flags(&m, inner.dirty_bits.contains(begin + i as usize)) + { errs.push(e); } if let Err(e) = self.check_oblock(&m, &mut inner.seen_oblocks) { @@ -177,12 +196,8 @@ mod format2 { // FIXME: duplicate to BTreeWalker::build_aggregrate() match errs.len() { 0 => Ok(()), - 1 => { - Err(errs[0].clone()) - } - _ => { - Err(array::aggregate_error(errs)) - } + 1 => Err(errs[0].clone()), + _ => Err(array::aggregate_error(errs)), } } } @@ -273,7 +288,8 @@ pub fn check(opts: CacheCheckOptions) -> anyhow::Result<()> { // TODO: factor out into check_mappings() if !opts.skip_mappings { - let w = ArrayWalker::new_with_sm(engine.clone(), metadata_sm.clone(), opts.ignore_non_fatal)?; + let w = + ArrayWalker::new_with_sm(engine.clone(), metadata_sm.clone(), opts.ignore_non_fatal)?; match sb.version { 1 => { let mut c = format1::MappingChecker::new(nr_origin_blocks); @@ -307,7 +323,8 @@ pub fn check(opts: CacheCheckOptions) -> anyhow::Result<()> { if sb.policy_hint_size != 4 { return Err(anyhow!("cache_check only supports policy hint size of 4")); } - let w = ArrayWalker::new_with_sm(engine.clone(), metadata_sm.clone(), opts.ignore_non_fatal)?; + let w = + ArrayWalker::new_with_sm(engine.clone(), metadata_sm.clone(), opts.ignore_non_fatal)?; let mut c = HintChecker::new(); if let Err(e) = w.walk(&mut c, sb.hint_root) { ctx.report.fatal(&format!("{}", e)); @@ -338,11 +355,9 @@ pub fn check(opts: CacheCheckOptions) -> anyhow::Result<()> { opts.ignore_non_fatal, )?; - if opts.auto_repair { - if !metadata_leaks.is_empty() { - ctx.report.info("Repairing metadata leaks."); - repair_space_map(ctx.engine.clone(), metadata_leaks, metadata_sm.clone())?; - } + if opts.auto_repair && !metadata_leaks.is_empty() { + ctx.report.info("Repairing metadata leaks."); + repair_space_map(ctx.engine.clone(), metadata_leaks, metadata_sm.clone())?; } Ok(()) diff --git a/src/cache/dump.rs b/src/cache/dump.rs index 235ef8a..7a88ceb 100644 --- a/src/cache/dump.rs +++ b/src/cache/dump.rs @@ -61,7 +61,10 @@ mod format1 { let mut inner = self.inner.lock().unwrap(); inner.valid_mappings.set(index as usize, true); - inner.visitor.mapping(&m).map_err(|e| array::value_err(format!("{}", e)))?; + inner + .visitor + .mapping(&m) + .map_err(|e| array::value_err(format!("{}", e)))?; } Ok(()) @@ -96,7 +99,7 @@ mod format2 { impl ArrayVisitor for DirtyVisitor { fn visit(&self, index: u64, b: ArrayBlock) -> array::Result<()> { - let mut pos = index as usize * (b.header.max_entries as usize) << 6; + let mut pos = (index as usize * (b.header.max_entries as usize)) << 6; for i in 0..b.header.nr_entries as usize { let bits = b.values[i]; @@ -127,7 +130,11 @@ mod format2 { } impl<'a> MappingEmitter<'a> { - pub fn new(nr_entries: usize, dirty_bits: FixedBitSet, visitor: &'a mut dyn MetadataVisitor) -> MappingEmitter<'a> { + pub fn new( + nr_entries: usize, + dirty_bits: FixedBitSet, + visitor: &'a mut dyn MetadataVisitor, + ) -> MappingEmitter<'a> { MappingEmitter { inner: Mutex::new(Inner { visitor, @@ -161,7 +168,10 @@ mod format2 { }; inner.valid_mappings.set(index as usize, true); - inner.visitor.mapping(&m).map_err(|e| array::value_err(format!("{}", e)))?; + inner + .visitor + .mapping(&m) + .map_err(|e| array::value_err(format!("{}", e)))?; } Ok(()) } @@ -272,7 +282,8 @@ fn dump_metadata(ctx: &Context, sb: &Superblock, _repair: bool) -> anyhow::Resul let dirty_bits = v.get_bits(); let w = ArrayWalker::new(engine.clone(), false); - let mut emitter = format2::MappingEmitter::new(sb.cache_blocks as usize, dirty_bits, &mut out); + let mut emitter = + format2::MappingEmitter::new(sb.cache_blocks as usize, dirty_bits, &mut out); w.walk(&mut emitter, sb.mapping_root)?; emitter.get_valid() } diff --git a/src/cache/hint.rs b/src/cache/hint.rs index 2a9ff9b..b066645 100644 --- a/src/cache/hint.rs +++ b/src/cache/hint.rs @@ -1,6 +1,5 @@ use nom::IResult; use std::convert::TryInto; -use std::marker::PhantomData; use crate::pdata::unpack::*; diff --git a/src/checksum.rs b/src/checksum.rs index 8c39f2c..01d8063 100644 --- a/src/checksum.rs +++ b/src/checksum.rs @@ -17,6 +17,7 @@ fn checksum(buf: &[u8]) -> u32 { } #[derive(Debug, PartialEq)] +#[allow(clippy::upper_case_acronyms)] pub enum BT { SUPERBLOCK, NODE, @@ -59,7 +60,9 @@ pub fn write_checksum(buf: &mut [u8], kind: BT) -> Result<()> { BITMAP => BITMAP_CSUM_XOR, INDEX => INDEX_CSUM_XOR, ARRAY => ARRAY_CSUM_XOR, - UNKNOWN => {return Err(anyhow!("Invalid block type"));} + UNKNOWN => { + return Err(anyhow!("Invalid block type")); + } }; let csum = checksum(buf) ^ salt; diff --git a/src/pdata/array.rs b/src/pdata/array.rs index b2cfbaf..f459d1f 100644 --- a/src/pdata/array.rs +++ b/src/pdata/array.rs @@ -135,15 +135,16 @@ pub fn unpack_array_block(path: &[u64], data: &[u8]) -> Result(path: &[u64], data: &[u8]) -> Result(path: &[u64], data: &[u8]) -> Result BLOCK_SIZE as u32 { return Err(array_block_err( path, - &format!("max_entries is too large ({})", header.max_entries) + &format!("max_entries is too large ({})", header.max_entries), )); } diff --git a/src/pdata/array_walker.rs b/src/pdata/array_walker.rs index f8d029f..de5f43d 100644 --- a/src/pdata/array_walker.rs +++ b/src/pdata/array_walker.rs @@ -38,7 +38,7 @@ impl<'a, V: Unpack + Copy> BlockValueVisitor<'a, V> { BlockValueVisitor { engine: e, array_visitor: v, - sm: sm, + sm, array_errs: Mutex::new(Vec::new()), } } @@ -58,11 +58,13 @@ impl<'a, V: Unpack + Copy> NodeVisitor for BlockValueVisitor<'a, V> { // The ordering of array indices had been verified in unpack_node(), // thus checking the upper bound implies key continuity among siblings. if *keys.first().unwrap() + keys.len() as u64 != *keys.last().unwrap() + 1 { - return Err(btree::value_err(format!("gaps in array indicies"))); + return Err(btree::value_err("gaps in array indicies".to_string())); } if let Some(end) = kr.end { if *keys.last().unwrap() + 1 != end { - return Err(btree::value_err(format!("gaps or overlaps in array indicies"))); + return Err(btree::value_err( + "gaps or overlaps in array indicies".to_string(), + )); } } @@ -82,7 +84,7 @@ impl<'a, V: Unpack + Copy> NodeVisitor for BlockValueVisitor<'a, V> { Err(_) => { let mut array_errs = self.array_errs.lock().unwrap(); array_errs.push(array::io_err(&path, values[i]).index_context(keys[i])); - }, + } Ok(b) => { path.push(b.loc); match unpack_array_block::(&path, b.get_data()) { @@ -92,13 +94,13 @@ impl<'a, V: Unpack + Copy> NodeVisitor for BlockValueVisitor<'a, V> { } let mut sm = self.sm.lock().unwrap(); sm.inc(b.loc, 1).unwrap(); - }, + } Err(e) => { self.array_errs.lock().unwrap().push(e); } } path.pop(); - }, + } } } } @@ -150,15 +152,11 @@ impl ArrayWalker { where V: Unpack + Copy, { - let w = BTreeWalker::new_with_sm( - self.engine.clone(), - self.sm.clone(), - self.ignore_non_fatal - )?; - let mut path = Vec::new(); - path.push(0); + let w = + BTreeWalker::new_with_sm(self.engine.clone(), self.sm.clone(), self.ignore_non_fatal)?; + let mut path = vec![0]; let v = BlockValueVisitor::::new(self.engine.clone(), self.sm.clone(), visitor); - let btree_err = w.walk(&mut path, &v, root).map_err(|e| ArrayError::BTreeError(e)); + let btree_err = w.walk(&mut path, &v, root).map_err(ArrayError::BTreeError); let mut array_errs = v.array_errs.into_inner().unwrap(); if let Err(e) = btree_err { diff --git a/src/pdata/bitset.rs b/src/pdata/bitset.rs index 82bf633..ef23ea8 100644 --- a/src/pdata/bitset.rs +++ b/src/pdata/bitset.rs @@ -50,11 +50,13 @@ impl BitsetVisitor { impl ArrayVisitor for BitsetVisitor { fn visit(&self, index: u64, b: ArrayBlock) -> array::Result<()> { - let mut begin = index as usize * (b.header.max_entries as usize) << 6; + let mut begin = (index as usize * (b.header.max_entries as usize)) << 6; for i in 0..b.header.nr_entries as usize { if begin > self.nr_entries as usize { - return Err(array::value_err("bitset size exceeds expectation".to_string())); + return Err(array::value_err( + "bitset size exceeds expectation".to_string(), + )); } let end: usize = std::cmp::min(begin + 64, self.nr_entries as usize); @@ -77,7 +79,7 @@ pub fn read_bitset( root: u64, nr_entries: usize, ignore_none_fatal: bool, -)-> (CheckedBitSet, Option) { +) -> (CheckedBitSet, Option) { let w = ArrayWalker::new(engine, ignore_none_fatal); let mut v = BitsetVisitor::new(nr_entries); let err = w.walk(&mut v, root); @@ -85,7 +87,7 @@ pub fn read_bitset( Ok(()) => None, Err(e) => Some(e), }; - return (v.get_bitset(), e); + (v.get_bitset(), e) } // TODO: multi-threaded is possible @@ -95,7 +97,7 @@ pub fn read_bitset_with_sm( nr_entries: usize, sm: Arc>, ignore_none_fatal: bool, -)-> array::Result<(CheckedBitSet, Option)> { +) -> array::Result<(CheckedBitSet, Option)> { let w = ArrayWalker::new_with_sm(engine, sm, ignore_none_fatal)?; let mut v = BitsetVisitor::new(nr_entries); let err = w.walk(&mut v, root); @@ -103,5 +105,5 @@ pub fn read_bitset_with_sm( Ok(()) => None, Err(e) => Some(e), }; - return Ok((v.get_bitset(), e)); + Ok((v.get_bitset(), e)) } diff --git a/src/pdata/btree.rs b/src/pdata/btree.rs index 8f72856..14105a9 100644 --- a/src/pdata/btree.rs +++ b/src/pdata/btree.rs @@ -560,7 +560,10 @@ pub fn unpack_node( for k in &keys { if let Some(l) = last { if k <= l { - return Err(node_err(&path, &format!("keys out of order: {} <= {}", k, l))); + return Err(node_err( + &path, + &format!("keys out of order: {} <= {}", k, l), + )); } } diff --git a/src/pdata/btree_builder.rs b/src/pdata/btree_builder.rs index 93242bc..3fad55e 100644 --- a/src/pdata/btree_builder.rs +++ b/src/pdata/btree_builder.rs @@ -138,7 +138,7 @@ pub struct WriteResult { /// Write a node to a free metadata block. fn write_node_(w: &mut WriteBatcher, mut node: Node) -> Result { let keys = node.get_keys(); - let first_key = keys.first().unwrap_or(&0u64).clone(); + let first_key = *keys.first().unwrap_or(&0u64); let b = w.alloc()?; node.set_block(b.loc); @@ -285,8 +285,8 @@ impl<'a, V: Pack + Unpack + Clone> NodeBuilder { /// Any shared nodes that are used have their block incremented in /// the space map. Will only increment the ref count for values /// contained in the nodes if it unpacks them. - pub fn push_nodes(&mut self, w: &mut WriteBatcher, nodes: &Vec) -> Result<()> { - assert!(nodes.len() > 0); + pub fn push_nodes(&mut self, w: &mut WriteBatcher, nodes: &[NodeSummary]) -> Result<()> { + assert!(!nodes.is_empty()); // As a sanity check we make sure that all the shared nodes contain the // minimum nr of entries. @@ -298,7 +298,7 @@ impl<'a, V: Pack + Unpack + Clone> NodeBuilder { } // Decide if we're going to use the pre-built nodes. - if (self.values.len() > 0) && (self.values.len() < half_full) { + if !self.values.is_empty() && (self.values.len() < half_full) { // To avoid writing an under populated node we have to grab some // values from the first of the shared nodes. let (keys, values) = self.read_node(w, nodes.get(0).unwrap().block)?; @@ -336,7 +336,7 @@ impl<'a, V: Pack + Unpack + Clone> NodeBuilder { pub fn complete(mut self, w: &mut WriteBatcher) -> Result> { let half_full = self.max_entries_per_node / 2; - if (self.values.len() > 0) && (self.values.len() < half_full) && (self.nodes.len() > 0) { + if !self.values.is_empty() && (self.values.len() < half_full) && !self.nodes.is_empty() { // We don't have enough values to emit a node. So we're going to // have to rebalance with the previous node. self.unshift_node(w)?; @@ -344,7 +344,7 @@ impl<'a, V: Pack + Unpack + Clone> NodeBuilder { self.emit_all(w)?; - if self.nodes.len() == 0 { + if self.nodes.is_empty() { self.emit_empty_leaf(w)? } @@ -461,7 +461,7 @@ impl Builder { self.leaf_builder.push_value(w, k, v) } - pub fn push_leaves(&mut self, w: &mut WriteBatcher, leaves: &Vec) -> Result<()> { + pub fn push_leaves(&mut self, w: &mut WriteBatcher, leaves: &[NodeSummary]) -> Result<()> { self.leaf_builder.push_nodes(w, leaves) } diff --git a/src/pdata/btree_walker.rs b/src/pdata/btree_walker.rs index 3de7c85..801f1cd 100644 --- a/src/pdata/btree_walker.rs +++ b/src/pdata/btree_walker.rs @@ -69,10 +69,7 @@ impl BTreeWalker { fn failed(&self, b: u64) -> Option { let fails = self.fails.lock().unwrap(); - match fails.get(&b) { - None => None, - Some(e) => Some(e.clone()), - } + fails.get(&b).cloned() } fn set_fail(&self, b: u64, err: BTreeError) { diff --git a/src/pdata/space_map_checker.rs b/src/pdata/space_map_checker.rs index dc41bc4..9a944a1 100644 --- a/src/pdata/space_map_checker.rs +++ b/src/pdata/space_map_checker.rs @@ -45,8 +45,10 @@ impl<'a> NodeVisitor for OverflowChecker<'a> { let v = values[n]; let expected = self.sm.get(k).unwrap(); if expected != v { - return Err(value_err(format!("Bad reference count for {} block {}. Expected {}, but space map contains {}.", - self.kind, k, expected, v))); + return Err(value_err(format!( + "Bad reference count for {} block {}. Expected {}, but space map contains {}.", + self.kind, k, expected, v + ))); } } @@ -76,10 +78,10 @@ fn inc_entries(sm: &ASpaceMap, entries: &[IndexEntry]) -> Result<()> { // Compare the refernece counts in bitmaps against the expected values // // `sm` - The in-core space map of expected reference counts -fn check_low_ref_counts<'a>( +fn check_low_ref_counts( engine: Arc, report: Arc, - kind: &'a str, + kind: &str, entries: Vec, sm: ASpaceMap, ) -> Result> { @@ -215,7 +217,12 @@ pub fn check_disk_space_map( metadata_sm: ASpaceMap, ignore_non_fatal: bool, ) -> Result> { - let entries = gather_disk_index_entries(engine.clone(), root.bitmap_root, metadata_sm.clone(), ignore_non_fatal)?; + let entries = gather_disk_index_entries( + engine.clone(), + root.bitmap_root, + metadata_sm.clone(), + ignore_non_fatal, + )?; // check overflow ref-counts { @@ -239,8 +246,15 @@ pub fn check_metadata_space_map( metadata_sm: ASpaceMap, ignore_non_fatal: bool, ) -> Result> { - count_btree_blocks::(engine.clone(), &mut vec![0], root.ref_count_root, metadata_sm.clone(), false)?; - let entries = gather_metadata_index_entries(engine.clone(), root.bitmap_root, metadata_sm.clone())?; + count_btree_blocks::( + engine.clone(), + &mut vec![0], + root.ref_count_root, + metadata_sm.clone(), + false, + )?; + let entries = + gather_metadata_index_entries(engine.clone(), root.bitmap_root, metadata_sm.clone())?; // check overflow ref-counts { @@ -259,7 +273,7 @@ pub fn check_metadata_space_map( pub fn repair_space_map( engine: Arc, entries: Vec, - sm: ASpaceMap + sm: ASpaceMap, ) -> Result<()> { let sm = sm.lock().unwrap(); diff --git a/src/pdata/space_map_disk.rs b/src/pdata/space_map_disk.rs index da2301e..2dee628 100644 --- a/src/pdata/space_map_disk.rs +++ b/src/pdata/space_map_disk.rs @@ -371,7 +371,7 @@ pub fn write_metadata_sm(w: &mut WriteBatcher, sm: &dyn SpaceMap) -> Result Result<()> { } let metadata_root = unpack::(&sb.metadata_sm_root[0..])?; - let mut path = Vec::new(); - path.push(0); + let mut path = vec![0]; // Device details. We read this once to get the number of thin devices, and hence the // maximum metadata ref count. Then create metadata space map, and reread to increment @@ -349,7 +347,10 @@ pub struct CheckMaps { pub data_sm: Arc>, } -pub fn check_with_maps(engine: Arc, report: Arc) -> Result { +pub fn check_with_maps( + engine: Arc, + report: Arc, +) -> Result { let ctx = mk_context(engine.clone(), report.clone())?; report.set_title("Checking thin metadata"); @@ -359,18 +360,12 @@ pub fn check_with_maps(engine: Arc, report: Arc(&sb.metadata_sm_root[0..])?; - let mut path = Vec::new(); - path.push(0); + let mut path = vec![0]; // Device details. We read this once to get the number of thin devices, and hence the // maximum metadata ref count. Then create metadata space map, and reread to increment // the ref counts for that metadata. - let devs = btree_to_map::( - &mut path, - engine.clone(), - false, - sb.details_root, - )?; + let devs = btree_to_map::(&mut path, engine.clone(), false, sb.details_root)?; let nr_devs = devs.len(); let metadata_sm = core_sm(engine.get_nr_blocks(), nr_devs as u32); inc_superblock(&metadata_sm)?; diff --git a/src/thin/dump.rs b/src/thin/dump.rs index db89b6e..47e4b32 100644 --- a/src/thin/dump.rs +++ b/src/thin/dump.rs @@ -255,8 +255,7 @@ fn collect_leaves( let mut w = LeafWalker::new(ctx.engine.clone(), sm.deref_mut(), false); let mut v = CollectLeaves::new(); - let mut path = Vec::new(); - path.push(0); + let mut path = vec![0]; // ctx.report.set_title(&format!("collecting {}", *r)); w.walk::(&mut path, &mut v, *r)?; @@ -323,8 +322,7 @@ fn build_metadata(ctx: &Context, sb: &Superblock) -> Result { report.set_title("Reading superblock"); //let metadata_root = unpack::(&sb.metadata_sm_root[0..])?; //let data_root = unpack::(&sb.data_sm_root[0..])?; - let mut path = Vec::new(); - path.push(0); + let mut path = vec![0]; report.set_title("Reading device details"); let details = btree_to_map::(&mut path, engine.clone(), true, sb.details_root)?; @@ -385,6 +383,7 @@ fn build_metadata(ctx: &Context, sb: &Superblock) -> Result { //------------------------------------------ +#[allow(dead_code)] fn gather_entries(g: &mut Gatherer, es: &[Entry]) { g.new_seq(); for e in es { @@ -399,6 +398,7 @@ fn gather_entries(g: &mut Gatherer, es: &[Entry]) { } } +#[allow(dead_code)] fn entries_to_runs(runs: &BTreeMap>, es: &[Entry]) -> Vec { use Entry::*; @@ -427,6 +427,7 @@ fn entries_to_runs(runs: &BTreeMap>, es: &[Entry]) -> Vec { // FIXME: do we really need to track kr? // FIXME: I think this may be better done as part of restore. +#[allow(dead_code)] fn optimise_metadata(md: Metadata) -> Result { use Entry::*; diff --git a/src/thin/restore.rs b/src/thin/restore.rs index e6a0a15..612dd93 100644 --- a/src/thin/restore.rs +++ b/src/thin/restore.rs @@ -89,7 +89,7 @@ impl<'a> Pass1<'a> { if let Some((name, nodes)) = current { Ok((name, nodes.complete(self.w)?)) } else { - let msg = format!("Unbalanced tag"); + let msg = "Unbalanced tag".to_string(); Err(anyhow!(msg)) } } @@ -154,7 +154,7 @@ impl<'a> MetadataVisitor for Pass1<'a> { } Ok(Visit::Continue) } else { - let msg = format!("Mapping tags must appear within a or tag."); + let msg = "Mapping tags must appear within a or tag.".to_string(); Err(anyhow!(msg)) } } diff --git a/src/thin/superblock.rs b/src/thin/superblock.rs index db7074c..f066032 100644 --- a/src/thin/superblock.rs +++ b/src/thin/superblock.rs @@ -110,14 +110,14 @@ fn pack_superblock(sb: &Superblock, w: &mut W) -> Result<()> { } w.write_u64::(sb.block)?; - w.write_all(&vec![0; UUID_SIZE])?; + w.write_all(&[0; UUID_SIZE])?; w.write_u64::(MAGIC)?; w.write_u32::(sb.version)?; w.write_u32::(sb.time)?; w.write_u64::(sb.transaction_id)?; w.write_u64::(sb.metadata_snap)?; - w.write_all(&vec![0; SPACE_MAP_ROOT_SIZE])?; // data sm root - w.write_all(&vec![0; SPACE_MAP_ROOT_SIZE])?; // metadata sm root + w.write_all(&[0; SPACE_MAP_ROOT_SIZE])?; // data sm root + w.write_all(&[0; SPACE_MAP_ROOT_SIZE])?; // metadata sm root w.write_u64::(sb.mapping_root)?; w.write_u64::(sb.details_root)?; w.write_u32::(sb.data_block_size)?;