wip: Make kernel changes build

Author: berkus

Cargo.lock

@@ -29,41 +29,22 @@ qemu = [
 
 [dependencies]
 aarch64-cpu = { workspace = true }
-# bit_field = { workspace = true }
-# bitflags = { workspace = true }
-# cfg-if = { workspace = true }
+cfg-if = { workspace = true }
 libaddress = { workspace = true }
 libboot = { workspace = true }
-# libconsole = { workspace = true }
 libcpu = { workspace = true }
 libexception = { workspace = true }
-# libkernel-state = { workspace = true }
 liblog = { workspace = true }
 liblocking = { workspace = true }
 libmachine = { workspace = true }
 libmapping = { workspace = true }
-# libplatform = { workspace = true }
 libprint = { workspace = true }
 libqemu = { workspace = true, optional = true }
 libobject = { workspace = true }
 libsyscall = { workspace = true }
-# libtime = { workspace = true }
 snafu = { workspace = true }
-# static_assertions = { workspace = true }
-# tock-registers = { workspace = true }
-# usize_conversions = { workspace = true }
-# ux = { workspace = true }
-#enum_dispatch = "0.3"
-#tap = "1.0" -- check no_std?
 shrinkwraprs = { version = "0.3", default-features = false }
-# dtb = "0.2" # Dec 2019 by Simon Prikhodko
-# Alternatives to dtb to look at:
-#device_tree = "1.1.0" # Jun 2016 by Marc Brinkmann
-#fdt-rs = "0.4.2" # Aug 2020 by Sean Wilson
-# fdt-rs latest 0.4.3 Jul 2021 by Sean Wilson -- interface is more basic than in dtb
-# @todo Added from_raw_pointer() finally
 fdt-rs = { version = "=0.4.4", default-features = false }
-# num = { version = "0.4", default-features = false }
 
 [dev-dependencies]
 libexception = { workspace = true, features = ["test_build"] }

kernel/init_thread/Cargo.toml

@@ -5,12 +5,13 @@
 //! Insert sections that are either "free" or "used", disparate used sections can not overlap,
 //! overlapping free sections are merged (unless they have different MemAttributes).
 //!
+#[cfg(qemu)]
+use libqemu::semi_println;
 use {
     core::{cell::LazyCell, fmt},
     libaddress::PhysAddr,
     liblocking::IRQSafeNullLock,
     libmapping::{AccessPermissions, AttributeFields, MemAttributes},
-    libqemu::semi_println,
     snafu::Snafu,
 };
 
@@ -318,6 +319,7 @@ impl BootInfo {
         if region.is_empty() {
             return Ok(());
         }
+        #[cfg(qemu)]
         semi_println!("BOOT_INFO.insert_free_region: {}", region);
         self.insert_raw(region)?;
         self.merge_free_regions();
@@ -347,11 +349,13 @@ impl BootInfo {
         if region.is_empty() {
             return Ok(());
         }
+        #[cfg(qemu)]
         semi_println!("BOOT_INFO.insert_used_region: {}", region);
 
         // Check for overlap with existing used regions.
         for slot in self.regions.iter() {
             if slot.is_used() && slot.intersects(&region) {
+                #[cfg(qemu)]
                 semi_println!(
                     "BOOT_INFO.insert_used_region: ERROR overlaps existing used region: {}",
                     slot
@@ -385,6 +389,7 @@ impl BootInfo {
             return Ok(());
         }
 
+        #[cfg(qemu)]
         semi_println!(
             "BOOT_INFO.insert_overlay_region: [{} - {}) {}",
             overlay_start,
@@ -642,6 +647,7 @@ impl BootInfo {
         // Add the remaining regions in largest to smallest order.
         self.insert_raw(rem_large)?;
         if self.insert_raw(rem_small).is_err() {
+            #[cfg(qemu)]
             semi_println!(
                 "BootInfo::alloc_region(): wasted {} bytes due to alignment, try to increase NUM_MEM_REGIONS",
                 rem_small.size()
@@ -685,9 +691,11 @@ impl BootInfo {
 
     /// Print all non-empty regions for debug purposes.
     pub fn dump(&self) {
+        #[cfg(qemu)]
         semi_println!("BOOT_INFO: {} region(s):", self.count());
         for region in self.regions.iter() {
             if !region.is_empty() {
+                #[cfg(qemu)]
                 semi_println!("  {}", region);
             }
         }

kernel/init_thread/src/boot_info.rs

@@ -431,12 +431,14 @@ pub struct FdtDumper<'a> {
 impl<'i, 'dt> FdtDumper<'_> {
     fn push_indent(&mut self) {
         for _ in 0..self.indent {
+            #[cfg(qemu)]
             libqemu::semi_print!("  ");
         }
     }
 
     fn dump_node_name(&mut self, name: &str) {
         self.push_indent();
+        #[cfg(qemu)]
         libqemu::semi_println!("{name} {{");
     }
 
@@ -454,12 +456,15 @@ impl<'i, 'dt> FdtDumper<'_> {
     fn dump_property(&mut self, prop: DevTreeIndexProp) -> DevTreeResult<()> {
         self.push_indent();
 
+        #[cfg(qemu)]
         libqemu::semi_print!("{}", prop.name()?);
 
         if prop.length() == 0 {
+            #[cfg(qemu)]
             libqemu::semi_println!(";");
             return Ok(());
         }
+        #[cfg(qemu)]
         libqemu::semi_print!(" = ");
 
         // Unsafe Ok - we're reinterpreting the data as expected.
@@ -468,31 +473,39 @@ impl<'i, 'dt> FdtDumper<'_> {
             if are_printable_strings(prop.iter_str()) {
                 let mut iter = prop.iter_str();
                 while let Some(s) = iter.next()? {
+                    #[cfg(qemu)]
                     libqemu::semi_print!("\"{}\", ", s);
                 }
                 // let _ = self.dump.pop();
                 // let _ = self.dump.pop();
             } else if prop.propbuf().len() % size_of::<u32>() == 0 {
+                #[cfg(qemu)]
                 libqemu::semi_print!("<");
                 for val in prop.propbuf().chunks_exact(size_of::<u32>()) {
                     // We use read_unaligned
                     #[allow(clippy::cast_ptr_alignment)]
                     let v = read_unaligned::<u32>(val.as_ptr() as *const u32);
                     let v = u32::from_be(v);
+                    #[cfg(qemu)]
                     libqemu::semi_print!("{:#010x} ", v);
                 }
                 // let _ = self.dump.pop(); // Pop off extra space
+                #[cfg(qemu)]
                 libqemu::semi_print!(">");
             } else {
+                #[cfg(qemu)]
                 libqemu::semi_print!("[");
                 for val in prop.propbuf() {
+                    #[cfg(qemu)]
                     libqemu::semi_print!("{:02x} ", val);
                 }
                 // let _ = self.dump.pop(); // Pop off extra space
+                #[cfg(qemu)]
                 libqemu::semi_print!("]");
             }
         }
 
+        #[cfg(qemu)]
         libqemu::semi_println!(";");
         Ok(())
     }
@@ -508,6 +521,7 @@ impl<'i, 'dt> FdtDumper<'_> {
         }
         self.indent -= 1;
         self.push_indent();
+        #[cfg(qemu)]
         libqemu::semi_println!("}};");
         Ok(())
     }
@@ -518,17 +532,28 @@ impl<'i, 'dt> FdtDumper<'_> {
 
     pub fn dump_metadata(&mut self) {
         let fdt = self.index.fdt();
+        #[cfg(qemu)]
         libqemu::semi_println!("// magic:\t\t{:#x}", fdt.magic());
         let s = fdt.totalsize();
+        #[cfg(qemu)]
         libqemu::semi_println!("// totalsize:\t\t{:#x} ({})", s, s);
+        #[cfg(qemu)]
         libqemu::semi_println!("// off_dt_struct:\t{:#x}", fdt.off_dt_struct());
+        #[cfg(qemu)]
         libqemu::semi_println!("// off_dt_strings:\t{:#x}", fdt.off_dt_strings());
+        #[cfg(qemu)]
         libqemu::semi_println!("// off_mem_rsvmap:\t{:#x}", fdt.off_mem_rsvmap());
+        #[cfg(qemu)]
         libqemu::semi_println!("// version:\t\t{:}", fdt.version());
+        #[cfg(qemu)]
         libqemu::semi_println!("// last_comp_version:\t{:}", fdt.last_comp_version());
+        #[cfg(qemu)]
         libqemu::semi_println!("// boot_cpuid_phys:\t{:#x}", fdt.boot_cpuid_phys());
+        #[cfg(qemu)]
         libqemu::semi_println!("// size_dt_strings:\t{:#x}", fdt.size_dt_strings());
+        #[cfg(qemu)]
         libqemu::semi_println!("// size_dt_struct:\t{:#x}", fdt.size_dt_struct());
+        #[cfg(qemu)]
         libqemu::semi_println!();
     }
 }

kernel/init_thread/src/device_tree.rs

@@ -1,13 +1,14 @@
 // init_thread/src/loader.rs
 
+#[cfg(qemu)]
+use libqemu::semi_println;
 use {
     crate::{
         embed::KERNEL,
         memory::{Alloc, BootAllocator, KernelLayout, MemoryPermissions},
     },
     core::ptr,
     libaddress::{PhysAddr, VirtAddr},
-    libqemu::semi_println,
 };
 
 /// Metadata for a kernel section
@@ -95,6 +96,7 @@ pub fn load_kernel(allocator: &mut BootAllocator) -> Result<KernelLayout, &'stat
         )
         .ok_or("Failed to allocate memory for kernel")?;
 
+    #[cfg(qemu)]
     semi_println!(
         "Nucleus is {total_pages} * 4K pages @ {:#016X}",
         phys_base.as_u64()
@@ -149,6 +151,7 @@ fn load_section(section: &LoadableSection, kernel_phys_base: PhysAddr) -> Result
     let offset = section.meta.offset_from_base(KERNEL.virt_base);
     let dest_phys = PhysAddr::new(kernel_phys_base.as_u64() + offset);
 
+    #[cfg(qemu)]
     semi_println!(
         "> section {}, copy {} bytes of {} bytes total to {:#016X}",
         section.meta.name,
@@ -184,6 +187,7 @@ fn zero_bss(bss: &SectionMeta, kernel_phys_base: PhysAddr) -> Result<(), &'stati
     let offset = bss.offset_from_base(KERNEL.virt_base);
     let dest_phys = PhysAddr::new(kernel_phys_base.as_u64() + offset);
 
+    #[cfg(qemu)]
     semi_println!(
         "> section {}, zero {} bytes at {:#016X}",
         bss.name,