2 use bch_bindgen::{bcachefs, bcachefs::bch_sb_handle, opt_set};
3 use log::{info, debug, error, LevelFilter};
6 use std::path::PathBuf;
8 use crate::key::KeyLocation;
9 use std::ffi::{CString, c_char, c_void};
10 use std::os::unix::ffi::OsStrExt;
14 target: impl AsRef<std::path::Path>,
16 mountflags: libc::c_ulong,
18 ) -> anyhow::Result<()> {
20 // bind the CStrings to keep them alive
21 let src = CString::new(src)?;
22 let target = CString::new(target.as_ref().as_os_str().as_bytes())?;
23 let data = data.map(CString::new).transpose()?;
24 let fstype = CString::new(fstype)?;
26 // convert to pointers for ffi
27 let src = src.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char;
28 let target = target.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char;
29 let data = data.as_ref().map_or(std::ptr::null(), |data| {
30 data.as_c_str().to_bytes_with_nul().as_ptr() as *const c_void
32 let fstype = fstype.as_c_str().to_bytes_with_nul().as_ptr() as *const c_char;
35 info!("mounting filesystem");
36 // REQUIRES: CAP_SYS_ADMIN
37 unsafe { libc::mount(src, target, fstype, mountflags, data) }
41 _ => Err(crate::ErrnoError(errno::errno()).into()),
45 /// Parse a comma-separated mount options and split out mountflags and filesystem
47 fn parse_mount_options(options: impl AsRef<str>) -> (Option<String>, libc::c_ulong) {
48 use either::Either::*;
49 debug!("parsing mount options: {}", options.as_ref());
50 let (opts, flags) = options
54 "dirsync" => Left(libc::MS_DIRSYNC),
55 "lazytime" => Left(1 << 25), // MS_LAZYTIME
56 "mand" => Left(libc::MS_MANDLOCK),
57 "noatime" => Left(libc::MS_NOATIME),
58 "nodev" => Left(libc::MS_NODEV),
59 "nodiratime" => Left(libc::MS_NODIRATIME),
60 "noexec" => Left(libc::MS_NOEXEC),
61 "nosuid" => Left(libc::MS_NOSUID),
62 "relatime" => Left(libc::MS_RELATIME),
63 "remount" => Left(libc::MS_REMOUNT),
64 "ro" => Left(libc::MS_RDONLY),
66 "strictatime" => Left(libc::MS_STRICTATIME),
67 "sync" => Left(libc::MS_SYNCHRONOUS),
71 .fold((Vec::new(), 0), |(mut opts, flags), next| match next {
72 Left(f) => (opts, flags | f),
91 target: impl AsRef<std::path::Path>,
92 options: impl AsRef<str>,
93 ) -> anyhow::Result<()> {
94 let (data, mountflags) = parse_mount_options(options);
97 "mounting bcachefs filesystem, {}",
98 target.as_ref().display()
100 mount_inner(device, target, "bcachefs", mountflags, data)
103 fn read_super_silent(path: &std::path::PathBuf) -> anyhow::Result<bch_sb_handle> {
104 let mut opts = bcachefs::bch_opts::default();
105 opt_set!(opts, noexcl, 1);
107 bch_bindgen::sb_io::read_super_silent(&path, opts)
110 fn get_devices_by_uuid(uuid: Uuid) -> anyhow::Result<Vec<(PathBuf, bch_sb_handle)>> {
111 debug!("enumerating udev devices");
112 let mut udev = udev::Enumerator::new()?;
114 udev.match_subsystem("block")?;
119 .filter_map(|dev| dev.devnode().map(ToOwned::to_owned))
120 .map(|dev| (dev.clone(), read_super_silent(&dev)))
121 .filter_map(|(dev, sb)| sb.ok().map(|sb| (dev, sb)))
122 .filter(|(_, sb)| sb.sb().uuid() == uuid)
127 /// Mount a bcachefs filesystem by its UUID.
128 #[derive(Parser, Debug)]
129 #[command(author, version, about, long_about = None)]
131 /// Where the password would be loaded from.
133 /// Possible values are:
134 /// "fail" - don't ask for password, fail if filesystem is encrypted;
135 /// "wait" - wait for password to become available before mounting;
136 /// "ask" - prompt the user for password;
137 #[arg(short, long, default_value = "ask", verbatim_doc_comment)]
138 key_location: KeyLocation,
140 /// Device, or UUID=<UUID>
143 /// Where the filesystem should be mounted. If not set, then the filesystem
144 /// won't actually be mounted. But all steps preceeding mounting the
145 /// filesystem (e.g. asking for passphrase) will still be performed.
146 mountpoint: Option<std::path::PathBuf>,
149 #[arg(short, default_value = "")]
152 /// Force color on/off. Default: autodetect tty
153 #[arg(short, long, action = clap::ArgAction::Set, default_value_t=atty::is(Stream::Stdout))]
157 #[arg(short, long, action = clap::ArgAction::Count)]
161 fn devs_str_sbs_from_uuid(uuid: String) -> anyhow::Result<(String, Vec<bch_sb_handle>)> {
162 debug!("enumerating devices with UUID {}", uuid);
164 let devs_sbs = Uuid::parse_str(&uuid)
165 .map(|uuid| get_devices_by_uuid(uuid))??;
167 let devs_str = devs_sbs
169 .map(|(dev, _)| dev.to_str().unwrap())
173 let sbs: Vec<bch_sb_handle> = devs_sbs.iter().map(|(_, sb)| *sb).collect();
179 fn cmd_mount_inner(opt: Cli) -> anyhow::Result<()> {
180 let (devs, sbs) = if opt.dev.starts_with("UUID=") {
181 let uuid = opt.dev.replacen("UUID=", "", 1);
182 devs_str_sbs_from_uuid(uuid)?
183 } else if opt.dev.starts_with("OLD_BLKID_UUID=") {
184 let uuid = opt.dev.replacen("OLD_BLKID_UUID=", "", 1);
185 devs_str_sbs_from_uuid(uuid)?
187 let mut sbs = Vec::new();
189 for dev in opt.dev.split(':') {
190 let dev = PathBuf::from(dev);
191 sbs.push(read_super_silent(&dev)?);
198 Err(anyhow::anyhow!("No device found from specified parameters"))?;
199 } else if unsafe { bcachefs::bch2_sb_is_encrypted(sbs[0].sb) } {
200 key::prepare_key(&sbs[0], opt.key_location)?;
203 if let Some(mountpoint) = opt.mountpoint {
205 "mounting with params: device: {}, target: {}, options: {}",
207 mountpoint.to_string_lossy(),
211 mount(devs, mountpoint, &opt.options)?;
214 "would mount with params: device: {}, options: {}",
223 pub fn cmd_mount(mut argv: Vec<String>, symlink_cmd: Option<&str>) -> i32 {
224 // If the bcachefs tool is being called as "bcachefs mount dev ..." (as opposed to via a
225 // symlink like "/usr/sbin/mount.bcachefs dev ...", then we need to pop the 0th argument
226 // ("bcachefs") since the CLI parser here expects the device at position 1.
227 if symlink_cmd.is_none() {
231 let opt = Cli::parse_from(argv);
233 // @TODO : more granular log levels via mount option
234 log::set_max_level(match opt.verbose {
235 0 => LevelFilter::Warn,
236 1 => LevelFilter::Trace,
237 2_u8..=u8::MAX => todo!(),
240 colored::control::set_override(opt.colorize);
241 if let Err(e) = cmd_mount_inner(opt) {
242 error!("Fatal error: {}", e);
245 info!("Successfully mounted");