aboutsummaryrefslogtreecommitdiff
path: root/kernel/l0
diff options
context:
space:
mode:
Diffstat (limited to 'kernel/l0')
-rw-r--r--kernel/l0/kmain.c12
-rw-r--r--kernel/l0/paging.c12
-rw-r--r--kernel/l0/thread.c (renamed from kernel/l0/task.c)100
3 files changed, 62 insertions, 62 deletions
diff --git a/kernel/l0/kmain.c b/kernel/l0/kmain.c
index 2ce3749..416b802 100644
--- a/kernel/l0/kmain.c
+++ b/kernel/l0/kmain.c
@@ -10,7 +10,7 @@
#include <region.h>
#include <kmalloc.h>
-#include <task.h>
+#include <thread.h>
#include <slab_alloc.h>
@@ -100,7 +100,7 @@ void kmalloc_test(void* kernel_data_end) {
dbg_print_region_info();
}
-void test_task(void* a) {
+void test_thread(void* a) {
int i = 0;
while(1) {
dbg_printf("b");
@@ -112,8 +112,8 @@ void test_task(void* a) {
}
}
void kernel_init_stage2(void* data) {
- task_t *tb = new_task(test_task);
- resume_task_with_result(tb, 0, false);
+ thread_t *tb = new_thread(test_thread);
+ resume_thread_with_result(tb, 0, false);
dbg_print_region_info();
dbg_print_frame_stats();
@@ -163,10 +163,10 @@ void kmain(struct multiboot_info_t *mbd, int32_t mb_magic) {
kmalloc_setup();
kmalloc_test(kernel_data_end);
- // enter multi-tasking mode
+ // enter multi-threading mode
// interrupts are enabled at this moment, so all
// code run from now on should be preemtible (ie thread-safe)
- tasking_setup(kernel_init_stage2, 0);
+ threading_setup(kernel_init_stage2, 0);
PANIC("Should never come here.");
}
diff --git a/kernel/l0/paging.c b/kernel/l0/paging.c
index b8fd454..683abe6 100644
--- a/kernel/l0/paging.c
+++ b/kernel/l0/paging.c
@@ -4,7 +4,7 @@
#include <dbglog.h>
#include <region.h>
#include <mutex.h>
-#include <task.h>
+#include <thread.h>
#include <kmalloc.h>
#define PAGE_OF_ADDR(x) (((size_t)x >> PAGE_SHIFT) % N_PAGES_IN_PT)
@@ -143,8 +143,8 @@ void paging_setup(void* kernel_data_end) {
}
pagedir_t *get_current_pagedir() {
- if (current_task == 0) return &kernel_pd_d;
- return current_task->current_pd_d;
+ if (current_thread == 0) return &kernel_pd_d;
+ return current_thread->current_pd_d;
}
pagedir_t *get_kernel_pagedir() {
@@ -153,7 +153,7 @@ pagedir_t *get_kernel_pagedir() {
void switch_pagedir(pagedir_t *pd) {
asm volatile("movl %0, %%cr3":: "r"(pd->phys_addr));
- if (current_task != 0) current_task->current_pd_d = pd;
+ if (current_thread != 0) current_thread->current_pd_d = pd;
}
// ============================== //
@@ -177,8 +177,8 @@ int pd_map_page(void* vaddr, uint32_t frame_id, bool rw) {
ASSERT((size_t)vaddr < PD_MIRROR_ADDR);
- pagedir_t *pdd = ((size_t)vaddr >= K_HIGHHALF_ADDR || current_task == 0
- ? &kernel_pd_d : current_task->current_pd_d);
+ pagedir_t *pdd = ((size_t)vaddr >= K_HIGHHALF_ADDR || current_thread == 0
+ ? &kernel_pd_d : current_thread->current_pd_d);
pagetable_t *pd = ((size_t)vaddr >= K_HIGHHALF_ADDR ? &kernel_pd : current_pd);
mutex_lock(&pdd->mutex);
diff --git a/kernel/l0/task.c b/kernel/l0/thread.c
index cf22f9d..b14ad9b 100644
--- a/kernel/l0/task.c
+++ b/kernel/l0/thread.c
@@ -1,4 +1,4 @@
-#include <task.h>
+#include <thread.h>
#include <kmalloc.h>
#include <dbglog.h>
#include <idt.h>
@@ -10,7 +10,7 @@ void save_context_and_enter_scheduler(saved_context_t *ctx);
void irq0_save_context_and_enter_scheduler(saved_context_t *ctx);
void resume_context(saved_context_t *ctx);
-task_t *current_task = 0;
+thread_t *current_thread = 0;
// ====================== //
// THE PROGRAMMABLE TIMER //
@@ -47,29 +47,29 @@ static inline void resume_interrupts(bool st) {
// THE TASK SCHEDULER //
// ================== //
-static task_t *queue_first_task = 0, *queue_last_task = 0;
+static thread_t *queue_first_thread = 0, *queue_last_thread = 0;
-void enqueue_task(task_t *t, bool just_ran) {
+void enqueue_thread(thread_t *t, bool just_ran) {
ASSERT(t->state == T_STATE_RUNNING);
- if (queue_first_task == 0) {
- queue_first_task = queue_last_task = t;
+ if (queue_first_thread == 0) {
+ queue_first_thread = queue_last_thread = t;
t->next_in_queue = 0;
} else if (just_ran) {
t->next_in_queue = 0;
- queue_last_task->next_in_queue = t;
- queue_last_task = t;
+ queue_last_thread->next_in_queue = t;
+ queue_last_thread = t;
} else {
- t->next_in_queue = queue_first_task;
- queue_first_task = t;
+ t->next_in_queue = queue_first_thread;
+ queue_first_thread = t;
}
}
-task_t* dequeue_task() {
- task_t *t = queue_first_task;
+thread_t* dequeue_thread() {
+ thread_t *t = queue_first_thread;
if (t == 0) return 0;
- queue_first_task = t->next_in_queue;
- if (queue_first_task == 0) queue_last_task = 0;
+ queue_first_thread = t->next_in_queue;
+ if (queue_first_thread == 0) queue_last_thread = 0;
return t;
}
@@ -82,13 +82,13 @@ void run_scheduler() {
// At this point, interrupts are disabled
// This function is expected NEVER TO RETURN
- if (current_task != 0 && current_task->state == T_STATE_RUNNING) {
- enqueue_task(current_task, true);
+ if (current_thread != 0 && current_thread->state == T_STATE_RUNNING) {
+ enqueue_thread(current_thread, true);
}
- current_task = dequeue_task();
- if (current_task != 0) {
- resume_context(&current_task->ctx);
+ current_thread = dequeue_thread();
+ if (current_thread != 0) {
+ resume_context(&current_thread->ctx);
} else {
// Wait for an IRQ
asm volatile("sti; hlt");
@@ -99,24 +99,24 @@ void run_scheduler() {
}
}
-static void run_task(void (*entry)(void*)) {
- ASSERT(current_task->state == T_STATE_RUNNING);
- ASSERT(current_task->has_result);
+static void run_thread(void (*entry)(void*)) {
+ ASSERT(current_thread->state == T_STATE_RUNNING);
+ ASSERT(current_thread->has_result);
switch_pagedir(get_kernel_pagedir());
- current_task->has_result = false;
+ current_thread->has_result = false;
asm volatile("sti");
- entry(current_task->result);
+ entry(current_thread->result);
- current_task->state = T_STATE_FINISHED;
- // TODO : add job for deleting the task, or whatever
+ current_thread->state = T_STATE_FINISHED;
+ // TODO : add job for deleting the thread, or whatever
yield(); // expected never to return!
ASSERT(false);
}
-task_t *new_task(entry_t entry) {
- task_t *t = (task_t*)kmalloc(sizeof(task_t));
+thread_t *new_thread(entry_t entry) {
+ thread_t *t = (thread_t*)kmalloc(sizeof(thread_t));
if (t == 0) return 0;
void* stack = region_alloc(KPROC_STACK_SIZE, REGION_T_KPROC_STACK, 0);
@@ -139,9 +139,9 @@ task_t *new_task(entry_t entry) {
t->ctx.esp = (uint32_t*)(t->stack_region->addr + t->stack_region->size);
*(--t->ctx.esp) = (uint32_t)entry; // push first argument : entry point
- *(--t->ctx.esp) = 0; // push invalid return address (the run_task function never returns)
+ *(--t->ctx.esp) = 0; // push invalid return address (the run_thread function never returns)
- t->ctx.eip = (void(*)())run_task;
+ t->ctx.eip = (void(*)())run_thread;
t->state = T_STATE_WAITING;
t->result = 0;
t->has_result = false;
@@ -158,17 +158,17 @@ task_t *new_task(entry_t entry) {
// ========== //
static void irq0_handler(registers_t *regs) {
- if (current_task != 0)
- irq0_save_context_and_enter_scheduler(&current_task->ctx);
+ if (current_thread != 0)
+ irq0_save_context_and_enter_scheduler(&current_thread->ctx);
}
-void tasking_setup(entry_t cont, void* arg) {
+void threading_setup(entry_t cont, void* arg) {
set_pit_frequency(TASK_SWITCH_FREQUENCY);
idt_set_irq_handler(IRQ0, irq0_handler);
- task_t *t = new_task(cont);
+ thread_t *t = new_thread(cont);
ASSERT(t != 0);
- resume_task_with_result(t, arg, false);
+ resume_thread_with_result(t, arg, false);
run_scheduler(); // never returns
ASSERT(false);
@@ -179,40 +179,40 @@ void tasking_setup(entry_t cont, void* arg) {
// ======================= //
void yield() {
- if (current_task == 0) {
- // might happen before tasking is initialized
+ if (current_thread == 0) {
+ // might happen before threading is initialized
// (but should not...)
dbg_printf("Warning: probable deadlock.");
} else {
- save_context_and_enter_scheduler(&current_task->ctx);
+ save_context_and_enter_scheduler(&current_thread->ctx);
}
}
void* wait_for_result() {
bool st = disable_interrupts();
- if (!current_task->has_result) {
- current_task->state = T_STATE_WAITING;
- save_context_and_enter_scheduler(&current_task->ctx);
+ if (!current_thread->has_result) {
+ current_thread->state = T_STATE_WAITING;
+ save_context_and_enter_scheduler(&current_thread->ctx);
}
- ASSERT(current_task->has_result);
- current_task->has_result = false;
+ ASSERT(current_thread->has_result);
+ current_thread->has_result = false;
- void *result = current_task->result;
+ void *result = current_thread->result;
resume_interrupts(st);
return result;
}
-void resume_task_with_result(task_t *task, void* data, bool run_at_once) {
+void resume_thread_with_result(thread_t *thread, void* data, bool run_at_once) {
bool st = disable_interrupts();
- task->has_result = true;
- task->result = data;
+ thread->has_result = true;
+ thread->result = data;
- if (task->state == T_STATE_WAITING) {
- task->state = T_STATE_RUNNING;
- enqueue_task(task, false);
+ if (thread->state == T_STATE_WAITING) {
+ thread->state = T_STATE_RUNNING;
+ enqueue_thread(thread, false);
}
if (run_at_once) yield();
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 23:27:40 +0000