Rewrote physical memory allocator

The physical memory allocator now uses a buddy allocator instead of a stack.

Also moved some of the platform-independent context code to kernel.c.

include/kernel.h

@@ -35,8 +35,9 @@ struct boot_info_t
 {
     char *bootloader;
     char *parameters;
-    size_t module_count;
+    size_t memory_size;
     struct memory_map_t map;
+    size_t module_count;
     struct module_t modules[module_limit];
 };
 
@@ -94,9 +95,9 @@ unsigned long kernel_current_pid();
 
 struct process_context_t *kernel_current_context();
 
-enum error_t kernel_store_active_context(struct process_context_t *context, size_t size);
+enum error_t kernel_store_active_context(struct process_context_t *context);
 
-enum error_t kernel_spawn_process(void *program_entry, int priority, physaddr_t address_space);
+unsigned long kernel_spawn_process(void *program_entry, int priority, physaddr_t address_space);
 
 struct process_context_t *kernel_advance_scheduler();
 
@@ -108,11 +109,11 @@ enum error_t kernel_remove_port(unsigned long id);
 
 unsigned long kernel_get_port_owner(unsigned long id);
 
-enum error_t kernel_send_message(int recipient, struct message_t *message);
+enum error_t kernel_send_message(unsigned long recipient, struct message_t *message);
 
-enum error_t kernel_queue_sender(int recipient);
+enum error_t kernel_queue_sender(unsigned long recipient);
 
-enum error_t kernel_queue_message(int recipient, struct message_t *message);
+enum error_t kernel_queue_message(unsigned long recipient, struct message_t *message);
 
 int receive_message(struct message_t *buffer, int flags);
 

include/mmgr.h

@@ -8,10 +8,24 @@
 extern const size_t page_size;
 
 /**
- * @brief Pop the topmost address from the stack and returns that value.
+ * @brief 
  * 
- * If the stack is empty, this function will instead return a status code. This
+ * @param size 
- * can be identified by testing the least signifigant bits of the return value.
+ * @return physaddr_t 
+ */
+physaddr_t reserve_region(size_t size);
+
+/**
+ * @brief 
+ * 
+ * @param location 
+ * @param size 
+ * @return int 
+ */
+int free_region(physaddr_t location, size_t size);
+
+/**
+ * @brief Reserves a single page and returns its physical address.
  * 
  * @param stack 
  * @return physaddr_t 
@@ -19,9 +33,7 @@ extern const size_t page_size;
 physaddr_t reserve_page();
 
 /**
- * @brief Pushes `location` onto the stack.
+ * @brief Marks the page at the given location as free.
- * 
- * If there is no room on the stack, the stack will be unaffected.
  * 
  * @param stack 
  * @param location 
@@ -41,22 +53,25 @@ size_t free_page_count();
  * 
  * @return void* 
  */
-void *page_stack_bottom();
+void *page_map_base();
 
 /**
  * @brief Get the location of the top of the page stack.
  * 
  * @return void* 
  */
-void *page_stack_top();
+void *page_map_end();
 
 /**
- * @brief Push all available pages in `map` onto the stack
+ * @brief Constructs the bitmaps used by the physical memory allocator.
  * 
- * @param stack 
  * @param map 
+ * @param base 
+ * @param memory_size 
+ * @param block_size 
+ * @return enum error_t 
  */
-int initialize_page_stack(struct memory_map_t *map, physaddr_t *stack_base);
+enum error_t initialize_page_map(struct memory_map_t *map, void *base, size_t memory_size, unsigned long block_size);
 
 /**
  * @brief Create a new top-level page table and map the kernel in it.

include/platform/context.h

@@ -1,19 +1,35 @@
-#pragma once
+#ifndef _QUARK_CONTEXT_H
+#define _QUARK_CONTEXT_H
 
-struct process_context_t;
+#include <stdint.h>
+
+#if defined __i386__ || defined __x86_64__
+#define DEFAULT_FLAGS 0x3200
+#endif
 
 /**
- * @brief Allocates a new process context and initializes it with the given 
+ * @brief Stores the context of a particular process. The contents of this
- * program counter.
+ * struct are platform-specific.
  * 
- * @param task_entry 
- * @return void* 
  */
-void *initialize_context(void *pc);
+struct process_context_t
+{
 
-void destroy_context(void *ctx);
+#if defined __i386__
+    uint32_t gp_registers[8];
+    uint32_t ss;
+    uint32_t cs;
+    uint32_t eip;
+    uint32_t flags;
+#elif defined __x86_64__
+    uint64_t gp_registers[16];
+    uint64_t ss;
+    uint64_t cs;
+    uint64_t rip;
+    uint64_t flags;
+#endif
 
-void save_context(struct process_context_t *context);
+};
 
 void load_context(struct process_context_t *context);
 
@@ -24,3 +40,5 @@ void set_context_stack(struct process_context_t *context, void *stack);
 void set_context_flags(struct process_context_t *context, unsigned long flags);
 
 void set_context_return(struct process_context_t *context, unsigned long value);
+
+#endif

include/x86/processstate.h

@@ -1,21 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-#define PCB_LOCATION 0x800
-
-struct process_context_t
-{
-    uint32_t eax;
-    uint32_t ebx;
-    uint32_t ecx;
-    uint32_t edx;
-    uint32_t edi;
-    uint32_t esi;
-    uint32_t ebp;
-    uint32_t ss;
-    uint32_t esp;
-    uint32_t cs;
-    uint32_t eip;
-    uint32_t flags;
-};

src/kernel.c

@@ -18,10 +18,11 @@ struct kernel_t kernel;
 void kernel_initialize(struct boot_info_t *boot_info)
 {
     insert_region(&boot_info->map, (physaddr_t)&_kernel_pstart, (physaddr_t)&_kernel_pend - (physaddr_t)&_kernel_pstart, M_UNAVAILABLE);
-    initialize_page_stack(&boot_info->map, (physaddr_t*)&_kernel_end);
+    initialize_page_map(&boot_info->map, (physaddr_t*)&_kernel_end, boot_info->memory_size, page_size);
-    kminit(&_kernel_start, page_stack_top(), 0xFFC00000 - (size_t)&_kernel_start, 64);
+    kminit(&_kernel_start, page_map_end(), 0xFFC00000 - (size_t)&_kernel_start, 64);
     initialize_screen();
     printf("***%s***\n", PACKAGE_STRING);
+    printf("Total memory: %08x\n", boot_info->memory_size);
     printf("Type\t\tLocation\t\tSize\n");
     for (size_t i = 0; i < boot_info->map.size && boot_info->map.array[i].size > 0; i++)
     {
@@ -217,14 +218,22 @@ struct process_context_t *kernel_current_context()
     }  
 }
 
-enum error_t kernel_spawn_process(void *program_entry, int priority, physaddr_t address_space)
+unsigned long kernel_spawn_process(void *program_entry, int priority, physaddr_t address_space)
 {
     struct process_t *new_process = (struct process_t*) kmalloc(sizeof(struct process_t));
     if(new_process == NULL)
     {
         return 0;
     }
-    struct process_context_t *initial_context = initialize_context(program_entry);
+    struct process_context_t *initial_context = kmalloc(sizeof(struct process_context_t));
+    if(initial_context == NULL)
+    {
+        return 0;
+    }
+    memset(initial_context, 0, sizeof(struct process_context_t));
+    set_context_pc(initial_context, program_entry);
+    set_context_flags(initial_context, DEFAULT_FLAGS);
+    set_context_stack(initial_context, NULL);
     new_process->priority = priority;
     new_process->pid = kernel.next_pid;
     new_process->page_table = address_space;
@@ -268,16 +277,26 @@ enum error_t kernel_terminate_process(size_t process_id)
     }
     kernel.process_table = avl_remove(kernel.process_table, process_id);
     priorityqueue_remove(&kernel.priority_queue, process);
-    destroy_context(process->ctx);
+    for(struct message_t *msg = queue_get_next(&process->message_queue); msg != NULL; msg = queue_get_next(&process->message_queue))
+    {
+        kfree(msg);
+    }
+    for(struct process_t *sender = queue_get_next(&process->sending_queue); sender != NULL; sender = queue_get_next(&process->sending_queue))
+    {
+        sender->state = PROCESS_ACTIVE;
+        set_context_return(sender->ctx, EEXITED);
+        priorityqueue_insert(&kernel.priority_queue, sender, sender->priority);
+    }
+    kfree(process->ctx);
     kfree(process);
     return ENONE;
 }
 
-enum error_t kernel_store_active_context(struct process_context_t *context, size_t size)
+enum error_t kernel_store_active_context(struct process_context_t *context)
 {
     if(kernel.active_process != NULL && kernel.active_process->ctx != NULL)
     {
-        memcpy(kernel.active_process->ctx, context, size);
+        memcpy(kernel.active_process->ctx, context, sizeof(*context));
         return ENONE;
     }
     else
@@ -330,7 +349,7 @@ unsigned long kernel_get_port_owner(unsigned long id)
     }
 }
 
-enum error_t kernel_send_message(int recipient, struct message_t *message)
+enum error_t kernel_send_message(unsigned long recipient, struct message_t *message)
 {
     struct process_t *dest = avl_get(kernel.process_table, recipient);
     if(dest == NULL)
@@ -358,7 +377,7 @@ enum error_t kernel_send_message(int recipient, struct message_t *message)
     }
 }
 
-enum error_t kernel_queue_sender(int recipient)
+enum error_t kernel_queue_sender(unsigned long recipient)
 {
     struct process_t *dest = avl_get(kernel.process_table, recipient);
     if(dest != NULL)
@@ -375,7 +394,7 @@ enum error_t kernel_queue_sender(int recipient)
     }
 }
 
-enum error_t kernel_queue_message(int recipient, struct message_t *message)
+enum error_t kernel_queue_message(unsigned long recipient, struct message_t *message)
 {
     struct process_t *dest = avl_get(kernel.process_table, recipient);
     if(dest != NULL)

src/mmgr.c

@@ -1,5 +1,6 @@
 #include "mmgr.h"
 #include "string.h"
+#include "math.h"
 #include "platform/paging.h"
 #include "types/status.h"
 #include <stdint.h>
@@ -12,11 +13,12 @@
  */
 struct page_stack_t
 {
+    
     /**
      * @brief The total number of physical pages managed by the system.
      * 
      */
-    size_t total_pages;
+    unsigned long total_pages;
 
     /**
      * @brief Points to the topmost physical address on the stack.
@@ -39,81 +41,230 @@ struct page_stack_t
 
 } page_stack;
 
-int initialize_page_stack(struct memory_map_t *map, physaddr_t *stack_base)
+struct page_map_t
 {
-    page_stack.base_pointer = stack_base;
+    /**
-    page_stack.limit_pointer = stack_base;
+     * @brief The underlying bitmap representing the availability of chunks of
-    page_stack.stack_pointer = stack_base;
+     * physical memory.
-    page_stack.total_pages = 0;
+     * 
-    for(int i = 0; i < map->size; i++)
+     */
+    unsigned long *bitmap;
+
+    /**
+     * @brief The size of the bitmap in bytes.
+     * 
+     */
+    unsigned long bitmap_size;
+
+    /**
+     * @brief The size in bytes of the smallest unit of allocation.
+     * 
+     * This value should either be the size of a page on the host system, or
+     * possibly some number of pages.
+     * 
+     */
+    unsigned long block_size;
+
+    /**
+     * @brief 
+     * 
+     */
+    unsigned long height;
+
+    /**
+     * @brief The number of available blocks of memory. 
+     * 
+     * Due to memory fragmentation, it may not be possible to allocate all 
+     * available memory at once.
+     * 
+     */
+    unsigned long free_block_count;
+} page_map;
+
+const int bitmap_word_size = 8 * sizeof(*page_map.bitmap);
+
+int split_block(int index)
+{
+    if(index)
     {
-        if(map->array[i].type != M_AVAILABLE)
+        int bitmap_index = index / bitmap_word_size;
-        {
+        int bitmap_offset = index % bitmap_word_size;
-            continue;
+        page_map.bitmap[bitmap_index] &= ~(1 << bitmap_offset);
+        index *= 2;
+        bitmap_index = index / bitmap_word_size;
+        bitmap_offset = index / bitmap_word_size;
+        page_map.bitmap[bitmap_index] |= 1 << bitmap_offset;
+        page_map.bitmap[bitmap_index] |= 1 << (bitmap_offset ^ 1);
     }
-        size_t location = (map->array[i].location + page_size - 1) & ~(page_size - 1);
+    return index;
-        while(location + page_size <= map->array[i].location + map->array[i].size)
+}
+
+int find_free_region(int height)
+{
+    if(height > page_map.height || height < 0)
     {
-            if(free_page(location) != ENONE)
+        return 0;
+    }
+    else if(height <= page_map.height - ilog2(bitmap_word_size))
+    {
+        for(int index = (1 << (page_map.height - height)) / bitmap_word_size; 
+            index < (1 << (page_map.height - height + 1)) / bitmap_word_size; 
+            index++)
+        {
+            if(page_map.bitmap[index] != 0)
+            {
+                return bitmap_word_size * index + __builtin_ctz(page_map.bitmap[index]);
+            }
+        }
+    }
+    else
+    {
+        static const int bitmasks[] = {0x00000002, 0x0000000C, 0x000000F0, 0x0000FF00, 0xFFFF0000};
+        int depth = page_map.height - height;
+        if(page_map.bitmap[0] & bitmasks[depth])
+        {
+            return __builtin_ctz(page_map.bitmap[0] & bitmasks[depth]);
+        }
+    }
+    return split_block(find_free_region(height + 1));
+}
+
+physaddr_t reserve_region(size_t size)
+{
+    int height = llog2(size / page_map.block_size);
+    int index = find_free_region(height);
+    if(index)
+    {
+        int bitmap_index = index / bitmap_word_size;
+        int bitmap_offset = index % bitmap_word_size;
+        page_map.bitmap[bitmap_index] &= ~(1 << bitmap_offset);
+        return (page_map.block_size << height) * (index - (1 << (page_map.height - height)));
+    }
+    else
     {
         return ENOMEM;
     }
-            page_stack.total_pages++;
+}
-            location += page_size;
+
-        }
+int free_region(physaddr_t location, size_t size)
+{
+    int height = llog2(size / page_map.block_size);
+    int index = (location / (page_map.block_size * (1 << height))) + (1 << (page_map.height - height));
+    int bitmap_index = index / bitmap_word_size;
+    int bitmap_offset = index % bitmap_word_size;
+    page_map.bitmap[bitmap_index] |= 1 << bitmap_offset;
+    while(page_map.bitmap[bitmap_index] & (1 << (bitmap_offset ^ 1)))
+    {
+        page_map.bitmap[bitmap_index] &= ~(1 << bitmap_offset);
+        page_map.bitmap[bitmap_index] &= ~(1 << (bitmap_offset ^ 1));
+        index /= 2;
+        bitmap_index = index / bitmap_word_size;
+        bitmap_offset = index % bitmap_word_size;
+        page_map.bitmap[bitmap_index] |= 1 << bitmap_offset;
     }
     return ENONE;
 }
 
 physaddr_t reserve_page()
 {
-    if(page_stack.stack_pointer > page_stack.base_pointer)
+    return reserve_region(page_size);
-    {
-        page_stack.stack_pointer--;
-        physaddr_t frame = *page_stack.stack_pointer;
-        *page_stack.stack_pointer = (physaddr_t) 0;
-        return frame;
-    }
-    return ENOMEM;
 }
 
 int free_page(physaddr_t location)
 {
-    if(page_stack.stack_pointer < page_stack.limit_pointer)
+    return free_region(location, page_size);
-    {
-        *page_stack.stack_pointer = location;
-        page_stack.stack_pointer++;
-        return ENONE;
-    }
-    else
-    {
-        switch(map_page(page_stack.limit_pointer, location, PAGE_RW))
-        {
-        case ENOMEM:
-            return ENOMEM;
-        case EOUTOFBOUNDS:
-            return EOUTOFBOUNDS;
-        case ENONE:
-            page_stack.limit_pointer += page_size / sizeof(*page_stack.limit_pointer);
-            return ENONE;
-        }
-        return ENOMEM;
-    }
 }
 
 size_t free_page_count()
 {
-    return page_stack.base_pointer - page_stack.stack_pointer;
+    return page_map.free_block_count;
 }
 
-void *page_stack_bottom()
+void *page_map_base()
 {
-    return (void*)page_stack.base_pointer;
+    return (void*)page_map.bitmap;
 }
 
-void *page_stack_top()
+void *page_map_end()
 {
-    return (void*)page_stack.limit_pointer;
+    return (void*)page_map.bitmap + page_map.bitmap_size;
+}
+
+enum error_t initialize_page_map(struct memory_map_t *map, void *base, size_t memory_size, unsigned long block_size)
+{
+    // Round memory_size up to nearest power of 2
+    memory_size = 1 << llog2(memory_size);
+    page_map.bitmap = (unsigned long*) base;
+    page_map.bitmap_size = (memory_size / page_size) / 4;
+    page_map.block_size = block_size;
+    page_map.height = llog2(memory_size / block_size);
+    page_map.free_block_count = 0;
+    int block_log = llog2(block_size);
+    int pages_mapped = 0;
+    for(int i = 0; i < map->size; i++)
+    {
+        if(map->array[i].type != M_AVAILABLE)
+        {
+            continue;
+        }
+        physaddr_t location = (map->array[i].location + page_size - 1) & ~(page_size - 1);
+        physaddr_t region_end = map->array[i].location + map->array[i].size;
+        while(location + block_size <= region_end)
+        {
+            if(pages_mapped < page_map.bitmap_size / page_size)
+            {
+                void *page = (void*)page_map.bitmap + pages_mapped * page_size;
+                for(int level = 0; level < page_table_levels; level++)
+                {
+                    if(!(get_pte_type(page, level) & PAGE_PRESENT))
+                    {
+                        if(set_pte(page, level, PAGE_PRESENT | PAGE_RW, location))
+                        {
+                            return ENOMEM;
+                        }
+                        else if(level == page_table_levels - 1)
+                        {
+                            pages_mapped++;
+                        }
+                        break;
+                    }
+                    else if(level == page_table_levels - 1)
+                    {
+                        pages_mapped++;
+                    }
+                }
+                location += page_size;
+                continue;
+            }
+            int bit_offset = (location / block_size) % bitmap_word_size;
+            int bitmap_index = (location / block_size) / bitmap_word_size;
+            size_t chunk_size = (bitmap_word_size - bit_offset) * block_size;
+            if(bit_offset == 0 && (region_end - location) >= chunk_size)
+            {
+                // Set all bits in the word
+                page_map.bitmap[bitmap_index] = ~0;
+            }
+            else if(bit_offset == 0)
+            {
+                // Set the first 'count' bits
+                int count = (region_end - location) >> block_log;
+                page_map.bitmap[bitmap_index] |= (1 << count) - 1;
+            }
+            else if((region_end - location) >= chunk_size)
+            {
+                // Set all bits starting at 'bit_offset'
+                page_map.bitmap[bitmap_index] |= ~((1 << bit_offset) - 1);
+            }
+            else
+            {
+                // Set all bits starting at 'bit_offset' up to 'count'
+                int count = (region_end - location) >> block_log;
+                page_map.bitmap[bitmap_index] |= ((1 << count) - 1) & ~((1 << bit_offset) - 1);
+            }
+            location += chunk_size;
+        }
+    }
+    return ENONE;
 }
 
 physaddr_t create_address_space()

src/x86/context.c

@@ -4,54 +4,17 @@
 #include "heap.h"
 #include "string.h"
 #include "system.h"
-#include "x86/processstate.h"
-
-void *initialize_context(void *task_entry)
-{
-    physaddr_t stack_frame = reserve_page();
-    if(stack_frame % page_size != 0)
-    {
-        return NULL;
-    }
-    map_page((void*)&_kernel_start - page_size, stack_frame, PAGE_RW | PAGE_USERMODE);
-    unmap_page((void*)&_kernel_start - (2 * page_size));
-    struct process_context_t *context = kmalloc(sizeof(struct process_context_t));
-    if(context != NULL)
-    {
-       memset(context, 0, sizeof(struct process_context_t));
-       uint32_t flags;
-       asm("pushf; "
-           "mov (%%esp), %0; "
-           "popf; "
-           : "=r"(flags));
-       context->cs = 0x1B;
-       context->eip = (uint32_t)task_entry;
-       context->flags = (flags & ~0xFD) | 0x200;
-       context->ss = 0x23;
-       context->esp = &_kernel_start;
-       context->ebp = &_kernel_start;
-    }
-    return (void*)context;
-}
-
-void destroy_context(void *ctx)
-{
-    kfree(ctx);
-}
-
-void save_context(struct process_context_t *context)
-{
-    kernel_store_active_context(context, sizeof(*context));
-}
 
 void set_context_pc(struct process_context_t *context, void *pc)
 {
     context->eip = pc;
+    context->cs = 0x1B;
 }
 
 void set_context_stack(struct process_context_t *context, void *stack)
 {
-    context->esp = stack;
+    context->gp_registers[7] = stack;
+    context->ss = 0x23;
 }
 
 void set_context_flags(struct process_context_t *context, unsigned long flags)
@@ -61,5 +24,5 @@ void set_context_flags(struct process_context_t *context, unsigned long flags)
 
 void set_context_return(struct process_context_t *context, unsigned long value)
 {
-    context->eax = value;
+    context->gp_registers[0] = value;
 }

src/x86/load_context.S

@@ -7,8 +7,8 @@
 .type load_context, @function
 load_context:
     mov 4(%esp), %eax
-    push 0x1C(%eax)
     push 0x20(%eax)
+    push 0x1C(%eax)
     push 0x2C(%eax)
     push 0x24(%eax)
     push 0x28(%eax)
@@ -19,10 +19,11 @@ load_context:
     mov 0x10(%eax), %edi
     mov 0x14(%eax), %esi
     mov 0x18(%eax), %ebp
-    mov 0x1C(%eax), %ax
+    mov 0x20(%eax), %ax
     mov %ax, %ds
     mov %ax, %es
     mov %ax, %fs
     mov %ax, %gs
     pop %eax
     iret
+.size load_context, . - load_context

src/x86/multiboot2.c

@@ -68,6 +68,14 @@ struct multiboot2_memory_map_t
     struct multiboot2_map_entry_t entries;
 };
 
+struct multiboot2_memory_info_t
+{
+    uint32_t type;
+    uint32_t size;
+    uint32_t low_memory;
+    uint32_t high_memory;
+};
+
 void *read_multiboot_table_entry(struct boot_info_t *boot_info, void *table)
 {
     uint32_t *int_table = (uint32_t *)table;
@@ -75,6 +83,9 @@ void *read_multiboot_table_entry(struct boot_info_t *boot_info, void *table)
     {
     case MB_END_TAG:
         return NULL;
+    case MB_MEMORY_INFO:
+        boot_info->memory_size = ((struct multiboot2_memory_info_t*) table)->high_memory * 1024;
+        break;
     case MB_MEMORY_MAP: ;
         unsigned int tag_size = ((struct multiboot2_memory_map_t*) table)->size - 16;
         unsigned int entry_size = ((struct multiboot2_memory_map_t*) table)->entry_size;

src/x86/preempt.S

@@ -58,14 +58,14 @@ isr_preempt:
     mov 4(%ebp), %eax
     push %eax
 
-    // Load ESP, then push it onto stack
-    mov 12(%ebp), %eax
-    push %eax
-
     // Load SS, then push it onto stack
     mov 16(%ebp), %eax
     push %eax
 
+    // Load ESP, then push it onto stack
+    mov 12(%ebp), %eax
+    push %eax
+
     // Load EBP, then push it onto stack
     mov -4(%ebp), %eax
     push %eax
@@ -84,7 +84,7 @@ isr_preempt:
     // Push pointer to the process context saved on the stack
     push %esp
 
-    call save_context
+    call kernel_store_active_context
     mov %ebp, %esp
 
     call kernel_advance_scheduler