Use std.BoundedArray instead of FixedVec

src/mem/phys.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
 
 const kernel = @import("../kernel.zig");
-const vec = @import("../util/vec.zig");
 const log = @import("../debug.zig").log;
 const mem = @import("../mem.zig");
 const vmm = @import("vmm.zig");
@@ -112,24 +111,24 @@ const PhysicalMemoryManager = struct {
     }
 };
 
-var gMemoryRegions: vec.FixedVec(MemoryRegion, 16) = .{};
+var gMemoryRegions: std.BoundedArray(MemoryRegion, 16) = .{};
-var gReservedRegions: vec.FixedVec(MemoryRegion, 16) = .{};
+var gReservedRegions: std.BoundedArray(MemoryRegion, 16) = .{};
 var gPhysicalMemoryLock = Spinlock{};
 var gPhysicalMemory = PhysicalMemoryManager{ .pageArray = undefined };
 
 pub fn addMemoryRegion(name: []const u8, base: u64, size: u64) void {
     log.info("Memory: '{s}', base 0x{x}, size 0x{x}", .{ name, base, size });
-    gMemoryRegions.push(.{ .name = name, .range = .{ .start = base, .len = size } });
+    gMemoryRegions.append(.{ .name = name, .range = .{ .start = base, .len = size } }) catch @panic("memory regions overflow");
 }
 
 pub fn addReservedRegion(name: []const u8, base: u64, size: u64) void {
     log.info("Reserved: '{s}', base 0x{x}, size 0x{x}", .{ name, base, size });
-    gReservedRegions.push(.{ .name = name, .range = .{ .start = base, .len = size } });
+    gReservedRegions.append(.{ .name = name, .range = .{ .start = base, .len = size } }) catch @panic("reserved regions overflow");
 }
 
 fn isReservedIn(page: u64) ?*const MemoryRegion {
     for (0..gReservedRegions.len) |i| {
-        const region = &gReservedRegions.data[i];
+        const region = &gReservedRegions.buffer[i];
         if (page >= region.range.start and page < region.range.end()) {
             return region;
         }
@@ -161,7 +160,7 @@ fn allocFromRegion(region: *const MemoryRegion, reason: []const u8, pageCount: u
 }
 
 fn allocPageArray(pageCount: usize) []Page {
-    for (gMemoryRegions.asConstSlice()) |region| {
+    for (gMemoryRegions.constSlice()) |region| {
         if (allocFromRegion(&region, "page-array", pageCount)) |physAddress| {
             const vaddr = (mem.PhysicalAddress{ .raw = physAddress }).virtualize();
             const len = pageCount * PhysicalMemoryManager.RECORDS_PER_PAGE;
@@ -180,7 +179,7 @@ pub fn init() void {
     var memoryStart: u64 = std.math.maxInt(u64);
     var memoryEnd: u64 = std.math.minInt(u64);
 
-    for (gMemoryRegions.asConstSlice()) |region| {
+    for (gMemoryRegions.constSlice()) |region| {
         if (region.range.start < memoryStart) {
             memoryStart = region.range.start;
         }
@@ -195,14 +194,14 @@ pub fn init() void {
     const pageArray = allocPageArray(pageArrayPages);
     var availablePages: usize = 0;
 
-    for (gMemoryRegions.asConstSlice()) |region| {
+    for (gMemoryRegions.constSlice()) |region| {
         const offset = (region.range.start - memoryStart) / vmm.PAGE_SIZE;
         for (0..region.range.len / vmm.PAGE_SIZE) |i| {
             pageArray[offset + i].makeAvailable();
             availablePages += 1;
         }
     }
-    for (gReservedRegions.asConstSlice()) |region| {
+    for (gReservedRegions.constSlice()) |region| {
         const offset = (region.range.start - memoryStart) / vmm.PAGE_SIZE;
         for (0..region.range.len / vmm.PAGE_SIZE) |i| {
             if (offset + i >= pageArray.len) {

src/util/vec.zig

@@ -1,18 +0,0 @@
-pub fn FixedVec(comptime T: type, comptime N: usize) type {
-    return struct {
-        data: [N]T = undefined,
-        len: usize = 0,
-
-        pub fn push(self: *@This(), value: T) void {
-            if (self.len + 1 >= self.data.len) {
-                @panic("Fixed vector overflowed");
-            }
-            self.data[self.len] = value;
-            self.len += 1;
-        }
-
-        pub fn asConstSlice(self: *const @This()) []const T {
-            return self.data[0..self.len];
-        }
-    };
-}