move bios and uefi specific code into submodules gated by features

Author: AlexJMohr

build.rs

@@ -44,6 +44,7 @@ fn main() {
 }
 
 #[cfg(not(docsrs_dummy_build))]
+#[cfg(feature = "uefi")]
 fn build_uefi_bootloader(out_dir: &Path) -> PathBuf {
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
     let mut cmd = Command::new(cargo);
@@ -78,6 +79,7 @@ fn build_uefi_bootloader(out_dir: &Path) -> PathBuf {
 }
 
 #[cfg(not(docsrs_dummy_build))]
+#[cfg(feature = "bios")]
 fn build_bios_boot_sector(out_dir: &Path) -> PathBuf {
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
     let mut cmd = Command::new(cargo);
@@ -121,6 +123,7 @@ fn build_bios_boot_sector(out_dir: &Path) -> PathBuf {
 }
 
 #[cfg(not(docsrs_dummy_build))]
+#[cfg(feature = "bios")]
 fn build_bios_stage_2(out_dir: &Path) -> PathBuf {
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
     let mut cmd = Command::new(cargo);
@@ -162,6 +165,7 @@ fn build_bios_stage_2(out_dir: &Path) -> PathBuf {
 }
 
 #[cfg(not(docsrs_dummy_build))]
+#[cfg(feature = "bios")]
 fn build_bios_stage_3(out_dir: &Path) -> PathBuf {
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
     let mut cmd = Command::new(cargo);
@@ -203,6 +207,7 @@ fn build_bios_stage_3(out_dir: &Path) -> PathBuf {
 }
 
 #[cfg(not(docsrs_dummy_build))]
+#[cfg(feature = "bios")]
 fn build_bios_stage_4(out_dir: &Path) -> PathBuf {
     let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
     let mut cmd = Command::new(cargo);
@@ -244,6 +249,7 @@ fn build_bios_stage_4(out_dir: &Path) -> PathBuf {
     convert_elf_to_bin(elf_path)
 }
 
+#[cfg(feature = "bios")]
 fn convert_elf_to_bin(elf_path: PathBuf) -> PathBuf {
     let flat_binary_path = elf_path.with_extension("bin");
 
@@ -273,23 +279,23 @@ fn convert_elf_to_bin(elf_path: PathBuf) -> PathBuf {
 
 // dummy implementations because docsrs builds have no network access
 
-#[cfg(docsrs_dummy_build)]
+#[cfg(any(docsrs_dummy_build, not(feature = "uefi")))]
 fn build_uefi_bootloader(_out_dir: &Path) -> PathBuf {
     PathBuf::new()
 }
-#[cfg(docsrs_dummy_build)]
+#[cfg(any(docsrs_dummy_build, not(feature = "bios")))]
 fn build_bios_boot_sector(_out_dir: &Path) -> PathBuf {
     PathBuf::new()
 }
-#[cfg(docsrs_dummy_build)]
+#[cfg(any(docsrs_dummy_build, not(feature = "bios")))]
 fn build_bios_stage_2(_out_dir: &Path) -> PathBuf {
     PathBuf::new()
 }
-#[cfg(docsrs_dummy_build)]
+#[cfg(any(docsrs_dummy_build, not(feature = "bios")))]
 fn build_bios_stage_3(_out_dir: &Path) -> PathBuf {
     PathBuf::new()
 }
-#[cfg(docsrs_dummy_build)]
+#[cfg(any(docsrs_dummy_build, not(feature = "bios")))]
 fn build_bios_stage_4(_out_dir: &Path) -> PathBuf {
     PathBuf::new()
 }

src/mbr.rs renamed to src/bios/mbr.rs

@@ -0,0 +1,67 @@
+use crate::fat;
+use anyhow::Context;
+use std::{
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+};
+use tempfile::NamedTempFile;
+
+mod mbr;
+
+const BIOS_STAGE_3: &str = "boot-stage-3";
+const BIOS_STAGE_4: &str = "boot-stage-4";
+
+/// Create disk images for booting on legacy BIOS systems.
+pub struct BiosBoot {
+    kernel: PathBuf,
+}
+
+impl BiosBoot {
+    /// Start creating a disk image for the given bootloader ELF executable.
+    pub fn new(kernel_path: &Path) -> Self {
+        Self {
+            kernel: kernel_path.to_owned(),
+        }
+    }
+
+    /// Create a bootable UEFI disk image at the given path.
+    pub fn create_disk_image(&self, out_path: &Path) -> anyhow::Result<()> {
+        let bootsector_path = Path::new(env!("BIOS_BOOT_SECTOR_PATH"));
+        let stage_2_path = Path::new(env!("BIOS_STAGE_2_PATH"));
+
+        let fat_partition = self
+            .create_fat_partition()
+            .context("failed to create FAT partition")?;
+
+        mbr::create_mbr_disk(
+            bootsector_path,
+            stage_2_path,
+            fat_partition.path(),
+            out_path,
+        )
+        .context("failed to create BIOS MBR disk image")?;
+
+        fat_partition
+            .close()
+            .context("failed to delete FAT partition after disk image creation")?;
+
+        Ok(())
+    }
+
+    /// Creates an BIOS-bootable FAT partition with the kernel.
+    fn create_fat_partition(&self) -> anyhow::Result<NamedTempFile> {
+        let stage_3_path = Path::new(env!("BIOS_STAGE_3_PATH"));
+        let stage_4_path = Path::new(env!("BIOS_STAGE_4_PATH"));
+
+        let mut files = BTreeMap::new();
+        files.insert(crate::KERNEL_FILE_NAME, self.kernel.as_path());
+        files.insert(BIOS_STAGE_3, stage_3_path);
+        files.insert(BIOS_STAGE_4, stage_4_path);
+
+        let out_file = NamedTempFile::new().context("failed to create temp file")?;
+        fat::create_fat_filesystem(files, out_file.path())
+            .context("failed to create BIOS FAT filesystem")?;
+
+        Ok(out_file)
+    }
+}

src/bios/mod.rs

@@ -4,132 +4,16 @@ An experimental x86_64 bootloader that works on both BIOS and UEFI systems.
 
 #![warn(missing_docs)]
 
-use anyhow::Context;
-use std::{
-    collections::BTreeMap,
-    path::{Path, PathBuf},
-};
-use tempfile::NamedTempFile;
-
+#[cfg(feature = "bios")]
+mod bios;
 mod fat;
-mod gpt;
-mod mbr;
-mod pxe;
-
-const KERNEL_FILE_NAME: &str = "kernel-x86_64";
-const BIOS_STAGE_3: &str = "boot-stage-3";
-const BIOS_STAGE_4: &str = "boot-stage-4";
-
-/// Create disk images for booting on legacy BIOS systems.
-pub struct BiosBoot {
-    kernel: PathBuf,
-}
-
-impl BiosBoot {
-    /// Start creating a disk image for the given bootloader ELF executable.
-    pub fn new(kernel_path: &Path) -> Self {
-        Self {
-            kernel: kernel_path.to_owned(),
-        }
-    }
-
-    /// Create a bootable UEFI disk image at the given path.
-    pub fn create_disk_image(&self, out_path: &Path) -> anyhow::Result<()> {
-        let bootsector_path = Path::new(env!("BIOS_BOOT_SECTOR_PATH"));
-        let stage_2_path = Path::new(env!("BIOS_STAGE_2_PATH"));
-
-        let fat_partition = self
-            .create_fat_partition()
-            .context("failed to create FAT partition")?;
-
-        mbr::create_mbr_disk(
-            bootsector_path,
-            stage_2_path,
-            fat_partition.path(),
-            out_path,
-        )
-        .context("failed to create BIOS MBR disk image")?;
-
-        fat_partition
-            .close()
-            .context("failed to delete FAT partition after disk image creation")?;
-
-        Ok(())
-    }
-
-    /// Creates an BIOS-bootable FAT partition with the kernel.
-    fn create_fat_partition(&self) -> anyhow::Result<NamedTempFile> {
-        let stage_3_path = Path::new(env!("BIOS_STAGE_3_PATH"));
-        let stage_4_path = Path::new(env!("BIOS_STAGE_4_PATH"));
-
-        let mut files = BTreeMap::new();
-        files.insert(KERNEL_FILE_NAME, self.kernel.as_path());
-        files.insert(BIOS_STAGE_3, stage_3_path);
-        files.insert(BIOS_STAGE_4, stage_4_path);
-
-        let out_file = NamedTempFile::new().context("failed to create temp file")?;
-        fat::create_fat_filesystem(files, out_file.path())
-            .context("failed to create BIOS FAT filesystem")?;
+#[cfg(feature = "uefi")]
+mod uefi;
 
-        Ok(out_file)
-    }
-}
+#[cfg(feature = "bios")]
+pub use bios::BiosBoot;
 
-/// Create disk images for booting on UEFI systems.
-pub struct UefiBoot {
-    kernel: PathBuf,
-}
+#[cfg(feature = "uefi")]
+pub use uefi::UefiBoot;
 
-impl UefiBoot {
-    /// Start creating a disk image for the given bootloader ELF executable.
-    pub fn new(kernel_path: &Path) -> Self {
-        Self {
-            kernel: kernel_path.to_owned(),
-        }
-    }
-
-    /// Create a bootable BIOS disk image at the given path.
-    pub fn create_disk_image(&self, out_path: &Path) -> anyhow::Result<()> {
-        let fat_partition = self
-            .create_fat_partition()
-            .context("failed to create FAT partition")?;
-
-        gpt::create_gpt_disk(fat_partition.path(), out_path)
-            .context("failed to create UEFI GPT disk image")?;
-
-        fat_partition
-            .close()
-            .context("failed to delete FAT partition after disk image creation")?;
-
-        Ok(())
-    }
-
-    /// Prepare a folder for use with booting over UEFI_PXE.
-    ///
-    /// This places the bootloader executable under the path "bootloader". The
-    /// DHCP server should set the filename option to that path, otherwise the
-    /// bootloader won't be found.
-    pub fn create_pxe_tftp_folder(&self, out_path: &Path) -> anyhow::Result<()> {
-        let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
-
-        pxe::create_uefi_tftp_folder(bootloader_path, self.kernel.as_path(), out_path)
-            .context("failed to create UEFI PXE tftp folder")?;
-
-        Ok(())
-    }
-
-    /// Creates an UEFI-bootable FAT partition with the kernel.
-    fn create_fat_partition(&self) -> anyhow::Result<NamedTempFile> {
-        let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
-
-        let mut files = BTreeMap::new();
-        files.insert("efi/boot/bootx64.efi", bootloader_path);
-        files.insert(KERNEL_FILE_NAME, self.kernel.as_path());
-
-        let out_file = NamedTempFile::new().context("failed to create temp file")?;
-        fat::create_fat_filesystem(files, out_file.path())
-            .context("failed to create UEFI FAT filesystem")?;
-
-        Ok(out_file)
-    }
-}
+const KERNEL_FILE_NAME: &str = "kernel-x86_64";

src/lib.rs

@@ -0,0 +1,69 @@
+use crate::fat;
+use anyhow::Context;
+use std::{
+    collections::BTreeMap,
+    path::{Path, PathBuf},
+};
+use tempfile::NamedTempFile;
+
+mod gpt;
+mod pxe;
+
+/// Create disk images for booting on UEFI systems.
+pub struct UefiBoot {
+    kernel: PathBuf,
+}
+
+impl UefiBoot {
+    /// Start creating a disk image for the given bootloader ELF executable.
+    pub fn new(kernel_path: &Path) -> Self {
+        Self {
+            kernel: kernel_path.to_owned(),
+        }
+    }
+
+    /// Create a bootable BIOS disk image at the given path.
+    pub fn create_disk_image(&self, out_path: &Path) -> anyhow::Result<()> {
+        let fat_partition = self
+            .create_fat_partition()
+            .context("failed to create FAT partition")?;
+
+        gpt::create_gpt_disk(fat_partition.path(), out_path)
+            .context("failed to create UEFI GPT disk image")?;
+
+        fat_partition
+            .close()
+            .context("failed to delete FAT partition after disk image creation")?;
+
+        Ok(())
+    }
+
+    /// Prepare a folder for use with booting over UEFI_PXE.
+    ///
+    /// This places the bootloader executable under the path "bootloader". The
+    /// DHCP server should set the filename option to that path, otherwise the
+    /// bootloader won't be found.
+    pub fn create_pxe_tftp_folder(&self, out_path: &Path) -> anyhow::Result<()> {
+        let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
+
+        pxe::create_uefi_tftp_folder(bootloader_path, self.kernel.as_path(), out_path)
+            .context("failed to create UEFI PXE tftp folder")?;
+
+        Ok(())
+    }
+
+    /// Creates an UEFI-bootable FAT partition with the kernel.
+    fn create_fat_partition(&self) -> anyhow::Result<NamedTempFile> {
+        let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
+
+        let mut files = BTreeMap::new();
+        files.insert("efi/boot/bootx64.efi", bootloader_path);
+        files.insert(crate::KERNEL_FILE_NAME, self.kernel.as_path());
+
+        let out_file = NamedTempFile::new().context("failed to create temp file")?;
+        fat::create_fat_filesystem(files, out_file.path())
+            .context("failed to create UEFI FAT filesystem")?;
+
+        Ok(out_file)
+    }
+}