548 lines
18 KiB
Rust
548 lines
18 KiB
Rust
//! GPT partitioning, filesystems, Btrfs layout, fstab/crypttab generation.
|
|
//!
|
|
//! The order is the proven one: partition, create ESP, LUKS format/open,
|
|
//! mkfs.btrfs, mount top-level, create subvolumes, unmount top-level, mount the
|
|
//! subvolume layout. fstab/crypttab are written *after* stage3 extraction.
|
|
|
|
use phoebus_core::system as sysgen;
|
|
use phoebus_core::{Encryption, InstallConfig, SecretString};
|
|
|
|
use crate::auth::DestructiveAuthorization;
|
|
use crate::command::{CommandSpec, ProcessRunner};
|
|
use crate::encryption;
|
|
use crate::error::{ExecError, Result};
|
|
use crate::exec::Exec;
|
|
use crate::probe;
|
|
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct StorageState {
|
|
pub efi_part: String,
|
|
pub root_part: String,
|
|
pub root_source: String,
|
|
pub luks_uuid: Option<String>,
|
|
pub efi_uuid: Option<String>,
|
|
}
|
|
|
|
pub fn require_tools(exec: &Exec) -> Result<()> {
|
|
exec.require_tools(&[
|
|
"sgdisk",
|
|
"partprobe",
|
|
"blkid",
|
|
"wipefs",
|
|
"mkfs.fat",
|
|
"mount",
|
|
"umount",
|
|
])
|
|
}
|
|
|
|
fn disk_transport(runner: &dyn ProcessRunner, disk: &str) -> String {
|
|
let spec = CommandSpec::new("storage_prepare", "disk transport", "lsblk")
|
|
.args(["-dn", "-o", "TRAN", disk]);
|
|
match runner.execute(&spec) {
|
|
Ok(out) => out.stdout_lossy().trim().to_string(),
|
|
Err(_) => String::new(),
|
|
}
|
|
}
|
|
|
|
/// The full storage preparation for a whole-disk install.
|
|
pub fn prepare(
|
|
exec: &Exec,
|
|
config: &InstallConfig,
|
|
auth: &DestructiveAuthorization,
|
|
passphrase: Option<&SecretString>,
|
|
state: &mut StorageState,
|
|
) -> Result<()> {
|
|
let disk = &config.storage.disk;
|
|
let root = exec.target();
|
|
|
|
wipe(exec, auth, disk)?;
|
|
create_gpt(exec, auth, config, disk)?;
|
|
identify_partitions(exec, disk, state)?;
|
|
if state.efi_part.is_empty() || state.root_part.is_empty() {
|
|
return Err(ExecError::operation(
|
|
"storage_prepare",
|
|
"identify partitions",
|
|
"could not identify the created partitions",
|
|
));
|
|
}
|
|
|
|
mkfs_efi(exec, auth, &state.efi_part)?;
|
|
prepare_root(exec, auth, config, passphrase, state)?;
|
|
create_layout(exec, auth, config, &state.root_source, exec.root.as_path())?;
|
|
mount_efi(exec, config, &state.efi_part, exec.root.as_path())?;
|
|
create_swapfile(exec, config, &root, &state.root_source)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn wipe(exec: &Exec, _auth: &DestructiveAuthorization, disk: &str) -> Result<()> {
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "wipe partition signatures", "wipefs")
|
|
.arg("-a")
|
|
.arg(disk),
|
|
)?;
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "zap GPT/MBR", "sgdisk")
|
|
.arg("--zap-all")
|
|
.arg(disk),
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn create_gpt(
|
|
exec: &Exec,
|
|
_auth: &DestructiveAuthorization,
|
|
config: &InstallConfig,
|
|
disk: &str,
|
|
) -> Result<()> {
|
|
let root_type = if config.is_encrypted() {
|
|
"8309"
|
|
} else {
|
|
"8300"
|
|
};
|
|
let efi = config.storage.efi_size_mib;
|
|
let mut spec = CommandSpec::new("storage_prepare", "create GPT", "sgdisk")
|
|
.arg("--set-alignment=2048")
|
|
.arg(format!("--new=1:0:+{efi}M"))
|
|
.arg("--typecode=1:ef00")
|
|
.arg("--change-name=1:EFI")
|
|
.arg("--new=2:0:0")
|
|
.arg(format!("--typecode=2:{root_type}"))
|
|
.arg("--change-name=2:phoebus-root")
|
|
.arg(disk);
|
|
// The final positional disk must come last; CommandSpec preserves order.
|
|
spec.stage = "storage_prepare".into();
|
|
exec.run(spec)?;
|
|
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "re-read partition table", "partprobe").arg(disk),
|
|
)?;
|
|
if crate::exec::find_in_path("udevadm").is_some() {
|
|
exec.run(CommandSpec::new("storage_prepare", "settle udev", "udevadm").arg("settle"))?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Identify the EFI and root partitions by GPT label, falling back to order.
|
|
pub fn identify_partitions(exec: &Exec, disk: &str, state: &mut StorageState) -> Result<()> {
|
|
let runner = exec.runner.as_ref();
|
|
let parts = probe::disk_partitions(runner, disk);
|
|
state.efi_part.clear();
|
|
state.root_part.clear();
|
|
for part in &parts {
|
|
match probe::blkid_partlabel(runner, part).as_deref() {
|
|
Some("EFI") => state.efi_part = part.clone(),
|
|
Some("phoebus-root") => state.root_part = part.clone(),
|
|
_ => {}
|
|
}
|
|
}
|
|
if state.efi_part.is_empty() {
|
|
if let Some(p) = parts.first() {
|
|
state.efi_part = p.clone();
|
|
}
|
|
}
|
|
if state.root_part.is_empty() {
|
|
if let Some(p) = parts.get(1) {
|
|
state.root_part = p.clone();
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn mkfs_efi(exec: &Exec, _auth: &DestructiveAuthorization, part: &str) -> Result<()> {
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "create FAT32 EFI filesystem", "mkfs.fat")
|
|
.args(["-F32", "-n", "EFI"])
|
|
.arg(part),
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn prepare_root(
|
|
exec: &Exec,
|
|
auth: &DestructiveAuthorization,
|
|
config: &InstallConfig,
|
|
passphrase: Option<&SecretString>,
|
|
state: &mut StorageState,
|
|
) -> Result<()> {
|
|
state.root_part = state.root_part.clone();
|
|
if config.encryption.mode == Encryption::None {
|
|
mkfs_btrfs(exec, auth, config, &state.root_part)?;
|
|
state.root_source = state.root_part.clone();
|
|
state.luks_uuid = None;
|
|
} else {
|
|
let passphrase = passphrase.ok_or_else(|| {
|
|
ExecError::operation(
|
|
"storage_prepare",
|
|
"encrypt root",
|
|
"no passphrase configured",
|
|
)
|
|
})?;
|
|
encryption::luks_format(exec, auth, config, &state.root_part, passphrase)?;
|
|
encryption::luks_open(exec, config, &state.root_part, passphrase)?;
|
|
let mapper = encryption::mapper_path(config);
|
|
mkfs_btrfs(exec, auth, config, &mapper)?;
|
|
state.root_source = mapper;
|
|
state.luks_uuid = probe::blkid_uuid(exec.runner.as_ref(), &state.root_part);
|
|
}
|
|
exec.logger
|
|
.info(format!("root filesystem source: {}", state.root_source));
|
|
Ok(())
|
|
}
|
|
|
|
pub fn mkfs_btrfs(
|
|
exec: &Exec,
|
|
_auth: &DestructiveAuthorization,
|
|
config: &InstallConfig,
|
|
device: &str,
|
|
) -> Result<()> {
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "create Btrfs filesystem", "mkfs.btrfs")
|
|
.args(["-f", "-L", &config.storage.btrfs_label])
|
|
.arg(device),
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Create the subvolume layout and mount it.
|
|
///
|
|
/// The top-level (subvolid=5) must be mounted to create @, @home, ...; only
|
|
/// afterwards can the individual subvolumes be mounted.
|
|
pub fn create_layout(
|
|
exec: &Exec,
|
|
_auth: &DestructiveAuthorization,
|
|
config: &InstallConfig,
|
|
device: &str,
|
|
root: &std::path::Path,
|
|
) -> Result<()> {
|
|
std::fs::create_dir_all(root).map_err(|e| ExecError::io(root.to_path_buf(), e))?;
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "mount Btrfs top-level", "mount")
|
|
.args(["-o", "subvolid=5"])
|
|
.arg(device)
|
|
.arg(root.to_string_lossy().to_string()),
|
|
)?;
|
|
|
|
let mut created = true;
|
|
for sv in &config.storage.subvols {
|
|
let target = root.join(sv);
|
|
let res = exec.run(
|
|
CommandSpec::new("storage_prepare", format!("create subvolume {sv}"), "btrfs")
|
|
.args(["subvolume", "create"])
|
|
.arg(target.to_string_lossy().to_string()),
|
|
);
|
|
if res.is_err() {
|
|
created = false;
|
|
break;
|
|
}
|
|
}
|
|
if !created {
|
|
let _ = exec.run(
|
|
CommandSpec::new("storage_prepare", "unmount top-level", "umount")
|
|
.arg(root.to_string_lossy().to_string()),
|
|
);
|
|
return Err(ExecError::operation(
|
|
"storage_prepare",
|
|
"create subvolumes",
|
|
"a subvolume could not be created",
|
|
));
|
|
}
|
|
|
|
set_default_subvolume(exec, root).ok();
|
|
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "unmount top-level", "umount")
|
|
.arg(root.to_string_lossy().to_string()),
|
|
)?;
|
|
|
|
mount_layout(exec, config, device, root)
|
|
}
|
|
|
|
fn set_default_subvolume(exec: &Exec, root: &std::path::Path) -> Result<()> {
|
|
let spec = CommandSpec::new("storage_prepare", "list subvolumes", "btrfs")
|
|
.args(["subvolume", "list", "-o"])
|
|
.arg(root.to_string_lossy().to_string());
|
|
let out = exec.runner.execute(&spec)?;
|
|
let mut id: Option<String> = None;
|
|
for line in out.stdout_lossy().lines() {
|
|
let fields: Vec<&str> = line.split_whitespace().collect();
|
|
if fields.last() == Some(&"@") && fields.len() >= 2 {
|
|
id = Some(fields[1].to_string());
|
|
}
|
|
}
|
|
if let Some(id) = id {
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "set @ as default", "btrfs")
|
|
.args(["subvolume", "set-default", &id])
|
|
.arg(root.to_string_lossy().to_string()),
|
|
)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn ssd_for(exec: &Exec, config: &InstallConfig) -> bool {
|
|
let transport = disk_transport(exec.runner.as_ref(), &config.storage.disk);
|
|
transport == "nvme" || transport == "sata"
|
|
}
|
|
|
|
pub fn btrfs_mount_opts(exec: &Exec, config: &InstallConfig) -> String {
|
|
sysgen::btrfs_mount_opts(&config.storage.compress, ssd_for(exec, config))
|
|
}
|
|
|
|
pub fn mount_layout(
|
|
exec: &Exec,
|
|
config: &InstallConfig,
|
|
device: &str,
|
|
root: &std::path::Path,
|
|
) -> Result<()> {
|
|
let opts = btrfs_mount_opts(exec, config);
|
|
std::fs::create_dir_all(root).map_err(|e| ExecError::io(root.to_path_buf(), e))?;
|
|
let root_sv = config.storage.root_subvolume();
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "mount root subvolume", "mount")
|
|
.arg("-o")
|
|
.arg(format!("{opts},subvol={root_sv}"))
|
|
.arg(device)
|
|
.arg(root.to_string_lossy().to_string()),
|
|
)?;
|
|
for (sv, target) in [
|
|
("@home", "home"),
|
|
("@var", "var"),
|
|
("@snapshots", ".snapshots"),
|
|
("@swap", "swap"),
|
|
] {
|
|
if !config.storage.subvols.iter().any(|s| s == sv) {
|
|
continue;
|
|
}
|
|
let mp = root.join(target);
|
|
std::fs::create_dir_all(&mp).map_err(|e| ExecError::io(mp.clone(), e))?;
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", format!("mount {sv}"), "mount")
|
|
.arg("-o")
|
|
.arg(format!("{opts},subvol={sv}"))
|
|
.arg(device)
|
|
.arg(mp.to_string_lossy().to_string()),
|
|
)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn mount_efi(
|
|
exec: &Exec,
|
|
config: &InstallConfig,
|
|
part: &str,
|
|
root: &std::path::Path,
|
|
) -> Result<()> {
|
|
let mp = root.join(config.storage.efi_mount.trim_start_matches('/'));
|
|
std::fs::create_dir_all(&mp).map_err(|e| ExecError::io(mp.clone(), e))?;
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "mount EFI", "mount")
|
|
.arg(part)
|
|
.arg(mp.to_string_lossy().to_string()),
|
|
)?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn create_swapfile(
|
|
exec: &Exec,
|
|
config: &InstallConfig,
|
|
root: &phoebus_core::TargetRoot,
|
|
_root_source: &str,
|
|
) -> Result<()> {
|
|
let swapdir = root.ensure_dir("swap")?;
|
|
let swapfile = swapdir.join("swapfile");
|
|
let size_mib = swap_size_mib(exec);
|
|
let spec = CommandSpec::new("storage_prepare", "create Btrfs swapfile", "btrfs")
|
|
.args([
|
|
"filesystem",
|
|
"mkswapfile",
|
|
"--size",
|
|
&format!("{size_mib}m"),
|
|
])
|
|
.arg(swapfile.to_string_lossy().to_string());
|
|
if exec.run(spec).is_ok() {
|
|
return Ok(());
|
|
}
|
|
// Fallback for older btrfs-progs.
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "create swapfile container", "truncate")
|
|
.args(["-s", &format!("{size_mib}M")])
|
|
.arg(swapfile.to_string_lossy().to_string()),
|
|
)?;
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "disable CoW on swapfile", "chattr")
|
|
.arg("+C")
|
|
.arg(swapfile.to_string_lossy().to_string()),
|
|
)?;
|
|
exec.run(
|
|
CommandSpec::new("storage_prepare", "make swap", "mkswap")
|
|
.arg(swapfile.to_string_lossy().to_string()),
|
|
)?;
|
|
let _ = config;
|
|
Ok(())
|
|
}
|
|
|
|
fn swap_size_mib(_exec: &Exec) -> u64 {
|
|
let mem = read_mem_mib();
|
|
let swap = if mem == 0 { 4096 } else { mem / 2 };
|
|
swap.clamp(1024, 8192)
|
|
}
|
|
|
|
fn read_mem_mib() -> u64 {
|
|
std::fs::read_to_string("/proc/meminfo")
|
|
.ok()
|
|
.and_then(|text| {
|
|
text.lines().find_map(|l| {
|
|
l.strip_prefix("MemTotal:")
|
|
.and_then(|r| r.split_whitespace().next())
|
|
.and_then(|kb| kb.parse::<u64>().ok())
|
|
.map(|kb| kb / 1024)
|
|
})
|
|
})
|
|
.unwrap_or(0)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// fstab / crypttab
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// The stable fstab source reference: the mapper path when encrypted,
|
|
/// otherwise `UUID=<fs-uuid>`.
|
|
pub fn root_source_ref(exec: &Exec, _config: &InstallConfig, state: &StorageState) -> String {
|
|
if state.root_source.starts_with("/dev/mapper/") {
|
|
state.root_source.clone()
|
|
} else {
|
|
probe::blkid_uuid(exec.runner.as_ref(), &state.root_source)
|
|
.map(|u| format!("UUID={u}"))
|
|
.unwrap_or_else(|| state.root_source.clone())
|
|
}
|
|
}
|
|
|
|
pub fn write_fstab(exec: &Exec, config: &InstallConfig, state: &mut StorageState) -> Result<()> {
|
|
let root = exec.target();
|
|
let src = root_source_ref(exec, config, state);
|
|
let opts = btrfs_mount_opts(exec, config);
|
|
if state.efi_uuid.is_none() {
|
|
state.efi_uuid = probe::blkid_uuid(exec.runner.as_ref(), &state.efi_part);
|
|
}
|
|
let text = sysgen::fstab(config, &src, state.efi_uuid.as_deref(), &opts);
|
|
root.write("etc/fstab", text)?;
|
|
exec.logger.info("wrote /etc/fstab");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn write_crypttab(exec: &Exec, config: &InstallConfig, state: &StorageState) -> Result<()> {
|
|
if !config.is_encrypted() {
|
|
return Ok(());
|
|
}
|
|
let text = encryption::crypttab_line(exec, config, &state.root_part)?;
|
|
exec.target().write("etc/crypttab", text)?;
|
|
exec.logger.info("wrote /etc/crypttab");
|
|
Ok(())
|
|
}
|
|
|
|
/// Unmount children first, the root last.
|
|
pub fn unmount_all(exec: &Exec, config: &InstallConfig, root: &std::path::Path) -> Result<()> {
|
|
let mut mounts = vec![
|
|
config.storage.efi_mount.clone(),
|
|
"/.snapshots".to_string(),
|
|
"/var".to_string(),
|
|
"/home".to_string(),
|
|
"/swap".to_string(),
|
|
String::new(),
|
|
];
|
|
mounts.dedup();
|
|
for m in mounts {
|
|
let target = root.join(m.trim_start_matches('/'));
|
|
let spec = CommandSpec::new("finalize", format!("unmount {m}"), "umount")
|
|
.args(["-R"])
|
|
.arg(target.to_string_lossy().to_string());
|
|
// Best effort.
|
|
let _ = exec.run(spec);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::command::RecordingRunner;
|
|
use crate::log::Logger;
|
|
use phoebus_core::Redactor;
|
|
|
|
fn make_exec(runner: RecordingRunner) -> Exec {
|
|
let path = tempfile::tempdir().unwrap().keep();
|
|
let logger = Logger::open(path.join("l.log"), Redactor::new(), false);
|
|
Exec::new(Box::new(runner), logger, false, path.join("root"), path)
|
|
}
|
|
|
|
#[test]
|
|
fn gpt_uses_luks_type_when_encrypted() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner.clone());
|
|
let cfg = InstallConfig::default();
|
|
let auth = crate::auth::authorize(&crate::auth::AutoConfirm, "p", "f").unwrap();
|
|
create_gpt(&exec, &auth, &cfg, "/dev/vda").unwrap();
|
|
let recorded = runner.recorded();
|
|
let gpt = recorded.iter().find(|s| s.program == "sgdisk").unwrap();
|
|
assert!(gpt.args.iter().any(|a| a == "--typecode=2:8309"));
|
|
assert!(gpt.args.iter().any(|a| a == "--typecode=1:ef00"));
|
|
assert_eq!(gpt.args.last().map(String::as_str), Some("/dev/vda"));
|
|
}
|
|
|
|
#[test]
|
|
fn create_layout_creates_subvolumes_before_mounting_root() {
|
|
let runner = RecordingRunner::new();
|
|
let exec = make_exec(runner.clone());
|
|
let cfg = InstallConfig::default();
|
|
let auth = crate::auth::authorize(&crate::auth::AutoConfirm, "p", "f").unwrap();
|
|
let root = exec.root.clone();
|
|
create_layout(&exec, &auth, &cfg, "/dev/mapper/cryptroot", &root).unwrap();
|
|
let recorded = runner.recorded();
|
|
// Find the first subvolume create and the first subvol=@ mount.
|
|
let create_idx = recorded
|
|
.iter()
|
|
.position(|s| {
|
|
s.program == "btrfs"
|
|
&& s.args.first().map(String::as_str) == Some("subvolume")
|
|
&& s.args.get(1).map(String::as_str) == Some("create")
|
|
})
|
|
.expect("subvolume create");
|
|
let mount_idx = recorded
|
|
.iter()
|
|
.position(|s| s.program == "mount" && s.args.iter().any(|a| a.contains("subvol=@")))
|
|
.expect("subvol mount");
|
|
assert!(
|
|
create_idx < mount_idx,
|
|
"subvolumes must be created before mounting @"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn fstab_and_crypttab_written_into_target() {
|
|
let runner = RecordingRunner::new();
|
|
runner.set_response(
|
|
"blkid",
|
|
crate::command::CommandOutput {
|
|
status: 0,
|
|
success: true,
|
|
stdout: b"1111-2222\n".to_vec(),
|
|
stderr: Vec::new(),
|
|
duration: std::time::Duration::from_millis(1),
|
|
},
|
|
);
|
|
let exec = make_exec(runner.clone());
|
|
let cfg = InstallConfig::default();
|
|
let mut state = StorageState {
|
|
efi_part: "/dev/vda1".into(),
|
|
root_part: "/dev/vda2".into(),
|
|
root_source: "/dev/mapper/cryptroot".into(),
|
|
..Default::default()
|
|
};
|
|
write_fstab(&exec, &cfg, &mut state).unwrap();
|
|
write_crypttab(&exec, &cfg, &state).unwrap();
|
|
let fstab = std::fs::read_to_string(exec.root.join("etc/fstab")).unwrap();
|
|
assert!(fstab.contains("subvol=@swap"));
|
|
let crypttab = std::fs::read_to_string(exec.root.join("etc/crypttab")).unwrap();
|
|
assert!(crypttab.contains("cryptroot UUID=1111-2222 none luks,discard"));
|
|
}
|
|
}
|