Recycle used kernel thread stacks

Because new_kernel_stack iterates through the available stack
space linearly, it can only provide each stack slot once. This
means that there is a limited number of kernel threads that can
be created over the lifetime of the kernel. With the kernel
stack space defined so currently, and with one-page guard pages
for each stack, this would currently give a limit of 255 kernel
threads (including the initial thread).

To address this issue, we now recycle old kernel stack when their
thread exits. When we create a new thread, we check whether there
is a dead stack available. If so, we reuse it, rather than allocating
another. This means we go from having a limit of 255 kernel threads
ever to a limit of 255 simultaneous kernel threads. In practice,
this is likely to be sufficient.

Author: SlyMarbo

kernel/src/multitasking/thread/mod.rs

@@ -7,6 +7,7 @@ use crate::utils::lazy::Lazy;
 use crate::utils::once::Once;
 use alloc::collections::BTreeMap;
 use alloc::sync::Arc;
+use alloc::vec::Vec;
 use core::cell::UnsafeCell;
 use core::sync::atomic::{AtomicU64, Ordering};
 use crossbeam::atomic::AtomicCell;
@@ -55,6 +56,22 @@ pub fn current_thread() -> &'static Arc<Thread> {
     unsafe { CURRENT.get() }
 }
 
+/// DEAD_STACKS is a free list of kernel stacks that
+/// have been released by kernel threads that have
+/// exited.
+///
+/// If there is a stack available in DEAD_STACKS
+/// when a new thread is created, it is used instead
+/// of allocating a new stack. This mitigates the
+/// inability to track unused stacks in new_kernel_stack,
+/// which would otherwise limit the number of
+/// kernel threads that can be created during the
+/// lifetime of the kernel. Instead, we're left
+/// with just a limit on the number of simultaneous
+/// kernel threads.
+///
+static DEAD_STACKS: spin::Mutex<Vec<StackBounds>> = spin::Mutex::new(Vec::new());
+
 /// idle_thread implements the idle thread. We
 /// fall back to this if the kernel has no other
 /// work left to do.
@@ -151,6 +168,9 @@ pub fn exit() -> ! {
 
     current.set_state(ThreadState::Exited);
     THREADS.lock().remove(&current.id);
+    if let Some(bounds) = current.stack_bounds {
+        DEAD_STACKS.lock().push(bounds);
+    }
 
     // We've now been unscheduled, so we
     // switch to the next thread.
@@ -278,8 +298,16 @@ impl Thread {
     ///
     pub fn new_kernel_thread(entry_point: fn() -> !) {
         // Allocate and prepare the stack pointer.
-        let stack = new_kernel_stack(Thread::DEFAULT_KERNEL_STACK_PAGES)
-            .expect("failed to allocate stack for new kernel thread");
+        // Check if we can reuse a dead stack, rather
+        // than allocating a new one.
+        let stack = {
+            let mut stacks = DEAD_STACKS.lock();
+            match stacks.pop() {
+                Some(stack) => stack,
+                None => new_kernel_stack(Thread::DEFAULT_KERNEL_STACK_PAGES)
+                    .expect("failed to allocate stack for new kernel thread"),
+            }
+        };
 
         let rsp = unsafe {
             let mut rsp: *mut u64 = stack.end().as_mut_ptr();