style: apply rustfmt and tidy up imports across arch modules

Reformat long expressions (VMA inserts, page-table walks, error
messages) to rustfmt line-wrapping, normalize indentation in
clear_user_space, and regroup/sort imports (module- vs. function-local,
std/crate blocks). Reorder pub-use reexports in arch/mod.rs and fix the
missing trailing newline. No functional change.

Author: stlankes

src/arch/aarch64/kernel/interrupts.rs

@@ -219,9 +219,7 @@ pub(crate) extern "C" fn do_sync(state: &mut State) {
 	 * COW-marked page, which can happen e.g. when the kernel writes
 	 * argv/envp into the freshly-mapped user page during the loader path.
 	 */
-	if ec == ESR_EL1::EC::Value::DataAbortCurrentEL
-		|| ec == ESR_EL1::EC::Value::DataAbortLowerEL
-	{
+	if ec == ESR_EL1::EC::Value::DataAbortCurrentEL || ec == ESR_EL1::EC::Value::DataAbortLowerEL {
 		#[cfg(feature = "common-os")]
 		increment_irq_counter(PAGE_FAULT_IRQ);
 
@@ -236,29 +234,35 @@ pub(crate) extern "C" fn do_sync(state: &mut State) {
 		let is_permission_fault = (0b00_1100..=0b00_1111).contains(&dfsc);
 
 		#[cfg(all(feature = "common-os", feature = "fork"))]
-		if is_write
-			&& is_permission_fault
-			&& do_cow_fault(VirtAddr::new(far))
-		{
+		if is_write && is_permission_fault && do_cow_fault(VirtAddr::new(far)) {
 			// Faulting instruction is retried on `eret` from the trap.
 			return;
 		}
 
 		#[cfg(feature = "common-os")]
 		{
-			use align_address::Align;
 			use core::ops::Bound;
+
+			use align_address::Align;
+
 			use crate::mm::FrameAlloc;
 			use crate::mm::vma::VirtualMemoryAreaProt;
 
 			let addr = VirtAddr::new(far).align_down(BasePageSize::SIZE);
 			let current_task = core_scheduler().get_current_task();
-        	let current_task_borrowed = current_task.borrow();
-        	let guard = current_task_borrowed.vmas.read();
+			let current_task_borrowed = current_task.borrow();
+			let guard = current_task_borrowed.vmas.read();
 
-			if let Some((_, vma)) = guard.range((Bound::Unbounded, Bound::Included(addr))).next_back() {
+			if let Some((_, vma)) = guard
+				.range((Bound::Unbounded, Bound::Included(addr)))
+				.next_back()
+			{
 				if addr >= vma.start && addr < vma.end {
-					let layout = PageLayout::from_size_align(BasePageSize::SIZE as usize, BasePageSize::SIZE as usize).unwrap();
+					let layout = PageLayout::from_size_align(
+						BasePageSize::SIZE as usize,
+						BasePageSize::SIZE as usize,
+					)
+					.unwrap();
 					let frame_range = FrameAlloc::allocate(layout).unwrap();
 					let physaddr = PhysAddr::from(frame_range.start());
 					let mut flags = PageTableEntryFlags::empty();
@@ -270,15 +274,15 @@ pub(crate) extern "C" fn do_sync(state: &mut State) {
 						flags.execute_disable();
 					}
 
-					paging::map::<BasePageSize>(
-						addr,
-						physaddr,
-						1,
-						flags,
-					);
+					paging::map::<BasePageSize>(addr, physaddr, 1, flags);
 
 					// clear page
-					let slice = unsafe { core::slice::from_raw_parts_mut(addr.as_mut_ptr() as *mut u8, BasePageSize::SIZE as usize) };
+					let slice = unsafe {
+						core::slice::from_raw_parts_mut(
+							addr.as_mut_ptr() as *mut u8,
+							BasePageSize::SIZE as usize,
+						)
+					};
 					slice.fill(0);
 
 					#[cfg(feature = "fork")]
@@ -292,16 +296,13 @@ pub(crate) extern "C" fn do_sync(state: &mut State) {
 		let kind = dfsc_kind(dfsc);
 		let access = if is_write { "write" } else { "read" };
 		error!("Current stack pointer {state:p}");
-		error!(
-			"Unhandled data abort: {kind} on {access} of {far:#x} (DFSC={dfsc:#x})"
-		);
+		error!("Unhandled data abort: {kind} on {access} of {far:#x} (DFSC={dfsc:#x})");
 		error!("Exception return address {:#x}", ELR_EL1.get());
 		error!("Thread ID register {:#x}", TPIDR_EL0.get());
 		error!("Table Base Register {:#x}", TTBR0_EL1.get());
 		error!("Exception Syndrome Register {esr:#x}");
 
-		if let Some(irqid) =
-			GicCpuInterface::get_and_acknowledge_interrupt(InterruptGroup::Group1)
+		if let Some(irqid) = GicCpuInterface::get_and_acknowledge_interrupt(InterruptGroup::Group1)
 		{
 			GicCpuInterface::end_interrupt(irqid, InterruptGroup::Group1);
 		} else {

src/arch/aarch64/kernel/mod.rs

@@ -14,12 +14,18 @@ pub mod serial;
 mod start;
 pub mod systemtime;
 
-use alloc::alloc::alloc;
-use core::alloc::Layout;
+use alloc::alloc::{Layout, alloc};
+#[cfg(feature = "common-os")]
+use core::arch::asm;
 use core::arch::global_asm;
 use core::ptr;
+#[cfg(feature = "common-os")]
+use core::slice;
 use core::sync::atomic::{AtomicPtr, AtomicU32, Ordering};
 
+#[cfg(feature = "common-os")]
+use memory_addresses::{PhysAddr, VirtAddr};
+
 pub(crate) use self::interrupts::wakeup_core;
 pub(crate) use self::processor::set_oneshot_timer;
 #[cfg(feature = "common-os")]
@@ -209,10 +215,10 @@ where
 
 	use crate::arch::aarch64::mm::paging::{self, PageTableEntryFlags};
 	use crate::fd::{Fd, RawFd};
-	use crate::mm::{FrameAlloc, PageRangeAllocator};
 	#[cfg(feature = "fork")]
 	use crate::mm::frame_ref_inc;
 	use crate::mm::vma::*;
+	use crate::mm::{FrameAlloc, PageRangeAllocator};
 
 	// Each process has its own object map.
 	let mut object_map = HashMap::<RawFd, Arc<async_lock::RwLock<Fd>>, RandomState>::with_hasher(
@@ -238,7 +244,22 @@ where
 		code_size / BasePageSize::SIZE as usize,
 		flags,
 	);
-	core_scheduler().get_current_task().borrow_mut().vmas.write().insert(VirtAddr::from(USER_START), VirtualMemoryArea::new(VirtAddr::from(USER_START), VirtAddr::from(USER_START + code_size).align_up(BasePageSize::SIZE), VirtualMemoryAreaProt::READ|VirtualMemoryAreaProt::WRITE|VirtualMemoryAreaProt::EXECUTE, MemoryType::CODE));
+	core_scheduler()
+		.get_current_task()
+		.borrow_mut()
+		.vmas
+		.write()
+		.insert(
+			VirtAddr::from(USER_START),
+			VirtualMemoryArea::new(
+				VirtAddr::from(USER_START),
+				VirtAddr::from(USER_START + code_size).align_up(BasePageSize::SIZE),
+				VirtualMemoryAreaProt::READ
+					| VirtualMemoryAreaProt::WRITE
+					| VirtualMemoryAreaProt::EXECUTE,
+				MemoryType::CODE,
+			),
+		);
 
 	let loader_start_ptr = ptr::with_exposed_provenance_mut(USER_START.as_usize());
 	let code_slice = unsafe { slice::from_raw_parts_mut(loader_start_ptr, code_size) };
@@ -270,10 +291,24 @@ where
 			tls_memsz / BasePageSize::SIZE as usize,
 			flags,
 		);
-		core_scheduler().get_current_task().borrow_mut().vmas.write().insert(tls_virt, VirtualMemoryArea::new(tls_virt, (tls_virt + tls_memsz).align_up(BasePageSize::SIZE), VirtualMemoryAreaProt::READ|VirtualMemoryAreaProt::WRITE, MemoryType::TLS));
-
-		let block =
-			unsafe { slice::from_raw_parts_mut(tls_virt.as_mut_ptr(), tls_offset + tls_size as usize) };
+		core_scheduler()
+			.get_current_task()
+			.borrow_mut()
+			.vmas
+			.write()
+			.insert(
+				tls_virt,
+				VirtualMemoryArea::new(
+					tls_virt,
+					(tls_virt + tls_memsz).align_up(BasePageSize::SIZE),
+					VirtualMemoryAreaProt::READ | VirtualMemoryAreaProt::WRITE,
+					MemoryType::TLS,
+				),
+			);
+
+		let block = unsafe {
+			slice::from_raw_parts_mut(tls_virt.as_mut_ptr(), tls_offset + tls_size as usize)
+		};
 		for elem in block.iter_mut() {
 			*elem = 0;
 		}
@@ -289,11 +324,10 @@ where
 		let tls_init = func(code_slice, Some(tls_image))?;
 
 		if let Some(init) = tls_init {
-			let template =
-				Arc::new(crate::scheduler::task::TlsTemplate {
-					size: tls_size as usize,
-					init,
-				});
+			let template = Arc::new(crate::scheduler::task::TlsTemplate {
+				size: tls_size as usize,
+				init,
+			});
 			core_scheduler()
 				.get_current_task()
 				.borrow_mut()
@@ -364,10 +398,10 @@ pub unsafe fn jump_to_user_land(entry_point: usize, arg: alloc::vec::Vec<&str>)
 
 	use crate::arch::aarch64::kernel::scheduler::TaskStacks;
 	use crate::arch::aarch64::mm::paging::{self, PageTableEntryFlags};
-	use crate::mm::{FrameAlloc, PageRangeAllocator};
 	#[cfg(feature = "fork")]
 	use crate::mm::frame_ref_inc;
 	use crate::mm::vma::*;
+	use crate::mm::{FrameAlloc, PageRangeAllocator};
 
 	debug!("Create new file descriptor table");
 	core_scheduler().recreate_objmap().unwrap();
@@ -386,7 +420,20 @@ pub unsafe fn jump_to_user_land(entry_point: usize, arg: alloc::vec::Vec<&str>)
 		USER_STACK_SIZE / BasePageSize::SIZE as usize,
 		flags,
 	);
-	core_scheduler().get_current_task().borrow_mut().vmas.write().insert(USER_STACK, VirtualMemoryArea::new(USER_STACK, USER_STACK+USER_STACK_SIZE, VirtualMemoryAreaProt::READ|VirtualMemoryAreaProt::WRITE, MemoryType::STACK));
+	core_scheduler()
+		.get_current_task()
+		.borrow_mut()
+		.vmas
+		.write()
+		.insert(
+			USER_STACK,
+			VirtualMemoryArea::new(
+				USER_STACK,
+				USER_STACK + USER_STACK_SIZE,
+				VirtualMemoryAreaProt::READ | VirtualMemoryAreaProt::WRITE,
+				MemoryType::STACK,
+			),
+		);
 	#[cfg(feature = "fork")]
 	for i in 0..USER_STACK_SIZE / BasePageSize::SIZE as usize {
 		frame_ref_inc(phys_addr + i * BasePageSize::SIZE as usize);

src/arch/aarch64/kernel/scheduler.rs

@@ -334,8 +334,7 @@ impl Task {
 	) {
 		unsafe {
 			// Debug marker at the very top of the kernel stack.
-			let mut stack = self.stacks.get_kernel_stack()
-				+ self.stacks.get_kernel_stack_size()
+			let mut stack = self.stacks.get_kernel_stack() + self.stacks.get_kernel_stack_size()
 				- TaskStacks::MARKER_SIZE;
 			*stack.as_mut_ptr::<u64>() = 0xdead_beefu64;
 

src/arch/aarch64/mm/mod.rs

@@ -1,15 +1,9 @@
 pub(crate) mod paging;
 
 #[cfg(feature = "common-os")]
-pub use paging::{
-	clear_user_space, create_new_root_page_table,
-	drop_user_space,
-};
-
+pub use paging::{clear_user_space, create_new_root_page_table, drop_user_space};
 #[cfg(all(feature = "common-os", feature = "fork"))]
-pub use paging::{
-	copy_current_root_page_table, copy_kernel_stack_to, prepare_mem_copy_on_write
-};
+pub use paging::{copy_current_root_page_table, copy_kernel_stack_to, prepare_mem_copy_on_write};
 
 use crate::mm::{FrameAlloc, PageAlloc, PageRangeAllocator};
 
@@ -28,10 +22,7 @@ pub fn allocate_thread_tls(template: &crate::scheduler::task::TlsTemplate) -> u6
 	use free_list::PageLayout;
 	use memory_addresses::arch::aarch64::{PhysAddr, VirtAddr};
 
-	use crate::arch::aarch64::mm::paging::{
-		self, BasePageSize, PageSize, PageTableEntryFlags,
-	};
-	use crate::mm::{FrameAlloc, PageAlloc, PageRangeAllocator};
+	use crate::arch::aarch64::mm::paging::{self, BasePageSize, PageSize, PageTableEntryFlags};
 	#[cfg(feature = "fork")]
 	use crate::mm::frame_ref_inc;
 

src/arch/aarch64/mm/paging.rs

@@ -854,29 +854,23 @@ pub fn do_cow_fault(faulting_addr: VirtAddr) -> bool {
 	}
 
 	let l1 = unsafe {
-		&mut *ptr::with_exposed_provenance_mut::<PageTable<L1Table>>(
-			l0_entry.address().as_usize(),
-		)
+		&mut *ptr::with_exposed_provenance_mut::<PageTable<L1Table>>(l0_entry.address().as_usize())
 	};
 	let l1_entry = &mut l1.entries[l1_idx];
 	if !l1_entry.is_present() || !l1_entry.is_table_or_4kib_page() {
 		return false;
 	}
 
 	let l2 = unsafe {
-		&mut *ptr::with_exposed_provenance_mut::<PageTable<L2Table>>(
-			l1_entry.address().as_usize(),
-		)
+		&mut *ptr::with_exposed_provenance_mut::<PageTable<L2Table>>(l1_entry.address().as_usize())
 	};
 	let l2_entry = &mut l2.entries[l2_idx];
 	if !l2_entry.is_present() || !l2_entry.is_table_or_4kib_page() {
 		return false;
 	}
 
 	let l3 = unsafe {
-		&mut *ptr::with_exposed_provenance_mut::<PageTable<L3Table>>(
-			l2_entry.address().as_usize(),
-		)
+		&mut *ptr::with_exposed_provenance_mut::<PageTable<L3Table>>(l2_entry.address().as_usize())
 	};
 	let l3_entry = &mut l3.entries[l3_idx];
 
@@ -1107,23 +1101,23 @@ pub fn drop_user_space(l0_phys: usize) {
 	clear_l0(l0_phys);
 
 	// The L0 table is not loaded on any core, so no TLB flush is necessary.
-	let range =
-		free_list::PageRange::new(l0_phys, l0_phys + BasePageSize::SIZE as usize).unwrap();
+	let range = free_list::PageRange::new(l0_phys, l0_phys + BasePageSize::SIZE as usize).unwrap();
 	unsafe { FrameAlloc::deallocate(range) };
 }
 
 /// Clear the user-space portion of the currently active address space.
 #[cfg(feature = "common-os")]
 pub fn clear_user_space() {
-	use crate::fd::STDERR_FILENO;
-	use crate::core_scheduler;
 	use aarch64_cpu::registers::TTBR0_EL1;
 
+	use crate::core_scheduler;
+	use crate::fd::STDERR_FILENO;
+
 	core_scheduler()
-        .get_current_task()
-        .borrow()       
-        .vmas                   
-        .write()
+		.get_current_task()
+		.borrow()
+		.vmas
+		.write()
 		.clear();
 	core_scheduler()
 		.get_current_task_object_map()
@@ -1157,8 +1151,7 @@ pub fn create_new_root_page_table() -> usize {
 	let new_l0_phys = frame_range.start();
 
 	let cur_l0_phys = TTBR0_EL1.get_baddr() as usize;
-	let cur_l0 =
-		unsafe { &*ptr::with_exposed_provenance::<PageTable<L0Table>>(cur_l0_phys) };
+	let cur_l0 = unsafe { &*ptr::with_exposed_provenance::<PageTable<L0Table>>(cur_l0_phys) };
 
 	let new_l0 =
 		unsafe { &mut *ptr::with_exposed_provenance_mut::<PageTable<L0Table>>(new_l0_phys) };
@@ -1218,8 +1211,7 @@ pub fn copy_current_root_page_table() -> usize {
 		unsafe { &mut *ptr::with_exposed_provenance_mut::<PageTable<L0Table>>(new_l0_phys) };
 
 	let cur_l0_phys = TTBR0_EL1.get_baddr() as usize;
-	let cur_l0 =
-		unsafe { &*ptr::with_exposed_provenance::<PageTable<L0Table>>(cur_l0_phys) };
+	let cur_l0 = unsafe { &*ptr::with_exposed_provenance::<PageTable<L0Table>>(cur_l0_phys) };
 
 	// Inherit kernel L0 entries verbatim (sharing the L1/L2/L3 tables
 	// below). Only the user-space slot needs a deep copy with COW so
@@ -1247,9 +1239,8 @@ pub fn copy_current_root_page_table() -> usize {
 		let cur_l1 = unsafe {
 			&*ptr::with_exposed_provenance::<PageTable<L1Table>>(cur_l0_entry.address().as_usize())
 		};
-		let new_l1 = unsafe {
-			&mut *ptr::with_exposed_provenance_mut::<PageTable<L1Table>>(new_l1_phys)
-		};
+		let new_l1 =
+			unsafe { &mut *ptr::with_exposed_provenance_mut::<PageTable<L1Table>>(new_l1_phys) };
 
 		for l1_idx in 0..512usize {
 			let cur_l1_entry = &cur_l1.entries[l1_idx];
@@ -1303,10 +1294,11 @@ pub fn copy_current_root_page_table() -> usize {
 				// The child holds an additional reference to every
 				// user-space frame in this page table.
 				for entry in new_l3.entries.iter() {
-					let flags = PageTableEntryFlags::from_bits_truncate(
-						entry.physical_address_and_flags,
-					);
-					if flags.contains(PageTableEntryFlags::PRESENT|PageTableEntryFlags::USER_ACCESSIBLE) {
+					let flags =
+						PageTableEntryFlags::from_bits_truncate(entry.physical_address_and_flags);
+					if flags.contains(
+						PageTableEntryFlags::PRESENT | PageTableEntryFlags::USER_ACCESSIBLE,
+					) {
 						crate::mm::frame_ref_inc(entry.address());
 					}
 				}