Use vmm.virtToPhys in x86 paging

test/mock/kernel/mem_mock.zig

@@ -29,12 +29,13 @@ pub const MemProfile = struct {
 };
 
 const FIXED_ALLOC_SIZE = 1024 * 1024;
+const ADDR_OFFSET: usize = 100;
 
 pub fn virtToPhys(virt: anytype) @TypeOf(virt) {
     const T = @TypeOf(virt);
     return switch (@typeInfo(T)) {
-        .Pointer => @intToPtr(T, @ptrToInt(virt) - KERNEL_ADDR_OFFSET),
-        .Int => virt - KERNEL_ADDR_OFFSET,
+        .Pointer => @intToPtr(T, @ptrToInt(virt) - ADDR_OFFSET),
+        .Int => virt - ADDR_OFFSET,
         else => @compileError("Only pointers and integers are supported"),
     };
 }
@@ -42,8 +43,8 @@ pub fn virtToPhys(virt: anytype) @TypeOf(virt) {
 pub fn physToVirt(phys: anytype) @TypeOf(phys) {
     const T = @TypeOf(phys);
     return switch (@typeInfo(T)) {
-        .Pointer => @intToPtr(T, @ptrToInt(phys) + KERNEL_ADDR_OFFSET),
-        .Int => phys + KERNEL_ADDR_OFFSET,
+        .Pointer => @intToPtr(T, @ptrToInt(phys) + ADDR_OFFSET),
+        .Int => phys + ADDR_OFFSET,
         else => @compileError("Only pointers and integers are supported"),
     };
 }

test/mock/kernel/vmm_mock.zig

@@ -1,5 +1,6 @@
 const mem = @import("mem_mock.zig");
 const bitmap = @import("../../../src/kernel/bitmap.zig");
+const vmm = @import("../../../src/kernel/vmm.zig");
 const arch = @import("arch_mock.zig");
 const std = @import("std");
 
@@ -8,21 +9,35 @@ pub const VmmError = error{
     NotAllocated,
 };
 
-pub const Attributes = struct {
-    kernel: bool,
-    writable: bool,
-    cachable: bool,
-};
+pub const Attributes = vmm.Attributes;
+
 pub const BLOCK_SIZE: u32 = 1024;
 
-pub fn Mapper(comptime Payload: type) type {
-    return struct {};
-}
+pub const Mapper = vmm.Mapper;
+
+pub const MapperError = error{
+    InvalidVirtualAddress,
+    InvalidPhysicalAddress,
+    AddressMismatch,
+    MisalignedVirtualAddress,
+    MisalignedPhysicalAddress,
+    NotMapped,
+};
+
+pub var kernel_vmm: VirtualMemoryManager(arch.VmmPayload) = undefined;
 
 pub fn VirtualMemoryManager(comptime Payload: type) type {
     return struct {
         const Self = @This();
 
+        pub fn init(start: usize, end: usize, allocator: *std.mem.Allocator, mapper: Mapper(Payload), payload: Payload) std.mem.Allocator.Error!Self {
+            return Self{};
+        }
+
+        pub fn virtToPhys(self: *const Self, virt: usize) VmmError!usize {
+            return 0;
+        }
+
         pub fn alloc(self: *Self, num: u32, attrs: Attributes) std.mem.Allocator.Error!?usize {
             return std.mem.Allocator.Error.OutOfMemory;
         }