thread.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <time.h>
#include "alarm.h"
#include "context.h"
#include "time.h"
#include "threadqueue.h"
#include "exception.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 struct OSTLSSection OSTLSSection;
typedef struct OSThreadGHSExceptionHandling OSThreadGHSExceptionHandling;
 
typedef uint8_t OSThreadState;
 
typedef uint32_t OSThreadRequest;
 
typedef uint8_t OSThreadAttributes;
 
typedef uint32_t OSThreadType;
 
typedef int (*OSThreadEntryPointFn)(int argc, const char **argv);
typedef void (*OSThreadCleanupCallbackFn)(OSThread *thread, void *stack);
typedef void (*OSThreadDeallocatorFn)(OSThread *thread, void *stack);
 
typedef enum OSThreadSpecificID
{
   OS_THREAD_SPECIFIC_0                = 0,
   OS_THREAD_SPECIFIC_1                = 1,
   OS_THREAD_SPECIFIC_2                = 2,
   OS_THREAD_SPECIFIC_3                = 3,
   OS_THREAD_SPECIFIC_4                = 4,
   OS_THREAD_SPECIFIC_5                = 5,
   OS_THREAD_SPECIFIC_6                = 6,
   OS_THREAD_SPECIFIC_7                = 7,
   OS_THREAD_SPECIFIC_8                = 8,
   OS_THREAD_SPECIFIC_9                = 9,
   OS_THREAD_SPECIFIC_10               = 10,
   OS_THREAD_SPECIFIC_11               = 11,
   OS_THREAD_SPECIFIC_12               = 12,
   OS_THREAD_SPECIFIC_13               = 13,
   OS_THREAD_SPECIFIC_WUT_RESERVED_0   = 14,
   OS_THREAD_SPECIFIC_WUT_RESERVED_1   = 15,
} OSThreadSpecificID;
 
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,
 
   OS_THREAD_ATTRIB_UNKNOWN         = 1 << 7
};
 
enum OS_THREAD_TYPE {
   OS_THREAD_TYPE_DRIVER = 0,
   OS_THREAD_TYPE_IO     = 1,
   OS_THREAD_TYPE_APP    = 2
};
 
struct WUT_PACKED OSThreadGHSExceptionHandling
{
   WUT_UNKNOWN_BYTES(0x68);
   void *eh_globals;
   void *eh_mem_manage[9];
   void *eh_store_globals[6];
   void *eh_store_globals_tdeh[76];
};
WUT_CHECK_OFFSET(OSThreadGHSExceptionHandling, 0x68, eh_globals);
WUT_CHECK_OFFSET(OSThreadGHSExceptionHandling, 0x6c, eh_mem_manage);
WUT_CHECK_OFFSET(OSThreadGHSExceptionHandling, 0x90, eh_store_globals);
WUT_CHECK_OFFSET(OSThreadGHSExceptionHandling, 0xa8, eh_store_globals_tdeh);
WUT_CHECK_SIZE(OSThreadGHSExceptionHandling, 0x1d8);
 
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);
 
struct OSTLSSection
{
   void* data;
   WUT_UNKNOWN_BYTES(4);
};
WUT_CHECK_OFFSET(OSTLSSection, 0x00, data);
WUT_CHECK_SIZE(OSTLSSection, 0x08);
 
#define OS_THREAD_TAG 0x74487244u
#pragma pack(push, 1)
struct WUT_ALIGNAS(8) 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;
 
   OSThreadQueue *coreRunQueue[3];
   OSThreadLink coreRunQueueLink[3];
 
   OSThreadQueue *queue;
 
   OSThreadLink link;
 
   OSThreadQueue joinQueue;
 
   OSMutex *mutex;
 
   OSMutexQueue mutexQueue;
 
   OSThreadLink activeLink;
 
   void *stackStart;
 
   void *stackEnd;
 
   OSThreadEntryPointFn entryPoint;
 
   OSThreadGHSExceptionHandling ghsExceptionHandling;
 
   BOOL alarmCancelled;
 
   void *specific[0x10];
 
   OSThreadType type;
 
   const char *name;
 
   OSAlarm *waitEventTimeoutAlarm;
 
   void *userStackPointer;
 
   OSThreadCleanupCallbackFn cleanupCallback;
 
   OSThreadDeallocatorFn deallocator;
 
   BOOL cancelState;
 
   OSThreadRequest requestFlag;
 
   int32_t needSuspend;
 
   int32_t suspendResult;
 
   OSThreadQueue suspendQueue;
 
   WUT_UNKNOWN_BYTES(0x4);
 
   int64_t runQuantumTicks;
 
   uint64_t coreTimeConsumedNs;
 
   uint64_t wakeCount;
 
   OSTime unk0x610;
   OSTime unk0x618;
   OSTime unk0x620;
   OSTime unk0x628;
 
   OSExceptionCallbackFn dsiCallback[3];
   OSExceptionCallbackFn isiCallback[3];
   OSExceptionCallbackFn programCallback[3];
   OSExceptionCallbackFn perfMonCallback[3];
 
   BOOL stackSyncObjAllowed;
 
   uint16_t tlsSectionCount;
 
   WUT_UNKNOWN_BYTES(0x2);
 
   OSTLSSection* tlsSections;
 
   OSFastMutex* fastMutex;
 
   OSFastMutexQueue contendedFastMutexes;
 
   OSFastMutexQueue fastMutexQueue;
 
   OSExceptionCallbackFn alignCallback[3];
 
   uint32_t reserved[5];
};
#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, 0x338, coreRunQueue);
WUT_CHECK_OFFSET(OSThread, 0x344, coreRunQueueLink);
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, 0x3a0, ghsExceptionHandling);
WUT_CHECK_OFFSET(OSThread, 0x57c, specific);
WUT_CHECK_OFFSET(OSThread, 0x5bc, type);
WUT_CHECK_OFFSET(OSThread, 0x5c0, name);
WUT_CHECK_OFFSET(OSThread, 0x5c4, waitEventTimeoutAlarm);
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_OFFSET(OSThread, 0x5f8, runQuantumTicks);
WUT_CHECK_OFFSET(OSThread, 0x600, coreTimeConsumedNs);
WUT_CHECK_OFFSET(OSThread, 0x608, wakeCount);
WUT_CHECK_OFFSET(OSThread, 0x610, unk0x610);
WUT_CHECK_OFFSET(OSThread, 0x618, unk0x618);
WUT_CHECK_OFFSET(OSThread, 0x620, unk0x620);
WUT_CHECK_OFFSET(OSThread, 0x628, unk0x628);
WUT_CHECK_OFFSET(OSThread, 0x630, dsiCallback);
WUT_CHECK_OFFSET(OSThread, 0x63c, isiCallback);
WUT_CHECK_OFFSET(OSThread, 0x648, programCallback);
WUT_CHECK_OFFSET(OSThread, 0x654, perfMonCallback);
WUT_CHECK_OFFSET(OSThread, 0x664, tlsSectionCount);
WUT_CHECK_OFFSET(OSThread, 0x668, tlsSections);
WUT_CHECK_OFFSET(OSThread, 0x66c, fastMutex);
WUT_CHECK_OFFSET(OSThread, 0x670, contendedFastMutexes);
WUT_CHECK_OFFSET(OSThread, 0x678, fastMutexQueue);
WUT_CHECK_OFFSET(OSThread, 0x680, alignCallback);
WUT_CHECK_OFFSET(OSThread, 0x68c, reserved);
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(OSThreadSpecificID 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(OSThreadSpecificID id,
                    void *value);
 
 
BOOL
OSSetThreadStackUsage(OSThread *thread);
 
 
void
OSSleepThread(OSThreadQueue *queue);
 
 
void
OSSleepTicks(OSTime ticks);
 
 
uint32_t
OSSuspendThread(OSThread *thread);
 
void
__OSSuspendThreadNolock(OSThread *thread);
 
void
OSTestThreadCancel();
 
 
void
OSWakeupThread(OSThreadQueue *queue);
 
 
void
OSYieldThread();
 
 
#ifdef __cplusplus
}
#endif