pspthreadman.h

Go to the documentation of this file.

/*
 * PSP Software Development Kit - https://github.com/pspdev
 * -----------------------------------------------------------------------
 * Licensed under the BSD license, see LICENSE in PSPSDK root for details.
 *
 * pspthreadman.h - Library imports for the kernel threading library.
 *
 * Copyright (c) 2005 Marcus R. Brown <mrbrown@ocgnet.org>
 * Copyright (c) 2005 James Forshaw <tyranid@gmail.com>
 * Copyright (c) 2005 John Kelley <ps2dev@kelley.ca>
 * Copyright (c) 2005 Florin Sasu
 *
 */
#ifndef __THREADMAN_H__
#define __THREADMAN_H__
 
#include <psptypes.h>
#include <pspkerneltypes.h>
/* Include for profile register definitions */
#include <pspdebug.h>
 
/* Note: Some of the structures, types, and definitions in this file were
   extrapolated from symbolic debugging information found in the Japanese
   version of Puzzle Bobble. */
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct SceKernelSysClock {
        SceUInt32   low;
        SceUInt32   hi;
} SceKernelSysClock;
 
enum PspThreadAttributes
{
        PSP_THREAD_ATTR_VFPU = 0x00004000,
        PSP_THREAD_ATTR_USER = 0x80000000,
        PSP_THREAD_ATTR_USBWLAN = 0xa0000000,
        PSP_THREAD_ATTR_VSH = 0xc0000000,
        PSP_THREAD_ATTR_SCRATCH_SRAM = 0x00008000,
        PSP_THREAD_ATTR_NO_FILLSTACK = 0x00100000,
        PSP_THREAD_ATTR_CLEAR_STACK = 0x00200000,
};
 
/* Maintained for compatibility with older versions of PSPSDK. */
#define THREAD_ATTR_VFPU PSP_THREAD_ATTR_VFPU
#define THREAD_ATTR_USER PSP_THREAD_ATTR_USER
 
 
/* Threads. */
 
typedef int (*SceKernelThreadEntry)(SceSize args, void *argp);
 
typedef struct SceKernelThreadOptParam {
        SceSize         size;
        SceUID          stackMpid;
} SceKernelThreadOptParam;
 
typedef struct SceKernelThreadInfo {
        SceSize     size;
        char            name[32];
        SceUInt     attr;
        int             status;
        SceKernelThreadEntry    entry;
        void *          stack;
        int             stackSize;
        void *          gpReg;
        int             initPriority;
        int             currentPriority;
        int             waitType;
        SceUID          waitId;
        int             wakeupCount;
        int             exitStatus;
        SceKernelSysClock   runClocks;
        SceUInt     intrPreemptCount;
        SceUInt     threadPreemptCount;
        SceUInt     releaseCount;
} SceKernelThreadInfo;
 
typedef struct SceKernelThreadRunStatus {
        SceSize         size;
        int             status;
        int             currentPriority;
        int             waitType;
        int             waitId;
        int             wakeupCount;
        SceKernelSysClock runClocks;
        SceUInt         intrPreemptCount;
        SceUInt         threadPreemptCount;
        SceUInt         releaseCount;
} SceKernelThreadRunStatus;
 
/* Sure there must be more than this, but haven't seen them */
enum PspThreadStatus
{
        PSP_THREAD_RUNNING = 1,
        PSP_THREAD_READY   = 2,
        PSP_THREAD_WAITING = 4,
        PSP_THREAD_SUSPEND = 8,
        PSP_THREAD_STOPPED = 16,
        PSP_THREAD_KILLED  = 32, /* Thread manager has killed the thread (stack overflow) */
};
 
SceUID sceKernelCreateThread(const char *name, SceKernelThreadEntry entry, int initPriority,
                             int stackSize, SceUInt attr, SceKernelThreadOptParam *option);
 
int sceKernelDeleteThread(SceUID thid);
 
int sceKernelStartThread(SceUID thid, SceSize arglen, void *argp);
 
int sceKernelExitThread(int status);
 
int sceKernelExitDeleteThread(int status);
 
int sceKernelTerminateThread(SceUID thid);
 
int sceKernelTerminateDeleteThread(SceUID thid);
 
int sceKernelSuspendDispatchThread(void);
 
int sceKernelResumeDispatchThread(int state);
 
int sceKernelSleepThread(void);
 
int sceKernelSleepThreadCB(void);
 
int sceKernelWakeupThread(SceUID thid);
 
int sceKernelCancelWakeupThread(SceUID thid);
 
int sceKernelSuspendThread(SceUID thid);
 
int sceKernelResumeThread(SceUID thid);
 
int sceKernelWaitThreadEnd(SceUID thid, SceUInt *timeout);
 
int sceKernelWaitThreadEndCB(SceUID thid, SceUInt *timeout);
 
int sceKernelDelayThread(SceUInt delay);
 
int sceKernelDelayThreadCB(SceUInt delay);
 
int sceKernelDelaySysClockThread(SceKernelSysClock *delay);
 
int sceKernelDelaySysClockThreadCB(SceKernelSysClock *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 sceKernelReferThreadStatus(SceUID thid, SceKernelThreadInfo *info);
 
int sceKernelReferThreadRunStatus(SceUID thid, SceKernelThreadRunStatus *status);
 
 
/* Semaphores. */
 
typedef struct SceKernelSemaOptParam {
        SceSize         size;
} SceKernelSemaOptParam;
 
typedef struct SceKernelSemaInfo {
        SceSize         size;
        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 sceKernelReferSemaStatus(SceUID semaid, SceKernelSemaInfo *info);
 
enum PspLwMutexAttributes
{
        PSP_LW_MUTEX_ATTR_THFIFO = 0x0000U,
        PSP_LW_MUTEX_ATTR_THPRI = 0x0100U,
        PSP_LW_MUTEX_ATTR_RECURSIVE = 0x0200U
};
 
typedef struct {
    int lockLevel;
    SceUID lockThread;
    int attr;
    int numWaitThreads;
    SceUID uid;
    int pad[3];
} SceLwMutexWorkarea;
 
int sceKernelCreateLwMutex(SceLwMutexWorkarea *workarea, const char *name, SceUInt32 attr, int initialCount, u32 *optionsPtr);
 
int sceKernelDeleteLwMutex(SceLwMutexWorkarea *workarea);
 
int sceKernelTryLockLwMutex(SceLwMutexWorkarea *workarea, int lockCount);
 
int sceKernelLockLwMutex(SceLwMutexWorkarea *workarea, int lockCount, unsigned int *pTimeout);
 
int sceKernelUnlockLwMutex(SceLwMutexWorkarea *workarea, int lockCount);
 
/* Event flags. */
 
typedef struct SceKernelEventFlagInfo {
        SceSize         size;
        char            name[32];
        SceUInt         attr;
        SceUInt         initPattern;
        SceUInt         currentPattern;
        int             numWaitThreads;
} SceKernelEventFlagInfo;
 
struct SceKernelEventFlagOptParam {
        SceSize         size;
};
 
typedef struct SceKernelEventFlagOptParam SceKernelEventFlagOptParam;
 
enum PspEventFlagAttributes
{
        PSP_EVENT_WAITMULTIPLE = 0x200
};
 
enum PspEventFlagWaitTypes
{
        PSP_EVENT_WAITAND = 0,
        PSP_EVENT_WAITOR  = 1,
        PSP_EVENT_WAITCLEAR = 0x20
};
 
SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt);
 
int sceKernelSetEventFlag(SceUID evid, u32 bits);
 
int sceKernelClearEventFlag(SceUID evid, u32 bits);
 
int sceKernelPollEventFlag(int evid, u32 bits, u32 wait, u32 *outBits);
 
int sceKernelWaitEventFlag(int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout);
 
int sceKernelWaitEventFlagCB(int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout);
 
int sceKernelDeleteEventFlag(int evid);
 
int sceKernelReferEventFlagStatus(SceUID event, SceKernelEventFlagInfo *status);
 
 
/* Message boxes. */
 
typedef struct SceKernelMbxOptParam {
        SceSize         size;
} SceKernelMbxOptParam;
 
typedef struct SceKernelMbxInfo {
        SceSize         size;
        char            name[32];
        SceUInt         attr;
        int             numWaitThreads;
        int             numMessages;
        void            *firstMessage;
} SceKernelMbxInfo;
 
typedef struct SceKernelMsgPacket {
        struct SceKernelMsgPacket *next;
        SceUChar    msgPriority;
        SceUChar    dummy[3];
} SceKernelMsgPacket;
 
SceUID sceKernelCreateMbx(const char *name, SceUInt attr, SceKernelMbxOptParam *option);
 
int sceKernelDeleteMbx(SceUID mbxid);
 
int sceKernelSendMbx(SceUID mbxid, void *message);
 
int sceKernelReceiveMbx(SceUID mbxid, void **pmessage, SceUInt *timeout);
 
int sceKernelReceiveMbxCB(SceUID mbxid, void **pmessage, SceUInt *timeout);
 
int sceKernelPollMbx(SceUID mbxid, void **pmessage);
 
int sceKernelCancelReceiveMbx(SceUID mbxid, int *pnum);
 
int sceKernelReferMbxStatus(SceUID mbxid, SceKernelMbxInfo *info);
 
 
/* Alarms. */
 
typedef SceUInt (*SceKernelAlarmHandler)(void *common);
 
typedef struct SceKernelAlarmInfo {
        SceSize         size;
        /* The current schedule */
        SceKernelSysClock schedule;
        SceKernelAlarmHandler handler;
        void *          common;
} SceKernelAlarmInfo;
 
SceUID sceKernelSetAlarm(SceUInt clock, SceKernelAlarmHandler handler, void *common);
 
SceUID sceKernelSetSysClockAlarm(SceKernelSysClock *clock, SceKernelAlarmHandler handler, void *common);
 
int sceKernelCancelAlarm(SceUID alarmid);
 
int sceKernelReferAlarmStatus(SceUID alarmid, SceKernelAlarmInfo *info);
 
/* Callbacks. */
 
typedef int (*SceKernelCallbackFunction)(int arg1, int arg2, void *arg);
 
typedef struct SceKernelCallbackInfo {
        SceSize         size;
        char    name[32];
        SceUID  threadId;
        SceKernelCallbackFunction       callback;
        void *  common;
        int     notifyCount;
        int     notifyArg;
} SceKernelCallbackInfo;
 
int sceKernelCreateCallback(const char *name, SceKernelCallbackFunction func, void *arg);
 
int sceKernelReferCallbackStatus(SceUID cb, SceKernelCallbackInfo *status);
 
int sceKernelDeleteCallback(SceUID cb);
 
int sceKernelNotifyCallback(SceUID cb, int arg2);
 
int sceKernelCancelCallback(SceUID cb);
 
int sceKernelGetCallbackCount(SceUID cb);
 
int sceKernelCheckCallback(void);
 
/* Misc. */
 
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,
};
 
int sceKernelGetThreadmanIdList(enum SceKernelIdListType type, SceUID *readbuf, int readbufsize, int *idcount);
 
typedef struct SceKernelSystemStatus {
        SceSize         size;
        SceUInt         status;
        SceKernelSysClock       idleClocks;
        SceUInt         comesOutOfIdleCount;
        SceUInt         threadSwitchCount;
        SceUInt         vfpuSwitchCount;
} SceKernelSystemStatus;
 
int sceKernelReferSystemStatus(SceKernelSystemStatus *status);
 
 
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;
        char    name[32];
        SceUInt         attr;
        int     bufSize;
        int     freeSize;
        int     numSendWaitThreads;
        int     numReceiveWaitThreads;
} SceKernelMppInfo;
 
int sceKernelReferMsgPipeStatus(SceUID uid, SceKernelMppInfo *info);
 
/* VPL Functions */
 
struct SceKernelVplOptParam {
        SceSize         size;
};
 
SceUID sceKernelCreateVpl(const char *name, int part, int attr, unsigned int size, struct SceKernelVplOptParam *opt);
 
int sceKernelDeleteVpl(SceUID uid);
 
int sceKernelAllocateVpl(SceUID uid, unsigned int size, void **data, unsigned int *timeout);
 
int sceKernelAllocateVplCB(SceUID uid, unsigned int size, void **data, unsigned int *timeout);
 
int sceKernelTryAllocateVpl(SceUID uid, unsigned int size, void **data);
 
int sceKernelFreeVpl(SceUID uid, void *data);
 
int sceKernelCancelVpl(SceUID uid, int *pnum);
 
typedef struct SceKernelVplInfo {
        SceSize         size;
        char    name[32];
        SceUInt         attr;
        int     poolSize;
        int     freeSize;
        int     numWaitThreads;
} SceKernelVplInfo;
 
int sceKernelReferVplStatus(SceUID uid, SceKernelVplInfo *info);
 
/* FPL Functions */
 
struct SceKernelFplOptParam {
        SceSize         size;
};
 
int sceKernelCreateFpl(const char *name, int part, int attr, unsigned int size, unsigned int blocks, struct SceKernelFplOptParam *opt);
 
int sceKernelDeleteFpl(SceUID uid);
 
int sceKernelAllocateFpl(SceUID uid, void **data, unsigned int *timeout);
 
int sceKernelAllocateFplCB(SceUID uid, void **data, unsigned int *timeout);
 
int sceKernelTryAllocateFpl(SceUID uid, void **data);
 
int sceKernelFreeFpl(SceUID uid, void *data);
 
int sceKernelCancelFpl(SceUID uid, int *pnum);
 
typedef struct SceKernelFplInfo {
        SceSize         size;
        char    name[32];
        SceUInt         attr;
        int     blockSize;
        int     numBlocks;
        int     freeBlocks;
        int     numWaitThreads;
} SceKernelFplInfo;
 
int sceKernelReferFplStatus(SceUID uid, SceKernelFplInfo *info);
 
void _sceKernelReturnFromTimerHandler(void);
 
void _sceKernelReturnFromCallback(void);
 
int sceKernelUSec2SysClock(unsigned int usec, SceKernelSysClock *clock);
 
SceInt64 sceKernelUSec2SysClockWide(unsigned int usec);
 
int sceKernelSysClock2USec(SceKernelSysClock *clock, unsigned int *low, unsigned int *high);
 
int sceKernelSysClock2USecWide(SceInt64 clock, unsigned *low, unsigned int *high);
 
int sceKernelGetSystemTime(SceKernelSysClock *time);
 
SceInt64 sceKernelGetSystemTimeWide(void);
 
unsigned int sceKernelGetSystemTimeLow(void);
 
struct SceKernelVTimerOptParam {
        SceSize         size;
};
 
SceUID sceKernelCreateVTimer(const char *name, struct SceKernelVTimerOptParam *opt);
 
int sceKernelDeleteVTimer(SceUID uid);
 
int sceKernelGetVTimerBase(SceUID uid, SceKernelSysClock *base);
 
SceInt64 sceKernelGetVTimerBaseWide(SceUID uid);
 
int sceKernelGetVTimerTime(SceUID uid, SceKernelSysClock *time);
 
SceInt64 sceKernelGetVTimerTimeWide(SceUID uid);
 
int sceKernelSetVTimerTime(SceUID uid, SceKernelSysClock *time);
 
SceInt64 sceKernelSetVTimerTimeWide(SceUID uid, SceInt64 time);
 
int sceKernelStartVTimer(SceUID uid);
 
int sceKernelStopVTimer(SceUID uid);
 
typedef SceUInt (*SceKernelVTimerHandler)(SceUID uid, SceKernelSysClock *, SceKernelSysClock *, void *);
typedef SceUInt (*SceKernelVTimerHandlerWide)(SceUID uid, SceInt64, SceInt64, void *);
 
int sceKernelSetVTimerHandler(SceUID uid, SceKernelSysClock *time, SceKernelVTimerHandler handler, void *common);
 
int sceKernelSetVTimerHandlerWide(SceUID uid, SceInt64 time, SceKernelVTimerHandlerWide handler, void *common);
 
int sceKernelCancelVTimerHandler(SceUID uid);
 
typedef struct SceKernelVTimerInfo {
        SceSize         size;
        char    name[32];
        int     active;
        SceKernelSysClock       base;
        SceKernelSysClock       current;
        SceKernelSysClock       schedule;
        SceKernelVTimerHandler  handler;
        void *  common;
} SceKernelVTimerInfo;
 
int sceKernelReferVTimerStatus(SceUID uid, SceKernelVTimerInfo *info);
 
void _sceKernelExitThread(void);
 
enum SceKernelIdListType sceKernelGetThreadmanIdType(SceUID uid);
 
typedef int (*SceKernelThreadEventHandler)(int mask, SceUID thid, void *common);
 
typedef struct SceKernelThreadEventHandlerInfo {
        SceSize         size;
        char    name[32];
        SceUID  threadId;
        int     mask;
        SceKernelThreadEventHandler     handler;
        void *  common;
} SceKernelThreadEventHandlerInfo;
 
enum ThreadEventIds
{
        THREADEVENT_ALL = 0xFFFFFFFF,
        THREADEVENT_KERN = 0xFFFFFFF8,
        THREADEVENT_USER = 0xFFFFFFF0,
        THREADEVENT_CURRENT = 0
};
 
enum ThreadEvents
{
        THREAD_CREATE = 1,
        THREAD_START  = 2,
        THREAD_EXIT   = 4,
        THREAD_DELETE = 8,
};
 
SceUID sceKernelRegisterThreadEventHandler(const char *name, SceUID threadID, int mask, SceKernelThreadEventHandler handler, void *common);
 
int sceKernelReleaseThreadEventHandler(SceUID uid);
 
int sceKernelReferThreadEventHandlerStatus(SceUID uid, struct SceKernelThreadEventHandlerInfo *info);
 
PspDebugProfilerRegs *sceKernelReferThreadProfiler(void);
 
PspDebugProfilerRegs *sceKernelReferGlobalProfiler(void);
 
#ifdef __cplusplus
}
#endif
 
#endif