PS Vita supports multi-threading in the non-secure kernel but not in the secure kernel. There is no user/POSIX threads; all threads are implemented as kernel threads and processes are functionally the same as threads. Threads can be specified to run on a specific core with the CPU affinity mask option when creating the thread and by default threads can run on any core. The kernel process can also run on any core. Additionally, the secure kernel can also run on any core.
Module
This module exists only in non-secure world. The SELF can be found in os0:kd/threadmgr.skprx
.
Version |
World |
Privilege
|
0.990-3.65 |
Non-secure |
Kernel
|
Libraries
Known NIDs
Types
Class Types
// this is a generic type which is not specific for SceKernelThreadMgr. It is used in class creation in many modules.
typedef struct SceObjectBase {
uint32_t sce_reserved[2]; //[0] seems to be SceKernelObject*
uint32_t data[];
} SceObjectBase;
typedef struct _SceCacheObj {
SceObjectBase base;
int unk8;
int unkC;
} SceCacheObj;
typedef struct _SceWaitableObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
} SceWaitableObj;
typedef struct _SceFastMutexObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceFastMutexObj;
typedef struct _SceAlarmObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceAlarmObj;
typedef struct _SceDelayObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceDelayObj;
typedef struct _SceLwMutexObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int attr_20;
int unk24;
int unk28;
int initCount_2C;
SceKernelLwMutexWork* work_30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceLwMutexObj;
typedef struct _SceCondObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int attr_20;
int unk24;
SceKernelCondOptParam* option_28;
SceUID mutexId_2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceCondObj;
typedef struct _SceEventFlagObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int attr_20;
int unk24;
int bits_28;
int bits_2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceEventFlagObj;
typedef struct _SceLwCondObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceLwCondObj;
typedef struct _SceMsgPipeObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceMsgPipeObj;
typedef struct _SceMutexObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int attr_20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int initCount_38;
int initCount_3C;
int unk40;
int ceilingPriority_44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceMutexObj;
typedef struct _SceRWLockObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceRWLockObj;
typedef struct SceKernelSemaOptParam {
/** Size of the ::SceKernelSemaOptParam structure. */
SceSize size;
} SceKernelSemaOptParam;
typedef struct _SceSemaObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int attr_20;
int unk24;
SceKernelSemaOptParam* option_28;
int initVal_2C;
int maxVal_30;
int initVal_34;
int unk_38;
int unk_3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceSemaObj;
typedef struct _SceSimpleEventObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceSimpleEventObj;
typedef struct _SceTimerObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceTimerObj;
typedef struct _SceCpuTimerObj {
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
} SceCpuTimerObj;
typedef int (*SceKernelCallbackFunction)(int notifyId, int notifyCount, int notifyArg, void *common);
typedef struct _SceCallbackObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int attr_1C;
int unk20;
int unk24;
SceKernelCallbackFunction func_28;
int unk2C;
int unk30;
int unk34;
void *arg_38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceCallbackObj;
typedef struct _SceRegisterCallbackObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
} SceRegisterCallbackObj;
typedef struct _SceThreadObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int attr_unk20;
int unk_24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
SceUID pid_60;
int unk_64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
int unk80;
int unk84;
int unk88;
int unk8C;
int unk90;
int unk94;
int unk98;
int unk9C;
int unkA0;
int unkA4;
int unkA8;
int unkAC;
int unkB0;
int unkB4;
int unkB8;
int unkBC;
int unkC0;
int unkC4;
int unkC8;
int attr_CC;
int attr_D0;
int priority_D4;
int priority_D8;
int unk_DC;
int priority_E0;
int unk_E4;
int unkE8;
int unkEC;
int unkF0;
int unkF4;
int unkF8;
int unkFC;
int unk100;
int unk104;
int unk108;
int unk10C;
int unk110;
int unk114;
int unk118;
int unk11C;
int unk120;
int unk124;
int unk128;
int unk12C;
int unk130;
int unk134;
int unk138;
int unk13C;
int unk140;
int unk144;
int unk148;
int unk14C;
int unk150;
int unk154;
int unk158;
int unk15C;
int unk160;
int unk164;
int unk168;
int unk16C;
int unk170;
int unk174;
int unk178;
int unk17C;
int unk180;
int unk184;
int unk188;
int unk18C;
int unk190;
int unk194;
int unk198;
int unk19C;
int unk1A0;
int unk1A4;
int unk1A8;
int unk1AC;
int unk1B0;
int unk1B4;
int unk1B8;
int unk1BC;
int unk1C0;
int unk1C4;
int unk1C8;
int unk1CC;
int unk1D0;
int unk1D4;
int unk1D8;
int unk1DC;
int unk1E0;
int unk1E4;
int unk1E8;
int unk1EC;
int unk1F0;
int unk1F4;
int unk1F8;
int unk1FC;
} SceThreadObj;
typedef struct _SceThreadEventObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceThreadEventObj;
typedef struct _SceWorkQueueObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int atomic_lock;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
unsigned long long obj_counter;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
SceUID sema_uid;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceWorkQueueObj;
typedef int (*SceKernelWorkQueueWorkFunction)(void *args);
typedef struct _SceWorkTaskObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int atomic_lock;
int unk1C;
int unk20;
int unk24;
SceWorkQueueObj *queue_obj;
int unk2C;
int unk30;
int unk34;
SceUID task_uid;
int unk3C;
unsigned long long obj_counter;
int unk48;
int unk4C;
int some_flag;
int unk54;
SceUID work_queue_uid;
SceKernelWorkQueueWorkFunction func;
void *args;
SceUID current_thread_uid;
int unk68;
int unk6C;
int unk70;
SceUID pid;
int unk78;
int unk7C;
} SceWorkTaskObj;
typedef struct _SceExcpObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
int unk38;
int unk3C;
int unk40;
int unk44;
int unk48;
int unk4C;
int unk50;
int unk54;
int unk58;
int unk5C;
int unk60;
int unk64;
int unk68;
int unk6C;
int unk70;
int unk74;
int unk78;
int unk7C;
} SceExcpObj;
typedef struct _SceEventObj
{
SceObjectBase base;
int unk8;
int unkC;
int unk10;
int unk14;
int unk18;
int unk1C;
int unk20;
int unk24;
int unk28;
int unk2C;
int unk30;
int unk34;
} SceEventObj;
ThreadMgr types
For SceProcessObj
, see SceProcessmgr page.
typedef struct SceKernelFastMutex {
SceUInt8 data[0x40];
} SceKernelFastMutex;
typedef struct IntrRequest {
struct IntrRequest *next;
int type; // In 0-3, 8-0x14, 0x18-0x19
int from_cache; // 0 = alloc from heap, otherwise comes from Threadmgr link list
int padding;
int arguments[4];
} IntrRequest;
typedef struct ThreadMgrCpuCB { // size is 0x880-bytes
ThreadCB *pRunningThreadCB;
ThreadCB *pNextRunningThreadCB;
int data_0x08;
struct {
SceUID pid;
SceUID thid;
} current[2];
SceUInt32 currentThreadPriority;
struct {
ThreadCB *next;
ThreadCB *prev;
} standbyList;
SceKernelSpinlock lock;
int unk_2C[2];
ThreadCB *pIdleThreadCB; // idle thread for this CPU
SceUInt64 unk_38;
IntrRequest *intrRequestQueue;
int unk_44;
void *SwitchStackBlock_base; // 0x1000 size - idk what for
SceUInt8 unk_4C[0x14];
SceUInt32 priorityQueueBitmap[0x20 / sizeof(SceUInt32)];
struct {
ThreadCB *next;
ThreadCB *prev;
} priorityQueue[0x100];
} ThreadMgrCpuCB;
typedef struct SceKernelThreadmgrPrivate { // size is 0x28B8-bytes
ThreadMgrCpuCB cpuCB[4];
SceKernelSpinlock threadMgrCBLock;
SceUInt8 data[0x6B4];
} SceKernelThreadmgrPrivate;
typedef struct SceKernelThreadStatus { // size is 0x100
int mode; // kernel:0, user:1
unsigned int reg[0xF];
unsigned int cpsr_kern;
int unk_0x44; // maybe DACR for user
int unk_0x48; // maybe DACR for kernel
int unk_0x4C; // ex:0xF00000
int unk_0x50;
void *ptr_0x54; // maybe user tls?
unsigned int TTBR1;
unsigned int unk_0x5C; // maybe cpu ctx
int unk_0x60;
unsigned int ptr_0x64; // maybe paddr
int unk_0x68;
int unk_0x6C;
int unk_0x70;
int unk_0x74;
int unk_0x78;
int unk_0x7C;
int unk_0x80;
int unk_0x84;
int unk_0x88;
int unk_0x8C;
int unk_0x90;
int unk_0x94;
int unk_0x98;
int unk_0x9C;
int unk_0xA0;
int unk_0xA4;
int unk_0xA8; // ex:0x8F5
int unk_0xAC;
unsigned int DFAR;
int unk_0xB4;
int unk_0xB8; // ex:0x2000, some size?
int unk_0xBC; // ex:user(0xFF), kernel(0xF0)? maybe?
const void *pc;
unsigned int cpsr;
unsigned int unk_0xC8; // fpcr?
int unk_0xCC;
int unk_0xD0;
int unk_0xD4;
int unk_0xD8;
int unk_0xDC;
int unk_0xE0;
int unk_0xE4;
int unk_0xE8;
int unk_0xEC;
int unk_0xF0;
int unk_0xF4;
int unk_0xF8;
int unk_0xFC;
} SceKernelThreadStatus;
typedef struct SceKernelThreadFloatRegister { // size is 0x100
union {
unsigned int s_reg_i[0x40];
float s_reg_f[0x40];
uint64_t d_reg_i[0x20];
double d_reg_f[0x20];
};
} SceKernelThreadFloatRegister;
typedef struct SceKernelThreadNeonInfo { // size is 0x120
SceKernelThreadFloatRegister float_register;
unsigned int fpscr;
unsigned int fpexc;
unsigned int unk_0x108;
unsigned int unk_0x10C;
unsigned int unk_0x110;
unsigned int unk_0x114;
unsigned int unk_0x118;
unsigned int unk_0x11C;
} SceKernelThreadNeonInfo;
typedef struct SceKernelThreadRegisterInfo { // size is 0x60
unsigned int reg[0xD];
unsigned int unk_0x34;
unsigned int unk_0x38; // ex:0xB90B45
unsigned int fpscr;
unsigned int unk_0x40;
unsigned int unk_0x44;
unsigned int unk_0x48;
unsigned int unk_0x4C;
unsigned int sp;
unsigned int lr;
unsigned int pc;
unsigned int cpsr;
} SceKernelThreadRegisterInfo;
typedef struct SceKernelThreadInfoInternal { // size is 0x128
SceSize size;
SceUID thid_user;
SceUID processId;
// offset:0xC
char name[0x20];
int pad_0x2C;
// offset:0x30
SceUInt attr;
int status;
SceKernelThreadEntry entry;
void *stack;
// offset:0x40
SceSize stackSize;
int unk_0x44;
int unk_0x48;
void *kernel_stack;
// offset:0x50
SceSize kernel_stack_size;
int unk_0x54;
int unk_0x58;
int unk_0x5C;
// offset:0x60
int unk_0x60;
int unk_0x64;
int unk_0x68;
void *ptr_0x6C; // kernel tls?
// offset:0x70
int unk_0x70;
int unk_0x74;
int initPriority;
int currentPriority;
// offset:0x80
int initCpuAffinityMask;
int currentCpuAffinityMask;
int unk_0x88;
int currentCpuId;
// offset:0x90
int lastExecutedCpuId;
int waitType; // maybe
int unk_0x98;
SceKernelSysClock runClocks;
int exitStatus;
int unk_0xA8; // IsThreadDebugSuspended
SceUInt intrPreemptCount;
// offset:0xB0
SceUInt threadPreemptCount;
SceUInt threadReleaseCount;
SceUID fNotifyCallback;
int reserved;
SceKernelThreadStatus *pStatus;
SceKernelThreadNeonInfo *pNeonInfo;
SceKernelThreadRegisterInfo *pUserRegisterInfo; // Is it set only when cause(0x10009)?
int unk_0xCC;
void *pUserTLS;
int unk_0xD4;
int unk_0xD8;
void *ptr_0xDC;
int unk_0xE0;
int unk_0xE4;
int unk_0xE8;
int unk_0xEC;
int unk_0xF0;
int unk_0xF4;
int unk_0xF8;
int unk_0xFC;
void *ptr_0x100;
int unk_0x104;
int unk_0x108;
int unk_0x10C;
int unk_0x110;
int unk_0x114;
int unk_0x118;
int unk_0x11C;
int unk_0x120;
int unk_0x124;
} __attribute__((packed)) SceKernelThreadInfoInternal;
/** @name Basic thread functions
*/
/*@{*/
/**
* @defgroup Thread attributes
* Defining thread attributes
* Specified in attr argument of sceKernelCreateThread()
*/
/*@{*/
#define SCE_KERNEL_THREAD_ATTR_NOUSE_VFP (0x01000000U) /**< Do not use VFP */
#define SCE_KERNEL_THREAD_ATTR_VM (0x04000000U) /**< (Unofficial name) Virtual Machine thread (can use ForVM functions on it) */
/*@}*/
/**
* @defgroup Thread priority
* Defining thread priorities
*/
/*@{*/
#define SCE_KERNEL_HIGHEST_PRIORITY_USER (64) /**< Highest priority of user mode threads */
#define SCE_KERNEL_LOWEST_PRIORITY_USER (191) /**< Lowest priority of user mode threads */
#define SCE_KERNEL_DEFAULT_PRIORITY ((SceInt32)0x10000100) /**< Default priority (whole system) */
#define SCE_KERNEL_INDIVIDUAL_QUEUE_HIGHEST_PRIORITY (64) /**< Highest priority of individual queue area */
#define SCE_KERNEL_INDIVIDUAL_QUEUE_LOWEST_PRIORITY (127) /**< Lowest priority of individual queue area */
#define SCE_KERNEL_COMMON_QUEUE_HIGHEST_PRIORITY (128) /**< Highest priority of common queue area */
#define SCE_KERNEL_COMMON_QUEUE_LOWEST_PRIORITY (191) /**< Lowest priority of common queue area */
/**
* Default priority (for users)
* The default priority for game applications is converted to 160 internally.
* You can also specify the default value ± offset (SCE_KERNEL_DEFAULT_PRIORITY_USER-10).
*/
#define SCE_KERNEL_DEFAULT_PRIORITY_USER SCE_KERNEL_DEFAULT_PRIORITY
#define SCE_KERNEL_CURRENT_THREAD_PRIORITY (0) /**< The priority of the currently executing thread */
/*@}*/
/**
* @defgroup Thread stack size
* Defining thread stack size
*/
/*@{*/
#define SCE_KERNEL_STACK_SIZE_MAX SCE_KERNEL_1MiB /**< Maximum stack size */
#define SCE_KERNEL_STACK_SIZE_MIN SCE_KERNEL_4KiB /**< Minimum stack size */
#define SCE_KERNEL_STACK_SIZE_DEFAULT SCE_KERNEL_STACK_SIZE_MIN /**< Default stack size */
#define SCE_KERNEL_STACK_SIZE_DEFAULT_USER_MAIN (0x00040000) /**< Default stack size of user main thread (byte) */
#define SCE_KERNEL_THREAD_STACK_SIZE_MAX SCE_KERNEL_32MiB /**< Maximum stack size */
#define SCE_KERNEL_THREAD_STACK_SIZE_MIN SCE_KERNEL_4KiB /**< Minimum stack size */
#define SCE_KERNEL_THREAD_STACK_SIZE_DEFAULT SCE_KERNEL_THREAD_STACK_SIZE_MIN /**< Default stack size */
#define SCE_KERNEL_THREAD_STACK_SIZE_DEFAULT_USER_MAIN SCE_KERNEL_256KiB /**< Default stack size of user main thread (byte) */
/*@}*/
/**
* @defgroup Thread state
* Defining thread state
*/
/*@{*/
#define SCE_KERNEL_THREAD_STATUS_RUNNING (0x00000001U) /**< RUNNING status */
#define SCE_KERNEL_THREAD_STATUS_READY (0x00000002U) /**< READY status */
#define SCE_KERNEL_THREAD_STATUS_STANDBY (0x00000004U) /**< STANDBY status */
#define SCE_KERNEL_THREAD_STATUS_WAITING (0x00000008U) /**< WAITING status */
#define SCE_KERNEL_THREAD_STATUS_DORMANT (0x00000010U) /**< DORMANT status */
#define SCE_KERNEL_THREAD_STATUS_DELETED (0x00000020U) /**< DELETED status */
#define SCE_KERNEL_THREAD_STATUS_DEAD (0x00000040U) /**< DEAD status */
#define SCE_KERNEL_THREAD_STATUS_STAGNANT (0x00000080U) /**< STAGNANT status */
#define SCE_KERNEL_THREAD_STATUS_SUSPENDED (0x00000100U) /**< SUSPENDED status */
#define SCE_KERNEL_THREAD_STATUS_MASK (0x0000ffffU) /**< Valid thread state mask */
/*@}*/
/**
* @defgroup Thread wait type
* Defining thread wait types
*/
/*@{*/
#if SCE_PSP2_SDK_VERSION < 0x01000000
#define SCE_KERNEL_WAITTYPE_DELAY (0x00000001) /**< Thread delay */
#define SCE_KERNEL_WAITTYPE_WAITTHEND (0x00000002) /**< End of thread */
#define SCE_KERNEL_WAITTYPE_EVENTFLAG (0x00000004) /**< Event flag */
#define SCE_KERNEL_WAITTYPE_MUTEX (0x00000008) /**< Mutex */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX (0x00000010) /**< Fast mutex */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX_SPIN (0x00000020) /**< Fast mutex (spin) */
#define SCE_KERNEL_WAITTYPE_SEMAPHORE (0x00000040) /**< Semaphore */
#define SCE_KERNEL_WAITTYPE_EVENT (0x00000080) /**< Single event */
#define SCE_KERNEL_WAITTYPE_COND (0x00000100) /**< Condition variable */
#define SCE_KERNEL_WAITTYPE_MSG_PIPE (0x00000200) /**< Message pipe */
#define SCE_KERNEL_WAITTYPE_RW_LOCK (0x00000400) /**< Reader / writer lock */
#define SCE_KERNEL_WAITTYPE_SIGNAL (0x00000800) /**< Signal */
#define SCE_KERNEL_WAITTYPE_LW_MUTEX (0x00001000) /**< Lightweight mutex */
#define SCE_KERNEL_WAITTYPE_LW_COND (0x00002000) /**< Lightweight condition variable */
#define SCE_KERNEL_WAITTYPE_MP_EVENTS (0x00008000) /**< Event multiplexing */
#define SCE_KERNEL_WAITTYPE_DELAY_CB (0x00010001) /**< With thread delay callback check */
#define SCE_KERNEL_WAITTYPE_WAITTHEND_CB (0x00010002) /**< With thread termination callback check */
#define SCE_KERNEL_WAITTYPE_EVENTFLAG_CB (0x00010004) /**< With event flag callback check */
#define SCE_KERNEL_WAITTYPE_MUTEX_CB (0x00010008) /**< With mutex callback check */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX_CB (0x00010010) /**< With fast mutex callback check */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX_SPIN_CB (0x00010020) /**< With fast mutex (spin) callback check */
#define SCE_KERNEL_WAITTYPE_SEMAPHORE_CB (0x00010040) /**< With semaphore callback check */
#define SCE_KERNEL_WAITTYPE_EVENT_CB (0x00010080) /**< With single event callback check */
#define SCE_KERNEL_WAITTYPE_COND_CB (0x00010100) /**< With condition variable callback check */
#define SCE_KERNEL_WAITTYPE_MSG_PIPE_CB (0x00010200) /**< With message pipe callback check */
#define SCE_KERNEL_WAITTYPE_RW_LOCK_CB (0x00010400) /**< With reader / writer lock callback check */
#define SCE_KERNEL_WAITTYPE_SIGNAL_CB (0x00010800) /**< With signal callback check */
#define SCE_KERNEL_WAITTYPE_LW_MUTEX_CB (0x00011000) /**< With lightweight mutex callback check */
#define SCE_KERNEL_WAITTYPE_LW_COND_CB (0x00012000) /**< With lightweight condition variable callback check */
#define SCE_KERNEL_WAITTYPE_MP_EVENTS_CB (0x00018000) /**< With event multiplexing callback check */
#else
#define SCE_KERNEL_WAITTYPE_DELAY (0x00000001U) /**< Thread delay */
#define SCE_KERNEL_WAITTYPE_WAITTHEND (0x00000002U) /**< End of thread */
#define SCE_KERNEL_WAITTYPE_SIGNAL (0x00000004U) /**< Signal */
#define SCE_KERNEL_WAITTYPE_WAITTHSUSPEND (0x00000008U) /**< Suspend thread */
#define SCE_KERNEL_WAITTYPE_EVENTFLAG (0x00000010U) /**< Event flag */
#define SCE_KERNEL_WAITTYPE_SEMAPHORE (0x00000020U) /**< Semaphore */
#define SCE_KERNEL_WAITTYPE_MUTEX (0x00000040U) /**< Mutex */
#define SCE_KERNEL_WAITTYPE_RW_LOCK (0x00000080U) /**< Reader / writer lock */
#define SCE_KERNEL_WAITTYPE_COND_SIGNAL (0x00000100U) /**< Condition variable (signal) */
#define SCE_KERNEL_WAITTYPE_COND_MUTEX (0x00000200U) /**< Condition variable (mutex) */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX (0x00001000U) /**< Fast mutex */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX_SPIN (0x00002000U) /**< Fast mutex (spin) */
#define SCE_KERNEL_WAITTYPE_EVENT (0x00010000U) /**< Single event */
#define SCE_KERNEL_WAITTYPE_MP_EVENTS (0x00020000U) /**< Event multiplexing */
#define SCE_KERNEL_WAITTYPE_MSG_PIPE (0x00040000U) /**< Message pipe */
#define SCE_KERNEL_WAITTYPE_LW_MUTEX (0x00100000U) /**< Lightweight mutex */
#define SCE_KERNEL_WAITTYPE_LW_COND_SIGNAL (0x00200000U) /**< Lightweight condition variable (signal) */
#define SCE_KERNEL_WAITTYPE_LW_COND_LW_MUTEX (0x00400000U) /**< Lightweight condition variable (mutex) */
#define SCE_KERNEL_WAITTYPE_DELAY_CB (0x80000001U) /**< With thread delay callback check */
#define SCE_KERNEL_WAITTYPE_WAITTHEND_CB (0x80000002U) /**< With thread termination callback check */
#define SCE_KERNEL_WAITTYPE_SIGNAL_CB (0x80000004U) /**< With signal callback check */
#define SCE_KERNEL_WAITTYPE_WAITTHSUSPEND_CB (0x80000008U) /**< With suspend thread callback check */
#define SCE_KERNEL_WAITTYPE_EVENTFLAG_CB (0x80000010U) /**< With event flag callback check */
#define SCE_KERNEL_WAITTYPE_SEMAPHORE_CB (0x80000020U) /**< With semaphore callback check */
#define SCE_KERNEL_WAITTYPE_MUTEX_CB (0x80000040U) /**< With mutex callback check */
#define SCE_KERNEL_WAITTYPE_RW_LOCK_CB (0x80000080U) /**< With reader / writer lock callback check */
#define SCE_KERNEL_WAITTYPE_COND_SIGNAL_CB (0x80000100U) /**< With condition variable (signal) callback check */
#define SCE_KERNEL_WAITTYPE_COND_MUTEX_CB (0x80000200U) /**< With condition variable (mutex) callback check */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX_CB (0x80001000U) /**< With fast mutex callback check */
#define SCE_KERNEL_WAITTYPE_FAST_MUTEX_SPIN_CB (0x80002000U) /**< With fast mutex (spin) callback check */
#define SCE_KERNEL_WAITTYPE_EVENT_CB (0x80010000U) /**< With single event callback check */
#define SCE_KERNEL_WAITTYPE_MP_EVENTS_CB (0x80020000U) /**< With event multiplexing callback check */
#define SCE_KERNEL_WAITTYPE_MSG_PIPE_CB (0x80040000U) /**< With message pipe callback check */
#define SCE_KERNEL_WAITTYPE_LW_MUTEX_CB (0x80100000U) /**< With lightweight mutex callback check */
#define SCE_KERNEL_WAITTYPE_LW_COND_SIGNAL_CB (0x80200000U) /**< With lightweight condition variable (signal) callback check */
#define SCE_KERNEL_WAITTYPE_LW_COND_LW_MUTEX_CB (0x80400000U) /**< With lightweight condition variable (mutex) callback check */
#endif
/*@}*/
/**
* @defgroup UID
* Thread ID definition
*/
/*@{*/
#define SCE_KERNEL_THREAD_ID_SELF (0) /**< UID representing own thread */
/*@}*/
/**
* @defgroup UID class
* Class definition of UID managed by thread manager (for User)
*/
/*@{*/
#define SCE_KERNEL_THREADMGR_UID_CLASS_THREAD (1) /**< Thread class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_SEMA (2) /**< Semaphore class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_EVENT_FLAG (3) /**< Event flag class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_MUTEX (4) /**< Mutex class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_COND (5) /**< Condition variable class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_TIMER (6) /**< Timer class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_MSG_PIPE (7) /**< Message pipe class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_CALLBACK (8) /**< Callback class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_THREAD_EVENT (9) /**< Thread event class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_LW_MUTEX (10) /**< Lightweight mutex class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_LW_COND (11) /**< Lightweight condition variable class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_RW_LOCK (12) /**< Reader / writer lock class */
#define SCE_KERNEL_THREADMGR_UID_CLASS_SIMPLE_EVENT (13) /**< Simple event class */
/*@}*/
/**
* @defgroup CPU affinity mask
* CPU affinity mask definition
*/
/*@{*/
/**
* @brief Default CPU affinity mask
*
* If the default CPU affinity mask is specified for a thread,
* the CPU affinity mask specified for the process to which it belongs is inherited.
*/
#define SCE_KERNEL_THREAD_CPU_AFFINITY_MASK_DEFAULT (0)
/*@}*/
/**
* @brief Thread entry type
*
* Thread entry function type. Specify to sceKernelCreateThread().
* The argument block of the thread given by the argument of sceKernelStartThread() is copied onto the
* stack of the started thread, and is received from the started thread through the argument of the entry function.
*
* When a thread entry function is terminated with return, the thread terminates,
* and the return value of the entry function becomes the termination status of that thread.
* The thread exit status can be obtained with sceKernelWaitThreadEnd() or
* sceKernelGetThreadExitStatus() if the thread is not deleted.
*
* @param argSize The argument size given by sceKernelStartThread() is passed.
* @param pArgBlock The address on the stack where the argument block given by sceKernelStartThread() is copied is passed.
* @return Thread exit status
*/
typedef SceInt32 (*SceKernelThreadEntry)(SceSize argSize, void *pArgBlock);
/**
* @brief Stack change function type
*
* The type of function to call when the stack changes. Specify to sceKernelCallWithChangeStack().
*
* With sceKernelCallWithChangeStack(), the stack is switched as soon as the stack change function is called.
* As soon as the stack change function ends with return, it returns to the original stack.
*
* @param pArg Arbitrary pointer to pass to stack change function
* @return Return value of sceKernelCallWithChangeStack()
*/
typedef SceInt32 (*SceKernelChangeStackFunction)(void *pArg);
/**
* @brief Thread additional data
*
* This structure is used to store additional data given when creating a thread with sceKernelCreateThread().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelThreadOptParam { // Min size is 4 bytes. Max size is 0x14 bytes.
SceSize size; /**< Size of this structure (sizeof(SceKernelThreadOptParam)) */
SceUInt32 attr; /**< A bit pattern that specifies valid members in a structure */
SceUInt32 kStackMemType;
SceUInt32 uStackMemType;
SceUInt32 uTLSMemType;
SceUInt32 uStackMemid;
SceUInt32 data_0x18;
} SceKernelThreadOptParam;
/**
* @brief Thread information structure
*
* A structure used to store thread information with sceKernelGetThreadInfo().
*/
typedef struct _SceKernelThreadInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelThreadInfo)) */
SceUID processId; /**< Process ID to which the thread belongs */
char name[SCE_UID_NAMELEN+1]; /**< Thread name */
SceUInt32 attr; /**< Thread attributes */
SceUInt32 status; /**< Thread state */
SceKernelThreadEntry entry; /**< Thread entry function address */
void *pStack; /**< Thread stack address (bottom) */
SceSize stackSize; /**< Thread stack size */
SceInt32 initPriority; /**< Thread initial priority */
SceInt32 currentPriority; /**< Thread current priority */
SceInt32 initCpuAffinityMask; /**< Thread initial CPU affinity mask */
SceInt32 currentCpuAffinityMask; /**< Thread current CPU affinity mask */
SceInt32 currentCpuId; /**< CPU number to which the thread currently belongs */
SceInt32 lastExecutedCpuId; /**< CPU number to which the thread was last executed */
SceUInt32 waitType; /**< Type when the thread is waiting */
SceUID waitId; /**< UID of the target synchronization object when the thread is waiting */
SceInt32 exitStatus; /**< Thread exit status */
SceKernelSysClock runClocks; /**< Time (in microseconds) executed since the thread was created */
SceUInt32 intrPreemptCount; /**< Number of times the thread was preempted by interrupt handling */
SceUInt32 threadPreemptCount; /**< Number of times the thread has been preempted by other thread operations */
SceUInt32 threadReleaseCount; /**< Number of times the thread has relinquished execution */
SceInt32 changeCpuCount; /**< Number of CPUs to which the thread is moved */
SceInt32 fNotifyCallback; /**< A flag indicating whether the thread is notified of the callback */
SceInt32 reserved; /**< Reserved area */
} SceKernelThreadInfo;
/**
* @brief Thread operating status on each CPU
*
* This structure is used by sceKernelGetThreadRunStatus() to obtain the operating status of threads on each CPU.
*
*/
typedef struct _SceKernelThreadRunStatus {
SceSize size; /**< Size of this structure (sizeof(SceKernelThreadRunStatus)) */
struct {
SceUID processId; /**< Process ID to which the running thread belongs */
SceUID threadId; /**< Thread ID being executed */
SceInt32 priority; /**< Priority of the running thread */
} cpuInfo[SCE_KERNEL_MAX_CPU]; /**< Information about individual CPUs */
} SceKernelThreadRunStatus;
/**
* @brief System state
*
* This structure is used to get the system status with sceKernelGetSystemInfo().
*
*/
typedef struct _SceKernelSystemInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelSystemInfo)) */
SceUInt32 activeCpuMask; /**< Currently available CPU mask */
struct {
SceKernelSysClock idleClock; /**< Time when there was no thread to execute */
SceUInt32 comesOutOfIdleCount; /**< Number of transitions from a state where there is no thread to execute to another state */
SceUInt32 threadSwitchCount; /**< Number of context switches that occurred */
} cpuInfo[SCE_KERNEL_MAX_CPU]; /**< Information about individual CPUs */
} SceKernelSystemInfo;
/*@}*//* Basic thread functions */
/** @name VFP exception
*/
/*@{*/
/**
* @defgroup Defining VFP exceptions
* Bit pattern that specifies a VFP exception
*/
/*@{*/
#define SCE_KERNEL_VFP_EXCEPTION_MASK_QCE (0x08000000U) /**< QCE flag interrupt enable */
#define SCE_KERNEL_VFP_EXCEPTION_MASK_IDE (0x00000080U) /**< IDE flag interrupt enable */
#define SCE_KERNEL_VFP_EXCEPTION_MASK_IXE (0x00000010U) /**< IXE flag interrupt enable */
#define SCE_KERNEL_VFP_EXCEPTION_MASK_UFE (0x00000008U) /**< UFE flag interrupt enable */
#define SCE_KERNEL_VFP_EXCEPTION_MASK_OFE (0x00000004U) /**< OFE flag interrupt enable */
#define SCE_KERNEL_VFP_EXCEPTION_MASK_DZE (0x00000002U) /**< DZE flag interrupt enable */
#define SCE_KERNEL_VFP_EXCEPTION_MASK_IOE (0x00000001U) /**< IOE flag interrupt enable */
/**
* Valid VFP exception mask
*/
#define SCE_KERNEL_VFP_EXCEPTION_MASK_ALL (SCE_KERNEL_VFP_EXCEPTION_MASK_QCE | SCE_KERNEL_VFP_EXCEPTION_MASK_IDE | \
SCE_KERNEL_VFP_EXCEPTION_MASK_IXE | SCE_KERNEL_VFP_EXCEPTION_MASK_UFE | \
SCE_KERNEL_VFP_EXCEPTION_MASK_OFE | SCE_KERNEL_VFP_EXCEPTION_MASK_DZE | \
SCE_KERNEL_VFP_EXCEPTION_MASK_IOE)
/*@}*/
/*@}*//* VFP exception */
/** @name Common to synchronization
*/
/*@{*/
/**
* @defgroup Synchronization object common attributes
* Attributes that can be set in common with synchronization objects
*/
/*@{*/
#define SCE_KERNEL_ATTR_SINGLE (0x00000000U) /**< Multiple threads cannot wait simultaneously (event flags only) */
#define SCE_KERNEL_ATTR_MULTI (0x00001000U) /**< Multiple threads can wait at the same time (event flags only) */
#define SCE_KERNEL_ATTR_TH_FIFO (0x00000000U) /**< Waiting thread queuing is FIFO */
#define SCE_KERNEL_ATTR_TH_PRIO (0x00002000U) /**< Queues for waiting threads are ordered by thread priority */
#define SCE_KERNEL_ATTR_MS_FIFO (0x00000000U) /**< Unused */
#define SCE_KERNEL_ATTR_MS_PRIO (0x00000000U) /**< Unused */
#define SCE_KERNEL_ATTR_OPENABLE (0x00000080U) /**< Object can be referenced */
/*@}*/
/**
* @defgroup Referencing synchronization objects
* Definitions for references to synchronization objects
*/
/*@{*/
#define SCE_KERNEL_OPEN_LIMIT_MAX (127) /**< Maximum value that can be specified when limiting the number of simultaneous references of synchronization objects */
/*@}*/
/*@}*//* Common to synchronization */
/** @name Callback
*/
/*@{*/
/**
* @brief Callback function type
*
* After the callback function is notified by sceKernelNotifyCallback(), the callback function
* confirms the notification by sceKernelCheckCallback() or executes a waiting function with a
* function to check for notifications such as sceKernelWaitSemaCB().
* It is possible to delete your own registration by returning a value other than 0 as the return value of the callback function.
*
* Note
* - The callback function is called as the context of the thread that generated the callback.
* In other words, the callback function can be called only by the callback generated by the own thread by the explicit callback
* check by sceKernelCheckCallback() or the wait function with callback check such as sceKernelWaitSemaCB(). is. To receive
* the callback notification, the thread that generated the callback must use sceKernelCheckCallback(), sceKernelWaitSemaCB(), etc.
* - The sceKernelCheckCallback() and sceKernelDeleteCallback() functions cannot be used inside the callback function.
* In addition, if you call a wait function with CB such as sceKernelWaitSemaCB() function in the callback function, nesting occurs, causing a stack overflow.
* Avoid processing that waits for more callbacks in the callback function.
*
* @param notifyId When a callback is notified from an event that registered a callback with sceKernelRegisterCallbackToEvent(),
* the identifier of the notification source event is passed.
* If not notified from the event, SCE_UID_INVALID_UID is passed.
* @param notifyCount Number of callback notifications until this callback function is executed is passed.
* @param notifyArg Argument given by sceKernelNotifyCallback() is passed.
* @param pCommon Argument given by sceKernelCreateCallback() is passed.
* @retval 0 Normal
* @retval Non-zero value Remove this callback
*/
typedef SceInt32 (*SceKernelCallbackFunction)(SceUID notifyId, SceInt32 notifyCount, SceInt32 notifyArg, void *pCommon);
/**
* @brief Callback state
*
* This structure is used to get the callback status with sceKernelGetCallbackInfo().
*/
typedef struct _SceKernelCallbackInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelCallbackInfo) */
SceUID callbackId; /**< Callback identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the callback specified with sceKernelCreateCallback() */
SceUInt32 attr; /**< Callback attribute specified by sceKernelCreateCallback() */
SceUID threadId; /**< Identifier of the thread to which the callback belongs */
SceKernelCallbackFunction callbackFunc; /**< Callback function registered with sceKernelCreateCallback() */
SceUID notifyId; /**< Caller notification source identifier */
SceInt32 notifyCount; /**< Number of times sceKernelNotifyCallback() has been executed for this callback that is still delayed without the callback function being called */
SceInt32 notifyArg; /**< Argument given by sceKernelNotifyCallback() for this callback */
void *pCommon; /**< pCommon argument registered with sceKernelCreateCallback() */
} SceKernelCallbackInfo;
/*@}*//* Callback */
/** @name Thread event
*/
/*@{*/
/**
* @defgroup Thread event handler type
* Defining thread events that trigger thread event handlers
*/
/*@{*/
#define SCE_KERNEL_THREAD_EVENT_TYPE_START (0x04) /**< Thread start event */
#define SCE_KERNEL_THREAD_EVENT_TYPE_EXIT (0x08) /**< Thread end event */
/**
* Valid thread event mask
*/
#define SCE_KERNEL_THREAD_EVENT_TYPE_ALL (SCE_KERNEL_THREAD_EVENT_TYPE_START | SCE_KERNEL_THREAD_EVENT_TYPE_EXIT)
/*@}*/
/**
* @defgroup Thread specification for thread event handler
* Thread specification macro in sceKernelRegisterThreadEventHandler()
*/
/*@{*/
#define SCE_KERNEL_THREAD_ID_USER ((SceUID)0xfffffff0) /**< Specify all user threads */
/*@}*/
/**
* @brief Thread event handler type
*
* Thread event handler type.
* @param type The thread event handler call cause is passed.
* - SCE_KERNEL_THREAD_EVENT_TYPE_START: thread started
* - SCE_KERNEL_THREAD_EVENT_TYPE_EXIT : thread terminated
* @param threadId Identifier of the thread that caused the thread event handler to be called is passed.
* @param arg Argument when calling the thread event handler is passed.
* @param pCommon pCommon specified in sceKernelRegisterThreadEventHandler() is passed as it is.
* @retval SCE_OK Success
* @retval Any value other than SCE_OK Remove this thread event handler
*/
typedef SceInt32 (*SceKernelThreadEventHandler)(SceInt32 type, SceUID threadId, SceInt32 arg, void *pCommon);
/*@}*//* Thread event */
/** @name An event
*/
/*@{*/
/**
* @defgroup Event object attributes
* Definition of attributes to be specified when creating an event object
*/
/*@{*/
#define SCE_KERNEL_EVENT_ATTR_MANUAL_RESET (0x00000000U) /**< Each bit of the event remains in the event notification state until it is manually transitioned to the event non notification state. */
#define SCE_KERNEL_EVENT_ATTR_AUTO_RESET (0x00000100U) /**< Each bit of the event automatically returns to the event non notification state when one waiting thread is woken up. */
#define SCE_KERNEL_ATTR_NOTIFY_CB_ALL (0x00000000U) /**< When an event is notified, all callbacks registered in the event object are notified. */
#define SCE_KERNEL_ATTR_NOTIFY_CB_WAKEUP_ONLY (0x00000800U) /**< When an event is notified, only the callback of the thread that is waiting for the event and wakes up among the callbacks registered in the event object is notified. */
/*@}*/
/**
* @defgroup Event type
* Definition of event to be notified
*/
/*@{*/
#define SCE_KERNEL_EVENT_IN (0x00000001U) /* Input event */
#define SCE_KERNEL_EVENT_OUT (0x00000002U) /* Output event */
#define SCE_KERNEL_EVENT_CREATE (0x00000004U) /* Generate event */
#define SCE_KERNEL_EVENT_DELETE (0x00000008U) /* Delete event */
#define SCE_KERNEL_EVENT_ERROR (0x00000010U) /* Error event */
#define SCE_KERNEL_EVENT_OPEN (0x00000100U) /* Reference event */
#define SCE_KERNEL_EVENT_CLOSE (0x00000200U) /* Reference end event */
#define SCE_KERNEL_EVENT_TIMER (0x00008000U) /* Timer event */
#define SCE_KERNEL_EVENT_DATA_EXIST (0x00010000U) /* Event that is notified when data exists in the message pipe buffer (level trigger) */
#define SCE_KERNEL_EVENT_USER_DEFINED_MASK (0xff000000U) /* User-defined event mask */
/*@}*/
/**
* @brief Event object state
*
* This structure is used to acquire the event object status with sceKernelGetEventInfo().
*/
typedef struct _SceKernelEventInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelEventInfo)) */
SceUID eventId; /**< Event object identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the event specified when creating the event object */
SceUInt32 attr; /**< Event attributes specified when creating the event object */
SceUInt32 eventPattern; /**< Bit pattern of the current event */
SceUInt64 userData; /**< User data added to the last notified event */
SceUInt32 numWaitThreads; /**< Number of threads waiting for the event object */
SceInt32 reserved[1]; /**< Reserved area */
} SceKernelEventInfo;
/**
* @defgroup Standby mode for event object multiple standby
* Definition of standby mode specified in sceKernelWaitMultipleEvents()
*/
/*@{*/
#define SCE_KERNEL_EVENT_WAIT_MODE_OR (0x00000001U) /**< Wait until one of the waits specified in the event wait condition list is met */
#define SCE_KERNEL_EVENT_WAIT_MODE_AND (0x00000002U) /**< Wait until all waits specified in the event wait condition list are satisfied */
/*@}*/
/**
* @brief Structure for event wait condition list
*
* Structure for event waiting condition list passed to sceKernelWaitMultipleEvents().
*/
typedef struct _SceKernelWaitEvent {
SceUID eventId; /**< Event object identifier */
SceUInt32 eventPattern; /**< Pattern of events to wait */
} SceKernelWaitEvent;
/**
* @brief Structure for event waiting result acquisition list
*
* Structure for event waiting result acquisition list to be passed to sceKernelWaitMultipleEvents().
*/
typedef struct _SceKernelResultEvent {
SceUID eventId; /**< Event object identifier */
SceInt32 result; /**< Wait result (equivalent to return value of sceKernelWaitEvent()) */
SceUInt32 resultPattern; /**< Event pattern when waiting completes */
SceInt32 reserved[1]; /**< Reserved area */
SceUInt64 userData; /**< User data received when waiting completed */
} SceKernelResultEvent;
/*@}*//* An event */
/**
* @name Event flag
*/
/*@{*/
/**
* @defgroup Event flag attributes
* Definition of attributes to be specified when generating eventflags
*/
/*@{*/
#define SCE_KERNEL_EVF_ATTR_TH_FIFO SCE_KERNEL_ATTR_TH_FIFO /**< Event flag waiting thread queuing is FIFO */
#define SCE_KERNEL_EVF_ATTR_TH_PRIO SCE_KERNEL_ATTR_TH_PRIO /**< Event flag waiting threads are queued in order of thread priority. */
#define SCE_KERNEL_EVF_ATTR_SINGLE SCE_KERNEL_ATTR_SINGLE /**< Multiple threads cannot wait at the same time */
#define SCE_KERNEL_EVF_ATTR_MULTI SCE_KERNEL_ATTR_MULTI /**< Multiple threads can wait at the same time */
/*@}*/
/**
* @defgroup Event flag wait mode
* Definition of standby mode specified for eventflag standby
*/
/*@{*/
#define SCE_KERNEL_EVF_WAITMODE_AND (0x00000000U) /**< Waiting for AND */
#define SCE_KERNEL_EVF_WAITMODE_OR (0x00000001U) /**< Waiting for OR */
#define SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL (0x00000002U) /**< Clear all bits after waiting */
#define SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT (0x00000004U) /**< After waiting, clear the bit specified in bitPattern */
/*@}*/
/**
* @brief Additional data for event flag
*
* This structure is used to store additional data to be given when creating an event flag with sceKernelCreateEventFlag().
*
* 将来の拡張のために用意されています。
*
*/
typedef struct _SceKernelEventFlagOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelEventFlagOptParam)) */
} SceKernelEventFlagOptParam;
/**
* @brief Event flag status
*
* This structure is used to acquire the event flag status with sceKernelGetEventFlagInfo().
*
*/
typedef struct _SceKernelEventFlagInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelEventFlagInfo)) */
SceUID evfId; /**< Event flag identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the eventflag specified by sceKernelCreateEventFlag() */
SceUInt32 attr; /**< Event flag attribute specified by sceKernelCreateEventFlag() */
SceUInt32 initPattern; /**< Initial bit pattern of event flag */
SceUInt32 currentPattern; /**< Current bit pattern of event flag */
SceUInt32 numWaitThreads; /**< Number of threads waiting for an event */
} SceKernelEventFlagInfo;
/*@}*//* Event flag */
/**
* @name Semaphore
*/
/*@{*/
/**
* @defgroup Semaphore attributes
* Definition of attributes to be specified when creating a semaphore
*/
/*@{*/
#define SCE_KERNEL_SEMA_ATTR_TH_FIFO SCE_KERNEL_ATTR_TH_FIFO /**< Semaphore waiting thread queuing is FIFO */
#define SCE_KERNEL_SEMA_ATTR_TH_PRIO SCE_KERNEL_ATTR_TH_PRIO /**< Semaphore waiting thread queuing is ordered by thread priority */
/*@}*/
/**
* @brief Additional semaphore data
*
* This structure is used to store additional data given when creating a semaphore with sceKernelCreateSema().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelSemaOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelSemaOptParam)) */
} SceKernelSemaOptParam;
/**
* @brief Semaphore state
*
* This structure is used to get the semaphore status with sceKernelGetSemaInfo().
*
*/
typedef struct _SceKernelSemaInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelSemaInfo)) */
SceUID semaId; /**< Semaphore identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the semaphore specified by sceKernelCreateSema() */
SceUInt32 attr; /**< Semaphore attributes specified with sceKernelCreateSema() */
SceInt32 initCount; /**< Initial number of semaphores specified by sceKernelCreateSema() */
SceInt32 currentCount; /**< Current number of semaphore resources */
SceInt32 maxCount; /**< Maximum number of semaphore resources specified by sceKernelCreateSema() */
SceInt32 numWaitThreads; /**< Number of threads waiting for the semaphore */
} SceKernelSemaInfo;
/*@}*//* Semaphore */
/**
* @name Mutex
*/
/*@{*/
/**
* @defgroup Mutex attribute
* Definition of attributes to be specified when creating a mutex
*/
/*@{*/
#define SCE_KERNEL_MUTEX_ATTR_TH_FIFO SCE_KERNEL_ATTR_TH_FIFO /**< Mutex wait thread queuing is FIFO */
#define SCE_KERNEL_MUTEX_ATTR_TH_PRIO SCE_KERNEL_ATTR_TH_PRIO /**< Mutes waiting threads are queued in order of thread priority */
#define SCE_KERNEL_MUTEX_ATTR_RECURSIVE (0x00000002U) /**< Mutex can be recursively locked */
#define SCE_KERNEL_MUTEX_ATTR_CEILING (0x00000004U) /**< Use the mutex priority sealing function */
/*@}*/
/**
* @brief Mutex additional data
*
* This structure is used to store additional data given when creating mutexes with sceKernelCreateMutex().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelMutexOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelMutexOptParam)) */
SceInt32 ceilingPriority; /**< Priority ceiling priority */
} SceKernelMutexOptParam;
/**
* @brief Mutex state
*
* This structure is used to get the mutex status with sceKernelGetMutexInfo().
*
*/
typedef struct _SceKernelMutexInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelMutexInfo)) */
SceUID mutexId; /**< Mutex identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the mutex specified by sceKernelCreateMutex() */
SceUInt32 attr; /**< Mutex attributes specified with sceKernelCreateMutex() */
SceInt32 initCount; /**< Initial lock count of mutex specified by sceKernelCreateMutex() */
SceInt32 currentCount; /**< Current number of mutex locks */
SceUID currentOwnerId; /**< Identifier of the thread that currently owns the mutex */
SceUInt32 numWaitThreads; /**< Number of threads waiting for the mutex */
SceInt32 ceilingPriority; /**< Priority ceiling priority (0 if priority ceiling function is not used) */
} SceKernelMutexInfo;
/*@}*//* Mutex */
/**
* @name Lightweight mutex
*/
/*@{*/
/**
* @defgroup Lightweight mutex attribute
* Definition of attributes to be specified when creating a lightweight mutex
*/
/*@{*/
#define SCE_KERNEL_LW_MUTEX_ATTR_TH_FIFO SCE_KERNEL_ATTR_TH_FIFO /**< Lightweight mutex wait thread queuing is FIFO */
#define SCE_KERNEL_LW_MUTEX_ATTR_TH_PRIO SCE_KERNEL_ATTR_TH_PRIO /**< Queues for lightweight mutex wait threads are ordered by thread priority */
#define SCE_KERNEL_LW_MUTEX_ATTR_RECURSIVE (0x00000002U) /**< Lightweight mutex can be recursively locked */
/*@}*/
/**
* @brief Light mutex work area
*
* A structure used to store work areas used by lightweight mutexes.
* The lightweight mutex work area must be reserved in the user memory space.
* All operations on the lightweight mutex are performed via the SceKernelLwMutexWork structure.
*
* Since the SceKernelLwMutexWork structure is used as a work area by the kernel, after creating
* a lightweight mutex with sceKernelCreateLwMutex(), the user program must not directly
* reference / manage the contents until it is deleted with sceKernelDeleteLwMutex(). The address cannot be moved.
*
* The SceKernelLwMutexWork structure must be arranged with 8-byte alignment on the memory.
*
*/
typedef struct _SceKernelLwMutexWork {
SceInt64 data[4]; /**< Light mutex work area */
} SceKernelLwMutexWork;
/**
* @brief Additional data for lightweight mutex
*
* This structure is used to store additional data given when creating a lightweight mutex with sceKernelCreateLwMutex().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelLwMutexOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelLwMutexOptParam)) */
} SceKernelLwMutexOptParam;
/**
* @brief Light mutex state
*
* A structure used to obtain the status of a lightweight mutex with sceKernelGetLwMutexInfo().
*
*/
typedef struct _SceKernelLwMutexInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelLwMutexInfo)) */
SceUID uid; /**< Lightweight mutex identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the mutex specified by sceKernelCreateLwMutex() */
SceUInt32 attr; /**< Mutex attributes specified with sceKernelCreateLwMutex() */
SceKernelLwMutexWork *pWork; /**< Mutex work area specified by sceKernelCreateLwMutex() */
SceInt32 initCount; /**< Initial number of lw mutex locks specified by sceKernelCreateLwMutex() */
SceInt32 currentCount; /**< Current lock count of lightweight mutex */
SceUID currentOwnerId; /**< Identifier of the thread that currently owns the lightweight mutex */
SceUInt32 numWaitThreads; /**< Number of threads waiting for the lightweight mutex */
} SceKernelLwMutexInfo;
/*@}*//* Lightweight mutex */
/** @name Condition variable
*/
/*@{*/
/**
* @defgroup Condition variable attributes
* Defining attributes to be specified when creating a condition variable
*/
/*@{*/
#define SCE_KERNEL_COND_ATTR_TH_FIFO SCE_KERNEL_ATTR_TH_FIFO /**< Condition variable wait thread queuing is FIFO */
#define SCE_KERNEL_COND_ATTR_TH_PRIO SCE_KERNEL_ATTR_TH_PRIO /**< Condition variable wait thread queuing is in order of thread priority */
/*@}*/
/**
* @brief Additional data for condition variables
*
* This structure is used to store additional data given when creating a condition variable with sceKernelCreateCond().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelCondOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelMutexOptParam)) */
} SceKernelCondOptParam;
/**
* @brief Condition variable state
*
* This structure is used to acquire the condition variable status with sceKernelGetCondInfo().
*
*/
typedef struct _SceKernelCondInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelCondInfo)) */
SceUID condId; /**< Condition variable identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Condition variable name specified in sceKernelCreateCond() */
SceUInt32 attr; /**< Condition variable attribute specified in sceKernelCreateCond() */
SceUID mutexId; /**< Mutex associated with the condition variable specified by sceKernelCreateCond() */
SceUInt32 numWaitThreads; /**< Number of threads waiting for the condition variable */
} SceKernelCondInfo;
/*@}*//* Condition variable */
/** @name Lightweight condition variable
*/
/*@{*/
/**
* @defgroup Lightweight condition variable attributes
* Definition of attributes to be specified when creating lightweight condition variables
*/
/*@{*/
#define SCE_KERNEL_LW_COND_ATTR_TH_FIFO SCE_KERNEL_ATTR_TH_FIFO /**< Lightweight condition variable waiting thread queuing is FIFO */
#define SCE_KERNEL_LW_COND_ATTR_TH_PRIO SCE_KERNEL_ATTR_TH_PRIO /**< Lightweight condition variable waiting thread queuing is ordered by thread priority */
/*@}*/
/**
* @brief Lightweight condition variable work area
*
* A structure used to store the work area used by the lightweight condition variable.
* The work area for lightweight condition variables must be allocated in the user memory space.
* All operations on lightweight condition variables are done via the SceKernelLwCondWork structure.
*
* Since the SceKernelLwCondWork structure is used as a work area by the kernel, once a
* lightweight condition variable is created with sceKernelCreateLwCond(), the contents must not be directly
* referenced / operated by the user program until it is deleted with sceKernelDeleteLwCond(). The address cannot be moved.
*/
typedef struct _SceKernelLwCondWork {
SceInt32 data[4]; /**< Lightweight condition variable work area */
} SceKernelLwCondWork;
/**
* @brief Additional data for lightweight condition variables
*
* This structure is used to store additional data given when creating a lightweight condition variable with sceKernelCreateLwCond().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelLwCondOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelLwCondOptParam)) */
} SceKernelLwCondOptParam;
/**
* @brief Lightweight condition variable state
*
* sceKernelGetLwCondInfo() is a structure used to obtain the status of a lightweight condition variable.
*
*/
typedef struct _SceKernelLwCondInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelLwCondInfo)) */
SceUID uid; /**< Lightweight condition variable identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the lightweight condition variable specified with sceKernelCreateLwCond() */
SceUInt32 attr; /**< Attributes of lightweight condition variable specified by sceKernelCreateLwCond() */
SceKernelLwCondWork *pWork; /**< Work area of lightweight condition variable specified by sceKernelCreateLwCond() */
SceKernelLwMutexWork *pLwMutex; /**< Lightweight mutex work area associated with the lightweight condition variable specified by sceKernelCreateLwCond() */
SceUInt32 numWaitThreads; /**< Number of threads waiting for lightweight condition variables */
} SceKernelLwCondInfo;
/*@}*//* Lightweight condition variable */
/** @name Timer
*/
/*@{*/
/**
* @defgroup Type of timer event notification
* Defining timer event notification types
*/
/*@{*/
#define SCE_KERNEL_TIMER_TYPE_SET_EVENT (0) /**< Timer is notified by set type event */
#define SCE_KERNEL_TIMER_TYPE_PULSE_EVENT (1) /**< Timer is notified by pulse type event */
/*@}*/
/**
* @brief Additional data for timer
*
* This structure is used to store additional data given when a timer is created with sceKernelCreateTimer().
*
* Provided for future expansion.
*/
typedef struct _SceKernelTimerOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelTimerOptParam)) */
} SceKernelTimerOptParam;
/**
* @brief Timer information
*
* Timer information acquisition structure.
*/
typedef struct _SceKernelTimerInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelTimerInfo)) */
SceUID timerId; /**< Timer identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Timer name specified by sceKernelCreateTimer() */
SceUInt32 attr; /**< Timer attribute specified by sceKernelCreateTimer() */
SceInt32 fActive; /**< Timer start flag (if 1, counter is running) */
SceKernelSysClock baseTime; /**< Timer reference process time */
SceKernelSysClock currentTime; /**< Timer current time */
SceKernelSysClock schedule; /**< Timer next scheduled event notification time (if an event is set) */
SceKernelSysClock interval; /**< Timer event notification interval specified by sceKernelSetTimerEvent() */
SceInt32 type; /**< Timer event notification type specified by sceKernelSetTimerEvent() */
SceInt32 fRepeat; /**< Timer repeat flag specified by sceKernelSetTimerEvent() (1: periodic timer) */
SceUInt32 numWaitThreads; /**< Number of threads waiting for timer */
SceInt32 reserved[1]; /**< Reserved area */
} SceKernelTimerInfo;
/*@}*//* Timer */
/** @name Simple event
*/
/*@{*/
/**
* @brief Simple event additional data
*
* This structure is used to store additional data given when a simple event is generated with sceKernelCreateSimpleEvent().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelSimpleEventOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelSimpleEventOptParam)) */
} SceKernelSimpleEventOptParam;
/*@}*//* Simple event */
/** @name Message pipe
*/
/*@{*/
/**
* @defgroup Message pipe attributes
* Defining message pipe attributes
*/
/*@{*/
#define SCE_KERNEL_MSG_PIPE_ATTR_TH_PRIO_S (0x00000001U) /**< The queue of the message sender's waiting thread is FIFO */
#define SCE_KERNEL_MSG_PIPE_ATTR_TH_PRIO_R (0x00000002U) /**< The queue of the message receiver standby thread is FIFO */
#define SCE_KERNEL_MSG_PIPE_ATTR_TH_PRIO (SCE_KERNEL_MSG_PIPE_ATTR_TH_PRIO_S | SCE_KERNEL_MSG_PIPE_ATTR_TH_PRIO_R) /**< Message queuing wait thread queuing is FIFO */
#define SCE_KERNEL_MSG_PIPE_ATTR_TH_FIFO_S (0x00000004U) /**< Queues for waiting threads on the message sender side are in order of thread priority */
#define SCE_KERNEL_MSG_PIPE_ATTR_TH_FIFO_R (0x00000008U) /**< Queues for message receiver standby threads are ordered by thread priority */
#define SCE_KERNEL_MSG_PIPE_ATTR_TH_FIFO (SCE_KERNEL_MSG_PIPE_ATTR_TH_FIFO_S | SCE_KERNEL_MSG_PIPE_ATTR_TH_FIFO_R) /**< Queues for message send / receive waiting threads are ordered by thread priority */
/*@}*/
/**
* @defgroup Message pipe wait mode
* Message pipe wait mode
*/
/*@{*/
#define SCE_KERNEL_MSG_PIPE_MODE_ASAP (0x00000000U) /**< Complete if you can send and receive even 1 byte of data */
#define SCE_KERNEL_MSG_PIPE_MODE_FULL (0x00000001U) /**< Complete when all data of the specified size has been sent and received */
#define SCE_KERNEL_MSG_PIPE_MODE_WAIT (0x00000000U) /**< Block threads until send / receive processing is complete (synchronous mode) */
#define SCE_KERNEL_MSG_PIPE_MODE_DONT_WAIT (0x00000010U) /**< Issue a send / receive request and return immediately (asynchronous mode) */
#define SCE_KERNEL_MSG_PIPE_MODE_DONT_REMOVE (0x00000100U) /**< Do not delete received data from the pipe (peak processing) */
/*@}*/
/**
* @defgroup Message pipe type
* Defining the pipe buffer type for a message pipe
* Specify which budget to get memory from
*/
/*@{*/
#define SCE_KERNEL_MSG_PIPE_TYPE_USER_MAIN (64) /**< User main area */
#define SCE_KERNEL_MSG_PIPE_TYPE_USER_CDRAM (66) /**< User CDRAM area (not mounted) */
/*@}*/
/**
* @defgroup Message pipe optional attributes
* Macros that can be specified in the attr member of SceKernelMsgPipeOptParam
*/
/*@{*/
#define SCE_KERNEL_MSG_PIPE_OPT_ATTR_OPEN_LIMITATION (0x00000100U) /**< Specify openLimit */
/*@}*/
/**
* Buffer information for message pipe discontinuous data transmission / reception
*
* sceKernelSendMsgPipeVector(), sceKernelSendMsgPipeVectorCB(), sceKernelTrySendMsgPipeVector(),
* sceKernelReceiveMsgPipeVector(), sceKernelReceiveMsgPipeVectorCB(), sceKernelTryReceiveMsgPipeVector()
* are used to transmit and receive data.
* This structure specifies a single contiguous memory range.
*
* Specify the base address in pBase.
* Specify the size (byte) in bufSize.
*
*/
typedef struct _SceKernelMsgPipeVector {
void *pBase; /**< Buffer base address */
SceSize bufSize; /**< Buffer size */
} SceKernelMsgPipeVector;
/**
* @brief Message pipe status
*
* This structure is used to get the message pipe status with sceKernelGetMsgPipeInfo().
*
*/
typedef struct _SceKernelMsgPipeInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelMsgPipeInfo)) */
SceUID msgPipeId; /**< Message pipe identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of the message pipe specified with sceKernelCreateMsgPipe() */
SceUInt32 attr; /**< Message pipe attribute specified by sceKernelCreateMsgPipe() */
SceSize bufferSize; /**< Total size of message pipe pipe buffer (bytes) */
SceSize freeSize; /**< Empty pipe buffer size of message pipe (byte) */
SceUInt32 numSendWaitThreads; /**< Number of threads waiting to be sent */
SceUInt32 numReceiveWaitThreads; /**< Number of threads waiting to receive */
} SceKernelMsgPipeInfo;
/**
* @brief Additional data for the message pipe
*
* This structure is used to store additional data given when creating a message pipe with sceKernelCreateMsgPipe().
*
* Specify a bit pattern that represents a valid member in attr.
* The following macros can be specified by logical OR.
* - SCE_KERNEL_MSG_PIPE_OPT_ATTR_OPEN_LIMITATION: Specify the maximum number that can be referenced simultaneously with sceKernelOpenMsgPipe() (openLimit)
*
* In openLimit, the maximum number of simultaneous references by sceKernelOpenMsgPipe() can be specified.
* The maximum number that can be specified is (0..SCE_KERNEL_OPEN_LIMIT_MAX (127)).
* If not specified, the number of simultaneous references is not limited.
*
* Be sure to call sizeof(SceKernelMsgPipeOptParam) for size.
*
*/
typedef struct _SceKernelMsgPipeOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelMsgPipeOptParam)) */
SceUInt32 attr; /**< A bit pattern that specifies a valid member of a structure */
SceInt32 reserved[2]; /**< Reserved area */
SceUInt32 openLimit; /**< Maximum number that can be referenced simultaneously with sceKernelOpenMsgPipe() (0..SCE_KERNEL_OPEN_LIMIT_MAX (127)) can be specified. If not specified, unlimited */
} SceKernelMsgPipeOptParam;
/*@}*//* Message pipe */
/** @name Reader / writer lock
*/
/*@{*/
/**
* @defgroup Reader / writer lock attribute
* Definition of attributes to be specified when creating a reader / writer lock
*/
/*@{*/
#define SCE_KERNEL_RW_LOCK_ATTR_TH_FIFO SCE_KERNEL_ATTR_TH_FIFO /**< Reader / writer lock waiting thread queuing is FIFO */
#define SCE_KERNEL_RW_LOCK_ATTR_TH_PRIO SCE_KERNEL_ATTR_TH_PRIO /**< Queued reader / writer lock waiting threads are ordered by thread priority */
#define SCE_KERNEL_RW_LOCK_ATTR_RECURSIVE (0x00000002U) /**< Reader / writer lock can be recursively locked */
#define SCE_KERNEL_RW_LOCK_ATTR_CEILING (0x00000004U) /**< Use the priority sealing function when the reader / writer lock is locked (not implemented) */
/*@}*/
/**
* @defgroup Reader / writer lock cancel flag
* Definition of flag to be specified when canceling reader / writer lock
*/
/*@{*/
#define SCE_KERNEL_RW_LOCK_CANCEL_WITH_WRITE_LOCK (1) /**< Acquire light lock atomically after cancellation */
/*@}*/
/**
* @brief Additional data for reader / writer lock
*
* This structure is used to store additional data given when creating a reader / writer lock with sceKernelCreateRWLock().
*
* Provided for future expansion.
*
*/
typedef struct _SceKernelRWLockOptParam {
SceSize size; /**< Size of this structure (sizeof(SceKernelRWLockOptParam)) */
} SceKernelRWLockOptParam;
/**
* @brief Reader / writer lock status
*
* This structure is used to acquire the reader / writer lock status with sceKernelGetRWLockInfo().
*
*/
typedef struct _SceKernelRWLockInfo {
SceSize size; /**< Size of this structure (sizeof(SceKernelRWLockInfo)) */
SceUID rwLockId; /**< Reader / writer lock identifier */
char name[SCE_UID_NAMELEN + 1]; /**< Name of reader / writer lock specified by sceKernelCreateRWLock() */
SceUInt32 attr; /**< Reader / writer lock attribute specified by sceKernelCreateRWLock() */
SceInt32 lockCount; /**< Current number of locks of reader / writer lock */
SceUID writeOwnerId; /**< Identifier of the thread that currently holds (owns) the reader / writer lock */
SceUInt32 numReadWaitThreads; /**< Number of threads waiting for reader / writer lock with read lock */
SceUInt32 numWriteWaitThreads; /**< Number of threads waiting for reader / writer lock with write lock */
} SceKernelRWLockInfo;
/*@}*//* Reader / writer lock */
typedef struct SceKernelWorkqueueCreateInfo { // size is 0x40-bytes
SceSize size;
SceUID wqueue_id;
char name[0x20];
SceInt32 unk_0x28;
SceInt32 unk_0x2C;
SceInt32 unk_0x30;
SceInt32 unk_0x34;
SceInt32 unk_0x38;
SceInt32 unk_0x3C;
} SceKernelWorkqueueCreateInfo;
typedef struct SceKernelWorktaskCreateInfo { // size is 0x34-bytes
SceSize size;
SceUID wtask_id;
char name[0x20];
const void *func;
void *argp;
SceUID wqueue_id;
} SceKernelWorktaskCreateInfo;
typedef struct SceThreadmgrForDriver_E605ED7A_t { // size is 0x58-bytes
SceSize size;
SceUID wtaskId;
SceUID processId;
SceInt32 unk_0x0C;
char name[0x20];
const void *func;
void *argp;
SceUID wqueue_id;
SceUID unk_0x3C;
SceUID unk_0x40;
void *unk_0x44;
SceInt32 unk_0x48;
SceInt32 unk_0x4C;
SceUID processId2;
SceInt32 unk_0x54;
} SceThreadmgrForDriver_E605ED7A_t;
#define SCE_KERNEL_WORKQUEUE_HAS_THREAD_NUMBER (1 << 0)
#define SCE_KERNEL_WORKQUEUE_HAS_PRIORITY (1 << 1)
#define SCE_KERNEL_WORKQUEUE_HAS_STACK_SIZE (1 << 2)
#define SCE_KERNEL_WORKQUEUE_HAS_CPU_AFFINITY_MASK (1 << 3)
typedef struct SceKernelCreateWorkQueueParam {
SceSize;
SceUInt32 nThread;
SceUInt32 initPriority;
SceSize stackSize;
SceUInt32 cpuAffinityMask;
} SceKernelCreateWorkQueueParam;
Possible function names according to SceTestBridge
sceTestBridgeThreadMgrCallCoredumpHandler -> ??
sceTestBridgeThreadMgrClearThreadMgrTestMode -> sceKernelClearThreadMgrTestModeForKernel
sceTestBridgeThreadMgrDeleteStopThreadEvf -> ??
sceTestBridgeThreadMgrExitDeleteThreadInSyscall -> sceKernelExitDeleteThread
sceTestBridgeThreadMgrFastMutexLockUnlock -> ??
sceTestBridgeThreadMgrFastMutexShowStat -> ??
sceTestBridgeThreadMgrFastMutexStart -> ??
sceTestBridgeThreadMgrFastMutexStop -> ??
sceTestBridgeThreadMgrGetLwMutexInfoAll -> looks like _sceKernelGetLwMutexInfoById
sceTestBridgeThreadMgrIsCoredumpHandlerRegistered
sceTestBridgeThreadMgrRegisterCoredumpHandler -> sceCoredumpRegisterCoredumpHandler
sceTestBridgeThreadMgrResumeThread -> sceKernelResumeThreadForVM
sceTestBridgeThreadMgrRunningInSyscall -> ??
sceTestBridgeThreadMgrSetAndDeleteSuspendThreadEvf -> ??
sceTestBridgeThreadMgrSetThreadMgrTestMode -> sceKernelSetThreadMgrTestModeForKernel
sceTestBridgeThreadMgrSpawnPriorityThread -> ??
sceTestBridgeThreadMgrStopThread -> sceKernelStopThreadForKernel
sceTestBridgeThreadMgrSuspendThread -> sceKernelSuspendThreadForVM
sceTestBridgeThreadMgrUnregisterCoredumpHandler -> sceCoredumpUnregisterCoredumpHandler
sceTestBridgeThreadMgrWaitInSyscall -> ??
sceTestBridgeThreadMgrWaitInSyscall2 -> ??
sceTestbridgeApi -> ??
Thread Priority
Basic Priority Table
General Priority |
Internal Priority |
Description
|
0 |
- |
Current running thread priority
|
< 0x100000E0 |
- |
Error with 0x80028023
|
>= 0x10000120 |
- |
Error with 0x80028023
|
0x10000100 |
0xA0 |
For GAME Process without some thread attr
|
0x10000100 |
0x60 |
For GAME Process
|
0x10000100 |
0x60 |
For MiniApp Process
|
0x10000100 |
0x60 |
For Shell Process
|
0x10000100 |
0x60 |
For Kernel Process
|
Internal Priority Table
Allowed Internal Priority |
Description
|
0x40 - 0xBF |
For User GAME Process
|
0x40 - 0xFB |
For User non-GAME Process (Kernel, shell, miniapp)
|
1 - 0xFB |
For non-User Process
|
SceThreadmgrForDriver
sceKernelSetEventWithNotifyCallbackForDriver
sceKernelRegisterKTLSForDriver
Version |
NID
|
0.990.000-3.740.011 |
0xB645C7EF
|
Temp name was sceKernelAllocateKTLSForDriver. sceKernelAllocateKTLS
symbol is present in old SCE modules but sceKernelRegisterKTLS
is more suitable and used more often.
typedef void SceKernelKTLSFreeCallback(void* ktls_data, void* pUserdata);
/**
* @brief Registers a kernel TLS slot.
*
* There are 8 KTLS slots available. However, slot 0 and 1 cannot be accessed via the KTLS API.
* Thus, only 6 slots can be registered and used by external callers.
*
* @param[in] size Size of the KTLS data to allocate
* @param[in,opt] freeCb Callback invoked when the KTLS data of a thread is freed (during thread termination)
* @param[in,opt] pUserdata User-provided data passed to freeCb
* @retval (>=0) KTLS index of the registered slot
* @retval (<0) Error code
* @note If no free KTLS slots are available, SCE_KERNEL_ERROR_KERNEL_TLS_FULL (0x80028081) is returned.
*/
SceInt32 sceKernelRegisterKTLSForDriver(SceSize size, SceKernelKTLSFreeCallback* freeCb, void* pUserdata);
sceKernelUnregisterKTLSForDriver
Version |
NID
|
0.990.000-3.740.011 |
0x8C3C1F78
|
/**
* @brief Unregisters a Kernel TLS slot.
*
* @param[in] index KTLS index returned by sceKernelRegisterKTLS()
* @retval SCE_OK Success
* @retval (<0) Error code
* @note A KTLS index can only be unregistered if no thread has KTLS data allocated for this index.
* Otherwise, error SCE_KERNEL_ERROR_KERNEL_TLS_BUSY (0x80028083) is returned.
*/
SceInt32 sceKernelUnregisterKTLSForDriver(SceInt32 index);
SceThreadmgrForDriver_89CA5698
Version |
NID
|
0.990.000-3.740.011 |
0x89CA5698
|
/**
* @brief Returns the pointer to KTLS data from a slot.
*
* @param[in] index KTLS index returned by sceKernelRegisterKTLS()
* @param[in] thid ID of the thread whose KTLS data should be retrieved, or 0 for the current thread
* @param[in] allocate Controls behavior if the KTLS data for the slot has not been allocated yet for this thread:
* SCE_TRUE => allocate and return the new allocation
* SCE_FALSE => don't allocate; return NULL
* @retval non-NULL Pointer to the KTLS data
* @retval NULL Error / KTLS data is not allocated (if allocate == SCE_FALSE)
*/
ScePVoid SceThreadmgrForDriver_89CA5698(SceInt32 index, SceUID thid, SceBool allocate);
SceThreadmgrForDriver_3A72C6D8
Version |
NID
|
0.990.000-3.740.011 |
0x3A72C6D8
|
Wrapper for SceKernelThreadMgr#SceThreadmgrForDriver_89CA5698.
ScePVoid SceThreadmgrForDriver_3A72C6D8(SceInt32 index) {
return SceThreadmgrForDriver_89CA5698(index, 0, SCE_TRUE);
}
sceKernelPMonSetControlRegisterForDriver
Version |
NID
|
0.990.000-2.060.011 |
not present. Present in #SceThreadmgrForKernel.
|
2.100.081-3.740.011 |
0x1AAFA818
|
sceKernelPMonSetUserEnableRegisterForDriver
Version |
NID
|
0.990.000-2.060.011 |
not present. Present in #SceThreadmgrForKernel.
|
2.100.081-3.740.011 |
0x5053B005
|
sceKernelWaitThreadEndCBForDriver
Version |
NID
|
3.60 |
0x9EF4F62C
|
sceKernelWaitThreadEndForDriver
Version |
NID
|
3.60 |
0x3E20216F
|
sceKernelWaitEventFlagCBForDriver
Version |
NID
|
3.60 |
0x8A35F714
|
sceKernelWaitEventFlagForDriver
Version |
NID
|
0.931-3.60 |
0x0C1D3F20
|
/**
* @brief Event flag wait
*
* This system call waits for the event flag specified by evfId to be set according to the wait release condition specified by waitMode.
* If the event flag specified by evfId already satisfies the wait release condition specified by waitMode,
* the issuing thread continues execution without transitioning to the waiting state (WAITING).
*
* When SCE_KERNEL_EVF_WAITMODE_AND is specified for waitMode, it waits until all the bits specified by bitPattern become 1.
* If SCE_KERNEL_EVF_WAITMODE_OR is specified for waitMode, wait until one of the bits specified in bitPattern becomes 1.
* If SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL is additionally specified for waitMode, all the eventflag bits
* are cleared to 0 when the wait release condition is satisfied and this thread is released.
* If SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT is additionally specified for waitMode, the bit specified
* by bitPattern is cleared to 0 when the wait release condition is satisfied and this thread is released.
*
* The event flag value is returned to pResultPat in the following cases. NULL can be specified if no value is required.
* - If the wait release condition is satisfied (SCE_OK is returned),
* the event flag value before clearing by specifying SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL,
* SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT is returned immediately after the condition is satisfied.
* - After exiting the wait state, the event flag value just before exiting from the wait state is returned when
* exiting except when the wait release condition is satisfied (when SCE_KERNEL_ERROR_WAIT_CANCEL,
* SCE_KERNEL_ERROR_WAIT_DELETE, SCE_KERNEL_ERROR_WAIT_TIMEOUT errors are returned).
* When canceling with sceKernelCancelEventFlag(), the eventflag value set at the time of cancellation is returned.
*
* When pTimeout is specified, the timeout operation specified in microseconds is set.
* If pTimeout is NULL, timeout operation is not performed.
* Note that if pTimeout is specified, the value pointed to by pTimeout is updated when the system call ends.
* If the condition is met within the time, it is updated with the remaining time. If not established,
* the value pointed to by pTimeout is updated with 0. In this case, error SCE_KERNEL_ERROR_WAIT_TIMEOUT is returned.
*
* Another thread cannot execute sceKernelWaitEventFlag() and sceKernelPollEventFlag() for an event flag with
* the SCE_KERNEL_EVF_ATTR_SINGLE attribute that already has a waiting thread.
* In this case, an error is returned immediately to the thread that executed sceKernelWaitEventFlag() or sceKernelPollEventFlag() later.
*
* If multiple threads are waiting for an event flag with the SCE_KERNEL_EVF_ATTR_MULTI attribute, a thread queue is created.
* In this case, a single sceKernelSetEventFlag() may release the waiting status of multiple threads.
*
* In the case of the event flag of the SCE_KERNEL_EVF_ATTR_TH_FIFO attribute, the thread queue is
* arranged in the order in which it waits first.
* In the event flag of the SCE_KERNEL_EVF_ATTR_TH_PRIO attribute, the thread with the highest
* priority among the waiting threads starts first and is arranged in the order of thread priority.
*
* If there is a thread with SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL specified or SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT specified in the
* queue and the wait release condition for that thread is satisfied, the event flag is cleared at the same time as the wait release.
* Threads that are lined up behind the thread that has specified SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL or SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT
* will see the event flag after being cleared, so the wait may not be released.
*
* @param evfId Specifies the identifier of the event flag to wait for.
* @param bitPattern Specify the comparison value with the eventflag.
* @param waitMode Specifies the wait mode. Specify one of the following:
* - SCE_KERNEL_EVF_WAITMODE_AND: Waiting for AND
* - SCE_KERNEL_EVF_WAITMODE_OR : Wait for OR
* In addition, you can optionally add either of the following specifications as a logical sum.
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL: After waiting, clear all bits
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT: After waiting, clear the bit specified in bitPattern
* @param pResultPat Specifies a pointer to the SceUInt32 type variable that receives the eventflag value when waiting is established.
* If NULL is specified, the event flag value is not received.
* @param pTimeout Specify a pointer to the SceUInt32 type variable that stores the upper limit (microseconds) of the waiting time.
* If NULL is specified, wait indefinitely. When the wait condition is satisfied, the remaining time is returned.
* @retval SCE_OK Success
* @retval (<0) Error code
*/
SceInt32 sceKernelWaitEventFlagForDriver(SceUID evfId, SceUInt32 bitPattern, SceUInt32 waitMode, SceUInt32 *pResultPat, SceUInt32 *pTimeout);
sceKernelWaitEventCBForDriver
Version |
NID
|
3.60 |
0x360C655C
|
sceKernelWaitEventForDriver
Version |
NID
|
3.60 |
0xC529EA32
|
sceKernelUnregisterThreadEventHandlerForDriver
Version |
NID
|
3.60 |
0x2C8ED6F0
|
sceKernelUnregisterCallbackFromEventAllForDriver
Version |
NID
|
3.60 |
0x8DADBD16
|
sceKernelUnregisterCallbackFromEventForDriver
Version |
NID
|
3.60 |
0x2E48D81C
|
sceKernelUnlockWriteRWLockForDriver
Version |
NID
|
3.60 |
0x94A73797
|
sceKernelUnlockReadRWLockForDriver
Version |
NID
|
3.60 |
0xDE1B9EEE
|
sceKernelTryLockWriteRWLockForDriver
Version |
NID
|
3.60 |
0xA96F2E5A
|
sceKernelTryLockReadRWLockForDriver
Version |
NID
|
3.60 |
0xFC2B5A50
|
sceKernelStopTimerForDriver
Version |
NID
|
3.60 |
0x474F214B
|
sceKernelStartTimerForDriver
Version |
NID
|
3.60 |
0x84C4CE4D
|
sceKernelSignalSemaForDriver
Version |
NID
|
3.60 |
0xD270498B
|
sceKernelSignalCondAllForDriver
Version |
NID
|
3.60 |
0x6EC78CD0
|
sceKernelSetTimerTimeWideForDriver
Version |
NID
|
3.60 |
0x85195A16
|
sceKernelSetEventFlagForDriver
Version |
NID
|
0.931 |
in ForKernel
|
3.60 |
0xD4780C3E
|
sceKernelSetEventForDriver
Version |
NID
|
3.60 |
0x9EA3A45C
|
_sceKernelExtendKernelStackWideForDriver
Version |
NID
|
3.60 |
0xE54FD746
|
Temp name was sceKernelRunWithStackForDriver.
This takes a function and runs it exclusively on the current core on its own stack.
// stack_size should be 0x2000
int _sceKernelExtendKernelStackWideForDriver(int stack_size, void *func, void *args);
sceKernelExtendKernelStackWideForDriver
Version |
NID
|
3.60 |
0xA2C801A5
|
Temp name was sceKernelRunWithStack2ForDriver.
// stack_size should be 0x2000
int sceKernelExtendKernelStackWideForDriver(int stack_size, void *func, void *args);
sceKernelRegisterCallbackToEventForDriver
Version |
NID
|
3.60 |
0x832A7E0C
|
sceKernelPulseEventWithNotifyCallbackForDriver
Version |
NID
|
3.60 |
0x714A107A
|
sceKernelPulseEventForDriver
Version |
NID
|
3.60 |
0x2427C81B
|
sceKernelPollSemaForDriver
Version |
NID
|
3.60 |
0x4FDDFE24
|
sceKernelPollEventFlagForDriver
Version |
NID
|
0.990-3.60 |
0x76C6555B
|
/**
* @brief Event flag polling
*
* Polls the event flag specified by evfId.
*
* sceKernelPollEventFlag() is a system call that removes the function to enter standby state from sceKernelWaitEventFlag().
* Unlike sceKernelWaitEventFlag(), an error (SCE_KERNEL_ERROR_EVF_COND) is returned immediately if the wait release condition is not satisfied.
* In this case, SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL / SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT specification is ignored.
*
* @param evfId Specify the event flag identifier to be polled.
* @param bitPattern Specify the comparison value with the eventflag.
* @param waitMode Specify the wait mode. Specify one of the following:
* - SCE_KERNEL_EVF_WAITMODE_AND: Waiting for AND
* - SCE_KERNEL_EVF_WAITMODE_OR : Wait for OR
* In addition, you can optionally add one of the following specifications as a logical sum.
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL: Clear all bits after waiting
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT: After waiting, clear the bit specified in bitPattern
* @param pResultPat Specify a pointer to the SceUInt32 type variable that receives the eventflag value when waiting is established.
* @retval SCE_OK Success
* @retval (<0) Error code
*/
SceInt32 sceKernelPollEventFlagForDriver(SceUID evfId, SceUInt32 bitPattern, SceUInt32 waitMode, SceUInt32 *pResultPat);
sceKernelNotifyCallbackForDriver
Version |
NID
|
3.60 |
0xC3E00919
|
sceKernelGetTimerTimeWideForDriver
Version |
NID
|
3.60 |
0xC1286004
|
sceKernelGetTimerBaseWideForDriver
Version |
NID
|
3.60 |
0xA6D11DD3
|
sceKernelGetThreadmgrUIDClassForDriver
Version |
NID
|
3.60 |
0x0A20775A
|
sceKernelGetThreadTLSAddrForDriver
Version |
NID
|
3.60 |
0x66EEA46A
|
sceKernelGetThreadStackFreeSizeForDriver
Version |
NID
|
3.60 |
0x7B278A0B
|
sceKernelGetThreadCpuAffinityMaskForDriver
Version |
NID
|
3.60 |
0x83DC703D
|
sceKernelGetCallbackCountForDriver
Version |
NID
|
3.60 |
0x0892D8DF
|
sceKernelCreateWorkQueueForDriver
Version |
NID
|
3.60 |
0x771522C6
|
SceUID sceKernelCreateWorkQueueForDriver(const char *name, SceUInt32 flags, const SceKernelCreateWorkQueueParam *opt);
sceKernelScheduleWorkTaskForDriver
Version |
NID
|
3.60 |
0xE50E1185
|
SceUID sceKernelScheduleWorkTaskForDriver(SceUID wqueue_id, const char *name, const void *wtask_func, void *argp);
sceKernelGetWorkqueueCreateInfoForDriver
Version |
NID
|
3.60 |
0xB92709C4
|
This is a guessed name.
int sceKernelGetWorkqueueCreateInfo(SceUID wqueue_id, SceKernelWorkqueueCreateInfo *info);
sceKernelGetWorktaskCreateInfoForDriver
Version |
NID
|
3.60 |
0x0B604A3C
|
This is a guessed name.
int sceKernelGetWorktaskCreateInfo(SceUID wtask_id, SceKernelWorktaskCreateInfo *info);
sceKernelGetWorkqueueInfoVectorForDriver
Version |
NID
|
3.60 |
0x920EA1CA
|
This is a guessed name.
int sceKernelGetWorkqueueInfoVector(int vis_level, void *dst, SceSize dst_size, SceUInt32 *nInfo);
sceKernelGetProcWorkqueueInfoVectorForDriver
Version |
NID
|
3.60 |
0x8C8A76EF
|
This is a guessed name.
int sceKernelGetProcWorkqueueInfoVector(SceUID pid, int vis_level, void *dst, SceSize dst_size, SceUInt32 *nInfo);
sceKernelGetWorktaskInfoVectorForDriver
Version |
NID
|
3.60 |
0xE605ED7A
|
This is a guessed name.
int sceKernelGetWorktaskInfoVector(int vis_level, SceThreadmgrForDriver_E605ED7A_t *dst, SceSize dst_size, SceUInt32 *nInfo);
sceKernelGetProcWorktaskInfoVectorForDriver
Version |
NID
|
3.60 |
0xB4CED111
|
This is a guessed name.
int sceKernelGetProcWorktaskInfoVector(SceUID pid, int vis_level, SceThreadmgrForDriver_E605ED7A_t *dst, SceSize dst_size, SceUInt32 *nInfo);
sceKernelWaitWorktaskForDriver
Version |
NID
|
3.60 |
0x12FC0FAB
|
This is a guessed name.
int sceKernelWaitWorktask(SceUID wtask_id, SceInt32 *timeout);
sceKernelWaitWorktask2ForDriver
Version |
NID
|
3.60 |
0xB247EC4B
|
This is a guessed name.
with user stack overflow detect?
int sceKernelWaitWorktask2(SceUID wtask_id, SceInt32 *timeout);
sceKernelDeleteThreadForDriver
Version |
NID
|
1.69-3.60 |
0xAC834F3F
|
/**
* @brief Delete thread
*
* Deletes the thread specified by threadId.
*
* Accordingly, the stack area and thread management area are released. The target thread must be in the DORMANT state.
*
* Since the own thread cannot be in the DORMANT state, it cannot be set as the target thread
* (this results in an SCE_KERNEL_ERROR_NOT_DORMANT error).
* Use sceKernelExitDeleteThread() to delete your own thread.
*
* @param threadId Specify the identifier of the thread to be deleted.
* @retval SCE_OK Success
* @retval Negative value Error code
*/
SceInt32 sceKernelDeleteThreadForDriver(
SceUID threadId
);
sceKernelDeleteSemaForDriver
Version |
NID
|
3.60 |
0x16A35E58
|
sceKernelDeleteMutexForDriver
Version |
NID
|
3.60 |
0x0A912340
|
int sceKernelDeleteMutexForDriver(SceUID mutexid);
sceKernelCloseEventFlagForDriver
Version |
NID
|
0.931-3.60 |
0x71ECB352
|
Temp name was sceKernelDeleteEventFlagForDriver.
sceKernelCreateThreadForDriver
Version |
NID
|
1.69-3.60 |
0xC6674E7D
|
/**
* @brief Thread generation that operates in the address space of its own process
*
* A thread that operates in the address space of its own process is created.
*
* Allocate a thread management area for the thread to be created, perform initialization, and secure a stack area.
* The thread information to be created is specified as an argument, and the thread identifier (UID) is returned as the return value.
*
* The generated thread is in the DORMANT state.
*
* @param pName Specifies the name of the thread.
* The name of the thread does not have to be unique because it is
* used by the operator to identify it when debugging. The maximum name length is 31 bytes.
* @param entry Specify the entry address of the thread. The thread entry point function
* can receive memory block data with two arguments.
* The argument is given by sceKernelStartThread() described later.
* The thread is terminated by returning from this function, and the return value of the function is the thread termination status.
* @param initPriority Specifies the initial priority of the thread. The smaller the number, the higher the priority.
* The range from SCE_KERNEL_HIGHEST_PRIORITY_USER (= 64) to SCE_KERNEL_LOWEST_PRIORITY_USER (= 191) can be used.
* By specifying SCE_KERNEL_DEFAULT_PRIORITY_USER, you can specify the default priority of the process to which the thread belongs.
* For the default priority, it is also possible to specify with SCE_KERNEL_DEFAULT_PRIORITY_USER ± offset.
* @param stackSize Specify the required stack size of the thread in bytes. The argument block given by
* sceKernelStartThread () is copied onto the stack, so specify the stack size with this margin in mind.
* An error will occur if a stack size less than 4 KiB is specified.
* @param attr You can specify multiple thread attributes by logical OR.
* @param cpuAffinityMask Specifies the initial CPU affinity mask for the thread.
* A thread can run only on the thread specified in the CPU affinity mask.
* The CPU affinity mask can be specified by the logical sum of the following macros.
* - SCE_KERNEL_CPU_MASK_USER_0
* - SCE_KERNEL_CPU_MASK_USER_1
* - SCE_KERNEL_CPU_MASK_USER_2
* The following macros are also available to represent all available CPUs.
* - SCE_KERNEL_CPU_MASK_USER_ALL
* @param pOptParam Argument for future expansion. Please specify NULL. Max size is 0x14.
* @retval Positive value Thread identifier (UID)
* @retval Negative value Error code
*/
SceUID sceKernelCreateThreadForDriver(
const char *pName,
SceKernelThreadEntry entry,
SceInt32 initPriority,
SceSize stackSize,
SceUInt32 attr,
SceInt32 cpuAffinityMask,
const SceKernelThreadOptParam *pOptParam
);
sceKernelCreateSimpleEventForDriver
Version |
NID
|
3.60 |
0x357A8177
|
sceKernelCreateMutexForDriver
Version |
NID
|
3.60 |
0xFBAA026E
|
SceUID sceKernelCreateMutexForDriver(const char *pName, SceUInt attr, int initCount, const SceKernelMutexOptParam *pOptParam);
sceKernelCreateEventFlagForDriver
Version |
NID
|
0.990-3.60 |
0x4336BAA4
|
/**
* @brief Event flag generation
*
* Generate an event flag and set the initial value of the event flag. Returns the identifier of the generated event flag as a return value.
*
* @param pName Specifies the name of the eventflag.
* The name of the eventflag does not need to be unique because it is used only for the purpose of operator
* identification when debugging without interprocess communication.
* However, if the SCE_KERNEL_ATTR_OPENABLE attribute is specified for attr,
* a unique name must be specified in the system.
* The maximum name length is 31 bytes.
* @param attr Specifies the event flag attribute.
* Specify the queue order from one of the following.
* - SCE_KERNEL_EVF_ATTR_TH_FIFO: Waiting thread queuing is FIFO
* - SCE_KERNEL_EVF_ATTR_TH_PRIO: Waiting thread queuing is based on the priority of threads.
* Specify whether to wait for multiple threads from either of the following.
* - SCE_KERNEL_EVF_ATTR_SINGLE: Multiple threads cannot wait simultaneously
* - SCE_KERNEL_EVF_ATTR_MULTI: To generate an event flag that can be referenced by
* sceKernelOpenEventFlag() that allows multiple threads to wait simultaneously, specify the following:
* - SCE_KERNEL_ATTR_OPENABLE
* @param initPattern Specifies the initial value of the eventflag.
* @param pOptParam Argument for future expansion. Please specify NULL.
* @retval (>=0) Event flag identifier (UID)
* @retval (<0) Error code
*/
SceUID sceKernelCreateEventFlagForDriver(const char *pName, SceUInt32 attr, SceUInt32 initPattern, const SceKernelEventFlagOptParam *pOptParam);
sceKernelClearEventFlagForDriver
Version |
NID
|
3.60 |
0x4F1DA3BE
|
sceKernelClearEventForDriver
Version |
NID
|
3.60 |
0x9C335818
|
sceKernelChangeThreadPriority2ForDriver
Version |
NID
|
3.60 |
0x63DAB420
|
Temp name was sceKernelChangeThreadPriorityForDriver.
sceKernelCancelCallbackForDriver
Version |
NID
|
3.60 |
0xC040EC1C
|
sceKernelCancelMsgPipeForDriver
Version |
NID
|
3.60 |
0x9D6A2311
|
sceKernelCreateMsgPipeForDriver
Version |
NID
|
3.60 |
0xBF631145
|
sceKernelDeleteMsgPipeForDriver
Version |
NID
|
3.60 |
0xB3453F88
|
sceKernelSendMsgPipeVectorForDriver
Version |
NID
|
3.60 |
0x67DD3BAD
|
sceKernelTryReceiveMsgPipeVectorForDriver
Version |
NID
|
3.60 |
0xCE09221A
|
sceKernelTrySendMsgPipeVectorForDriver
Version |
NID
|
3.60 |
0x4CF1BE58
|
sceKernelIsThreadDebugSuspendedForDriver
Version |
NID
|
0.990-3.60 |
0xA0B1AB21
|
Used by SceCoredump maybe to get the state at the time of process crash.
/**
* @param[in] thid thread id (kernel uid)
* @return suspend state, else < 0 on error.
*/
int sceKernelIsThreadDebugSuspendedForDriver(SceUID thid);
sceKernelDebugResumeThreadForDriver
Version |
NID
|
0.990-3.60 |
0xEC8343DF
|
sceKernelResumeThreadForDriver
Version |
NID
|
0.990-3.60 |
0xE3CE20AA
|
sceKernelCreateRemoteThreadForDriver
Version |
NID
|
0.990-3.65 |
0xC8E57BB4
|
Some value are allowed if Thread name is "ScePsp2SwuCui".
/**
* @brief Thread generation that does not operate in the address space of its own process
*
* A thread that does not operate in the address space of its own process is created.
*
* Allocate a thread management area for the thread to be created, perform initialization, and secure a stack area.
* The thread information to be created is specified as an argument, and the thread identifier (UID) is returned as the return value.
*
* The generated thread is in the DORMANT state.
*
* @param pid Specifies the ID of the process the thread belongs to.
* @param pName Specifies the name of the thread.
* The name of the thread does not have to be unique because it is
* used by the operator to identify it when debugging. The maximum name length is 31 bytes.
* @param entry Specify the entry address of the thread. The thread entry point function
* can receive memory block data with two arguments.
* The argument is given by sceKernelStartThread() described later.
* The thread is terminated by returning from this function, and the return value of the function is the thread termination status.
* @param initPriority Specifies the initial priority of the thread. The smaller the number, the higher the priority.
* The range from SCE_KERNEL_HIGHEST_PRIORITY_USER (= 64) to SCE_KERNEL_LOWEST_PRIORITY_USER (= 191) can be used.
* By specifying SCE_KERNEL_DEFAULT_PRIORITY_USER, you can specify the default priority of the process to which the thread belongs.
* For the default priority, it is also possible to specify with SCE_KERNEL_DEFAULT_PRIORITY_USER ± offset.
* @param stackSize Specify the required stack size of the thread in bytes. The argument block given by
* sceKernelStartThread () is copied onto the stack, so specify the stack size with this margin in mind.
* An error will occur if a stack size less than 4 KiB is specified.
* @param attr You can specify multiple thread attributes by logical OR.
* @param cpuAffinityMask Specifies the initial CPU affinity mask for the thread.
* A thread can run only on the thread specified in the CPU affinity mask.
* The CPU affinity mask can be specified by the logical sum of the following macros.
* - SCE_KERNEL_CPU_MASK_USER_0
* - SCE_KERNEL_CPU_MASK_USER_1
* - SCE_KERNEL_CPU_MASK_USER_2
* The following macros are also available to represent all available CPUs.
* - SCE_KERNEL_CPU_MASK_USER_ALL
* @param pOptParam Argument for future expansion. Please specify NULL. Max size is 0x14.
* @retval Positive value Thread identifier (UID)
* @retval Negative value Error code
*/
SceUID sceKernelCreateRemoteThreadForDriver(
SceUID pid,
const char *pName,
SceKernelThreadEntry entry,
SceInt32 initPriority,
SceSize stackSize,
SceUInt32 attr,
SceInt32 cpuAffinityMask,
const SceKernelThreadOptParam *pOptParam
);
sceKernelGetThreadIdListForDriver
Version |
NID
|
0.990.000-3.740.011 |
0xEA7B8AEF
|
This function is used to query and obtain the number of threads within a process.
/**
* @brief Retrieve a list of all threads belonging to a process.
* @param[in] pid The process to query.
* @param[out] ids The list of thread IDs. Can be NULL if output is not required.
* @param[in] n The max number of thread IDs to copy out.
* @param[out] copy_count The number of thread IDs copied.
* @return The number of threads within the process, else < 0 on error.
*/
int sceKernelGetThreadIdListForDriver(SceUID pid, SceUID *ids, int n, int *copy_count);
sceKernelGetThreadCpuRegistersForDriver
Version |
NID
|
3.60 |
0x5022689D
|
This function is used to get the state of the registers for a SUSPENDED thread. It returns the registers in a two part structure. It is uncertain what the difference is between the two parts. It seems like it is a usermode/kernel separation. It could also be a current/exception difference. In normal usage on a suspended thread it seems to be the usermode aspect that contains valid values. When you query a suspended thread that has no had the opportunity to start yet, the kernel side is filled.
/** Structure representing all ARM registers */
typedef struct ArmCpuRegisters {
uint32_t r0;
uint32_t r1;
uint32_t r2;
uint32_t r3;
uint32_t r4;
uint32_t r5;
uint32_t r6;
uint32_t r7;
uint32_t r8;
uint32_t r9;
uint32_t r10;
uint32_t r11;
uint32_t r12;
uint32_t sp;
uint32_t lr;
uint32_t pc;
uint32_t cpsr;
uint32_t fpscr;
} ArmCpuRegisters;
/** Structure containing a threads register states. */
typedef struct ThreadCpuRegisters {
ArmCpuRegisters entry[2];
} ThreadCpuRegisters;
/**
* @brief Query the state of the registers for a suspended thread.
*
* The registers returned are the usermode/kernel set for the requested thread.
* It is uncertain if usermode/kernel is correct representation and instead it could be current/exception.
* The thread provided must be suspended for this function to succeed.
*
* @param[in] thid The thread to query.
* @param[out] registers The set of registers belonging to the thread.
* @return Zero on success, else < 0 on error.
*/
int sceKernelGetThreadCpuRegistersForDriver(SceUID thid, ThreadCpuRegisters *registers);
sceKernelChangeThreadSuspendStatusForDriver
Version |
NID
|
3.60 |
0x04C6764B
|
This function allows you to change the status of a suspended thread. Most of the valid suspend bits are unknown, but some can be used to prevent the kernel rethrowing exceptions or pull threads into the running/ready state.
/**
* @brief Change the thread suspension status to another value.
*
* More research needs to be done to find out exactly what each status actually means. Some examples of useful scenarios:
* When handling an exception changing the status to 0x1002 (on a newly suspended thread) will stop the kernel rethrowing the same exception.
* When resuming a suspended thread changing the status to 2 will allow it to resume.
*
* @param[in] thid The thread to change.
* @param[in] status The new status for suspension.
* @return Zero on success, else < 0 on error.
*/
int sceKernelChangeThreadSuspendStatusForDriver(SceUID thid, int status);
sceKernelChangeActiveCpuMaskForDriver
Version |
NID
|
1.69-3.60 |
0x001173F8
|
sceKernelGetThreadCurrentPriorityForDriver
Version |
NID
|
1.69-3.60 |
0x01414F0B
|
sceKernelCreateCallbackForDriver
Version |
NID
|
1.69-3.60 |
0x1C41614C
|
sceKernelWaitThreadEndCB_089ForDriver
Version |
NID
|
1.69 |
0x0373C5E3
|
3.60 |
not present
|
sceKernelDeleteCallbackForDriver
Version |
NID
|
1.69-3.60 |
0x3A7E17F6
|
sceKernelExitThreadForDriver
Version |
NID
|
1.69-3.60 |
0x0C8A38E1
|
/**
* @brief End of own thread
*
* Terminates the own thread normally and shifts to the DORMANT state.
* sceKernelExitThread() is a system call that does not return to the context of the issuer.
*
* Resources (memory, semaphores, etc.) acquired by the terminating thread are not automatically released.
* However, for mutexes only, mutexes that have been locked by the terminating thread are automatically unlocked.
* The mutex is unlocked and not deleted.
*
* When the terminated thread is restarted with sceKernelStartThread(), the information included in the thread
* management area, such as thread priority, is reset.
* It will not inherit the one at the end.
*
* When a thread exits, exitStatus becomes the exit status of that thread.
*
* If the thread is terminated by a return from the entry function without using
* sceKernelExitThread(), the return value of the entry function becomes the termination status.
*
* The end status of a thread can be obtained by sceKernelGetThreadExitStatus() and sceKernelGetThreadInfo(),
* and when another thread waits for the end of the thread by sceKernelWaitThreadEnd(), it can be obtained by the return value.
*
* The thread exit status is saved while the thread exits and is in the DORMANT state,
* but the value is lost if the thread is restarted or deleted with sceKernelStartThread().
*
* @param exitStatus Specify the value to be set for the termination status of the local thread.
* @retval Negative value Error code
*/
SceInt32 sceKernelExitThreadForDriver(
SceInt32 exitStatus
);
sceKernelLockMutex_089ForDriver
Version |
NID
|
0.990-3.60 |
0x16AC80C5
|
int sceKernelLockMutex_089ForDriver(SceUID mutex_id, int unk1, int unk2);
sceKernelExitDeleteThreadForDriver
Version |
NID
|
1.69-3.60 |
0x1D17DECF
|
/**
* @brief End and delete own thread
*
* Terminates the own thread normally and deletes it.
* sceKernelExitDeleteThread() is a system call that does not return to the context of the issuer.
*
* Resources (memory, semaphores, etc.) acquired by the terminating thread are not automatically released.
* However, for mutexes only, mutexes that have been locked by the terminating thread are automatically unlocked.
* The mutex is unlocked and not deleted.
*
* When a thread exits, exitStatus becomes the exit status of that thread (sceKernelExitDeleteThread()
* directly deletes the thread without going through the DORMANT state.
* (It cannot be obtained by sceKernelGetThreadInfo(). The end status can be obtained by the return
* value only when waiting for the end of the thread by sceKernelWaitThreadEnd().)
*
* @param exitStatus Specify the value to be set for the termination status of the local thread.
* @retval Negative value Error code
*/
SceInt32 sceKernelExitDeleteThreadForDriver(
SceInt32 exitStatus
);
sceKernelUnlockMutex_089ForDriver
Version |
NID
|
0.990-3.60 |
0x1E82E5D0
|
int sceKernelUnlockMutex_089ForDriver(SceUID mutex_id, int unk1);
sceKernelStartThread_089ForDriver
Version |
NID
|
1.69-3.60 |
0x21F5419B
|
/**
* @brief Thread activation
*
* Starts the thread specified by threadId and puts it in READY state.
*
* The argument block specified by argSize and argBlock is copied onto the thread stack, argSize is
* passed directly to the first argument of the thread entry function, and the second argument of
* the entry function is the argument copied onto the stack. The block address is passed.
*
* This system call does not queue activation requests. In other words, if the target thread is not
* in the DORMANT state, an SCE_KERNEL_ERROR_NOT_DORMANT error is returned to the calling thread.
*
* @param threadId Specify the identifier of the thread to be started.
* @param argSize Specify the size (byte) of the argument to be passed to the thread.
* @param pArgBlock Specify the address of the argument to be passed to the thread.
* @retval SCE_OK Success
* @retval Negative value Error code
*/
SceInt32 sceKernelStartThread_089ForDriver(
SceUID threadId,
SceSize argSize,
const void *pArgBlock
);
sceKernelTryLockMutex_089ForDriver
Version |
NID
|
1.69-3.60 |
0x270993A6
|
sceKernelGetSystemTimeLowForDriver
Version |
NID
|
1.69-3.60 |
0x47F6DE49
|
sceKernelDelayThreadForDriver
Version |
NID
|
1.69-3.60 |
0x4B675D05
|
sceKernelGetMutexInfo_089ForDriver
Version |
NID
|
1.69-3.60 |
0x69B78A12
|
int sceKernelGetMutexInfo_089ForDriver(SceUID mutexid, SceKernelMutexInfo *info);
sceKernelCancelMutex_089ForDriver
Version |
NID
|
1.69-3.60 |
0x7204B846
|
sceKernelChangeCurrentThreadAttrForDriver
Version |
NID
|
1.69-3.60 |
0x751C9B7A
|
sceKernelDelayThreadCBForDriver
Version |
NID
|
1.69-3.60 |
0x9C0180E1
|
sceKernelLockMutexCB_089ForDriver
Version |
NID
|
1.69-3.60 |
0xD06F2886
|
sceKernelCheckWaitableStatusForDriver
Version |
NID
|
1.69-3.60 |
0xD9BD74EB
|
sceKernelCheckCallbackForDriver
Version |
NID
|
1.69-3.60 |
0xE53E41F6
|
sceKernelWaitThreadEnd_089ForDriver
Version |
NID
|
1.69 |
0xF3489EF4
|
3.60 |
not present
|
sceKernelGetSystemTimeWideForDriver
Version |
NID
|
1.69-3.60 |
0xF4EE4FA9
|
sceKernelGetThreadInfoForDriver
Version |
NID
|
0.990-3.60 |
0x283807E2
|
int sceKernelGetThreadInfoForDriver(SceUID thid, SceKernelThreadInfo *info)
sceKernelInitializeFastMutexForDriver
Version |
NID
|
0.990-3.60 |
0xAF8E1266
|
int sceKernelInitializeFastMutexForDriver(void* mutex, const char* name, uint32_t attr, int unk)
sceKernelLockFastMutexForDriver
Version |
NID
|
1.69-3.60 |
0x70627F3A
|
int sceKernelLockFastMutexForDriver(void* mutex)
sceKernelUnlockFastMutexForDriver
Version |
NID
|
1.69-3.60 |
0xDB395782
|
int sceKernelUnlockFastMutexForDriver(void* mutex)
sceKernelFinalizeFastMutexForDriver
Version |
NID
|
0.990-3.60 |
0x11FE84A1
|
Temp name was sceKernelDeleteFastMutexForDriver.
int sceKernelFinalizeFastMutexForDriver(void* mutex)
sceKernelSignalCondToForDriver
Version |
NID
|
1.69-3.60 |
0x61533DA9
|
int sceKernelSignalCondToForDriver(SceUID condId, SceUID threadId)
sceKernelCreateCondForDriver
Version |
NID
|
1.69-3.60 |
0xDB6CD34A
|
SceUID sceKernelCreateCondForDriver(const char *name, SceUInt attr, SceUID mutexId, const SceKernelCondOptParam *option)
sceKernelWaitCondForDriver
Version |
NID
|
1.69-3.60 |
0xCC7E027D
|
int sceKernelWaitCondForDriver(SceUID condId, unsigned int *timeout)
sceKernelReceiveMsgPipeVectorForDriver
Version |
NID
|
1.69-3.60 |
0xDA1F256B
|
sceKernelReceiveMsgPipeVectorCBForDriver
Version |
NID
|
1.69-3.60 |
0xDA5C9AC6
|
sceKernelGetThreadIdForDriver
Version |
NID
|
1.69-3.60 |
0x59D06540
|
SceUID sceKernelGetThreadIdForDriver(void);
sceKernelDeleteCondForDriver
Version |
NID
|
1.69-3.60 |
0xAEE0D27C
|
int sceKernelDeleteCondForDriver(SceUID cid);
sceKernelCreateSemaForDriver
Version |
NID
|
1.69-3.60 |
0x30E93C31
|
/**
* Creates a new semaphore
*
* @par Example:
* @code
* int semaid;
* semaid = sceKernelCreateSemaForDriver("MySema", 0, 1, 1, 0);
* @endcode
*
* @param name - Specifies the name of the sema
* @param attr - Sema attribute flags (normally set to 0)
* @param initVal - Sema initial value
* @param maxVal - Sema maximum value
* @param option - Sema options (normally set to 0)
* @return A semaphore id
*/
SceUID sceKernelCreateSemaForDriver(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option);
sceKernelWaitSemaCBForDriver
Version |
NID
|
1.69-3.60 |
0xF55E4D86
|
/**
* Lock a semaphore
*
* @par Example:
* @code
* sceKernelWaitSemaCBForDriver(sema_id, 1, 0);
* @endcode
*
* @param sema_id - The sema id returned from ::sceKernelCreateSemaForDriver
* @param signal - The value to wait for (i.e. if 1 then wait till reaches a signal state of 1)
* @param timeout - Timeout in microseconds (assumed).
*
* @return < 0 on error.
*/
int sceKernelWaitSemaCBForDriver(SceUID sema_id, int signal, SceUInt *timeout);
sceKernelWaitSemaForDriver
Version |
NID
|
1.69-3.60 |
0x3C8B55A9
|
/**
* Lock a semaphore
*
* @par Example:
* @code
* sceKernelWaitSemaForDriver(sema_id, 1, 0);
* @endcode
*
* @param sema_id - The sema id returned from ::sceKernelCreateSemaForDriver
* @param signal - The value to wait for (i.e. if 1 then wait till reaches a signal state of 1)
* @param timeout - Timeout in microseconds (assumed).
*
* @return < 0 on error.
*/
int sceKernelWaitSemaForDriver(SceUID sema_id, int signal, SceUInt *timeout);
sceKernelSignalCondForDriver
Version |
NID
|
1.69-3.60 |
0xAC616150
|
int sceKernelSignalCondForDriver(SceUID condId);
sceKernelChangeThreadCpuAffinityMaskForDriver
Version |
NID
|
1.69-3.60 |
0x6D0733A8
|
/**
* @brief Thread CPU affinity mask setting
*
* Change the CPU affinity mask of the thread specified by threadId to cpuAffinityMask.
* A thread can run only on the CPU specified by the CPU affinity mask.
*
* If the CPU affinity mask of a running thread is changed and cannot be executed on the current CPU, the thread is dispatched immediately.
* As a result of scheduling, if a higher priority thread is running on the newly executable CPU, it is made to wait in the READY state.
*
* However, if the dispatch is disabled, the CPU affinity mask is changed immediately,
* but the rescheduling process is delayed until dispatch is permitted.
*
* @param threadId Specify the identifier of the thread whose CPU affinity mask is to be changed.
* You can specify your own thread with SCE_KERNEL_THREAD_ID_SELF.
* @param cpuAffinityMask Specify the CPU affinity mask after the change.
* The CPU affinity mask is expressed by the logical OR of the following macros.
* - SCE_KERNEL_CPU_MASK_USER_0
* - SCE_KERNEL_CPU_MASK_USER_1
* - SCE_KERNEL_CPU_MASK_USER_2
* The following macros are also available to specify all available CPUs.
* - SCE_KERNEL_CPU_MASK_USER_ALL
* @retval Positive value CPU affinity mask before change
* @retval Negative value Error code
*/
SceInt32 sceKernelChangeThreadCpuAffinityMaskForDriver(
SceUID threadId,
SceInt32 cpuAffinityMask
);
sceKernelSetThreadAccessLevelForDriver
Version |
NID
|
1.69-3.65 |
0x02EEDF17
|
Temp name was sceKernelSetPermissionForDriver.
// return value is previous value
int sceKernelSetThreadAccessLevelForDriver(int value);
sceKernelGetProcessIdForDriver
Version |
NID
|
1.69-3.60 |
0x9DCB4B7A
|
Returns the process ID.
SceUID sceKernelGetProcessIdForDriver(void);
sceKernelSetImpersonateIdForDriver
Version |
NID
|
1.69-3.60 |
0x0486F239
|
This is a guessed name. Temp name was sceKernelSetProcessIdToTLSForDriver.
Sets impersonation ID for the current thread.
Impersonation ID is used for access checks in e.g. SceIofilemgr.
// Returns the previous impersonation ID
ScePID sceKernelSetImpersonateIdForDriver(ScePID pid);
sceKernelGetImpersonateIdForDriver
Version |
NID
|
1.69-3.60 |
0xFA54D49A
|
This is a guessed name. Temp name was sceKernelGetProcessIdFromTLSForDriver.
Returns the current thread's impersonation ID.
Used by SceIofilemgr, which calls the returned value impersonateId
.
ScePID sceKernelGetImpersonateIdForDriver(void);
sceKernelRegisterTimerForDriver
Version |
NID
|
0.990 |
also in ForKernel
|
3.60 |
0xC58DF384
|
// seen: unk = 0, 2 so maybe UDCD bus
int sceKernelRegisterTimerForDriver(char *name, SceUInt32 time, void *function, int unk);
sceKernelRegisterTimerWithOptForDriver
Version |
NID
|
0.990 |
also in ForKernel
|
0.990-3.60 |
0x10517330
|
This is a guessed name.
typedef struct SceKernelRegisterTimerOpt {
SceUInt32 time;
char *log_buffer_start;
} SceKernelRegisterTimerOpt;
int sceKernelRegisterTimerWithOptForDriver(char *name, SceKernelRegisterTimerOpt *pOpt, void *function, int unk);
sceKernelCreateRWLockForDriver
Version |
NID
|
0.990-3.60 |
0x04150799
|
sceKernelCreateTimerForDriver
Version |
NID
|
3.60 |
0x90656C98
|
int sceKernelCreateTimerForDriver(const char *name, uint32_t attr);
sceKernelDelayThreadUnkCBForDriver
Version |
NID
|
3.60 |
0x2B60B793
|
sceKernelDelayThreadUnkForDriver
Version |
NID
|
3.60 |
0xE9A99C50
|
int sceKernelDelayThreadUnkForDriver(SceUInt32 nsec, SceUInt32 *some_time);
sceKernelGetTHBPForDriver
Version |
NID
|
0.990-3.60 |
0x453B764A
|
Used by SceDeci4pSDbgp.
Get thread hardware break point.
int sceKernelGetTHBPForDriver(SceUID thid, SceUInt32 a2, int *a3, int *a4);
sceKernelSetTHBPForDriver
Version |
NID
|
0.990-3.60 |
0x385831A1
|
int sceKernelSetTHBPForDriver(SceUID pid, SceUInt32 a2, int a3, int a4);
SceThreadmgrForDriver_86DAE59B
Version |
NID
|
3.60 |
0x86DAE59B
|
Get maybe current CPU mask.
int SceThreadmgrForDriver_86DAE59B(void);
sceKernelCancelAlarmForDriver
Version |
NID
|
0.990-3.60 |
0x44CCF310
|
Used in SceCtrl, SceTouch.
int sceKernelCancelAlarmForDriver(SceUID uid_or_pid);
sceKernelDebugSuspendThreadForDriver
Version |
NID
|
3.60 |
0xFB3706CB
|
int sceKernelDebugSuspendThreadForDriver(SceUID threadId, SceUInt32 status);
sceKernelGetEventFlagInfoForDriver
Version |
NID
|
3.60 |
0x612277C9
|
int sceKernelGetEventFlagInfoForDriver(SceUID uid, SceKernelEventFlagInfo *pInfo);
sceKernelGetThreadInfoForDebuggerForDriver
Version |
NID
|
0.990-3.60 |
0xDD8D9429
|
This is a guessed name. Old name was sceKernelGetThreadInfoInternalForDriver.
int sceKernelGetThreadInfoForDebuggerForDriver(SceUID thid, int a2, SceKernelThreadInfoInternal *pInfo);
sceKernelGetVfpRegisterForDebuggerForDriver
Version |
NID
|
3.60 |
0x5CDE387A
|
Temp name was sceKernelGetThreadFloatRegisterForDriver.
int sceKernelGetVfpRegisterForDebuggerForDriver(SceUID thid, SceKernelThreadFloatRegister *pRegister);
sceKernelGetUserThreadIdForDriver
Version |
NID
|
3.60 |
0xF311808F
|
This is a guessed name.
SceUID sceKernelGetUserThreadIdForDriver(SceUID thid_kern);
sceKernelGetSemaInfoForDriver
Version |
NID
|
3.60 |
0xC99DCF0D
|
This is a guessed name.
int sceKernelGetSemaInfoForDriver(SceUID semaid, SceKernelSemaInfo *info);
sceKernelGetEventFlagInfoForDriver
Version |
NID
|
3.60 |
0x612277C9
|
This is a guessed name.
int sceKernelGetEventFlagInfoForDriver(SceUID evfid, SceKernelEventFlagInfo *info);
sceKernelGetLwMutexInfoForDriver
Version |
NID
|
3.60 |
0x15287EF6
|
This is a guessed name.
int sceKernelGetLwMutexInfoForDriver(SceUID lwmtxid, SceKernelLwMutexInfo *info);
sceKernelGetMsgPipeInfoForDriver
Version |
NID
|
3.60 |
0x207E0E18
|
This is a guessed name.
int sceKernelGetMsgPipeInfoForDriver(SceUID msgpipe_id, SceKernelMsgPipeInfo *info);
sceKernelGetLwCondInfoForDriver
Version |
NID
|
3.60 |
0xC2AFFBD0
|
This is a guessed name.
int sceKernelGetLwCondInfoForDriver(SceUID lwcond_id, SceKernelLwCondInfo *info);
sceKernelGetThreadExitStatusForDriver
Version |
NID
|
3.60 |
0x70131EA5
|
This is a guessed name.
int sceKernelGetThreadExitStatusForDriver(SceUID thid, SceInt32 *status);
SceThreadmgrForDriver_032E8F73
Version |
NID
|
3.60 |
0x032E8F73
|
sceKernelGetLwMutexInfoAllProcForDriver
Version |
NID
|
3.60 |
0x069D8A20
|
SceThreadmgrForDriver_09346D1A
Version |
NID
|
3.60 |
0x09346D1A
|
SceThreadmgrForDriver_0A4AD37A
Version |
NID
|
3.60 |
0x0A4AD37A
|
sceKernelGetEventPatternForDriver
Version |
NID
|
3.60 |
0x0C6BCB8C
|
SceThreadmgrForDriver_0D0644DA
Version |
NID
|
3.60 |
0x0D0644DA
|
SceThreadmgrForDriver_0EB0ABF0
Version |
NID
|
3.60 |
0x0EB0ABF0
|
SceThreadmgrForDriver_1096042E
Version |
NID
|
3.60 |
0x1096042E
|
SceThreadmgrForDriver_1378F6EF
Version |
NID
|
3.60 |
0x1378F6EF
|
sceKernelGetCurrentThreadVfpExceptionForDriver
Version |
NID
|
3.60 |
0x14F8167C
|
SceThreadmgrForDriver_154F2C2A_waitWorkQueue
Version |
NID
|
3.60 |
0x154F2C2A
|
SceThreadmgrForDriver_19F3E92A
Version |
NID
|
3.60 |
0x19F3E92A
|
SceThreadmgrForDriver_20C228E4
Version |
NID
|
3.60 |
0x20C228E4
|
sceKernelGetMutexInfoAllProcForDriver
Version |
NID
|
3.60 |
0x2322A2F3
|
SceThreadmgrForDriver_25AB8F6B
Version |
NID
|
3.60 |
0x25AB8F6B
|
SceThreadmgrForDriver_2828F884
Version |
NID
|
3.60 |
0x2828F884
|
sceKernelDeleteSimpleEventForDriver
Version |
NID
|
3.60 |
0x2BDE3B40
|
SceThreadmgrForDriver_2E95B628
Version |
NID
|
3.60 |
0x2E95B628
|
SceThreadmgrForDriver_2F9F75AA
Version |
NID
|
3.60 |
0x2F9F75AA
|
SceThreadmgrForDriver_2FC0FFF6
Version |
NID
|
3.60 |
0x2FC0FFF6
|
sceKernelDeleteRWLockForDriver
Version |
NID
|
3.60 |
0x32452017
|
sceKernelGetTimerEventRemainingTimeForDriver
Version |
NID
|
3.60 |
0x3634FFE6
|
SceThreadmgrForDriver_36F8E58A
Version |
NID
|
3.60 |
0x36F8E58A
|
sceKernelGetRWLockInfoForDriver
Version |
NID
|
3.60 |
0x374C3267
|
threadmgrGpuExceptionHandlerForDriver
Version |
NID
|
3.60 |
0x37F51E91
|
sceKernelChangeThreadPriorityAndCpuAffinityMaskForDriver
Version |
NID
|
3.60 |
0x3857C94E
|
SceThreadmgrForDriver_3A72C6D8
Version |
NID
|
3.60 |
0x3A72C6D8
|
SceThreadmgrForDriver_3C297724
Version |
NID
|
3.60 |
0x3C297724
|
SceThreadmgrForDriver_3F5E1D56
Version |
NID
|
3.60 |
0x3F5E1D56
|
SceThreadmgrForDriver_419E6736
Version |
NID
|
3.60 |
0x419E6736
|
SceThreadmgrForDriver_477F7C8A
Version |
NID
|
3.60 |
0x477F7C8A
|
SceThreadmgrForDriver_47F26712
Version |
NID
|
3.60 |
0x47F26712
|
Used to unregister a Threadmgr interrupt handler. See SceThreadmgrForDriver_6C2E3A49.
//Pass same slot and kind as to SceThreadmgrForDriver_6C2E3A49.
int SceThreadmgrForDriver_47F26712(unsigned slot, unsigned kind);
SceThreadmgrForDriver_48C06CD6_waitWorkQueue
Version |
NID
|
3.60 |
0x48C06CD6
|
sceKernelSetVfpRegisterForDebuggerForDriver
Version |
NID
|
3.60 |
0x49A0B679
|
SceThreadmgrForDriver_4A038803
Version |
NID
|
3.60 |
0x4A038803
|
SceThreadmgrForDriver_4DE77569
Version |
NID
|
3.60 |
0x4DE77569
|
SceThreadmgrForDriver_5311CFB5
Version |
NID
|
0.990.000-3.740.011 |
0x5311CFB5
|
Registers exception handler.
Used by SceAppMgr.
int SceThreadmgrForDriver_5311CFB5(int (* handler)(SceUID pid, SceUID thid, int cause_flag, void *argp), void *argp);
SceThreadmgrForDriver_54566860
Version |
NID
|
3.60 |
0x54566860
|
sceKernelCountWaitingThreadsProcForDriver
Version |
NID
|
3.60 |
0x54E1AF04
|
SceThreadmgrForDriver_555CA6BB
Version |
NID
|
3.60 |
0x555CA6BB
|
SceThreadmgrForDriver_56C18B11
Version |
NID
|
3.60 |
0x56C18B11
|
SceThreadmgrForDriver_5870C73A
Version |
NID
|
3.60 |
0x5870C73A
|
SceThreadmgrForDriver_5D8F88B1
Version |
NID
|
3.60 |
0x5D8F88B1
|
sceKernelSetCpuRegisterForDebuggerForDriver
Version |
NID
|
3.60 |
0x64E89DE9
|
sceKernelGetRWLockInfoAllProcForDriver
Version |
NID
|
3.60 |
0x6624E612
|
SceThreadmgrForDriver_6657429E
Version |
NID
|
3.60 |
0x6657429E
|
SceThreadmgrForDriver_67022B18
Version |
NID
|
3.60 |
0x67022B18
|
SceThreadmgrForDriver_6C2E3A49
Version |
NID
|
3.60 |
0x6C2E3A49
|
Register a Threadmgr interrupt handler.
//Specify 0 or 1 for slot.
//Specify one of the following for kind, to select which "interrupt" the handler is registered for:
// 0 -> Thread events (To determine event, check argp->unk0: 1 = DeleteThread, 2 = StartThread)
// 1 -> Vfp
// 2 -> Gpu Exception
// 3 -> Stack overflow
// 4 -> Syscall Error - Illegal Context
// 5 -> Syscall Error - Critical Usage
// 6 -> Syscall Error - Illegal Number
// 7 -> ApiDeclareSuicide (unknown what this is for)
int SceThreadmgrForDriver_6C2E3A49(unsigned slot, unsigned kind, void (*handler)(int args, void* argp));
SceThreadmgrForDriver_6D4C1EB7
Version |
NID
|
3.60 |
0x6D4C1EB7
|
SceThreadmgrForDriver_738FF63D
Version |
NID
|
3.60 |
0x738FF63D
|
sceKernelTryLockFastMutexForDriver
Version |
NID
|
3.60 |
0x741F4707
|
int sceKernelTryLockFastMutexForDriver(void *pFastMutex);
SceThreadmgrForDriver_767CA30C
Version |
NID
|
3.60 |
0x767CA30C
|
sceKernelCancelRWLockForDriver
Version |
NID
|
3.60 |
0x7A4EF925
|
SceThreadmgrForDriver_7D12344A
Version |
NID
|
3.60 |
0x7D12344A
|
SceThreadmgrForDriver_7E280B69
Version |
NID
|
3.60 |
0x7E280B69
|
SceThreadmgrForDriver_84EB1EA4
Version |
NID
|
3.60 |
0x84EB1EA4
|
SceThreadmgrForDriver_85F4DC8C
Version |
NID
|
3.60 |
0x85F4DC8C
|
sceKernelCancelSemaForDriver
Version |
NID
|
3.60 |
0x8760C8ED
|
SceThreadmgrForDriver_88206D29
Version |
NID
|
3.60 |
0x88206D29
|
SceThreadmgrForDriver_89CA5698
Version |
NID
|
3.60 |
0x89CA5698
|
SceThreadmgrForDriver_8C3C1F78
Version |
NID
|
3.60 |
0x8C3C1F78
|
SceThreadmgrForDriver_8C48E53B
Version |
NID
|
3.60 |
0x8C48E53B
|
sceKernelIsUserModeThreadForDriver
Version |
NID
|
3.60 |
0x91382762
|
SceThreadmgrForDriver_91A8F38B
Version |
NID
|
3.60 |
0x91A8F38B
|
sceKernelSetTimerEventForDriver
Version |
NID
|
3.60 |
0x92A3DCDD
|
SceThreadmgrForDriver_995F32E1
Version |
NID
|
3.60 |
0x995F32E1
|
SceThreadmgrForDriver_A64B00F6
Version |
NID
|
3.60 |
0xA64B00F6
|
SceThreadmgrForDriver_A90B1E01
Version |
NID
|
3.60 |
0xA90B1E01
|
SceThreadmgrForDriver_AB977C72
Version |
NID
|
3.60 |
0xAB977C72
|
SceThreadmgrForDriver_AF302193
Version |
NID
|
3.60 |
0xAF302193
|
SceThreadmgrForDriver_B4A05763
Version |
NID
|
3.60 |
0xB4A05763
|
sceKernelGetWaitingThreadListForDriver
Version |
NID
|
3.60 |
0xB5C782A3
|
SceThreadmgrForDriver_B6DA4669
Version |
NID
|
3.60 |
0xB6DA4669
|
sceKernelCancelEventForDriver
Version |
NID
|
3.60 |
0xB6FA8305
|
SceThreadmgrForDriver_C03799E2
Version |
NID
|
3.60 |
0xC03799E2
|
SceThreadmgrForDriver_C2DA6286
Version |
NID
|
3.60 |
0xC2DA6286
|
SceThreadmgrForDriver_C327CA7C
Version |
NID
|
3.60 |
0xC327CA7C
|
SceThreadmgrForDriver_C4456EC9
Version |
NID
|
3.60 |
0xC4456EC9
|
SceThreadmgrForDriver_C6741986
Version |
NID
|
3.60 |
0xC6741986
|
SceThreadmgrForDriver_C7F5FFE0
Version |
NID
|
3.60 |
0xC7F5FFE0
|
SceThreadmgrForDriver_CA704239
Version |
NID
|
3.60 |
0xCA704239
|
sceKernelGetTimerTimeForDriver
Version |
NID
|
3.60 |
0xCB795E13
|
SceThreadmgrForDriver_CBA7FAAA
Version |
NID
|
3.60 |
0xCBA7FAAA
|
SceThreadmgrForDriver_CFA2FFAF
Version |
NID
|
3.60 |
0xCFA2FFAF
|
SceThreadmgrForDriver_D0262C55
Version |
NID
|
3.60 |
0xD0262C55
|
sceKernelPollEventForDriver
Version |
NID
|
3.60 |
0xD08C71C6
|
SceThreadmgrForDriver_D1FBDFA6
Version |
NID
|
3.60 |
0xD1FBDFA6
|
SceThreadmgrForDriver_D26BFF26
Version |
NID
|
3.60 |
0xD26BFF26
|
sceKernelGetTimerBaseForDriver
Version |
NID
|
3.60 |
0xD41F53D4
|
SceThreadmgrForDriver_D7455187
Version |
NID
|
3.60 |
0xD7455187
|
SceThreadmgrForDriver_D74F66BD
Version |
NID
|
3.60 |
0xD74F66BD
|
sceKernelGetFastMutexInfoForDriver
Version |
NID
|
3.60 |
0xD7AF2E58
|
This is a guessed name.
int sceKernelGetFastMutexInfoForDriver(void *pFastMutex, void *pInfo);
sceKernelSetTimerTimeForDriver
Version |
NID
|
3.60 |
0xD978D16F
|
sceKernelChangeThreadPriorityForDriver
Version |
NID
|
3.60 |
0xDA1544D1
|
sceKernelUIDInheritedEventClassInitForDriver
Version |
NID
|
3.60 |
0xDBB77032
|
SceThreadmgrForDriver_E0C7BCBB
Version |
NID
|
3.60 |
0xE0C7BCBB
|
SceThreadmgrForDriver_E2B57231
Version |
NID
|
3.60 |
0xE2B57231
|
sceKernelCancelEventWithSetPatternForDriver
Version |
NID
|
3.60 |
0xE5CAD3E2
|
SceThreadmgrForDriver_E6D80698
Version |
NID
|
3.60 |
0xE6D80698
|
SceThreadmgrForDriver_E938FB20
Version |
NID
|
3.60 |
0xE938FB20
|
SceThreadmgrForDriver_E9E50096
Version |
NID
|
3.60 |
0xE9E50096
|
sceKernelCancelEventFlagForDriver
Version |
NID
|
3.60 |
0xEA211225
|
sceKernelCancelTimerForDriver
Version |
NID
|
3.60 |
0xF285C94F
|
SceThreadmgrForDriver_F2C9DC97
Version |
NID
|
3.60 |
0xF2C9DC97
|
sceKernelChangeThreadVfpExceptionForDriver
Version |
NID
|
3.60 |
0xF4C81683
|
SceThreadmgrForDriver_F5074173
Version |
NID
|
3.60 |
0xF5074173
|
SceThreadmgrForDriver_F8A6013B
Version |
NID
|
3.60 |
0xF8A6013B
|
SceThreadmgrForDriver_F96FE0D5
Version |
NID
|
3.60 |
0xF96FE0D5
|
SceThreadmgrForDriver_FD6150D5
Version |
NID
|
3.60 |
0xFD6150D5
|
SceThreadmgrForDriver_FD87586C
Version |
NID
|
3.60 |
0xFD87586C
|
sceKernelGetCallbackInfoForDriver
Version |
NID
|
3.60 |
0xFDC044AC
|
SceThreadmgrForDriver_FF8DA217
Version |
NID
|
3.60 |
0xFF8DA217
|
SceThreadmgrForKernel
sceKernelCpuScanThreadForProcessmgrForKernel
Version |
NID
|
3.65 |
0x01369E06
|
sceKernelSetDTraceThreadCBEnableForKernel
Version |
NID
|
3.65 |
0x0AE9C713
|
sceKernelSetSyslibtraceThreadCBEnableForKernel
Version |
NID
|
3.65 |
0x4F2B45DC
|
sceKernelSetThreadMgrTestModeForKernel
Version |
NID
|
3.65 |
0x1394E856
|
sceKernelClearThreadMgrTestModeForKernel
Version |
NID
|
3.65 |
0x5D270A94
|
sceKernelThreadMgrProcessCreateForKernel
Version |
NID
|
3.65 |
0xB46502E6
|
sceKernelThreadMgrProcessDeleteAfterPUIDCloseForKernel
Version |
NID
|
3.65 |
0x5A23A1BE
|
sceKernelThreadMgrProcessDeleteBeforePUIDCloseForKernel
Version |
NID
|
3.65 |
0x205506FC
|
sceKernelRegisterKTLSForKernel
Version |
NID
|
0.990.000-1.692.000 |
0xB645C7EF
|
1.80-3.740.011 |
not present. Still present in #SceThreadmgrForDriver.
|
Temp name was sceKernelAllocateKTLSForKernel.
See #sceKernelRegisterKTLSForDriver.
sceKernelUnregisterKTLSForKernel
Version |
NID
|
0.990.000-1.692.000 |
0x8C3C1F78
|
1.80-3.740.011 |
not present. Still present in #SceThreadmgrForDriver.
|
See #sceKernelUnregisterKTLSForDriver.
SceThreadmgrForKernel_89CA5698
Version |
NID
|
0.990.000-1.692.000 |
0x89CA5698
|
1.80-3.740.011 |
not present. Still present in #SceThreadmgrForDriver.
|
See #SceThreadmgrForDriver_89CA5698.
SceThreadmgrForKernel_3A72C6D8
Version |
NID
|
0.990.000-1.692.000 |
0x3A72C6D8
|
1.80-3.740.011 |
not present. Still present in #SceThreadmgrForDriver.
|
See #SceThreadmgrForDriver_3A72C6D8.
sceKernelSetEventWithNotifyCallbackForKernel
sceKernelSetEventFlagForKernel
Version |
NID
|
0.931 |
0xD4780C3E
|
3.60 |
in ForDriver
|
SceThreadmgrForKernel_05F5306C
Version |
NID
|
0.990 |
0x05F5306C
|
3.60 |
not present
|
Uses DIP switch 216.
SceThreadmgrForKernel_CA84C603
Version |
NID
|
0.990 |
0xCA84C603
|
3.60 |
not present
|
Uses DIP switch 216.
sceKernelGetDefaultCpuAffinityMaskForKernel
Version |
NID
|
0.990 |
not present
|
3.60 |
0x091322E5
|
3.65 |
0xD9C097DD
|
sceKernelDebugSuspendThreadForKernel
Version |
NID
|
0.931-0.990 |
0xFB3706CB
|
3.60 |
not present
|
int sceKernelDebugSuspendThreadForKernel(SceUID threadId, SceUInt32 status);
SceThreadmgrForKernel_86DAE59B
Version |
NID
|
0.931-0.990 |
0x86DAE59B
|
3.60 |
not present
|
Get maybe current CPU mask.
int SceThreadmgrForKernel_86DAE59B(void);
sceKernelGetCurrentThreadUnkInfoForKernel
Version |
NID
|
0.931-0.990 |
0x332E127C
|
3.60 |
To ForDriver
|
Get some current thread information.
int sceKernelGetCurrentThreadUnkInfoForKernel(void);
SceThreadmgrForKernel_33E85E9E
Version |
NID
|
0.931-3.60 |
0x33E85E9E
|
typedef struct SceThreadmgrForKernel_33E85E9E_buf { // size is 0x34 on FW 0.990
SceSize size; // Size of this structure
char unk[0x30];
} SceThreadmgrForKernel_33E85E9E_buf;
int SceThreadmgrForKernel_33E85E9E(SceThreadmgrForKernel_33E85E9E_buf *buf);
sceKernelPMonThreadSetEventForKernel
Version |
NID
|
0.990-3.60 |
0x6ECCDCBD
|
sceKernelPMonSetControlRegisterForKernel
See #sceKernelPMonSetControlRegisterForDriver.
sceKernelPMonSetUserEnableRegisterForKernel
See #sceKernelPMonSetUserEnableRegisterForDriver.
sceKernelPMonThreadSetEnableCounterForKernel
Version |
NID
|
0.990.000-3.610.011 |
0x72E5DA4E
|
3.630.011-3.740.011 |
0x7F831213
|
sceKernelPMonThreadSetCounterForKernel
Version |
NID
|
0.990.000-3.610.011 |
0xD2BE5EFB
|
3.630.011-3.740.011 |
0x7B3368F1
|
sceKernelPMonThreadClearEnableCounterForKernel
Version |
NID
|
0.990.000-3.610.011 |
0x43D13895
|
3.630.011-3.740.011 |
0x1D2A6815
|
sceKernelGetThreadIdListForKernel
Version |
NID
|
0.990.000-1.692.000 |
0xEA7B8AEF
|
1.80-3.740.011 |
not present. Still present in SceThreadmgrForDriver.
|
See #sceKernelGetThreadIdListForDriver.
sceKernelCreateTimerForKernel
Version |
NID
|
0.990 |
0x90656C98
|
3.60 |
not present. Moved to ForDriver.
|
int sceKernelCreateTimerForKernel(const char *name, uint32_t attr);
sceKernelLockMutex_089ForKernel
Version |
NID
|
1.69-3.60 |
0x16AC80C5
|
int sceKernelLockMutex_089ForKernel(SceUID mutex_id, int unk1, int unk2);
sceKernelUnlockMutex_089ForKernel
Version |
NID
|
0.990-3.60 |
0x1E82E5D0
|
int sceKernelUnlockMutex_089ForKernel(SceUID mutex_id, int unk1);
sceKernelLockMutexCB_089ForKernel
Version |
NID
|
1.69 |
0xD06F2886
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelTryLockMutex_089ForKernel
Version |
NID
|
1.69 |
0x270993A6
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelCreateMutexForKernel
Version |
NID
|
1.69-3.60 |
0xFBAA026E
|
SceUID sceKernelCreateMutexForKernel(const char *pName, SceUInt attr, int initCount, const SceKernelMutexOptParam *pOptParam);
sceKernelDeleteMutexForKernel
Version |
NID
|
1.69-3.60 |
0x0A912340
|
int sceKernelDeleteMutexForKernel(SceUID mutexid);
sceKernelGetMutexInfo_089ForKernel
Version |
NID
|
1.69 |
0x69B78A12
|
3.60 |
not present. Moved to ForDriver.
|
int sceKernelGetMutexInfo_089ForKernel(SceUID mutexid, SceKernelMutexInfo *info);
sceKernelCancelMutex_089ForKernel
Version |
NID
|
1.69 |
0x7204B846
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelSetThreadAccessLevelForKernel
Version |
NID
|
0.990-3.60 |
0x02EEDF17
|
Temp name was sceKernelSetPermissionForKernel.
// return value is previous value
int sceKernelSetThreadAccessLevelForKernel(int value);
sceKernelCreateSemaForKernel
Version |
NID
|
0.990-3.60 |
0x30E93C31
|
/**
* Creates a new semaphore
*
* @par Example:
* @code
* int semaid;
* semaid = sceKernelCreateSemaForKernel("MySema", 0, 1, 1, 0);
* @endcode
*
* @param name - Specifies the name of the sema
* @param attr - Sema attribute flags (normally set to 0)
* @param initVal - Sema initial value
* @param maxVal - Sema maximum value
* @param option - Sema options (normally set to 0)
* @return A semaphore id
*/
SceUID sceKernelCreateSemaForKernel(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option);
sceKernelSignalSemaForKernel
Version |
NID
|
3.60 |
0xD270498B
|
sceKernelWaitSemaForKernel
Version |
NID
|
3.60 |
0x3C8B55A9
|
/**
* Lock a semaphore
*
* @par Example:
* @code
* sceKernelWaitSemaForKernel(sema_id, 1, 0);
* @endcode
*
* @param sema_id - The sema id returned from ::sceKernelCreateSemaForKernel
* @param signal - The value to wait for (i.e. if 1 then wait till reaches a signal state of 1)
* @param timeout - Timeout in microseconds (assumed).
*
* @return < 0 on error.
*/
int sceKernelWaitSemaForKernel(SceUID sema_id, int signal, SceUInt *timeout);
sceKernelDeleteSemaForKernel
Version |
NID
|
0.990-3.60 |
0x16A35E58
|
sceKernelStartThread_089ForKernel
Version |
NID
|
0.990-1.69 |
0x21F5419B
|
3.60 |
not present. Moved to ForDriver.
|
/**
* @brief Thread activation
*
* Starts the thread specified by threadId and puts it in READY state.
*
* The argument block specified by argSize and argBlock is copied onto the thread stack, argSize is
* passed directly to the first argument of the thread entry function, and the second argument of
* the entry function is the argument copied onto the stack. The block address is passed.
*
* This system call does not queue activation requests. In other words, if the target thread is not
* in the DORMANT state, an SCE_KERNEL_ERROR_NOT_DORMANT error is returned to the calling thread.
*
* @param threadId Specify the identifier of the thread to be started.
* @param argSize Specify the size (byte) of the argument to be passed to the thread.
* @param pArgBlock Specify the address of the argument to be passed to the thread.
* @retval SCE_OK Success
* @retval Negative value Error code
*/
SceInt32 sceKernelStartThread_089ForKernel(
SceUID threadId,
SceSize argSize,
const void *pArgBlock
);
sceKernelWaitThreadEnd_089ForKernel
Version |
NID
|
1.69 |
0xF3489EF4
|
3.60 |
not present
|
sceKernelDelayThreadForKernel
Version |
NID
|
1.69 |
0x4B675D05
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelDelayThreadUnkCBForKernel
Version |
NID
|
0.990 |
0x2B60B793
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelDelayThreadUnkForKernel
Version |
NID
|
0.990 |
0xE9A99C50
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelStopThreadForKernel
Version |
NID
|
0.990-3.60 |
0x150AEF74
|
sceKernelSuspendThreadForKernel
Version |
NID
|
0.931-3.60 |
0xAEEE955F
|
// semaId must be strictly between 0 and 255
int sceKernelSuspendThreadForKernel(SceUID threadId, SceUID semaId);
sceKernelWaitThreadEndCB_089ForKernel
Version |
NID
|
1.69 |
0x0373C5E3
|
3.60 |
not present
|
sceKernelExitThreadForKernel
Version |
NID
|
1.69 |
0x0C8A38E1
|
3.60 |
not present. Moved to ForDriver.
|
/**
* @brief End of own thread
*
* Terminates the own thread normally and shifts to the DORMANT state.
* sceKernelExitThread() is a system call that does not return to the context of the issuer.
*
* Resources (memory, semaphores, etc.) acquired by the terminating thread are not automatically released.
* However, for mutexes only, mutexes that have been locked by the terminating thread are automatically unlocked.
* The mutex is unlocked and not deleted.
*
* When the terminated thread is restarted with sceKernelStartThread(), the information included in the thread
* management area, such as thread priority, is reset.
* It will not inherit the one at the end.
*
* When a thread exits, exitStatus becomes the exit status of that thread.
*
* If the thread is terminated by a return from the entry function without using
* sceKernelExitThread(), the return value of the entry function becomes the termination status.
*
* The end status of a thread can be obtained by sceKernelGetThreadExitStatus() and sceKernelGetThreadInfo(),
* and when another thread waits for the end of the thread by sceKernelWaitThreadEnd(), it can be obtained by the return value.
*
* The thread exit status is saved while the thread exits and is in the DORMANT state,
* but the value is lost if the thread is restarted or deleted with sceKernelStartThread().
*
* @param exitStatus Specify the value to be set for the termination status of the local thread.
* @retval Negative value Error code
*/
SceInt32 sceKernelExitThreadForKernel(
SceInt32 exitStatus
);
sceKernelExitDeleteThreadForKernel
Version |
NID
|
1.69 |
0x1D17DECF
|
3.60 |
not present. Moved to ForDriver.
|
/**
* @brief End and delete own thread
*
* Terminates the own thread normally and deletes it.
* sceKernelExitDeleteThread() is a system call that does not return to the context of the issuer.
*
* Resources (memory, semaphores, etc.) acquired by the terminating thread are not automatically released.
* However, for mutexes only, mutexes that have been locked by the terminating thread are automatically unlocked.
* The mutex is unlocked and not deleted.
*
* When a thread exits, exitStatus becomes the exit status of that thread (sceKernelExitDeleteThread()
* directly deletes the thread without going through the DORMANT state.
* (It cannot be obtained by sceKernelGetThreadInfo(). The end status can be obtained by the return
* value only when waiting for the end of the thread by sceKernelWaitThreadEnd().)
*
* @param exitStatus Specify the value to be set for the termination status of the local thread.
* @retval Negative value Error code
*/
SceInt32 sceKernelExitDeleteThreadForKernel(
SceInt32 exitStatus
);
sceKernelDelayThreadCBForKernel
Version |
NID
|
1.69 |
0x9C0180E1
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelGetThreadCurrentPriorityForKernel
Version |
NID
|
1.69 |
0x01414F0B
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelChangeCurrentThreadAttrForKernel
Version |
NID
|
1.69 |
0x751C9B7A
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelCpuScanThreadForProcessmgrForKernel
Version |
NID
|
0.990-3.60 |
0x3B4B8293
|
sceKernelGetProcessIdForKernel
Version |
NID
|
0.931-1.69 |
0x9DCB4B7A
|
3.60 |
not present. Moved to ForDriver.
|
Returns the process ID.
SceUID sceKernelGetProcessIdForKernel(void);
sceKernelChangeActiveCpuMaskForKernel
Version |
NID
|
1.69 |
0x001173F8
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelCheckWaitableStatusForKernel
Version |
NID
|
1.69 |
0xD9BD74EB
|
3.60 |
not present. Moved to ForDriver.
|
sceKernelCheckCallbackForKernel
Version |
NID
|
1.69 |
0xE53E41F6
|
3.60 |
not present. Moved to ForDriver.
|
_sceKernelExtendKernelStackWideForKernel
Version |
NID
|
0.990-3.60 |
0xE54FD746
|
Temp name was sceKernelRunWithStackForKernel.
This takes a function and runs it exclusively on the current core on its own stack.
// stack_size should be 0x2000
int _sceKernelExtendKernelStackWideForKernel(int stack_size, void *func, void *args);
sceKernelExtendKernelStackWideForKernel
Version |
NID
|
0.990-1.69 |
0xA2C801A5
|
3.60 |
not present. Moved to ForDriver.
|
Temp name was sceKernelRunWithStack2ForKernel.
// stack_size should be 0x2000
int sceKernelExtendKernelStackWideForKernel(int stack_size, void *func, void *args);
sceKernelExtendKernelStackWide2ForKernel
Version |
NID
|
0.990 |
0x236AF33A
|
3.60 |
unk
|
// stack_size should be 0x2000
int sceKernelExtendKernelStackWide2ForKernel(int stack_size, void *func, void *args);
sceKernelGetThreadContextInfoForKernel
Version |
NID
|
0.931-3.60 |
0xD8B9AC8D
|
3.65-3.67 |
0x6C1F092F
|
Temp name was sceKernelGetFaultingProcessForKernel.
Returns information about the thread currently scheduled on caller CPU.
This function can be called from an exception or interrupt handler, in which case it returns information about the thread that was interrupted.
struct SceKernelThreadContextInfo { // Previous name: SceKernelFaultingProcessInfo
ScePID processId; //<! GUID of the process the currently scheduled thread
SceUID threadId; //<! GUID of the thread currently scheduled
};
SceInt32 sceKernelGetThreadContextInfoForKernel(struct SceKernelThreadContextInfo * pInfo);
sceKernelCloseEventFlagForKernel
Version |
NID
|
0.990 |
0x71ECB352
|
3.60 |
not present. Moved to ForDriver.
|
Temp name was sceKernelDeleteEventFlagForKernel.
See #sceKernelCloseEventFlagForDriver.
SceThreadmgrForKernel_E0833C77
Version |
NID
|
0.990-3.57 |
not present. Added on FW 3.60.
|
3.60 |
0xE0833C77
|
sceKernelSetThreadMgrTestModeForKernel
Version |
NID
|
1.69-3.60 |
0x333B26AD
|
int sceKernelSetThreadMgrTestModeForKernel(void);
sceKernelClearThreadMgrTestModeForKernel
Version |
NID
|
1.69-3.60 |
0xE00333A6
|
int sceKernelClearThreadMgrTestModeForKernel(void);
sceKernelSetThreadDebugCallbackForKernel
Version |
NID
|
3.60 |
0x41CF346A
|
This is a guessed name.
typedef struct SceThreadDebugCallbackParam {
union {
struct {
SceKernelThreadEntry entry;
SceUID thid;
SceUID pid;
} create;
struct {
SceUID pid;
SceUID thid;
SceSize argc;
void *argp;
} start;
};
} SceThreadDebugCallbackParam;
typedef int (* SceKernelThreadDebugCallback)(int a1, int a2, SceThreadDebugCallbackParam param);
int (* sceKernelSetThreadDebugCallback)(SceKernelThreadDebugCallback callback);
Code example:
int sceKernelThreadDebugCallback(int a1, int a2, SceThreadDebugCallbackParam param){
// start thread
if (a1 == 2 && a2 == 4) {
ksceDebugPrintf(
"%s:start pid:0x%08X thid:0x%08X argc:0x%08X argp:0x%08X\n",
__FUNCTION__, param.start.pid, param.start.thid, param.start.argc, param.start.argp
);
} else if (a1 == 0 && a2 == 3) { // create thread
} else if (a1 == 7 && a2 == 3) { // some timer (in SceThreadmgrTimer handler)
} else if (a1 == 6 && a2 == 1) { // unknown (in SceThreadmgrForDriver_44CCF310)
} else if (a1 == 1 && a2 == 2) { // delete thread (In sub_81000D78)
}
return 0;
}
SceThreadmgr
_sceKernelCloseTimer
Version |
NID
|
1.69 |
0x22605E63
|
3.60 |
not present
|
_sceKernelCloseMutex
Version |
NID
|
1.69 |
0x21716C81
|
3.60 |
not present
|
_sceKernelPollSema
Version |
NID
|
1.69 |
0x20AF286A
|
3.60 |
not present
|
_sceKernelCancelCallback
Version |
NID
|
1.69 |
0x19A0C1B6
|
3.60 |
not present
|
_sceKernelOpenMsgPipe
Version |
NID
|
1.69 |
0x16EC5B7C
|
3.60 |
not present
|
_sceKernelDeleteEventFlag
Version |
NID
|
1.69 |
0x16C93704
|
3.60 |
not present
|
_sceKernelDeleteThread
Version |
NID
|
1.69 |
0x151E0020
|
3.60 |
not present
|
Simply calls sceKernelDeleteThread();
/**
* @brief Delete thread
*
* Deletes the thread specified by threadId.
*
* Accordingly, the stack area and thread management area are released. The target thread must be in the DORMANT state.
*
* Since the own thread cannot be in the DORMANT state, it cannot be set as the target thread
* (this results in an SCE_KERNEL_ERROR_NOT_DORMANT error).
* Use sceKernelExitDeleteThread() to delete your own thread.
*
* @param threadId Specify the identifier of the thread to be deleted.
* @retval SCE_OK Success
* @retval Negative value Error code
*/
SceInt32 _sceKernelDeleteThread(
SceUID threadId
);
_sceKernelUnlockMutex
Version |
NID
|
1.69 |
0x12948A63
|
3.60 |
not present
|
sceKernelGetActiveCpuMask
Version |
NID
|
1.69 |
0x0C3CBB8B
|
3.60 |
not present
|
_sceKernelSignalCondAll
Version |
NID
|
1.69 |
0x0F11545D
|
3.60 |
not present
|
sceKernelUnregisterThreadEventHandler
Version |
NID
|
3.60 |
0x2C8ED6F0
|
sceKernelChangeActiveCpuMask
Version |
NID
|
1.69-3.60 |
0x001173F8
|
sceKernelGetThreadCurrentPriority
Version |
NID
|
1.69-3.60 |
0x01414F0B
|
sceKernelWaitThreadEndCB_089
Version |
NID
|
1.69-3.60 |
0x0373C5E3
|
sceKernelGetCallbackCount
Version |
NID
|
1.69-3.60 |
0x038644D5
|
_sceKernelTryReceiveMsgPipeVector
Version |
NID
|
1.69-3.60 |
0x03CFCF00
|
sceKernelCloseMutex
Version |
NID
|
1.69-3.60 |
0x03E23AF6
|
_sceKernelGetSemaInfo
Version |
NID
|
1.69-3.60 |
0x0402C633
|
_sceKernelWaitCond
Version |
NID
|
1.69-3.60 |
0x040795C7
|
_sceKernelWaitMultipleEventsCB
Version |
NID
|
1.69-3.60 |
0x0558B7C1
|
_sceKernelGetCondInfo
Version |
NID
|
1.69-3.60 |
0x05C51CE1
|
_sceKernelSignalLwCondAll
Version |
NID
|
1.69-3.60 |
0x07D2584A
|
sceKernelExitThread
Version |
NID
|
1.69-3.60 |
0x0C8A38E1
|
/**
* @brief End of own thread
*
* Terminates the own thread normally and shifts to the DORMANT state.
* sceKernelExitThread() is a system call that does not return to the context of the issuer.
*
* Resources (memory, semaphores, etc.) acquired by the terminating thread are not automatically released.
* However, for mutexes only, mutexes that have been locked by the terminating thread are automatically unlocked.
* The mutex is unlocked and not deleted.
*
* When the terminated thread is restarted with sceKernelStartThread(), the information included in the thread
* management area, such as thread priority, is reset.
* It will not inherit the one at the end.
*
* When a thread exits, exitStatus becomes the exit status of that thread.
*
* If the thread is terminated by a return from the entry function without using
* sceKernelExitThread(), the return value of the entry function becomes the termination status.
*
* The end status of a thread can be obtained by sceKernelGetThreadExitStatus() and sceKernelGetThreadInfo(),
* and when another thread waits for the end of the thread by sceKernelWaitThreadEnd(), it can be obtained by the return value.
*
* The thread exit status is saved while the thread exits and is in the DORMANT state,
* but the value is lost if the thread is restarted or deleted with sceKernelStartThread().
*
* @param exitStatus Specify the value to be set for the termination status of the local thread.
* @retval Negative value Error code
*/
SceInt32 sceKernelExitThread(
SceInt32 exitStatus
);
_sceKernelCreateSema
Version |
NID
|
1.69-3.60 |
0x0D76458E
|
sceKernelOpenMsgPipe
Version |
NID
|
1.69-3.60 |
0x0E1CB9F6
|
_sceKernelGetEventFlagInfo
Version |
NID
|
1.69-3.60 |
0x106C216F
|
_sceKernelSetEventWithNotifyCallback
Version |
NID
|
1.69-3.60 |
0x118F646E
|
sceKernelSignalCondTo
Version |
NID
|
1.69-3.60 |
0x1269F4EC
|
sceKernelCloseMsgPipe
Version |
NID
|
1.69-3.60 |
0x1305A065
|
_sceKernelCancelTimer
Version |
NID
|
1.69-3.60 |
0x13117B21
|
sceKernelChangeThreadCpuAffinityMask
Version |
NID
|
1.69-3.60 |
0x15129174
|
/**
* @brief Thread CPU affinity mask setting
*
* Change the CPU affinity mask of the thread specified by threadId to cpuAffinityMask.
* A thread can run only on the CPU specified by the CPU affinity mask.
*
* If the CPU affinity mask of a running thread is changed and cannot be executed on the current CPU, the thread is dispatched immediately.
* As a result of scheduling, if a higher priority thread is running on the newly executable CPU, it is made to wait in the READY state.
*
* However, if the dispatch is disabled, the CPU affinity mask is changed immediately,
* but the rescheduling process is delayed until dispatch is permitted.
*
* @param threadId Specify the identifier of the thread whose CPU affinity mask is to be changed.
* You can specify your own thread with SCE_KERNEL_THREAD_ID_SELF.
* @param cpuAffinityMask Specify the CPU affinity mask after the change.
* The CPU affinity mask is expressed by the logical OR of the following macros.
* - SCE_KERNEL_CPU_MASK_USER_0
* - SCE_KERNEL_CPU_MASK_USER_1
* - SCE_KERNEL_CPU_MASK_USER_2
* The following macros are also available to specify all available CPUs.
* - SCE_KERNEL_CPU_MASK_USER_ALL
* @retval Positive value CPU affinity mask before change
* @retval Negative value Error code
*/
SceInt32 sceKernelChangeThreadCpuAffinityMask(
SceUID threadId,
SceInt32 cpuAffinityMask
);
sceKernelCloseCond
Version |
NID
|
1.69-3.60 |
0x15C690E0
|
sceKernelLockMutex_089
Version |
NID
|
1.69-3.60 |
0x16AC80C5
|
int sceKernelLockMutex_089(SceUID mutex_id, int unk1, int unk2);
sceKernelUnregisterCallbackFromEvent
Version |
NID
|
1.69-3.60 |
0x18462B11
|
_sceKernelWaitLwCond
Version |
NID
|
1.69-3.60 |
0x18C65756
|
sceKernelUnlockMutex
Version |
NID
|
1.69-3.60 |
0x1A372EC8
|
_sceKernelCancelMutex
Version |
NID
|
1.69-3.60 |
0x1B74CB89
|
sceKernelDeleteThread
Version |
NID
|
1.69-3.60 |
0x1BBDE3D9
|
/**
* @brief Delete thread
*
* Deletes the thread specified by threadId.
*
* Accordingly, the stack area and thread management area are released. The target thread must be in the DORMANT state.
*
* Since the own thread cannot be in the DORMANT state, it cannot be set as the target thread
* (this results in an SCE_KERNEL_ERROR_NOT_DORMANT error).
* Use sceKernelExitDeleteThread() to delete your own thread.
*
* @param threadId Specify the identifier of the thread to be deleted.
* @retval SCE_OK Success
* @retval Negative value Error code
*/
SceInt32 sceKernelDeleteThread(
SceUID threadId
);
_sceKernelCancelSema
Version |
NID
|
1.69-3.60 |
0x1CAF805D
|
sceKernelExitDeleteThread
Version |
NID
|
1.69-3.60 |
0x1D17DECF
|
/**
* @brief End and delete own thread
*
* Terminates the own thread normally and deletes it.
* sceKernelExitDeleteThread() is a system call that does not return to the context of the issuer.
*
* Resources (memory, semaphores, etc.) acquired by the terminating thread are not automatically released.
* However, for mutexes only, mutexes that have been locked by the terminating thread are automatically unlocked.
* The mutex is unlocked and not deleted.
*
* When a thread exits, exitStatus becomes the exit status of that thread (sceKernelExitDeleteThread()
* directly deletes the thread without going through the DORMANT state.
* (It cannot be obtained by sceKernelGetThreadInfo(). The end status can be obtained by the return
* value only when waiting for the end of the thread by sceKernelWaitThreadEnd().)
*
* @param exitStatus Specify the value to be set for the termination status of the local thread.
* @retval Negative value Error code
*/
SceInt32 sceKernelExitDeleteThread(
SceInt32 exitStatus
);
sceKernelUnlockMutex_089
Version |
NID
|
1.69-3.60 |
0x1E82E5D0
|
int sceKernelUnlockMutex_089(SceUID mutex_id, int unk1);
_sceKernelWaitMultipleEvents
Version |
NID
|
1.69-3.60 |
0x200CC503
|
sceKernelTryLockWriteRWLock
Version |
NID
|
1.69-3.60 |
0x206CBB66
|
sceKernelDeleteSimpleEvent
Version |
NID
|
1.69-3.60 |
0x208CFE28
|
_sceKernelGetThreadCpuAffinityMask
Version |
NID
|
1.69-3.60 |
0x212E6C35
|
_sceKernelGetTimerEventRemainingTime
Version |
NID
|
1.69-3.60 |
0x215FD24D
|
_sceKernelPollEvent
Version |
NID
|
1.69-3.60 |
0x21C7913E
|
sceKernelStartThread_089
Version |
NID
|
1.69-3.60 |
0x21F5419B
|
/**
* @brief Thread activation
*
* Starts the thread specified by threadId and puts it in READY state.
*
* The argument block specified by argSize and argBlock is copied onto the thread stack, argSize is
* passed directly to the first argument of the thread entry function, and the second argument of
* the entry function is the argument copied onto the stack. The block address is passed.
*
* This system call does not queue activation requests. In other words, if the target thread is not
* in the DORMANT state, an SCE_KERNEL_ERROR_NOT_DORMANT error is returned to the calling thread.
*
* @param threadId Specify the identifier of the thread to be started.
* @param argSize Specify the size (byte) of the argument to be passed to the thread.
* @param pArgBlock Specify the address of the argument to be passed to the thread.
* @retval SCE_OK Success
* @retval Negative value Error code
*/
SceInt32 sceKernelStartThread_089(
SceUID threadId,
SceSize argSize,
const void *pArgBlock
);
_sceKernelExitCallback
Version |
NID
|
1.69 |
0x2682E6ED
|
sceKernelTryLockMutex_089
Version |
NID
|
1.69-3.60 |
0x270993A6
|
sceKernelSetTimerTimeWide
Version |
NID
|
1.69 |
0x273B4A4D
|
_sceKernelOpenCond
Version |
NID
|
1.69 |
0x27DD11EA
|
_sceKernelGetThreadmgrUIDClass
Version |
NID
|
1.69 |
0x27EE191B
|
sceKernelOpenMutex_089
Version |
NID
|
1.69 |
0x2928D2EC
|
_sceKernelCancelEvent
Version |
NID
|
1.69 |
0x29483405
|
_sceKernelCreateMsgPipeWithLR
Version |
NID
|
1.69 |
0x2AAC8BFD
|
typedef struct SceKernelCreateMsgPipeSyscallArgs { // size is 0x10-bytes
SceSize bufSize;
void *opt;
void *lr;
int padding_0x0C:
} SceKernelCreateMsgPipeSyscallArgs;
int _sceKernelCreateMsgPipeWithLR(const char *name, int type, int attr, SceKernelCreateMsgPipeSyscallArgs *args);
_sceKernelUnlockLwMutex
Version |
NID
|
1.69 |
0x2ABC41DF
|
_sceKernelGetMsgPipeCreatorId
Version |
NID
|
1.69 |
0x2B751F95
|
sceKernelCancelCallback
Version |
NID
|
1.69 |
0x30741EF2
|
sceKernelSetEvent
Version |
NID
|
1.69 |
0x324218CD
|
_sceKernelGetTimerBaseWide
Version |
NID
|
1.69 |
0x370E147B
|
_sceKernelGetThreadContextForVM
Version |
NID
|
1.69 |
0x377094D5
|
_sceKernelCreateEventFlag
Version |
NID
|
1.69 |
0x38AA5E8E
|
/**
* @brief Event flag generation
*
* Generate an event flag and set the initial value of the event flag. Returns the identifier of the generated event flag as a return value.
*
* @param pName Specifies the name of the eventflag.
* The name of the eventflag does not need to be unique because it is used only for the purpose of operator
* identification when debugging without interprocess communication.
* However, if the SCE_KERNEL_ATTR_OPENABLE attribute is specified for attr,
* a unique name must be specified in the system.
* The maximum name length is 31 bytes.
* @param attr Specifies the event flag attribute.
* Specify the queue order from one of the following.
* - SCE_KERNEL_EVF_ATTR_TH_FIFO: Waiting thread queuing is FIFO
* - SCE_KERNEL_EVF_ATTR_TH_PRIO: Waiting thread queuing is based on the priority of threads.
* Specify whether to wait for multiple threads from either of the following.
* - SCE_KERNEL_EVF_ATTR_SINGLE: Multiple threads cannot wait simultaneously
* - SCE_KERNEL_EVF_ATTR_MULTI: To generate an event flag that can be referenced by
* sceKernelOpenEventFlag() that allows multiple threads to wait simultaneously, specify the following:
* - SCE_KERNEL_ATTR_OPENABLE
* @param initPattern Specifies the initial value of the eventflag.
* @param pOptParam Argument for future expansion. Please specify NULL.
* @retval (>=0) Event flag identifier (UID)
* @retval (<0) Error code
*/
SceUID _sceKernelCreateEventFlag(const char *pName, SceUInt32 attr, SceUInt32 initPattern, const SceKernelEventFlagOptParam *pOptParam);
_sceKernelSetTimerTimeWide
Version |
NID
|
1.69 |
0x39364623
|
_sceKernelWaitThreadEndCB_0910
Version |
NID
|
1.69 |
0x394BCCF2
|
_sceKernelSignalCondTo
Version |
NID
|
1.69 |
0x3C00071F
|
_sceKernelReceiveMsgPipeVector
Version |
NID
|
1.69 |
0x3DD9E4AB
|
_sceKernelPulseEventWithNotifyCallback
Version |
NID
|
1.69 |
0x3E49D3F1
|
sceKernelUnlockReadRWLock
Version |
NID
|
1.69 |
0x3EF91145
|
sceKernelGetTimerTimeWide
Version |
NID
|
1.69 |
0x3EFD3165
|
_sceKernelCreateCallback
Version |
NID
|
1.69 |
0x3F42E175
|
_sceKernelWaitEventFlagCB
Version |
NID
|
1.69 |
0x401E0C68
|
_sceKernelSetEventFlag
Version |
NID
|
1.69 |
0x438917E4
|
_sceKernelWaitCondCB
Version |
NID
|
1.69 |
0x452B0AB3
|
_sceKernelWaitSema
Version |
NID
|
1.69 |
0x45389B6B
|
sceKernelGetSystemTimeLow
Version |
NID
|
1.69-3.60 |
0x47F6DE49
|
sceKernelStartTimer
Version |
NID
|
1.69 |
0x48091E0C
|
sceKernelDelayThread
Version |
NID
|
1.69-3.60 |
0x4B675D05
|
_sceKernelClearEvent
Version |
NID
|
1.69 |
0x4B7F47DC
|
__sceKernelCreateLwMutex
Version |
NID
|
1.69-3.60 |
0x4BB3154A
|
typedef struct sceKernelCreateLwMutex_opt //size is 0x10
{
int initCount;
const SceKernelLwMutexOptParam* pOptParam;
uint32_t unk_8;
uint32_t unk_C;
} sceKernelCreateLwMutex_opt;
int __sceKernelCreateLwMutex(SceKernelLwMutexWork *pWork, const char *pName, unsigned int attr, sceKernelCreateLwMutex_opt* opt);
sceKernelClearEventFlag
Version |
NID
|
1.69 |
0x4CB87CA7
|
_sceKernelReceiveMsgPipeVectorCB
Version |
NID
|
1.69 |
0x4DBF648E
|
_sceKernelNotifyCallback
Version |
NID
|
1.69 |
0x4DF8B624
|
_sceKernelWaitEvent
Version |
NID
|
1.69 |
0x4E0EA70D
|
sceKernelOpenSimpleEvent
Version |
NID
|
1.69 |
0x4E1E4DF8
|
sceKernelGetThreadStackFreeSize
Version |
NID
|
1.69 |
0x4F8A3DA0
|
_sceKernelWaitSignal
Version |
NID
|
1.69 |
0x50407BF4
|
_sceKernelTryLockWriteRWLock
Version |
NID
|
1.69 |
0x52DD3322
|
sceKernelOpenMutex
Version |
NID
|
1.69 |
0x52E17182
|
sceKernelDeleteEventFlag
Version |
NID
|
1.69 |
0x5840162C
|
_sceKernelUnregisterCallbackFromEventAll
Version |
NID
|
1.69 |
0x5B5650C7
|
_sceKernelUnlockWriteRWLock
Version |
NID
|
1.69 |
0x5B746A69
|
_sceKernelGetCallbackCount
Version |
NID
|
1.69 |
0x5D06FF09
|
_sceKernelLockReadRWLockCB
Version |
NID
|
1.69 |
0x5D86D763
|
sceKernelGetTimerBaseWide
Version |
NID
|
1.69 |
0x5DBC1960
|
_sceKernelSendMsgPipeVector
Version |
NID
|
1.69 |
0x5E65E454
|
_sceKernelWaitExceptionCB
Version |
NID
|
1.69 |
0x5E7876F2
|
sceKernelResumeThreadForVM
Version |
NID
|
0.931-1.61 |
not present
|
1.660.011-2.120.011 |
0x5E93840E
|
2.50-3.740.011 |
not present
|
_sceKernelCloseCond
Version |
NID
|
1.69 |
0x650CE348
|
_sceKernelPMonCpuGetCounter
Version |
NID
|
1.69 |
0x667A4649
|
_sceKernelGetActiveCpuMask
Version |
NID
|
1.69 |
0x67FDA21B
|
_sceKernelDeleteCallback
Version |
NID
|
1.69 |
0x68D0FA79
|
sceKernelGetMutexInfo_089
Version |
NID
|
1.69-3.60 |
0x69B78A12
|
int sceKernelGetMutexInfo_089(SceUID mutexid, SceKernelMutexInfo *info);
_sceKernelPMonThreadGetCounter
Version |
NID
|
1.69 |
0x6B9711AC
|
_sceKernelGetLwCondInfo
Version |
NID
|
1.69 |
0x6C79F2F2
|
sceKernelSignalCond
Version |
NID
|
1.69-3.60 |
0x6ED2E2DC
|
_sceKernelSignalLwCondTo
Version |
NID
|
1.69 |
0x6F1A4A2E
|
_sceKernelGetTimerTime
Version |
NID
|
1.69 |
0x6F2C41BA
|
_sceKernelWaitException
Version |
NID
|
1.69 |
0x6F7C4DE6
|
_sceKernelGetEventPattern
Version |
NID
|
1.69 |
0x70358258
|
sceKernelGetMsgPipeCreatorId
Version |
NID
|
1.69 |
0x70E2A6D2
|
_sceKernelSuspendThreadForVM
Version |
NID
|
1.000.071-1.810.021 |
0x7192B01C
|
2.000.081-3.740.011 |
not present
|
sceKernelCancelMutex_089
Version |
NID
|
1.69-3.60 |
0x7204B846
|
_sceKernelWaitLwCondCB
Version |
NID
|
1.69 |
0x72DBB96B
|
sceKernelTryLockMutex
Version |
NID
|
1.69 |
0x72FC1F54
|
sceKernelChangeCurrentThreadAttr
Version |
NID
|
1.69-3.60 |
0x751C9B7A
|
_sceKernelDeleteLwCond
Version |
NID
|
1.69 |
0x75FCF058
|
sceKernelOpenCond
Version |
NID
|
1.69 |
0x76BDA02F
|
sceKernelRegisterCallbackToEvent
Version |
NID
|
1.69 |
0x76FB37E9
|
_sceKernelSignalCond
Version |
NID
|
1.69 |
0x79889DAC
|
_sceKernelCreateTimer
Version |
NID
|
1.69 |
0x79BA0A6D
|
_sceKernelGetMsgPipeInfo
Version |
NID
|
1.69 |
0x7AE31060
|
sceKernelClearEvent
Version |
NID
|
1.69 |
0x7B2A4B28
|
_sceKernelUnlockReadRWLock
Version |
NID
|
1.69 |
0x7D16FB3B
|
_sceKernelWaitEventCB
Version |
NID
|
1.69 |
0x7D483C33
|
_sceKernelLockReadRWLock
Version |
NID
|
1.69 |
0x7EB9E8B5
|
_sceKernelLockMutex
Version |
NID
|
1.69 |
0x7FA945AD
|
_sceKernelGetThreadExitStatus_0940
Version |
NID
|
1.69 |
0x800BB137
|
_sceKernelLockWriteRWLock
Version |
NID
|
1.69 |
0x80191FAA
|
_sceKernelGetSystemInfo
Version |
NID
|
1.69 |
0x80544E0C
|
_sceKernelDeleteSema
Version |
NID
|
1.69 |
0x855F49D5
|
_sceKernelOpenTimer
Version |
NID
|
1.69 |
0x8564E008
|
_sceKernelGetTimerBase
Version |
NID
|
1.69 |
0x865DA482
|
sceKernelPollSema
Version |
NID
|
1.69 |
0x866EF048
|
_sceKernelGetCallbackInfo
Version |
NID
|
1.69 |
0x86761234
|
sceKernelStopTimer
Version |
NID
|
1.69 |
0x869E9F20
|
sceKernelDeleteCond
Version |
NID
|
1.69 |
0x879E6EBD
|
sceKernelUnregisterCallbackFromEventAll
Version |
NID
|
1.69 |
0x888A7361
|
_sceKernelGetRWLockInfo
Version |
NID
|
1.69 |
0x8CE3AFC7
|
sceKernelPulseEvent
Version |
NID
|
1.69 |
0x8D27BAD6
|
_sceKernelCancelEventWithSetPattern
Version |
NID
|
1.69 |
0x8E68E870
|
_sceKernelSignalSema
Version |
NID
|
1.69 |
0x8E9A0400
|
_sceKernelDeleteLwMutex
Version |
NID
|
1.69 |
0x91262C5F
|
_sceKernelDeleteTimer
Version |
NID
|
1.69 |
0x921A043D
|
_sceKernelCreateMutex
Version |
NID
|
1.69 |
0x92667AE5
|
SceUID _sceKernelCreateMutex(const char *pName, SceUInt32 attr, SceInt32 initCount, const SceKernelMutexOptParam *pOptParam);
_sceKernelCreateLwCond
Version |
NID
|
1.69 |
0x940B9EBE
|
sceKernelCloseEventFlag
Version |
NID
|
1.69 |
0x9A68F547
|
_sceKernelSetEvent
Version |
NID
|
1.69 |
0x9A92C33F
|
_sceKernelDeleteRWLock
Version |
NID
|
1.69 |
0x9AA387DF
|
_sceKernelGetTimerTimeWide
Version |
NID
|
1.69 |
0x9AC39954
|
_sceKernelRegisterCallbackToEvent
Version |
NID
|
1.69 |
0x9B1922F2
|
sceKernelDelayThreadCB
Version |
NID
|
1.69-3.60 |
0x9C0180E1
|
_sceKernelCreateSimpleEvent
Version |
NID
|
1.69 |
0x9C187FAD
|
_sceKernelLockLwMutex
Version |
NID
|
1.69 |
0x9C572180
|
_sceKernelChangeThreadCpuAffinityMask
Version |
NID
|
1.69 |
0x9C921F8D
|
Simply calls sceKernelChangeThreadCpuAffinityMask().
/**
* @brief Thread CPU affinity mask setting
*
* Change the CPU affinity mask of the thread specified by threadId to cpuAffinityMask.
* A thread can run only on the CPU specified by the CPU affinity mask.
*
* If the CPU affinity mask of a running thread is changed and cannot be executed on the current CPU, the thread is dispatched immediately.
* As a result of scheduling, if a higher priority thread is running on the newly executable CPU, it is made to wait in the READY state.
*
* However, if the dispatch is disabled, the CPU affinity mask is changed immediately,
* but the rescheduling process is delayed until dispatch is permitted.
*
* @param threadId Specify the identifier of the thread whose CPU affinity mask is to be changed.
* You can specify your own thread with SCE_KERNEL_THREAD_ID_SELF.
* @param cpuAffinityMask Specify the CPU affinity mask after the change.
* The CPU affinity mask is expressed by the logical OR of the following macros.
* - SCE_KERNEL_CPU_MASK_USER_0
* - SCE_KERNEL_CPU_MASK_USER_1
* - SCE_KERNEL_CPU_MASK_USER_2
* The following macros are also available to specify all available CPUs.
* - SCE_KERNEL_CPU_MASK_USER_ALL
* @retval Positive value CPU affinity mask before change
* @retval Negative value Error code
*/
SceInt32 _sceKernelChangeThreadCpuAffinityMask(
SceUID threadId,
SceInt32 cpuAffinityMask
);
_sceKernelOpenMutex
Version |
NID
|
1.69 |
0x9D291788
|
sceKernelGetProcessId
Version |
NID
|
1.69-3.60 |
0x9DCB4B7A
|
sceKernelCloseSema
Version |
NID
|
1.69 |
0xA2D81F9E
|
sceKernelCloseMutex_089
Version |
NID
|
1.69 |
0xA35427EE
|
sceKernelNotifyCallback
Version |
NID
|
1.69 |
0xA4683592
|
_sceKernelCloseMsgPipe
Version |
NID
|
1.69 |
0xAA888831
|
sceKernelDeleteTimer
Version |
NID
|
1.69 |
0xAB1E42C4
|
_sceKernelGetTimerInfo
Version |
NID
|
1.69 |
0xAC7FE4F3
|
sceKernelCloseTimer
Version |
NID
|
1.69 |
0xACE60E4A
|
_sceKernelCreateRWLock
Version |
NID
|
1.69 |
0xB1877F5E
|
sceKernelCreateCallback
Version |
NID
|
1.69 |
0xB19CF7E9
|
_sceKernelGetThreadInfo
Version |
NID
|
1.69-3.60 |
0xB373D8A1
|
typedef struct get_thread_info_opt
{
uint32_t size; // size of SceKernelThreadInfo
uint32_t unk;
}get_thread_info_opt;
int _sceKernelGetThreadInfo(SceUID thid, SceKernelThreadInfo *info, get_thread_info_opt* opt)
_sceKernelTrySendMsgPipeVector
Version |
NID
|
1.69 |
0xB3D600AB
|
sceKernelUnlockWriteRWLock
Version |
NID
|
1.69 |
0xB4151397
|
_sceKernelGetThreadStackFreeSize
Version |
NID
|
1.69 |
0xB5EC061A
|
_sceKernelDeleteMsgPipe
Version |
NID
|
1.69 |
0xB6D50FCC
|
sceKernelOpenTimer
Version |
NID
|
1.69 |
0xB6E286E7
|
_sceKernelGetSystemTime
Version |
NID
|
1.69 |
0xB70EBAE9
|
_sceKernelChangeThreadVfpException
Version |
NID
|
1.69 |
0xB8F165B4
|
_sceKernelOpenSema
Version |
NID
|
1.69 |
0xB96FED7D
|
_sceKernelGetThreadTLSAddr
Version |
NID
|
1.69 |
0xBACA6891
|
sceKernelOpenEventFlag
Version |
NID
|
1.69 |
0xBC19F8A1
|
_sceKernelTryLockMutex
Version |
NID
|
1.69 |
0xBCFB867F
|
sceKernelChangeThreadPriority
Version |
NID
|
1.69 |
0xBD0139F2
|
sceKernelCreateThreadForUser
Version |
NID
|
1.69-3.60 |
0xC0FAF6A3
|
/**
* @brief Thread generation that operates in the address space of its own process
*
* A thread that operates in the address space of its own process is created.
*
* Allocate a thread management area for the thread to be created, perform initialization, and secure a stack area.
* The thread information to be created is specified as an argument, and the thread identifier (UID) is returned as the return value.
*
* The generated thread is in the DORMANT state.
*
* @param pName Specifies the name of the thread.
* The name of the thread does not have to be unique because it is
* used by the operator to identify it when debugging. The maximum name length is 31 bytes.
* @param entry Specify the entry address of the thread. The thread entry point function
* can receive memory block data with two arguments.
* The argument is given by sceKernelStartThread() described later.
* The thread is terminated by returning from this function, and the return value of the function is the thread termination status.
* @param initPriority Specifies the initial priority of the thread. The smaller the number, the higher the priority.
* The range from SCE_KERNEL_HIGHEST_PRIORITY_USER (= 64) to SCE_KERNEL_LOWEST_PRIORITY_USER (= 191) can be used.
* By specifying SCE_KERNEL_DEFAULT_PRIORITY_USER, you can specify the default priority of the process to which the thread belongs.
* For the default priority, it is also possible to specify with SCE_KERNEL_DEFAULT_PRIORITY_USER ± offset.
* @param stackSize Specify the required stack size of the thread in bytes. The argument block given by
* sceKernelStartThread () is copied onto the stack, so specify the stack size with this margin in mind.
* An error will occur if a stack size less than 4 KiB is specified.
* @param attr You can specify multiple thread attributes by logical OR.
* @param cpuAffinityMask Specifies the initial CPU affinity mask for the thread.
* A thread can run only on the thread specified in the CPU affinity mask.
* The CPU affinity mask can be specified by the logical sum of the following macros.
* - SCE_KERNEL_CPU_MASK_USER_0
* - SCE_KERNEL_CPU_MASK_USER_1
* - SCE_KERNEL_CPU_MASK_USER_2
* The following macros are also available to represent all available CPUs.
* - SCE_KERNEL_CPU_MASK_USER_ALL
* @param pOptParam Argument for future expansion. Please specify NULL. Max size is 0x14.
* @retval Positive value Thread identifier (UID)
* @retval Negative value Error code
*/
SceUID sceKernelCreateThreadForUser(
const char *pName,
SceKernelThreadEntry entry,
SceInt32 initPriority,
SceSize stackSize,
SceUInt32 attr,
SceInt32 cpuAffinityMask,
const SceKernelThreadOptParam *pOptParam
);
_sceKernelSendSignal
Version |
NID
|
1.69 |
0xC21FC992
|
_sceKernelCloseRWLock
Version |
NID
|
1.69 |
0xC239DBCC
|
sceKernelSignalCondAll
Version |
NID
|
1.69 |
0xC2E7AC22
|
_sceKernelStartThread
Version |
NID
|
1.69 |
0xC30B1745
|
/**
* @brief Thread activation
*
* Starts the thread specified by threadId and puts it in READY state.
*
* The argument block specified by argSize and argBlock is copied onto the thread stack, argSize is
* passed directly to the first argument of the thread entry function, and the second argument of
* the entry function is the argument copied onto the stack. The block address is passed.
*
* This system call does not queue activation requests. In other words, if the target thread is not
* in the DORMANT state, an SCE_KERNEL_ERROR_NOT_DORMANT error is returned to the calling thread.
*
* @param threadId Specify the identifier of the thread to be started.
* @param argSize Specify the size (byte) of the argument to be passed to the thread.
* @param pArgBlock Specify the address of the argument to be passed to the thread.
* @retval SCE_OK Success
* @retval Negative value Error code
*/
SceInt32 _sceKernelStartThread(
SceUID threadId,
SceSize argSize,
const void *pArgBlock
);
_sceKernelSignalLwCond
Version |
NID
|
1.69 |
0xC37F6983
|
_sceKernelStartTimer
Version |
NID
|
1.69 |
0xC3ED6E4A
|
_sceKernelCloseSimpleEvent
Version |
NID
|
1.69 |
0xC6FFE335
|
_sceKernelGetThreadRunStatus
Version |
NID
|
1.69 |
0xC7FB5497
|
sceKernelGetThreadmgrUIDClass
Version |
NID
|
1.69 |
0xC9678F7F
|
_sceKernelStopTimer
Version |
NID
|
1.69 |
0xC96F4269
|
sceKernelDeleteMutex
Version |
NID
|
1.69 |
0xCB78710D
|
sceKernelOpenSema
Version |
NID
|
1.69 |
0xCBE235C7
|
_sceKernelCreateCond
Version |
NID
|
1.69 |
0xCC14FA59
|
sceKernelChangeThreadVfpException
Version |
NID
|
1.69 |
0xCC18FBAE
|
sceKernelOpenRWLock
Version |
NID
|
1.69 |
0xCE510196
|
_sceKernelCancelMsgPipe
Version |
NID
|
1.69 |
0xCE769C83
|
_sceKernelWaitSignalCB
Version |
NID
|
1.69 |
0xCEA3FC52
|
_sceKernelCancelRWLock
Version |
NID
|
1.69 |
0xD004EA15
|
sceKernelLockMutexCB_089
Version |
NID
|
1.69-3.60 |
0xD06F2886
|
_sceKernelGetThreadExitStatus
Version |
NID
|
1.69 |
0xD3210C08
|
_sceKernelWaitThreadEnd_0910
Version |
NID
|
1.69 |
0xD38231C9
|
sceKernelDeleteCallback
Version |
NID
|
1.69 |
0xD469676B
|
_sceKernelSetThreadContextForVM
Version |
NID
|
1.69 |
0xD4785C41
|
sceKernelSendSignal
Version |
NID
|
1.69 |
0xD4C367B2
|
_sceKernelDeleteCond
Version |
NID
|
1.69 |
0xD99F51D3
|
sceKernelCheckWaitableStatus
Version |
NID
|
1.69-3.60 |
0xD9BD74EB
|
_sceKernelGetLwCondInfoById
Version |
NID
|
1.69 |
0xD9E78D30
|
_sceKernelPollEventFlag
Version |
NID
|
1.69 |
0xDAB1B1C8
|
/**
* @brief Event flag polling
*
* Polls the event flag specified by evfId.
*
* sceKernelPollEventFlag() is a system call that removes the function to enter standby state from sceKernelWaitEventFlag().
* Unlike sceKernelWaitEventFlag(), an error (SCE_KERNEL_ERROR_EVF_COND) is returned immediately if the wait release condition is not satisfied.
* In this case, SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL / SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT specification is ignored.
*
* @param evfId Specify the event flag identifier to be polled.
* @param bitPattern Specify the comparison value with the eventflag.
* @param waitMode Specify the wait mode. Specify one of the following:
* - SCE_KERNEL_EVF_WAITMODE_AND: Waiting for AND
* - SCE_KERNEL_EVF_WAITMODE_OR : Wait for OR
* In addition, you can optionally add one of the following specifications as a logical sum.
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL: Clear all bits after waiting
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT: After waiting, clear the bit specified in bitPattern
* @param pResultPat Specify a pointer to the SceUInt32 type variable that receives the eventflag value when waiting is established.
* @retval SCE_OK Success
* @retval (<0) Error code
*/
SceInt32 _sceKernelPollEventFlag(SceUID evfId, SceUInt32 bitPattern, SceUInt32 waitMode, SceUInt32 *pResultPat);
sceKernelDeleteSema
Version |
NID
|
1.69 |
0xDB32948A
|
_sceKernelLockMutexCB
Version |
NID
|
1.69 |
0xDB9F5333
|
_sceKernelLockWriteRWLockCB
Version |
NID
|
1.69 |
0xDBD09B09
|
_sceKernelOpenRWLock
Version |
NID
|
1.69 |
0xDFCEE5AB
|
_sceKernelDeleteMutex
Version |
NID
|
1.69 |
0xE0A6D759
|
_sceKernelSetTimerEvent
Version |
NID
|
1.69 |
0xE2C0BFEF
|
_sceKernelOpenSimpleEvent
Version |
NID
|
1.69 |
0xE326EA7A
|
sceKernelCheckCallback
Version |
NID
|
1.69-3.60 |
0xE53E41F6
|
_sceKernelChangeThreadPriority
Version |
NID
|
1.69 |
0xE61C2B06
|
sceKernelSignalSema
Version |
NID
|
1.69 |
0xE6B761D1
|
sceKernelDeleteRWLock
Version |
NID
|
1.69 |
0xE73649CA
|
sceKernelDeleteMsgPipe
Version |
NID
|
1.69 |
0xE78BCCF7
|
_sceKernelCloseSema
Version |
NID
|
1.69 |
0xE8C03447
|
_sceKernelGetMutexInfo
Version |
NID
|
1.69-3.60 |
0xE8CC3DF0
|
int _sceKernelGetMutexInfo(SceUID mutexid, SceKernelMutexInfo *pInfo, SceKernelMutexOptParam* pOpt);
_sceKernelWaitThreadEnd
Version |
NID
|
1.69 |
0xEA5C52F5
|
_sceKernelTryLockReadRWLock
Version |
NID
|
1.69 |
0xEB9054B2
|
sceKernelSetEventFlag
Version |
NID
|
1.69 |
0xEC94DFF7
|
sceKernelTryLockReadRWLock
Version |
NID
|
1.69 |
0xEFDDA456
|
_sceKernelClearEventFlag
Version |
NID
|
1.69 |
0xF0526CE2
|
sceKernelGetThreadCpuAffinityMask
Version |
NID
|
1.69 |
0xF1AE5654
|
sceKernelWaitThreadEnd_089
Version |
NID
|
1.69-3.60 |
0xF3489EF4
|
sceKernelGetSystemTimeWide
Version |
NID
|
1.69-3.60 |
0xF4EE4FA9
|
_sceKernelPulseEvent
Version |
NID
|
1.69 |
0xF6A0FE84
|
_sceKernelCloseEventFlag
Version |
NID
|
1.69 |
0xF6CFB4F1
|
_sceKernelSendMsgPipeVectorCB
Version |
NID
|
1.69 |
0xF6D515DC
|
_sceKernelDeleteSimpleEvent
Version |
NID
|
1.69 |
0xF7413EC7
|
_sceKernelCancelEventFlag
Version |
NID
|
1.69 |
0xF76F3056
|
_sceKernelWaitSemaCB
Version |
NID
|
1.69 |
0xF8E06784
|
_sceKernelWaitThreadEndCB
Version |
NID
|
1.69 |
0xFA3D4491
|
_sceKernelOpenEventFlag
Version |
NID
|
1.69 |
0xFA64FB37
|
_sceKernelUnregisterCallbackFromEvent
Version |
NID
|
1.69 |
0xFB66565E
|
_sceKernelWaitEventFlag
Version |
NID
|
1.69 |
0xFCE2F728
|
/**
* @brief Event flag wait
*
* This system call waits for the event flag specified by evfId to be set according to the wait release condition specified by waitMode.
* If the event flag specified by evfId already satisfies the wait release condition specified by waitMode,
* the issuing thread continues execution without transitioning to the waiting state (WAITING).
*
* When SCE_KERNEL_EVF_WAITMODE_AND is specified for waitMode, it waits until all the bits specified by bitPattern become 1.
* If SCE_KERNEL_EVF_WAITMODE_OR is specified for waitMode, wait until one of the bits specified in bitPattern becomes 1.
* If SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL is additionally specified for waitMode, all the eventflag bits
* are cleared to 0 when the wait release condition is satisfied and this thread is released.
* If SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT is additionally specified for waitMode, the bit specified
* by bitPattern is cleared to 0 when the wait release condition is satisfied and this thread is released.
*
* The event flag value is returned to pResultPat in the following cases. NULL can be specified if no value is required.
* - If the wait release condition is satisfied (SCE_OK is returned),
* the event flag value before clearing by specifying SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL,
* SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT is returned immediately after the condition is satisfied.
* - After exiting the wait state, the event flag value just before exiting from the wait state is returned when
* exiting except when the wait release condition is satisfied (when SCE_KERNEL_ERROR_WAIT_CANCEL,
* SCE_KERNEL_ERROR_WAIT_DELETE, SCE_KERNEL_ERROR_WAIT_TIMEOUT errors are returned).
* When canceling with sceKernelCancelEventFlag(), the eventflag value set at the time of cancellation is returned.
*
* When pTimeout is specified, the timeout operation specified in microseconds is set.
* If pTimeout is NULL, timeout operation is not performed.
* Note that if pTimeout is specified, the value pointed to by pTimeout is updated when the system call ends.
* If the condition is met within the time, it is updated with the remaining time. If not established,
* the value pointed to by pTimeout is updated with 0. In this case, error SCE_KERNEL_ERROR_WAIT_TIMEOUT is returned.
*
* Another thread cannot execute sceKernelWaitEventFlag() and sceKernelPollEventFlag() for an event flag with
* the SCE_KERNEL_EVF_ATTR_SINGLE attribute that already has a waiting thread.
* In this case, an error is returned immediately to the thread that executed sceKernelWaitEventFlag() or sceKernelPollEventFlag() later.
*
* If multiple threads are waiting for an event flag with the SCE_KERNEL_EVF_ATTR_MULTI attribute, a thread queue is created.
* In this case, a single sceKernelSetEventFlag() may release the waiting status of multiple threads.
*
* In the case of the event flag of the SCE_KERNEL_EVF_ATTR_TH_FIFO attribute, the thread queue is
* arranged in the order in which it waits first.
* In the event flag of the SCE_KERNEL_EVF_ATTR_TH_PRIO attribute, the thread with the highest
* priority among the waiting threads starts first and is arranged in the order of thread priority.
*
* If there is a thread with SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL specified or SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT specified in the
* queue and the wait release condition for that thread is satisfied, the event flag is cleared at the same time as the wait release.
* Threads that are lined up behind the thread that has specified SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL or SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT
* will see the event flag after being cleared, so the wait may not be released.
*
* @param evfId Specifies the identifier of the event flag to wait for.
* @param bitPattern Specify the comparison value with the eventflag.
* @param waitMode Specifies the wait mode. Specify one of the following:
* - SCE_KERNEL_EVF_WAITMODE_AND: Waiting for AND
* - SCE_KERNEL_EVF_WAITMODE_OR : Wait for OR
* In addition, you can optionally add either of the following specifications as a logical sum.
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_ALL: After waiting, clear all bits
* - SCE_KERNEL_EVF_WAITMODE_CLEAR_PAT: After waiting, clear the bit specified in bitPattern
* @param pResultPat Specifies a pointer to the SceUInt32 type variable that receives the eventflag value when waiting is established.
* If NULL is specified, the event flag value is not received.
* @param pTimeout Specify a pointer to the SceUInt32 type variable that stores the upper limit (microseconds) of the waiting time.
* If NULL is specified, wait indefinitely. When the wait condition is satisfied, the remaining time is returned.
* @retval SCE_OK Success
* @retval (<0) Error code
*/
SceInt32 _sceKernelWaitEventFlag(SceUID evfId, SceUInt32 bitPattern, SceUInt32 waitMode, SceUInt32 *pResultPat, SceUInt32 *pTimeout);
sceKernelCloseRWLock
Version |
NID
|
1.69 |
0xFD5BD5C1
|
_sceKernelGetLwMutexInfoById
Version |
NID
|
1.69 |
0xFEC9E946
|
sceKernelCloseSimpleEvent
Version |
NID
|
1.69 |
0xFEF4CA53
|
_sceKernelSetTimerTime
Version |
NID
|
1.69 |
0xFF738CD9
|
_sceKernelRegisterThreadEventHandler
Version |
NID
|
0.990 |
not present
|
3.60 |
0xCE6B49D8
|
typedef struct sceKernelRegisterThreadEventHandlerOpt { // size is 0x10 on FW 3.60
SceKernelThreadEventHandler *handler;
void *common;
int reserved0;
int reserved1;
} sceKernelRegisterThreadEventHandlerOpt;
int _sceKernelRegisterThreadEventHandler(char *name, SceUID thread_id, SceUInt32 mask, sceKernelRegisterThreadEventHandlerOpt *pOpt);
SceThreadmgrCoredumpTime
sceKernelExitThread
Version |
NID
|
3.60 |
0x0C8A38E1
|
/**
* @brief End of own thread
*
* Terminates the own thread normally and shifts to the DORMANT state.
* sceKernelExitThread() is a system call that does not return to the context of the issuer.
*
* Resources (memory, semaphores, etc.) acquired by the terminating thread are not automatically released.
* However, for mutexes only, mutexes that have been locked by the terminating thread are automatically unlocked.
* The mutex is unlocked and not deleted.
*
* When the terminated thread is restarted with sceKernelStartThread(), the information included in the thread
* management area, such as thread priority, is reset.
* It will not inherit the one at the end.
*
* When a thread exits, exitStatus becomes the exit status of that thread.
*
* If the thread is terminated by a return from the entry function without using
* sceKernelExitThread(), the return value of the entry function becomes the termination status.
*
* The end status of a thread can be obtained by sceKernelGetThreadExitStatus() and sceKernelGetThreadInfo(),
* and when another thread waits for the end of the thread by sceKernelWaitThreadEnd(), it can be obtained by the return value.
*
* The thread exit status is saved while the thread exits and is in the DORMANT state,
* but the value is lost if the thread is restarted or deleted with sceKernelStartThread().
*
* @param exitStatus Specify the value to be set for the termination status of the local thread.
* @retval Negative value Error code
*/
SceInt32 sceKernelExitThread(
SceInt32 exitStatus
);