sylveos

pinned.zig (4781B)

---

 const system = @import("./system.zig");
 const mmu = @import("./mmu.zig");
 const mem = @import("./mem.zig");
 
 pub const Error = error{
     MMUEnabled,
     MMUDisabled,
     InvalidMVA,
     TranslationAborted,
     BadSetVA,
     BadSetAttr,
     BadSetPA,
     ExpectedPinned,
 };
 
 // Invalidate page table
 const null_pages: [4096 * 4]u8 align(1 << 14) = .{0} ** (4096 * 4);
 pub fn init() Error!void {
     if (mmu.is_enabled()) return Error.MMUEnabled;
 
     mmu.init();
     mmu.DomainAccessControlRegister.set_all(.Client);
 }
 
 // Map VA -> PA at IDX with attributes E
 pub fn set(idx: u3, va: usize, pa: usize, attr: PinnedAttribute) Error!void {
     const cs = mem.enter_critical_section();
     defer cs.exit();
 
     // Initialize lockdown values
     const lockdown_attr: mmu.LockdownAttributesRegister = .{
         .shared = true,
         .domain = attr.domain,
         .page_table_encoding = .{ .preset = attr.mem_attributes },
         // 0 initialize everything else
         .execute_never = false,
         .ap1 = .TotalNoAccess,
         .ap2 = .TotalNoAccess,
         .ap3 = .TotalNoAccess,
         .subpages_valid = false,
     };
 
     // Make user pointers into real values
     var lockdown_va: mmu.LockdownVA = @bitCast(va);
     lockdown_va.asid = attr.asid;
     lockdown_va.scope = attr.scope;
 
     var lockdown_pa: mmu.LockdownPA = @bitCast(pa);
     lockdown_pa.nsa = .Secure;
     lockdown_pa.nstid = .Secure;
     lockdown_pa.valid = true;
     lockdown_pa.size = .@"1MB";
     lockdown_pa.ap0 = attr.permission;
     lockdown_pa.apx = attr.permission_x;
 
     mmu.LockdownIndex.set(idx);
 
     lockdown_va.set();
     lockdown_attr.set();
     lockdown_pa.set();
 
     // Update to TLB, need prefetch flush
     mem.barrier(.Instruction);
 
     // Validate
     if (mmu.LockdownVA.get() != lockdown_va) return Error.BadSetPA;
     if (mmu.LockdownAttributesRegister.get() != lockdown_attr) return Error.BadSetAttr;
     if (mmu.LockdownPA.get() != lockdown_pa) return Error.BadSetVA;
 }
 
 // Clear IDX
 pub fn clear(idx: u3) Error!void {
     mmu.LockdownIndex.set(idx);
 
     // Zero out everything
     mmu.LockdownVA.set(@bitCast(0));
     mmu.LockdownAttributesRegister.set(@bitCast(0));
     mmu.LockdownPA.set(@bitCast(0));
 
     // Update to TLB, need prefetch flush
     mem.barrier(.Instruction);
 
     // Validate
     if (mmu.LockdownVA.get() != 0) return Error.BadSetPA;
     if (mmu.LockdownAttributesRegister.get() != 0) return Error.BadSetAttr;
     if (mmu.LockdownPA.get() != 0) return Error.BadSetVA;
 }
 
 // Get VA -> PA
 pub fn get(va: u32) Error!u32 {
     if (!mmu.is_enabled()) return Error.MMUDisabled;
     // 3-79: MVA 0:2 SBZ
     if (va & 0b11 != 0) return Error.InvalidMVA;
 
     const pa = mmu.va_translation_cw(va, .PrivilegedRead);
     if (pa.aborted) return Error.TranslationAborted;
 
     const physical_base = @as(u32, pa.inner.success.address) << 10;
     const offset = va & 0xFFF;
 
     return physical_base | offset;
 }
 
 // Check if VA == PA
 pub fn is_pinned(va: u32) Error!bool {
     const pa = get(va) catch |err| {
         // A translation abort explicitly means the VA is not pinned
         if (err == Error.TranslationAborted) return false;
         return err;
     };
 
     return va == pa;
 }
 
 pub const PinnedAttribute = struct {
     asid: u8,
     domain: u4,
     scope: mmu.LockdownVA.Scope,
     permission: mmu.AccessPermissions,
     permission_x: mmu.AccessPermissionsExtended,
     mem_attributes: mmu.LockdownAttributesRegister.PageTableEncodingPreset,
 
     pub fn dupe_asid_domain(self: *const PinnedAttribute, asid: u8, domain: u4) PinnedAttribute {
         return .{
             .scope = self.scope,
             .permission = self.permission,
             .permission_x = self.permission_x,
             .mem_attributes = self.mem_attributes,
             .asid = asid,
             .domain = domain,
         };
     }
 };
 
 const uart = @import("./devices/mini-uart.zig");
 pub fn lockdown_print_entry(idx: u3) void {
     mmu.LockdownIndex.set(idx);
     const pa = mmu.LockdownPA.get();
     const va = mmu.LockdownVA.get();
     const attr = mmu.LockdownAttributesRegister.get();
 
     uart.print("  PA = 0x{X} (valid={any} size={s} ap={s} apx={s})\n", .{ pa.physical_address, pa.valid, @tagName(pa.size), @tagName(pa.ap0), @tagName(pa.apx) });
     uart.print("  VA = 0x{X} (asid={d} scope={s})\n", .{ va.virtual_address, va.asid, @tagName(va.scope) });
     uart.print("  Attributes: domain={d} XN={any} shared={any} tex={d} c={d} b={d}\n", .{ attr.domain, attr.execute_never, attr.shared, attr.page_table_encoding.manual.tex, attr.page_table_encoding.manual.c, attr.page_table_encoding.manual.b });
     uart.flush();
 }
 
 pub fn lockdown_print_entries() void {
     for (0..8) |i| {
         uart.print("Entry {d}:\n", .{i});
         lockdown_print_entry(@truncate(i));
     }
 }