Move TargetType, TargetTypeBuf out of core

Just use in outer layer.

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

Author: mulkieran

src/cachedev.rs

@@ -7,13 +7,13 @@ use std::fmt;
 use std::path::PathBuf;
 use std::str::FromStr;
 
-use crate::core::{DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, TargetTypeBuf, DM};
+use crate::core::{DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, 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,
+    TargetTable, TargetTypeBuf,
 };
 use crate::units::{DataBlocks, MetaBlocks, Sectors};
 
@@ -187,9 +187,7 @@ impl fmt::Display for CacheDevTargetTable {
 }
 
 impl TargetTable for CacheDevTargetTable {
-    fn from_raw_table(
-        table: &[(u64, u64, TargetTypeBuf, String)],
-    ) -> DmResult<CacheDevTargetTable> {
+    fn from_raw_table(table: &[(u64, u64, String, String)]) -> DmResult<CacheDevTargetTable> {
         if table.len() != 1 {
             let err_msg = format!(
                 "CacheDev table should have exactly one line, has {} lines",
@@ -205,7 +203,7 @@ impl TargetTable for CacheDevTargetTable {
         ))
     }
 
-    fn to_raw_table(&self) -> Vec<(u64, u64, TargetTypeBuf, String)> {
+    fn to_raw_table(&self) -> Vec<(u64, u64, String, String)> {
         to_raw_table_unique!(self)
     }
 }

src/core/dm.rs

@@ -10,9 +10,7 @@ use std::{cmp, slice, u32};
 use nix::libc::c_ulong;
 use nix::libc::ioctl as nix_ioctl;
 
-use crate::core::{
-    DevId, Device, DeviceInfo, DmFlags, DmName, DmNameBuf, DmOptions, DmUuid, TargetTypeBuf,
-};
+use crate::core::{DevId, Device, DeviceInfo, DmFlags, DmName, DmNameBuf, DmOptions, DmUuid};
 use crate::result::{DmError, DmResult};
 
 use crate::core::deviceinfo::{DM_NAME_LEN, DM_UUID_LEN};
@@ -400,7 +398,7 @@ impl DM {
         &self,
         id: &DevId,
         options: &DmOptions,
-    ) -> DmResult<(DeviceInfo, Vec<(u64, u64, TargetTypeBuf, String)>)> {
+    ) -> DmResult<(DeviceInfo, Vec<(u64, u64, String, 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)?;
@@ -422,15 +420,15 @@ impl DM {
     /// # Example
     ///
     /// ```no_run
-    /// use devicemapper::{DM, DevId, DmName, TargetTypeBuf};
+    /// use devicemapper::{DM, DevId, DmName};
     /// 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![(
     ///     0,
     ///     32768,
-    ///     TargetTypeBuf::new("linear".into()).expect("valid"),
+    ///     "linear".into(),
     ///     "/dev/sdb1 2048".into()
     /// )];
     ///
@@ -441,7 +439,7 @@ impl DM {
     pub fn table_load(
         &self,
         id: &DevId,
-        targets: &[(u64, u64, TargetTypeBuf, String)],
+        targets: &[(u64, u64, String, String)],
     ) -> DmResult<DeviceInfo> {
         let mut targs = Vec::new();
 
@@ -547,13 +545,15 @@ impl DM {
     /// Panics if there is an error parsing the table.
     /// Trims trailing white space off final entry on each line. This
     /// canonicalization makes checking identity of tables easier.
+    /// Postcondition: The length of the next to last entry in any tuple is
+    /// no more than 16 characters.
     // Justification: If the ioctl succeeded, the data is correct and
     // complete. An error in parsing can only result from a change in the
     // kernel. We rely on DM's interface versioning system. Kernel changes
     // 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<(u64, u64, TargetTypeBuf, String)> {
+    fn parse_table_status(count: u32, buf: &[u8]) -> Vec<(u64, u64, String, String)> {
         let mut targets = Vec::new();
         if !buf.is_empty() {
             let mut next_off = 0;
@@ -579,12 +579,7 @@ impl DM {
                     String::from_utf8_lossy(slc).trim_end().to_owned()
                 };
 
-                targets.push((
-                    targ.sector_start,
-                    targ.length,
-                    TargetTypeBuf::new(target_type).expect("< sizeof target_spec"),
-                    params,
-                ));
+                targets.push((targ.sector_start, targ.length, target_type, params));
 
                 next_off = targ.next as usize;
             }
@@ -625,7 +620,7 @@ impl DM {
         &self,
         id: &DevId,
         options: &DmOptions,
-    ) -> DmResult<(DeviceInfo, Vec<(u64, u64, TargetTypeBuf, String)>)> {
+    ) -> DmResult<(DeviceInfo, Vec<(u64, u64, String, String)>)> {
         let mut hdr = options.to_ioctl_hdr(
             Some(id),
             DmFlags::DM_NOFLUSH | DmFlags::DM_STATUS_TABLE | DmFlags::DM_QUERY_INACTIVE_TABLE,

src/core/mod.rs

@@ -19,4 +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::{DevId, DmName, DmNameBuf, DmUuid, DmUuidBuf, TargetType, TargetTypeBuf};
+pub use self::types::{DevId, DmName, DmNameBuf, DmUuid, DmUuidBuf};

src/core/types.rs

@@ -38,8 +38,3 @@ impl<'a> fmt::Display for DevId<'a> {
         }
     }
 }
-
-/// Number of bytes in Struct_dm_target_spec::target_type field.
-const DM_TARGET_TYPE_LEN: usize = 16;
-
-str_id!(TargetType, TargetTypeBuf, DM_TARGET_TYPE_LEN);

src/lib.rs

@@ -133,13 +133,13 @@ pub use crate::cachedev::{
 pub use crate::consts::IEC;
 pub use crate::core::{
     devnode_to_devno, DevId, Device, DmCookie, DmFlags, DmName, DmNameBuf, DmOptions, DmUuid,
-    DmUuidBuf, TargetType, TargetTypeBuf, DM,
+    DmUuidBuf, DM,
 };
 pub use crate::lineardev::{
     FlakeyTargetParams, LinearDev, LinearDevTargetParams, LinearDevTargetTable, LinearTargetParams,
 };
 pub use crate::result::{DmError, DmResult, ErrorEnum};
-pub use crate::shared::{device_exists, DmDevice, TargetLine};
+pub use crate::shared::{device_exists, DmDevice, TargetLine, TargetType, TargetTypeBuf};
 pub use crate::thindev::{ThinDev, ThinDevWorkingStatus, ThinStatus};
 pub use crate::thindevid::ThinDevId;
 pub use crate::thinpooldev::{

src/lineardev.rs

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

src/shared.rs

@@ -6,16 +6,25 @@
 // devices.
 
 use std::fmt;
+
+use std::borrow::Borrow;
+use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 
 use crate::core::{
-    devnode_to_devno, DevId, Device, DeviceInfo, DmFlags, DmName, DmOptions, DmUuid, TargetTypeBuf,
-    DM,
+    devnode_to_devno, DevId, Device, DeviceInfo, DmFlags, DmName, DmOptions, DmUuid, DM,
 };
 use crate::result::{DmError, DmResult, ErrorEnum};
 use crate::units::Sectors;
 
+use crate::core::errors::ErrorKind;
+
+/// Number of bytes in Struct_dm_target_spec::target_type field.
+const DM_TARGET_TYPE_LEN: usize = 16;
+
+str_id!(TargetType, TargetTypeBuf, DM_TARGET_TYPE_LEN);
+
 /// The trait for properties of the params string of TargetType
 pub trait TargetParams: Clone + fmt::Debug + fmt::Display + Eq + FromStr + PartialEq {
     /// Return the param string only
@@ -49,10 +58,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: &[(u64, u64, TargetTypeBuf, String)]) -> DmResult<Self>;
+    fn from_raw_table(table: &[(u64, u64, String, String)]) -> DmResult<Self>;
 
     /// Generates a table that can be loaded by DM::table_load()
-    fn to_raw_table(&self) -> Vec<(u64, u64, TargetTypeBuf, String)>;
+    fn to_raw_table(&self) -> Vec<(u64, u64, String, String)>;
 }
 
 /// A trait capturing some shared properties of DM devices.

src/shared_macros.rs

@@ -36,7 +36,7 @@ macro_rules! to_raw_table_unique {
         vec![(
             *$s.table.start,
             *$s.table.length,
-            $s.table.params.target_type(),
+            $s.table.params.target_type().to_string(),
             $s.table.params.param_str(),
         )]
     };

src/thindev.rs

@@ -6,13 +6,11 @@ use std::fmt;
 use std::path::PathBuf;
 use std::str::FromStr;
 
-use crate::core::{
-    DevId, Device, DeviceInfo, DmCookie, DmFlags, DmName, DmOptions, DmUuid, TargetTypeBuf, DM,
-};
+use crate::core::{DevId, Device, DeviceInfo, DmCookie, DmFlags, DmName, DmOptions, DmUuid, DM};
 use crate::result::{DmError, DmResult, ErrorEnum};
 use crate::shared::{
     device_create, device_exists, device_match, get_status_line_fields, message, parse_device,
-    parse_value, DmDevice, TargetLine, TargetParams, TargetTable,
+    parse_value, DmDevice, TargetLine, TargetParams, TargetTable, TargetTypeBuf,
 };
 use crate::thindevid::ThinDevId;
 use crate::thinpooldev::ThinPoolDev;
@@ -118,7 +116,7 @@ impl fmt::Display for ThinDevTargetTable {
 }
 
 impl TargetTable for ThinDevTargetTable {
-    fn from_raw_table(table: &[(u64, u64, TargetTypeBuf, String)]) -> DmResult<ThinDevTargetTable> {
+    fn from_raw_table(table: &[(u64, u64, String, String)]) -> DmResult<ThinDevTargetTable> {
         if table.len() != 1 {
             let err_msg = format!(
                 "ThinDev table should have exactly one line, has {} lines",
@@ -130,11 +128,11 @@ impl TargetTable for ThinDevTargetTable {
         Ok(ThinDevTargetTable::new(
             Sectors(line.0),
             Sectors(line.1),
-            format!("{} {}", line.2.to_string(), line.3).parse::<ThinTargetParams>()?,
+            format!("{} {}", line.2, line.3).parse::<ThinTargetParams>()?,
         ))
     }
 
-    fn to_raw_table(&self) -> Vec<(u64, u64, TargetTypeBuf, String)> {
+    fn to_raw_table(&self) -> Vec<(u64, u64, String, String)> {
         to_raw_table_unique!(self)
     }
 }

src/thinpooldev.rs

@@ -7,13 +7,13 @@ use std::fmt;
 use std::path::PathBuf;
 use std::str::FromStr;
 
-use crate::core::{DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, TargetTypeBuf, DM};
+use crate::core::{DevId, Device, DeviceInfo, DmName, DmOptions, DmUuid, 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,
+    TargetTable, TargetTypeBuf,
 };
 use crate::units::{DataBlocks, MetaBlocks, Sectors};
 
@@ -158,9 +158,7 @@ impl fmt::Display for ThinPoolDevTargetTable {
 }
 
 impl TargetTable for ThinPoolDevTargetTable {
-    fn from_raw_table(
-        table: &[(u64, u64, TargetTypeBuf, String)],
-    ) -> DmResult<ThinPoolDevTargetTable> {
+    fn from_raw_table(table: &[(u64, u64, String, String)]) -> DmResult<ThinPoolDevTargetTable> {
         if table.len() != 1 {
             let err_msg = format!(
                 "ThinPoolDev table should have exactly one line, has {} lines",
@@ -172,11 +170,11 @@ impl TargetTable for ThinPoolDevTargetTable {
         Ok(ThinPoolDevTargetTable::new(
             Sectors(line.0),
             Sectors(line.1),
-            format!("{} {}", line.2.to_string(), line.3).parse::<ThinPoolTargetParams>()?,
+            format!("{} {}", line.2, line.3).parse::<ThinPoolTargetParams>()?,
         ))
     }
 
-    fn to_raw_table(&self) -> Vec<(u64, u64, TargetTypeBuf, String)> {
+    fn to_raw_table(&self) -> Vec<(u64, u64, String, String)> {
         to_raw_table_unique!(self)
     }
 }