kernel_builder/

lib.rs

pub mod boot;
pub mod cli;
pub mod consts;
pub mod discovery;
mod error;

pub use cli::Args;
pub use consts::KernelPaths;
pub use discovery::VersionEntry;
pub use error::BuilderErr;

use crate::boot::BootManager;
use crate::consts::{DEFAULT_LOG_LEVEL, MAKE_COMMAND};
use dialoguer::{Confirm, Select, console::Term, theme::ColorfulTheme};
use indicatif::{ProgressBar, ProgressStyle};
use serde::Deserialize;
use std::io::Write;
use std::num::NonZeroUsize;
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use tracing::info;

/// The progress bar that is currently driving the build, if any.
///
/// Log records are routed through it so they appear cleanly above the bar
/// instead of corrupting it.
static ACTIVE_BAR: OnceLock<ProgressBar> = OnceLock::new();

#[derive(Debug, Clone)]
pub struct BuildProgress {
    steps: Vec<BuildStep>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BuildStep {
    ConfigLink,
    SymlinkUpdate,
    Menuconfig,
    ConfigUpdate,
    BuildKernel,
    InstallKernel,
    InstallModules,
    GenerateInitramfs,
    CleanupKernel,
}

impl BuildStep {
    #[must_use]
    pub fn label(&self) -> &'static str {
        match self {
            BuildStep::ConfigLink => "Linking kernel config",
            BuildStep::SymlinkUpdate => "Updating linux symlink",
            BuildStep::Menuconfig => "Running menuconfig",
            BuildStep::ConfigUpdate => "Updating kernel config",
            BuildStep::BuildKernel => "Building kernel",
            BuildStep::InstallKernel => "Installing kernel",
            BuildStep::InstallModules => "Installing modules",
            BuildStep::GenerateInitramfs => "Generating initramfs",
            BuildStep::CleanupKernel => "Cleaning up old kernels",
        }
    }
}

impl BuildProgress {
    #[must_use]
    pub fn new() -> Self {
        Self { steps: Vec::new() }
    }

    pub fn add_step(&mut self, step: BuildStep) {
        self.steps.push(step);
    }

    /// Create a progress bar for the build steps.
    #[must_use]
    pub fn create_progress_bar(&self) -> ProgressBar {
        let count = self.steps.len();
        if count == 0 {
            return ProgressBar::hidden();
        }

        let pb = ProgressBar::new(count as u64);
        pb.set_style(
            ProgressStyle::with_template(
                "{spinner:.cyan} [{bar:40.cyan/dim}] {pos}/{len} {wide_msg}",
            )
                .expect("valid template")
                .progress_chars("=>-"),
        );
        pb.set_message("Starting...");
        pb
    }
}

impl Default for BuildProgress {
    fn default() -> Self {
        Self::new()
    }
}

/// A [`std::io::Write`] that emits log records above the active progress bar.
///
/// While a progress bar is running, writes are wrapped in
/// [`ProgressBar::suspend`] so the bar is cleared and redrawn around each log
/// line. Without an active bar, writes go straight to stderr.
struct ProgressBarWriter;

impl Write for ProgressBarWriter {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        match ACTIVE_BAR.get() {
            Some(bar) if !bar.is_hidden() => {
                let buf = buf.to_vec();
                bar.suspend(|| {
                    let _ = std::io::stderr().write_all(&buf);
                });
            }
            _ => std::io::stderr().write_all(buf)?,
        }
        Ok(buf.len())
    }

    fn flush(&mut self) -> std::io::Result<()> {
        std::io::stderr().flush()
    }
}

struct ProgressBarMakeWriter;

impl tracing_subscriber::fmt::MakeWriter<'_> for ProgressBarMakeWriter {
    type Writer = ProgressBarWriter;

    fn make_writer(&self) -> Self::Writer {
        ProgressBarWriter
    }
}

/// Initialise logging based on the requested verbosity level.
///
/// * `0` — no logging, only the progress bar.
/// * `1` — info logs and live kernel build output.
/// * `2` or more — debug logs.
pub fn init_logging(verbose: u8) {
    use tracing_subscriber::{EnvFilter, fmt, prelude::*};

    if verbose == 0 {
        return;
    }

    let default_level = if verbose >= 2 { "debug" } else { DEFAULT_LOG_LEVEL };
    let filter =
        EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(default_level));

    tracing_subscriber::registry()
        .with(
            fmt::layer()
                .with_target(false)
                .without_time()
                .with_writer(ProgressBarMakeWriter),
        )
        .with(filter)
        .init();
}

#[derive(Debug, Deserialize)]
pub struct KBConfig {
    #[serde(rename = "kernel")]
    pub kernel_file_path: PathBuf,
    #[serde(rename = "initramfs")]
    pub initramfs_file_path: Option<PathBuf>,
    #[serde(rename = "kernel-config")]
    pub kernel_config_file_path: PathBuf,
    #[serde(rename = "kernel-src")]
    pub kernel_src: PathBuf,
    #[serde(rename = "keep-last-kernel")]
    pub keep_last_kernel: bool,
    #[serde(rename = "last-kernel-suffix")]
    pub last_kernel_suffix: Option<String>,
    #[serde(rename = "cleanup-keep-count", default)]
    pub cleanup_keep_count: Option<u32>,
}

impl KBConfig {
    /// Validate the configuration.
    ///
    /// # Errors
    ///
    /// Returns an error if validation fails.
    pub fn validate(&self) -> Result<(), BuilderErr> {
        if !self.kernel_src.exists() {
            return Err(BuilderErr::invalid_config(format!(
                "Kernel source directory does not exist: {}",
                self.kernel_src.display()
            )));
        }

        if !self.kernel_src.is_dir() {
            return Err(BuilderErr::invalid_config(format!(
                "Kernel source path is not a directory: {}",
                self.kernel_src.display()
            )));
        }

        if self.kernel_file_path.parent().is_some_and(|p| !p.exists()) {
            return Err(BuilderErr::invalid_config(format!(
                "Kernel file parent directory does not exist: {}",
                self.kernel_file_path.display()
            )));
        }

        if let Some(ref initramfs) = self.initramfs_file_path {
            if initramfs.parent().is_some_and(|p| !p.exists()) {
                return Err(BuilderErr::invalid_config(format!(
                    "Initramfs parent directory does not exist: {}",
                    initramfs.display()
                )));
            }
        }

        Ok(())
    }

    #[must_use]
    pub fn to_kernel_paths(&self) -> KernelPaths {
        KernelPaths::new(
            self.kernel_file_path.clone(),
            self.initramfs_file_path.clone(),
            self.kernel_config_file_path.clone(),
            self.kernel_src.clone(),
        )
    }
}

#[derive(Debug)]
pub struct KernelBuilder {
    config: KBConfig,
    versions: Vec<VersionEntry>,
    boot_manager: BootManager,
}

impl KernelBuilder {
    /// Create a new `KernelBuilder` instance.
    ///
    /// # Errors
    ///
    /// Returns an error if validation fails or version scanning fails.
    pub fn new(config: KBConfig) -> Result<Self, BuilderErr> {
        config.validate()?;

        let versions = Self::scan_versions(&config.kernel_src)?;
        let paths = config.to_kernel_paths();
        let boot_manager = BootManager::new(
            paths,
            config.keep_last_kernel,
            config.last_kernel_suffix.clone(),
        );

        Ok(Self {
            config,
            versions,
            boot_manager,
        })
    }

    #[must_use]
    pub fn versions(&self) -> &[VersionEntry] {
        &self.versions
    }

    fn scan_versions(kernel_src: &Path) -> Result<Vec<VersionEntry>, BuilderErr> {
        let entries = std::fs::read_dir(kernel_src).map_err(|e| {
            BuilderErr::discovery_error(format!(
                "Failed to read kernel source directory {}: {e}",
                kernel_src.display()
            ))
        })?;

        let mut versions: Vec<VersionEntry> = Vec::new();
        for dir in entries.flatten() {
            let path = dir.path();
            if path.is_dir() && !path.is_symlink() {
                if let Some(entry) = VersionEntry::from_path(&path) {
                    versions.push(entry);
                }
            }
        }

        versions.sort();
        versions.reverse();

        tracing::debug!("Found {} kernel versions", versions.len());
        for v in &versions {
            tracing::debug!("  - {v}");
        }

        Ok(versions)
    }

    /// Execute the kernel build workflow.
    ///
    /// # Errors
    ///
    /// Returns an error if any step of the build process fails.
    pub fn build(&self, cli: &Args) -> Result<(), BuilderErr> {
        let Some(version_entry) = self.prompt_for_kernel_version() else {
            tracing::debug!("No kernel version selected, exiting");
            return Ok(());
        };

        info!("Selected kernel: {}", version_entry.version_string);

        if !self.config.kernel_config_file_path.exists() {
            return Err(BuilderErr::kernel_config_missing());
        }

        let mut progress = BuildProgress::new();
        progress.add_step(BuildStep::ConfigLink);
        progress.add_step(BuildStep::SymlinkUpdate);

        if cli.menuconfig {
            progress.add_step(BuildStep::Menuconfig);
        }

        if !cli.no_build {
            progress.add_step(BuildStep::ConfigUpdate);
            progress.add_step(BuildStep::BuildKernel);
            progress.add_step(BuildStep::InstallKernel);
        }

        if !cli.no_modules {
            progress.add_step(BuildStep::InstallModules);
        }

        #[cfg(feature = "dracut")]
        if !cli.no_initramfs {
            progress.add_step(BuildStep::GenerateInitramfs);
        }

        if self.config.cleanup_keep_count.is_some() {
            progress.add_step(BuildStep::CleanupKernel);
        }

        let mut pb = progress.create_progress_bar();
        let _ = ACTIVE_BAR.set(pb.clone());

        pb.set_message(BuildStep::ConfigLink.label());
        pb.inc(1);
        self.boot_manager.link_kernel_config(&version_entry.path)?;

        pb.set_message(BuildStep::SymlinkUpdate.label());
        pb.inc(1);
        self.boot_manager.update_linux_symlink(&version_entry)?;

        if cli.menuconfig {
            pb.set_message(BuildStep::Menuconfig.label());
            pb.inc(1);
            // Run interactive menuconfig attached to the user's terminal.
            use std::process::{Command, Stdio};

            // Suspend the progress bar while the TUI runs to avoid output clashes.
            let status = pb.suspend(|| {
                Command::new(MAKE_COMMAND)
                    .arg("menuconfig")
                    .current_dir(&version_entry.path)
                    .stdin(Stdio::inherit())
                    .stdout(Stdio::inherit())
                    .stderr(Stdio::inherit())
                    .status()
                    .map_err(|e| BuilderErr::CommandError(format!("Failed to run menuconfig: {e}")))
            })?;

            if !status.success() {
                return Err(BuilderErr::MenuconfigError);
            }

            if !Self::confirm_prompt("Continue build process?")? {
                pb.finish_with_message("Cancelled by user");
                return Ok(());
            }
        }

        if !cli.no_build {
            self.build_kernel(&version_entry, cli.replace, &mut pb)?;
        }

        if !cli.no_modules && Self::confirm_prompt("Do you want to install kernel modules?")? {
            self.install_modules(&version_entry, &mut pb)?;
        }

        #[cfg(feature = "dracut")]
        if !cli.no_initramfs
            && Self::confirm_prompt("Do you want to generate initramfs with dracut?")?
        {
            self.generate_initramfs(&version_entry, cli.replace, &mut pb)?;
        }

        if let Some(keep_count) = self.config.cleanup_keep_count {
            self.cleanup_old_kernels(keep_count, &mut pb)?;
        }

        pb.finish_with_message("Build complete!");
        Ok(())
    }

    fn cleanup_old_kernels(&self, keep_count: u32, pb: &mut ProgressBar) -> Result<(), BuilderErr> {
        let current_kernel = self.boot_manager.get_current_kernel();
        let current_version = current_kernel
            .as_ref()
            .and_then(|p| self.versions.iter().find(|v| v.path == *p));

        let mut to_keep: Vec<&VersionEntry> = Vec::new();
        if let Some(current) = current_version {
            to_keep.push(current);
        }

        for v in &self.versions {
            if to_keep.len() >= keep_count as usize {
                break;
            }
            if !to_keep.contains(&v) {
                to_keep.push(v);
            }
        }

        let to_delete: Vec<&VersionEntry> = self
            .versions
            .iter()
            .filter(|v| !to_keep.contains(v))
            .collect();

        pb.set_message(BuildStep::CleanupKernel.label());

        if to_delete.is_empty() {
            info!("No old kernels to clean up");
            pb.inc(1);
            return Ok(());
        }

        for v in &to_delete {
            info!("Cleaning up old kernel: {}", v.version_string);
            self.boot_manager.remove_kernel(&v.path)?;
        }

        pb.inc(1);
        info!("Cleaned up {} old kernel(s)", to_delete.len());
        Ok(())
    }

    /// Build a callback that streams a command's current output line into the
    /// progress bar message, replacing the static step label with live output.
    fn line_callback(pb: &ProgressBar) -> impl FnMut(&str) + '_ {
        move |line: &str| {
            if !line.is_empty() {
                pb.set_message(line.to_owned());
            }
        }
    }

    fn build_kernel(
        &self,
        version_entry: &VersionEntry,
        replace: bool,
        pb: &mut ProgressBar,
    ) -> Result<(), BuilderErr> {
        pb.set_message(BuildStep::ConfigUpdate.label());

        if self
            .boot_manager
            .check_new_config_options(&version_entry.path)?
        {
            info!("New config options detected, running olddefconfig");
            self.boot_manager.run_olddefconfig(&version_entry.path)?;
        }
        pb.inc(1);

        let threads = std::thread::available_parallelism()
            .unwrap_or(NonZeroUsize::new(1).unwrap())
            .get();

        pb.set_message(BuildStep::BuildKernel.label());
        {
            let mut on_line = Self::line_callback(pb);
            self.boot_manager
                .build_kernel(&version_entry.path, threads, &mut on_line)?;
        }
        pb.inc(1);

        pb.set_message(BuildStep::InstallKernel.label());
        self.boot_manager
            .install_kernel(&version_entry.path, replace)?;
        pb.inc(1);

        Ok(())
    }

    fn install_modules(
        &self,
        version_entry: &VersionEntry,
        pb: &mut ProgressBar,
    ) -> Result<(), BuilderErr> {
        pb.set_message(BuildStep::InstallModules.label());
        {
            let mut on_line = Self::line_callback(pb);
            self.boot_manager
                .install_modules(&version_entry.path, &mut on_line)?;
        }
        pb.inc(1);
        Ok(())
    }

    #[cfg(feature = "dracut")]
    fn generate_initramfs(
        &self,
        version_entry: &VersionEntry,
        replace: bool,
        pb: &mut ProgressBar,
    ) -> Result<(), BuilderErr> {
        pb.set_message(BuildStep::GenerateInitramfs.label());
        {
            let mut on_line = Self::line_callback(pb);
            self.boot_manager
                .generate_initramfs(version_entry, replace, &mut on_line)?;
        }
        pb.inc(1);
        Ok(())
    }

    fn prompt_for_kernel_version(&self) -> Option<VersionEntry> {
        if self.versions.is_empty() {
            tracing::debug!(
                "No kernel versions found in {}",
                self.config.kernel_src.display()
            );
            return None;
        }

        let version_strings: Vec<&str> = self
            .versions
            .iter()
            .map(|v| v.version_string.as_str())
            .collect();

        Select::with_theme(&ColorfulTheme::default())
            .with_prompt("Pick version to build and install")
            .items(&version_strings)
            .default(0)
            .interact_on_opt(&Term::stderr())
            .ok()
            .flatten()
            .map(|idx| self.versions[idx].clone())
    }

    fn confirm_prompt(message: &str) -> Result<bool, BuilderErr> {
        Confirm::new()
            .with_prompt(message)
            .interact()
            .map_err(BuilderErr::PromptError)
    }
}