mirror of
https://github.com/koverstreet/bcachefs-tools.git
synced 2025-01-22 00:04:31 +03:00
rust: use rustfmt defaults
follow the kernel style guide, i.e idiomatic rust style. Signed-off-by: Alexander Fougner <fougner89@gmail.com>
This commit is contained in:
Alexander Fougner
parent
bdc290eee0
commit
20aecb42d8
@ -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`");
|
||||
}
|
||||
|
||||
@ -1,2 +1,3 @@
|
||||
max_width=120
|
||||
hard_tabs = true
|
||||
# Default settings, i.e. idiomatic rust
|
||||
edition = "2021"
|
||||
newline_style = "Unix"
|
||||
@ -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<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)]
|
||||
|
||||
@ -3,5 +3,5 @@ pub mod keyutils;
|
||||
pub mod rs;
|
||||
|
||||
pub mod c {
|
||||
pub use crate::bcachefs::*;
|
||||
pub use crate::bcachefs::*;
|
||||
}
|
||||
|
||||
@ -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<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();
|
||||
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())?;
|
||||
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();
|
||||
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");
|
||||
// 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);
|
||||
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",
|
||||
)))
|
||||
}
|
||||
}
|
||||
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)
|
||||
}
|
||||
|
||||
@ -1,2 +1,3 @@
|
||||
max_width=120
|
||||
hard_tabs = true
|
||||
# Default settings, i.e. idiomatic rust
|
||||
edition = "2021"
|
||||
newline_style = "Unix"
|
||||
@ -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<PathBuf>,
|
||||
/// 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(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 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");
|
||||
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)
|
||||
})
|
||||
}
|
||||
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},
|
||||
};
|
||||
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)?;
|
||||
// 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()),
|
||||
}
|
||||
// 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 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 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<HashMap<Uuid, FileSystem>> {
|
||||
tracing::trace!("enumerating udev devices");
|
||||
let mut udev = udev::Enumerator::new()?;
|
||||
tracing::trace!("enumerating udev devices");
|
||||
let mut udev = udev::Enumerator::new()?;
|
||||
|
||||
udev.match_subsystem("block")?; // find kernel block devices
|
||||
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)? {
|
||||
let mut fs_map = HashMap::new();
|
||||
let devresults = udev
|
||||
.scan_devices()?
|
||||
.into_iter()
|
||||
.filter_map(|dev| dev.devnode().map(ToOwned::to_owned));
|
||||
|
||||
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)
|
||||
});
|
||||
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);
|
||||
},
|
||||
fs.devices.push(pathbuf);
|
||||
}
|
||||
|
||||
Err(e) => { tracing::debug!(inner2_error=?e);}
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
tracing::debug!(inner2_error=?e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
tracing::info!(msg = "found filesystems", count = fs_map.len());
|
||||
Ok(fs_map)
|
||||
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();
|
||||
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 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);
|
||||
let uuid = (&super_block).sb().uuid();
|
||||
tracing::debug!(found="bcachefs superblock", devnode=?path, ?uuid);
|
||||
|
||||
Ok(Ok((uuid, super_block)))
|
||||
Ok(Ok((uuid, super_block)))
|
||||
}
|
||||
|
||||
@ -1,97 +1,97 @@
|
||||
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),
|
||||
}
|
||||
}
|
||||
|
||||
@ -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<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;
|
||||
@ -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()
|
||||
}
|
||||
|
||||
@ -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();
|
||||
// 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);
|
||||
}
|
||||
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!();
|
||||
// }
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user