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

7 files changed, 1500 insertions, 0 deletions

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 <psp2kern/types.h>
+
+#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 <psp2/types.h>
+
+#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 <psp2/types.h>
+
+#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 <psp2kern/types.h>
+
+#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 <psp2kern/types.h>
+
+#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 <psp2kern/types.h>
+
+#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