Changes corresponding to u128 changes to Bytes

Author: jbaublitz

Cargo.lock

@@ -8,7 +8,7 @@ edition = "2018"
 dbus = {version = "0.8", optional = true}
 clap = "2"
 nix = "0.14"
-devicemapper = "0.28.0"
+devicemapper = { git = "https://github.com/jbaublitz/devicemapper-rs", branch = "u128-bytes" }
 crc = "1"
 byteorder = "1"
 chrono = "0.4"

Cargo.toml

@@ -27,24 +27,20 @@ fn get_properties_shared(
 
     let return_message = message.method_return();
 
-    let return_value: HashMap<String, (bool, Variant<Box<dyn RefArg>>)> =
-        properties
-            .unique()
-            .filter_map(|prop| match prop.as_str() {
-                consts::BLOCKDEV_TOTAL_SIZE_PROP => Some((
-                    prop,
-                    result_to_tuple(blockdev_operation(
-                        m.tree,
-                        object_path.get_name(),
-                        |_, bd| {
-                            Ok((u128::from(*bd.size()) * devicemapper::SECTOR_SIZE as u128)
-                                .to_string())
-                        },
-                    )),
+    let return_value: HashMap<String, (bool, Variant<Box<dyn RefArg>>)> = properties
+        .unique()
+        .filter_map(|prop| match prop.as_str() {
+            consts::BLOCKDEV_TOTAL_SIZE_PROP => Some((
+                prop,
+                result_to_tuple(blockdev_operation(
+                    m.tree,
+                    object_path.get_name(),
+                    |_, bd| Ok((*bd.size()).to_string()),
                 )),
-                _ => None,
-            })
-            .collect();
+            )),
+            _ => None,
+        })
+        .collect();
 
     Ok(vec![return_message.append1(return_value)])
 }

src/dbus_api/blockdev/fetch_properties_2_0/methods.rs

@@ -49,18 +49,15 @@ pub fn get_pool_has_cache(m: &MethodInfo<MTFn<TData>, TData>) -> Result<bool, St
 
 pub fn get_pool_total_size(m: &MethodInfo<MTFn<TData>, TData>) -> Result<String, String> {
     pool_operation(m.tree, m.path.get_name(), |(_, _, pool)| {
-        Ok(
-            (u128::from(*pool.total_physical_size()) * devicemapper::SECTOR_SIZE as u128)
-                .to_string(),
-        )
+        Ok((*pool.total_physical_size().bytes()).to_string())
     })
 }
 
 pub fn get_pool_total_used(m: &MethodInfo<MTFn<TData>, TData>) -> Result<String, String> {
     pool_operation(m.tree, m.path.get_name(), |(_, _, pool)| {
         pool.total_physical_used()
             .map_err(|e| e.to_string())
-            .map(|size| (u128::from(*size) * devicemapper::SECTOR_SIZE as u128).to_string())
+            .map(|size| (*size.bytes()).to_string())
     })
 }
 

src/dbus_api/pool/shared.rs

@@ -46,7 +46,7 @@ impl BlockDev for SimDev {
     }
 
     fn size(&self) -> Sectors {
-        Bytes(IEC::Gi).sectors()
+        Bytes(u128::from(IEC::Gi)).sectors()
     }
 
     fn set_dbus_path(&mut self, path: MaybeDbusPath) {

src/engine/sim_engine/blockdev.rs

@@ -372,7 +372,7 @@ impl BlockDevMgr {
             current_time
         };
 
-        let data_size = Bytes(metadata.len() as u64);
+        let data_size = Bytes(metadata.len() as u128);
         let candidates = self
             .block_devs
             .iter_mut()

src/engine/strat_engine/backstore/blockdevmgr.rs

@@ -34,7 +34,7 @@ use crate::{
     stratis::{ErrorEnum, StratisError, StratisResult},
 };
 
-const MIN_DEV_SIZE: Bytes = Bytes(IEC::Gi);
+const MIN_DEV_SIZE: Bytes = Bytes(IEC::Gi as u128);
 
 // Get information that can be obtained from udev for the block device
 // identified by devnode. Return an error if there was an error finding the

src/engine/strat_engine/backstore/devices.rs

@@ -5,7 +5,9 @@
 use std::{
     self,
     cmp::Ordering,
+    convert::TryInto,
     io::{Read, Seek, SeekFrom},
+    num::TryFromIntError,
 };
 
 use byteorder::{ByteOrder, LittleEndian};
@@ -44,7 +46,7 @@ pub struct MDARegions {
 
 impl MDARegions {
     /// Calculate the offset from start of device for an MDARegion.
-    fn mda_offset(header_size: Bytes, index: usize, per_region_size: Bytes) -> u64 {
+    fn mda_offset(header_size: Bytes, index: usize, per_region_size: Bytes) -> u128 {
         *(header_size + per_region_size * index)
     }
 
@@ -72,11 +74,11 @@ impl MDARegions {
         let region_size = mda_size.region_size();
         let region_size_bytes = region_size.sectors().bytes();
         for region in 0..mda_size::NUM_MDA_REGIONS {
-            f.seek(SeekFrom::Start(MDARegions::mda_offset(
-                header_size,
-                region,
-                region_size_bytes,
-            )))?;
+            f.seek(SeekFrom::Start(
+                MDARegions::mda_offset(header_size, region, region_size_bytes)
+                    .try_into()
+                    .map_err(|e: TryFromIntError| StratisError::Error(e.to_string()))?,
+            ))?;
             f.write_all(&hdr_buf)?;
         }
 
@@ -112,11 +114,11 @@ impl MDARegions {
         // been corrupted, return an error.
         let mut load_a_region = |index: usize| -> StratisResult<Option<MDAHeader>> {
             let mut hdr_buf = [0u8; mda_size::_MDA_REGION_HDR_SIZE];
-            f.seek(SeekFrom::Start(MDARegions::mda_offset(
-                header_size,
-                index,
-                region_size_bytes,
-            )))?;
+            f.seek(SeekFrom::Start(
+                MDARegions::mda_offset(header_size, index, region_size_bytes)
+                    .try_into()
+                    .map_err(|e: TryFromIntError| StratisError::Error(e.to_string()))?,
+            ))?;
             f.read_exact(&mut hdr_buf)?;
             Ok(MDAHeader::from_buf(&hdr_buf)?)
         };
@@ -159,7 +161,7 @@ impl MDARegions {
             ));
         }
 
-        let used = Bytes(data.len() as u64);
+        let used = Bytes(data.len() as u128);
         let max_available = self.max_data_size().bytes();
         if used > max_available {
             let err_msg = format!(
@@ -179,11 +181,11 @@ impl MDARegions {
         // Write data to a region specified by index.
         let region_size = self.region_size.sectors().bytes();
         let mut save_region = |index: usize| -> StratisResult<()> {
-            f.seek(SeekFrom::Start(MDARegions::mda_offset(
-                header_size,
-                index,
-                region_size,
-            )))?;
+            f.seek(SeekFrom::Start(
+                MDARegions::mda_offset(header_size, index, region_size)
+                    .try_into()
+                    .map_err(|e: TryFromIntError| StratisError::Error(e.to_string()))?,
+            ))?;
             f.write_all(&hdr_buf)?;
             f.write_all(data)?;
             f.sync_all()?;
@@ -221,8 +223,10 @@ impl MDARegions {
         // It is an error if the metadata can not be found.
         let mut load_region = |index: usize| -> StratisResult<Vec<u8>> {
             let offset = MDARegions::mda_offset(header_size, index, region_size)
-                + mda_size::_MDA_REGION_HDR_SIZE as u64;
-            f.seek(SeekFrom::Start(offset))?;
+                + mda_size::_MDA_REGION_HDR_SIZE as u128;
+            f.seek(SeekFrom::Start(offset.try_into().map_err(
+                |e: TryFromIntError| StratisError::Error(e.to_string()),
+            )?))?;
             mda.load_region(f)
         };
 
@@ -335,7 +339,7 @@ impl MDAHeader {
                 assert!(secs <= std::i64::MAX as u64);
 
                 Some(MDAHeader {
-                    used: MetaDataSize::new(Bytes(used)),
+                    used: MetaDataSize::new(Bytes(u128::from(used))),
                     last_updated: Utc.timestamp(secs as i64, LittleEndian::read_u32(&buf[24..28])),
                     data_crc: LittleEndian::read_u32(&buf[4..8]),
                 })
@@ -485,7 +489,7 @@ mod tests {
 
             let header = MDAHeader {
                 last_updated: Utc.timestamp(sec, nsec),
-                used: MetaDataSize::new(Bytes(data.len() as u64)),
+                used: MetaDataSize::new(Bytes(data.len() as u128)),
                 data_crc: crc32::checksum_castagnoli(data),
             };
             let buf = header.to_buf();
@@ -507,7 +511,7 @@ mod tests {
 
         let header = MDAHeader {
             last_updated: Utc::now(),
-            used: MetaDataSize::new(Bytes(data.len() as u64)),
+            used: MetaDataSize::new(Bytes(data.len() as u128)),
             data_crc: crc32::checksum_castagnoli(&data),
         };
         let mut buf = header.to_buf();

src/engine/strat_engine/backstore/metadata/mda.rs

@@ -48,7 +48,7 @@ pub mod mda_size {
     use devicemapper::{Bytes, Sectors};
 
     pub const _MDA_REGION_HDR_SIZE: usize = 32;
-    const MDA_REGION_HDR_SIZE: Bytes = Bytes(_MDA_REGION_HDR_SIZE as u64);
+    const MDA_REGION_HDR_SIZE: Bytes = Bytes(_MDA_REGION_HDR_SIZE as u128);
 
     // The minimum size allocated for variable length metadata
     pub const MIN_MDA_DATA_REGION_SIZE: Bytes = Bytes(260_064);

src/engine/strat_engine/backstore/metadata/sizes.rs

@@ -476,11 +476,11 @@ pub mod tests {
         let pool_uuid = Uuid::new_v4();
         let dev_uuid = Uuid::new_v4();
         let mda_size = MDADataSize::new(
-            MDADataSize::default().bytes() + Bytes(u64::from(mda_size_factor * 4)),
+            MDADataSize::default().bytes() + Bytes(u128::from(mda_size_factor * 4)),
         )
         .region_size()
         .mda_size();
-        let blkdev_size = (Bytes(IEC::Mi) + Sectors(blkdev_size).bytes()).sectors();
+        let blkdev_size = (Bytes(IEC::Mi as u128) + Sectors(blkdev_size).bytes()).sectors();
         StaticHeader::new(
             StratisIdentifiers::new(pool_uuid, dev_uuid),
             mda_size,

src/engine/strat_engine/backstore/metadata/static_header.rs

@@ -5,8 +5,10 @@
 // Functions for dealing with devices.
 
 use std::{
+    convert::TryInto,
     fs::{File, OpenOptions},
     io::{self, BufWriter, Cursor, Seek, SeekFrom, Write},
+    num::TryFromIntError,
     os::unix::prelude::AsRawFd,
     path::Path,
 };
@@ -33,7 +35,7 @@ pub fn blkdev_size(file: &File) -> StratisResult<Bytes> {
 
     match unsafe { blkgetsize64(file.as_raw_fd(), &mut val) } {
         Err(x) => Err(StratisError::Nix(x)),
-        Ok(_) => Ok(Bytes(val)),
+        Ok(_) => Ok(Bytes(u128::from(val))),
     }
 }
 
@@ -82,7 +84,9 @@ pub fn write_sectors<P: AsRef<Path>>(
     let mut f =
         BufWriter::with_capacity(IEC::Mi as usize, OpenOptions::new().write(true).open(path)?);
 
-    f.seek(SeekFrom::Start(*offset.bytes()))?;
+    f.seek(SeekFrom::Start((*offset.bytes()).try_into().map_err(
+        |e: TryFromIntError| StratisError::Error(e.to_string()),
+    )?))?;
     for _ in 0..*length {
         f.write_all(buf)?;
     }

src/engine/strat_engine/device.rs

@@ -790,7 +790,7 @@ mod tests {
             let buf = &[1u8; SECTOR_SIZE];
 
             let mut amount_written = Sectors(0);
-            let buffer_length = Bytes(buffer_length).sectors();
+            let buffer_length = Bytes(u128::from(buffer_length)).sectors();
             while pool.thin_pool.extend_state() == PoolExtendState::Good
                 && pool.thin_pool.state() == PoolState::Running
             {
@@ -816,7 +816,11 @@ mod tests {
     #[test]
     pub fn loop_test_add_datadevs() {
         loopbacked::test_with_spec(
-            &loopbacked::DeviceLimits::Range(2, 3, Some((4u64 * Bytes(IEC::Gi)).sectors())),
+            &loopbacked::DeviceLimits::Range(
+                2,
+                3,
+                Some((4u64 * Bytes(u128::from(IEC::Gi))).sectors()),
+            ),
             test_add_datadevs,
         );
     }
@@ -826,8 +830,8 @@ mod tests {
         real::test_with_spec(
             &real::DeviceLimits::AtLeast(
                 2,
-                Some((2u64 * Bytes(IEC::Gi)).sectors()),
-                Some((4u64 * Bytes(IEC::Gi)).sectors()),
+                Some((2u64 * Bytes(u128::from(IEC::Gi))).sectors()),
+                Some((4u64 * Bytes(u128::from(IEC::Gi))).sectors()),
             ),
             test_add_datadevs,
         );

src/engine/strat_engine/pool.rs

@@ -39,7 +39,7 @@ impl LoopTestDev {
     /// Create its backing store of specified size. The file is sparse but
     /// will appear to be zeroed.
     pub fn new(lc: &LoopControl, path: &Path, size: Option<Sectors>) -> LoopTestDev {
-        let size = size.unwrap_or_else(|| Bytes(IEC::Gi).sectors());
+        let size = size.unwrap_or_else(|| Bytes(u128::from(IEC::Gi)).sectors());
 
         let f = OpenOptions::new()
             .read(true)

src/engine/strat_engine/tests/loopbacked.rs

@@ -33,7 +33,12 @@ impl RealTestDev {
     /// Wipe initial MiB to clear metadata.
     pub fn new(dev: Either<PathBuf, LinearDev>) -> RealTestDev {
         let test_dev = RealTestDev { dev };
-        wipe_sectors(test_dev.as_path(), Sectors(0), Bytes(IEC::Mi).sectors()).unwrap();
+        wipe_sectors(
+            test_dev.as_path(),
+            Sectors(0),
+            Bytes(u128::from(IEC::Mi)).sectors(),
+        )
+        .unwrap();
         test_dev
     }
 
@@ -44,7 +49,12 @@ impl RealTestDev {
 
     /// Teardown a real test dev
     fn teardown(self) {
-        wipe_sectors(&self.as_path(), Sectors(0), Bytes(IEC::Mi).sectors()).unwrap();
+        wipe_sectors(
+            &self.as_path(),
+            Sectors(0),
+            Bytes(u128::from(IEC::Mi)).sectors(),
+        )
+        .unwrap();
         if let Some(mut ld) = self.dev.right() {
             ld.teardown(get_dm()).unwrap();
         }
@@ -88,7 +98,7 @@ fn get_device_runs<'a>(
         }
     };
 
-    let min_size = min_size.unwrap_or_else(|| Bytes(IEC::Gi).sectors());
+    let min_size = min_size.unwrap_or_else(|| Bytes(u128::from(IEC::Gi)).sectors());
 
     assert!(max_size.is_none() || Some(min_size) <= max_size);
 

src/engine/strat_engine/tests/real.rs

@@ -356,7 +356,7 @@ pub fn fs_usage(mount_point: &Path) -> StratisResult<(Bytes, Bytes)> {
         stat.blocks_free() as u64,
     );
     Ok((
-        Bytes(block_size * blocks),
-        Bytes(block_size * (blocks - blocks_free)),
+        Bytes(u128::from(block_size * blocks)),
+        Bytes(u128::from(block_size * (blocks - blocks_free))),
     ))
 }