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

process struct now uses address_space struct

Browse Source
This commit is contained in:
Nathan Giddings
2023-11-09 23:00:12 -06:00
parent 1375596310
commit df90bd7313
7 changed files with 32 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/addressspace.h
View File

@@ -3,13 +3,13 @@
#include "types/physaddr.h" #include "types/physaddr.h"
typedef struct addressspace_t typedef struct address_space_t
{ {
physaddr_t page_table; physaddr_t page_table;
int refcount; int refcount;
} addressspace_t; } address_space_t;
addressspace_t *addressspace_construct(); address_space_t *address_space_construct();

3
include/kernel.h
View File

@@ -5,6 +5,7 @@
#include "queue.h" #include "queue.h"
#include "mmgr.h" #include "mmgr.h"
#include "syscalls.h" #include "syscalls.h"
#include "addressspace.h"
#include "types/syscallid.h" #include "types/syscallid.h"
#include "types/status.h" #include "types/status.h"
#include "types/pid.h" #include "types/pid.h"
@@ -65,7 +66,7 @@ struct process_context_t *kernel_current_context();
error_t kernel_store_active_context(struct process_context_t *context); error_t kernel_store_active_context(struct process_context_t *context);
pid_t kernel_spawn_process(void *program_entry, int priority, physaddr_t address_space); pid_t kernel_spawn_process(void *program_entry, int priority, address_space_t *address_space);
struct process_context_t *kernel_advance_scheduler(); struct process_context_t *kernel_advance_scheduler();

7
include/process.h
View File

@@ -5,6 +5,7 @@
#include "types/physaddr.h" #include "types/physaddr.h"
#include "types/status.h" #include "types/status.h"
#include "queue.h" #include "queue.h"
#include "addressspace.h"
typedef enum process_state_t typedef enum process_state_t
{ {
@@ -17,7 +18,7 @@ typedef struct process_t
{ {
pid_t pid; pid_t pid;
int priority; int priority;
physaddr_t page_table; address_space_t *address_space;
struct avltree_t *shared_objects; struct avltree_t *shared_objects;
process_state_t state; process_state_t state;
struct queue_t sending_queue; struct queue_t sending_queue;
@@ -26,8 +27,6 @@ typedef struct process_t
struct process_context_t *ctx; struct process_context_t *ctx;
} process_t; } process_t;
process_t *process_construct(pid_t pid, void *entry, void *stack, int priority, physaddr_t address_space); process_t *process_construct(pid_t pid, void *entry, void *stack, int priority, address_space_t *address_space);
error_t process_call_func(process_t *process, void *func, void *ret, int argc, ...);
#endif #endif

2
src/Makefile.am
View File

@@ -1,5 +1,5 @@
bin_PROGRAMS = quark-kernel bin_PROGRAMS = quark-kernel
quark_kernel_SOURCES = kernel.c mmgr.c priorityqueue.c stdio.c string.c elf.c syscalls.c heap.c avltree.c queue.c math.c process.c sharedobject.c quark_kernel_SOURCES = kernel.c mmgr.c priorityqueue.c stdio.c string.c elf.c syscalls.c heap.c avltree.c queue.c math.c process.c sharedobject.c addressspace.c
quark_kernel_LDADD = -lgcc -lmalloc quark_kernel_LDADD = -lgcc -lmalloc
quark_kernel_CFLAGS = -I$(top_srcdir)/include -I$(prefix)/include -ffreestanding -mgeneral-regs-only -O0 -Wall -ggdb quark_kernel_CFLAGS = -I$(top_srcdir)/include -I$(prefix)/include -ffreestanding -mgeneral-regs-only -O0 -Wall -ggdb
quark_kernel_LDFLAGS = -L$(prefix)/lib -nostdlib quark_kernel_LDFLAGS = -L$(prefix)/lib -nostdlib

4
src/addressspace.c
View File

@@ -2,9 +2,9 @@
#include "heap.h" #include "heap.h"
#include "mmgr.h" #include "mmgr.h"
addressspace_t *addressspace_construct() address_space_t *address_space_construct()
{ {
addressspace_t *as = kmalloc(sizeof(addressspace_t)); address_space_t *as = kmalloc(sizeof(address_space_t));
if(as == NULL) if(as == NULL)
{ {
return NULL; return NULL;

22
src/kernel.c
View File

@@ -212,11 +212,11 @@ size_t kernel_do_syscall(syscall_id_t id, syscall_arg_t arg1, syscall_arg_t arg2
error_t kernel_load_module(struct module_t *module) error_t kernel_load_module(struct module_t *module)
{ {
physaddr_t module_address_space = create_address_space(); address_space_t *module_address_space = address_space_construct();
if(module_address_space == ENOMEM) { if(module_address_space == NULL) {
kernel_panic("failed to create address space for module: out of memory"); kernel_panic("failed to create address space for module: out of memory");
} }
paging_load_address_space(module_address_space); paging_load_address_space(module_address_space->page_table);
void *const load_base = (void*)0x80000000; void *const load_base = (void*)0x80000000;
physaddr_t p = module->start & ~(page_size - 1); physaddr_t p = module->start & ~(page_size - 1);
map_region(load_base, p, module->end - p, PAGE_RW); map_region(load_base, p, module->end - p, PAGE_RW);
@@ -243,7 +243,7 @@ error_t kernel_load_module(struct module_t *module)
} }
load_offset += page_size; load_offset += page_size;
} }
if(kernel_spawn_process(module_entry, 1, current_address_space()) > 0) if(kernel_spawn_process(module_entry, 1, module_address_space) > 0)
{ {
return ENONE; return ENONE;
} }
@@ -277,7 +277,7 @@ struct process_context_t *kernel_current_context()
} }
} }
pid_t kernel_spawn_process(void *program_entry, int priority, physaddr_t address_space) pid_t kernel_spawn_process(void *program_entry, int priority, address_space_t *address_space)
{ {
physaddr_t stack_page = reserve_page(); physaddr_t stack_page = reserve_page();
if(stack_page % page_size) if(stack_page % page_size)
@@ -308,8 +308,8 @@ struct process_context_t *kernel_advance_scheduler()
kernel.active_process = priorityqueue_extract_min(&kernel.priority_queue); kernel.active_process = priorityqueue_extract_min(&kernel.priority_queue);
if(kernel.active_process != NULL) if(kernel.active_process != NULL)
{ {
paging_load_address_space(kernel.active_process->page_table); paging_load_address_space(kernel.active_process->address_space->page_table);
printf("entering process %08x cr3=%08x ctx=%08x sched=%i.\n", kernel.active_process->pid, kernel.active_process->page_table, kernel.active_process->ctx, kernel.priority_queue.size); printf("entering process %08x cr3=%08x ctx=%08x sched=%i.\n", kernel.active_process->pid, kernel.active_process->address_space->page_table, kernel.active_process->ctx, kernel.priority_queue.size);
return kernel.active_process->ctx; return kernel.active_process->ctx;
} }
kernel_panic("no processes available to enter!"); kernel_panic("no processes available to enter!");
@@ -413,9 +413,9 @@ error_t kernel_send_message(unsigned long recipient, struct message_t *message)
struct message_t kernel_buffer; struct message_t kernel_buffer;
memcpy(&kernel_buffer, message, sizeof(struct message_t)); memcpy(&kernel_buffer, message, sizeof(struct message_t));
kernel_buffer.sender = kernel.active_process->pid; kernel_buffer.sender = kernel.active_process->pid;
paging_load_address_space(dest->page_table); paging_load_address_space(dest->address_space->page_table);
memcpy(dest->message_buffer, &kernel_buffer, sizeof(struct message_t)); memcpy(dest->message_buffer, &kernel_buffer, sizeof(struct message_t));
paging_load_address_space(kernel.active_process->page_table); paging_load_address_space(kernel.active_process->address_space->page_table);
dest->message_buffer = NULL; dest->message_buffer = NULL;
dest->state = PROCESS_ACTIVE; dest->state = PROCESS_ACTIVE;
set_context_return(dest->ctx, ENONE); set_context_return(dest->ctx, ENONE);
@@ -512,7 +512,7 @@ error_t kernel_execute_interrupt_handler(unsigned long interrupt)
return EDOESNTEXIST; return EDOESNTEXIST;
} }
paging_load_address_space(process->page_table); paging_load_address_space(process->address_space->page_table);
struct signal_context_t siginfo = { struct signal_context_t siginfo = {
.signal_id = interrupt .signal_id = interrupt
@@ -527,7 +527,7 @@ error_t kernel_execute_interrupt_handler(unsigned long interrupt)
priorityqueue_insert(&kernel.priority_queue, process, process->priority); priorityqueue_insert(&kernel.priority_queue, process, process->priority);
} }
paging_load_address_space(kernel.active_process->page_table); paging_load_address_space(kernel.active_process->address_space->page_table);
return ENONE; return ENONE;
} }

13
src/process.c
View File

@@ -3,7 +3,7 @@
#include "platform/context.h" #include "platform/context.h"
#include "string.h" #include "string.h"
process_t *process_construct(pid_t pid, void *entry, void *stack, int priority, physaddr_t address_space) process_t *process_construct(pid_t pid, void *entry, void *stack, int priority, address_space_t *address_space)
{ {
process_t *new_process = (process_t*) kmalloc(sizeof(process_t)); process_t *new_process = (process_t*) kmalloc(sizeof(process_t));
if(new_process == NULL) if(new_process == NULL)
@@ -14,7 +14,13 @@ process_t *process_construct(pid_t pid, void *entry, void *stack, int priority,
struct process_context_t *initial_context = kmalloc(sizeof(struct process_context_t)); struct process_context_t *initial_context = kmalloc(sizeof(struct process_context_t));
if(initial_context == NULL) if(initial_context == NULL)
{ {
return 0; return NULL;
}
if(address_space == NULL
&& (address_space = address_space_construct()) == NULL)
{
return NULL;
} }
context_construct(initial_context); context_construct(initial_context);
@@ -22,7 +28,8 @@ process_t *process_construct(pid_t pid, void *entry, void *stack, int priority,
set_context_stack(initial_context, stack); set_context_stack(initial_context, stack);
new_process->priority = priority; new_process->priority = priority;
new_process->pid = pid; new_process->pid = pid;
new_process->page_table = address_space; new_process->address_space = address_space;
new_process->address_space->refcount++;
new_process->state = PROCESS_ACTIVE; new_process->state = PROCESS_ACTIVE;
new_process->message_buffer = NULL; new_process->message_buffer = NULL;
new_process->ctx = initial_context; new_process->ctx = initial_context;