sched.c

Go to the documentation of this file.

 
#include <core/system.h>
#include <core/panic.h>
#include <core/arch.h>
#include <sys/proc.h>
#include <sys/sched.h>
#include <sys/signal.h>
#include <ds/list.h>
#include <dev/random.h>
#include <sys/callout.h>
#include <fs/vfs.h>
 
#include <aquila/stat.h>
 
/* The threads ready to run, in the order they will run (their run_link). */
static struct list ready;
 
/* The processors; cpus[0] is the one that booted. */
struct cpu cpus[CPUS_MAX];
int cpus_count;
 
/* The threads waiting with a deadline (thread->sleep_until), whichever
 * wait queue they sleep on (their timer_link). */
static struct list timed;
 
/* nanosleep() sleeps here; only the timer wakes its threads up. */
static struct waitq naps;
 
/* The processes with a real time timer armed (proc->alarm_at, their
 * alarm_link). */
static struct list alarms;

void sched_cpu_tick(uint32_t period, int user)
{
    /* a killed thread's process may be gone already (thread->killed) */
    if (!curcpu()->idle && curthread && !curthread->killed) {
        if (user)
            curproc->utime += period;
        else
            curproc->stime += period;
    }
}

void sched_timer_tick(uint32_t period, int user)
{
    uint64_t now = arch_rtime_ns();
 
    /* when an interrupt comes, counted in cycles, isn't predictable */
    random_add((uint32_t) arch_cycles());
 
    callout_run(now);
 
    sched_cpu_tick(period, user);
 
    list_for (node, &timed) {
        struct thread *thread = list_entry(node, struct thread, timer_link);
 
        if (now >= thread->sleep_until) {
            sched_timer_cancel(thread);
            thread_wakeup(thread);
        }
    }
 
    list_for (node, &alarms) {
        struct proc *proc = list_entry(node, struct proc, alarm_link);
 
        if (now >= proc->alarm_at) {
            if (proc->alarm_interval) {
                /* the next expiry, rather than every one that was missed */
                proc->alarm_at += proc->alarm_interval;
                if (proc->alarm_at <= now)
                    proc->alarm_at = now + proc->alarm_interval;
            } else {
                list_remove(&proc->alarm_link);
            }
 
            signal_proc_send(proc, SIGALRM);
        }
    }
}

void sched_alarm_get(struct proc *proc, uint64_t *value, uint64_t *interval)
{
    uint64_t now = arch_rtime_ns();
 
    int armed = list_linked(&proc->alarm_link);
 
    *value = !armed ? 0 : proc->alarm_at > now ? proc->alarm_at - now : 1;
    *interval = armed ? proc->alarm_interval : 0;
}

void sched_alarm(struct proc *proc, uint64_t value, uint64_t interval,
                 uint64_t *old_value, uint64_t *old_interval)
{
    uint64_t now = arch_rtime_ns(), v, i;
 
    sched_alarm_get(proc, &v, &i);
 
    if (old_value)
        *old_value = v;
 
    if (old_interval)
        *old_interval = i;
 
    list_remove(&proc->alarm_link);
 
    if (!value)
        return;
 
    proc->alarm_at = now + value;
    proc->alarm_interval = interval;
    list_append(&alarms, &proc->alarm_link);
}

void sched_timer_cancel(struct thread *thread)
{
    list_remove(&thread->timer_link);
}

int sched_wait(struct waitq *waitq, uint64_t until)
{
    if (until) {
        if (arch_rtime_ns() >= until)
            return 1;
 
        curthread->sleep_until = until;
        list_append(&timed, &curthread->timer_link);
    }
 
    int err = waitq_sleep(waitq);
    sched_timer_cancel(curthread);
 
    if (err)
        return err;
 
    return until && arch_rtime_ns() >= until;
}

int sched_sleep(uint64_t until)
{
    int r;
 
    while (!(r = sched_wait(&naps, until)))
        ;
 
    return r < 0 ? r : 0;
}

struct cpu *sched_thread_cpu(struct thread *thread)
{
    for (int i = 0; i < cpus_count; ++i)
        if (cpus[i].thread == thread && &cpus[i] != curcpu())
            return &cpus[i];
 
    return NULL;
}

void sched_thread_kick(struct thread *thread)
{
    struct cpu *cpu = sched_thread_cpu(thread);
 
    if (cpu)
        arch_cpu_kick(cpu);
}

void sched_thread_killed(void)
{
    struct thread *thread = curthread;
 
    if (thread->owner) {
        queue_remove(&thread->owner->threads, thread);
        waitq_wakeup(&thread->owner->thread_join);
        thread->owner = NULL;
    }
 
    arch_cur_thread_kill();
}

static void sched_cpu_wake(void)
{
    if (!sched_running || curcpu()->idle)
        return;
 
    for (int i = 0; i < cpus_count; ++i) {
        struct cpu *cpu = &cpus[i];
 
        /* a CPU already woken up runs another thread: try the next one */
        if (cpu != curcpu() && cpu->idle && !cpu->kicked) {
            cpu->kicked = 1;
            arch_cpu_kick(cpu);
            return;
        }
    }
}

void sched_thread_ready(struct thread *thread)
{
    list_append(&ready, &thread->run_link);
    sched_cpu_wake();
}
 
/* An urgent thread was woken up: switch to it when the interrupt returns
 * to user mode (an idle CPU switches anyway). */
int sched_urgent = 0;

void sched_thread_wake(struct thread *thread)
{
    if (!thread->urgent) {
        sched_thread_ready(thread);
        return;
    }
 
    list_prepend(&ready, &thread->run_link);
    sched_urgent = 1;
    sched_cpu_wake();
}

void kernel_idle(void)
{
    curcpu()->idle = 1;
 
    if (!list_empty(&ready))
        schedule();
 
    arch_idle();
}

void sched_idle_wakeup(void)
{
    /* another CPU may wake this one up again */
    curcpu()->kicked = 0;
 
    if (curcpu()->idle && !list_empty(&ready))
        schedule();
}

void sched_thread_spawn(struct thread *thread)
{
    thread->spawned = 1;
    arch_thread_spawn(thread);
}
 
int sched_running = 0;

void sched_init_spawn(struct proc *init)
{
    proc_init(init);
 
    /* init's defaults */
    init->mask = 022;   /* umask */
    init->cwd = vfs_root;
    vfs_root->ref++;
 
    arch_sched_init();
 
    session_new(init);
 
    curthread = (struct thread *) init->threads.head->value;
    curthread->state = RUNNABLE;
    sched_running = 1;
    sched_thread_spawn(curthread);
}

void schedule(void)
{
    sched_urgent = 0;
 
    if (!curcpu()->idle)
        sched_thread_ready(curthread);
 
    curcpu()->idle = 0;
 
    if (list_empty(&ready))
        kernel_idle();
 
    curthread = list_entry(list_pop(&ready), struct thread, run_link);
 
    if (curthread->spawned) {
        arch_thread_switch(curthread);
    } else {
        sched_thread_spawn(curthread);
    }
}