Thread Manager Library


Description détaillée

Library imports for the kernel threading library.


Structures de données

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

Macros

#define THREAD_ATTR_VFPU   PSP_THREAD_ATTR_VFPU
#define THREAD_ATTR_USER   PSP_THREAD_ATTR_USER

Définition de type

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)

Énumérations

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. Plus de détails...
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. Plus de détails...
enum  PspEventFlagWaitTypes { PSP_EVENT_WAITAND = 0, PSP_EVENT_WAITOR = 1, PSP_EVENT_WAITCLEAR = 0x20 }
 Event flag wait types. Plus de détails...
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. Plus de détails...
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 }

Fonctions

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.


Documentation des macros

#define THREAD_ATTR_USER   PSP_THREAD_ATTR_USER

#define THREAD_ATTR_VFPU   PSP_THREAD_ATTR_VFPU


Documentation des définition de type

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


Documentation du type de l'énumération

enum PspEventFlagAttributes

Event flag creation attributes.

Valeurs énumérées:
PSP_EVENT_WAITMULTIPLE  Allow the event flag to be waited upon by multiple threads.

enum PspEventFlagWaitTypes

Event flag wait types.

Valeurs énumérées:
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.

Valeurs énumérées:
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

Valeurs énumérées:
PSP_THREAD_RUNNING 
PSP_THREAD_READY 
PSP_THREAD_WAITING 
PSP_THREAD_SUSPEND 
PSP_THREAD_STOPPED 
PSP_THREAD_KILLED 

enum SceKernelIdListType

Threadman types for sceKernelGetThreadmanIdList.

Valeurs énumérées:
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

Valeurs énumérées:
THREADEVENT_ALL 
THREADEVENT_KERN 
THREADEVENT_USER 
THREADEVENT_CURRENT 

enum ThreadEvents

Valeurs énumérées:
THREAD_CREATE 
THREAD_START 
THREAD_EXIT 
THREAD_DELETE 


Documentation des fonctions

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.

Paramètres:
uid - The UID of the pool
data - Receives the address of the allocated data
timeout - Amount of time to wait for allocation?
Renvoie:
0 on success, < 0 on error

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

Allocate from the pool (with callback).

Paramètres:
uid - The UID of the pool
data - Receives the address of the allocated data
timeout - Amount of time to wait for allocation?
Renvoie:
0 on success, < 0 on error

int sceKernelAllocateVpl ( SceUID  uid,
unsigned int  size,
void **  data,
unsigned int *  timeout 
)

Allocate from the pool.

Paramètres:
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?
Renvoie:
0 on success, < 0 on error

int sceKernelAllocateVplCB ( SceUID  uid,
unsigned int  size,
void **  data,
unsigned int *  timeout 
)

Allocate from the pool (with callback).

Paramètres:
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?
Renvoie:
0 on success, < 0 on error

int sceKernelCancelAlarm ( SceUID  alarmid  ) 

Cancel a pending alarm.

Paramètres:
alarmid - UID of the alarm to cancel.
Renvoie:
0 on success, < 0 on error.

int sceKernelCancelCallback ( SceUID  cb  ) 

Cancel a callback ?

Paramètres:
cb - The UID of the specified callback
Renvoie:
0 on succes, < 0 on error

int sceKernelCancelFpl ( SceUID  uid,
int *  pnum 
)

Cancel a pool.

Paramètres:
uid - The UID of the pool
pnum - Receives the number of waiting threads
Renvoie:
0 on success, < 0 on error

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

Cancel a message pipe.

Paramètres:
uid - UID of the pipe to cancel
psend - Receive number of sending threads?
precv - Receive number of receiving threads?
Renvoie:
0 on success, < 0 on error

int sceKernelCancelReceiveMbx ( SceUID  mbxid,
int *  pnum 
)

Abort all wait operations on a messagebox.

Example:
Paramètres:
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)
Renvoie:
< 0 on error

int sceKernelCancelVpl ( SceUID  uid,
int *  pnum 
)

Cancel a pool.

Paramètres:
uid - The UID of the pool
pnum - Receives the number of waiting threads
Renvoie:
0 on success, < 0 on error

int sceKernelCancelVTimerHandler ( SceUID  uid  ) 

Cancel the timer handler.

Paramètres:
uid - The UID of the vtimer
Renvoie:
0 on success, < 0 on error

int sceKernelCancelWakeupThread ( SceUID  thid  ) 

Cancel a thread that was to be woken with sceKernelWakeupThread.

Paramètres:
thid - UID of the thread to cancel.
Renvoie:
Success if >= 0, an error if < 0.

int sceKernelChangeCurrentThreadAttr ( int  unknown,
SceUInt  attr 
)

Modify the attributes of the current thread.

Paramètres:
unknown - Set to 0.
attr - The thread attributes to modify. One of PspThreadAttributes.
Renvoie:
< 0 on error.

int sceKernelChangeThreadPriority ( SceUID  thid,
int  priority 
)

Change the threads current priority.

Paramètres:
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);
Renvoie:
0 if successful, otherwise the error code.

int sceKernelCheckCallback ( void   ) 

Check callback ?

Renvoie:
Something or another

int sceKernelCheckThreadStack ( void   ) 

Check the thread stack?

Renvoie:
Unknown.

int sceKernelClearEventFlag ( SceUID  evid,
u32  bits 
)

Clear a event flag bit pattern.

Paramètres:
evid - The event id returned by sceKernelCreateEventFlag
bits - The bits to clean
Renvoie:
< 0 on Error

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

Create callback.

Example:
 int cbid;
 cbid = sceKernelCreateCallback("Exit Callback", exit_cb, NULL);
Paramètres:
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 ?
Renvoie:
>= 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.

Paramètres:
name - The name of the event flag.
attr - Attributes from PspEventFlagAttributes
bits - Initial bit pattern.
opt - Options, set to NULL
Renvoie:
< 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.

Paramètres:
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)
Renvoie:
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);
Paramètres:
name - Specifies the name of the mbx
attr - Mbx attribute flags (normally set to 0)
option - Mbx options (normally set to NULL)
Renvoie:
A messagebox id

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

Create a message pipe.

Paramètres:
name - Name of the pipe
part - ID of the memory partition
attr - Set to 0?
unk1 - Unknown
opt - Message pipe options (set to NULL)
Renvoie:
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);
Paramètres:
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)
Renvoie:
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);
Paramètres:
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.
Renvoie:
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.

Paramètres:
name - Name of the pool
part - The memory partition ID
attr - Attributes
size - Size of pool
opt - Options (set to NULL)
Renvoie:
The UID of the created pool, < 0 on error.

SceUID sceKernelCreateVTimer ( const char *  name,
struct SceKernelVTimerOptParam opt 
)

Create a virtual timer.

Paramètres:
name - Name for the timer.
opt - Pointer to an SceKernelVTimerOptParam (pass NULL)
Renvoie:
The VTimer's UID or < 0 on error.

int sceKernelDelaySysClockThread ( SceKernelSysClock delay  ) 

Delay the current thread by a specified number of sysclocks.

Paramètres:
delay - Delay in sysclocks
Renvoie:
0 on success, < 0 on error

int sceKernelDelaySysClockThreadCB ( SceKernelSysClock delay  ) 

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

Paramètres:
delay - Delay in sysclocks
Renvoie:
0 on success, < 0 on error

int sceKernelDelayThread ( SceUInt  delay  ) 

Delay the current thread by a specified number of microseconds.

Paramètres:
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.

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

int sceKernelDeleteCallback ( SceUID  cb  ) 

Delete a callback.

Paramètres:
cb - The UID of the specified callback
Renvoie:
0 on success, < 0 on error

int sceKernelDeleteEventFlag ( int  evid  ) 

Delete an event flag.

Paramètres:
evid - The event id returned by sceKernelCreateEventFlag.
Renvoie:
< 0 On error

int sceKernelDeleteFpl ( SceUID  uid  ) 

Delete a fixed pool.

Paramètres:
uid - The UID of the pool
Renvoie:
0 on success, < 0 on error

int sceKernelDeleteMbx ( SceUID  mbxid  ) 

Destroy a messagebox.

Paramètres:
mbxid - The mbxid returned from a previous create call.
Renvoie:
Returns the value 0 if its succesful otherwise an error code

int sceKernelDeleteMsgPipe ( SceUID  uid  ) 

Delete a message pipe.

Paramètres:
uid - The UID of the pipe
Renvoie:
0 on success, < 0 on error

int sceKernelDeleteSema ( SceUID  semaid  ) 

Destroy a semaphore.

Paramètres:
semaid - The semaid returned from a previous create call.
Renvoie:
Returns the value 0 if its succesful otherwise -1

int sceKernelDeleteThread ( SceUID  thid  ) 

Delate a thread.

Paramètres:
thid - UID of the thread to be deleted.
Renvoie:
< 0 on error.

int sceKernelDeleteVpl ( SceUID  uid  ) 

Delete a variable pool.

Paramètres:
uid - The UID of the pool
Renvoie:
0 on success, < 0 on error

int sceKernelDeleteVTimer ( SceUID  uid  ) 

Delete a virtual timer.

Paramètres:
uid - The UID of the timer
Renvoie:
< 0 on error.

int sceKernelExitDeleteThread ( int  status  ) 

Exit a thread and delete itself.

Paramètres:
status - Exit status

int sceKernelExitThread ( int  status  ) 

Exit a thread.

Paramètres:
status - Exit status.

int sceKernelFreeFpl ( SceUID  uid,
void *  data 
)

Free a block.

Paramètres:
uid - The UID of the pool
data - The data block to deallocate
Renvoie:
0 on success, < 0 on error

int sceKernelFreeVpl ( SceUID  uid,
void *  data 
)

Free a block.

Paramètres:
uid - The UID of the pool
data - The data block to deallocate
Renvoie:
0 on success, < 0 on error

int sceKernelGetCallbackCount ( SceUID  cb  ) 

Get the callback count.

Paramètres:
cb - The UID of the specified callback
Renvoie:
The callback count, < 0 on error

int sceKernelGetSystemTime ( SceKernelSysClock time  ) 

Get the system time.

Paramètres:
time - Pointer to a SceKernelSysClock structure
Renvoie:
0 on success, < 0 on error

unsigned int sceKernelGetSystemTimeLow ( void   ) 

Get the low 32bits of the current system time.

Renvoie:
The low 32bits of the system time

SceInt64 sceKernelGetSystemTimeWide ( void   ) 

Get the system time (wide version).

Renvoie:
The system time

int sceKernelGetThreadCurrentPriority ( void   ) 

Get the current priority of the thread you are in.

Renvoie:
The current thread priority

int sceKernelGetThreadExitStatus ( SceUID  thid  ) 

Get the exit status of a thread.

Paramètres:
thid - The UID of the thread to check.
Renvoie:
The exit status

int sceKernelGetThreadId ( void   ) 

Get the current thread Id.

Renvoie:
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.

Paramètres:
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.
Renvoie:
< 0 on error. Either 0 or the same as idcount on success.

enum SceKernelIdListType sceKernelGetThreadmanIdType ( SceUID  uid  ) 

Get the type of a threadman uid.

Paramètres:
uid - The uid to get the type from
Renvoie:
The type, < 0 on error

int sceKernelGetThreadStackFreeSize ( SceUID  thid  ) 

Get the free stack size for a thread.

Paramètres:
thid - The thread ID. Seem to take current thread if set to 0.
Renvoie:
The free size.

int sceKernelGetVTimerBase ( SceUID  uid,
SceKernelSysClock base 
)

Get the timer base.

Paramètres:
uid - UID of the vtimer
base - Pointer to a SceKernelSysClock structure
Renvoie:
0 on success, < 0 on error

SceInt64 sceKernelGetVTimerBaseWide ( SceUID  uid  ) 

Get the timer base (wide format).

Paramètres:
uid - UID of the vtimer
Renvoie:
The 64bit timer base

int sceKernelGetVTimerTime ( SceUID  uid,
SceKernelSysClock time 
)

Get the timer time.

Paramètres:
uid - UID of the vtimer
time - Pointer to a SceKernelSysClock structure
Renvoie:
0 on success, < 0 on error

SceInt64 sceKernelGetVTimerTimeWide ( SceUID  uid  ) 

Get the timer time (wide format).

Paramètres:
uid - UID of the vtimer
Renvoie:
The 64bit timer time

int sceKernelNotifyCallback ( SceUID  cb,
int  arg2 
)

Notify a callback.

Paramètres:
cb - The UID of the specified callback
arg2 - Passed as arg2 into the callback function
Renvoie:
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.

Paramètres:
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.
Renvoie:
< 0 On error

int sceKernelPollMbx ( SceUID  mbxid,
void **  pmessage 
)

Check if a message has arrived in a messagebox.

Example:
 void *msg;
 sceKernelPollMbx(mbxid, &msg);
Paramètres:
mbxid - The mbx id returned from sceKernelCreateMbx
pmessage - A pointer to where a pointer to the received message should be stored
Renvoie:
< 0 on error (SCE_KERNEL_ERROR_MBOX_NOMSG if the mbx is empty).

int sceKernelPollSema ( SceUID  semaid,
int  signal 
)

Poll a sempahore.

Paramètres:
semaid - UID of the semaphore to poll.
signal - The value to test for.
Renvoie:
< 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);
Paramètres:
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
Renvoie:
< 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);
Paramètres:
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
Renvoie:
< 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.

Paramètres:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for receive
Renvoie:
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).

Paramètres:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for receive
Renvoie:
0 on success, < 0 on error

int sceKernelReferAlarmStatus ( SceUID  alarmid,
SceKernelAlarmInfo info 
)

Refer the status of a created alarm.

Paramètres:
alarmid - UID of the alarm to get the info of
info - Pointer to a SceKernelAlarmInfo structure
Renvoie:
0 on success, < 0 on error.

int sceKernelReferCallbackStatus ( SceUID  cb,
SceKernelCallbackInfo status 
)

Gets the status of a specified callback.

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

int sceKernelReferEventFlagStatus ( SceUID  event,
SceKernelEventFlagInfo status 
)

Get the status of an event flag.

Paramètres:
event - The UID of the event.
status - A pointer to a SceKernelEventFlagInfo structure.
Renvoie:
< 0 on error.

int sceKernelReferFplStatus ( SceUID  uid,
SceKernelFplInfo info 
)

Get the status of an FPL.

Paramètres:
uid - The uid of the FPL
info - Pointer to a SceKernelFplInfo structure
Renvoie:
0 on success, < 0 on error

PspDebugProfilerRegs* sceKernelReferGlobalProfiler ( void   ) 

Get the globile profiler registers.

Renvoie:
Pointer to the registers, NULL on error

int sceKernelReferMbxStatus ( SceUID  mbxid,
SceKernelMbxInfo info 
)

Retrieve information about a messagebox.

Paramètres:
mbxid - UID of the messagebox to retrieve info for.
info - Pointer to a SceKernelMbxInfo struct to receive the info.
Renvoie:
< 0 on error.

int sceKernelReferMsgPipeStatus ( SceUID  uid,
SceKernelMppInfo info 
)

Get the status of a Message Pipe.

Paramètres:
uid - The uid of the Message Pipe
info - Pointer to a SceKernelMppInfo structure
Renvoie:
0 on success, < 0 on error

int sceKernelReferSemaStatus ( SceUID  semaid,
SceKernelSemaInfo info 
)

Retrieve information about a semaphore.

Paramètres:
semaid - UID of the semaphore to retrieve info for.
info - Pointer to a SceKernelSemaInfo struct to receive the info.
Renvoie:
< 0 on error.

int sceKernelReferSystemStatus ( SceKernelSystemStatus status  ) 

Get the current system status.

Paramètres:
status - Pointer to a SceKernelSystemStatus structure.
Renvoie:
< 0 on error.

int sceKernelReferThreadEventHandlerStatus ( SceUID  uid,
struct SceKernelThreadEventHandlerInfo info 
)

Refer the status of an thread event handler.

Paramètres:
uid - The UID of the event handler
info - Pointer to a SceKernelThreadEventHandlerInfo structure
Renvoie:
0 on success, < 0 on error

PspDebugProfilerRegs* sceKernelReferThreadProfiler ( void   ) 

Get the thread profiler registers.

Renvoie:
Pointer to the registers, NULL on error

int sceKernelReferThreadRunStatus ( SceUID  thid,
SceKernelThreadRunStatus status 
)

Retrive the runtime status of a thread.

Paramètres:
thid - UID of the thread to retrive status.
status - Pointer to a SceKernelThreadRunStatus struct to receive the runtime status.
Renvoie:
0 if successful, otherwise the error code.

int sceKernelReferThreadStatus ( SceUID  thid,
SceKernelThreadInfo info 
)

Get the status information for the specified thread.

Paramètres:
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... }
Renvoie:
0 if successful, otherwise the error code.

int sceKernelReferVplStatus ( SceUID  uid,
SceKernelVplInfo info 
)

Get the status of an VPL.

Paramètres:
uid - The uid of the VPL
info - Pointer to a SceKernelVplInfo structure
Renvoie:
0 on success, < 0 on error

int sceKernelReferVTimerStatus ( SceUID  uid,
SceKernelVTimerInfo info 
)

Get the status of a VTimer.

Paramètres:
uid - The uid of the VTimer
info - Pointer to a SceKernelVTimerInfo structure
Renvoie:
0 on success, < 0 on error

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

Register a thread event handler.

Paramètres:
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
Renvoie:
The UID of the create event handler, < 0 on error

int sceKernelReleaseThreadEventHandler ( SceUID  uid  ) 

Release a thread event handler.

Paramètres:
uid - The UID of the event handler
Renvoie:
0 on success, < 0 on error

int sceKernelReleaseWaitThread ( SceUID  thid  ) 

Release a thread in the wait state.

Paramètres:
thid - The UID of the thread.
Renvoie:
0 on success, < 0 on error

int sceKernelResumeDispatchThread ( int  state  ) 

Resume the dispatch thread.

Paramètres:
state - The state of the dispatch thread (from sceKernelSuspendDispatchThread)
Renvoie:
0 on success, < 0 on error

int sceKernelResumeThread ( SceUID  thid  ) 

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

Paramètres:
thid - UID of the thread to resume.
Renvoie:
Success if >= 0, an error if < 0.

int sceKernelRotateThreadReadyQueue ( int  priority  ) 

Rotate thread ready queue at a set priority.

Paramètres:
priority - The priority of the queue
Renvoie:
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);
Paramètres:
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
Renvoie:
< 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.

Paramètres:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for send
Renvoie:
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).

Paramètres:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
timeout - Timeout for send
Renvoie:
0 on success, < 0 on error

SceUID sceKernelSetAlarm ( SceUInt  clock,
SceKernelAlarmHandler  handler,
void *  common 
)

Set an alarm.

Paramètres:
clock - The number of micro seconds till the alarm occurrs.
handler - Pointer to a SceKernelAlarmHandler
common - Common pointer for the alarm handler
Renvoie:
A UID representing the created alarm, < 0 on error.

int sceKernelSetEventFlag ( SceUID  evid,
u32  bits 
)

Set an event flag bit pattern.

Paramètres:
evid - The event id returned by sceKernelCreateEventFlag.
bits - The bit pattern to set.
Renvoie:
< 0 On error

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

Set an alarm using a SceKernelSysClock structure for the time.

Paramètres:
clock - Pointer to a SceKernelSysClock structure
handler - Pointer to a SceKernelAlarmHandler
common - Common pointer for the alarm handler.
Renvoie:
A UID representing the created alarm, < 0 on error.

int sceKernelSetVTimerHandler ( SceUID  uid,
SceKernelSysClock time,
SceKernelVTimerHandler  handler,
void *  common 
)

Set the timer handler.

Paramètres:
uid - UID of the vtimer
time - Time to call the handler?
handler - The timer handler
common - Common pointer
Renvoie:
0 on success, < 0 on error

int sceKernelSetVTimerHandlerWide ( SceUID  uid,
SceInt64  time,
SceKernelVTimerHandlerWide  handler,
void *  common 
)

Set the timer handler (wide mode).

Paramètres:
uid - UID of the vtimer
time - Time to call the handler?
handler - The timer handler
common - Common pointer
Renvoie:
0 on success, < 0 on error

int sceKernelSetVTimerTime ( SceUID  uid,
SceKernelSysClock time 
)

Set the timer time.

Paramètres:
uid - UID of the vtimer
time - Pointer to a SceKernelSysClock structure
Renvoie:
0 on success, < 0 on error

SceInt64 sceKernelSetVTimerTimeWide ( SceUID  uid,
SceInt64  time 
)

Set the timer time (wide format).

Paramètres:
uid - UID of the vtimer
time - Pointer to a SceKernelSysClock structure
Renvoie:
Possibly the last time

int sceKernelSignalSema ( SceUID  semaid,
int  signal 
)

Send a signal to a semaphore.

Example:
 // Signal the sema
 sceKernelSignalSema(semaid, 1);
Paramètres:
semaid - The sema id returned from sceKernelCreateSema
signal - The amount to signal the sema (i.e. if 2 then increment the sema by 2)
Renvoie:
< 0 On error.

int sceKernelSleepThread ( void   ) 

Sleep thread.

Renvoie:
< 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.

Paramètres:
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.

Paramètres:
uid - The UID of the timer
Renvoie:
< 0 on error

int sceKernelStopVTimer ( SceUID  uid  ) 

Stop a virtual timer.

Paramètres:
uid - The UID of the timer
Renvoie:
< 0 on error

int sceKernelSuspendDispatchThread ( void   ) 

Suspend the dispatch thread.

Renvoie:
The current state of the dispatch thread, < 0 on error

int sceKernelSuspendThread ( SceUID  thid  ) 

Suspend a thread.

Paramètres:
thid - UID of the thread to suspend.
Renvoie:
Success if >= 0, an error if < 0.

int sceKernelSysClock2USec ( SceKernelSysClock clock,
unsigned int *  low,
unsigned int *  high 
)

Convert a SceKernelSysClock structure to microseconds.

Paramètres:
clock - Pointer to a SceKernelSysClock structure
low - Pointer to the low part of the time
high - Pointer to the high part of the time
Renvoie:
0 on success, < 0 on error

int sceKernelSysClock2USecWide ( SceInt64  clock,
unsigned *  low,
unsigned int *  high 
)

Convert a wide time to microseconds.

Paramètres:
clock - Wide time
low - Pointer to the low part of the time
high - Pointer to the high part of the time
Renvoie:
0 on success, < 0 on error

int sceKernelTerminateDeleteThread ( SceUID  thid  ) 

Terminate and delete a thread.

Paramètres:
thid - UID of the thread to terminate and delete.
Renvoie:
Success if >= 0, an error if < 0.

int sceKernelTerminateThread ( SceUID  thid  ) 

Terminate a thread.

Paramètres:
thid - UID of the thread to terminate.
Renvoie:
Success if >= 0, an error if < 0.

int sceKernelTryAllocateFpl ( SceUID  uid,
void **  data 
)

Try to allocate from the pool.

Paramètres:
uid - The UID of the pool
data - Receives the address of the allocated data
Renvoie:
0 on success, < 0 on error

int sceKernelTryAllocateVpl ( SceUID  uid,
unsigned int  size,
void **  data 
)

Try to allocate from the pool.

Paramètres:
uid - The UID of the pool
size - The size to allocate
data - Receives the address of the allocated data
Renvoie:
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.

Paramètres:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
Renvoie:
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.

Paramètres:
uid - The UID of the pipe
message - Pointer to the message
size - Size of the message
unk1 - Unknown
unk2 - Unknown
Renvoie:
0 on success, < 0 on error

int sceKernelUSec2SysClock ( unsigned int  usec,
SceKernelSysClock clock 
)

Convert a number of microseconds to a SceKernelSysClock structure.

Paramètres:
usec - Number of microseconds
clock - Pointer to a SceKernelSysClock structure
Renvoie:
0 on success, < 0 on error

SceInt64 sceKernelUSec2SysClockWide ( unsigned int  usec  ) 

Convert a number of microseconds to a wide time.

Paramètres:
usec - Number of microseconds.
Renvoie:
The time

int sceKernelWaitEventFlag ( int  evid,
u32  bits,
u32  wait,
u32 outBits,
SceUInt timeout 
)

Wait for an event flag for a given bit pattern.

Paramètres:
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
Renvoie:
< 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.

Paramètres:
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
Renvoie:
< 0 On error

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

Lock a semaphore.

Example:
 sceKernelWaitSema(semaid, 1, 0);
Paramètres:
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).
Renvoie:
< 0 on error.

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

Lock a semaphore a handle callbacks if necessary.

Example:
 sceKernelWaitSemaCB(semaid, 1, 0);
Paramètres:
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).
Renvoie:
< 0 on error.

int sceKernelWaitThreadEnd ( SceUID  thid,
SceUInt timeout 
)

Wait until a thread has ended.

Paramètres:
thid - Id of the thread to wait for.
timeout - Timeout in microseconds (assumed).
Renvoie:
< 0 on error.

int sceKernelWaitThreadEndCB ( SceUID  thid,
SceUInt timeout 
)

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

Paramètres:
thid - Id of the thread to wait for.
timeout - Timeout in microseconds (assumed).
Renvoie:
< 0 on error.

int sceKernelWakeupThread ( SceUID  thid  ) 

Wake a thread previously put into the sleep state.

Paramètres:
thid - UID of the thread to wake.
Renvoie:
Success if >= 0, an error if < 0.


Traduit par ADreNaLiNe-DJ pour SmartPSP.net | Généré le Fri Apr 24 11:46:30 2009 pour pspsdk-1.0+beta2 par  doxygen 1.5.1