sched.h

Go to the documentation of this file.

 
#ifndef __AA64_SCHED_H__
#define __AA64_SCHED_H__
 
#include <stdint.h>
#include <Hal/AA64/aa64cpu.h>
/* Pointer only. The full <list.h> declares list_add(list_t*, void*), which
 * cannot share a file with mainline list_add(list_head*, list_head*).
 * DCL/linux_irq_shim.c includes this header and then <linux/kernel.h>. */
typedef struct _list_ list_t;
 
#ifdef ARCH_ARM64
 
#define THREAD_STATE_READY          1
#define THREAD_STATE_BLOCKED        3
#define THREAD_STATE_SLEEP          4
#define THREAD_STATE_KILLABLE       5
#define THREAD_STATE_LEFT_IN_KERNEL 6
#define THREAD_STATE_PENDING_SIGNAL 7
#define THREAD_STATE_RUNNING        8
 
 
#define THREAD_LEVEL_KERNEL      (1 << 0)
#define THREAD_LEVEL_USER        (1 << 1)
#define THREAD_LEVEL_SUBTHREAD   (1 << 2)
#define THREAD_LEVEL_MAIN_THREAD (1 << 3)
 
//#pragma pack(push,1)
/* AuUserEntry structure */
typedef struct _uentry_ {
    uint64_t entrypoint;
    uint64_t rsp;
    uint64_t cs;
    uint64_t ss;
    int num_args;
    uint64_t argvaddr;   /* user-space VA of argv[] page (for crt0 via stack) */
    uint64_t argvkernel; /* kernel-space VA of argv[] page (for EL1 writes) */
    char** argvs;
    uint64_t stackBase;
    /* PROCESS_TYPE_LINUX aux vector. Zero on a PE process. */
    uint64_t linux_phdr;
    uint16_t linux_phent;
    uint16_t linux_phnum;
} AuUserEntry;
//#pragma pack(pop)
 
#define MAX_SIGNAL_ENTRY 10
 
typedef struct _gp_context_ {
    uint64_t x[31];
    uint64_t sp_el0;
    uint64_t elr_el1;
    uint64_t spsr_el1;
} _gp_context_t;
 
typedef struct _signal_frame_ {
    AA64Registers regs;
    uint64_t elr_el1;
    uint64_t sigret_address;
} _signal_frame_t;
 
//#pragma pack(push,1)
typedef struct _aa64_task_ {
    uint64_t x19;         //0
    uint64_t x20;         //8
    uint64_t x21;         //16
    uint64_t x22;         //24
    uint64_t x23;         //32
    uint64_t x24;         //40
    uint64_t x25;         //48
    uint64_t x26;         //56
    uint64_t x27;         //64
    uint64_t x28;         //72
    uint64_t x29;         //80
    uint64_t x30;         //88
    uint64_t sp;          //96
    uint64_t elr_el1;     //104
    uint64_t spsr_el1;    //112
    uint64_t x0;          //120
    uint64_t x1;          //128
    uint64_t x2;          //136
    uint64_t x3;          //144
    uint64_t x4;          //152
    uint64_t x5;          //160
    uint64_t x6;          //168
    uint64_t x7;          //176
    uint64_t x8;          //184
    uint8_t state;        //192
    uint8_t threadType;   //193
    uint64_t pml;         //186
    char name[8];         //130
    void* procSlot;       //138
    AuUserEntry* uentry;  //146
    bool first_run;       //206
    uint64_t thread_id;   //207
    uint64_t sleepQuanta; //215
    uint64_t originalKSp; //223
    bool returnFromSyscall;
    bool justStored;
    void* data;
    AU_ALIGN(16) uint8_t fp_regs[512];
    uint64_t fpcr;
    uint64_t fpsr;
    uint32_t syscallNum;
    uint64_t sig_pending;
    _signal_frame_t signal;
    uint64_t start_time_us;
    uint64_t* sigs[32];
    struct _aa64_task_* next;
    struct _aa64_task_* prev;
    /* EDF real-time class (implicit-deadline periodic model). Zeroed by
     * default: thread is best-effort round-robin. See Hal/sched_edf.c. */
    uint8_t edf_enabled;
    uint8_t edf_waiting;
    uint64_t edf_period_us;
    uint64_t edf_wcet_us;
    uint64_t edf_deadline_us;
    uint64_t edf_release_us;
    uint64_t edf_misses;
    list_t* waitlist;
    uint16_t wait_ref_count;
    /* Linux ELF pthread. Saved across switches because EL0 writes TPIDR_EL0. */
    uint64_t linux_tls;
    uint64_t clear_child_tid;
    uint64_t futex_uaddr;
    uint32_t futex_bitset;
    uint8_t futex_waiting;
    uint64_t sleep_until_us;
    uint8_t blocked_on_poll;
} AA64Thread;
 
//#pragma pack(pop)
extern void AuSchedulerInitialize();
extern uint64_t AuCreateKernelStack(uint64_t* pml);
AU_EXTERN AU_EXPORT AA64Thread* AuCreateKthread(void (*entry)(uint64_t), uint64_t* pml, char* name);
AU_EXTERN AU_EXPORT AA64Thread*
AuCreateSubKthread(void (*entry)(uint64_t), uint64_t stack, uint64_t* pml, char* name);
 
extern void AuScheduleThread(AA64Registers* regs);
extern void AuScheduleNext();
/* Park the caller for about ms and run another thread. Returns 0, or
 * -1 when the scheduler is not running yet. */
extern int AuSchedYieldMs(uint64_t ms);
extern void AuSchedulerStart();
extern AA64Thread* AuGetIdleThread();
extern AA64Thread* AuGetCurrentThread();
 
AU_EXTERN AU_EXPORT void AuBlockThread(AA64Thread* thread);
 
AU_EXTERN AU_EXPORT void AuUnblockThread(AA64Thread* thread);
 
AU_EXTERN AU_EXPORT void AuThreadWakePoller(AA64Thread* t);
AU_EXTERN AU_EXPORT void AuForceScheduler();
 
AU_EXTERN AU_EXPORT void AuSleepThread(AA64Thread* thread, uint64_t ms);
 
AU_EXTERN AU_EXPORT AA64Thread* AuThreadFindByID(uint64_t id);
 
AU_EXTERN AU_EXPORT AA64Thread* AuThreadFindByIDBlockList(uint64_t id);
 
AU_EXTERN AU_EXPORT AA64Thread* AuThreadFindByIDSleepList(uint64_t id);
AU_EXTERN AU_EXPORT void AuThreadMoveToTrash(AA64Thread* t);
 
extern void AuThreadCleanTrash(AA64Thread* t);
 
extern uint64_t AuGetSystemTimerTick();
 
extern void AuHandleSleepThreads();
 
extern void AuThreadMakeReady(AA64Thread* thread);
 
/* Scheduler list lock (mask + spinlock, DAIF save/restore). Tick path
 * runs masked already; thread context must use these (or the locking
 * AuThread* wrappers) around list access. */
extern uint64_t AuSchedLock(void);
extern void AuSchedUnlock(uint64_t saved_daif);
extern bool AuSchedValidateLists(void);
 
/* EDF real-time class, see Hal/sched_edf.c. All no-ops / NULL-safe when
 * the thread is not EDF-enabled; best-effort threads are unaffected. */
extern bool AuEDFSetParams(AA64Thread* thread, uint64_t period_us, uint64_t wcet_us);
extern void AuEDFRemove(AA64Thread* thread);
extern void AuEDFWaitPeriod(AA64Thread* thread);
extern void AuEDFHandleReleases(uint64_t now_us);
extern AA64Thread* AuEDFPickNext(void);
extern uint64_t AuEDFGetMisses(AA64Thread* thread);
extern void AuEDFSelfTestStart(void);
extern void AuSoakStart(void);
 
extern int AuThreadWaitForTermination(int thread_id);
extern void AuThreadAwakeWaiters(AA64Thread* thread);
 
#endif
 
#endif