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 <ckyrouac@redhat.com>

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,27 @@
+use anyhow::Result;
+use bootc_mount::Filesystem;
+
+pub(crate) fn check_root_siblings() -> Result<Vec<String>> {
+    let mounts = bootc_mount::run_findmnt(&[], None)?;
+    let problem_filesystems: Vec<String> = 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(|zs| {
+            format!(
+                "Type: {}, Mount Point: {}, Source: {}",
+                zs.fstype, zs.target, zs.source
+            )
+        })
+        .collect();
+    Ok(problem_filesystems)
+}

system-reinstall-bootc/src/btrfs.rs

@@ -0,0 +1,103 @@
+use std::process::{Command, Stdio};
+
+use anyhow::Result;
+use bootc_mount::run_findmnt;
+use bootc_utils::CommandRunExt;
+use serde::Deserialize;
+
+#[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,
+}
+
+pub(crate) fn binary_available(binary: &str) -> bool {
+    Command::new("which")
+        .arg(binary)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map(|status| status.success())
+        .unwrap_or(false)
+}
+
+pub(crate) fn parse_volumes(group: Option<String>) -> Result<Vec<LogicalVolume>> {
+    if !binary_available("lvs") {
+        tracing::debug!("lvs binary not found. Skipping logical volume check.");
+        return Ok(Vec::<LogicalVolume>::new());
+    }
+
+    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<String>> {
+    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<String> = 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()
+        })
+        .filter_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 {
+                ""
+            };
+
+            if mount_path == "/" {
+                None
+            } else {
+                format!(
+                    "Type: LVM, Mount Point: {}, LV: {}, VG: {}, Size: {}",
+                    mount_path, lv.lv_name, lv.vg_name, lv.lv_size
+                )
+                .into()
+            }
+        })
+        .collect();
+
+    Ok(siblings)
+}

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);
 
@@ -48,6 +52,9 @@ fn run() -> Result<()> {
     println!();
     println!("{}", reinstall_podman_command.to_string_pretty());
 
+    println!();
+    println!("After reboot, the current root will be available in the /sysroot directory. Existing mounts will not be automatically mounted by the bootc system unless they are defined in the bootc image. Some automatic cleanup of the previous root will be performed.");
+
     prompt::temporary_developer_protection_prompt()?;
 
     reinstall_podman_command

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,34 @@ pub(crate) fn ask_yes_no(prompt: &str, default: bool) -> Result<bool> {
         .context("prompting")
 }
 
+pub(crate) fn press_enter() {
+    println!();
+    println!("Press <enter> to continue.");
+
+    loop {
+        if let Event::Key(_) = event::read().unwrap() {
+            break;
+        }
+    }
+}
+
+pub(crate) fn mount_warning() -> Result<()> {
+    let mut mounts = btrfs::check_root_siblings()?;
+    mounts.extend(lvm::check_root_siblings()?);
+
+    if !mounts.is_empty() {
+        println!();
+        println!("NOTICE: the following mounts are left unchanged by this tool and will not be automatically mounted unless specified in the bootc image. Consult the bootc documentation to determine the appropriate action for your system.");
+        println!();
+        for m in mounts {
+            println!("{m}");
+        }
+        press_enter();
+    }
+
+    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