Formatted code

Signed-off-by: Ioan-Cristian CÎRSTEA <ioan.cirstea@oxidos.io>

Author: IoanCristianCirstea

arch/cortex-m/src/mpu.rs

@@ -7,14 +7,10 @@
 //! Implementation of the memory protection unit for the Cortex-M0+, Cortex-M3,
 //! Cortex-M4, and Cortex-M7.
 
-use kernel::platform::mmu::{
-    Asid,
-    MPU as MpuTrait,
-    MpuMmuCommon,
-};
 use kernel::memory_management::pages::Page4KiB;
 use kernel::memory_management::permissions::Permissions;
 use kernel::memory_management::regions::PhysicalProtectedAllocatedRegion;
+use kernel::platform::mmu::{Asid, MpuMmuCommon, MPU as MpuTrait};
 use kernel::utilities::math;
 use kernel::utilities::registers::interfaces::Writeable;
 use kernel::utilities::registers::{register_bitfields, FieldValue, ReadOnly, ReadWrite};
@@ -142,9 +138,7 @@ impl<const NUM_REGIONS: usize, const MIN_REGION_SIZE: usize> MPU<NUM_REGIONS, MI
     const RAM_REGION_INDEX: usize = 1;
 
     pub unsafe fn new(registers: StaticRef<MpuRegisters>) -> Self {
-        let mpu = Self {
-            registers,
-        };
+        let mpu = Self { registers };
 
         // Mark all regions as empty.
         for region_index in 0..NUM_REGIONS {
@@ -171,14 +165,13 @@ impl<const NUM_REGIONS: usize, const MIN_REGION_SIZE: usize> MPU<NUM_REGIONS, MI
         index: usize,
         protected_region: &PhysicalProtectedAllocatedRegion<Page4KiB>,
     ) {
-        let starting_pointer = protected_region.get_starting_pointer()
-            .infallible_cast();
+        let starting_pointer = protected_region.get_starting_pointer().infallible_cast();
         let raw_starting_pointer = unsafe { starting_pointer.to_raw() };
         let protected_length_bytes = protected_region.get_protected_length_bytes();
         let permissions = protected_region.get_permissions();
 
         if let Some(cortex_m_region) = CortexMRegion::new(
-            raw_starting_pointer, 
+            raw_starting_pointer,
             protected_length_bytes.get(),
             index,
             None,

arch/cortex-m/src/syscall.rs

@@ -14,8 +14,7 @@ use core::ops::Range;
 use core::ptr::{self, addr_of, addr_of_mut, read_volatile, write_volatile};
 use kernel::errorcode::ErrorCode;
 use kernel::memory_management::pointers::{
-    ImmutableKernelVirtualPointer,
-    ImmutableUserVirtualPointer,
+    ImmutableKernelVirtualPointer, ImmutableUserVirtualPointer,
 };
 
 use crate::CortexMVariant;
@@ -274,7 +273,10 @@ impl<A: CortexMVariant> kernel::syscall::UserspaceKernelBoundary for SysCall<A>
         user_accessible_memory_start: &ImmutableUserVirtualPointer<u8>,
         user_app_brk: &ImmutableUserVirtualPointer<u8>,
         state: &mut CortexMStoredState,
-    ) -> (kernel::syscall::ContextSwitchReason, Option<ImmutableUserVirtualPointer<u8>>) {
+    ) -> (
+        kernel::syscall::ContextSwitchReason,
+        Option<ImmutableUserVirtualPointer<u8>>,
+    ) {
         let user_accessible_memory_start_address = user_accessible_memory_start.get_address();
         let user_app_brk_address = user_app_brk.get_address();
 

arch/riscv/src/pmp.rs

@@ -3,8 +3,8 @@
 // Copyright Tock Contributors 2022.
 
 use core::cell::Cell;
-use core::num::NonZeroUsize;
 use core::fmt;
+use core::num::NonZeroUsize;
 
 use kernel::memory_management::pages::Page4KiB;
 use kernel::memory_management::permissions::Permissions;
@@ -838,11 +838,8 @@ impl<const MAX_REGIONS: usize, P: TORUserPMP<MAX_REGIONS> + 'static> PMPUserMPU<
         #[allow(clippy::let_unit_value)]
         let _: () = P::CONST_ASSERT_CHECK;
 
-        const DEFAULT_REGION: (TORUserPMPCFG, *const u8, *const u8) = (
-            TORUserPMPCFG::OFF,
-            core::ptr::null(),
-            core::ptr::null(),
-        );
+        const DEFAULT_REGION: (TORUserPMPCFG, *const u8, *const u8) =
+            (TORUserPMPCFG::OFF, core::ptr::null(), core::ptr::null());
 
         PMPUserMPU {
             regions: MapCell::new([DEFAULT_REGION; MAX_REGIONS]),
@@ -876,8 +873,8 @@ impl<const MAX_REGIONS: usize, P: TORUserPMP<MAX_REGIONS> + 'static> PMPUserMPU<
     }
 }
 
-impl<const MAX_REGIONS: usize, P: TORUserPMP<MAX_REGIONS> + 'static> kernel::platform::mmu::MpuMmuCommon
-    for PMPUserMPU<MAX_REGIONS, P>
+impl<const MAX_REGIONS: usize, P: TORUserPMP<MAX_REGIONS> + 'static>
+    kernel::platform::mmu::MpuMmuCommon for PMPUserMPU<MAX_REGIONS, P>
 {
     type Granule = Page4KiB;
 

arch/riscv/src/syscall.rs

@@ -11,8 +11,7 @@ use core::ops::Range;
 use crate::csr::mcause;
 use kernel::errorcode::ErrorCode;
 use kernel::memory_management::pointers::{
-    ImmutableKernelVirtualPointer,
-    ImmutableUserVirtualPointer,
+    ImmutableKernelVirtualPointer, ImmutableUserVirtualPointer,
 };
 use kernel::syscall::ContextSwitchReason;
 

arch/x86/src/boundary/boundary_impl.rs

@@ -7,8 +7,7 @@ use core::fmt::Write;
 use crate::registers::bits32::eflags::{EFlags, EFLAGS};
 
 use kernel::memory_management::pointers::{
-    ImmutableKernelVirtualPointer,
-    ImmutableUserVirtualPointer,
+    ImmutableKernelVirtualPointer, ImmutableUserVirtualPointer,
 };
 use kernel::process::FunctionCall;
 use kernel::syscall::{ContextSwitchReason, Syscall, SyscallReturn, UserspaceKernelBoundary};
@@ -56,7 +55,9 @@ impl UserspaceKernelBoundary for Boundary {
         user_app_brk: &ImmutableUserVirtualPointer<u8>,
         state: &mut Self::StoredState,
     ) -> Result<(), ()> {
-        if user_app_brk.get_address().get() - user_accessible_memory_start.get_address().get() < Self::MIN_APP_BRK {
+        if user_app_brk.get_address().get() - user_accessible_memory_start.get_address().get()
+            < Self::MIN_APP_BRK
+        {
             return Err(());
         }
 

arch/x86/src/mmu.rs

@@ -4,22 +4,15 @@
 
 // todo: this module needs some polish
 
-use crate::registers::bits32::paging::{
-    PAddr, PDEntry, PTEntry, PD, PDFLAGS, PT, PTFLAGS,
-};
+use crate::registers::bits32::paging::{PAddr, PDEntry, PTEntry, PD, PDFLAGS, PT, PTFLAGS};
 use crate::registers::controlregs::{self, CR0, CR4};
 use crate::registers::tlb;
 use core::fmt;
 use kernel::memory_management::pages::Page4KiB;
 use kernel::memory_management::permissions::Permissions;
-use kernel::memory_management::pointers::{
-    MutableUserVirtualPointer,
-    MutablePhysicalPointer,
-};
+use kernel::memory_management::pointers::{MutablePhysicalPointer, MutableUserVirtualPointer};
 use kernel::memory_management::regions::UserMappedProtectedAllocatedRegion;
-use kernel::platform::mmu::{
-    Asid,
-};
+use kernel::platform::mmu::Asid;
 use kernel::utilities::cells::OptionalCell;
 use tock_registers::LocalRegisterCopy;
 
@@ -380,7 +373,8 @@ impl kernel::platform::mmu::MMU for MMU<'_> {
         }
 
         self.add_user_region(mapped_region);
-        self.cached_user_prog_region.set(CachedRegion::new(mapped_region));
+        self.cached_user_prog_region
+            .set(CachedRegion::new(mapped_region));
 
         unsafe { tlb::flush_all() };
     }
@@ -394,7 +388,8 @@ impl kernel::platform::mmu::MMU for MMU<'_> {
         }
 
         self.add_user_region(mapped_region);
-        self.cached_user_ram_region.set(CachedRegion::new(mapped_region));
+        self.cached_user_ram_region
+            .set(CachedRegion::new(mapped_region));
 
         unsafe { tlb::flush_all() };
     }

boards/qemu_i486_q35/src/linker.rs

@@ -56,7 +56,10 @@ extern "C" {
 ///
 /// 1. `start` and `end` are not page-aligned.
 /// 2. address(`start`) >= address(`end`)
-unsafe fn get_mutable_physical_slice(start: *mut u8, end: *mut u8) -> MutablePhysicalSlice<'static, Page4KiB> {
+unsafe fn get_mutable_physical_slice(
+    start: *mut u8,
+    end: *mut u8,
+) -> MutablePhysicalSlice<'static, Page4KiB> {
     // PANIC: the function's precondition ensures that `start` is page-aligned.
     let start = MutablePointer::new(start.cast()).unwrap();
     // PANIC: the function's precondition ensures that `end` is page-aligned.
@@ -96,7 +99,7 @@ pub(crate) unsafe fn get_kernel_prog_region() -> MutablePhysicalSlice<'static, P
     let kernel_prog_start = core::ptr::addr_of_mut!(_sprog);
     let kernel_prog_end = core::ptr::addr_of_mut!(_eprog);
 
-    // SAFETY: 
+    // SAFETY:
     //
     // 1. the function's precondition ensures that `get_kernel_prog_region()` is called only once
     //    and as such `get_mutable_physical_slice()` too.
@@ -114,7 +117,7 @@ pub(crate) unsafe fn get_kernel_ram_region() -> MutablePhysicalSlice<'static, Pa
     let kernel_ram_start = core::ptr::addr_of_mut!(_sram);
     let kernel_ram_end = core::ptr::addr_of_mut!(_eram);
 
-    // SAFETY: 
+    // SAFETY:
     //
     // 1. the function's precondition ensures that `get_kernel_ram_region()` is called only once
     //    and as such `get_mutable_physical_slice()` too.
@@ -128,7 +131,7 @@ pub(crate) unsafe fn get_kernel_peripheral_region() -> MutablePhysicalSlice<'sta
     let kernel_peripheral_start = core::ptr::addr_of_mut!(_speripheral);
     let kernel_peripheral_end = core::ptr::addr_of_mut!(_eperipheral);
 
-    // SAFETY: 
+    // SAFETY:
     //
     // 1. the function's precondition ensures that `get_kernel_peripheral_region()` is called only
     //    once and as such `get_mutable_physical_slice()` too.

boards/qemu_i486_q35/src/main.rs

@@ -27,9 +27,9 @@ use kernel::platform::{KernelResources, SyscallDriverLookup};
 use kernel::process::Process;
 use kernel::scheduler::cooperative::CooperativeSched;
 use kernel::syscall::SyscallDriver;
-use kernel::{create_capability, static_init, Kernel};
 use kernel::utilities::cells::OptionalCell;
 use kernel::utilities::slices::NonEmptyMutableSlice;
+use kernel::{create_capability, static_init, Kernel};
 
 use x86::registers::bits32::paging::{PDEntry, PTEntry, PD, PT};
 use x86::registers::irq;
@@ -52,7 +52,8 @@ const NUM_PROCS: usize = 4;
 
 // Actual memory for holding the active process structures. Need an empty list
 // at least.
-static mut PROCESSES: [OptionalCell<&'static dyn Process>; NUM_PROCS] = [const { OptionalCell::empty() }; NUM_PROCS];
+static mut PROCESSES: [OptionalCell<&'static dyn Process>; NUM_PROCS] =
+    [const { OptionalCell::empty() }; NUM_PROCS];
 
 // Reference to the chip for panic dumps
 static mut CHIP: Option<&'static Pc> = None;
@@ -174,12 +175,14 @@ unsafe extern "cdecl" fn main() {
     use kernel::memory_management::pages::Page4KiB;
     let apps_ram = core::slice::from_raw_parts_mut(
         (core::ptr::addr_of_mut!(linker::_sappmem) as usize) as *mut Page4KiB,
-        core::ptr::addr_of!(linker::_eappmem) as usize - core::ptr::addr_of!(linker::_sappmem) as usize,
+        core::ptr::addr_of!(linker::_eappmem) as usize
+            - core::ptr::addr_of!(linker::_sappmem) as usize,
     );
 
     // PANIC: the linker script ensures that the RAM region is not empty.
     let non_empty_ram_memory = NonEmptyMutableSlice::new(apps_ram).unwrap();
-    let physical_ram_memory = kernel::memory_management::slices::MutablePhysicalSlice::new(non_empty_ram_memory);
+    let physical_ram_memory =
+        kernel::memory_management::slices::MutablePhysicalSlice::new(non_empty_ram_memory);
 
     type RamAllocator = kernel::memory_management::allocators::StaticAllocator<'static, Page4KiB>;
     let ram_allocator = RamAllocator::new(physical_ram_memory);
@@ -189,15 +192,39 @@ unsafe extern "cdecl" fn main() {
     let physical_kernel_ram_memory = linker::get_kernel_ram_region();
     let physical_kernel_peripheral_memory = linker::get_kernel_peripheral_region();
 
-    let allocated_kernel_rom_memory = kernel::memory_management::regions::PhysicalAllocatedRegion::new(physical_kernel_rom_memory);
-    let allocated_kernel_prog_memory = kernel::memory_management::regions::PhysicalAllocatedRegion::new(physical_kernel_prog_memory);
-    let allocated_kernel_ram_memory = kernel::memory_management::regions::PhysicalAllocatedRegion::new(physical_kernel_ram_memory);
-    let allocated_kernel_peripheral_memory = kernel::memory_management::regions::PhysicalAllocatedRegion::new(physical_kernel_peripheral_memory);
-
-    let mapped_kernel_rom_memory = kernel::memory_management::regions::MappedAllocatedRegion::new_flat(allocated_kernel_rom_memory);
-    let mapped_kernel_prog_memory = kernel::memory_management::regions::MappedAllocatedRegion::new_flat(allocated_kernel_prog_memory);
-    let mapped_kernel_ram_memory = kernel::memory_management::regions::MappedAllocatedRegion::new_flat(allocated_kernel_ram_memory);
-    let mapped_kernel_peripheral_memory = kernel::memory_management::regions::MappedAllocatedRegion::new_flat(allocated_kernel_peripheral_memory);
+    let allocated_kernel_rom_memory =
+        kernel::memory_management::regions::PhysicalAllocatedRegion::new(
+            physical_kernel_rom_memory,
+        );
+    let allocated_kernel_prog_memory =
+        kernel::memory_management::regions::PhysicalAllocatedRegion::new(
+            physical_kernel_prog_memory,
+        );
+    let allocated_kernel_ram_memory =
+        kernel::memory_management::regions::PhysicalAllocatedRegion::new(
+            physical_kernel_ram_memory,
+        );
+    let allocated_kernel_peripheral_memory =
+        kernel::memory_management::regions::PhysicalAllocatedRegion::new(
+            physical_kernel_peripheral_memory,
+        );
+
+    let mapped_kernel_rom_memory =
+        kernel::memory_management::regions::MappedAllocatedRegion::new_flat(
+            allocated_kernel_rom_memory,
+        );
+    let mapped_kernel_prog_memory =
+        kernel::memory_management::regions::MappedAllocatedRegion::new_flat(
+            allocated_kernel_prog_memory,
+        );
+    let mapped_kernel_ram_memory =
+        kernel::memory_management::regions::MappedAllocatedRegion::new_flat(
+            allocated_kernel_ram_memory,
+        );
+    let mapped_kernel_peripheral_memory =
+        kernel::memory_management::regions::MappedAllocatedRegion::new_flat(
+            allocated_kernel_peripheral_memory,
+        );
 
     // Create a board kernel instance
     let board_kernel = static_init!(

boards/qemu_rv32_virt/src/linker.rs

@@ -60,7 +60,10 @@ extern "C" {
 ///
 /// 1. `start` and `end` are not page-aligned.
 /// 2. address(`start`) >= address(`end`)
-unsafe fn get_mutable_physical_slice(start: *mut u8, end: *mut u8) -> MutablePhysicalSlice<'static, Page4KiB> {
+unsafe fn get_mutable_physical_slice(
+    start: *mut u8,
+    end: *mut u8,
+) -> MutablePhysicalSlice<'static, Page4KiB> {
     // PANIC: the function's precondition ensures that `start` is page-aligned.
     let start = MutablePointer::new(start.cast()).unwrap();
     // PANIC: the function's precondition ensures that `end` is page-aligned.
@@ -100,7 +103,7 @@ pub(crate) unsafe fn get_kernel_prog_region() -> MutablePhysicalSlice<'static, P
     let kernel_prog_start = core::ptr::addr_of_mut!(_sprog);
     let kernel_prog_end = core::ptr::addr_of_mut!(_eprog);
 
-    // SAFETY: 
+    // SAFETY:
     //
     // 1. the function's precondition ensures that `get_kernel_prog_region()` is called only once
     //    and as such `get_mutable_physical_slice()` too.
@@ -118,7 +121,7 @@ pub(crate) unsafe fn get_kernel_ram_region() -> MutablePhysicalSlice<'static, Pa
     let kernel_ram_start = core::ptr::addr_of_mut!(_sram);
     let kernel_ram_end = core::ptr::addr_of_mut!(_eram);
 
-    // SAFETY: 
+    // SAFETY:
     //
     // 1. the function's precondition ensures that `get_kernel_ram_region()` is called only once
     //    and as such `get_mutable_physical_slice()` too.
@@ -132,7 +135,7 @@ pub(crate) unsafe fn get_kernel_peripheral_region() -> MutablePhysicalSlice<'sta
     let kernel_peripheral_start = core::ptr::addr_of_mut!(_speripheral);
     let kernel_peripheral_end = core::ptr::addr_of_mut!(_eperipheral);
 
-    // SAFETY: 
+    // SAFETY:
     //
     // 1. the function's precondition ensures that `get_kernel_peripheral_region()` is called only
     //    once and as such `get_mutable_physical_slice()` too.