comparing 98b9dd0405f68b0b32ad278d5bc3b43a428890e8 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

+19

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);

     

       8
       8
       +
           asm volatile ("int3");

     

       9
       9
       +
           asm volatile (

     

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

     

       11
       11
       +
               \\ xor %%rsi, %%rsi

     

       12
       12
       +
               \\ xor %%rbx, %%rbx

     

       13
       13
       +
               \\ mainloop:

     

       14
       14
       +
               \\ xor %%rax, %%rax

     

       15
       15
       +
               \\ delayloop:

     

       16
       16
       +
               \\ inc %%rax

     

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

     

       18
       18
       +
               \\ jnz delayloop

     

       19
       19
       +
               \\ inc %%rbx

     

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

     

       21
       21
       +
               \\ syscall

     

       22
       22
       +
               \\ jmp mainloop

     

       23
       23
       +
               :

     

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

     

       25
       25
       +
           );

     

       7
       26
        
       

     

       8
       27
        
           die();

     

       9
       28
        
       }

+3 -4

components/ukernel/arch/aarch64/boot.zig

···

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

     

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

     

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

     

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

     

       6
       5
        
       const log = std.log.scoped(.aarch64_init);

     

       7
       6
        
       

     

       8
       7
        
       pub const limine_requests = struct {

     
···

       22
       21
        
       pub fn bsp_init() callconv(.c) noreturn {

     

       23
       22
        
           if (limine_requests.framebuffer.response) |fb_response| {

     

       24
       23
        
               if (fb_response.framebuffer_count > 0) {

     

       25
       25
       -
                   const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       24
       24
       +
                   const fb = common.aux.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       26
       25
        
                   common.init_data.framebuffer = fb;

     

       27
       26
        
                   @memset(fb.address[0..64], 0xFF);

     

       28
       27
        
               }

     
···

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

     

       69
       68
        
                   const mod_size = mod.size;

     

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

     

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

     

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

     

       72
       71
        
               }

     

       73
       72
        
           } else {

     

       74
       73
        
               @branchHint(.unlikely);

     
···

       83
       82
        
       fn initConsole() void {

     

       84
       83
        
           if (limine_requests.framebuffer.response) |fb_response| {

     

       85
       84
        
               if (fb_response.framebuffer_count > 0) {

     

       86
       86
       -
                   const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       85
       85
       +
                   const fb = common.aux.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       87
       86
        
                   common.init_data.framebuffer = fb;

     

       88
       87
        
                   // At this point, log becomes usable

     

       89
       88
        
                   common.init_data.console = console.Console.from_font(fb, console.DefaultFont);

+64 -241

components/ukernel/arch/amd64/boot.zig

···

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

     

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

     

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

     

       7
       7
       -
       const Idt = arch.structures.Idt;

     

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

     

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

     

       10
       9
        
       

     
···

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

     

       23
       22
        
       };

     

       24
       23
        
       

     

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

     

       24
       24
       +
       pub fn early_init() void {

     

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

     

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

     

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

     
···

       34
       33
        
               arch.instructions.die();

     

       35
       34
        
           }

     

       36
       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
       +
       

     

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

     

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

     

       39
       44
        
               @branchHint(.cold);

     
···

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

     

       48
       53
        
           common.init_data.hhdm_slide = hhdm_offset;

     

       49
       54
        
       

     

       50
       50
       -
           // Add in a framebuffer if found

     

       51
       51
       -
           initConsole();

     

       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
       +
           };

     

       74
       74
       +
       

     

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

     

       76
       76
       +
           gdt.load();

     

       77
       77
       +
       

     

       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
       +
           }

     

       52
       97
        
       

     

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

     

       54
       99
        
           initHwDesc();

     

       55
       100
        
       

     

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

     

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

     

       58
       58
       -
       

     

       59
       101
        
           // Attach the root task

     

       60
       102
        
           if (limine_requests.modules.response) |module_response| {

     

       61
       103
        
               if (module_response.module_count > 0) {

     
···

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

     

       64
       106
        
                   const mod_size = mod.size;

     

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

     

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

     

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

     

       67
       109
        
               }

     

       68
       110
        
           } else {

     

       69
       111
        
               @branchHint(.unlikely);

     

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

     

       71
       113
        
           }

     

       72
       114
        
       

     

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

     

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

     

       75
       75
       -
       

     

       76
       76
       -
           // Install the IDT

     

       77
       77
       -
           initIdt();

     

       78
       78
       -
       

     

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

     

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

     

       81
       81
       -
           gdt.* = .{};

     

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

     

       83
       83
       -
           // TSS rsp 0x3800

     

       84
       84
       -
           tss.* = .{

     

       85
       85
       -
               .rsp0 = 0x3800,

     

       86
       86
       -
               .rsp1 = 0x3800,

     

       87
       87
       -
               .rsp2 = 0x3800,

     

       88
       88
       -
           };

     

       89
       89
       -
       

     

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

     

       91
       91
       -
           gdt.load();

     

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

     

       93
       93
       -
       

     

       94
       94
       -
           // AP bootstrap

     

       95
       115
        
           bootstrapAPs();

     

       96
       96
       -
       

     

       97
       97
       -
           // Calibrate our TSC

     

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

     

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

     

       100
       100
       -
               arch.instructions.die();

     

       101
       101
       -
           };

     

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

     

       103
       103
       -
       

     

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

     

       105
       105
       -
       

     

       106
       106
       -
           initApic() catch |err| {

     

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

     

       108
       108
       -
               @panic("apic");

     

       109
       109
       -
           };

     

       110
       110
       -
       

     

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

     

       112
       112
       -
       

     

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

     

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

     

       115
       115
       -
               .vaddr = 0x3000,

     

       116
       116
       -
               .size = 0x1000,

     

       117
       117
       -
               .memory_type = .MemoryWriteBack,

     

       118
       118
       -
               .perms = .{

     

       119
       119
       -
                   .executable = false,

     

       120
       120
       -
                   .userspace_accessible = true,

     

       121
       121
       -
                   .writable = true,

     

       122
       122
       -
               },

     

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

     

       124
       124
       -
       

     

       125
       125
       -
           const entry = common.loadRootTask() catch |err| {

     

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

     

       127
       127
       -
               @panic("ggz");

     

       128
       128
       -
           };

     

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

     

       130
       130
       -
       

     

       131
       131
       -
           init_syscalls();

     

       132
       132
       -
       

     

       133
       133
       -
           enter_userspace(entry, 0x69, 0x4000);

     

       134
       116
        
       }

     

       135
       117
        
       

     

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

     

       137
       137
       -
       fn init_syscalls() void {

     

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

     

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

     

       140
       140
       -
           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;

     

       141
       141
       -
           IA32_STAR.write(star_value);

     

       142
       142
       -
       

     

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

     

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

     

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

     

       146
       146
       -
           IA32_EFER.write(efer_val);

     

       147
       147
       -
       

     

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

     

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

     

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

     

       151
       151
       -
       

     

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

     

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

     

       154
       154
       -
       }

     

       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)];

     

       155
       124
        
       

     

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

     

       157
       157
       -
           .name = "syscall_entry",

     

       158
       158
       -
       });

     

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

     

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

     

       161
       161
       -
       }

     

       162
       162
       -
       

     

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

     

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

     

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

     

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

     

       167
       167
       -
           asm volatile (

     

       168
       168
       -
               \\ push %[userdata64]

     

       169
       169
       -
               \\ push %[stack]

     

       170
       170
       -
               \\ push $0x202

     

       171
       171
       -
               \\ push %[usercode64]

     

       172
       172
       -
               \\ push %[entry]

     

       173
       173
       -
               \\

     

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

     

       175
       175
       -
               \\ mov %%rax, %%es

     

       176
       176
       -
               \\ mov %%rax, %%ds

     

       177
       177
       -
               \\

     

       178
       178
       -
               \\ xor %%rsi, %%rsi

     

       179
       179
       -
               \\ xor %%rax, %%rax

     

       180
       180
       -
               \\ xor %%rdx, %%rdx

     

       181
       181
       -
               \\ xor %%rcx, %%rcx

     

       182
       182
       -
               \\ xor %%rbp, %%rbp

     

       183
       183
       -
               \\ xor %%rbx, %%rbx

     

       184
       184
       -
               \\

     

       185
       185
       -
               \\ xor %%r8, %%r8

     

       186
       186
       -
               \\ xor %%r9, %%r9

     

       187
       187
       -
               \\ xor %%r10, %%r10

     

       188
       188
       -
               \\ xor %%r11, %%r11

     

       189
       189
       -
               \\ xor %%r12, %%r12

     

       190
       190
       -
               \\ xor %%r13, %%r13

     

       191
       191
       -
               \\ xor %%r14, %%r14

     

       192
       192
       -
               \\ xor %%r15, %%r15

     

       193
       193
       -
               \\

     

       194
       194
       -
               \\ iretq

     

       195
       195
       -
               \\

     

       196
       196
       -
               :

     

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

     

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

     

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

     

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

     

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

     

       202
       202
       -
           );

     

       203
       203
       -
           unreachable;

     

       204
       204
       -
       }

     

       205
       205
       -
       

     

       206
       206
       -
       fn initApic() !void {

     

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

     

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

     

       209
       209
       -
               true => .x2apic,

     

       210
       210
       -
               false => blk: {

     

       211
       211
       -
                   // Map the APIC first!

     

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

     

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

     

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

     

       215
       215
       -
                       .paddr = 0xFEE0_0000,

     

       216
       216
       -
                       .size = 0x1000,

     

       217
       217
       -
                       .memory_type = .DeviceUncacheable,

     

       218
       218
       -
                       .perms = .{

     

       219
       219
       -
                           .executable = false,

     

       220
       220
       -
                           .userspace_accessible = false,

     

       221
       221
       -
                           .writable = true,

     

       222
       222
       -
                       },

     

       223
       223
       -
                   });

     

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

     

       225
       225
       -
               },

     

       226
       226
       -
           };

     

       227
       227
       -
           // Set up the spurious vector and the TPR

     

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

     

       229
       229
       -
       

     

       230
       230
       -
           // Calibrate the APIC timer

     

       231
       231
       -
           arch.interrupts.apic.init.calibrateTimer();

     

       232
       232
       -
       

     

       233
       233
       -
           // Enable periodic interrupts

     

       234
       234
       -
           arch.interrupts.apic.init.enablePeriodicInterrupt(1000);

     

       235
       235
       -
       }

     

       236
       236
       -
       

     

       237
       237
       -
       fn initConsole() void {

     

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

     

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

     

       240
       240
       -
                   const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       241
       241
       -
                   common.init_data.framebuffer = fb;

     

       242
       242
       -
                   // At this point, log becomes usable

     

       243
       243
       -
                   common.init_data.console = console.Console.from_font(fb, console.DefaultFont);

     

       244
       244
       -
                   common.init_data.console.?.setColor(0x3bcf1d, 0);

     

       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
       +
                   }

     

       245
       132
        
               }

     

       246
       133
        
           }

     

       247
       134
        
       }

     
···

       255
       142
        
           }

     

       256
       143
        
       }

     

       257
       144
        
       

     

       258
       258
       -
       pub fn initIdt() void {

     

       259
       259
       -
           const idt_addr: usize = @intFromPtr(arch.per_cpu_init_data.idt);

     

       260
       260
       -
       

     

       261
       261
       -
           // Install the known exception handlers

     

       262
       262
       -
           arch.per_cpu_init_data.idt.breakpoint.installHandler(breakpoint_handler);

     

       263
       263
       -
           arch.per_cpu_init_data.idt.double_fault.installHandler(double_fault);

     

       264
       264
       -
           arch.per_cpu_init_data.idt.general_protection_fault.installHandler(gpf);

     

       265
       265
       -
           arch.per_cpu_init_data.idt.page_fault.installHandler(page_fault);

     

       266
       266
       -
           arch.per_cpu_init_data.idt.interrupts[0xFF - 32].installHandler(arch.interrupts.apic.spurious_interrupt_handler);

     

       267
       267
       -
           arch.per_cpu_init_data.idt.interrupts[48 - 32].installHandler(arch.interrupts.apic.periodic_handler);

     

       268
       268
       -
       

     

       269
       269
       -
           // Load the Idt Register

     

       270
       270
       -
           const reg: Idt.Idtr = .{ .addr = idt_addr, .limit = @sizeOf(Idt) - 1 };

     

       271
       271
       -
           reg.load();

     

       272
       272
       -
       }

     

       273
       273
       -
       

     

       274
       274
       -
       // TODO: update the type reflection thing to make a custom

     

       275
       275
       -
       // function type for the ISR

     

       276
       276
       -
       pub const PageFaultErrorCode = packed struct(u64) {

     

       277
       277
       -
           present: bool,

     

       278
       278
       -
           write: bool,

     

       279
       279
       -
           user: bool,

     

       280
       280
       -
           reserved_write: bool,

     

       281
       281
       -
           instruction_fetch: bool,

     

       282
       282
       -
           protection_key: bool,

     

       283
       283
       -
           shadow_stack: bool,

     

       284
       284
       -
           _reserved: u8,

     

       285
       285
       -
           sgx: bool,

     

       286
       286
       -
           _reserved2: u48,

     

       287
       287
       -
       

     

       288
       288
       -
           pub fn val(self: *const PageFaultErrorCode) u64 {

     

       289
       289
       -
               return @bitCast(self.*);

     

       290
       290
       -
           }

     

       291
       291
       -
       };

     

       292
       292
       -
       pub fn page_fault(stack_frame: *arch.structures.Idt.InterruptStackFrame, err_code_u64: u64) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       293
       293
       -
           const err_code: PageFaultErrorCode = @bitCast(err_code_u64);

     

       294
       294
       -
           log.err("PAGE FAULT @ 0x{x:0>16}, code 0x{x}!!!!!!!!!!!", .{ stack_frame.instruction_pointer, err_code.val() });

     

       295
       295
       -
           const cr2 = arch.registers.ControlRegisters.Cr2.read();

     

       296
       296
       -
           switch (err_code.write) {

     

       297
       297
       -
               true => log.err("Tried to write to vaddr 0x{x:0>16}", .{cr2}),

     

       298
       298
       -
               false => log.err("Tried to read from vaddr 0x{x:0>16}", .{cr2}),

     

       299
       299
       -
           }

     

       300
       300
       -
           log.err("dying...", .{});

     

       301
       301
       -
           arch.instructions.die();

     

       302
       302
       -
       }

     

       303
       303
       -
       

     

       304
       304
       -
       pub fn breakpoint_handler(stack_frame: *Idt.InterruptStackFrame) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       305
       305
       -
           log.warn("Breakpoint @ 0x{x:0>16}, returning execution...", .{stack_frame.instruction_pointer});

     

       306
       306
       -
       }

     

       307
       307
       -
       

     

       308
       308
       -
       pub fn gpf(stack_frame: *Idt.InterruptStackFrame, err_code: u64) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       309
       309
       -
           log.warn("gpf @ 0x{x:0>16} ERR CODE {}, returning execution...", .{ stack_frame.instruction_pointer, err_code });

     

       310
       310
       -
           arch.instructions.die();

     

       311
       311
       -
       }

     

       312
       312
       -
       

     

       313
       313
       -
       pub fn double_fault(stack_frame: *Idt.InterruptStackFrame, err_code: u64) callconv(.{ .x86_64_interrupt = .{} }) noreturn {

     

       314
       314
       -
           common.init_data.console.?.setColor(0xf40d17, 0);

     

       315
       315
       -
           log.err("FATAL DOUBLE FAULT @ 0x{x:0>16}, code 0x{x}!!!!!!!!!!!", .{ stack_frame.instruction_pointer, err_code });

     

       316
       316
       -
           log.err("dying...", .{});

     

       317
       317
       -
           arch.instructions.die();

     

       318
       318
       -
       }

     

       319
       319
       -
       

     

       320
       145
        
       fn bootstrapAPs() void {

     

       321
       146
        
           log.info("Bootstrapping APs...", .{});

     

       322
       147
        
           const cpus = limine_requests.mp.response.?.getCpus();

     
···

       327
       152
        
       

     

       328
       153
        
       fn ap_init(mp_info: *limine.SmpMpFeature.MpInfo) callconv(.c) noreturn {

     

       329
       154
        
           // Set up the IDT

     

       330
       330
       -
           const idt_addr: usize = @intFromPtr(arch.per_cpu_init_data.idt);

     

       331
       331
       -
           const reg: Idt.Idtr = .{ .addr = idt_addr, .limit = @sizeOf(Idt) - 1 };

     

       332
       332
       -
           reg.load();

     

       155
       155
       +
           arch.interrupts.idt.load();

     

       333
       156
        
       

     

       334
       157
        
           // Set up our GDT and TSS

     

       335
       158
        
           const gdt = &arch.per_cpu_init_data.gdt_buf[mp_info.processor_id];

+61

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

···

       1
       1
       +
       // Do all the needed CPUID calls here, and store the info for later use

     

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

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       pub const captured = struct {

     

       6
       6
       +
           pub var vendor_str: [12]u8 = undefined;

     

       7
       7
       +
       };

     

       8
       8
       +
       pub fn init() void {

     

       9
       9
       +
           capture_vendor_str();

     

       10
       10
       +
           capture_cpu_features();

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       fn capture_vendor_str() void {

     

       14
       14
       +
           const res = cpuid(0, 0);

     

       15
       15
       +
           @memcpy(captured.vendor_str[0..4], std.mem.asBytes(&res.ebx));

     

       16
       16
       +
           @memcpy(captured.vendor_str[4..8], std.mem.asBytes(&res.edx));

     

       17
       17
       +
           @memcpy(captured.vendor_str[8..12], std.mem.asBytes(&res.ecx));

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       fn capture_cpu_features() void {

     

       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;

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       const FeaturesEcx = packed struct(u32) {

     

       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,

     

       52
       52
       +
           tsc_deadline: bool,

     

       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,

     

       60
       60
       +
       };

     

       61
       61
       +
       

     

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

     

       2
       63
        
           var eax: u32 = undefined;

     

       3
       64
        
           var ebx: u32 = undefined;

+6 -3

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

···

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

     

       2
       2
        
       

     

       3
       3
        
       pub inline fn die() noreturn {

     

       4
       4
       -
           while (true) {

     

       5
       5
       -
               asm volatile ("hlt");

     

       6
       6
       -
           }

     

       4
       4
       +
           asm volatile (

     

       5
       5
       +
               \\ mov $0xDEADDEADDEADDEAD, %%rax

     

       6
       6
       +
               \\ 1: hlt

     

       7
       7
       +
               \\ jmp 1b

     

       8
       8
       +
           );

     

       9
       9
       +
           unreachable;

     

       7
       10
        
       }

+82 -13

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;

     

       8
       8
       +
       pub var tsc_deadline_available = false;

     

       9
       9
       +
       pub var has_x2apic: bool = false;

     

       6
       10
        
       

     

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

     

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

     
···

       224
       228
        
       };

     

       225
       229
        
       

     

       226
       230
        
       pub const init = struct {

     

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

     

       228
       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

     

       229
       238
        
               singleton.setSpuriousInterruptRegister(.{

     

       230
       239
        
                   .apic_soft_enable = true,

     

       231
       240
        
                   .idt_entry = 0xFF,

     
···

       234
       243
        
               //     .priority_class = 0,

     

       235
       244
        
               //     .priority_sub_class = 0,

     

       236
       245
        
               // });

     

       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);

     

       248
       248
       +
       

     

       249
       249
       +
               // Calibrate against the TSC

     

       250
       250
       +
               calibrateTimer();

     

       251
       251
       +
               // Set up the LVT Timer Register

     

       252
       252
       +
               enableOneshotInterrupt();

     

       237
       253
        
           }

     

       238
       254
        
       

     

       239
       239
       -
           pub fn calibrateTimer() void {

     

       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
       +
               };

     

       275
       275
       +
           }

     

       276
       276
       +
       

     

       277
       277
       +
           fn calibrateTimer() void {

     

       240
       278
        
               singleton.setDivideConfigurationRegister(.div2);

     

       241
       279
        
               singleton.setLVTTimerRegister(.{

     

       242
       280
        
                   .idt_entry = 0x69,

     
···

       272
       310
        
       

     

       273
       311
        
               lapic_timer_khz = norm / 5;

     

       274
       312
        
       

     

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

     

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

     

       276
       314
        
           }

     

       277
       315
        
       

     

       278
       278
       -
           pub fn enablePeriodicInterrupt(ms: usize) void {

     

       279
       279
       -
               singleton.setInitialCountRegister(0);

     

       280
       280
       -
               singleton.setDivideConfigurationRegister(.div2);

     

       316
       316
       +
           fn enableOneshotInterrupt() void {

     

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

     

       318
       318
       +
                   true => .tsc_deadline,

     

       319
       319
       +
                   false => blk: {

     

       320
       320
       +
                       singleton.setInitialCountRegister(0);

     

       321
       321
       +
                       singleton.setDivideConfigurationRegister(.div2);

     

       322
       322
       +
                       break :blk .oneshot;

     

       323
       323
       +
                   },

     

       324
       324
       +
               };

     

       281
       325
        
       

     

       326
       326
       +
               // TODO: detect and support tsc_deadline, ditto @ armTimer

     

       282
       327
        
               singleton.setLVTTimerRegister(.{

     

       283
       328
        
                   .idt_entry = 48,

     

       284
       284
       -
                   .mode = .periodic,

     

       329
       329
       +
                   .mode = mode,

     

       285
       330
        
                   .masked = false,

     

       286
       331
        
               });

     

       332
       332
       +
           }

     

       333
       333
       +
       };

     

       287
       334
        
       

     

       335
       335
       +
       pub fn armTimer(ms: usize) void {

     

       336
       336
       +
           if (tsc_deadline_available) {

     

       337
       337
       +
               const IA32_TSC_DEADLINE = arch.registers.MSR(u64, 0x6E0);

     

       338
       338
       +
               const delta = arch.tsc.tsc_khz * ms;

     

       339
       339
       +
               const target = arch.tsc.rdtsc() + delta;

     

       340
       340
       +
       

     

       341
       341
       +
               IA32_TSC_DEADLINE.write(target);

     

       342
       342
       +
           } else {

     

       288
       343
        
               const ticks: u32 = @truncate(lapic_timer_khz * ms);

     

       289
       289
       -
       

     

       290
       344
        
               singleton.setInitialCountRegister(ticks);

     

       291
       345
        
           }

     

       292
       292
       -
       };

     

       346
       346
       +
       }

     

       293
       347
        
       

     

       294
       294
       -
       pub fn spurious_interrupt_handler(_: *arch.structures.Idt.InterruptStackFrame) callconv(.{ .x86_64_interrupt = .{} }) void {

     

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

     

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

     

       296
       350
        
       }

     

       297
       351
        
       

     

       298
       298
       -
       pub fn periodic_handler(_: *arch.structures.Idt.InterruptStackFrame) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       299
       299
       -
           log.warn("Got an ACPI timer interrupt!", .{});

     

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

     

       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);

     

       301
       370
        
       }

+314

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

···

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

     

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

     

       3
       3
       +
       const interrupts = arch.interrupts;

     

       4
       4
       +
       const StandardGdt = arch.structures.gdt.StandardGdt;

     

       5
       5
       +
       

     

       6
       6
       +
       // The actual IDT memory

     

       7
       7
       +
       const entry_count = 256;

     

       8
       8
       +
       export var interrupt_descriptor_table: [entry_count]Entry = undefined;

     

       9
       9
       +
       

     

       10
       10
       +
       // Pointers to the actual ISRs which the global interrupt handler call

     

       11
       11
       +
       // Each IDT entry pushes the interrupt number then calls the global

     

       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
       +
       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;

     

       20
       20
       +
       

     

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

     

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

     

       23
       23
       +
       const actual_handlers: [entry_count]ActualHandler = blk: {

     

       24
       24
       +
           @setEvalBranchQuota(100000000);

     

       25
       25
       +
           var ret: [entry_count]ActualHandler = undefined;

     

       26
       26
       +
           for (0..256) |i| {

     

       27
       27
       +
               ret[i] = make_actual_handler(.{ .interrupt = i });

     

       28
       28
       +
           }

     

       29
       29
       +
           break :blk ret;

     

       30
       30
       +
       };

     

       31
       31
       +
       

     

       32
       32
       +
       fn make_actual_handler(comptime interrupt: Interrupt) ActualHandler {

     

       33
       33
       +
           var asm_code: []const u8 = "";

     

       34
       34
       +
           // Make the stack consistent

     

       35
       35
       +
           if (!interrupt.has_error_code()) {

     

       36
       36
       +
               asm_code = asm_code ++ "pushq $0\n";

     

       37
       37
       +
           }

     

       38
       38
       +
           // Push the interrupt number

     

       39
       39
       +
           asm_code = asm_code ++ std.fmt.comptimePrint("pushq ${}\n", .{interrupt.interrupt});

     

       40
       40
       +
           // Jump to the common interrupt handler code

     

       41
       41
       +
           asm_code = asm_code ++ "jmp _int_handler_common";

     

       42
       42
       +
           const code = asm_code;

     

       43
       43
       +
       

     

       44
       44
       +
           const tmp_struct = struct {

     

       45
       45
       +
               fn actual_handler() callconv(.naked) void {

     

       46
       46
       +
                   asm volatile (code);

     

       47
       47
       +
               }

     

       48
       48
       +
           };

     

       49
       49
       +
           return tmp_struct.actual_handler;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       // The global assembly for the common interrupt handler

     

       53
       53
       +
       comptime {

     

       54
       54
       +
           // Construct the push and pop instructions from SavedRegisters

     

       55
       55
       +
           var push_instrs: []const u8 = "\n";

     

       56
       56
       +
           var pop_instrs: []const u8 = "\n";

     

       57
       57
       +
       

     

       58
       58
       +
           const saved_regs = @typeInfo(SavedRegisters).@"struct".fields;

     

       59
       59
       +
           for (saved_regs) |saved_reg| {

     

       60
       60
       +
               // We must prepend to push because pushes are basically

     

       61
       61
       +
               // building the struct in reverse order, so reverse the effects

     

       62
       62
       +
               push_instrs = "\n pushq %" ++ saved_reg.name ++ push_instrs;

     

       63
       63
       +
               // Of course, pop in the opposite order as push

     

       64
       64
       +
               pop_instrs = pop_instrs ++ "popq %" ++ saved_reg.name ++ "\n";

     

       65
       65
       +
           }

     

       66
       66
       +
       

     

       67
       67
       +
           asm (

     

       68
       68
       +
               \\ .global _int_handler_common

     

       69
       69
       +
               \\ .type _int_handler_common, @function

     

       70
       70
       +
               \\ _int_handler_common:

     

       71
       71
       +
       

     

       72
       72
       +
               // Push the general purpose registers and then CR3

     

       73
       73
       +
           ++ push_instrs ++

     

       74
       74
       +
               \\     mov %cr3, %rax

     

       75
       75
       +
               \\     pushq %rax

     

       76
       76
       +
       

     

       77
       77
       +
               // Now, rsp points to the start of InterruptFrame. Read int_num and call into an offset of

     

       78
       78
       +
               // the defined handlers list after setting the first arg to the created structure.

     

       79
       79
       +
           ++ std.fmt.comptimePrint("\nmov {}(%rsp), %rcx\n", .{@offsetOf(InterruptFrame(u64), "int_num")}) ++

     

       80
       80
       +
               \\     mov      %rsp, %rdi

     

       81
       81
       +
               \\     callq    *defined_handlers(, %rcx, 8)

     

       82
       82
       +
       

     

       83
       83
       +
               // Skip the stack all the way down to the general purpose

     

       84
       84
       +
               // registers, then pop all of them

     

       85
       85
       +
               // TODO: restore CR3??

     

       86
       86
       +
           ++ std.fmt.comptimePrint("\nadd ${}, %rsp\n", .{@offsetOf(InterruptFrame(u64), "regs")}) ++ pop_instrs ++

     

       87
       87
       +
               // Skip the interrupt number and error code and iretq

     

       88
       88
       +
               \\     add $16, %rsp

     

       89
       89
       +
               \\     iretq

     

       90
       90
       +
           );

     

       91
       91
       +
       }

     

       92
       92
       +
       

     

       93
       93
       +
       /// IDT Register

     

       94
       94
       +
       const Idtr = packed struct(u80) {

     

       95
       95
       +
           limit: u16,

     

       96
       96
       +
           addr: u64,

     

       97
       97
       +
       

     

       98
       98
       +
           /// Load the IDT Register

     

       99
       99
       +
           pub fn load(self: *const Idtr) void {

     

       100
       100
       +
               asm volatile ("lidt (%[idtr_addr])"

     

       101
       101
       +
                   :

     

       102
       102
       +
                   : [idtr_addr] "r" (self),

     

       103
       103
       +
               );

     

       104
       104
       +
           }

     

       105
       105
       +
       };

     

       106
       106
       +
       

     

       107
       107
       +
       // A raw IDT entry

     

       108
       108
       +
       const Entry = extern struct {

     

       109
       109
       +
           func_low: u16,

     

       110
       110
       +
           gdt_selector: u16,

     

       111
       111
       +
           options: Options,

     

       112
       112
       +
           func_mid: u16,

     

       113
       113
       +
           func_high: u32,

     

       114
       114
       +
           _reserved0: u32 = 0,

     

       115
       115
       +
       

     

       116
       116
       +
           pub const Options = packed struct(u16) {

     

       117
       117
       +
               ist_index: u3,

     

       118
       118
       +
               _reserved0: u5 = 0,

     

       119
       119
       +
               disable_interrupts: bool = true,

     

       120
       120
       +
               // type: Type,

     

       121
       121
       +
               must_be_one: u3 = 0b111,

     

       122
       122
       +
               must_be_zero: u1 = 0,

     

       123
       123
       +
               dpl: u2,

     

       124
       124
       +
               present: bool,

     

       125
       125
       +
           };

     

       126
       126
       +
       

     

       127
       127
       +
           pub const Owner = enum {

     

       128
       128
       +
               kernel,

     

       129
       129
       +
               user,

     

       130
       130
       +
           };

     

       131
       131
       +
       

     

       132
       132
       +
           const Self = @This();

     

       133
       133
       +
           pub fn init(func_ptr: usize, dpl: u2, ist: u3) Entry {

     

       134
       134
       +
               // _ = typ;

     

       135
       135
       +
               return .{

     

       136
       136
       +
                   .func_low = @truncate(func_ptr),

     

       137
       137
       +
                   .gdt_selector = StandardGdt.selectors.kernel_code,

     

       138
       138
       +
                   .options = .{

     

       139
       139
       +
                       .ist_index = ist,

     

       140
       140
       +
                       .dpl = dpl,

     

       141
       141
       +
                       .present = true,

     

       142
       142
       +
                   },

     

       143
       143
       +
                   .func_mid = @truncate(func_ptr >> 16),

     

       144
       144
       +
                   .func_high = @truncate(func_ptr >> 32),

     

       145
       145
       +
               };

     

       146
       146
       +
           }

     

       147
       147
       +
       

     

       148
       148
       +
           // Changes the address without changing anything else

     

       149
       149
       +
           pub fn set_func(self: *Self, ptr: usize) void {

     

       150
       150
       +
               self.func_low = @truncate(ptr);

     

       151
       151
       +
               self.func_mid = @truncate(ptr >> 16);

     

       152
       152
       +
               self.func_high = @truncate(ptr >> 32);

     

       153
       153
       +
           }

     

       154
       154
       +
       };

     

       155
       155
       +
       

     

       156
       156
       +
       /// A selector error code indexing into the GDT, IDT, or LDT.

     

       157
       157
       +
       /// Used in a general protection fault for example.

     

       158
       158
       +
       pub const SelectorErrorCode = packed struct(u64) {

     

       159
       159
       +
           external: bool,

     

       160
       160
       +
           interrupt: bool,

     

       161
       161
       +
           // Only valid if not interrupt

     

       162
       162
       +
           type: enum(u1) {

     

       163
       163
       +
               gdt = 0,

     

       164
       164
       +
               ldt = 1,

     

       165
       165
       +
           },

     

       166
       166
       +
           idx: u13,

     

       167
       167
       +
           _reserved0: u48 = 0,

     

       168
       168
       +
       

     

       169
       169
       +
           pub const Target = union(enum) {

     

       170
       170
       +
               interrupt: Interrupt,

     

       171
       171
       +
               gdt_sel: u16,

     

       172
       172
       +
               ldt_sel: u13,

     

       173
       173
       +
           };

     

       174
       174
       +
       

     

       175
       175
       +
           const Self = @This();

     

       176
       176
       +
           pub fn parse(self: Self) Target {

     

       177
       177
       +
               return switch (self.interrupt) {

     

       178
       178
       +
                   true => .{ .interrupt = .{ .interrupt = @truncate(self.idx) } },

     

       179
       179
       +
                   false => switch (self.type) {

     

       180
       180
       +
                       .gdt => .{ .gdt_sel = self.idx },

     

       181
       181
       +
                       .ldt => .{ .ldt_sel = self.idx },

     

       182
       182
       +
                   },

     

       183
       183
       +
               };

     

       184
       184
       +
           }

     

       185
       185
       +
       };

     

       186
       186
       +
       

     

       187
       187
       +
       /// List of the general built in exceptions

     

       188
       188
       +
       pub const Exception = enum(u8) {

     

       189
       189
       +
           divide_error = 0x00,

     

       190
       190
       +
           debug_exeption = 0x01,

     

       191
       191
       +
           non_maskable_interrupt = 0x02,

     

       192
       192
       +
           breakpoint = 0x03,

     

       193
       193
       +
           overflow = 0x04,

     

       194
       194
       +
           bound_range_exceeded = 0x05,

     

       195
       195
       +
           invalid_opcode = 0x06,

     

       196
       196
       +
           device_not_available = 0x07,

     

       197
       197
       +
           double_fault = 0x08,

     

       198
       198
       +
           // _coprocessor_segment_overrun = 0x09,

     

       199
       199
       +
           invalid_tss = 0x0a,

     

       200
       200
       +
           segment_not_present = 0x0b,

     

       201
       201
       +
           stack_segment_fault = 0x0c,

     

       202
       202
       +
           general_protection_fault = 0x0d,

     

       203
       203
       +
           page_fault = 0x0e,

     

       204
       204
       +
           // _reserved0 = 0x0f,

     

       205
       205
       +
           x87_floating_point = 0x10,

     

       206
       206
       +
           alignment_check = 0x11,

     

       207
       207
       +
           machine_check = 0x12,

     

       208
       208
       +
           simd_floating_point = 0x13,

     

       209
       209
       +
           virtualization = 0x14,

     

       210
       210
       +
           control_protection = 0x15,

     

       211
       211
       +
           hypervisor = 0x1c,

     

       212
       212
       +
           vmm = 0x1d,

     

       213
       213
       +
           security_fault = 0x1e,

     

       214
       214
       +
           _,

     

       215
       215
       +
       

     

       216
       216
       +
           fn has_error_code(self: Exception) bool {

     

       217
       217
       +
               return switch (self) {

     

       218
       218
       +
                   .double_fault, .invalid_tss, .segment_not_present, .general_protection_fault, .page_fault, .security_fault => true,

     

       219
       219
       +
                   else => false,

     

       220
       220
       +
               };

     

       221
       221
       +
           }

     

       222
       222
       +
       };

     

       223
       223
       +
       

     

       224
       224
       +
       pub const Interrupt = packed union {

     

       225
       225
       +
           exception: Exception,

     

       226
       226
       +
           interrupt: u8,

     

       227
       227
       +
       

     

       228
       228
       +
           pub fn has_error_code(self: Interrupt) bool {

     

       229
       229
       +
               return self.exception.has_error_code();

     

       230
       230
       +
           }

     

       231
       231
       +
       };

     

       232
       232
       +
       

     

       233
       233
       +
       /// Basically all the general purpose registers except rsp,

     

       234
       234
       +
       /// because RSP is already in the InterruptFrame. Ordered

     

       235
       235
       +
       /// in the order of the X.Reg from the instruction encoding lol

     

       236
       236
       +
       pub const SavedRegisters = extern struct {

     

       237
       237
       +
           rax: u64,

     

       238
       238
       +
           rcx: u64,

     

       239
       239
       +
           rdx: u64,

     

       240
       240
       +
           rbx: u64,

     

       241
       241
       +
           // rsp: u64,

     

       242
       242
       +
           rbp: u64,

     

       243
       243
       +
           rsi: u64,

     

       244
       244
       +
           rdi: u64,

     

       245
       245
       +
           r8: u64,

     

       246
       246
       +
           r9: u64,

     

       247
       247
       +
           r10: u64,

     

       248
       248
       +
           r11: u64,

     

       249
       249
       +
           r12: u64,

     

       250
       250
       +
           r13: u64,

     

       251
       251
       +
           r14: u64,

     

       252
       252
       +
           r15: u64,

     

       253
       253
       +
       

     

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

     

       255
       255
       +
       };

     

       256
       256
       +
       

     

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

     

       258
       258
       +
       pub fn InterruptFrame(comptime ErrorCode: type) type {

     

       259
       259
       +
           if (@bitSizeOf(ErrorCode) != 64) {

     

       260
       260
       +
               @compileError("ErrorCode for InterruptFrame must be exactly 64 bits!");

     

       261
       261
       +
           }

     

       262
       262
       +
           return extern struct {

     

       263
       263
       +
               // CR3

     

       264
       264
       +
               cr3: u64,

     

       265
       265
       +
               // All the general purpose registers

     

       266
       266
       +
               regs: SavedRegisters align(8),

     

       267
       267
       +
               // The interrupt number

     

       268
       268
       +
               int_num: Interrupt align(8),

     

       269
       269
       +
               // Pushed by the CPU (error_code may be pushed by us)

     

       270
       270
       +
               error_code: ErrorCode,

     

       271
       271
       +
               rip: u64,

     

       272
       272
       +
               cs: u16 align(8),

     

       273
       273
       +
               eflags: u64,

     

       274
       274
       +
               rsp: u64,

     

       275
       275
       +
               ss: u16 align(8),

     

       276
       276
       +
       

     

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

     

       278
       278
       +
                   return @ptrCast(self);

     

       279
       279
       +
               }

     

       280
       280
       +
           };

     

       281
       281
       +
       }

     

       282
       282
       +
       

     

       283
       283
       +
       // Initialize the IDT with the default unhandled exception

     

       284
       284
       +
       pub fn init() void {

     

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

     

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

     

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

     

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

     

       289
       289
       +
           }

     

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

     

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

     

       292
       292
       +
       

     

       293
       293
       +
           // Finally, load the idt

     

       294
       294
       +
           load();

     

       295
       295
       +
       }

     

       296
       296
       +
       

     

       297
       297
       +
       pub fn load() void {

     

       298
       298
       +
           const idtr: Idtr = .{

     

       299
       299
       +
               .addr = @intFromPtr(&interrupt_descriptor_table),

     

       300
       300
       +
               .limit = 0xFFF,

     

       301
       301
       +
           };

     

       302
       302
       +
           idtr.load();

     

       303
       303
       +
       }

     

       304
       304
       +
       

     

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

     

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

     

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

     

       308
       308
       +
           tmp.options.dpl = dpl;

     

       309
       309
       +
           tmp.options.ist_index = ist;

     

       310
       310
       +
           interrupt_descriptor_table[interrupt.interrupt] = tmp;

     

       311
       311
       +
       

     

       312
       312
       +
           // Add the InterruptHandler

     

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

     

       314
       314
       +
       }

+10

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;

     

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

     

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

     

       3
       6
        
       const out = arch.port.out;

     

       4
       7
        
       const in = arch.port.in;

     

       5
       8
        
       

     
···

       48
       51
        
           wait();

     

       49
       52
        
           out(u8, PIC_TWO_DATA_PORT, 0b1111_1111);

     

       50
       53
        
           wait();

     

       54
       54
       +
       

     

       55
       55
       +
           // Set up a spurious IRQ7 handler

     

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

     

       51
       57
        
       }

     

       52
       58
        
       

     

       53
       59
        
       inline fn wait() void {

     
···

       58
       64
        
       pub fn end_of_timer_interrupt() void {

     

       59
       65
        
           out(u8, PIC_ONE_CMD_PORT, CMD_EOI);

     

       60
       66
        
       }

     

       67
       67
       +
       

     

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

     

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

     

       70
       70
       +
       }

+165

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

···

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

     

       2
       2
        
       pub const pic = @import("pic.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);

     

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

     

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

     

       4
       9
        
       

     

       5
       10
        
       pub inline fn enable() void {

     

       6
       11
        
           asm volatile ("sti");

     
···

       8
       13
        
       pub inline fn disable() void {

     

       9
       14
        
           asm volatile ("cli");

     

       10
       15
        
       }

     

       16
       16
       +
       

     

       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 {

     

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

     

       46
       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 });

     

       47
       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 });

     

       48
       48
       +
           std.log.err("R8:  0x{x:0>16}, R9:  0x{x:0>16}, R10: 0x{x:0>16}, R11: 0x{x:0>16}", .{ frame.regs.r8, frame.regs.r9, frame.regs.r10, frame.regs.r11 });

     

       49
       49
       +
           std.log.err("R12: 0x{x:0>16}, R13: 0x{x:0>16}, R14: 0x{x:0>16}, R15: 0x{x:0>16}", .{ frame.regs.r12, frame.regs.r13, frame.regs.r14, frame.regs.r15 });

     

       50
       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 });

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

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

     

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

     

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

     

       56
       56
       +
           } else {

     

       57
       57
       +
               std.log.err("Unhandled interrupt (0x{x})!!!", .{frame.int_num.interrupt});

     

       58
       58
       +
           }

     

       59
       59
       +
       

     

       60
       60
       +
           print_regs(frame);

     

       61
       61
       +
       

     

       62
       62
       +
           arch.interrupts.disable();

     

       63
       63
       +
           arch.instructions.die();

     

       64
       64
       +
       }

     

       65
       65
       +
       

     

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

     

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

     

       68
       68
       +
       }

     

       69
       69
       +
       

     

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

     

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

     

       72
       72
       +
           print_regs(stack_frame);

     

       73
       73
       +
           arch.interrupts.disable();

     

       74
       74
       +
           arch.instructions.die();

     

       75
       75
       +
       }

     

       76
       76
       +
       

     

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

     

       78
       78
       +
           arch.interrupts.disable();

     

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

     

       80
       80
       +
       

     

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

     

       82
       82
       +
           switch (target) {

     

       83
       83
       +
               .interrupt => |int| {

     

       84
       84
       +
                   if (std.enums.tagName(idt.Exception, int.exception)) |exc_name| {

     

       85
       85
       +
                       std.log.warn("Caused by interrupt 0x{x} ({s})", .{ int.interrupt, exc_name });

     

       86
       86
       +
                   } else {

     

       87
       87
       +
                       std.log.warn("Caused by interrupt 0x{x}", .{int.interrupt});

     

       88
       88
       +
                   }

     

       89
       89
       +
               },

     

       90
       90
       +
               .gdt_sel => |gdt_sel| {

     

       91
       91
       +
                   std.log.warn("GDT selector: 0x{x}", .{gdt_sel});

     

       92
       92
       +
               },

     

       93
       93
       +
               .ldt_sel => |ldt_sel| {

     

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

     

       95
       95
       +
               },

     

       96
       96
       +
           }

     

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

     

       98
       98
       +
           arch.instructions.die();

     

       99
       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
       +
       }

+227 -153

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

···

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

     

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

     

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

     

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

     

       4
       4
       -
       const physToVirt = common.mm.physToHHDM;

     

       4
       4
       +
       const Cr3 = arch.registers.ControlRegisters.Cr3;

     

       5
       5
       +
       const Cr4 = arch.registers.ControlRegisters.Cr4;

     

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

     

       5
       7
        
       const Perms = common.mm.paging.Perms;

     

       6
       6
       -
       

     

       7
       7
       -
       pub const page_sizes = [_]usize{

     

       8
       8
       -
           0x1000, // 4K

     

       9
       9
       -
           0x200000, // 2M

     

       10
       10
       -
           0x40000000, // 1G

     

       11
       11
       -
           0x8000000000, // 512G

     

       12
       12
       -
           0x1000000000000, // 256T

     

       13
       13
       -
       };

     

       14
       8
        
       

     

       15
       9
        
       pub const PageTable = extern struct {

     

       16
       10
        
           entries: [512]Entry,

     
···

       43
       37
        
           };

     

       44
       38
        
       };

     

       45
       39
        
       

     

       46
       46
       -
       fn extract_index_from_vaddr(vaddr: u64, level: u6) u9 {

     

       47
       47
       -
           const shamt = 12 + level * 9;

     

       48
       48
       -
           return @truncate(vaddr >> shamt);

     

       40
       40
       +
       pub const MemoryType = enum {

     

       41
       41
       +
           DeviceUncacheable,

     

       42
       42
       +
           DeviceWriteCombining,

     

       43
       43
       +
           MemoryWritethrough,

     

       44
       44
       +
           MemoryWriteBack,

     

       45
       45
       +
       };

     

       46
       46
       +
       

     

       47
       47
       +
       pub fn detect_5level() bool {

     

       48
       48
       +
           const bits: u64 = 1 << 12;

     

       49
       49
       +
           return Cr4.read() & bits != 0;

     

       49
       50
        
       }

     

       50
       51
        
       

     

       51
       51
       -
       pub const TypedPTE = union(common.mm.paging.PTEType) {

     

       52
       52
       -
           Mapping: MappingHandle,

     

       53
       53
       -
           Table: TableHandle,

     

       54
       54
       -
           Empty,

     

       52
       52
       +
       pub const Context = struct {

     

       53
       53
       +
           cr3_val: u64,

     

       54
       54
       +
           level5: bool,

     

       55
       55
        
       

     

       56
       56
        
           const Self = @This();

     

       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);

     

       61
       61
       +
               IA32_EFER.write(efer_val);

     

       57
       62
        
       

     

       58
       58
       -
           pub fn decode(pte: *PageTable.Entry, level: u3) Self {

     

       63
       63
       +
               // Set the level 5 bit accordingly

     

       64
       64
       +
               const cr4 = Cr4.read();

     

       65
       65
       +
               const level5mask: u64 = 1 << 12;

     

       66
       66
       +
               Cr4.write(if (self.level5) cr4 | level5mask else cr4 & ~level5mask);

     

       67
       67
       +
       

     

       68
       68
       +
               Cr3.write(self.cr3_val);

     

       69
       69
       +
           }

     

       70
       70
       +
       

     

       71
       71
       +
           pub fn get_current() Context {

     

       72
       72
       +
               return .{

     

       73
       73
       +
                   .cr3_val = Cr3.read(),

     

       74
       74
       +
                   .level5 = detect_5level(),

     

       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
       +
       

     

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

     

       92
       92
       +
               return level < 2;

     

       93
       93
       +
           }

     

       94
       94
       +
       

     

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

     

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

     

       97
       97
       +
               return .{

     

       98
       98
       +
                   // Mask out the cr3 value

     

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

     

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

     

       101
       101
       +
                   .context = self,

     

       102
       102
       +
                   .perms = .{

     

       103
       103
       +
                       .x = true,

     

       104
       104
       +
                       .w = true,

     

       105
       105
       +
                       .u = true,

     

       106
       106
       +
                   },

     

       107
       107
       +
                   .underlying = null,

     

       108
       108
       +
               };

     

       109
       109
       +
           }

     

       110
       110
       +
       

     

       111
       111
       +
           pub fn decode(self: *Self, pte: *PageTable.Entry, level: u3) SomePteHandle {

     

       59
       112
        
               if (!pte.present) {

     

       60
       113
        
                   return .Empty;

     

       61
       114
        
               }

     

       62
       115
        
               if (!pte.huge and level != 0) {

     

       63
       63
       -
                   return .{ .Table = decode_table(pte, level) };

     

       116
       116
       +
                   return .{ .Table = self.parse_table(pte, level) };

     

       64
       117
        
               }

     

       65
       65
       -
               return .{ .Mapping = decode_mapping(pte, level) };

     

       118
       118
       +
               return .{ .Mapping = self.parse_mapping(pte, level) };

     

       66
       119
        
           }

     

       67
       120
        
       

     

       68
       68
       -
           pub fn decode_table(pte: *PageTable.Entry, level: u3) TableHandle {

     

       121
       121
       +
           pub fn parse_mapping(self: *Self, pte: *PageTable.Entry, level: u3) MappingHandle {

     

       122
       122
       +
               const memory_type = self.decode_memory_type(pte, level);

     

       69
       123
        
               return .{

     

       70
       70
       -
                   .phys_addr = pte.getAddr(),

     

       124
       124
       +
                   .context = self,

     

       125
       125
       +
                   .paddr = pte.getAddr(),

     

       71
       126
        
                   .level = level,

     

       127
       127
       +
                   .memory_type = memory_type,

     

       72
       128
        
                   .underlying = pte,

     

       73
       129
        
                   .perms = .{

     

       74
       74
       -
                       .writable = pte.writable,

     

       75
       75
       -
                       .executable = !pte.nx,

     

       76
       76
       -
                       .userspace_accessible = pte.user_accessible,

     

       130
       130
       +
                       .w = pte.writable,

     

       131
       131
       +
                       .x = !pte.nx,

     

       132
       132
       +
                       .u = pte.user_accessible,

     

       77
       133
        
                   },

     

       78
       134
        
               };

     

       79
       135
        
           }

     

       80
       136
        
       

     

       81
       81
       -
           pub fn decode_mapping(pte: *PageTable.Entry, level: u3) MappingHandle {

     

       137
       137
       +
           pub fn decode_memory_type(_: *Self, pte: *PageTable.Entry, _: u3) ?MemoryType {

     

       138
       138
       +
               return switch (pte.disable_cache) {

     

       139
       139
       +
                   true => .DeviceUncacheable,

     

       140
       140
       +
                   false => switch (pte.write_through) {

     

       141
       141
       +
                       true => .MemoryWritethrough,

     

       142
       142
       +
                       false => .MemoryWriteBack,

     

       143
       143
       +
                   },

     

       144
       144
       +
               };

     

       145
       145
       +
           }

     

       146
       146
       +
       

     

       147
       147
       +
           pub fn encode_memory_type(_: *Self, pte: *PageTable.Entry, mapping_handle: MappingHandle) void {

     

       148
       148
       +
               switch (mapping_handle.memory_type.?) {

     

       149
       149
       +
                   .MemoryWritethrough => pte.write_through = true,

     

       150
       150
       +
                   .DeviceUncacheable => pte.disable_cache = true,

     

       151
       151
       +
                   .MemoryWriteBack => {},

     

       152
       152
       +
                   else => @panic("bad memory type"),

     

       153
       153
       +
               }

     

       154
       154
       +
           }

     

       155
       155
       +
       

     

       156
       156
       +
           pub fn parse_table(self: *Self, pte: *PageTable.Entry, level: u3) TableHandle {

     

       82
       157
        
               return .{

     

       83
       83
       -
                   .phys_addr = pte.getAddr(),

     

       158
       158
       +
                   .context = self,

     

       159
       159
       +
                   .paddr = pte.getAddr(),

     

       84
       160
        
                   .level = level,

     

       85
       85
       -
                   // TODO: memory types

     

       86
       86
       -
                   .memory_type = null,

     

       87
       161
        
                   .underlying = pte,

     

       88
       162
        
                   .perms = .{

     

       89
       89
       -
                       .writable = pte.writable,

     

       90
       90
       -
                       .executable = !pte.nx,

     

       91
       91
       -
                       .userspace_accessible = pte.user_accessible,

     

       163
       163
       +
                       .w = pte.writable,

     

       164
       164
       +
                       .x = !pte.nx,

     

       165
       165
       +
                       .u = pte.user_accessible,

     

       92
       166
        
                   },

     

       93
       167
        
               };

     

       94
       168
        
           }

     

       169
       169
       +
       

     

       170
       170
       +
           pub fn encode_mapping(self: *Self, mapping_handle: MappingHandle) PageTable.Entry {

     

       171
       171
       +
               var pte = std.mem.zeroes(PageTable.Entry);

     

       172
       172
       +
               pte.setAddr(mapping_handle.paddr);

     

       173
       173
       +
               pte.present = true;

     

       174
       174
       +
               if (mapping_handle.level != 0) {

     

       175
       175
       +
                   pte.huge = true;

     

       176
       176
       +
               }

     

       177
       177
       +
       

     

       178
       178
       +
               pte.writable = mapping_handle.perms.w;

     

       179
       179
       +
               pte.user_accessible = mapping_handle.perms.u;

     

       180
       180
       +
               pte.nx = !mapping_handle.perms.x;

     

       181
       181
       +
       

     

       182
       182
       +
               self.encode_memory_type(&pte, mapping_handle);

     

       183
       183
       +
               return pte;

     

       184
       184
       +
           }

     

       185
       185
       +
       

     

       186
       186
       +
           pub fn encode_table(_: *Self, table_handle: TableHandle) PageTable.Entry {

     

       187
       187
       +
               var pte = std.mem.zeroes(PageTable.Entry);

     

       188
       188
       +
               pte.writable = table_handle.perms.w;

     

       189
       189
       +
               pte.user_accessible = table_handle.perms.u;

     

       190
       190
       +
               pte.nx = !table_handle.perms.x;

     

       191
       191
       +
               pte.setAddr(table_handle.paddr);

     

       192
       192
       +
       

     

       193
       193
       +
               pte.present = true;

     

       194
       194
       +
               pte.huge = false;

     

       195
       195
       +
       

     

       196
       196
       +
               return pte;

     

       197
       197
       +
           }

     

       198
       198
       +
       

     

       199
       199
       +
           pub fn invalidate(_: *const Self, vaddr: u64) void {

     

       200
       200
       +
               asm volatile (

     

       201
       201
       +
                   \\ invlpg (%[vaddr])

     

       202
       202
       +
                   :

     

       203
       203
       +
                   : [vaddr] "r" (vaddr),

     

       204
       204
       +
                   : .{ .memory = true });

     

       205
       205
       +
           }

     

       206
       206
       +
       

     

       207
       207
       +
           pub fn domain(_: *const Self, level: u3, vaddr: u64) StupidSlice {

     

       208
       208
       +
               return .{

     

       209
       209
       +
                   .ptr = vaddr & ~(page_sizes[level] - 1),

     

       210
       210
       +
                   .len = page_sizes[level],

     

       211
       211
       +
               };

     

       212
       212
       +
           }

     

       213
       213
       +
       

     

       214
       214
       +
           pub fn virt_to_phys(context: *Context, vaddr: usize) ?usize {

     

       215
       215
       +
               const root = context.root_table(0).get_children();

     

       216
       216
       +
               const indexes = [_]usize{

     

       217
       217
       +
                   (vaddr >> 39) & 0x1FF,

     

       218
       218
       +
                   (vaddr >> 30) & 0x1FF,

     

       219
       219
       +
                   (vaddr >> 21) & 0x1FF,

     

       220
       220
       +
                   (vaddr >> 12) & 0x1FF,

     

       221
       221
       +
               };

     

       222
       222
       +
               var pte_ptr = &root[indexes[0]];

     

       223
       223
       +
               std.log.warn("{*}: {any}, addr 0x{x}", .{ pte_ptr, pte_ptr, pte_ptr.getAddr() });

     

       224
       224
       +
               for (0..3) |i| {

     

       225
       225
       +
                   if (!pte_ptr.present) {

     

       226
       226
       +
                       return null;

     

       227
       227
       +
                   }

     

       228
       228
       +
                   const next_page_table = common.mm.physToHHDM(*PageTable, pte_ptr.getAddr());

     

       229
       229
       +
                   pte_ptr = &next_page_table.entries[indexes[i + 1]];

     

       230
       230
       +
                   std.log.warn("{*}: {any}, addr 0x{x}", .{ pte_ptr, pte_ptr, pte_ptr.getAddr() });

     

       231
       231
       +
               }

     

       232
       232
       +
               return pte_ptr.getAddr() + (vaddr & 0xFFF);

     

       233
       233
       +
           }

     

       95
       234
        
       };

     

       96
       235
        
       

     

       97
       97
       -
       pub const MappingHandle = struct {

     

       98
       98
       -
           phys_addr: usize,

     

       236
       236
       +
       fn idx_from_level(vaddr: u64, level: u6) u9 {

     

       237
       237
       +
           const shamt = 12 + level * 9;

     

       238
       238
       +
           return @truncate(vaddr >> shamt);

     

       239
       239
       +
       }

     

       240
       240
       +
       

     

       241
       241
       +
       pub fn make_page_table() !usize {

     

       242
       242
       +
           const page_size = std.heap.pageSize();

     

       243
       243
       +
           const paddr = try common.init_data.bootmem.allocPhys(page_size);

     

       244
       244
       +
           const pt_ptr = common.mm.physToHHDM([*]u8, paddr);

     

       245
       245
       +
           @memset(pt_ptr[0..page_size], 0);

     

       246
       246
       +
           return paddr;

     

       247
       247
       +
       }

     

       248
       248
       +
       

     

       249
       249
       +
       pub const page_sizes = [_]usize{

     

       250
       250
       +
           0x1000,

     

       251
       251
       +
           0x200000,

     

       252
       252
       +
           0x40000000,

     

       253
       253
       +
           0x8000000000,

     

       254
       254
       +
           0x1000000000000,

     

       255
       255
       +
       };

     

       256
       256
       +
       

     

       257
       257
       +
       const MappingHandle = struct {

     

       258
       258
       +
           paddr: u64,

     

       99
       259
        
           level: u3,

     

       100
       260
        
           memory_type: ?MemoryType,

     

       261
       261
       +
           context: *Context,

     

       101
       262
        
           perms: Perms,

     

       102
       263
        
           underlying: *PageTable.Entry,

     

       103
       264
        
       };

     

       104
       265
        
       

     

       105
       266
        
       pub const TableHandle = struct {

     

       106
       106
       -
           phys_addr: usize,

     

       267
       267
       +
           paddr: u64,

     

       107
       268
        
           level: u3,

     

       269
       269
       +
           context: *Context,

     

       108
       270
        
           perms: Perms,

     

       109
       271
        
           underlying: ?*PageTable.Entry,

     

       110
       272
        
       

     

       111
       273
        
           const Self = @This();

     

       112
       112
       -
       

     

       113
       113
       -
           // Get the child entries of this page table

     

       114
       274
        
           pub fn get_children(self: *const Self) []PageTable.Entry {

     

       115
       115
       -
               const page_table = physToVirt(*PageTable, self.phys_addr);

     

       116
       116
       -
               return page_table.entries[0..];

     

       275
       275
       +
               const pt = common.mm.physToHHDM(*PageTable, self.paddr);

     

       276
       276
       +
               return pt.entries[0..];

     

       117
       277
        
           }

     

       118
       278
        
       

     

       119
       119
       -
           // Get children from the position holding the table and on

     

       120
       120
       -
           pub fn skip_to(self: *const Self, vaddr: usize) []PageTable.Entry {

     

       121
       121
       -
               return self.get_children()[extract_index_from_vaddr(vaddr, self.level - 1)..];

     

       279
       279
       +
           pub fn skip_to(self: *const Self, vaddr: u64) []PageTable.Entry {

     

       280
       280
       +
               return self.get_children()[idx_from_level(vaddr, self.level - 1)..];

     

       122
       281
        
           }

     

       123
       282
        
       

     

       124
       124
       -
           // Decode child table given an entry

     

       125
       125
       -
           pub fn decode_child(self: *const Self, pte: *PageTable.Entry) TypedPTE {

     

       126
       126
       -
               return TypedPTE.decode(pte, self.level - 1);

     

       283
       283
       +
           pub fn decode_child(self: *const Self, pte: *PageTable.Entry) SomePteHandle {

     

       284
       284
       +
               return self.context.decode(pte, self.level - 1);

     

       127
       285
        
           }

     

       128
       286
        
       

     

       129
       287
        
           pub fn addPerms(self: *const Self, perms: Perms) void {

     

       130
       130
       -
               if (perms.executable) {

     

       288
       288
       +
               if (perms.x) {

     

       131
       289
        
                   self.underlying.?.nx = false;

     

       132
       290
        
               }

     

       133
       133
       -
               if (perms.writable) {

     

       291
       291
       +
               if (perms.w) {

     

       134
       292
        
                   self.underlying.?.writable = true;

     

       135
       293
        
               }

     

       136
       136
       -
               if (perms.userspace_accessible) {

     

       294
       294
       +
               if (perms.u) {

     

       137
       295
        
                   self.underlying.?.user_accessible = true;

     

       138
       296
        
               }

     

       139
       297
        
           }

     

       140
       298
        
       

     

       141
       141
       -
           pub fn child_domain(self: *const Self, vaddr: usize) UntypedSlice {

     

       142
       142
       -
               return domain(vaddr, self.level - 1);

     

       143
       143
       -
           }

     

       144
       144
       -
       

     

       145
       299
        
           pub fn make_child_table(self: *const Self, pte: *PageTable.Entry, perms: Perms) !TableHandle {

     

       146
       300
        
               const pmem = try make_page_table();

     

       147
       301
        
       

     

       148
       302
        
               const result: TableHandle = .{

     

       149
       149
       -
                   .phys_addr = pmem,

     

       303
       303
       +
                   .paddr = pmem,

     

       304
       304
       +
                   .context = self.context,

     

       150
       305
        
                   .level = self.level - 1,

     

       151
       306
        
                   .perms = perms,

     

       152
       307
        
                   .underlying = pte,

     

       153
       308
        
               };

     

       154
       154
       -
               pte.* = encode_table(result);

     

       309
       309
       +
               pte.* = self.context.encode_table(result);

     

       155
       310
        
       

     

       156
       311
        
               return result;

     

       157
       312
        
           }

     

       158
       313
        
       

     

       159
       159
       -
           pub fn make_child_mapping(

     

       160
       160
       -
               self: *const Self,

     

       161
       161
       -
               pte: *PageTable.Entry,

     

       162
       162
       -
               paddr: ?usize,

     

       163
       163
       -
               perms: Perms,

     

       164
       164
       -
               memory_type: MemoryType,

     

       165
       165
       -
           ) !MappingHandle {

     

       314
       314
       +
           pub fn make_child_mapping(self: *const Self, pte: *PageTable.Entry, paddr: ?u64, perms: Perms, memory_type: MemoryType) !MappingHandle {

     

       166
       315
        
               const page_size = page_sizes[self.level - 1];

     

       167
       316
        
               const pmem = paddr orelse try common.init_data.bootmem.allocPhys(page_size);

     

       168
       317
        
       

     

       169
       318
        
               const result: MappingHandle = .{

     

       170
       319
        
                   .level = self.level - 1,

     

       171
       320
        
                   .memory_type = memory_type,

     

       321
       321
       +
                   .context = self.context,

     

       172
       322
        
                   .perms = perms,

     

       173
       323
        
                   .underlying = pte,

     

       174
       174
       -
                   .phys_addr = pmem,

     

       324
       324
       +
                   .paddr = pmem,

     

       175
       325
        
               };

     

       176
       326
        
       

     

       177
       177
       -
               pte.* = encode_mapping(result);

     

       327
       327
       +
               pte.* = self.context.encode_mapping(result);

     

       178
       328
        
       

     

       179
       329
        
               return result;

     

       180
       330
        
           }

     

       181
       181
       -
       };

     

       182
       331
        
       

     

       183
       183
       -
       pub fn root_table(vaddr: usize) TableHandle {

     

       184
       184
       -
           _ = vaddr;

     

       185
       185
       -
           const cr3_val = arch.registers.ControlRegisters.Cr3.read() & 0xFFFF_FFFF_FFFF_F000;

     

       186
       186
       -
           return .{

     

       187
       187
       -
               .phys_addr = cr3_val,

     

       188
       188
       -
               // TODO: detect and support 5 level paging!

     

       189
       189
       -
               .level = 4,

     

       190
       190
       -
               .perms = .{

     

       191
       191
       -
                   .executable = true,

     

       192
       192
       -
                   .writable = true,

     

       193
       193
       -
               },

     

       194
       194
       -
               .underlying = null,

     

       195
       195
       -
           };

     

       196
       196
       -
       }

     

       197
       197
       -
       

     

       198
       198
       -
       fn encode_table(pte_handle: TableHandle) PageTable.Entry {

     

       199
       199
       -
           var pte = std.mem.zeroes(PageTable.Entry);

     

       200
       200
       -
       

     

       201
       201
       -
           pte.setAddr(pte_handle.phys_addr);

     

       202
       202
       -
           pte.writable = pte_handle.perms.writable;

     

       203
       203
       -
           pte.user_accessible = pte_handle.perms.userspace_accessible;

     

       204
       204
       -
           pte.nx = !pte_handle.perms.executable;

     

       205
       205
       -
           pte.present = true;

     

       206
       206
       -
           pte.huge = false;

     

       207
       207
       -
       

     

       208
       208
       -
           return pte;

     

       209
       209
       -
       }

     

       210
       210
       -
       

     

       211
       211
       -
       fn encode_mapping(pte_handle: MappingHandle) PageTable.Entry {

     

       212
       212
       -
           var pte = std.mem.zeroes(PageTable.Entry);

     

       213
       213
       -
       

     

       214
       214
       -
           pte.setAddr(pte_handle.phys_addr);

     

       215
       215
       -
           pte.present = true;

     

       216
       216
       -
       

     

       217
       217
       -
           if (pte_handle.level != 0) {

     

       218
       218
       -
               pte.huge = true;

     

       332
       332
       +
           pub fn child_domain(self: *const Self, vaddr: u64) StupidSlice {

     

       333
       333
       +
               return self.context.domain(self.level - 1, vaddr);

     

       219
       334
        
           }

     

       220
       220
       -
       

     

       221
       221
       -
           pte.writable = pte_handle.perms.writable;

     

       222
       222
       -
           pte.user_accessible = pte_handle.perms.userspace_accessible;

     

       223
       223
       -
           pte.nx = !pte_handle.perms.executable;

     

       224
       224
       -
       

     

       225
       225
       -
           encode_memory_type(&pte, pte_handle);

     

       226
       226
       -
       

     

       227
       227
       -
           return pte;

     

       228
       228
       -
       }

     

       335
       335
       +
       };

     

       229
       336
        
       

     

       230
       230
       -
       fn encode_memory_type(pte: *PageTable.Entry, pte_handle: MappingHandle) void {

     

       231
       231
       -
           const mt = pte_handle.memory_type orelse @panic("Unknown memory type");

     

       337
       337
       +
       pub const SomePteHandle = union(common.mm.paging.PTEType) {

     

       338
       338
       +
           Mapping: MappingHandle,

     

       339
       339
       +
           Table: TableHandle,

     

       340
       340
       +
           Empty,

     

       341
       341
       +
       };

     

       232
       342
        
       

     

       233
       233
       -
           // TODO: Page Attribute Table

     

       234
       234
       -
           switch (mt) {

     

       235
       235
       -
               .MemoryWritethrough => pte.write_through = true,

     

       236
       236
       -
               .DeviceUncacheable => pte.disable_cache = true,

     

       237
       237
       -
               .MemoryWriteBack => {},

     

       238
       238
       -
               else => @panic("Cannot set memory type"),

     

       239
       239
       -
           }

     

       240
       240
       -
       }

     

       241
       241
       -
       

     

       242
       242
       -
       /// Returns physical address

     

       243
       243
       -
       fn make_page_table() !usize {

     

       244
       244
       -
           const pt_phys = try common.init_data.bootmem.allocPhys(std.heap.pageSize());

     

       245
       245
       -
           const pt = physToVirt([*]u8, pt_phys);

     

       246
       246
       -
           @memset(pt[0..std.heap.pageSize()], 0x00);

     

       247
       247
       -
           return pt_phys;

     

       248
       248
       -
       }

     

       249
       249
       -
       

     

       250
       250
       -
       pub fn invalidate(vaddr: u64) void {

     

       251
       251
       -
           asm volatile (

     

       252
       252
       -
               \\ invlpg (%[vaddr])

     

       253
       253
       -
               :

     

       254
       254
       -
               : [vaddr] "r" (vaddr),

     

       255
       255
       -
               : .{ .memory = true });

     

       256
       256
       -
       }

     

       257
       257
       -
       

     

       258
       258
       -
       const UntypedSlice = struct {

     

       343
       343
       +
       pub const StupidSlice = struct {

     

       259
       344
        
           len: usize,

     

       260
       345
        
           ptr: usize,

     

       261
       346
        
       };

     

       262
       347
        
       

     

       263
       263
       -
       pub fn domain(vaddr: usize, level: u3) UntypedSlice {

     

       264
       264
       -
           return .{

     

       265
       265
       -
               .len = page_sizes[level],

     

       266
       266
       -
               .ptr = vaddr & ~(page_sizes[level] - 1),

     

       267
       267
       -
           };

     

       268
       268
       -
       }

     

       269
       269
       -
       

     

       270
       270
       -
       pub const MemoryType = enum {

     

       271
       271
       -
           DeviceUncacheable,

     

       272
       272
       -
           DeviceWriteCombining,

     

       273
       273
       -
           MemoryWritethrough,

     

       274
       274
       -
           MemoryWriteBack,

     

       275
       275
       -
       };

     

       276
       276
       -
       

     

       277
       277
       -
       pub fn can_map_at(level: u3) bool {

     

       278
       278
       -
           return level < 2;

     

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

     

       349
       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 });

     

       352
       352
       +
           arch.instructions.die();

     

       279
       353
        
       }

+21 -23

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
        
       

     

       26
       23
        
       const PerCpuInitData = struct {

     

       27
       24
        
           const StandardGdt = structures.gdt.StandardGdt;

     

       28
       25
        
           const Tss = structures.tss.Tss;

     

       29
       29
       -
           const Idt = structures.Idt;

     

       30
       26
        
       

     

       31
       27
        
           gdt_buf: []StandardGdt = undefined,

     

       32
       28
        
           tss_buf: []Tss = undefined,

     

       33
       33
       -
           idt: *Idt = undefined,

     

       29
       29
       +
           // Physical ptr

     

       30
       30
       +
           stack_buf: usize = undefined,

     

       31
       31
       +
       

     

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

     

       34
       33
        
       

     

       35
       34
        
           const Self = @This();

     

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

     

       37
       37
       -
               // 1. Allocate an IDT

     

       38
       38
       -
               const idt_addr = common.init_data.bootmem.allocMem(@sizeOf(Idt)) catch |err| {

     

       39
       39
       -
                   std.log.err("init PerCpuInitData: IDT alloc failed: {}", .{err});

     

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

     

       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");

     

       41
       40
        
               };

     

       42
       42
       -
               self.idt = @ptrFromInt(idt_addr);

     

       43
       41
        
       

     

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

     

       45
       43
        
               const gdt_size = @sizeOf(StandardGdt);

     
···

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

     

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

     

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

     

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

     

       49
       49
       +
                   @panic("gdt_tss_buf");

     

       52
       50
        
               });

     

       53
       51
        
       

     

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

     
···

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

     

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

     

       59
       57
        
           }

     

       60
       60
       -
       };

     

       61
       58
        
       

     

       62
       62
       -
       comptime {

     

       63
       63
       -
           // Entry point (_start)

     

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

     

       65
       65
       -
       }

     

       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
       +
       };

-170

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

···

       1
       1
       -
       //! The entire Interrupt Descriptor Table (IDT) structure for AMD64,

     

       2
       2
       -
       //! including all the necessary ISR entries. Each of the defined

     

       3
       3
       -
       //! ISRs is meant for a specific type of exception, while the

     

       4
       4
       -
       //! array at the end of the IDT can be used for whatever is necessary.

     

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

     

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

     

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

     

       8
       8
       -
       

     

       9
       9
       -
       /// Faulty division (mostly divide by zero)

     

       10
       10
       -
       divide_error: Entry(.handler),

     

       11
       11
       -
       /// AMD64 Debug Exception, either a fault or a trap

     

       12
       12
       -
       debug_exception: Entry(.handler),

     

       13
       13
       -
       /// Non Maskable Interrupt

     

       14
       14
       -
       non_maskable_interrupt: Entry(.handler),

     

       15
       15
       -
       /// Breakpoint (int3) trap

     

       16
       16
       -
       breakpoint: Entry(.handler),

     

       17
       17
       -
       /// Overflow trap (INTO instruction)

     

       18
       18
       -
       overflow: Entry(.handler),

     

       19
       19
       -
       /// Bound Range Exception (BOUND instruction)

     

       20
       20
       -
       bound_range_exceeded: Entry(.handler),

     

       21
       21
       -
       /// Invalid Opcode Exception

     

       22
       22
       -
       invalid_opcode: Entry(.handler),

     

       23
       23
       -
       /// Device Not Available (FPU instructions when FPU disabled)

     

       24
       24
       -
       device_not_available: Entry(.handler),

     

       25
       25
       -
       /// Double Fault Exception

     

       26
       26
       -
       double_fault: Entry(.abort_with_err_code),

     

       27
       27
       -
       _coprocessor_segment_overrun: Entry(.handler),

     

       28
       28
       -
       /// Invalid TSS: bad segment selector

     

       29
       29
       -
       invalid_tss: Entry(.handler_with_err_code),

     

       30
       30
       -
       /// Segment Not Present

     

       31
       31
       -
       segment_not_present: Entry(.handler_with_err_code),

     

       32
       32
       -
       /// Stack Segment Fault

     

       33
       33
       -
       stack_segment_fault: Entry(.handler_with_err_code),

     

       34
       34
       -
       /// General Protection Fault

     

       35
       35
       -
       general_protection_fault: Entry(.handler_with_err_code),

     

       36
       36
       -
       /// Page Fault

     

       37
       37
       -
       page_fault: Entry(.handler_with_err_code),

     

       38
       38
       -
       

     

       39
       39
       -
       _reserved1: Entry(.handler),

     

       40
       40
       -
       /// x87 Floating Point Exception

     

       41
       41
       -
       x87_floating_point: Entry(.handler),

     

       42
       42
       -
       /// Alignment Check Exception

     

       43
       43
       -
       alignment_check: Entry(.handler_with_err_code),

     

       44
       44
       -
       /// Machine Check Exception (MCE)

     

       45
       45
       -
       machine_check: Entry(.abort),

     

       46
       46
       -
       /// SIMD Floating Point Exception

     

       47
       47
       -
       simd_floating_point: Entry(.handler),

     

       48
       48
       -
       /// Virtualization Exception

     

       49
       49
       -
       virtualization: Entry(.handler),

     

       50
       50
       -
       /// Control Protection Exception

     

       51
       51
       -
       control_protection: Entry(.handler_with_err_code),

     

       52
       52
       -
       _reserved2: [10]Entry(.handler),

     

       53
       53
       -
       /// User Accessible Interrupts

     

       54
       54
       -
       interrupts: [256 - 32]Entry(.handler),

     

       55
       55
       -
       

     

       56
       56
       -
       /// An ISR Entry in the IDT

     

       57
       57
       -
       pub const EntryType = union(enum) {

     

       58
       58
       -
           abort: void,

     

       59
       59
       -
           abort_with_err_code: void,

     

       60
       60
       -
           handler: void,

     

       61
       61
       -
           handler_with_err_code: void,

     

       62
       62
       -
           handler_with_custom_err_code: type,

     

       63
       63
       -
       };

     

       64
       64
       -
       pub fn Entry(comptime entry_type: EntryType) type {

     

       65
       65
       -
           const return_type = switch (entry_type) {

     

       66
       66
       -
               .abort, .abort_with_err_code => noreturn,

     

       67
       67
       -
               .handler, .handler_with_err_code, .handler_with_custom_err_code => void,

     

       68
       68
       -
           };

     

       69
       69
       -
           const params: []const std.builtin.Type.Fn.Param = switch (entry_type) {

     

       70
       70
       -
               .handler, .abort => &.{

     

       71
       71
       -
                   // Interrupt stack frame

     

       72
       72
       -
                   .{ .is_generic = false, .is_noalias = false, .type = *InterruptStackFrame },

     

       73
       73
       -
               },

     

       74
       74
       -
               .handler_with_err_code, .abort_with_err_code => &.{

     

       75
       75
       -
                   // Interrupt stack frame

     

       76
       76
       -
                   .{ .is_generic = false, .is_noalias = false, .type = *InterruptStackFrame },

     

       77
       77
       -
                   // Error code

     

       78
       78
       -
                   .{ .is_generic = false, .is_noalias = false, .type = u64 },

     

       79
       79
       -
               },

     

       80
       80
       -
               .handler_with_custom_err_code => |err_code_type| &.{

     

       81
       81
       -
                   // Interrupt stack frame

     

       82
       82
       -
                   .{ .is_generic = false, .is_noalias = false, .type = *InterruptStackFrame },

     

       83
       83
       -
                   // Custom Error code

     

       84
       84
       -
                   .{ .is_generic = false, .is_noalias = false, .type = err_code_type },

     

       85
       85
       -
               },

     

       86
       86
       -
           };

     

       87
       87
       -
           const FunctionTypeInfo: std.builtin.Type = .{

     

       88
       88
       -
               .@"fn" = .{

     

       89
       89
       -
                   .calling_convention = .{ .x86_64_interrupt = .{} },

     

       90
       90
       -
                   .is_generic = false,

     

       91
       91
       -
                   .is_var_args = false,

     

       92
       92
       -
                   .return_type = return_type,

     

       93
       93
       -
                   .params = params,

     

       94
       94
       -
               },

     

       95
       95
       -
           };

     

       96
       96
       -
       

     

       97
       97
       -
           // The actual IDT entry structure

     

       98
       98
       -
           return extern struct {

     

       99
       99
       -
               func_low: u16,

     

       100
       100
       -
               gdt_selector: u16,

     

       101
       101
       -
               options: Options,

     

       102
       102
       -
               func_mid: u16,

     

       103
       103
       -
               func_high: u32,

     

       104
       104
       -
               _reserved: u32 = 0,

     

       105
       105
       -
       

     

       106
       106
       -
               const FuncType = @Type(FunctionTypeInfo);

     

       107
       107
       -
       

     

       108
       108
       -
               pub const Options = packed struct(u16) {

     

       109
       109
       -
                   /// Interrupt Stack Table Index

     

       110
       110
       -
                   ist_index: u3,

     

       111
       111
       -
                   _reserved: u5 = 0,

     

       112
       112
       -
                   disable_interrupts: bool,

     

       113
       113
       -
                   must_be_one: u3 = 0b111,

     

       114
       114
       -
                   must_be_zero: u1 = 0,

     

       115
       115
       -
                   /// Descriptor Privilege Level

     

       116
       116
       -
                   dpl: u2,

     

       117
       117
       -
                   present: bool,

     

       118
       118
       -
               };

     

       119
       119
       -
       

     

       120
       120
       -
               const Self = @This();

     

       121
       121
       -
       

     

       122
       122
       -
               pub fn installHandler(self: *Self, func: *const FuncType) void {

     

       123
       123
       -
                   // Fetch the Code Segment

     

       124
       124
       -
                   const func_ptr = @intFromPtr(func);

     

       125
       125
       -
                   self.* = .{

     

       126
       126
       -
                       // Set the function pointer

     

       127
       127
       -
                       .func_low = @truncate(func_ptr & 0xFFFF),

     

       128
       128
       -
                       .func_mid = @truncate((func_ptr >> 16) & 0xFFFF),

     

       129
       129
       -
                       .func_high = @truncate((func_ptr >> 32) & 0xFFFF_FFFF),

     

       130
       130
       -
                       .gdt_selector = StandardGdt.selectors.kernel_code,

     

       131
       131
       -
                       .options = .{

     

       132
       132
       -
                           // No Interrupt Stack Table yet

     

       133
       133
       -
                           .ist_index = 0,

     

       134
       134
       -
                           // Mask interrupts while running ISR handler

     

       135
       135
       -
                           .disable_interrupts = true,

     

       136
       136
       -
                           // Ring 3 Minimum privilege level

     

       137
       137
       -
                           .dpl = 3,

     

       138
       138
       -
                           // Mark as present

     

       139
       139
       -
                           .present = true,

     

       140
       140
       -
                       },

     

       141
       141
       -
                   };

     

       142
       142
       -
               }

     

       143
       143
       -
           };

     

       144
       144
       -
       }

     

       145
       145
       -
       

     

       146
       146
       -
       /// IDT Register

     

       147
       147
       -
       pub const Idtr = packed struct(u80) {

     

       148
       148
       -
           limit: u16,

     

       149
       149
       -
           addr: u64,

     

       150
       150
       -
       

     

       151
       151
       -
           /// Load the IDT Register

     

       152
       152
       -
           pub fn load(self: *const Idtr) void {

     

       153
       153
       -
               asm volatile ("lidt (%[idtr_addr])"

     

       154
       154
       -
                   :

     

       155
       155
       -
                   : [idtr_addr] "r" (self),

     

       156
       156
       -
               );

     

       157
       157
       -
           }

     

       158
       158
       -
       };

     

       159
       159
       -
       

     

       160
       160
       -
       /// Interrupt Stack Frame

     

       161
       161
       -
       /// TODO: maybe move this somewhere else

     

       162
       162
       -
       pub const InterruptStackFrame = extern struct {

     

       163
       163
       -
           instruction_pointer: u64,

     

       164
       164
       -
           code_segment: u16,

     

       165
       165
       -
           _reserved1: [6]u8,

     

       166
       166
       -
           cpu_flags: u64,

     

       167
       167
       -
           stack_pointer: u64,

     

       168
       168
       -
           stack_segment: u16,

     

       169
       169
       -
           _reserved2: [6]u8,

     

       170
       170
       -
       };

+24 -1

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
       -
       pub const Idt = @import("Idt.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

+14 -20

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 console_mod = console_dep.module("console");

     

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

     

       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);

     

       79
       79
       -
       

     

       80
       80
       -
           console_mod.addImport("limine", limine_mod);

     

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

     

       81
       74
        
       

     

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

     

       83
       83
       -
           common_mod.addImport("console", console_mod);

     

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

     

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

     

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

     

       85
       79
        
       

     

       86
       80
        
           const kernel = b.addExecutable(.{

     

       87
       81
        
               .name = "ukernel",

     

       88
       88
       -
               .root_module = arch_module,

     

       82
       82
       +
               .root_module = common_mod,

     

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

     

       90
       84
        
               .use_llvm = true,

     

       91
       85
        
           });

     

       92
       86
        
       

     

       93
       87
        
           kernel.pie = false;

     

       94
       94
       -
           kernel.want_lto = true;

     

       88
       88
       +
           kernel.want_lto = false;

     

       95
       89
        
           kernel.setLinkerScript(b.path(linker_script_path));

     

       96
       90
        
           b.installArtifact(kernel);

     

       97
       91
        
       }

+5 -1

components/ukernel/build.zig.zon

···

       6
       6
        
           .dependencies = .{

     

       7
       7
        
               .limine = .{ .path = "deps/limine-zig" },

     

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

     

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

     

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

     

       10
       10
       -
               .build_helpers = .{ .path = "../build_helpers" },

     

       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",

+17 -7

components/ukernel/common/aux.zig

···

       19
       19
        
           console: ?console.Console = null,

     

       20
       20
        
           framebuffer: ?console.Framebuffer = null,

     

       21
       21
        
           hardware_description: HardwareDescription = .none,

     

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

     

       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,

     

       24
       25
        
       };

     

       25
       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
       +
       

     

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

     

       27
       38
        
       

     

       28
       39
        
       pub fn logFn(

     
···

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

     

       35
       46
        
       

     

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

     

       37
       37
       -
           const level, const color = switch (message_level) {

     

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

     

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

     

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

     

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

     
···

       51
       62
        
               stdout_lock.lock();

     

       52
       63
        
               defer stdout_lock.unlock();

     

       53
       64
        
       

     

       54
       54
       -
               const cons = &common.init_data.console.?;

     

       55
       55
       -
       

     

       56
       56
       -
               cons.setColor(color, 0);

     

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

     

       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;

     

       58
       69
        
           }

     

       59
       70
        
       }

     

       60
       71
        
       

     

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

     

       62
       73
        
           _ = first_trace_addr;

     

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

     

       64
       64
       -
           common.init_data.console.?.setColor(0xff0000, 0);

     

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

     

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

     

       67
       77
        
           defer it.deinit();

+9 -8

components/ukernel/common/loader.zig

···

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

     

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

     

       2
       3
        
       const paging = common.mm.paging;

     

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

     

       4
       5
        
       const elf = std.elf;

     

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

     

       6
       7
        
       

     

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

     

       8
       8
       -
       pub fn loadRootTask() !usize {

     

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

     

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

     

       10
       10
        
           const hdr = blk: {

     

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

     

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

     

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

     

       13
       13
        
           };

     

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

     

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

     

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

     

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

     

       17
       17
        
       

     
···

       27
       27
        
                   .size = memsz_pages,

     

       28
       28
        
                   .memory_type = .MemoryWriteBack,

     

       29
       29
        
                   .perms = .{

     

       30
       30
       -
                       .executable = entry.p_flags & elf.PF_X > 0,

     

       31
       31
       -
                       .writable = entry.p_flags & elf.PF_W > 0,

     

       32
       32
       -
                       .userspace_accessible = true,

     

       30
       30
       +
                       .x = entry.p_flags & elf.PF_X > 0,

     

       31
       31
       +
                       .w = entry.p_flags & elf.PF_W > 0,

     

       32
       32
       +
                       .u = true,

     

       33
       33
        
                   },

     

       34
       34
       +
                   .context = context,

     

       34
       35
        
               });

     

       35
       36
        
       

     

       36
       37
        
               // 2. Copy filesz bytes from offset to this new page

     

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

     

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

     

       39
       40
        
       

     

       40
       40
       -
               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];

     

       41
       42
        
               @memcpy(dst_slice, src_slice);

     

       42
       43
        
       

     

       43
       44
        
               // 3. Add memsz - filesz zeroes

-1

components/ukernel/common/mm/bootmem.zig

···

       142
       142
        
       

     

       143
       143
        
           // Finally, initialize the global bootmem

     

       144
       144
        
           common.init_data.bootmem.initialize(bootmem_struct);

     

       145
       145
       -
           common.init_data.bootmem.debugInfo();

     

       146
       145
        
       }

+25 -17

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;

     

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

     

       5
       7
        
       

     

       6
       8
        
       pub const Perms = struct {

     

       7
       7
       -
           writable: bool,

     

       8
       8
       -
           executable: bool,

     

       9
       9
       -
           userspace_accessible: bool = false,

     

       9
       9
       +
           /// Writable

     

       10
       10
       +
           w: bool,

     

       11
       11
       +
           /// Executable

     

       12
       12
       +
           x: bool,

     

       13
       13
       +
           /// Userspace Accessible

     

       14
       14
       +
           u: bool = false,

     

       10
       15
        
       

     

       11
       16
        
           const Self = @This();

     

       12
       17
        
       

     

       13
       18
        
           /// Verify that the current permissions are a superset of the provided ones

     

       14
       19
        
           pub fn allows(self: Self, other: Self) bool {

     

       15
       15
       -
               if (!self.writable and other.writable) {

     

       20
       20
       +
               if (!self.w and other.w) {

     

       16
       21
        
                   return false;

     

       17
       22
        
               }

     

       18
       18
       -
               if (!self.executable and other.executable) {

     

       23
       23
       +
               if (!self.x and other.x) {

     

       19
       24
        
                   return false;

     

       20
       25
        
               }

     

       21
       21
       -
               if (!self.userspace_accessible and other.userspace_accessible) {

     

       26
       26
       +
               if (!self.u and other.u) {

     

       22
       27
        
                   return false;

     

       23
       28
        
               }

     

       24
       29
        
               return true;

     
···

       27
       32
        
           /// OR two permissions

     

       28
       33
        
           pub fn addPerms(self: Self, other: Self) Self {

     

       29
       34
        
               return .{

     

       30
       30
       -
                   .writable = self.writable or other.writable,

     

       31
       31
       -
                   .executable = self.executable or other.executable,

     

       32
       32
       -
                   .userspace = self.userspace_accessible or other.userspace_accessible,

     

       35
       35
       +
                   .w = self.w or other.w,

     

       36
       36
       +
                   .x = self.x or other.x,

     

       37
       37
       +
                   .u = self.u or other.u,

     

       33
       38
        
               };

     

       34
       39
        
           }

     

       35
       40
        
       };

     
···

       42
       47
        
           size: usize,

     

       43
       48
        
           perms: Perms,

     

       44
       49
        
           memory_type: MemoryType,

     

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

     

       45
       51
        
       }) !void {

     

       46
       46
       -
           const root = arch.mm.paging.root_table(args.vaddr);

     

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

     

       47
       53
        
           var vaddr = args.vaddr;

     

       48
       54
        
           var paddr = args.paddr;

     

       49
       55
        
           var size = args.size;

     

       50
       50
       -
           try mapPageImpl(&vaddr, &paddr, &size, root, args.perms, args.memory_type);

     

       56
       56
       +
           try mapPageImpl(&vaddr, &paddr, &size, root, args.perms, args.memory_type, args.context);

     

       51
       57
        
       }

     

       52
       58
        
       

     

       53
       59
        
       pub fn map(args: struct {

     
···

       55
       61
        
           size: usize,

     

       56
       62
        
           perms: Perms,

     

       57
       63
        
           memory_type: MemoryType,

     

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

     

       58
       65
        
       }) !void {

     

       59
       59
       -
           const root = arch.mm.paging.root_table(args.vaddr);

     

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

     

       60
       67
        
           var vaddr = args.vaddr;

     

       61
       68
        
           var size = args.size;

     

       62
       62
       -
           try mapPageImpl(&vaddr, null, &size, root, args.perms, args.memory_type);

     

       69
       69
       +
           try mapPageImpl(&vaddr, null, &size, root, args.perms, args.memory_type, args.context);

     

       63
       70
        
       }

     

       64
       71
        
       

     

       65
       72
        
       fn mapPageImpl(

     
···

       69
       76
        
           table: TableHandle,

     

       70
       77
        
           perms: Perms,

     

       71
       78
        
           memory_type: MemoryType,

     

       79
       79
       +
           context: *Context,

     

       72
       80
        
       ) !void {

     

       73
       81
        
           // 1. Get slice of every child from the target forwards

     

       74
       82
        
           const children = table.skip_to(vaddr.*);

     
···

       84
       92
        
               switch (table.decode_child(child)) {

     

       85
       93
        
                   .Mapping => return error.AlreadyPresent,

     

       86
       94
        
                   .Table => |*tbl| {

     

       87
       87
       -
                       try mapPageImpl(vaddr, paddr, size, tbl.*, perms, memory_type);

     

       95
       95
       +
                       try mapPageImpl(vaddr, paddr, size, tbl.*, perms, memory_type, context);

     

       88
       96
        
                       if (!tbl.perms.allows(perms)) {

     

       89
       97
        
                           tbl.addPerms(perms);

     

       90
       90
       -
                           arch.mm.paging.invalidate(vaddr.*);

     

       98
       98
       +
                           context.invalidate(vaddr.*);

     

       91
       99
        
                       }

     

       92
       100
        
                   },

     

       93
       101
        
                   .Empty => {

     

       94
       102
        
                       const domain = table.child_domain(vaddr.*);

     

       95
       95
       -
                       if (domain.ptr == vaddr.* and domain.len <= size.* and arch.mm.paging.can_map_at(table.level - 1) and is_aligned(vaddr.*, paddr, table.level - 1)) {

     

       103
       103
       +
                       if (domain.ptr == vaddr.* and domain.len <= size.* and context.can_map_at(table.level - 1) and is_aligned(vaddr.*, paddr, table.level - 1)) {

     

       96
       104
        
                           // Make child mapping etc

     

       97
       105
        
                           _ = try table.make_child_mapping(child, if (paddr) |p| p.* else null, perms, memory_type);

     

       98
       106
        
                           const step = domain.len;

     
···

       108
       116
        
                           }

     

       109
       117
        
                       } else {

     

       110
       118
        
                           const tbl = try table.make_child_table(child, perms);

     

       111
       111
       -
                           try mapPageImpl(vaddr, paddr, size, tbl, perms, memory_type);

     

       119
       119
       +
                           try mapPageImpl(vaddr, paddr, size, tbl, perms, memory_type, context);

     

       112
       120
        
                       }

     

       113
       121
        
                   },

     

       114
       122
        
               }

+80 -1

components/ukernel/common/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
       +
       }

+1 -2

components/ukernel/deps/console/build.zig

···

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

     

       2
       2
       -
       

     

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

     

       4
       3
        
           _ = b.addModule("console", .{

     

       5
       5
       -
               .root_source_file = b.path("console.zig"),

     

       4
       4
       +
               .root_source_file = b.path("src/root.zig"),

     

       6
       5
        
           });

     

       7
       6
        
       }

+4 -9

components/ukernel/deps/console/build.zig.zon

···

       1
       1
        
       .{

     

       2
       2
        
           .name = .console,

     

       3
       3
       -
           .fingerprint = 0x3603cfb6f7920fba,

     

       4
       4
       -
           .version = "0.0.1",

     

       3
       3
       +
           .version = "0.0.0",

     

       4
       4
       +
           .fingerprint = 0x3603cfb621692996, // Changing this has security and trust implications.

     

       5
       5
        
           .minimum_zig_version = "0.15.1",

     

       6
       6
       -
           .dependencies = .{

     

       7
       7
       -
               .limine = .{

     

       8
       8
       -
                   .path = "../limine-zig",

     

       9
       9
       -
               },

     

       10
       10
       -
           },

     

       6
       6
       +
           .dependencies = .{},

     

       11
       7
        
           .paths = .{

     

       12
       8
        
               "build.zig",

     

       13
       9
        
               "build.zig.zon",

     

       14
       14
       -
               "console.zig",

     

       15
       15
       -
               "psf2.zig",

     

       10
       10
       +
               "src",

     

       16
       11
        
               "fonts",

     

       17
       12
        
           },

     

       18
       13
        
       }

-195

components/ukernel/deps/console/console.zig

···

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

     

       2
       2
       -
       const builtin = @import("builtin");

     

       3
       3
       -
       const psf2 = @import("psf2.zig");

     

       4
       4
       -
       pub const Font = psf2.Font;

     

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

     

       6
       6
       -
       const fontdata = @embedFile("fonts/spleen-12x24.psf");

     

       7
       7
       -
       const are_we_le = builtin.cpu.arch.endian() == .little;

     

       8
       8
       -
       

     

       9
       9
       -
       pub const DefaultFont = Font.new(fontdata) catch unreachable;

     

       10
       10
       -
       

     

       11
       11
       -
       pub const Framebuffer = struct {

     

       12
       12
       -
           const Self = @This();

     

       13
       13
       -
           address: [*]u8,

     

       14
       14
       -
           width: u64,

     

       15
       15
       -
           height: u64,

     

       16
       16
       -
           pitch: u64,

     

       17
       17
       -
           bypp: u16,

     

       18
       18
       -
           red_mask_size: u8,

     

       19
       19
       -
           red_mask_shift: u8,

     

       20
       20
       -
           green_mask_size: u8,

     

       21
       21
       -
           green_mask_shift: u8,

     

       22
       22
       -
           blue_mask_size: u8,

     

       23
       23
       -
           blue_mask_shift: u8,

     

       24
       24
       -
       

     

       25
       25
       -
           pub fn from_limine(fb: *const limine.Framebuffer) Self {

     

       26
       26
       -
               return .{

     

       27
       27
       -
                   .address = @ptrCast(fb.address),

     

       28
       28
       -
                   .width = fb.width,

     

       29
       29
       -
                   .height = fb.height,

     

       30
       30
       -
                   .pitch = fb.pitch,

     

       31
       31
       -
                   .red_mask_size = fb.red_mask_size,

     

       32
       32
       -
                   .red_mask_shift = fb.red_mask_shift,

     

       33
       33
       -
                   .green_mask_size = fb.green_mask_size,

     

       34
       34
       -
                   .green_mask_shift = fb.green_mask_shift,

     

       35
       35
       -
                   .blue_mask_size = fb.blue_mask_size,

     

       36
       36
       -
                   .blue_mask_shift = fb.blue_mask_shift,

     

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

     

       38
       38
       -
               };

     

       39
       39
       -
           }

     

       40
       40
       -
       };

     

       41
       41
       -
       

     

       42
       42
       -
       pub const Console = struct {

     

       43
       43
       -
           const Self = @This();

     

       44
       44
       -
           const Writer = std.io.GenericWriter(*Self, error{}, write);

     

       45
       45
       -
           // framebuffer data

     

       46
       46
       -
           fb: Framebuffer,

     

       47
       47
       -
           // font

     

       48
       48
       -
           font: psf2.Font,

     

       49
       49
       -
           // state data

     

       50
       50
       -
           current_x: u64 = 0,

     

       51
       51
       -
           current_y: u64 = 0,

     

       52
       52
       -
           fg_color: u32 = 0xFFFFFFFF,

     

       53
       53
       -
           bg_color: u32 = 0,

     

       54
       54
       -
       

     

       55
       55
       -
           pub fn from_font(fb: Framebuffer, font: psf2.Font) Self {

     

       56
       56
       -
               return .{

     

       57
       57
       -
                   .fb = fb,

     

       58
       58
       -
                   .font = font,

     

       59
       59
       -
               };

     

       60
       60
       -
           }

     

       61
       61
       -
       

     

       62
       62
       -
           // places a character at the given position

     

       63
       63
       -
           pub fn putchar(self: *const Self, ch: u8, cx: u64, cy: u64, fg_val: u32, bg_val: u32) void {

     

       64
       64
       -
               // convert colors to bytes

     

       65
       65
       -
               const fg_bytes: [4]u8 = @bitCast(if (are_we_le) fg_val else @byteSwap(fg_val));

     

       66
       66
       -
               const bg_bytes: [4]u8 = @bitCast(if (are_we_le) bg_val else @byteSwap(bg_val));

     

       67
       67
       -
               // initial calculations

     

       68
       68
       -
               const bytes_per_line = self.font.hdr.bytesPerLine();

     

       69
       69
       -
               const mask_shamt: u5 = @intCast(bytes_per_line * 8 - 1);

     

       70
       70
       -
               const mask_initial: u32 = @as(u32, 1) << mask_shamt;

     

       71
       71
       -
               const glyph = self.font.getGlyph(ch) catch return;

     

       72
       72
       -
       

     

       73
       73
       -
               // find the screen offset for the beignning of the character

     

       74
       74
       -
               // add pitch to go to next line...

     

       75
       75
       -
               var offset: u64 = (cy * self.font.hdr.height * self.fb.pitch) + (cx * (self.font.hdr.width + 0) * self.fb.bypp);

     

       76
       76
       -
               // run for every line

     

       77
       77
       -
               var y: u32 = 0;

     

       78
       78
       -
               var mask: u32 = 0;

     

       79
       79
       -
               while (y < self.font.hdr.height) : (y += 1) {

     

       80
       80
       -
                   // initialize the mask and the current line

     

       81
       81
       -
                   mask = mask_initial;

     

       82
       82
       -
       

     

       83
       83
       -
                   // get the current line

     

       84
       84
       -
                   const line_value: u32 = psf2.readIntTo32(glyph[y * bytes_per_line ..][0..bytes_per_line]);

     

       85
       85
       -
                   var line_offset: u64 = offset;

     

       86
       86
       -
                   var x: u32 = 0;

     

       87
       87
       -
                   while (x < self.font.hdr.width) : (x += 1) {

     

       88
       88
       -
                       // write the pixel value to the correct position of the screen...

     

       89
       89
       -
                       if (line_value & mask != 0) {

     

       90
       90
       -
                           @memcpy(self.fb.address[line_offset..][0..self.fb.bypp], fg_bytes[0..]);

     

       91
       91
       -
                       } else {

     

       92
       92
       -
                           @memcpy(self.fb.address[line_offset..][0..self.fb.bypp], bg_bytes[0..]);

     

       93
       93
       -
                       }

     

       94
       94
       -
                       line_offset += self.fb.bypp;

     

       95
       95
       -
                       mask >>= 1;

     

       96
       96
       -
                   }

     

       97
       97
       -
                   offset += self.fb.pitch;

     

       98
       98
       -
               }

     

       99
       99
       -
           }

     

       100
       100
       -
       

     

       101
       101
       -
           pub fn putc(self: *Self, ch: u8) void {

     

       102
       102
       -
               // input can be \r, \n, or printable.

     

       103
       103
       -
               // ignore \r, move down for \n, and print char normally

     

       104
       104
       -
               // if \n, check to see if we overrun then scroll

     

       105
       105
       -
               // if normal, see if we overrun the end and do newline

     

       106
       106
       -
               if (ch == '\r') return;

     

       107
       107
       -
               if (ch == '\n') {

     

       108
       108
       -
                   self.current_x = 0;

     

       109
       109
       -
                   self.current_y += 1;

     

       110
       110
       -
                   // go to top if we went below the bottom of the screen

     

       111
       111
       -
                   if (self.current_y >= self.maxCharsHeight()) {

     

       112
       112
       -
                       self.scrollUp(1);

     

       113
       113
       -
                       self.current_y = self.maxCharsHeight() - 1;

     

       114
       114
       -
                   }

     

       115
       115
       -
                   return;

     

       116
       116
       -
               }

     

       117
       117
       -
               self.putchar(ch, self.current_x, self.current_y, self.fg_color, self.bg_color);

     

       118
       118
       -
               self.current_x += 1;

     

       119
       119
       -
       

     

       120
       120
       -
               if (self.current_x < self.maxCharsWidth()) return;

     

       121
       121
       -
               self.current_x = 0;

     

       122
       122
       -
               self.current_y += 1;

     

       123
       123
       -
               if (self.current_y >= self.maxCharsHeight()) {

     

       124
       124
       -
                   self.scrollUp(1);

     

       125
       125
       -
                   self.current_y = self.maxCharsHeight() - 1;

     

       126
       126
       -
               }

     

       127
       127
       -
           }

     

       128
       128
       -
       

     

       129
       129
       -
           pub fn puts(self: *Self, msg: []const u8) void {

     

       130
       130
       -
               for (msg) |ch| {

     

       131
       131
       -
                   self.putc(ch);

     

       132
       132
       -
               }

     

       133
       133
       -
           }

     

       134
       134
       -
       

     

       135
       135
       -
           fn convertColor(self: *const Self, color: u32) u32 {

     

       136
       136
       -
               const mult: u32 = blk: {

     

       137
       137
       -
                   const width: u4 = @truncate(self.fb.red_mask_size);

     

       138
       138
       -
                   break :blk (@as(u32, 1) << width) - 1;

     

       139
       139
       -
               };

     

       140
       140
       -
               const div = 255;

     

       141
       141
       -
               const red: u32 = (color >> 16) & 0xFF;

     

       142
       142
       -
               const green: u32 = (color >> 8) & 0xFF;

     

       143
       143
       -
               const blue: u32 = color & 0xFF;

     

       144
       144
       -
       

     

       145
       145
       -
               const red_shift: u5 = @truncate(self.fb.red_mask_shift);

     

       146
       146
       -
               const green_shift: u5 = @truncate(self.fb.green_mask_shift);

     

       147
       147
       -
               const blue_shift: u5 = @truncate(self.fb.blue_mask_shift);

     

       148
       148
       -
       

     

       149
       149
       -
               return (((red * mult) / div) << red_shift) | (((green * mult) / div) << green_shift) | (((blue * mult) / div) << blue_shift);

     

       150
       150
       -
           }

     

       151
       151
       -
       

     

       152
       152
       -
           pub fn setColor(self: *Self, fg: u32, bg: u32) void {

     

       153
       153
       -
               self.fg_color = self.convertColor(fg);

     

       154
       154
       -
               self.bg_color = self.convertColor(bg);

     

       155
       155
       -
           }

     

       156
       156
       -
       

     

       157
       157
       -
           pub fn writer(self: *Self) Writer {

     

       158
       158
       -
               return .{ .context = self };

     

       159
       159
       -
           }

     

       160
       160
       -
       

     

       161
       161
       -
           pub fn write(self: *Self, buffer: []const u8) !usize {

     

       162
       162
       -
               self.puts(buffer);

     

       163
       163
       -
               return buffer.len;

     

       164
       164
       -
           }

     

       165
       165
       -
       

     

       166
       166
       -
           // scroll the lines of text, without doing anything else.

     

       167
       167
       -
           // erase the first line of text, and memcpy the second line and on up to the first

     

       168
       168
       -
           pub fn scrollUp(self: *Self, amount: u64) void {

     

       169
       169
       -
               const num_lines = self.maxCharsHeight();

     

       170
       170
       -
               const h = self.font.hdr.height;

     

       171
       171
       -
               if (amount > num_lines) return; // later just clear the entire screen

     

       172
       172
       -
               var i: u64 = amount;

     

       173
       173
       -
               while (i < num_lines) : (i += 1) {

     

       174
       174
       -
                   // for each run, erase the previous line and copy the current line up a line.

     

       175
       175
       -
                   // const curr_line = self.fb.address[i * h * self.fb.pitch .. (i + 1) * h * self.fb.pitch];

     

       176
       176
       -
                   const curr_line = self.fb.address[i * h * self.fb.pitch ..][0 .. h * self.fb.pitch];

     

       177
       177
       -
                   const prev_line = self.fb.address[(i - amount) * h * self.fb.pitch ..][0 .. h * self.fb.pitch];

     

       178
       178
       -
       

     

       179
       179
       -
                   @memset(prev_line, 0);

     

       180
       180
       -
                   @memcpy(prev_line, curr_line);

     

       181
       181
       -
               }

     

       182
       182
       -
               // finally, delete the last line (s)

     

       183
       183
       -
               // const last_line = self.fb.address[(num_lines - amount) * h * self.fb.pitch .. (num_lines) * h * self.fb.pitch];

     

       184
       184
       -
               const last_line = self.fb.address[(num_lines - amount) * h * self.fb.pitch ..][0 .. amount * h * self.fb.pitch];

     

       185
       185
       -
               @memset(last_line, 0);

     

       186
       186
       -
           }

     

       187
       187
       -
       

     

       188
       188
       -
           fn maxCharsWidth(self: *const Self) u64 {

     

       189
       189
       -
               return self.fb.width / (self.font.hdr.width + 0);

     

       190
       190
       -
           }

     

       191
       191
       -
       

     

       192
       192
       -
           fn maxCharsHeight(self: *const Self) u64 {

     

       193
       193
       -
               return self.fb.height / self.font.hdr.height;

     

       194
       194
       -
           }

     

       195
       195
       -
       };

+24

components/ukernel/deps/console/flake.lock

···

       1
       1
       +
       {

     

       2
       2
       +
         "nodes": {

     

       3
       3
       +
           "nixpkgs": {

     

       4
       4
       +
             "locked": {

     

       5
       5
       +
               "lastModified": 315532800,

     

       6
       6
       +
               "narHash": "sha256-t4zrLJk1EZWk1lUnvNEVjPBVNBHVzS3A0RsxkRSwwSE=",

     

       7
       7
       +
               "rev": "6d7ec06d6868ac6d94c371458fc2391ded9ff13d",

     

       8
       8
       +
               "type": "tarball",

     

       9
       9
       +
               "url": "https://releases.nixos.org/nixpkgs/nixpkgs-25.11pre861040.6d7ec06d6868/nixexprs.tar.xz?rev=6d7ec06d6868ac6d94c371458fc2391ded9ff13d"

     

       10
       10
       +
             },

     

       11
       11
       +
             "original": {

     

       12
       12
       +
               "type": "tarball",

     

       13
       13
       +
               "url": "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz"

     

       14
       14
       +
             }

     

       15
       15
       +
           },

     

       16
       16
       +
           "root": {

     

       17
       17
       +
             "inputs": {

     

       18
       18
       +
               "nixpkgs": "nixpkgs"

     

       19
       19
       +
             }

     

       20
       20
       +
           }

     

       21
       21
       +
         },

     

       22
       22
       +
         "root": "root",

     

       23
       23
       +
         "version": 7

     

       24
       24
       +
       }

+23

components/ukernel/deps/console/flake.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         inputs = {

     

       3
       3
       +
           nixpkgs.url = "https://channels.nixos.org/nixpkgs-unstable/nixexprs.tar.xz";

     

       4
       4
       +
         };

     

       5
       5
       +
         outputs =

     

       6
       6
       +
           { nixpkgs, ... }@inputs:

     

       7
       7
       +
           let

     

       8
       8
       +
             inherit (inputs.nixpkgs) lib;

     

       9
       9
       +
             forAllSystems =

     

       10
       10
       +
               body: lib.genAttrs lib.systems.flakeExposed (system: body nixpkgs.legacyPackages.${system});

     

       11
       11
       +
           in

     

       12
       12
       +
           {

     

       13
       13
       +
             devShells = forAllSystems (pkgs: {

     

       14
       14
       +
               default = pkgs.mkShell {

     

       15
       15
       +
                 packages = with pkgs; [

     

       16
       16
       +
                   zig_0_15

     

       17
       17
       +
                 ];

     

       18
       18
       +
               };

     

       19
       19
       +
             });

     

       20
       20
       +
       

     

       21
       21
       +
             formatter = forAllSystems (pkgs: pkgs.nixfmt-rfc-style);

     

       22
       22
       +
           };

     

       23
       23
       +
       }

-24

components/ukernel/deps/console/fonts/LICENSE.spleen

···

       1
       1
       -
       Copyright (c) 2018-2024, Frederic Cambus

     

       2
       2
       -
       All rights reserved.

     

       3
       3
       -
       

     

       4
       4
       -
       Redistribution and use in source and binary forms, with or without

     

       5
       5
       -
       modification, are permitted provided that the following conditions are met:

     

       6
       6
       -
       

     

       7
       7
       -
         * Redistributions of source code must retain the above copyright

     

       8
       8
       -
           notice, this list of conditions and the following disclaimer.

     

       9
       9
       -
       

     

       10
       10
       -
         * Redistributions in binary form must reproduce the above copyright

     

       11
       11
       -
           notice, this list of conditions and the following disclaimer in the

     

       12
       12
       -
           documentation and/or other materials provided with the distribution.

     

       13
       13
       -
       

     

       14
       14
       -
       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       15
       15
       -
       AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       16
       16
       -
       IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       17
       17
       -
       ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS

     

       18
       18
       -
       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       19
       19
       -
       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       20
       20
       -
       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       21
       21
       -
       INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       22
       22
       -
       CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       23
       23
       -
       ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       24
       24
       -
       POSSIBILITY OF SUCH DAMAGE.

components/ukernel/deps/console/fonts/bold16x32.psf

This is a binary file and will not be displayed.

components/ukernel/deps/console/fonts/bold8x16.psf

This is a binary file and will not be displayed.

components/ukernel/deps/console/fonts/spleen-12x24.psf

This is a binary file and will not be displayed.

components/ukernel/deps/console/fonts/spleen-16x32.psf

This is a binary file and will not be displayed.

components/ukernel/deps/console/fonts/spleen-32x64.psf

This is a binary file and will not be displayed.

components/ukernel/deps/console/fonts/spleen-5x8.psf

This is a binary file and will not be displayed.

components/ukernel/deps/console/fonts/spleen-6x12.psf

This is a binary file and will not be displayed.

components/ukernel/deps/console/fonts/spleen-8x16.psf

This is a binary file and will not be displayed.

-53

components/ukernel/deps/console/psf2.zig

···

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

     

       2
       2
       -
       

     

       3
       3
       -
       pub const Font = struct {

     

       4
       4
       -
           const Self = @This();

     

       5
       5
       -
           pub const PsfHeader = extern struct {

     

       6
       6
       -
               magic: u32 = 0x864ab572,

     

       7
       7
       -
               version: u32,

     

       8
       8
       -
               header_size: u32,

     

       9
       9
       -
               flags: u32,

     

       10
       10
       -
               numglyph: u32,

     

       11
       11
       -
               bytes_per_glyph: u32,

     

       12
       12
       -
               height: u32,

     

       13
       13
       -
               width: u32,

     

       14
       14
       -
       

     

       15
       15
       -
               pub fn bytesPerLine(self: *const PsfHeader) u32 {

     

       16
       16
       -
                   return (self.width + 7) / 8;

     

       17
       17
       -
               }

     

       18
       18
       -
           };

     

       19
       19
       -
       

     

       20
       20
       -
           fontdata: []const u8,

     

       21
       21
       -
           hdr: PsfHeader,

     

       22
       22
       -
       

     

       23
       23
       -
           pub fn new(fontdata: []const u8) !Self {

     

       24
       24
       -
               var ret: Self = undefined;

     

       25
       25
       -
               ret.fontdata = fontdata;

     

       26
       26
       -
       

     

       27
       27
       -
               // fill the header properly

     

       28
       28
       -
               const hdr_size = @sizeOf(PsfHeader);

     

       29
       29
       -
               if (fontdata.len < hdr_size) return error.TooSmall;

     

       30
       30
       -
               const hdr_ptr: [*]u8 = @ptrCast(&ret.hdr);

     

       31
       31
       -
               @memcpy(hdr_ptr[0..hdr_size], fontdata[0..hdr_size]);

     

       32
       32
       -
       

     

       33
       33
       -
               return ret;

     

       34
       34
       -
           }

     

       35
       35
       -
       

     

       36
       36
       -
           pub fn getGlyph(self: *const Self, ch: u8) ![]const u8 {

     

       37
       37
       -
               const startpos: u64 = self.hdr.header_size + ch * self.hdr.bytes_per_glyph;

     

       38
       38
       -
               const endpos: u64 = startpos + self.hdr.bytes_per_glyph;

     

       39
       39
       -
       

     

       40
       40
       -
               if (self.fontdata.len < endpos) return error.InvalidCharacter;

     

       41
       41
       -
               return self.fontdata[startpos..endpos];

     

       42
       42
       -
           }

     

       43
       43
       -
       };

     

       44
       44
       -
       pub fn readIntTo32(buffer: []const u8) u32 {

     

       45
       45
       -
           const readInt = std.mem.readInt;

     

       46
       46
       -
           return switch (buffer.len) {

     

       47
       47
       -
               0 => 0,

     

       48
       48
       -
               1 => @intCast(readInt(u8, buffer[0..1], .big)),

     

       49
       49
       -
               2 => @intCast(readInt(u16, buffer[0..2], .big)),

     

       50
       50
       -
               3 => @intCast(readInt(u24, buffer[0..3], .big)),

     

       51
       51
       -
               else => @intCast(readInt(u32, buffer[0..4], .big)),

     

       52
       52
       -
           };

     

       53
       53
       -
       }

+24

components/ukernel/deps/console/src/fonts/LICENSE.spleen

···

       1
       1
       +
       Copyright (c) 2018-2024, Frederic Cambus

     

       2
       2
       +
       All rights reserved.

     

       3
       3
       +
       

     

       4
       4
       +
       Redistribution and use in source and binary forms, with or without

     

       5
       5
       +
       modification, are permitted provided that the following conditions are met:

     

       6
       6
       +
       

     

       7
       7
       +
         * Redistributions of source code must retain the above copyright

     

       8
       8
       +
           notice, this list of conditions and the following disclaimer.

     

       9
       9
       +
       

     

       10
       10
       +
         * Redistributions in binary form must reproduce the above copyright

     

       11
       11
       +
           notice, this list of conditions and the following disclaimer in the

     

       12
       12
       +
           documentation and/or other materials provided with the distribution.

     

       13
       13
       +
       

     

       14
       14
       +
       THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

     

       15
       15
       +
       AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

     

       16
       16
       +
       IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

     

       17
       17
       +
       ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS

     

       18
       18
       +
       BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

     

       19
       19
       +
       CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

     

       20
       20
       +
       SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

     

       21
       21
       +
       INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

     

       22
       22
       +
       CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

     

       23
       23
       +
       ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

     

       24
       24
       +
       POSSIBILITY OF SUCH DAMAGE.

components/ukernel/deps/console/src/fonts/spleen-12x24.psf

This is a binary file and will not be displayed.

+39

components/ukernel/deps/console/src/psf2.zig

···

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

     

       2
       2
       +
       

     

       3
       3
       +
       pub const Psf2Header = extern struct {

     

       4
       4
       +
           magic: u32 = 0x864ab572,

     

       5
       5
       +
           version: u32,

     

       6
       6
       +
           header_size: u32,

     

       7
       7
       +
           flags: u32,

     

       8
       8
       +
           numglyph: u32,

     

       9
       9
       +
           bytes_per_glyph: u32,

     

       10
       10
       +
           height: u32,

     

       11
       11
       +
           width: u32,

     

       12
       12
       +
       

     

       13
       13
       +
           pub fn bytesPerLine(self: *const Psf2Header) u32 {

     

       14
       14
       +
               return (self.width + 7) / 8;

     

       15
       15
       +
           }

     

       16
       16
       +
       };

     

       17
       17
       +
       

     

       18
       18
       +
       pub const Font = struct {

     

       19
       19
       +
           const Self = @This();

     

       20
       20
       +
           fontdata: []const u8 align(4),

     

       21
       21
       +
           pub fn new(fontdata: []const u8) Self {

     

       22
       22
       +
               return .{

     

       23
       23
       +
                   .fontdata = fontdata,

     

       24
       24
       +
               };

     

       25
       25
       +
           }

     

       26
       26
       +
       

     

       27
       27
       +
           pub fn getHdr(self: *const Self) *const Psf2Header {

     

       28
       28
       +
               return @ptrCast(@alignCast(self.fontdata));

     

       29
       29
       +
           }

     

       30
       30
       +
       

     

       31
       31
       +
           pub fn getGlyph(self: *const Self, ch: u8) ![]const u8 {

     

       32
       32
       +
               const hdr = self.getHdr();

     

       33
       33
       +
               const startpos: u64 = @as(u64, hdr.header_size) + @as(u64, ch) * @as(u64, hdr.bytes_per_glyph);

     

       34
       34
       +
       

     

       35
       35
       +
               if (self.fontdata.len < startpos + @as(u64, hdr.bytes_per_glyph)) return error.InvalidCharacter;

     

       36
       36
       +
       

     

       37
       37
       +
               return self.fontdata[startpos..][0..hdr.bytes_per_glyph];

     

       38
       38
       +
           }

     

       39
       39
       +
       };

+290

components/ukernel/deps/console/src/root.zig

···

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

     

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

     

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

     

       4
       4
       +
       const are_we_le = builtin.cpu.arch.endian() == .little;

     

       5
       5
       +
       

     

       6
       6
       +
       const fontdata_embed = @embedFile("fonts/spleen-12x24.psf");

     

       7
       7
       +
       const fontdata: [fontdata_embed.len]u8 align(@alignOf(u32)) = fontdata_embed.*;

     

       8
       8
       +
       

     

       9
       9
       +
       /// Basic framebuffer container

     

       10
       10
       +
       pub const Framebuffer = struct {

     

       11
       11
       +
           const Self = @This();

     

       12
       12
       +
           address: [*]u32,

     

       13
       13
       +
           width: u64,

     

       14
       14
       +
           height: u64,

     

       15
       15
       +
           pitch: u64,

     

       16
       16
       +
           bypp: u16,

     

       17
       17
       +
           red_mask_size: u8,

     

       18
       18
       +
           red_mask_shift: u8,

     

       19
       19
       +
           green_mask_size: u8,

     

       20
       20
       +
           green_mask_shift: u8,

     

       21
       21
       +
           blue_mask_size: u8,

     

       22
       22
       +
           blue_mask_shift: u8,

     

       23
       23
       +
       };

     

       24
       24
       +
       

     

       25
       25
       +
       /// Framebuffer based console

     

       26
       26
       +
       pub const Console = struct {

     

       27
       27
       +
           fb: Framebuffer,

     

       28
       28
       +
           canvas: [*]u8,

     

       29
       29
       +
           font: psf2.Font,

     

       30
       30
       +
           x_pos: usize = 0,

     

       31
       31
       +
           y_pos: usize = 0,

     

       32
       32
       +
           x_chrs_max: usize,

     

       33
       33
       +
           y_chrs_max: usize,

     

       34
       34
       +
           fg_color: u32 = 0xFFFFFFFF,

     

       35
       35
       +
           bg_color: u32 = 0,

     

       36
       36
       +
       

     

       37
       37
       +
           /// Create an instance given a framebuffer

     

       38
       38
       +
           /// Canvas must be exactly fb.width * fb.height * fb.bypp bytes

     

       39
       39
       +
           pub fn init(fb: Framebuffer, canvas: [*]u8) Console {

     

       40
       40
       +
               const font = psf2.Font.new(&fontdata);

     

       41
       41
       +
               return init_with_font(fb, canvas, font);

     

       42
       42
       +
           }

     

       43
       43
       +
       

     

       44
       44
       +
           /// Create an instance given a framebuffer and font

     

       45
       45
       +
           pub fn init_with_font(fb: Framebuffer, canvas: [*]u8, font: psf2.Font) Console {

     

       46
       46
       +
               const font_hdr = font.getHdr();

     

       47
       47
       +
               return .{

     

       48
       48
       +
                   .fb = fb,

     

       49
       49
       +
                   .font = font,

     

       50
       50
       +
                   .canvas = canvas,

     

       51
       51
       +
                   // TODO: implement spacing between chars?

     

       52
       52
       +
                   .x_chrs_max = fb.width / font_hdr.width,

     

       53
       53
       +
                   .y_chrs_max = fb.height / font_hdr.height,

     

       54
       54
       +
               };

     

       55
       55
       +
           }

     

       56
       56
       +
       

     

       57
       57
       +
           /// Write a string to the console

     

       58
       58
       +
           pub fn puts(self: *Console, msg: []const u8) usize {

     

       59
       59
       +
               var written: usize = 0;

     

       60
       60
       +
       

     

       61
       61
       +
               const start_line, const num_lines = blk: {

     

       62
       62
       +
                   const start_line = self.y_pos;

     

       63
       63
       +
                   var scrolled: bool = false;

     

       64
       64
       +
                   for (msg) |ch| {

     

       65
       65
       +
                       // TODO: handle characters that failed to print

     

       66
       66
       +
                       scrolled |= self.putc(ch) catch false;

     

       67
       67
       +
                       written += 1;

     

       68
       68
       +
                   }

     

       69
       69
       +
                   if (scrolled) break :blk .{ 0, self.y_chrs_max };

     

       70
       70
       +
                   break :blk .{ start_line, self.y_pos - start_line + 1 };

     

       71
       71
       +
               };

     

       72
       72
       +
               self.renderCanvas(start_line, num_lines);

     

       73
       73
       +
               return written;

     

       74
       74
       +
           }

     

       75
       75
       +
       

     

       76
       76
       +
           // Copy in the given lines from the canvas to the framebuffer

     

       77
       77
       +
           fn renderCanvas(

     

       78
       78
       +
               self: *Console,

     

       79
       79
       +
               start_line: usize,

     

       80
       80
       +
               num_lines: usize,

     

       81
       81
       +
           ) void {

     

       82
       82
       +
               const glyph_height: usize = @intCast(self.font.getHdr().height);

     

       83
       83
       +
               // Not necessarily fb pitch!

     

       84
       84
       +
               const canvas_pitch = self.fb.width * self.fb.bypp;

     

       85
       85
       +
               const byte_fb: [*]u8 = @ptrCast(self.fb.address);

     

       86
       86
       +
       

     

       87
       87
       +
               if (canvas_pitch == self.fb.pitch) {

     

       88
       88
       +
                   const src_buf = self.canvas[canvas_pitch * glyph_height * start_line ..][0 .. canvas_pitch * glyph_height * num_lines];

     

       89
       89
       +
                   const dst_buf = byte_fb[self.fb.pitch * glyph_height * start_line ..][0 .. self.fb.pitch * glyph_height * num_lines];

     

       90
       90
       +
                   @memcpy(dst_buf, src_buf);

     

       91
       91
       +
               } else {

     

       92
       92
       +
                   // Unfortunately we have to copy line by line

     

       93
       93
       +
                   var i: usize = 0;

     

       94
       94
       +
                   const canvas_start = canvas_pitch * start_line * glyph_height;

     

       95
       95
       +
                   const fb_start = self.fb.pitch * start_line * glyph_height;

     

       96
       96
       +
                   while (i < num_lines * glyph_height) : (i += 1) {

     

       97
       97
       +
                       const src_line = self.canvas[canvas_start + i * canvas_pitch ..][0..canvas_pitch];

     

       98
       98
       +
                       const dst_line = byte_fb[fb_start + i * self.fb.pitch ..][0..canvas_pitch];

     

       99
       99
       +
                       @memcpy(dst_line, src_line);

     

       100
       100
       +
                   }

     

       101
       101
       +
               }

     

       102
       102
       +
           }

     

       103
       103
       +
       

     

       104
       104
       +
           /// Write a character to the console, return true if scrolled

     

       105
       105
       +
           /// If putchar failed we did not scroll for sure

     

       106
       106
       +
           fn putc(self: *Console, ch: u8) !bool {

     

       107
       107
       +
               var scrolled: bool = false;

     

       108
       108
       +
               // Handle newlines

     

       109
       109
       +
               if (ch == '\r') return scrolled;

     

       110
       110
       +
               if (ch == '\n') {

     

       111
       111
       +
                   // Reset to the beginning of the next line

     

       112
       112
       +
                   self.x_pos = 0;

     

       113
       113
       +
                   self.y_pos += 1;

     

       114
       114
       +
                   // If we've overrun, scroll the entire framebuffer up one

     

       115
       115
       +
                   // and then reset to the last line

     

       116
       116
       +
                   if (self.y_pos >= self.y_chrs_max) {

     

       117
       117
       +
                       self.scrollUp();

     

       118
       118
       +
                       scrolled = true;

     

       119
       119
       +
                   }

     

       120
       120
       +
                   return scrolled;

     

       121
       121
       +
               }

     

       122
       122
       +
               // TODO: color palette and escape codes?

     

       123
       123
       +
               try self.putchar(ch, self.x_pos, self.y_pos, self.fg_color, self.bg_color);

     

       124
       124
       +
               self.x_pos += 1;

     

       125
       125
       +
       

     

       126
       126
       +
               // If our x is too far, go down a line

     

       127
       127
       +
               if (self.x_pos < self.x_chrs_max) return scrolled;

     

       128
       128
       +
               self.x_pos = 0;

     

       129
       129
       +
               self.y_pos += 1;

     

       130
       130
       +
               if (self.y_pos >= self.y_chrs_max) {

     

       131
       131
       +
                   self.scrollUp();

     

       132
       132
       +
                   scrolled = true;

     

       133
       133
       +
               }

     

       134
       134
       +
               return scrolled;

     

       135
       135
       +
           }

     

       136
       136
       +
       

     

       137
       137
       +
           fn putchar(self: *const Console, ch: u8, x_pos: usize, y_pos: usize, fg_val: u32, bg_val: u32) !void {

     

       138
       138
       +
               const raw_color_choice: [2]u32 = [2]u32{

     

       139
       139
       +
                   if (are_we_le) bg_val else @byteSwap(bg_val),

     

       140
       140
       +
                   if (are_we_le) fg_val else @byteSwap(fg_val),

     

       141
       141
       +
               };

     

       142
       142
       +
       

     

       143
       143
       +
               const font = self.font;

     

       144
       144
       +
               const hdr = font.getHdr();

     

       145
       145
       +
       

     

       146
       146
       +
               const bytes_per_line = hdr.bytesPerLine();

     

       147
       147
       +
               const mask_shamt: u5 = @truncate(bytes_per_line * 8 - 1);

     

       148
       148
       +
               const mask_initial: u32 = @as(u32, 1) << mask_shamt;

     

       149
       149
       +
               const glyph = try font.getGlyph(ch);

     

       150
       150
       +
       

     

       151
       151
       +
               // Offset into framebuffer of the beginning of the character

     

       152
       152
       +
               const canvas_pitch: usize = self.fb.width * self.fb.bypp;

     

       153
       153
       +
               var offset: usize = (y_pos * @as(usize, hdr.height) * canvas_pitch) + (x_pos * @as(usize, hdr.width) * self.fb.bypp);

     

       154
       154
       +
               // run for every line

     

       155
       155
       +
               var glyph_y: u32 = 0;

     

       156
       156
       +
               var mask: u32 = 0;

     

       157
       157
       +
               while (glyph_y < hdr.height) : (glyph_y += 1) {

     

       158
       158
       +
                   // initialize the mask and current line

     

       159
       159
       +
                   mask = mask_initial;

     

       160
       160
       +
                   // TODO: endian

     

       161
       161
       +
                   const line_value: u32 = std.mem.readVarInt(u32, glyph[glyph_y * bytes_per_line ..][0..bytes_per_line], .big);

     

       162
       162
       +
                   // offset into the fb of the current line

     

       163
       163
       +
                   var line_offset: usize = offset;

     

       164
       164
       +
                   var glyph_x: u32 = 0;

     

       165
       165
       +
                   while (glyph_x < hdr.width) : (glyph_x += 1) {

     

       166
       166
       +
                       // Write the fb or bg color

     

       167
       167
       +
                       const color: [4]u8 = @bitCast(raw_color_choice[@intFromBool(line_value & mask != 0)]);

     

       168
       168
       +
                       @memcpy(self.canvas[line_offset..][0..self.fb.bypp], color[0..]);

     

       169
       169
       +
                       // Move right a pixel

     

       170
       170
       +
                       line_offset += self.fb.bypp;

     

       171
       171
       +
                       mask >>= 1;

     

       172
       172
       +
                   }

     

       173
       173
       +
                   // Move down a line

     

       174
       174
       +
                   offset += canvas_pitch;

     

       175
       175
       +
               }

     

       176
       176
       +
           }

     

       177
       177
       +
       

     

       178
       178
       +
           // Set the fg and bg color

     

       179
       179
       +
           pub fn setColor(self: *Console, new_fg: u32, new_bg: u32) void {

     

       180
       180
       +
               self.fg_color = self.convertColor(new_fg);

     

       181
       181
       +
               self.bg_color = self.convertColor(new_bg);

     

       182
       182
       +
           }

     

       183
       183
       +
       

     

       184
       184
       +
           // Convert a normal _RGB u32 to the actual framebuffer format

     

       185
       185
       +
           fn convertColor(self: *const Console, color: u32) u32 {

     

       186
       186
       +
               // The color value also needs to be scaled. For example,

     

       187
       187
       +
               // if it's 10 bits per color and we're starting from 8 bits,

     

       188
       188
       +
               // Full bright will only be 0xFF/0x3FF or about 25% brightness.

     

       189
       189
       +
               // To fix this hypothetical, shift left by (10 - 8). This isn't

     

       190
       190
       +
               // perfectly accurate but close enough.

     

       191
       191
       +
               const red_left_shift: u5 = @truncate(self.fb.red_mask_size);

     

       192
       192
       +
               const green_left_shift: u5 = @truncate(self.fb.red_mask_size);

     

       193
       193
       +
               const blue_left_shift: u5 = @truncate(self.fb.red_mask_size);

     

       194
       194
       +
       

     

       195
       195
       +
               // Get our source RGB 888

     

       196
       196
       +
               const right_shift = 8;

     

       197
       197
       +
               const red_src: u32 = (color >> 16) & 0xFF;

     

       198
       198
       +
               const green_src: u32 = (color >> 8) & 0xFF;

     

       199
       199
       +
               const blue_src: u32 = color & 0xFF;

     

       200
       200
       +
       

     

       201
       201
       +
               // These shifts are the offsets to place each color.

     

       202
       202
       +
               const red_dest_shift: u5 = @truncate(self.fb.red_mask_shift);

     

       203
       203
       +
               const green_dest_shift: u5 = @truncate(self.fb.green_mask_shift);

     

       204
       204
       +
               const blue_dest_shift: u5 = @truncate(self.fb.blue_mask_shift);

     

       205
       205
       +
       

     

       206
       206
       +
               // Do the calculations

     

       207
       207
       +
               const red_dst = switch (std.math.order(red_left_shift, right_shift)) {

     

       208
       208
       +
                   .gt => red_src << (red_left_shift - right_shift),

     

       209
       209
       +
                   .lt => red_src >> (right_shift - red_left_shift),

     

       210
       210
       +
                   .eq => red_src,

     

       211
       211
       +
               } << red_dest_shift;

     

       212
       212
       +
       

     

       213
       213
       +
               const green_dst = switch (std.math.order(green_left_shift, right_shift)) {

     

       214
       214
       +
                   .gt => green_src << (green_left_shift - right_shift),

     

       215
       215
       +
                   .lt => green_src >> (right_shift - green_left_shift),

     

       216
       216
       +
                   .eq => green_src,

     

       217
       217
       +
               } << green_dest_shift;

     

       218
       218
       +
       

     

       219
       219
       +
               const blue_dst = switch (std.math.order(blue_left_shift, right_shift)) {

     

       220
       220
       +
                   .gt => blue_src << (blue_left_shift - right_shift),

     

       221
       221
       +
                   .lt => blue_src >> (right_shift - blue_left_shift),

     

       222
       222
       +
                   .eq => blue_src,

     

       223
       223
       +
               } << blue_dest_shift;

     

       224
       224
       +
       

     

       225
       225
       +
               return red_dst | green_dst | blue_dst;

     

       226
       226
       +
           }

     

       227
       227
       +
       

     

       228
       228
       +
           // Make sure to set damage to the entire screen!

     

       229
       229
       +
           fn scrollUp(self: *Console) void {

     

       230
       230
       +
               const glyph_height: usize = @intCast(self.font.getHdr().height);

     

       231
       231
       +
               const canvas_pitch: usize = self.fb.width * self.fb.bypp;

     

       232
       232
       +
       

     

       233
       233
       +
               // Copy 1:n line up to 0:n-1 with memmove

     

       234
       234
       +
               const dst_buf = self.canvas[0 .. canvas_pitch * glyph_height * (self.y_chrs_max - 1)];

     

       235
       235
       +
               const src_buf = self.canvas[canvas_pitch * glyph_height ..][0 .. canvas_pitch * glyph_height * (self.y_chrs_max - 1)];

     

       236
       236
       +
               @memmove(dst_buf, src_buf);

     

       237
       237
       +
       

     

       238
       238
       +
               // Clear last line

     

       239
       239
       +
               const last_line = self.canvas[canvas_pitch * glyph_height * (self.y_chrs_max - 1) ..][0 .. canvas_pitch * glyph_height];

     

       240
       240
       +
               @memset(last_line, 0);

     

       241
       241
       +
               self.x_pos = 0;

     

       242
       242
       +
               self.y_pos = self.y_chrs_max - 1;

     

       243
       243
       +
           }

     

       244
       244
       +
       

     

       245
       245
       +
           // Get a writer with optional buffering

     

       246
       246
       +
           pub fn writer(self: *Console, buffer: []u8) Writer {

     

       247
       247
       +
               return Writer.init(self, buffer);

     

       248
       248
       +
           }

     

       249
       249
       +
       

     

       250
       250
       +
           // Writer with the new std.Io.Writer interface

     

       251
       251
       +
           pub const Writer = struct {

     

       252
       252
       +
               console: *Console,

     

       253
       253
       +
               interface: std.Io.Writer,

     

       254
       254
       +
       

     

       255
       255
       +
               pub fn init(console: *Console, buffer: []u8) Writer {

     

       256
       256
       +
                   return .{

     

       257
       257
       +
                       .console = console,

     

       258
       258
       +
                       .interface = .{

     

       259
       259
       +
                           .buffer = buffer,

     

       260
       260
       +
                           .vtable = &.{ .drain = Writer.drain },

     

       261
       261
       +
                       },

     

       262
       262
       +
                   };

     

       263
       263
       +
               }

     

       264
       264
       +
       

     

       265
       265
       +
               pub fn drain(w: *std.Io.Writer, data: []const []const u8, splat: usize) !usize {

     

       266
       266
       +
                   // fieldParentPtr is so cool

     

       267
       267
       +
                   const self: *Writer = @fieldParentPtr("interface", w);

     

       268
       268
       +
                   var written: usize = 0;

     

       269
       269
       +
                   // First, consume the buffer

     

       270
       270
       +
                   if (w.end < w.buffer.len) {

     

       271
       271
       +
                       const n = self.console.puts(w.buffer[w.end..]);

     

       272
       272
       +
                       written += n;

     

       273
       273
       +
                       w.end += n;

     

       274
       274
       +
                   }

     

       275
       275
       +
       

     

       276
       276
       +
                   // Iterate over all the provided slices

     

       277
       277
       +
                   for (data, 0..) |slice, i| {

     

       278
       278
       +
                       // If we are the last slice, splat by the amount

     

       279
       279
       +
                       if (i == data.len - 1) {

     

       280
       280
       +
                           for (0..splat) |_| {

     

       281
       281
       +
                               written += self.console.puts(slice);

     

       282
       282
       +
                           }

     

       283
       283
       +
                           break;

     

       284
       284
       +
                       }

     

       285
       285
       +
                       written += self.console.puts(slice);

     

       286
       286
       +
                   }

     

       287
       287
       +
                   return written;

     

       288
       288
       +
               }

     

       289
       289
       +
           };

     

       290
       290
       +
       };

Compare changes