proc.h

Go to the documentation of this file.

#ifndef KERN_PROC_H
#define KERN_PROC_H

#include "cfg/cfg_kern.h"
#include <cfg/compiler.h>

#if CONFIG_KERN_PREEMPT
    #include <cfg/debug.h> // ASSERT()
#endif

#include <cpu/types.h> // cpu_stack_t
#include <cpu/frame.h> // CPU_SAVED_REGS_CNT

/*
 * Forward declaration. The definition of struct Process is private to the
 * scheduler and hidden in proc_p.h.
 */
struct Process;

void proc_init(void);
struct Process *proc_new_with_name(const char *name, void (*entry)(void), iptr_t data, size_t stacksize, cpu_stack_t *stack);

#if !CONFIG_KERN_MONITOR
    #define proc_new(entry,data,size,stack) proc_new_with_name(NULL,(entry),(data),(size),(stack))
#else
    #define proc_new(entry,data,size,stack) proc_new_with_name(#entry,(entry),(data),(size),(stack))
#endif

void proc_exit(void);
void proc_yield(void);
void proc_rename(struct Process *proc, const char *name);
const char *proc_name(struct Process *proc);
const char *proc_currentName(void);
iptr_t proc_currentUserData(void);

int proc_testSetup(void);
int proc_testRun(void);
int proc_testTearDown(void);

INLINE struct Process *proc_current(void)
{
    extern struct Process *CurrentProcess;
    return CurrentProcess;
}

#if CONFIG_KERN_PRI
    void proc_setPri(struct Process *proc, int pri);
#else
    INLINE void proc_setPri(UNUSED_ARG(struct Process *,proc), UNUSED_ARG(int, pri))
    {
    }
#endif

INLINE void proc_forbid(void)
{
    #if CONFIG_KERN_PREEMPT
        extern cpu_atomic_t _preempt_forbid_cnt;
        /*
         * We don't need to protect the counter against other processes.
         * The reason why is a bit subtle.
         *
         * If a process gets here, preempt_forbid_cnt can be either 0,
         * or != 0.  In the latter case, preemption is already disabled
         * and no concurrency issues can occur.
         *
         * In the former case, we could be preempted just after reading the
         * value 0 from memory, and a concurrent process might, in fact,
         * bump the value of preempt_forbid_cnt under our nose!
         *
         * BUT: if this ever happens, then we won't get another chance to
         * run until the other process calls proc_permit() to re-enable
         * preemption.  At this point, the value of preempt_forbid_cnt
         * must be back to 0, and thus what we had originally read from
         * memory happens to be valid.
         *
         * No matter how hard you think about it, and how complicated you
         * make your scenario, the above holds true as long as
         * "preempt_forbid_cnt != 0" means that no task switching is
         * possible.
         */
        ++_preempt_forbid_cnt;

        /*
         * Make sure _preempt_forbid_cnt is flushed to memory so the
         * preemption softirq will see the correct value from now on.
         */
        MEMORY_BARRIER;
    #endif
}

INLINE void proc_permit(void)
{
    #if CONFIG_KERN_PREEMPT

        /*
         * This is to ensure any global state changed by the process gets
         * flushed to memory before task switching is re-enabled.
         */
        MEMORY_BARRIER;
        extern cpu_atomic_t _preempt_forbid_cnt;
        /* No need to protect against interrupts here. */
        ASSERT(_preempt_forbid_cnt != 0);
        --_preempt_forbid_cnt;

        /*
         * This ensures _preempt_forbid_cnt is flushed to memory immediately
         * so the preemption interrupt sees the correct value.
         */
        MEMORY_BARRIER;

    #endif
}

INLINE bool proc_allowed(void)
{
    #if CONFIG_KERN_PREEMPT
        extern cpu_atomic_t _preempt_forbid_cnt;
        return (_preempt_forbid_cnt == 0);
    #else
        return true;
    #endif
}

#define PROC_ATOMIC(CODE) \
    do { \
        proc_forbid(); \
        CODE; \
        proc_permit(); \
    } while(0)

#ifndef CONFIG_KERN_MINSTACKSIZE

    #if (ARCH & ARCH_EMUL)
        /* We need a large stack because system libraries are bloated */
        #define CONFIG_KERN_MINSTACKSIZE  65536
    #else

        #define CONFIG_KERN_MINSTACKSIZE  \
            (CPU_SAVED_REGS_CNT * 2 * sizeof(cpu_stack_t) \
            + 48 * sizeof(int))
    #endif
#endif

/* Memory fill codes to help debugging */
#if CONFIG_KERN_MONITOR
    #include <cpu/types.h>
    #if (SIZEOF_CPUSTACK_T == 1)
        /* 8bit cpu_stack_t */
        #define CONFIG_KERN_STACKFILLCODE  0xA5
        #define CONFIG_KERN_MEMFILLCODE    0xDB
    #elif (SIZEOF_CPUSTACK_T == 2)
        /* 16bit cpu_stack_t */
        #define CONFIG_KERN_STACKFILLCODE  0xA5A5
        #define CONFIG_KERN_MEMFILLCODE    0xDBDB
    #elif (SIZEOF_CPUSTACK_T == 4)
        /* 32bit cpu_stack_t */
        #define CONFIG_KERN_STACKFILLCODE  0xA5A5A5A5UL
        #define CONFIG_KERN_MEMFILLCODE    0xDBDBDBDBUL
    #elif (SIZEOF_CPUSTACK_T == 8)
        /* 64bit cpu_stack_t */
        #define CONFIG_KERN_STACKFILLCODE  0xA5A5A5A5A5A5A5A5ULL
        #define CONFIG_KERN_MEMFILLCODE    0xDBDBDBDBDBDBDBDBULL
    #else
        #error No cpu_stack_t size supported!
    #endif
#endif

#endif /* KERN_PROC_H */