Thread Manager Library

Detailed Description

Library imports for the kernel threading library.


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 int(*) SceKernelThreadEntry (SceSize args, void *argp)
typedef SceKernelEventFlagOptParam SceKernelEventFlagOptParam
typedef SceUInt(*) SceKernelAlarmHandler (void *common)
 Prototype for alarm handlers.
typedef int(*) SceKernelCallbackFunction (int arg1, int arg2, void *arg)
 Callback function prototype.
typedef SceUInt(*) SceKernelVTimerHandler (SceUID uid, SceKernelSysClock *, SceKernelSysClock *, void *)
typedef SceUInt(*) SceKernelVTimerHandlerWide (SceUID uid, SceInt64, SceInt64, void *)
typedef int(*) SceKernelThreadEventHandler (int mask, SceUID thid, void *common)

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.
PspDebugProfilerRegs * sceKernelReferThreadProfiler (void)
 Get the thread profiler registers.
PspDebugProfilerRegs * sceKernelReferGlobalProfiler (void)
 Get the globile profiler registers.

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.

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

Callback function prototype.

typedef struct SceKernelEventFlagOptParam SceKernelEventFlagOptParam

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

typedef int(*) SceKernelThreadEventHandler(int mask, SceUID thid, void *common)

typedef SceUInt(*) SceKernelVTimerHandler(SceUID uid, SceKernelSysClock *, SceKernelSysClock *, void *)

typedef SceUInt(*) SceKernelVTimerHandlerWide(SceUID uid, SceInt64, SceInt64, void *)

Enumeration Type Documentation

enum PspEventFlagAttributes

Event flag creation attributes.

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

enum PspEventFlagWaitTypes

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.

enum PspThreadAttributes

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.

enum PspThreadStatus

Enumerator:
PSP_THREAD_RUNNING 
PSP_THREAD_READY 
PSP_THREAD_WAITING 
PSP_THREAD_SUSPEND 
PSP_THREAD_STOPPED 
PSP_THREAD_KILLED 

enum SceKernelIdListType

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 

enum ThreadEventIds

Enumerator:
THREADEVENT_ALL 
THREADEVENT_KERN 
THREADEVENT_USER 
THREADEVENT_CURRENT 

enum ThreadEvents

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:
 sceKernelCancelReceiveMbx(mbxid, NULL);
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.

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);

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.

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

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

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.

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

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.

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.

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.

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

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.

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

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.

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

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.

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

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

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
handler - Pointer to a SceKernelThreadEventHandler function
mask - Bit mask for what events to handle (only lowest 4 bits valid)
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

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.

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

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.

Generated on Tue Jul 24 15:21:26 2007 for PSPSDK-Rev2272 by  doxygen 1.5.2