loader: add support for initrd

Add the optional "initrd_path" property to the "boot-source" the REST API.
The initrd is for the moment loaded at a fixed address.

Co-developed-by: Tim Deegan <[email protected]>
Signed-off-by: Tim Deegan <[email protected]>
Co-developed-by: Marco Vedovati <[email protected]>
Signed-off-by: Marco Vedovati <[email protected]>

Author: marcov

api_server/src/request/boot_source.rs

@@ -32,10 +32,12 @@ mod tests {
     fn test_into_parsed_request() {
         let body = BootSourceConfig {
             kernel_image_path: String::from("/foo/bar"),
+            initrd_path: None,
             boot_args: Some(String::from("foobar")),
         };
         let same_body = BootSourceConfig {
             kernel_image_path: String::from("/foo/bar"),
+            initrd_path: None,
             boot_args: Some(String::from("foobar")),
         };
         let (sender, receiver) = oneshot::channel();

api_server/swagger/firecracker.yaml

@@ -395,6 +395,9 @@ definitions:
       kernel_image_path:
         type: string
         description: Host level path to the kernel image used to boot the guest
+      initrd_path:
+        type: string
+        description: Host level path to the initrd image used to boot the guest
       boot_args:
         type: string
         description: Kernel boot arguments

arch/src/x86_64/mod.rs

@@ -98,6 +98,8 @@ pub fn configure_system(
     guest_mem: &GuestMemory,
     cmdline_addr: GuestAddress,
     cmdline_size: usize,
+    initrd_addr: GuestAddress,
+    initrd_size: usize,
     num_cpus: u8,
 ) -> super::Result<()> {
     const KERNEL_BOOT_FLAG_MAGIC: u16 = 0xaa55;
@@ -120,6 +122,8 @@ pub fn configure_system(
     params.0.hdr.cmd_line_ptr = cmdline_addr.offset() as u32;
     params.0.hdr.cmdline_size = cmdline_size as u32;
     params.0.hdr.kernel_alignment = KERNEL_MIN_ALIGNMENT_BYTES;
+    params.0.hdr.ramdisk_image = initrd_addr.offset() as u32;
+    params.0.hdr.ramdisk_size = initrd_size as u32;
 
     add_e820_entry(&mut params.0, 0, EBDA_START, E820_RAM)?;
 
@@ -212,7 +216,7 @@ mod tests {
     fn test_system_configuration() {
         let no_vcpus = 4;
         let gm = GuestMemory::new(&[(GuestAddress(0), 0x10000)]).unwrap();
-        let config_err = configure_system(&gm, GuestAddress(0), 0, 1);
+        let config_err = configure_system(&gm, GuestAddress(0), 0, GuestAddress(0), 0, 1);
         assert!(config_err.is_err());
         match config_err.unwrap_err() {
             super::super::Error::X86_64Setup(e) => assert_eq!(
@@ -224,19 +228,19 @@ mod tests {
         let mem_size = 128 << 20;
         let arch_mem_regions = arch_memory_regions(mem_size);
         let gm = GuestMemory::new(&arch_mem_regions).unwrap();
-        configure_system(&gm, GuestAddress(0), 0, no_vcpus).unwrap();
+        configure_system(&gm, GuestAddress(0), 0, GuestAddress(0), 0, no_vcpus).unwrap();
 
         // Now assigning some memory that is equal to the start of the 32bit memory hole.
         let mem_size = 3328 << 20;
         let arch_mem_regions = arch_memory_regions(mem_size);
         let gm = GuestMemory::new(&arch_mem_regions).unwrap();
-        configure_system(&gm, GuestAddress(0), 0, no_vcpus).unwrap();
+        configure_system(&gm, GuestAddress(0), 0, GuestAddress(0), 0, no_vcpus).unwrap();
 
         // Now assigning some memory that falls after the 32bit memory hole.
         let mem_size = 3330 << 20;
         let arch_mem_regions = arch_memory_regions(mem_size);
         let gm = GuestMemory::new(&arch_mem_regions).unwrap();
-        configure_system(&gm, GuestAddress(0), 0, no_vcpus).unwrap();
+        configure_system(&gm, GuestAddress(0), 0, GuestAddress(0), 0, no_vcpus).unwrap();
     }
 
     #[test]

kernel/src/loader/mod.rs

@@ -30,8 +30,10 @@ pub enum Error {
     InvalidProgramHeaderSize,
     InvalidProgramHeaderOffset,
     InvalidProgramHeaderAddress,
+    ReadInitrd,
     ReadKernelDataStruct(&'static str),
     ReadKernelImage,
+    SeekInitrd,
     SeekKernelStart,
     SeekKernelImage,
     SeekProgramHeader,
@@ -49,12 +51,14 @@ impl fmt::Display for Error {
                 Error::InvalidProgramHeaderSize => "Invalid ELF program header size",
                 Error::InvalidProgramHeaderOffset => "Invalid ELF program header offset",
                 Error::InvalidProgramHeaderAddress => "Invalid ELF program header address",
+                Error::ReadInitrd => "Failed to read initrd image",
                 Error::ReadKernelDataStruct(ref e) => e,
                 Error::ReadKernelImage => "Failed to write kernel image to guest memory",
                 Error::SeekKernelStart => {
                     "Failed to seek to file offset as pointed by the ELF program header"
                 }
                 Error::SeekKernelImage => "Failed to seek to offset of kernel image",
+                Error::SeekInitrd => "Failed to seek initrd image",
                 Error::SeekProgramHeader => "Failed to seek to ELF program header",
             }
         )
@@ -258,6 +262,37 @@ pub fn load_cmdline(
     Ok(())
 }
 
+/// Loads the initrd from a file into the given memory slice.
+///
+/// * `guest_mem` - The guest memory region the initrd is written to.
+/// * `initrd_image` - Input initrd image.
+///
+/// Returns the entry address of the initrd and its length as a tuple
+pub fn load_initrd<F>(
+    guest_mem: &GuestMemory,
+    initrd_image: &mut F,
+) -> Result<(GuestAddress, usize)>
+where
+    F: Read + Seek,
+{
+    // This works for bzImage kernels because they load at 1MiB and have 16MiB init space.
+    // In practice works for many ELF kernels too because they load at 16MiB.
+    // Ought to have an allocator in guest_mem to find an empty spot.
+    const INITRD_LOAD_ADDRESS: usize = 0x300_0000; // 48 MiB
+
+    let load_bytes = initrd_image
+        .seek(SeekFrom::End(0))
+        .map_err(|_| Error::SeekInitrd)? as usize;
+    initrd_image
+        .seek(SeekFrom::Start(0))
+        .map_err(|_| Error::SeekInitrd)?;
+    guest_mem
+        .read_to_memory(GuestAddress(INITRD_LOAD_ADDRESS), initrd_image, load_bytes)
+        .map_err(|_| Error::ReadInitrd)?;
+
+    Ok((GuestAddress(INITRD_LOAD_ADDRESS), load_bytes))
+}
+
 #[cfg(test)]
 mod tests {
     use super::super::cmdline::Cmdline;

vmm/src/lib.rs

@@ -742,6 +742,7 @@ impl Drop for EpollContext {
 struct KernelConfig {
     cmdline: kernel_cmdline::Cmdline,
     kernel_file: File,
+    initrd_file: Option<File>,
     #[cfg(target_arch = "x86_64")]
     cmdline_addr: GuestAddress,
 }
@@ -1323,10 +1324,10 @@ impl Vmm {
         Ok(entry_addr)
     }
 
-    fn configure_system(&self) -> std::result::Result<(), StartMicrovmError> {
+    fn configure_system(&mut self) -> std::result::Result<(), StartMicrovmError> {
         use StartMicrovmError::*;
 
-        let kernel_config = self.kernel_config.as_ref().ok_or(MissingKernelConfig)?;
+        let kernel_config = self.kernel_config.as_mut().ok_or(MissingKernelConfig)?;
 
         let vm_memory = self.vm.get_memory().ok_or(GuestMemory(
             memory_model::GuestMemoryError::MemoryNotInitialized,
@@ -1336,11 +1337,22 @@ impl Vmm {
         // having set the vcpu count.
         let vcpu_count = self.vm_config.vcpu_count.ok_or(VcpusNotConfigured)?;
 
+        let initrd_file: &mut Option<File> = &mut kernel_config.initrd_file;
+
+        let (initrd_addr, initrd_size) = if let Some(ref mut initrd_file) = initrd_file {
+            kernel_loader::load_initrd(vm_memory, initrd_file)
+                .map_err(|e| StartMicrovmError::KernelLoader(e))?
+        } else {
+            (GuestAddress(0), 0)
+        };
+
         #[cfg(target_arch = "x86_64")]
         arch::x86_64::configure_system(
             vm_memory,
             kernel_config.cmdline_addr,
             kernel_config.cmdline.len() + 1,
+            initrd_addr,
+            initrd_size,
             vcpu_count,
         )
         .map_err(ConfigureSystem)?;
@@ -1606,6 +1618,7 @@ impl Vmm {
     fn configure_boot_source(
         &mut self,
         kernel_image_path: String,
+        initrd_path: Option<String>,
         kernel_cmdline: Option<String>,
     ) -> std::result::Result<VmmData, VmmActionError> {
         use BootSourceConfigError::{
@@ -1621,13 +1634,26 @@ impl Vmm {
         let kernel_file =
             File::open(kernel_image_path).map_err(|_| BootSource(User, InvalidKernelPath))?;
 
+        let initrd_file = match initrd_path {
+            None => None,
+            Some(path) => Some({
+                File::open(path).map_err(|_| {
+                    VmmActionError::BootSource(
+                        ErrorKind::User,
+                        BootSourceConfigError::InvalidInitrdPath,
+                    )
+                })?
+            }),
+        };
+
         let mut cmdline = kernel_cmdline::Cmdline::new(arch::CMDLINE_MAX_SIZE);
         cmdline
             .insert_str(kernel_cmdline.unwrap_or_else(|| String::from(DEFAULT_KERNEL_CMDLINE)))
             .map_err(|_| BootSource(User, InvalidKernelCommandLine))?;
 
         let kernel_config = KernelConfig {
             kernel_file,
+            initrd_file,
             cmdline,
             #[cfg(target_arch = "x86_64")]
             cmdline_addr: GuestAddress(arch::x86_64::layout::CMDLINE_START),
@@ -1934,6 +1960,7 @@ impl Vmm {
                 Vmm::send_response(
                     self.configure_boot_source(
                         boot_source_body.kernel_image_path,
+                        boot_source_body.initrd_path,
                         boot_source_body.boot_args,
                     ),
                     sender,
@@ -2142,6 +2169,7 @@ mod tests {
             let kernel_cfg = KernelConfig {
                 cmdline,
                 kernel_file,
+                initrd_file: None,
                 #[cfg(target_arch = "x86_64")]
                 cmdline_addr: GuestAddress(arch::x86_64::layout::CMDLINE_START),
             };
@@ -2685,6 +2713,7 @@ mod tests {
             cmdline_addr: dummy_addr,
             cmdline: kernel_cmdline::Cmdline::new(10),
             kernel_file: tempfile::tempfile().unwrap(),
+            initrd_file: None,
         });
         assert!(vmm.check_health().is_ok());
     }
@@ -2875,27 +2904,43 @@ mod tests {
 
         // Test invalid kernel path.
         assert!(vmm
-            .configure_boot_source(String::from("dummy-path"), None)
+            .configure_boot_source(String::from("dummy-path"), None, None)
             .is_err());
 
         // Test valid kernel path and invalid cmdline.
         let kernel_file = NamedTempFile::new().expect("Failed to create temporary kernel file.");
         let kernel_path = String::from(kernel_file.path().to_path_buf().to_str().unwrap());
+        let initrd_file = NamedTempFile::new().expect("Failed to create temporary initrd file.");
+        let initrd_path = String::from(initrd_file.path().to_path_buf().to_str().unwrap());
         let invalid_cmdline = String::from_utf8(vec![b'X'; arch::CMDLINE_MAX_SIZE + 1]).unwrap();
         assert!(vmm
-            .configure_boot_source(kernel_path.clone(), Some(invalid_cmdline))
+            .configure_boot_source(kernel_path.clone(), None, Some(invalid_cmdline))
             .is_err());
 
         // Test valid configuration.
-        assert!(vmm.configure_boot_source(kernel_path.clone(), None).is_ok());
         assert!(vmm
-            .configure_boot_source(kernel_path.clone(), Some(String::from("reboot=k")))
+            .configure_boot_source(kernel_path.clone(), None, None)
+            .is_ok());
+        assert!(vmm
+            .configure_boot_source(kernel_path.clone(), None, Some(String::from("reboot=k")))
+            .is_ok());
+
+        // Test valid configuration + initrd.
+        assert!(vmm
+            .configure_boot_source(kernel_path.clone(), Some(initrd_path.clone()), None)
+            .is_ok());
+        assert!(vmm
+            .configure_boot_source(
+                kernel_path.clone(),
+                Some(initrd_path.clone()),
+                Some(String::from("reboot=k"))
+            )
             .is_ok());
 
         // Test valid configuration after boot (should fail).
         vmm.set_instance_state(InstanceState::Running);
         assert!(vmm
-            .configure_boot_source(kernel_path.clone(), None)
+            .configure_boot_source(kernel_path.clone(), None, None)
             .is_err());
     }
 

vmm/src/vmm_config/boot_source.rs

@@ -10,6 +10,8 @@ use std::fmt::{Display, Formatter, Result};
 pub struct BootSourceConfig {
     /// Path of the kernel image.
     pub kernel_image_path: String,
+    /// Path of the initrd, if there is one.
+    pub initrd_path: Option<String>,
     /// The boot arguments to pass to the kernel. If this field is uninitialized, the default
     /// kernel command line is used: `reboot=k panic=1 pci=off nomodules 8250.nr_uarts=0`.
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -21,6 +23,8 @@ pub struct BootSourceConfig {
 pub enum BootSourceConfigError {
     /// The kernel file cannot be opened.
     InvalidKernelPath,
+    /// The initrd file cannot be opened.
+    InvalidInitrdPath,
     /// The kernel command line is invalid.
     InvalidKernelCommandLine,
     /// The boot source cannot be update post boot.
@@ -36,6 +40,11 @@ impl Display for BootSourceConfigError {
                 "The kernel file cannot be opened due to invalid kernel path or \
                  invalid permissions.",
             ),
+            InvalidInitrdPath => write!(
+                f,
+                "The initrd file cannot be opened due to invalid path or \
+                 invalid permissions.",
+            ),
             InvalidKernelCommandLine => write!(f, "The kernel command line is invalid!"),
             UpdateNotAllowedPostBoot => {
                 write!(f, "The update operation is not allowed after boot.")