proc.c

Go to the documentation of this file.

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

#include "cfg/cfg_proc.h"
#define LOG_LEVEL KERN_LOG_LEVEL
#define LOG_FORMAT KERN_LOG_FORMAT
#include <cfg/log.h>

#include "cfg/cfg_arch.h"  // ARCH_EMUL
#include "cfg/cfg_monitor.h"
#include <cfg/macros.h>    // ROUND_UP2
#include <cfg/module.h>
#include <cfg/depend.h>    // CONFIG_DEPEND()

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

#if CONFIG_KERN_HEAP
    #include <struct/heap.h>
#endif

#include <string.h>           /* memset() */

/*
 * The scheduer tracks ready processes by enqueuing them in the
 * ready list.
 *
 * \note Access to the list must occur while interrupts are disabled.
 */
REGISTER List ProcReadyList;

/*
 * Holds a pointer to the TCB of the currently running process.
 *
 * \note User applications should use proc_current() to retrieve this value.
 */
REGISTER Process *CurrentProcess;

#if (ARCH & ARCH_EMUL)
/*
 * In some hosted environments, we must emulate the stack on the real
 * process stack to satisfy consistency checks in system libraries and
 * because some ABIs place trampolines on the stack.
 *
 * Access to this list must be protected by PROC_ATOMIC().
 */
List StackFreeList;

#define NPROC 10
cpu_stack_t proc_stacks[NPROC][(64 * 1024) / sizeof(cpu_stack_t)];
#endif

struct Process MainProcess;


static void proc_init_struct(Process *proc)
{
    /* Avoid warning for unused argument. */
    (void)proc;

#if CONFIG_KERN_SIGNALS
    proc->sig_recv = 0;
    proc->sig_wait = 0;
#endif

#if CONFIG_KERN_HEAP
    proc->flags = 0;
#endif

#if CONFIG_KERN_PRI
    proc->link.pri = 0;
#endif

}

MOD_DEFINE(proc);

void proc_init(void)
{
    LIST_INIT(&ProcReadyList);

#if ARCH & ARCH_EMUL
    LIST_INIT(&StackFreeList);
    for (int i = 0; i < NPROC; i++)
        ADDTAIL(&StackFreeList, (Node *)proc_stacks[i]);
#endif

    /*
     * We "promote" the current context into a real process. The only thing we have
     * to do is create a PCB and make it current. We don't need to setup the stack
     * pointer because it will be written the first time we switch to another process.
     */
    proc_init_struct(&MainProcess);
    CurrentProcess = &MainProcess;

#if CONFIG_KERN_MONITOR
    monitor_init();
    monitor_add(CurrentProcess, "main");
#endif

#if CONFIG_KERN_PREEMPT
    preempt_init();
#endif

    MOD_INIT(proc);
}

struct Process *proc_new_with_name(UNUSED_ARG(const char *, name), void (*entry)(void), iptr_t data, size_t stack_size, cpu_stack_t *stack_base)
{
    Process *proc;
    const size_t PROC_SIZE_WORDS = ROUND_UP2(sizeof(Process), sizeof(cpu_stack_t)) / sizeof(cpu_stack_t);
#if CONFIG_KERN_HEAP
    bool free_stack = false;
#endif
    LOG_INFO("name=%s", name);

#if (ARCH & ARCH_EMUL)
    /* Ignore stack provided by caller and use the large enough default instead. */
    PROC_ATOMIC(stack_base = (cpu_stack_t *)list_remHead(&StackFreeList));
    ASSERT(stack_base);

    stack_size = KERN_MINSTACKSIZE;
#elif CONFIG_KERN_HEAP
    /* Did the caller provide a stack for us? */
    if (!stack_base)
    {
        /* Did the caller specify the desired stack size? */
        if (!stack_size)
            stack_size = KERN_MINSTACKSIZE;

        /* Allocate stack dinamically */
        if (!(stack_base = heap_alloc(stack_size)))
            return NULL;

        free_stack = true;
    }

#else // !ARCH_EMUL && !CONFIG_KERN_HEAP

    /* Stack must have been provided by the user */
    ASSERT_VALID_PTR(stack_base);
    ASSERT(stack_size);

#endif // !ARCH_EMUL && !CONFIG_KERN_HEAP

#if CONFIG_KERN_MONITOR
    /*
     * Fill-in the stack with a special marker to help debugging.
     * On 64bit platforms, CONFIG_KERN_STACKFILLCODE is larger
     * than an int, so the (int) cast is required to silence the
     * warning for truncating its size.
     */
    memset(stack_base, (int)CONFIG_KERN_STACKFILLCODE, stack_size);
#endif

    /* Initialize the process control block */
    if (CPU_STACK_GROWS_UPWARD)
    {
        proc = (Process *)stack_base;
        proc->stack = stack_base + PROC_SIZE_WORDS;
        // On some architecture stack should be aligned, so we do it.
        proc->stack = (cpu_stack_t *)((uintptr_t)proc->stack + (sizeof(cpu_aligned_stack_t) - ((uintptr_t)proc->stack % sizeof(cpu_aligned_stack_t))));
        if (CPU_SP_ON_EMPTY_SLOT)
            proc->stack++;
    }
    else
    {
        proc = (Process *)(stack_base + stack_size / sizeof(cpu_stack_t) - PROC_SIZE_WORDS);
        // On some architecture stack should be aligned, so we do it.
        proc->stack = (cpu_stack_t *)((uintptr_t)proc - ((uintptr_t)proc % sizeof(cpu_aligned_stack_t)));
        if (CPU_SP_ON_EMPTY_SLOT)
            proc->stack--;
    }
    /* Ensure stack is aligned */
    ASSERT((uintptr_t)proc->stack % sizeof(cpu_aligned_stack_t) == 0);

    stack_size -= PROC_SIZE_WORDS * sizeof(cpu_stack_t);
    proc_init_struct(proc);
    proc->user_data = data;

#if CONFIG_KERN_HEAP | CONFIG_KERN_MONITOR | (ARCH & ARCH_EMUL)
    proc->stack_base = stack_base;
    proc->stack_size = stack_size;
    #if CONFIG_KERN_HEAP
    if (free_stack)
        proc->flags |= PF_FREESTACK;
    #endif
#endif

    #if CONFIG_KERN_PREEMPT

        getcontext(&proc->context);
        proc->context.uc_stack.ss_sp = proc->stack;
        proc->context.uc_stack.ss_size = stack_size - 1;
        proc->context.uc_link = NULL;
        makecontext(&proc->context, (void (*)(void))proc_entry, 1, entry);

    #else // !CONFIG_KERN_PREEMPT
    
        CPU_CREATE_NEW_STACK(proc->stack, entry, proc_exit);
        
    #endif // CONFIG_KERN_PREEMPT

    #if CONFIG_KERN_MONITOR
        monitor_add(proc, name);
    #endif

    /* Add to ready list */
    ATOMIC(SCHED_ENQUEUE(proc));

    return proc;
}

const char *proc_name(struct Process *proc)
{
    #if CONFIG_KERN_MONITOR
        return proc ? proc->monitor.name : "<NULL>";
    #else
        (void)proc;
        return "---";
    #endif
}

const char *proc_currentName(void)
{
    return proc_name(proc_current());
}

void proc_rename(struct Process *proc, const char *name)
{
#if CONFIG_KERN_MONITOR
    monitor_rename(proc, name);
#else
    (void)proc; (void)name;
#endif
}


#if CONFIG_KERN_PRI

void proc_setPri(struct Process *proc, int pri)
{
        if (proc->link.pri == pri)
            return;

        proc->link.pri = pri;

        if (proc != CurrentProcess)
        {
                proc_forbid();
                ATOMIC(sched_reenqueue(proc));
                proc_permit();
        }
}
#endif // CONFIG_KERN_PRI

void proc_exit(void)
{
    LOG_INFO("%p:%s", CurrentProcess, proc_currentName());

#if CONFIG_KERN_MONITOR
    monitor_remove(CurrentProcess);
#endif

#if CONFIG_KERN_HEAP
    /*
     * The following code is BROKEN.
     * We are freeing our own stack before entering proc_schedule()
     * BAJO: A correct fix would be to rearrange the scheduler with
     *  an additional parameter which frees the old stack/process
     *  after a context switch.
     */
    if (CurrentProcess->flags & PF_FREESTACK)
        heap_free(CurrentProcess->stack_base, CurrentProcess->stack_size);
    heap_free(CurrentProcess);
#endif

#if (ARCH & ARCH_EMUL)
    /* Reinsert process stack in free list */
    PROC_ATOMIC(ADDHEAD(&StackFreeList, (Node *)CurrentProcess->stack_base));

    /*
     * NOTE: At this point the first two words of what used
     * to be our stack contain a list node. From now on, we
     * rely on the compiler not reading/writing the stack.
     */
#endif /* ARCH_EMUL */

    CurrentProcess = NULL;
    proc_switch();
    /* not reached */
}


iptr_t proc_currentUserData(void)
{
    return CurrentProcess->user_data;
}