1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
// tiny preemptive round robin scheduler. a task is a saved frame + cr3 + kernel
// stack, task 0 is the kernel event loop. the pit tick swaps the interrupted
// frame for the next ready tasks and iretqs in, which covers ring 0 and ring 3
// alike. each task has its own kernel stack so preempting one mid syscall (e.g. a
// read() parked on sti/hlt) doesnt clobber anothers rsp0
const std = @import("std");
const Frame = @import("regs.zig").Frame;
const vmm = @import("vmm.zig");
const gdt = @import("gdt.zig");
const bridge = @import("bridge");
const MAX_TASKS = 8;
const KSTACK_SIZE = 16 * 1024;
const State = enum { free, ready, dead, blocked };
const Task = struct {
frame: Frame = std.mem.zeroes(Frame),
cr3: u64 = 0,
kstack_top: u64 = 0, // tss rsp0 for this task, 0 for the ring 0 kernel task
state: State = .free,
};
var tasks: [MAX_TASKS]Task = @splat(.{});
var kstacks: [MAX_TASKS][KSTACK_SIZE]u8 align(16) = undefined;
var current: usize = 0;
var spawn_count: u64 = 0;
var blocked_reader: ?usize = null;
var foreground: ?usize = null;
var stdin_buf: [64]u8 = undefined;
var stdin_head: usize = 0;
var stdin_tail: usize = 0;
fn stdinPush(byte: u8) void {
if (stdin_tail -% stdin_head >= stdin_buf.len) return;
stdin_buf[stdin_tail % stdin_buf.len] = byte;
stdin_tail +%= 1;
}
fn stdinPop() ?u8 {
if (stdin_head == stdin_tail) return null;
const byte = stdin_buf[stdin_head % stdin_buf.len];
stdin_head +%= 1;
return byte;
}
// task 0 = the kernel/event loop, running in whatever cr3 boot set up
pub fn init(kernel_cr3: u64) void {
tasks[0] = .{ .cr3 = kernel_cr3, .state = .ready, .kstack_top = 0 };
current = 0;
}
pub fn spawn(cr3: u64, entry: u64, ustack: u64) void {
var i: usize = 1;
while (i < MAX_TASKS) : (i += 1) {
if (tasks[i].state != .free) continue;
var f = std.mem.zeroes(Frame);
f.rip = entry;
f.cs = 0x1b; // user code (0x18) | rpl 3
f.rflags = 0x202; // reserved bit + if=1, so its preemptible
f.rsp = ustack;
f.ss = 0x23; // user data (0x20) | rpl 3
f.rdi = spawn_count;
spawn_count += 1;
tasks[i] = .{
.frame = f,
.cr3 = cr3,
.kstack_top = @intFromPtr(&kstacks[i]) + KSTACK_SIZE,
.state = .ready,
};
return;
}
}
pub fn procCount() u64 {
var count: u64 = 0;
var i: usize = 1;
while (i < MAX_TASKS) : (i += 1) {
if (tasks[i].state == .ready or tasks[i].state == .blocked) count += 1;
}
return count;
}
var proc_exited_flag: bool = false;
// mark the running process dead. it then sti+hlts
pub fn exitCurrent() void {
if (current != 0) {
tasks[current].state = .dead;
proc_exited_flag = true; // the kernel task reprints the prompt on seeing this
if (foreground == current) { // hand keyboard back to the shell
foreground = null;
stdin_head = 0;
stdin_tail = 0;
}
}
}
pub fn takeProcExited() bool {
const e = proc_exited_flag;
proc_exited_flag = false;
return e;
}
pub fn readReady() ?u8 {
foreground = current;
return stdinPop();
}
pub fn blockCurrentOnRead(resume_frame: Frame) void {
if (current == 0) return; // the kernel task never blocks like this
tasks[current].frame = resume_frame;
tasks[current].state = .blocked;
blocked_reader = current;
}
pub fn deliverInput(byte: u8) bool {
if (blocked_reader) |task| {
tasks[task].frame.rax = byte; // read()s return value
tasks[task].state = .ready;
blocked_reader = null;
return true;
}
if (foreground != null) {
stdinPush(byte);
return true;
}
return false;
}
pub fn tick(frame: *Frame) void {
if (bridge.vmBusy()) return;
if (tasks[current].state == .dead) {
tasks[current].state = .free; // reclaim, dont bother saving its context
} else if (tasks[current].state == .blocked) {
// keep the resume frame saved by blockcurrentonread, dont clobber it you bitch
} else {
tasks[current].frame = frame.*; // freeze the current task
}
var next = current;
var i = current;
var n: usize = 0;
while (n < MAX_TASKS) : (n += 1) {
i = (i + 1) % MAX_TASKS;
if (tasks[i].state == .ready) {
next = i;
break;
}
}
if (tasks[current].state != .ready and next == current) next = 0;
if (next == current) return;
current = next;
frame.* = tasks[current].frame;
vmm.loadPml4(tasks[current].cr3);
if (tasks[current].kstack_top != 0) gdt.setKernelStack(tasks[current].kstack_top);
}
|
