thread.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include "context.h"
#include "time.h"
#include "threadqueue.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct OSFastMutex OSFastMutex;
typedef struct OSFastMutexQueue OSFastMutexQueue;
typedef struct OSMutex OSMutex;
typedef struct OSMutexQueue OSMutexQueue;
typedef struct OSThread OSThread;

typedef uint8_t OSThreadState;

typedef uint32_t OSThreadRequest;

typedef uint8_t OSThreadAttributes;

typedef int (*OSThreadEntryPointFn)(int argc, const char **argv);
typedef void (*OSThreadCleanupCallbackFn)(OSThread *thread, void *stack);
typedef void (*OSThreadDeallocatorFn)(OSThread *thread, void *stack);

enum OS_THREAD_STATE
{
   OS_THREAD_STATE_NONE             = 0,

   OS_THREAD_STATE_READY            = 1 << 0,

   OS_THREAD_STATE_RUNNING          = 1 << 1,

   OS_THREAD_STATE_WAITING          = 1 << 2,

   OS_THREAD_STATE_MORIBUND         = 1 << 3,
};

enum OS_THREAD_REQUEST
{
   OS_THREAD_REQUEST_NONE           = 0,
   OS_THREAD_REQUEST_SUSPEND        = 1,
   OS_THREAD_REQUEST_CANCEL         = 2,
};

enum OS_THREAD_ATTRIB
{
   OS_THREAD_ATTRIB_AFFINITY_CPU0   = 1 << 0,

   OS_THREAD_ATTRIB_AFFINITY_CPU1   = 1 << 1,

   OS_THREAD_ATTRIB_AFFINITY_CPU2   = 1 << 2,

   OS_THREAD_ATTRIB_AFFINITY_ANY    = ((1 << 0) | (1 << 1) | (1 << 2)),

   OS_THREAD_ATTRIB_DETACHED        = 1 << 3,

   OS_THREAD_ATTRIB_STACK_USAGE     = 1 << 5
};

struct OSMutexQueue
{
   OSMutex *head;
   OSMutex *tail;
   void *parent;
   WUT_UNKNOWN_BYTES(4);
};
WUT_CHECK_OFFSET(OSMutexQueue, 0x0, head);
WUT_CHECK_OFFSET(OSMutexQueue, 0x4, tail);
WUT_CHECK_OFFSET(OSMutexQueue, 0x8, parent);
WUT_CHECK_SIZE(OSMutexQueue, 0x10);

struct OSFastMutexQueue
{
   OSFastMutex *head;
   OSFastMutex *tail;
};
WUT_CHECK_OFFSET(OSFastMutexQueue, 0x00, head);
WUT_CHECK_OFFSET(OSFastMutexQueue, 0x04, tail);
WUT_CHECK_SIZE(OSFastMutexQueue, 0x08);

#define OS_THREAD_TAG 0x74487244u
#pragma pack(push, 1)
struct OSThread
{
   OSContext context;

   uint32_t tag;

   OSThreadState state;

   OSThreadAttributes attr;

   uint16_t id;

   int32_t suspendCounter;

   int32_t priority;

   int32_t basePriority;

   int32_t exitValue;

   WUT_UNKNOWN_BYTES(0x35C - 0x338);

   OSThreadQueue *queue;

   OSThreadLink link;

   OSThreadQueue joinQueue;

   OSMutex *mutex;

   OSMutexQueue mutexQueue;

   OSThreadLink activeLink;

   void *stackStart;

   void *stackEnd;

   OSThreadEntryPointFn entryPoint;

   WUT_UNKNOWN_BYTES(0x57c - 0x3a0);

   void *specific[0x10];

   WUT_UNKNOWN_BYTES(0x5c0 - 0x5bc);

   const char *name;

   WUT_UNKNOWN_BYTES(0x4);

   void *userStackPointer;

   OSThreadCleanupCallbackFn cleanupCallback;

   OSThreadDeallocatorFn deallocator;

   BOOL cancelState;

   OSThreadRequest requestFlag;

   int32_t needSuspend;

   int32_t suspendResult;

   OSThreadQueue suspendQueue;

   WUT_UNKNOWN_BYTES(0x6a0 - 0x5f4);
};
#pragma pack(pop)
WUT_CHECK_OFFSET(OSThread, 0x320, tag);
WUT_CHECK_OFFSET(OSThread, 0x324, state);
WUT_CHECK_OFFSET(OSThread, 0x325, attr);
WUT_CHECK_OFFSET(OSThread, 0x326, id);
WUT_CHECK_OFFSET(OSThread, 0x328, suspendCounter);
WUT_CHECK_OFFSET(OSThread, 0x32c, priority);
WUT_CHECK_OFFSET(OSThread, 0x330, basePriority);
WUT_CHECK_OFFSET(OSThread, 0x334, exitValue);
WUT_CHECK_OFFSET(OSThread, 0x35c, queue);
WUT_CHECK_OFFSET(OSThread, 0x360, link);
WUT_CHECK_OFFSET(OSThread, 0x368, joinQueue);
WUT_CHECK_OFFSET(OSThread, 0x378, mutex);
WUT_CHECK_OFFSET(OSThread, 0x37c, mutexQueue);
WUT_CHECK_OFFSET(OSThread, 0x38c, activeLink);
WUT_CHECK_OFFSET(OSThread, 0x394, stackStart);
WUT_CHECK_OFFSET(OSThread, 0x398, stackEnd);
WUT_CHECK_OFFSET(OSThread, 0x39c, entryPoint);
WUT_CHECK_OFFSET(OSThread, 0x57c, specific);
WUT_CHECK_OFFSET(OSThread, 0x5c0, name);
WUT_CHECK_OFFSET(OSThread, 0x5c8, userStackPointer);
WUT_CHECK_OFFSET(OSThread, 0x5cc, cleanupCallback);
WUT_CHECK_OFFSET(OSThread, 0x5d0, deallocator);
WUT_CHECK_OFFSET(OSThread, 0x5d4, cancelState);
WUT_CHECK_OFFSET(OSThread, 0x5d8, requestFlag);
WUT_CHECK_OFFSET(OSThread, 0x5dc, needSuspend);
WUT_CHECK_OFFSET(OSThread, 0x5e0, suspendResult);
WUT_CHECK_OFFSET(OSThread, 0x5e4, suspendQueue);
WUT_CHECK_SIZE(OSThread, 0x6a0);


void
OSCancelThread(OSThread *thread);


int32_t
OSCheckActiveThreads();


int32_t
OSCheckThreadStackUsage(OSThread *thread);


void
OSClearThreadStackUsage(OSThread *thread);


void
OSContinueThread(OSThread *thread);


BOOL
OSCreateThread(OSThread *thread,
               OSThreadEntryPointFn entry,
               int32_t argc,
               char *argv,
               void *stack,
               uint32_t stackSize,
               int32_t priority,
               OSThreadAttributes attributes);


void
OSDetachThread(OSThread *thread);


void
OSExitThread(int32_t result);


void
OSGetActiveThreadLink(OSThread *thread,
                      OSThreadLink *link);


OSThread *
OSGetCurrentThread();


OSThread *
OSGetDefaultThread(uint32_t coreID);


uint32_t
OSGetStackPointer();


uint32_t
OSGetThreadAffinity(OSThread *thread);


const char *
OSGetThreadName(OSThread *thread);


int32_t
OSGetThreadPriority(OSThread *thread);


void *
OSGetThreadSpecific(uint32_t id);


BOOL
OSIsThreadSuspended(OSThread *thread);


BOOL
OSIsThreadTerminated(OSThread *thread);


BOOL
OSJoinThread(OSThread *thread,
             int *threadResult);


int32_t
OSResumeThread(OSThread *thread);


BOOL
OSRunThread(OSThread *thread,
            OSThreadEntryPointFn entry,
            int argc,
            const char **argv);


BOOL
OSSetThreadAffinity(OSThread *thread,
                    uint32_t affinity);


BOOL
OSSetThreadCancelState(BOOL state);


OSThreadCleanupCallbackFn
OSSetThreadCleanupCallback(OSThread *thread,
                           OSThreadCleanupCallbackFn callback);


OSThreadDeallocatorFn
OSSetThreadDeallocator(OSThread *thread,
                       OSThreadDeallocatorFn deallocator);


void
OSSetThreadName(OSThread *thread,
                const char *name);


BOOL
OSSetThreadPriority(OSThread *thread,
                    int32_t priority);


BOOL
OSSetThreadRunQuantum(OSThread *thread,
                      uint32_t quantum);

void
OSSetThreadSpecific(uint32_t id,
                    void *value);


BOOL
OSSetThreadStackUsage(OSThread *thread);


void
OSSleepThread(OSThreadQueue *queue);


void
OSSleepTicks(OSTime ticks);


uint32_t
OSSuspendThread(OSThread *thread);


void
OSTestThreadCancel();


void
OSWakeupThread(OSThreadQueue *queue);


void
OSYieldThread();


#ifdef __cplusplus
}
#endif