coop.c

Go to the documentation of this file.

#include "proc_p.h"
#include "proc.h"

// Log settings for cfg/log.h.
#define LOG_LEVEL   KERN_LOG_LEVEL
#define LOG_FORMAT  KERN_LOG_FORMAT
#include <cfg/log.h>

#include <cpu/irq.h>
#include <cpu/types.h>
#include <cpu/attr.h>
#include <cpu/frame.h>

EXTERN_C void asm_switch_context(cpu_stack_t **new_sp, cpu_stack_t **save_sp);


static void proc_schedule(void)
{
    cpu_flags_t flags;

    ATOMIC(LIST_ASSERT_VALID(&ProcReadyList));
    ASSERT_USER_CONTEXT();
    IRQ_ASSERT_ENABLED();

    /* Poll on the ready queue for the first ready process */
    IRQ_SAVE_DISABLE(flags);
    while (!(CurrentProcess = (struct Process *)list_remHead(&ProcReadyList)))
    {
        /*
         * Make sure we physically reenable interrupts here, no matter what
         * the current task status is. This is important because if we
         * are idle-spinning, we must allow interrupts, otherwise no
         * process will ever wake up.
         *
         * During idle-spinning, an interrupt can occur and it may
         * modify \p ProcReadyList. To ensure that compiler reload this
         * variable every while cycle we call CPU_MEMORY_BARRIER.
         * The memory barrier ensure that all variables used in this context
         * are reloaded.
         * \todo If there was a way to write sig_wait() so that it does not
         * disable interrupts while waiting, there would not be any
         * reason to do this.
         */
        IRQ_ENABLE;
        CPU_IDLE;
        MEMORY_BARRIER;
        IRQ_DISABLE;
    }
    IRQ_RESTORE(flags);
}

void proc_switch(void)
{
    /* Remember old process to save its context later */
    Process * const old_process = CurrentProcess;

    proc_schedule();

    /*
     * Optimization: don't switch contexts when the active
     * process has not changed.
     */
    if (CurrentProcess != old_process)
    {
        cpu_stack_t *dummy;

        #if CONFIG_KERN_MONITOR
            LOG_INFO("Switch from %p(%s) to %p(%s)\n",
                old_process,    proc_name(old_process),
                CurrentProcess, proc_currentName());
        #endif

        /* Save context of old process and switch to new process. If there is no
         * old process, we save the old stack pointer into a dummy variable that
         * we ignore. In fact, this happens only when the old process has just
         * exited.
         * TODO: Instead of physically clearing the process at exit time, a zombie
         * list should be created.
         */
        asm_switch_context(&CurrentProcess->stack, old_process ? &old_process->stack : &dummy);
    }

    /* This RET resumes the execution on the new process */
}


void proc_yield(void)
{
    ATOMIC(SCHED_ENQUEUE(CurrentProcess));
    proc_switch();
}