mango/sched/task.c

#include <socks/locks.h>
#include <socks/printk.h>
#include <socks/clock.h>
#include <socks/sched.h>
#include <socks/object.h>
#include <socks/cpu.h>
#include <socks/libc/stdio.h>

static struct object_type task_type = {
	.ob_name = "task",
	.ob_size = sizeof(struct task),
};

static struct task *__kernel_task;
static struct task *__idle_task;

static spin_lock_t task_list_lock;
static struct btree task_list;

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)

struct task *kernel_task(void)
{
	return __kernel_task;
}

struct task *idle_task(void)
{
	return __idle_task;
}

static void __idle_function(void)
{
	while (1) {
		clock_wait(HZ);
		printk("idle");
		ml_cpu_pause();
	}
}

kern_status_t setup_kernel_task(void)
{
	__kernel_task = task_alloc();
	if (!__kernel_task) {
		return KERN_NO_MEMORY;
	}

	__kernel_task->t_id = 0;
	__kernel_task->t_pmap = get_kernel_pmap();
	__kernel_task->t_state = TASK_RUNNING;

	snprintf(__kernel_task->t_name, sizeof __kernel_task->t_name, "kernel_task");

	struct thread *kernel_thread = thread_alloc();
	kernel_thread->tr_id = 0;
	kernel_thread->tr_prio = PRIO_NORMAL;
	kernel_thread->tr_state = THREAD_READY;
	kernel_thread->tr_parent = __kernel_task;
	kernel_thread->tr_quantum_target = default_quantum();

	unsigned long flags;
	task_lock_irqsave(__kernel_task, &flags);
	queue_push_back(&__kernel_task->t_threads, &kernel_thread->tr_threads);
	task_unlock_irqrestore(__kernel_task, flags);

	spin_lock_irqsave(&task_list_lock, &flags);
	task_list_insert(&task_list, __kernel_task);
	spin_unlock_irqrestore(&task_list_lock, flags);

	return KERN_OK;
}

kern_status_t setup_idle_task(void)
{
	/*
	__kernel_task = task_alloc();
	if (!__kernel_task) {
		return KERN_NO_MEMORY;
	}

	__kernel_task->t_id = 0;
	__kernel_task->t_pmap = get_kernel_pmap();
	__kernel_task->t_state = TASK_RUNNING;

	snprintf(__kernel_task->t_name, sizeof __kernel_task->t_name, "kernel_task");

	struct thread *kernel_thread = thread_alloc();
	kernel_thread->tr_id = 0;
	kernel_thread->tr_prio = PRIO_NORMAL;
	kernel_thread->tr_state = THREAD_READY;
	kernel_thread->tr_parent = __kernel_task;
	kernel_thread->tr_quantum_target = default_quantum();

	unsigned long flags;
	task_lock_irqsave(__kernel_task, &flags);
	queue_push_back(&__kernel_task->t_threads, &kernel_thread->tr_threads);
	task_unlock_irqrestore(__kernel_task, flags);

	spin_lock_irqsave(&task_list_lock, &flags);
	task_list_insert(&task_list, __kernel_task);
	spin_unlock_irqrestore(&task_list_lock, flags);
	*/

	__idle_task = task_alloc();
	if (!__idle_task) {
		return KERN_NO_MEMORY;
	}

	unsigned long flags;
	task_lock_irqsave(__idle_task, &flags);

	__idle_task->t_id = (unsigned int)-1;
	__idle_task->t_pmap = get_kernel_pmap();
	__idle_task->t_state = TASK_RUNNING;

	snprintf(__idle_task->t_name, sizeof __idle_task->t_name, "idle");

	struct thread *idle_thread = thread_alloc();
	if (!idle_thread) {
		task_deref(__idle_task);
		__idle_task = NULL;
		return KERN_NO_MEMORY;
	}

	idle_thread->tr_id = 0;
	idle_thread->tr_parent = __idle_task;
	thread_init(idle_thread, (uintptr_t)__idle_function);

	queue_push_back(&__idle_task->t_threads, &idle_thread->tr_threads);

	task_unlock_irqrestore(__idle_task, flags);

	return KERN_OK;
}

kern_status_t task_object_type_init(void)
{
	return object_type_register(&task_type);
}

struct task *task_alloc(void)
{
	struct object *task_obj = object_create(&task_type);
	if (!task_obj) {
		return NULL;
	}

	struct task *t = object_data(task_obj);
	memset(t, 0x00, sizeof *t);
	return t;
}

struct task *task_from_pid(unsigned int pid)
{
	unsigned long flags;
	spin_lock_irqsave(&task_list_lock, &flags);
	struct task *t = task_list_get(&task_list, pid);
	spin_unlock_irqrestore(&task_list_lock, flags);
	return t;
}

struct task *current_task(void)
{
	struct thread *thr = current_thread();
	return thr ? thr->tr_parent : NULL;
}