include/psp2/kernel/threadmgr.h

Go to the documentation of this file.

#ifndef _PSP2_KERNEL_THREADMGR_H_
#define _PSP2_KERNEL_THREADMGR_H_

#include <psp2/types.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef SceUInt64 SceKernelSysClock;

/* Threads. */

typedef int (*SceKernelThreadEntry)(SceSize args, void *argp);

typedef struct SceKernelThreadOptParam {
    SceSize     size;
    SceUInt32       attr;
} SceKernelThreadOptParam;

typedef struct SceKernelThreadInfo {
    SceSize         size;
    SceUID          processId; //Needs confirmation
    char            name[32];
    SceUInt         attr;
    int             status;
    SceKernelThreadEntry entry;
    void            *stack;
    int             stackSize;
    int             initPriority;
    int             currentPriority;
    int             initCpuAffinityMask;
    int             currentCpuAffinityMask;
    int             currentCpuId;
    int             lastExecutedCpuId;
    int             waitType;
    SceUID          waitId;
    int             exitStatus;
    SceKernelSysClock runClocks;
    SceUInt     intrPreemptCount;
    SceUInt     threadPreemptCount;
    SceUInt     threadReleaseCount;
    SceUID      fNotifyCallback;
    int         reserved;
} SceKernelThreadInfo;

typedef struct SceKernelThreadRunStatus {
    SceSize        size;
    struct {
        SceUID processId;
        SceUID threadId;
        int    priority;
    } cpuInfo[4];
} SceKernelThreadRunStatus;

/* Sure there must be more than this, but haven't seen them */
typedef enum Psp2ThreadStatus
{
    PSP2_THREAD_RUNNING = 1,
    PSP2_THREAD_READY   = 2,
    PSP2_THREAD_WAITING = 4,
    PSP2_THREAD_SUSPEND = 8,
    PSP2_THREAD_STOPPED = 16,
    PSP2_THREAD_KILLED  = 32, /* Thread manager has killed the thread (stack overflow) */
} Psp2ThreadStatus;

SceUID sceKernelCreateThread(const char *name, SceKernelThreadEntry entry, int initPriority,
                             int stackSize, SceUInt attr, int cpuAffinityMask,
                             const SceKernelThreadOptParam *option);

int sceKernelDeleteThread(SceUID thid);

int sceKernelStartThread(SceUID thid, SceSize arglen, void *argp);

int sceKernelExitThread(int status);

int sceKernelExitDeleteThread(int status);

int sceKernelWaitThreadEnd(SceUID thid, int *stat, SceUInt *timeout);

int sceKernelWaitThreadEndCB(SceUID thid, int *stat, SceUInt *timeout);

int sceKernelDelayThread(SceUInt delay);

int sceKernelDelayThreadCB(SceUInt delay);

int sceKernelChangeCurrentThreadAttr(int unknown, SceUInt attr);

int sceKernelChangeThreadPriority(SceUID thid, int priority);

int sceKernelRotateThreadReadyQueue(int priority);

int sceKernelReleaseWaitThread(SceUID thid);

int sceKernelGetThreadId(void);

int sceKernelGetThreadCurrentPriority(void);

int sceKernelGetThreadExitStatus(SceUID thid);

int sceKernelCheckThreadStack(void);

int sceKernelGetThreadStackFreeSize(SceUID thid);

int sceKernelGetThreadInfo(SceUID thid, SceKernelThreadInfo *info);

int sceKernelGetThreadRunStatus(SceUID thid, SceKernelThreadRunStatus *status);


/* Semaphores. */

typedef struct SceKernelSemaOptParam {
    SceSize     size;
} SceKernelSemaOptParam;

typedef struct SceKernelSemaInfo {
    SceSize         size;
    SceUID          semaId;
    char            name[32];
    SceUInt         attr;
    int             initCount;
    int             currentCount;
    int             maxCount;
    int             numWaitThreads;
} SceKernelSemaInfo;

SceUID sceKernelCreateSema(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option);

int sceKernelDeleteSema(SceUID semaid);

int sceKernelSignalSema(SceUID semaid, int signal);

int sceKernelWaitSema(SceUID semaid, int signal, SceUInt *timeout);

int sceKernelWaitSemaCB(SceUID semaid, int signal, SceUInt *timeout);

int sceKernelPollSema(SceUID semaid, int signal);

int sceKernelCancelSema(SceUID semaid, int setCount, int *numWaitThreads);

int sceKernelGetSemaInfo(SceUID semaid, SceKernelSemaInfo *info);


/* Mutexes. */

typedef struct SceKernelMutexOptParam {
    SceSize     size;
    int             ceilingPriority;
} SceKernelMutexOptParam;

typedef struct SceKernelMutexInfo {
    SceSize         size;
    SceUID          mutexId;
    char            name[32];
    SceUInt         attr;
    int             initCount;
    int             currentCount;
    SceUID          currentOwnerId;
    int             numWaitThreads;
} SceKernelMutexInfo;

SceUID sceKernelCreateMutex(const char *name, SceUInt attr, int initCount, SceKernelMutexOptParam *option);

int sceKernelDeleteMutex(SceUID mutexid);

int sceKernelOpenMutex(const char *name);

int sceKernelCloseMutex(SceUID mutexid);

int sceKernelLockMutex(SceUID mutexid, int lockCount, unsigned int *timeout);

int sceKernelLockMutexCB(SceUID mutexid, int lockCount, unsigned int *timeout);

int sceKernelTryLockMutex(SceUID mutexid, int lockCount);

int sceKernelUnlockMutex(SceUID mutexid, int unlockCount);

int sceKernelCancelMutex(SceUID mutexid, int newCount, int *numWaitThreads);

int sceKernelGetMutexInfo(SceUID mutexid, SceKernelMutexInfo info);


/* Event flags. */

typedef struct SceKernelEventFlagInfo {
    SceSize     size;
    SceUID          evfId; // Needs confirmation
    char        name[32];
    SceUInt     attr;
    SceUInt     initPattern;
    SceUInt     currentPattern;
    int         numWaitThreads;
} SceKernelEventFlagInfo;

typedef struct SceKernelEventFlagOptParam {
    SceSize         size;
} SceKernelEventFlagOptParam;

typedef struct SceKernelEventFlagOptParam SceKernelEventFlagOptParam;

typedef enum Psp2EventFlagAttributes {
    PSP2_EVENT_WAITMULTIPLE = 0x200
} Psp2EventFlagAttributes;

typedef enum Psp2EventFlagWaitTypes {
    PSP2_EVENT_WAITAND = 0,
    PSP2_EVENT_WAITOR  = 1,
    PSP2_EVENT_WAITCLEAR = 0x20
} Psp2EventFlagWaitTypes;

SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt);

int sceKernelSetEventFlag(SceUID evid, unsigned int bits);

int sceKernelClearEventFlag(SceUID evid, unsigned int bits);

int sceKernelPollEventFlag(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits);

int sceKernelWaitEventFlag(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits, SceUInt *timeout);

int sceKernelWaitEventFlagCB(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits, SceUInt *timeout);

int sceKernelDeleteEventFlag(int evid);

int sceKernelGetEventFlagInfo(SceUID event, SceKernelEventFlagInfo *info);


/* Callbacks. */

typedef int (*SceKernelCallbackFunction)(int notifyId, int notifyCount, int notifyArg, void *common);

typedef struct SceKernelCallbackInfo {
    SceSize size;
    SceUID  callbackId; // Needs confirmation
    char    name[32];
    SceUID  threadId;
    SceKernelCallbackFunction callback;
    void    *common;
    int     notifyCount;
    int     notifyArg;
} SceKernelCallbackInfo;

int sceKernelCreateCallback(const char *name, unsigned int attr, SceKernelCallbackFunction func, void *arg);

int sceKernelGetCallbackInfo(SceUID cb, SceKernelCallbackInfo *infop);

int sceKernelDeleteCallback(SceUID cb);

int sceKernelNotifyCallback(SceUID cb, int arg2);

int sceKernelCancelCallback(SceUID cb);

int sceKernelGetCallbackCount(SceUID cb);

int sceKernelCheckCallback(void);


/* Message pipes */

SceUID sceKernelCreateMsgPipe(const char *name, int part, int attr, void *unk1, void *opt);

int sceKernelDeleteMsgPipe(SceUID uid);

int sceKernelSendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelSendMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelTrySendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);

int sceKernelReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelReceiveMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelTryReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);

int sceKernelCancelMsgPipe(SceUID uid, int *psend, int *precv);

typedef struct SceKernelMppInfo {
    SceSize size;
    SceUID  mppId; // Needs confirmation
    char    name[32];
    SceUInt attr;
    int     bufSize;
    int     freeSize;
    int     numSendWaitThreads;
    int     numReceiveWaitThreads;
} SceKernelMppInfo;

int sceKernelGetMsgPipeInfo(SceUID uid, SceKernelMppInfo *info);


/* Misc. */

typedef struct SceKernelSystemInfo {
    SceSize   size;
    SceUInt32 activeCpuMask;

    struct {
        SceKernelSysClock idleClock;
        SceUInt32         comesOutOfIdleCount;
        SceUInt32         threadSwitchCount;
    } cpuInfo[4];
} SceKernelSystemInfo;

int sceKernelGetSystemInfo(SceKernelSystemInfo *info);

/* Misc. */

typedef enum SceKernelIdListType {
    SCE_KERNEL_TMID_Thread = 1,
    SCE_KERNEL_TMID_Semaphore = 2,
    SCE_KERNEL_TMID_EventFlag = 3,
    SCE_KERNEL_TMID_Mbox = 4,
    SCE_KERNEL_TMID_Vpl = 5,
    SCE_KERNEL_TMID_Fpl = 6,
    SCE_KERNEL_TMID_Mpipe = 7,
    SCE_KERNEL_TMID_Callback = 8,
    SCE_KERNEL_TMID_ThreadEventHandler = 9,
    SCE_KERNEL_TMID_Alarm = 10,
    SCE_KERNEL_TMID_VTimer = 11,
    SCE_KERNEL_TMID_SleepThread = 64,
    SCE_KERNEL_TMID_DelayThread = 65,
    SCE_KERNEL_TMID_SuspendThread = 66,
    SCE_KERNEL_TMID_DormantThread = 67,
} SceKernelIdListType;

SceKernelIdListType sceKernelGetThreadmgrUIDClass(SceUID uid);

#ifdef __cplusplus
}
#endif

#endif /* _PSP2_KERNEL_THREADMGR_H_ */