sylveos

thread.zig (3372B)

---

 const std = @import("std");
 
 const interrupts = @import("./interrupts.zig");
 const switching = @import("./switching.zig");
 const PSR = @import("./psr.zig").PSR;
 const mem = @import("./mem.zig");
 
 var tid_counter: usize = 1;
 var ready: bool = false;
 var threads: std.DoublyLinkedList = .{};
 var scheduler_thread: *Thread = undefined;
 var allocator: std.mem.Allocator = undefined;
 
 pub const Thread = struct {
     tid: usize,
     node: std.DoublyLinkedList.Node,
 
     // Store them all
     registers: interrupts.Registers,
     stack: [1024]usize align(8),
 };
 
 pub fn init(alloc: std.mem.Allocator) !void {
     allocator = alloc;
 }
 
 pub fn destroy() void {
     var thread_node = threads.first;
 
     while (thread_node) |n| {
         thread_node = n.next;
         allocator.destroy(get_current());
     }
 }
 
 pub fn fork(f: *const fn (?*anyopaque) callconv(.c) void, arg: ?*anyopaque) !void {
     var thread = try allocator.create(Thread);
 
     thread.tid = tid_counter;
     tid_counter += 1;
 
     const stack_top = @intFromPtr(&thread.stack) + thread.stack.len;
     var registers: interrupts.Registers = .{
         .gp = .{0} ** 13,
         .sp = stack_top,
         // trampoline will handle exit (hopefully)
         .lr = 0,
         .pc = @intFromPtr(&thread_trampoline),
         .psr = PSR.get_c(),
     };
 
     registers.gp[0] = @intFromPtr(f);
     if (arg) |a| {
         registers.gp[1] = @intFromPtr(a);
     }
 
     thread.registers = registers;
 
     threads.append(&thread.node);
 }
 
 fn get_current() *Thread {
     return @alignCast(@fieldParentPtr("node", threads.first.?));
 }
 
 pub fn join() !void {
     if (threads.first == null) {
         // Nothing to do
         return;
     }
 
     var thread = try allocator.create(Thread);
     thread.tid = 0;
 
     scheduler_thread = thread;
 
     @import("devices/mini-uart.zig").print("switching to PC=0x{X}\n", .{get_current().registers.pc});
 
     switching.switch_state(&thread.registers, &get_current().registers);
 
     ready = false;
 }
 
 // Comes in from exception
 pub fn preempt(regs: *const interrupts.Registers) void {
     // Haven't joined yet
     if (!ready) return;
 
     // Single task
     if (threads.first == threads.last) {
         return;
     }
 
     if (threads.first == null) {
         ready = false;
 
         return;
     }
 
     const node_task = threads.popFirst().?;
     threads.append(node_task);
 
     const current: *Thread = @alignCast(@fieldParentPtr("node", node_task));
     current.registers = regs.*;
 
     // Switch to new thread
     switching.restore_state(&get_current().registers);
 }
 
 pub fn get_tid() usize {
     return get_current().tid;
 }
 
 pub fn is_ready() bool {
     return ready;
 }
 
 fn thread_trampoline(func: *const fn (?*anyopaque) callconv(.c) void, arg: ?*anyopaque) callconv(.c) noreturn {
     // Won't release as next's CPSR will already reenable
     // _ = mem.enter_critical_section();
     @import("devices/mini-uart.zig").print("in trampoline, running PC=0x{X}\n", .{@intFromPtr(func)});
 
     ready = true;
 
     func(arg);
 
     const current: *Thread = @alignCast(@fieldParentPtr("node", threads.popFirst().?));
     allocator.destroy(current);
 
     if (threads.first) |node_task| {
         const next: *Thread = @alignCast(@fieldParentPtr("node", node_task));
         switching.restore_state(&next.registers);
     } else {
         switching.restore_state(&scheduler_thread.registers);
     }
 }