diff --git a/src/bin/utils/predict_usage.rs b/src/bin/utils/predict_usage.rs index a7757fa4b5..f9c5f80d81 100644 --- a/src/bin/utils/predict_usage.rs +++ b/src/bin/utils/predict_usage.rs @@ -13,7 +13,10 @@ use serde_json::{json, Value}; use devicemapper::{Bytes, Sectors}; -use stratisd::engine::{crypt_metadata_size, integrity_meta_space, ThinPoolSizeParams, BDA}; +use stratisd::engine::{ + crypt_metadata_size, integrity_meta_space, ThinPoolSizeParams, BDA, + DEFAULT_INTEGRITY_BLOCK_SIZE, DEFAULT_INTEGRITY_JOURNAL_SIZE, DEFAULT_INTEGRITY_TAG_SIZE, +}; // 2^FS_SIZE_START_POWER is the logical size of the smallest Stratis // filesystem for which usage data exists in FSSizeLookup::internal, i.e., @@ -168,7 +171,12 @@ fn predict_pool_metadata_usage(device_sizes: Vec) -> Result, + integrity_journal_size: Option, + integrity_tag_size: Option, ) -> StratisResult { - let data_tier = DataTier::::new(BlockDevMgr::::initialize( - pool_uuid, - devices, - mda_data_size, - )?); + let data_tier = DataTier::::new( + BlockDevMgr::::initialize(pool_uuid, devices, mda_data_size)?, + integrity_journal_size, + None, + integrity_tag_size, + ); let mut backstore = Backstore { data_tier, @@ -1248,8 +1252,15 @@ mod tests { let initdatadevs = get_devices(initdatapaths).unwrap(); let initcachedevs = get_devices(initcachepaths).unwrap(); - let mut backstore = - Backstore::initialize(pool_uuid, initdatadevs, MDADataSize::default(), None).unwrap(); + let mut backstore = Backstore::initialize( + pool_uuid, + initdatadevs, + MDADataSize::default(), + None, + None, + None, + ) + .unwrap(); invariant(&backstore); @@ -1340,8 +1351,15 @@ mod tests { let devices1 = get_devices(paths1).unwrap(); let devices2 = get_devices(paths2).unwrap(); - let mut backstore = - Backstore::initialize(pool_uuid, devices1, MDADataSize::default(), None).unwrap(); + let mut backstore = Backstore::initialize( + pool_uuid, + devices1, + MDADataSize::default(), + None, + None, + None, + ) + .unwrap(); for path in paths1 { assert_eq!( @@ -1404,6 +1422,8 @@ mod tests { "tang".to_string(), json!({"url": env::var("TANG_URL").expect("TANG_URL env var required"), "stratis:tang:trust_url": true}), ))), + None, + None, ) .unwrap(); backstore.alloc(pool_uuid, &[Sectors(512)]).unwrap(); @@ -1478,6 +1498,8 @@ mod tests { json!({"url": env::var("TANG_URL").expect("TANG_URL env var required"), "stratis:tang:trust_url": true}), ), )), + None, + None, ).unwrap(); cmd::udev_settle().unwrap(); diff --git a/src/engine/strat_engine/backstore/blockdev/mod.rs b/src/engine/strat_engine/backstore/blockdev/mod.rs index 986a2a8a2b..9fa01c99dc 100644 --- a/src/engine/strat_engine/backstore/blockdev/mod.rs +++ b/src/engine/strat_engine/backstore/blockdev/mod.rs @@ -95,17 +95,6 @@ pub trait InternalBlockDev { /// * Otherwise, `Some(_)` fn calc_new_size(&self) -> StratisResult>; - /// Grow the block device if the underlying physical device has grown in size. - /// Return an error and leave the size as is if the device has shrunk. - /// Do nothing if the device is the same size as recorded in the metadata. - /// - /// This method does not need to block IO to the extended crypt device prior - /// to rollback because of per-pool locking. Growing the device will acquire - /// an exclusive lock on the pool and therefore the thin pool cannot be - /// extended to use the larger or unencrypted block device size until the - /// transaction has been completed successfully. - fn grow(&mut self) -> StratisResult; - /// Load the pool-level metadata for the given block device. fn load_state(&self) -> StratisResult, &DateTime)>>; diff --git a/src/engine/strat_engine/backstore/blockdev/v1.rs b/src/engine/strat_engine/backstore/blockdev/v1.rs index f5002cd952..dd628fca0f 100644 --- a/src/engine/strat_engine/backstore/blockdev/v1.rs +++ b/src/engine/strat_engine/backstore/blockdev/v1.rs @@ -336,72 +336,16 @@ impl StratBlockDev { } } - #[cfg(test)] - pub fn invariant(&self) { - assert!(self.total_size() == self.used.size()); - } -} - -impl InternalBlockDev for StratBlockDev { - fn uuid(&self) -> DevUuid { - self.bda.dev_uuid() - } - - fn device(&self) -> &Device { - &self.dev - } - - fn physical_path(&self) -> &Path { - self.devnode() - } - - fn blksizes(&self) -> StratSectorSizes { - self.blksizes - } - - fn metadata_version(&self) -> StratSigblockVersion { - self.bda.sigblock_version() - } - - fn total_size(&self) -> BlockdevSize { - self.bda.dev_size() - } - - fn available(&self) -> Sectors { - self.used.available() - } - - fn metadata_size(&self) -> Sectors { - self.bda.extended_size().sectors() - } - - fn max_stratis_metadata_size(&self) -> MDADataSize { - self.bda.max_data_size() - } - - fn in_use(&self) -> bool { - self.used.used() > self.metadata_size() - } - - fn alloc(&mut self, size: Sectors) -> PerDevSegments { - self.used.alloc_front(size) - } - - fn calc_new_size(&self) -> StratisResult> { - let s = Self::scan_blkdev_size( - self.physical_path(), - self.underlying_device.crypt_handle().is_some(), - )?; - if Some(s) == self.new_size - || (self.new_size.is_none() && s == self.bda.dev_size().sectors()) - { - Ok(None) - } else { - Ok(Some(s)) - } - } - - fn grow(&mut self) -> StratisResult { + /// Grow the block device if the underlying physical device has grown in size. + /// Return an error and leave the size as is if the device has shrunk. + /// Do nothing if the device is the same size as recorded in the metadata. + /// + /// This method does not need to block IO to the extended crypt device prior + /// to rollback because of per-pool locking. Growing the device will acquire + /// an exclusive lock on the pool and therefore the thin pool cannot be + /// extended to use the larger or unencrypted block device size until the + /// transaction has been completed successfully. + pub fn grow(&mut self) -> StratisResult { /// Precondition: size > h.blkdev_size fn needs_rollback(bd: &mut StratBlockDev, size: BlockdevSize) -> StratisResult<()> { let mut f = OpenOptions::new() @@ -472,6 +416,70 @@ impl InternalBlockDev for StratBlockDev { } } } + #[cfg(test)] + pub fn invariant(&self) { + assert!(self.total_size() == self.used.size()); + } +} + +impl InternalBlockDev for StratBlockDev { + fn uuid(&self) -> DevUuid { + self.bda.dev_uuid() + } + + fn device(&self) -> &Device { + &self.dev + } + + fn physical_path(&self) -> &Path { + self.devnode() + } + + fn blksizes(&self) -> StratSectorSizes { + self.blksizes + } + + fn metadata_version(&self) -> StratSigblockVersion { + self.bda.sigblock_version() + } + + fn total_size(&self) -> BlockdevSize { + self.bda.dev_size() + } + + fn available(&self) -> Sectors { + self.used.available() + } + + fn metadata_size(&self) -> Sectors { + self.bda.extended_size().sectors() + } + + fn max_stratis_metadata_size(&self) -> MDADataSize { + self.bda.max_data_size() + } + + fn in_use(&self) -> bool { + self.used.used() > self.metadata_size() + } + + fn alloc(&mut self, size: Sectors) -> PerDevSegments { + self.used.alloc_front(size) + } + + fn calc_new_size(&self) -> StratisResult> { + let s = Self::scan_blkdev_size( + self.physical_path(), + self.underlying_device.crypt_handle().is_some(), + )?; + if Some(s) == self.new_size + || (self.new_size.is_none() && s == self.bda.dev_size().sectors()) + { + Ok(None) + } else { + Ok(Some(s)) + } + } fn load_state(&self) -> StratisResult, &DateTime)>> { let mut f = OpenOptions::new() diff --git a/src/engine/strat_engine/backstore/blockdev/v2.rs b/src/engine/strat_engine/backstore/blockdev/v2.rs index 4c872b0cb6..06c5a745f3 100644 --- a/src/engine/strat_engine/backstore/blockdev/v2.rs +++ b/src/engine/strat_engine/backstore/blockdev/v2.rs @@ -14,7 +14,7 @@ use std::{ use chrono::{DateTime, Utc}; use serde_json::Value; -use devicemapper::{Bytes, Device, Sectors, IEC}; +use devicemapper::{Bytes, Device, Sectors}; use crate::{ engine::{ @@ -43,14 +43,19 @@ use crate::{ /// Return the amount of space required for integrity for a device of the given size. /// -/// This is a slight overestimation for the sake of simplicity. Because it uses the whole disk +/// This default is a slight overestimation for the sake of simplicity. Because it uses the whole disk /// size, once the integrity metadata size is calculated, the remaining data size is now smaller /// than the metadata region could support for integrity. /// The result is divisible by 8 sectors. -pub fn integrity_meta_space(total_space: Sectors) -> Sectors { +pub fn integrity_meta_space( + total_space: Sectors, + journal_size: Sectors, + block_size: Bytes, + tag_size: Bytes, +) -> Sectors { Bytes(4096).sectors() - + Bytes::from(64 * IEC::Mi).sectors() - + Bytes::from((*total_space * 32u64 + 4095) & !4095).sectors() + + journal_size + + Bytes::from(((*total_space.bytes() / *block_size) * *tag_size + 4095) & !4095).sectors() } #[derive(Debug)] @@ -206,6 +211,61 @@ impl StratBlockDev { } } + /// Grow the block device if the underlying physical device has grown in size. + /// Return an error and leave the size as is if the device has shrunk. + /// Do nothing if the device is the same size as recorded in the metadata. + /// + /// This will also extend integrity metadata reservations according to the new + /// size of the device. + pub fn grow( + &mut self, + integrity_journal_size: Sectors, + integrity_block_size: Bytes, + integrity_tag_size: Bytes, + ) -> StratisResult { + let size = BlockdevSize::new(Self::scan_blkdev_size(self.devnode())?); + let metadata_size = self.bda.dev_size(); + match size.cmp(&metadata_size) { + Ordering::Less => Err(StratisError::Msg( + "The underlying device appears to have shrunk; you may experience data loss" + .to_string(), + )), + Ordering::Equal => Ok(false), + Ordering::Greater => { + let mut f = OpenOptions::new() + .write(true) + .read(true) + .open(self.devnode())?; + let mut h = static_header(&mut f)?.ok_or_else(|| { + StratisError::Msg(format!( + "No static header found on device {}", + self.devnode().display() + )) + })?; + + h.blkdev_size = size; + let h = StaticHeader::write_header(&mut f, h, MetadataLocation::Both)?; + + self.bda.header = h; + self.used.increase_size(size.sectors()); + + let integrity_grow = integrity_meta_space( + size.sectors(), + integrity_journal_size, + integrity_block_size, + integrity_tag_size, + ) - self + .integrity_meta_allocs + .iter() + .map(|(_, len)| *len) + .sum::(); + self.alloc_int_meta_back(integrity_grow); + + Ok(true) + } + } + } + #[cfg(test)] pub fn invariant(&self) { assert!(self.total_size() == self.used.size()); @@ -269,46 +329,6 @@ impl InternalBlockDev for StratBlockDev { } } - fn grow(&mut self) -> StratisResult { - let size = BlockdevSize::new(Self::scan_blkdev_size(self.devnode())?); - let metadata_size = self.bda.dev_size(); - match size.cmp(&metadata_size) { - Ordering::Less => Err(StratisError::Msg( - "The underlying device appears to have shrunk; you may experience data loss" - .to_string(), - )), - Ordering::Equal => Ok(false), - Ordering::Greater => { - let mut f = OpenOptions::new() - .write(true) - .read(true) - .open(self.devnode())?; - let mut h = static_header(&mut f)?.ok_or_else(|| { - StratisError::Msg(format!( - "No static header found on device {}", - self.devnode().display() - )) - })?; - - h.blkdev_size = size; - let h = StaticHeader::write_header(&mut f, h, MetadataLocation::Both)?; - - self.bda.header = h; - self.used.increase_size(size.sectors()); - - let integrity_grow = integrity_meta_space(size.sectors()) - - self - .integrity_meta_allocs - .iter() - .map(|(_, len)| *len) - .sum::(); - self.alloc_int_meta_back(integrity_grow); - - Ok(true) - } - } - } - fn load_state(&self) -> StratisResult, &DateTime)>> { let mut f = OpenOptions::new().read(true).open(&*self.devnode)?; match (self.bda.load_state(&mut f)?, self.bda.last_update_time()) { diff --git a/src/engine/strat_engine/backstore/blockdevmgr.rs b/src/engine/strat_engine/backstore/blockdevmgr.rs index 04525081c3..6a1807886e 100644 --- a/src/engine/strat_engine/backstore/blockdevmgr.rs +++ b/src/engine/strat_engine/backstore/blockdevmgr.rs @@ -165,6 +165,15 @@ impl BlockDevMgr { self.encryption_info().is_some() } + pub fn grow(&mut self, dev: DevUuid) -> StratisResult { + let bd = self + .block_devs + .iter_mut() + .find(|bd| bd.uuid() == dev) + .ok_or_else(|| StratisError::Msg(format!("Block device with UUID {dev} not found")))?; + bd.grow() + } + #[cfg(test)] fn invariant(&self) { let pool_uuids = self @@ -234,6 +243,25 @@ impl BlockDevMgr { Ok(bdev_uuids) } + pub fn grow( + &mut self, + dev: DevUuid, + integrity_journal_size: Sectors, + integrity_block_size: Bytes, + integrity_tag_size: Bytes, + ) -> StratisResult { + let bd = self + .block_devs + .iter_mut() + .find(|bd| bd.uuid() == dev) + .ok_or_else(|| StratisError::Msg(format!("Block device with UUID {dev} not found")))?; + bd.grow( + integrity_journal_size, + integrity_block_size, + integrity_tag_size, + ) + } + #[cfg(test)] fn invariant(&self) { let pool_uuids = self @@ -467,15 +495,6 @@ where self.block_devs.iter().map(|bd| bd.metadata_size()).sum() } - pub fn grow(&mut self, dev: DevUuid) -> StratisResult { - let bd = self - .block_devs - .iter_mut() - .find(|bd| bd.uuid() == dev) - .ok_or_else(|| StratisError::Msg(format!("Block device with UUID {dev} not found")))?; - bd.grow() - } - /// Tear down devicemapper devices for the block devices in this BlockDevMgr. pub fn teardown(&mut self) -> StratisResult<()> { let errs = self.block_devs.iter_mut().fold(Vec::new(), |mut errs, bd| { diff --git a/src/engine/strat_engine/backstore/data_tier.rs b/src/engine/strat_engine/backstore/data_tier.rs index 04fd6fc9b5..b6d4a44065 100644 --- a/src/engine/strat_engine/backstore/data_tier.rs +++ b/src/engine/strat_engine/backstore/data_tier.rs @@ -7,7 +7,7 @@ #[cfg(test)] use std::collections::HashSet; -use devicemapper::Sectors; +use devicemapper::{Bytes, Sectors, IEC}; use crate::{ engine::{ @@ -32,6 +32,10 @@ use crate::{ stratis::StratisResult, }; +pub const DEFAULT_INTEGRITY_JOURNAL_SIZE: Bytes = Bytes(128 * IEC::Mi as u128); +pub const DEFAULT_INTEGRITY_BLOCK_SIZE: Bytes = Bytes(4 * IEC::Ki as u128); +pub const DEFAULT_INTEGRITY_TAG_SIZE: Bytes = Bytes(64u128); + /// Handles the lowest level, base layer of this tier. #[derive(Debug)] pub struct DataTier { @@ -39,6 +43,12 @@ pub struct DataTier { pub(super) block_mgr: BlockDevMgr, /// The list of segments granted by block_mgr and used by dm_device pub(super) segments: AllocatedAbove, + /// Integrity journal size. + integrity_journal_size: Option, + /// Integrity block size. + integrity_block_size: Option, + /// Integrity tag size. + integrity_tag_size: Option, } impl DataTier { @@ -52,6 +62,9 @@ impl DataTier { DataTier { block_mgr, segments: AllocatedAbove { inner: vec![] }, + integrity_journal_size: None, + integrity_block_size: None, + integrity_tag_size: None, } } @@ -97,6 +110,10 @@ impl DataTier { pub fn blockdevs_mut(&mut self) -> Vec<(DevUuid, &mut v1::StratBlockDev)> { self.block_mgr.blockdevs_mut() } + + pub fn grow(&mut self, dev: DevUuid) -> StratisResult { + self.block_mgr.grow(dev) + } } impl DataTier { @@ -105,16 +122,33 @@ impl DataTier { /// Initially 0 segments are allocated. /// /// WARNING: metadata changing event - pub fn new(mut block_mgr: BlockDevMgr) -> DataTier { + pub fn new( + mut block_mgr: BlockDevMgr, + integrity_journal_size: Option, + integrity_block_size: Option, + integrity_tag_size: Option, + ) -> DataTier { + let integrity_journal_size = + integrity_journal_size.unwrap_or_else(|| DEFAULT_INTEGRITY_JOURNAL_SIZE.sectors()); + let integrity_block_size = integrity_block_size.unwrap_or(DEFAULT_INTEGRITY_BLOCK_SIZE); + let integrity_tag_size = integrity_tag_size.unwrap_or(DEFAULT_INTEGRITY_TAG_SIZE); for (_, bd) in block_mgr.blockdevs_mut() { // NOTE: over-allocates integrity metadata slightly. Some of the // total size of the device will not make use of the integrity // metadata. - bd.alloc_int_meta_back(integrity_meta_space(bd.total_size().sectors())); + bd.alloc_int_meta_back(integrity_meta_space( + bd.total_size().sectors(), + integrity_journal_size, + integrity_block_size, + integrity_tag_size, + )); } DataTier { block_mgr, segments: AllocatedAbove { inner: vec![] }, + integrity_journal_size: Some(integrity_journal_size), + integrity_block_size: Some(integrity_block_size), + integrity_tag_size: Some(integrity_tag_size), } } @@ -142,10 +176,10 @@ impl DataTier { assert_eq!(bds.len(), uuids.len()); for bd in bds { bd.alloc_int_meta_back(integrity_meta_space( - // NOTE: Subtracting metadata size works here because the only metadata currently - // recorded in a newly created block device is the BDA. If this becomes untrue in - // the future, this code will no longer work. - bd.total_size().sectors() - bd.metadata_size(), + bd.total_size().sectors(), + self.integrity_journal_size.expect("Must be some in V2"), + self.integrity_block_size.expect("Must be some in V2"), + self.integrity_tag_size.expect("Must be some in V2"), )); } Ok(uuids) @@ -179,6 +213,15 @@ impl DataTier { pub fn blockdevs_mut(&mut self) -> Vec<(DevUuid, &mut v2::StratBlockDev)> { self.block_mgr.blockdevs_mut() } + + pub fn grow(&mut self, dev: DevUuid) -> StratisResult { + self.block_mgr.grow( + dev, + self.integrity_journal_size.expect("Must be Some in V2"), + self.integrity_block_size.expect("Must be Some in V2"), + self.integrity_tag_size.expect("Must be Some in V2"), + ) + } } impl DataTier @@ -207,6 +250,9 @@ where Ok(DataTier { block_mgr, segments, + integrity_journal_size: data_tier_save.integrity_journal_size, + integrity_block_size: data_tier_save.integrity_block_size, + integrity_tag_size: data_tier_save.integrity_tag_size, }) } @@ -265,10 +311,6 @@ where self.block_mgr.load_state() } - pub fn grow(&mut self, dev: DevUuid) -> StratisResult { - self.block_mgr.grow(dev) - } - /// Return the partition of the block devs that are in use and those /// that are not. pub fn partition_by_use(&self) -> BlockDevPartition<'_, B> { @@ -301,6 +343,9 @@ where allocs: vec![self.segments.record()], devs: self.block_mgr.record(), }, + integrity_journal_size: self.integrity_journal_size, + integrity_block_size: self.integrity_block_size, + integrity_tag_size: self.integrity_tag_size, } } } @@ -439,7 +484,7 @@ mod tests { ) .unwrap(); - let mut data_tier = DataTier::::new(mgr); + let mut data_tier = DataTier::::new(mgr, None, None, None); data_tier.invariant(); // A data_tier w/ some devices but nothing allocated diff --git a/src/engine/strat_engine/backstore/mod.rs b/src/engine/strat_engine/backstore/mod.rs index 58add8867b..3311b24253 100644 --- a/src/engine/strat_engine/backstore/mod.rs +++ b/src/engine/strat_engine/backstore/mod.rs @@ -14,6 +14,9 @@ mod shared; pub use self::{ blockdev::v2::integrity_meta_space, + data_tier::{ + DEFAULT_INTEGRITY_BLOCK_SIZE, DEFAULT_INTEGRITY_JOURNAL_SIZE, DEFAULT_INTEGRITY_TAG_SIZE, + }, devices::{find_stratis_devs_by_uuid, get_devno_from_path, ProcessedPathInfos, UnownedDevices}, }; diff --git a/src/engine/strat_engine/mod.rs b/src/engine/strat_engine/mod.rs index f9520dd0a6..2e4a093b74 100644 --- a/src/engine/strat_engine/mod.rs +++ b/src/engine/strat_engine/mod.rs @@ -26,7 +26,10 @@ mod writing; pub use self::{backstore::ProcessedPathInfos, pool::v1::StratPool}; pub use self::{ - backstore::integrity_meta_space, + backstore::{ + integrity_meta_space, DEFAULT_INTEGRITY_BLOCK_SIZE, DEFAULT_INTEGRITY_JOURNAL_SIZE, + DEFAULT_INTEGRITY_TAG_SIZE, + }, crypt::{ crypt_metadata_size, register_clevis_token, set_up_crypt_logging, CLEVIS_TANG_TRUST_URL, }, diff --git a/src/engine/strat_engine/pool/v2.rs b/src/engine/strat_engine/pool/v2.rs index d28c5a1831..8ec0a5b540 100644 --- a/src/engine/strat_engine/pool/v2.rs +++ b/src/engine/strat_engine/pool/v2.rs @@ -159,8 +159,14 @@ impl StratPool { // FIXME: Initializing with the minimum MDA size is not necessarily // enough. If there are enough devices specified, more space will be // required. - let mut backstore = - Backstore::initialize(pool_uuid, devices, MDADataSize::default(), encryption_info)?; + let mut backstore = Backstore::initialize( + pool_uuid, + devices, + MDADataSize::default(), + encryption_info, + None, + None, + )?; let thinpool = ThinPool::::new( pool_uuid, diff --git a/src/engine/strat_engine/serde_structs.rs b/src/engine/strat_engine/serde_structs.rs index a9c907139d..bb23225b44 100644 --- a/src/engine/strat_engine/serde_structs.rs +++ b/src/engine/strat_engine/serde_structs.rs @@ -14,7 +14,7 @@ use serde::{Serialize, Serializer}; -use devicemapper::{Sectors, ThinDevId}; +use devicemapper::{Bytes, Sectors, ThinDevId}; use crate::engine::types::{DevUuid, Features, FilesystemUuid}; @@ -117,6 +117,12 @@ pub struct BackstoreSave { #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)] pub struct DataTierSave { pub blockdev: BlockDevSave, + #[serde(skip_serializing_if = "Option::is_none")] + pub integrity_journal_size: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub integrity_block_size: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub integrity_tag_size: Option, } #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)] diff --git a/src/engine/strat_engine/thinpool/thinpool.rs b/src/engine/strat_engine/thinpool/thinpool.rs index aea8df8a71..d95d72b96d 100644 --- a/src/engine/strat_engine/thinpool/thinpool.rs +++ b/src/engine/strat_engine/thinpool/thinpool.rs @@ -3157,6 +3157,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let size = ThinPoolSizeParams::new(backstore.datatier_usable_size()).unwrap(); @@ -3259,6 +3261,8 @@ mod tests { first_devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new( @@ -3394,6 +3398,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); warn!("Available: {}", backstore.available_in_backstore()); @@ -3519,6 +3525,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new( @@ -3588,6 +3596,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new( @@ -3667,6 +3677,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new( @@ -3733,6 +3745,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new( @@ -3794,6 +3808,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new( @@ -3900,6 +3916,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new( @@ -4038,6 +4056,8 @@ mod tests { devices, MDADataSize::default(), None, + None, + None, ) .unwrap(); let mut pool = ThinPool::::new(