Merge pull request #421 from mulkieran/master-core-module

Make a core sub-module

Author: mergify[bot]

src/cachedev.rs

@@ -7,18 +7,15 @@ use std::fmt;
 use std::path::PathBuf;
 use std::str::FromStr;
 
-use crate::device::Device;
-use crate::deviceinfo::DeviceInfo;
-use crate::dm::DM;
-use crate::dm_options::DmOptions;
+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::types::{DataBlocks, DevId, DmName, DmUuid, MetaBlocks, Sectors, TargetTypeBuf};
+use crate::units::{DataBlocks, MetaBlocks, Sectors};
 
 const CACHE_TARGET_NAME: &str = "cache";
 
@@ -190,9 +187,7 @@ impl fmt::Display for CacheDevTargetTable {
 }
 
 impl TargetTable for CacheDevTargetTable {
-    fn from_raw_table(
-        table: &[(Sectors, Sectors, 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",
@@ -202,13 +197,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, String, String)> {
         to_raw_table_unique!(self)
     }
 }
@@ -737,7 +732,7 @@ use std::path::Path;
 #[cfg(test)]
 use crate::consts::IEC;
 #[cfg(test)]
-use crate::device::devnode_to_devno;
+use crate::core::devnode_to_devno;
 #[cfg(test)]
 use crate::lineardev::LinearTargetParams;
 #[cfg(test)]

src/consts.rs

@@ -2,9 +2,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-/// disk sector size in bytes
-pub const SECTOR_SIZE: usize = 512;
-
 #[allow(non_upper_case_globals)]
 #[allow(non_snake_case)]
 /// International Electrotechnical Commission Units Standards

src/device.rs src/core/device.rssrc/device.rs renamed to src/core/device.rs

@@ -10,9 +10,10 @@ use std::{fmt, io};
 use libc::{dev_t, major, makedev, minor};
 use nix::sys::stat::SFlag;
 
-use crate::errors::ErrorKind;
 use crate::result::{DmError, DmResult};
 
+use crate::core::errors::ErrorKind;
+
 /// A struct containing the device's major and minor numbers
 ///
 /// Also allows conversion to/from a single 64bit dev_t value.

src/deviceinfo.rs src/core/deviceinfo.rssrc/deviceinfo.rs renamed to src/core/deviceinfo.rs

@@ -3,11 +3,10 @@
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 use std::str::from_utf8;
 
-use crate::device::Device;
-use crate::dm_flags::DmFlags;
-use crate::dm_ioctl as dmi;
-use crate::types::{DmName, DmUuid};
-use crate::util::slice_to_null;
+use crate::core::{Device, DmFlags, DmName, DmUuid};
+
+use crate::core::dm_ioctl as dmi;
+use crate::core::util::slice_to_null;
 
 /// Name max length
 pub const DM_NAME_LEN: usize = 128;

src/dm.rs src/core/dm.rssrc/dm.rs renamed to src/core/dm.rs

@@ -10,16 +10,13 @@ use std::{cmp, slice, u32};
 use nix::libc::c_ulong;
 use nix::libc::ioctl as nix_ioctl;
 
-use crate::device::Device;
-use crate::deviceinfo::{DeviceInfo, DM_NAME_LEN, DM_UUID_LEN};
-use crate::dm_flags::DmFlags;
-use crate::dm_ioctl as dmi;
-use crate::dm_options::DmOptions;
-use crate::errors::ErrorKind;
+use crate::core::{DevId, Device, DeviceInfo, DmFlags, DmName, DmNameBuf, DmOptions, DmUuid};
 use crate::result::{DmError, DmResult};
 
-use crate::types::{DevId, DmName, DmNameBuf, DmUuid, Sectors, TargetTypeBuf};
-use crate::util::{align_to, slice_to_null};
+use crate::core::deviceinfo::{DM_NAME_LEN, DM_UUID_LEN};
+use crate::core::dm_ioctl as dmi;
+use crate::core::errors::ErrorKind;
+use crate::core::util::{align_to, slice_to_null};
 
 /// Indicator to send IOCTL to DM
 const DM_IOCTL: u8 = 0xfd;
@@ -401,7 +398,7 @@ impl DM {
         &self,
         id: &DevId,
         options: &DmOptions,
-    ) -> DmResult<(DeviceInfo, Vec<(Sectors, Sectors, 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)?;
@@ -423,15 +420,15 @@ impl DM {
     /// # Example
     ///
     /// ```no_run
-    /// use devicemapper::{DM, DevId, DmName, Sectors, 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![(
-    ///     Sectors(0),
-    ///     Sectors(32768),
-    ///     TargetTypeBuf::new("linear".into()).expect("valid"),
+    ///     0,
+    ///     32768,
+    ///     "linear".into(),
     ///     "/dev/sdb1 2048".into()
     /// )];
     ///
@@ -442,16 +439,16 @@ impl DM {
     pub fn table_load(
         &self,
         id: &DevId,
-        targets: &[(Sectors, Sectors, TargetTypeBuf, String)],
+        targets: &[(u64, u64, String, 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]) };
@@ -548,16 +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<(Sectors, Sectors, 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;
@@ -583,12 +579,7 @@ impl DM {
                     String::from_utf8_lossy(slc).trim_end().to_owned()
                 };
 
-                targets.push((
-                    Sectors(targ.sector_start),
-                    Sectors(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;
             }
@@ -629,7 +620,7 @@ impl DM {
         &self,
         id: &DevId,
         options: &DmOptions,
-    ) -> DmResult<(DeviceInfo, Vec<(Sectors, Sectors, 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,
@@ -683,13 +674,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()
@@ -723,10 +714,11 @@ impl DM {
 #[cfg(test)]
 mod tests {
 
-    use crate::errors::Error;
     use crate::result::DmError;
     use crate::test_lib::{test_name, test_uuid};
 
+    use crate::core::errors::Error;
+
     use super::*;
 
     #[test]

src/dm_flags.rs src/core/dm_flags.rssrc/dm_flags.rs renamed to src/core/dm_flags.rs

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
-use crate::dm_ioctl as dmi;
+use crate::core::dm_ioctl as dmi;
 
 bitflags! {
     /// Flags used by devicemapper.

src/dm_ioctl.rs src/core/dm_ioctl.rssrc/dm_ioctl.rs renamed to src/core/dm_ioctl.rs

@@ -10,8 +10,9 @@
 use std::borrow::Cow;
 use std::fmt;
 
-use crate::device::Device;
-use crate::util::slice_to_null;
+use crate::core::Device;
+
+use crate::core::util::slice_to_null;
 
 pub type __s8 = ::libc::c_char;
 pub type __u8 = ::libc::c_uchar;

src/dm_options.rs src/core/dm_options.rssrc/dm_options.rs renamed to src/core/dm_options.rs

@@ -1,7 +1,7 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at http://mozilla.org/MPL/2.0/.
-use crate::dm_flags::{DmCookie, DmFlags};
+use crate::core::{DmCookie, DmFlags};
 
 /// Encapsulates options for device mapper calls
 #[derive(Debug, Default, Clone)]

src/errors.rs src/core/errors.rssrc/errors.rs renamed to src/core/errors.rs

@@ -7,7 +7,7 @@ use std::path::PathBuf;
 
 use nix;
 
-use crate::deviceinfo::DeviceInfo;
+use crate::core::DeviceInfo;
 
 error_chain! {
     errors {

src/core/mod.rs

@@ -0,0 +1,22 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! Modules that support handling of devicemapper ioctls at a low-level.
+
+mod device;
+pub(self) mod deviceinfo;
+mod dm;
+mod dm_flags;
+pub(self) mod dm_ioctl;
+mod dm_options;
+pub mod errors;
+mod types;
+pub(self) mod util;
+
+pub use self::device::{devnode_to_devno, Device};
+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};