summaryrefslogtreecommitdiff
path: root/rust-src/src/cmd_mount.rs
diff options
context:
space:
mode:
Diffstat (limited to 'rust-src/src/cmd_mount.rs')
-rw-r--r--rust-src/src/cmd_mount.rs196
1 files changed, 157 insertions, 39 deletions
diff --git a/rust-src/src/cmd_mount.rs b/rust-src/src/cmd_mount.rs
index 7748b199..af830d77 100644
--- a/rust-src/src/cmd_mount.rs
+++ b/rust-src/src/cmd_mount.rs
@@ -1,18 +1,128 @@
-use bch_bindgen::{error, info};
+use atty::Stream;
+use bch_bindgen::{bcachefs, bcachefs::bch_sb_handle, debug, error, info};
use clap::Parser;
use colored::Colorize;
-use atty::Stream;
use uuid::Uuid;
-use crate::filesystem;
+use std::path::PathBuf;
use crate::key;
use crate::key::KeyLoc;
-
-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);
+use std::ffi::{CStr, CString, OsStr, c_int, c_char, c_void};
+use std::os::unix::ffi::OsStrExt;
+
+fn mount_inner(
+ src: String,
+ target: impl AsRef<std::path::Path>,
+ fstype: &str,
+ mountflags: u64,
+ data: Option<String>,
+) -> anyhow::Result<()> {
+
+ // 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 = {
+ 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()),
}
- return Uuid::parse_str(&uuid);
+}
+
+/// Parse a comma-separated mount options and split out mountflags and filesystem
+/// specific options.
+fn parse_mount_options(options: impl AsRef<str>) -> (Option<String>, u64) {
+ use either::Either::*;
+ debug!("parsing mount 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),
+ "relatime" => Left(libc::MS_RELATIME),
+ "remount" => Left(libc::MS_REMOUNT),
+ "ro" => Left(libc::MS_RDONLY),
+ "rw" => Left(0),
+ "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,
+ )
+}
+
+fn mount(
+ device: String,
+ target: impl AsRef<std::path::Path>,
+ options: impl AsRef<str>,
+) -> anyhow::Result<()> {
+ let (data, mountflags) = parse_mount_options(options);
+
+ info!(
+ "mounting bcachefs filesystem, {}",
+ target.as_ref().display()
+ );
+ mount_inner(device, target, "bcachefs", mountflags, data)
+}
+
+fn read_super_silent(path: &std::path::PathBuf) -> std::io::Result<bch_sb_handle> {
+ // Stop libbcachefs from spamming the output
+ let _gag = gag::BufferRedirect::stdout().unwrap();
+
+ bch_bindgen::rs::read_super(&path)?
+}
+
+fn get_devices_by_uuid(uuid: Uuid) -> anyhow::Result<Vec<(PathBuf, bch_sb_handle)>> {
+ debug!("enumerating udev devices");
+ let mut udev = udev::Enumerator::new()?;
+
+ udev.match_subsystem("block")?;
+
+ let devs = udev
+ .scan_devices()?
+ .into_iter()
+ .filter_map(|dev| dev.devnode().map(ToOwned::to_owned))
+ .map(|dev| (dev.clone(), read_super_silent(&dev)))
+ .filter_map(|(dev, sb)| sb.ok().map(|sb| (dev, sb)))
+ .filter(|(_, sb)| sb.sb().uuid() == uuid)
+ .collect();
+ Ok(devs)
}
fn stdout_isatty() -> &'static str {
@@ -26,7 +136,7 @@ fn stdout_isatty() -> &'static str {
/// Mount a bcachefs filesystem by its UUID.
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
-pub struct Cli {
+struct Cli {
/// Where the password would be loaded from.
///
/// Possible values are:
@@ -34,63 +144,71 @@ pub struct Cli {
/// "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,
+ 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,
+ /// Device, or UUID=<UUID>
+ dev: String,
/// 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>,
+ mountpoint: std::path::PathBuf,
/// Mount options
#[arg(short, default_value = "")]
- pub options: String,
+ options: String,
/// Force color on/off. Default: autodetect tty
#[arg(short, long, action = clap::ArgAction::Set, default_value=stdout_isatty())]
- pub colorize: bool,
+ colorize: bool,
#[arg(short = 'v', long, action = clap::ArgAction::Count)]
- pub verbose: u8,
+ verbose: u8,
}
-pub fn cmd_mount_inner(opt: Cli) -> anyhow::Result<()> {
- unsafe {
- libc::setvbuf(filesystem::stdout, std::ptr::null_mut(), libc::_IONBF, 0);
- }
+fn cmd_mount_inner(opt: Cli) -> anyhow::Result<()> {
+ let (devs, sbs) = if opt.dev.starts_with("UUID=") {
+ let uuid = opt.dev.replacen("UUID=", "", 1);
+ let uuid = Uuid::parse_str(&uuid)?;
+ let devs_sbs = get_devices_by_uuid(uuid)?;
+
+ let devs_strs: Vec<_> = devs_sbs.iter().map(|(dev, _)| dev.clone().into_os_string().into_string().unwrap()).collect();
+ let devs_str = devs_strs.join(":");
+ let sbs = devs_sbs.iter().map(|(_, sb)| *sb).collect();
+
+ (devs_str, sbs)
+ } else {
+ let mut sbs = Vec::new();
+
+ for dev in opt.dev.split(':') {
+ let dev = PathBuf::from(dev);
+ sbs.push(bch_bindgen::rs::read_super(&dev)??);
+ }
- let fss = filesystem::probe_filesystems()?;
- let fs = fss
- .get(&opt.uuid)
- .ok_or_else(|| anyhow::anyhow!("filesystem was not found"))?;
+ (opt.dev, sbs)
+ };
- info!("found filesystem {}", fs);
- if fs.encrypted() {
+ if unsafe { bcachefs::bch2_sb_is_encrypted(sbs[0].sb) } {
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(&sbs[0], key)?;
}
- let mountpoint = opt
- .mountpoint
- .ok_or_else(|| anyhow::anyhow!("mountpoint option was not specified"))?;
-
- fs.mount(&mountpoint, &opt.options)?;
-
+ mount(devs, &opt.mountpoint, &opt.options)?;
Ok(())
}
#[no_mangle]
-pub extern "C" fn cmd_mount() {
- let opt = Cli::parse();
+pub extern "C" fn cmd_mount(argc: c_int, argv: *const *const c_char) {
+ let argv: Vec<_> = (0..argc)
+ .map(|i| unsafe { CStr::from_ptr(*argv.add(i as usize)) })
+ .map(|i| OsStr::from_bytes(i.to_bytes()))
+ .collect();
+
+ let opt = Cli::parse_from(argv);
bch_bindgen::log::set_verbose_level(opt.verbose + bch_bindgen::log::ERROR);
colored::control::set_override(opt.colorize);
if let Err(e) = cmd_mount_inner(opt) {
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-01 18:01:40 +0000