Have dm methods return raw values instead of Sectors

For more rawness and better encapsulation.

Signed-off-by: mulhern <amulhern@redhat.com>

Author: mulkieran

src/cachedev.rs

@@ -7,17 +7,15 @@ use std::fmt;
 use std::path::PathBuf;
 use std::str::FromStr;
 
-use crate::core::{
-    DataBlocks, DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, MetaBlocks, Sectors,
-    TargetTypeBuf, DM,
-};
+use crate::core::{DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, TargetTypeBuf, DM};
 use crate::lineardev::{LinearDev, LinearDevTargetParams};
 use crate::result::{DmError, DmResult, ErrorEnum};
 use crate::shared::{
     device_create, device_exists, device_match, get_status_line_fields,
     make_unexpected_value_error, parse_device, parse_value, DmDevice, TargetLine, TargetParams,
     TargetTable,
 };
+use crate::units::{DataBlocks, MetaBlocks, Sectors};
 
 const CACHE_TARGET_NAME: &str = "cache";
 
@@ -190,7 +188,7 @@ impl fmt::Display for CacheDevTargetTable {
 
 impl TargetTable for CacheDevTargetTable {
     fn from_raw_table(
-        table: &[(Sectors, Sectors, TargetTypeBuf, String)],
+        table: &[(u64, u64, TargetTypeBuf, String)],
     ) -> DmResult<CacheDevTargetTable> {
         if table.len() != 1 {
             let err_msg = format!(
@@ -201,13 +199,13 @@ impl TargetTable for CacheDevTargetTable {
         }
         let line = table.first().expect("table.len() == 1");
         Ok(CacheDevTargetTable::new(
-            line.0,
-            line.1,
+            Sectors(line.0),
+            Sectors(line.1),
             format!("{} {}", line.2.to_string(), line.3).parse::<CacheTargetParams>()?,
         ))
     }
 
-    fn to_raw_table(&self) -> Vec<(Sectors, Sectors, TargetTypeBuf, String)> {
+    fn to_raw_table(&self) -> Vec<(u64, u64, TargetTypeBuf, String)> {
         to_raw_table_unique!(self)
     }
 }

src/core/dm.rs

@@ -11,8 +11,7 @@ use nix::libc::c_ulong;
 use nix::libc::ioctl as nix_ioctl;
 
 use crate::core::{
-    DevId, Device, DeviceInfo, DmFlags, DmName, DmNameBuf, DmOptions, DmUuid, Sectors,
-    TargetTypeBuf,
+    DevId, Device, DeviceInfo, DmFlags, DmName, DmNameBuf, DmOptions, DmUuid, TargetTypeBuf,
 };
 use crate::result::{DmError, DmResult};
 
@@ -401,7 +400,7 @@ impl DM {
         &self,
         id: &DevId,
         options: &DmOptions,
-    ) -> DmResult<(DeviceInfo, Vec<(Sectors, Sectors, TargetTypeBuf, String)>)> {
+    ) -> DmResult<(DeviceInfo, Vec<(u64, u64, TargetTypeBuf, String)>)> {
         let mut hdr = options.to_ioctl_hdr(Some(id), DmFlags::DM_QUERY_INACTIVE_TABLE);
 
         let data_out = self.do_ioctl(dmi::DM_DEV_WAIT_CMD as u8, &mut hdr, None)?;
@@ -423,14 +422,14 @@ impl DM {
     /// # Example
     ///
     /// ```no_run
-    /// use devicemapper::{DM, DevId, DmName, Sectors, TargetTypeBuf};
+    /// use devicemapper::{DM, DevId, DmName, TargetTypeBuf};
     /// let dm = DM::new().unwrap();
     ///
     /// // Create a 16MiB device (32768 512-byte sectors) that maps to /dev/sdb1
     /// // starting 1MiB into sdb1
     /// let table = vec![(
-    ///     Sectors(0),
-    ///     Sectors(32768),
+    ///     0,
+    ///     32768,
     ///     TargetTypeBuf::new("linear".into()).expect("valid"),
     ///     "/dev/sdb1 2048".into()
     /// )];
@@ -442,16 +441,16 @@ impl DM {
     pub fn table_load(
         &self,
         id: &DevId,
-        targets: &[(Sectors, Sectors, TargetTypeBuf, String)],
+        targets: &[(u64, u64, TargetTypeBuf, String)],
     ) -> DmResult<DeviceInfo> {
         let mut targs = Vec::new();
 
         // Construct targets first, since we need to know how many & size
         // before initializing the header.
         for t in targets {
             let mut targ: dmi::Struct_dm_target_spec = Default::default();
-            targ.sector_start = *t.0;
-            targ.length = *t.1;
+            targ.sector_start = t.0;
+            targ.length = t.1;
             targ.status = 0;
 
             let dst: &mut [u8] = unsafe { &mut *(&mut targ.target_type[..] as *mut [u8]) };
@@ -554,10 +553,7 @@ impl DM {
     // will either be backwards-compatible, or will increment
     // DM_VERSION_MAJOR.  Since calls made with a non-matching major version
     // will fail, this protects against callers parsing unknown formats.
-    fn parse_table_status(
-        count: u32,
-        buf: &[u8],
-    ) -> Vec<(Sectors, Sectors, TargetTypeBuf, String)> {
+    fn parse_table_status(count: u32, buf: &[u8]) -> Vec<(u64, u64, TargetTypeBuf, String)> {
         let mut targets = Vec::new();
         if !buf.is_empty() {
             let mut next_off = 0;
@@ -584,8 +580,8 @@ impl DM {
                 };
 
                 targets.push((
-                    Sectors(targ.sector_start),
-                    Sectors(targ.length),
+                    targ.sector_start,
+                    targ.length,
                     TargetTypeBuf::new(target_type).expect("< sizeof target_spec"),
                     params,
                 ));
@@ -629,7 +625,7 @@ impl DM {
         &self,
         id: &DevId,
         options: &DmOptions,
-    ) -> DmResult<(DeviceInfo, Vec<(Sectors, Sectors, TargetTypeBuf, String)>)> {
+    ) -> DmResult<(DeviceInfo, Vec<(u64, u64, TargetTypeBuf, String)>)> {
         let mut hdr = options.to_ioctl_hdr(
             Some(id),
             DmFlags::DM_NOFLUSH | DmFlags::DM_STATUS_TABLE | DmFlags::DM_QUERY_INACTIVE_TABLE,
@@ -683,13 +679,13 @@ impl DM {
     pub fn target_msg(
         &self,
         id: &DevId,
-        sector: Option<Sectors>,
+        sector: Option<u64>,
         msg: &str,
     ) -> DmResult<(DeviceInfo, Option<String>)> {
         let mut hdr = DmOptions::new().to_ioctl_hdr(Some(id), DmFlags::empty());
 
         let mut msg_struct: dmi::Struct_dm_target_msg = Default::default();
-        msg_struct.sector = *sector.unwrap_or_default();
+        msg_struct.sector = sector.unwrap_or_default();
         let mut data_in = unsafe {
             let ptr = &msg_struct as *const dmi::Struct_dm_target_msg as *mut u8;
             slice::from_raw_parts(ptr, size_of::<dmi::Struct_dm_target_msg>()).to_vec()

src/core/mod.rs

@@ -19,7 +19,4 @@ pub use self::deviceinfo::DeviceInfo;
 pub use self::dm::DM;
 pub use self::dm_flags::{DmCookie, DmFlags};
 pub use self::dm_options::DmOptions;
-pub use self::types::{
-    Bytes, DataBlocks, DevId, DmName, DmNameBuf, DmUuid, DmUuidBuf, MetaBlocks, Sectors,
-    TargetType, TargetTypeBuf, SECTOR_SIZE,
-};
+pub use self::types::{DevId, DmName, DmNameBuf, DmUuid, DmUuidBuf, TargetType, TargetTypeBuf};

src/core/types.rs

@@ -4,67 +4,13 @@
 
 use std::borrow::Borrow;
 use std::fmt;
-use std::iter::Sum;
-use std::ops::{Add, Deref, Div, Mul, Rem};
-
-use serde;
+use std::ops::Deref;
 
 use crate::result::{DmError, DmResult};
 
 use crate::core::deviceinfo::{DM_NAME_LEN, DM_UUID_LEN};
 use crate::core::errors::ErrorKind;
 
-/// disk sector size in bytes
-pub const SECTOR_SIZE: usize = 512;
-
-/// a kernel defined block size constant for any DM meta device
-/// a DM meta device may store cache device or thinpool device metadata
-/// defined in drivers/md/persistent-data/dm-space-map-metadata.h as
-/// DM_SM_METADATA_BLOCK_SIZE.
-const META_BLOCK_SIZE: Sectors = Sectors(8);
-
-/// The maximum size of a metadata device.
-/// defined in drivers/md/persistent-data/dm-space-map-metadata.h as
-/// DM_SM_METADATA_MAX_BLOCKS.
-/// As far as I can tell, this is not a limit on the size of a designated
-/// metadata device, but instead on the possible usage of that device.
-#[allow(dead_code)]
-const MAX_META_DEV_SIZE: MetaBlocks = MetaBlocks(255 * ((1 << 14) - 64));
-
-range!(DataBlocks, "data blocks");
-
-range!(MetaBlocks, "meta blocks");
-
-impl MetaBlocks {
-    /// Return the number of Sectors in the MetaBlocks.
-    pub fn sectors(self) -> Sectors {
-        self.0 * META_BLOCK_SIZE
-    }
-}
-
-range!(Bytes, "bytes");
-
-impl Bytes {
-    /// Return the number of Sectors fully contained in these bytes.
-    pub fn sectors(self) -> Sectors {
-        Sectors(self.0 / SECTOR_SIZE as u64)
-    }
-}
-
-range!(Sectors, "sectors");
-
-impl Sectors {
-    /// The number of bytes in these sectors.
-    pub fn bytes(self) -> Bytes {
-        Bytes(self.0 * SECTOR_SIZE as u64)
-    }
-
-    /// The number of whole metablocks contained in these sectors.
-    pub fn metablocks(self) -> MetaBlocks {
-        MetaBlocks(self / META_BLOCK_SIZE)
-    }
-}
-
 /// A devicemapper name. Really just a string, but also the argument type of
 /// DevId::Name. Used in function arguments to indicate that the function
 /// takes only a name, not a devicemapper uuid.

src/lib.rs

@@ -117,6 +117,8 @@ mod thindev;
 mod thindevid;
 /// thinpooldev is shared space for  other thin provisioned devices to use
 mod thinpooldev;
+/// representation of units used by the outer layers
+mod units;
 
 #[cfg(test)]
 mod loopbacked;
@@ -130,8 +132,8 @@ pub use crate::cachedev::{
 };
 pub use crate::consts::IEC;
 pub use crate::core::{
-    devnode_to_devno, Bytes, DataBlocks, DevId, Device, DmCookie, DmFlags, DmName, DmNameBuf,
-    DmOptions, DmUuid, DmUuidBuf, MetaBlocks, Sectors, TargetType, TargetTypeBuf, DM, SECTOR_SIZE,
+    devnode_to_devno, DevId, Device, DmCookie, DmFlags, DmName, DmNameBuf, DmOptions, DmUuid,
+    DmUuidBuf, TargetType, TargetTypeBuf, DM,
 };
 pub use crate::lineardev::{
     FlakeyTargetParams, LinearDev, LinearDevTargetParams, LinearDevTargetTable, LinearTargetParams,
@@ -144,3 +146,4 @@ pub use crate::thinpooldev::{
     ThinPoolDev, ThinPoolNoSpacePolicy, ThinPoolStatus, ThinPoolStatusSummary, ThinPoolUsage,
     ThinPoolWorkingStatus,
 };
+pub use crate::units::{Bytes, DataBlocks, MetaBlocks, Sectors, SECTOR_SIZE};

src/lineardev.rs

@@ -7,14 +7,13 @@ use std::fmt;
 use std::path::PathBuf;
 use std::str::FromStr;
 
-use crate::core::{
-    DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, Sectors, TargetTypeBuf, DM,
-};
+use crate::core::{DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, TargetTypeBuf, DM};
 use crate::result::{DmError, DmResult, ErrorEnum};
 use crate::shared::{
     device_create, device_exists, device_match, parse_device, parse_value, DmDevice, TargetLine,
     TargetParams, TargetTable,
 };
+use crate::units::Sectors;
 
 const FLAKEY_TARGET_NAME: &str = "flakey";
 const LINEAR_TARGET_NAME: &str = "linear";
@@ -325,29 +324,29 @@ impl fmt::Display for LinearDevTargetTable {
 
 impl TargetTable for LinearDevTargetTable {
     fn from_raw_table(
-        table: &[(Sectors, Sectors, TargetTypeBuf, String)],
+        table: &[(u64, u64, TargetTypeBuf, String)],
     ) -> DmResult<LinearDevTargetTable> {
         Ok(LinearDevTargetTable {
             table: table
                 .iter()
                 .map(|x| -> DmResult<TargetLine<LinearDevTargetParams>> {
                     Ok(TargetLine::new(
-                        x.0,
-                        x.1,
+                        Sectors(x.0),
+                        Sectors(x.1),
                         format!("{} {}", x.2.to_string(), x.3).parse::<LinearDevTargetParams>()?,
                     ))
                 })
                 .collect::<DmResult<Vec<_>>>()?,
         })
     }
 
-    fn to_raw_table(&self) -> Vec<(Sectors, Sectors, TargetTypeBuf, String)> {
+    fn to_raw_table(&self) -> Vec<(u64, u64, TargetTypeBuf, String)> {
         self.table
             .iter()
             .map(|x| {
                 (
-                    x.start,
-                    x.length,
+                    *x.start,
+                    *x.length,
                     x.params.target_type(),
                     x.params.param_str(),
                 )

src/loopbacked.rs

@@ -13,8 +13,8 @@ use nix;
 use tempfile::{self, TempDir};
 
 use crate::consts::IEC;
-use crate::core::{Bytes, Sectors, SECTOR_SIZE};
 use crate::test_lib::clean_up;
+use crate::units::{Bytes, Sectors, SECTOR_SIZE};
 
 /// send IOCTL via blkgetsize64
 ioctl_read!(blkgetsize64, 0x12, 114, u64);

src/shared.rs

@@ -10,10 +10,11 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 
 use crate::core::{
-    devnode_to_devno, DevId, Device, DeviceInfo, DmFlags, DmName, DmOptions, DmUuid, Sectors,
-    TargetTypeBuf, DM,
+    devnode_to_devno, DevId, Device, DeviceInfo, DmFlags, DmName, DmOptions, DmUuid, TargetTypeBuf,
+    DM,
 };
 use crate::result::{DmError, DmResult, ErrorEnum};
+use crate::units::Sectors;
 
 /// The trait for properties of the params string of TargetType
 pub trait TargetParams: Clone + fmt::Debug + fmt::Display + Eq + FromStr + PartialEq {
@@ -48,10 +49,10 @@ impl<T: TargetParams> TargetLine<T> {
 
 pub trait TargetTable: Clone + fmt::Debug + fmt::Display + Eq + PartialEq + Sized {
     /// Constructs a table from a raw table returned by DM::table_status()
-    fn from_raw_table(table: &[(Sectors, Sectors, TargetTypeBuf, String)]) -> DmResult<Self>;
+    fn from_raw_table(table: &[(u64, u64, TargetTypeBuf, String)]) -> DmResult<Self>;
 
     /// Generates a table that can be loaded by DM::table_load()
-    fn to_raw_table(&self) -> Vec<(Sectors, Sectors, TargetTypeBuf, String)>;
+    fn to_raw_table(&self) -> Vec<(u64, u64, TargetTypeBuf, String)>;
 }
 
 /// A trait capturing some shared properties of DM devices.

src/shared_macros.rs

@@ -34,8 +34,8 @@ macro_rules! devnode {
 macro_rules! to_raw_table_unique {
     ($s:ident) => {
         vec![(
-            $s.table.start,
-            $s.table.length,
+            *$s.table.start,
+            *$s.table.length,
             $s.table.params.target_type(),
             $s.table.params.param_str(),
         )]