tasks.hpp File Reference

#include <stdint.h>
#include <Arch/Arch.hpp>
#include <Memory/paging.hpp>

Include dependency graph for tasks.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	task
struct	tasklist
struct	task_sync

Macros
#define	TIME_SLICE_SIZE   (1 * 1000 * 1000ULL)
#define	TASK_ONLY   if (current_task != NULL)
#define	MAX_TASKS_QUEUED   8

Enumerations
enum	task_state {   TASK_RUNNING = 0, TASK_READY = 1, TASK_SLEEPING, TASK_BLOCKED,   TASK_STOPPED, TASK_PAUSED, TASK_STATE_COUNT }
enum	task_alloc { ALLOC_STATIC, ALLOC_DYNAMIC }

Functions
void	tasks_init ()
void	tasks_switch_to (struct task *task)
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)
void	tasks_sync_block (struct task_sync *tsc)
void	tasks_sync_unblock (struct task_sync *tsc)

Variables
struct task *	current_task

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.hpp.

Macro Definition Documentation

MAX_TASKS_QUEUED

#define MAX_TASKS_QUEUED   8

Definition at line 54 of file tasks.hpp.

TASK_ONLY

#define TASK_ONLY   if (current_task != NULL)

Definition at line 46 of file tasks.hpp.

TIME_SLICE_SIZE

#define TIME_SLICE_SIZE   (1 * 1000 * 1000ULL)

Definition at line 17 of file tasks.hpp.

Enumeration Type Documentation

task_alloc

enum task_alloc

Enumerator
ALLOC_STATIC
ALLOC_DYNAMIC

Definition at line 30 of file tasks.hpp.

{ ALLOC_STATIC, ALLOC_DYNAMIC };

task_state

enum task_state

Enumerator
TASK_RUNNING
TASK_READY
TASK_SLEEPING
TASK_BLOCKED
TASK_STOPPED
TASK_PAUSED
TASK_STATE_COUNT

Definition at line 19 of file tasks.hpp.

{
    TASK_RUNNING  = 0,
    TASK_READY    = 1,
    TASK_SLEEPING,
    TASK_BLOCKED,
    TASK_STOPPED,
    TASK_PAUSED,
    TASK_STATE_COUNT
};

Function Documentation

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_switch_to()

void tasks_switch_to

(

struct task *

task

)

Switches to a provided task.

Parameters

task	Pointer to the task struct

tasks_sync_block()

void tasks_sync_block

(

struct task_sync *

tsc

)

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 *

tsc

)

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();
}

Variable Documentation

current_task

struct task* current_task

Definition at line 40 of file tasks.cpp.