tasks.cpp File Reference

#include <Arch/Arch.hpp>
#include <Arch/Memory.hpp>
#include <Scheduler/tasks.hpp>
#include <Panic.hpp>
#include <Memory/heap.hpp>
#include <Library/stdio.hpp>
#include <Devices/Serial/rs232.hpp>
#include <stdint.h>
#include <x86gprintrin.h>
#include <Arch/i686/timer.hpp>
#include <Logger.hpp>

Include dependency graph for tasks.cpp:

Go to the source code of this file.

Macros
#define	NAMED_TASKLIST(name)
#define	TASK_ACTION(action, task)

Functions
void	_tasks_enqueue_ready (struct task *task)
void	tasks_update_time ()
void	_wakeup (struct task *task)
	NAMED_TASKLIST (sleeping)
	NAMED_TASKLIST (stopped)
void	tasks_init ()
struct task *	tasks_new (void(*entry)(void), struct task *storage, task_state state, const char *name)
void	tasks_schedule ()
uint64_t	tasks_get_self_time ()
void	tasks_block_current (task_state reason)
void	tasks_unblock (struct task *task)
void	tasks_nano_sleep_until (uint64_t time)
void	tasks_nano_sleep (uint64_t time)
void	tasks_exit ()
void	tasks_sync_block (struct task_sync *ts)
void	tasks_sync_unblock (struct task_sync *ts)

Variables
struct task *	current_task = NULL
struct tasklist	tasks_ready = { }

Detailed Description

Author

Micah Switzer (mswit.nosp@m.zer@.nosp@m.cedar.nosp@m.vill.nosp@m.e.edu)

Version

0.3

Date

2020-08-29

Copyright

Copyright the Xyris Contributors (c) 2020

Definition in file tasks.cpp.

Macro Definition Documentation

NAMED_TASKLIST

#define NAMED_TASKLIST

(

name

)

Value:

    struct tasklist tasks_##name = { /* Zero */ }; \
    static inline void _enqueue_##name(struct task *task) { \
        _enqueue_task(&tasks_##name, task); } \
    static inline struct task *_dequeue_##name() { \
        return _dequeue_task(&tasks_##name); }

Definition at line 33 of file tasks.cpp.

TASK_ACTION

#define TASK_ACTION	(		action,
			task
	)

Definition at line 124 of file tasks.cpp.

Function Documentation

_tasks_enqueue_ready()

void _tasks_enqueue_ready

(

struct task *

task

)

Definition at line 279 of file tasks.cpp.

{
    _enqueue_task(&tasks_ready, task);
}

Here is the caller graph for this function:

_wakeup()

void _wakeup

(

struct task *

task

)

Definition at line 440 of file tasks.cpp.

{
    task->state = TASK_READY;
    task->wakeup_time = (0ULL - 1);
    _tasks_enqueue_ready(task);
    TASK_ACTION(__func__, task);
}

Here is the call graph for this function:

NAMED_TASKLIST() [1/2]

NAMED_TASKLIST

(

sleeping

)

NAMED_TASKLIST() [2/2]

NAMED_TASKLIST

(

stopped

)

tasks_block_current()

void tasks_block_current

(

task_state

reason

)

Blocks the current task.

Parameters

reason

Definition at line 422 of file tasks.cpp.

{
    _aquire_scheduler_lock();
    current_task->state = reason;
    TASK_ACTION(__func__, current_task);
    _schedule();
    _release_scheduler_lock();
}

tasks_exit()

void tasks_exit

(

void

)

Exits the current task.

Definition at line 511 of file tasks.cpp.

{
    // userspace cleanup can happen here
    Logger::Debug(__func__, "task \"%s\" (0x%08lx) exiting", current_task->name, (uint32_t)current_task);
 
    _aquire_scheduler_lock();
    // all scheduling-specific operations must happen here
    _enqueue_stopped(current_task);
 
    // the ordering of these two should really be reversed
    // but the scheduler currently isn't very smart
    tasks_block_current(TASK_STOPPED);
 
    tasks_unblock(&_cleaner_task);
 
    _release_scheduler_lock();
}

Here is the call graph for this function:

tasks_get_self_time()

uint64_t tasks_get_self_time

(

)

Returns the lifetime of the current task (in nanoseconds).

Returns

uint64_t Task lifetime (in nanoseconds)

Definition at line 416 of file tasks.cpp.

{
    tasks_update_time();
    return current_task->time_used;
}

Here is the call graph for this function:

tasks_init()

void tasks_init

(

)

Initializes the kernel task manager.

Definition at line 151 of file tasks.cpp.

{
    // get a pointer to the first task's tcb
    struct task *this_task = &_first_task;
    // discover the CPU speed for accurate scheduling
    _discover_cpu_speed();
    *this_task = {
        // this will be filled in when we switch to another task for the first time
        .stack_top = 0,
        // this will be the same for kernel tasks
        .page_dir = Memory::getPageDirPhysAddr(),
        // this is a linked list with only this task
        .next = NULL,
        // this task is currently running
        .state = TASK_RUNNING,
        // just say that this task hasn't spent any time running yet
        .time_used = 0,
        // Set wakeup time to 0 to make compiler happy
        .wakeup_time = 0,
        // name
        .name = "[main]",
        // this is not backed by dynamic memory
        .alloc = ALLOC_STATIC,
    };
    TASK_ACTION(__func__, this_task);
    // create a task for the cleaner and set it's state to "paused"
    (void) tasks_new(_cleaner_task_impl, &_cleaner_task, TASK_PAUSED, "[cleaner]");
    _cleaner_task.state = TASK_PAUSED;
    // update the timer variables
    _last_time = _get_cpu_time_ns();
    _last_timer_time = _last_time;
    // enable time slices
    _time_slice_remaining = TIME_SLICE_SIZE;
    // this is the current task
    current_task = this_task;
    timer_register_callback(_on_timer);
}

tasks_nano_sleep()

void tasks_nano_sleep

(

uint64_t

time

)

Sleep for a given period of time (in nanoseconds).

Parameters

time	Nanoseconds to sleep

Definition at line 506 of file tasks.cpp.

{
    tasks_nano_sleep_until(_get_cpu_time_ns() + time);
}

Here is the call graph for this function:

Here is the caller graph for this function:

tasks_nano_sleep_until()

void tasks_nano_sleep_until

(

uint64_t

time

)

Sleeps until the provided absolute time (in nanoseconds).

Parameters

time	Absolute time to sleep until (in nanoseconds since boot)

Definition at line 494 of file tasks.cpp.

{
    // TODO: maybe validate that this time is in the future?
    _aquire_scheduler_lock();
    current_task->state = TASK_SLEEPING;
    current_task->wakeup_time = time;
    _enqueue_sleeping(current_task);
    TASK_ACTION(__func__, current_task);
    _schedule();
    _release_scheduler_lock();
}

Here is the caller graph for this function:

tasks_new()

struct task* tasks_new	(	void(*)(void)	entry,
		struct task *	storage,
		task_state	state,
		const char *	name
	)

Creates a new kernel task with a provided entry point, register storage struct, and task state struct. If the storage parameter is provided, the struct task struct provided will be written to. If NULL is passed as the storage parameter, a pointer to a allocated task will be returned.

Parameters

entry	Task function entry point
storage	Task stack structure (if NULL, a pointer to the task is returned)
state	Task state structure
name	Task name (for debugging / printing)

Returns

struct task* Pointer to the created kernel task

Definition at line 289 of file tasks.cpp.

{
    struct task *new_task = storage;
    if (storage == NULL) {
        // allocate memory for our task structure
        new_task = (struct task*)malloc(sizeof(struct task));
        // panic if the alloc fails (we have no fallback)
        if (new_task == NULL) {
            panic("Unable to allocate memory for new task struct.");
        }
    }
    // allocate a page for this stack (we might change this later)
    // TODO: Should more than one page be allocated / freed?
    uint8_t *stack = (uint8_t *)Memory::newPage(1);
    if (stack == NULL) {
        panic("Unable to allocate memory for new task stack.");
    }
    // remember, the stack grows up
    void *stack_pointer = stack + ARCH_PAGE_SIZE;
    // a null stack frame to make the panic screen happy
    _stack_push_word(&stack_pointer, 0);
    // the last thing to happen is the task stopping function
    _stack_push_word(&stack_pointer, (size_t)_task_stopping);
    // next entry is the main function to call (the start of the task)
    _stack_push_word(&stack_pointer, (size_t)entry);
    // when this task is started, the CPU will pop off this value which will become the new EIP
    // we push this function to allow some setup code to be run from within the context of the new task
    _stack_push_word(&stack_pointer, (size_t)_task_starting);
    // our task switching code is going to pop four values off of the stack before returning
    _stack_push_word(&stack_pointer, 0);
    _stack_push_word(&stack_pointer, 0);
    _stack_push_word(&stack_pointer, 0);
    _stack_push_word(&stack_pointer, 0);
    new_task->stack_top = (uintptr_t)stack_pointer;
    new_task->page_dir = Memory::getPageDirPhysAddr();
    new_task->next = NULL;
    new_task->state = state;
    new_task->time_used = 0;
    new_task->name = name;
    new_task->alloc = storage == NULL ? ALLOC_DYNAMIC : ALLOC_STATIC;
    if (state == TASK_READY) {
        _tasks_enqueue_ready(new_task);
    }
    TASK_ACTION(__func__, new_task);
    return new_task;
}

Here is the call graph for this function:

tasks_schedule()

void tasks_schedule

(

)

Tell the kernel task scheduler to schedule all of the added tasks.

Definition at line 406 of file tasks.cpp.

{
    // we must lock on all scheduling operations
    _aquire_scheduler_lock();
    // run the scheduler
    _schedule();
    // this will run when we switch back to the calling task
    _release_scheduler_lock();
}

tasks_sync_block()

void tasks_sync_block

(

struct task_sync *

ts

)

Definition at line 560 of file tasks.cpp.

{
    _aquire_scheduler_lock();
#ifdef DEBUG
    if (ts->dbg_name != NULL) {
        Logger::Debug(__func__, "blocking %s", ts->dbg_name);
    }
#endif
    // push the current task to the waiting queue
    _enqueue_task(&ts->waiting, current_task);
    // now block until the mutex is freed
    tasks_block_current(TASK_BLOCKED);
    _release_scheduler_lock();
}

Here is the caller graph for this function:

tasks_sync_unblock()

void tasks_sync_unblock

(

struct task_sync *

ts

)

Definition at line 575 of file tasks.cpp.

{
    _aquire_scheduler_lock();
#ifdef DEBUG
    if (ts->dbg_name != NULL) {
        Logger::Debug(__func__, "unblocking %s", ts->dbg_name);
    }
#endif
    // iterate all tasks that were blocked and unblock them
    struct task *task = ts->waiting.head;
    struct task *next = NULL;
    if (task == NULL) {
        // no other tasks were blocked
        goto exit;
    }
    do {
        next = task->next;
        _wakeup(task);
        task->next = NULL;
        task = next;
    } while (task != NULL);
    ts->waiting.head = NULL;
    ts->waiting.tail = NULL;
    // we woke up some tasks
    _schedule();
exit:
    _release_scheduler_lock();
}

Here is the caller graph for this function:

tasks_unblock()

void tasks_unblock

(

struct task *

task

)

Unblocks the current task.

Parameters

task

Definition at line 431 of file tasks.cpp.

{
    _aquire_scheduler_lock();
    task->state = TASK_READY;
    TASK_ACTION(__func__, task);
    _tasks_enqueue_ready(task);
    _release_scheduler_lock();
}

tasks_update_time()

void tasks_update_time

(

)

Definition at line 336 of file tasks.cpp.

{
    uint64_t current_time = _get_cpu_time_ns();
    uint64_t delta = current_time - _last_time;
    if (current_task == NULL) {
        _idle_time += delta;
    } else {
        current_task->time_used += delta;
    }
    _last_time = current_time;
}

Here is the caller graph for this function:

Variable Documentation

current_task

struct task* current_task = NULL

Definition at line 40 of file tasks.cpp.

tasks_ready

struct tasklist tasks_ready = { }

Definition at line 44 of file tasks.cpp.