improving io.asm and isr.asm

src/drivers/io/io.asm

@@ -1,14 +1,24 @@
+section .text
 global inb
 global outb
 
-section .text
+; Read a byte from the specified port
+; Input: DX = port number
+; Output: AL = data read from the port
 inb:
-    MOV DX, WORD [ESP + 16]
+    PUSH DX    ; Preserve DX
-    IN AL, DX
+    IN AL, DX  ; Read from port
+    POP DX     ; Restore DX
     RET
 
+; Write a byte to the specified port
+; Input: DX = port number, AL = data to write
 outb:
-    MOV DX, WORD [ESP + 16]
+    PUSH DX    ; Preserve DX
-    MOV AL, BYTE [ESP + 24]
+    PUSH AX    ; Preserve AX
-    OUT DX, AL
+    MOV DX, [ESP + 4] ; Get port number from stack
+    MOV AL, [ESP + 6] ; Get data from stack
+    OUT DX, AL  ; Write to port
+    POP AX     ; Restore AX
+    POP DX     ; Restore DX
     RET

src/kernel/arch/x86/include/memory.h

@@ -1,11 +1,13 @@
-#ifndef MEMORY_H
+#ifndef MEMORY_H
-#define MEMORY_H
+#define MEMORY_H
-
+
-#include <stddef.h>
+#include <stddef.h>
-#include <stdint.h>
+#include <stdint.h>
-
+
-void  init_heap(void *start, size_t size);
+void init_heap(void *start, size_t size);
-void *kmalloc(size_t size);
+void *kmalloc(size_t size);
-void  kfree(void *ptr);
+void kfree(void *ptr);
-
+void *malloc(size_t size); // Adding malloc and free declarations
-#endif /* MEMORY_H */
+void free(void *ptr);
+
+#endif /* MEMORY_H */

src/kernel/arch/x86/isr/isr.asm

@@ -1,11 +1,50 @@
+section .text
 global isr_handler
 global _isr_stub
 
 _isr_stub:
-    PUSH DWORD [ESP + 8]
+    ; Save context
-    PUSH DWORD [ESP + 8]
+    PUSHAD ; Preserve all general-purpose registers
 
+    ; Disable interrupts to handle nested interrupts
+    CLI
+
+    ; Align stack to 16-byte boundary for performance (if needed)
+    ; AND ESP, 0xFFFFFFF0
+
+    ; Check if an error code is present (typically in EAX)
+    ; This is just a placeholder, actual implementation depends on your IDT setup
+    CMP BYTE [ISR_HAS_ERROR_CODE], 1
+    JNE no_error_code
+    PUSH DWORD [ESP + 32] ; Push error code
+    JMP done_pushing_error_code
+no_error_code:
+    PUSH DWORD 0 ; Push a dummy error code
+done_pushing_error_code:
+
+    ; Push interrupt number onto the stack
+    MOV EAX, [ESP + 36] ; Move interrupt number to EAX (accounting for the dummy/error code)
+    PUSH EAX ; Interrupt number
+
+    ; Call isr_handler
     CALL isr_handler
 
-    ADD ESP, 8
+    ; Send EOI to PIC only if it's a hardware interrupt
+    ; This is just a placeholder, actual implementation depends on your IDT setup
+    CMP BYTE [ISR_IS_HARDWARE_INTERRUPT], 1
+    JNE skip_eoi
+    MOV AL, 0x20
+    OUT 0x20, AL
+skip_eoi:
+
+    ; Enable interrupts
+    STI
+
+    ; Clean up the stack
+    ADD ESP, 8 ; Remove error code and interrupt number
+
+    ; Restore context
+    POPAD ; Restore all general-purpose registers
+
+    ; Return from interrupt
     IRETD

src/kernel/arch/x86/memory/memory.c

@@ -1,59 +1,80 @@
-#include "../include/memory.h"
+#include "../include/memory.h"
-#include <stddef.h>
+#include <stddef.h>
-#include <string.h>
+#include <string.h>
-
+
-/* The start of the kernel heap */
+/* The start of the kernel heap */
-static uint8_t *heap_start = NULL;
+static uint8_t *heap_start = NULL;
-
+
-/* The end of the kernel heap */
+/* The end of the kernel heap */
-static uint8_t *heap_end = NULL;
+static uint8_t *heap_end = NULL;
-
+
-/* The current position of the heap */
+/* The current position of the heap */
-static uint8_t *heap_pos = NULL;
+static uint8_t *heap_pos = NULL;
-
+
-/* The size of the heap */
+/* The size of the heap */
-static size_t heap_size = 0;
+static size_t heap_size = 0;
-
+
-void init_heap(void *start, size_t size)
+void init_heap(void *start, size_t size)
-{
+{
-    heap_start = (uint8_t *)start;
+	heap_start = (uint8_t *)start;
-    heap_end   = heap_start + size;
+	heap_end = heap_start + size;
-    heap_pos   = heap_start;
+	heap_pos = heap_start;
-    heap_size  = size;
+	heap_size = size;
-}
+}
-
+
-void *kmalloc(size_t size)
+void *kmalloc(size_t size)
-{
+{
-    /* Round up the size to a multiple of 4 bytes */
+	/* Round up the size to a multiple of 4 bytes */
-    size = (size + 3) & ~3;
+	size = (size + 3) & ~3;
-
+
-    /* Check if there is enough space in the heap */
+	/* Check if there is enough space in the heap */
-    if (heap_pos + size > heap_end)
+	if (heap_pos + size > heap_end)
-    {
+	{
-        return NULL;
+		return NULL;
-    }
+	}
-
+
-    /* Allocate memory from the heap */
+	/* Allocate memory from the heap */
-    void *ptr = heap_pos;
+	void *ptr = heap_pos;
-    heap_pos += size;
+	heap_pos += size;
-
+
-    return ptr;
+	return ptr;
-}
+}
-
+
-void kfree(void *ptr)
+// Implementing a simple malloc-like function
-{
+void *malloc(size_t size)
-    /* Check if the pointer is within the heap */
+{
-    if ((uint8_t *)ptr >= heap_start && ptr < (void *)heap_end)
+	// Round up the size to a multiple of  4 bytes
-    {
+	size = (size + 3) & ~3;
-        /* Zero out the memory */
+
-        volatile uint8_t *volatile_ptr = (volatile uint8_t *)ptr;
+	// Call kmalloc to allocate memory from the heap
-        size_t            size         = (uint8_t *)heap_pos - (uint8_t *)ptr;
+	return kmalloc(size);
-        while (size--)
+}
-        {
+
-            *volatile_ptr++ = 0;
+// Implementing a simple free-like function
-        }
+void free(void *ptr)
-
+{
-        /* Free the memory by moving the heap position */
+	// Check if the pointer is within the heap
-        heap_pos = (uint8_t *)ptr;
+	if ((uint8_t *)ptr >= heap_start && ptr < (void *)heap_end)
-    }
+	{
-}
+		// Call kfree to deallocate the memory
+		kfree(ptr);
+	}
+}
+
+void kfree(void *ptr)
+{
+	/* Check if the pointer is within the heap */
+	if ((uint8_t *)ptr >= heap_start && ptr < (void *)heap_end)
+	{
+		/* Zero out the memory */
+		volatile uint8_t *volatile_ptr = (volatile uint8_t *)ptr;
+		size_t size = (uint8_t *)heap_pos - (uint8_t *)ptr;
+		while (size--)
+		{
+			*volatile_ptr++ = 0;
+		}
+
+		/* Free the memory by moving the heap position */
+		heap_pos = (uint8_t *)ptr;
+	}
+}