sylveos

procmap.zig (4288B)

---

 // TODO; handle different page sizes
 const std = @import("std");
 
 const uart = @import("./devices/mini-uart.zig");
 const pinned = @import("./pinned.zig");
 const mmu = @import("./mmu.zig");
 const mem = @import("./mem.zig");
 const pt = @import("./pt.zig");
 
 const pi = @import("./root.zig");
 
 pub const DEVICE_ATTR: pinned.PinnedAttribute = .{
     .asid = 0,
     .domain = 1,
     .scope = .Global,
     .permission = .UserNoAccess,
     .permission_x = .SupervisorRW,
     .mem_attributes = .StronglyOrdered,
 };
 
 pub const READ_WRITE_ATTR: pinned.PinnedAttribute = .{
     .asid = 0,
     .domain = 1,
     .scope = .Global,
     .permission = .UserNoAccess,
     .permission_x = .SupervisorRW,
     .mem_attributes = .OuterInnerNoncacheable,
 };
 
 pub const READ_ONLY_ATTR: pinned.PinnedAttribute = .{
     .asid = 0,
     .domain = 1,
     .scope = .Global,
     .permission = .UserNoAccess,
     .permission_x = .SupervisorRO,
     .mem_attributes = .OuterInnerNoncacheable,
 };
 
 const MB = 1024 * 1024;
 
 pub const Error = error{
     FailedTranslation,
 };
 
 pub const ProcEntry = struct {
     pub const ProcEntryType = enum {
         Device,
         ReadWrite,
         ReadOnly,
     };
 
     virt_addr: u32,
     phys_addr: u32,
     n_bytes: u32,
     type: ProcEntryType,
     domain: u4 = 1,
     asid: u8 = 0,
 
     pub fn identity(addr: u32, n_bytes: u32, ty: ProcEntryType, dom: u4) ProcEntry {
         return .{
             .virt_addr = addr,
             .phys_addr = addr,
             .n_bytes = n_bytes,
             .domain = dom,
             .type = ty,
         };
     }
 };
 
 pub const ProcMap = struct {
     pt: []mmu.FirstLevelDescriptor,
     entries: std.ArrayList(ProcEntry),
     alloc: std.mem.Allocator,
 
     const Self = @This();
 
     pub fn init(alloc: std.mem.Allocator, dom: u4) !Self {
         var map: ProcMap = .{
             .pt = try pt.init(alloc, 4096),
             .entries = try .initCapacity(alloc, 8),
             .alloc = alloc,
         };
 
         // BCM2835
         try map.push(ProcEntry.identity(0x20000000, MB * 3, .Device, dom));
 
         // Program Code
         try map.push(ProcEntry.identity(0x00000000, MB, .ReadWrite, dom));
 
         // Page table
         try map.push(ProcEntry.identity(@intFromPtr(map.pt.ptr), MB, .ReadWrite, dom));
         try map.push(ProcEntry.identity(0x7E00000, MB, .ReadWrite, dom));
 
         // Stacks
         try map.push(ProcEntry.identity(pi.get_stack_address() - MB, MB, .ReadWrite, dom));
         try map.push(ProcEntry.identity(pi.get_interrupt_stack_address() - MB, MB, .ReadWrite, dom));
 
         return map;
     }
 
     pub fn push(self: *Self, entry: ProcEntry) !void {
         try self.entries.append(self.alloc, entry);
     }
 
     fn pin(self: *const Self) !void {
         for (self.entries.items) |entry| {
             var attr = switch (entry.type) {
                 .Device => DEVICE_ATTR,
                 .ReadWrite => READ_WRITE_ATTR,
                 .ReadOnly => READ_ONLY_ATTR,
             };
             attr.domain = entry.domain;
             attr.asid = entry.asid;
 
             for (0..(entry.n_bytes / MB)) |offset| {
                 const va = entry.virt_addr + offset * MB;
                 const pa = entry.phys_addr + offset * MB;
                 _ = try pt.set(self.pt, va, pa, attr);
             }
         }
     }
 
     pub fn enable(self: *const Self, asid: u8) !void {
         mmu.init();
         mmu.DomainAccessControlRegister.set_all(.Manager);
 
         try self.pin();
 
         try pt.pt_switch(self.pt, 0x140E, asid);
         mmu.sync_pte();
         mmu.enable();
 
         for (self.entries.items) |entry| {
             const res = mmu.va_translation_cw(entry.virt_addr, .PrivilegedRead);
             if (res.aborted) return Error.FailedTranslation;
 
             const physical_base = @as(u32, res.inner.success.address) << 10;
             const offset = entry.virt_addr & 0xFFF;
 
             if ((physical_base | offset) != entry.phys_addr) return Error.FailedTranslation;
         }
     }
 
     pub fn disable(self: *const Self) !void {
         _ = self;
         mmu.disable();
     }
 
     pub fn dupe(self: *const Self) !Self {
         return .{
             .alloc = self.alloc,
             .entries = try self.entries.clone(self.alloc),
             .pt = try pt.dupe(self.alloc, self.pt),
         };
     }
 };