Imbus/pluto
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make some integers usize

Browse source
This commit is contained in:
Sam Tebbs 2020-05-12 14:08:29 +01:00
parent 76ff52b1fa
commit 39fd5a151c
8 changed files with 46 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/kernel/arch/x86/arch.zig
View file

@ -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.

4
src/kernel/arch/x86/paging.zig
View file

@ -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 };

52
src/kernel/bitmap.zig
View file

@ -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;
}

2
src/kernel/kmain.zig
View file

@ -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});

6
src/kernel/mem.zig
View file

@ -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],
};
}

8
src/kernel/panic.zig
View file

@ -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;

6
src/kernel/pmm.zig
View file

@ -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;
}

12
src/kernel/vmm.zig
View file

@ -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