follow the kernel style guide, i.e idiomatic rust style.
Signed-off-by: Alexander Fougner <fougner89@gmail.com>
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`");
}
-max_width=120
-hard_tabs = true
+# Default settings, i.e. idiomatic rust
+edition = "2021"
+newline_style = "Unix"
\ No newline at end of file
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<bch_scrypt_flags> {
- 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<bch_scrypt_flags> {
+ 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::<LittleEndian>().unwrap();
- let dword2 = internal_uuid.read_u32::<LittleEndian>().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::<LittleEndian>().unwrap();
+ let dword2 = internal_uuid.read_u32::<LittleEndian>().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)]
pub mod rs;
pub mod c {
- pub use crate::bcachefs::*;
+ pub use crate::bcachefs::*;
}
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<T> = std::io::Result<std::io::Result<T>>;
#[tracing_attributes::instrument(skip(opts))]
-pub fn read_super_opts(path: &std::path::Path, mut opts: bcachefs::bch_opts) -> RResult<bcachefs::bch_sb_handle> {
- // 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<bcachefs::bch_sb_handle> {
+ // 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<bcachefs::bch_sb_handle> {
- 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)
}
-max_width=120
-hard_tabs = true
+# Default settings, i.e. idiomatic rust
+edition = "2021"
+newline_style = "Unix"
\ No newline at end of file
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")]
+ /// 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<PathBuf>,
}
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<std::path::Path>,
- options: impl AsRef<str>,
- ) -> 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<std::path::Path>,
+ options: impl AsRef<str>,
+ ) -> 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<std::path::Path>,
- fstype: &str,
- mountflags: u64,
- data: Option<String>,
+ src: String,
+ target: impl AsRef<std::path::Path>,
+ fstype: &str,
+ mountflags: u64,
+ data: Option<String>,
) -> 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<str>) -> (Option<String>, 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;
#[tracing_attributes::instrument]
pub fn probe_filesystems() -> anyhow::Result<HashMap<Uuid, FileSystem>> {
- 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<std::io::Result<(Uuid, bcachefs::bch_sb_handle)>> {
- 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<std::io::Result<(Uuid, bcachefs::bch_sb_handle)>> {
+ 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)))
}
use tracing::info;
fn check_for_key(key_name: &std::ffi::CStr) -> anyhow::Result<bool> {
- 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::<LittleEndian>().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::<LittleEndian>().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::<bch_encrypted_key>() 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::<bch_key>() 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::<bch_encrypted_key>() 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::<bch_key>() 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),
+ }
}
use uuid::Uuid;
pub mod err {
- pub enum GError {
- Unknown{
- message: std::borrow::Cow<'static, String>
- }
- }
- pub type GResult<T, E, OE> =::core::result::Result< ::core::result::Result<T, E>, OE>;
- pub type Result<T, E> = GResult<T, E, GError>;
+ pub enum GError {
+ Unknown {
+ message: std::borrow::Cow<'static, String>,
+ },
+ }
+ pub type GResult<T, E, OE> = ::core::result::Result<::core::result::Result<T, E>, OE>;
+ pub type Result<T, E> = GResult<T, E, GError>;
}
#[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<KeyLocation>);
impl std::ops::Deref for KeyLoc {
- type Target = Option<KeyLocation>;
- fn deref(&self) -> &Self::Target {
- &self.0
- }
+ type Target = Option<KeyLocation>;
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
}
impl std::str::FromStr for KeyLoc {
- type Err = anyhow::Error;
- fn from_str(s: &str) -> anyhow::Result<Self> {
- // 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<Self> {
+ // 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<Uuid, uuid::Error> {
- 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=<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=<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<std::path::PathBuf>,
+ /// 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<std::path::PathBuf>,
- /// Mount options
- #[arg(short, default_value = "")]
- pub options: String,
+ /// Mount options
+ #[arg(short, default_value = "")]
+ pub options: String,
}
pub mod filesystem;
#[test]
fn verify_cli() {
- use clap::CommandFactory;
- Cli::command().debug_assert()
+ use clap::CommandFactory;
+ Cli::command().debug_assert()
}
-
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!();
+ // }
}
projects / bcachefs-tools-debian / commitdiff