Refactor FAT creation function to take arbitrary file list

Author: phil-opp

src/fat.rs

@@ -0,0 +1,82 @@
+use anyhow::Context;
+use std::{collections::BTreeMap, fs, io, path::Path};
+
+use crate::KERNEL_FILE_NAME;
+
+pub fn create_fat_filesystem(
+    files: BTreeMap<&str, &Path>,
+    out_fat_path: &Path,
+) -> anyhow::Result<()> {
+    const MB: u64 = 1024 * 1024;
+
+    // calculate needed size
+    let mut needed_size = 0;
+    for path in files.values() {
+        let file_size = fs::metadata(path)
+            .with_context(|| format!("failed to read metadata of file `{}`", path.display()))?
+            .len();
+        needed_size += file_size;
+    }
+
+    // create new filesystem image file at the given path and set its length
+    let fat_file = fs::OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(true)
+        .open(&out_fat_path)
+        .unwrap();
+    let fat_size_padded_and_rounded = ((needed_size + 1024 * 64 - 1) / MB + 1) * MB;
+    fat_file.set_len(fat_size_padded_and_rounded).unwrap();
+
+    // choose a file system label
+    let mut label = *b"MY_RUST_OS!";
+    if let Some(path) = files.get(KERNEL_FILE_NAME) {
+        if let Some(name) = path.file_stem() {
+            let converted = name.to_string_lossy();
+            let name = converted.as_bytes();
+            let mut new_label = [0u8; 11];
+            let name = &name[..new_label.len()];
+            let slice = &mut new_label[..name.len()];
+            slice.copy_from_slice(name);
+            label = new_label;
+        }
+    }
+
+    // format the file system and open it
+    let format_options = fatfs::FormatVolumeOptions::new().volume_label(label);
+    fatfs::format_volume(&fat_file, format_options).context("Failed to format UEFI FAT file")?;
+    let filesystem = fatfs::FileSystem::new(&fat_file, fatfs::FsOptions::new())
+        .context("Failed to open FAT file system of UEFI FAT file")?;
+
+    // copy files to file system
+    let root_dir = filesystem.root_dir();
+    for (target_path_raw, file_path) in files {
+        let target_path = Path::new(target_path_raw);
+        // create parent directories
+        let ancestors: Vec<_> = target_path.ancestors().skip(1).collect();
+        for ancestor in ancestors.into_iter().rev().skip(1) {
+            root_dir
+                .create_dir(&ancestor.display().to_string())
+                .with_context(|| {
+                    format!(
+                        "failed to create directory `{}` on FAT filesystem",
+                        ancestor.display()
+                    )
+                })?;
+        }
+
+        let mut new_file = root_dir
+            .create_file(target_path_raw)
+            .with_context(|| format!("failed to create file at `{}`", target_path.display()))?;
+        new_file.truncate().unwrap();
+        io::copy(
+            &mut fs::File::open(file_path)
+                .with_context(|| format!("failed to open `{}` for copying", file_path.display()))?,
+            &mut new_file,
+        )
+        .with_context(|| format!("failed to copy `{}` to FAT filesystem", file_path.display()))?;
+    }
+
+    Ok(())
+}

src/lib.rs

@@ -69,90 +69,34 @@ for all possible configuration options.
 
 use anyhow::Context;
 use std::{
+    collections::BTreeMap,
     fs::{self, File},
     io::{self, Seek},
     path::Path,
 };
 
+mod fat;
+
+const KERNEL_FILE_NAME: &str = "kernel-x86_64";
+
 pub fn create_uefi_disk_image(
     kernel_binary: &Path,
     out_fat_path: &Path,
     out_gpt_path: &Path,
 ) -> anyhow::Result<()> {
     let bootloader_path = Path::new(env!("UEFI_BOOTLOADER_PATH"));
 
-    create_fat_filesystem(bootloader_path, kernel_binary, &out_fat_path)
+    let mut files = BTreeMap::new();
+    files.insert("efi/boot/bootx64.efi", bootloader_path);
+    files.insert(KERNEL_FILE_NAME, kernel_binary);
+
+    fat::create_fat_filesystem(files, &out_fat_path)
         .context("failed to create UEFI FAT filesystem")?;
     create_gpt_disk(out_fat_path, out_gpt_path);
 
     Ok(())
 }
 
-fn create_fat_filesystem(
-    bootloader_efi_file: &Path,
-    kernel_binary: &Path,
-    out_fat_path: &Path,
-) -> anyhow::Result<()> {
-    const MB: u64 = 1024 * 1024;
-
-    // retrieve size of `.efi` file and round it up
-    let efi_size = fs::metadata(&bootloader_efi_file).unwrap().len();
-    let kernel_size = fs::metadata(&kernel_binary)
-        .context("failed to read metadata of kernel binary")?
-        .len();
-
-    // create new filesystem image file at the given path and set its length
-    let fat_file = fs::OpenOptions::new()
-        .read(true)
-        .write(true)
-        .create(true)
-        .truncate(true)
-        .open(&out_fat_path)
-        .unwrap();
-    let fat_size = efi_size + kernel_size;
-    let fat_size_padded_and_rounded = ((fat_size + 1024 * 64 - 1) / MB + 1) * MB;
-    fat_file.set_len(fat_size_padded_and_rounded).unwrap();
-
-    // create new FAT file system and open it
-    let label = {
-        if let Some(name) = bootloader_efi_file.file_stem() {
-            let converted = name.to_string_lossy();
-            let name = converted.as_bytes();
-            let mut label = [0u8; 11];
-            let name = &name[..label.len()];
-            let slice = &mut label[..name.len()];
-            slice.copy_from_slice(name);
-            label
-        } else {
-            *b"MY_RUST_OS!"
-        }
-    };
-    let format_options = fatfs::FormatVolumeOptions::new().volume_label(label);
-    fatfs::format_volume(&fat_file, format_options).context("Failed to format UEFI FAT file")?;
-    let filesystem = fatfs::FileSystem::new(&fat_file, fatfs::FsOptions::new())
-        .context("Failed to open FAT file system of UEFI FAT file")?;
-
-    // copy EFI file to FAT filesystem
-    let root_dir = filesystem.root_dir();
-    root_dir.create_dir("efi").unwrap();
-    root_dir.create_dir("efi/boot").unwrap();
-    let mut bootx64 = root_dir.create_file("efi/boot/bootx64.efi").unwrap();
-    bootx64.truncate().unwrap();
-    io::copy(
-        &mut fs::File::open(&bootloader_efi_file).unwrap(),
-        &mut bootx64,
-    )
-    .unwrap();
-
-    // copy kernel to FAT filesystem
-    let mut kernel_file = root_dir.create_file("kernel-x86_64")?;
-    kernel_file.truncate()?;
-    io::copy(&mut fs::File::open(&kernel_binary)?, &mut kernel_file)
-        .context("failed to copy kernel to UEFI FAT filesystem")?;
-
-    Ok(())
-}
-
 fn create_gpt_disk(fat_image: &Path, out_gpt_path: &Path) {
     // create new file
     let mut disk = fs::OpenOptions::new()