Integrate 64-bit RISC-V support

Co-authored-by: Martin Kröning <martin.kroening@eonerc.rwth-aachen.de>
Signed-off-by: Martin Kröning <martin.kroening@eonerc.rwth-aachen.de>

Author: simonschoening

src/drivers/net/mod.rs

@@ -78,3 +78,14 @@ pub(crate) extern "x86-interrupt" fn network_irqhandler(_stack_frame: ExceptionS
 
 	core_scheduler().reschedule();
 }
+
+#[cfg(target_arch = "riscv64")]
+pub fn network_irqhandler() {
+	debug!("Receive network interrupt");
+
+	// PLIC end of interrupt
+	crate::arch::kernel::interrupts::external_eoi();
+	let _ = _irqhandler();
+
+	core_scheduler().reschedule();
+}

src/drivers/net/virtio_net.rs

@@ -18,6 +18,7 @@ use zerocopy::AsBytes;
 
 use self::constants::{FeatureSet, Features, NetHdrFlag, NetHdrGSO, Status, MAX_NUM_VQ};
 use self::error::VirtioNetError;
+#[cfg(not(target_arch = "riscv64"))]
 use crate::arch::kernel::core_local::increment_irq_counter;
 use crate::config::VIRTIO_MAX_QUEUE_SIZE;
 #[cfg(not(feature = "pci"))]
@@ -648,6 +649,7 @@ impl NetworkDriver for VirtioNetDriver {
 	}
 
 	fn handle_interrupt(&mut self) -> bool {
+		#[cfg(not(target_arch = "riscv64"))]
 		increment_irq_counter(32 + self.irq);
 
 		let result = if self.isr_stat.is_interrupt() {

src/drivers/virtio/transport/mmio.rs

@@ -394,6 +394,7 @@ pub(crate) fn init_device(
 					info!("Virtio network driver initialized.");
 					// Install interrupt handler
 					irq_install_handler(irq_no, network_irqhandler);
+					#[cfg(not(target_arch = "riscv64"))]
 					add_irq_name(irq_no, "virtio_net");
 
 					Ok(VirtioDriver::Network(virt_net_drv))

src/executor/network.rs

@@ -78,6 +78,13 @@ fn start_endpoint() -> u16 {
 	(value % (u16::MAX as u64)).try_into().unwrap()
 }
 
+#[cfg(target_arch = "riscv64")]
+fn start_endpoint() -> u16 {
+	(riscv::register::time::read64() % (u16::MAX as u64))
+		.try_into()
+		.unwrap()
+}
+
 #[inline]
 pub(crate) fn now() -> Instant {
 	let microseconds = arch::processor::get_timer_ticks() + arch::get_boot_time();

src/fd/mod.rs

@@ -163,6 +163,13 @@ fn uhyve_send<T>(port: u16, data: &mut T) {
 	}
 }
 
+/// forward a request to the hypervisor uhyve
+#[inline]
+#[cfg(target_arch = "riscv64")]
+fn uhyve_send<T>(port: u16, data: &mut T) {
+	todo!()
+}
+
 fn open_flags_to_perm(flags: i32, mode: u32) -> FilePerms {
 	let mut perms = FilePerms {
 		raw: flags as u32,

src/lib.rs

@@ -9,14 +9,18 @@
 #![allow(clippy::missing_safety_doc)]
 #![cfg_attr(target_arch = "aarch64", allow(incomplete_features))]
 #![cfg_attr(target_arch = "x86_64", feature(abi_x86_interrupt))]
+#![cfg_attr(target_arch = "riscv64", feature(offset_of))]
 #![feature(allocator_api)]
 #![feature(asm_const)]
 #![feature(core_intrinsics)]
 #![feature(linked_list_cursors)]
 #![feature(maybe_uninit_slice)]
 #![feature(naked_functions)]
 #![feature(noop_waker)]
-#![cfg_attr(target_arch = "aarch64", feature(specialization))]
+#![cfg_attr(
+	any(target_arch = "aarch64", target_arch = "riscv64"),
+	feature(specialization)
+)]
 #![feature(strict_provenance)]
 #![cfg_attr(target_os = "none", no_std)]
 #![cfg_attr(target_os = "none", feature(custom_test_frameworks))]
@@ -264,6 +268,10 @@ extern "C" fn initd(_arg: usize) {
 	arch::init_drivers();
 	crate::executor::init();
 
+	// Initialize MMIO Drivers if on riscv64
+	#[cfg(target_arch = "riscv64")]
+	riscv64::kernel::init_drivers();
+
 	syscalls::init();
 	fd::init();
 	#[cfg(feature = "fs")]
@@ -320,6 +328,8 @@ fn boot_processor_main() -> ! {
 		env::get_tls_memsz()
 	);
 	arch::boot_processor_init();
+
+	#[cfg(not(target_arch = "riscv64"))]
 	scheduler::add_current_core();
 
 	if !env::is_uhyve() {
@@ -355,6 +365,7 @@ fn boot_processor_main() -> ! {
 #[cfg(all(target_os = "none", feature = "smp"))]
 fn application_processor_main() -> ! {
 	arch::application_processor_init();
+	#[cfg(not(target_arch = "riscv64"))]
 	scheduler::add_current_core();
 
 	info!("Entering idle loop for application processor");

src/macros.rs

@@ -105,7 +105,10 @@ macro_rules! kernel_function {
 
 // TODO: Properly switch kernel stack with newlib
 // https://github.com/hermitcore/hermit-kernel/issues/471
-#[cfg(all(target_arch = "x86_64", feature = "newlib"))]
+#[cfg(any(
+	target_arch = "riscv64",
+	all(target_arch = "x86_64", feature = "newlib")
+))]
 macro_rules! kernel_function {
 	($f:ident($($x:tt)*)) => {{
 		$f($($x)*)

src/scheduler/mod.rs

@@ -8,10 +8,14 @@ use core::sync::atomic::{AtomicU32, Ordering};
 
 use crossbeam_utils::Backoff;
 use hermit_sync::{without_interrupts, *};
+#[cfg(target_arch = "riscv64")]
+use riscv::register::sstatus;
 
 use crate::arch;
 use crate::arch::core_local::*;
 use crate::arch::interrupts;
+#[cfg(target_arch = "riscv64")]
+use crate::arch::switch::switch_to_task;
 #[cfg(target_arch = "x86_64")]
 use crate::arch::switch::{switch_to_fpu_owner, switch_to_task};
 use crate::kernel::scheduler::TaskStacks;
@@ -289,7 +293,7 @@ impl PerCoreScheduler {
 
 	/// Returns `true` if a reschedule is required
 	#[inline]
-	#[cfg(all(target_arch = "x86_64", feature = "smp"))]
+	#[cfg(all(any(target_arch = "x86_64", target_arch = "riscv64"), feature = "smp"))]
 	pub fn is_scheduling(&self) -> bool {
 		self.current_task.borrow().prio < self.ready_queue.get_highest_priority()
 	}
@@ -422,6 +426,18 @@ impl PerCoreScheduler {
 		})
 	}
 
+	#[cfg(target_arch = "riscv64")]
+	pub fn set_current_kernel_stack(&self) {
+		let current_task_borrowed = self.current_task.borrow();
+
+		set_kernel_stack(
+			(current_task_borrowed.stacks.get_kernel_stack()
+				+ current_task_borrowed.stacks.get_kernel_stack_size()
+				- TaskStacks::MARKER_SIZE)
+				.as_u64(),
+		);
+	}
+
 	/// Save the FPU context for the current FPU owner and restore it for the current task,
 	/// which wants to use the FPU now.
 	#[cfg(target_arch = "x86_64")]
@@ -447,7 +463,7 @@ impl PerCoreScheduler {
 		}
 	}
 
-	#[cfg(all(target_arch = "x86_64", feature = "smp"))]
+	#[cfg(all(any(target_arch = "x86_64", target_arch = "riscv64"), feature = "smp"))]
 	pub fn check_input(&mut self) {
 		let mut input_locked = self.input.lock();
 
@@ -488,6 +504,12 @@ impl PerCoreScheduler {
 		})
 	}
 
+	#[cfg(target_arch = "riscv64")]
+	pub fn reschedule(&mut self) {
+		// TODO: Align with others
+		without_interrupts(|| self.scheduler());
+	}
+
 	/// Trigger an interrupt to reschedule the system
 	#[cfg(target_arch = "aarch64")]
 	pub fn reschedule(&self) {
@@ -630,10 +652,26 @@ impl PerCoreScheduler {
 					unsafe { *last_stack_pointer },
 					new_stack_pointer
 				);
-				self.current_task = task;
+				#[cfg(not(target_arch = "riscv64"))]
+				{
+					self.current_task = task;
+				}
 
 				// Finally return the context of the new task.
+				#[cfg(not(target_arch = "riscv64"))]
 				return Some(last_stack_pointer);
+
+				#[cfg(target_arch = "riscv64")]
+				{
+					if sstatus::read().fs() == sstatus::FS::Dirty {
+						self.current_task.borrow_mut().last_fpu_state.save();
+					}
+					task.borrow().last_fpu_state.restore();
+					self.current_task = task;
+					unsafe {
+						switch_to_task(last_stack_pointer, new_stack_pointer.as_usize());
+					}
+				}
 			}
 		}
 

src/scheduler/task.rs

@@ -323,7 +323,7 @@ impl PriorityTaskQueue {
 	}
 
 	/// Returns the highest priority of all available task
-	#[cfg(all(target_arch = "x86_64", feature = "smp"))]
+	#[cfg(all(any(target_arch = "x86_64", target_arch = "riscv64"), feature = "smp"))]
 	pub fn get_highest_priority(&self) -> Priority {
 		if let Some(i) = msb(self.prio_bitmap) {
 			Priority::from(i.try_into().unwrap())

src/syscalls/interfaces/uhyve.rs

@@ -56,6 +56,13 @@ pub(crate) fn uhyve_send<T>(port: u16, data: &mut T) {
 	}
 }
 
+/// forward a request to the hypervisor uhyve
+#[inline]
+#[cfg(target_arch = "riscv64")]
+fn uhyve_send<T>(port: u16, data: &mut T) {
+	todo!()
+}
+
 const MAX_ARGC_ENVC: usize = 128;
 
 #[repr(C, packed)]