allocin'g actually works now, but we can free random pointers... weird

kernel/arch/pmm/pmm.c

@@ -49,32 +49,32 @@ void pmm_init(void);
 void* pmm_alloc_block(void);
 void pmm_free_block(void* p);
 
-void __pmm_set(int bit, struct pmm_mem_info mem_block)
+void __pmm_set(int bit, struct pmm_mem_info* mem_block)
 {
-	(mem_block.bitmap)[bit / 32] |= (1 << (bit % 32));
+	(mem_block->bitmap)[bit / 32] |= (1 << (bit % 32));
-	mem_block.used_blocks++;
+	mem_block->used_blocks++;
-	mem_block.free_blocks--;
+	mem_block->free_blocks--;
 }
 
-void __pmm_unset(int bit, struct pmm_mem_info mem_block)
+void __pmm_unset(int bit, struct pmm_mem_info* mem_block)
 {
-	(mem_block.bitmap)[bit / 32] &= ~(1 << (bit % 32));
+	(mem_block->bitmap)[bit / 32] &= ~(1 << (bit % 32));
-	mem_block.used_blocks--;
+	mem_block->used_blocks--;
-	mem_block.free_blocks--;
+	mem_block->free_blocks++;
 }
 
-bool __pmm_test(int bit, struct pmm_mem_info mem_block)
+bool __pmm_test(int bit, struct pmm_mem_info* mem_block)
 {
-	return (mem_block.bitmap)[bit / 32] & (1 << (bit % 32));
+	return (mem_block->bitmap)[bit / 32] & (1 << (bit % 32));
 }
 
-int __pmm_first_free(struct pmm_mem_info mem_block)
+int __pmm_first_free(struct pmm_mem_info* mem_block)
 {
-	for (uint32_t i = 0; i < PMM_GET_MEM_BLOCKS(mem_block) / 32; i++) {
+	for (uint32_t i = 0; i < PMM_GET_MEM_BLOCKS((*mem_block)) / 32; i++) {
-		if (mem_block.bitmap[i] == 0xFFFFFFFF) // this segment is full
+		if (mem_block->bitmap[i] == 0xFFFFFFFF) // this segment is full
 			continue;
 		for (int j = 0; j < 32; j++) {
-			if (mem_block.bitmap[i] & (1 << j))
+			if (mem_block->bitmap[i] & (1 << j))
 				continue; // this page is used 
 			return (i * 32) + j; // i * 32 is the chunk of 32, plus j to get to the page in the chunk
 		}
@@ -84,29 +84,29 @@ int __pmm_first_free(struct pmm_mem_info mem_block)
 
 void __pmm_add_mem_block(uint32_t addr, int32_t len, struct pmm_mem_info* mem_block)
 {
-	mem_block->startaddr = addr;
+	mem_block->startaddr = addr; // main_mem isn't properly being set like this... TODO
 	mem_block->len = len;
 	mem_block->bitmap = 0;
 }
 
-void __pmm_init(struct pmm_mem_info mem_block)
+void __pmm_init(struct pmm_mem_info* mem_block)
 {
 	// TODO same as above
-	mem_block.used_blocks = 0;
+	mem_block->used_blocks = 0;
-	mem_block.max_blocks = PMM_GET_MEM_BLOCKS(main_mem);
+	mem_block->max_blocks = PMM_GET_MEM_BLOCKS(main_mem);
-	mem_block.free_blocks = mem_block.max_blocks;
+	mem_block->free_blocks = mem_block->max_blocks;
 
-	memset(mem_block.bitmap, 0x0, PMM_GET_MEM_BLOCKS(mem_block) / PMM_BLOCKS_PER_BYTE); // declare all memory available
+	memset(mem_block->bitmap, 0x0, PMM_GET_MEM_BLOCKS((*mem_block)) / PMM_BLOCKS_PER_BYTE); // declare all memory available
 
 #ifdef __TESTING__
-	printf("Initialized %1 blocks of memory (%1KiB available)\n", mem_block.max_blocks, mem_block.free_blocks * 4096);
+	printf("Initialized %1 blocks of memory (%1KiB available)\n", mem_block->max_blocks, mem_block->free_blocks * 4096);
 #endif
 	__pmm_set(0, mem_block); // first block must always be set
 }
 
-void* __pmm_alloc_block(struct pmm_mem_info mem_block)
+void* __pmm_alloc_block(struct pmm_mem_info* mem_block)
 {
-	if (mem_block.free_blocks == 0) {
+	if (mem_block->free_blocks == 0) {
 		kerror("OUT OF MEMORY");
 		return 0;
 	}
@@ -119,13 +119,13 @@ void* __pmm_alloc_block(struct pmm_mem_info mem_block)
 
 	__pmm_set(block_in_map, mem_block);
 
-	return (void*) (mem_block.startaddr + (block_in_map * PMM_PAGE_SIZE));
+	return (void*) (mem_block->startaddr + (block_in_map * PMM_PAGE_SIZE));
 }
 
-void __pmm_free_block(void* p, struct pmm_mem_info mem_block)
+void __pmm_free_block(void* p, struct pmm_mem_info* mem_block)
 {
 	uint64_t* addr = (uint64_t*) &p;
-	int idx = ((*addr) - mem_block.startaddr) / PMM_PAGE_SIZE;
+	int idx = ((*addr) - mem_block->startaddr) / PMM_PAGE_SIZE;
 
 	__pmm_unset(idx, mem_block);
 }
@@ -142,25 +142,25 @@ void pmm_set(int bit)
 	 *
 	 * below is merely a temporary solution
 	 */
-	__pmm_set(bit, main_mem); 
+	__pmm_set(bit, &main_mem); 
 }
 
 void pmm_unset(int bit)
 {
 	 // TODO: same as above
-	 __pmm_unset(bit, main_mem);
+	 __pmm_unset(bit, &main_mem);
 }
 
 bool pmm_test(int bit)
 {
 	// TODO: same as above
-	return __pmm_test(bit, main_mem);
+	return __pmm_test(bit, &main_mem);
 }
 
 int pmm_first_free(void) //TODO implement a free_s where it finds a series of free pages
 {
 	// TODO: same as above
-	int ret = __pmm_first_free(main_mem);
+	int ret = __pmm_first_free(&main_mem);
 	if (ret == -1)
 		kerror("OUT OF MEMORY");
 	return ret;
@@ -170,17 +170,23 @@ int pmm_first_free(void) //TODO implement a free_s where it finds a series of fr
 void pmm_init(void)
 {
 	// TODO same as above
-	__pmm_init(main_mem);
+	__pmm_init(&main_mem);
 }
 
 void* pmm_alloc_block(void)
 {
-	return __pmm_alloc_block(main_mem);
+#ifdef __TESTING__
+	printf("PMM: Alloc'd a block!\n");
+#endif
+	return __pmm_alloc_block(&main_mem);
 }
 
 void pmm_free_block(void* p)
 {
-	__pmm_free_block(p, main_mem);
+	__pmm_free_block(p, &main_mem);
+#ifdef __TESTING__
+	puts("PMM: Free'd a block!");
+#endif
 }
 
 void pmm_add_mem_block(uint32_t addr, uint32_t len)

kernel/kmain.c

@@ -16,6 +16,8 @@
 
 #include "multiboot.h"
 
+extern struct pmm_mem_info main_mem;
+
 void verify_memmap(multiboot_info_t* mbd, uint32_t magic)
 {
 	if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
@@ -61,7 +63,13 @@ void _main(multiboot_info_t* mbd, uint32_t magic)
 	pmm_init();
 	print_main_mem();
 
-	pmm_alloc_block();
+	
+	void* a = pmm_alloc_block(); 
+
+	print_main_mem();
+
+
+	pmm_free_block(a);
 
 	print_main_mem();