feat: implement decompression of Hermit images

fogti · fogti · commit 31f545b56e72 · 2025-11-28T14:16:16.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,7 +11,7 @@ align-address = "0.3"
 allocator-api2 = { version = "0.3", default-features = false }
 anstyle = { version = "1", default-features = false }
 cfg-if = "1"
-hermit-entry = { version = "0.10", features = ["loader"] }
+hermit-entry = { version = "0.10", git = "https://github.com/fogti/hermit-entry.git", branch = "image-reader", features = ["allocator-api2", "loader"] }
 log = "0.4"
 one-shot-mutex = "0.2"
 sptr = "0.3"
diff --git a/src/arch/aarch64/mod.rs b/src/arch/aarch64/mod.rs
@@ -20,7 +20,7 @@ use sptr::Strict;
 
 use crate::BootInfoExt;
 use crate::arch::paging::*;
-use crate::os::CONSOLE;
+use crate::os::{CONSOLE, ExtraBootInfo};
 
 unsafe extern "C" {
 	static mut loader_end: u8;
@@ -110,12 +110,14 @@ pub fn find_kernel() -> &'static [u8] {
 	}
 }
 
-pub unsafe fn boot_kernel(kernel_info: LoadedKernel) -> ! {
+pub unsafe fn boot_kernel(kernel_info: LoadedKernel, extra_info: ExtraBootInfo) -> ! {
 	let LoadedKernel {
 		load_info,
 		entry_point,
 	} = kernel_info;
 
+	assert!(extra_info.image.is_none());
+
 	let dtb = unsafe {
 		Fdt::from_ptr(sptr::from_exposed_addr(get_dtb_addr() as usize))
 			.expect(".dtb file has invalid header")
diff --git a/src/arch/mod.rs b/src/arch/mod.rs
@@ -5,7 +5,7 @@ cfg_if::cfg_if! {
 	} else if #[cfg(target_arch = "riscv64")] {
 		mod riscv64;
 		pub use self::riscv64::*;
-	} else if #[cfg(all(target_arch = "x86_64"))] {
+	} else if #[cfg(target_arch = "x86_64")] {
 		mod x86_64;
 		pub use self::x86_64::*;
 	}
diff --git a/src/arch/riscv64/mod.rs b/src/arch/riscv64/mod.rs
@@ -17,6 +17,7 @@ use log::info;
 use sptr::Strict;
 
 use crate::BootInfoExt;
+use crate::os::ExtraBootInfo;
 
 fn find_kernel_linux(chosen: &FdtNode<'_, '_>) -> Option<&'static [u8]> {
 	let initrd_start = chosen.property("linux,initrd-start")?.as_usize()?;
@@ -90,7 +91,7 @@ pub unsafe fn get_memory(memory_size: u64) -> u64 {
 	u64::try_from(start_address).unwrap()
 }
 
-pub unsafe fn boot_kernel(kernel_info: LoadedKernel) -> ! {
+pub unsafe fn boot_kernel(kernel_info: LoadedKernel, extra_info: ExtraBootInfo) -> ! {
 	let LoadedKernel {
 		load_info,
 		entry_point,
@@ -118,6 +119,8 @@ pub unsafe fn boot_kernel(kernel_info: LoadedKernel) -> ! {
 		DeviceTreeAddress::new(fdt_addr.try_into().unwrap())
 	};
 
+	assert!(extra_info.image.is_none());
+
 	let boot_info = BootInfo {
 		hardware_info: HardwareInfo {
 			phys_addr_range,
diff --git a/src/arch/x86_64/firecracker.rs b/src/arch/x86_64/firecracker.rs
@@ -20,6 +20,7 @@ use super::physicalmem::PhysAlloc;
 use super::{KERNEL_STACK_SIZE, SERIAL_IO_PORT, paging};
 use crate::BootInfoExt;
 use crate::fdt::Fdt;
+use crate::os::ExtraBootInfo;
 
 unsafe extern "C" {
 	static mut loader_end: u8;
@@ -118,7 +119,7 @@ pub fn find_kernel() -> &'static [u8] {
 	unsafe { slice::from_raw_parts(sptr::from_exposed_addr(elf_start), elf_len) }
 }
 
-pub unsafe fn boot_kernel(kernel_info: LoadedKernel) -> ! {
+pub unsafe fn boot_kernel(kernel_info: LoadedKernel, extra_info: ExtraBootInfo) -> ! {
 	let LoadedKernel {
 		load_info,
 		entry_point,
@@ -172,7 +173,12 @@ pub unsafe fn boot_kernel(kernel_info: LoadedKernel) -> ! {
 		write_bytes(stack, 0, KERNEL_STACK_SIZE.try_into().unwrap());
 	}
 
-	let mut fdt = Fdt::new("firecracker").unwrap();
+	let maybe_image = match extra_info.image {
+		None => &[],
+		Some(tar_image) => tar_image,
+	};
+
+	let mut fdt = Fdt::new("firecracker", maybe_image).unwrap();
 
 	// Load the boot_param memory-map information
 	let linux_e820_entries =
diff --git a/src/arch/x86_64/multiboot.rs b/src/arch/x86_64/multiboot.rs
@@ -18,6 +18,7 @@ use super::physicalmem::PhysAlloc;
 use crate::BootInfoExt;
 use crate::arch::x86_64::{KERNEL_STACK_SIZE, SERIAL_IO_PORT};
 use crate::fdt::Fdt;
+use crate::os::ExtraBootInfo;
 
 unsafe extern "C" {
 	static mut loader_end: u8;
@@ -55,15 +56,20 @@ impl MemoryManagement for Mem {
 pub struct DeviceTree;
 
 impl DeviceTree {
-	pub fn create() -> FdtWriterResult<&'static [u8]> {
+	pub fn create(extra_info: &ExtraBootInfo) -> FdtWriterResult<&'static [u8]> {
 		let mut mem = Mem;
 		let multiboot = unsafe { Multiboot::from_ptr(mb_info as u64, &mut mem).unwrap() };
 
 		let memory_regions = multiboot
 			.memory_regions()
 			.expect("Could not find a memory map in the Multiboot information");
 
-		let mut fdt = Fdt::new("multiboot")?.memory_regions(memory_regions)?;
+		let maybe_image = match extra_info.image {
+			None => &[],
+			Some(tar_image) => tar_image,
+		};
+
+		let mut fdt = Fdt::new("multiboot", maybe_image)?.memory_regions(memory_regions)?;
 
 		if let Some(cmdline) = multiboot.command_line() {
 			fdt = fdt.bootargs(cmdline.to_owned())?;
@@ -142,7 +148,7 @@ pub fn find_kernel() -> &'static [u8] {
 	unsafe { slice::from_raw_parts(sptr::from_exposed_addr(elf_start), elf_len) }
 }
 
-pub unsafe fn boot_kernel(kernel_info: LoadedKernel) -> ! {
+pub unsafe fn boot_kernel(kernel_info: LoadedKernel, extra_info: ExtraBootInfo) -> ! {
 	let LoadedKernel {
 		load_info,
 		entry_point,
@@ -185,7 +191,7 @@ pub unsafe fn boot_kernel(kernel_info: LoadedKernel) -> ! {
 		write_bytes(stack, 0, KERNEL_STACK_SIZE.try_into().unwrap());
 	}
 
-	let device_tree = DeviceTree::create().expect("Unable to create devicetree!");
+	let device_tree = DeviceTree::create(extra_info).expect("Unable to create devicetree!");
 	let device_tree =
 		DeviceTreeAddress::new(u64::try_from(device_tree.as_ptr().expose_addr()).unwrap());
 
diff --git a/src/fdt.rs b/src/fdt.rs
@@ -9,31 +9,47 @@ pub struct Fdt {
 	writer: FdtWriter,
 	root_node: FdtWriterNode,
 	bootargs: Option<String>,
+	image_range: Option<(u64, u64)>,
 }
 
 impl Fdt {
-	pub fn new(platform: &str) -> FdtWriterResult<Self> {
-		let mut writer = FdtWriter::new()?;
+	pub fn new(platform: &str, maybe_image: &'static [u8]) -> FdtWriterResult<Self> {
+		let mut mem_reserved = Vec::new();
+
+		let image_range = if maybe_image.is_empty() {
+			None
+		} else {
+			let image_start = (&maybe_image[0]) as *const u8 as u64;
+			mem_reserved.push(FdtReserveEntry::new(image_start, maybe_image.len() as u64)?);
+			Some((image_start, maybe_image.len() as u64))
+		};
+
+		let mut writer = FdtWriter::new_with_mem_reserv(&mem_reserved[..])?;
 
 		let root_node = writer.begin_node("")?;
 		writer.property_string("compatible", &format!("hermit,{platform}"))?;
 		writer.property_u32("#address-cells", 0x2)?;
 		writer.property_u32("#size-cells", 0x2)?;
 
-		let bootargs = None;
-
 		Ok(Self {
 			writer,
 			root_node,
-			bootargs,
+			bootargs: None,
+			image_range,
 		})
 	}
 
 	pub fn finish(mut self) -> FdtWriterResult<Vec<u8>> {
 		let chosen_node = self.writer.begin_node("chosen")?;
+
 		if let Some(bootargs) = &self.bootargs {
 			self.writer.property_string("bootargs", bootargs)?;
 		}
+
+		if let Some((image_start, image_len)) = self.image_range {
+			self.writer_property_array_u64("image_reg", &[image_start, image_len])?;
+		}
+
 		self.writer.end_node(chosen_node)?;
 
 		self.writer.end_node(self.root_node)?;
diff --git a/src/main.rs b/src/main.rs
@@ -12,7 +12,9 @@ use hermit_entry::boot_info::{BootInfo, RawBootInfo};
 mod macros;
 
 mod arch;
+
 mod bump_allocator;
+
 #[cfg(any(target_os = "uefi", target_arch = "x86_64"))]
 mod fdt;
 mod log;
@@ -45,3 +47,38 @@ fn _print(args: core::fmt::Arguments<'_>) {
 
 	self::os::CONSOLE.lock().write_fmt(args).unwrap();
 }
+
+/// Detects the input format are resolves the kernel
+fn resolve_kernel<'a, A: allocator_api2::alloc::Allocator>(
+	input_blob: &[u8],
+	alloc: A,
+	buf: &'a mut Option<allocator_api2::boxes::Box<hermit_entry::tar_parser::Bytes, A>>,
+) -> (&'a [u8], Option<hermit_entry::config::Config>) {
+	use hermit_entry::{Format, ThinTree, decompress_image_with_allocator, detect_format};
+	match detect_format(input_blob) {
+		Some(Format::Elf) => (input_blob, None),
+
+		Some(Format::Gzip) => {
+			*buf = Some(
+				decompress_image_with_allocator(input_blob, alloc)
+					.expect("Unable to decompress Hermit gzip image"),
+			);
+			let tmp = buf.as_mut().unwrap();
+
+			let image_tree =
+				ThinTree::try_from_image(&tmp).expect("Unable to parse Hermit image tarball");
+
+			let (config, kernel) = image_tree
+				.handle_config()
+				.expect("Unable to find Hermit image configuration + kernel");
+
+			// TODO: do we just let the kernel handle the config
+
+			(kernel, Some(config))
+		}
+
+		None => {
+			panic!("Input BLOB has unknown magic bytes (neither Gzip nor ELF)")
+		}
+	}
+}
diff --git a/src/os/mod.rs b/src/os/mod.rs
@@ -7,3 +7,9 @@ cfg_if::cfg_if! {
 		pub use self::uefi::*;
 	}
 }
+
+//#[cfg(any(target_os = "none", feature = "fc"))]
+#[derive(Clone)]
+pub struct ExtraBootInfo {
+	pub(crate) image: Option<&'static [u8]>,
+}
diff --git a/src/os/none/allocator/mod.rs b/src/os/none/allocator/mod.rs
@@ -2,6 +2,8 @@
 
 mod bootstrap;
 
+pub mod oneshot;
+
 use core::ptr;
 use core::ptr::NonNull;
 
diff --git a/src/os/none/allocator/oneshot.rs b/src/os/none/allocator/oneshot.rs
@@ -0,0 +1,85 @@
+//! A one-shot allocator.
+//!
+//! This is a simple allocator design which can only allocate once.
+
+use core::cell::Cell;
+use core::mem::MaybeUninit;
+use core::ptr::NonNull;
+
+use allocator_api2::alloc::{AllocError, Allocator, Layout};
+
+/// A simple, `!Sync` implementation of a one-shot allocator.
+///
+/// This allocator manages the provided memory.
+pub struct OneshotAllocator {
+	mem: Cell<*mut u8>,
+}
+
+unsafe impl Allocator for OneshotAllocator {
+	fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
+		assert!(layout.align() <= 8);
+		// `mem` is already aligned.
+
+		match NonNull::new(self.mem.take()) {
+			None => return Err(AllocError),
+			Some(mem) => {
+				let mid = layout.size();
+				if mid >= (usize::MAX / 2) {
+					self.mem.set(mem);
+					Err(AllocError)
+				} else {
+					Ok(mem)
+				}
+			}
+		}
+	}
+
+	unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+		if self.mem.get().is_null() {
+			self.mem.set(ptr);
+		} else {
+			#[cfg(debug_assertions)]
+			panic!("Tried to deallocate pointer that was allocated from a different allocator");
+		}
+	}
+
+	unsafe fn grow(
+		&self,
+		ptr: NonNull<u8>,
+		old_layout: Layout,
+		new_layout: Layout,
+	) -> Result<NonNull<[u8]>, AllocError> {
+		assert!(new_layout.align() <= 8);
+		Ok(ptr)
+	}
+
+	unsafe fn grow_zeroed(
+		&self,
+		ptr: NonNull<u8>,
+		old_layout: Layout,
+		new_layout: Layout,
+	) -> Result<NonNull<[u8]>, AllocError> {
+		assert!(
+			new_layout.size() >= old_layout.size(),
+			"`new_layout.size()` must be greater than or equal to `old_layout.size()`"
+		);
+		assert!(new_layout.align() <= 8);
+
+		unsafe {
+			ptr.add(old_layout.size())
+				.as_ptr()
+				.write_bytes(0, new_layout.size() - old_layout.size())
+		};
+
+		Ok(ptr)
+	}
+}
+
+impl OneshotAllocator {
+	pub fn new(ptr: NonNull<u8>) -> Self {
+		let align_offset = ptr.align_offset(8);
+		Self {
+			mem: Cell::new(ptr.add(align_offset)),
+		}
+	}
+}
diff --git a/src/os/none/mod.rs b/src/os/none/mod.rs
@@ -1,4 +1,4 @@
-mod allocator;
+pub(crate) mod allocator;
 mod console;
 
 use core::fmt::Write;
@@ -10,6 +10,7 @@ use log::info;
 
 pub use self::console::CONSOLE;
 use crate::arch;
+use crate::os::ExtraBootInfo;
 
 unsafe extern "C" {
 	static loader_end: u8;
@@ -26,8 +27,19 @@ pub(crate) unsafe extern "C" fn loader_main() -> ! {
 	}
 
 	let kernel = arch::find_kernel();
+
+	let allocator = allocator::oneshot::OneshotAllocator::new(todo!());
+	let mut buf = None;
+	let (kernel, _) = crate::resolve_kernel(kernel, allocator, &mut buf);
+
 	let kernel = KernelObject::parse(kernel).unwrap();
 
+	let mut extra_info = ExtraBootInfo::default();
+	if let Some(tar_image) = buf {
+		let tar_image = allocator_api2::boxed::Box::leak(tar_image);
+		extra_info.image = Some(&tar_image[..]);
+	}
+
 	let mem_size = kernel.mem_size();
 	let kernel_addr = unsafe { arch::get_memory(mem_size as u64) };
 	let kernel_addr = kernel.start_addr().unwrap_or(kernel_addr);
@@ -40,7 +52,7 @@ pub(crate) unsafe extern "C" fn loader_main() -> ! {
 
 	let kernel_info = kernel.load_kernel(memory, memory.as_ptr() as u64);
 
-	unsafe { arch::boot_kernel(kernel_info) }
+	unsafe { arch::boot_kernel(kernel_info, extra_info) }
 }
 
 #[panic_handler]
diff --git a/src/os/uefi/mod.rs b/src/os/uefi/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ cfg_if::cfg_if! {`
`5`	`5`	`} else if #[cfg(target_arch = "riscv64")] {`
`6`	`6`	`mod riscv64;`
`7`	`7`	`pub use self::riscv64::*;`
`8`		`- } else if #[cfg(all(target_arch = "x86_64"))] {`
	`8`	`+ } else if #[cfg(target_arch = "x86_64")] {`
`9`	`9`	`mod x86_64;`
`10`	`10`	`pub use self::x86_64::*;`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,3 +7,9 @@ cfg_if::cfg_if! {`
`7`	`7`	`pub use self::uefi::*;`
`8`	`8`	`}`
`9`	`9`	`}`
	`10`	`+`
	`11`	`+//#[cfg(any(target_os = "none", feature = "fc"))]`
	`12`	`+#[derive(Clone)]`
	`13`	`+pub struct ExtraBootInfo {`
	`14`	`+ pub(crate) image: Option<&'static [u8]>,`
	`15`	`+}`