memory safety stuff

Author: braindigitalis

include/e1000.h

@@ -157,4 +157,4 @@ void e1000_get_mac_addr(uint8_t* src_mac_addr);
 
 bool e1000_send_packet(void * p_data, uint16_t p_len);
 
-bool init_e1000();
+void init_e1000();

include/kmalloc.h

@@ -12,25 +12,120 @@
 
 #include <stddef.h>
 
-/* Initialize the heap system */
-void init_heap();
-void print_heapinfo();
+/**
+ * @brief Initialise the kernel heap.
+ *
+ * Sets up internal data structures required for dynamic memory allocation.
+ * Should be called early during kernel initialisation.
+ */
+void init_heap(void);
+
+/**
+ * @brief Print diagnostic heap information to the terminal.
+ *
+ * Outputs allocator statistics such as used, free, and total heap space.
+ * Primarily for debugging and diagnostics.
+ */
+void print_heapinfo(void);
 
-/* Core alloc/free */
+/**
+ * @brief Allocate memory from the kernel heap.
+ *
+ * @param size Number of bytes to allocate.
+ * @return Pointer to allocated memory, or NULL if allocation fails.
+ */
 void* kmalloc(uint64_t size);
+
+/**
+ * @brief Free previously allocated memory.
+ *
+ * @param addr Pointer previously returned by kmalloc/kcalloc/krealloc.
+ */
 void kfree(const void* addr);
 
-/* calloc/realloc helpers */
+/**
+ * @brief Allocate zero-initialised memory.
+ *
+ * @param num Number of elements.
+ * @param size Size of each element in bytes.
+ * @return Pointer to allocated memory, or NULL if allocation fails.
+ */
 void* kcalloc(size_t num, size_t size);
+
+/**
+ * @brief Resize previously allocated memory block.
+ *
+ * Preserves contents up to the lesser of old and new sizes.
+ *
+ * @param ptr Pointer to memory allocated by kmalloc/kcalloc/krealloc.
+ * @param new_size New size in bytes.
+ * @return Pointer to reallocated memory, or NULL if resizing fails.
+ */
 void* krealloc(void* ptr, size_t new_size);
 
-/* Low-memory special allocator: for <4GB identity mapped area */
+/**
+ * @brief Allocate memory from low (identity-mapped) memory under 4GB.
+ *
+ * Intended for DMA buffers or page tables that require low physical addresses.
+ *
+ * @param size Number of bytes to allocate.
+ * @return Physical address of the allocated block (below 4GB).
+ */
 uint32_t kmalloc_low(uint32_t size);
-void kfree_low(uint32_t addr);  /* New: explicitly free low memory if needed */
 
-/* Debug/statistics */
-uint64_t get_free_memory();
-uint64_t get_used_memory();
-uint64_t get_total_memory();
+/**
+ * @brief Free a low-memory allocation made with kmalloc_low().
+ *
+ * Only needed if low memory is explicitly managed and reused.
+ *
+ * @param addr Physical address of the block to free.
+ */
+void kfree_low(uint32_t addr);
+
+/**
+ * @brief Get total amount of free memory.
+ *
+ * @return Free heap space in bytes.
+ */
+uint64_t get_free_memory(void);
+
+/**
+ * @brief Get total amount of used memory.
+ *
+ * @return Used heap space in bytes.
+ */
+uint64_t get_used_memory(void);
+
+/**
+ * @brief Get total available memory managed by the kernel heap.
+ *
+ * @return Total heap size in bytes.
+ */
+uint64_t get_total_memory(void);
+
+/**
+ * @brief Halt the system with a preboot failure message.
+ *
+ * Used when a critical failure occurs before full initialisation.
+ *
+ * @param msg Null-terminated string describing the failure.
+ */
 void preboot_fail(const char* msg);
 
+/**
+ * @brief Free memory and set the pointer to NULL.
+ *
+ * This macro safely frees a dynamically allocated pointer and sets it to NULL
+ * to avoid dangling references. It must be passed the address of the pointer
+ * (i.e., a pointer to the pointer).
+ *
+ * Example usage:
+ * @code
+ * void* ptr = kmalloc(128);
+ * kfree_null(&ptr); // ptr is now NULL
+ * @endcode
+ *
+ * @param p A pointer to the pointer to be freed. Must not be NULL.
+ */
+#define kfree_null(p) do { kfree(*(p)); *(p) = NULL; } while (0)
+

include/rtl8139.h

@@ -184,9 +184,8 @@ void rtl8139_handler(uint8_t isr, uint64_t error, uint64_t irq, void* opaque);
  * @brief Initialise RTL8139
  * 
  * @return true card detected and initialised
- * @return false card not detected, or would not reset
  */
-bool init_rtl8139();
+void init_rtl8139();
 
 /**
  * @brief Get the MAC address of the card in display format

include/string.h

@@ -7,11 +7,11 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-struct gc_str
+typedef struct gc_str
 {
 	const char* ptr;
-	struct gc_str* next;
-};
+	struct gc_str_t* next;
+} gc_str_t;
 
 unsigned int strlen(const char* str);
 

src/arp.c

@@ -101,7 +101,7 @@ void arp_send_packet(uint8_t* dst_hardware_addr, uint8_t* dst_protocol_addr) {
 
 	ethernet_send_packet(broadcast_mac_address, (uint8_t*)arp_packet, sizeof(arp_packet_t), ETHERNET_TYPE_ARP);
 
-	kfree(arp_packet);
+	kfree_null(&arp_packet);
 }
 
 void arp_prediscover(uint8_t* protocol_addr) {

src/dhcp.c

@@ -7,12 +7,12 @@ void dhcp_handle_packet(uint32_t src_ip, uint16_t src_port, uint16_t dst_port, v
 		if (*type == DHCPOFFER) {
 			uint32_t* server_ip = get_dhcp_options(packet, OPT_SERVER_IP);
 			if (!server_ip) {
-				kfree(type);
-				kfree(server_ip);
+				kfree_null(&type);
+				kfree_null(&server_ip);
 				return;
 			}
 			dhcp_request((uint8_t*)&packet->your_ip, packet->xid, *server_ip);
-			kfree(server_ip);
+			kfree_null(&server_ip);
 		} else if (*type == DHCPACK) {
 			sethostaddr((const unsigned char*)&packet->your_ip);
 			uint32_t* dns = get_dhcp_options(packet, OPT_DNS);
@@ -22,25 +22,25 @@ void dhcp_handle_packet(uint32_t src_ip, uint16_t src_port, uint16_t dst_port, v
 			if (subnet) {
 				setnetmask(*subnet);
 				get_ip_str(ip, (uint8_t*)subnet);
-				kfree(subnet);
+				kfree_null(&subnet);
 				dprintf("DHCP: Received subnet mask: %s\n", ip);
 			}
 			if (dns) {
 				setdnsaddr(*dns);
 				get_ip_str(ip, (uint8_t*)dns);
-				kfree(dns);
+				kfree_null(&dns);
 				dprintf("DHCP: Received DNS address: %s\n", ip);
 			}
 			if (gateway) {
 				setgatewayaddr(*gateway);
 				get_ip_str(ip, (uint8_t*)gateway);
-				kfree(gateway);
+				kfree_null(&gateway);
 				dprintf("DHCP: Received gateway address: %s\n", ip);
 			}
 		} else if (*type == DHCPNAK) {
 			/* Negative ack, to be implemented */
 		}
-		kfree(type);
+		kfree_null(&type);
 	}
 }
 
@@ -53,7 +53,7 @@ void dhcp_discover() {
 	memset(packet, 0, sizeof(dhcp_packet_t));
 	uint16_t optsize = make_dhcp_packet(packet, DHCPDISCOVER, request_ip, DHCP_TRANSACTION_IDENTIFIER, 0);
 	udp_send_packet(dst_ip, DHCP_DST_PORT, DHCP_SRC_PORT, packet, optsize);
-	kfree(packet);
+	kfree_null(&packet);
 }
 
 void dhcp_request(uint8_t* request_ip, uint32_t xid, uint32_t server_ip) {
@@ -62,7 +62,7 @@ void dhcp_request(uint8_t* request_ip, uint32_t xid, uint32_t server_ip) {
 	memset(packet, 0, sizeof(dhcp_packet_t));
 	uint16_t optsize = make_dhcp_packet(packet, DHCPREQUEST, request_ip, xid, server_ip);
 	udp_send_packet(dst_ip, DHCP_DST_PORT, DHCP_SRC_PORT, packet, optsize);
-	kfree(packet);
+	kfree_null(&packet);
 }
 
 void* get_dhcp_options(dhcp_packet_t* packet, uint8_t type) {
@@ -73,7 +73,9 @@ void* get_dhcp_options(dhcp_packet_t* packet, uint8_t type) {
 		uint8_t len = *(options + 1);
 		if (curr_type == type) {
 			void* ret = kmalloc(len);
-			memcpy(ret, options + 2, len);
+			if (ret) {
+				memcpy(ret, options + 2, len);
+			}
 			return ret;
 		}
 		options += (2 + len);

src/e1000.c

@@ -372,7 +372,7 @@ bool e1000_start(pci_dev_t *pci_device) {
 	return true;
 }
 
-bool init_e1000() {
+void init_e1000() {
 	pci_dev_t pci_device;
 	bool found = false;
 
@@ -386,7 +386,7 @@ bool init_e1000() {
 		}
 	}
 	if (!found) {
-		return false;
+		return;
 	}
 	uint32_t ret = pci_read(pci_device, PCI_BAR0);
 	bar_type = pci_bar_type(ret);
@@ -398,5 +398,5 @@ bool init_e1000() {
 	pci_bus_master(pci_device);
 	eerprom_exists = false;
 
-	return e1000_start(&pci_device);
+	e1000_start(&pci_device);
 }

src/ethernet.c

@@ -19,7 +19,7 @@ int ethernet_send_packet(uint8_t* dst_mac_addr, uint8_t* data, int len, uint16_t
 	frame->type = htons(protocol);
 	dprintf("ethernet_send_packet frame=%08x\n", frame);
 	dev->send_packet(frame, sizeof(ethernet_frame_t) + len);
-	kfree(frame);
+	kfree_null(&frame);
 	return len;
 }
 

src/init.c

@@ -7,6 +7,7 @@ init_func_t init_funcs[] = {
 	init_cores, init_idt, init_pci, init_realtime_clock,
 	init_devicenames, init_keyboard, init_ide, init_ahci,
 	init_filesystem, init_iso9660, init_devfs, init_fat32,
+	init_rtl8139, init_e1000,
 	NULL,
 };
 
@@ -15,6 +16,7 @@ char* init_funcs_names[] = {
 	"idt",		"pci",			"clock",
 	"devicenames",	"keyboard",		"ide",		"ahci",
 	"filesystem",	"iso9660",		"devfs",	"fat32",
+	"rtl8139",	"e1000",
 	NULL,
 };