Doubly linked list. Preliminary thread and process structures.

Author: AndreaOrru

kernel/interrupt.zig

@@ -1,4 +1,5 @@
 const isr = @import("isr.zig");
+const tty = @import("tty.zig");
 const x86 = @import("x86.zig");
 
 // PIC ports.
@@ -16,15 +17,15 @@ const ICW4_8086 = 0x01;
 // Default interrupt handler.
 //
 fn unhandled() {
-    @panic("unhandled interrupt");
+    const n = isr.context.interrupt_n;
+    tty.panic("unhandled interrupt number {d}", n);
 }
 
 // Registered interrupt handlers.
 export var interrupt_handlers = []fn() { unhandled } ** 48;
 
 ////
-// Register an interrupt handler.
-//
+// Register an interrupt handler. //
 // Arguments:
 //     n: Index of the interrupt.
 //     handler: Interrupt handler.

kernel/isr.s

@@ -11,12 +11,13 @@
         push $\n  // Push the interrupt number.
         pusha     // Save the registers state.
 
-        // Keep a pointer to the saved context.
-        mov %esp, context
+        mov %esp, context  // Save context pointer.
 
         // Call the designed interrupt handler.
         call *(interrupt_handlers + (\n * 4))
 
+        mov context, %esp  // Restore context pointer (potentially different).
+
         // Only for IRQs: send "End Of Interrupt" signal.
         .if (\n >= 32 && \n < 48)
             mov $0x20, %al

kernel/isr.zig

@@ -32,11 +32,6 @@ pub const Context = packed struct {
 // Pointer to the current saved context.
 export var context: &volatile Context = undefined;
 
-////
-// Return a pointer to the current saved context.
-//
-pub inline fn getContext() -> &volatile Context { context }
-
 ////
 // Install the Interrupt Service Routines in the IDT.
 //

kernel/kmain.zig

@@ -1,8 +1,8 @@
 use @import("multiboot.zig");
-const allocator = @import("allocator.zig");
 const gdt = @import("gdt.zig");
 const idt = @import("idt.zig");
 const scheduler = @import("scheduler.zig");
+const mem = @import("mem.zig");
 const pmem = @import("pmem.zig");
 const vmem = @import("vmem.zig");
 const timer = @import("timer.zig");
@@ -47,7 +47,7 @@ export fn kmain(magic: u32, info: &const MultibootInfo) -> noreturn {
     idt.initialize();
     pmem.initialize(info);
     vmem.initialize();
-    allocator.initialize(pmem.stack_end, 0x100000);
+    mem.initialize(pmem.stack_end, 0x100000);
     timer.initialize(50);
     scheduler.initialize();
 

kernel/list.zig

@@ -0,0 +1,251 @@
+const mem = @import("std").mem;
+
+// Node inside the linked list wrapping the actual data.
+fn Node(comptime T: type) -> type {
+    struct {
+        const Self = this;
+
+        prev: ?&Self,
+        next: ?&Self,
+        data: T,
+    }
+}
+
+// Generic doubly linked list.
+pub fn List(comptime T: type) -> type {
+    struct {
+        const Self = this;
+
+        first: ?&Node(T),
+        last:  ?&Node(T),
+        len:   usize,
+        allocator: &mem.Allocator,
+
+        ////
+        // Initialize a linked list.
+        //
+        // Arguments:
+        //     allocator: Dynamic memory allocator.
+        //
+        // Returns:
+        //     An empty linked list.
+        //
+        pub fn init(allocator: &mem.Allocator) -> Self {
+            Self {
+                .first = null,
+                .last  = null,
+                .len   = 0,
+                .allocator = allocator,
+            }
+        }
+
+        ////
+        // Insert a new node after an existing one.
+        //
+        // Arguments:
+        //     node: Pointer to a node in the list.
+        //     new_node: Pointer to the new node to insert.
+        //
+        pub fn insert(self: &Self, node: &Node(T), new_node: &Node(T)) {
+            new_node.prev = node;
+            if (node.next == null) {
+                // Last element of the list.
+                new_node.next = null;
+                self.last = new_node;
+            } else {
+                // Intermediate node.
+                new_node.next = node.next;
+                (??node.next).prev = new_node;
+            }
+            node.next = new_node;
+
+            self.len += 1;
+        }
+
+        ////
+        // Insert a new node before an existing one.
+        //
+        // Arguments:
+        //     node: Pointer to a node in the list.
+        //     new_node: Pointer to the new node to insert.
+        //
+        pub fn insertBefore(self: &Self, node: &Node(T), new_node: &Node(T)) {
+            new_node.next = node;
+            if (node.prev == null) {
+                // First element of the list.
+                new_node.prev = null;
+                self.first = new_node;
+            } else {
+                // Intermediate node.
+                new_node.prev = node.prev;
+                (??node.prev).next = new_node;
+            }
+            node.prev = new_node;
+
+            self.len += 1;
+        }
+
+        ////
+        // Insert a new node at the end of the list.
+        //
+        // Arguments:
+        //     new_node: Pointer to the new node to insert.
+        //
+        pub fn append(self: &Self, new_node: &Node(T)) {
+            if (self.last == null) {
+                // Empty list.
+                self.prepend(new_node);
+            } else {
+                // Insert after last.
+                self.insert(??self.last, new_node);
+            }
+        }
+
+        ////
+        // Insert a new node at the beginning of the list.
+        //
+        // Arguments:
+        //     new_node: Pointer to the new node to insert.
+        //
+        pub fn prepend(self: &Self, new_node: &Node(T)) {
+            if (self.first != null) {
+                // Insert before first.
+                self.insert(??self.first, new_node);
+            } else {
+                // Empty list.
+                self.first = new_node;
+                self.last  = new_node;
+                new_node.prev = null;
+                new_node.next = null;
+
+                self.len = 1;
+            }
+        }
+
+        ////
+        // Remove a node from the list.
+        //
+        // Arguments:
+        //     node: Pointer to the node to be removed.
+        //
+        pub fn remove(self: &Self, node: &Node(T)) {
+            if (node.prev == null) {
+                // First element of the list.
+                self.first = node.next;
+            } else {
+                (??node.prev).next = node.next;
+            }
+
+            if (node.next == null) {
+                // Last element of the list.
+                self.last = node.prev;
+            } else {
+                (??node.next).prev = node.prev;
+            }
+
+            self.len -= 1;
+        }
+
+        ////
+        // Remove and return the last node in the list.
+        //
+        // Returns:
+        //     A pointer to the last node in the list.
+        //
+        pub fn pop(self: &Self) -> ?&Node(T) {
+            const last = self.last ?? return null;
+            self.remove(last);
+            return last;
+        }
+
+        ////
+        // Remove and return the first node in the list.
+        //
+        // Returns:
+        //     A pointer to the first node in the list.
+        //
+        pub fn popFirst(self: &Self) -> ?&Node(T) {
+            const first = self.first ?? return null;
+            self.remove(first);
+            return first;
+        }
+
+        ////
+        // Allocate a new node.
+        //
+        // Returns:
+        //     A pointer to the new node.
+        //
+        pub fn createNode(self: &Self) -> ?&Node(T) {
+            self.allocator.create(Node(T))
+        }
+
+        ////
+        // Deallocate a node.
+        //
+        // Arguments:
+        //     node: Pointer to the node to deallocate.
+        //
+        pub fn destroyNode(self: &Self, node: &Node(T)) {
+            self.allocator.destroy(node);
+        }
+
+        ////
+        // Allocate and initialize a node and its data.
+        //
+        // Arguments:
+        //     data: The data to put inside the node.
+        //
+        // Returns:
+        //     A pointer to the new node.
+        //
+        pub fn initNode(self: &Self, data: T) -> %&Node(T) {
+            var node = %return self.createNode();
+            node.data = data;
+            return node;
+        }
+
+        ////
+        // Iterate through the elements of the list.
+        //
+        // Returns:
+        //     A list iterator with a next() method.
+        //
+        pub fn iterate(self: &Self) -> ListIterator(T, false) {
+            ListIterator(T, false) {
+                .node = self.first,
+            }
+        }
+
+        ////
+        // Iterate through the elements of the list backwards.
+        //
+        // Returns:
+        //     A list iterator with a next() method.
+        //
+        pub fn iterateBackwards(self: &Self) -> ListIterator(T, true) {
+            ListIterator(T, true) {
+                .node = self.last,
+            }
+        }
+    }
+}
+
+// Abstract iteration over a linked list.
+fn ListIterator(comptime T: type, comptime backwards: bool) -> type {
+    struct {
+        const Self = this;
+
+        node: ?&Node(T),
+
+        ////
+        // Return the next element of the list, until the end.
+        // When no more elements are available, return null.
+        //
+        pub fn next(self: &Self) -> ?&Node(T) {
+            const current = self.node ?? return null;
+            self.node = if (backwards) current.prev else current.next;
+            return current;
+        }
+    }
+}

kernel/allocator.zig renamed to kernel/mem.zig

@@ -30,7 +30,7 @@ fn realloc(self: &mem.Allocator, old_mem: []u8, new_size: usize) -> %[]u8 {
 fn free(self: &mem.Allocator, old_mem: []u8) {}
 
 pub fn initialize(address: usize, capacity: usize) {
-    tty.step("Initializing the Kernel Allocator");
+    tty.step("Initializing Dynamic Memory Allocation");
 
     bytes = @intToPtr(&u8, address)[0...capacity];
 

kernel/process.zig

@@ -0,0 +1,7 @@
+const Thread = @import("thread.zig").Thread;
+const List = @import("std").list.List;
+
+pub const Process = struct {
+    pid: u16,
+    threads: List(Thread),
+};

kernel/scheduler.zig

@@ -1,16 +1,19 @@
+const mem = @import("mem.zig");
 const timer = @import("timer.zig");
 const tty = @import("tty.zig");
-const x86 = @import("x86.zig");
+const Thread = @import("thread.zig").Thread;
+const List = @import("list.zig").List;
 
-fn schedule() {
-    tty.printf("\nScheduler running.");
+var ready_queue: List(Thread) = undefined;
 
-    x86.hang();
+fn schedule() {
+    tty.printf("\nSchedule!");
 }
 
 pub fn initialize() {
     tty.step("Initializing the Scheduler");
 
+    ready_queue = List(Thread).init(&mem.allocator);
     timer.registerHandler(schedule);
 
     tty.stepOK();

kernel/thread.zig

@@ -0,0 +1,12 @@
+const Context = @import("isr.zig").Context;
+
+pub const Thread = struct {
+    context: Context,
+
+    tid: u16,
+    local_tid: u8,
+};
+
+pub fn create(entry_point: usize) {
+
+}

kernel/vmem.zig

@@ -85,7 +85,7 @@ fn pageFault() {
     // Get the faulting address from the CR2 register.
     const address = x86.readCR2();
     // Get the error code from the interrupt stack.
-    const code = isr.getContext().error_code;
+    const code = isr.context.error_code;
 
     const err       = if (code & PAGE_PRESENT != 0) "protection" else "non-present";
     const operation = if (code & PAGE_WRITE   != 0) "write"      else "read";