replaced more vmm calls with heap calls

Author: Glowman554

mckrnl/core/driver/acpi/madt.c

@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <stdio.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 
 uint8_t* madt_lapic_ids = NULL;
 uint8_t madt_lapic_count = 0;
@@ -32,16 +32,16 @@ void parse_madt() {
 			case 0: // Processor local apic
 				{
 					madt_local_processor_t* processor = (madt_local_processor_t*) record;
-					madt_lapic_ids = vmm_resize(sizeof(uint8_t), madt_lapic_count, madt_lapic_count + 1, madt_lapic_ids);
+					madt_lapic_ids = krealloc(madt_lapic_ids, sizeof(uint8_t) * (madt_lapic_count + 1));
 					madt_lapic_ids[madt_lapic_count++] = processor->apic_id;
 				}
 				break;
 
 			case 1: // I/O apic
 				{
 					madt_io_apic_t* ioapic = (madt_io_apic_t*) record;
-					madt_ioapic_ids = vmm_resize(sizeof(uint8_t), madt_ioapic_count, madt_ioapic_count + 1, madt_ioapic_ids);
-					madt_ioapic_base_addr = vmm_resize(sizeof(uint32_t), madt_ioapic_count, madt_ioapic_count + 1, madt_ioapic_base_addr);
+					madt_ioapic_ids = krealloc(madt_ioapic_ids, sizeof(uint8_t) * (madt_ioapic_count + 1));
+					madt_ioapic_base_addr = krealloc(madt_ioapic_base_addr, sizeof(uint32_t) * (madt_ioapic_count + 1));
 					madt_ioapic_ids[madt_ioapic_count] = ioapic->io_apic_id;
 					madt_ioapic_base_addr[madt_ioapic_count++] = ioapic->io_apic_address;
 				}

mckrnl/core/driver/disk_driver.c

@@ -3,14 +3,14 @@
 #include <config.h>
 #include <assert.h>
 #include <stdio.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <stddef.h>
 
 int num_disks = 0;
 disk_driver_t** disks = NULL;
 
 int register_disk(disk_driver_t* disk) {
-	disks = vmm_resize(sizeof(disk_driver_t*), num_disks, num_disks + 1, disks);
+	disks = krealloc(disks, sizeof(disk_driver_t*) * (num_disks + 1));
 	disks[num_disks] = disk;
 	debugf("Registered disk %d", num_disks);
 	num_disks++;

mckrnl/core/driver/driver.c

@@ -1,14 +1,14 @@
 #include <driver/driver.h>
 
 #include <stdio.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <stddef.h>
 
 driver_t** drivers = NULL;
 int num_drivers = 0;
 
 void register_driver(driver_t* driver) {
-	drivers = vmm_resize(sizeof(driver_t*), num_drivers, num_drivers + 1, drivers);
+	drivers = krealloc(drivers, sizeof(driver_t*) * (num_drivers + 1));
 	drivers[num_drivers] = driver;
 	num_drivers++;
 }

mckrnl/core/driver/pci/pci.c

@@ -4,7 +4,7 @@
 #include <config.h>
 
 #include <stddef.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 
 pci_driver_t* pci_drivers = NULL;
 int num_pci_drivers = 0;
@@ -25,7 +25,7 @@ void apend_pci_device(pci_device_header_t header,  uint16_t bus, uint16_t device
 		.driver_loaded = driver
 	};
 
-	pci_devices = vmm_resize(sizeof(pci_device_list_entry_t), num_pci_devices, num_pci_devices + 1, pci_devices);
+	pci_devices = krealloc(pci_devices, sizeof(pci_device_list_entry_t) * (num_pci_devices + 1));
 	pci_devices[num_pci_devices++] = entry;
 }
 
@@ -74,7 +74,7 @@ void register_pci_driver_cs(uint8_t _class, uint8_t subclass, uint8_t prog_IF, v
 	driver.prog_IF = prog_IF;
 	driver.use_class_subclass_prog_IF = true;
 	driver.load_driver = load_driver;
-	pci_drivers = vmm_resize(sizeof(pci_driver_t), num_pci_drivers, num_pci_drivers + 1, pci_drivers);
+	pci_drivers = krealloc(pci_drivers, sizeof(pci_driver_t) * (num_pci_drivers + 1));
 	pci_drivers[num_pci_drivers++] = driver;
 
 	debugf("Registered PCI driver with class %d, subclass %d, prog_IF %d", _class, subclass, prog_IF);
@@ -86,7 +86,7 @@ void register_pci_driver_vd(uint16_t vendor_id, uint16_t device_id, void (*load_
 	driver.device_id = device_id;
 	driver.use_vendor_device_id = true;
 	driver.load_driver = load_driver;
-	pci_drivers = vmm_resize(sizeof(pci_driver_t), num_pci_drivers, num_pci_drivers + 1, pci_drivers);
+	pci_drivers = krealloc(pci_drivers, sizeof(pci_driver_t) * (num_pci_drivers + 1));
 	pci_drivers[num_pci_drivers++] = driver;
 
 	debugf("Registered PCI driver with vendor_id %x, device_id %x", vendor_id, device_id);

mckrnl/core/fs/fd.c

@@ -1,7 +1,7 @@
 #include <fs/fd.h>
 
 #include <config.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <stddef.h>
 
 file_t** fd_table;
@@ -15,7 +15,7 @@ int file_to_fd(file_t* file) {
 		}
 	}
 
-	fd_table = vmm_resize(sizeof(file_t*), num_fd, num_fd + 1, fd_table);
+	fd_table = krealloc(fd_table, sizeof(file_t*) * (num_fd + 1));
 	fd_table[num_fd] = file;
 	num_fd++;
 

mckrnl/core/fs/vfs.c

@@ -5,7 +5,7 @@
 #include <config.h>
 #include <driver/disk_driver.h>
 
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <stddef.h>
 
 vfs_mount_t** vfs_mounts = NULL;
@@ -36,7 +36,7 @@ bool try_read_disk_label(char* out, vfs_mount_t* mount) {
 void vfs_mount(vfs_mount_t* mount) {
 	debugf("VFS: Mounting %s", mount->name(mount));
 
-	vfs_mounts = vmm_resize(sizeof(vfs_mount_t*), num_vfs_mounts, num_vfs_mounts + 1, vfs_mounts);
+	vfs_mounts = krealloc(vfs_mounts, sizeof(vfs_mount_t*) * (num_vfs_mounts + 1));
 	vfs_mounts[num_vfs_mounts] = mount;
 	num_vfs_mounts++;
 }
@@ -190,7 +190,7 @@ bool vfs_fs_at(int idx, char* out) {
 }
 
 void vfs_register_fs_scanner(fs_scanner scanner) {
-	vfs_scanner = vmm_resize(sizeof(fs_scanner), num_vfs_scanners, num_vfs_scanners + 1, vfs_scanner);
+	vfs_scanner = krealloc(vfs_scanner, sizeof(fs_scanner) * (num_vfs_scanners + 1));
 	vfs_scanner[num_vfs_scanners] = scanner;
 	debugf("Registered VFS scanner %d at 0x%x", num_vfs_scanners, scanner);
 	num_vfs_scanners++;

mckrnl/core/net/ipv4.c

@@ -1,16 +1,15 @@
 #include <net/ipv4.h>
 #include <net/arp.h>
 #include <stdio.h>
-#include <memory/vmm.h>
 #include <string.h>
 
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <string.h>
 #include <config.h>
 #ifdef NETWORK_STACK
 
 void ipv4_register(network_stack_t* stack, ipv4_handler_t handler) {
-	stack->ipv4->handlers = vmm_resize(sizeof(ipv4_handler_t), stack->ipv4->num_handlers, stack->ipv4->num_handlers + 1, stack->ipv4->handlers);
+	stack->ipv4->handlers = krealloc(stack->ipv4->handlers, sizeof(ipv4_handler_t) * (stack->ipv4->num_handlers + 1));
 	stack->ipv4->handlers[stack->ipv4->num_handlers] = handler;
 	stack->ipv4->num_handlers++;
 }
@@ -33,7 +32,7 @@ mac_u ipv4_resolve_route(network_stack_t* stack, async_t* async, ip_u dest_ip) {
 }
 
 void ipv4_send(ipv4_handler_t* handler, network_stack_t* stack, ip_u dest_ip, mac_u route, uint8_t* payload, uint32_t size) {
-	uint8_t* buffer = vmm_alloc((size + sizeof(ipv4_message_t)) / 0x1000 + 1);
+	uint8_t* buffer = kmalloc(size + sizeof(ipv4_message_t));
 	memset(buffer, 0, size + sizeof(ipv4_message_t));
 	ipv4_message_t* ipv4 = (ipv4_message_t*) buffer;
 
@@ -60,7 +59,7 @@ void ipv4_send(ipv4_handler_t* handler, network_stack_t* stack, ip_u dest_ip, ma
 
 	etherframe_send(&stack->ipv4->handler, stack, route.mac, buffer, size + sizeof(ipv4_message_t));
 
-	vmm_free(buffer, (size + sizeof(ipv4_message_t)) / 0x1000 + 1);
+	kfree(buffer);
 }
 
 void ipv4_etherframe_recv(struct ether_frame_handler* handler, mac_u src_mac, uint8_t* payload, uint32_t size) {
@@ -117,7 +116,7 @@ uint16_t ipv4_checksum(uint16_t* data, uint32_t size) {
 }
 
 void ipv4_init(network_stack_t* stack) {
-	stack->ipv4 = vmm_alloc(PAGES_OF(ipv4_provider_t));
+	stack->ipv4 = kmalloc(sizeof(ipv4_provider_t));
 	memset(stack->ipv4, 0, sizeof(ipv4_provider_t));
 
 	stack->ipv4->handler.ether_type_be = BSWAP16(0x0800);

mckrnl/core/scheduler/resource.c

@@ -1,5 +1,6 @@
 #include <scheduler/scheduler.h>
 #include <stddef.h>
+#include <memory/heap.h>
 
 void resource_register_self(resource_t resource) {
 	task_t* self = get_self();
@@ -11,7 +12,7 @@ void resource_register_self(resource_t resource) {
 		}
 	}
 
-	self->resources = vmm_resize(sizeof(resource_t), self->num_resources, self->num_resources + 1, self->resources);
+	self->resources = krealloc(self->resources, sizeof(resource_t) * (self->num_resources + 1));
 	self->resources[self->num_resources] = resource;
 	self->num_resources++;
 }
@@ -36,7 +37,7 @@ void resource_dealloc_self() {
 	}
 
 	if (self->resources != NULL) {
-		vmm_free(self->resources, TO_PAGES(sizeof(resource_t) * self->num_resources));
+		kfree(self->resources);
 		self->resources = NULL;
 	}
 }
@@ -49,7 +50,7 @@ void resource_dealloc(task_t* self) {
 	}
 
 	if (self->resources != NULL) {
-		vmm_free(self->resources, TO_PAGES(sizeof(resource_t) * self->num_resources));
+		kfree(self->resources);
 		self->resources = NULL;
 	}
 }

mckrnl/core/syscall/syscalls.c

@@ -2,7 +2,7 @@
 
 #include <stdio.h>
 #include <stddef.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <config.h>
 
 syscall_handler_t* syscall_table = { 0 };
@@ -15,9 +15,8 @@ void register_syscall(uint8_t syscall_id, syscall_handler_t handler) {
 	}
 
 	if (syscall_id >= num_syscall_handlers) {
-		int old_num_syscall_handlers = num_syscall_handlers;
 		num_syscall_handlers = syscall_id + 1;
-		syscall_table = vmm_resize(sizeof(syscall_handler_t), old_num_syscall_handlers, num_syscall_handlers, syscall_table);
+		syscall_table = krealloc(syscall_table, sizeof(syscall_handler_t) * num_syscall_handlers);
 	}
 
 	syscall_table[syscall_id] = handler;

mckrnl/core/utils/trace.c

@@ -1,7 +1,7 @@
 #include <utils/trace.h>
 #include <stdio.h>
 #include <stddef.h>
-#include <memory/vmm.h>
+#include <memory/heap.h>
 #include <string.h>
 
 void stack_unwind(int max, void (*callback)(int frame_num, uint32_t eip)) {
@@ -25,7 +25,7 @@ void register_symbol(symbol_t sym) {
 	if (sym.name[0] == '_' && sym.name[1] == '_' && sym.name[2] == 'F') {
 		return;
 	}
-	symbols = vmm_resize(sizeof(symbol_t), symbols_count, symbols_count + 1, symbols);
+	symbols = krealloc(symbols, sizeof(symbol_t) * (symbols_count + 1));
 	symbols[symbols_count] = sym;
 	symbols_count++;
 }