sylveos

pages.zig (5584B)

---

 const std = @import("std");
 const pi = @import("pi");
 
 const memory = @import("./memory.zig");
 
 const mmu = pi.mmu;
 const pt = pi.pt;
 
 const SECOND_LEVEL_FAULT: mmu.SecondLevelDescriptor = .{ .ty = .Fault, .descriptor = .{ .fault = .{} } };
 const CoarseTable = struct {
     node: std.SinglyLinkedList.Node,
     descriptor: [256]mmu.SecondLevelDescriptor align(1 << 10),
 };
 
 alloc: std.mem.Allocator,
 root: []mmu.FirstLevelDescriptor,
 sectors: []mmu.FirstLevelDescriptor,
 // TODO; this should be a linked list as they don't need to be contiguous
 pages: std.SinglyLinkedList,
 asid: u8,
 
 old_context: mmu.ContextId = .{},
 
 pub const Error = error{
     InvalidSection,
     InvalidLargePage,
     InvalidSmallPage,
     TossingCoarsePage,
     TossingSection,
     Map64To4,
     Map4To64,
     Unaligned,
 } || std.mem.Allocator.Error;
 
 // XKCD 927
 pub const Attributes = struct {
     encoding: mmu.LockdownAttributesRegister.PageTableEncoding = .{ .preset = .StronglyOrdered },
     access_permission: mmu.AccessPermissions = .UserReadWrite,
     access_permission_x: mmu.AccessPermissionsExtended = .SupervisorRW,
     scope: mmu.LockdownVA.Scope = .Global,
     never_execute: bool = false,
     shared: bool = false,
     domain: u4 = 1,
 };
 
 const Self = @This();
 
 pub fn fork(alloc: std.mem.Allocator, root: []mmu.FirstLevelDescriptor, asid: u8) !Self {
     return .{
         .sectors = try pt.dupe(alloc, root),
         .pages = .{},
         .alloc = alloc,
         .root = root,
         .asid = asid,
     };
 }
 
 fn va_to_index(va: u32) usize {
     return @intCast(va >> 20);
 }
 
 fn get_descriptor(self: *Self, current: *mmu.FirstLevelDescriptor, domain: u4) !*[256]mmu.SecondLevelDescriptor {
     if (current.ty == .Section) return Error.TossingSection;
     if (current.ty == .Fault) {
         var coarse_table = try self.alloc.create(CoarseTable);
         self.pages.prepend(&coarse_table.node);
         @memset(std.mem.asBytes(&coarse_table.descriptor), 0);
 
         current.ty = .CoarsePageTable;
         current.descriptor = .{ .coarse = .{
             .domain = domain,
             .coarse_base_address = @truncate(@intFromPtr(&coarse_table.*.descriptor) >> 10),
         } };
     }
 
     return @ptrFromInt(@as(u32, current.descriptor.coarse.coarse_base_address) << 10);
 }
 
 pub fn map_1mb(self: *Self, va: u32, pa: u32, attr: Attributes) !void {
     if (!std.mem.isAligned(pa, memory.MB) or !std.mem.isAligned(va, memory.MB)) return Error.Unaligned;
 
     // Whole section, yippee
     // Just check we aren't chucking a coarse page
     const idx = va_to_index(va);
     var current = &self.sectors[idx];
 
     if (current.ty == .CoarsePageTable) return Error.TossingCoarsePage;
 
     const mem_attr = attr.encoding.manual;
 
     current.ty = .Section;
     current.descriptor = .{ .section = .{
         .not_global = if (attr.scope == .Global) false else true,
         .ap = attr.access_permission,
         .apx = attr.access_permission_x,
         .b = mem_attr.b,
         .c = mem_attr.c,
         .tex = mem_attr.tex,
         .domain = attr.domain,
         .never_execute = attr.never_execute,
         .shared = attr.shared,
         .section_base_address = @truncate(pa >> 20),
     } };
     // TODO; only do 1 line
     mmu.sync_pte();
 }
 // Assume user isn't stupid and tries to map 4kb then 64kb
 pub fn map_64kb(self: *Self, va: u32, pa: u32, attr: Attributes) !void {
     if (!std.mem.isAligned(pa, memory.KB64) or !std.mem.isAligned(va, memory.KB64)) return Error.Unaligned;
 
     const idx = va_to_index(va);
     const descriptor = try self.get_descriptor(&self.sectors[idx], attr.domain);
 
     const base_entry = ((va >> 12) & 0xFF) & ~@as(usize, 0xF);
     const mem_attr = attr.encoding.manual;
 
     for (0..16) |i| {
         descriptor[base_entry + i].ty = .LargePage;
         descriptor[base_entry + i].descriptor.large_page = .{
             .not_global = if (attr.scope == .Global) false else true,
             .ap = attr.access_permission,
             .apx = attr.access_permission_x,
             .b = mem_attr.b,
             .c = mem_attr.c,
             .tex = mem_attr.tex,
             .never_execute = attr.never_execute,
             .shared = attr.shared,
             .base_address = @truncate(pa >> 16),
         };
     }
 
     // TODO; only do 1 line
     mmu.sync_pte();
 }
 pub fn map_4kb(self: *Self, va: u32, pa: u32, attr: Attributes) !void {
     if (!std.mem.isAligned(pa, memory.KB4) or !std.mem.isAligned(va, memory.KB4)) return Error.Unaligned;
 
     const idx = va_to_index(va);
     const descriptor = try self.get_descriptor(&self.sectors[idx], attr.domain);
 
     const page_idx = (va >> 12) & 0xFF;
     const mem_attr = attr.encoding.manual;
 
     descriptor[page_idx].ty = if (attr.never_execute) .SmallPageNeverExecute else .SmallPageExecutable;
     descriptor[page_idx].descriptor.small_page = .{
         .not_global = if (attr.scope == .Global) false else true,
         .ap = attr.access_permission,
         .apx = attr.access_permission_x,
         .b = mem_attr.b,
         .c = mem_attr.c,
         .tex = mem_attr.tex,
         .shared = attr.shared,
         .base_address = @truncate(pa >> 12),
     };
     // TODO; only do 1 line
     mmu.sync_pte();
 }
 
 pub fn switch_into(self: *Self, pid: u24) void {
     self.old_context = .get();
 
     mmu.set_context_ttbr0(.{ .asid = self.asid, .pid = pid }, .{
         .translation_table_base = @truncate(@intFromPtr(self.sectors.ptr) >> 5),
     });
 }
 
 pub fn switch_out_of(self: *const Self) void {
     mmu.set_context_ttbr0(self.old_context, .{
         .translation_table_base = @truncate(@intFromPtr(self.root.ptr) >> 5),
     });
 }