switch to nested hashmaps

Signed-off-by: Krishnan Winter <krishnan.winter@unsw.edu.au>

Author: Kswin01

tool/microkit/src/capdl/builder.rs

@@ -24,7 +24,7 @@ use crate::{
     },
     elf::ElfFile,
     sdf::{
-        CapMapType, CpuCore, SysMap, SysMapPerms, SystemDescription, BUDGET_DEFAULT, CAP_MAP_TYPES,
+        CapMapType, CpuCore, SysMap, SysMapPerms, SystemDescription, BUDGET_DEFAULT,
         MONITOR_PD_NAME, MONITOR_PRIORITY,
     },
     sel4::{Arch, Config, PageSize},
@@ -548,15 +548,15 @@ pub fn build_capdl_spec(
     };
 
     // Mapping between pd name and id for faster lookups
-    let mut pd_name_to_id: HashMap<String, usize> = HashMap::new();
+    let mut pd_name_to_id: HashMap<&String, usize> = HashMap::new();
 
     // Keep tabs on each PD's CSpace, Notification and Endpoint objects so we can create channels between them at a later step.
     let mut pd_id_to_cspace_id: HashMap<usize, ObjectId> = HashMap::new();
     let mut pd_id_to_ntfn_id: HashMap<usize, ObjectId> = HashMap::new();
     let mut pd_id_to_ep_id: HashMap<usize, ObjectId> = HashMap::new();
 
     // Keep tabs on caps such as TCB and SC so that we can create additional mappings for the cap into other PD's cspaces.
-    let mut pd_shadow_cspace: HashMap<usize, Vec<Option<Cap>>> = HashMap::new();
+    let mut pd_shadow_cspace: HashMap<usize, HashMap<CapMapType, Cap>> = HashMap::new();
 
     // Keep track of the global count of vCPU objects so we can bind them to the monitor for setting TCB name in debug config.
     // Only used on ARM and RISC-V as on x86-64 VMs share the same TCB as PD's which will have their TCB name set separately.
@@ -568,8 +568,9 @@ pub fn build_capdl_spec(
     for (pd_global_idx, pd) in system.protection_domains.iter().enumerate() {
         let elf_obj = &elfs[pd_global_idx];
 
-        pd_name_to_id.insert(pd.name.clone(), pd_global_idx);
+        pd_name_to_id.insert(&pd.name, pd_global_idx);
 
+        let mut pd_shadow_cspace_inner: HashMap<CapMapType, Cap> = HashMap::new();
         let mut caps_to_bind_to_tcb: Vec<CapTableEntry> = Vec::new();
         let mut caps_to_insert_to_pd_cspace: Vec<CapTableEntry> = Vec::new();
 
@@ -582,12 +583,8 @@ pub fn build_capdl_spec(
         let pd_tcb_obj = capdl_util_make_tcb_cap(pd_tcb_obj_id);
         let pd_vspace_obj = capdl_util_make_page_table_cap(pd_vspace_obj_id);
 
-        pd_shadow_cspace
-            .entry(pd_global_idx)
-            .or_insert_with(|| vec![None; CAP_MAP_TYPES])[CapMapType::Tcb as usize] =
-            Some(pd_tcb_obj.clone());
-        pd_shadow_cspace.get_mut(&pd_global_idx).unwrap()[CapMapType::Vspace as usize] =
-            Some(pd_vspace_obj.clone());
+        pd_shadow_cspace_inner.insert(CapMapType::Tcb, pd_tcb_obj.clone());
+        pd_shadow_cspace_inner.insert(CapMapType::Vspace, pd_vspace_obj.clone());
 
         // In the benchmark configuration, we allow PDs to access their own TCB.
         // This is necessary for accessing kernel's benchmark API.
@@ -677,8 +674,7 @@ pub fn build_capdl_spec(
         );
         let pd_sc_cap = capdl_util_make_sc_cap(pd_sc_obj_id);
 
-        pd_shadow_cspace.get_mut(&pd_global_idx).unwrap()[CapMapType::Sc as usize] =
-            Some(pd_sc_cap.clone());
+        pd_shadow_cspace_inner.insert(CapMapType::Sc, pd_sc_cap.clone());
 
         caps_to_bind_to_tcb.push(capdl_util_make_cte(
             TcbBoundSlot::SchedContext as u32,
@@ -996,8 +992,7 @@ pub fn build_capdl_spec(
         );
         let pd_guard_size = kernel_config.cap_address_bits - PD_CAP_BITS as u64;
         let pd_cnode_cap = capdl_util_make_cnode_cap(pd_cnode_obj_id, 0, pd_guard_size as u8);
-        pd_shadow_cspace.get_mut(&pd_global_idx).unwrap()[CapMapType::Cnode as usize] =
-            Some(pd_cnode_cap.clone());
+        pd_shadow_cspace_inner.insert(CapMapType::Cnode, pd_cnode_cap.clone());
         caps_to_bind_to_tcb.push(capdl_util_make_cte(
             TcbBoundSlot::CSpace as u32,
             pd_cnode_cap,
@@ -1048,6 +1043,7 @@ pub fn build_capdl_spec(
                 capdl_util_make_ntfn_cap(pd_ntfn_obj_id, true, true, 0),
             );
         }
+        pd_shadow_cspace.insert(pd_global_idx, pd_shadow_cspace_inner);
     }
 
     // *********************************
@@ -1119,22 +1115,24 @@ pub fn build_capdl_spec(
 
     for (pd_dest_idx, pd) in system.protection_domains.iter().enumerate() {
         let pd_dest_cspace_id = pd_id_to_cspace_id[&pd_dest_idx];
-
         for cap_map in pd.cap_maps.iter() {
             let pd_src_idx = pd_name_to_id.get(&cap_map.pd_name).ok_or(format!(
                 "PD: '{}', does not exist when trying to map extra TCB cap into PD: '{}'",
                 cap_map.pd_name, pd.name
             ))?;
 
-            let pd_obj = pd_shadow_cspace[pd_src_idx][cap_map.cap_type as usize]
-                .as_ref()
-                .unwrap();
+            let pd_shadow_cspace_inner = pd_shadow_cspace.get(pd_src_idx).unwrap();
+
+            let pd_obj = pd_shadow_cspace_inner
+                .get(&cap_map.cap_type)
+                .unwrap()
+                .clone();
             // Map this into the destination pd's cspace and the specified slot.
             capdl_util_insert_cap_into_cspace(
                 &mut spec_container,
                 pd_dest_cspace_id,
                 (PD_BASE_USER_CAPS + cap_map.dest_cspace_slot) as u32,
-                pd_obj.clone(),
+                pd_obj,
             );
         }
     }

tool/microkit/src/sdf.rs

@@ -281,10 +281,7 @@ pub struct ProtectionDomain {
     text_pos: Option<roxmltree::TextPos>,
 }
 
-/// Update CAP_MAP_TYPES whenever making changes to the CapMapType enum
-pub const CAP_MAP_TYPES: usize = 4;
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
 pub enum CapMapType {
     Tcb = 0,
     Sc,