started to implement kernel heap

Author: Glowman554

mckrnl/core/devices/font.c

@@ -1,4 +1,4 @@
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <devices/font.h>
 #include <assert.h>
 #include <string.h>
@@ -26,8 +26,8 @@ char* font_file_name(struct devfs_file* dfile) {
 }
 
 devfs_file_t* get_font_file(int font_size, void* font_pointer) {
-    font_file_t* file = vmm_alloc(TO_PAGES(sizeof(font_file_t)));
-
+    font_file_t* file = kmalloc(sizeof(font_file_t));
+    
     file->file.read = font_file_read;
     file->file.prepare = font_file_prepare;
     file->file.name = font_file_name;

mckrnl/core/devices/nic.c

@@ -1,5 +1,5 @@
 #include <devices/nic.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <driver/disk_driver.h>
 #include <stdio.h>
 #include <assert.h>
@@ -57,7 +57,7 @@ char* nic_file_name(devfs_file_t* file) {
 
 
 devfs_file_t* create_nic_file(nic_driver_t* nic, int id) {
-    nic_file_t* nic_file = vmm_alloc(TO_PAGES(sizeof(nic_file_t)));
+    nic_file_t* nic_file = kmalloc(sizeof(nic_file_t));
     memset(nic_file, 0, sizeof(nic_file_t));
 
     nic_file->nic = nic;

mckrnl/core/driver/char_input_driver.c

@@ -5,7 +5,7 @@
 #include <fs/vfs.h>
 #include <stdio.h>
 #include <utils/string.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <assert.h>
 #include <config.h>
 
@@ -51,7 +51,7 @@ void init_keymap(char* path) {
     if (!file) {
         abortf(false, "Failed to open keymap: %s", path);
     }
-    loaded_keymap = vmm_alloc(TO_PAGES(file->size));
+    loaded_keymap = kmalloc(file->size);
     vfs_read(file, loaded_keymap, file->size, 0);
     vfs_close(file);
 

mckrnl/core/driver/disk/virtual_disk.c

@@ -1,6 +1,6 @@
 #include <driver/disk/virtual_disk.h>
 
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <string.h>
 
 bool virtual_disk_is_device_present(driver_t* driver) {
@@ -30,8 +30,8 @@ void virtual_disk_flush(disk_driver_t* driver) {
 }
 
 disk_driver_t* get_virtual_disk_driver(disk_driver_t* disk, uint64_t lba_offset) {
-	disk_driver_t* driver = (disk_driver_t*) vmm_alloc(1);
-	memset(driver, 0, 0x1000);
+	disk_driver_t* driver = (disk_driver_t*) kmalloc(sizeof(disk_driver_t));
+	memset(driver, 0, sizeof(disk_driver_t));
 
 	driver->driver.is_device_present = virtual_disk_is_device_present;
 	driver->driver.get_device_name = virtual_disk_get_device_name;
@@ -43,7 +43,7 @@ disk_driver_t* get_virtual_disk_driver(disk_driver_t* disk, uint64_t lba_offset)
 
 	driver->physical = false;
 
-	driver->driver.driver_specific_data = driver + sizeof(disk_driver_t);
+	driver->driver.driver_specific_data = kmalloc(sizeof(virtual_disk_driver_data_t));
 
 	virtual_disk_driver_data_t* data = (virtual_disk_driver_data_t*) driver->driver.driver_specific_data;
 

mckrnl/core/driver/nic_driver.c

@@ -2,7 +2,7 @@
 #include <net/stack.h>
 #include <stdint.h>
 #include <stdio.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <stddef.h>
 #include <string.h>
 #include <config.h>
@@ -13,7 +13,7 @@ nic_driver_t** nic_drivers = NULL;
 int num_nic_drivers = 0;
 
 void register_nic_driver(nic_driver_t* driver) {	
-	nic_drivers = vmm_resize(sizeof(nic_driver_t*), num_nic_drivers, num_nic_drivers + 1, nic_drivers);
+	nic_drivers = krealloc(nic_drivers, sizeof(nic_driver_t*) * (num_nic_drivers + 1));
 	nic_drivers[num_nic_drivers] = driver;
 	num_nic_drivers++;
 }
@@ -37,12 +37,12 @@ void send_async_send_packet(async_t* async) {
 
 	send_data->driver->send(send_data->driver, async, send_data->data, send_data->len);
 	if (is_resolved(async)) {
-		vmm_free(send_data, TO_PAGES(sizeof(send_data_t) + send_data->len));
+		kfree(send_data);
 	}
 }
 
 void send_packet(nic_driver_t* driver, uint8_t* data, uint32_t len) {
-	uint8_t* copy = vmm_alloc(TO_PAGES(sizeof(send_data_t) + len));
+	uint8_t* copy = kmalloc(sizeof(send_data_t) + len);
 
 	send_data_t* send_data = (send_data_t*) copy;
 	uint8_t* packet_data = copy + sizeof(send_data_t);

mckrnl/core/fs/devfs.c

@@ -1,7 +1,7 @@
 #include <fs/devfs.h>
 #include <stdio.h>
 #include <string.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 
 file_t* devfs_open(vfs_mount_t* mount, char* path, int flags) {
 	devfs_t* devfs = (devfs_t*) mount;
@@ -14,7 +14,7 @@ file_t* devfs_open(vfs_mount_t* mount, char* path, int flags) {
 
 	for (int i = 0; i < devfs->num_files; i++) {
 		if (strcmp(devfs->files[i]->name(devfs->files[i]), path) == 0) {
-			file_t* f = (file_t*) vmm_alloc(1);
+			file_t* f = (file_t*) kmalloc(sizeof(file_t));
 			f->mount = mount;
 			f->size = -1;
 			f->driver_specific_data = devfs->files[i];
@@ -30,7 +30,7 @@ file_t* devfs_open(vfs_mount_t* mount, char* path, int flags) {
 }
 
 void devfs_close(vfs_mount_t* mount, file_t* file) {
-	vmm_free(file, 1);
+	kfree(file);
 }
 
 void devfs_read(vfs_mount_t* mount, file_t* file, void* buf, size_t size, size_t offset) {
@@ -83,7 +83,7 @@ devfs_t global_devfs = {
 
 void devfs_register_file(devfs_t* devfs, devfs_file_t* file) {
 	debugf("Registering devfs file %s!", file->name(file));
-	devfs->files = vmm_resize(sizeof(devfs_file_t*), devfs->num_files, devfs->num_files + 1, devfs->files);
+	devfs->files = krealloc(devfs->files, sizeof(devfs_file_t*) * (devfs->num_files + 1));
 	devfs->files[devfs->num_files] = file;
 	devfs->num_files++;
 }

mckrnl/core/fs/gpt.c

@@ -1,20 +1,21 @@
 #include <fs/gpt.h>
 
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <stdio.h>
 #include <string.h>
 #include <driver/disk/virtual_disk.h>
 
 bool read_gpt(disk_driver_t* disk) {
-	struct gpt_header* header = (struct gpt_header*) vmm_alloc(1);
+	struct gpt_header* header = (struct gpt_header*) kmalloc(512);
 	disk->read(disk, 1, 1, (void*) header);
 
 	if (memcmp(header->signature, "EFI PART", 8) != 0) {
-		vmm_free(header, 1);
+		kfree(header);
 		return false;
 	} else {
-		struct gpt_partition_entry* entries = (struct gpt_partition_entry*) vmm_alloc(((header->partition_entries_size * header->partition_entries_count) / 4096) + 1);
-		disk->read(disk, header->partition_entries_startting_lba, ((header->partition_entries_size * header->partition_entries_count) / 512 ) + 1, (void*) entries);
+		int sectors = ((header->partition_entries_size * header->partition_entries_count) / 512) + 1;
+		struct gpt_partition_entry* entries = (struct gpt_partition_entry*) kmalloc(sectors * 512);
+		disk->read(disk, header->partition_entries_startting_lba, sectors, (void*) entries);
 
 		for (int i = 0; i < header->partition_entries_count; i++) {
 			if (entries[i].type_guid.data1 == 0) {
@@ -27,8 +28,8 @@ bool read_gpt(disk_driver_t* disk) {
 		}
 
 
-		vmm_free(entries, ((header->partition_entries_size * header->partition_entries_count) / 4096) + 1);
-		vmm_free(header, 1);
+		kfree(entries);
+		kfree(header);
 		return true;
 	}
 }

mckrnl/core/fs/initrd.c

@@ -1,7 +1,7 @@
 #include <fs/initrd.h>
 
 #include <stdio.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <utils/string.h>
 #include <assert.h>
 
@@ -52,7 +52,7 @@ file_t* initrd_open(vfs_mount_t* mount, char* path, int flags) {
 
 	saf_node_file_t* file_node = (saf_node_file_t*) file;
 
-	file_t* f = (file_t*) vmm_alloc(1);
+	file_t* f = (file_t*) kmalloc(sizeof(file_t));
 	f->mount = mount;
 	f->size = file_node->size;
 	f->driver_specific_data = (void*) ((uint32_t) mount->driver_specific_data + (uint32_t) file_node->addr);
@@ -61,7 +61,7 @@ file_t* initrd_open(vfs_mount_t* mount, char* path, int flags) {
 }
 
 void initrd_close(vfs_mount_t* mount, file_t* f) {
-	vmm_free(f, 1);
+	kfree(f);
 }
 
 void initrd_read(vfs_mount_t* mount, file_t* f, void* buffer, size_t size, size_t offset) {
@@ -120,7 +120,7 @@ dir_t initrd_dir_at(vfs_mount_t* mount, int idx, char* path) {
 }
 
 vfs_mount_t* initrd_mount(void* saf_image) {
-	vfs_mount_t* mount = (vfs_mount_t*) vmm_alloc(1);
+	vfs_mount_t* mount = (vfs_mount_t*) kmalloc(sizeof(vfs_mount_t));
 	memset(mount, 0, sizeof(vfs_mount_t));
 
 	mount->driver_specific_data = saf_image;

mckrnl/core/include/memory/heap.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#define MB(x) ((x) * 1024 * 1024)
+
+typedef struct heap_segment_header {
+	size_t length;
+	struct heap_segment_header* next;
+	struct heap_segment_header* last;
+
+	bool free;
+
+} heap_segment_header_t;
+
+void* kmalloc(size_t size);
+void* krealloc(void* ptr, size_t size);
+void kfree(void* address);
+void* kcalloc(size_t count, size_t size);
+
+void initialize_heap(size_t page_count);

mckrnl/core/init.c

@@ -14,6 +14,7 @@
 #include <scheduler/killer.h>
 #include <memory/pmm.h>
 #include <memory/vmm.h>
+#include <memory/heap.h>
 
 #include <driver/output/serial.h>
 #include <driver/clock/cmos.h>
@@ -106,10 +107,10 @@ void load_init() {
 		if (file == NULL) {
 			abortf(false, "Could not open %s", init_exec);
 		}
-		void* buffer = vmm_alloc(file->size / 4096 + 1);
+		void* buffer = kmalloc(file->size);
 		vfs_read(file, buffer, file->size, 0);
 		init_executable(1, buffer, argv, envp);
-		vmm_free(buffer, file->size / 4096 + 1);
+		kfree(buffer);
 		vfs_close(file);
 	} else {
 		abortf(false, "Please use --init to set a init process");
@@ -166,6 +167,7 @@ void _main(multiboot_info_t* mb_info) {
 
 	pmm_init();
 	vmm_init();
+	initialize_heap(MB(4) / 0x1000);
 
 	set_gdt(new_gdt());