vitasdk-odin/Kernel/Kernel.odin

package kernel

import "core:c"
import sce "../common"

foreign import libkernel "system:SceLibKernel_stub"

/** Message Pipe status info */
SceKernelMppInfo :: struct {
    size: sce.Size,
    mppId: sce.UID, // Needs confirmation
    name: [32]c.char,
    attr: sce.UInt,
    bufSize: c.int,
    freeSize: c.int,
    numSendWaitThreads: c.int,
    numReceiveWaitThreads: c.int,
}
#assert(size_of(SceKernelMppInfo) == 0x3C)

/** Additional options used when creating rwlock. */
SceKernelRWLockOptParam :: struct {
	/** Size of the ::SceKernelRWLockOptParam structure */
  size: sce.Size,
}
#assert(size_of(SceKernelRWLockOptParam) == 4)

/** Current state of a rwlock.
 * @see sceKernelGetRWLockInfo
 */
SceKernelRWLockInfo :: struct {
	/** Size of the ::SceKernelRWLockInfo structure */
  size: sce.Size,
	/** The UID of the rwlock */
	rwLockId: sce.UID,
	/** NULL-terminated name of the rwlock */
	name: [32]c.char,
	/** Attributes */
  attr: sce.UInt32,
	/** The current lock count */
	lockCount: sce.Int32,
	/** The UID of the current owner of the rwlock with write access, 0 when locked for reads */
	writeOwnerId: sce.UID,
	/** The number of threads waiting on the rwlock for read access */
	numReadWaitThreads: sce.UInt32,
	/** The number of threads waiting on the rwlock for write access */
	numWriteWaitThreads: sce.UInt32,
}
#assert(size_of(SceKernelRWLockInfo) == 0x3C)

SceKernelSystemInfo :: struct {
    size: sce.Size,
    activeCpuMask: sce.UInt32,

    cpuInfo: [4]struct {
        idleClock: sce.KernelSysClock,
        comesOutOfIdleCount: sce.UInt32,
        threadSwitchCount: sce.UInt32,
    },
}
#assert(size_of(SceKernelSystemInfo) == 0x48)

@(link_prefix = "sceKernel")
foreign libkernel {
    /**
    * Fills the output buffer with random data.
    *
    * @param[out] output - Output buffer
    * @param[in] size - Size of the output buffer, 64 bytes maximum
    *
    * @return 0 on success, < 0 on error.
    */
    GetRandomNumber :: proc(output: rawptr, size: sce.Size) -> c.int ---

    /**
    * 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.
    */
    GetCallbackInfo :: proc(cb: sce.UID, infop: ^SceKernelCallbackInfo) -> c.int ---

    /**
    * Creates a new condition variable
    *
    * @par Example:
    * @code
    * SceUID condId
    * condId = sceKernelCreateCond("MyCond", 0, mutexId, NULL)
    * @endcode
    *
    * @param name - Specifies the name of the condition variable
    * @param attr - Condition variable attribute flags (normally set to 0)
    * @param mutexId - Mutex to be related to the condition variable
    * @param option - Condition variable options (normally set to 0)
    * @return A condition variable id
    */
    CreateCond :: proc(name: cstring, attr: sce.UInt, mutexId: sce.UID, option: ^SceKernelCondOptParam) -> sce.UID ---

    /**
    * Waits for a signal of a condition variable
    *
    * @param condId - The condition variable id returned from ::sceKernelCreateCond
    * @param timeout - Timeout in microseconds (assumed)
    * @return < 0 On error.
    */
    WaitCond :: proc(condId: sce.UID, timeout: ^c.uint) -> c.int ---

    /**
    * Waits for a signal of a condition variable (with callbacks)
    *
    * @param condId - The condition variable id returned from ::sceKernelCreateCond
    * @param timeout - Timeout in microseconds (assumed)
    * @return < 0 On error.
    */
    WaitCondCB :: proc(condId: sce.UID, timeout: ^c.uint) -> c.int ---

    /**
    * 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, NULL)
    * @endcode
    */
    CreateEventFlag :: proc(name: cstring, attr: c.int, bits: c.int, opt: ^SceKernelEventFlagOptParam) -> sce.UID ---

    /**
    * 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
    */
    PollEventFlag :: proc(evid: c.int, bits: c.uint, wait: c.uint, outBits: ^c.uint) -> c.int ---

    /**
    * 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
    */
    WaitEventFlag :: proc(evid: c.int, bits: c.uint, wait: c.uint, outBits: ^c.uint, timeout: ^sce.UInt) -> c.int ---

    /**
    * 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
    */
    WaitEventFlagCB :: proc(evid: c.int, bits: c.uint, wait: c.uint, outBits: ^c.uint, timeout: ^sce.UInt) -> c.int ---

    /**
    * 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.
    */
    GetEventFlagInfo :: proc(event: sce.UID, info: ^SceKernelEventFlagInfo) -> c.int ---

    CreateLwCond :: proc(pWork: ^SceKernelLwCondWork, pName: cstring, attr: c.uint, pLwMutex: ^SceKernelLwMutexWork, pOptParam: ^SceKernelLwCondOptParam) -> c.int ---
    DeleteLwCond :: proc(pWork: ^SceKernelLwCondWork) -> c.int ---
    SignalLwCond :: proc(pWork: ^SceKernelLwCondWork) -> c.int ---
    SignalLwCondAll :: proc(pWork: ^SceKernelLwCondWork) -> c.int ---
    SignalLwCondTo :: proc(pWork: ^SceKernelLwCondWork, threadId: sce.UID) -> c.int ---
    WaitLwCond :: proc(pWork: ^SceKernelLwCondWork, pTimeout: ^c.uint) -> c.int ---

    CreateLwMutex :: proc(pWork: ^SceKernelLwMutexWork, pName: cstring, attr: c.uint, initCount: c.int, pOptParam: ^SceKernelLwMutexOptParam) -> c.int ---
    DeleteLwMutex :: proc(pWork: ^SceKernelLwMutexWork) -> c.int ---
    LockLwMutex :: proc(pWork: ^SceKernelLwMutexWork, lockCount: c.int, pTimeout: ^c.uint) -> c.int ---
    TryLockLwMutex :: proc(pWork: ^SceKernelLwMutexWork, lockCount: c.int) -> c.int ---
    UnlockLwMutex :: proc(pWork: ^SceKernelLwMutexWork, unlockCount: c.int) -> c.int ---

    /**
    * 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
    */
    CreateMsgPipe :: proc(name: cstring, type: c.int, attr: c.int, bufSize: c.uint, opt: rawptr) -> sce.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
    */
    SendMsgPipe :: proc(uid: sce.UID , message: rawptr, size: c.uint, unk1: c.int, unk2: rawptr, timeout: ^c.uint) -> c.int ---

    /**
    * 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
    */
    SendMsgPipeCB :: proc(uid: sce.UID, message: rawptr, size: c.uint, unk1: c.int, unk2: rawptr, timeout: ^c.uint) -> c.int ---

    /**
    * 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
    */
    TrySendMsgPipe :: proc(uid: sce.UID, message: rawptr, size: sce.Size, unk1: c.int, unk2: rawptr) -> c.int ---

    /**
    * 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
    */
    ReceiveMsgPipe :: proc(uid: sce.UID, message: rawptr, size: sce.Size, unk1: c.int, unk2: rawptr, timeout: ^c.uint) -> c.int ---

    /**
    * 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
    */
    ReceiveMsgPipeCB :: proc(uid: sce.UID, message: rawptr, size: sce.Size, unk1: c.int, unk2: rawptr, timeout: ^c.uint) -> c.int ---

    /**
    * 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
    */
    TryReceiveMsgPipe :: proc(uid: sce.UID, message: rawptr, size: sce.Size, unk1: c.int, unk2: rawptr) -> c.int ---


    /**
    * 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
    */
    CancelMsgPipe :: proc(uid: sce.UID, psend: ^c.int, precv: ^c.int) -> c.int ---

    /**
    * 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
    */
    GetMsgPipeInfo :: proc(uid: sce.UID, info: ^SceKernelMppInfo) -> c.int ---

    /**
    * Creates a new mutex
    *
    * @par Example:
    * @code
    * int mutexid
    * mutexid = sceKernelCreateMutex("MyMutex", 0, 1, NULL)
    * @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
    */
    CreateMutex :: proc(name: cstring, attr: sce.UInt, initCount: c.int, option: ^SceKernelMutexOptParam) -> sce.UID ---

    /**
    * 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.
    */
    LockMutex :: proc(mutexid: sce.UID, lockCount: c.int, timeout: ^c.uint) -> c.int ---

    /**
    * 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.
    */
    LockMutexCB :: proc(mutexid: sce.UID, lockCount: c.int, timeout: ^c.uint) -> c.int ---

    /**
    * 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.
    */
    CancelMutex :: proc(mutexid: sce.UID, newCount: c.int, numWaitThreads: ^c.int) -> c.int ---

    /**
    * 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.
    */
    GetMutexInfo :: proc(mutexid: sce.UID, info: ^SceKernelMutexInfo) -> c.int ---

    /**
    * Creates a new rwlock
    *
    * @par Example:
    * @code
    * int rwlock_id
    * rwlock_id = sceKernelCreateRWLock("MyRWLock", 0, NULL)
    * @endcode
    *
    * @param name - Specifies the name of the rwlock
    * @param attr - RWLock attribute flags (normally set to 0)
    * @param option - RWLock options (normally set to NULL)
    * @return RWLock id on success, < 0 on error
    */
    CreateRWLock :: proc(name: cstring, attr: sce.UInt32, opt_param: ^SceKernelRWLockOptParam) -> sce.UID ---

    /**
    * Lock a rwlock with read access
    *
    * @param rwlock_id - The rwlock id returned from ::sceKernelCreateRWLock
    * @param timeout - Timeout in microseconds, use NULL to disable it
    * @return 0 on success, < 0 on error
    */
    LockReadRWLock :: proc(rwlock_id: sce.UID, timeout: ^c.uint) -> c.int ---

    /**
    * Lock a rwlock with write access
    *
    * @param rwlock_id - The rwlock id returned from ::sceKernelCreateRWLock
    * @param timeout - Timeout in microseconds, use NULL to disable it
    * @return 0 on success, < 0 on error
    */
    LockWriteRWLock :: proc(rwlock_id: sce.UID, timeout: ^c.uint) -> c.int ---

    /**
    * Lock a rwlock with read access and handle callbacks
    *
    * @param rwlock_id - The rwlock id returned from ::sceKernelCreateRWLock
    * @param timeout - Timeout in microseconds, use NULL to disable it
    * @return 0 on success, < 0 on error
    */
    LockReadRWLockCB :: proc(rwlock_id: sce.UID, timeout: ^c.uint) -> c.int ---

    /**
    * Lock a rwlock with write access and handle callbacks
    *
    * @param rwlock_id - The rwlock id returned from ::sceKernelCreateRWLock
    * @param timeout - Timeout in microseconds, use NULL to disable it
    * @return 0 on success, < 0 on error
    */
    LockWriteRWLockCB :: proc(rwlock_id: sce.UID, timeout: ^c.uint) -> c.int ---

    /**
    * Retrieve information about a rwlock.
    *
    * @param rwlock_id - UID of the rwlock to retrieve info for.
    * @param info - Pointer to a ::SceKernelRWLockInfo struct to receive the info.
    *
    * @return 0 on success, < 0 on error
    */
    GetRWLockInfo :: proc(rwlock_id: sce.UID, info: ^SceKernelRWLockInfo) -> c.int ---

    /**
    * Creates a new semaphore
    *
    * @par Example:
    * @code
    * int semaid
    * semaid = sceKernelCreateSema("MySema", 0, 1, 1, NULL)
    * @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
    */
    CreateSema :: proc(name: cstring, attr: sce.UInt, initVal: c.int, maxVal: c.int, option: ^SceKernelSemaOptParam) -> sce.UID ---


    /**
    * 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.
    */
    WaitSema :: proc(semaid: sce.UID, signal: c.int, timeout: ^sce.UInt) -> c.int ---

    /**
    * 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.
    */
    WaitSemaCB :: proc(semaid: sce.UID, signal: c.int, timeout: ^sce.UInt) -> c.int ---

    /**
    * 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.
    */
    CancelSema :: proc(semaid: sce.UID, setCount: c.int, numWaitThreads: ^c.int) -> c.int ---

    /**
    * 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.
    */
    GetSemaInfo :: proc(semaid: sce.UID, info: ^SceKernelSemaInfo) -> c.int ---

    /**
    * @brief Sleep current thread and wait for a signal. After it receives a signal, the thread wakes up.
    *
    * This is like a semphore with limit 1.
    * If signal was sent before and not consumed before, the function will immediately return.
    * @param unk0 unknown parameter. 0 can be used.
    * @param delay the delay before wating for a signal
    * @param timeout the timeout if it's null, it waits indefinitely.
    * @return 0 on success
    */
    WaitSignal :: proc(unk0: sce.UInt32, delay: sce.UInt32, timeout: ^sce.UInt32) -> c.int ---

    /**
    * 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
    *                          A thread can run only on the cores specified in the CPU affinity mask.
    *                          The CPU affinity mask can be specified by the logical sum of the following macros:
    *                          - SCE_KERNEL_CPU_MASK_USER_0
    *                          - SCE_KERNEL_CPU_MASK_USER_1
    *                          - SCE_KERNEL_CPU_MASK_USER_2
    *                          - SCE_KERNEL_CPU_MASK_SYSTEM (system-reserved core)
    *                          The following macro are also available to represent all available in userland CPU cores:
    *                          - SCE_KERNEL_CPU_MASK_USER_ALL
    *                          The following macro are also available to inherit affinity mask of the calling process:
    *                          - SCE_KERNEL_THREAD_CPU_AFFINITY_MASK_DEFAULT
    * @param option - Additional options specified by ::SceKernelThreadOptParam.

    * @return UID of the created thread, or an error code.
    */
    CreateThread :: proc(name: cstring, entry: SceKernelThreadEntry, initPriority: c.int, stackSize: sce.Size, attr: sce.UInt, cpuAffinityMask: c.int, option: ^SceKernelThreadOptParam) -> sce.UID ---


    /**
    * 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.
    */
    StartThread :: proc(thid: sce.UID, arglen: sce.Size, argp: rawptr) -> c.int ---


    /**
    * 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.
    */
    WaitThreadEnd :: proc(thid: sce.UID, stat: ^c.int, timeout: ^sce.UInt) -> c.int ---

    /**
    * 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.
    */
    WaitThreadEndCB :: proc(thid: sce.UID, stat: ^c.int, timeout: ^sce.UInt) -> c.int ---

    /**
    * Modify the attributes of the current thread.
    *
    * @param clearAttr - The thread attributes to clear.  One of ::SceThreadAttributes.
    * @param setAttr - The thread attributes to set.  One of ::SceThreadAttributes.
    *
    * @return < 0 on error.
    */
    ChangeCurrentThreadAttr :: proc(clearAttr: sce.UInt, setAttr: sce.UInt) -> c.int ---


    /**
    * Get the current priority of the thread you are in.
    *
    * @return The current thread priority
    */
    GetThreadCurrentPriority :: proc() -> c.int ---

    /**
    * Get the exit status of a thread.
    *
    * @param[in]  thid   - The UID of the thread to check.
    * @param[out] status - Status out pointer
    * @return The exit status
    */
    GetThreadExitStatus :: proc(thid: sce.UID, status: ^c.int) -> c.int ---

    /**
    * Check the thread stack?
    *
    * @return Unknown.
    */
    CheckThreadStack :: proc() -> c.int ---


    /**
    * 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.
    */
    GetThreadInfo :: proc(thid: sce.UID, info: ^SceKernelThreadInfo) -> c.int ---

    /**
    * Retrive the runtime status of a thread.
    *
    * @param thid - UID of the thread to retrieve status.
    * @param status - Pointer to a ::SceKernelThreadRunStatus struct to receive the runtime status.
    *
    * @return 0 if successful, otherwise the error code.
    */
    GetThreadRunStatus :: proc(thid: sce.UID, status: ^SceKernelThreadRunStatus) -> c.int ---

    /**
    * Get the current thread Id
    *
    * @return The thread id of the calling thread.
    */
    GetThreadId :: proc() -> c.int ---

    /**
    * Get the system information
    *
    * @param info - Pointer to a ::SceKernelSystemInfo structure
    *
    * @return 0 on success, < 0 on error
    */
    GetSystemInfo :: proc(info: ^SceKernelSystemInfo) -> c.int ---

    /**
    * @brief sceKernelGetTLSAddr get pointer to TLS key area for current thread
    * @param key - the TLS keyslot index
    * @return pointer to TLS key value
    */
    GetTLSAddr :: proc(key: c.int) -> rawptr ---

    AtomicSet8 :: proc(store: ^sce.Int8, value: sce.Int8) ---
    AtomicSet16 :: proc(store: sce.Int16, value: sce.Int16) ---
    AtomicSet32 :: proc(store: sce.Int32, value: sce.Int32) ---
    AtomicSet64 :: proc(store: sce.Int64, value: sce.Int64) ---

    AtomicCompareAndSet8 :: proc(store: sce.Int8, value, SceInt8, new_value: sce.Int8) -> sce.Int8 ---
    AtomicCompareAndSet16 :: proc(store: sce.Int16, value, SceInt16, new_value: sce.Int16) -> sce.Int16 ---
    AtomicCompareAndSet32 :: proc(store: sce.Int32, value, SceInt32, new_value: sce.Int32) -> sce.Int32 ---
    AtomicCompareAndSet64 :: proc(store: sce.Int64, value, SceInt64, new_value: sce.Int64) -> sce.Int64 ---


    AtomicAddAndGet8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicAddAndGet16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicAddAndGet32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicAddAndGet64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicAddUnless8 :: proc(store: sce.Int8, value: sce.Int8, cmpv: sce.Int8) -> sce.Bool ---
    AtomicAddUnless16 :: proc(store: sce.Int16, value: sce.Int16, cmpv: sce.Int16) -> sce.Bool ---
    AtomicAddUnless32 :: proc(store: sce.Int32, value: sce.Int32, cmpv: sce.Int32) -> sce.Bool ---
    AtomicAddUnless64 :: proc(store: sce.Int64, value: sce.Int64, cmpv: sce.Int64) -> sce.Bool ---

    AtomicSubAndGet8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicSubAndGet16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicSubAndGet32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicSubAndGet64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicAndAndGet8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicAndAndGet16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicAndAndGet32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicAndAndGet64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicOrAndGet8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicOrAndGet16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicOrAndGet32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicOrAndGet64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicXorAndGet8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicXorAndGet16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicXorAndGet32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicXorAndGet64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicClearAndGet8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicClearAndGet16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicClearAndGet32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicClearAndGet64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---


    AtomicGetAndSet8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicGetAndSet16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicGetAndSet32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicGetAndSet64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicGetAndAdd8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicGetAndAdd16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicGetAndAdd32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicGetAndAdd64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicGetAndSub8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicGetAndSub16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicGetAndSub32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicGetAndSub64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicGetAndAnd8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicGetAndAnd16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicGetAndAnd32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicGetAndAnd64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicGetAndOr8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicGetAndOr16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicGetAndOr32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicGetAndOr64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicGetAndXor8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicGetAndXor16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicGetAndXor32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicGetAndXor64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---

    AtomicGetAndClear8 :: proc(store: sce.Int8, value: sce.Int8) -> sce.Int8 ---
    AtomicGetAndClear16 :: proc(store: sce.Int16, value: sce.Int16) -> sce.Int16 ---
    AtomicGetAndClear32 :: proc(store: sce.Int32, value: sce.Int32) -> sce.Int32 ---
    AtomicGetAndClear64 :: proc(store: sce.Int64, value: sce.Int64) -> sce.Int64 ---


    AtomicClearMask8 :: proc(store: sce.Int8, value: sce.Int8) ---
    AtomicClearMask16 :: proc(store: sce.Int16, value: sce.Int16) ---
    AtomicClearMask32 :: proc(store: sce.Int32, value: sce.Int32) ---
    AtomicClearMask64 :: proc(store: sce.Int64, value: sce.Int64) ---

    AtomicDecIfPositive8 :: proc(store: ^sce.Int8) -> sce.Int8 ---
    AtomicDecIfPositive16 :: proc(store: ^sce.Int16) -> sce.Int16 ---
    AtomicDecIfPositive32 :: proc(store: ^sce.Int32) -> sce.Int32 ---
    AtomicDecIfPositive64 :: proc(store: ^sce.Int64) -> sce.Int64 ---


    LoadModule :: proc(path: cstring, flags: c.int, option: ^SceKernelLMOption) -> sce.UID ---
    UnloadModule :: proc(modid: sce.UID, flags: c.int, option: ^SceKernelULMOption) -> c.int ---

    StartModule :: proc(modid: sce.UID, args: sce.Size, argp: rawptr, flags: c.int, option: rawptr, status: ^c.int) -> c.int ---
    StopModule :: proc(modid: sce.UID, args: sce.Size, argp: rawptr, flags: c.int, option: rawptr, status: ^c.int) -> c.int ---

    LoadStartModule :: proc(path: cstring, args: sce.Size, argp: rawptr, flags: c.int, option: ^SceKernelLMOption, status: ^c.int) -> sce.UID ---
    StopUnloadModule :: proc(modid: sce.UID, args: sce.Size, argp: rawptr, flags: c.int, option: ^SceKernelULMOption, status: ^c.int) -> c.int ---

    /**
    * Exit current Process with specified return code
    *
    * @param[in] res - Exit code to return
    *
    * @return 0 on success, < 0 on error.
    */
    ExitProcess :: proc(res: c.int) -> c.int ---

    /**
    * Get the process time of the current process.
    *
    * @param[out] type - Pointer to a ::SceKernelSysClock structure which will receive the process time.
    *
    * @return 0 on success, < 0 on error.
    */
    GetProcessTime :: proc(pSysClock: ^sce.KernelSysClock) -> c.int ---

    /**
    * Get the lower 32 bits part of process time of the current process.
    *
    * @return process time of the current process
    */
    GetProcessTimeLow :: proc() -> sce.UInt32 ---

    /**
    * Get the process time of the current process.
    *
    * @return process time of the current process
    */
    GetProcessTimeWide :: proc() -> sce.UInt64 ---



    GetOpenPsId :: proc(id: ^SceKernelOpenPsId) -> c.int ---
}