kernel/src/memory/Heap.cpp

@@ -26,7 +26,7 @@ static constexpr usize BLOCK_DEAD = 0xdeaddeaddeaddead;
 
 static constexpr usize MINIMUM_PAGES_PER_ALLOCATION = 4;
 
-struct HeapBlock : LinkedListNode<HeapBlock>
+struct HeapBlock : DoublyLinkedListNode<HeapBlock>
 {
     usize req_size;
     usize full_size;
@@ -38,7 +38,7 @@ static_assert(sizeof(HeapBlock) == 48UL);
 
 static const isize HEAP_BLOCK_SIZE = 48;
 
-static LinkedList<HeapBlock> heap;
+static DoublyLinkedList<HeapBlock> heap;
 
 static Result<HeapBlock*> allocate_pages(usize count)
 {

kernel/src/thread/Scheduler.cpp

@@ -178,18 +178,29 @@ namespace Scheduler
         if (!g_current->ticks_left) switch_task(regs);
     }
 
-    LinkedList<Thread> check_for_dying_threads()
+    DoublyLinkedList<Thread> check_for_dying_threads()
     {
-        LinkedList<Thread> result;
+        DoublyLinkedList<Thread> result;
 
-        g_threads.delayed_for_each([&](Thread* thread) {
+        Thread* thread_to_remove = nullptr;
-            if (thread->state == ThreadState::Dying)
+
+        g_threads.for_each([&](Thread* thread) {
+            if (thread_to_remove)
             {
-                g_threads.remove(thread);
+                g_threads.remove(thread_to_remove);
-                result.append(thread);
+                result.append(thread_to_remove);
             }
+
+            if (thread->state == ThreadState::Dying) { thread_to_remove = thread; }
+            else { thread_to_remove = nullptr; }
         });
 
+        if (thread_to_remove)
+        {
+            g_threads.remove(thread_to_remove);
+            result.append(thread_to_remove);
+        }
+
         return result;
     }
 }

kernel/src/thread/Scheduler.h

@@ -20,7 +20,7 @@ namespace Scheduler
 
     void invoke(Registers* regs);
 
-    LinkedList<Thread> check_for_dying_threads();
+    DoublyLinkedList<Thread> check_for_dying_threads();
 }
 
 extern "C" void kernel_yield();

kernel/src/thread/Thread.cpp

@@ -4,7 +4,7 @@
 
 static Atomic<u64> g_next_id;
 
-LinkedList<Thread> g_threads;
+DoublyLinkedList<Thread> g_threads;
 
 void Thread::init()
 {

kernel/src/thread/Thread.h

@@ -18,7 +18,7 @@ enum class ThreadState
     Dying
 };
 
-struct Thread : public LinkedListNode<Thread>
+struct Thread : public DoublyLinkedListNode<Thread>
 {
     Registers regs;
 
@@ -60,4 +60,4 @@ bool is_in_kernel(Registers* regs);
 
 Result<Thread*> new_thread();
 
-extern LinkedList<Thread> g_threads;
+extern DoublyLinkedList<Thread> g_threads;

luna/include/luna/LinkedList.h

@@ -9,11 +9,11 @@ template <typename T> inline Option<T*> nonnull_or_error(T* ptr)
         return ptr;
 }
 
-template <typename T> class LinkedList;
+template <typename T> class DoublyLinkedList;
 
-template <typename T> class LinkedListNode
+template <typename T> class DoublyLinkedListNode
 {
-    using SelfType = LinkedListNode<T>;
+    using SelfType = DoublyLinkedListNode<T>;
 
   private:
     SelfType* m_next_node;
@@ -57,14 +57,14 @@ template <typename T> class LinkedListNode
         this->m_next_node = start_node;
     }
 
-    friend class LinkedList<T>;
+    friend class DoublyLinkedList<T>;
 };
 
-template <typename T> class LinkedList
+template <typename T> class DoublyLinkedList
 {
-    using Node = LinkedListNode<T>;
+    using Node = DoublyLinkedListNode<T>;
 
-    static_assert(IsBaseOf<LinkedListNode<T>, T>);
+    static_assert(IsBaseOf<DoublyLinkedListNode<T>, T>);
 
   public:
     void append(T* ptr)
@@ -155,45 +155,33 @@ template <typename T> class LinkedList
         return nonnull_or_error((T*)extract_node(item)->get_last());
     }
 
-    // Iterates over the elements of the LinkedList from start to end, calling callback for every element.
+    // Iterates over the elements of the DoublyLinkedList from start to end, calling callback for every element.
     template <typename Callback> void for_each(Callback callback)
     {
         for (Node* node = m_start_node; node; node = node->get_next()) { callback((T*)node); }
     }
 
-    // Iterates over the elements of the LinkedList from start to end, calling callback for every element. This
+    // Iterates over the elements of the DoublyLinkedList from end to start, calling callback for every element.
-    // for_each is implemented in such a way that elements can be removed while iterating over it.
-    template <typename Callback> void delayed_for_each(Callback callback)
-    {
-        for (Node* node = m_start_node; node;)
-        {
-            T* current = (T*)node;
-            node = node->get_next();
-            callback(current);
-        }
-    }
-
-    // Iterates over the elements of the LinkedList from end to start, calling callback for every element.
     template <typename Callback> void for_each_reversed(Callback callback)
     {
         for (Node* node = m_end_node; node; node = node->get_last()) { callback((T*)node); }
     }
 
-    // Iterates over the elements of the LinkedList from the element after 'start' to end, calling callback for
+    // Iterates over the elements of the DoublyLinkedList from the element after 'start' to end, calling callback for
     // every element.
     template <typename Callback> void for_each_after(T* start, Callback callback)
     {
         for (Node* node = extract_node(start)->m_next_node; node; node = node->get_next()) { callback((T*)node); }
     }
 
-    // Iterates over the elements of the LinkedList from the element before 'end' to start, calling callback for
+    // Iterates over the elements of the DoublyLinkedList from the element before 'end' to start, calling callback for
     // every element.
     template <typename Callback> void for_each_before(T* end, Callback callback)
     {
         for (Node* node = extract_node(end)->m_last_node; node; node = node->get_last()) { callback((T*)node); }
     }
 
-    // Iterates over the elements of the LinkedList from start to end, removing each element before passing it to
+    // Iterates over the elements of the DoublyLinkedList from start to end, removing each element before passing it to
     // the callback.
     template <typename Callback> void consume(Callback callback)
     {