diff --git a/src/kernel/arch/x86/arch.zig b/src/kernel/arch/x86/arch.zig index d90593d..35cd776 100644 --- a/src/kernel/arch/x86/arch.zig +++ b/src/kernel/arch/x86/arch.zig @@ -62,7 +62,7 @@ pub const KERNEL_VMM_PAYLOAD = &paging.kernel_directory; pub const VMM_MAPPER: vmm.Mapper(VmmPayload) = vmm.Mapper(VmmPayload){ .mapFn = paging.map, .unmapFn = paging.unmap }; /// The size of each allocatable block of memory, normally set to the page size. -pub const MEMORY_BLOCK_SIZE = paging.PAGE_SIZE_4KB; +pub const MEMORY_BLOCK_SIZE: usize = paging.PAGE_SIZE_4KB; /// /// Assembly to write to a given port with a byte of data. diff --git a/src/kernel/arch/x86/paging.zig b/src/kernel/arch/x86/paging.zig index 0b5150e..6a5a8d1 100644 --- a/src/kernel/arch/x86/paging.zig +++ b/src/kernel/arch/x86/paging.zig @@ -99,10 +99,10 @@ const TENTRY_AVAILABLE: u32 = 0xE00; const TENTRY_PAGE_ADDR: u32 = 0xFFFFF000; /// The number of bytes in 4MB -pub const PAGE_SIZE_4MB: u32 = 0x400000; +pub const PAGE_SIZE_4MB: usize = 0x400000; /// The number of bytes in 4KB -pub const PAGE_SIZE_4KB: u32 = PAGE_SIZE_4MB / 1024; +pub const PAGE_SIZE_4KB: usize = PAGE_SIZE_4MB / 1024; /// The kernel's page directory. Should only be used to map kernel-owned code and data pub var kernel_directory: Directory align(@truncate(u29, PAGE_SIZE_4KB)) = Directory{ .entries = [_]DirectoryEntry{0} ** ENTRIES_PER_DIRECTORY, .tables = [_]?*Table{null} ** ENTRIES_PER_DIRECTORY }; diff --git a/src/kernel/bitmap.zig b/src/kernel/bitmap.zig index 75bb50c..505cb03 100644 --- a/src/kernel/bitmap.zig +++ b/src/kernel/bitmap.zig @@ -22,7 +22,7 @@ pub fn Bitmap(comptime BitmapType: type) type { const Self = @This(); /// The number of entries that one bitmap type can hold. Evaluates to the number of bits the type has - pub const ENTRIES_PER_BITMAP: u32 = std.meta.bitCount(BitmapType); + pub const ENTRIES_PER_BITMAP: usize = std.meta.bitCount(BitmapType); /// The value that a full bitmap will have pub const BITMAP_FULL = std.math.maxInt(BitmapType); @@ -30,16 +30,16 @@ pub fn Bitmap(comptime BitmapType: type) type { /// The type of an index into a bitmap entry. The smallest integer needed to represent all bit positions in the bitmap entry type pub const IndexType = @Type(builtin.TypeInfo{ .Int = builtin.TypeInfo.Int{ .is_signed = false, .bits = std.math.log2(std.meta.bitCount(BitmapType)) } }); - num_bitmaps: u32, - num_entries: u32, + num_bitmaps: usize, + num_entries: usize, bitmaps: []BitmapType, - num_free_entries: u32, + num_free_entries: usize, /// /// Create an instance of this bitmap type. /// /// Arguments: - /// IN num_entries: u32 - The number of entries that the bitmap created will have. + /// IN num_entries: usize - The number of entries that the bitmap created will have. /// The number of BitmapType required to store this many entries will be allocated and each will be zeroed. /// IN allocator: *std.mem.Allocator - The allocator to use when allocating the BitmapTypes required. /// @@ -49,8 +49,8 @@ pub fn Bitmap(comptime BitmapType: type) type { /// Error: std.mem.Allocator.Error /// OutOfMemory: There isn't enough memory available to allocate the required number of BitmapType. /// - pub fn init(num_entries: u32, allocator: *std.mem.Allocator) !Self { - const num = @floatToInt(u32, @ceil(@intToFloat(f32, num_entries) / @intToFloat(f32, ENTRIES_PER_BITMAP))); + pub fn init(num_entries: usize, allocator: *std.mem.Allocator) !Self { + const num = std.mem.alignForward(num_entries, ENTRIES_PER_BITMAP) / ENTRIES_PER_BITMAP; const self = Self{ .num_bitmaps = num, .num_entries = num_entries, @@ -68,12 +68,12 @@ pub fn Bitmap(comptime BitmapType: type) type { /// /// Arguments: /// INOUT self: *Self - The bitmap to modify. - /// IN idx: BitmapIndex - The index within the bitmap to set. + /// IN idx: usize - The index within the bitmap to set. /// /// Error: BitmapError. /// OutOfBounds: The index given is out of bounds. /// - pub fn setEntry(self: *Self, idx: u32) BitmapError!void { + pub fn setEntry(self: *Self, idx: usize) BitmapError!void { if (idx >= self.num_entries) return BitmapError.OutOfBounds; if (!try self.isSet(idx)) { const bit = self.indexToBit(idx); @@ -87,12 +87,12 @@ pub fn Bitmap(comptime BitmapType: type) type { /// /// Arguments: /// INOUT self: *Self - The bitmap to modify. - /// IN idx: BitmapIndex - The index within the bitmap to clear. + /// IN idx: usize - The index within the bitmap to clear. /// /// Error: BitmapError. /// OutOfBounds: The index given is out of bounds. /// - pub fn clearEntry(self: *Self, idx: u32) BitmapError!void { + pub fn clearEntry(self: *Self, idx: usize) BitmapError!void { if (idx >= self.num_entries) return BitmapError.OutOfBounds; if (try self.isSet(idx)) { const bit = self.indexToBit(idx); @@ -106,12 +106,12 @@ pub fn Bitmap(comptime BitmapType: type) type { /// /// Arguments: /// IN self: *const Self - The bitmap to use. - /// IN idx: u32 - The index into all of the bitmap's entries. + /// IN idx: usize - The index into all of the bitmap's entries. /// /// Return: BitmapType. /// The bit corresponding to that index but within a single BitmapType. /// - fn indexToBit(self: *const Self, idx: u32) BitmapType { + fn indexToBit(self: *const Self, idx: usize) BitmapType { return @as(BitmapType, 1) << @intCast(IndexType, idx % ENTRIES_PER_BITMAP); } @@ -120,26 +120,26 @@ pub fn Bitmap(comptime BitmapType: type) type { /// /// Arguments: /// INOUT self: *Self - The bitmap to modify. - /// IN num: u32 - The number of entries to set. + /// IN num: usize - The number of entries to set. /// - /// Return: ?u32 + /// Return: ?usize /// The first entry set or null if there weren't enough contiguous entries. /// - pub fn setContiguous(self: *Self, num: u32) ?u32 { + pub fn setContiguous(self: *Self, num: usize) ?usize { if (num > self.num_free_entries) { return null; } - var count: u32 = 0; - var start: ?u32 = null; + var count: usize = 0; + var start: ?usize = null; for (self.bitmaps) |bmp, i| { var bit: IndexType = 0; while (true) { - const entry = bit + @intCast(u32, i * ENTRIES_PER_BITMAP); + const entry = bit + i * ENTRIES_PER_BITMAP; if (entry >= self.num_entries) { return null; } - if ((bmp & @as(u32, 1) << bit) != 0) { + if ((bmp & @as(BitmapType, 1) << bit) != 0) { // This is a one so clear the progress count = 0; start = null; @@ -170,7 +170,7 @@ pub fn Bitmap(comptime BitmapType: type) type { if (count == num) { if (start) |start_entry| { - var i: u32 = 0; + var i: usize = 0; while (i < num) : (i += 1) { // Can't fail as the entry was found to be free self.setEntry(start_entry + i) catch unreachable; @@ -184,17 +184,17 @@ pub fn Bitmap(comptime BitmapType: type) type { /// /// Set the first free entry within the bitmaps as occupied. /// - /// Return: ?u32. + /// Return: ?usize. /// The index within all bitmaps that was set or null if there wasn't one free. /// 0 .. ENTRIES_PER_BITMAP - 1 if in the first bitmap, ENTRIES_PER_BITMAP .. ENTRIES_PER_BITMAP * 2 - 1 if in the second etc. /// - pub fn setFirstFree(self: *Self) ?u32 { + pub fn setFirstFree(self: *Self) ?usize { if (self.num_free_entries == 0) return null; for (self.bitmaps) |*bmp, i| { if (bmp.* == BITMAP_FULL) continue; const bit = @truncate(IndexType, @ctz(BitmapType, ~bmp.*)); - const idx = bit + @intCast(u32, i) * ENTRIES_PER_BITMAP; + const idx = bit + i * ENTRIES_PER_BITMAP; // Failing here means that the index is outside of the bitmap, so there are no free entries self.setEntry(idx) catch return null; return idx; @@ -207,7 +207,7 @@ pub fn Bitmap(comptime BitmapType: type) type { /// /// Arguments: /// IN self: *const Self - The bitmap to check. - /// IN idx: u32 - The entry to check. + /// IN idx: usize - The entry to check. /// /// Return: bool. /// True if the entry is set, else false. @@ -215,7 +215,7 @@ pub fn Bitmap(comptime BitmapType: type) type { /// Error: BitmapError. /// OutOfBounds: The index given is out of bounds. /// - pub fn isSet(self: *const Self, idx: u32) BitmapError!bool { + pub fn isSet(self: *const Self, idx: usize) BitmapError!bool { if (idx >= self.num_entries) return BitmapError.OutOfBounds; return (self.bitmaps[idx / ENTRIES_PER_BITMAP] & self.indexToBit(idx)) != 0; } diff --git a/src/kernel/kmain.zig b/src/kernel/kmain.zig index 7db7299..f6aead4 100644 --- a/src/kernel/kmain.zig +++ b/src/kernel/kmain.zig @@ -68,7 +68,7 @@ export fn kmain(mb_info: *multiboot.multiboot_info_t, mb_magic: u32) void { var heap_size = mem_profile.mem_kb / 10 * 1024; // The heap size must be a power of two so find the power of two smaller than or equal to the heap_size if (!std.math.isPowerOfTwo(heap_size)) { - heap_size = std.math.floorPowerOfTwo(u32, heap_size); + heap_size = std.math.floorPowerOfTwo(usize, heap_size); } var kernel_heap = heap.init(arch.VmmPayload, &kernel_vmm, vmm.Attributes{ .kernel = true, .writable = true, .cachable = true }, heap_size, &fixed_allocator.allocator) catch |e| { panic_root.panic(@errorReturnTrace(), "Failed to initialise kernel heap: {}\n", .{e}); diff --git a/src/kernel/mem.zig b/src/kernel/mem.zig index f6ea41d..8f7c37a 100644 --- a/src/kernel/mem.zig +++ b/src/kernel/mem.zig @@ -17,10 +17,10 @@ pub const MemProfile = struct { physaddr_start: [*]u8, /// The amount of memory in the system, in kilobytes. - mem_kb: u32, + mem_kb: usize, /// The size of the fixed buffer allocator used as the first memory allocator. - fixed_alloc_size: u32, + fixed_alloc_size: usize, /// The boot modules provided by the bootloader. boot_modules: []multiboot.multiboot_module_t, @@ -114,7 +114,7 @@ pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile { // Total memory available including the initial 1MiB that grub doesn't include .mem_kb = mb_info.mem_upper + mb_info.mem_lower + 1024, .fixed_alloc_size = FIXED_ALLOC_SIZE, - .boot_modules = @intToPtr([*]multiboot.multiboot_mod_list, physToVirt(mb_info.mods_addr))[0..mods_count], + .boot_modules = @intToPtr([*]multiboot.multiboot_mod_list, physToVirt(@intCast(usize, mb_info.mods_addr)))[0..mods_count], .mem_map = @intToPtr([*]multiboot.multiboot_memory_map_t, mmap_addr)[0..num_mmap_entries], }; } diff --git a/src/kernel/panic.zig b/src/kernel/panic.zig index 37a6932..23529bf 100644 --- a/src/kernel/panic.zig +++ b/src/kernel/panic.zig @@ -283,11 +283,11 @@ pub fn init(mem_profile: *const mem.MemProfile, allocator: *std.mem.Allocator) ! // Exit if we haven't loaded all debug modules if (mem_profile.boot_modules.len < 1) return; - var kmap_start: u32 = 0; - var kmap_end: u32 = 0; + var kmap_start: usize = 0; + var kmap_end: usize = 0; for (mem_profile.boot_modules) |module| { - const mod_start = mem.physToVirt(module.mod_start); - const mod_end = mem.physToVirt(module.mod_end) - 1; + const mod_start = mem.physToVirt(@intCast(usize, module.mod_start)); + const mod_end = mem.physToVirt(@intCast(usize, module.mod_end) - 1); const mod_str_ptr = mem.physToVirt(@intToPtr([*:0]u8, module.cmdline)); if (std.mem.eql(u8, std.mem.span(mod_str_ptr), "kernel.map")) { kmap_start = mod_start; diff --git a/src/kernel/pmm.zig b/src/kernel/pmm.zig index 0da10b0..5b6804a 100644 --- a/src/kernel/pmm.zig +++ b/src/kernel/pmm.zig @@ -19,7 +19,7 @@ const PmmError = error{ }; /// The size of memory associated with each bitmap entry -pub const BLOCK_SIZE = arch.MEMORY_BLOCK_SIZE; +pub const BLOCK_SIZE: usize = arch.MEMORY_BLOCK_SIZE; var bitmap: PmmBitmap = undefined; @@ -85,10 +85,10 @@ pub fn free(addr: usize) (PmmBitmap.BitmapError || PmmError)!void { /// /// Get the number of unallocated blocks of memory. /// -/// Return: u32. +/// Return: usize. /// The number of unallocated blocks of memory /// -pub fn blocksFree() u32 { +pub fn blocksFree() usize { return bitmap.num_free_entries; } diff --git a/src/kernel/vmm.zig b/src/kernel/vmm.zig index e705b9e..dc7309f 100644 --- a/src/kernel/vmm.zig +++ b/src/kernel/vmm.zig @@ -31,7 +31,7 @@ const Allocation = struct { }; /// The size of each allocatable block, the same as the physical memory manager's block size -pub const BLOCK_SIZE: u32 = pmm.BLOCK_SIZE; +pub const BLOCK_SIZE: usize = pmm.BLOCK_SIZE; pub const MapperError = error{ InvalidVirtualAddress, @@ -121,7 +121,7 @@ pub const VmmError = error{ pub fn VirtualMemoryManager(comptime Payload: type) type { return struct { /// The bitmap that keeps track of allocated and free regions - bmp: bitmap.Bitmap(u32), + bmp: bitmap.Bitmap(usize), /// The start of the memory to be tracked start: usize, @@ -161,7 +161,7 @@ pub fn VirtualMemoryManager(comptime Payload: type) type { /// pub fn init(start: usize, end: usize, allocator: *std.mem.Allocator, mapper: Mapper(Payload), payload: Payload) std.mem.Allocator.Error!Self { const size = end - start; - var bmp = try bitmap.Bitmap(u32).init(@floatToInt(u32, @ceil(@intToFloat(f32, size) / @intToFloat(f32, pmm.BLOCK_SIZE))), allocator); + var bmp = try bitmap.Bitmap(usize).init(std.mem.alignForward(size, pmm.BLOCK_SIZE) / pmm.BLOCK_SIZE, allocator); return Self{ .bmp = bmp, .start = start, @@ -250,7 +250,7 @@ pub fn VirtualMemoryManager(comptime Payload: type) type { /// /// Arguments: /// INOUT self: *Self - The manager to allocate for - /// IN num: u32 - The number of blocks to allocate + /// IN num: usize - The number of blocks to allocate /// IN attrs: Attributes - The attributes to apply to the mapped memory /// /// Return: ?usize @@ -259,7 +259,7 @@ pub fn VirtualMemoryManager(comptime Payload: type) type { /// Error: std.mem.Allocator.Error /// std.mem.AllocatorError.OutOfMemory: The required amount of memory couldn't be allocated /// - pub fn alloc(self: *Self, num: u32, attrs: Attributes) std.mem.Allocator.Error!?usize { + pub fn alloc(self: *Self, num: usize, attrs: Attributes) std.mem.Allocator.Error!?usize { if (num == 0) return null; // Ensure that there is both enough physical and virtual address space free @@ -269,7 +269,7 @@ pub fn VirtualMemoryManager(comptime Payload: type) type { var block_list = std.ArrayList(usize).init(self.allocator); try block_list.ensureCapacity(num); - var i: u32 = 0; + var i: usize = 0; const vaddr_start = self.start + entry * BLOCK_SIZE; var vaddr = vaddr_start; // Map the blocks to physical memory