kernel

Author: PythonPlumber

include/kernel.h

@@ -21,5 +21,36 @@ uint32_t acpi_rsdp_addr(void);
 uint32_t acpi_rsdt_addr(void);
 uint32_t acpi_rsdt_entries(void);
 uint32_t acpi_rsdt_entry(uint32_t index);
+uint32_t acpi_find_table(const char* signature);
+
+typedef struct {
+    uint8_t signature[4];
+    uint32_t length;
+    uint8_t revision;
+    uint8_t checksum;
+    uint8_t oemid[6];
+    uint8_t oem_table_id[8];
+    uint32_t oem_revision;
+    uint32_t creator_id;
+    uint32_t creator_revision;
+} acpi_sdt_header_t;
+
+typedef struct {
+    acpi_sdt_header_t header;
+    uint32_t local_apic_address;
+    uint32_t flags;
+} __attribute__((packed)) acpi_madt_t;
+
+typedef struct {
+    uint8_t type;
+    uint8_t length;
+} __attribute__((packed)) acpi_madt_entry_t;
+
+typedef struct {
+    acpi_madt_entry_t header;
+    uint8_t processor_id;
+    uint8_t apic_id;
+    uint32_t flags;
+} __attribute__((packed)) acpi_madt_local_apic_t;
 
 #endif

include/ports.h

@@ -11,6 +11,26 @@ static inline unsigned char inb(unsigned short port) {
     return ret;
 }
 
+static inline void outw(unsigned short port, unsigned short value) {
+    asm volatile("outw %0, %1" : : "a"(value), "Nd"(port));
+}
+
+static inline unsigned short inw(unsigned short port) {
+    unsigned short ret;
+    asm volatile("inw %1, %0" : "=a"(ret) : "Nd"(port));
+    return ret;
+}
+
+static inline void outl(unsigned short port, unsigned int value) {
+    asm volatile("outl %0, %1" : : "a"(value), "Nd"(port));
+}
+
+static inline unsigned int inl(unsigned short port) {
+    unsigned int ret;
+    asm volatile("inl %1, %0" : "=a"(ret) : "Nd"(port));
+    return ret;
+}
+
 static inline void io_wait(void) {
     asm volatile("outb %%al, $0x80" : : "a"(0));
 }

src/cpu/smp_rally.c

@@ -1,12 +1,41 @@
 #include "smp_rally.h"
+#include "kernel.h"
 #include "types.h"
+#include "util.h"
 
 static uint32_t cpu_count = 1;
 static uint32_t online_mask = 1;
 
 void smp_rally_init(void) {
     cpu_count = 1;
     online_mask = 1;
+
+    uint32_t madt_addr = acpi_find_table("APIC");
+    if (!madt_addr) {
+        return;
+    }
+
+    acpi_madt_t* madt = (acpi_madt_t*)madt_addr;
+    uint32_t length = madt->header.length;
+    uint32_t current = madt_addr + sizeof(acpi_madt_t);
+    uint32_t end = madt_addr + length;
+
+    cpu_count = 0;
+    while (current < end) {
+        acpi_madt_entry_t* entry = (acpi_madt_entry_t*)current;
+        if (entry->length == 0) break; // Prevent infinite loop
+
+        if (entry->type == 0) { // Local APIC
+            acpi_madt_local_apic_t* lapic = (acpi_madt_local_apic_t*)current;
+            if (lapic->flags & 1) { // Enabled
+                cpu_count++;
+            }
+        }
+        current += entry->length;
+    }
+
+    if (cpu_count == 0) cpu_count = 1;
+    online_mask = 1;
 }
 
 uint32_t smp_rally_cpu_count(void) {

src/kernel.c

@@ -165,35 +165,15 @@ typedef struct {
     uint32_t rsdt_address;
 } acpi_rsdp_t;
 
-typedef struct {
-    uint8_t signature[4];
-    uint32_t length;
-    uint8_t revision;
-    uint8_t checksum;
-    uint8_t oemid[6];
-    uint8_t oem_table_id[8];
-    uint32_t oem_revision;
-    uint32_t creator_id;
-    uint32_t creator_revision;
-} acpi_sdt_header_t;
-
 static uint32_t acpi_rsdp_phys = 0;
 static uint32_t acpi_rsdt_phys = 0;
 static uint32_t acpi_rsdt_count = 0;
 
 uint32_t pci_config_read(uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset) {
     uint32_t address = (uint32_t)(0x80000000u | ((uint32_t)bus << 16)
         | ((uint32_t)slot << 11) | ((uint32_t)func << 8) | (offset & 0xFC));
-    outb(0xCF8, (uint8_t)(address & 0xFF));
-    outb(0xCF8 + 1, (uint8_t)((address >> 8) & 0xFF));
-    outb(0xCF8 + 2, (uint8_t)((address >> 16) & 0xFF));
-    outb(0xCF8 + 3, (uint8_t)((address >> 24) & 0xFF));
-    uint32_t data = 0;
-    data |= (uint32_t)inb(0xCFC);
-    data |= (uint32_t)inb(0xCFC + 1) << 8;
-    data |= (uint32_t)inb(0xCFC + 2) << 16;
-    data |= (uint32_t)inb(0xCFC + 3) << 24;
-    return data;
+    outl(0xCF8, address);
+    return inl(0xCFC);
 }
 
 uint32_t pci_scan_bus(void) {
@@ -336,6 +316,19 @@ uint32_t acpi_rsdt_entry(uint32_t index) {
     return entries[index];
 }
 
+uint32_t acpi_find_table(const char* signature) {
+    if (!acpi_rsdt_phys) return 0;
+    for (uint32_t i = 0; i < acpi_rsdt_count; ++i) {
+        uint32_t entry = acpi_rsdt_entry(i);
+        if (!entry) continue;
+        const acpi_sdt_header_t* hdr = (const acpi_sdt_header_t*)entry;
+        if (memcmp(hdr->signature, signature, 4) == 0) {
+            return entry;
+        }
+    }
+    return 0;
+}
+
 static void task_a(void) {
     const char spin[] = "|/-\\";
     uint32_t i = 0;

src/kernel/sched.c

@@ -2,6 +2,7 @@
 #include "sched.h"
 #include "secure_caps.h"
 #include "signal.h"
+#include "smp_rally.h"
 #include "timer.h"
 #include "types.h"
 #include "vm_space.h"
@@ -101,10 +102,11 @@ static void list_append(process_t* proc) {
 static void enqueue_task(process_t* proc) {
     uint32_t best_cpu = 0;
     uint32_t min_count = 0xFFFFFFFF;
+    uint32_t online = smp_rally_online_mask();
 
-    // Find best CPU
+    // Find best CPU among online ones in mask
     for (uint32_t i = 0; i < MAX_CPUS; i++) {
-        if ((proc->cpu_mask & (1 << i)) && runqueues[i].count < min_count) {
+        if ((online & (1 << i)) && (proc->cpu_mask & (1 << i)) && runqueues[i].count < min_count) {
             min_count = runqueues[i].count;
             best_cpu = i;
         }
@@ -288,7 +290,7 @@ static process_t* process_create_ex(void (*entry)(void), uint32_t* page_director
     proc->time_slice = default_time_slice;
     proc->time_remaining = default_time_slice;
     proc->sched_class = SCHED_CLASS_CFS;
-    proc->cpu_mask = 1;
+    proc->cpu_mask = 0xFFFFFFFF;
     proc->cgroup_share = 1024;
 
     proc->parent_pid = proc->pid;
@@ -513,9 +515,10 @@ void scheduler_balance_load(void) {
 
     uint32_t busiest_cpu = this_cpu;
     uint32_t max_count = 0;
+    uint32_t online = smp_rally_online_mask();
 
     for (uint32_t i = 0; i < MAX_CPUS; i++) {
-        if (runqueues[i].count > max_count) {
+        if ((online & (1 << i)) && runqueues[i].count > max_count) {
             max_count = runqueues[i].count;
             busiest_cpu = i;
         }
@@ -692,7 +695,7 @@ process_t* switch_task(registers_t* saved_stack, process_t** previous) {
             int switch_needed = 0;
             if (best) {
                 // Priority class overrides
-                if (best->sched_class < current->sched_class) switch_needed = 1; 
+                if (best->sched_class > current->sched_class) switch_needed = 1; 
                 else if (best->sched_class == current->sched_class) {
                      if (best->sched_class == SCHED_CLASS_RT && best_prio > current_prio) switch_needed = 1;
                      else if (best->sched_class == SCHED_CLASS_CFS && best->vruntime < current->vruntime) switch_needed = 1;
@@ -967,6 +970,7 @@ void process_exit(process_t* proc, uint32_t code) {
                  process_t* next = p->wait_next;
                  p->wait_next = 0;
                  p->state = PROCESS_READY;
+                 enqueue_task(p);
                  p = next;
              }
              queue->head = 0;
@@ -1098,6 +1102,8 @@ process_t* wait_queue_wake_one(wait_queue_t* queue) {
 
     proc->wait_next = 0;
     proc->state = PROCESS_READY;
+    enqueue_task(proc);
+    
     spin_unlock(&sched_lock);
     return proc;
 }
@@ -1115,6 +1121,7 @@ uint32_t wait_queue_wake_all(wait_queue_t* queue) {
         process_t* next = proc->wait_next;
         proc->wait_next = 0;
         proc->state = PROCESS_READY;
+        enqueue_task(proc);
         proc = next;
         count++;
     }

src/mem/heap.c

@@ -96,14 +96,69 @@ uint32_t heap_free_bytes(void) {
 }
 
 void* aligned_alloc(uint32_t size, uint32_t align) {
+    if (size == 0 || align == 0 || !heap_head) {
+        return 0;
+    }
     if (align < 16) {
         align = 16;
     }
     if ((align & (align - 1)) != 0) {
         return 0;
     }
-    uint32_t aligned_size = align_up(size, align);
-    return kmalloc(aligned_size);
+
+    size = align_up(size, 16);
+    heap_block_t* current = heap_head;
+    while (current) {
+        if (current->free) {
+            uint32_t data_ptr = (uint32_t)current + sizeof(heap_block_t);
+            uint32_t aligned_ptr = align_up(data_ptr, align);
+            uint32_t padding = aligned_ptr - data_ptr;
+            
+            uint32_t required_size = size + padding;
+            
+            if (current->size >= required_size) {
+                // If there's padding, we MUST split the block so that the 
+                // returned pointer has its header immediately before it.
+                if (padding > 0) {
+                     while (padding < sizeof(heap_block_t)) {
+                         // Not enough space for a header in the padding.
+                         // We need more padding to fit a header.
+                         // Instead, we move to the NEXT aligned address.
+                         aligned_ptr += align;
+                         padding = aligned_ptr - data_ptr;
+                         required_size = size + padding;
+                         
+                         if (current->size < required_size) {
+                             goto next_block;
+                         }
+                     }
+                    
+                    // Now padding >= sizeof(heap_block_t).
+                    // We can split.
+                    uint32_t old_size = current->size;
+                    current->size = padding - sizeof(heap_block_t);
+                    
+                    heap_block_t* next = (heap_block_t*)((uint8_t*)current + padding);
+                    next->size = old_size - padding;
+                    next->free = 1;
+                    next->next = current->next;
+                    current->next = next;
+                    
+                    // The block we want is 'next'
+                    current = next;
+                }
+                
+                // Now split at the end if needed
+                split_block(current, size);
+                current->free = 0;
+                
+                return (void*)((uint8_t*)current + sizeof(heap_block_t));
+            }
+        }
+next_block:
+        current = current->next;
+    }
+    return 0;
 }
 
 void kheap_stats(uint32_t* total_bytes, uint32_t* free_bytes) {