From 20aecb42d8d1c869b17b38b979b9f2f7cbd2ca34 Mon Sep 17 00:00:00 2001 From: Alexander Fougner Date: Mon, 16 Jan 2023 09:22:49 +0100 Subject: rust: use rustfmt defaults follow the kernel style guide, i.e idiomatic rust style. Signed-off-by: Alexander Fougner --- rust-src/bch_bindgen/build.rs | 146 ++++++++------ rust-src/bch_bindgen/rustfmt.toml | 5 +- rust-src/bch_bindgen/src/bcachefs.rs | 133 ++++++------- rust-src/bch_bindgen/src/lib.rs | 2 +- rust-src/bch_bindgen/src/rs.rs | 87 ++++----- rust-src/mount/rustfmt.toml | 5 +- rust-src/mount/src/filesystem.rs | 357 ++++++++++++++++++----------------- rust-src/mount/src/key.rs | 150 +++++++-------- rust-src/mount/src/lib.rs | 124 ++++++------ rust-src/mount/src/main.rs | 81 ++++---- 10 files changed, 560 insertions(+), 530 deletions(-) diff --git a/rust-src/bch_bindgen/build.rs b/rust-src/bch_bindgen/build.rs index e729bcab..da1541b1 100644 --- a/rust-src/bch_bindgen/build.rs +++ b/rust-src/bch_bindgen/build.rs @@ -1,67 +1,91 @@ fn main() { - use std::path::PathBuf; + use std::path::PathBuf; - let out_dir: PathBuf = std::env::var_os("OUT_DIR").expect("ENV Var 'OUT_DIR' Expected").into(); - let top_dir: PathBuf = std::env::var_os("CARGO_MANIFEST_DIR") - .expect("ENV Var 'CARGO_MANIFEST_DIR' Expected") - .into(); - let libbcachefs_inc_dir = - std::env::var("LIBBCACHEFS_INCLUDE").unwrap_or_else(|_| top_dir.join("libbcachefs").display().to_string()); - let libbcachefs_inc_dir = std::path::Path::new(&libbcachefs_inc_dir); - println!("{}", libbcachefs_inc_dir.display()); + let out_dir: PathBuf = std::env::var_os("OUT_DIR") + .expect("ENV Var 'OUT_DIR' Expected") + .into(); + let top_dir: PathBuf = std::env::var_os("CARGO_MANIFEST_DIR") + .expect("ENV Var 'CARGO_MANIFEST_DIR' Expected") + .into(); + let libbcachefs_inc_dir = std::env::var("LIBBCACHEFS_INCLUDE") + .unwrap_or_else(|_| top_dir.join("libbcachefs").display().to_string()); + let libbcachefs_inc_dir = std::path::Path::new(&libbcachefs_inc_dir); + println!("{}", libbcachefs_inc_dir.display()); - println!("cargo:rustc-link-lib=dylib=bcachefs"); - println!("cargo:rustc-link-search={}", env!("LIBBCACHEFS_LIB")); + println!("cargo:rustc-link-lib=dylib=bcachefs"); + println!("cargo:rustc-link-search={}", env!("LIBBCACHEFS_LIB")); - let _libbcachefs_dir = top_dir.join("libbcachefs").join("libbcachefs"); - let bindings = bindgen::builder() - .header(top_dir.join("src").join("libbcachefs_wrapper.h").display().to_string()) - .clang_arg(format!("-I{}", libbcachefs_inc_dir.join("include").display())) - .clang_arg(format!("-I{}", libbcachefs_inc_dir.display())) - .clang_arg("-DZSTD_STATIC_LINKING_ONLY") - .clang_arg("-DNO_BCACHEFS_FS") - .clang_arg("-D_GNU_SOURCE") - .derive_debug(true) - .derive_default(true) - .derive_eq(true) - .layout_tests(true) - .default_enum_style(bindgen::EnumVariation::Rust { non_exhaustive: true }) - .allowlist_function(".*bch2_.*") - .allowlist_function("bio_.*") - .allowlist_function("bch2_super_write_fd") - .allowlist_function("derive_passphrase") - .allowlist_function("request_key") - .allowlist_function("add_key") - .allowlist_function("keyctl_search") - .blocklist_type("bch_extent_ptr") - .blocklist_type("btree_node") - .blocklist_type("bch_extent_crc32") - .blocklist_type("rhash_lock_head") - .blocklist_type("srcu_struct") - .allowlist_var("BCH_.*") - .allowlist_var("KEY_SPEC_.*") - .allowlist_type("bch_kdf_types") - .allowlist_type("bch_sb_field_.*") - .allowlist_type("bch_encrypted_key") - .allowlist_type("nonce") - .newtype_enum("bch_kdf_types") - .opaque_type("gendisk") - .opaque_type("bkey") - .opaque_type("gc_stripe") - .opaque_type("open_bucket.*") - .generate() - .expect("BindGen Generation Failiure: [libbcachefs_wrapper]"); - bindings - .write_to_file(out_dir.join("bcachefs.rs")) - .expect("Writing to output file failed for: `bcachefs.rs`"); + let _libbcachefs_dir = top_dir.join("libbcachefs").join("libbcachefs"); + let bindings = bindgen::builder() + .header( + top_dir + .join("src") + .join("libbcachefs_wrapper.h") + .display() + .to_string(), + ) + .clang_arg(format!( + "-I{}", + libbcachefs_inc_dir.join("include").display() + )) + .clang_arg(format!("-I{}", libbcachefs_inc_dir.display())) + .clang_arg("-DZSTD_STATIC_LINKING_ONLY") + .clang_arg("-DNO_BCACHEFS_FS") + .clang_arg("-D_GNU_SOURCE") + .derive_debug(true) + .derive_default(true) + .derive_eq(true) + .layout_tests(true) + .default_enum_style(bindgen::EnumVariation::Rust { + non_exhaustive: true, + }) + .allowlist_function(".*bch2_.*") + .allowlist_function("bio_.*") + .allowlist_function("bch2_super_write_fd") + .allowlist_function("derive_passphrase") + .allowlist_function("request_key") + .allowlist_function("add_key") + .allowlist_function("keyctl_search") + .blocklist_type("bch_extent_ptr") + .blocklist_type("btree_node") + .blocklist_type("bch_extent_crc32") + .blocklist_type("rhash_lock_head") + .blocklist_type("srcu_struct") + .allowlist_var("BCH_.*") + .allowlist_var("KEY_SPEC_.*") + .allowlist_type("bch_kdf_types") + .allowlist_type("bch_sb_field_.*") + .allowlist_type("bch_encrypted_key") + .allowlist_type("nonce") + .newtype_enum("bch_kdf_types") + .opaque_type("gendisk") + .opaque_type("bkey") + .opaque_type("gc_stripe") + .opaque_type("open_bucket.*") + .generate() + .expect("BindGen Generation Failiure: [libbcachefs_wrapper]"); + bindings + .write_to_file(out_dir.join("bcachefs.rs")) + .expect("Writing to output file failed for: `bcachefs.rs`"); - let keyutils = pkg_config::probe_library("libkeyutils").expect("Failed to find keyutils lib"); - let bindings = bindgen::builder() - .header(top_dir.join("src").join("keyutils_wrapper.h").display().to_string()) - .clang_args(keyutils.include_paths.iter().map(|p| format!("-I{}", p.display()))) - .generate() - .expect("BindGen Generation Failiure: [Keyutils]"); - bindings - .write_to_file(out_dir.join("keyutils.rs")) - .expect("Writing to output file failed for: `keyutils.rs`"); + let keyutils = pkg_config::probe_library("libkeyutils").expect("Failed to find keyutils lib"); + let bindings = bindgen::builder() + .header( + top_dir + .join("src") + .join("keyutils_wrapper.h") + .display() + .to_string(), + ) + .clang_args( + keyutils + .include_paths + .iter() + .map(|p| format!("-I{}", p.display())), + ) + .generate() + .expect("BindGen Generation Failiure: [Keyutils]"); + bindings + .write_to_file(out_dir.join("keyutils.rs")) + .expect("Writing to output file failed for: `keyutils.rs`"); } diff --git a/rust-src/bch_bindgen/rustfmt.toml b/rust-src/bch_bindgen/rustfmt.toml index a2b7f327..42f2ad7c 100644 --- a/rust-src/bch_bindgen/rustfmt.toml +++ b/rust-src/bch_bindgen/rustfmt.toml @@ -1,2 +1,3 @@ -max_width=120 -hard_tabs = true +# Default settings, i.e. idiomatic rust +edition = "2021" +newline_style = "Unix" \ No newline at end of file diff --git a/rust-src/bch_bindgen/src/bcachefs.rs b/rust-src/bch_bindgen/src/bcachefs.rs index 6e36790a..fa8dbdeb 100644 --- a/rust-src/bch_bindgen/src/bcachefs.rs +++ b/rust-src/bch_bindgen/src/bcachefs.rs @@ -7,101 +7,104 @@ include!(concat!(env!("OUT_DIR"), "/bcachefs.rs")); use bitfield::bitfield; bitfield! { - pub struct bch_scrypt_flags(u64); - pub N, _: 15, 0; - pub R, _: 31, 16; - pub P, _: 47, 32; + pub struct bch_scrypt_flags(u64); + pub N, _: 15, 0; + pub R, _: 31, 16; + pub P, _: 47, 32; } bitfield! { - pub struct bch_crypt_flags(u64); - pub TYPE, _: 4, 0; + pub struct bch_crypt_flags(u64); + pub TYPE, _: 4, 0; } use memoffset::offset_of; impl bch_sb_field_crypt { - pub fn scrypt_flags(&self) -> Option { - use std::convert::TryInto; - match bch_kdf_types(bch_crypt_flags(self.flags).TYPE().try_into().ok()?) { - bch_kdf_types::BCH_KDF_SCRYPT => Some(bch_scrypt_flags(self.kdf_flags)), - _ => None, - } - } - pub fn key(&self) -> &bch_encrypted_key { - &self.key - } + pub fn scrypt_flags(&self) -> Option { + use std::convert::TryInto; + match bch_kdf_types(bch_crypt_flags(self.flags).TYPE().try_into().ok()?) { + bch_kdf_types::BCH_KDF_SCRYPT => Some(bch_scrypt_flags(self.kdf_flags)), + _ => None, + } + } + pub fn key(&self) -> &bch_encrypted_key { + &self.key + } } impl PartialEq for bch_sb { - fn eq(&self, other: &Self) -> bool { - self.magic.b == other.magic.b - && self.user_uuid.b == other.user_uuid.b - && self.block_size == other.block_size - && self.version == other.version - && self.uuid.b == other.uuid.b - && self.seq == other.seq - } + fn eq(&self, other: &Self) -> bool { + self.magic.b == other.magic.b + && self.user_uuid.b == other.user_uuid.b + && self.block_size == other.block_size + && self.version == other.version + && self.uuid.b == other.uuid.b + && self.seq == other.seq + } } impl bch_sb { - pub fn crypt(&self) -> Option<&bch_sb_field_crypt> { - unsafe { - let ptr = bch2_sb_field_get(self as *const _ as *mut _, bch_sb_field_type::BCH_SB_FIELD_crypt) as *const u8; - if ptr.is_null() { - None - } else { - let offset = offset_of!(bch_sb_field_crypt, field); - Some(&*((ptr.sub(offset)) as *const _)) - } - } - } - pub fn uuid(&self) -> uuid::Uuid { - uuid::Uuid::from_bytes(self.user_uuid.b) - } + pub fn crypt(&self) -> Option<&bch_sb_field_crypt> { + unsafe { + let ptr = bch2_sb_field_get( + self as *const _ as *mut _, + bch_sb_field_type::BCH_SB_FIELD_crypt, + ) as *const u8; + if ptr.is_null() { + None + } else { + let offset = offset_of!(bch_sb_field_crypt, field); + Some(&*((ptr.sub(offset)) as *const _)) + } + } + } + pub fn uuid(&self) -> uuid::Uuid { + uuid::Uuid::from_bytes(self.user_uuid.b) + } - /// Get the nonce used to encrypt the superblock - pub fn nonce(&self) -> nonce { - use byteorder::{LittleEndian, ReadBytesExt}; - let mut internal_uuid = &self.uuid.b[..]; - let dword1 = internal_uuid.read_u32::().unwrap(); - let dword2 = internal_uuid.read_u32::().unwrap(); - nonce { - d: [0, 0, dword1, dword2], - } - } + /// Get the nonce used to encrypt the superblock + pub fn nonce(&self) -> nonce { + use byteorder::{LittleEndian, ReadBytesExt}; + let mut internal_uuid = &self.uuid.b[..]; + let dword1 = internal_uuid.read_u32::().unwrap(); + let dword2 = internal_uuid.read_u32::().unwrap(); + nonce { + d: [0, 0, dword1, dword2], + } + } } impl bch_sb_handle { - pub fn sb(&self) -> &bch_sb { - unsafe { &*self.sb } - } + pub fn sb(&self) -> &bch_sb { + unsafe { &*self.sb } + } - pub fn bdev(&self) -> &block_device { - unsafe { &*self.bdev } - } + pub fn bdev(&self) -> &block_device { + unsafe { &*self.bdev } + } } #[repr(C)] // #[repr(align(8))] #[derive(Debug, Default, Copy, Clone)] pub struct bch_extent_ptr { - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>, } #[repr(C, packed(8))] pub struct btree_node { - pub csum: bch_csum, - pub magic: __le64, - pub flags: __le64, - pub min_key: bpos, - pub max_key: bpos, - pub _ptr: bch_extent_ptr, - pub format: bkey_format, - pub __bindgen_anon_1: btree_node__bindgen_ty_1, + pub csum: bch_csum, + pub magic: __le64, + pub flags: __le64, + pub min_key: bpos, + pub max_key: bpos, + pub _ptr: bch_extent_ptr, + pub format: bkey_format, + pub __bindgen_anon_1: btree_node__bindgen_ty_1, } #[repr(C, packed(8))] // #[repr(align(8))] #[derive(Debug, Default, Copy, Clone)] pub struct bch_extent_crc32 { - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, - pub csum: __u32, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, + pub csum: __u32, } // #[repr(u8)] diff --git a/rust-src/bch_bindgen/src/lib.rs b/rust-src/bch_bindgen/src/lib.rs index c19b5a2f..dc8bcf4a 100644 --- a/rust-src/bch_bindgen/src/lib.rs +++ b/rust-src/bch_bindgen/src/lib.rs @@ -3,5 +3,5 @@ pub mod keyutils; pub mod rs; pub mod c { - pub use crate::bcachefs::*; + pub use crate::bcachefs::*; } diff --git a/rust-src/bch_bindgen/src/rs.rs b/rust-src/bch_bindgen/src/rs.rs index 4452f0b2..7a3a3eaf 100644 --- a/rust-src/bch_bindgen/src/rs.rs +++ b/rust-src/bch_bindgen/src/rs.rs @@ -1,58 +1,61 @@ use crate::bcachefs; -pub const SUPERBLOCK_MAGIC: uuid::Uuid = uuid::Uuid::from_u128( - 0x_c68573f6_4e1a_45ca_8265_f57f48ba6d81 -); - +pub const SUPERBLOCK_MAGIC: uuid::Uuid = + uuid::Uuid::from_u128(0x_c68573f6_4e1a_45ca_8265_f57f48ba6d81); + extern "C" { - pub static stdout: *mut libc::FILE; + pub static stdout: *mut libc::FILE; } pub enum ReadSuperErr { - Io(std::io::Error), + Io(std::io::Error), } type RResult = std::io::Result>; #[tracing_attributes::instrument(skip(opts))] -pub fn read_super_opts(path: &std::path::Path, mut opts: bcachefs::bch_opts) -> RResult { - // let devp = camino::Utf8Path::from_path(devp).unwrap(); - - use std::os::unix::ffi::OsStrExt; - let path = std::ffi::CString::new(path.as_os_str().as_bytes())?; - - let mut sb = std::mem::MaybeUninit::zeroed(); - - // use gag::{BufferRedirect}; - // // Stop libbcachefs from spamming the output - // let gag = BufferRedirect::stderr().unwrap(); - // tracing::trace!("entering libbcachefs"); - - let ret = unsafe { crate::bcachefs::bch2_read_super(path.as_ptr(), &mut opts, sb.as_mut_ptr()) }; - tracing::trace!(%ret); - - match -ret { - libc::EACCES => Err(std::io::Error::new( - std::io::ErrorKind::PermissionDenied, - "Access Permission Denied", - )), - 0 => Ok(Ok(unsafe { sb.assume_init() })), - 22 => Ok(Err(std::io::Error::new( - std::io::ErrorKind::InvalidData, - "Not a BCacheFS SuperBlock", - ))), - code => { - tracing::debug!(msg = "BCacheFS return error code", ?code); - Ok(Err(std::io::Error::new( - std::io::ErrorKind::Other, - "Failed to Read SuperBlock", - ))) - } - } +pub fn read_super_opts( + path: &std::path::Path, + mut opts: bcachefs::bch_opts, +) -> RResult { + // let devp = camino::Utf8Path::from_path(devp).unwrap(); + + use std::os::unix::ffi::OsStrExt; + let path = std::ffi::CString::new(path.as_os_str().as_bytes())?; + + let mut sb = std::mem::MaybeUninit::zeroed(); + + // use gag::{BufferRedirect}; + // // Stop libbcachefs from spamming the output + // let gag = BufferRedirect::stderr().unwrap(); + // tracing::trace!("entering libbcachefs"); + + let ret = + unsafe { crate::bcachefs::bch2_read_super(path.as_ptr(), &mut opts, sb.as_mut_ptr()) }; + tracing::trace!(%ret); + + match -ret { + libc::EACCES => Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "Access Permission Denied", + )), + 0 => Ok(Ok(unsafe { sb.assume_init() })), + 22 => Ok(Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + "Not a BCacheFS SuperBlock", + ))), + code => { + tracing::debug!(msg = "BCacheFS return error code", ?code); + Ok(Err(std::io::Error::new( + std::io::ErrorKind::Other, + "Failed to Read SuperBlock", + ))) + } + } } #[tracing_attributes::instrument] pub fn read_super(path: &std::path::Path) -> RResult { - let opts = bcachefs::bch_opts::default(); //unsafe {std::mem::MaybeUninit::zeroed().assume_init()}; - read_super_opts(path, opts) + let opts = bcachefs::bch_opts::default(); //unsafe {std::mem::MaybeUninit::zeroed().assume_init()}; + read_super_opts(path, opts) } diff --git a/rust-src/mount/rustfmt.toml b/rust-src/mount/rustfmt.toml index a2b7f327..42f2ad7c 100644 --- a/rust-src/mount/rustfmt.toml +++ b/rust-src/mount/rustfmt.toml @@ -1,2 +1,3 @@ -max_width=120 -hard_tabs = true +# Default settings, i.e. idiomatic rust +edition = "2021" +newline_style = "Unix" \ No newline at end of file diff --git a/rust-src/mount/src/filesystem.rs b/rust-src/mount/src/filesystem.rs index 89865bc4..430d3c64 100644 --- a/rust-src/mount/src/filesystem.rs +++ b/rust-src/mount/src/filesystem.rs @@ -1,158 +1,159 @@ extern "C" { - pub static stdout: *mut libc::FILE; + pub static stdout: *mut libc::FILE; } use getset::{CopyGetters, Getters}; use std::path::PathBuf; #[derive(Getters, CopyGetters)] pub struct FileSystem { - /// External UUID of the bcachefs - #[getset(get = "pub")] - uuid: uuid::Uuid, - /// Whether filesystem is encrypted - #[getset(get_copy = "pub")] - encrypted: bool, - /// Super block - #[getset(get = "pub")] - sb: bcachefs::bch_sb_handle, - /// Member devices for this filesystem - #[getset(get = "pub")] - devices: Vec, + /// External UUID of the bcachefs + #[getset(get = "pub")] + uuid: uuid::Uuid, + /// Whether filesystem is encrypted + #[getset(get_copy = "pub")] + encrypted: bool, + /// Super block + #[getset(get = "pub")] + sb: bcachefs::bch_sb_handle, + /// Member devices for this filesystem + #[getset(get = "pub")] + devices: Vec, } impl std::fmt::Debug for FileSystem { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("FileSystem") - .field("uuid", &self.uuid) - .field("encrypted", &self.encrypted) - .field("devices", &self.device_string()) - .finish() - } + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("FileSystem") + .field("uuid", &self.uuid) + .field("encrypted", &self.encrypted) + .field("devices", &self.device_string()) + .finish() + } } use std::fmt; impl std::fmt::Display for FileSystem { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let devs = self.device_string(); - write!( - f, - "{:?}: locked?={lock} ({}) ", - self.uuid, - devs, - lock = self.encrypted - ) - } + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let devs = self.device_string(); + write!( + f, + "{:?}: locked?={lock} ({}) ", + self.uuid, + devs, + lock = self.encrypted + ) + } } impl FileSystem { - pub(crate) fn new(sb: bcachefs::bch_sb_handle) -> Self { - Self { - uuid: sb.sb().uuid(), - encrypted: sb.sb().crypt().is_some(), - sb: sb, - devices: Vec::new(), - } - } - - pub fn device_string(&self) -> String { - use itertools::Itertools; - self.devices.iter().map(|d| d.display()).join(":") - } - - pub fn mount( - &self, - target: impl AsRef, - options: impl AsRef, - ) -> anyhow::Result<()> { - tracing::info_span!("mount").in_scope(|| { - let src = self.device_string(); - let (data, mountflags) = parse_mount_options(options); - // let fstype = c_str!("bcachefs"); - - tracing::info!(msg="mounting bcachefs filesystem", target=%target.as_ref().display()); - mount_inner(src, target, "bcachefs", mountflags, data) - }) - } + pub(crate) fn new(sb: bcachefs::bch_sb_handle) -> Self { + Self { + uuid: sb.sb().uuid(), + encrypted: sb.sb().crypt().is_some(), + sb: sb, + devices: Vec::new(), + } + } + + pub fn device_string(&self) -> String { + use itertools::Itertools; + self.devices.iter().map(|d| d.display()).join(":") + } + + pub fn mount( + &self, + target: impl AsRef, + options: impl AsRef, + ) -> anyhow::Result<()> { + tracing::info_span!("mount").in_scope(|| { + let src = self.device_string(); + let (data, mountflags) = parse_mount_options(options); + // let fstype = c_str!("bcachefs"); + + tracing::info!(msg="mounting bcachefs filesystem", target=%target.as_ref().display()); + mount_inner(src, target, "bcachefs", mountflags, data) + }) + } } fn mount_inner( - src: String, - target: impl AsRef, - fstype: &str, - mountflags: u64, - data: Option, + src: String, + target: impl AsRef, + fstype: &str, + mountflags: u64, + data: Option, ) -> anyhow::Result<()> { - use std::{ - ffi::{c_void, CString}, - os::{raw::c_char, unix::ffi::OsStrExt}, - }; - - // bind the CStrings to keep them alive - let src = CString::new(src)?; - let target = CString::new(target.as_ref().as_os_str().as_bytes())?; - let data = data.map(CString::new).transpose()?; - let fstype = CString::new(fstype)?; - - // convert to pointers for ffi - let src = src.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char; - let target = target.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char; - let data = data.as_ref().map_or(std::ptr::null(), |data| { - data.as_c_str().to_bytes_with_nul().as_ptr() as *const c_void - }); - let fstype = fstype.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char; - - let ret = {let _entered = tracing::info_span!("libc::mount").entered(); - tracing::info!("mounting filesystem"); - // REQUIRES: CAP_SYS_ADMIN - unsafe { libc::mount(src, target, fstype, mountflags, data) } - }; - match ret { - 0 => Ok(()), - _ => Err(crate::ErrnoError(errno::errno()).into()), - } + use std::{ + ffi::{c_void, CString}, + os::{raw::c_char, unix::ffi::OsStrExt}, + }; + + // bind the CStrings to keep them alive + let src = CString::new(src)?; + let target = CString::new(target.as_ref().as_os_str().as_bytes())?; + let data = data.map(CString::new).transpose()?; + let fstype = CString::new(fstype)?; + + // convert to pointers for ffi + let src = src.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char; + let target = target.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char; + let data = data.as_ref().map_or(std::ptr::null(), |data| { + data.as_c_str().to_bytes_with_nul().as_ptr() as *const c_void + }); + let fstype = fstype.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char; + + let ret = { + let _entered = tracing::info_span!("libc::mount").entered(); + tracing::info!("mounting filesystem"); + // REQUIRES: CAP_SYS_ADMIN + unsafe { libc::mount(src, target, fstype, mountflags, data) } + }; + match ret { + 0 => Ok(()), + _ => Err(crate::ErrnoError(errno::errno()).into()), + } } /// Parse a comma-separated mount options and split out mountflags and filesystem /// specific options. #[tracing_attributes::instrument(skip(options))] fn parse_mount_options(options: impl AsRef) -> (Option, u64) { - use either::Either::*; - tracing::debug!(msg="parsing mount options", options=?options.as_ref()); - let (opts, flags) = options - .as_ref() - .split(",") - .map(|o| match o { - "dirsync" => Left(libc::MS_DIRSYNC), - "lazytime" => Left(1 << 25), // MS_LAZYTIME - "mand" => Left(libc::MS_MANDLOCK), - "noatime" => Left(libc::MS_NOATIME), - "nodev" => Left(libc::MS_NODEV), - "nodiratime" => Left(libc::MS_NODIRATIME), - "noexec" => Left(libc::MS_NOEXEC), - "nosuid" => Left(libc::MS_NOSUID), - "ro" => Left(libc::MS_RDONLY), - "rw" => Left(0), - "relatime" => Left(libc::MS_RELATIME), - "strictatime" => Left(libc::MS_STRICTATIME), - "sync" => Left(libc::MS_SYNCHRONOUS), - "" => Left(0), - o @ _ => Right(o), - }) - .fold((Vec::new(), 0), |(mut opts, flags), next| match next { - Left(f) => (opts, flags | f), - Right(o) => { - opts.push(o); - (opts, flags) - } - }); - - use itertools::Itertools; - ( - if opts.len() == 0 { - None - } else { - Some(opts.iter().join(",")) - }, - flags, - ) + use either::Either::*; + tracing::debug!(msg="parsing mount options", options=?options.as_ref()); + let (opts, flags) = options + .as_ref() + .split(",") + .map(|o| match o { + "dirsync" => Left(libc::MS_DIRSYNC), + "lazytime" => Left(1 << 25), // MS_LAZYTIME + "mand" => Left(libc::MS_MANDLOCK), + "noatime" => Left(libc::MS_NOATIME), + "nodev" => Left(libc::MS_NODEV), + "nodiratime" => Left(libc::MS_NODIRATIME), + "noexec" => Left(libc::MS_NOEXEC), + "nosuid" => Left(libc::MS_NOSUID), + "ro" => Left(libc::MS_RDONLY), + "rw" => Left(0), + "relatime" => Left(libc::MS_RELATIME), + "strictatime" => Left(libc::MS_STRICTATIME), + "sync" => Left(libc::MS_SYNCHRONOUS), + "" => Left(0), + o @ _ => Right(o), + }) + .fold((Vec::new(), 0), |(mut opts, flags), next| match next { + Left(f) => (opts, flags | f), + Right(o) => { + opts.push(o); + (opts, flags) + } + }); + + use itertools::Itertools; + ( + if opts.len() == 0 { + None + } else { + Some(opts.iter().join(",")) + }, + flags, + ) } use bch_bindgen::bcachefs; @@ -161,53 +162,57 @@ use uuid::Uuid; #[tracing_attributes::instrument] pub fn probe_filesystems() -> anyhow::Result> { - tracing::trace!("enumerating udev devices"); - let mut udev = udev::Enumerator::new()?; - - udev.match_subsystem("block")?; // find kernel block devices - - let mut fs_map = HashMap::new(); - let devresults = - udev.scan_devices()? - .into_iter() - .filter_map(|dev| dev.devnode().map(ToOwned::to_owned)); - - for pathbuf in devresults { - match get_super_block_uuid(&pathbuf)? { - - Ok((uuid_key, superblock)) => { - let fs = fs_map.entry(uuid_key).or_insert_with(|| { - tracing::info!(msg="found bcachefs pool", uuid=?uuid_key); - FileSystem::new(superblock) - }); - - fs.devices.push(pathbuf); - }, - - Err(e) => { tracing::debug!(inner2_error=?e);} - } - } - - - tracing::info!(msg = "found filesystems", count = fs_map.len()); - Ok(fs_map) + tracing::trace!("enumerating udev devices"); + let mut udev = udev::Enumerator::new()?; + + udev.match_subsystem("block")?; // find kernel block devices + + let mut fs_map = HashMap::new(); + let devresults = udev + .scan_devices()? + .into_iter() + .filter_map(|dev| dev.devnode().map(ToOwned::to_owned)); + + for pathbuf in devresults { + match get_super_block_uuid(&pathbuf)? { + Ok((uuid_key, superblock)) => { + let fs = fs_map.entry(uuid_key).or_insert_with(|| { + tracing::info!(msg="found bcachefs pool", uuid=?uuid_key); + FileSystem::new(superblock) + }); + + fs.devices.push(pathbuf); + } + + Err(e) => { + tracing::debug!(inner2_error=?e); + } + } + } + + tracing::info!(msg = "found filesystems", count = fs_map.len()); + Ok(fs_map) } // #[tracing_attributes::instrument(skip(dev, fs_map))] -fn get_super_block_uuid(path: &std::path::Path) -> std::io::Result> { - use gag::{BufferRedirect}; - // Stop libbcachefs from spamming the output - let gag = BufferRedirect::stdout().unwrap(); - - let sb = bch_bindgen::rs::read_super(&path)?; - let super_block = match sb { - Err(e) => { return Ok(Err(e)); } - Ok(sb) => sb, - }; - drop(gag); - - let uuid = (&super_block).sb().uuid(); - tracing::debug!(found="bcachefs superblock", devnode=?path, ?uuid); - - Ok(Ok((uuid, super_block))) +fn get_super_block_uuid( + path: &std::path::Path, +) -> std::io::Result> { + use gag::BufferRedirect; + // Stop libbcachefs from spamming the output + let gag = BufferRedirect::stdout().unwrap(); + + let sb = bch_bindgen::rs::read_super(&path)?; + let super_block = match sb { + Err(e) => { + return Ok(Err(e)); + } + Ok(sb) => sb, + }; + drop(gag); + + let uuid = (&super_block).sb().uuid(); + tracing::debug!(found="bcachefs superblock", devnode=?path, ?uuid); + + Ok(Ok((uuid, super_block))) } diff --git a/rust-src/mount/src/key.rs b/rust-src/mount/src/key.rs index 5e64da54..454e641e 100644 --- a/rust-src/mount/src/key.rs +++ b/rust-src/mount/src/key.rs @@ -1,97 +1,97 @@ use tracing::info; fn check_for_key(key_name: &std::ffi::CStr) -> anyhow::Result { - use bch_bindgen::keyutils::{self, keyctl_search}; - let key_name = key_name.to_bytes_with_nul().as_ptr() as *const _; - let key_type = c_str!("logon"); + use bch_bindgen::keyutils::{self, keyctl_search}; + let key_name = key_name.to_bytes_with_nul().as_ptr() as *const _; + let key_type = c_str!("logon"); - let key_id = unsafe { keyctl_search(keyutils::KEY_SPEC_USER_KEYRING, key_type, key_name, 0) }; - if key_id > 0 { - info!("Key has became avaiable"); - Ok(true) - } else if errno::errno().0 != libc::ENOKEY { - Err(crate::ErrnoError(errno::errno()).into()) - } else { - Ok(false) - } + let key_id = unsafe { keyctl_search(keyutils::KEY_SPEC_USER_KEYRING, key_type, key_name, 0) }; + if key_id > 0 { + info!("Key has became avaiable"); + Ok(true) + } else if errno::errno().0 != libc::ENOKEY { + Err(crate::ErrnoError(errno::errno()).into()) + } else { + Ok(false) + } } fn wait_for_key(uuid: &uuid::Uuid) -> anyhow::Result<()> { - let key_name = std::ffi::CString::new(format!("bcachefs:{}", uuid)).unwrap(); - loop { - if check_for_key(&key_name)? { - break Ok(()); - } + let key_name = std::ffi::CString::new(format!("bcachefs:{}", uuid)).unwrap(); + loop { + if check_for_key(&key_name)? { + break Ok(()); + } - std::thread::sleep(std::time::Duration::from_secs(1)); - } + std::thread::sleep(std::time::Duration::from_secs(1)); + } } const BCH_KEY_MAGIC: &str = "bch**key"; use crate::filesystem::FileSystem; fn ask_for_key(fs: &FileSystem) -> anyhow::Result<()> { - use anyhow::anyhow; - use byteorder::{LittleEndian, ReadBytesExt}; - use bch_bindgen::bcachefs::{self, bch2_chacha_encrypt_key, bch_encrypted_key, bch_key}; - use std::os::raw::c_char; + use anyhow::anyhow; + use bch_bindgen::bcachefs::{self, bch2_chacha_encrypt_key, bch_encrypted_key, bch_key}; + use byteorder::{LittleEndian, ReadBytesExt}; + use std::os::raw::c_char; - let key_name = std::ffi::CString::new(format!("bcachefs:{}", fs.uuid())).unwrap(); - if check_for_key(&key_name)? { - return Ok(()); - } + let key_name = std::ffi::CString::new(format!("bcachefs:{}", fs.uuid())).unwrap(); + if check_for_key(&key_name)? { + return Ok(()); + } - let bch_key_magic = BCH_KEY_MAGIC.as_bytes().read_u64::().unwrap(); - let crypt = fs.sb().sb().crypt().unwrap(); - let pass = rpassword::read_password_from_tty(Some("Enter passphrase: "))?; - let pass = std::ffi::CString::new(pass.trim_end())?; // bind to keep the CString alive - let mut output: bch_key = unsafe { - bcachefs::derive_passphrase( - crypt as *const _ as *mut _, - pass.as_c_str().to_bytes_with_nul().as_ptr() as *const _, - ) - }; + let bch_key_magic = BCH_KEY_MAGIC.as_bytes().read_u64::().unwrap(); + let crypt = fs.sb().sb().crypt().unwrap(); + let pass = rpassword::read_password_from_tty(Some("Enter passphrase: "))?; + let pass = std::ffi::CString::new(pass.trim_end())?; // bind to keep the CString alive + let mut output: bch_key = unsafe { + bcachefs::derive_passphrase( + crypt as *const _ as *mut _, + pass.as_c_str().to_bytes_with_nul().as_ptr() as *const _, + ) + }; - let mut key = crypt.key().clone(); - let ret = unsafe { - bch2_chacha_encrypt_key( - &mut output as *mut _, - fs.sb().sb().nonce(), - &mut key as *mut _ as *mut _, - std::mem::size_of::() as usize, - ) - }; - if ret != 0 { - Err(anyhow!("chacha decryption failure")) - } else if key.magic != bch_key_magic { - Err(anyhow!("failed to verify the password")) - } else { - let key_type = c_str!("logon"); - let ret = unsafe { - bch_bindgen::keyutils::add_key( - key_type, - key_name.as_c_str().to_bytes_with_nul() as *const _ as *const c_char, - &output as *const _ as *const _, - std::mem::size_of::() as usize, - bch_bindgen::keyutils::KEY_SPEC_USER_KEYRING, - ) - }; - if ret == -1 { - Err(anyhow!("failed to add key to keyring: {}", errno::errno())) - } else { - Ok(()) - } - } + let mut key = crypt.key().clone(); + let ret = unsafe { + bch2_chacha_encrypt_key( + &mut output as *mut _, + fs.sb().sb().nonce(), + &mut key as *mut _ as *mut _, + std::mem::size_of::() as usize, + ) + }; + if ret != 0 { + Err(anyhow!("chacha decryption failure")) + } else if key.magic != bch_key_magic { + Err(anyhow!("failed to verify the password")) + } else { + let key_type = c_str!("logon"); + let ret = unsafe { + bch_bindgen::keyutils::add_key( + key_type, + key_name.as_c_str().to_bytes_with_nul() as *const _ as *const c_char, + &output as *const _ as *const _, + std::mem::size_of::() as usize, + bch_bindgen::keyutils::KEY_SPEC_USER_KEYRING, + ) + }; + if ret == -1 { + Err(anyhow!("failed to add key to keyring: {}", errno::errno())) + } else { + Ok(()) + } + } } #[tracing_attributes::instrument] pub fn prepare_key(fs: &FileSystem, password: crate::KeyLocation) -> anyhow::Result<()> { - use crate::KeyLocation::*; - use anyhow::anyhow; + use crate::KeyLocation::*; + use anyhow::anyhow; - tracing::info!(msg = "checking if key exists for filesystem"); - match password { - Fail => Err(anyhow!("no key available")), - Wait => Ok(wait_for_key(fs.uuid())?), - Ask => ask_for_key(fs), - } + tracing::info!(msg = "checking if key exists for filesystem"); + match password { + Fail => Err(anyhow!("no key available")), + Wait => Ok(wait_for_key(fs.uuid())?), + Ask => ask_for_key(fs), + } } diff --git a/rust-src/mount/src/lib.rs b/rust-src/mount/src/lib.rs index 554ed798..f2964561 100644 --- a/rust-src/mount/src/lib.rs +++ b/rust-src/mount/src/lib.rs @@ -3,99 +3,99 @@ use clap::Parser; use uuid::Uuid; pub mod err { - pub enum GError { - Unknown{ - message: std::borrow::Cow<'static, String> - } - } - pub type GResult =::core::result::Result< ::core::result::Result, OE>; - pub type Result = GResult; + pub enum GError { + Unknown { + message: std::borrow::Cow<'static, String>, + }, + } + pub type GResult = ::core::result::Result<::core::result::Result, OE>; + pub type Result = GResult; } #[macro_export] macro_rules! c_str { - ($lit:expr) => { - unsafe { - std::ffi::CStr::from_ptr(concat!($lit, "\0").as_ptr() as *const std::os::raw::c_char) - .to_bytes_with_nul() - .as_ptr() as *const std::os::raw::c_char - } - }; + ($lit:expr) => { + unsafe { + std::ffi::CStr::from_ptr(concat!($lit, "\0").as_ptr() as *const std::os::raw::c_char) + .to_bytes_with_nul() + .as_ptr() as *const std::os::raw::c_char + } + }; } #[derive(Debug)] struct ErrnoError(errno::Errno); impl std::fmt::Display for ErrnoError { - fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { - self.0.fmt(f) - } + fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { + self.0.fmt(f) + } } impl std::error::Error for ErrnoError {} #[derive(Clone, Debug)] pub enum KeyLocation { - Fail, - Wait, - Ask, + Fail, + Wait, + Ask, } #[derive(Clone, Debug)] pub struct KeyLoc(pub Option); impl std::ops::Deref for KeyLoc { - type Target = Option; - fn deref(&self) -> &Self::Target { - &self.0 - } + type Target = Option; + fn deref(&self) -> &Self::Target { + &self.0 + } } impl std::str::FromStr for KeyLoc { - type Err = anyhow::Error; - fn from_str(s: &str) -> anyhow::Result { - // use anyhow::anyhow; - match s { - "" => Ok(KeyLoc(None)), - "fail" => Ok(KeyLoc(Some(KeyLocation::Fail))), - "wait" => Ok(KeyLoc(Some(KeyLocation::Wait))), - "ask" => Ok(KeyLoc(Some(KeyLocation::Ask))), - _ => Err(anyhow!("invalid password option")), - } - } + type Err = anyhow::Error; + fn from_str(s: &str) -> anyhow::Result { + // use anyhow::anyhow; + match s { + "" => Ok(KeyLoc(None)), + "fail" => Ok(KeyLoc(Some(KeyLocation::Fail))), + "wait" => Ok(KeyLoc(Some(KeyLocation::Wait))), + "ask" => Ok(KeyLoc(Some(KeyLocation::Ask))), + _ => Err(anyhow!("invalid password option")), + } + } } fn parse_fstab_uuid(uuid_raw: &str) -> Result { - let mut uuid = String::from(uuid_raw); - if uuid.starts_with("UUID=") { - uuid = uuid.replacen("UUID=", "", 1); - } - return Uuid::parse_str(&uuid); + let mut uuid = String::from(uuid_raw); + if uuid.starts_with("UUID=") { + uuid = uuid.replacen("UUID=", "", 1); + } + return Uuid::parse_str(&uuid); } /// Mount a bcachefs filesystem by its UUID. #[derive(Parser, Debug)] #[command(author, version, about, long_about = None)] pub struct Cli { - /// Where the password would be loaded from. - /// - /// Possible values are: - /// "fail" - don't ask for password, fail if filesystem is encrypted; - /// "wait" - wait for password to become available before mounting; - /// "ask" - prompt the user for password; - #[arg(short, long, default_value = "", verbatim_doc_comment)] - pub key_location: KeyLoc, + /// Where the password would be loaded from. + /// + /// Possible values are: + /// "fail" - don't ask for password, fail if filesystem is encrypted; + /// "wait" - wait for password to become available before mounting; + /// "ask" - prompt the user for password; + #[arg(short, long, default_value = "", verbatim_doc_comment)] + pub key_location: KeyLoc, - /// External UUID of the bcachefs filesystem - /// - /// Accepts the UUID as is or as fstab style UUID= - #[arg(value_parser=parse_fstab_uuid)] - pub uuid: uuid::Uuid, + /// External UUID of the bcachefs filesystem + /// + /// Accepts the UUID as is or as fstab style UUID= + #[arg(value_parser=parse_fstab_uuid)] + pub uuid: uuid::Uuid, - /// Where the filesystem should be mounted. If not set, then the filesystem - /// won't actually be mounted. But all steps preceeding mounting the - /// filesystem (e.g. asking for passphrase) will still be performed. - pub mountpoint: Option, + /// Where the filesystem should be mounted. If not set, then the filesystem + /// won't actually be mounted. But all steps preceeding mounting the + /// filesystem (e.g. asking for passphrase) will still be performed. + pub mountpoint: Option, - /// Mount options - #[arg(short, default_value = "")] - pub options: String, + /// Mount options + #[arg(short, default_value = "")] + pub options: String, } pub mod filesystem; @@ -105,6 +105,6 @@ pub mod key; #[test] fn verify_cli() { - use clap::CommandFactory; - Cli::command().debug_assert() + use clap::CommandFactory; + Cli::command().debug_assert() } diff --git a/rust-src/mount/src/main.rs b/rust-src/mount/src/main.rs index 66a60d9a..3e4cee89 100644 --- a/rust-src/mount/src/main.rs +++ b/rust-src/mount/src/main.rs @@ -1,64 +1,57 @@ - use clap::Parser; fn main() { - // convert existing log statements to tracing events - // tracing_log::LogTracer::init().expect("logtracer init failed!"); - // format tracing log data to env_logger like stdout - tracing_subscriber::fmt::init(); - - if let Err(e) = crate::main_inner() { - tracing::error!(fatal_error = ?e); - } + // convert existing log statements to tracing events + // tracing_log::LogTracer::init().expect("logtracer init failed!"); + // format tracing log data to env_logger like stdout + tracing_subscriber::fmt::init(); + + if let Err(e) = crate::main_inner() { + tracing::error!(fatal_error = ?e); + } } - #[tracing_attributes::instrument("main")] pub fn main_inner() -> anyhow::Result<()> { - use bcachefs_mount::{Cli, filesystem, key}; - unsafe { - libc::setvbuf( - filesystem::stdout, - std::ptr::null_mut(), - libc::_IONBF, - 0, - ); - // libc::fflush(filesystem::stdout); - } + use bcachefs_mount::{filesystem, key, Cli}; + unsafe { + libc::setvbuf(filesystem::stdout, std::ptr::null_mut(), libc::_IONBF, 0); + // libc::fflush(filesystem::stdout); + } - let opt = Cli::parse(); + let opt = Cli::parse(); - tracing::trace!(?opt); + tracing::trace!(?opt); - let fss = filesystem::probe_filesystems()?; - let fs = fss - .get(&opt.uuid) - .ok_or_else(|| anyhow::anyhow!("filesystem was not found"))?; + let fss = filesystem::probe_filesystems()?; + let fs = fss + .get(&opt.uuid) + .ok_or_else(|| anyhow::anyhow!("filesystem was not found"))?; - tracing::info!(msg="found filesystem", %fs); - if fs.encrypted() { - let key = opt - .key_location - .0 - .ok_or_else(|| anyhow::anyhow!("no keyoption specified for locked filesystem"))?; + tracing::info!(msg="found filesystem", %fs); + if fs.encrypted() { + let key = opt + .key_location + .0 + .ok_or_else(|| anyhow::anyhow!("no keyoption specified for locked filesystem"))?; - key::prepare_key(&fs, key)?; - } + key::prepare_key(&fs, key)?; + } - let mountpoint = opt - .mountpoint - .ok_or_else(|| anyhow::anyhow!("mountpoint option was not specified"))?; + let mountpoint = opt + .mountpoint + .ok_or_else(|| anyhow::anyhow!("mountpoint option was not specified"))?; - fs.mount(&mountpoint, &opt.options)?; + fs.mount(&mountpoint, &opt.options)?; - Ok(()) + Ok(()) } #[cfg(test)] mod test { - // use insta::assert_debug_snapshot; - // #[test] - // fn snapshot_testing() { - // insta::assert_debug_snapshot!(); - // } + // use insta::assert_debug_snapshot; + // #[test] + // fn snapshot_testing() { + // insta::assert_debug_snapshot!(); + // } } -- cgit v1.2.3