kbtstrp cleanup

Author: frogrammer9

include/stdbigos/error.h

@@ -7,7 +7,7 @@ typedef enum {
 	ERR_CRITICAL_INTERNAL_FAILURE,
 	ERR_HARDWARE_NOT_COMPATIBLE,
 	ERR_ALL_ADDRESS_SPACES_IN_USE,
-	ERR_PHISICAL_MEMORY_FULL,
+	ERR_PHYSICAL_MEMORY_FULL,
 } error_t;
 
 const char* get_error_msg(error_t err);

src/bootstrap/bootstrap_memory_services.c

@@ -3,6 +3,7 @@
 #include <debug/debug_stdio.h>
 #include <stdbigos/string.h>
 
+// TODO: This shouldn't be here
 u64 align_up(u64 val, u64 align) {
 	return (val + align - 1) & ~(align - 1);
 }
@@ -23,48 +24,49 @@ u64 get_ram_size() {
 	return s_mem_size;
 }
 
-// This shouldn't be here
+// TODO: This also shouldn't be here
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 
-// I know this algorithm is very naive, but busy_memory_regions_amount most likely won't exceed 6
-error_t allocate_phisical_memory_region(void* dt, phisical_memory_region_t busy_memory_regions[],
-										u64 busy_memory_regions_amount, u64 allocation_size, u64 aligment,
-										phisical_memory_region_t* pmrOUT) {
-	u64 unavalible_regions_in_dt_amount = 0;
-	u64 unavalible_regions_amount = 0;
+// I know this algorithm is very naive, but busy memory regions amount most likely won't exceed 6
+error_t allocate_physical_memory_region(void* dt, u64 size, u64 align, physical_memory_region_t* pmrOUT) {
+	static physical_memory_region_t allocated_memory_regions[16] = {0};
+	static u64 allocated_regions_end_idx = 0;
+	if(allocated_regions_end_idx >= sizeof(allocated_memory_regions) / sizeof(allocated_memory_regions[0]))
+		return ERR_CRITICAL_INTERNAL_FAILURE;
 	//TEST:
-	unavalible_regions_in_dt_amount = 1;
+	u64 unavaliable_regions_amount = 0;
+	unavaliable_regions_amount = 1;
+	physical_memory_region_t unavaliable_regions[unavaliable_regions_amount];
+	unavaliable_regions[0] = (physical_memory_region_t){.address = (void*)0x80000000, .size = 160 * kiB};
+	// TODO: read the rest of the unavalible memory regions and the region of kboot from the dt
 	//!TEST
-	phisical_memory_region_t unavalible_regions[unavalible_regions_in_dt_amount + busy_memory_regions_amount];
-	if(busy_memory_regions)
-		memcpy(unavalible_regions, busy_memory_regions, busy_memory_regions_amount * sizeof(phisical_memory_region_t));
-	// TODO: read the rest of the unavalible memory regions from the dt
-	//TEST:
-	unavalible_regions[busy_memory_regions_amount] = (phisical_memory_region_t){.address = (void*)0x80000000, .size = 160 * 1024};
-	//!TEST
-	unavalible_regions_amount = unavalible_regions_in_dt_amount + busy_memory_regions_amount;
-
-	void* curr_addr = (void*)align_up((u64)get_ram_start(), aligment);
+	void* curr_region_start = (void*)align_up((u64)get_ram_start(), align);
 
-	while((curr_addr + allocation_size) < (get_ram_start() + get_ram_size())) {
+	physical_memory_region_t* busy_regions_ptrs[] = {allocated_memory_regions, unavaliable_regions};
+	u64 busy_regions_sizes[] = {allocated_regions_end_idx, unavaliable_regions_amount};
+	while((curr_region_start + size) < (get_ram_start() + get_ram_size())) {
 		bool overlap = false;
-		for(u64 i = 0; i < unavalible_regions_amount; ++i) {
-			void* region_start = unavalible_regions[i].address;
-			void* region_end = unavalible_regions[i].address + unavalible_regions[i].size;
-			if(MAX(curr_addr, region_start) < MIN(curr_addr + allocation_size, region_end)) {
-				curr_addr = region_end;
-				curr_addr = (void*)align_up((u64)curr_addr, aligment);
-				overlap = true;
-				break;
+		for(u64 reg_idx = 0; reg_idx < sizeof(busy_regions_ptrs) / sizeof(busy_regions_ptrs[0]); ++reg_idx) {
+			for(u64 i = 0; i < busy_regions_sizes[reg_idx]; ++i) {
+				void* busy_region_start = busy_regions_ptrs[reg_idx][i].address;
+				void* busy_region_end = busy_regions_ptrs[reg_idx][i].address + busy_regions_ptrs[reg_idx][i].size;
+				if(MAX(curr_region_start, busy_region_start) < MIN(curr_region_start + size, busy_region_end)) {
+					curr_region_start = busy_region_end;
+					curr_region_start = (void*)align_up((u64)curr_region_start, align);
+					overlap = true;
+					break;
+				}
 			}
+			if(overlap) break;
 		}
 		if(!overlap) {
-			*pmrOUT = (phisical_memory_region_t){.address = curr_addr, .size = allocation_size};
+			*pmrOUT = (physical_memory_region_t){.address = curr_region_start, .size = size};
+			allocated_memory_regions[allocated_regions_end_idx++] = *pmrOUT;
 			return ERR_NONE;
 		}
 	}
-	return ERR_PHISICAL_MEMORY_FULL;
+	return ERR_PHYSICAL_MEMORY_FULL;
 }
 
 typedef enum : u8 {
@@ -215,30 +217,24 @@ static void load_elf_segment_at_address(void* elf_img, elf64_program_header_t ph
 }
 
 error_t load_elf_at_address(void* elf_img, void* target_addr, void** elf_entry_OUT) {
-	if(((u64)target_addr & 0xfff) != 0) { // if targed_addr is not aligned to 4kiB then elf alignemnts will be broken
-		return ERR_INVALID_ARGUMENT;
-	}
 	const elf64_header_t* header = elf_img;
-	if(header->magic[0] != 0x7f || header->magic[1] != 'E' || header->magic[2] != 'L' || header->magic[3] != 'F') {
+	if(((u64)target_addr & 0xfff) != 0) // if targed_addr is not aligned to 4kiB then elf alignments will be broken
 		return ERR_INVALID_ARGUMENT;
-	}
-	if(header->version != 0x01) { return ERR_INVALID_ARGUMENT; }
-	if(header->class != 0x02) {		  // Only elf64 is supported
+	if(header->magic[0] != 0x7f || header->magic[1] != 'E' || header->magic[2] != 'L' || header->magic[3] != 'F')
 		return ERR_INVALID_ARGUMENT;
-	}
-	if(header->data != 0x01) {		  // Only little-endian is supported
+	if(header->version != 0x01) return ERR_INVALID_ARGUMENT;
+	if(header->class != 0x02)		// Only elf64 is supported
 		return ERR_INVALID_ARGUMENT;
-	}
-	if(header->machine != EM_RISCV) { // Only riscv is supported
+	if(header->data != 0x01)		// Only little-endian is supported
 		return ERR_INVALID_ARGUMENT;
-	}
-	if(header->entry == 0) {		  // ELF doesnt have an entry point
+	if(header->machine != EM_RISCV) // Only riscv is supported
+		return ERR_INVALID_ARGUMENT;
+	if(header->entry == 0)			// ELF doesnt have an entry point
 		return ERR_INVALID_ARGUMENT;
-	}
 	*elf_entry_OUT = target_addr + header->entry;
 	const elf64_program_header_t* segment_table = elf_img + header->start_of_program_headers;
 	for(u64 i = 0; i < header->size_of_program_headrs; ++i) {
-		if(segment_table[i].type == PT_LOAD) { load_elf_segment_at_address(elf_img, segment_table[i], target_addr); }
+		if(segment_table[i].type == PT_LOAD) load_elf_segment_at_address(elf_img, segment_table[i], target_addr);
 	}
 	return ERR_NONE;
 }

src/bootstrap/bootstrap_memory_services.h

@@ -7,17 +7,19 @@
 typedef struct {
 	void* address;
 	u64 size;
-} phisical_memory_region_t;
+} physical_memory_region_t;
+
+// TODO: This probably shouldn't be here
+#define kiB (1ull << 10)
+#define MiB (1ull << 20)
+#define GiB (1ull << 30)
 
 u64 align_up(u64 val, u64 align);
 void set_ram_params(void* ram_start, u64 ram_size);
 void* get_ram_start();
 u64 get_ram_size();
 
-error_t allocate_phisical_memory_region(void* dt, phisical_memory_region_t busy_memory_regions[],
-										u64 busy_memory_regions_amount, u64 allocation_size, u64 aligment,
-										phisical_memory_region_t* pmrOUT);
-
-error_t load_elf_at_address(void* elf_img, void* target_addr, void** elf_entry_OUT);
+[[nodiscard]] error_t allocate_physical_memory_region(void* dt, u64 size, u64 align, physical_memory_region_t* pmrOUT);
+[[nodiscard]] error_t load_elf_at_address(void* elf_img, void* target_addr, void** elf_entry_OUT);
 
 #endif // !__BOOTSTRAP_BOOTSTRAP_MEMORY_SERVICES_H__

src/bootstrap/bootstrap_page_table.c

@@ -5,14 +5,13 @@
 #include <stdbigos/string.h>
 
 #include "bootstrap_memory_services.h"
-#include "bootstrap_panic.h"
 
 //===============================
 //===        INTERNAL        ====
 //===============================
 
 static virtual_memory_scheme_t s_active_vms = VMS_BARE;
-static phisical_memory_region_t s_page_mem_regs[5] = {0};
+static physical_memory_region_t s_page_mem_regs[5] = {0};
 
 static inline reg_t create_satp(virtual_memory_scheme_t vms, u16 asid, ppn_t ppn) {
 	return ((u64)((vms == -1 ? 0 : vms + 8)) << 60) | ((u64)asid << 44) | ((u64)ppn & 0xfffffffffff);
@@ -37,37 +36,25 @@ static inline void read_page_table_entry(u64 pte, u8* flagsOUT, u8* rswOUT, ppn_
 	if(ppnOUT) *ppnOUT = (pte >> 10) & 0xfffffffffff;
 }
 
-static bool add_to_vpn_reg(u64 vpn_reg[], u32* inx, u64 val, u64 size) {
-	for(u32 i = 0; i < *inx; ++i) {
-		if(vpn_reg[i] == val) return true;
-	}
-	vpn_reg[(*inx)++] = val;
-	if(*inx >= size) return false;
-	return true;
-}
-
 ppn_t get_page_frame(page_size_t ps) {
 	static u64 number_of_allocated_pages[PAGE_SIZE_AMOUNT] = {0};
-	return (u64)(s_page_mem_regs[ps].address + number_of_allocated_pages[ps] * (0x1000 << (9 * ps))) >> 12;
+	return (u64)(s_page_mem_regs[ps].address + (number_of_allocated_pages[ps]++) * ((4 * kiB) << (9 * ps))) >> 12;
 }
 
 static void page_table_add_entry(u64 root_pt_ppn, page_size_t ps, vpn_t vpn, ppn_t ppn, bool R, bool W, bool X) {
 	u16 vpn_slice[5] = {
-		(vpn >> 9 * 0) & 0x1ff,
-		(vpn >> 9 * 1) & 0x1ff,
-		(vpn >> 9 * 2) & 0x1ff,
-		(vpn >> 9 * 3) & 0x1ff,
-		(vpn >> 9 * 4) & 0x1ff,
+		(vpn >> 9 * 0) & 0x1ff, (vpn >> 9 * 1) & 0x1ff, (vpn >> 9 * 2) & 0x1ff,
+		(vpn >> 9 * 3) & 0x1ff, (vpn >> 9 * 4) & 0x1ff,
 	};
-	u64 (*current_page)[512] = (u64(*)[512])(root_pt_ppn << 12);
+	u64(*current_page)[512] = (u64(*)[512])(root_pt_ppn << 12);
 	for(i8 lvl = s_active_vms + 2; lvl >= ps; --lvl) {
 		u8 flags = 0;
 		ppn_t current_ppn = 0;
 		u64* current_pte = &(*current_page)[vpn_slice[lvl]];
 		read_page_table_entry(*current_pte, &flags, nullptr, &current_ppn);
 		if((flags & PTEF_V) == 0) {
 			current_ppn = get_page_frame(PAGE_SIZE_4kB);
-			memset((void*)(current_ppn << 12), 0, 0x1000);
+			memset((void*)(current_ppn << 12), 0, 4 * kiB);
 			*current_pte = create_page_table_entry(PTEF_V | PTEF_G, 0, current_ppn);
 		}
 		current_page = (u64(*)[512])(current_ppn << 12);
@@ -79,26 +66,31 @@ static void page_table_add_entry(u64 root_pt_ppn, page_size_t ps, vpn_t vpn, ppn
 	(*current_page)[vpn_slice[ps]] = create_page_table_entry(flags, 0, ppn);
 }
 
+static bool add_to_vpn_reg(u64 vpn_reg[], u32* inx, u64 val, u64 size) {
+	for(u32 i = 0; i < *inx; ++i) {
+		if(vpn_reg[i] == val) return true;
+	}
+	vpn_reg[(*inx)++] = val;
+	if(*inx >= size) return false;
+	return true;
+}
+
 //===============================
 //===    !!! INTERNAL !!!    ====
 //===============================
 
-void init_boot_page_table_managment(virtual_memory_scheme_t vms) {
+u16 initialize_virtual_memory(virtual_memory_scheme_t vms) {
 	s_active_vms = vms;
-}
-
-void set_page_memory_regions(phisical_memory_region_t mem_regions[5]) {
-	memcpy(s_page_mem_regs, mem_regions, 5 * sizeof(phisical_memory_region_t));
-	const char* page_names[] = {"kilo", "mega", "giga", "tera", "peta"};
-	DEBUG_PRINTF("[i] page memory region set:\n");
-	for(u8 i = 0; i < 5; ++i) {
-		DEBUG_PRINTF("\t[i] %s page to: %lx, size: %lu\n", page_names[i], (u64)mem_regions[i].address,
-					 mem_regions[i].size);
-	}
+	reg_t satp = create_satp(VMS_BARE, UINT16_MAX, 0);
+	CSR_WRITE(satp, satp);
+	satp = CSR_READ(satp);
+	u16 asid_max_val = 0;
+	read_satp(satp, nullptr, &asid_max_val, nullptr);
+	return asid_max_val;
 }
 
 required_memory_space_t calc_required_memory_for_page_table(region_t* regions, u64 regions_amount) {
-	constexpr u32 vpn_reg_size = 1024;
+	constexpr u32 vpn_reg_size = 256;
 	u64 vpn_reg[vpn_reg_size] = {0};
 	u32 vpn_reg_inx = 0;
 	u32 max_vpn_reg_inx = 0;
@@ -111,17 +103,17 @@ required_memory_space_t calc_required_memory_for_page_table(region_t* regions, u
 		u32 new_vpn_reg_inx = 0;
 		for(u32 i = 0; i < vpn_reg_inx; ++i)
 			if(!add_to_vpn_reg(new_vpn_reg, &new_vpn_reg_inx, vpn_reg[i] >> 9, vpn_reg_size))
-				return (required_memory_space_t){{0}, .error = true};
+				return (required_memory_space_t){{0}, .error = ERR_CRITICAL_INTERNAL_FAILURE};
 		page_amounts[PAGE_SIZE_4kB] += new_vpn_reg_inx;
 		for(u64 i = 0; i < regions_amount; ++i) {
 			if(regions[i].ps == lvl) {
 				u64 size_left = regions[i].size;
 				u64 curr_addr = regions[i].addr;
-				const u64 size_dif = 0x1000 << (9 * lvl);
+				const u64 size_dif = (4 * kiB) << (9 * lvl);
 				while(size_left > 0) {
 					u32 old_inx = new_vpn_reg_inx;
 					if(!add_to_vpn_reg(new_vpn_reg, &new_vpn_reg_inx, curr_addr >> (12 + 9 * lvl), vpn_reg_size))
-						return (required_memory_space_t){{0}, .error = true};
+						return (required_memory_space_t){{0}, .error = ERR_CRITICAL_INTERNAL_FAILURE};
 					if(old_inx == new_vpn_reg_inx) {
 						DEBUG_PRINTF("overaping mem regions, i: %lu page: %lu\n", i,
 									 (curr_addr - regions[i].addr) / size_dif);
@@ -136,31 +128,32 @@ required_memory_space_t calc_required_memory_for_page_table(region_t* regions, u
 		vpn_reg_inx = new_vpn_reg_inx;
 		memcpy(vpn_reg, new_vpn_reg, new_vpn_reg_inx * sizeof(u64));
 	}
-	required_memory_space_t ret = {{0}, false};
+	required_memory_space_t ret = {{0}, ERR_NONE};
 	memcpy(ret.require_page_amounts, page_amounts, sizeof(page_amounts));
 	return ret;
 }
 
-u16 initialize_virtual_memory() {
-	reg_t satp = create_satp(VMS_BARE, UINT16_MAX, 0);
-	CSR_WRITE(satp, satp);
-	satp = CSR_READ(satp);
-	u16 asid_max_val = 0;
-	read_satp(satp, nullptr, &asid_max_val, nullptr);
-	return asid_max_val;
+void set_page_memory_regions(physical_memory_region_t mem_regions[5]) {
+	memcpy(s_page_mem_regs, mem_regions, 5 * sizeof(physical_memory_region_t));
+	const char* page_names[] = {"kilo", "mega", "giga", "tera", "peta"};
+	DEBUG_PRINTF("[i] page memory region set:\n");
+	for(u8 i = 0; i < 5; ++i) {
+		DEBUG_PRINTF("\t[i] %s page to: 0x%lx, size: %lu\n", page_names[i], (u64)mem_regions[i].address,
+					 mem_regions[i].size);
+	}
 }
 
 ppn_t create_page_table(region_t regions[], u64 regions_amount) {
 	ppn_t root_ppn = get_page_frame(PAGE_SIZE_4kB);
-	memset((void*)(root_ppn << 12), 0, 0x1000);
+	memset((void*)(root_ppn << 12), 0, (4 * kiB));
 	for(u64 i = 0; i < regions_amount; ++i) {
 		u64 size_left = regions[i].size;
 		u64 curr_addr = regions[i].addr;
 		u64 map_addr = regions[i].map_address;
 		while(size_left > 0) {
 			ppn_t use_ppn = (regions[i].mapped) ? (map_addr >> 12) : get_page_frame(regions[i].ps);
 			page_table_add_entry(root_ppn, regions[i].ps, curr_addr >> 12, use_ppn, 1, 1, 1);
-			const u64 size_dif = 0x1000 << (9 * regions[i].ps);
+			const u64 size_dif = (4 * kiB) << (9 * regions[i].ps);
 			if(regions[i].mapped) map_addr += size_dif;
 			curr_addr += size_dif;
 			if(size_left < size_dif) size_left = size_dif;

src/bootstrap/bootstrap_page_table.h

@@ -16,14 +16,12 @@ typedef struct {
 
 typedef struct {
 	u64 require_page_amounts[PAGE_SIZE_AMOUNT];
-	bool error;
+	error_t error;
 } required_memory_space_t;
 
-void init_boot_page_table_managment(virtual_memory_scheme_t vms);
-void set_page_memory_regions(phisical_memory_region_t mem_regions[5]);
+[[nodiscard]] u16 initialize_virtual_memory(virtual_memory_scheme_t vms);
 [[nodiscard]] required_memory_space_t calc_required_memory_for_page_table(region_t* regions, u64 regions_amount);
-[[nodiscard]] u16 initialize_virtual_memory();
-[[nodiscard]] ppn_t get_page_frame(page_size_t ps);
+void set_page_memory_regions(physical_memory_region_t mem_regions[5]);
 [[nodiscard]] ppn_t create_page_table(region_t* regions, u64 regions_amount);
 
 #endif