Added: Linux ioctls (#7)

Author: cecton

.travis.yml

@@ -1,10 +1,17 @@
 sudo: false
 language: rust
 cache: cargo
+os:
+  - linux
+  - windows
 
 rust:
   - stable
 
+# NOTE: disable Travis' cache for now because it makes the Windows build fail
+cache:
+  directories:
+
 before_script:
   - rustup component add rustfmt-preview clippy
 

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "gptman"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Cecile Tonglet <[email protected]>"]
 license = "MIT"
 edition = "2018"
@@ -59,7 +59,7 @@ version = "0.6.0"
 optional = true
 
 [dependencies.nix]
-version = "0.12.0"
+version = "0.14.1"
 optional = true
 
 [dependencies.rand]
@@ -72,4 +72,7 @@ optional = true
 
 [features]
 default = [ "cli" ]
-cli = [ "lazy_static", "ansi_term", "pad", "unicode-width", "clap", "linefeed", "nix", "rand", "structopt" ]
+cli = [ "lazy_static", "ansi_term", "pad", "unicode-width", "clap", "linefeed", "rand", "structopt" ]
+
+[target.'cfg(target_os = "linux")'.dependencies]
+nix = "0.14.1"

Cargo.toml

@@ -36,6 +36,7 @@ Features
  *  Swap partition indexes (s)
  *  Randomize disk's GUID and all partition's GUID (Z)
  *  Copy/clone all partitions from one disk and insert it to another (C)
+ *  Write protective MBR
 
 Installation
 ------------

README.md

@@ -5,6 +5,8 @@ use crate::opt::Opt;
 use crate::table::Table;
 use crate::types::PartitionTypeGUID;
 use crate::uuid::{convert_str_to_array, generate_random_uuid, UUID};
+#[cfg(target_os = "linux")]
+use gptman::linux::reread_partition_table;
 use std::fs;
 use std::io::{Read, Seek, SeekFrom};
 use std::path::PathBuf;
@@ -504,15 +506,7 @@ fn fix_partitions_order(gpt: &mut GPT) {
     gpt.sort();
 }
 
-ioctl_none!(reread_partition_table, 0x12, 95);
-
-const S_IFMT: u32 = 0o170_000;
-const S_IFBLK: u32 = 0o60_000;
-
 fn write(gpt: &mut GPT, opt: &Opt) -> Result<()> {
-    use std::os::linux::fs::MetadataExt;
-    use std::os::unix::io::IntoRawFd;
-
     let mut f = fs::OpenOptions::new().write(true).open(&opt.device)?;
     gpt.write_into(&mut f)?;
 
@@ -521,12 +515,10 @@ fn write(gpt: &mut GPT, opt: &Opt) -> Result<()> {
         println!("protective MBR has been written");
     }
 
-    if fs::metadata(&opt.device)?.st_mode() & S_IFMT == S_IFBLK {
-        println!("calling re-read ioctl");
-        match unsafe { reread_partition_table(f.into_raw_fd()) } {
-            Err(err) => println!("ioctl call failed: {}", err),
-            Ok(0) => {}
-            Ok(x) => println!("ioctl returned error code: {}", x),
+    #[cfg(target_os = "linux")]
+    {
+        if let Err(err) = reread_partition_table(&mut f) {
+            println!("rereading partition table failed: {}", err);
         }
     }
 

src/cli/commands.rs

@@ -2,10 +2,8 @@
 extern crate lazy_static;
 #[macro_use]
 extern crate clap;
-extern crate linefeed;
-#[macro_use]
-extern crate nix;
 extern crate gptman;
+extern crate linefeed;
 extern crate rand;
 extern crate structopt;
 
@@ -21,19 +19,14 @@ use self::commands::{execute, print};
 use self::error::*;
 use self::opt::*;
 use self::uuid::generate_random_uuid;
+#[cfg(target_os = "linux")]
+use gptman::linux::get_sector_size;
 use gptman::GPT;
 use linefeed::{Interface, ReadResult, Signal};
 use std::fs;
 use std::io::{Seek, SeekFrom};
-use std::os::linux::fs::MetadataExt;
-use std::os::unix::io::AsRawFd;
 use structopt::StructOpt;
 
-ioctl_read_bad!(blksszget, 0x1268, u64);
-
-const S_IFMT: u32 = 0o170_000;
-const S_IFBLK: u32 = 0o60_000;
-
 macro_rules! main_unwrap {
     ($e:expr) => {{
         match $e {
@@ -122,16 +115,15 @@ where
 
     let mut f = fs::File::open(&opt.device)?;
     let len = f.seek(SeekFrom::End(0))?;
-    let metadata = fs::metadata(&opt.device).expect("could not get metadata");
 
+    #[allow(unused_mut)]
     let mut sector_size = opt.sector_size.unwrap_or(512);
 
-    if opt.sector_size.is_none() && metadata.st_mode() & S_IFMT == S_IFBLK {
-        println!("getting sector size from device");
-        match unsafe { blksszget(f.as_raw_fd(), &mut sector_size) } {
-            Err(err) => println!("ioctl call failed: {}", err),
-            Ok(0) => {}
-            Ok(x) => println!("ioctl returned error code: {}", x),
+    #[cfg(target_os = "linux")]
+    {
+        match get_sector_size(&mut f) {
+            Err(err) => println!("failed to get sector size of device: {}", err),
+            Ok(x) => sector_size = x,
         }
     }
 
@@ -144,6 +136,8 @@ where
     ask("Do you wish to continue (yes/no)?").and_then(|x| {
         if x == "yes" {
             Ok(())
+        } else if x == "no" {
+            Err(Error::new("Aborted."))
         } else {
             Err(Error::new(&format!(
                 "Invalid answer '{}'. Please type 'yes' or 'no'.",

src/cli/main.rs

@@ -71,6 +71,9 @@ extern crate serde;
 #[macro_use]
 extern crate serde_derive;
 extern crate crc;
+#[cfg(target_os = "linux")]
+#[macro_use]
+extern crate nix;
 
 use bincode::{deserialize_from, serialize, serialize_into};
 use crc::{crc32, Hasher32};
@@ -83,6 +86,9 @@ use std::io;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::ops::{Index, IndexMut};
 
+/// Linux specific helpers
+pub mod linux;
+
 const DEFAULT_ALIGN: u64 = 2048;
 const MAX_ALIGN: u64 = 16384;
 

src/lib.rs

@@ -0,0 +1,62 @@
+#![cfg(target_os = "linux")]
+
+use std::fs;
+use std::io;
+use std::os::linux::fs::MetadataExt;
+use std::os::unix::io::AsRawFd;
+
+mod ioctl {
+    ioctl_read_bad!(blksszget, 0x1268, u64);
+    ioctl_none!(blkrrpart, 0x12, 95);
+}
+
+const S_IFMT: u32 = 0o170_000;
+const S_IFBLK: u32 = 0o60_000;
+
+/// An error that can happen while doing an ioctl call with a block device
+#[derive(Debug, Error)]
+pub enum BlockError {
+    /// An error that occurs when the metadata of the input file couldn't be retrieved
+    #[error(display = "failed to get metadata of device fd")]
+    Metadata(#[error(cause)] io::Error),
+    /// An error that occurs when the partition table could not be reloaded by the OS
+    #[error(display = "failed to reload partition table of device")]
+    RereadTable(#[error(cause)] nix::Error),
+    /// An error that occurs when an invalid return code has been received from an ioctl call
+    #[error(display = "invalid return value of ioctl ({} != 0)", _0)]
+    InvalidReturnValue(i32),
+    /// An error that occurs when the file provided is not a block device
+    #[error(display = "not a block device")]
+    NotBlock,
+}
+
+/// Makes an ioctl call to make the OS reread the partition table of a block device
+pub fn reread_partition_table(file: &mut fs::File) -> Result<(), BlockError> {
+    let metadata = file.metadata().map_err(BlockError::Metadata)?;
+
+    if metadata.st_mode() & S_IFMT == S_IFBLK {
+        match unsafe { ioctl::blkrrpart(file.as_raw_fd()) } {
+            Err(err) => Err(BlockError::RereadTable(err)),
+            Ok(0) => Ok(()),
+            Ok(r) => Err(BlockError::InvalidReturnValue(r)),
+        }
+    } else {
+        Err(BlockError::NotBlock)
+    }
+}
+
+/// Makes an ioctl call to obtain the sector size of a block device
+pub fn get_sector_size(file: &mut fs::File) -> Result<u64, BlockError> {
+    let metadata = file.metadata().map_err(BlockError::Metadata)?;
+    let mut sector_size = 512;
+
+    if metadata.st_mode() & S_IFMT == S_IFBLK {
+        match unsafe { ioctl::blksszget(file.as_raw_fd(), &mut sector_size) } {
+            Err(err) => Err(BlockError::RereadTable(err)),
+            Ok(0) => Ok(sector_size),
+            Ok(r) => Err(BlockError::InvalidReturnValue(r)),
+        }
+    } else {
+        Err(BlockError::NotBlock)
+    }
+}