Move almost all the kernel into crates/.

4 files changed, 134 insertions, 0 deletions

diff --git a/crates/kernel/src/arch/hosted.rs b/crates/kernel/src/arch/hosted.rs
new file mode 100644
index 0000000..df62bab
--- /dev/null
+++ b/crates/kernel/src/arch/hosted.rs
@@ -0,0 +1,29 @@
+//! Support for running under an operating system that provides libstd, for testing.
+
+extern crate std;
+
+use std::{thread::sleep, time::Duration};
+
+/// The size of a page of memory.
+///
+/// Obviously, this value is unrealistic, but for now we just need the hosted arch to compile.
+pub const PAGE_SIZE: usize = 64;
+
+/// The number of bits in the size of a page of memory.
+///
+/// Obviously, this value is unrealistic, but for now we just need the hosted arch to compile.
+pub const PAGE_SIZE_BITS: usize = 6;
+
+/// No-opped interrupt support.
+///
+/// TODO: Should this use Unix signals?
+pub mod interrupts {
+    pub fn disable_interrupts() {}
+}
+
+/// Sleeps forever, in one-second chunks.
+pub fn sleep_forever() -> ! {
+    loop {
+        sleep(Duration::from_secs(1));
+    }
+}
diff --git a/crates/kernel/src/arch/mod.rs b/crates/kernel/src/arch/mod.rs
new file mode 100644
index 0000000..bfdfcc7
--- /dev/null
+++ b/crates/kernel/src/arch/mod.rs
@@ -0,0 +1,11 @@
+cfg_if::cfg_if! {
+    if #[cfg(not(target_os = "none"))] {
+        mod hosted;
+        pub use self::hosted::*;
+    } else if #[cfg(target_arch = "riscv64")] {
+        mod riscv64;
+        pub use self::riscv64::*;
+    } else {
+        compile_error!("unsupported platform");
+    }
+}
diff --git a/crates/kernel/src/arch/riscv64/interrupts.rs b/crates/kernel/src/arch/riscv64/interrupts.rs
new file mode 100644
index 0000000..84f2258
--- /dev/null
+++ b/crates/kernel/src/arch/riscv64/interrupts.rs
@@ -0,0 +1,80 @@
+use core::{
+    arch::{asm, global_asm},
+    time::Duration,
+};
+use log::info;
+use vernos_driver_riscv_timer::{set_timer, Instant};
+
+/// Sets up the timer interrupt.
+#[inline(never)]
+pub(crate) fn example_timer() {
+    let now = Instant::now();
+    info!("now = {now:?}");
+
+    let in_a_sec = now + Duration::from_secs(1);
+    info!("in_a_sec = {in_a_sec:?}");
+    info!("setting a timer for 1s...");
+    set_timer(in_a_sec);
+
+    enable_interrupts();
+}
+
+/// Disables interrupts.
+pub fn disable_interrupts() {
+    // Set SSTATUS.SIE to 0, which disables interrupts.
+    //
+    // SAFETY: Not running interrupts shouldn't be able to compromise safety.
+    unsafe {
+        asm!(
+            "csrc sstatus, {sie}",
+            sie = in(reg) (1 << 1),
+            options(nomem, nostack)
+        );
+    }
+}
+
+/// Enables interrupts.
+pub fn enable_interrupts() {
+    // Set STVEC.BASE to the handler function, and STVEC.MODE to Direct. Since the trap_handler_asm
+    // has a `.align 4` before it, the lower two bits of its address should already be zero.
+    //
+    // SAFETY: Even if interrupts were already enabled, this is a valid handler.
+    unsafe {
+        asm!(
+            "csrw stvec, {stvec}",
+            stvec = in(reg) trap_handler_asm,
+            options(nomem, nostack)
+        );
+    }
+
+    // Set SSTATUS.SIE to 1, which enables interrupts.
+    //
+    // SAFETY: We just initialized STVEC, so it should be able to handle interrupts.
+    unsafe {
+        asm!(
+            "csrs sstatus, {sie}",
+            sie = in(reg) (1 << 1),
+            options(nomem, nostack)
+        );
+    }
+}
+
+fn trap_handler() {
+    todo!("trap_handler")
+}
+
+// The assembly code that calls the Rust trap handler, after saving all caller-save registers
+// to the stack.
+global_asm! {
+    // Declare the handler's symbol.
+    ".align 4",
+    "trap_handler_asm:",
+    // TODO
+    "nop",
+    "call {trap_handler}",
+    trap_handler = sym trap_handler
+}
+
+extern "C" {
+    fn trap_handler_asm();
+}
diff --git a/crates/kernel/src/arch/riscv64/mod.rs b/crates/kernel/src/arch/riscv64/mod.rs
new file mode 100644
index 0000000..216a90c
--- /dev/null
+++ b/crates/kernel/src/arch/riscv64/mod.rs
@@ -0,0 +1,14 @@
+pub mod interrupts;
+
+/// The size of a page of memory.
+pub const PAGE_SIZE: usize = 4096;
+
+/// The number of bits in the size of a page of memory.
+pub const PAGE_SIZE_BITS: usize = 12;
+
+/// Halts the hart.
+pub fn sleep_forever() -> ! {
+    loop {
+        unsafe { core::arch::asm!("wfi") }
+    }
+}