tool: implement memory region data prefilling

Signed-off-by: Bill Nguyen <bill.nguyen@unsw.edu.au>

Author: dreamliner787-9

tool/microkit/src/capdl/builder.rs

@@ -19,7 +19,7 @@ use crate::{
     capdl::{
         irq::create_irq_handler_cap,
         memory::{create_vspace, create_vspace_ept, map_page},
-        spec::{capdl_obj_physical_size_bits, ElfContent},
+        spec::{capdl_obj_physical_size_bits, BytesContent, ElfContent, FillContent},
         util::*,
     },
     elf::ElfFile,
@@ -104,7 +104,7 @@ const PD_SCHEDCONTEXT_EXTRA_SIZE_BITS: u64 = PD_SCHEDCONTEXT_EXTRA_SIZE.ilog2()
 pub const SLOT_BITS: u64 = 5;
 pub const SLOT_SIZE: u64 = 1 << SLOT_BITS;
 
-pub type FrameFill = Fill<ElfContent>;
+pub type FrameFill = Fill<FillContent>;
 pub type CapDLNamedObject = NamedObject<FrameFill>;
 
 pub struct ExpectedAllocation {
@@ -230,12 +230,12 @@ impl CapDLSpecContainer {
                             start: dest_offset,
                             end: dest_offset + len_to_cpy,
                         },
-                        content: FillEntryContent::Data(ElfContent {
+                        content: FillEntryContent::Data(FillContent::ElfContent(ElfContent {
                             elf_id,
                             elf_seg_idx: seg_idx,
                             elf_seg_data_range: (section_offset as usize
                                 ..((section_offset + len_to_cpy) as usize)),
-                        }),
+                        })),
                     });
                 }
 
@@ -510,11 +510,39 @@ pub fn build_capdl_spec(
             let paddr = mr
                 .paddr()
                 .map(|base_paddr| Word(base_paddr + (frame_sequence * mr.page_size_bytes())));
+
+            let frame_fill = if let Some(prefill_bytes) = &mr.prefill_bytes {
+                let starting_byte_idx = frame_sequence * mr.page_size_bytes();
+                let remaining_bytes_to_fill = prefill_bytes.len() as u64 - starting_byte_idx;
+                let num_bytes_to_fill = min(mr.page_size_bytes(), remaining_bytes_to_fill);
+
+                let mut frame_bytes = vec![];
+                frame_bytes.extend_from_slice(
+                    &prefill_bytes[starting_byte_idx as usize
+                        ..(starting_byte_idx + num_bytes_to_fill) as usize],
+                );
+
+                FrameFill {
+                    entries: [FillEntry {
+                        range: Range {
+                            start: 0,
+                            end: num_bytes_to_fill,
+                        },
+                        content: FillEntryContent::Data(FillContent::BytesContent(BytesContent {
+                            bytes: frame_bytes,
+                        })),
+                    }]
+                    .to_vec(),
+                }
+            } else {
+                FrameFill {
+                    entries: [].to_vec(),
+                }
+            };
+
             frame_ids.push(capdl_util_make_frame_obj(
                 &mut spec_container,
-                Fill {
-                    entries: [].to_vec(),
-                },
+                frame_fill,
                 &format!("mr_{}_{:09}", mr.name, frame_sequence),
                 paddr,
                 frame_size_bits as u8,

tool/microkit/src/capdl/packaging.rs

@@ -5,7 +5,7 @@
 //
 
 use crate::{
-    capdl::{initialiser::CapDLInitialiser, CapDLSpecContainer},
+    capdl::{initialiser::CapDLInitialiser, spec::FillContent, CapDLSpecContainer},
     elf::ElfFile,
     sel4::{Config, PageSize},
 };
@@ -23,10 +23,19 @@ pub fn pack_spec_into_initial_task(
     let (mut output_spec, embedded_frame_data_list) = spec_container.spec.embed_fill(
         PageSize::Small.fixed_size_bits(sel4_config) as u8,
         |_| embed_frames,
-        |d, buf| {
-            buf.copy_from_slice(
-                &system_elfs[d.elf_id].segments[d.elf_seg_idx].data()[d.elf_seg_data_range.clone()],
-            );
+        |d, buf: &mut [u8]| {
+            match d {
+                FillContent::ElfContent(elf_content) => {
+                    buf.copy_from_slice(
+                        &system_elfs[elf_content.elf_id].segments[elf_content.elf_seg_idx].data()
+                            [elf_content.elf_seg_data_range.clone()],
+                    );
+                }
+                FillContent::BytesContent(bytes_content) => {
+                    buf.copy_from_slice(&bytes_content.bytes);
+                }
+            }
+
             compress_frames
         },
     );

tool/microkit/src/capdl/spec.rs

@@ -21,6 +21,17 @@ pub struct ElfContent {
     pub elf_seg_data_range: Range<usize>,
 }
 
+#[derive(Clone, Serialize)]
+pub struct BytesContent {
+    pub bytes: Vec<u8>,
+}
+
+#[derive(Clone, Serialize)]
+pub enum FillContent {
+    ElfContent(ElfContent),
+    BytesContent(BytesContent),
+}
+
 /// CNode and SchedContext are quirky as they have variable size.
 pub fn capdl_obj_physical_size_bits(obj: &Object<FrameFill>, sel4_config: &Config) -> u64 {
     match obj {

tool/microkit/src/main.rs

@@ -23,7 +23,8 @@ use microkit_tool::sel4::{
 };
 use microkit_tool::symbols::patch_symbols;
 use microkit_tool::util::{
-    human_size_strict, json_str, json_str_as_bool, json_str_as_u64, round_down, round_up,
+    get_full_path, human_size_strict, json_str, json_str_as_bool, json_str_as_u64, round_down,
+    round_up,
 };
 use microkit_tool::{DisjointMemoryRegion, MemoryRegion};
 use std::collections::HashMap;
@@ -40,17 +41,6 @@ const KERNEL_COPY_FILENAME: &str = "sel4.elf";
 // also copy the 32-bit version that was prepared by build_sdk.py for convenience.
 const KERNEL32_COPY_FILENAME: &str = "sel4_32.elf";
 
-fn get_full_path(path: &Path, search_paths: &Vec<PathBuf>) -> Option<PathBuf> {
-    for search_path in search_paths {
-        let full_path = search_path.join(path);
-        if full_path.exists() {
-            return Some(full_path.to_path_buf());
-        }
-    }
-
-    None
-}
-
 fn print_usage() {
     println!("usage: microkit [-h] [-o OUTPUT] [--image-type {{binary,elf,uimage}}] [-r REPORT] --board BOARD --config CONFIG [--capdl-json CAPDL_SPEC] --search-path [SEARCH_PATH ...] system")
 }
@@ -560,7 +550,12 @@ fn main() -> Result<(), String> {
         "Microkit tool has various assumptions about the word size being 64-bits."
     );
 
-    let mut system = match parse(args.system, &xml, &kernel_config) {
+    let mut search_paths = vec![std::env::current_dir().unwrap()];
+    for path in args.search_paths {
+        search_paths.push(PathBuf::from(path));
+    }
+
+    let mut system = match parse(args.system, &xml, &kernel_config, &search_paths) {
         Ok(system) => system,
         Err(err) => {
             eprintln!("{err}");
@@ -617,11 +612,6 @@ fn main() -> Result<(), String> {
         std::process::exit(1);
     });
 
-    let mut search_paths = vec![std::env::current_dir().unwrap()];
-    for path in args.search_paths {
-        search_paths.push(PathBuf::from(path));
-    }
-
     // This list refers to all PD ELFs as well as the Monitor ELF.
     // The monitor is very similar to a PD so it is useful to pass around
     // a list like this.

tool/microkit/src/sdf.rs

@@ -19,10 +19,11 @@
 use crate::sel4::{
     Arch, ArmRiscvIrqTrigger, Config, PageSize, X86IoapicIrqPolarity, X86IoapicIrqTrigger,
 };
-use crate::util::{ranges_overlap, str_to_bool};
+use crate::util::{get_full_path, ranges_overlap, round_up, str_to_bool};
 use crate::MAX_PDS;
 use std::collections::HashSet;
 use std::fmt::Display;
+use std::fs;
 use std::path::{Path, PathBuf};
 
 /// Events that come through entry points (e.g notified or protected) are given an
@@ -125,6 +126,7 @@ pub struct SysMemoryRegion {
     /// due to the user's SDF or created by the tool for setting up the
     /// stack, ELF, etc.
     pub kind: SysMemoryRegionKind,
+    pub prefill_bytes: Option<Vec<u8>>,
 }
 
 impl SysMemoryRegion {
@@ -212,6 +214,7 @@ pub enum SysSetVarKind {
     Paddr { region: String },
     Id { id: u64 },
     X86IoPortAddr { address: u64 },
+    PrefillSize { mr: String },
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -346,6 +349,7 @@ impl SysMap {
         if allow_setvar {
             attrs.push("setvar_vaddr");
             attrs.push("setvar_size");
+            attrs.push("setvar_prefill_size");
         }
         check_attributes(xml_sdf, node, &attrs)?;
 
@@ -646,6 +650,14 @@ impl ProtectionDomain {
                         checked_add_setvar(&mut setvars, setvar, xml_sdf, &child)?;
                     }
 
+                    if let Some(setvar_prefill_size) = child.attribute("setvar_prefill_size") {
+                        let setvar = SysSetVar {
+                            symbol: setvar_prefill_size.to_string(),
+                            kind: SysSetVarKind::PrefillSize { mr: map.mr.clone() },
+                        };
+                        checked_add_setvar(&mut setvars, setvar, xml_sdf, &child)?;
+                    }
+
                     maps.push(map);
                 }
                 "irq" => {
@@ -1204,17 +1216,75 @@ impl VirtualMachine {
 }
 
 impl SysMemoryRegion {
+    fn determine_size(
+        xml_sdf: &XmlSystemDescription,
+        node: &roxmltree::Node,
+        prefill_bytes_maybe: &Option<Vec<u8>>,
+        page_size: u64,
+    ) -> Result<u64, String> {
+        match checked_lookup(xml_sdf, node, "size") {
+            Ok(size_str) => {
+                // Size explicitly specified
+                let size_parsed = sdf_parse_number(size_str, node)?;
+
+                if !size_parsed.is_multiple_of(page_size) {
+                    return Err(value_error(
+                        xml_sdf,
+                        node,
+                        "size is not a multiple of the page size".to_string(),
+                    ));
+                }
+
+                match &prefill_bytes_maybe {
+                    Some(bytes) => {
+                        if bytes.len() > size_parsed as usize {
+                            return Err(value_error(
+                                xml_sdf,
+                                node,
+                                format!(
+                                    "size of prefill file exceeds memory region size: {:x} > {:x}",
+                                    bytes.len(),
+                                    size_parsed
+                                ),
+                            ));
+                        }
+
+                        Ok(size_parsed)
+                    }
+                    None => Ok(size_parsed),
+                }
+            }
+
+            Err(_) => {
+                // No size explicitly specified
+                match &prefill_bytes_maybe {
+                    Some(bytes) => Ok(round_up(bytes.len() as u64, page_size)),
+
+                    None => Err(value_error(
+                        xml_sdf,
+                        node,
+                        "size must be specified if memory region is not prefilled".to_string(),
+                    )),
+                }
+            }
+        }
+    }
+
     fn from_xml(
         config: &Config,
         xml_sdf: &XmlSystemDescription,
         node: &roxmltree::Node,
+        search_paths: &Vec<PathBuf>,
     ) -> Result<SysMemoryRegion, String> {
-        check_attributes(xml_sdf, node, &["name", "size", "page_size", "phys_addr"])?;
+        check_attributes(
+            xml_sdf,
+            node,
+            &["name", "size", "page_size", "phys_addr", "prefill_path"],
+        )?;
 
         let name = checked_lookup(xml_sdf, node, "name")?;
-        let size = sdf_parse_number(checked_lookup(xml_sdf, node, "size")?, node)?;
-        let mut page_size_specified_by_user = false;
 
+        let mut page_size_specified_by_user = false;
         let page_size = if let Some(xml_page_size) = node.attribute("page_size") {
             page_size_specified_by_user = true;
             sdf_parse_number(xml_page_size, node)?
@@ -1231,13 +1301,42 @@ impl SysMemoryRegion {
             ));
         }
 
-        if !size.is_multiple_of(page_size) {
-            return Err(value_error(
-                xml_sdf,
-                node,
-                "size is not a multiple of the page size".to_string(),
-            ));
-        }
+        let prefill_bytes_maybe = node
+            .attribute("prefill_path")
+            .map(|path_str| {
+                get_full_path(&PathBuf::from(path_str), search_paths)
+                    .ok_or_else(|| {
+                        value_error(
+                            xml_sdf,
+                            node,
+                            format!("unable to find prefill file: '{path_str}'"),
+                        )
+                    })
+                    .and_then(|prefill_path| {
+                        fs::read(&prefill_path)
+                            .map_err(|_| {
+                                value_error(
+                                    xml_sdf,
+                                    node,
+                                    format!("failed to read file '{path_str}' at prefill_path"),
+                                )
+                            })
+                            .and_then(|bytes| {
+                                if bytes.is_empty() {
+                                    Err(value_error(
+                                        xml_sdf,
+                                        node,
+                                        format!("prefill file '{path_str}' is empty"),
+                                    ))
+                                } else {
+                                    Ok(bytes)
+                                }
+                            })
+                    })
+            })
+            .transpose()?;
+
+        let size = Self::determine_size(xml_sdf, node, &prefill_bytes_maybe, page_size)?;
 
         let phys_addr = if let Some(xml_phys_addr) = node.attribute("phys_addr") {
             SysMemoryRegionPaddr::Specified(sdf_parse_number(xml_phys_addr, node)?)
@@ -1267,6 +1366,7 @@ impl SysMemoryRegion {
             phys_addr,
             text_pos: Some(xml_sdf.doc.text_pos_at(node.range().start)),
             kind: SysMemoryRegionKind::User,
+            prefill_bytes: prefill_bytes_maybe,
         })
     }
 }
@@ -1605,7 +1705,12 @@ fn pd_flatten(
     Ok(all_pds)
 }
 
-pub fn parse(filename: &str, xml: &str, config: &Config) -> Result<SystemDescription, String> {
+pub fn parse(
+    filename: &str,
+    xml: &str,
+    config: &Config,
+    search_paths: &Vec<PathBuf>,
+) -> Result<SystemDescription, String> {
     let doc = match roxmltree::Document::parse(xml) {
         Ok(doc) => doc,
         Err(err) => return Err(format!("Could not parse '{filename}': {err}")),
@@ -1645,7 +1750,12 @@ pub fn parse(filename: &str, xml: &str, config: &Config) -> Result<SystemDescrip
                 root_pds.push(ProtectionDomain::from_xml(config, &xml_sdf, &child, false)?)
             }
             "channel" => channel_nodes.push(child),
-            "memory_region" => mrs.push(SysMemoryRegion::from_xml(config, &xml_sdf, &child)?),
+            "memory_region" => mrs.push(SysMemoryRegion::from_xml(
+                config,
+                &xml_sdf,
+                &child,
+                search_paths,
+            )?),
             "virtual_machine" => {
                 let pos = xml_sdf.doc.text_pos_at(child.range().start);
                 return Err(format!(