refactor: don't import arch module

Author: mkroening

src/executor/device.rs

@@ -14,7 +14,7 @@ use smoltcp::socket::dns;
 use smoltcp::wire::{EthernetAddress, HardwareAddress, IpCidr, Ipv4Address, Ipv4Cidr};
 
 use super::network::{NetworkInterface, NetworkState};
-use crate::arch;
+use crate::arch::kernel::systemtime;
 #[cfg(feature = "write-pcap-file")]
 use crate::drivers::Driver;
 use crate::drivers::net::NetworkDriver;
@@ -80,7 +80,7 @@ impl<'a> NetworkInterface<'a> {
 
 		// use the current time based on the wall-clock time as seed
 		let mut config = Config::new(hardware_addr);
-		config.random_seed = (arch::kernel::systemtime::now_micros()) / 1_000_000;
+		config.random_seed = systemtime::now_micros() / 1_000_000;
 		if capabilities.medium == Medium::Ethernet {
 			config.hardware_addr = hardware_addr;
 		}

src/executor/network.rs

@@ -22,7 +22,7 @@ use smoltcp::wire::{DnsQueryType, IpAddress};
 #[cfg(feature = "dhcpv4")]
 use smoltcp::wire::{IpCidr, Ipv4Address, Ipv4Cidr};
 
-use crate::arch;
+use crate::arch::kernel::systemtime;
 use crate::drivers::net::{NetworkDevice, NetworkDriver};
 #[cfg(feature = "dns")]
 use crate::errno::Errno;
@@ -123,7 +123,7 @@ fn start_endpoint() -> u16 {
 
 #[inline]
 pub(crate) fn now() -> Instant {
-	Instant::from_micros_const(arch::kernel::systemtime::now_micros().try_into().unwrap())
+	Instant::from_micros_const(systemtime::now_micros().try_into().unwrap())
 }
 
 #[cfg(feature = "dhcpv4")]

src/scheduler/task/mod.rs

@@ -19,8 +19,8 @@ use memory_addresses::VirtAddr;
 #[cfg(not(feature = "common-os"))]
 use self::tls::Tls;
 use super::timer_interrupts::{Source, create_timer_abs};
-use crate::arch;
 use crate::arch::core_local::*;
+use crate::arch::processor::{self, FPUState};
 use crate::arch::scheduler::TaskStacks;
 use crate::fd::{Fd, RawFd, stdio};
 use crate::scheduler::CoreId;
@@ -373,7 +373,7 @@ pub(crate) struct Task {
 	/// Last stack pointer on the user stack before jumping to kernel space
 	pub user_stack_pointer: VirtAddr,
 	/// Last FPU state before a context switch to another task using the FPU
-	pub last_fpu_state: arch::processor::FPUState,
+	pub last_fpu_state: FPUState,
 	/// ID of the core this task is running on
 	pub core_id: CoreId,
 	/// Stack of the task
@@ -410,14 +410,14 @@ impl Task {
 			prio: task_prio,
 			last_stack_pointer: VirtAddr::zero(),
 			user_stack_pointer: VirtAddr::zero(),
-			last_fpu_state: arch::processor::FPUState::new(),
+			last_fpu_state: FPUState::new(),
 			core_id,
 			stacks,
 			object_map,
 			#[cfg(not(feature = "common-os"))]
 			tls: None,
 			#[cfg(all(target_arch = "x86_64", feature = "common-os"))]
-			root_page_table: arch::create_new_root_page_table(),
+			root_page_table: crate::arch::create_new_root_page_table(),
 		}
 	}
 
@@ -458,7 +458,7 @@ impl Task {
 			prio: IDLE_PRIO,
 			last_stack_pointer: VirtAddr::zero(),
 			user_stack_pointer: VirtAddr::zero(),
-			last_fpu_state: arch::processor::FPUState::new(),
+			last_fpu_state: FPUState::new(),
 			core_id,
 			stacks: TaskStacks::from_boot_stacks(),
 			object_map: OBJECT_MAP.get().unwrap().clone(),
@@ -602,7 +602,7 @@ impl BlockedTaskQueue {
 	/// at least one task has elapsed.
 	pub fn handle_waiting_tasks(&mut self, ready_queue: &mut PriorityTaskQueue) {
 		// Get the current time.
-		let time = arch::processor::get_timer_ticks();
+		let time = processor::get_timer_ticks();
 
 		// Get the wakeup time of this task and check if we have reached the first task
 		// that hasn't elapsed yet or waits indefinitely.

src/syscalls/entropy.rs

@@ -2,7 +2,7 @@ use core::slice;
 
 use hermit_sync::TicketMutex;
 
-use crate::arch;
+use crate::arch::processor;
 use crate::entropy::{self, Flags};
 use crate::errno::Errno;
 
@@ -115,7 +115,7 @@ pub extern "C" fn sys_srand(seed: u32) {
 }
 
 pub(crate) fn init_entropy() {
-	let seed: u32 = arch::processor::get_timestamp() as u32;
+	let seed: u32 = processor::get_timestamp() as u32;
 
 	*PARK_MILLER_LEHMER_SEED.lock() = seed;
 }

src/syscalls/mman.rs

@@ -13,10 +13,9 @@ use free_list::{FreeList, PageLayout, PageRange};
 use hermit_sync::SpinMutex;
 use memory_addresses::{PhysAddr, VirtAddr};
 
-use crate::arch;
 #[cfg(target_arch = "x86_64")]
 use crate::arch::mm::paging::PageTableEntryFlagsExt;
-use crate::arch::mm::paging::{BasePageSize, PageSize, PageTableEntryFlags};
+use crate::arch::mm::paging::{self, BasePageSize, PageSize, PageTableEntryFlags};
 use crate::mm::{FrameAlloc, PageAlloc, PageRangeAllocator};
 
 bitflags! {
@@ -67,7 +66,7 @@ pub extern "C" fn sys_mmap(size: usize, prot_flags: MemoryProtection, ret: &mut
 		flags.execute_disable();
 	}
 
-	arch::mm::paging::map::<BasePageSize>(virtual_address, physical_address, count, flags);
+	paging::map::<BasePageSize>(virtual_address, physical_address, count, flags);
 
 	*ret = virtual_address.as_mut_ptr();
 
@@ -86,11 +85,8 @@ pub extern "C" fn sys_munmap(ptr: *mut u8, size: usize) -> i32 {
 		return 0;
 	}
 
-	if let Some(physical_address) = arch::mm::paging::virtual_to_physical(virtual_address) {
-		arch::mm::paging::unmap::<BasePageSize>(
-			virtual_address,
-			size / BasePageSize::SIZE as usize,
-		);
+	if let Some(physical_address) = paging::virtual_to_physical(virtual_address) {
+		paging::unmap::<BasePageSize>(virtual_address, size / BasePageSize::SIZE as usize);
 		debug!("Unmapping {virtual_address:X} ({size}) -> {physical_address:X}");
 
 		let frame_range =
@@ -127,14 +123,14 @@ pub extern "C" fn sys_mprotect(ptr: *mut u8, size: usize, prot_flags: MemoryProt
 	let virtual_address = VirtAddr::from_ptr(ptr);
 
 	debug!("Mprotect {virtual_address:X} ({size}) -> {prot_flags:?})");
-	if let Some(physical_address) = arch::mm::paging::virtual_to_physical(virtual_address) {
-		arch::mm::paging::map::<BasePageSize>(virtual_address, physical_address, count, flags);
+	if let Some(physical_address) = paging::virtual_to_physical(virtual_address) {
+		paging::map::<BasePageSize>(virtual_address, physical_address, count, flags);
 		0
 	} else {
 		let frame_layout = PageLayout::from_size(size).unwrap();
 		let frame_range = FrameAlloc::allocate(frame_layout).unwrap();
 		let physical_address = PhysAddr::from(frame_range.start());
-		arch::mm::paging::map::<BasePageSize>(virtual_address, physical_address, count, flags);
+		paging::map::<BasePageSize>(virtual_address, physical_address, count, flags);
 		0
 	}
 }

src/syscalls/timer.rs

@@ -1,4 +1,5 @@
-use crate::arch;
+use crate::arch::kernel::systemtime;
+use crate::arch::processor;
 use crate::errno::Errno;
 use crate::syscalls::usleep;
 use crate::time::{itimerval, timespec, timeval};
@@ -63,11 +64,11 @@ pub unsafe extern "C" fn sys_clock_gettime(clock_id: clockid_t, tp: *mut timespe
 
 	match clock_id {
 		CLOCK_REALTIME => {
-			*result = timespec::from_usec(arch::kernel::systemtime::now_micros() as i64);
+			*result = timespec::from_usec(systemtime::now_micros() as i64);
 			0
 		}
 		CLOCK_MONOTONIC => {
-			*result = timespec::from_usec(arch::processor::get_timer_ticks() as i64);
+			*result = timespec::from_usec(processor::get_timer_ticks() as i64);
 			0
 		}
 		_ => {
@@ -111,9 +112,9 @@ pub unsafe extern "C" fn sys_clock_nanosleep(
 
 			if flags & TIMER_ABSTIME > 0 {
 				if clock_id == CLOCK_REALTIME {
-					microseconds -= arch::kernel::systemtime::now_micros();
+					microseconds -= systemtime::now_micros();
 				} else {
-					microseconds -= arch::processor::get_timer_ticks();
+					microseconds -= processor::get_timer_ticks();
 				}
 			}
 
@@ -144,7 +145,7 @@ pub unsafe extern "C" fn sys_gettimeofday(tp: *mut timeval, tz: usize) -> i32 {
 	if let Some(result) = unsafe { tp.as_mut() } {
 		// Return the current time based on the wallclock time when we were booted up
 		// plus the current timer ticks.
-		let microseconds = arch::kernel::systemtime::now_micros();
+		let microseconds = systemtime::now_micros();
 		*result = timeval::from_usec(microseconds as i64);
 	}
 

src/time.rs

@@ -1,6 +1,6 @@
 use core::time::Duration;
 
-use crate::arch;
+use crate::arch::kernel::systemtime;
 
 #[allow(non_camel_case_types)]
 pub type time_t = i64;
@@ -80,9 +80,7 @@ impl SystemTime {
 
 	/// Returns the system time corresponding to "now".
 	pub fn now() -> Self {
-		Self(timespec::from_usec(
-			arch::kernel::systemtime::now_micros() as i64
-		))
+		Self(timespec::from_usec(systemtime::now_micros() as i64))
 	}
 
 	/// Returns the amount of time elapsed from an earlier point in time.

src/uhyve.rs

@@ -5,7 +5,7 @@ use uhyve_interface::GuestPhysAddr;
 use uhyve_interface::v2::parameters::SerialWriteBufferParams;
 use uhyve_interface::v2::{Hypercall, HypercallAddress};
 
-use crate::arch;
+use crate::arch::kernel::processor;
 use crate::arch::mm::paging::virtual_to_physical;
 
 #[cfg(target_os = "none")]
@@ -93,6 +93,6 @@ pub(crate) fn uhyve_hypercall(hypercall: Hypercall<'_>) {
 pub fn shutdown(error_code: i32) -> ! {
 	uhyve_hypercall(Hypercall::Exit(error_code));
 	loop {
-		arch::processor::halt();
+		processor::halt();
 	}
 }