proc.h

Go to the documentation of this file.

#ifndef KERN_PROC_H
#define KERN_PROC_H

#include "cfg/cfg_proc.h"
#include "cfg/cfg_signal.h"
#include "cfg/cfg_monitor.h"

#include <struct/list.h> // Node, PriNode

#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

/*
 * WARNING: struct Process is considered private, so its definition can change any time
 * without notice. DO NOT RELY on any field defined here, use only the interface
 * functions below.
 *
 * You have been warned.
 */
typedef struct Process
{
#if CONFIG_KERN_PRI
    PriNode      link;        
#else
    Node         link;        
#endif
    cpu_stack_t  *stack;       
    iptr_t       user_data;   
#if CONFIG_KERN_SIGNALS
    sigmask_t    sig_wait;    
    sigmask_t    sig_recv;    
#endif

#if CONFIG_KERN_HEAP
    uint16_t     flags;       
#endif

#if CONFIG_KERN_HEAP | CONFIG_KERN_MONITOR | (ARCH & ARCH_EMUL)
    cpu_stack_t  *stack_base;  
    size_t       stack_size;  
#endif

#if CONFIG_KERN_PREEMPT
    ucontext_t   context;
#endif

#if CONFIG_KERN_MONITOR
    struct ProcMonitor
    {
        Node        link;
        const char *name;
    } monitor;
#endif

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

#if (ARCH & ARCH_EMUL)
    /* We need a large stack because system libraries are bloated */
    #define KERN_MINSTACKSIZE 65536
#else
    #define KERN_MINSTACKSIZE \
        (sizeof(Process) + CPU_SAVED_REGS_CNT * 2 * sizeof(cpu_stack_t) \
        + 32 * sizeof(int))
#endif

#ifndef CONFIG_KERN_MINSTACKSIZE
    /* For backward compatibility */
    #define CONFIG_KERN_MINSTACKSIZE KERN_MINSTACKSIZE
#else
    #warning FIXME: This macro is deprecated, use KERN_MINSTACKSIZE instead
#endif

#define PROC_DEFINE_STACK(name, size) \
    STATIC_ASSERT((size) >= KERN_MINSTACKSIZE); \
    cpu_stack_t name[(size) / sizeof(cpu_stack_t)];

/* 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 */