Added initial support for kernel threads

This is a fairly big change. This introduces threads of execution,
which are initially implemented only for kernel threads. The longer
term plan is to implement threads for userspace too. The plan for
Firefly is to have a hierarchical structure of threads (the unit
of scheduling) belonging to processes (the unit of programs)
belonging to workloads (the unit of applications).

This initial support is quite primitive, but it's a good starting
point. There is no support for preemption yet, so threads must
yield to the scheduler using thread::switch(). The structures for
tracking the current process and the idle thread are not yet
CPU-local, so the implementation is not safe to run in parallel.
However, as we don't yet enable more than one CPU, this is safe
in practice. We will need to add support for CPU-local data
before we can enable multiple cores.

Calling thread::init() initialises the thread module, creating
the idle thread and preparing the current thread and the scheduler.
When thread::switch is called for the first time (in kmain), the
kernel's initial context is stored into the idle thread. From that
point on, the idle thread will execute when no other threads are
runnable. For now, the idle thread exits QEMU, to simplify
development, but this will be removed once the thread functionality
is more stable.

For now, we just demonstrate the threads functionality by switching
to a simple debugging thread, returning to the idle thread, and
exiting.

Signed-off-by: SlyMarbo <[email protected]>

Author: SlyMarbo

kernel/Cargo.lock

@@ -6,6 +6,7 @@ edition = "2018"
 
 [dependencies]
 bootloader = {version = "=0.9.19", features = ["map_physical_memory"]}
+crossbeam = { version = "=0.8.1", default-features = false, features = ["alloc"] }
 crossbeam-queue = {version = "=0.2.1", default-features = false, features = ["alloc"]}
 lazy_static = {version = "=1.4.0", features = ["spin_no_std"]}
 linked_list_allocator = "=0.9.0"

kernel/Cargo.toml

@@ -22,13 +22,16 @@
 #![cfg_attr(test, no_main)]
 #![feature(abi_x86_interrupt)]
 #![feature(alloc_error_handler)]
+#![feature(const_btree_new)]
 #![feature(const_mut_refs)]
 #![feature(custom_test_frameworks)]
+#![feature(global_asm)]
 #![test_runner(crate::test_runner)]
 #![reexport_test_harness_main = "test_main"]
 
 extern crate alloc;
 
+use crate::multitasking::thread;
 use bootloader::BootInfo;
 use core::panic::PanicInfo;
 use lazy_static::lazy_static;
@@ -60,6 +63,7 @@ pub fn init(boot_info: &'static BootInfo) {
 
     // Set up the heap allocator.
     unsafe { memory::init(boot_info) };
+    thread::init();
 }
 
 #[alloc_error_handler]

kernel/src/lib.rs

@@ -14,6 +14,7 @@ extern crate alloc;
 
 use bootloader::{entry_point, BootInfo};
 use core::panic::PanicInfo;
+use kernel::multitasking::thread;
 use kernel::{memory, pci, println};
 
 /// This function is called on panic.
@@ -62,7 +63,26 @@ fn kmain() {
 
     pci::init();
 
-    kernel::shutdown_qemu();
+    // Schedule the thread we want to run next
+    // with switch.
+    thread::Thread::new_kernel_thread(debug_threading);
+
+    // Hand over to the scheduler.
+    thread::switch();
+
+    // We're now executing as the idle
+    // thread.
+    thread::idle_thread();
+}
+
+fn debug_threading() -> ! {
+    let foo: u64 = 1;
+    println!(
+        "Successfully entered new thread with stack address {:p}.",
+        &foo
+    );
+
+    thread::exit();
 }
 
 #[allow(dead_code)]

kernel/src/main.rs

@@ -17,8 +17,12 @@
 // build the memory manager.
 
 use bootloader::BootInfo;
+use core::sync::atomic::{AtomicU64, Ordering};
 use x86_64::registers::control::Cr3;
-use x86_64::structures::paging::{OffsetPageTable, PageTable};
+use x86_64::structures::paging::mapper::MapToError;
+use x86_64::structures::paging::{
+    FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PageTableFlags, Size4KiB,
+};
 use x86_64::VirtAddr;
 
 mod constants;
@@ -82,6 +86,93 @@ pub unsafe fn kernel_pml4() -> OffsetPageTable<'static> {
     OffsetPageTable::new(page_table, PHYSICAL_MEMORY_OFFSET)
 }
 
+/// StackBounds describes the address space used
+/// for a stack.
+///
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct StackBounds {
+    start: VirtAddr,
+    end: VirtAddr,
+}
+
+impl StackBounds {
+    /// from returns a set of stack bounds consisting of the
+    /// given virtual address range.
+    ///
+    pub fn from(range: &VirtAddrRange) -> Self {
+        StackBounds {
+            start: range.start(),
+            end: range.end() + 1u64, // StackBounds is exclusive, range is inclusive.
+        }
+    }
+
+    /// start returns the smallest valid address in the
+    /// stack bounds. As the stack grows downwards, this
+    /// is also known as the bottom of the stack.
+    ///
+    pub fn start(&self) -> VirtAddr {
+        self.start
+    }
+
+    /// end returns the first address beyond the stack
+    /// bounds. As the stack grows downwards, this is
+    /// also known as the top of the stack.
+    ///
+    pub fn end(&self) -> VirtAddr {
+        self.end
+    }
+}
+
+/// reserve_kernel_stack reserves num_pages pages of
+/// stack memory for a kernel thread.
+///
+/// reserve_kernel_stack returns the page at the start
+/// of the stack (the lowest address).
+///
+fn reserve_kernel_stack(num_pages: u64) -> Page {
+    static STACK_ALLOC_NEXT: AtomicU64 = AtomicU64::new(constants::KERNEL_STACK_1_START.as_u64());
+    let start_addr = VirtAddr::new(
+        STACK_ALLOC_NEXT.fetch_add(num_pages * Page::<Size4KiB>::SIZE, Ordering::Relaxed),
+    );
+
+    let last_addr = start_addr + (num_pages * Page::<Size4KiB>::SIZE) - 1u64;
+    if !KERNEL_STACK.contains_range(start_addr, last_addr) {
+        panic!("cannot reserve kernel stack: kernel stack space exhausted");
+    }
+
+    Page::from_start_address(start_addr).expect("`STACK_ALLOC_NEXT` not page aligned")
+}
+
+/// new_kernel_stack allocates num_pages pages of stack
+/// memory for a kernel thread and guard page, returning
+/// the address space of the allocated stack.
+///
+pub fn new_kernel_stack(num_pages: u64) -> Result<StackBounds, MapToError<Size4KiB>> {
+    let guard_page = reserve_kernel_stack(num_pages + 1);
+    let stack_start = guard_page + 1;
+    let stack_end = stack_start + num_pages;
+
+    let mut mapper = unsafe { kernel_pml4() };
+    let mut frame_allocator = pmm::ALLOCATOR.lock();
+    for page in Page::range(stack_start, stack_end) {
+        let frame = frame_allocator
+            .allocate_frame()
+            .ok_or(MapToError::FrameAllocationFailed)?;
+
+        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE | PageTableFlags::NO_EXECUTE;
+        unsafe {
+            mapper
+                .map_to(page, frame, flags, &mut *frame_allocator)?
+                .flush()
+        };
+    }
+
+    Ok(StackBounds {
+        start: stack_start.start_address(),
+        end: stack_end.start_address(),
+    })
+}
+
 #[test_case]
 fn simple_allocation() {
     use alloc::boxed::Box;

kernel/src/memory/mod.rs

@@ -2,3 +2,4 @@
 //! preemptive multitasking.
 
 pub mod task;
+pub mod thread;