wash/mango
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

kernel: don't use typedef for enums or non-opaque structs

Browse Source
This commit is contained in:
max 🍓
2023-04-12 20:17:11 +01:00
parent 0d75e347e9
commit b6f8c1ccaa
51 changed files with 663 additions and 665 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
sched/core.c
View File

@@ -26,9 +26,9 @@ kern_status_t sched_init(void)
return status;
}
thread_t *this_thread = QUEUE_CONTAINER(thread_t, tr_threads, queue_first(&kernel_task()->t_threads));
struct thread *this_thread = QUEUE_CONTAINER(struct thread, tr_threads, queue_first(&kernel_task()->t_threads));
cpu_data_t *this_cpu = get_this_cpu();
struct cpu_data *this_cpu = get_this_cpu();
runqueue_init(&this_cpu->c_rq);
this_cpu->c_current_thread = this_thread;
put_cpu(this_cpu);

2
sched/runqueue.c
View File

@@ -1,7 +1,7 @@
#include <socks/sched.h>
#include <socks/percpu.h>
void runqueue_init(runqueue_t *rq)
void runqueue_init(struct runqueue *rq)
{
memset(rq, 0x00, sizeof *rq);
rq->rq_lock = SPIN_LOCK_INIT;

30
sched/task.c
View File

@@ -4,20 +4,20 @@
#include <socks/cpu.h>
#include <socks/libc/stdio.h>
static object_type_t task_type = {
static struct object_type task_type = {
.ob_name = "task",
.ob_size = sizeof(task_t),
.ob_size = sizeof(struct task),
};
static task_t *__kernel_task;
static struct task *__kernel_task;
static spin_lock_t task_list_lock;
static btree_t task_list;
static struct btree task_list;
BTREE_DEFINE_SIMPLE_GET(task_t, unsigned int, t_tasklist, t_id, task_list_get)
BTREE_DEFINE_SIMPLE_INSERT(task_t, t_tasklist, t_id, task_list_insert)
BTREE_DEFINE_SIMPLE_GET(struct task, unsigned int, t_tasklist, t_id, task_list_get)
BTREE_DEFINE_SIMPLE_INSERT(struct task, t_tasklist, t_id, task_list_insert)
task_t *kernel_task(void)
struct task *kernel_task(void)
{
return __kernel_task;
}
@@ -35,7 +35,7 @@ kern_status_t setup_kernel_task(void)
snprintf(__kernel_task->t_name, sizeof __kernel_task->t_name, "kernel_task");
thread_t *kernel_thread = thread_alloc();
struct thread *kernel_thread = thread_alloc();
kernel_thread->tr_id = 0;
kernel_thread->tr_prio = PRIO_NORMAL;
kernel_thread->tr_state = THREAD_READY;
@@ -58,29 +58,29 @@ kern_status_t task_object_type_init(void)
return object_type_register(&task_type);
}
task_t *task_alloc(void)
struct task *task_alloc(void)
{
object_t *task_obj = object_create(&task_type);
struct object *task_obj = object_create(&task_type);
if (!task_obj) {
return NULL;
}
task_t *t = object_data(task_obj);
struct task *t = object_data(task_obj);
memset(t, 0x00, sizeof *t);
return t;
}
task_t *task_from_pid(unsigned int pid)
struct task *task_from_pid(unsigned int pid)
{
unsigned long flags;
spin_lock_irqsave(&task_list_lock, &flags);
task_t *t = task_list_get(&task_list, pid);
struct task *t = task_list_get(&task_list, pid);
spin_unlock_irqrestore(&task_list_lock, flags);
return t;
}
task_t *current_task(void)
struct task *current_task(void)
{
thread_t *thr = current_thread();
struct thread *thr = current_thread();
return thr ? thr->tr_parent : NULL;
}

18
sched/thread.c
View File

@@ -2,9 +2,9 @@
#include <socks/object.h>
#include <socks/cpu.h>
static object_type_t thread_type = {
static struct object_type thread_type = {
.ob_name = "thread",
.ob_size = sizeof(thread_t),
.ob_size = sizeof(struct thread),
};
kern_status_t thread_object_type_init(void)
@@ -12,31 +12,31 @@ kern_status_t thread_object_type_init(void)
return object_type_register(&thread_type);
}
thread_t *thread_alloc(void)
struct thread *thread_alloc(void)
{
object_t *thread_obj = object_create(&thread_type);
struct object *thread_obj = object_create(&thread_type);
if (!thread_obj) {
return NULL;
}
thread_t *t = object_data(thread_obj);
struct thread *t = object_data(thread_obj);
memset(t, 0x00, sizeof *t);
return t;
}
void thread_free(thread_t *thr)
void thread_free(struct thread *thr)
{
}
thread_t *current_thread(void)
struct thread *current_thread(void)
{
cpu_data_t *cpu = get_this_cpu();
struct cpu_data *cpu = get_this_cpu();
if (!cpu) {
return NULL;
}
thread_t *out = cpu->c_current_thread;
struct thread *out = cpu->c_current_thread;
put_cpu(cpu);
return out;
}