nathan/quark-kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrote physical memory allocator

Browse Source 
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.
This commit is contained in:
ngiddings
2022-08-23 13:00:26 -05:00
parent 54e2beefc1
commit bacedbea86
10 changed files with 314 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/kernel.c
View File

@@ -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);
kminit(&_kernel_start, page_stack_top(), 0xFFC00000 - (size_t)&_kernel_start, 64);
initialize_page_map(&boot_info->map, (physaddr_t*)&_kernel_end, boot_info->memory_size, page_size);
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)

251
src/mmgr.c
View File

@@ -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;
page_stack.stack_pointer = stack_base;
page_stack.total_pages = 0;
for(int i = 0; i < map->size; i++)
/**
* @brief The underlying bitmap representing the availability of chunks of
* physical memory.
*
*/
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;
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);
}
return index;
}
int find_free_region(int height)
{
if(height > page_map.height || height < 0)
{
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++)
{
continue;
}
size_t location = (map->array[i].location + page_size - 1) & ~(page_size - 1);
while(location + page_size <= map->array[i].location + map->array[i].size)
{
if(free_page(location) != ENONE)
if(page_map.bitmap[index] != 0)
{
return ENOMEM;
return bitmap_word_size * index + __builtin_ctz(page_map.bitmap[index]);
}
page_stack.total_pages++;
location += page_size;
}
}
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;
}
}
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)
{
page_stack.stack_pointer--;
physaddr_t frame = *page_stack.stack_pointer;
*page_stack.stack_pointer = (physaddr_t) 0;
return frame;
}
return ENOMEM;
return reserve_region(page_size);
}
int free_page(physaddr_t location)
{
if(page_stack.stack_pointer < page_stack.limit_pointer)
{
*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;
}
return free_region(location, page_size);
}
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()

45
src/x86/context.c
View File

@@ -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;
}

7
src/x86/load_context.S
View File

@@ -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
iret
.size load_context, . - load_context

11
src/x86/multiboot2.c
View File

@@ -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;

10
src/x86/preempt.S
View File

@@ -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