run rust-fmt and clippy fix

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

Author: Kswin01

tool/microkit/src/capdl/builder.rs

@@ -11,8 +11,8 @@ use std::{
 };
 
 use sel4_capdl_initializer_types::{
-    object, CapTableEntry, Fill, FillEntry, FillEntryContent, NamedObject, Object, ObjectId, Spec,
-    Word, DomainSchedEntry,
+    object, CapTableEntry, DomainSchedEntry, Fill, FillEntry, FillEntryContent, NamedObject,
+    Object, ObjectId, Spec, Word,
 };
 
 use crate::{
@@ -410,8 +410,7 @@ pub fn build_capdl_spec(
         for pd in system.protection_domains.iter() {
             if pd.name == monitor_name {
                 return Err(format!(
-                    "Error: User defined PD name clashes with monitor name '{}'",
-                    monitor_name,
+                    "Error: User defined PD name clashes with monitor name '{monitor_name}'",
                 ));
             }
         }
@@ -432,7 +431,8 @@ pub fn build_capdl_spec(
         // Create monitor fault endpoint object + cap
         let mon_fault_ep_obj_id =
             capdl_util_make_endpoint_obj(&mut spec_container, monitor_name_str, true);
-        let mon_fault_ep_cap = capdl_util_make_endpoint_cap(mon_fault_ep_obj_id, true, true, true, 0);
+        let mon_fault_ep_cap =
+            capdl_util_make_endpoint_cap(mon_fault_ep_obj_id, true, true, true, 0);
 
         mon_fault_ep_id_by_dom.push(mon_fault_ep_obj_id);
 
@@ -593,7 +593,13 @@ pub fn build_capdl_spec(
 
         // Step 3-1: Create TCB and VSpace with all ELF loadable frames mapped in.
         let pd_tcb_obj_id = spec_container
-            .add_elf_to_spec(kernel_config, &pd.name, pd.cpu, ElfIndex::SystemElf(pd_global_idx), elf_obj)
+            .add_elf_to_spec(
+                kernel_config,
+                &pd.name,
+                pd.cpu,
+                ElfIndex::SystemElf(pd_global_idx),
+                elf_obj,
+            )
             .unwrap();
         let pd_vspace_obj_id = capdl_util_get_vspace_id_from_tcb_id(&spec_container, pd_tcb_obj_id);
 
@@ -1132,21 +1138,25 @@ pub fn build_capdl_spec(
         };
 
         for sched_entry in system.domain_schedule.as_ref().unwrap().schedule.iter() {
-            domain_schedule.push(DomainSchedEntry{
+            domain_schedule.push(DomainSchedEntry {
                 id: sched_entry.id,
                 time: sched_entry.length * ticks_in_ms,
             });
         }
 
         spec_container.spec.domain_schedule = Some(domain_schedule);
-        spec_container.spec.domain_set_start = system.domain_schedule
-                                                .as_ref()
-                                                .unwrap()
-                                                .domain_start_idx.map(|idx| Word(idx));
-        spec_container.spec.domain_idx_shift = system.domain_schedule
-                                        .as_ref()
-                                        .unwrap()
-                                        .domain_idx_shift.map(|shift| Word(shift));
+        spec_container.spec.domain_set_start = system
+            .domain_schedule
+            .as_ref()
+            .unwrap()
+            .domain_start_idx
+            .map(Word);
+        spec_container.spec.domain_idx_shift = system
+            .domain_schedule
+            .as_ref()
+            .unwrap()
+            .domain_idx_shift
+            .map(Word);
     }
 
     // *********************************

tool/microkit/src/capdl/packaging.rs

@@ -5,10 +5,10 @@
 //
 
 use crate::{
+    capdl::spec::ElfIndex,
     capdl::{initialiser::CapDLInitialiser, CapDLSpecContainer},
     elf::ElfFile,
     sel4::{Config, PageSize},
-    capdl::spec::{ElfIndex},
 };
 
 pub fn pack_spec_into_initial_task(
@@ -29,16 +29,18 @@ pub fn pack_spec_into_initial_task(
             match d.elf_id {
                 ElfIndex::SystemElf(elf_id) => {
                     buf.copy_from_slice(
-                        &system_elfs[elf_id].segments[d.elf_seg_idx].data()[d.elf_seg_data_range.clone()],
+                        &system_elfs[elf_id].segments[d.elf_seg_idx].data()
+                            [d.elf_seg_data_range.clone()],
                     );
                 }
                 ElfIndex::MonitorElf(elf_id) => {
                     buf.copy_from_slice(
-                        &monitor_elfs[elf_id].segments[d.elf_seg_idx].data()[d.elf_seg_data_range.clone()],
+                        &monitor_elfs[elf_id].segments[d.elf_seg_idx].data()
+                            [d.elf_seg_data_range.clone()],
                     );
                 }
             }
-            
+
             compress_frames
         },
     );
@@ -52,7 +54,9 @@ pub fn pack_spec_into_initial_task(
         match build_config {
             "smp-debug" | "debug" | "debug_domains" => {}
             // We don't copy over the object names as there is no debug printing in these configuration to save memory.
-            "release" | "release_domains" | "benchmark" | "smp-release" | "smp-benchmark" => named_obj.name = None,
+            "release" | "release_domains" | "benchmark" | "smp-release" | "smp-benchmark" => {
+                named_obj.name = None
+            }
             _ => panic!("unknown configuration {build_config}"),
         };
     }

tool/microkit/src/main.rs

@@ -687,12 +687,15 @@ fn main() -> Result<(), String> {
         spec_need_refinement = false;
 
         // Patch all the required symbols in the Monitor and PDs according to the Microkit's requirements
-        if let Err(err) = patch_symbols(&kernel_config, &mut system_elfs, &mut monitor_elfs, &system) {
+        if let Err(err) =
+            patch_symbols(&kernel_config, &mut system_elfs, &mut monitor_elfs, &system)
+        {
             eprintln!("ERROR: {err}");
             std::process::exit(1);
         }
 
-        let mut spec_container = build_capdl_spec(&kernel_config, &mut system_elfs, &mut monitor_elfs, &system)?;
+        let mut spec_container =
+            build_capdl_spec(&kernel_config, &mut system_elfs, &mut monitor_elfs, &system)?;
         pack_spec_into_initial_task(
             &kernel_config,
             args.config,

tool/microkit/src/sdf.rs

@@ -21,8 +21,8 @@ use crate::sel4::{
 };
 use crate::util::{ranges_overlap, str_to_bool};
 use crate::MAX_PDS;
-use std::collections::HashSet;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::fmt::Display;
 use std::path::{Path, PathBuf};
 
@@ -608,16 +608,16 @@ impl ProtectionDomain {
             (Some(domain_schedule), Ok(domain_name)) => {
                 let domain_id_get = domain_schedule.domain_ids.get(domain_name);
                 if domain_id_get.is_none() {
-                    return Err(format!("Protection domain {} specifies a domain {} that is not in the domain schedule", name, domain_name));
+                    return Err(format!("Protection domain {name} specifies a domain {domain_name} that is not in the domain schedule"));
                 }
                 domain_id = Some(*domain_id_get.unwrap());
             }
             (Some(_), _) => {
-                return Err(format!("System specifies a domain schedule but protection domain {} does not specify a domain", name))
+                return Err(format!("System specifies a domain schedule but protection domain {name} does not specify a domain"))
             }
             (_, Ok(domain)) => {
                 if config.num_domain_schedules > 1 {
-                    return Err(format!("Protection domain {} specifies a domain {} but system does not specify a domain schedule", name, domain));
+                    return Err(format!("Protection domain {name} specifies a domain {domain} but system does not specify a domain schedule"));
                 } else {
                     return Err("Assigning PDs to domains is only supported built with a config that supports domains".to_string());
                 }
@@ -1029,7 +1029,8 @@ impl ProtectionDomain {
                     checked_add_setvar(&mut setvars, setvar, xml_sdf, &child)?;
                 }
                 "protection_domain" => {
-                    let child_pd = ProtectionDomain::from_xml(config, xml_sdf, &child, true, domain_schedule)?;
+                    let child_pd =
+                        ProtectionDomain::from_xml(config, xml_sdf, &child, true, domain_schedule)?;
 
                     if let Some(setvar_id) = &child_pd.setvar_id {
                         let setvar = SysSetVar {
@@ -1127,9 +1128,7 @@ impl DomainSchedule {
         node: &roxmltree::Node,
     ) -> Result<DomainSchedule, String> {
         if config.num_domains <= 1 {
-            return Err(format!(
-                "Error: Attempting to set a domain schedule when kernel config does not support more than 1 domain",
-            ));
+            return Err("Error: Attempting to set a domain schedule when kernel config does not support more than 1 domain".to_string());
         }
 
         let pos = xml_sdf.doc.text_pos_at(node.range().start);
@@ -1188,34 +1187,28 @@ impl DomainSchedule {
                         return Err(format!(
                             "Error: Duplicate setting of domain start index, already set to '{}'",
                             domain_start_idx.unwrap()
-                        ))
+                        ));
                     }
                     check_attributes(xml_sdf, &child, &["index"])?;
                     let start_index = checked_lookup(xml_sdf, &child, "index")?.parse::<u64>();
                     if start_index.is_err() {
-                        return Err(format!(
-                            "Error: invalid domain start index",
-                        ))
+                        return Err("Error: invalid domain start index".to_string());
                     }
                     domain_start_idx = Some(start_index.unwrap());
-
                 }
                 "domain_idx_shift" => {
                     if domain_idx_shift.is_some() {
                         return Err(format!(
                             "Error: Duplicate setting of domain index shift, already set to '{}'",
                             domain_idx_shift.unwrap()
-                        ))
+                        ));
                     }
                     check_attributes(xml_sdf, &child, &["shift"])?;
                     let index_shift = checked_lookup(xml_sdf, &child, "shift")?.parse::<u64>();
                     if index_shift.is_err() {
-                        return Err(format!(
-                            "Error: invalid domain index shift",
-                        ))
+                        return Err("Error: invalid domain index shift".to_string());
                     }
                     domain_idx_shift = Some(index_shift.unwrap());
-
                 }
                 _ => {
                     return Err(format!(
@@ -1224,7 +1217,6 @@ impl DomainSchedule {
                         loc_string(xml_sdf, pos)
                     ));
                 }
-
             }
         }
 
@@ -1808,9 +1800,13 @@ pub fn parse(filename: &str, xml: &str, config: &Config) -> Result<SystemDescrip
 
         let child_name = child.tag_name().name();
         match child_name {
-            "protection_domain" => {
-                root_pds.push(ProtectionDomain::from_xml(config, &xml_sdf, &child, false, &domain_schedule)?)
-            }
+            "protection_domain" => root_pds.push(ProtectionDomain::from_xml(
+                config,
+                &xml_sdf,
+                &child,
+                false,
+                &domain_schedule,
+            )?),
             "channel" => channel_nodes.push(child),
             "memory_region" => mrs.push(SysMemoryRegion::from_xml(config, &xml_sdf, &child)?),
             "virtual_machine" => {
@@ -1819,15 +1815,19 @@ pub fn parse(filename: &str, xml: &str, config: &Config) -> Result<SystemDescrip
                     "Error: virtual machine must be a child of a protection domain: {}",
                     loc_string(&xml_sdf, pos)
                 ));
-            },
+            }
             "domain_schedule" => {
                 if config.num_domain_schedules > 1 {
                     if let Some(domain_schedule_node) = system
                         .children()
                         .filter(|&child| child.is_element())
                         .find(|&child| child.tag_name().name() == "domain_schedule")
                     {
-                        domain_schedule = Some(DomainSchedule::from_xml(&xml_sdf, &config, &domain_schedule_node)?);
+                        domain_schedule = Some(DomainSchedule::from_xml(
+                            &xml_sdf,
+                            config,
+                            &domain_schedule_node,
+                        )?);
                     }
                 }
             }
@@ -2200,18 +2200,16 @@ pub fn parse(filename: &str, xml: &str, config: &Config) -> Result<SystemDescrip
                 "Error: Domain index of '{}' is out of bounds for domain schedule length '{}'. Note that the schedule is 0 indexed.",
                 dom_sched.domain_start_idx.unwrap(),
                 schedule_len
-            ))
+            ));
         }
 
         // Make sure our schedule length, including the shift, is in bounds of
         // the kernel configured max number of schedules.
         if schedule_len + dom_shift >= config.num_domain_schedules {
             return Err(format!(
                 "Error: Schedule length '{}' with shift of '{}' exceeds max schedule length '{}'.",
-                schedule_len,
-                dom_shift,
-                config.num_domain_schedules,
-            ))
+                schedule_len, dom_shift, config.num_domain_schedules,
+            ));
         }
     }
 

tool/microkit/src/symbols.rs

@@ -8,7 +8,7 @@ use std::{cmp::min, collections::HashMap};
 
 use crate::{
     elf::ElfFile,
-    sdf::{self, SysMemoryRegion, SystemDescription, ProtectionDomain},
+    sdf::{self, ProtectionDomain, SysMemoryRegion, SystemDescription},
     sel4::{Arch, Config},
     util::{monitor_serialise_names, monitor_serialise_u64_vec},
     MAX_PDS, MAX_VMS, PD_MAX_NAME_LENGTH, VM_MAX_NAME_LENGTH,
@@ -35,15 +35,9 @@ pub fn patch_symbols(
             .filter(|pd| pd.domain_id.unwrap_or(0) == mon_idx as u8)
             .collect();
 
-        let pd_names: Vec<String> = filtered_pds
-            .iter()
-            .map(|pd| pd.name.clone())
-            .collect();
+        let pd_names: Vec<String> = filtered_pds.iter().map(|pd| pd.name.clone()).collect();
         monitor_elf
-            .write_symbol(
-                "pd_names_len",
-                &filtered_pds.len().to_le_bytes(),
-            )
+            .write_symbol("pd_names_len", &filtered_pds.len().to_le_bytes())
             .unwrap();
         monitor_elf
             .write_symbol(
@@ -90,10 +84,7 @@ pub fn patch_symbols(
             .unwrap();
 
         monitor_elf
-            .write_symbol(
-                "monitor_name",
-                format!("monitor_{}", mon_idx).as_bytes()
-            )
+            .write_symbol("monitor_name", format!("monitor_{mon_idx}").as_bytes())
             .unwrap();
     }