Data Structures | Defines | Typedefs | Enumerations | Functions

Thread Manager Library

Library imports for the kernel threading library. More...

Data Structures

struct  SceKernelSysClock
 64-bit system clock type. More...
struct  SceKernelThreadOptParam
 Additional options used when creating threads. More...
struct  SceKernelThreadInfo
 Structure to hold the status information for a thread. More...
struct  SceKernelThreadRunStatus
 Statistics about a running thread. More...
struct  SceKernelSemaOptParam
 Additional options used when creating semaphores. More...
struct  SceKernelSemaInfo
 Current state of a semaphore. More...
struct  SceKernelEventFlagInfo
 Structure to hold the event flag information. More...
struct  SceKernelEventFlagOptParam
struct  SceKernelMbxOptParam
 Additional options used when creating messageboxes. More...
struct  SceKernelMbxInfo
 Current state of a messagebox. More...
struct  SceKernelMsgPacket
 Header for a message box packet. More...
struct  SceKernelAlarmInfo
 Struct containing alarm info. More...
struct  SceKernelCallbackInfo
 Structure to hold the status information for a callback. More...
struct  SceKernelSystemStatus
 Structure to contain the system status returned by sceKernelReferSystemStatus. More...
struct  SceKernelMppInfo
 Message Pipe status info. More...
struct  SceKernelVplOptParam
struct  SceKernelVplInfo
 Variable pool status info. More...
struct  SceKernelFplOptParam
struct  SceKernelFplInfo
 Fixed pool status information. More...
struct  SceKernelVTimerOptParam
struct  SceKernelVTimerInfo
struct  SceKernelThreadEventHandlerInfo
 Struct for event handler info. More...

Defines

#define THREAD_ATTR_VFPU   PSP_THREAD_ATTR_VFPU
#define THREAD_ATTR_USER   PSP_THREAD_ATTR_USER

Typedefs

typedef struct SceKernelSysClock SceKernelSysClock
 64-bit system clock type.
typedef int(* SceKernelThreadEntry )(SceSize args, void *argp)
typedef struct
SceKernelThreadOptParam 
SceKernelThreadOptParam
 Additional options used when creating threads.
typedef struct SceKernelThreadInfo SceKernelThreadInfo
 Structure to hold the status information for a thread.
typedef struct
SceKernelThreadRunStatus 
SceKernelThreadRunStatus
 Statistics about a running thread.
typedef struct
SceKernelSemaOptParam 
SceKernelSemaOptParam
 Additional options used when creating semaphores.
typedef struct SceKernelSemaInfo SceKernelSemaInfo
 Current state of a semaphore.
typedef struct
SceKernelEventFlagInfo 
SceKernelEventFlagInfo
 Structure to hold the event flag information.
typedef struct
SceKernelEventFlagOptParam 
SceKernelEventFlagOptParam
typedef struct SceKernelMbxOptParam SceKernelMbxOptParam
 Additional options used when creating messageboxes.
typedef struct SceKernelMbxInfo SceKernelMbxInfo
 Current state of a messagebox.
typedef struct SceKernelMsgPacket SceKernelMsgPacket
 Header for a message box packet.
typedef SceUInt(* SceKernelAlarmHandler )(void *common)
 Prototype for alarm handlers.
typedef struct SceKernelAlarmInfo SceKernelAlarmInfo
 Struct containing alarm info.
typedef int(* SceKernelCallbackFunction )(int arg1, int arg2, void *arg)
 Callback function prototype.
typedef struct
SceKernelCallbackInfo 
SceKernelCallbackInfo
 Structure to hold the status information for a callback.
typedef struct
SceKernelSystemStatus 
SceKernelSystemStatus
 Structure to contain the system status returned by sceKernelReferSystemStatus.
typedef struct SceKernelMppInfo SceKernelMppInfo
 Message Pipe status info.
typedef struct SceKernelVplInfo SceKernelVplInfo
 Variable pool status info.
typedef struct SceKernelFplInfo SceKernelFplInfo
 Fixed pool status information.
typedef SceUInt(* SceKernelVTimerHandler )(SceUID uid, SceKernelSysClock *, SceKernelSysClock *, void *)
typedef SceUInt(* SceKernelVTimerHandlerWide )(SceUID uid, SceInt64, SceInt64, void *)
typedef struct SceKernelVTimerInfo SceKernelVTimerInfo
typedef int(* SceKernelThreadEventHandler )(int mask, SceUID thid, void *common)
typedef struct
SceKernelThreadEventHandlerInfo 
SceKernelThreadEventHandlerInfo
 Struct for event handler info.

Enumerations

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
}
 

Attribute for threads.

More...
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
}
enum  PspEventFlagAttributes { PSP_EVENT_WAITMULTIPLE = 0x200 }
 

Event flag creation attributes.

More...
enum  PspEventFlagWaitTypes { PSP_EVENT_WAITAND = 0, PSP_EVENT_WAITOR = 1, PSP_EVENT_WAITCLEAR = 0x20 }
 

Event flag wait types.

More...
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
}
 

Threadman types for sceKernelGetThreadmanIdList.

More...
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 }

Functions

SceUID sceKernelCreateThread (const char *name, SceKernelThreadEntry entry, int initPriority, int stackSize, SceUInt attr, SceKernelThreadOptParam *option)
 Create a thread.
int sceKernelDeleteThread (SceUID thid)
 Delate a thread.
int sceKernelStartThread (SceUID thid, SceSize arglen, void *argp)
 Start a created thread.
int sceKernelExitThread (int status)
 Exit a thread.
int sceKernelExitDeleteThread (int status)
 Exit a thread and delete itself.
int sceKernelTerminateThread (SceUID thid)
 Terminate a thread.
int sceKernelTerminateDeleteThread (SceUID thid)
 Terminate and delete a thread.
int sceKernelSuspendDispatchThread (void)
 Suspend the dispatch thread.
int sceKernelResumeDispatchThread (int state)
 Resume the dispatch thread.
int sceKernelSleepThread (void)
 Sleep thread.
int sceKernelSleepThreadCB (void)
 Sleep thread but service any callbacks as necessary.
int sceKernelWakeupThread (SceUID thid)
 Wake a thread previously put into the sleep state.
int sceKernelCancelWakeupThread (SceUID thid)
 Cancel a thread that was to be woken with sceKernelWakeupThread.
int sceKernelSuspendThread (SceUID thid)
 Suspend a thread.
int sceKernelResumeThread (SceUID thid)
 Resume a thread previously put into a suspended state with sceKernelSuspendThread.
int sceKernelWaitThreadEnd (SceUID thid, SceUInt *timeout)
 Wait until a thread has ended.
int sceKernelWaitThreadEndCB (SceUID thid, SceUInt *timeout)
 Wait until a thread has ended and handle callbacks if necessary.
int sceKernelDelayThread (SceUInt delay)
 Delay the current thread by a specified number of microseconds.
int sceKernelDelayThreadCB (SceUInt delay)
 Delay the current thread by a specified number of microseconds and handle any callbacks.
int sceKernelDelaySysClockThread (SceKernelSysClock *delay)
 Delay the current thread by a specified number of sysclocks.
int sceKernelDelaySysClockThreadCB (SceKernelSysClock *delay)
 Delay the current thread by a specified number of sysclocks handling callbacks.
int sceKernelChangeCurrentThreadAttr (int unknown, SceUInt attr)
 Modify the attributes of the current thread.
int sceKernelChangeThreadPriority (SceUID thid, int priority)
 Change the threads current priority.
int sceKernelRotateThreadReadyQueue (int priority)
 Rotate thread ready queue at a set priority.
int sceKernelReleaseWaitThread (SceUID thid)
 Release a thread in the wait state.
int sceKernelGetThreadId (void)
 Get the current thread Id.
int sceKernelGetThreadCurrentPriority (void)
 Get the current priority of the thread you are in.
int sceKernelGetThreadExitStatus (SceUID thid)
 Get the exit status of a thread.
int sceKernelCheckThreadStack (void)
 Check the thread stack?
int sceKernelGetThreadStackFreeSize (SceUID thid)
 Get the free stack size for a thread.
int sceKernelReferThreadStatus (SceUID thid, SceKernelThreadInfo *info)
 Get the status information for the specified thread.
int sceKernelReferThreadRunStatus (SceUID thid, SceKernelThreadRunStatus *status)
 Retrive the runtime status of a thread.
SceUID sceKernelCreateSema (const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option)
 Creates a new semaphore.
int sceKernelDeleteSema (SceUID semaid)
 Destroy a semaphore.
int sceKernelSignalSema (SceUID semaid, int signal)
 Send a signal to a semaphore.
int sceKernelWaitSema (SceUID semaid, int signal, SceUInt *timeout)
 Lock a semaphore.
int sceKernelWaitSemaCB (SceUID semaid, int signal, SceUInt *timeout)
 Lock a semaphore a handle callbacks if necessary.
int sceKernelPollSema (SceUID semaid, int signal)
 Poll a sempahore.
int sceKernelReferSemaStatus (SceUID semaid, SceKernelSemaInfo *info)
 Retrieve information about a semaphore.
SceUID sceKernelCreateEventFlag (const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt)
 Create an event flag.
int sceKernelSetEventFlag (SceUID evid, u32 bits)
 Set an event flag bit pattern.
int sceKernelClearEventFlag (SceUID evid, u32 bits)
 Clear a event flag bit pattern.
int sceKernelPollEventFlag (int evid, u32 bits, u32 wait, u32 *outBits)
 Poll an event flag for a given bit pattern.
int sceKernelWaitEventFlag (int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout)
 Wait for an event flag for a given bit pattern.
int sceKernelWaitEventFlagCB (int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout)
 Wait for an event flag for a given bit pattern with callback.
int sceKernelDeleteEventFlag (int evid)
 Delete an event flag.
int sceKernelReferEventFlagStatus (SceUID event, SceKernelEventFlagInfo *status)
 Get the status of an event flag.
SceUID sceKernelCreateMbx (const char *name, SceUInt attr, SceKernelMbxOptParam *option)
 Creates a new messagebox.
int sceKernelDeleteMbx (SceUID mbxid)
 Destroy a messagebox.
int sceKernelSendMbx (SceUID mbxid, void *message)
 Send a message to a messagebox.
int sceKernelReceiveMbx (SceUID mbxid, void **pmessage, SceUInt *timeout)
 Wait for a message to arrive in a messagebox.
int sceKernelReceiveMbxCB (SceUID mbxid, void **pmessage, SceUInt *timeout)
 Wait for a message to arrive in a messagebox and handle callbacks if necessary.
int sceKernelPollMbx (SceUID mbxid, void **pmessage)
 Check if a message has arrived in a messagebox.
int sceKernelCancelReceiveMbx (SceUID mbxid, int *pnum)
 Abort all wait operations on a messagebox.
int sceKernelReferMbxStatus (SceUID mbxid, SceKernelMbxInfo *info)
 Retrieve information about a messagebox.
SceUID sceKernelSetAlarm (SceUInt clock, SceKernelAlarmHandler handler, void *common)
 Set an alarm.
SceUID sceKernelSetSysClockAlarm (SceKernelSysClock *clock, SceKernelAlarmHandler handler, void *common)
 Set an alarm using a SceKernelSysClock structure for the time.
int sceKernelCancelAlarm (SceUID alarmid)
 Cancel a pending alarm.
int sceKernelReferAlarmStatus (SceUID alarmid, SceKernelAlarmInfo *info)
 Refer the status of a created alarm.
int sceKernelCreateCallback (const char *name, SceKernelCallbackFunction func, void *arg)
 Create callback.
int sceKernelReferCallbackStatus (SceUID cb, SceKernelCallbackInfo *status)
 Gets the status of a specified callback.
int sceKernelDeleteCallback (SceUID cb)
 Delete a callback.
int sceKernelNotifyCallback (SceUID cb, int arg2)
 Notify a callback.
int sceKernelCancelCallback (SceUID cb)
 Cancel a callback ?
int sceKernelGetCallbackCount (SceUID cb)
 Get the callback count.
int sceKernelCheckCallback (void)
 Check callback ?
int sceKernelGetThreadmanIdList (enum SceKernelIdListType type, SceUID *readbuf, int readbufsize, int *idcount)
 Get a list of UIDs from threadman.
int sceKernelReferSystemStatus (SceKernelSystemStatus *status)
 Get the current system status.
SceUID sceKernelCreateMsgPipe (const char *name, int part, int attr, void *unk1, void *opt)
 Create a message pipe.
int sceKernelDeleteMsgPipe (SceUID uid)
 Delete a message pipe.
int sceKernelSendMsgPipe (SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout)
 Send a message to a pipe.
int sceKernelSendMsgPipeCB (SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout)
 Send a message to a pipe (with callback).
int sceKernelTrySendMsgPipe (SceUID uid, void *message, unsigned int size, int unk1, void *unk2)
 Try to send a message to a pipe.
int sceKernelReceiveMsgPipe (SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout)
 Receive a message from a pipe.
int sceKernelReceiveMsgPipeCB (SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout)
 Receive a message from a pipe (with callback).
int sceKernelTryReceiveMsgPipe (SceUID uid, void *message, unsigned int size, int unk1, void *unk2)
 Receive a message from a pipe.
int sceKernelCancelMsgPipe (SceUID uid, int *psend, int *precv)
 Cancel a message pipe.
int sceKernelReferMsgPipeStatus (SceUID uid, SceKernelMppInfo *info)
 Get the status of a Message Pipe.
SceUID sceKernelCreateVpl (const char *name, int part, int attr, unsigned int size, struct SceKernelVplOptParam *opt)
 Create a variable pool.
int sceKernelDeleteVpl (SceUID uid)
 Delete a variable pool.
int sceKernelAllocateVpl (SceUID uid, unsigned int size, void **data, unsigned int *timeout)
 Allocate from the pool.
int sceKernelAllocateVplCB (SceUID uid, unsigned int size, void **data, unsigned int *timeout)
 Allocate from the pool (with callback).
int sceKernelTryAllocateVpl (SceUID uid, unsigned int size, void **data)
 Try to allocate from the pool.
int sceKernelFreeVpl (SceUID uid, void *data)
 Free a block.
int sceKernelCancelVpl (SceUID uid, int *pnum)
 Cancel a pool.
int sceKernelReferVplStatus (SceUID uid, SceKernelVplInfo *info)
 Get the status of an VPL.
int sceKernelCreateFpl (const char *name, int part, int attr, unsigned int size, unsigned int blocks, struct SceKernelFplOptParam *opt)
 Create a fixed pool.
int sceKernelDeleteFpl (SceUID uid)
 Delete a fixed pool.
int sceKernelAllocateFpl (SceUID uid, void **data, unsigned int *timeout)
 Allocate from the pool.
int sceKernelAllocateFplCB (SceUID uid, void **data, unsigned int *timeout)
 Allocate from the pool (with callback).
int sceKernelTryAllocateFpl (SceUID uid, void **data)
 Try to allocate from the pool.
int sceKernelFreeFpl (SceUID uid, void *data)
 Free a block.
int sceKernelCancelFpl (SceUID uid, int *pnum)
 Cancel a pool.
int sceKernelReferFplStatus (SceUID uid, SceKernelFplInfo *info)
 Get the status of an FPL.
void _sceKernelReturnFromTimerHandler (void)
 Return from a timer handler (doesn't seem to do alot).
void _sceKernelReturnFromCallback (void)
 Return from a callback (used as a syscall for the return of the callback function).
int sceKernelUSec2SysClock (unsigned int usec, SceKernelSysClock *clock)
 Convert a number of microseconds to a SceKernelSysClock structure.
SceInt64 sceKernelUSec2SysClockWide (unsigned int usec)
 Convert a number of microseconds to a wide time.
int sceKernelSysClock2USec (SceKernelSysClock *clock, unsigned int *low, unsigned int *high)
 Convert a SceKernelSysClock structure to microseconds.
int sceKernelSysClock2USecWide (SceInt64 clock, unsigned *low, unsigned int *high)
 Convert a wide time to microseconds.
int sceKernelGetSystemTime (SceKernelSysClock *time)
 Get the system time.
SceInt64 sceKernelGetSystemTimeWide (void)
 Get the system time (wide version).
unsigned int sceKernelGetSystemTimeLow (void)
 Get the low 32bits of the current system time.
SceUID sceKernelCreateVTimer (const char *name, struct SceKernelVTimerOptParam *opt)
 Create a virtual timer.
int sceKernelDeleteVTimer (SceUID uid)
 Delete a virtual timer.
int sceKernelGetVTimerBase (SceUID uid, SceKernelSysClock *base)
 Get the timer base.
SceInt64 sceKernelGetVTimerBaseWide (SceUID uid)
 Get the timer base (wide format).
int sceKernelGetVTimerTime (SceUID uid, SceKernelSysClock *time)
 Get the timer time.
SceInt64 sceKernelGetVTimerTimeWide (SceUID uid)
 Get the timer time (wide format).
int sceKernelSetVTimerTime (SceUID uid, SceKernelSysClock *time)
 Set the timer time.
SceInt64 sceKernelSetVTimerTimeWide (SceUID uid, SceInt64 time)
 Set the timer time (wide format).
int sceKernelStartVTimer (SceUID uid)
 Start a virtual timer.
int sceKernelStopVTimer (SceUID uid)
 Stop a virtual timer.
int sceKernelSetVTimerHandler (SceUID uid, SceKernelSysClock *time, SceKernelVTimerHandler handler, void *common)
 Set the timer handler.
int sceKernelSetVTimerHandlerWide (SceUID uid, SceInt64 time, SceKernelVTimerHandlerWide handler, void *common)
 Set the timer handler (wide mode).
int sceKernelCancelVTimerHandler (SceUID uid)
 Cancel the timer handler.
int sceKernelReferVTimerStatus (SceUID uid, SceKernelVTimerInfo *info)
 Get the status of a VTimer.
void _sceKernelExitThread (void)
 Exit the thread (probably used as the syscall when the main thread returns.
enum SceKernelIdListType sceKernelGetThreadmanIdType (SceUID uid)
 Get the type of a threadman uid.
SceUID sceKernelRegisterThreadEventHandler (const char *name, SceUID threadID, int mask, SceKernelThreadEventHandler handler, void *common)
 Register a thread event handler.
int sceKernelReleaseThreadEventHandler (SceUID uid)
 Release a thread event handler.
int sceKernelReferThreadEventHandlerStatus (SceUID uid, struct SceKernelThreadEventHandlerInfo *info)
 Refer the status of an thread event handler.
PspDebugProfilerRegssceKernelReferThreadProfiler (void)
 Get the thread profiler registers.
PspDebugProfilerRegssceKernelReferGlobalProfiler (void)
 Get the globile profiler registers.

Detailed Description

Library imports for the kernel threading library.


Define Documentation

#define THREAD_ATTR_USER   PSP_THREAD_ATTR_USER
#define THREAD_ATTR_VFPU   PSP_THREAD_ATTR_VFPU

Typedef Documentation

typedef SceUInt(* SceKernelAlarmHandler)(void *common)

Prototype for alarm handlers.

Struct containing alarm info.

typedef int(* SceKernelCallbackFunction)(int arg1, int arg2, void *arg)

Callback function prototype.

Structure to hold the status information for a callback.

Structure to hold the event flag information.

Fixed pool status information.

Current state of a messagebox.

See also:
sceKernelReferMbxStatus.

Additional options used when creating messageboxes.

Message Pipe status info.

Header for a message box packet.

Current state of a semaphore.

See also:
sceKernelReferSemaStatus.

Additional options used when creating semaphores.

64-bit system clock type.

Structure to contain the system status returned by sceKernelReferSystemStatus.

typedef int(* SceKernelThreadEntry)(SceSize args, void *argp)
typedef int(* SceKernelThreadEventHandler)(int mask, SceUID thid, void *common)

Struct for event handler info.

Structure to hold the status information for a thread.

See also:
sceKernelReferThreadStatus

Additional options used when creating threads.

Statistics about a running thread.

See also:
sceKernelReferThreadRunStatus.

Variable pool status info.


Enumeration Type Documentation

Event flag creation attributes.

Enumerator:
PSP_EVENT_WAITMULTIPLE 

Allow the event flag to be waited upon by multiple threads.

Event flag wait types.

Enumerator:
PSP_EVENT_WAITAND 

Wait for all bits in the pattern to be set.

PSP_EVENT_WAITOR 

Wait for one or more bits in the pattern to be set.

PSP_EVENT_WAITCLEAR 

Clear the wait pattern when it matches.

Attribute for threads.

Enumerator:
PSP_THREAD_ATTR_VFPU 

Enable VFPU access for the thread.

PSP_THREAD_ATTR_USER 

Start the thread in user mode (done automatically if the thread creating it is in user mode).

PSP_THREAD_ATTR_USBWLAN 

Thread is part of the USB/WLAN API.

PSP_THREAD_ATTR_VSH 

Thread is part of the VSH API.

PSP_THREAD_ATTR_SCRATCH_SRAM 

Allow using scratchpad memory for a thread, NOT USABLE ON V1.0.

PSP_THREAD_ATTR_NO_FILLSTACK 

Disables filling the stack with 0xFF on creation.

PSP_THREAD_ATTR_CLEAR_STACK 

Clear the stack when the thread is deleted.

Enumerator:
PSP_THREAD_RUNNING 
PSP_THREAD_READY 
PSP_THREAD_WAITING 
PSP_THREAD_SUSPEND 
PSP_THREAD_STOPPED 
PSP_THREAD_KILLED 

Threadman types for sceKernelGetThreadmanIdList.

Enumerator:
SCE_KERNEL_TMID_Thread 
SCE_KERNEL_TMID_Semaphore 
SCE_KERNEL_TMID_EventFlag 
SCE_KERNEL_TMID_Mbox 
SCE_KERNEL_TMID_Vpl 
SCE_KERNEL_TMID_Fpl 
SCE_KERNEL_TMID_Mpipe 
SCE_KERNEL_TMID_Callback 
SCE_KERNEL_TMID_ThreadEventHandler 
SCE_KERNEL_TMID_Alarm 
SCE_KERNEL_TMID_VTimer 
SCE_KERNEL_TMID_SleepThread 
SCE_KERNEL_TMID_DelayThread 
SCE_KERNEL_TMID_SuspendThread 
SCE_KERNEL_TMID_DormantThread 
Enumerator:
THREADEVENT_ALL 
THREADEVENT_KERN 
THREADEVENT_USER 
THREADEVENT_CURRENT 
Enumerator:
THREAD_CREATE 
THREAD_START 
THREAD_EXIT 
THREAD_DELETE 

Function Documentation

void _sceKernelExitThread ( void   ) 

Exit the thread (probably used as the syscall when the main thread returns.

void _sceKernelReturnFromCallback ( void   ) 

Return from a callback (used as a syscall for the return of the callback function).

void _sceKernelReturnFromTimerHandler ( void   ) 

Return from a timer handler (doesn't seem to do alot).

int sceKernelAllocateFpl ( SceUID  uid,
void **  data,
unsigned int *  timeout 
)

Allocate from the pool.

Parameters:
uid - The UID of the pool
data - Receives the address of the allocated data
timeout - Amount of time to wait for allocation?
Returns:
0 on success, < 0 on error
int sceKernelAllocateFplCB ( SceUID  uid,
void **  data,
unsigned int *  timeout 
)

Allocate from the pool (with callback).

Parameters:
uid - The UID of the pool
data - Receives the address of the allocated data
timeout - Amount of time to wait for allocation?
Returns:
0 on success, < 0 on error
int sceKernelAllocateVpl ( SceUID  uid,
unsigned int  size,
void **  data,
unsigned int *  timeout 
)

Allocate from the pool.

Parameters:
uid - The UID of the pool
size - The size to allocate
data - Receives the address of the allocated data
timeout - Amount of time to wait for allocation?
Returns:
0 on success, < 0 on error
int sceKernelAllocateVplCB ( SceUID  uid,
unsigned int  size,
void **  data,
unsigned int *  timeout 
)

Allocate from the pool (with callback).

Parameters:
uid - The UID of the pool
size - The size to allocate
data - Receives the address of the allocated data
timeout - Amount of time to wait for allocation?
Returns:
0 on success, < 0 on error
int sceKernelCancelAlarm ( SceUID  alarmid  ) 

Cancel a pending alarm.

Parameters:
alarmid - UID of the alarm to cancel.
Returns:
0 on success, < 0 on error.
int sceKernelCancelCallback ( SceUID  cb  ) 

Cancel a callback ?

Parameters:
cb - The UID of the specified callback
Returns:
0 on succes, < 0 on error
int sceKernelCancelFpl ( SceUID  uid,
int *  pnum 
)

Cancel a pool.

Parameters:
uid - The UID of the pool
pnum - Receives the number of waiting threads
Returns:
0 on success, < 0 on error
int sceKernelCancelMsgPipe ( SceUID  uid,
int *  psend,
int *  precv 
)

Cancel a message pipe.

Parameters:
uid - UID of the pipe to cancel
psend - Receive number of sending threads?
precv - Receive number of receiving threads?
Returns:
0 on success, < 0 on error
int sceKernelCancelReceiveMbx ( SceUID  mbxid,
int *  pnum 
)

Abort all wait operations on a messagebox.

Example:
Parameters:
mbxid - The mbx id returned from sceKernelCreateMbx
pnum - A pointer to where the number of threads which were waiting on the mbx should be stored (NULL if you don't care)
Returns:
< 0 on error
int sceKernelCancelVpl ( SceUID  uid,
int *  pnum 
)

Cancel a pool.

Parameters:
uid - The UID of the pool
pnum - Receives the number of waiting threads
Returns:
0 on success, < 0 on error
int sceKernelCancelVTimerHandler ( SceUID  uid  ) 

Cancel the timer handler.

Parameters:
uid - The UID of the vtimer
Returns:
0 on success, < 0 on error
int sceKernelCancelWakeupThread ( SceUID  thid  ) 

Cancel a thread that was to be woken with sceKernelWakeupThread.

Parameters:
thid - UID of the thread to cancel.
Returns:
Success if >= 0, an error if < 0.
int sceKernelChangeCurrentThreadAttr ( int  unknown,
SceUInt  attr 
)

Modify the attributes of the current thread.

Parameters:
unknown - Set to 0.
attr - The thread attributes to modify. One of PspThreadAttributes.
Returns:
< 0 on error.

Referenced by pspvfpu_initcontext().

int sceKernelChangeThreadPriority ( SceUID  thid,
int  priority 
)

Change the threads current priority.

Parameters:
thid - The ID of the thread (from sceKernelCreateThread or sceKernelGetThreadId)
priority - The new priority (the lower the number the higher the priority)
Example:
 int thid = sceKernelGetThreadId();
 // Change priority of current thread to 16
 sceKernelChangeThreadPriority(thid, 16);
Returns:
0 if successful, otherwise the error code.
int sceKernelCheckCallback ( void   ) 

Check callback ?

Returns:
Something or another
int sceKernelCheckThreadStack ( void   ) 

Check the thread stack?

Returns:
Unknown.
int sceKernelClearEventFlag ( SceUID  evid,
u32  bits 
)

Clear a event flag bit pattern.

Parameters:
evid - The event id returned by sceKernelCreateEventFlag
bits - The bits to clean
Returns:
< 0 on Error
int sceKernelCreateCallback ( const char *  name,
SceKernelCallbackFunction  func,
void *  arg 
)

Create callback.

Example:
 int cbid;
 cbid = sceKernelCreateCallback("Exit Callback", exit_cb, NULL);
Parameters:
name - A textual name for the callback
func - A pointer to a function that will be called as the callback
arg - Argument for the callback ?
Returns:
>= 0 A callback id which can be used in subsequent functions, < 0 an error.
SceUID sceKernelCreateEventFlag ( const char *  name,
int  attr,
int  bits,
SceKernelEventFlagOptParam opt 
)

Create an event flag.

Parameters:
name - The name of the event flag.
attr - Attributes from PspEventFlagAttributes
bits - Initial bit pattern.
opt - Options, set to NULL
Returns:
< 0 on error. >= 0 event flag id.
Example:
 int evid;
 evid = sceKernelCreateEventFlag("wait_event", 0, 0, 0);

Referenced by sceGuInit().

int sceKernelCreateFpl ( const char *  name,
int  part,
int  attr,
unsigned int  size,
unsigned int  blocks,
struct SceKernelFplOptParam opt 
)

Create a fixed pool.

Parameters:
name - Name of the pool
part - The memory partition ID
attr - Attributes
size - Size of pool block
blocks - Number of blocks to allocate
opt - Options (set to NULL)
Returns:
The UID of the created pool, < 0 on error.
SceUID sceKernelCreateMbx ( const char *  name,
SceUInt  attr,
SceKernelMbxOptParam option 
)

Creates a new messagebox.

Example:
 int mbxid;
 mbxid = sceKernelCreateMbx("MyMessagebox", 0, NULL);
Parameters:
name - Specifies the name of the mbx
attr - Mbx attribute flags (normally set to 0)
option - Mbx options (normally set to NULL)
Returns:
A messagebox id
SceUID sceKernelCreateMsgPipe ( const char *  name,
int  part,
int  attr,
void *  unk1,
void *  opt 
)

Create a message pipe.

Parameters:
name - Name of the pipe
part - ID of the memory partition
attr - Set to 0?
unk1 - Unknown
opt - Message pipe options (set to NULL)
Returns:
The UID of the created pipe, < 0 on error
SceUID sceKernelCreateSema ( const char *  name,
SceUInt  attr,
int  initVal,
int  maxVal,
SceKernelSemaOptParam option 
)

Creates a new semaphore.

Example:
 int semaid;
 semaid = sceKernelCreateSema("MyMutex", 0, 1, 1, 0);
Parameters:
name - Specifies the name of the sema
attr - Sema attribute flags (normally set to 0)
initVal - Sema initial value
maxVal - Sema maximum value
option - Sema options (normally set to 0)
Returns:
A semaphore id
SceUID sceKernelCreateThread ( const char *  name,
SceKernelThreadEntry  entry,
int  initPriority,
int  stackSize,
SceUInt  attr,
SceKernelThreadOptParam option 
)

Create a thread.

Example:
 SceUID thid;
 thid = sceKernelCreateThread("my_thread", threadFunc, 0x18, 0x10000, 0, NULL);
Parameters:
name - An arbitrary thread name.
entry - The thread function to run when started.
initPriority - The initial priority of the thread. Less if higher priority.
stackSize - The size of the initial stack.
attr - The thread attributes, zero or more of PspThreadAttributes.
option - Additional options specified by SceKernelThreadOptParam.
Returns:
UID of the created thread, or an error code.

Referenced by _start(), and pspAudioInit().

SceUID sceKernelCreateVpl ( const char *  name,
int  part,
int  attr,
unsigned int  size,
struct SceKernelVplOptParam opt 
)

Create a variable pool.

Parameters:
name - Name of the pool
part - The memory partition ID
attr - Attributes
size - Size of pool
opt - Options (set to NULL)
Returns:
The UID of the created pool, < 0 on error.
SceUID sceKernelCreateVTimer ( const char *  name,
struct SceKernelVTimerOptParam opt 
)

Create a virtual timer.

Parameters:
name - Name for the timer.
opt - Pointer to an SceKernelVTimerOptParam (pass NULL)
Returns:
The VTimer's UID or < 0 on error.
int sceKernelDelaySysClockThread ( SceKernelSysClock delay  ) 

Delay the current thread by a specified number of sysclocks.

Parameters:
delay - Delay in sysclocks
Returns:
0 on success, < 0 on error
int sceKernelDelaySysClockThreadCB ( SceKernelSysClock delay  ) 

Delay the current thread by a specified number of sysclocks handling callbacks.

Parameters:
delay - Delay in sysclocks
Returns:
0 on success, < 0 on error
int sceKernelDelayThread ( SceUInt  delay  ) 

Delay the current thread by a specified number of microseconds.

Parameters:
delay - Delay in microseconds.
Example:
 sceKernelDelayThread(1000000); // Delay for a second

Referenced by pspDebugSioInit().

int sceKernelDelayThreadCB ( SceUInt  delay  ) 

Delay the current thread by a specified number of microseconds and handle any callbacks.

Parameters:
delay - Delay in microseconds.
Example:
 sceKernelDelayThread(1000000); // Delay for a second
int sceKernelDeleteCallback ( SceUID  cb  ) 

Delete a callback.

Parameters:
cb - The UID of the specified callback
Returns:
0 on success, < 0 on error
int sceKernelDeleteEventFlag ( int  evid  ) 

Delete an event flag.

Parameters:
evid - The event id returned by sceKernelCreateEventFlag.
Returns:
< 0 On error

Referenced by sceGuTerm().

int sceKernelDeleteFpl ( SceUID  uid  ) 

Delete a fixed pool.

Parameters:
uid - The UID of the pool
Returns:
0 on success, < 0 on error
int sceKernelDeleteMbx ( SceUID  mbxid  ) 

Destroy a messagebox.

Parameters:
mbxid - The mbxid returned from a previous create call.
Returns:
Returns the value 0 if its succesful otherwise an error code
int sceKernelDeleteMsgPipe ( SceUID  uid  ) 

Delete a message pipe.

Parameters:
uid - The UID of the pipe
Returns:
0 on success, < 0 on error
int sceKernelDeleteSema ( SceUID  semaid  ) 

Destroy a semaphore.

Parameters:
semaid - The semaid returned from a previous create call.
Returns:
Returns the value 0 if its succesful otherwise -1
int sceKernelDeleteThread ( SceUID  thid  ) 

Delate a thread.

Parameters:
thid - UID of the thread to be deleted.
Returns:
< 0 on error.

Referenced by pspAudioEnd(), and pspAudioInit().

int sceKernelDeleteVpl ( SceUID  uid  ) 

Delete a variable pool.

Parameters:
uid - The UID of the pool
Returns:
0 on success, < 0 on error
int sceKernelDeleteVTimer ( SceUID  uid  ) 

Delete a virtual timer.

Parameters:
uid - The UID of the timer
Returns:
< 0 on error.
int sceKernelExitDeleteThread ( int  status  ) 

Exit a thread and delete itself.

Parameters:
status - Exit status

Referenced by _pspDebugTrapEntry().

int sceKernelExitThread ( int  status  ) 

Exit a thread.

Parameters:
status - Exit status.
int sceKernelFreeFpl ( SceUID  uid,
void *  data 
)

Free a block.

Parameters:
uid - The UID of the pool
data - The data block to deallocate
Returns:
0 on success, < 0 on error
int sceKernelFreeVpl ( SceUID  uid,
void *  data 
)

Free a block.

Parameters:
uid - The UID of the pool
data - The data block to deallocate
Returns:
0 on success, < 0 on error
int sceKernelGetCallbackCount ( SceUID  cb  ) 

Get the callback count.

Parameters:
cb - The UID of the specified callback
Returns:
The callback count, < 0 on error
int sceKernelGetSystemTime ( SceKernelSysClock time  ) 

Get the system time.

Parameters:
time - Pointer to a SceKernelSysClock structure
Returns:
0 on success, < 0 on error
unsigned int sceKernelGetSystemTimeLow ( void   ) 

Get the low 32bits of the current system time.

Returns:
The low 32bits of the system time
SceInt64 sceKernelGetSystemTimeWide ( void   ) 

Get the system time (wide version).

Returns:
The system time
int sceKernelGetThreadCurrentPriority ( void   ) 

Get the current priority of the thread you are in.

Returns:
The current thread priority
int sceKernelGetThreadExitStatus ( SceUID  thid  ) 

Get the exit status of a thread.

Parameters:
thid - The UID of the thread to check.
Returns:
The exit status
int sceKernelGetThreadId ( void   ) 

Get the current thread Id.

Returns:
The thread id of the calling thread.

Referenced by pspDebugGetStackTrace2().

int sceKernelGetThreadmanIdList ( enum SceKernelIdListType  type,
SceUID readbuf,
int  readbufsize,
int *  idcount 
)

Get a list of UIDs from threadman.

Allows you to enumerate resources such as threads or semaphores.

Parameters:
type - The type of resource to list, one of SceKernelIdListType.
readbuf - A pointer to a buffer to store the list.
readbufsize - The size of the buffer in SceUID units.
idcount - Pointer to an integer in which to return the number of ids in the list.
Returns:
< 0 on error. Either 0 or the same as idcount on success.
enum SceKernelIdListType sceKernelGetThreadmanIdType ( SceUID  uid  ) 

Get the type of a threadman uid.

Parameters:
uid - The uid to get the type from
Returns:
The type, < 0 on error
int sceKernelGetThreadStackFreeSize ( SceUID  thid  ) 

Get the free stack size for a thread.

Parameters:
thid - The thread ID. Seem to take current thread if set to 0.
Returns:
The free size.
int sceKernelGetVTimerBase ( SceUID  uid,
SceKernelSysClock base 
)

Get the timer base.

Parameters:
uid - UID of the vtimer
base - Pointer to a SceKernelSysClock structure
Returns:
0 on success, < 0 on error
SceInt64 sceKernelGetVTimerBaseWide ( SceUID  uid  ) 

Get the timer base (wide format).

Parameters:
uid - UID of the vtimer
Returns:
The 64bit timer base
int sceKernelGetVTimerTime ( SceUID  uid,
SceKernelSysClock time 
)

Get the timer time.

Parameters:
uid - UID of the vtimer
time - Pointer to a SceKernelSysClock structure
Returns:
0 on success, < 0 on error
SceInt64 sceKernelGetVTimerTimeWide ( SceUID  uid  ) 

Get the timer time (wide format).

Parameters:
uid - UID of the vtimer
Returns:
The 64bit timer time
int sceKernelNotifyCallback ( SceUID  cb,
int  arg2 
)

Notify a callback.

Parameters:
cb - The UID of the specified callback
arg2 - Passed as arg2 into the callback function
Returns:
0 on success, < 0 on error
int sceKernelPollEventFlag ( int  evid,
u32  bits,
u32  wait,
u32 outBits 
)

Poll an event flag for a given bit pattern.

Parameters:
evid - The event id returned by sceKernelCreateEventFlag.
bits - The bit pattern to poll for.
wait - Wait type, one or more of PspEventFlagWaitTypes or'ed together
outBits - The bit pattern that was matched.
Returns:
< 0 On error
int sceKernelPollMbx ( SceUID  mbxid,
void **  pmessage 
)

Check if a message has arrived in a messagebox.

Example:
 void *msg;
 sceKernelPollMbx(mbxid, &msg);
Parameters:
mbxid - The mbx id returned from sceKernelCreateMbx
pmessage - A pointer to where a pointer to the received message should be stored
Returns:
< 0 on error (SCE_KERNEL_ERROR_MBOX_NOMSG if the mbx is empty).
int sceKernelPollSema ( SceUID  semaid,
int  signal 
)

Poll a sempahore.

Parameters:
semaid - UID of the semaphore to poll.
signal - The value to test for.
Returns:
< 0 on error.
int sceKernelReceiveMbx ( SceUID  mbxid,
void **  pmessage,
SceUInt timeout 
)

Wait for a message to arrive in a messagebox.

Example:
 void *msg;
 sceKernelReceiveMbx(mbxid, &msg, NULL);
Parameters:
mbxid - The mbx id returned from sceKernelCreateMbx
pmessage - A pointer to where a pointer to the received message should be stored
timeout - Timeout in microseconds
Returns:
< 0 on error.
int sceKernelReceiveMbxCB ( SceUID  mbxid,
void **  pmessage,
SceUInt timeout 
)

Wait for a message to arrive in a messagebox and handle callbacks if necessary.

Example:
 void *msg;
 sceKernelReceiveMbxCB(mbxid, &msg, NULL);
Parameters:
mbxid - The mbx id returned from sceKernelCreateMbx
pmessage - A pointer to where a pointer to the received message should be stored
timeout - Timeout in microseconds
Returns:
< 0 on error.
int sceKernelReceiveMsgPipe ( SceUID  uid,
void *  message,
unsigned int  size,
int  unk1,
void *  unk2,
unsigned int *  timeout 
)

Receive a message from a pipe.

Parameters:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for receive
Returns:
0 on success, < 0 on error
int sceKernelReceiveMsgPipeCB ( SceUID  uid,
void *  message,
unsigned int  size,
int  unk1,
void *  unk2,
unsigned int *  timeout 
)

Receive a message from a pipe (with callback).

Parameters:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for receive
Returns:
0 on success, < 0 on error
int sceKernelReferAlarmStatus ( SceUID  alarmid,
SceKernelAlarmInfo info 
)

Refer the status of a created alarm.

Parameters:
alarmid - UID of the alarm to get the info of
info - Pointer to a SceKernelAlarmInfo structure
Returns:
0 on success, < 0 on error.
int sceKernelReferCallbackStatus ( SceUID  cb,
SceKernelCallbackInfo status 
)

Gets the status of a specified callback.

Parameters:
cb - The UID of the callback to refer.
status - Pointer to a status structure. The size parameter should be initialised before calling.
Returns:
< 0 on error.

Referenced by pspSdkReferCallbackStatusByName().

int sceKernelReferEventFlagStatus ( SceUID  event,
SceKernelEventFlagInfo status 
)

Get the status of an event flag.

Parameters:
event - The UID of the event.
status - A pointer to a SceKernelEventFlagInfo structure.
Returns:
< 0 on error.

Referenced by pspSdkReferEventFlagStatusByName().

int sceKernelReferFplStatus ( SceUID  uid,
SceKernelFplInfo info 
)

Get the status of an FPL.

Parameters:
uid - The uid of the FPL
info - Pointer to a SceKernelFplInfo structure
Returns:
0 on success, < 0 on error

Referenced by pspSdkReferFplStatusByName().

PspDebugProfilerRegs* sceKernelReferGlobalProfiler ( void   ) 

Get the globile profiler registers.

Returns:
Pointer to the registers, NULL on error
int sceKernelReferMbxStatus ( SceUID  mbxid,
SceKernelMbxInfo info 
)

Retrieve information about a messagebox.

Parameters:
mbxid - UID of the messagebox to retrieve info for.
info - Pointer to a SceKernelMbxInfo struct to receive the info.
Returns:
< 0 on error.

Referenced by pspSdkReferMboxStatusByName().

int sceKernelReferMsgPipeStatus ( SceUID  uid,
SceKernelMppInfo info 
)

Get the status of a Message Pipe.

Parameters:
uid - The uid of the Message Pipe
info - Pointer to a SceKernelMppInfo structure
Returns:
0 on success, < 0 on error

Referenced by pspSdkReferMppStatusByName().

int sceKernelReferSemaStatus ( SceUID  semaid,
SceKernelSemaInfo info 
)

Retrieve information about a semaphore.

Parameters:
semaid - UID of the semaphore to retrieve info for.
info - Pointer to a SceKernelSemaInfo struct to receive the info.
Returns:
< 0 on error.

Referenced by pspSdkReferSemaStatusByName().

int sceKernelReferSystemStatus ( SceKernelSystemStatus status  ) 

Get the current system status.

Parameters:
status - Pointer to a SceKernelSystemStatus structure.
Returns:
< 0 on error.
int sceKernelReferThreadEventHandlerStatus ( SceUID  uid,
struct SceKernelThreadEventHandlerInfo info 
)

Refer the status of an thread event handler.

Parameters:
uid - The UID of the event handler
info - Pointer to a SceKernelThreadEventHandlerInfo structure
Returns:
0 on success, < 0 on error

Referenced by pspSdkReferThreadEventHandlerStatusByName().

PspDebugProfilerRegs* sceKernelReferThreadProfiler ( void   ) 

Get the thread profiler registers.

Returns:
Pointer to the registers, NULL on error
int sceKernelReferThreadRunStatus ( SceUID  thid,
SceKernelThreadRunStatus status 
)

Retrive the runtime status of a thread.

Parameters:
thid - UID of the thread to retrive status.
status - Pointer to a SceKernelThreadRunStatus struct to receive the runtime status.
Returns:
0 if successful, otherwise the error code.
int sceKernelReferThreadStatus ( SceUID  thid,
SceKernelThreadInfo info 
)

Get the status information for the specified thread.

Parameters:
thid - Id of the thread to get status
info - Pointer to the info structure to receive the data. Note: The structures size field should be set to sizeof(SceKernelThreadInfo) before calling this function.
Example:
 SceKernelThreadInfo status;
 status.size = sizeof(SceKernelThreadInfo);
 if(sceKernelReferThreadStatus(thid, &status) == 0)
 { Do something... }
Returns:
0 if successful, otherwise the error code.

Referenced by pspDebugGetStackTrace2(), and pspSdkReferThreadStatusByName().

int sceKernelReferVplStatus ( SceUID  uid,
SceKernelVplInfo info 
)

Get the status of an VPL.

Parameters:
uid - The uid of the VPL
info - Pointer to a SceKernelVplInfo structure
Returns:
0 on success, < 0 on error

Referenced by pspSdkReferVplStatusByName().

int sceKernelReferVTimerStatus ( SceUID  uid,
SceKernelVTimerInfo info 
)

Get the status of a VTimer.

Parameters:
uid - The uid of the VTimer
info - Pointer to a SceKernelVTimerInfo structure
Returns:
0 on success, < 0 on error

Referenced by pspSdkReferVTimerStatusByName().

SceUID sceKernelRegisterThreadEventHandler ( const char *  name,
SceUID  threadID,
int  mask,
SceKernelThreadEventHandler  handler,
void *  common 
)

Register a thread event handler.

Parameters:
name - Name for the thread event handler
threadID - Thread ID to monitor
mask - Bit mask for what events to handle (only lowest 4 bits valid)
handler - Pointer to a SceKernelThreadEventHandler function
common - Common pointer
Returns:
The UID of the create event handler, < 0 on error
int sceKernelReleaseThreadEventHandler ( SceUID  uid  ) 

Release a thread event handler.

Parameters:
uid - The UID of the event handler
Returns:
0 on success, < 0 on error
int sceKernelReleaseWaitThread ( SceUID  thid  ) 

Release a thread in the wait state.

Parameters:
thid - The UID of the thread.
Returns:
0 on success, < 0 on error
int sceKernelResumeDispatchThread ( int  state  ) 

Resume the dispatch thread.

Parameters:
state - The state of the dispatch thread (from sceKernelSuspendDispatchThread)
Returns:
0 on success, < 0 on error
int sceKernelResumeThread ( SceUID  thid  ) 

Resume a thread previously put into a suspended state with sceKernelSuspendThread.

Parameters:
thid - UID of the thread to resume.
Returns:
Success if >= 0, an error if < 0.
int sceKernelRotateThreadReadyQueue ( int  priority  ) 

Rotate thread ready queue at a set priority.

Parameters:
priority - The priority of the queue
Returns:
0 on success, < 0 on error.
int sceKernelSendMbx ( SceUID  mbxid,
void *  message 
)

Send a message to a messagebox.

Example:
 struct MyMessage {
        SceKernelMsgPacket header;
        char text[8];
 };

 struct MyMessage msg = { {0}, "Hello" };
 // Send the message
 sceKernelSendMbx(mbxid, (void*) &msg);
Parameters:
mbxid - The mbx id returned from sceKernelCreateMbx
message - A message to be forwarded to the receiver. The start of the message should be the SceKernelMsgPacket structure, the rest
Returns:
< 0 On error.
int sceKernelSendMsgPipe ( SceUID  uid,
void *  message,
unsigned int  size,
int  unk1,
void *  unk2,
unsigned int *  timeout 
)

Send a message to a pipe.

Parameters:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for send
Returns:
0 on success, < 0 on error
int sceKernelSendMsgPipeCB ( SceUID  uid,
void *  message,
unsigned int  size,
int  unk1,
void *  unk2,
unsigned int *  timeout 
)

Send a message to a pipe (with callback).

Parameters:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for send
Returns:
0 on success, < 0 on error
SceUID sceKernelSetAlarm ( SceUInt  clock,
SceKernelAlarmHandler  handler,
void *  common 
)

Set an alarm.

Parameters:
clock - The number of micro seconds till the alarm occurrs.
handler - Pointer to a SceKernelAlarmHandler
common - Common pointer for the alarm handler
Returns:
A UID representing the created alarm, < 0 on error.
int sceKernelSetEventFlag ( SceUID  evid,
u32  bits 
)

Set an event flag bit pattern.

Parameters:
evid - The event id returned by sceKernelCreateEventFlag.
bits - The bit pattern to set.
Returns:
< 0 On error

Referenced by callbackSig().

SceUID sceKernelSetSysClockAlarm ( SceKernelSysClock clock,
SceKernelAlarmHandler  handler,
void *  common 
)

Set an alarm using a SceKernelSysClock structure for the time.

Parameters:
clock - Pointer to a SceKernelSysClock structure
handler - Pointer to a SceKernelAlarmHandler
common - Common pointer for the alarm handler.
Returns:
A UID representing the created alarm, < 0 on error.
int sceKernelSetVTimerHandler ( SceUID  uid,
SceKernelSysClock time,
SceKernelVTimerHandler  handler,
void *  common 
)

Set the timer handler.

Parameters:
uid - UID of the vtimer
time - Time to call the handler?
handler - The timer handler
common - Common pointer
Returns:
0 on success, < 0 on error
int sceKernelSetVTimerHandlerWide ( SceUID  uid,
SceInt64  time,
SceKernelVTimerHandlerWide  handler,
void *  common 
)

Set the timer handler (wide mode).

Parameters:
uid - UID of the vtimer
time - Time to call the handler?
handler - The timer handler
common - Common pointer
Returns:
0 on success, < 0 on error
int sceKernelSetVTimerTime ( SceUID  uid,
SceKernelSysClock time 
)

Set the timer time.

Parameters:
uid - UID of the vtimer
time - Pointer to a SceKernelSysClock structure
Returns:
0 on success, < 0 on error
SceInt64 sceKernelSetVTimerTimeWide ( SceUID  uid,
SceInt64  time 
)

Set the timer time (wide format).

Parameters:
uid - UID of the vtimer
time - Pointer to a SceKernelSysClock structure
Returns:
Possibly the last time
int sceKernelSignalSema ( SceUID  semaid,
int  signal 
)

Send a signal to a semaphore.

Example:
 // Signal the sema
 sceKernelSignalSema(semaid, 1);
Parameters:
semaid - The sema id returned from sceKernelCreateSema
signal - The amount to signal the sema (i.e. if 2 then increment the sema by 2)
Returns:
< 0 On error.
int sceKernelSleepThread ( void   ) 

Sleep thread.

Returns:
< 0 on error.
int sceKernelSleepThreadCB ( void   ) 

Sleep thread but service any callbacks as necessary.

Example:
 // Once all callbacks have been setup call this function
 sceKernelSleepThreadCB();
int sceKernelStartThread ( SceUID  thid,
SceSize  arglen,
void *  argp 
)

Start a created thread.

Parameters:
thid - Thread id from sceKernelCreateThread
arglen - Length of the data pointed to by argp, in bytes
argp - Pointer to the arguments.

Referenced by _start(), and pspAudioInit().

int sceKernelStartVTimer ( SceUID  uid  ) 

Start a virtual timer.

Parameters:
uid - The UID of the timer
Returns:
< 0 on error
int sceKernelStopVTimer ( SceUID  uid  ) 

Stop a virtual timer.

Parameters:
uid - The UID of the timer
Returns:
< 0 on error

Referenced by gprof_cleanup().

int sceKernelSuspendDispatchThread ( void   ) 

Suspend the dispatch thread.

Returns:
The current state of the dispatch thread, < 0 on error
int sceKernelSuspendThread ( SceUID  thid  ) 

Suspend a thread.

Parameters:
thid - UID of the thread to suspend.
Returns:
Success if >= 0, an error if < 0.
int sceKernelSysClock2USec ( SceKernelSysClock clock,
unsigned int *  low,
unsigned int *  high 
)

Convert a SceKernelSysClock structure to microseconds.

Parameters:
clock - Pointer to a SceKernelSysClock structure
low - Pointer to the low part of the time
high - Pointer to the high part of the time
Returns:
0 on success, < 0 on error
int sceKernelSysClock2USecWide ( SceInt64  clock,
unsigned *  low,
unsigned int *  high 
)

Convert a wide time to microseconds.

Parameters:
clock - Wide time
low - Pointer to the low part of the time
high - Pointer to the high part of the time
Returns:
0 on success, < 0 on error
int sceKernelTerminateDeleteThread ( SceUID  thid  ) 

Terminate and delete a thread.

Parameters:
thid - UID of the thread to terminate and delete.
Returns:
Success if >= 0, an error if < 0.
int sceKernelTerminateThread ( SceUID  thid  ) 

Terminate a thread.

Parameters:
thid - UID of the thread to terminate.
Returns:
Success if >= 0, an error if < 0.
int sceKernelTryAllocateFpl ( SceUID  uid,
void **  data 
)

Try to allocate from the pool.

Parameters:
uid - The UID of the pool
data - Receives the address of the allocated data
Returns:
0 on success, < 0 on error
int sceKernelTryAllocateVpl ( SceUID  uid,
unsigned int  size,
void **  data 
)

Try to allocate from the pool.

Parameters:
uid - The UID of the pool
size - The size to allocate
data - Receives the address of the allocated data
Returns:
0 on success, < 0 on error
int sceKernelTryReceiveMsgPipe ( SceUID  uid,
void *  message,
unsigned int  size,
int  unk1,
void *  unk2 
)

Receive a message from a pipe.

Parameters:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
Returns:
0 on success, < 0 on error
int sceKernelTrySendMsgPipe ( SceUID  uid,
void *  message,
unsigned int  size,
int  unk1,
void *  unk2 
)

Try to send a message to a pipe.

Parameters:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
Returns:
0 on success, < 0 on error
int sceKernelUSec2SysClock ( unsigned int  usec,
SceKernelSysClock clock 
)

Convert a number of microseconds to a SceKernelSysClock structure.

Parameters:
usec - Number of microseconds
clock - Pointer to a SceKernelSysClock structure
Returns:
0 on success, < 0 on error
SceInt64 sceKernelUSec2SysClockWide ( unsigned int  usec  ) 

Convert a number of microseconds to a wide time.

Parameters:
usec - Number of microseconds.
Returns:
The time
int sceKernelWaitEventFlag ( int  evid,
u32  bits,
u32  wait,
u32 outBits,
SceUInt timeout 
)

Wait for an event flag for a given bit pattern.

Parameters:
evid - The event id returned by sceKernelCreateEventFlag.
bits - The bit pattern to poll for.
wait - Wait type, one or more of PspEventFlagWaitTypes or'ed together
outBits - The bit pattern that was matched.
timeout - Timeout in microseconds
Returns:
< 0 On error
int sceKernelWaitEventFlagCB ( int  evid,
u32  bits,
u32  wait,
u32 outBits,
SceUInt timeout 
)

Wait for an event flag for a given bit pattern with callback.

Parameters:
evid - The event id returned by sceKernelCreateEventFlag.
bits - The bit pattern to poll for.
wait - Wait type, one or more of PspEventFlagWaitTypes or'ed together
outBits - The bit pattern that was matched.
timeout - Timeout in microseconds
Returns:
< 0 On error
int sceKernelWaitSema ( SceUID  semaid,
int  signal,
SceUInt timeout 
)

Lock a semaphore.

Example:
 sceKernelWaitSema(semaid, 1, 0);
Parameters:
semaid - The sema id returned from sceKernelCreateSema
signal - The value to wait for (i.e. if 1 then wait till reaches a signal state of 1)
timeout - Timeout in microseconds (assumed).
Returns:
< 0 on error.
int sceKernelWaitSemaCB ( SceUID  semaid,
int  signal,
SceUInt timeout 
)

Lock a semaphore a handle callbacks if necessary.

Example:
 sceKernelWaitSemaCB(semaid, 1, 0);
Parameters:
semaid - The sema id returned from sceKernelCreateSema
signal - The value to wait for (i.e. if 1 then wait till reaches a signal state of 1)
timeout - Timeout in microseconds (assumed).
Returns:
< 0 on error.
int sceKernelWaitThreadEnd ( SceUID  thid,
SceUInt timeout 
)

Wait until a thread has ended.

Parameters:
thid - Id of the thread to wait for.
timeout - Timeout in microseconds (assumed).
Returns:
< 0 on error.
int sceKernelWaitThreadEndCB ( SceUID  thid,
SceUInt timeout 
)

Wait until a thread has ended and handle callbacks if necessary.

Parameters:
thid - Id of the thread to wait for.
timeout - Timeout in microseconds (assumed).
Returns:
< 0 on error.
int sceKernelWakeupThread ( SceUID  thid  ) 

Wake a thread previously put into the sleep state.

Parameters:
thid - UID of the thread to wake.
Returns:
Success if >= 0, an error if < 0.