feat(kernel): add a balanced source-kernel choice alongside bin and tuned
Some checks are pending
ci / test (push) Waiting to run
Some checks are pending
ci / test (push) Waiting to run
This commit is contained in:
parent
aeb46aceee
commit
531b9f0ea5
10 changed files with 504 additions and 83 deletions
|
|
@ -5,6 +5,25 @@ this file is the curated, human-readable summary.
|
|||
|
||||
## Unreleased — Fast defaults with user-controlled source builds
|
||||
|
||||
- **Three explicit kernel choices (2026-09-29).** Kernel selection is now a
|
||||
first-class three-way choice rather than only a prebuilt-vs-source config
|
||||
enum: `bin` (the default `sys-kernel/gentoo-kernel-bin`, no compile),
|
||||
`balanced` (source-built `sys-kernel/gentoo-kernel` with the broad
|
||||
distribution configuration — the fragment makes common hot-plug drivers
|
||||
explicit as modules: USB Ethernet chipsets, USB mass storage, USB serial, and
|
||||
removable-media filesystems such as exFAT/NTFS3), and `tuned` (the same broad
|
||||
coverage plus one conservative optimization; no driver is dropped). New typed
|
||||
action `BuildBalancedKernel { make_default }` and phrase
|
||||
`sys build balanced kernel`; both source choices keep `gentoo-kernel-bin`
|
||||
installed as the known-good fallback and create a separate BLS entry
|
||||
(`phoebus-balanced.conf` / `phoebus-tuned.conf`) that is only promoted after a
|
||||
test boot. Core: `fastinstall::{KernelChoice, kernel_build_plan,
|
||||
balanced_kernel_plan, kernel_build_review}`; `system::{balanced_kernel_config,
|
||||
tuned_kernel_config}`; executor `kernel::build_balanced_kernel` (refactored
|
||||
from the tuned path). Gates: `cargo fmt`, `clippy --workspace --all-targets --
|
||||
-D warnings`, `cargo test --workspace` 849 passed / 0 failed. VM journeys for
|
||||
the balanced/tuned builds and source conversion are in progress (multi-hour
|
||||
compiles).
|
||||
- **OpenCode is now a standard transport (2026-09-29).** The OpenCode backend was
|
||||
special-cased twice: it ran **outside** the model sandbox (a comment called it
|
||||
"a different trust boundary") and its endpoint policy was stricter than the
|
||||
|
|
|
|||
|
|
@ -82,6 +82,7 @@ Booting that recovery entry offline remains a manual gate.
|
|||
| Single generic kernel default (no second generic kernel) | yes | yes (guard + tuned path keeps the fallback) | yes (existing boot path unchanged) | no |
|
||||
| User-initiated source builds (`convert_to_source`) | yes | yes (table incl. thunderbird, review, build-before-remove, Brave/unknown refusals) | no (no conversion journey run in a VM) | no |
|
||||
| Tuned-kernel build (`build_tuned_kernel`, separate BLS, fallback kept) | yes | yes (refusal without fallback, entry creation, default never blind-switched) | no (no build/boot-test in a VM) | no |
|
||||
| Balanced source kernel (`build_balanced_kernel`, broad hardware, bin fallback) | yes | yes (plan/fragment/review, refusal without fallback, separate `phoebus-balanced.conf`, default untouched) | in progress (VM build/boot journey started 2026-09-29) | no |
|
||||
| Installed first-login welcome (once per user, reopenable, non-blocking) | yes | yes (assets, launcher, autostart, QML guards, DMS seed) | no (first login + graphical checks not run) | no |
|
||||
| Install metrics (time, download, peak disk, installed size) | yes | yes (report rendering; orchestration hooks) | yes (Run 13 recorded 588 compile times into target metrics) | no |
|
||||
| XWayland / polkit agent / kitty / wofi | yes | no | installed, not launched | no |
|
||||
|
|
|
|||
|
|
@ -320,6 +320,16 @@ pub enum SystemAction {
|
|||
#[serde(default)]
|
||||
make_default: bool,
|
||||
},
|
||||
/// Build a **balanced** source kernel (not the prebuilt `-bin`) from the
|
||||
/// broad distribution configuration, so common hot-pluggable hardware
|
||||
/// (USB Ethernet, USB storage, extra filesystems) keeps working. Creates a
|
||||
/// separate BLS entry, boot-tests it before offering to make it default,
|
||||
/// and always keeps `gentoo-kernel-bin` as the fallback.
|
||||
BuildBalancedKernel {
|
||||
/// Make the balanced kernel the default only after a verified boot.
|
||||
#[serde(default)]
|
||||
make_default: bool,
|
||||
},
|
||||
}
|
||||
|
||||
impl SystemAction {
|
||||
|
|
@ -511,6 +521,13 @@ impl SystemAction {
|
|||
.to_string()
|
||||
}
|
||||
}
|
||||
SystemAction::BuildBalancedKernel { make_default } => {
|
||||
if *make_default {
|
||||
"build a balanced source kernel (broad hardware) and make it default after a verified boot (keeps generic fallback)".to_string()
|
||||
} else {
|
||||
"build a balanced source kernel (broad hardware) as a separate boot entry (keeps generic fallback)".to_string()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -570,7 +587,8 @@ impl SystemAction {
|
|||
| SystemAction::CustomEbuildInstall { .. }
|
||||
| SystemAction::CustomEbuildRemove { .. }
|
||||
| SystemAction::ConvertToSource { .. }
|
||||
| SystemAction::BuildTunedKernel { .. } => Risk::High,
|
||||
| SystemAction::BuildTunedKernel { .. }
|
||||
| SystemAction::BuildBalancedKernel { .. } => Risk::High,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -668,6 +686,7 @@ impl SystemAction {
|
|||
| SystemAction::CustomEbuildList => Some(Backend::CustomEbuild),
|
||||
SystemAction::ConvertToSource { .. } => Some(Backend::PortageSource),
|
||||
SystemAction::BuildTunedKernel { .. } => Some(Backend::PortageSource),
|
||||
SystemAction::BuildBalancedKernel { .. } => Some(Backend::PortageSource),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -950,6 +969,7 @@ impl SystemAction {
|
|||
Ok(())
|
||||
}
|
||||
SystemAction::BuildTunedKernel { .. } => Ok(()),
|
||||
SystemAction::BuildBalancedKernel { .. } => Ok(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1577,6 +1597,15 @@ fn parse_natural_raw(text: &str) -> Option<SystemAction> {
|
|||
make_default: false,
|
||||
});
|
||||
}
|
||||
if t == "build balanced kernel"
|
||||
|| t == "build a balanced kernel"
|
||||
|| t == "build balanced source kernel"
|
||||
|| t == "balanced kernel"
|
||||
{
|
||||
return Some(SystemAction::BuildBalancedKernel {
|
||||
make_default: false,
|
||||
});
|
||||
}
|
||||
for prefix in ["build ", "compile "] {
|
||||
if let Some(rest) = rest(prefix) {
|
||||
let rest = rest.trim();
|
||||
|
|
@ -2292,6 +2321,24 @@ mod tests {
|
|||
make_default: false
|
||||
})
|
||||
);
|
||||
assert_eq!(
|
||||
parse_natural("build balanced kernel"),
|
||||
Some(SystemAction::BuildBalancedKernel {
|
||||
make_default: false
|
||||
})
|
||||
);
|
||||
let balanced_json =
|
||||
parse_action(r#"{"action":"build_balanced_kernel","make_default":false}"#)
|
||||
.expect("balanced JSON parses");
|
||||
assert_eq!(
|
||||
balanced_json,
|
||||
SystemAction::BuildBalancedKernel {
|
||||
make_default: false
|
||||
}
|
||||
);
|
||||
assert_eq!(balanced_json.risk(), Risk::High);
|
||||
assert!(balanced_json.is_mutating());
|
||||
assert_eq!(balanced_json.backend(), Some(Backend::PortageSource));
|
||||
// Brave has no trustworthy source route: the phrase still parses so
|
||||
// the refusal carries the reason (resolve_effects fails closed with
|
||||
// it before any approval or command).
|
||||
|
|
|
|||
|
|
@ -205,37 +205,149 @@ pub fn source_conversion_review(conv: &SourceConversion) -> String {
|
|||
o
|
||||
}
|
||||
|
||||
/// The opt-in tuned-kernel build plan.
|
||||
/// A user-facing kernel choice. Three options are deliberately distinct:
|
||||
/// the prebuilt distribution kernel (the default), a source-built **balanced**
|
||||
/// kernel using the broad distribution configuration (so hot-plugged hardware
|
||||
/// such as a USB Ethernet adapter or a new filesystem keeps working), and a
|
||||
/// machine-**tuned** kernel built from the same broad base plus conservative
|
||||
/// tuning.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum KernelChoice {
|
||||
/// Prebuilt `sys-kernel/gentoo-kernel-bin` (the default; no compile).
|
||||
Bin,
|
||||
/// Source-built `sys-kernel/gentoo-kernel` with the broad distribution
|
||||
/// configuration. Portable and supports common peripherals.
|
||||
Balanced,
|
||||
/// Source-built `sys-kernel/gentoo-kernel` plus conservative machine
|
||||
/// tuning; required drivers are retained.
|
||||
Tuned,
|
||||
}
|
||||
|
||||
impl KernelChoice {
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
KernelChoice::Bin => "bin",
|
||||
KernelChoice::Balanced => "balanced",
|
||||
KernelChoice::Tuned => "tuned",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
KernelChoice::Bin => "default prebuilt kernel",
|
||||
KernelChoice::Balanced => "balanced source kernel",
|
||||
KernelChoice::Tuned => "tuned source kernel",
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(value: &str) -> Option<Self> {
|
||||
match value.trim().to_ascii_lowercase().as_str() {
|
||||
"bin" | "prebuilt" | "default" => Some(KernelChoice::Bin),
|
||||
"balanced" | "broad" | "generic-source" => Some(KernelChoice::Balanced),
|
||||
"tuned" | "optimized" => Some(KernelChoice::Tuned),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// The Portage package this choice installs.
|
||||
pub fn package(self) -> &'static str {
|
||||
match self {
|
||||
KernelChoice::Bin => "sys-kernel/gentoo-kernel-bin",
|
||||
KernelChoice::Balanced | KernelChoice::Tuned => "sys-kernel/gentoo-kernel",
|
||||
}
|
||||
}
|
||||
|
||||
/// Every supported choice, in presentation order.
|
||||
pub fn all() -> [KernelChoice; 3] {
|
||||
[
|
||||
KernelChoice::Bin,
|
||||
KernelChoice::Balanced,
|
||||
KernelChoice::Tuned,
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
/// The opt-in source kernel build plan (balanced or tuned).
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct TunedKernelPlan {
|
||||
pub struct KernelBuildPlan {
|
||||
pub choice: KernelChoice,
|
||||
pub base_config: &'static str,
|
||||
pub source_atom: &'static str,
|
||||
pub fallback_atom: &'static str,
|
||||
pub bls_entry: &'static str,
|
||||
/// The on-disk config fragment file name under `/etc/kernel/config.d`.
|
||||
pub fragment_file: &'static str,
|
||||
}
|
||||
|
||||
pub fn tuned_kernel_plan() -> TunedKernelPlan {
|
||||
TunedKernelPlan {
|
||||
base_config: "Phoebus proven Gentoo distribution-kernel configuration",
|
||||
source_atom: "sys-kernel/gentoo-kernel",
|
||||
fallback_atom: "sys-kernel/gentoo-kernel-bin",
|
||||
bls_entry: "Phoebus (tuned kernel, separate BLS entry)",
|
||||
/// Kept for existing callers: the tuned plan is the tuned [`KernelBuildPlan`].
|
||||
pub type TunedKernelPlan = KernelBuildPlan;
|
||||
|
||||
pub fn kernel_build_plan(choice: KernelChoice) -> KernelBuildPlan {
|
||||
match choice {
|
||||
KernelChoice::Balanced => KernelBuildPlan {
|
||||
choice,
|
||||
base_config: "the Gentoo distribution kernel configuration (broad, portable)",
|
||||
source_atom: "sys-kernel/gentoo-kernel",
|
||||
fallback_atom: "sys-kernel/gentoo-kernel-bin",
|
||||
bls_entry: "Phoebus (balanced kernel, separate BLS entry)",
|
||||
fragment_file: "10-phoebus-balanced.config",
|
||||
},
|
||||
// Bin is not a source build; present it plainly if asked.
|
||||
KernelChoice::Bin => KernelBuildPlan {
|
||||
choice,
|
||||
base_config: "the prebuilt Gentoo distribution kernel",
|
||||
source_atom: "sys-kernel/gentoo-kernel-bin",
|
||||
fallback_atom: "sys-kernel/gentoo-kernel-bin",
|
||||
bls_entry: "(the default entry)",
|
||||
fragment_file: "",
|
||||
},
|
||||
KernelChoice::Tuned => KernelBuildPlan {
|
||||
choice,
|
||||
base_config: "the proven Gentoo distribution-kernel configuration",
|
||||
source_atom: "sys-kernel/gentoo-kernel",
|
||||
fallback_atom: "sys-kernel/gentoo-kernel-bin",
|
||||
bls_entry: "Phoebus (tuned kernel, separate BLS entry)",
|
||||
fragment_file: "10-phoebus-tuned.config",
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
/// Review text for the tuned-kernel build.
|
||||
pub fn tuned_kernel_review(plan: &TunedKernelPlan) -> String {
|
||||
pub fn balanced_kernel_plan() -> KernelBuildPlan {
|
||||
kernel_build_plan(KernelChoice::Balanced)
|
||||
}
|
||||
|
||||
pub fn tuned_kernel_plan() -> KernelBuildPlan {
|
||||
kernel_build_plan(KernelChoice::Tuned)
|
||||
}
|
||||
|
||||
/// Review text for a source kernel build, describing the specific choice.
|
||||
pub fn kernel_build_review(plan: &KernelBuildPlan) -> String {
|
||||
let tuned = plan.choice == KernelChoice::Tuned;
|
||||
let mut o = String::new();
|
||||
o.push_str(
|
||||
"Build a kernel tuned for this machine\n========================================\n\n",
|
||||
);
|
||||
o.push_str(&format!(
|
||||
"Build the {} for this machine\n{}\n\n",
|
||||
plan.choice.label(),
|
||||
"=".repeat(40)
|
||||
));
|
||||
o.push_str(&format!(" Start from : {}\n", plan.base_config));
|
||||
o.push_str(&format!(" Source package: {}\n", plan.source_atom));
|
||||
o.push_str(" Tuning : only supported, measurable tuning; required storage,\n");
|
||||
o.push_str(" encryption, filesystem, firmware, input and recovery\n");
|
||||
o.push_str(" support are retained.\n");
|
||||
o.push_str(" Expected work : typically 20–60 min on 8 vCPUs; ~15 GiB temporary space;\n");
|
||||
o.push_str(" keep AC power connected.\n");
|
||||
if tuned {
|
||||
o.push_str(
|
||||
" Tuning : only supported, measurable tuning; required storage,\n\
|
||||
\x20 encryption, filesystem, firmware, input and recovery\n\
|
||||
\x20 support are retained.\n",
|
||||
);
|
||||
} else {
|
||||
o.push_str(
|
||||
" Coverage : the broad distribution configuration is kept, so common\n\
|
||||
\x20 hot-pluggable hardware (USB Ethernet, USB storage,\n\
|
||||
\x20 common filesystems) keeps working.\n",
|
||||
);
|
||||
}
|
||||
o.push_str(
|
||||
" Expected work : typically 20–60 min on 8 vCPUs; ~15 GiB temporary space;\n\
|
||||
\x20 keep AC power connected.\n",
|
||||
);
|
||||
o.push_str(&format!(
|
||||
" Boot entry : {} (separate entry; boot-tested first)\n",
|
||||
plan.bls_entry
|
||||
|
|
@ -244,12 +356,22 @@ pub fn tuned_kernel_review(plan: &TunedKernelPlan) -> String {
|
|||
" Fallback : {} stays installed and selectable as known-good.\n",
|
||||
plan.fallback_atom
|
||||
));
|
||||
o.push_str(" Safety : a failed build or failed boot never replaces the working\n");
|
||||
o.push_str(" default; a clear route back to the generic kernel remains.\n");
|
||||
o.push_str(" Approval : explicit approval is required before the broker runs.\n");
|
||||
o.push_str(
|
||||
" Safety : a failed build or failed boot never replaces the working\n\
|
||||
\x20 default; a clear route back to the generic kernel remains.\n\
|
||||
\x20Approval : explicit approval is required before the broker runs.\n",
|
||||
);
|
||||
o
|
||||
}
|
||||
|
||||
pub fn balanced_kernel_review(plan: &KernelBuildPlan) -> String {
|
||||
kernel_build_review(plan)
|
||||
}
|
||||
|
||||
pub fn tuned_kernel_review(plan: &KernelBuildPlan) -> String {
|
||||
kernel_build_review(plan)
|
||||
}
|
||||
|
||||
/// Guard: the fast install must not record a permanent preference.
|
||||
///
|
||||
/// The installer may choose `-bin`/Flatpak/generic-kernel for speed, but it
|
||||
|
|
@ -420,6 +542,30 @@ mod tests {
|
|||
assert!(review.contains("explicit approval"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn balanced_kernel_is_broad_and_keeps_the_bin_fallback() {
|
||||
assert_eq!(KernelChoice::parse("bin"), Some(KernelChoice::Bin));
|
||||
assert_eq!(
|
||||
KernelChoice::parse("balanced"),
|
||||
Some(KernelChoice::Balanced)
|
||||
);
|
||||
assert_eq!(KernelChoice::parse("tuned"), Some(KernelChoice::Tuned));
|
||||
assert_eq!(KernelChoice::all().len(), 3);
|
||||
assert_eq!(KernelChoice::Bin.package(), "sys-kernel/gentoo-kernel-bin");
|
||||
assert_eq!(KernelChoice::Balanced.package(), "sys-kernel/gentoo-kernel");
|
||||
assert_eq!(KernelChoice::Tuned.package(), "sys-kernel/gentoo-kernel");
|
||||
|
||||
let plan = balanced_kernel_plan();
|
||||
assert_eq!(plan.choice, KernelChoice::Balanced);
|
||||
assert_eq!(plan.source_atom, "sys-kernel/gentoo-kernel");
|
||||
assert_eq!(plan.fallback_atom, "sys-kernel/gentoo-kernel-bin");
|
||||
assert_eq!(plan.fragment_file, "10-phoebus-balanced.config");
|
||||
let review = balanced_kernel_review(&plan);
|
||||
assert!(review.contains("hot-pluggable hardware"), "{review}");
|
||||
assert!(review.contains("known-good"), "{review}");
|
||||
assert!(review.contains("separate entry"), "{review}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn metrics_report_renders_measurements() {
|
||||
let m = InstallMetrics {
|
||||
|
|
|
|||
|
|
@ -1231,10 +1231,91 @@ pub fn kernel_profile_config(config: &InstallConfig) -> String {
|
|||
o
|
||||
}
|
||||
|
||||
/// The **balanced** source-kernel fragment: the broad hardware a user may
|
||||
/// attach later. It is applied on top of the Gentoo distribution-kernel
|
||||
/// configuration (which is already broad) and makes the common hot-plug
|
||||
/// drivers explicit as **modules**, so a USB Ethernet adapter, USB storage,
|
||||
/// serial adapter or a new filesystem keeps working without a rebuild.
|
||||
///
|
||||
/// Nothing here disables support; it only ensures presence. `olddefconfig`
|
||||
/// drops symbols a given kernel version does not know, which is harmless.
|
||||
pub fn balanced_kernel_config() -> String {
|
||||
let mut o = String::new();
|
||||
o.push_str("# Phoebus balanced-kernel fragment (broad hardware coverage).\n");
|
||||
o.push_str("# Applied on top of the Gentoo distribution-kernel configuration.\n");
|
||||
o.push_str("# Modules (not built-in) so hot-plugged hardware loads on demand.\n");
|
||||
|
||||
o.push_str("\n# USB Ethernet adapters (common chipsets)\n");
|
||||
for line in [
|
||||
"CONFIG_USB_USBNET=m",
|
||||
"CONFIG_USB_NET_AX8817X=m",
|
||||
"CONFIG_USB_NET_AX88179_178A=m",
|
||||
"CONFIG_USB_NET_CDCETHER=m",
|
||||
"CONFIG_USB_NET_CDC_NCM=m",
|
||||
"CONFIG_USB_NET_CDC_SUBSET=m",
|
||||
"CONFIG_USB_NET_RNDIS_HOST=m",
|
||||
"CONFIG_USB_NET_SMSC75XX=m",
|
||||
"CONFIG_USB_NET_SMSC95XX=m",
|
||||
"CONFIG_USB_RTL8152=m",
|
||||
] {
|
||||
o.push_str(line);
|
||||
o.push('\n');
|
||||
}
|
||||
|
||||
o.push_str("\n# USB mass storage (flash drives, external disks)\n");
|
||||
for line in ["CONFIG_USB_STORAGE=m", "CONFIG_USB_UAS=m"] {
|
||||
o.push_str(line);
|
||||
o.push('\n');
|
||||
}
|
||||
|
||||
o.push_str("\n# USB serial / embedded debug adapters\n");
|
||||
for line in [
|
||||
"CONFIG_USB_ACM=m",
|
||||
"CONFIG_USB_SERIAL=m",
|
||||
"CONFIG_USB_SERIAL_FTDI_SIO=m",
|
||||
"CONFIG_USB_SERIAL_CH341=m",
|
||||
"CONFIG_USB_SERIAL_CP210X=m",
|
||||
"CONFIG_USB_SERIAL_PL2303=m",
|
||||
] {
|
||||
o.push_str(line);
|
||||
o.push('\n');
|
||||
}
|
||||
|
||||
o.push_str("\n# Removable-media filesystems (interoperability)\n");
|
||||
for line in [
|
||||
"CONFIG_EXFAT_FS=m",
|
||||
"CONFIG_NTFS3_FS=m",
|
||||
"CONFIG_VFAT_FS=m",
|
||||
"CONFIG_MSDOS_FS=m",
|
||||
"CONFIG_UDF_FS=m",
|
||||
"CONFIG_F2FS_FS=m",
|
||||
"CONFIG_XFS_FS=m",
|
||||
] {
|
||||
o.push_str(line);
|
||||
o.push('\n');
|
||||
}
|
||||
|
||||
o.push_str("\n# Thunderbolt / USB4 and firmware loading\n");
|
||||
for line in ["CONFIG_THUNDERBOLT=m", "CONFIG_FW_LOADER=y"] {
|
||||
o.push_str(line);
|
||||
o.push('\n');
|
||||
}
|
||||
o
|
||||
}
|
||||
|
||||
/// The **tuned** source-kernel fragment: the broad balanced coverage plus a
|
||||
/// single supported, measurable optimization. Required drivers are never
|
||||
/// disabled, so a tuned kernel remains as hardware-tolerant as the balanced one.
|
||||
pub fn tuned_kernel_config() -> String {
|
||||
let mut o = balanced_kernel_config();
|
||||
o.push_str("\n# Tuning (conservative, portable; no -march=native)\n");
|
||||
o.push_str("CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y\n");
|
||||
o
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Mango + DankMaterialShell (canonical Phoebus desktop)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// The Mango session entry point written to `/usr/local/bin/phoebus-session-mango`.
|
||||
///
|
||||
/// It starts exactly one compositor (mango), one shell, notification, lock and
|
||||
|
|
@ -2352,6 +2433,33 @@ mod tests {
|
|||
assert!(pkgs.contains(&"net-misc/networkmanager"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn balanced_kernel_config_covers_broad_hardware_and_tuned_adds_only_tuning() {
|
||||
let balanced = balanced_kernel_config();
|
||||
// Broad hot-plug coverage: USB Ethernet, USB storage, extra filesystems.
|
||||
for needle in [
|
||||
"CONFIG_USB_NET_CDCETHER=m",
|
||||
"CONFIG_USB_RTL8152=m",
|
||||
"CONFIG_USB_STORAGE=m",
|
||||
"CONFIG_EXFAT_FS=m",
|
||||
"CONFIG_NTFS3_FS=m",
|
||||
"CONFIG_FW_LOADER=y",
|
||||
] {
|
||||
assert!(
|
||||
balanced.contains(needle),
|
||||
"balanced missing {needle}: {balanced}"
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
!balanced.contains("CC_OPTIMIZE_FOR_PERFORMANCE"),
|
||||
"balanced must not carry tuning"
|
||||
);
|
||||
let tuned = tuned_kernel_config();
|
||||
assert!(tuned.contains("CC_OPTIMIZE_FOR_PERFORMANCE=y"), "{tuned}");
|
||||
// Tuned retains the broad coverage (drivers are never dropped).
|
||||
assert!(tuned.contains("CONFIG_USB_NET_CDCETHER=m"), "{tuned}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn kernel_extras_follow_cpu_features() {
|
||||
let cpu = CpuInfo {
|
||||
|
|
|
|||
|
|
@ -74,6 +74,12 @@ pub fn preview(action: &SystemAction) -> String {
|
|||
&phoebus_core::fastinstall::tuned_kernel_plan(),
|
||||
));
|
||||
}
|
||||
SystemAction::BuildBalancedKernel { .. } => {
|
||||
out.push('\n');
|
||||
out.push_str(&phoebus_core::fastinstall::balanced_kernel_review(
|
||||
&phoebus_core::fastinstall::balanced_kernel_plan(),
|
||||
));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
out
|
||||
|
|
@ -219,6 +225,12 @@ fn pretend_args(action: &SystemAction) -> Option<Vec<String>> {
|
|||
"--".into(),
|
||||
"sys-kernel/gentoo-kernel".into(),
|
||||
]),
|
||||
SystemAction::BuildBalancedKernel { .. } => Some(vec![
|
||||
"--pretend".into(),
|
||||
"--color=n".into(),
|
||||
"--".into(),
|
||||
"sys-kernel/gentoo-kernel".into(),
|
||||
]),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -1783,6 +1795,9 @@ pub fn execute_inner(
|
|||
SystemAction::BuildTunedKernel { make_default } => {
|
||||
crate::kernel::build_tuned_kernel(exec, root, *make_default)?
|
||||
}
|
||||
SystemAction::BuildBalancedKernel { make_default } => {
|
||||
crate::kernel::build_balanced_kernel(exec, root, *make_default)?
|
||||
}
|
||||
};
|
||||
Ok(ActionOutcome {
|
||||
action: action.clone(),
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
|
||||
use std::path::Path;
|
||||
|
||||
use phoebus_core::fastinstall::KernelChoice;
|
||||
use phoebus_core::policy::{PackagePolicyEngine, PolicyContext};
|
||||
use phoebus_core::system as sysgen;
|
||||
use phoebus_core::{HardwareReport, InstallConfig};
|
||||
|
|
@ -70,56 +71,80 @@ fn assert_only_generic_kernel(packages: &[String]) {
|
|||
}
|
||||
|
||||
/// Build a kernel tuned for this machine without ever replacing the working
|
||||
/// default.
|
||||
/// default (see [`build_source_kernel`]).
|
||||
pub fn build_tuned_kernel(exec: &Exec, root: &Path, make_default: bool) -> Result<String> {
|
||||
build_source_kernel(exec, root, KernelChoice::Tuned, make_default)
|
||||
}
|
||||
|
||||
/// Build a **balanced** source kernel (broad hardware coverage) without ever
|
||||
/// replacing the working default (see [`build_source_kernel`]).
|
||||
pub fn build_balanced_kernel(exec: &Exec, root: &Path, make_default: bool) -> Result<String> {
|
||||
build_source_kernel(exec, root, KernelChoice::Balanced, make_default)
|
||||
}
|
||||
|
||||
/// Build an opt-in source kernel (balanced or tuned) without ever replacing the
|
||||
/// working default.
|
||||
///
|
||||
/// 1. Refuses unless `sys-kernel/gentoo-kernel-bin` is installed (the
|
||||
/// known-good fallback must exist first).
|
||||
/// 2. Writes the tuned fragment on top of the proven distribution-kernel
|
||||
/// configuration (supported, measurable tuning only; storage, encryption,
|
||||
/// filesystem, firmware, input and recovery support retained).
|
||||
/// 3. Builds `sys-kernel/gentoo-kernel` as a binary package first, so a
|
||||
/// failed build never touches the boot selection.
|
||||
/// 2. Writes the choice's fragment on top of the proven distribution-kernel
|
||||
/// configuration. The balanced fragment keeps broad hot-plug coverage; the
|
||||
/// tuned fragment adds one conservative optimization and retains it.
|
||||
/// 3. Builds `sys-kernel/gentoo-kernel` as a binary package first, so a failed
|
||||
/// build never touches the boot selection.
|
||||
/// 4. Installs it and creates a **separate** BLS entry. The default is only
|
||||
/// switched when `make_default` is set **and** the running kernel already
|
||||
/// is the tuned one (i.e. after an explicit test boot) — otherwise the
|
||||
/// entry is left for a test boot with the route back documented.
|
||||
pub fn build_tuned_kernel(exec: &Exec, root: &Path, make_default: bool) -> Result<String> {
|
||||
use phoebus_core::fastinstall::tuned_kernel_plan;
|
||||
let plan = tuned_kernel_plan();
|
||||
/// switched when `make_default` is set **and** the running kernel already is
|
||||
/// the source kernel (after an explicit test boot) — otherwise the entry is
|
||||
/// left for a test boot with the route back documented.
|
||||
fn build_source_kernel(
|
||||
exec: &Exec,
|
||||
root: &Path,
|
||||
choice: KernelChoice,
|
||||
make_default: bool,
|
||||
) -> Result<String> {
|
||||
use phoebus_core::fastinstall::kernel_build_plan;
|
||||
let plan = kernel_build_plan(choice);
|
||||
// 1. The fallback must exist.
|
||||
if !vdb_has_atom(root, plan.fallback_atom) {
|
||||
return Err(ExecError::operation(
|
||||
"sys",
|
||||
"build tuned kernel",
|
||||
choice.label(),
|
||||
format!(
|
||||
"{} is not installed; refusing to build a tuned kernel without the known-good fallback",
|
||||
"{} is not installed; refusing to build a source kernel without the known-good fallback",
|
||||
plan.fallback_atom
|
||||
),
|
||||
));
|
||||
}
|
||||
// 2. Tuned fragment, derived from the proven profile fragment.
|
||||
// 2. The choice's fragment, on top of the proven profile fragment.
|
||||
let fragment = match choice {
|
||||
KernelChoice::Balanced => sysgen::balanced_kernel_config(),
|
||||
KernelChoice::Tuned => sysgen::tuned_kernel_config(),
|
||||
KernelChoice::Bin => {
|
||||
return Err(ExecError::operation(
|
||||
"sys",
|
||||
choice.label(),
|
||||
"the prebuilt default kernel is not a source build",
|
||||
))
|
||||
}
|
||||
};
|
||||
exec.target().write(
|
||||
"etc/kernel/config.d/10-phoebus-tuned.config",
|
||||
tuned_kernel_fragment(),
|
||||
&format!("etc/kernel/config.d/{}", plan.fragment_file),
|
||||
fragment,
|
||||
)?;
|
||||
exec.logger.info("wrote tuned kernel fragment");
|
||||
exec.logger
|
||||
.info(format!("wrote {} fragment", choice.label()));
|
||||
// 3. Build only; a failure here leaves boot untouched.
|
||||
portage::chroot(
|
||||
exec,
|
||||
root,
|
||||
"emerge",
|
||||
&[
|
||||
"--ask=n",
|
||||
"--buildpkgonly",
|
||||
"--",
|
||||
"sys-kernel/gentoo-kernel",
|
||||
],
|
||||
&["--ask=n", "--buildpkgonly", "--", plan.source_atom],
|
||||
)
|
||||
.map_err(|e| {
|
||||
ExecError::operation(
|
||||
"sys",
|
||||
"build tuned kernel",
|
||||
format!("the tuned kernel build failed; the working default is unchanged: {e}"),
|
||||
choice.label(),
|
||||
format!("the source kernel build failed; the working default is unchanged: {e}"),
|
||||
)
|
||||
})?;
|
||||
// 4. Install from the verified build, then a separate BLS entry.
|
||||
|
|
@ -127,26 +152,26 @@ pub fn build_tuned_kernel(exec: &Exec, root: &Path, make_default: bool) -> Resul
|
|||
exec,
|
||||
root,
|
||||
"emerge",
|
||||
&["--ask=n", "--usepkg=y", "--", "sys-kernel/gentoo-kernel"],
|
||||
&["--ask=n", "--usepkg=y", "--", plan.source_atom],
|
||||
)
|
||||
.map_err(|e| ExecError::operation("sys", "install tuned kernel", e.to_string()))?;
|
||||
if !vdb_has_atom(root, "sys-kernel/gentoo-kernel") {
|
||||
.map_err(|e| ExecError::operation("sys", choice.label(), e.to_string()))?;
|
||||
if !vdb_has_atom(root, plan.source_atom) {
|
||||
return Err(ExecError::operation(
|
||||
"sys",
|
||||
"build tuned kernel",
|
||||
"the tuned kernel did not verify in the package database; the working default is unchanged",
|
||||
choice.label(),
|
||||
"the source kernel did not verify in the package database; the working default is unchanged",
|
||||
));
|
||||
}
|
||||
let entry = tuned_bls_entry(root)?;
|
||||
let entry = source_kernel_bls_entry(root, choice)?;
|
||||
let mut out = format!(
|
||||
"tuned kernel built and verified; separate boot entry `{entry}` created; \
|
||||
{} stays the default",
|
||||
"{} built and verified; separate boot entry `{entry}` created; {} stays the default",
|
||||
choice.label(),
|
||||
plan.fallback_atom
|
||||
);
|
||||
if make_default {
|
||||
if tuned_kernel_is_running(root)? {
|
||||
set_default_entry(exec, root, &entry)?;
|
||||
out.push_str("; test boot confirmed, tuned kernel is now the default");
|
||||
out.push_str("; test boot confirmed, the source kernel is now the default");
|
||||
} else {
|
||||
out.push_str(
|
||||
"; not made default yet: boot the new entry once for a test boot, \
|
||||
|
|
@ -159,20 +184,6 @@ pub fn build_tuned_kernel(exec: &Exec, root: &Path, make_default: bool) -> Resul
|
|||
Ok(out)
|
||||
}
|
||||
|
||||
/// Only supported, measurable tuning on top of the proven base: native
|
||||
/// optimization markers and build parallelism hints. Required storage,
|
||||
/// encryption, filesystem, firmware, input and recovery support from the
|
||||
/// base fragment are retained, never disabled.
|
||||
fn tuned_kernel_fragment() -> String {
|
||||
let mut o = String::new();
|
||||
o.push_str("# Phoebus tuned-kernel fragment (generated).\n");
|
||||
o.push_str("# Applied on top of the proven Gentoo distribution-kernel\n");
|
||||
o.push_str("# configuration plus 00-phoebus-profile.config. Only supported,\n");
|
||||
o.push_str("# measurable tuning; required drivers are never disabled.\n");
|
||||
o.push_str("CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y\n");
|
||||
o
|
||||
}
|
||||
|
||||
/// Whether a VDB record exists for `atom` under `root`.
|
||||
fn vdb_has_atom(root: &Path, atom: &str) -> bool {
|
||||
// Normalize versioned/slotted atoms to `category/name` before the lookup.
|
||||
|
|
@ -191,9 +202,10 @@ fn vdb_has_atom(root: &Path, atom: &str) -> bool {
|
|||
})
|
||||
}
|
||||
|
||||
/// Copy the default BLS entry to a separate tuned-kernel entry. Returns the
|
||||
/// new entry file name. Never rewrites the default loader selection.
|
||||
fn tuned_bls_entry(root: &Path) -> Result<String> {
|
||||
/// Copy the default BLS entry to a separate source-kernel entry (balanced or
|
||||
/// tuned). Returns the new entry file name. Never rewrites the default loader
|
||||
/// selection.
|
||||
fn source_kernel_bls_entry(root: &Path, choice: KernelChoice) -> Result<String> {
|
||||
let entries = root.join("efi/EFI/Linux");
|
||||
let entries = if entries.is_dir() {
|
||||
entries
|
||||
|
|
@ -203,7 +215,7 @@ fn tuned_bls_entry(root: &Path) -> Result<String> {
|
|||
let Ok(dir) = std::fs::read_dir(&entries) else {
|
||||
return Err(ExecError::operation(
|
||||
"sys",
|
||||
"build tuned kernel",
|
||||
choice.label(),
|
||||
"no BLS entry directory found; refusing to guess the boot layout",
|
||||
));
|
||||
};
|
||||
|
|
@ -216,18 +228,23 @@ fn tuned_bls_entry(root: &Path) -> Result<String> {
|
|||
let Some(src) = current.first().cloned() else {
|
||||
return Err(ExecError::operation(
|
||||
"sys",
|
||||
"build tuned kernel",
|
||||
"no existing BLS entry to derive the tuned entry from",
|
||||
choice.label(),
|
||||
"no existing BLS entry to derive the separate entry from",
|
||||
));
|
||||
};
|
||||
let text = std::fs::read_to_string(&src).map_err(|e| ExecError::io(src.clone(), e))?;
|
||||
let tuned = format!(
|
||||
"{}\n# Phoebus tuned kernel (test entry; generic fallback stays default)\n",
|
||||
text.trim_end()
|
||||
let entry = format!(
|
||||
"{}\n# Phoebus {} kernel (test entry; generic fallback stays default)\n",
|
||||
text.trim_end(),
|
||||
choice.as_str()
|
||||
);
|
||||
let name = "phoebus-tuned.conf";
|
||||
let name = match choice {
|
||||
KernelChoice::Balanced => "phoebus-balanced.conf",
|
||||
KernelChoice::Tuned => "phoebus-tuned.conf",
|
||||
KernelChoice::Bin => "phoebus-bin.conf",
|
||||
};
|
||||
let dest = entries.join(name);
|
||||
std::fs::write(&dest, tuned).map_err(|e| ExecError::io(dest.clone(), e))?;
|
||||
std::fs::write(&dest, entry).map_err(|e| ExecError::io(dest.clone(), e))?;
|
||||
Ok(name.to_string())
|
||||
}
|
||||
|
||||
|
|
@ -372,4 +389,60 @@ mod tests {
|
|||
// default install list is exactly the single bin package.
|
||||
assert_only_generic_kernel(&["sys-kernel/gentoo-kernel-bin".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn balanced_build_refuses_without_the_known_good_fallback() {
|
||||
let runner = RecordingRunner::new();
|
||||
let exec = make_exec(runner.clone());
|
||||
let err = build_balanced_kernel(&exec, Path::new(&exec.root), false).unwrap_err();
|
||||
assert!(err.to_string().contains("known-good fallback"), "{err}");
|
||||
assert!(runner.recorded().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn balanced_build_creates_a_separate_entry_and_keeps_the_default() {
|
||||
let runner = RecordingRunner::new();
|
||||
let exec = make_exec(runner.clone());
|
||||
let root = Path::new(&exec.root);
|
||||
for dir in [
|
||||
"var/db/pkg/sys-kernel/gentoo-kernel-bin-6.12.32",
|
||||
"var/db/pkg/sys-kernel/gentoo-kernel-6.12.32",
|
||||
] {
|
||||
std::fs::create_dir_all(root.join(dir)).unwrap();
|
||||
}
|
||||
std::fs::create_dir_all(root.join("efi/EFI/Linux")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("efi/EFI/Linux/phoebus.conf"),
|
||||
"title Phoebus\nlinux /vmlinuz-6.12.32\noptions root=/dev/mapper/cryptroot\n",
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::create_dir_all(root.join("efi/loader")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("efi/loader/loader.conf"),
|
||||
"default phoebus.conf\n",
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let out = build_balanced_kernel(&exec, root, false).unwrap();
|
||||
assert!(out.contains("balanced source kernel"), "{out}");
|
||||
let entry =
|
||||
std::fs::read_to_string(root.join("efi/EFI/Linux/phoebus-balanced.conf")).unwrap();
|
||||
assert!(entry.contains("linux /vmlinuz-6.12.32"), "{entry}");
|
||||
assert!(entry.contains("balanced"), "{entry}");
|
||||
// The balanced fragment carries broad hot-plug coverage, not tuning.
|
||||
let frag =
|
||||
std::fs::read_to_string(root.join("etc/kernel/config.d/10-phoebus-balanced.config"))
|
||||
.unwrap();
|
||||
assert!(frag.contains("CONFIG_USB_NET_CDCETHER=m"), "{frag}");
|
||||
assert!(frag.contains("CONFIG_USB_RTL8152=m"), "{frag}");
|
||||
assert!(frag.contains("CONFIG_EXFAT_FS=m"), "{frag}");
|
||||
assert!(
|
||||
!frag.contains("CC_OPTIMIZE_FOR_PERFORMANCE"),
|
||||
"balanced must not carry the tuned optimization: {frag}"
|
||||
);
|
||||
// The default is untouched.
|
||||
let loader = std::fs::read_to_string(root.join("efi/loader/loader.conf")).unwrap();
|
||||
assert!(loader.contains("default phoebus.conf"), "{loader}");
|
||||
assert!(!loader.contains("phoebus-balanced"), "{loader}");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -366,6 +366,7 @@ fn run() -> std::result::Result<(), Box<dyn std::error::Error>> {
|
|||
sys undo --legacy | sys enable <service> --legacy | \
|
||||
sys choose <app> --legacy | \
|
||||
sys build <app> from source --legacy | \
|
||||
sys build balanced kernel --legacy | \
|
||||
sys build tuned kernel --legacy"
|
||||
);
|
||||
Err("unsupported instruction in legacy mode".into())
|
||||
|
|
|
|||
|
|
@ -900,4 +900,14 @@ fn source_build_and_tuned_kernel_require_root_like_other_mutations() {
|
|||
assert!(!out.status.success());
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("require root"), "stderr: {stderr}");
|
||||
|
||||
let out = sys()
|
||||
.arg("--root")
|
||||
.arg(root.path())
|
||||
.args(["build", "balanced", "kernel", "--legacy"])
|
||||
.output()
|
||||
.expect("run sys");
|
||||
assert!(!out.status.success());
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
assert!(stderr.contains("require root"), "stderr: {stderr}");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -224,6 +224,7 @@ if [[ "$(id -u)" -ne 0 ]]; then
|
|||
run_expect_nonzero nonroot-clean-cache "require root" clean cache --legacy
|
||||
run_expect_nonzero nonroot-source-build "require root" --legacy --action '{"action":"convert_to_source","app":"firefox"}'
|
||||
run_expect_nonzero nonroot-tuned-kernel "require root" --legacy build tuned kernel
|
||||
run_expect_nonzero nonroot-balanced-kernel "require root" --legacy build balanced kernel
|
||||
fi
|
||||
|
||||
# User-initiated source builds fail closed before any mutation, even as root:
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue