From 92f1eacaee2948052d3f16ebf5c855f7c39573a1 Mon Sep 17 00:00:00 2001 From: Davee Date: Thu, 3 Nov 2016 05:38:47 +0100 Subject: kernel development headers (#67) * Added some kernel headers * Modified kernel headers * Added suprx loading args to headers * Added kernel modulemgr load/stop nids * Added struct for versioninfo * Added sceKernelMemcpyKernelToUser * Added SceSblACMgr * Added syscall entry/exit stubs * Added strncpy u2k/k2u functions * Wrong offset for version * More kernel adds * Added sceKernelQueueLoadModuleForPid * Added sceKernelGetSystemSwVersion to user headers * Added sceKernelStrncpyUserForPid * Added a couple more kernel apis --- include/kernel/kernel/cpu.h | 141 +++++ include/kernel/kernel/modulemgr.h | 96 ++++ include/kernel/kernel/processmgr.h | 16 + include/kernel/kernel/sysmem.h | 133 +++++ include/kernel/kernel/threadmgr.h | 1068 ++++++++++++++++++++++++++++++++++++ include/kernel/sblacmgr.h | 19 + include/user/kernel/modulemgr.h | 27 + nids/360/SceIofilemgr.yml | 42 ++ nids/360/SceKernel.yml | 437 --------------- nids/360/SceKernelModulemgr.yml | 29 + nids/360/SceKernelThreadMgr.yml | 112 ++++ nids/360/SceLibKernel.yml | 278 ++++++++++ nids/360/SceProcessmgr.yml | 27 + nids/360/SceSblACMgr.yml | 11 + nids/360/SceSblSsMgr.yml | 8 + nids/360/SceStdio.yml | 8 + nids/360/SceSysmem.yml | 105 ++++ 17 files changed, 2120 insertions(+), 437 deletions(-) create mode 100644 include/kernel/kernel/cpu.h create mode 100644 include/kernel/kernel/modulemgr.h create mode 100644 include/kernel/kernel/processmgr.h create mode 100644 include/kernel/kernel/sysmem.h create mode 100644 include/kernel/kernel/threadmgr.h create mode 100644 include/kernel/sblacmgr.h create mode 100644 nids/360/SceIofilemgr.yml delete mode 100644 nids/360/SceKernel.yml create mode 100644 nids/360/SceKernelModulemgr.yml create mode 100644 nids/360/SceKernelThreadMgr.yml create mode 100644 nids/360/SceLibKernel.yml create mode 100644 nids/360/SceProcessmgr.yml create mode 100644 nids/360/SceSblACMgr.yml create mode 100644 nids/360/SceSblSsMgr.yml create mode 100644 nids/360/SceStdio.yml create mode 100644 nids/360/SceSysmem.yml diff --git a/include/kernel/kernel/cpu.h b/include/kernel/kernel/cpu.h new file mode 100644 index 0000000..5c84c46 --- /dev/null +++ b/include/kernel/kernel/cpu.h @@ -0,0 +1,141 @@ +#ifndef _PSP2_KERNEL_CPU_H_ +#define _PSP2_KERNEL_CPU_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Call this when entering a syscall + * + * @param state The state + */ +#define ENTER_SYSCALL(state) do { \ + asm volatile ("mrc p15, 0, %0, c13, c0, 3" : "=r" (state)); \ + asm volatile ("mcr p15, 0, %0, c13, c0, 3" :: "r" (state << 16) : "memory"); \ +} while(0) + +/** + * @brief Call this when existing a syscall + * + * @param state The state + */ +#define EXIT_SYSCALL(state) do { \ + asm volatile ("mcr p15, 0, %0, c13, c0, 3" :: "r" (state) : "memory"); \ +} while (0) + +/** + * @brief Save process context + * + * @param context The context + */ +static inline void sceKernelCpuSaveContext(int context[3]) { + asm ("mrc p15, 0, %0, c2, c0, 1" : "=r" (context[0])); + asm ("mrc p15, 0, %0, c3, c0, 0" : "=r" (context[1])); + asm ("mrc p15, 0, %0, c13, c0, 1" : "=r" (context[2])); +} + +/** + * @brief Restore process context + * + * @param context The context, can be from `sceKernelGetPidContext` + */ +static inline void sceKernelCpuRestoreContext(int context[3]) { + int cpsr; + int tmp; + + asm volatile ("mrs %0, cpsr" : "=r" (cpsr)); + if (!(cpsr & 0x80)) { + asm volatile ("cpsid i" ::: "memory"); + } + asm volatile ("mrc p15, 0, %0, c13, c0, 1" : "=r" (tmp)); + tmp = (tmp & 0xFFFFFF00) | context[2]; + asm volatile ("mcr p15, 0, %0, c13, c0, 1" :: "r" (0)); + asm volatile ("isb" ::: "memory"); + asm volatile ("mcr p15, 0, %0, c2, c0, 1" :: "r" (context[0] | 0x4A)); + asm volatile ("isb" ::: "memory"); + asm volatile ("mcr p15, 0, %0, c13, c0, 1" :: "r" (tmp)); + asm volatile ("mcr p15, 0, %0, c3, c0, 0" :: "r" (context[1] & 0x55555555)); + if (!(cpsr & 0x80)) { + asm volatile ("cpsie i" ::: "memory"); + } +} + +/** + * @brief Disabled interrupts + * + * @return Interrupt masks before disabling + */ +int sceKernelCpuDisableInterrupts(void); + +/** + * @brief Enable interrupts + * + * @param[in] flags Interrupt masks + * + * @return Zero on success + */ +int sceKernelCpuEnableInterrupts(int flags); + +/** + * @brief Flush L1 dcache and L2 + * + * Note: symbols currently does not work on 3.x, need to find new ones. + * + * @param ptr The pointer + * @param[in] len The length + * + * @return Zero on success + */ +int sceKernelCpuDcacheAndL2Flush(void *ptr, size_t len); + +/** + * @brief Flush L2 dcache without L2 + * + * @param ptr The pointer + * @param[in] len The length + * + * @return Zero on success + */ +int sceKernelCpuDcacheFlush(void *ptr, size_t len); + +/** + * @brief Flush L1 icache and L2 + * + * @param ptr The pointer + * @param[in] len The length + * + * @return Zero on success + */ +int sceKernelCpuIcacheAndL2Flush(void *ptr, size_t len); + +/** + * @brief Flush L1 dcache and L2 for DMA operations + * + * @param ptr The pointer + * @param[in] len The length + * + * @return Zero on success + */ +int sceKernelCpuDcacheAndL2AndDMAFlush(void *ptr, size_t len); + +/** + * @brief MMU permission bypassing memcpy + * + * This works by writing to the DACR before and after the memcpy. + * + * @param dst The destination + * @param[in] src The source + * @param[in] len The length + * + * @return Zero on success. + */ +int sceKernelCpuUnrestrictedMemcpy(void *dst, const void *src, size_t len); + +#ifdef __cplusplus +} +#endif + +#endif /* _PSP2_KERNEL_CPU_H_ */ diff --git a/include/kernel/kernel/modulemgr.h b/include/kernel/kernel/modulemgr.h new file mode 100644 index 0000000..67f5ab5 --- /dev/null +++ b/include/kernel/kernel/modulemgr.h @@ -0,0 +1,96 @@ +#ifndef _PSP2_KERNEL_MODULEMGR_H_ +#define _PSP2_KERNEL_MODULEMGR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Return values for plugins `module_start` and `module_stop` + */ +/** @{ */ +#define SCE_KERNEL_START_SUCCESS (0) +#define SCE_KERNEL_START_RESIDENT SCE_KERNEL_START_SUCCESS +#define SCE_KERNEL_START_NO_RESIDENT (1) +#define SCE_KERNEL_START_FAILED (2) + +#define SCE_KERNEL_STOP_SUCCESS (0) +#define SCE_KERNEL_STOP_FAIL (1) +#define SCE_KERNEL_STOP_CANCEL SCE_KERNEL_STOP_FAIL +/** @} */ + +typedef struct +{ + SceUInt size; //< this structure size (0x18) + SceUInt perms; //< probably rwx in low bits + void *vaddr; //< address in memory + SceUInt memsz; //< size in memory + SceUInt flags; //< meanig unknown + SceUInt res; //< unused? +} SceKernelSegmentInfo; + +typedef struct +{ + SceUInt size; //< 0x1B8 for Vita 1.x + SceUInt handle; //< kernel module handle? + SceUInt flags; //< some bits. could be priority or whatnot + char module_name[28]; + SceUInt unk28; + void *module_start; + SceUInt unk30; + void *module_stop; + void *exidxTop; + void *exidxBtm; + SceUInt unk40; + SceUInt unk44; + void *tlsInit; + SceSize tlsInitSize; + SceSize tlsAreaSize; + char path[256]; + SceKernelSegmentInfo segments[4]; + SceUInt type; //< 6 = user-mode PRX? +} SceKernelModuleInfo; + +typedef struct { + SceSize size; +} SceKernelLMOption; + +typedef struct { + SceSize size; +} SceKernelULMOption; + +typedef struct +{ + SceSize size; + char versionString[16]; + SceUInt unk_14; + SceUInt unk_18; + SceUInt unk_1C; + SceUInt version; + SceUInt unk_24; +} SceKernelFwInfo; + +int sceKernelGetModuleList(SceUID pid, int flags1, int flags2, SceUID *modids, size_t *num); +int sceKernelGetModuleInfo(SceUID pid, SceUID modid, SceKernelModuleInfo *info); +int sceKernelGetModuleInternal(SceUID modid, void **module); + +int sceKernelGetSystemSwVersion(SceKernelFwInfo *data); + +SceUID sceKernelLoadModule(const char *path, int flags, SceKernelLMOption *option); +int sceKernelStartModule(SceUID modid, SceSize args, void *argp, int flags, SceKernelLMOption *option, int *status); + +SceUID sceKernelLoadStartSharedModuleForPid(SceUID pid, const char *path, SceSize args, void *argp, int flags, SceKernelLMOption *option, int *status); +SceUID sceKernelLoadStartModuleForPid(SceUID pid, const char *path, SceSize args, void *argp, int flags, SceKernelLMOption *option, int *status); +SceUID sceKernelLoadModuleForPid(SceUID pid, const char *path, int flags, SceKernelLMOption *option); + +int sceKernelUnloadModule(SceUID modid, int flags); + +int sceKernelStopUnloadModule(SceUID modid, SceSize args, void *argp, int flags, SceKernelULMOption *option, int *status); + +#ifdef __cplusplus +} +#endif + +#endif /* _PSP2_KERNEL_MODULEMGR_H_ */ diff --git a/include/kernel/kernel/processmgr.h b/include/kernel/kernel/processmgr.h new file mode 100644 index 0000000..963d42c --- /dev/null +++ b/include/kernel/kernel/processmgr.h @@ -0,0 +1,16 @@ +#ifndef _PSP2_KERNEL_PROCESSMGR_H_ +#define _PSP2_KERNEL_PROCESSMGR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void *sceKernelGetProcessKernelBuf(SceUID pid); + +#ifdef __cplusplus +} +#endif + +#endif /* _PSP2_KERNEL_PROCESSMGR_H_ */ diff --git a/include/kernel/kernel/sysmem.h b/include/kernel/kernel/sysmem.h new file mode 100644 index 0000000..09acf27 --- /dev/null +++ b/include/kernel/kernel/sysmem.h @@ -0,0 +1,133 @@ +#ifndef _PSP2_KERNEL_SYSMEM_H_ +#define _PSP2_KERNEL_SYSMEM_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef int SceKernelMemBlockType; + +enum { + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW = 0x0c20d060, + SCE_KERNEL_MEMBLOCK_TYPE_USER_RW_UNCACHE = 0x0c208060, + SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_RW = 0x0c80d060, + SCE_KERNEL_MEMBLOCK_TYPE_USER_MAIN_PHYCONT_NC_RW = 0x0d808060, + SCE_KERNEL_MEMBLOCK_TYPE_USER_CDRAM_RW = 0x09408060, + SCE_KERNEL_MEMBLOCK_TYPE_KERNEL_RX = 0x1020D005, + SCE_KERNEL_MEMBLOCK_TYPE_SHARED_RX = 0x390D050, + SCE_KERNEL_MEMBLOCK_TYPE_USER_RX = 0xC20D050, + SCE_KERNEL_MEMBLOCK_TYPE_RW_UNK0 = 0x6020D006 +}; + +// specific to 3.60 +typedef struct SceKernelAllocMemBlockKernelOpt { + SceSize size; + SceUInt32 field_4; + SceUInt32 attr; + SceUInt32 field_C; + SceUInt32 paddr; + SceSize alignment; + SceUInt32 field_18; + SceUInt32 field_1C; + SceUInt32 mirror_blkid; + SceUID pid; + SceUInt32 field_28; + SceUInt32 field_2C; + SceUInt32 field_30; + SceUInt32 field_34; + SceUInt32 field_38; + SceUInt32 field_3C; + SceUInt32 field_40; + SceUInt32 field_44; + SceUInt32 field_48; + SceUInt32 field_4C; + SceUInt32 field_50; + SceUInt32 field_54; +} SceKernelAllocMemBlockKernelOpt; + +enum { + SCE_KERNEL_MODEL_VITA = 0x10000, + SCE_KERNEL_MODEL_VITATV = 0x20000 +}; + +#define SCE_KERNEL_ALLOC_MEMBLOCK_ATTR_HAS_ALIGNMENT 0x00000004U + +/*** + * Allocates a new memoy block + * + * @param[in] name - Name for the memory block + * @param[in] type - Type of the memory to allocate + * @param[in] size - Size of the memory to allocate + * @param[in] optp - Memory block options? + * + * @return SceUID of the memory block on success, < 0 on error. +*/ +SceUID sceKernelAllocMemBlock(const char *name, SceKernelMemBlockType type, int size, SceKernelAllocMemBlockKernelOpt *optp); + +/*** + * Frees new memoy block + * + * @param[in] uid - SceUID of the memory block to free + * + * @return 0 on success, < 0 on error. +*/ +int sceKernelFreeMemBlock(SceUID uid); + +/*** + * Gets the base address of a memoy block + * + * @param[in] uid - SceUID of the memory block to free + * @param[out] basep - Base address of the memory block identified by SceUID + * + * @return 0 on success, < 0 on error. +*/ +int sceKernelGetMemBlockBase(SceUID uid, void **basep); + +SceUID sceKernelMemPoolCreate(const char *name, SceSize size, void *opt); +int sceKernelMemPoolDestroy(SceUID pool); +void *sceKernelMemPoolAlloc(SceUID pool, SceSize size); +void sceKernelMemPoolFree(SceUID pool, void *ptr); + +int sceKernelMemcpyUserToKernelForPid(SceUID pid, void *dst, uintptr_t src, size_t len); +int sceKernelMemcpyUserToKernel(void *dst, uintptr_t src, size_t len); +int sceKernelMemcpyKernelToUser(uintptr_t dst, const void *src, size_t len); +int sceKernelRxMemcpyKernelToUserForPid(SceUID pid, uintptr_t dst, const void *src, size_t len); + +int sceKernelStrncpyUserToKernel(void *dst, uintptr_t src, size_t len); +int sceKernelStrncpyKernelToUser(uintptr_t dst, const void *src, size_t len); +int sceKernelStrncpyUserForPid(SceUID pid, void *dst, uintptr_t src, size_t len); + +typedef struct { + char data[0x2C]; +} SceClass; + +typedef struct { + uint32_t sce_reserved[2]; +} SceObjectBase; + +SceUID sceKernelKernelUidForUserUid(SceUID pid, SceUID user_uid); +SceUID sceKernelCreateUserUid(SceUID pid, SceUID kern_uid); +SceUID sceKernelCreateUidObj(SceClass *cls, const char *name, void *opt, SceObjectBase **obj); +int sceKernelGetObjForUid(SceUID uid, SceClass *cls, SceObjectBase **obj); +SceClass *sceKernelGetUidClass(void); +typedef int (*SceClassCallback)(void *item); +int sceKernelCreateClass(SceClass *cls, const char *name, void *uidclass, size_t itemsize, SceClassCallback create, SceClassCallback destroy); +int sceKernelDeleteUserUid(SceUID pid, SceUID user_uid); +int sceKernelDeleteUid(SceUID uid); + +int sceKernelSwitchVmaForPid(SceUID pid); + +void *sceKernelGetSysrootBuffer(void); +int sceKernelGetPidContext(SceUID pid, int **ctx); + +int sceKernelGetProcessTitleId(SceUID pid, char *titleid, size_t len); + +int sceKernelMapBlockUserVisible(SceUID uid); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/kernel/kernel/threadmgr.h b/include/kernel/kernel/threadmgr.h new file mode 100644 index 0000000..9fe1faf --- /dev/null +++ b/include/kernel/kernel/threadmgr.h @@ -0,0 +1,1068 @@ +#ifndef _PSP2_KERNEL_THREADMGR_H_ +#define _PSP2_KERNEL_THREADMGR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define SCE_KERNEL_MUTEX_ATTR_RECURSIVE 2 + +/** 64-bit system clock type. */ +typedef SceUInt64 SceKernelSysClock; + +/* Threads. */ + +typedef int (*SceKernelThreadEntry)(SceSize args, void *argp); + +/** Additional options used when creating threads. */ +typedef struct SceKernelThreadOptParam { + /** Size of the ::SceKernelThreadOptParam structure. */ + SceSize size; + /** Attributes */ + SceUInt32 attr; +} SceKernelThreadOptParam; + +/** Structure to hold the status information for a thread + * @see sceKernelGetThreadInfo + */ +typedef struct SceKernelThreadInfo { + /** Size of the structure */ + SceSize size; + /** The UID of the process where the thread belongs */ + SceUID processId; //Needs confirmation + /** Nul terminated name of the thread */ + char name[32]; + /** Thread attributes */ + SceUInt attr; + /** Thread status */ + int status; + /** Thread entry point */ + SceKernelThreadEntry entry; + /** Thread stack pointer */ + void *stack; + /** Thread stack size */ + int stackSize; + /** Initial priority */ + int initPriority; + /** Current priority */ + int currentPriority; + /** Initial CPU affinity mask */ + int initCpuAffinityMask; + /** Current CPU affinity mask */ + int currentCpuAffinityMask; + /** Current CPU ID */ + int currentCpuId; + /** Last executed CPU ID */ + int lastExecutedCpuId; + /** Wait type */ + int waitType; + /** Wait id */ + SceUID waitId; + /** Exit status of the thread */ + int exitStatus; + /** Number of clock cycles run */ + SceKernelSysClock runClocks; + /** Interrupt preemption count */ + SceUInt intrPreemptCount; + /** Thread preemption count */ + SceUInt threadPreemptCount; + /** Thread release count */ + SceUInt threadReleaseCount; + /** Function notify callback UID */ + SceUID fNotifyCallback; + /** Reserved */ + int reserved; +} SceKernelThreadInfo; + +/** Statistics about a running thread. + * @see sceKernelGetThreadRunStatus. + */ +typedef struct SceKernelThreadRunStatus { + SceSize size; + struct { + SceUID processId; + SceUID threadId; + int priority; + } cpuInfo[4]; +} SceKernelThreadRunStatus; + +/* Sure there must be more than this, but haven't seen them */ +typedef enum SceThreadStatus +{ + SCE_THREAD_RUNNING = 1, + SCE_THREAD_READY = 2, + SCE_THREAD_WAITING = 4, + SCE_THREAD_SUSPEND = 8, + SCE_THREAD_STOPPED = 16, + SCE_THREAD_KILLED = 32, /* Thread manager has killed the thread (stack overflow) */ +} SceThreadStatus; + +/** + * Create a thread + * + * @par Example: + * @code + * SceUID thid; + * thid = sceKernelCreateThread("my_thread", threadFunc, 0x10000100, 0x10000, 0, 0, NULL); + * @endcode + * + * @param name - An arbitrary thread name. + * @param entry - The thread function to run when started. + * @param initPriority - The initial priority of the thread. Less if higher priority. + * @param stackSize - The size of the initial stack. + * @param attr - The thread attributes, zero or more of ::SceThreadAttributes. + * @param cpuAffinityMask - The CPU affinity mask + * @param option - Additional options specified by ::SceKernelThreadOptParam. + + * @return UID of the created thread, or an error code. + */ +SceUID sceKernelCreateThread(const char *name, SceKernelThreadEntry entry, int initPriority, + int stackSize, SceUInt attr, int cpuAffinityMask, + const SceKernelThreadOptParam *option); + +/** + * Delate a thread + * + * @param thid - UID of the thread to be deleted. + * + * @return < 0 on error. + */ +int sceKernelDeleteThread(SceUID thid); + +/** + * Start a created thread + * + * @param thid - Thread id from sceKernelCreateThread + * @param arglen - Length of the data pointed to by argp, in bytes + * @param argp - Pointer to the arguments. + */ +int sceKernelStartThread(SceUID thid, SceSize arglen, void *argp); + +/** + * Exit a thread + * + * @param status - Exit status. + */ +int sceKernelExitThread(int status); + +/** + * Exit a thread and delete itself. + * + * @param status - Exit status + */ +int sceKernelExitDeleteThread(int status); + +/** + * Wait until a thread has ended. + * + * @param thid - Id of the thread to wait for. + * @param stat - Exit status. + * @param timeout - Timeout in microseconds (assumed). + * + * @return < 0 on error. + */ +int sceKernelWaitThreadEnd(SceUID thid, int *stat, SceUInt *timeout); + +/** + * Wait until a thread has ended and handle callbacks if necessary. + * + * @param thid - Id of the thread to wait for. + * @param stat - Exit status. + * @param timeout - Timeout in microseconds (assumed). + * + * @return < 0 on error. + */ +int sceKernelWaitThreadEndCB(SceUID thid, int *stat, SceUInt *timeout); + +/** + * Delay the current thread by a specified number of microseconds + * + * @param delay - Delay in microseconds. + * + * @par Example: + * @code + * sceKernelDelayThread(1000000); // Delay for a second + * @endcode + */ +int sceKernelDelayThread(SceUInt delay); + +/** + * Delay the current thread by a specified number of microseconds and handle any callbacks. + * + * @param delay - Delay in microseconds. + * + * @par Example: + * @code + * sceKernelDelayThread(1000000); // Delay for a second + * @endcode + */ +int sceKernelDelayThreadCB(SceUInt delay); + +/** + * Modify the attributes of the current thread. + * + * @param unknown - Set to 0. + * @param attr - The thread attributes to modify. One of ::SceThreadAttributes. + * + * @return < 0 on error. + */ +int sceKernelChangeCurrentThreadAttr(int unknown, SceUInt attr); + +/** + * Change the threads current priority. + * + * @param thid - The ID of the thread (from sceKernelCreateThread or sceKernelGetThreadId) + * @param priority - The new priority (the lower the number the higher the priority) + * + * @par Example: + * @code + * int thid = sceKernelGetThreadId(); + * // Change priority of current thread to 16 + * sceKernelChangeThreadPriority(thid, 16); + * @endcode + * + * @return 0 if successful, otherwise the error code. + */ +int sceKernelChangeThreadPriority(SceUID thid, int priority); + +/** + * Release a thread in the wait state. + * + * @param thid - The UID of the thread. + * + * @return 0 on success, < 0 on error + */ +int sceKernelReleaseWaitThread(SceUID thid); + +/** + * Get the current thread Id + * + * @return The thread id of the calling thread. + */ +int sceKernelGetThreadId(void); + +/** + * Get the current priority of the thread you are in. + * + * @return The current thread priority + */ +int sceKernelGetThreadCurrentPriority(void); + +/** + * Get the exit status of a thread. + * + * @param thid - The UID of the thread to check. + * + * @return The exit status + */ +int sceKernelGetThreadExitStatus(SceUID thid); + +/** + * Check the thread stack? + * + * @return Unknown. + */ +int sceKernelCheckThreadStack(void); + +/** + * Get the free stack size for a thread. + * + * @param thid - The thread ID. Seem to take current thread + * if set to 0. + * + * @return The free size. + */ +int sceKernelGetThreadStackFreeSize(SceUID thid); + +/** + * Get the status information for the specified thread. + * + * @param thid - Id of the thread to get status + * @param info - Pointer to the info structure to receive the data. + * Note: The structures size field should be set to + * sizeof(SceKernelThreadInfo) before calling this function. + * + * @par Example: + * @code + * SceKernelThreadInfo status; + * status.size = sizeof(SceKernelThreadInfo); + * if(sceKernelGetThreadInfo(thid, &status) == 0) + * { Do something... } + * @endcode + * @return 0 if successful, otherwise the error code. + */ +int sceKernelGetThreadInfo(SceUID thid, SceKernelThreadInfo *info); + +/** + * Retrive the runtime status of a thread. + * + * @param thid - UID of the thread to retrive status. + * @param status - Pointer to a ::SceKernelThreadRunStatus struct to receive the runtime status. + * + * @return 0 if successful, otherwise the error code. + */ +int sceKernelGetThreadRunStatus(SceUID thid, SceKernelThreadRunStatus *status); + + +/* Semaphores. */ + +/** Additional options used when creating semaphores. */ +typedef struct SceKernelSemaOptParam { + /** Size of the ::SceKernelSemaOptParam structure. */ + SceSize size; +} SceKernelSemaOptParam; + +/** Current state of a semaphore. + * @see sceKernelGetSemaInfo. + */ +typedef struct SceKernelSemaInfo { + /** Size of the ::SceKernelSemaInfo structure. */ + SceSize size; + /** The UID of the semaphore */ + SceUID semaId; + /** NUL-terminated name of the semaphore. */ + char name[32]; + /** Attributes. */ + SceUInt attr; + /** The initial count the semaphore was created with. */ + int initCount; + /** The current count. */ + int currentCount; + /** The maximum count. */ + int maxCount; + /** The number of threads waiting on the semaphore. */ + int numWaitThreads; +} SceKernelSemaInfo; + +/** + * Creates a new semaphore + * + * @par Example: + * @code + * int semaid; + * semaid = sceKernelCreateSema("MyMutex", 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 sceKernelCreateSema(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option); + +/** + * Destroy a semaphore + * + * @param semaid - The semaid returned from a previous create call. + * @return Returns the value 0 if its succesful otherwise -1 + */ +int sceKernelDeleteSema(SceUID semaid); + +/** + * Send a signal to a semaphore + * + * @par Example: + * @code + * // Signal the sema + * sceKernelSignalSema(semaid, 1); + * @endcode + * + * @param semaid - The sema id returned from sceKernelCreateSema + * @param signal - The amount to signal the sema (i.e. if 2 then increment the sema by 2) + * + * @return < 0 On error. + */ +int sceKernelSignalSema(SceUID semaid, int signal); + +/** + * Lock a semaphore + * + * @par Example: + * @code + * sceKernelWaitSema(semaid, 1, 0); + * @endcode + * + * @param semaid - The sema id returned from sceKernelCreateSema + * @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 sceKernelWaitSema(SceUID semaid, int signal, SceUInt *timeout); + +/** + * Lock a semaphore and handle callbacks if necessary. + * + * @par Example: + * @code + * sceKernelWaitSemaCB(semaid, 1, 0); + * @endcode + * + * @param semaid - The sema id returned from sceKernelCreateSema + * @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 sceKernelWaitSemaCB(SceUID semaid, int signal, SceUInt *timeout); + +/** + * Poll a sempahore. + * + * @param semaid - UID of the semaphore to poll. + * @param signal - The value to test for. + * + * @return < 0 on error. + */ +int sceKernelPollSema(SceUID semaid, int signal); + +/** + * Cancels a semaphore + * + * @param semaid - The sema id returned from sceKernelCreateSema + * @param setCount - The new lock count of the semaphore + * @param numWaitThreads - Number of threads waiting for the semaphore + * @return < 0 On error. + */ +int sceKernelCancelSema(SceUID semaid, int setCount, int *numWaitThreads); + +/** + * Retrieve information about a semaphore. + * + * @param semaid - UID of the semaphore to retrieve info for. + * @param info - Pointer to a ::SceKernelSemaInfo struct to receive the info. + * + * @return < 0 on error. + */ +int sceKernelGetSemaInfo(SceUID semaid, SceKernelSemaInfo *info); + + +/* Mutexes. */ + +/** Additional options used when creating mutexes. */ +typedef struct SceKernelMutexOptParam { + /** Size of the ::SceKernelMutexOptParam structure. */ + SceSize size; + int ceilingPriority; +} SceKernelMutexOptParam; + +/** Current state of a mutex. + * @see sceKernelGetMutexInfo. + */ +typedef struct SceKernelMutexInfo { + /** Size of the ::SceKernelMutexInfo structure. */ + SceSize size; + /** The UID of the mutex. */ + SceUID mutexId; + /** NUL-terminated name of the mutex. */ + char name[32]; + /** Attributes. */ + SceUInt attr; + /** The initial count the mutex was created with. */ + int initCount; + /** The current count. */ + int currentCount; + /** The UID of the current owner of the mutex. */ + SceUID currentOwnerId; + /** The number of threads waiting on the mutex. */ + int numWaitThreads; +} SceKernelMutexInfo; + +/** + * Creates a new mutex + * + * @par Example: + * @code + * int mutexid; + * mutexid = sceKernelCreateMutex("MyMutex", 0, 1, 1, 0); + * @endcode + * + * @param name - Specifies the name of the mutex + * @param attr - Mutex attribute flags (normally set to 0) + * @param initCount - Mutex initial value + * @param option - Mutex options (normally set to 0) + * @return A mutex id + */ +SceUID sceKernelCreateMutex(const char *name, SceUInt attr, int initCount, SceKernelMutexOptParam *option); + +/** + * Destroy a mutex + * + * @param mutexid - The mutex id returned from sceKernelCreateMutex + * @return Returns the value 0 if its succesful otherwise -1 + */ +int sceKernelDeleteMutex(SceUID mutexid); + +/** + * Open a mutex + * + * @param name - The name of the mutex to open + * @return Returns the value 0 if its succesful otherwise -1 + */ +int sceKernelOpenMutex(const char *name); + +/** + * Close a mutex + * + * @param mutexid - The mutex id returned from sceKernelCreateMutex + * @return Returns the value 0 if its succesful otherwise -1 + */ +int sceKernelCloseMutex(SceUID mutexid); + +/** + * Lock a mutex + * + * @param mutexid - The mutex id returned from sceKernelCreateMutex + * @param lockCount - The value to increment to the lock count of the mutex + * @param timeout - Timeout in microseconds (assumed) + * @return < 0 On error. + */ +int sceKernelLockMutex(SceUID mutexid, int lockCount, unsigned int *timeout); + +/** + * Lock a mutex and handle callbacks if necessary. + * + * @param mutexid - The mutex id returned from sceKernelCreateMutex + * @param lockCount - The value to increment to the lock count of the mutex + * @param timeout - Timeout in microseconds (assumed) + * @return < 0 On error. + */ +int sceKernelLockMutexCB(SceUID mutexid, int lockCount, unsigned int *timeout); + +/** + * Try to lock a mutex (non-blocking) + * + * @param mutexid - The mutex id returned from sceKernelCreateMutex + * @param lockCount - The value to increment to the lock count of the mutex + * @return < 0 On error. + */ +int sceKernelTryLockMutex(SceUID mutexid, int lockCount); + +/** + * Try to unlock a mutex (non-blocking) + * + * @param mutexid - The mutex id returned from sceKernelCreateMutex + * @param unlockCount - The value to decrement to the lock count of the mutex + * @return < 0 On error. + */ +int sceKernelUnlockMutex(SceUID mutexid, int unlockCount); + +/** + * Cancels a mutex + * + * @param mutexid - The mutex id returned from sceKernelCreateMutex + * @param newCount - The new lock count of the mutex + * @param numWaitThreads - Number of threads waiting for the mutex + * @return < 0 On error. + */ +int sceKernelCancelMutex(SceUID mutexid, int newCount, int *numWaitThreads); + +/** + * Retrieve information about a mutex. + * + * @param mutexid - UID of the mutex to retrieve info for. + * @param info - Pointer to a ::SceKernelMutexInfo struct to receive the info. + * + * @return < 0 on error. + */ +int sceKernelGetMutexInfo(SceUID mutexid, SceKernelMutexInfo info); + + +/* Event flags. */ + +/** Structure to hold the event flag information */ +typedef struct SceKernelEventFlagInfo { + SceSize size; + SceUID evfId; // Needs confirmation + char name[32]; + SceUInt attr; + SceUInt initPattern; + SceUInt currentPattern; + int numWaitThreads; +} SceKernelEventFlagInfo; + +typedef struct SceKernelEventFlagOptParam { + SceSize size; +} SceKernelEventFlagOptParam; + +typedef struct SceKernelEventFlagOptParam SceKernelEventFlagOptParam; + +/** Event flag creation attributes */ +typedef enum SceEventFlagAttributes { + /** Allow the event flag to be waited upon by multiple threads */ + SCE_EVENT_WAITMULTIPLE = 0x200 +} SceEventFlagAttributes; + +/** Event flag wait types */ +typedef enum SceEventFlagWaitTypes { + /** Wait for all bits in the pattern to be set */ + SCE_EVENT_WAITAND = 0, + /** Wait for one or more bits in the pattern to be set */ + SCE_EVENT_WAITOR = 1, + /** Clear all the bits when it matches */ + SCE_EVENT_WAITCLEAR = 2, + /** Clear the wait pattern when it matches */ + SCE_EVENT_WAITCLEAR_PAT = 4 +} SceEventFlagWaitTypes; + +/** + * Create an event flag. + * + * @param name - The name of the event flag. + * @param attr - Attributes from ::SceEventFlagAttributes + * @param bits - Initial bit pattern. + * @param opt - Options, set to NULL + * @return < 0 on error. >= 0 event flag id. + * + * @par Example: + * @code + * int evid; + * evid = sceKernelCreateEventFlag("wait_event", 0, 0, 0); + * @endcode + */ +SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt); + +/** + * Set an event flag bit pattern. + * + * @param evid - The event id returned by sceKernelCreateEventFlag. + * @param bits - The bit pattern to set. + * + * @return < 0 On error + */ +int sceKernelSetEventFlag(SceUID evid, unsigned int bits); + +/** + * Clear a event flag bit pattern + * + * @param evid - The event id returned by ::sceKernelCreateEventFlag + * @param bits - The bits to clean + * + * @return < 0 on Error + */ +int sceKernelClearEventFlag(SceUID evid, unsigned int bits); + +/** + * Poll an event flag for a given bit pattern. + * + * @param evid - The event id returned by sceKernelCreateEventFlag. + * @param bits - The bit pattern to poll for. + * @param wait - Wait type, one or more of ::SceEventFlagWaitTypes or'ed together + * @param outBits - The bit pattern that was matched. + * @return < 0 On error + */ +int sceKernelPollEventFlag(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits); + +/** + * Wait for an event flag for a given bit pattern. + * + * @param evid - The event id returned by sceKernelCreateEventFlag. + * @param bits - The bit pattern to poll for. + * @param wait - Wait type, one or more of ::SceEventFlagWaitTypes or'ed together + * @param outBits - The bit pattern that was matched. + * @param timeout - Timeout in microseconds + * @return < 0 On error + */ +int sceKernelWaitEventFlag(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits, SceUInt *timeout); + +/** + * Wait for an event flag for a given bit pattern with callback. + * + * @param evid - The event id returned by sceKernelCreateEventFlag. + * @param bits - The bit pattern to poll for. + * @param wait - Wait type, one or more of ::SceEventFlagWaitTypes or'ed together + * @param outBits - The bit pattern that was matched. + * @param timeout - Timeout in microseconds + * @return < 0 On error + */ +int sceKernelWaitEventFlagCB(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits, SceUInt *timeout); + +/** + * Delete an event flag + * + * @param evid - The event id returned by sceKernelCreateEventFlag. + * + * @return < 0 On error + */ +int sceKernelDeleteEventFlag(int evid); + +/** + * Get the status of an event flag. + * + * @param event - The UID of the event. + * @param status - A pointer to a ::SceKernelEventFlagInfo structure. + * + * @return < 0 on error. + */ +int sceKernelGetEventFlagInfo(SceUID event, SceKernelEventFlagInfo *info); + + +/* Callbacks. */ + +/** Callback function prototype */ +typedef int (*SceKernelCallbackFunction)(int notifyId, int notifyCount, int notifyArg, void *common); + +/** Structure to hold the status information for a callback */ +typedef struct SceKernelCallbackInfo { + /** Size of the structure (i.e. sizeof(SceKernelCallbackInfo)) */ + SceSize size; + /** The UID of the callback. */ + SceUID callbackId; // Needs confirmation + /** The name given to the callback */ + char name[32]; + /** The thread id associated with the callback */ + SceUID threadId; + /** Pointer to the callback function */ + SceKernelCallbackFunction callback; + /** User supplied argument for the callback */ + void *common; + /** Unknown */ + int notifyCount; + /** Unknown */ + int notifyArg; +} SceKernelCallbackInfo; + +/** + * Create callback + * + * @par Example: + * @code + * int cbid; + * cbid = sceKernelCreateCallback("Exit Callback", exit_cb, NULL); + * @endcode + * + * @param name - A textual name for the callback + * @param func - A pointer to a function that will be called as the callback + * @param arg - Argument for the callback ? + * + * @return >= 0 A callback id which can be used in subsequent functions, < 0 an error. + */ +int sceKernelCreateCallback(const char *name, unsigned int attr, SceKernelCallbackFunction func, void *arg); + +/** + * Gets the status of a specified callback. + * + * @param cb - The UID of the callback to retrieve info for. + * @param status - Pointer to a status structure. The size parameter should be + * initialised before calling. + * + * @return < 0 on error. + */ +int sceKernelGetCallbackInfo(SceUID cb, SceKernelCallbackInfo *infop); + +/** + * Delete a callback + * + * @param cb - The UID of the specified callback + * + * @return 0 on success, < 0 on error + */ +int sceKernelDeleteCallback(SceUID cb); + +/** + * Notify a callback + * + * @param cb - The UID of the specified callback + * @param arg2 - Passed as arg2 into the callback function + * + * @return 0 on success, < 0 on error + */ +int sceKernelNotifyCallback(SceUID cb, int arg2); + +/** + * Cancel a callback ? + * + * @param cb - The UID of the specified callback + * + * @return 0 on succes, < 0 on error + */ +int sceKernelCancelCallback(SceUID cb); + +/** + * Get the callback count + * + * @param cb - The UID of the specified callback + * + * @return The callback count, < 0 on error + */ +int sceKernelGetCallbackCount(SceUID cb); + +/** + * Check callback ? + * + * @return Something or another + */ +int sceKernelCheckCallback(void); + + +/* Message pipes */ + +/** + * Create a message pipe + * + * @param name - Name of the pipe + * @param type - The type of memory attribute to use internally (set to 0x40) + * @param attr - Set to 12 + * @param bufSize - The size of the internal buffer in multiples of 0x1000 (4KB) + * @param opt - Message pipe options (set to NULL) + * + * @return The UID of the created pipe, < 0 on error + */ +SceUID sceKernelCreateMsgPipe(const char *name, int type, int attr, unsigned int bufSize, void *opt); + +/** + * Delete a message pipe + * + * @param uid - The UID of the pipe + * + * @return 0 on success, < 0 on error + */ +int sceKernelDeleteMsgPipe(SceUID uid); + +/** + * Send a message to a pipe + * + * @param uid - The UID of the pipe + * @param message - Pointer to the message + * @param size - Size of the message + * @param unk1 - Unknown - async vs sync? use 0 for sync + * @param unk2 - Unknown - use NULL + * @param timeout - Timeout for send in us. use NULL to wait indefinitely + * + * @return 0 on success, < 0 on error + */ +int sceKernelSendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout); + +/** + * Send a message to a pipe (with callback) + * + * @param uid - The UID of the pipe + * @param message - Pointer to the message + * @param size - Size of the message + * @param unk1 - Unknown - async vs sync? use 0 for sync + * @param unk2 - Unknown - use NULL + * @param timeout - Timeout for send in us. use NULL to wait indefinitely + * + * @return 0 on success, < 0 on error + */ +int sceKernelSendMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout); + +/** + * Try to send a message to a pipe + * + * @param uid - The UID of the pipe + * @param message - Pointer to the message + * @param size - Size of the message + * @param unk1 - Unknown - use 0 + * @param unk2 - Unknown - use NULL + * + * @return 0 on success, < 0 on error + */ +int sceKernelTrySendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2); + +/** + * Receive a message from a pipe + * + * @param uid - The UID of the pipe + * @param message - Pointer to the message + * @param size - Size of the message + * @param unk1 - Unknown - async vs sync? use 0 for sync + * @param unk2 - Unknown - use NULL + * @param timeout - Timeout for receive in us. use NULL to wait indefinitely + * + * @return 0 on success, < 0 on error + */ +int sceKernelReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout); + +/** + * Receive a message from a pipe (with callback) + * + * @param uid - The UID of the pipe + * @param message - Pointer to the message + * @param size - Size of the message + * @param unk1 - Unknown - async vs sync? use 0 for sync + * @param unk2 - Unknown - use NULL + * @param timeout - Timeout for receive in us. use NULL to wait indefinitely + * + * @return 0 on success, < 0 on error + */ +int sceKernelReceiveMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout); + +/** + * Receive a message from a pipe + * + * @param uid - The UID of the pipe + * @param message - Pointer to the message + * @param size - Size of the message + * @param unk1 - Unknown - use 0 + * @param unk2 - Unknown - use NULL + * + * @return 0 on success, < 0 on error + */ +int sceKernelTryReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2); + +/** + * Cancel a message pipe + * + * @param uid - UID of the pipe to cancel + * @param psend - Receive number of sending threads, NULL is valid + * @param precv - Receive number of receiving threads, NULL is valid + * + * @return 0 on success, < 0 on error + */ +int sceKernelCancelMsgPipe(SceUID uid, int *psend, int *precv); + +/** Message Pipe status info */ +typedef struct SceKernelMppInfo { + SceSize size; + SceUID mppId; // Needs confirmation + char name[32]; + SceUInt attr; + int bufSize; + int freeSize; + int numSendWaitThreads; + int numReceiveWaitThreads; +} SceKernelMppInfo; + +/** + * Get the status of a Message Pipe + * + * @param uid - The uid of the Message Pipe + * @param info - Pointer to a ::SceKernelMppInfo structure + * + * @return 0 on success, < 0 on error + */ +int sceKernelGetMsgPipeInfo(SceUID uid, SceKernelMppInfo *info); + + +/* Misc. */ + +typedef struct SceKernelSystemInfo { + SceSize size; + SceUInt32 activeCpuMask; + + struct { + SceKernelSysClock idleClock; + SceUInt32 comesOutOfIdleCount; + SceUInt32 threadSwitchCount; + } cpuInfo[4]; +} SceKernelSystemInfo; + +/** + * Get the system information + * + * @param info - Pointer to a ::SceKernelSystemInfo structure + * + * @return 0 on success, < 0 on error + */ +int sceKernelGetSystemInfo(SceKernelSystemInfo *info); + +/* Misc. */ + +/** Threadmgr types */ +typedef enum SceKernelIdListType { + SCE_KERNEL_TMID_Thread = 1, + SCE_KERNEL_TMID_Semaphore = 2, + SCE_KERNEL_TMID_EventFlag = 3, + SCE_KERNEL_TMID_Mbox = 4, + SCE_KERNEL_TMID_Vpl = 5, + SCE_KERNEL_TMID_Fpl = 6, + SCE_KERNEL_TMID_Mpipe = 7, + SCE_KERNEL_TMID_Callback = 8, + SCE_KERNEL_TMID_ThreadEventHandler = 9, + SCE_KERNEL_TMID_Alarm = 10, + SCE_KERNEL_TMID_VTimer = 11, + SCE_KERNEL_TMID_SleepThread = 64, + SCE_KERNEL_TMID_DelayThread = 65, + SCE_KERNEL_TMID_SuspendThread = 66, + SCE_KERNEL_TMID_DormantThread = 67, +} SceKernelIdListType; + +/** + * Get the type of a threadman uid + * + * @param uid - The uid to get the type from + * + * @return The type, < 0 on error + */ +SceKernelIdListType sceKernelGetThreadmgrUIDClass(SceUID uid); + + + +typedef struct SceKernelLwMutexWork { + SceInt64 data[4]; +} SceKernelLwMutexWork; + +typedef struct SceKernelLwMutexOptParam { + SceSize size; +} SceKernelLwMutexOptParam; + +int sceKernelCreateLwMutex(SceKernelLwMutexWork *pWork,const char *pName, unsigned int attr, int initCount, const SceKernelLwMutexOptParam *pOptParam); +int sceKernelDeleteLwMutex(SceKernelLwMutexWork *pWork); +int sceKernelLockLwMutex(SceKernelLwMutexWork *pWork, int lockCount, unsigned int *pTimeout); +int sceKernelUnlockLwMutex(SceKernelLwMutexWork *pWork, int unlockCount); + +typedef struct SceKernelLwCondWork { + SceInt64 data[4]; +} SceKernelLwCondWork; + +typedef struct SceKernelLwCondOptParam { + SceSize size; +} SceKernelLwCondOptParam; + +int sceKernelCreateLwCond(SceKernelLwCondWork *pWork, const char *pName, unsigned int attr, SceKernelLwMutexWork *pLwMutex, const SceKernelLwCondOptParam *pOptParam); +int sceKernelDeleteLwCond(SceKernelLwCondWork *pWork); +int sceKernelSignalLwCond(SceKernelLwCondWork *pWork); +int sceKernelWaitLwCond(SceKernelLwCondWork *pWork, unsigned int *pTimeout); + + + +/** + * Get the system time (wide version) + * + * @return The system time + */ +SceInt64 sceKernelGetSystemTimeWide(void); + +/** + * @brief sceKernelGetThreadTLSAddr gets an address to a 4 bytes area of TLS memory for the specified thread + * @param thid - The UID of the thread to access TLS + * @param key - the TLS keyslot index + * @return pointer to TLS memory + */ +void *sceKernelGetThreadTLSAddr(SceUID thid, int key); + +/** + * @brief sceKernelGetTLSAddr get pointer to TLS key area for current thread + * @param key - the TLS keyslot index + * @return pointer to TLS key value + */ +void *sceKernelGetTLSAddr(int key); + +/** + * @brief Gets the current process PID + * + * @return Current PID + */ +SceUID sceKernelGetProcessId(void); + +/** + * @brief Runs a function with larger stack size + * + * @param[in] stack_size The stack size + * @param[in] to_call To call + * @param args The arguments + * + * @return Zero on success + */ +int sceKernelRunWithStack(int stack_size, int (*to_call)(void *), void *args); + +#ifdef __cplusplus +} +#endif + +#endif /* _PSP2_KERNEL_THREADMGR_H_ */ diff --git a/include/kernel/sblacmgr.h b/include/kernel/sblacmgr.h new file mode 100644 index 0000000..3f4143d --- /dev/null +++ b/include/kernel/sblacmgr.h @@ -0,0 +1,19 @@ +#ifndef _PSP2_KERNEL_SBLACMGR_H_ +#define _PSP2_KERNEL_SBLACMGR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +int sceSblACMgrIsShell(SceUID pid); +int sceSblACMgrIsGameProgram(SceUID pid); +int sceSblACMgrIsNonGameProgram(SceUID pid); +int sceSblACMgrIsDevelopmentMode(void); + +#ifdef __cplusplus +} +#endif + +#endif /* _PSP2_KERNEL_SBLACMGR_H_ */ diff --git a/include/user/kernel/modulemgr.h b/include/user/kernel/modulemgr.h index ab41eba..abdf387 100644 --- a/include/user/kernel/modulemgr.h +++ b/include/user/kernel/modulemgr.h @@ -7,6 +7,20 @@ extern "C" { #endif +/** + * @brief Return values for plugins `module_start` and `module_stop` + */ +/** @{ */ +#define SCE_KERNEL_START_SUCCESS (0) +#define SCE_KERNEL_START_RESIDENT SCE_KERNEL_START_SUCCESS +#define SCE_KERNEL_START_NO_RESIDENT (1) +#define SCE_KERNEL_START_FAILED (2) + +#define SCE_KERNEL_STOP_SUCCESS (0) +#define SCE_KERNEL_STOP_FAIL (1) +#define SCE_KERNEL_STOP_CANCEL SCE_KERNEL_STOP_FAIL +/** @} */ + typedef struct { SceUInt size; //< this structure size (0x18) @@ -56,6 +70,19 @@ int sceKernelUnloadModule(SceUID modid, int flags, SceKernelULMOption *option); SceUID sceKernelLoadStartModule(char *path, SceSize args, void *argp, int flags, SceKernelLMOption *option, int *status); int sceKernelStopUnloadModule(SceUID modid, SceSize args, void *argp, int flags, SceKernelULMOption *option, int *status); +typedef struct +{ + SceSize size; + char versionString[16]; + SceUInt unk_14; + SceUInt unk_18; + SceUInt unk_1C; + SceUInt version; + SceUInt unk_24; +} SceKernelFwInfo; + +int sceKernelGetSystemSwVersion(SceKernelFwInfo *data); + #ifdef __cplusplus } #endif diff --git a/nids/360/SceIofilemgr.yml b/nids/360/SceIofilemgr.yml new file mode 100644 index 0000000..db4d4ef --- /dev/null +++ b/nids/360/SceIofilemgr.yml @@ -0,0 +1,42 @@ +modules: + SceIofilemgr: + nid: 0x3E244C17 + libraries: + SceIofilemgr: + nid: 0xF2FF276E + functions: + sceIoCancel: 0xCEF48835 + sceIoClose: 0xC70B8886 + sceIoCloseAsync: 0x8EA3616A + sceIoComplete: 0xD1C49D2F + sceIoDclose: 0x422A221A + sceIoFlockForSystem: 0x3E98E422 + sceIoGetPriority: 0xF2A472A1 + sceIoGetProcessDefaultPriority: 0x0DC4F1BB + sceIoGetThreadDefaultPriority: 0xA176CD03 + sceIoLseek32: 0x49252B9B + sceIoRead: 0xFDB32293 + sceIoReadAsync: 0x773EBD45 + sceIoSetPriority: 0x14B2D56C + sceIoSetPriorityForSystem: 0x27373135 + sceIoSetProcessDefaultPriority: 0x7F2ABBAF + sceIoSetThreadDefaultPriority: 0x49312108 + sceIoSetThreadDefaultPriorityForSystem: 0xB9C9C9CF + sceIoSyncByFd: 0x16512F59 + sceIoSyncByFdAsync: 0x7E1367CB + sceIoWrite: 0x34EFD876 + sceIoWriteAsync: 0xE0D63D2A + SceIofilemgrForDriver: + nid: 0x40FD29C7 + functions: + sceIoChstat: 0x7D42B8DC + sceIoClose: 0xF99DD8A3 + sceIoDopen: 0x463B25CC + sceIoDread: 0x20CF5FC7 + sceIoGetstat: 0x75C96D25 + sceIoLseek: 0x62090481 + sceIoMkdir: 0x7F710B25 + sceIoOpen: 0x75192972 + sceIoRead: 0xE17EFC03 + sceIoRename: 0xDC0C4997 + sceIoWrite: 0x21EE91F0 diff --git a/nids/360/SceKernel.yml b/nids/360/SceKernel.yml deleted file mode 100644 index 5fa0bca..0000000 --- a/nids/360/SceKernel.yml +++ /dev/null @@ -1,437 +0,0 @@ -modules: - SceKernel: - nid: 0x00000048 - libraries: - SceCpu: - nid: 0x45265161 - SceDebugLed: - nid: 0xAE004C0A - functions: - sceKernelGetGPI: 0x14F582CF - sceKernelSetGPO: 0x78E702D3 - SceDipsw: - nid: 0xB36D5922 - functions: - sceKernelCheckDipsw: 0x1C783FB2 - sceKernelClearDipsw: 0x800EDCC1 - sceKernelSetDipsw: 0x817053D4 - SceIofilemgr: - nid: 0xF2FF276E - functions: - sceIoCancel: 0xCEF48835 - sceIoClose: 0xC70B8886 - sceIoCloseAsync: 0x8EA3616A - sceIoComplete: 0xD1C49D2F - sceIoDclose: 0x422A221A - sceIoFlockForSystem: 0x3E98E422 - sceIoGetPriority: 0xF2A472A1 - sceIoGetProcessDefaultPriority: 0x0DC4F1BB - sceIoGetThreadDefaultPriority: 0xA176CD03 - sceIoLseek32: 0x49252B9B - sceIoRead: 0xFDB32293 - sceIoReadAsync: 0x773EBD45 - sceIoSetPriority: 0x14B2D56C - sceIoSetPriorityForSystem: 0x27373135 - sceIoSetProcessDefaultPriority: 0x7F2ABBAF - sceIoSetThreadDefaultPriority: 0x49312108 - sceIoSetThreadDefaultPriorityForSystem: 0xB9C9C9CF - sceIoSyncByFd: 0x16512F59 - sceIoSyncByFdAsync: 0x7E1367CB - sceIoWrite: 0x34EFD876 - sceIoWriteAsync: 0xE0D63D2A - SceLibKernel: - nid: 0xCAE9ACE6 - functions: - SceKernelStackChkGuard: 0x4458BCF3 - __sce_aeabi_idiv0: 0x4373B548 - __sce_aeabi_ldiv0: 0xFB235848 - __stack_chk_fail: 0x37691BF8 - __stack_chk_guard: 0x93B8AA67 - _sceKernelCreateLwMutex: 0xB84EF718 - sceClibAbort: 0x2F2C6046 - sceClibDprintf: 0x4340EF77 - sceClibLookCtypeTable: 0xD8EBBB7E - sceClibMemchr: 0x407D6153 - sceClibMemcmp: 0x9CC2BFDF - sceClibMemcmpConstTime: 0x100091AF - sceClibMemcpy: 0x14E9DBD7 - sceClibMemcpyChk: 0x1F94EF45 - sceClibMemcpy_safe: 0x2E3B02A1 - sceClibMemmove: 0x736753C8 - sceClibMemmoveChk: 0xA18068FC - sceClibMemset: 0x632980D7 - sceClibMemsetChk: 0xD19B6DC5 - sceClibMspaceCalloc: 0x678374AD - sceClibMspaceCreate: 0x3B9E301A - sceClibMspaceDestroy: 0xAE1A21EC - sceClibMspaceFree: 0x9C56B4D1 - sceClibMspaceIsHeapEmpty: 0xD1D59701 - sceClibMspaceMalloc: 0x86EF7680 - sceClibMspaceMallocStats: 0x8CC1D38E - sceClibMspaceMallocStatsFast: 0x738E0322 - sceClibMspaceMallocUsableSize: 0x46A02279 - sceClibMspaceMemalign: 0x3C847D57 - sceClibMspaceRealloc: 0x774891D6 - sceClibMspaceReallocalign: 0x586AC68D - sceClibPrintf: 0xFA26BC62 - sceClibSnprintf: 0x8CBA03D5 - sceClibSnprintfChk: 0xC2E1A945 - sceClibStrcatChk: 0x0F28A495 - sceClibStrchr: 0x614076B7 - sceClibStrcmp: 0xA2FB4D9D - sceClibStrcpyChk: 0xB9B6B05A - sceClibStrlcat: 0x70CBC2D5 - sceClibStrlcatChk: 0x4CCB60A9 - sceClibStrlcpy: 0x2CDFCD1C - sceClibStrlcpyChk: 0xAC6CF5DB - sceClibStrncasecmp: 0xB54C0BE4 - sceClibStrncat: 0xA37E6383 - sceClibStrncatChk: 0x489EBEDF - sceClibStrncmp: 0x660D1F6D - sceClibStrncpy: 0xC458D60A - sceClibStrncpyChk: 0x9CBE1475 - sceClibStrnlen: 0xAC595E68 - sceClibStrrchr: 0x6E728AAE - sceClibStrstr: 0xE265498B - sceClibStrtoll: 0x2E581B88 - sceClibTolower: 0x4C5471BC - sceClibToupper: 0xB0335388 - sceClibVdprintf: 0xABC6893C - sceClibVprintf: 0x5EA3B6CE - sceClibVsnprintf: 0xFA6BE467 - sceClibVsnprintfChk: 0xB628786B - sceIoChstat: 0x29482F7F - sceIoChstatByFd: 0x6E903AB2 - sceIoDevctl: 0x04B30CB2 - sceIoDopen: 0xA9283DD0 - sceIoDread: 0x9C8B6624 - sceIoGetstat: 0xBCA5B623 - sceIoGetstatByFd: 0x57F8CD25 - sceIoIoctl: 0x54ABACFA - sceIoLseek: 0x99BA173E - sceIoMkdir: 0x9670D39F - sceIoOpen: 0x6C60AC61 - sceIoPread: 0x52315AD7 - sceIoPwrite: 0x8FFFF5A8 - sceIoRemove: 0xE20ED0F3 - sceIoRename: 0xF737E369 - sceIoRmdir: 0xE9F91EC8 - sceIoSync: 0x98ACED6D - sceKernelAtomicAddAndGet16: 0x495C52EC - sceKernelAtomicAddAndGet32: 0x2E84A93B - sceKernelAtomicAddAndGet64: 0xB6CE9B9A - sceKernelAtomicAddAndGet8: 0x8F7BD940 - sceKernelAtomicAddUnless16: 0x1CF4AA4B - sceKernelAtomicAddUnless32: 0x4B33FD3C - sceKernelAtomicAddUnless64: 0xFFCE7438 - sceKernelAtomicAddUnless8: 0x7FD94393 - sceKernelAtomicAndAndGet16: 0xF9890F7E - sceKernelAtomicAndAndGet32: 0x6709D30C - sceKernelAtomicAndAndGet64: 0xAED2B370 - sceKernelAtomicAndAndGet8: 0x86B9170F - sceKernelAtomicClearAndGet16: 0xCC36B775 - sceKernelAtomicClearAndGet32: 0x9DAA0DE8 - sceKernelAtomicClearAndGet64: 0x264209F3 - sceKernelAtomicClearAndGet8: 0x17B40010 - sceKernelAtomicClearMask16: 0x5FE7DFF8 - sceKernelAtomicClearMask32: 0xE3DF0CB3 - sceKernelAtomicClearMask64: 0x953D118A - sceKernelAtomicClearMask8: 0xD7D49E36 - sceKernelAtomicCompareAndSet16: 0xE8C01236 - sceKernelAtomicCompareAndSet32: 0x1124A1D4 - sceKernelAtomicCompareAndSet64: 0x1EBDFCCD - sceKernelAtomicCompareAndSet8: 0x327DB4C0 - sceKernelAtomicDecIfPositive16: 0x323718FB - sceKernelAtomicDecIfPositive32: 0xCA3294F1 - sceKernelAtomicDecIfPositive64: 0x8BE2A007 - sceKernelAtomicDecIfPositive8: 0x9DABE6C3 - sceKernelAtomicGetAndAdd16: 0x5674DB0C - sceKernelAtomicGetAndAdd32: 0x2611CB0B - sceKernelAtomicGetAndAdd64: 0x63DAF37D - sceKernelAtomicGetAndAdd8: 0x27A2AAFA - sceKernelAtomicGetAndAnd16: 0x7A0CB056 - sceKernelAtomicGetAndAnd32: 0x08266595 - sceKernelAtomicGetAndAnd64: 0x4828BC43 - sceKernelAtomicGetAndAnd8: 0x53DCA02B - sceKernelAtomicGetAndClear16: 0x57CD7E7D - sceKernelAtomicGetAndClear32: 0x0226A017 - sceKernelAtomicGetAndClear64: 0x436AA0B5 - sceKernelAtomicGetAndClear8: 0xA10873A4 - sceKernelAtomicGetAndOr16: 0x31E49E73 - sceKernelAtomicGetAndOr32: 0x984AD276 - sceKernelAtomicGetAndOr64: 0xC39186CD - sceKernelAtomicGetAndOr8: 0x107A68DF - sceKernelAtomicGetAndSet16: 0xF7B9ADFC - sceKernelAtomicGetAndSet32: 0x9B43E667 - sceKernelAtomicGetAndSet64: 0xD82B3A7A - sceKernelAtomicGetAndSet8: 0x2672EA0B - sceKernelAtomicGetAndSub16: 0xAC51979C - sceKernelAtomicGetAndSub32: 0x115C516F - sceKernelAtomicGetAndSub64: 0x4AE9C8E6 - sceKernelAtomicGetAndSub8: 0xCDF5DF67 - sceKernelAtomicGetAndXor16: 0x6E2D0B9E - sceKernelAtomicGetAndXor32: 0x38739E2F - sceKernelAtomicGetAndXor64: 0x6A19BBE9 - sceKernelAtomicGetAndXor8: 0x7350B2DF - sceKernelAtomicOrAndGet16: 0x8E248EBD - sceKernelAtomicOrAndGet32: 0xC3B2F7F8 - sceKernelAtomicOrAndGet64: 0x809BBC7D - sceKernelAtomicOrAndGet8: 0x51693931 - sceKernelAtomicSet16: 0x450BFECF - sceKernelAtomicSet32: 0xB69DA09B - sceKernelAtomicSet64: 0xC8A4339C - sceKernelAtomicSet8: 0xE960FDA2 - sceKernelAtomicSubAndGet16: 0xC26BBBB1 - sceKernelAtomicSubAndGet32: 0x01C9CD92 - sceKernelAtomicSubAndGet64: 0x9BB4A94B - sceKernelAtomicSubAndGet8: 0x99E1796E - sceKernelAtomicXorAndGet16: 0x6F524195 - sceKernelAtomicXorAndGet32: 0x46940704 - sceKernelAtomicXorAndGet64: 0xDDC6866E - sceKernelAtomicXorAndGet8: 0x634AF062 - sceKernelBacktrace: 0x894037E8 - sceKernelBacktraceSelf: 0xD16C03B0 - sceKernelCallModuleExit: 0x15E2A45D - sceKernelCallWithChangeStack: 0xAFE2B300 - sceKernelCancelEvent: 0x603AB770 - sceKernelCancelEventFlag: 0x2A12D9B7 - sceKernelCancelEventWithSetPattern: 0xB01387D5 - sceKernelCancelMsgPipe: 0xEF14BA37 - sceKernelCancelMutex: 0x2144890D - sceKernelCancelRWLock: 0x190CA94B - sceKernelCancelSema: 0x66D6BF05 - sceKernelCancelTimer: 0x9CCF768C - sceKernelChangeCurrentThreadAttr: 0x36833F93 - sceKernelCheckThreadStack: 0x84092FD0 - sceKernelCloseModule: 0x657FA50E - sceKernelCreateCond: 0x50572FDA - sceKernelCreateEventFlag: 0x8516D040 - sceKernelCreateLwCond: 0x48C7EAE6 - sceKernelCreateLwMutex: 0xDA6EC8EF - sceKernelCreateMsgPipe: 0x0A10C1C8 - sceKernelCreateMutex: 0xED53334A - sceKernelCreateRWLock: 0x8667951D - sceKernelCreateSema: 0x1BD67366 - sceKernelCreateSimpleEvent: 0xE6DB2494 - sceKernelCreateThread: 0xC5C11EE7 - sceKernelCreateTimer: 0x2255B2A5 - sceKernelDeleteLwCond: 0x721F6CB3 - sceKernelDeleteLwMutex: 0x244E76D2 - sceKernelExitProcess: 0x7595D9AA - sceKernelGetCallbackInfo: 0x88DD1BC8 - sceKernelGetCondInfo: 0x6864DCE2 - sceKernelGetCurrentThreadVfpException: 0xA37A6057 - sceKernelGetEventFlagInfo: 0x8BA4C0C1 - sceKernelGetEventInfo: 0xE35F19D6 - sceKernelGetEventPattern: 0xE5A2AC66 - sceKernelGetLwCondInfo: 0xE4DF36A0 - sceKernelGetLwCondInfoById: 0x971F1DE8 - sceKernelGetLwMutexInfo: 0xF7D8F1FC - sceKernelGetLwMutexInfoById: 0x4846613D - sceKernelGetModuleInfoByAddr: 0xD11A5103 - sceKernelGetMsgPipeInfo: 0x4046D16B - sceKernelGetMutexInfo: 0x9A6C43CA - sceKernelGetOpenPsId: 0x261E2C34 - sceKernelGetPMUSERENR: 0xF8A99FDF - sceKernelGetProcessTime: 0x4C4672BF - sceKernelGetProcessTimeLow: 0xE9F973B1 - sceKernelGetProcessTimeWide: 0xB110C123 - sceKernelGetRWLockInfo: 0x079A573B - sceKernelGetSemaInfo: 0x595D3FA6 - sceKernelGetSystemInfo: 0xE0241FAA - sceKernelGetTLSAddr: 0xB295EB61 - sceKernelGetThreadCpuAffinityMask: 0x8C57AC2A - sceKernelGetThreadCurrentPriority: 0xC53A9848 - sceKernelGetThreadExitStatus: 0xD5DC26C4 - sceKernelGetThreadId: 0x0FB972F9 - sceKernelGetThreadInfo: 0x8D9C5461 - sceKernelGetThreadRunStatus: 0xD6B01013 - sceKernelGetTimerBase: 0x1F59E04D - sceKernelGetTimerEventRemainingTime: 0x75B1EB3E - sceKernelGetTimerInfo: 0x7E35E10A - sceKernelGetTimerTime: 0x381DC300 - sceKernelLoadModule: 0xBBE82155 - sceKernelLoadStartModule: 0x2DCC4AFA - sceKernelLockLwMutex: 0x46E7BE7B - sceKernelLockLwMutexCB: 0x3148C6B6 - sceKernelLockMutex: 0x1D8D7945 - sceKernelLockMutexCB: 0x2BDAA524 - sceKernelLockReadRWLock: 0xFA670F0F - sceKernelLockReadRWLockCB: 0x2D4A62B7 - sceKernelLockWriteRWLock: 0x67A187BB - sceKernelLockWriteRWLockCB: 0xA4777082 - sceKernelOpenModule: 0x4F2D8B15 - sceKernelPMonThreadGetCounter: 0x99B2BF15 - sceKernelPollEvent: 0x241F3634 - sceKernelPollEventFlag: 0x1FBB0FE1 - sceKernelPrintBacktrace: 0x1C02A434 - sceKernelPulseEventWithNotifyCallback: 0x92F162F3 - sceKernelReceiveMsgPipe: 0x4E81DD5C - sceKernelReceiveMsgPipeCB: 0x33AF829B - sceKernelReceiveMsgPipeVector: 0x9F899087 - sceKernelReceiveMsgPipeVectorCB: 0xBE5B3E27 - sceKernelSendMsgPipe: 0x0CA71EA2 - sceKernelSendMsgPipeCB: 0xA5CA74AC - sceKernelSendMsgPipeVector: 0x94D506F7 - sceKernelSendMsgPipeVectorCB: 0x9C6F7F79 - sceKernelSetEventWithNotifyCallback: 0x5FF3EE92 - sceKernelSetTimerEvent: 0x621D293B - sceKernelSetTimerTime: 0xFFAD717F - sceKernelSignalLwCond: 0x3AC63B9A - sceKernelSignalLwCondAll: 0xE5241A0C - sceKernelSignalLwCondTo: 0xFC1A48EB - sceKernelStackChkFail: 0xEC287338 - sceKernelStartModule: 0x702425D5 - sceKernelStartThread: 0xF08DE149 - sceKernelStopModule: 0x3B2CBA09 - sceKernelStopUnloadModule: 0x2415F8A4 - sceKernelTryLockLwMutex: 0xA6A2C915 - sceKernelTryReceiveMsgPipe: 0x5615B006 - sceKernelTryReceiveMsgPipeVector: 0x86ECC0FF - sceKernelTrySendMsgPipe: 0xDFC670E0 - sceKernelTrySendMsgPipeVector: 0x60DB346F - sceKernelUnloadModule: 0x1987920E - sceKernelUnlockLwMutex: 0x120AFC8C - sceKernelWaitCond: 0xC88D44AD - sceKernelWaitCondCB: 0x4CE42CE2 - sceKernelWaitEvent: 0x120F03AF - sceKernelWaitEventCB: 0xA0490795 - sceKernelWaitEventFlag: 0x83C0E2AF - sceKernelWaitEventFlagCB: 0xE737B1DF - sceKernelWaitLwCond: 0xE1878282 - sceKernelWaitLwCondCB: 0x8FA54B07 - sceKernelWaitMultipleEvents: 0x10586418 - sceKernelWaitMultipleEventsCB: 0x4263DBC9 - sceKernelWaitSema: 0x0C7B834B - sceKernelWaitSemaCB: 0x174692B4 - sceKernelWaitSignal: 0xADCA94E5 - sceKernelWaitSignalCB: 0x24460BB3 - sceKernelWaitThreadEnd: 0xDDB395A9 - sceKernelWaitThreadEndCB: 0xC54941ED - sceSblACMgrIsGameProgram: 0x963F4A99 - SceLibRng: - nid: 0xF9AC7CF8 - functions: - sceKernelGetRandomNumber: 0xB2700165 - SceModulemgr: - nid: 0xEAED1616 - functions: - sceKernelGetModuleIdByAddr: 0xF5798C7C - sceKernelGetModuleInfo: 0x36585DAF - sceKernelGetModuleList: 0x2EF2581F - sceKernelGetSystemSwVersion: 0x5182E212 - SceProcessmgr: - nid: 0x2DD91812 - functions: - sceKernelGetStderr: 0xFA5E3ADA - sceKernelGetStdin: 0xC1727F59 - sceKernelGetStdout: 0xE5AA625C - sceKernelIsCDialogAvailable: 0x143BC4D6 - sceKernelIsGameBudget: 0xCE0F02F0 - sceKernelLibcClock: 0x9E45DA09 - sceKernelLibcGettimeofday: 0x4B879059 - sceKernelLibcGmtime_r: 0xBCA437CD - sceKernelLibcLocaltime_r: 0x94F041ED - sceKernelLibcMktime: 0x890BDC39 - sceKernelLibcTime: 0x0039BE45 - sceKernelPowerLock: 0x7AA73378 - sceKernelPowerTick: 0x2252890C - sceKernelPowerUnlock: 0x466C0CBD - sceKernelRegisterProcessTerminationCallback: 0x5EC77870 - sceKernelUnregisterProcessTerminationCallback: 0x973A4527 - SceSysmem: - nid: 0x37FE725A - functions: - sceKernelAllocMemBlock: 0xB9D5EBDE - sceKernelAllocMemBlockForVM: 0xE2D7E137 - sceKernelCloseMemBlock: 0xB680E3A0 - sceKernelCloseVMDomain: 0xD6CA56CA - sceKernelFindMemBlockByAddr: 0xA33B99D1 - sceKernelFreeMemBlock: 0xA91E15EE - sceKernelGetFreeMemorySize: 0x87CC580B - sceKernelGetMemBlockBase: 0xB8EF5818 - sceKernelGetMemBlockInfoByAddr: 0x4010AD65 - sceKernelGetMemBlockInfoByRange: 0x006F3DB4 - sceKernelGetModel: 0xD0D4F729 - sceKernelGetModelForCDialog: 0xA2CB322F - sceKernelOpenMemBlock: 0x8EB8DFBB - sceKernelOpenVMDomain: 0x9CA3EB2B - sceKernelSyncVMDomain: 0x19D2A81A - SceThreadmgr: - nid: 0x859A24B1 - functions: - sceKernelCancelCallback: 0x30741EF2 - sceKernelChangeActiveCpuMask: 0x001173F8 - sceKernelChangeThreadCpuAffinityMask: 0x15129174 - sceKernelChangeThreadPriority: 0xBD0139F2 - sceKernelChangeThreadVfpException: 0xCC18FBAE - sceKernelCheckCallback: 0xE53E41F6 - sceKernelCheckWaitableStatus: 0xD9BD74EB - sceKernelClearEvent: 0x7B2A4B28 - sceKernelClearEventFlag: 0x4CB87CA7 - sceKernelCloseCond: 0x15C690E0 - sceKernelCloseEventFlag: 0x9A68F547 - sceKernelCloseMsgPipe: 0x1305A065 - sceKernelCloseMutex: 0x03E23AF6 - sceKernelCloseRWLock: 0xFD5BD5C1 - sceKernelCloseSema: 0xA2D81F9E - sceKernelCloseSimpleEvent: 0xFEF4CA53 - sceKernelCloseTimer: 0xACE60E4A - sceKernelCreateCallback: 0xB19CF7E9 - sceKernelCreateThreadForUser: 0xC0FAF6A3 - sceKernelDelayThread: 0x4B675D05 - sceKernelDelayThreadCB: 0x9C0180E1 - sceKernelDeleteCallback: 0xD469676B - sceKernelDeleteCond: 0x879E6EBD - sceKernelDeleteEventFlag: 0x5840162C - sceKernelDeleteMsgPipe: 0xE78BCCF7 - sceKernelDeleteMutex: 0xCB78710D - sceKernelDeleteRWLock: 0xE73649CA - sceKernelDeleteSema: 0xDB32948A - sceKernelDeleteSimpleEvent: 0x208CFE28 - sceKernelDeleteThread: 0x1BBDE3D9 - sceKernelDeleteTimer: 0xAB1E42C4 - sceKernelExitDeleteThread: 0x1D17DECF - sceKernelGetCallbackCount: 0x038644D5 - sceKernelGetMsgPipeCreatorId: 0x70E2A6D2 - sceKernelGetProcessId: 0x9DCB4B7A - sceKernelGetSystemTimeWide: 0xF4EE4FA9 - sceKernelGetThreadStackFreeSize: 0x4F8A3DA0 - sceKernelGetThreadTLSAddr: 0xBACA6891 - sceKernelGetThreadmgrUIDClass: 0xC9678F7F - sceKernelGetTimerBaseWide: 0x5DBC1960 - sceKernelGetTimerTimeWide: 0x3EFD3165 - sceKernelNotifyCallback: 0xA4683592 - sceKernelOpenCond: 0x76BDA02F - sceKernelOpenEventFlag: 0xBC19F8A1 - sceKernelOpenMsgPipe: 0x0E1CB9F6 - sceKernelOpenMutex: 0x52E17182 - sceKernelOpenRWLock: 0xCE510196 - sceKernelOpenSema: 0xCBE235C7 - sceKernelOpenSimpleEvent: 0x4E1E4DF8 - sceKernelOpenTimer: 0xB6E286E7 - sceKernelPollSema: 0x866EF048 - sceKernelPulseEvent: 0x8D27BAD6 - sceKernelRegisterCallbackToEvent: 0x76FB37E9 - sceKernelSendSignal: 0xD4C367B2 - sceKernelSetEvent: 0x324218CD - sceKernelSetEventFlag: 0xEC94DFF7 - sceKernelSetTimerTimeWide: 0x273B4A4D - sceKernelSignalCond: 0x6ED2E2DC - sceKernelSignalCondAll: 0xC2E7AC22 - sceKernelSignalCondTo: 0x1269F4EC - sceKernelSignalSema: 0xE6B761D1 - sceKernelStartTimer: 0x48091E0C - sceKernelStopTimer: 0x869E9F20 - sceKernelTryLockMutex: 0x72FC1F54 - sceKernelTryLockReadRWLock: 0xEFDDA456 - sceKernelTryLockWriteRWLock: 0x206CBB66 - sceKernelUnlockMutex: 0x1A372EC8 - sceKernelUnlockReadRWLock: 0x3EF91145 - sceKernelUnlockWriteRWLock: 0xB4151397 - sceKernelUnregisterCallbackFromEvent: 0x18462B11 - sceKernelUnregisterCallbackFromEventAll: 0x888A7361 - SceThreadmgrCoredumpTime: - nid: 0x5E8D0E22 - functions: - sceKernelExitThread: 0x0C8A38E1 diff --git a/nids/360/SceKernelModulemgr.yml b/nids/360/SceKernelModulemgr.yml new file mode 100644 index 0000000..d889f7b --- /dev/null +++ b/nids/360/SceKernelModulemgr.yml @@ -0,0 +1,29 @@ +modules: + SceKernelModulemgr: + nid: 0x726C6635 + libraries: + SceModulemgr: + nid: 0xEAED1616 + functions: + sceKernelGetModuleIdByAddr: 0xF5798C7C + sceKernelGetModuleInfo: 0x36585DAF + sceKernelGetModuleList: 0x2EF2581F + sceKernelGetSystemSwVersion: 0x5182E212 + SceModulemgrForDriver: + nid: 0xD4A60A52 + functions: + sceKernelGetSystemSwVersion: 0x5182E212 + sceKernelLoadModule: 0x86D8D634 + sceKernelLoadStartModule: 0x189BFBBB + sceKernelLoadStartModuleForPid: 0x9D953C22 + sceKernelLoadStartSharedModuleForPid: 0xE2ADEF8D + sceKernelStartModule: 0x0675B682 + sceKernelStopUnloadModule: 0x100DAEB9 + sceKernelUnloadModule: 0x728E72A6 + SceModulemgrForKernel: + nid: 0xC445FA63 + functions: + sceKernelGetModuleInfo: 0xD269F915 + sceKernelGetModuleInternal: 0xFE303863 + sceKernelGetModuleList: 0x97CF7B4E + sceKernelLoadModuleForPid: 0xFA21D8CB diff --git a/nids/360/SceKernelThreadMgr.yml b/nids/360/SceKernelThreadMgr.yml new file mode 100644 index 0000000..ec66d76 --- /dev/null +++ b/nids/360/SceKernelThreadMgr.yml @@ -0,0 +1,112 @@ +modules: + SceKernelThreadMgr: + nid: 0xA09CFA5C + libraries: + SceCpu: + nid: 0x45265161 + SceDebugLed: + nid: 0xAE004C0A + functions: + sceKernelGetGPI: 0x14F582CF + sceKernelSetGPO: 0x78E702D3 + SceDipsw: + nid: 0xB36D5922 + functions: + sceKernelCheckDipsw: 0x1C783FB2 + sceKernelClearDipsw: 0x800EDCC1 + sceKernelSetDipsw: 0x817053D4 + SceThreadmgr: + nid: 0x859A24B1 + functions: + sceKernelCancelCallback: 0x30741EF2 + sceKernelChangeActiveCpuMask: 0x001173F8 + sceKernelChangeThreadCpuAffinityMask: 0x15129174 + sceKernelChangeThreadPriority: 0xBD0139F2 + sceKernelChangeThreadVfpException: 0xCC18FBAE + sceKernelCheckCallback: 0xE53E41F6 + sceKernelCheckWaitableStatus: 0xD9BD74EB + sceKernelClearEvent: 0x7B2A4B28 + sceKernelClearEventFlag: 0x4CB87CA7 + sceKernelCloseCond: 0x15C690E0 + sceKernelCloseEventFlag: 0x9A68F547 + sceKernelCloseMsgPipe: 0x1305A065 + sceKernelCloseMutex: 0x03E23AF6 + sceKernelCloseRWLock: 0xFD5BD5C1 + sceKernelCloseSema: 0xA2D81F9E + sceKernelCloseSimpleEvent: 0xFEF4CA53 + sceKernelCloseTimer: 0xACE60E4A + sceKernelCreateCallback: 0xB19CF7E9 + sceKernelCreateThreadForUser: 0xC0FAF6A3 + sceKernelDelayThread: 0x4B675D05 + sceKernelDelayThreadCB: 0x9C0180E1 + sceKernelDeleteCallback: 0xD469676B + sceKernelDeleteCond: 0x879E6EBD + sceKernelDeleteEventFlag: 0x5840162C + sceKernelDeleteMsgPipe: 0xE78BCCF7 + sceKernelDeleteMutex: 0xCB78710D + sceKernelDeleteRWLock: 0xE73649CA + sceKernelDeleteSema: 0xDB32948A + sceKernelDeleteSimpleEvent: 0x208CFE28 + sceKernelDeleteThread: 0x1BBDE3D9 + sceKernelDeleteTimer: 0xAB1E42C4 + sceKernelExitDeleteThread: 0x1D17DECF + sceKernelGetCallbackCount: 0x038644D5 + sceKernelGetMsgPipeCreatorId: 0x70E2A6D2 + sceKernelGetProcessId: 0x9DCB4B7A + sceKernelGetSystemTimeWide: 0xF4EE4FA9 + sceKernelGetThreadStackFreeSize: 0x4F8A3DA0 + sceKernelGetThreadTLSAddr: 0xBACA6891 + sceKernelGetThreadmgrUIDClass: 0xC9678F7F + sceKernelGetTimerBaseWide: 0x5DBC1960 + sceKernelGetTimerTimeWide: 0x3EFD3165 + sceKernelNotifyCallback: 0xA4683592 + sceKernelOpenCond: 0x76BDA02F + sceKernelOpenEventFlag: 0xBC19F8A1 + sceKernelOpenMsgPipe: 0x0E1CB9F6 + sceKernelOpenMutex: 0x52E17182 + sceKernelOpenRWLock: 0xCE510196 + sceKernelOpenSema: 0xCBE235C7 + sceKernelOpenSimpleEvent: 0x4E1E4DF8 + sceKernelOpenTimer: 0xB6E286E7 + sceKernelPollSema: 0x866EF048 + sceKernelPulseEvent: 0x8D27BAD6 + sceKernelRegisterCallbackToEvent: 0x76FB37E9 + sceKernelSendSignal: 0xD4C367B2 + sceKernelSetEvent: 0x324218CD + sceKernelSetEventFlag: 0xEC94DFF7 + sceKernelSetTimerTimeWide: 0x273B4A4D + sceKernelSignalCond: 0x6ED2E2DC + sceKernelSignalCondAll: 0xC2E7AC22 + sceKernelSignalCondTo: 0x1269F4EC + sceKernelSignalSema: 0xE6B761D1 + sceKernelStartTimer: 0x48091E0C + sceKernelStopTimer: 0x869E9F20 + sceKernelTryLockMutex: 0x72FC1F54 + sceKernelTryLockReadRWLock: 0xEFDDA456 + sceKernelTryLockWriteRWLock: 0x206CBB66 + sceKernelUnlockMutex: 0x1A372EC8 + sceKernelUnlockReadRWLock: 0x3EF91145 + sceKernelUnlockWriteRWLock: 0xB4151397 + sceKernelUnregisterCallbackFromEvent: 0x18462B11 + sceKernelUnregisterCallbackFromEventAll: 0x888A7361 + SceThreadmgrCoredumpTime: + nid: 0x5E8D0E22 + functions: + sceKernelExitThread: 0x0C8A38E1 + SceThreadmgrForDriver: + nid: 0xE2C40624 + functions: + sceKernelCreateThread: 0xC6674E7D + sceKernelDeleteThread: 0xAC834F3F + sceKernelGetProcessId: 0x9DCB4B7A + sceKernelGetSystemTimeWide: 0xF4EE4FA9 + sceKernelStartThread: 0x21F5419B + sceKernelWaitThreadEnd: 0x3E20216F + SceThreadmgrForKernel: + nid: 0xA8CA0EFD + functions: + sceKernelCreateMutex: 0xFBAA026E + sceKernelDeleteMutex: 0x0A912340 + sceKernelLockMutex: 0x16AC80C5 + sceKernelRunWithStack: 0xE54FD746 + sceKernelUnlockMutex: 0x1E82E5D0 diff --git a/nids/360/SceLibKernel.yml b/nids/360/SceLibKernel.yml new file mode 100644 index 0000000..8cee1ee --- /dev/null +++ b/nids/360/SceLibKernel.yml @@ -0,0 +1,278 @@ +modules: + SceLibKernel: + nid: 0x00000048 + libraries: + SceLibKernel: + nid: 0xCAE9ACE6 + functions: + SceKernelStackChkGuard: 0x4458BCF3 + __sce_aeabi_idiv0: 0x4373B548 + __sce_aeabi_ldiv0: 0xFB235848 + __stack_chk_fail: 0x37691BF8 + __stack_chk_guard: 0x93B8AA67 + _sceKernelCreateLwMutex: 0xB84EF718 + sceClibAbort: 0x2F2C6046 + sceClibDprintf: 0x4340EF77 + sceClibLookCtypeTable: 0xD8EBBB7E + sceClibMemchr: 0x407D6153 + sceClibMemcmp: 0x9CC2BFDF + sceClibMemcmpConstTime: 0x100091AF + sceClibMemcpy: 0x14E9DBD7 + sceClibMemcpyChk: 0x1F94EF45 + sceClibMemcpy_safe: 0x2E3B02A1 + sceClibMemmove: 0x736753C8 + sceClibMemmoveChk: 0xA18068FC + sceClibMemset: 0x632980D7 + sceClibMemsetChk: 0xD19B6DC5 + sceClibMspaceCalloc: 0x678374AD + sceClibMspaceCreate: 0x3B9E301A + sceClibMspaceDestroy: 0xAE1A21EC + sceClibMspaceFree: 0x9C56B4D1 + sceClibMspaceIsHeapEmpty: 0xD1D59701 + sceClibMspaceMalloc: 0x86EF7680 + sceClibMspaceMallocStats: 0x8CC1D38E + sceClibMspaceMallocStatsFast: 0x738E0322 + sceClibMspaceMallocUsableSize: 0x46A02279 + sceClibMspaceMemalign: 0x3C847D57 + sceClibMspaceRealloc: 0x774891D6 + sceClibMspaceReallocalign: 0x586AC68D + sceClibPrintf: 0xFA26BC62 + sceClibSnprintf: 0x8CBA03D5 + sceClibSnprintfChk: 0xC2E1A945 + sceClibStrcatChk: 0x0F28A495 + sceClibStrchr: 0x614076B7 + sceClibStrcmp: 0xA2FB4D9D + sceClibStrcpyChk: 0xB9B6B05A + sceClibStrlcat: 0x70CBC2D5 + sceClibStrlcatChk: 0x4CCB60A9 + sceClibStrlcpy: 0x2CDFCD1C + sceClibStrlcpyChk: 0xAC6CF5DB + sceClibStrncasecmp: 0xB54C0BE4 + sceClibStrncat: 0xA37E6383 + sceClibStrncatChk: 0x489EBEDF + sceClibStrncmp: 0x660D1F6D + sceClibStrncpy: 0xC458D60A + sceClibStrncpyChk: 0x9CBE1475 + sceClibStrnlen: 0xAC595E68 + sceClibStrrchr: 0x6E728AAE + sceClibStrstr: 0xE265498B + sceClibStrtoll: 0x2E581B88 + sceClibTolower: 0x4C5471BC + sceClibToupper: 0xB0335388 + sceClibVdprintf: 0xABC6893C + sceClibVprintf: 0x5EA3B6CE + sceClibVsnprintf: 0xFA6BE467 + sceClibVsnprintfChk: 0xB628786B + sceIoChstat: 0x29482F7F + sceIoChstatByFd: 0x6E903AB2 + sceIoDevctl: 0x04B30CB2 + sceIoDopen: 0xA9283DD0 + sceIoDread: 0x9C8B6624 + sceIoGetstat: 0xBCA5B623 + sceIoGetstatByFd: 0x57F8CD25 + sceIoIoctl: 0x54ABACFA + sceIoLseek: 0x99BA173E + sceIoMkdir: 0x9670D39F + sceIoOpen: 0x6C60AC61 + sceIoPread: 0x52315AD7 + sceIoPwrite: 0x8FFFF5A8 + sceIoRemove: 0xE20ED0F3 + sceIoRename: 0xF737E369 + sceIoRmdir: 0xE9F91EC8 + sceIoSync: 0x98ACED6D + sceKernelAtomicAddAndGet16: 0x495C52EC + sceKernelAtomicAddAndGet32: 0x2E84A93B + sceKernelAtomicAddAndGet64: 0xB6CE9B9A + sceKernelAtomicAddAndGet8: 0x8F7BD940 + sceKernelAtomicAddUnless16: 0x1CF4AA4B + sceKernelAtomicAddUnless32: 0x4B33FD3C + sceKernelAtomicAddUnless64: 0xFFCE7438 + sceKernelAtomicAddUnless8: 0x7FD94393 + sceKernelAtomicAndAndGet16: 0xF9890F7E + sceKernelAtomicAndAndGet32: 0x6709D30C + sceKernelAtomicAndAndGet64: 0xAED2B370 + sceKernelAtomicAndAndGet8: 0x86B9170F + sceKernelAtomicClearAndGet16: 0xCC36B775 + sceKernelAtomicClearAndGet32: 0x9DAA0DE8 + sceKernelAtomicClearAndGet64: 0x264209F3 + sceKernelAtomicClearAndGet8: 0x17B40010 + sceKernelAtomicClearMask16: 0x5FE7DFF8 + sceKernelAtomicClearMask32: 0xE3DF0CB3 + sceKernelAtomicClearMask64: 0x953D118A + sceKernelAtomicClearMask8: 0xD7D49E36 + sceKernelAtomicCompareAndSet16: 0xE8C01236 + sceKernelAtomicCompareAndSet32: 0x1124A1D4 + sceKernelAtomicCompareAndSet64: 0x1EBDFCCD + sceKernelAtomicCompareAndSet8: 0x327DB4C0 + sceKernelAtomicDecIfPositive16: 0x323718FB + sceKernelAtomicDecIfPositive32: 0xCA3294F1 + sceKernelAtomicDecIfPositive64: 0x8BE2A007 + sceKernelAtomicDecIfPositive8: 0x9DABE6C3 + sceKernelAtomicGetAndAdd16: 0x5674DB0C + sceKernelAtomicGetAndAdd32: 0x2611CB0B + sceKernelAtomicGetAndAdd64: 0x63DAF37D + sceKernelAtomicGetAndAdd8: 0x27A2AAFA + sceKernelAtomicGetAndAnd16: 0x7A0CB056 + sceKernelAtomicGetAndAnd32: 0x08266595 + sceKernelAtomicGetAndAnd64: 0x4828BC43 + sceKernelAtomicGetAndAnd8: 0x53DCA02B + sceKernelAtomicGetAndClear16: 0x57CD7E7D + sceKernelAtomicGetAndClear32: 0x0226A017 + sceKernelAtomicGetAndClear64: 0x436AA0B5 + sceKernelAtomicGetAndClear8: 0xA10873A4 + sceKernelAtomicGetAndOr16: 0x31E49E73 + sceKernelAtomicGetAndOr32: 0x984AD276 + sceKernelAtomicGetAndOr64: 0xC39186CD + sceKernelAtomicGetAndOr8: 0x107A68DF + sceKernelAtomicGetAndSet16: 0xF7B9ADFC + sceKernelAtomicGetAndSet32: 0x9B43E667 + sceKernelAtomicGetAndSet64: 0xD82B3A7A + sceKernelAtomicGetAndSet8: 0x2672EA0B + sceKernelAtomicGetAndSub16: 0xAC51979C + sceKernelAtomicGetAndSub32: 0x115C516F + sceKernelAtomicGetAndSub64: 0x4AE9C8E6 + sceKernelAtomicGetAndSub8: 0xCDF5DF67 + sceKernelAtomicGetAndXor16: 0x6E2D0B9E + sceKernelAtomicGetAndXor32: 0x38739E2F + sceKernelAtomicGetAndXor64: 0x6A19BBE9 + sceKernelAtomicGetAndXor8: 0x7350B2DF + sceKernelAtomicOrAndGet16: 0x8E248EBD + sceKernelAtomicOrAndGet32: 0xC3B2F7F8 + sceKernelAtomicOrAndGet64: 0x809BBC7D + sceKernelAtomicOrAndGet8: 0x51693931 + sceKernelAtomicSet16: 0x450BFECF + sceKernelAtomicSet32: 0xB69DA09B + sceKernelAtomicSet64: 0xC8A4339C + sceKernelAtomicSet8: 0xE960FDA2 + sceKernelAtomicSubAndGet16: 0xC26BBBB1 + sceKernelAtomicSubAndGet32: 0x01C9CD92 + sceKernelAtomicSubAndGet64: 0x9BB4A94B + sceKernelAtomicSubAndGet8: 0x99E1796E + sceKernelAtomicXorAndGet16: 0x6F524195 + sceKernelAtomicXorAndGet32: 0x46940704 + sceKernelAtomicXorAndGet64: 0xDDC6866E + sceKernelAtomicXorAndGet8: 0x634AF062 + sceKernelBacktrace: 0x894037E8 + sceKernelBacktraceSelf: 0xD16C03B0 + sceKernelCallModuleExit: 0x15E2A45D + sceKernelCallWithChangeStack: 0xAFE2B300 + sceKernelCancelEvent: 0x603AB770 + sceKernelCancelEventFlag: 0x2A12D9B7 + sceKernelCancelEventWithSetPattern: 0xB01387D5 + sceKernelCancelMsgPipe: 0xEF14BA37 + sceKernelCancelMutex: 0x2144890D + sceKernelCancelRWLock: 0x190CA94B + sceKernelCancelSema: 0x66D6BF05 + sceKernelCancelTimer: 0x9CCF768C + sceKernelChangeCurrentThreadAttr: 0x36833F93 + sceKernelCheckThreadStack: 0x84092FD0 + sceKernelCloseModule: 0x657FA50E + sceKernelCreateCond: 0x50572FDA + sceKernelCreateEventFlag: 0x8516D040 + sceKernelCreateLwCond: 0x48C7EAE6 + sceKernelCreateLwMutex: 0xDA6EC8EF + sceKernelCreateMsgPipe: 0x0A10C1C8 + sceKernelCreateMutex: 0xED53334A + sceKernelCreateRWLock: 0x8667951D + sceKernelCreateSema: 0x1BD67366 + sceKernelCreateSimpleEvent: 0xE6DB2494 + sceKernelCreateThread: 0xC5C11EE7 + sceKernelCreateTimer: 0x2255B2A5 + sceKernelDeleteLwCond: 0x721F6CB3 + sceKernelDeleteLwMutex: 0x244E76D2 + sceKernelExitProcess: 0x7595D9AA + sceKernelGetCallbackInfo: 0x88DD1BC8 + sceKernelGetCondInfo: 0x6864DCE2 + sceKernelGetCurrentThreadVfpException: 0xA37A6057 + sceKernelGetEventFlagInfo: 0x8BA4C0C1 + sceKernelGetEventInfo: 0xE35F19D6 + sceKernelGetEventPattern: 0xE5A2AC66 + sceKernelGetLwCondInfo: 0xE4DF36A0 + sceKernelGetLwCondInfoById: 0x971F1DE8 + sceKernelGetLwMutexInfo: 0xF7D8F1FC + sceKernelGetLwMutexInfoById: 0x4846613D + sceKernelGetModuleInfoByAddr: 0xD11A5103 + sceKernelGetMsgPipeInfo: 0x4046D16B + sceKernelGetMutexInfo: 0x9A6C43CA + sceKernelGetOpenPsId: 0x261E2C34 + sceKernelGetPMUSERENR: 0xF8A99FDF + sceKernelGetProcessTime: 0x4C4672BF + sceKernelGetProcessTimeLow: 0xE9F973B1 + sceKernelGetProcessTimeWide: 0xB110C123 + sceKernelGetRWLockInfo: 0x079A573B + sceKernelGetSemaInfo: 0x595D3FA6 + sceKernelGetSystemInfo: 0xE0241FAA + sceKernelGetTLSAddr: 0xB295EB61 + sceKernelGetThreadCpuAffinityMask: 0x8C57AC2A + sceKernelGetThreadCurrentPriority: 0xC53A9848 + sceKernelGetThreadExitStatus: 0xD5DC26C4 + sceKernelGetThreadId: 0x0FB972F9 + sceKernelGetThreadInfo: 0x8D9C5461 + sceKernelGetThreadRunStatus: 0xD6B01013 + sceKernelGetTimerBase: 0x1F59E04D + sceKernelGetTimerEventRemainingTime: 0x75B1EB3E + sceKernelGetTimerInfo: 0x7E35E10A + sceKernelGetTimerTime: 0x381DC300 + sceKernelLoadModule: 0xBBE82155 + sceKernelLoadStartModule: 0x2DCC4AFA + sceKernelLockLwMutex: 0x46E7BE7B + sceKernelLockLwMutexCB: 0x3148C6B6 + sceKernelLockMutex: 0x1D8D7945 + sceKernelLockMutexCB: 0x2BDAA524 + sceKernelLockReadRWLock: 0xFA670F0F + sceKernelLockReadRWLockCB: 0x2D4A62B7 + sceKernelLockWriteRWLock: 0x67A187BB + sceKernelLockWriteRWLockCB: 0xA4777082 + sceKernelOpenModule: 0x4F2D8B15 + sceKernelPMonThreadGetCounter: 0x99B2BF15 + sceKernelPollEvent: 0x241F3634 + sceKernelPollEventFlag: 0x1FBB0FE1 + sceKernelPrintBacktrace: 0x1C02A434 + sceKernelPulseEventWithNotifyCallback: 0x92F162F3 + sceKernelReceiveMsgPipe: 0x4E81DD5C + sceKernelReceiveMsgPipeCB: 0x33AF829B + sceKernelReceiveMsgPipeVector: 0x9F899087 + sceKernelReceiveMsgPipeVectorCB: 0xBE5B3E27 + sceKernelSendMsgPipe: 0x0CA71EA2 + sceKernelSendMsgPipeCB: 0xA5CA74AC + sceKernelSendMsgPipeVector: 0x94D506F7 + sceKernelSendMsgPipeVectorCB: 0x9C6F7F79 + sceKernelSetEventWithNotifyCallback: 0x5FF3EE92 + sceKernelSetTimerEvent: 0x621D293B + sceKernelSetTimerTime: 0xFFAD717F + sceKernelSignalLwCond: 0x3AC63B9A + sceKernelSignalLwCondAll: 0xE5241A0C + sceKernelSignalLwCondTo: 0xFC1A48EB + sceKernelStackChkFail: 0xEC287338 + sceKernelStartModule: 0x702425D5 + sceKernelStartThread: 0xF08DE149 + sceKernelStopModule: 0x3B2CBA09 + sceKernelStopUnloadModule: 0x2415F8A4 + sceKernelTryLockLwMutex: 0xA6A2C915 + sceKernelTryReceiveMsgPipe: 0x5615B006 + sceKernelTryReceiveMsgPipeVector: 0x86ECC0FF + sceKernelTrySendMsgPipe: 0xDFC670E0 + sceKernelTrySendMsgPipeVector: 0x60DB346F + sceKernelUnloadModule: 0x1987920E + sceKernelUnlockLwMutex: 0x120AFC8C + sceKernelWaitCond: 0xC88D44AD + sceKernelWaitCondCB: 0x4CE42CE2 + sceKernelWaitEvent: 0x120F03AF + sceKernelWaitEventCB: 0xA0490795 + sceKernelWaitEventFlag: 0x83C0E2AF + sceKernelWaitEventFlagCB: 0xE737B1DF + sceKernelWaitLwCond: 0xE1878282 + sceKernelWaitLwCondCB: 0x8FA54B07 + sceKernelWaitMultipleEvents: 0x10586418 + sceKernelWaitMultipleEventsCB: 0x4263DBC9 + sceKernelWaitSema: 0x0C7B834B + sceKernelWaitSemaCB: 0x174692B4 + sceKernelWaitSignal: 0xADCA94E5 + sceKernelWaitSignalCB: 0x24460BB3 + sceKernelWaitThreadEnd: 0xDDB395A9 + sceKernelWaitThreadEndCB: 0xC54941ED + sceSblACMgrIsGameProgram: 0x963F4A99 + SceLibRng: + nid: 0xF9AC7CF8 + functions: + sceKernelGetRandomNumber: 0xB2700165 diff --git a/nids/360/SceProcessmgr.yml b/nids/360/SceProcessmgr.yml new file mode 100644 index 0000000..7235635 --- /dev/null +++ b/nids/360/SceProcessmgr.yml @@ -0,0 +1,27 @@ +modules: + SceProcessmgr: + nid: 0xF019E1DA + libraries: + SceProcessmgr: + nid: 0x2DD91812 + functions: + sceKernelGetStderr: 0xFA5E3ADA + sceKernelGetStdin: 0xC1727F59 + sceKernelGetStdout: 0xE5AA625C + sceKernelIsCDialogAvailable: 0x143BC4D6 + sceKernelIsGameBudget: 0xCE0F02F0 + sceKernelLibcClock: 0x9E45DA09 + sceKernelLibcGettimeofday: 0x4B879059 + sceKernelLibcGmtime_r: 0xBCA437CD + sceKernelLibcLocaltime_r: 0x94F041ED + sceKernelLibcMktime: 0x890BDC39 + sceKernelLibcTime: 0x0039BE45 + sceKernelPowerLock: 0x7AA73378 + sceKernelPowerTick: 0x2252890C + sceKernelPowerUnlock: 0x466C0CBD + sceKernelRegisterProcessTerminationCallback: 0x5EC77870 + sceKernelUnregisterProcessTerminationCallback: 0x973A4527 + SceProcessmgrForKernel: + nid: 0x7A69DE86 + functions: + sceKernelGetProcessKernelBuf: 0xB9E68092 diff --git a/nids/360/SceSblACMgr.yml b/nids/360/SceSblACMgr.yml new file mode 100644 index 0000000..c744b03 --- /dev/null +++ b/nids/360/SceSblACMgr.yml @@ -0,0 +1,11 @@ +modules: + SceSblACMgr: + nid: 0xB6E5AEBE + libraries: + SceSblACMgrForDriver: + nid: 0x9AD8E213 + functions: + sceSblACMgrIsDevelopmentMode: 0xE87D1777 + sceSblACMgrIsGameProgram: 0x1298C647 + sceSblACMgrIsNonGameProgram: 0x6C5AB07F + sceSblACMgrIsShell: 0x8612B243 diff --git a/nids/360/SceSblSsMgr.yml b/nids/360/SceSblSsMgr.yml new file mode 100644 index 0000000..4ef2d51 --- /dev/null +++ b/nids/360/SceSblSsMgr.yml @@ -0,0 +1,8 @@ +modules: + SceSblSsMgr: + nid: 0xFDDD93FA + libraries: + SceSblSsMgrForDriver: + nid: 0x61E9428D + functions: + sceKernelGetRandomNumber: 0x4F9BFBE5 diff --git a/nids/360/SceStdio.yml b/nids/360/SceStdio.yml new file mode 100644 index 0000000..d82ed9d --- /dev/null +++ b/nids/360/SceStdio.yml @@ -0,0 +1,8 @@ +modules: + SceStdio: + nid: 0x771A73C0 + libraries: + SceDebugForDriver: + nid: 0x88758561 + functions: + printf: 0x391B74B7 diff --git a/nids/360/SceSysmem.yml b/nids/360/SceSysmem.yml new file mode 100644 index 0000000..e69a4f0 --- /dev/null +++ b/nids/360/SceSysmem.yml @@ -0,0 +1,105 @@ +modules: + SceSysmem: + nid: 0xB93950C6 + libraries: + SceCpuForDriver: + nid: 0x40ECDB0E + functions: + sceKernelCpuDcacheAndL2AndDMAFlush: 0x364E68A4 + sceKernelCpuDcacheAndL2Flush: 0x9CB9F0CE + sceKernelCpuDisableInterrupts: 0x821FC0EE + sceKernelCpuEnableInterrupts: 0xF5BAD43B + SceCpuForKernel: + nid: 0x54BF2BAB + functions: + sceKernelCpuDcacheFlush: 0x6BA2E51C + sceKernelCpuIcacheAndL2Flush: 0x19F17BD0 + sceKernelCpuRestoreContext: 0x0A4F0FB9 + sceKernelCpuSaveContext: 0x211B89DA + sceKernelCpuUnrestrictedMemcpy: 0x8C683DEC + SceSysclibForDriver: + nid: 0x7EE45391 + functions: + __aeabi_uidiv: 0xA9FF1205 + __aeabi_uidivmod: 0xA46CB7DE + memcmp: 0xF939E83D + memcpy: 0x40C88316 + memset: 0x0AB9BF5C + rshift: 0x1D89F6C0 + sceKernelStackCheckFail: 0xB997493D + snprintf: 0xAE7A8981 + strchr: 0x38463759 + strcmp: 0x0B33BC43 + strlen: 0xCFC6A9AC + strncat: 0xA1D1C32C + strncmp: 0x12CEE649 + strnlen: 0xCD4BD884 + strrchr: 0x7F0E0835 + strstr: 0x1304A69D + strtol: 0xAB77C5AA + SceSysmem: + nid: 0x37FE725A + functions: + sceKernelAllocMemBlock: 0xB9D5EBDE + sceKernelAllocMemBlockForVM: 0xE2D7E137 + sceKernelCloseMemBlock: 0xB680E3A0 + sceKernelCloseVMDomain: 0xD6CA56CA + sceKernelFindMemBlockByAddr: 0xA33B99D1 + sceKernelFreeMemBlock: 0xA91E15EE + sceKernelGetFreeMemorySize: 0x87CC580B + sceKernelGetMemBlockBase: 0xB8EF5818 + sceKernelGetMemBlockInfoByAddr: 0x4010AD65 + sceKernelGetMemBlockInfoByRange: 0x006F3DB4 + sceKernelGetModel: 0xD0D4F729 + sceKernelGetModelForCDialog: 0xA2CB322F + sceKernelOpenMemBlock: 0x8EB8DFBB + sceKernelOpenVMDomain: 0x9CA3EB2B + sceKernelSyncVMDomain: 0x19D2A81A + SceSysmemForDriver: + nid: 0x6F25E18A + functions: + sceKernelAllocMemBlock: 0xC94850C9 + sceKernelCreateClass: 0x61317102 + sceKernelCreateUserUid: 0xBF209859 + sceKernelDeleteUid: 0x047D32F2 + sceKernelDeleteUserUid: 0x84A4AF5E + sceKernelFindMemBlockByAddr: 0x8A1742F6 + sceKernelFirstDifferentIntUserForPid: 0x8334454F + sceKernelFreeMemBlock: 0x009E1C61 + sceKernelGetMemBlockBase: 0xA841EDDA + sceKernelGetObjForUid: 0x00ED6C14 + sceKernelGetPaddr: 0x8D160E65 + sceKernelGetPaddrList: 0xE68BEEBD + sceKernelGetPidContext: 0x2ECF7944 + sceKernelGetUidClass: 0x85336A1C + sceKernelKernelUidForUserUid: 0x45D22597 + sceKernelMapBlockUserVisible: 0x58D21746 + sceKernelMapUserBlock: 0x7D4F8B5F + sceKernelMemPoolAlloc: 0x7B4CB60A + sceKernelMemPoolCreate: 0x9328E0E8 + sceKernelMemPoolDestroy: 0xD6437637 + sceKernelMemPoolFree: 0x3EBCE343 + sceKernelMemcpyKernelToUser: 0x6D88EF8A + sceKernelMemcpyKernelToUserForPid: 0x6B825479 + sceKernelMemcpyKernelToUserForPidUnchecked: 0xFED82F2D + sceKernelMemcpyUserToKernel: 0xBC996A7A + sceKernelMemcpyUserToKernelForPid: 0x605275F8 + sceKernelMemcpyUserToUserForPid: 0x8E086C33 + sceKernelRemapBlock: 0xDFE2C8CB + sceKernelRoMemcpyKernelToUserForPid: 0x571D2739 + sceKernelStrlenUser: 0xB429D419 + sceKernelStrncpyKernelToUser: 0x80BD6FEB + sceKernelStrncpyUserForPid: 0x75AAF178 + sceKernelStrncpyUserToKernel: 0xDB3EC244 + sceKernelStrnlenUserForPid: 0x9929EB07 + sceKernelSwitchVmaForPid: 0x6F2ACDAE + SceSysmemForKernel: + nid: 0x63A519E5 + functions: + sceKernelCreateUidObj: 0xDF0288D7 + sceKernelRxMemcpyKernelToUserForPid: 0x30931572 + SceSysrootForKernel: + nid: 0x3691DA45 + functions: + sceKernelGetProcessTitleId: 0xEC3124A3 + sceKernelGetSysrootBuffer: 0x3E455842 -- cgit v1.2.3