Use zpool_search_import instead of zpool_find_import (#85)

* Use zpool_search_import instead of zpool_find_import

Fixes #84.

Signed-off-by: Joe Grund <jgrund@whamcloud.io>

* initalize importargs

Signed-off-by: Joe Grund <jgrund@whamcloud.io>

* update bitfield args

Signed-off-by: Joe Grund <jgrund@whamcloud.io>

Author: Joe Grund

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "libzfs-sys"
-version = "0.5.10"
+version = "0.5.11"
 description = "Rust bindings to libzfs"
 license = "MIT"
 repository = "https://github.com/whamcloud/rust-libzfs"
@@ -12,5 +12,5 @@ build = "build.rs"
 nvpair-sys = "0.1"
 
 [build-dependencies]
-bindgen = "0.43.1"
-pkg-config = "0.3.14"
+bindgen = "0.51.0"
+pkg-config = "0.3.15"

libzfs-sys/Cargo.toml

@@ -78,7 +78,7 @@ fn main() {
         .whitelist_function("thread_fini")
         .whitelist_function("zpool_import")
         .whitelist_function("zpool_export")
-        .whitelist_function("zpool_find_import")
+        .whitelist_function("zpool_search_import")
         .whitelist_function("zpool_iter")
         .whitelist_function("zpool_open_canfail")
         .whitelist_function("zpool_close")

libzfs-sys/build.rs

@@ -1,5 +1,86 @@
 /* automatically generated by rust-bindgen */
 
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct __BindgenBitfieldUnit<Storage, Align> {
+    storage: Storage,
+    align: [Align; 0],
+}
+impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
+    #[inline]
+    pub const fn new(storage: Storage) -> Self {
+        Self { storage, align: [] }
+    }
+}
+impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
+where
+    Storage: AsRef<[u8]> + AsMut<[u8]>,
+{
+    #[inline]
+    pub fn get_bit(&self, index: usize) -> bool {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = self.storage.as_ref()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        byte & mask == mask
+    }
+    #[inline]
+    pub fn set_bit(&mut self, index: usize, val: bool) {
+        debug_assert!(index / 8 < self.storage.as_ref().len());
+        let byte_index = index / 8;
+        let byte = &mut self.storage.as_mut()[byte_index];
+        let bit_index = if cfg!(target_endian = "big") {
+            7 - (index % 8)
+        } else {
+            index % 8
+        };
+        let mask = 1 << bit_index;
+        if val {
+            *byte |= mask;
+        } else {
+            *byte &= !mask;
+        }
+    }
+    #[inline]
+    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+        let mut val = 0;
+        for i in 0..(bit_width as usize) {
+            if self.get_bit(i + bit_offset) {
+                let index = if cfg!(target_endian = "big") {
+                    bit_width as usize - 1 - i
+                } else {
+                    i
+                };
+                val |= 1 << index;
+            }
+        }
+        val
+    }
+    #[inline]
+    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
+        debug_assert!(bit_width <= 64);
+        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
+        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
+        for i in 0..(bit_width as usize) {
+            let mask = 1 << i;
+            let val_bit_is_set = val & mask == mask;
+            let index = if cfg!(target_endian = "big") {
+                bit_width as usize - 1 - i
+            } else {
+                i
+            };
+            self.set_bit(index + bit_offset, val_bit_is_set);
+        }
+    }
+}
 pub const ZFS_MAX_DATASET_NAME_LEN: u32 = 256;
 pub const ZPROP_VALUE: &'static [u8; 6usize] = b"value\0";
 pub const ZPOOL_CONFIG_POOL_NAME: &'static [u8; 5usize] = b"name\0";
@@ -81,7 +162,7 @@ impl ::std::ops::BitAndAssign for zfs_type_t {
         self.0 &= rhs.0;
     }
 }
-#[repr(C)]
+#[repr(transparent)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct zfs_type_t(pub u32);
 pub const dmu_objset_type_DMU_OST_NONE: dmu_objset_type = 0;
@@ -661,11 +742,158 @@ extern "C" {
         altroot: *mut ::std::os::raw::c_char,
     ) -> ::std::os::raw::c_int;
 }
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct importargs {
+    pub path: *mut *mut ::std::os::raw::c_char,
+    pub paths: ::std::os::raw::c_int,
+    pub poolname: *mut ::std::os::raw::c_char,
+    pub guid: u64,
+    pub cachefile: *mut ::std::os::raw::c_char,
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
+    pub __bindgen_padding_0: [u8; 7usize],
+}
+#[test]
+fn bindgen_test_layout_importargs() {
+    assert_eq!(
+        ::std::mem::size_of::<importargs>(),
+        48usize,
+        concat!("Size of: ", stringify!(importargs))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<importargs>(),
+        8usize,
+        concat!("Alignment of ", stringify!(importargs))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<importargs>())).path as *const _ as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(importargs),
+            "::",
+            stringify!(path)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<importargs>())).paths as *const _ as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(importargs),
+            "::",
+            stringify!(paths)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<importargs>())).poolname as *const _ as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(importargs),
+            "::",
+            stringify!(poolname)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<importargs>())).guid as *const _ as usize },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(importargs),
+            "::",
+            stringify!(guid)
+        )
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<importargs>())).cachefile as *const _ as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(importargs),
+            "::",
+            stringify!(cachefile)
+        )
+    );
+}
+impl importargs {
+    #[inline]
+    pub fn can_be_active(&self) -> ::std::os::raw::c_int {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_can_be_active(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn unique(&self) -> ::std::os::raw::c_int {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_unique(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn exists(&self) -> ::std::os::raw::c_int {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_exists(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn scan(&self) -> ::std::os::raw::c_int {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_scan(&mut self, val: ::std::os::raw::c_int) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        can_be_active: ::std::os::raw::c_int,
+        unique: ::std::os::raw::c_int,
+        exists: ::std::os::raw::c_int,
+        scan: ::std::os::raw::c_int,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
+            Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let can_be_active: u32 = unsafe { ::std::mem::transmute(can_be_active) };
+            can_be_active as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let unique: u32 = unsafe { ::std::mem::transmute(unique) };
+            unique as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let exists: u32 = unsafe { ::std::mem::transmute(exists) };
+            exists as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let scan: u32 = unsafe { ::std::mem::transmute(scan) };
+            scan as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+pub type importargs_t = importargs;
 extern "C" {
-    pub fn zpool_find_import(
+    pub fn zpool_search_import(
         arg1: *mut libzfs_handle_t,
-        arg2: ::std::os::raw::c_int,
-        arg3: *mut *mut ::std::os::raw::c_char,
+        arg2: *mut importargs_t,
     ) -> *mut nvlist_t;
 }
 extern "C" {

libzfs-sys/src/bindings.rs

@@ -26,6 +26,7 @@
 
 extern crate nvpair_sys;
 use nvpair_sys::*;
+
 include!("bindings.rs");
 
 fn utf8_to_string(bytes: &[u8]) -> String {
@@ -96,6 +97,18 @@ pub fn zfs_type_dataset() -> zfs_type_t {
     zfs_type_t::ZFS_TYPE_FILESYSTEM | zfs_type_t::ZFS_TYPE_VOLUME | zfs_type_t::ZFS_TYPE_SNAPSHOT
 }
 
+pub fn import_args() -> importargs {
+    importargs {
+        path: std::ptr::null_mut(),
+        paths: 0,
+        poolname: std::ptr::null_mut(),
+        guid: 0,
+        cachefile: std::ptr::null_mut(),
+        _bitfield_1: importargs::new_bitfield_1(0, 1, 1, 0),
+        __bindgen_padding_0: [0, 0, 0, 0, 0, 0, 0],
+    }
+}
+
 /// Converts a `Vec<u64>` to `vdev_stat_t`
 pub fn to_vdev_stat(mut xs: Vec<u64>) -> vdev_stat_t {
     xs.shrink_to_fit();
@@ -203,7 +216,10 @@ mod tests {
 
         let (nvl, nvp) = unsafe {
             thread_init();
-            let nvl = zpool_find_import(h, 0, ptr::null_mut());
+
+            let mut args = import_args();
+
+            let nvl = zpool_search_import(h, &mut args as *mut importargs);
             thread_fini();
 
             let nvp = nvlist_next_nvpair(nvl, ptr::null_mut());

libzfs-sys/src/lib.rs

@@ -1,16 +1,16 @@
 [package]
 name = "libzfs"
-version = "0.6.14"
+version = "0.6.15"
 authors = ["IML Team <iml@whamcloud.com>"]
 description = "Rust wrapper around libzfs-sys"
 license = "MIT"
 
 [dependencies]
-libzfs-sys = { path = "../libzfs-sys", version = "0.5.10"}
+libzfs-sys = { path = "../libzfs-sys", version = "0.5.11"}
 libzfs-types = { path = "../libzfs-types", version = "0.1.1" }
 nvpair-sys = "0.1"
 serde = "1.0"
 serde_derive = "1.0"
 foreign-types = "0.3"
 cstr-argument = "0.1"
-lazy_static = "1.1"
+lazy_static = "1.3"

libzfs/Cargo.toml

@@ -67,7 +67,9 @@ impl Libzfs {
         let _l = LOCK.lock().unwrap();
         unsafe {
             sys::thread_init();
-            let x = sys::zpool_find_import(self.raw, 0, ptr::null_mut());
+            let mut args = sys::import_args();
+
+            let x = sys::zpool_search_import(self.raw, &mut args as *mut sys::importargs);
             sys::thread_fini();
 
             nvpair::NvList::from_ptr(x)
@@ -91,7 +93,8 @@ impl Libzfs {
                     0 => Ok(()),
                     x => Err(LibZfsError::Io(Error::from_raw_os_error(x))),
                 }
-            }).collect()
+            })
+            .collect()
     }
     pub fn export_all(&mut self, pools: &[Zpool]) -> Result<Vec<()>> {
         pools

libzfs/src/libzfs.rs

@@ -70,7 +70,8 @@ impl Zfs {
                     .map(|v| ZProp {
                         name: x.user_prop().to_owned().into_string().unwrap(),
                         value: v.into_string().unwrap(),
-                    }).ok(),
+                    })
+                    .ok(),
                 y => {
                     let raw = CString::new("0".repeat(buff_size)).unwrap().into_raw();
 
@@ -100,7 +101,8 @@ impl Zfs {
                         None
                     }
                 }
-            }).collect::<Vec<_>>();
+            })
+            .collect::<Vec<_>>();
 
         Ok(xs)
     }
@@ -171,7 +173,8 @@ mod tests {
                         "guid".to_owned(),
                         "createtxg".to_owned()
                     ]
-                        .contains(&x.name)).collect::<Vec<ZProp>>(),
+                    .contains(&x.name))
+                    .collect::<Vec<ZProp>>(),
                 vec![
                     ZProp {
                         name: "name".to_owned(),