comparing 275adef51141aa757daae7799c69ed00d88294e4 and dev on pci.express/frostium

+2 -1

assets/limine.conf

···

       2
       2
        
       //AMD64 Kernel

     

       3
       3
        
         protocol: limine

     

       4
       4
        
         path: boot():/kernel-amd64.elf

     

       5
       5
       -
         module_path: boot():/init-amd64.elf

     

       5
       5
       +
         module_path: boot():/root-69.elf

     

       6
       6
       +
         module_path: boot():/root-420.elf

     

       6
       7
        
       //aarch64 Kernel

     

       7
       8
        
         protocol: limine

     

       8
       9
        
         path: boot():/kernel-aarch64.elf

+12 -5

build.zig

···

       11
       11
        
           const ukernel_inst = b.addInstallFile(ukernel_artifact.getEmittedBin(), arch.kernelExeName());

     

       12
       12
        
           b.getInstallStep().dependOn(&ukernel_inst.step);

     

       13
       13
        
       

     

       14
       14
       -
           const root_dep = b.dependency("root_server", .{

     

       14
       14
       +
           const root_69 = b.dependency("root_server", .{

     

       15
       15
       +
               .arch = arch,

     

       16
       16
       +
               .number = 0x69,

     

       17
       17
       +
           }).artifact("root_server");

     

       18
       18
       +
           const root_69_inst = b.addInstallFile(root_69.getEmittedBin(), "root-69.elf");

     

       19
       19
       +
           b.getInstallStep().dependOn(&root_69_inst.step);

     

       20
       20
       +
       

     

       21
       21
       +
           const root_420 = b.dependency("root_server", .{

     

       15
       22
        
               .arch = arch,

     

       16
       16
       -
           });

     

       17
       17
       -
           const root_artifact = root_dep.artifact("root_server");

     

       18
       18
       -
           const root_inst = b.addInstallFile(root_artifact.getEmittedBin(), arch.rootTaskName());

     

       19
       19
       -
           b.getInstallStep().dependOn(&root_inst.step);

     

       23
       23
       +
               .number = 0x420,

     

       24
       24
       +
           }).artifact("root_server");

     

       25
       25
       +
           const root_420_inst = b.addInstallFile(root_420.getEmittedBin(), "root-420.elf");

     

       26
       26
       +
           b.getInstallStep().dependOn(&root_420_inst.step);

     

       20
       27
        
       

     

       21
       28
        
           // Run in QEMU

     

       22
       29
        
           run_blk: {

+3 -4

build.zig.zon

···

       14
       14
        
                   .path = "components/build_helpers",

     

       15
       15
        
               },

     

       16
       16
        
               .limine_binary = .{

     

       17
       17
       -
                   .url = "git+https://codeberg.org/Limine/Limine?ref=v9.x-binary#acf1e35c4685dba7ef271013db375a727c340ff7",

     

       18
       18
       -
                   .hash = "N-V-__8AAOkzSACT_9p6kmSSly1l008erzXuG39Z6r54B_y0",

     

       19
       19
       -
                   // Codeberg is always down so better to leave it not lazy

     

       20
       20
       -
                   // .lazy = true,

     

       17
       17
       +
                   .url = "git+https://codeberg.org/Limine/Limine?ref=v10.x-binary#648e33afd153bdbf780ba123e45997428796395d",

     

       18
       18
       +
                   .hash = "N-V-__8AAJ8bSADxAGaebgaAbkAR2kqOBy52rXAL0oCumn0t",

     

       19
       19
       +
                   .lazy = true,

     

       21
       20
        
               },

     

       22
       21
        
               .edk2_binary = .{

     

       23
       22
        
                   .url = "git+https://github.com/retrage/edk2-nightly#23068f498687bf64f2b8f80fbcf11e82d987fd9b",

components/root_server/build.zig

···

       3
       3
        
       

     

       4
       4
        
       pub fn build(b: *std.Build) void {

     

       5
       5
        
           const arch = b.option(build_helpers.Architecture, "arch", "The target root_server architecture") orelse .amd64;

     

       6
       6
       +
           const number = b.option(usize, "number", "The syscall number to use") orelse 0x69;

     

       6
       7
        
       

     

       7
       8
        
           // set CPU features based on the architecture

     

       8
       9
        
           const target = b.resolveTargetQuery(.{

     
···

       20
       21
        
       

     

       21
       22
        
           const config = b.addOptions();

     

       22
       23
        
           config.addOption(build_helpers.Architecture, "arch", arch);

     

       24
       24
       +
           config.addOption(usize, "number", number);

     

       23
       25
        
       

     

       24
       26
        
           const build_helpers_dep = b.dependency("build_helpers", .{});

     

       25
       27

+6 -2

components/root_server/src/main.zig

···

       1
       1
        
       const std = @import("std");

     

       2
       2
        
       const os = @import("os.zig");

     

       3
       3
       +
       const config = @import("config");

     

       3
       4
        
       

     

       4
       5
        
       export fn _start() callconv(.c) noreturn {

     

       5
       6
        
           _ = os.syscall1(SYS_poke, 0xB16B00B5BADBABE);

     

       6
       7
        
           _ = os.syscall1(SYS_exit, 0x69696969);

     

       7
       8
        
           asm volatile ("int3");

     

       8
       9
        
           asm volatile (

     

       9
       9
       -
               \\ mov $0x69696969, %%rdi

     

       10
       10
       +
               \\ mov %[number], %%rdi

     

       10
       11
        
               \\ xor %%rsi, %%rsi

     

       11
       12
        
               \\ xor %%rbx, %%rbx

     

       12
       13
        
               \\ mainloop:

     

       13
       14
        
               \\ xor %%rax, %%rax

     

       14
       15
        
               \\ delayloop:

     

       15
       16
        
               \\ inc %%rax

     

       16
       16
       -
               \\ cmp $0x4000000, %%rax

     

       17
       17
       +
               \\ cmp $0x1000000, %%rax

     

       17
       18
        
               \\ jnz delayloop

     

       18
       19
        
               \\ inc %%rbx

     

       20
       20
       +
               \\ mov %%rsp, %%rsi

     

       19
       21
        
               \\ syscall

     

       20
       22
        
               \\ jmp mainloop

     

       23
       23
       +
               :

     

       24
       24
       +
               : [number] "r" (config.number),

     

       21
       25
        
           );

     

       22
       26
        
       

     

       23
       27
        
           die();

+1 -1

components/ukernel/arch/aarch64/boot.zig

···

       67
       67
        
                   const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       68
       68
        
                   const mod_size = mod.size;

     

       69
       69
        
                   log.info("Loading root task with {s} @ {*}", .{ mod.path, mod.address });

     

       70
       70
       -
                   common.init_data.root_task = mod_addr[0..mod_size];

     

       70
       70
       +
                   common.init_data.root_task_elf = mod_addr[0..mod_size];

     

       71
       71
        
               }

     

       72
       72
        
           } else {

     

       73
       73
        
               @branchHint(.unlikely);

+61 -183

components/ukernel/arch/amd64/boot.zig

···

       7
       7
        
       const StandardGdt = arch.structures.gdt.StandardGdt;

     

       8
       8
        
       const Tss = arch.structures.tss.Tss;

     

       9
       9
        
       

     

       10
       10
       -
       var pg_ctx: arch.mm.paging.Context = undefined;

     

       11
       11
       -
       

     

       12
       10
        
       pub const limine_requests = struct {

     

       13
       11
        
           export var start_marker: limine.RequestsStartMarker linksection(".limine_reqs_start") = .{};

     

       14
       12
        
           export var end_marker: limine.RequestsEndMarker linksection(".limine_reqs_end") = .{};

     
···

       23
       21
        
           pub export var mp: limine.SmpMpFeature.MpRequest linksection(".limine_reqs") = .{ .flags = .{ .x2apic = true } };

     

       24
       22
        
       };

     

       25
       23
        
       

     

       26
       26
       -
       pub fn bsp_init() callconv(.c) noreturn {

     

       24
       24
       +
       pub fn early_init() void {

     

       27
       25
        
           // Don't optimize away the limine requests

     

       28
       26
        
           inline for (@typeInfo(limine_requests).@"struct".decls) |decl| {

     

       29
       27
        
               std.mem.doNotOptimizeAway(&@field(limine_requests, decl.name));

     
···

       35
       33
        
               arch.instructions.die();

     

       36
       34
        
           }

     

       37
       35
        
       

     

       36
       36
       +
           // If the base revision isn't supported, we can't boot

     

       37
       37
       +
           if (!limine_requests.base_revision.isSupported()) {

     

       38
       38
       +
               @branchHint(.cold);

     

       39
       39
       +
               arch.instructions.die();

     

       40
       40
       +
           }

     

       41
       41
       +
       

     

       38
       42
        
           // Die if we don't have a memory map or Higher Half Direct Mapping

     

       39
       43
        
           if (limine_requests.memmap.response == null) {

     

       40
       44
        
               @branchHint(.cold);

     
···

       48
       52
        
           const hhdm_offset = limine_requests.hhdm.response.?.offset;

     

       49
       53
        
           common.init_data.hhdm_slide = hhdm_offset;

     

       50
       54
        
       

     

       51
       51
       -
           // Set up the temporary Physical Memory Allocator

     

       52
       52
       -
           common.mm.bootmem.init();

     

       55
       55
       +
           // Get CPUID info

     

       56
       56
       +
           arch.instructions.cpuid.init();

     

       57
       57
       +
       

     

       58
       58
       +
           // Set up the kernel paging context

     

       59
       59
       +
           common.init_data.kernel_paging_ctx = arch.mm.paging.Context.get_current();

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       pub fn bsp_init() void {

     

       63
       63
       +
           // Set up per-cpu data

     

       64
       64
       +
           arch.per_cpu_init_data.init(limine_requests.mp.response.?.cpu_count);

     

       65
       65
       +
       

     

       66
       66
       +
           // Set up our own GDT and TSS

     

       67
       67
       +
           const gdt = &arch.per_cpu_init_data.gdt_buf[0];

     

       68
       68
       +
           gdt.* = .{};

     

       69
       69
       +
           const tss = &arch.per_cpu_init_data.tss_buf[0];

     

       70
       70
       +
           // TODO: create a fixed mapping for the pages maybe?

     

       71
       71
       +
           tss.* = .{

     

       72
       72
       +
               .rsp0 = common.init_data.hhdm_slide + arch.per_cpu_init_data.getStackPhys(0),

     

       73
       73
       +
           };

     

       53
       74
        
       

     

       54
       54
       -
           // Add in a framebuffer if found

     

       55
       55
       -
           initConsole();

     

       75
       75
       +
           gdt.tss_desc.set_tss_addr(tss);

     

       76
       76
       +
           gdt.load();

     

       56
       77
        
       

     

       57
       57
       -
           // Get basic information through CPUID

     

       58
       58
       -
           arch.instructions.cpuid.init();

     

       78
       78
       +
           // Add in the framebuffer

     

       79
       79
       +
           if (limine_requests.framebuffer.response) |fb_response| {

     

       80
       80
       +
               if (fb_response.framebuffer_count > 0) {

     

       81
       81
       +
                   const fb = fb_response.getFramebuffers()[0];

     

       82
       82
       +
                   common.init_data.framebuffer = .{

     

       83
       83
       +
                       .address = @ptrCast(@alignCast(fb.address)),

     

       84
       84
       +
                       .width = fb.width,

     

       85
       85
       +
                       .height = fb.height,

     

       86
       86
       +
                       .pitch = fb.pitch,

     

       87
       87
       +
                       .red_mask_size = fb.red_mask_size,

     

       88
       88
       +
                       .red_mask_shift = fb.red_mask_shift,

     

       89
       89
       +
                       .green_mask_size = fb.green_mask_size,

     

       90
       90
       +
                       .green_mask_shift = fb.green_mask_shift,

     

       91
       91
       +
                       .blue_mask_size = fb.blue_mask_size,

     

       92
       92
       +
                       .blue_mask_shift = fb.blue_mask_shift,

     

       93
       93
       +
                       .bypp = fb.bpp / 8,

     

       94
       94
       +
                   };

     

       95
       95
       +
               }

     

       96
       96
       +
           }

     

       59
       97
        
       

     

       60
       98
        
           // Add in ACPI/dtb if found, prefer ACPI

     

       61
       99
        
           initHwDesc();

     
···

       67
       105
        
                   const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       68
       106
        
                   const mod_size = mod.size;

     

       69
       107
        
                   log.info("Loading root task with {s} @ {*}", .{ mod.path, mod.address });

     

       70
       70
       -
                   common.init_data.root_task = mod_addr[0..mod_size];

     

       108
       108
       +
                   common.init_data.root_task_elf = mod_addr[0..mod_size];

     

       71
       109
        
               }

     

       72
       110
        
           } else {

     

       73
       111
        
               @branchHint(.unlikely);

     

       74
       112
        
               @panic("No root task found!");

     

       75
       113
        
           }

     

       76
       114
        
       

     

       77
       77
       -
           // Initialize per-cpu data (GDT and TSS)

     

       78
       78
       -
           arch.per_cpu_init_data.init(limine_requests.mp.response.?.cpu_count);

     

       79
       79
       -
       

     

       80
       80
       -
           // Install the IDT

     

       81
       81
       -
           arch.interrupts.idt.init();

     

       82
       82
       -
       

     

       83
       83
       -
           // Set up our own GDT and TSS

     

       84
       84
       -
           const gdt = &arch.per_cpu_init_data.gdt_buf[0];

     

       85
       85
       -
           gdt.* = .{};

     

       86
       86
       -
           const tss = &arch.per_cpu_init_data.tss_buf[0];

     

       87
       87
       -
           // TSS rsp 0x3800

     

       88
       88
       -
           tss.* = .{

     

       89
       89
       -
               .rsp0 = 0x7ffe_0000_8000,

     

       90
       90
       -
               .rsp1 = 0x7ffe_0000_8000,

     

       91
       91
       -
               .rsp2 = 0x7ffe_0000_8000,

     

       92
       92
       -
           };

     

       93
       93
       -
       

     

       94
       94
       -
           gdt.tss_desc.set_tss_addr(tss);

     

       95
       95
       -
           gdt.load();

     

       96
       96
       -
           log.info("BSP successfully setup GDT+TSS!", .{});

     

       97
       97
       -
       

     

       98
       98
       -
           // AP bootstrap

     

       99
       115
        
           bootstrapAPs();

     

       100
       100
       -
       

     

       101
       101
       -
           // Calibrate our TSC

     

       102
       102
       -
           arch.tsc.calibrate_pit() catch {

     

       103
       103
       -
               log.info("Failed to calibrate with PIT!", .{});

     

       104
       104
       -
               arch.instructions.die();

     

       105
       105
       -
           };

     

       106
       106
       -
           log.info("TSC estimate: {} MHz", .{arch.tsc.tsc_khz / 1000});

     

       107
       107
       -
       

     

       108
       108
       -
           log.info("Setting up scheduling...", .{});

     

       109
       109
       -
       

     

       110
       110
       -
           pg_ctx = arch.mm.paging.Context.get_current();

     

       111
       111
       -
       

     

       112
       112
       -
           initApic() catch |err| {

     

       113
       113
       -
               log.err("Failed to set up APIC! {}", .{err});

     

       114
       114
       -
               @panic("apic");

     

       115
       115
       -
           };

     

       116
       116
       -
       

     

       117
       117
       -
           log.info("Allocating code for userspace...", .{});

     

       118
       118
       -
       

     

       119
       119
       -
           // Allocate a stack (0x3000 - 0x4000)

     

       120
       120
       -
           common.mm.paging.map(.{

     

       121
       121
       -
               .vaddr = 0x7ffe_0000_0000,

     

       122
       122
       -
               .size = 65536,

     

       123
       123
       -
               .memory_type = .MemoryWriteBack,

     

       124
       124
       -
               .perms = .{

     

       125
       125
       -
                   .x = false,

     

       126
       126
       -
                   .u = true,

     

       127
       127
       -
                   .w = true,

     

       128
       128
       -
               },

     

       129
       129
       -
               .context = &pg_ctx,

     

       130
       130
       -
           }) catch @panic("couldn't map user stack");

     

       131
       131
       -
       

     

       132
       132
       -
           const entry = common.loadRootTask(&pg_ctx) catch |err| {

     

       133
       133
       -
               log.err("Couldn't load the root task! {}", .{err});

     

       134
       134
       -
               @panic("ggz");

     

       135
       135
       -
           };

     

       136
       136
       -
           log.info("Dropping to userspace entry 0x{x:0>16}", .{entry});

     

       137
       137
       -
       

     

       138
       138
       -
           init_syscalls();

     

       139
       139
       -
       

     

       140
       140
       -
           arch.interrupts.apic.armTimer(1000);

     

       141
       141
       -
           enter_userspace(entry, 0x69, 0x7ffe_0001_0000);

     

       142
       116
        
       }

     

       143
       117
        
       

     

       144
       144
       -
       // Get ready for system calls (set MSRs)

     

       145
       145
       -
       fn init_syscalls() void {

     

       146
       146
       -
           // Set up the STAR MSR with the segment descriptors

     

       147
       147
       -
           const IA32_STAR = arch.registers.MSR(u64, 0xC0000081);

     

       148
       148
       -
           const star_value: u64 = 0 | @as(u64, arch.structures.gdt.StandardGdt.selectors.kernel_code) << 32 | (@as(u64, arch.structures.gdt.StandardGdt.selectors.tss_desc + 8) | 3) << 48;

     

       149
       149
       -
           IA32_STAR.write(star_value);

     

       150
       150
       -
       

     

       151
       151
       -
           // Set up the EFER MSR with SCE (System Call Enable)

     

       152
       152
       -
           const IA32_EFER = arch.registers.MSR(u64, 0xC0000080);

     

       153
       153
       -
           const efer_val = IA32_EFER.read() | 0b1;

     

       154
       154
       -
           IA32_EFER.write(efer_val);

     

       155
       155
       -
       

     

       156
       156
       -
           // Set up LSTAR with the syscall handler and FMASK to clear interrupts

     

       157
       157
       -
           const IA32_LSTAR = arch.registers.MSR(u64, 0xC0000082);

     

       158
       158
       -
           IA32_LSTAR.write(@intFromPtr(syscall_entry));

     

       159
       159
       -
       

     

       160
       160
       -
           const IA32_FMASK = arch.registers.MSR(u64, 0xC0000084);

     

       161
       161
       -
           IA32_FMASK.write(1 << 9);

     

       162
       162
       -
       }

     

       163
       163
       -
       

     

       164
       164
       -
       const syscall_entry = @extern(*anyopaque, .{

     

       165
       165
       -
           .name = "syscall_entry",

     

       166
       166
       -
       });

     

       167
       167
       -
       export fn syscall_handler(rdi: usize, rsi: usize) callconv(.c) void {

     

       168
       168
       -
           std.log.info("Got a syscall! rdi=0x{x}, rsi=0x{x}", .{ rdi, rsi });

     

       169
       169
       -
       }

     

       170
       170
       -
       

     

       171
       171
       -
       fn enter_userspace(entry: u64, arg: u64, stack: u64) noreturn {

     

       172
       172
       -
           log.info("usercode64 GDT 0x{x}, userdata64 GDT 0x{x}", .{ arch.structures.gdt.StandardGdt.selectors.user_code, arch.structures.gdt.StandardGdt.selectors.user_data });

     

       173
       173
       -
           const cr3 = arch.registers.ControlRegisters.Cr3.read();

     

       174
       174
       -
           arch.registers.ControlRegisters.Cr3.write(cr3);

     

       175
       175
       -
           asm volatile (

     

       176
       176
       -
               \\ push %[userdata64]

     

       177
       177
       -
               \\ push %[stack]

     

       178
       178
       -
               \\ push $0x202

     

       179
       179
       -
               \\ push %[usercode64]

     

       180
       180
       -
               \\ push %[entry]

     

       181
       181
       -
               \\

     

       182
       182
       -
               \\ mov %[userdata64], %%rax

     

       183
       183
       -
               \\ mov %%rax, %%es

     

       184
       184
       -
               \\ mov %%rax, %%ds

     

       185
       185
       -
               \\

     

       186
       186
       -
               \\ xor %%rsi, %%rsi

     

       187
       187
       -
               \\ xor %%rax, %%rax

     

       188
       188
       -
               \\ xor %%rdx, %%rdx

     

       189
       189
       -
               \\ xor %%rcx, %%rcx

     

       190
       190
       -
               \\ xor %%rbp, %%rbp

     

       191
       191
       -
               \\ xor %%rbx, %%rbx

     

       192
       192
       -
               \\

     

       193
       193
       -
               \\ xor %%r8, %%r8

     

       194
       194
       -
               \\ xor %%r9, %%r9

     

       195
       195
       -
               \\ xor %%r10, %%r10

     

       196
       196
       -
               \\ xor %%r11, %%r11

     

       197
       197
       -
               \\ xor %%r12, %%r12

     

       198
       198
       -
               \\ xor %%r13, %%r13

     

       199
       199
       -
               \\ xor %%r14, %%r14

     

       200
       200
       -
               \\ xor %%r15, %%r15

     

       201
       201
       -
               \\

     

       202
       202
       -
               \\ iretq

     

       203
       203
       -
               \\

     

       204
       204
       -
               :

     

       205
       205
       -
               : [arg] "{rdi}" (arg),

     

       206
       206
       -
                 [stack] "r" (stack),

     

       207
       207
       -
                 [entry] "r" (entry),

     

       208
       208
       -
                 [userdata64] "i" (arch.structures.gdt.StandardGdt.selectors.user_data),

     

       209
       209
       -
                 [usercode64] "i" (arch.structures.gdt.StandardGdt.selectors.user_code),

     

       210
       210
       -
           );

     

       211
       211
       -
           unreachable;

     

       212
       212
       -
       }

     

       118
       118
       +
       pub fn loadTasks() void {

     

       119
       119
       +
           const tasks_buf: [*]arch.structures.Task = @ptrFromInt(common.init_data.bootmem.allocMem(std.heap.pageSize()) catch {

     

       120
       120
       +
               std.log.err("Couldn't allocate tasks!", .{});

     

       121
       121
       +
               @panic("allocPhys");

     

       122
       122
       +
           });

     

       123
       123
       +
           const tasks_scratch: []arch.structures.Task = tasks_buf[0 .. std.heap.pageSize() / @sizeOf(arch.structures.Task)];

     

       213
       124
        
       

     

       214
       214
       -
       fn initApic() !void {

     

       215
       215
       -
           const has_x2apic = limine_requests.mp.response.?.flags.x2apic;

     

       216
       216
       -
           arch.interrupts.apic.singleton = switch (has_x2apic) {

     

       217
       217
       -
               true => .x2apic,

     

       218
       218
       -
               false => blk: {

     

       219
       219
       -
                   // Map the APIC first!

     

       220
       220
       -
                   const apic_base = common.mm.physToHHDM([*]volatile u8, 0xFEE0_0000);

     

       221
       221
       -
                   try common.mm.paging.mapPhys(.{

     

       222
       222
       -
                       .vaddr = @intFromPtr(apic_base),

     

       223
       223
       -
                       .paddr = 0xFEE0_0000,

     

       224
       224
       -
                       .size = 0x1000,

     

       225
       225
       -
                       .memory_type = .DeviceUncacheable,

     

       226
       226
       -
                       .perms = .{

     

       227
       227
       -
                           .x = false,

     

       228
       228
       -
                           .u = false,

     

       229
       229
       -
                           .w = true,

     

       230
       230
       -
                       },

     

       231
       231
       -
                       .context = &pg_ctx,

     

       232
       232
       -
                   });

     

       233
       233
       -
                   break :blk .{ .xapic = apic_base };

     

       234
       234
       -
               },

     

       235
       235
       -
           };

     

       236
       236
       -
           // Set up the spurious vector, TPR, and

     

       237
       237
       -
           // calibrate the timer

     

       238
       238
       -
           arch.interrupts.apic.init.initialSetup();

     

       239
       239
       -
       

     

       240
       240
       -
           // Enable one-shot interrupts

     

       241
       241
       -
           arch.interrupts.apic.init.enableOneshotInterrupt();

     

       242
       242
       -
       }

     

       243
       243
       -
       

     

       244
       244
       -
       fn initConsole() void {

     

       245
       245
       -
           if (limine_requests.framebuffer.response) |fb_response| {

     

       246
       246
       -
               if (fb_response.framebuffer_count > 0) {

     

       247
       247
       -
                   const fb = common.aux.fb_from_limine(fb_response.getFramebuffers()[0]);

     

       248
       248
       -
                   common.init_data.framebuffer = fb;

     

       249
       249
       -
                   // Create a canvas for the console to render to

     

       250
       250
       -
                   const canvas: [*]u8 = @ptrFromInt(common.init_data.bootmem.allocMem(fb.width * fb.height * fb.bypp) catch @panic("Couldn't allocate a canvas"));

     

       251
       251
       -
                   @memset(canvas[0 .. fb.width * fb.height * fb.bypp], 0);

     

       252
       252
       -
       

     

       253
       253
       -
                   common.init_data.console = console.Console.init(fb, canvas);

     

       125
       125
       +
           if (limine_requests.modules.response) |module_response| {

     

       126
       126
       +
               if (module_response.module_count > 0) {

     

       127
       127
       +
                   for (module_response.modules.?[0..module_response.module_count], 0..) |mod, i| {

     

       128
       128
       +
                       const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       129
       129
       +
                       const mod_size = mod.size;

     

       130
       130
       +
                       common.loadTask(&tasks_scratch[i], mod_addr[0..mod_size]);

     

       131
       131
       +
                   }

     

       254
       132
        
               }

     

       255
       133
        
           }

     

       256
       134
        
       }

+32 -2

components/ukernel/arch/amd64/instructions/cpuid.zig

···

       21
       21
        
           const res = cpuid(1, 0);

     

       22
       22
        
           const feat_ecx: FeaturesEcx = @bitCast(res.ecx);

     

       23
       23
        
           arch.interrupts.apic.tsc_deadline_available = feat_ecx.tsc_deadline;

     

       24
       24
       +
           arch.interrupts.apic.has_x2apic = feat_ecx.x2apic;

     

       24
       25
        
       }

     

       25
       26
        
       

     

       26
       27
        
       const FeaturesEcx = packed struct(u32) {

     

       27
       27
       -
           _reserved0: u24,

     

       28
       28
       +
           sse3: bool,

     

       29
       29
       +
           pclmulqdq: bool,

     

       30
       30
       +
           dtes64: bool,

     

       31
       31
       +
           monitor: bool,

     

       32
       32
       +
           ds_cpl: bool,

     

       33
       33
       +
           vmx: bool,

     

       34
       34
       +
           smx: bool,

     

       35
       35
       +
           est: bool,

     

       36
       36
       +
           tm2: bool,

     

       37
       37
       +
           ssse3: bool,

     

       38
       38
       +
           cnxt_id: bool,

     

       39
       39
       +
           sdbg: bool,

     

       40
       40
       +
           fma: bool,

     

       41
       41
       +
           cx16: bool,

     

       42
       42
       +
           xtpr: bool,

     

       43
       43
       +
           pdcm: bool,

     

       44
       44
       +
           _reserved0: bool,

     

       45
       45
       +
           pcid: bool,

     

       46
       46
       +
           dca: bool,

     

       47
       47
       +
           sse4_1: bool,

     

       48
       48
       +
           sse4_2: bool,

     

       49
       49
       +
           x2apic: bool,

     

       50
       50
       +
           movbe: bool,

     

       51
       51
       +
           popcnt: bool,

     

       28
       52
        
           tsc_deadline: bool,

     

       29
       29
       -
           _reserved1: u7,

     

       53
       53
       +
           aesni: bool,

     

       54
       54
       +
           xsave: bool,

     

       55
       55
       +
           osxsave: bool,

     

       56
       56
       +
           avx: bool,

     

       57
       57
       +
           f16c: bool,

     

       58
       58
       +
           rdrand: bool,

     

       59
       59
       +
           hypervisor: bool,

     

       30
       60
        
       };

     

       31
       61
        
       

     

       32
       62
        
       pub inline fn cpuid(leaf: u32, sub: u32) DefaultResults {

+57 -11

components/ukernel/arch/amd64/interrupts/apic.zig

···

       1
       1
        
       const std = @import("std");

     

       2
       2
        
       const arch = @import("../root.zig");

     

       3
       3
       +
       const idt = arch.interrupts.idt;

     

       3
       4
        
       const log = std.log.scoped(.apic);

     

       5
       5
       +
       const common = @import("common");

     

       4
       6
        
       

     

       5
       7
        
       pub var lapic_timer_khz: usize = 0;

     

       6
       8
        
       pub var tsc_deadline_available = false;

     

       9
       9
       +
       pub var has_x2apic: bool = false;

     

       7
       10
        
       

     

       8
       11
        
       // tbh every cpu will be either x2apic or not, and if xapic it will

     

       9
       12
        
       // have the exact same base address anyways so this is fine

     
···

       225
       228
        
       };

     

       226
       229
        
       

     

       227
       230
        
       pub const init = struct {

     

       228
       228
       -
           // Get the APIC ready (call first)

     

       229
       231
        
           pub fn initialSetup() void {

     

       232
       232
       +
               // First, make the APIC accessible

     

       233
       233
       +
               initSingleton() catch |err| {

     

       234
       234
       +
                   log.err("Failed to map APIC! {}", .{err});

     

       235
       235
       +
                   @panic("initSingleton");

     

       236
       236
       +
               };

     

       237
       237
       +
               // Set up the interrupt handlers

     

       230
       238
        
               singleton.setSpuriousInterruptRegister(.{

     

       231
       239
        
                   .apic_soft_enable = true,

     

       232
       240
        
                   .idt_entry = 0xFF,

     
···

       235
       243
        
               //     .priority_class = 0,

     

       236
       244
        
               //     .priority_sub_class = 0,

     

       237
       245
        
               // });

     

       238
       238
       -
               arch.interrupts.idt.add_handler(.{ .interrupt = 0xFF }, spurious_interrupt_handler, 3, 0);

     

       239
       239
       -
               arch.interrupts.idt.add_handler(.{ .interrupt = 48 }, periodic_handler, 3, 0);

     

       246
       246
       +
               arch.interrupts.idt.add_handler(.{ .interrupt = 0xFF }, u64, spurious_interrupt_handler, 0, 0);

     

       247
       247
       +
               arch.interrupts.idt.add_handler(.{ .interrupt = 48 }, u64, timer_handler, 0, 0);

     

       240
       248
        
       

     

       249
       249
       +
               // Calibrate against the TSC

     

       241
       250
        
               calibrateTimer();

     

       251
       251
       +
               // Set up the LVT Timer Register

     

       252
       252
       +
               enableOneshotInterrupt();

     

       253
       253
       +
           }

     

       254
       254
       +
       

     

       255
       255
       +
           fn initSingleton() !void {

     

       256
       256
       +
               arch.interrupts.apic.singleton = switch (has_x2apic) {

     

       257
       257
       +
                   true => .x2apic,

     

       258
       258
       +
                   false => blk: {

     

       259
       259
       +
                       // Map the APIC first!

     

       260
       260
       +
                       const apic_base = common.mm.physToHHDM([*]volatile u8, 0xFEE0_0000);

     

       261
       261
       +
                       try common.mm.paging.mapPhys(.{

     

       262
       262
       +
                           .vaddr = @intFromPtr(apic_base),

     

       263
       263
       +
                           .paddr = 0xFEE0_0000,

     

       264
       264
       +
                           .size = 0x1000,

     

       265
       265
       +
                           .memory_type = .DeviceUncacheable,

     

       266
       266
       +
                           .perms = .{

     

       267
       267
       +
                               .x = false,

     

       268
       268
       +
                               .u = false,

     

       269
       269
       +
                               .w = true,

     

       270
       270
       +
                           },

     

       271
       271
       +
                       });

     

       272
       272
       +
                       break :blk .{ .xapic = apic_base };

     

       273
       273
       +
                   },

     

       274
       274
       +
               };

     

       242
       275
        
           }

     

       243
       276
        
       

     

       244
       277
        
           fn calibrateTimer() void {

     
···

       277
       310
        
       

     

       278
       311
        
               lapic_timer_khz = norm / 5;

     

       279
       312
        
       

     

       280
       280
       -
               log.debug("APIC timer: {} kHz", .{lapic_timer_khz});

     

       313
       313
       +
               log.debug("timer: {} kHz", .{lapic_timer_khz});

     

       281
       314
        
           }

     

       282
       315
        
       

     

       283
       283
       -
           pub fn enableOneshotInterrupt() void {

     

       316
       316
       +
           fn enableOneshotInterrupt() void {

     

       284
       317
        
               const mode: LAPIC.LVTTimerRegister.Mode = switch (tsc_deadline_available) {

     

       285
       318
        
                   true => .tsc_deadline,

     

       286
       319
        
                   false => blk: {

     
···

       312
       345
        
           }

     

       313
       346
        
       }

     

       314
       347
        
       

     

       315
       315
       -
       pub fn spurious_interrupt_handler(_: *arch.interrupts.idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       348
       348
       +
       pub fn spurious_interrupt_handler(_: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       316
       349
        
           log.warn("Got a spurious interrupt!", .{});

     

       317
       350
        
       }

     

       318
       351
        
       

     

       319
       319
       -
       pub fn periodic_handler(stack_trace: *arch.interrupts.idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       320
       320
       -
           log.warn("Got an APIC timer interrupt, incrementing user's rsi...", .{});

     

       321
       321
       -
           stack_trace.regs.rsi += 1;

     

       322
       322
       -
           singleton.setRegister(.eoi, 0);

     

       323
       323
       -
           armTimer(1000);

     

       352
       352
       +
       pub fn timer_handler(stack_trace: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       353
       353
       +
           defer {

     

       354
       354
       +
               singleton.setRegister(.eoi, 0);

     

       355
       355
       +
               armTimer(20);

     

       356
       356
       +
           }

     

       357
       357
       +
           // 1. Get the next task. If there is no next task, just keep scheduling.

     

       358
       358
       +
           const task = common.scheduler.getNextTask() orelse return;

     

       359
       359
       +
           // 2. Swap the next task state with the current interrupt trace

     

       360
       360
       +
           std.mem.swap(arch.interrupts.idt.SavedRegisters, &task.regs, &stack_trace.regs);

     

       361
       361
       +
           std.mem.swap(u64, &task.rip, &stack_trace.rip);

     

       362
       362
       +
           std.mem.swap(u64, &task.rsp, &stack_trace.rsp);

     

       363
       363
       +
           // If task has a new cr3, swap current CR3 and task cr3 too

     

       364
       364
       +
           if (task.cr3_val != stack_trace.cr3) {

     

       365
       365
       +
               arch.registers.ControlRegisters.Cr3.write(task.cr3_val);

     

       366
       366
       +
               task.cr3_val = stack_trace.cr3;

     

       367
       367
       +
           }

     

       368
       368
       +
           // 3. Now, `task` has our current state, so enqueue it.

     

       369
       369
       +
           common.scheduler.pushTask(task);

     

       324
       370
        
       }

+15 -11

components/ukernel/arch/amd64/interrupts/idt.zig

···

       12
       12
        
       // handler, which pushes more information then calls the user

     

       13
       13
        
       // defined handler. Use common sense and don't return from an exception

     

       14
       14
        
       // which shouldn't be returned from.

     

       15
       15
       -
       const DefinedHandler = *const fn (*InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void;

     

       16
       16
       -
       pub export var defined_handlers: [entry_count]DefinedHandler = undefined;

     

       15
       15
       +
       pub const CallConv: std.builtin.CallingConvention = .{ .x86_64_sysv = .{} };

     

       16
       16
       +
       pub fn InterruptHandler(comptime E: type) type {

     

       17
       17
       +
           return *const fn (*InterruptFrame(E)) callconv(CallConv) void;

     

       18
       18
       +
       }

     

       19
       19
       +
       pub export var defined_handlers: [entry_count]InterruptHandler(u64) = undefined;

     

       17
       20
        
       

     

       18
       21
        
       // The actual handlers with addresses in the IDT.

     

       19
       22
        
       const ActualHandler = *const fn () callconv(.naked) void;

     
···

       247
       250
        
           r13: u64,

     

       248
       251
        
           r14: u64,

     

       249
       252
        
           r15: u64,

     

       253
       253
       +
       

     

       254
       254
       +
           pub const default = std.mem.zeroes(SavedRegisters);

     

       250
       255
        
       };

     

       251
       256
        
       

     

       252
       257
        
       /// The Interrupt frame which we help generate

     
···

       268
       273
        
               eflags: u64,

     

       269
       274
        
               rsp: u64,

     

       270
       275
        
               ss: u16 align(8),

     

       276
       276
       +
       

     

       277
       277
       +
               pub fn normalize(self: *InterruptFrame(ErrorCode)) *InterruptFrame(u64) {

     

       278
       278
       +
                   return @ptrCast(self);

     

       279
       279
       +
               }

     

       271
       280
        
           };

     

       272
       281
        
       }

     

       273
       282
        
       

     
···

       276
       285
        
           // Set every IDT entry to the corresponding ActualHandler

     

       277
       286
        
           for (0..entry_count) |i| {

     

       278
       287
        
               const actual_handler = @intFromPtr(actual_handlers[i]);

     

       279
       279
       -
               interrupt_descriptor_table[i] = Entry.init(actual_handler, 3, 0);

     

       288
       288
       +
               interrupt_descriptor_table[i] = Entry.init(actual_handler, 0, 0);

     

       280
       289
        
           }

     

       281
       290
        
           // Now, set every defined handler to the default one

     

       282
       291
        
           @memset(&defined_handlers, arch.interrupts.unhandled_interrupt);

     

       283
       292
        
       

     

       284
       293
        
           // Finally, load the idt

     

       285
       294
        
           load();

     

       286
       286
       -
       

     

       287
       287
       -
           add_handler(.{ .exception = .breakpoint }, arch.interrupts.breakpoint, 3, 0);

     

       288
       288
       -
           add_handler(.{ .exception = .double_fault }, arch.interrupts.double_fault, 3, 0);

     

       289
       289
       -
           add_handler(.{ .exception = .general_protection_fault }, arch.interrupts.general_protection_fault, 3, 0);

     

       290
       290
       -
           add_handler(.{ .exception = .page_fault }, arch.mm.paging.page_fault_handler, 3, 0);

     

       291
       295
        
       }

     

       292
       296
        
       

     

       293
       297
        
       pub fn load() void {

     
···

       298
       302
        
           idtr.load();

     

       299
       303
        
       }

     

       300
       304
        
       

     

       301
       301
       -
       pub fn add_handler(interrupt: Interrupt, handler: anytype, dpl: u2, ist: u3) void {

     

       305
       305
       +
       pub fn add_handler(interrupt: Interrupt, comptime E: type, handler: InterruptHandler(E), dpl: u2, ist: u3) void {

     

       302
       306
        
           // Modify the type, dpl, and ist in place

     

       303
       307
        
           var tmp = interrupt_descriptor_table[interrupt.interrupt];

     

       304
       308
        
           tmp.options.dpl = dpl;

     

       305
       309
        
           tmp.options.ist_index = ist;

     

       306
       310
        
           interrupt_descriptor_table[interrupt.interrupt] = tmp;

     

       307
       311
        
       

     

       308
       308
       -
           // Add the DefinedHandler

     

       309
       309
       -
           defined_handlers[interrupt.interrupt] = @ptrCast(&handler);

     

       312
       312
       +
           // Add the InterruptHandler

     

       313
       313
       +
           defined_handlers[interrupt.interrupt] = @ptrCast(handler);

     

       310
       314
        
       }

+3 -2

components/ukernel/arch/amd64/interrupts/pic.zig

···

       1
       1
        
       /// Remap the 8259 PIC to an interrupt base of 0x32

     

       2
       2
        
       const arch = @import("../root.zig");

     

       3
       3
       +
       const idt = arch.interrupts.idt;

     

       3
       4
        
       const std = @import("std");

     

       4
       5
        
       const log = std.log.scoped(.pic);

     

       5
       6
        
       const out = arch.port.out;

     
···

       52
       53
        
           wait();

     

       53
       54
        
       

     

       54
       55
        
           // Set up a spurious IRQ7 handler

     

       55
       55
       -
           arch.interrupts.idt.add_handler(.{ .interrupt = 32 + 7 }, spurious_handler, 3, 0);

     

       56
       56
       +
           arch.interrupts.idt.add_handler(.{ .interrupt = 32 + 7 }, u64, spurious_handler, 0, 0);

     

       56
       57
        
       }

     

       57
       58
        
       

     

       58
       59
        
       inline fn wait() void {

     
···

       64
       65
        
           out(u8, PIC_ONE_CMD_PORT, CMD_EOI);

     

       65
       66
        
       }

     

       66
       67
        
       

     

       67
       67
       -
       pub fn spurious_handler(_: *arch.interrupts.idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       68
       68
       +
       pub fn spurious_handler(_: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       68
       69
        
           std.log.warn("Got a spurious IRQ7 (8259)", .{});

     

       69
       70
        
       }

+112 -6

components/ukernel/arch/amd64/interrupts/root.zig

···

       3
       3
        
       pub const pit = @import("pit.zig");

     

       4
       4
        
       pub const idt = @import("idt.zig");

     

       5
       5
        
       const std = @import("std");

     

       6
       6
       +
       const log = std.log.scoped(.interrupts);

     

       6
       7
        
       const arch = @import("../root.zig");

     

       8
       8
       +
       const common = @import("common");

     

       7
       9
        
       

     

       8
       10
        
       pub inline fn enable() void {

     

       9
       11
        
           asm volatile ("sti");

     
···

       12
       14
        
           asm volatile ("cli");

     

       13
       15
        
       }

     

       14
       16
        
       

     

       15
       15
       -
       fn print_regs(frame: *idt.InterruptFrame(u64)) void {

     

       17
       17
       +
       const syscall_entry = @extern(*anyopaque, .{

     

       18
       18
       +
           .name = "syscall_entry",

     

       19
       19
       +
       });

     

       20
       20
       +
       

     

       21
       21
       +
       export fn syscall_handler(rdi: usize, rsi: usize) callconv(.c) void {

     

       22
       22
       +
           std.log.info("Got a syscall! rdi=0x{x}, rsi=0x{x}", .{ rdi, rsi });

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       pub fn init_syscalls() void {

     

       26
       26
       +
           // Set up the STAR MSR with the segment descriptors

     

       27
       27
       +
           const IA32_STAR = arch.registers.MSR(u64, 0xC0000081);

     

       28
       28
       +
           const star_value: u64 = 0 | @as(u64, arch.structures.gdt.StandardGdt.selectors.kernel_code) << 32 | (@as(u64, arch.structures.gdt.StandardGdt.selectors.tss_desc + 8) | 3) << 48;

     

       29
       29
       +
           IA32_STAR.write(star_value);

     

       30
       30
       +
       

     

       31
       31
       +
           // Set up the EFER MSR with SCE (System Call Enable)

     

       32
       32
       +
           const IA32_EFER = arch.registers.MSR(u64, 0xC0000080);

     

       33
       33
       +
           const efer_val = IA32_EFER.read() | 0b1;

     

       34
       34
       +
           IA32_EFER.write(efer_val);

     

       35
       35
       +
       

     

       36
       36
       +
           // Set up LSTAR with the syscall handler and FMASK to clear interrupts

     

       37
       37
       +
           const IA32_LSTAR = arch.registers.MSR(u64, 0xC0000082);

     

       38
       38
       +
           IA32_LSTAR.write(@intFromPtr(syscall_entry));

     

       39
       39
       +
       

     

       40
       40
       +
           const IA32_FMASK = arch.registers.MSR(u64, 0xC0000084);

     

       41
       41
       +
           IA32_FMASK.write(1 << 9);

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       pub fn print_regs(frame: *idt.InterruptFrame(u64)) void {

     

       16
       45
        
           std.log.err("CR3: 0x{x:0>16}", .{frame.cr3});

     

       17
       46
        
           std.log.err("RAX: 0x{x:0>16}, RBX: 0x{x:0>16}, RCX: 0x{x:0>16}, RDX: 0x{x:0>16}", .{ frame.regs.rax, frame.regs.rbx, frame.regs.rcx, frame.regs.rdx });

     

       18
       47
        
           std.log.err("RSI: 0x{x:0>16}, RDI: 0x{x:0>16}, RBP: 0x{x:0>16}, RSP: 0x{x:0>16}", .{ frame.regs.rsi, frame.regs.rdi, frame.regs.rbp, frame.rsp });

     
···

       21
       50
        
           std.log.err("RFL: 0x{x:0>16}, RIP: 0x{x:0>16}, CS:  0x{x:0>16}, SS:  0x{x:0>16}", .{ frame.eflags, frame.rip, frame.cs, frame.ss });

     

       22
       51
        
       }

     

       23
       52
        
       

     

       24
       24
       -
       pub fn unhandled_interrupt(frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       53
       53
       +
       pub fn unhandled_interrupt(frame: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       25
       54
        
           if (std.enums.tagName(idt.Exception, frame.int_num.exception)) |exception_name| {

     

       26
       55
        
               std.log.err("Unhandled interrupt (0x{x} : {s})!!!", .{ frame.int_num.interrupt, exception_name });

     

       27
       56
        
           } else {

     
···

       34
       63
        
           arch.instructions.die();

     

       35
       64
        
       }

     

       36
       65
        
       

     

       37
       37
       -
       pub fn breakpoint(stack_frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       66
       66
       +
       pub fn breakpoint(stack_frame: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       38
       67
        
           std.log.warn("Breakpoint @ 0x{x}, returning execution...", .{stack_frame.rip});

     

       39
       68
        
       }

     

       40
       69
        
       

     

       41
       41
       -
       pub fn double_fault(stack_frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       70
       70
       +
       pub fn double_fault(stack_frame: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       42
       71
        
           std.log.err("Double fault @ 0x{x}, dying!!!", .{stack_frame.rip});

     

       43
       72
        
           print_regs(stack_frame);

     

       44
       73
        
           arch.interrupts.disable();

     

       45
       74
        
           arch.instructions.die();

     

       46
       75
        
       }

     

       47
       76
        
       

     

       48
       48
       -
       pub fn general_protection_fault(stack_frame: *idt.InterruptFrame(idt.SelectorErrorCode)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       77
       77
       +
       pub fn general_protection_fault(stack_frame: *idt.InterruptFrame(idt.SelectorErrorCode)) callconv(idt.CallConv) void {

     

       78
       78
       +
           arch.interrupts.disable();

     

       49
       79
        
           std.log.warn("General Protection Fault @ 0x{x}", .{stack_frame.rip});

     

       50
       80
        
       

     

       51
       81
        
           const target = stack_frame.error_code.parse();

     
···

       64
       94
        
                   std.log.warn("LDT selector: 0x{x}", .{ldt_sel});

     

       65
       95
        
               },

     

       66
       96
        
           }

     

       67
       67
       -
           print_regs(@ptrCast(stack_frame));

     

       97
       97
       +
           print_regs(stack_frame.normalize());

     

       68
       98
        
           arch.instructions.die();

     

       69
       99
        
       }

     

       100
       100
       +
       

     

       101
       101
       +
       // Start scheduling

     

       102
       102
       +
       pub fn startScheduling() noreturn {

     

       103
       103
       +
           // 1. Pop off the task to run

     

       104
       104
       +
           const task = common.scheduler.getNextTask() orelse {

     

       105
       105
       +
               std.log.scoped(.startScheduling).err("No root task!", .{});

     

       106
       106
       +
               @panic("startScheduling");

     

       107
       107
       +
           };

     

       108
       108
       +
           // 2. Apply the paging context

     

       109
       109
       +
           task.getPagingContext().apply();

     

       110
       110
       +
           // 3. Give a slice of 1000ms and fire away

     

       111
       111
       +
           apic.armTimer(20);

     

       112
       112
       +
           enter_userspace(task.rip, 0x69, task.rsp);

     

       113
       113
       +
       }

     

       114
       114
       +
       

     

       115
       115
       +
       // Set up the IDT, PIC, TSC, and APIC

     

       116
       116
       +
       pub fn init() void {

     

       117
       117
       +
           // Set up the IDT and associated vectors

     

       118
       118
       +
           idt.init();

     

       119
       119
       +
           idt.add_handler(.{ .exception = .breakpoint }, u64, arch.interrupts.breakpoint, 3, 0);

     

       120
       120
       +
           idt.add_handler(.{ .exception = .double_fault }, u64, arch.interrupts.double_fault, 0, 0);

     

       121
       121
       +
           idt.add_handler(.{ .exception = .general_protection_fault }, idt.SelectorErrorCode, arch.interrupts.general_protection_fault, 0, 0);

     

       122
       122
       +
           idt.add_handler(.{ .exception = .page_fault }, u64, arch.mm.paging.page_fault_handler, 0, 0);

     

       123
       123
       +
           // Set up the 8254's (we need 8259 timer to calibrate tsc)

     

       124
       124
       +
           pic.init();

     

       125
       125
       +
           // Calibrate the TSC against the 8259

     

       126
       126
       +
           arch.tsc.calibrate_pit() catch |err| {

     

       127
       127
       +
               log.err("Failed to calibrate TSC: {}", .{err});

     

       128
       128
       +
           };

     

       129
       129
       +
           // Set up everything needed to arm the timer

     

       130
       130
       +
           apic.init.initialSetup();

     

       131
       131
       +
       }

     

       132
       132
       +
       

     

       133
       133
       +
       // TODO: make this slightly less shit

     

       134
       134
       +
       pub fn enter_userspace(entry: u64, arg: u64, stack: u64) noreturn {

     

       135
       135
       +
           log.info("usercode64 GDT 0x{x}, userdata64 GDT 0x{x}", .{ arch.structures.gdt.StandardGdt.selectors.user_code, arch.structures.gdt.StandardGdt.selectors.user_data });

     

       136
       136
       +
           const cr3 = arch.registers.ControlRegisters.Cr3.read();

     

       137
       137
       +
           arch.registers.ControlRegisters.Cr3.write(cr3);

     

       138
       138
       +
           asm volatile (

     

       139
       139
       +
               \\ push %[userdata64]

     

       140
       140
       +
               \\ push %[stack]

     

       141
       141
       +
               \\ push $0x202

     

       142
       142
       +
               \\ push %[usercode64]

     

       143
       143
       +
               \\ push %[entry]

     

       144
       144
       +
               \\

     

       145
       145
       +
               \\ mov %[userdata64], %%rax

     

       146
       146
       +
               \\ mov %%rax, %%es

     

       147
       147
       +
               \\ mov %%rax, %%ds

     

       148
       148
       +
               \\

     

       149
       149
       +
               \\ xor %%rsi, %%rsi

     

       150
       150
       +
               \\ xor %%rax, %%rax

     

       151
       151
       +
               \\ xor %%rdx, %%rdx

     

       152
       152
       +
               \\ xor %%rcx, %%rcx

     

       153
       153
       +
               \\ xor %%rbp, %%rbp

     

       154
       154
       +
               \\ xor %%rbx, %%rbx

     

       155
       155
       +
               \\

     

       156
       156
       +
               \\ xor %%r8, %%r8

     

       157
       157
       +
               \\ xor %%r9, %%r9

     

       158
       158
       +
               \\ xor %%r10, %%r10

     

       159
       159
       +
               \\ xor %%r11, %%r11

     

       160
       160
       +
               \\ xor %%r12, %%r12

     

       161
       161
       +
               \\ xor %%r13, %%r13

     

       162
       162
       +
               \\ xor %%r14, %%r14

     

       163
       163
       +
               \\ xor %%r15, %%r15

     

       164
       164
       +
               \\

     

       165
       165
       +
               \\ iretq

     

       166
       166
       +
               \\

     

       167
       167
       +
               :

     

       168
       168
       +
               : [arg] "{rdi}" (arg),

     

       169
       169
       +
                 [stack] "r" (stack),

     

       170
       170
       +
                 [entry] "r" (entry),

     

       171
       171
       +
                 [userdata64] "i" (arch.structures.gdt.StandardGdt.selectors.user_data),

     

       172
       172
       +
                 [usercode64] "i" (arch.structures.gdt.StandardGdt.selectors.user_code),

     

       173
       173
       +
           );

     

       174
       174
       +
           unreachable;

     

       175
       175
       +
       }

+24 -8

components/ukernel/arch/amd64/mm/paging.zig

···

       54
       54
        
           level5: bool,

     

       55
       55
        
       

     

       56
       56
        
           const Self = @This();

     

       57
       57
       -
           pub fn apply(self: *Self) void {

     

       57
       57
       +
           pub fn apply(self: *const Self) void {

     

       58
       58
        
               // NX Enable

     

       59
       59
        
               const IA32_EFER = arch.registers.MSR(u64, 0xC0000080);

     

       60
       60
        
               const efer_val = IA32_EFER.read() | (0b1 << 11);

     
···

       75
       75
        
               };

     

       76
       76
        
           }

     

       77
       77
        
       

     

       78
       78
       +
           pub fn make_user() !Context {

     

       79
       79
       +
               // Make a new root page table

     

       80
       80
       +
               const user_root_paddr = try make_page_table();

     

       81
       81
       +
               const user_root = common.mm.physToHHDM(*PageTable, user_root_paddr);

     

       82
       82
       +
               // Copy the entire higher half entries

     

       83
       83
       +
               const higher_half = common.init_data.kernel_paging_ctx.root_table(0).get_children();

     

       84
       84
       +
               @memcpy(user_root.entries[256..], higher_half[256..]);

     

       85
       85
       +
               return .{

     

       86
       86
       +
                   .cr3_val = user_root_paddr,

     

       87
       87
       +
                   .level5 = common.init_data.kernel_paging_ctx.level5,

     

       88
       88
       +
               };

     

       89
       89
       +
           }

     

       90
       90
       +
       

     

       78
       91
        
           pub fn can_map_at(_: *const Self, level: u3) bool {

     

       79
       92
        
               return level < 2;

     

       80
       93
        
           }

     
···

       82
       95
        
           // We need the parameter because aarch64 has 2 root page tables

     

       83
       96
        
           pub fn root_table(self: *Self, _: u64) TableHandle {

     

       84
       97
        
               return .{

     

       85
       85
       -
                   .paddr = self.cr3_val,

     

       98
       98
       +
                   // Mask out the cr3 value

     

       99
       99
       +
                   .paddr = self.cr3_val & 0xFFFFFFFF_FFFFF000,

     

       86
       100
        
                   .level = if (self.level5) 5 else 4,

     

       87
       101
        
                   .context = self,

     

       88
       102
        
                   .perms = .{

     
···

       233
       247
        
       }

     

       234
       248
        
       

     

       235
       249
        
       pub const page_sizes = [_]usize{

     

       236
       236
       -
           0x1000, // 4K

     

       237
       237
       -
           0x200000, // 2M

     

       238
       238
       -
           0x40000000, // 1G

     

       239
       239
       -
           0x8000000000, // 512G

     

       240
       240
       -
           0x1000000000000, // 256T

     

       250
       250
       +
           0x1000,

     

       251
       251
       +
           0x200000,

     

       252
       252
       +
           0x40000000,

     

       253
       253
       +
           0x8000000000,

     

       254
       254
       +
           0x1000000000000,

     

       241
       255
        
       };

     

       242
       256
        
       

     

       243
       257
        
       const MappingHandle = struct {

     
···

       331
       345
        
           ptr: usize,

     

       332
       346
        
       };

     

       333
       347
        
       

     

       334
       334
       -
       pub fn page_fault_handler(stack_frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       348
       348
       +
       pub fn page_fault_handler(stack_frame: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       335
       349
        
           std.log.err("Page Fault @ 0x{x}, dying...", .{stack_frame.rip});

     

       350
       350
       +
           arch.interrupts.print_regs(stack_frame.normalize());

     

       351
       351
       +
           std.log.err("Error CR2: 0x{x:0>16}, Error Code: 0x{x:0>16}", .{ arch.registers.ControlRegisters.Cr2.read(), stack_frame.error_code });

     

       336
       352
        
           arch.instructions.die();

     

       337
       353
        
       }

+25 -18

components/ukernel/arch/amd64/root.zig

···

       9
       9
        
       const common = @import("common");

     

       10
       10
        
       const std = @import("std");

     

       11
       11
        
       

     

       12
       12
       -
       fn pageSize() usize {

     

       13
       13
       -
           return 4 << 10;

     

       14
       14
       -
       }

     

       15
       15
       -
       

     

       16
       16
       -
       pub const std_options: std.Options = .{

     

       17
       17
       -
           .logFn = common.aux.logFn,

     

       18
       18
       -
           .page_size_min = 4 << 10,

     

       19
       19
       -
           .page_size_max = 4 << 10,

     

       20
       20
       -
           .queryPageSize = pageSize,

     

       12
       12
       +
       // needed by std options

     

       13
       13
       +
       pub const page_size = struct {

     

       14
       14
       +
           pub const min = 4 << 10;

     

       15
       15
       +
           pub const max = 4 << 10;

     

       16
       16
       +
           pub fn get() usize {

     

       17
       17
       +
               return 4 << 10;

     

       18
       18
       +
           }

     

       21
       19
        
       };

     

       22
       22
       -
       pub const panic = std.debug.FullPanic(common.aux.panic);

     

       23
       20
        
       

     

       24
       21
        
       pub var per_cpu_init_data: PerCpuInitData = .{};

     

       25
       22
        
       

     
···

       29
       26
        
       

     

       30
       27
        
           gdt_buf: []StandardGdt = undefined,

     

       31
       28
        
           tss_buf: []Tss = undefined,

     

       29
       29
       +
           // Physical ptr

     

       30
       30
       +
           stack_buf: usize = undefined,

     

       31
       31
       +
       

     

       32
       32
       +
           const stack_size = std.heap.page_size_max;

     

       32
       33
        
       

     

       33
       34
        
           const Self = @This();

     

       34
       35
        
           pub fn init(self: *Self, cpu_count: u64) void {

     

       35
       35
       -
               // 1. Allocate space for GDT and TSS data

     

       36
       36
       +
               // 1. Allocate stack space for every core

     

       37
       37
       +
               self.stack_buf = common.init_data.bootmem.allocPhys(stack_size * cpu_count) catch |err| {

     

       38
       38
       +
                   std.log.err("init PerCpuInitData: failed to allocate stack! {}", .{err});

     

       39
       39
       +
                   @panic("stack_buf");

     

       40
       40
       +
               };

     

       41
       41
       +
       

     

       42
       42
       +
               // 2. Allocate space for GDT and TSS data

     

       36
       43
        
               const gdt_size = @sizeOf(StandardGdt);

     

       37
       44
        
               const tss_size = @sizeOf(Tss);

     

       38
       45
        
       

     

       39
       46
        
               const total_required_size = gdt_size * cpu_count + tss_size * cpu_count;

     

       40
       47
        
               const buf: [*]u8 = @ptrFromInt(common.init_data.bootmem.allocMem(total_required_size) catch |err| {

     

       41
       48
        
                   std.log.err("init PerCpuInitData: GDT/TSS alloc failed: {}", .{err});

     

       42
       42
       -
                   @panic("rip bozo");

     

       49
       49
       +
                   @panic("gdt_tss_buf");

     

       43
       50
        
               });

     

       44
       51
        
       

     

       45
       45
       -
               // 2. Transmute and fill out the structure

     

       52
       52
       +
               // 3. Transmute and fill out the structure

     

       46
       53
        
               const gdt_buf: [*]StandardGdt = @ptrCast(@alignCast(buf[0 .. gdt_size * cpu_count]));

     

       47
       54
        
               const tss_buf: [*]Tss = @ptrCast(@alignCast(buf[gdt_size * cpu_count ..][0 .. tss_size * cpu_count]));

     

       48
       55
        
               self.gdt_buf = gdt_buf[0..cpu_count];

     

       49
       56
        
               self.tss_buf = tss_buf[0..cpu_count];

     

       50
       57
        
           }

     

       51
       51
       -
       };

     

       52
       58
        
       

     

       53
       53
       -
       comptime {

     

       54
       54
       -
           // Entry point (_start)

     

       55
       55
       -
           @export(&boot.bsp_init, .{ .name = "_start", .linkage = .strong });

     

       56
       56
       -
       }

     

       59
       59
       +
           // returns a pointer to the TOP of the stack!

     

       60
       60
       +
           pub fn getStackPhys(self: *Self, core_num: usize) usize {

     

       61
       61
       +
               return self.stack_buf + (core_num + 1) * stack_size;

     

       62
       62
       +
           }

     

       63
       63
       +
       };

+24

components/ukernel/arch/amd64/structures/root.zig

···

       1
       1
        
       pub const gdt = @import("gdt.zig");

     

       2
       2
        
       pub const tss = @import("tss.zig");

     

       3
       3
       +
       const arch = @import("../root.zig");

     

       4
       4
       +
       const common = @import("common");

     

       5
       5
       +
       const Queue = @import("Queue");

     

       6
       6
       +
       

     

       7
       7
       +
       // Uses an intrusive queue

     

       8
       8
       +
       pub const Task = struct {

     

       9
       9
       +
           // Saved Registers

     

       10
       10
       +
           regs: arch.interrupts.idt.SavedRegisters align(8),

     

       11
       11
       +
           // Address Space context

     

       12
       12
       +
           cr3_val: u64,

     

       13
       13
       +
           // Instruction Pointer

     

       14
       14
       +
           rip: u64,

     

       15
       15
       +
           // Stack Pointer

     

       16
       16
       +
           rsp: u64,

     

       17
       17
       +
           // Next task basically

     

       18
       18
       +
           node: Queue.Node = .{},

     

       19
       19
       +
       

     

       20
       20
       +
           pub fn getPagingContext(self: Task) arch.mm.paging.Context {

     

       21
       21
       +
               return .{

     

       22
       22
       +
                   .cr3_val = self.cr3_val,

     

       23
       23
       +
                   .level5 = common.init_data.kernel_paging_ctx.level5,

     

       24
       24
       +
               };

     

       25
       25
       +
           }

     

       26
       26
       +
       };

components/ukernel/arch/amd64/tsc.zig

···

       1
       1
        
       const arch = @import("root.zig");

     

       2
       2
       +
       const std = @import("std");

     

       2
       3
        
       const out = arch.port.out;

     

       3
       4
        
       const in = arch.port.in;

     

       5
       5
       +
       const log = std.log.scoped(.tsc);

     

       4
       6
        
       

     

       5
       7
        
       pub var tsc_khz: usize = 0;

     

       6
       8
        
       

     
···

       45
       47
        
           if (pollcnt < 1000) return error.PitError;

     

       46
       48
        
       

     

       47
       49
        
           tsc_khz = (end - start) / 50;

     

       50
       50
       +
       

     

       51
       51
       +
           log.debug("{} MHz", .{tsc_khz / 1000});

     

       48
       52
        
       }

     

       49
       53
        
       

     

       50
       54
        
       /// Delay for a set amount of ms using crappy polling

+12 -17

components/ukernel/build.zig

···

       45
       45
        
           const target = b.resolveTargetQuery(target_query);

     

       46
       46
        
           const optimize = b.standardOptimizeOption(.{ .preferred_optimize_mode = .ReleaseSafe });

     

       47
       47
        
       

     

       48
       48
       -
           const arch_module = b.createModule(.{

     

       49
       49
       -
               .root_source_file = b.path(arch_root_path),

     

       48
       48
       +
           const common_mod = b.createModule(.{

     

       49
       49
       +
               .root_source_file = b.path("common/root.zig"),

     

       50
       50
        
               .target = target,

     

       51
       51
        
               .optimize = optimize,

     

       52
       52
        
               .code_model = code_model,

     

       53
       53
        
           });

     

       54
       54
        
       

     

       55
       55
       +
           const arch_module = b.createModule(.{

     

       56
       56
       +
               .root_source_file = b.path(arch_root_path),

     

       57
       57
       +
           });

     

       55
       58
        
           switch (arch) {

     

       56
       59
        
               .amd64 => {

     

       57
       60
        
                   arch_module.addAssemblyFile(b.path("arch/amd64/asm/traps.S"));

     
···

       59
       62
        
               else => {},

     

       60
       63
        
           }

     

       61
       64
        
       

     

       62
       62
       -
           const limine_dep = b.dependency("limine", .{

     

       63
       63
       -
               .api_revision = 3,

     

       64
       64
       -
           });

     

       65
       65
       -
           const spinlock_dep = b.dependency("spinlock", .{});

     

       66
       66
       -
           const console_dep = b.dependency("console", .{});

     

       67
       67
       -
       

     

       68
       68
       -
           const limine_mod = limine_dep.module("limine");

     

       69
       69
       -
           const spinlock_mod = spinlock_dep.module("spinlock");

     

       70
       70
       -
           const console_mod = console_dep.module("console");

     

       71
       71
       -
       

     

       72
       72
       -
           const common_mod = b.createModule(.{

     

       73
       73
       -
               .root_source_file = b.path("common/root.zig"),

     

       74
       74
       -
           });

     

       65
       65
       +
           const spinlock_mod = b.dependency("spinlock", .{}).module("spinlock");

     

       66
       66
       +
           const limine_mod = b.dependency("limine", .{ .api_revision = 3 }).module("limine");

     

       67
       67
       +
           const console_mod = b.dependency("console", .{}).module("console");

     

       68
       68
       +
           const queue_mod = b.dependency("Queue", .{}).module("Queue");

     

       75
       69
        
       

     

       76
       70
        
           arch_module.addImport("limine", limine_mod);

     

       77
       71
        
           arch_module.addImport("console", console_mod);

     

       78
       72
        
           arch_module.addImport("common", common_mod);

     

       73
       73
       +
           arch_module.addImport("Queue", queue_mod);

     

       79
       74
        
       

     

       80
       75
        
           common_mod.addImport("arch", arch_module);

     

       81
       76
        
           common_mod.addImport("spinlock", spinlock_mod);

     

       82
       77
        
           common_mod.addImport("console", console_mod);

     

       83
       83
       -
           common_mod.addImport("limine", limine_mod);

     

       78
       78
       +
           common_mod.addImport("Queue", queue_mod);

     

       84
       79
        
       

     

       85
       80
        
           const kernel = b.addExecutable(.{

     

       86
       81
        
               .name = "ukernel",

     

       87
       87
       -
               .root_module = arch_module,

     

       82
       82
       +
               .root_module = common_mod,

     

       88
       83
        
               // TODO: remove when x86 backend is less broken with removing CPU features

     

       89
       84
        
               .use_llvm = true,

     

       90
       85
        
           });

components/ukernel/build.zig.zon

···

       8
       8
        
               .spinlock = .{ .path = "deps/spinlock" },

     

       9
       9
        
               .build_helpers = .{ .path = "../build_helpers" },

     

       10
       10
        
               .console = .{ .path = "deps/console" },

     

       11
       11
       +
               .Queue = .{

     

       12
       12
       +
                   .url = "git+https://tangled.org/@sydney.blue/Queue.zig?ref=dev#6c0760e8a233c1d59554a40a87f0ef293a9697f3",

     

       13
       13
       +
                   .hash = "Queue-0.0.0-upnEfhEPAADNV4Dvs3DVCRSnOh-BrhgsRR6scaE2qTIa",

     

       14
       14
       +
               },

     

       11
       15
        
           },

     

       12
       16
        
           .paths = .{

     

       13
       17
        
               "build.zig",

-89

components/ukernel/common/aux/root.zig

···

       1
       1
       -
       const console = @import("console");

     

       2
       2
       -
       const common = @import("../root.zig");

     

       3
       3
       -
       const mm = common.mm;

     

       4
       4
       -
       const std = @import("std");

     

       5
       5
       -
       const arch = @import("arch");

     

       6
       6
       -
       const spinlock = @import("spinlock");

     

       7
       7
       -
       const limine = @import("limine");

     

       8
       8
       -
       

     

       9
       9
       -
       // Types

     

       10
       10
       -
       pub const HardwareDescription = union(enum) {

     

       11
       11
       -
           /// Physical address of ACPI RSDP

     

       12
       12
       -
           acpi_rsdp: usize,

     

       13
       13
       -
           /// Virtual pointer to DTB

     

       14
       14
       -
           dtb: *anyopaque,

     

       15
       15
       -
           none,

     

       16
       16
       -
       };

     

       17
       17
       -
       

     

       18
       18
       -
       pub const InitState = struct {

     

       19
       19
       -
           bootmem: mm.bootmem.BootPmm = .{},

     

       20
       20
       -
           console: ?console.Console = null,

     

       21
       21
       -
           framebuffer: ?console.Framebuffer = null,

     

       22
       22
       -
           hardware_description: HardwareDescription = .none,

     

       23
       23
       -
           root_task: []align(4096) u8 = undefined,

     

       24
       24
       -
           hhdm_slide: usize = 0,

     

       25
       25
       -
       };

     

       26
       26
       -
       

     

       27
       27
       -
       pub fn fb_from_limine(fb: *const limine.Framebuffer) console.Framebuffer {

     

       28
       28
       -
           return .{

     

       29
       29
       -
               .address = @ptrCast(@alignCast(fb.address)),

     

       30
       30
       -
               .width = fb.width,

     

       31
       31
       -
               .height = fb.height,

     

       32
       32
       -
               .pitch = fb.pitch,

     

       33
       33
       -
               .red_mask_size = fb.red_mask_size,

     

       34
       34
       -
               .red_mask_shift = fb.red_mask_shift,

     

       35
       35
       -
               .green_mask_size = fb.green_mask_size,

     

       36
       36
       -
               .green_mask_shift = fb.green_mask_shift,

     

       37
       37
       -
               .blue_mask_size = fb.blue_mask_size,

     

       38
       38
       -
               .blue_mask_shift = fb.blue_mask_shift,

     

       39
       39
       -
               .bypp = fb.bpp / 8,

     

       40
       40
       -
           };

     

       41
       41
       -
       }

     

       42
       42
       -
       

     

       43
       43
       -
       var stdout_lock: spinlock.Spinlock = .{};

     

       44
       44
       -
       

     

       45
       45
       -
       pub fn logFn(

     

       46
       46
       -
           comptime message_level: std.log.Level,

     

       47
       47
       -
           comptime scope: @TypeOf(.enum_literal),

     

       48
       48
       -
           comptime format: []const u8,

     

       49
       49
       -
           args: anytype,

     

       50
       50
       -
       ) void {

     

       51
       51
       -
           if (common.init_data.console == null) return;

     

       52
       52
       -
       

     

       53
       53
       -
           // Use the same naming as the default logger

     

       54
       54
       -
           const level, const color: u32 = switch (message_level) {

     

       55
       55
       -
               .debug => .{ "D", 0x3bcf1d },

     

       56
       56
       -
               .err => .{ "E", 0xff0000 },

     

       57
       57
       -
               .info => .{ "I", 0x00bbbb },

     

       58
       58
       -
               .warn => .{ "W", 0xfee409 },

     

       59
       59
       -
           };

     

       60
       60
       -
           // Use same format as default once again

     

       61
       61
       -
           const scope_text = switch (scope) {

     

       62
       62
       -
               .default => "",

     

       63
       63
       -
               else => "<" ++ @tagName(scope) ++ ">",

     

       64
       64
       -
           };

     

       65
       65
       -
           const prefix = std.fmt.comptimePrint("{s}{s}: ", .{ level, scope_text });

     

       66
       66
       -
       

     

       67
       67
       -
           {

     

       68
       68
       -
               stdout_lock.lock();

     

       69
       69
       -
               defer stdout_lock.unlock();

     

       70
       70
       -
       

     

       71
       71
       -
               common.init_data.console.?.setColor(color, 0);

     

       72
       72
       -
               // No buffering for now

     

       73
       73
       -
               var writer = console.Console.Writer.init(&common.init_data.console.?, &.{});

     

       74
       74
       -
               writer.interface.print(prefix ++ format ++ "\n", args) catch return;

     

       75
       75
       -
           }

     

       76
       76
       -
       }

     

       77
       77
       -
       

     

       78
       78
       -
       pub fn panic(msg: []const u8, first_trace_addr: ?usize) noreturn {

     

       79
       79
       -
           _ = first_trace_addr;

     

       80
       80
       -
           const log = std.log.scoped(.panic);

     

       81
       81
       -
           log.err("PANIC: {s}", .{msg});

     

       82
       82
       -
           var it = std.debug.StackIterator.init(@returnAddress(), @frameAddress());

     

       83
       83
       -
           defer it.deinit();

     

       84
       84
       -
           while (it.next()) |addr| {

     

       85
       85
       -
               if (addr == 0) break;

     

       86
       86
       -
               log.err("Addr: 0x{x:0>16}", .{addr});

     

       87
       87
       -
           }

     

       88
       88
       -
           arch.instructions.die();

     

       89
       89
       -
       }

+83

components/ukernel/common/aux.zig

···

       1
       1
       +
       const console = @import("console");

     

       2
       2
       +
       const common = @import("root.zig");

     

       3
       3
       +
       const mm = common.mm;

     

       4
       4
       +
       const std = @import("std");

     

       5
       5
       +
       const arch = @import("arch");

     

       6
       6
       +
       const spinlock = @import("spinlock");

     

       7
       7
       +
       

     

       8
       8
       +
       // Types

     

       9
       9
       +
       pub const HardwareDescription = union(enum) {

     

       10
       10
       +
           /// Physical address of ACPI RSDP

     

       11
       11
       +
           acpi_rsdp: usize,

     

       12
       12
       +
           /// Virtual pointer to DTB

     

       13
       13
       +
           dtb: *anyopaque,

     

       14
       14
       +
           none,

     

       15
       15
       +
       };

     

       16
       16
       +
       

     

       17
       17
       +
       pub const InitState = struct {

     

       18
       18
       +
           bootmem: mm.bootmem.BootPmm = .{},

     

       19
       19
       +
           console: ?console.Console = null,

     

       20
       20
       +
           framebuffer: ?console.Framebuffer = null,

     

       21
       21
       +
           hardware_description: HardwareDescription = .none,

     

       22
       22
       +
           root_task_elf: []align(4096) u8 = undefined,

     

       23
       23
       +
           hhdm_slide: usize = 0,

     

       24
       24
       +
           kernel_paging_ctx: arch.mm.paging.Context = undefined,

     

       25
       25
       +
       };

     

       26
       26
       +
       

     

       27
       27
       +
       pub fn initConsole() void {

     

       28
       28
       +
           const fb = common.init_data.framebuffer.?;

     

       29
       29
       +
           // Create a canvas for the console to render to

     

       30
       30
       +
           const canvas: [*]u8 = @ptrFromInt(common.init_data.bootmem.allocMem(fb.width * fb.height * fb.bypp) catch @panic("Couldn't allocate a canvas"));

     

       31
       31
       +
           @memset(canvas[0 .. fb.width * fb.height * fb.bypp], 0);

     

       32
       32
       +
       

     

       33
       33
       +
           // Set the console instance

     

       34
       34
       +
           common.init_data.console = console.Console.init(fb, canvas);

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       var stdout_lock: spinlock.Spinlock = .{};

     

       38
       38
       +
       

     

       39
       39
       +
       pub fn logFn(

     

       40
       40
       +
           comptime message_level: std.log.Level,

     

       41
       41
       +
           comptime scope: @TypeOf(.enum_literal),

     

       42
       42
       +
           comptime format: []const u8,

     

       43
       43
       +
           args: anytype,

     

       44
       44
       +
       ) void {

     

       45
       45
       +
           if (common.init_data.console == null) return;

     

       46
       46
       +
       

     

       47
       47
       +
           // Use the same naming as the default logger

     

       48
       48
       +
           const level, const color: u32 = switch (message_level) {

     

       49
       49
       +
               .debug => .{ "D", 0x3bcf1d },

     

       50
       50
       +
               .err => .{ "E", 0xff0000 },

     

       51
       51
       +
               .info => .{ "I", 0x00bbbb },

     

       52
       52
       +
               .warn => .{ "W", 0xfee409 },

     

       53
       53
       +
           };

     

       54
       54
       +
           // Use same format as default once again

     

       55
       55
       +
           const scope_text = switch (scope) {

     

       56
       56
       +
               .default => "",

     

       57
       57
       +
               else => "<" ++ @tagName(scope) ++ ">",

     

       58
       58
       +
           };

     

       59
       59
       +
           const prefix = std.fmt.comptimePrint("{s}{s}: ", .{ level, scope_text });

     

       60
       60
       +
       

     

       61
       61
       +
           {

     

       62
       62
       +
               stdout_lock.lock();

     

       63
       63
       +
               defer stdout_lock.unlock();

     

       64
       64
       +
       

     

       65
       65
       +
               common.init_data.console.?.setColor(color, 0);

     

       66
       66
       +
               // No buffering for now

     

       67
       67
       +
               var writer = console.Console.Writer.init(&common.init_data.console.?, &.{});

     

       68
       68
       +
               writer.interface.print(prefix ++ format ++ "\n", args) catch return;

     

       69
       69
       +
           }

     

       70
       70
       +
       }

     

       71
       71
       +
       

     

       72
       72
       +
       pub fn panic(msg: []const u8, first_trace_addr: ?usize) noreturn {

     

       73
       73
       +
           _ = first_trace_addr;

     

       74
       74
       +
           const log = std.log.scoped(.panic);

     

       75
       75
       +
           log.err("PANIC: {s}", .{msg});

     

       76
       76
       +
           var it = std.debug.StackIterator.init(@returnAddress(), @frameAddress());

     

       77
       77
       +
           defer it.deinit();

     

       78
       78
       +
           while (it.next()) |addr| {

     

       79
       79
       +
               if (addr == 0) break;

     

       80
       80
       +
               log.err("Addr: 0x{x:0>16}", .{addr});

     

       81
       81
       +
           }

     

       82
       82
       +
           arch.instructions.die();

     

       83
       83
       +
       }

+4 -5

components/ukernel/common/loader.zig

···

       6
       6
        
       const log = std.log.scoped(.elf_loader);

     

       7
       7
        
       

     

       8
       8
        
       // Load root task, return the entry point

     

       9
       9
       -
       pub fn loadRootTask(context: *arch.mm.paging.Context) !usize {

     

       10
       10
       -
           const root_task = common.init_data.root_task;

     

       9
       9
       +
       pub fn loadElf(context: *arch.mm.paging.Context, task_slice: []align(4096) u8) !usize {

     

       11
       10
        
           const hdr = blk: {

     

       12
       12
       -
               const hdr: *elf.Elf64_Ehdr = @ptrCast(root_task);

     

       11
       11
       +
               const hdr: *elf.Elf64_Ehdr = @ptrCast(task_slice);

     

       13
       12
        
               break :blk elf.Header.init(hdr.*, .little);

     

       14
       13
        
           };

     

       15
       15
       -
           var iter = hdr.iterateProgramHeadersBuffer(root_task);

     

       14
       14
       +
           var iter = hdr.iterateProgramHeadersBuffer(task_slice);

     

       16
       15
        
           while (try iter.next()) |entry| {

     

       17
       16
        
               if ((entry.p_type != elf.PT_LOAD) or (entry.p_memsz == 0)) continue;

     

       18
       17
        
       

     
···

       39
       38
        
               const dst = common.mm.physToHHDM([*]u8, page_backing + vaddr_shift);

     

       40
       39
        
               const dst_slice = dst[0..entry.p_filesz];

     

       41
       40
        
       

     

       42
       42
       -
               const src_slice = root_task[entry.p_offset..][0..entry.p_filesz];

     

       41
       41
       +
               const src_slice = task_slice[entry.p_offset..][0..entry.p_filesz];

     

       43
       42
        
               @memcpy(dst_slice, src_slice);

     

       44
       43
        
       

     

       45
       44
        
               // 3. Add memsz - filesz zeroes

+3 -2

components/ukernel/common/mm/paging.zig

···

       1
       1
        
       const arch = @import("arch");

     

       2
       2
        
       const std = @import("std");

     

       3
       3
       +
       const common = @import("../root.zig");

     

       3
       4
        
       const TableHandle = arch.mm.paging.TableHandle;

     

       4
       5
        
       const MemoryType = arch.mm.paging.MemoryType;

     

       5
       6
        
       const Context = arch.mm.paging.Context;

     
···

       46
       47
        
           size: usize,

     

       47
       48
        
           perms: Perms,

     

       48
       49
        
           memory_type: MemoryType,

     

       49
       49
       -
           context: *Context,

     

       50
       50
       +
           context: *Context = &common.init_data.kernel_paging_ctx,

     

       50
       51
        
       }) !void {

     

       51
       52
        
           const root = args.context.root_table(args.vaddr);

     

       52
       53
        
           var vaddr = args.vaddr;

     
···

       60
       61
        
           size: usize,

     

       61
       62
        
           perms: Perms,

     

       62
       63
        
           memory_type: MemoryType,

     

       63
       63
       -
           context: *Context,

     

       64
       64
       +
           context: *Context = &common.init_data.kernel_paging_ctx,

     

       64
       65
        
       }) !void {

     

       65
       66
        
           const root = args.context.root_table(args.vaddr);

     

       66
       67
        
           var vaddr = args.vaddr;

+81 -2

components/ukernel/common/root.zig

···

       1
       1
       -
       pub const aux = @import("aux/root.zig");

     

       1
       1
       +
       pub const aux = @import("aux.zig");

     

       2
       2
        
       pub const mm = @import("mm/root.zig");

     

       3
       3
       -
       pub const loadRootTask = loader.loadRootTask;

     

       3
       3
       +
       pub const scheduler = @import("scheduler.zig");

     

       4
       4
       +
       pub const loadElf = loader.loadElf;

     

       5
       5
       +
       const arch = @import("arch");

     

       6
       6
       +
       const std = @import("std");

     

       4
       7
        
       const loader = @import("loader.zig");

     

       5
       8
        
       

     

       6
       9
        
       // Arch init must set up appropriate fields!

     

       7
       10
        
       pub var init_data: aux.InitState = .{};

     

       11
       11
       +
       

     

       12
       12
       +
       // Generic bsp init

     

       13
       13
       +
       pub fn generic_init() callconv(.c) noreturn {

     

       14
       14
       +
           const log = std.log.scoped(.generic_init);

     

       15
       15
       +
           // First, do early arch init

     

       16
       16
       +
           arch.boot.early_init();

     

       17
       17
       +
       

     

       18
       18
       +
           // Now, set up the bootmem and console

     

       19
       19
       +
           mm.bootmem.init();

     

       20
       20
       +
       

     

       21
       21
       +
           // Now, do the rest of the arch init

     

       22
       22
       +
           arch.boot.bsp_init();

     

       23
       23
       +
       

     

       24
       24
       +
           // Next, set up the console

     

       25
       25
       +
           aux.initConsole();

     

       26
       26
       +
       

     

       27
       27
       +
           // Now, set up interrupts

     

       28
       28
       +
           arch.interrupts.init();

     

       29
       29
       +
           arch.interrupts.init_syscalls();

     

       30
       30
       +
       

     

       31
       31
       +
           log.info("Loading attached tasks...", .{});

     

       32
       32
       +
           arch.boot.loadTasks();

     

       33
       33
       +
       

     

       34
       34
       +
           log.info("Dropping to userspace!", .{});

     

       35
       35
       +
       

     

       36
       36
       +
           arch.interrupts.startScheduling();

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       pub fn loadTask(scratch: *arch.structures.Task, task_slice: []align(4096) u8) void {

     

       40
       40
       +
           // 1. Create a user address space

     

       41
       41
       +
           var user_ctx = arch.mm.paging.Context.make_user() catch |err| {

     

       42
       42
       +
               std.log.err("Failed to make user context! {}", .{err});

     

       43
       43
       +
               @panic("make_user_ctx");

     

       44
       44
       +
           };

     

       45
       45
       +
       

     

       46
       46
       +
           // 2. Allocate a user stack

     

       47
       47
       +
           mm.paging.map(.{

     

       48
       48
       +
               .vaddr = 0x7ffe_0000_0000,

     

       49
       49
       +
               .size = 65536,

     

       50
       50
       +
               .memory_type = .MemoryWriteBack,

     

       51
       51
       +
               .perms = .{

     

       52
       52
       +
                   .x = false,

     

       53
       53
       +
                   .u = true,

     

       54
       54
       +
                   .w = true,

     

       55
       55
       +
               },

     

       56
       56
       +
               .context = &user_ctx,

     

       57
       57
       +
           }) catch @panic("couldn't map user stack");

     

       58
       58
       +
       

     

       59
       59
       +
           // 3. Map ELF into address space

     

       60
       60
       +
           const entry = loadElf(&user_ctx, task_slice) catch |err| {

     

       61
       61
       +
               std.log.err("Couldn't load the root task! {}", .{err});

     

       62
       62
       +
               @panic("ggz");

     

       63
       63
       +
           };

     

       64
       64
       +
           // 4. Add task to scheduler

     

       65
       65
       +
           scratch.* = .{

     

       66
       66
       +
               .cr3_val = user_ctx.cr3_val,

     

       67
       67
       +
               .regs = .default,

     

       68
       68
       +
               .rip = entry,

     

       69
       69
       +
               .rsp = 0x7ffe_0001_0000,

     

       70
       70
       +
           };

     

       71
       71
       +
           scheduler.pushTask(scratch);

     

       72
       72
       +
       }

     

       73
       73
       +
       

     

       74
       74
       +
       // std options etc.

     

       75
       75
       +
       pub const panic = std.debug.FullPanic(aux.panic);

     

       76
       76
       +
       pub const std_options: std.Options = .{

     

       77
       77
       +
           .logFn = aux.logFn,

     

       78
       78
       +
           .page_size_min = arch.page_size.min,

     

       79
       79
       +
           .page_size_max = arch.page_size.max,

     

       80
       80
       +
           .queryPageSize = arch.page_size.get,

     

       81
       81
       +
       };

     

       82
       82
       +
       

     

       83
       83
       +
       comptime {

     

       84
       84
       +
           // Entry point (_start)

     

       85
       85
       +
           @export(&generic_init, .{ .name = "_start", .linkage = .strong });

     

       86
       86
       +
       }

+16

components/ukernel/common/scheduler.zig

···

       1
       1
       +
       const std = @import("std");

     

       2
       2
       +
       const arch = @import("arch");

     

       3
       3
       +
       const Queue = @import("Queue");

     

       4
       4
       +
       const Task = arch.structures.Task;

     

       5
       5
       +
       

     

       6
       6
       +
       var task_queue: Queue = .{};

     

       7
       7
       +
       

     

       8
       8
       +
       pub fn pushTask(task: *Task) void {

     

       9
       9
       +
           task_queue.enqueue(&task.node);

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       pub fn getNextTask() ?*Task {

     

       13
       13
       +
           const node = task_queue.dequeue() orelse return null;

     

       14
       14
       +
           const task: *Task = @fieldParentPtr("node", node);

     

       15
       15
       +
           return task;

     

       16
       16
       +
       }

Compare changes