reinstall: Add warnings about mounts

This uses findmnt to locate filesystem mounts that are on the same
source as the root mount. If any are found, the user is warned these
filesystems will persist unmounted in the bootc system. The user must
hit <enter> to proceed.

This does the same for logical volumes in the same group as root.

It also adds a generic warning to help the user understand what will
happen after rebooting into the bootc system.

Signed-off-by: ckyrouac <[email protected]>

Author: ckyrouac

Cargo.lock

@@ -45,7 +45,7 @@ pub struct Filesystem {
     pub children: Option<Vec<Filesystem>>,
 }
 
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Default)]
 pub struct Findmnt {
     pub filesystems: Vec<Filesystem>,
 }

mount/src/mount.rs

@@ -16,6 +16,7 @@ platforms = ["*-unknown-linux-gnu"]
 
 [dependencies]
 anyhow = { workspace = true }
+bootc-mount = { path = "../mount" }
 bootc-utils = { path = "../utils" }
 clap = { workspace = true, features = ["derive"] }
 crossterm = "0.29.0"

system-reinstall-bootc/Cargo.toml

@@ -0,0 +1,58 @@
+use anyhow::Result;
+use bootc_mount::Filesystem;
+
+use crate::prompt::press_enter;
+
+pub(crate) struct ProblemMount {
+    target: String,
+    fs_type: String,
+    source: String,
+}
+
+impl std::fmt::Display for ProblemMount {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(
+            format!(
+                "Type: {}, Target: {}, Source: {}",
+                self.fs_type, self.target, self.source
+            )
+            .as_str(),
+        )
+    }
+}
+
+pub(crate) fn check_root_siblings() -> Result<Vec<ProblemMount>> {
+    let mounts = bootc_mount::run_findmnt(&[], None)?;
+    let problem_filesystems: Vec<ProblemMount> = mounts
+        .filesystems
+        .iter()
+        .filter(|fs| fs.target == "/")
+        .flat_map(|root| {
+            let children: Vec<&Filesystem> = root
+                .children
+                .iter()
+                .flatten()
+                .filter(|child| child.source == root.source)
+                .collect();
+            children
+        })
+        .map(|fs| ProblemMount {
+            target: fs.target.clone(),
+            fs_type: fs.fstype.clone(),
+            source: fs.source.clone(),
+        })
+        .collect();
+    Ok(problem_filesystems)
+}
+
+pub(crate) fn print_warning(mounts: Vec<ProblemMount>) {
+    if !mounts.is_empty() {
+        println!();
+        println!("NOTICE: the following filesystems are currently mounted on the same drive as root. After reboot, these will not be automatically mounted unless defined in the bootc image. The filesystems will be preserved and continue to consume disk space. Consult the bootc documentation to determine the appropriate action for your system.");
+        println!();
+        for m in mounts {
+            println!("{}", m);
+        }
+        press_enter();
+    }
+}

system-reinstall-bootc/src/btrfs.rs

@@ -0,0 +1,103 @@
+use std::process::Command;
+
+use anyhow::Result;
+use bootc_mount::run_findmnt;
+use bootc_utils::CommandRunExt;
+use serde::Deserialize;
+
+use crate::prompt::press_enter;
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct Lvs {
+    report: Vec<LvsReport>,
+}
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct LvsReport {
+    lv: Vec<LogicalVolume>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub(crate) struct LogicalVolume {
+    lv_name: String,
+    lv_size: String,
+    lv_path: String,
+    vg_name: String,
+    #[serde(default)]
+    mount_path: String,
+}
+
+pub(crate) fn parse_volumes(group: Option<String>) -> Result<Vec<LogicalVolume>> {
+    let mut cmd = Command::new("lvs");
+    cmd.args([
+        "--reportformat=json",
+        "-o",
+        "lv_name,lv_size,lv_path,vg_name",
+    ]);
+
+    if let Some(group) = group {
+        cmd.arg(group);
+    }
+
+    let output: Lvs = cmd.run_and_parse_json()?;
+
+    Ok(output
+        .report
+        .iter()
+        .flat_map(|r| r.lv.iter().cloned())
+        .collect())
+}
+
+pub(crate) fn check_root_siblings() -> Result<Vec<LogicalVolume>> {
+    let all_volumes = parse_volumes(None)?;
+
+    // first look for a lv mounted to '/'
+    // then gather all the sibling lvs in the vg along with their mount points
+    let siblings: Vec<LogicalVolume> = all_volumes
+        .iter()
+        .filter(|lv| {
+            let mount = run_findmnt(&["-S", &lv.lv_path], None).unwrap_or_default();
+            if let Some(fs) = mount.filesystems.first() {
+                &fs.target == "/"
+            } else {
+                false
+            }
+        })
+        .flat_map(|root_lv| {
+            tracing::warn!("inside flat_map");
+            parse_volumes(Some(root_lv.vg_name.clone())).unwrap_or_default()
+        })
+        .map(|lv| {
+            tracing::warn!("inside map");
+            let mount = run_findmnt(&["-S", &lv.lv_path], None).unwrap();
+            let mount_path = if let Some(fs) = mount.filesystems.first() {
+                &fs.target
+            } else {
+                ""
+            };
+            LogicalVolume {
+                lv_name: lv.lv_name,
+                lv_size: lv.lv_size,
+                lv_path: lv.lv_path,
+                vg_name: lv.vg_name,
+                mount_path: mount_path.to_string(),
+            }
+        })
+        .filter(|lv| lv.mount_path != "/")
+        .collect();
+
+    Ok(siblings)
+}
+
+pub(crate) fn print_warning(volumes: Vec<LogicalVolume>) {
+    println!();
+    println!("NOTICE: the following logical volumes are in the same volume group as root. After reboot, these will not be automatically mounted unless defined in the bootc image. The filesystems will be preserved and continue to consume disk space. Consult the bootc documentation to determine the appropriate action for your system.");
+    println!();
+    for vol in volumes {
+        println!(
+            "Mount Path: {}, Name: {}, Size: {}, Group: {}",
+            vol.mount_path, vol.lv_name, vol.lv_size, vol.vg_name
+        );
+    }
+    press_enter();
+}

system-reinstall-bootc/src/lvm.rs

@@ -4,7 +4,9 @@ use anyhow::{ensure, Context, Result};
 use bootc_utils::CommandRunExt;
 use rustix::process::getuid;
 
+mod btrfs;
 mod config;
+mod lvm;
 mod podman;
 mod prompt;
 pub(crate) mod users;
@@ -40,6 +42,8 @@ fn run() -> Result<()> {
 
     prompt::get_ssh_keys(ssh_key_file_path)?;
 
+    prompt::mount_warning()?;
+
     let mut reinstall_podman_command =
         podman::reinstall_command(&config.bootc_image, ssh_key_file_path);
 

system-reinstall-bootc/src/main.rs

@@ -1,4 +1,4 @@
-use crate::{prompt, users::get_all_users_keys};
+use crate::{btrfs, lvm, prompt, users::get_all_users_keys};
 use anyhow::{ensure, Context, Result};
 
 use crossterm::event::{self, Event};
@@ -92,6 +92,46 @@ pub(crate) fn ask_yes_no(prompt: &str, default: bool) -> Result<bool> {
         .context("prompting")
 }
 
+fn check_lvm_mounts() -> Result<()> {
+    let siblings = lvm::check_root_siblings()?;
+    if !siblings.is_empty() {
+        lvm::print_warning(siblings);
+    }
+    Ok(())
+}
+
+fn check_btrfs_mounts() -> Result<()> {
+    let siblings = btrfs::check_root_siblings()?;
+    if !siblings.is_empty() {
+        btrfs::print_warning(siblings);
+    }
+    Ok(())
+}
+
+pub(crate) fn press_enter() {
+    println!();
+    println!("Press <enter> to continue.");
+
+    loop {
+        if let Event::Key(_) = event::read().unwrap() {
+            break;
+        }
+    }
+}
+
+fn generic_warning() {
+    println!();
+    println!("NOTICE: the reinstall procedure will switch to use the bootc image as the system root. The current root will be available in the /sysroot directory. Some automatic cleanup of the old root is performed on reboot. Any existing mounts will not be automatically mounted by the bootc system unless they are defined in the bootc image.");
+    press_enter()
+}
+
+pub(crate) fn mount_warning() -> Result<()> {
+    check_lvm_mounts()?;
+    check_btrfs_mounts()?;
+    generic_warning();
+    Ok(())
+}
+
 /// Gather authorized keys for all user's of the host system
 /// prompt the user to select which users's keys will be imported
 /// into the target system's root user's authorized_keys file