View source for Coreinit.rpl

coreinit.rpl is the the system library that provides direct access to Cafe OS services. It provides kernel calls, thread scheduling, memory management, and filesystem services. coreinit is the first RPL loaded by the loader, even before the main executable itself.

==Functions==
===Auto Power-Down===
The Auto Power-Down feature in the WiiU saves the battery of the console, shutting down in one hour when there is no user activity.
{| class="wikitable"
!Name
!Prototype
!Description
|-
|IMEnableAPD
|<code>void IMEnableAPD(void)</code> 
|Enables the Auto Power-Down system.
|-
|IMDisableAPD
|<code>void IMDisableAPD(void)</code> 
|Disables the Auto Power-Down system.
|-
|IMIsAPDEnabled
|<code>void IMIsAPDEnabled(uint32_t *isEnabled)</code> 
|Writes the current Auto Power-Down setting to isEnabled: 0x0 = off, 0x1 = on.
|-
|IMIsAPDEnabledBySysSettings
|<code>void IMIsAPDEnabledBySysSettings(uint32_t *isEnabled)</code> 
|Writes the current Auto Power-Down setting from system settings to isEnabled: 0x0 = off, 0x1 = on.
|
|-
|IMGetAPDPeriod
|<code>void IMGetAPDPeriod(uint32_t *apd_secs)</code> 
|Returns the amount of seconds it takes of user inactivity to turn off the WiiU, if the Auto Power-Down setting is True. apd_secs is a pointer to the variable that stores the amount of seconds.
|-
|IMGetTimeBeforeAPD
|<code>void IMGetTimeBeforeAPD(uint32_t *apd_secs)</code> 
|Returns the amount of seconds that are left until the WiiU powers down, if the Auto Power-Down setting is True. apd_secs is a pointer to the variable that stores the amount of seconds.
|}
===OSDriver===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSDriver_Register
|<code>uint32_t OSDriver_Register(char *drv_name, size_t name_len, void *buf1, void *buf2)</code>
|Will register an OSDriver entity with the given name and bufs
|-
|OSDriver_Deregister
|<code>uint32_t OSDriver_Deregister(char *drv_name, size_t name_len)</code>
|Will try to find a OSDriver with the given name (and length because implementing a strlen was too hard), and deregister him
|-
|OSDriver_CopyToSaveArea
|<code>uint32_t OSDriver_CopyToSaveArea(char *drv_name, size_t name_len, void *in_buf, size_t buf_size)</code>
|Will copy buf to an OSDriver "safe" save area [0x44/4]
|-
|OSDriver_CopyFromSaveArea
|<code>uint32_t OSDriver_CopyFromSaveArea(char *drv_name, size_t name_len, void *out_buf, size_t buf_size)</code>
|Will copy data from the OSDriver save area to an user controlled buffer
|}
===Memory===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|memset
|<code>void *memset(void *str, int c, size_t n)</code> 
|Call OSBlockSet (Looks like it does the same thing as standart memset). Copies the character c (an unsigned char) to the first n characters of the String pointed to by the argument str. See  [http://www.tutorialspoint.com/c_standard_library/c_function_memset.htm]
|-
|memclr
|<code>void *memclr(void *str, size_t n)</code> 
|Like memset but sets the memory to 0. Call OSBlockSet (memset) with 0 as second arg (r4).
|-
|memcpy
|<code>void *memcpy(void *str1, const void *str2, size_t n)</code> 
|Call OSBlockMove with  1 as the  fourth arg (r6).Copies n characters from memory area str2 to memory area str1. See [http://www.tutorialspoint.com/c_standard_library/c_function_memcpy.htm]
|-
|memmove
|<code>void *memmove(void *str1, const void *str2, size_t n)</code> 
|Call OSBlockMove with 1 as the fourth arg (r6) exactly the same as memcpy.
|-
|MEMAllocFromDefaultHeapEx
|<code>void *MEMAllocFromDefaultHeapEx(uint32_t size, int alignment)</code> 
|Allocates memory on the heap with the given size and memory alignment. This is typically in the 0x4??????? memory area
|-
|MEMFreeToDefaultHeap
|<code>void MEMFreeToDefaultHeap(void* addr)</code> 
|Frees previously heap memory. addr is the address returned by MEMAllocFromDefaultHeapEx()
|-
|OSAllocFromSystem
|<code>void *OSAllocFromSystem(uint32_t size, int alignment)</code> 
|Allocates system memory with the given size and memory alignment. This is typically in the 0x10?????? memory area
|-
|OSFreeToSystem
|<code>void OSFreeToSystem(void* addr)</code> 
|Frees previously allocated system memory. addr is the address returned by OSAllocFromSystem()
|-
|OSBlockMove
|<code>void *OSBlockMove(void* dst, const void* src, uint32_t size, bool flush);</code>
|Will move src to dest (And set the flush flag to flush src in the data cache)
|-
|OSBlockSet
|<code>void *OSBlockSet(void* dst, uint8_t val, uint32_t size);</code>
|Basic memset (??? Is that uint8_t)
|}

===Cache===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|DCFlushRange
|<code>void DCFlushRange(const void *addr, size_t length)</code> 
|Flush the specified data cache blocks to memory
|-
|DCInvalidateRange
|<code>void DCInvalidateRange(void *addr, size_t length)</code> 
|Invalidate the specified data cache blocks
|-
|ICInvalidateRange
|<code>void ICInvalidateRange(const void *addr, size_t length)</code> 
|Invalidate the specified instruction cache blocks
|}

===Disassembler===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|DisassemblePPCOpcode
|<code>void DisassemblePPCOpcode(uint32_t *addr, char *instr_buf, int instr_len, find_symbol_t sym_func, int flags)</code>
|Disassemble a PPC opcode at addr and place it into instr_buf (instr_len must be 0x40 or lower)
|-
|DisassemblePPCRange
|<code>void DisassemblePPCRange(uint32_t *start, uint32_t *end, printf_t printf_func, find_symbol_t sym_func, int flags)</code> 
|Disassemble PPC instructions from start to end, printing them using printf_func() with various flags applied
|}

===Dynamic Linking===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSDynLoad_Acquire
|<code>int OSDynLoad_Acquire(const char *rplname, uint32_t *handle)</code> 
|Acquire a handle to an RPL by name and returns a error code.
|-
|OSDynLoad_IsModuleLoaded
|<code>int OSDynLoad_IsModuleLoaded(const char *rplname, uint32_t *handle)</code> 
|Checks if a module is loaded. If the target module is loaded the function set the existing handle to the module otherwise the handle is not set. Returns a errorcode.
|-
|OSDynLoad_FindExport
|<code>int OSDynLoad_FindExport(uint32_t handle, bool isdata, const char *symname, void **address)</code> 
|Get a symbol address from a loaded RPL and returns a error code.
|-
|OSDynLoad_Release
|<code>void OSDynLoad_Release(uint32_t *handle)</code> 
|Decrease the reference count and release the module if the reference count hit zero. "coreinit.rpl" can´t be released.
|}

Attempting to use OSDynLoad_Acquire() with rplname "nn_uds.rpl" / "test.rpl" (which Internet Browser itself doesn't import) under Internet Browser has the same result: OSDynLoad_Acquire() never returns. Launching a game which uses the former before running Internet Browser has the same result.

===Error===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSFatal
|<code>void OSFatal(const char *msg)</code> 
|Print a message to the screen then halts the system via: OSPanic("OSFatal.c", linenum, OSFatal_inputmsg)
|}

===Internal===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|__os_snprintf
|<code>int __os_snprintf(char *buf, size_t n, const char *format, ... )</code> 
|Format a string and place it in a buffer (just like [http://www.cplusplus.com/reference/cstdio/snprintf/ snprintf()])
|}

===Threads===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSCreateThread
|<code>bool OSCreateThread(OSThread *thread, void (*entry)(int,void*), int argc, void *args, void *stack, size_t stack_size, int32_t priority, int16_t affinity)</code> 
|Create a (initially-paused) thread that starts at the specified entry point
|-
|OSResumeThread
|<code>void OSResumeThread(OSThread *thread)</code>
|Resume a paused thread, causing it to be scheduled
|-
|OSYieldThread
|<code>void OSYieldThread(void)</code>
|Yield control of the CPU, allowing another thread to run
|-
|OSGetCurrentThread
|<code>OSThread *OSGetCurrentThread(void)</code>
|Get the OSThread structure ptr for the current thread
|-
|OSSetThreadName
|<code>void OSSetThreadName(OSThread *thread, char *name)</code>
|Sets a new name for the thread
|-
|OSGetThreadName
|<code>char *OSGetThreadName(OSThread *thread)</code>
|Returns a pointer to the thread's name char array
|-
|OSSetThreadAffinity
|<code>uint32_t OSSetThreadAffinity(OSThread* thread, int16_t affinity)</code>
|Sets the affinity for the specified thread. Returns 0 for failure, 1 for success
|-
|OSGetCoreId
|<code>uint32_t OSGetCoreId(void)</code>
|Returns the PowerPC coreid this code is running on(value of spr1007)
|-
|OSGetStackPointer
|<code>uint32_t *OSGetStackPointer(void)</code>
|Returns the r1 register(aka "sp")
|-
|OSSwitchStack
|<code>void OSSwitchStack(uint32_t *stackptr)</code>
|This basically sets the current thread's r1(aka sp) to the input address, and also calls internal coreinit functions with input_param=input_stackptr. Note that this overwrites data near the start of the specified address due to stack push/pop. This will return to the address LR was set to at function entry
|}

===Codegen===
These functions are used for managing the codegen/JIT area which begins at virtual-memory address 0x01800000. The codegen area size, whether codegen can be used at all, and permissions/etc are loaded from cos.xml for the process. Hence, almost all processes which don't use WebKit don't have access to codegen. These permissions include the coreid which is allowed to use codegen at all(with [[Internet Browser]] this is core1). These permissions also seem to include whether the process is allowed to use OSCodegenCopy([[Internet Browser]] isn't allowed to use it). Certain Virtual Console titles seem to be the only applications which are allowed to use OSCodegenCopy due to cos.xml(codegen_core is set to 40000001 for these, unlike 80000001 for browser-based titles).

{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSGetCodegenVirtAddrRange
|<code>void OSGetCodegenVirtAddrRange(uint32_t *outaddr, uint32_t *outsize)</code>
|This calls syscall 0x4e00 then writes the output r3/r4 from the syscall, to outaddr/outsize. The outaddr value is codegen+0, outsize is the size of the entire codegen memory that's currently mapped. When codegen isn't available, the output values are all-zero.
|-
|OSGetCodegenCore
|<code>uint32_t OSGetCodegenCore(void)</code>
|This returns (syscall_7600() & 0x3), which is the coreid that's allowed to use codegen.
|-
|OSGetCodegenMode
|<code>uint32_t OSGetCodegenMode(void)</code>
|This returns (syscall_7600() & ~0x3), which contains some of the flags used by the kernel for codegen permission checking. The only bits which the kernel can ever set here are for bitmask 0xC0000000.
|-
|OSSwitchSecCodeGenMode
|<code>uint32_t OSSwitchSecCodeGenMode(bool flag)</code>
|This adjusts the entire codegen memory permissions, if codegen is available. 0: RW- permissions. Non-zero: R-X permissions. This returns 0 for failure, non-zero for success.
|-
|OSGetSecCodeGenMode
|<code>uint32_t OSGetSecCodeGenMode(void)</code>
|This just calls syscall 0x7700. Which then returns 1 when codegen is available+mapped, 0 otherwise.
|-
|OSCodegenCopy
|<code>uint32_t OSCodegenCopy(uint32_t *dstaddr, uint32_t *srcaddr, uint32_t size)</code>
|In coreinit this just executes syscall 0x7800. This returns 0 for failure, 1 for success. The dstaddr(+size) must be within the codegen memory(integer overflow with dstaddr+size is checked for). If all of the permissions/bounds checks pass(size must not be zero), the kernel will then set the codegen permissions to RW- with code used by SwitchSecCodeGenMode internally. Then it copies the input data from userland memory to the dstaddr with the specified size. Lastly, the codegen permissions are set to R-X with the previously mentioned internal function.
|}

=== Screen ===
"bufferNum" is the screenid, see the below screen defines for that. OSScreen *only* supports values 0-1 for screenid. "colour" in the form stored in memory is RGBA8. These functions can't be used without crashing, unless OSScreen was properly initialized. The below functions will immediately return if x/y is out-of-bounds.

This uses the hardware registers via the vaddr loaded with __OSPhysicalToEffectiveUncached(0x0C200000). This is the same hardware used for normal framebuffer display with framebuffers rendered by the GPU. The coreinit register r/w access code for this will only access the registers if OSIsECOMode() returns 0(when reading it would always return value 0 if that func-call returns non-zero). Internally the coreinit reg-access functions for this use word-offsets for the registers. The registers are accessed from there with the following: above_vaddr_base + (screenid<<9) + reg_wordoffset.

OSFatal does the following for initializing the framebuffer addresses: "OSScreenSetBufferEx(0, 0xF4000000)" and "OSScreenSetBufferEx(1, 0xF4000000 + OSScreenGetBufferSizeEx(0))".

The framebuffer addresses passed to OSScreenSetBufferEx must be 0x100-byte aligned(bitmask 0xff clear). The byte-size of each scanline in the framebuffers are 0x100-byte aligned as well.

{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSScreenInit
|void OSScreenInit(void)
|This is the main initialization function, this must be called before any of the other OSScreen functions. This includes register writes which will enable framebuffer display, via the same bit OSScreenEnableEx() uses.
|-
|OSScreenShutdown
|void OSScreenShutdown(void)
|This just does the following two function calls: "OSScreenEnableEx(0, 0)" and "OSScreenEnableEx(1, 0)".
|-
|OSScreenEnableEx
|void OSScreenEnableEx(int bufferNum, bool flag)
|flag0: disable framebuffer display(solid-black is displayed instead). flag1: enable framebuffer display. There's no need to call this right after OSScreenInit() for enabling framebuf display, see above.
|-
|OSScreenGetBufferSizeEx
|uint32_t OSScreenGetBufferSizeEx(int bufferNum)
|This returns the total byte-size of the primary+secondary framebuffers for the specified screen(single_framebufsize*2).
|-
|OSScreenSetBufferEx
|void OSScreenSetBufferEx(int bufferNum, uint32_t *vaddr_framebufptr)
|This sets the framebuffer addresses for the specified screen(only in coreinit state). primary_framebuf = vaddr_framebufptr+0, secondary_framebuf = vaddr_framebufptr+single_framebuf_bytesize. The physical framebuffer addresses in hardware won't get updated until OSScreenFlipBuffersEx() is called. This function must be called before using any of the other OSScreen functions with this screen(besides OSScreenEnableEx), otherwise a crash will occur due to the framebuf addrs not being initialized.
|-
|OSScreenFlipBuffersEx
|void OSScreenFlipBuffersEx(int bufferNum)
|Do a buffer-swap, which results in the buffer previously being drawn to being displayed. This flushes data-cache for the framebuffer and updates coreinit + hw-regs state.
|-
|OSScreenClearBufferEx
|void OSScreenClearBufferEx(int bufferNum, uint32_t colour)
|Fill the specified buffer with a certain color. This writes the input u32 value to coreinit screen state, then copies that u32 in state to every u32 in the single framebuffer(calculated with the total bytesize of a single framebuffer).
|-
|OSScreenPutPixelEx
|void OSScreenPutPixelEx(int bufferNum, uint32_t posX, uint32_t posY, uint32_t colour)
|Draw a pixel of a certain color to the specified coordinates. This just writes the input u32 to the target location in the framebuffer, nothing is done with the data already stored in the framebuffer.
|-
|OSScreenPutFontEx
|void OSScreenPutFontEx(int bufferNum, uint32_t posX, uint32_t posY, const char *str)
|Write text to the specified buffer; unlike OSFatal() this doesn't halt your system.
|}

===OSSystem=== <!-- TODO: Find better name?? -->

{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSGetSystemTime
|<code>OSTime OSGetSystemTime(void)</code>
|Gets OSTime (which is just an int64_t) from tbu/tb (timebase upper/lower special purpose registers), same as get_timebase in kernel (FFF099E0 on 5.5.X)
|-
|OSGetTime
|<code>OSTime OSGetTime(void)</code>
|Returns OSTime equal to then number of ticks from 1/1/2000 00:00
|-
|OSTicksToCalendarTime
|<code>void OSTicksToCalendarTime(OSTime time, OSCalendarTime *calendartime)</code>
|Converts OStime to an OSCalendarTime structure
|-
|OSGetSystemInfo
|<code>uint32_t* OSGetSystemInfo(void)</code>
|Returns pointer to OSSystemInfo struct (see below)
|-
|OSIsDebuggerInitialized
|<code>int OSIsDebuggerInitialized(void)</code>
|Returns 1 if [https://en.wikipedia.org/wiki/GNU_Debugger GDB] has been initialized. Default is 0.
|-
|OSIsDebuggerPresent
|<code>uint32_t OSIsDebuggerPresent(void)</code>
|Returns 1 if a debugger is present. Default is 0.
|-
|OSIsInterruptEnabled
|<code>int OSIsInterruptEnabled(void)</code>
|Returns 1 if [https://en.wikipedia.org/wiki/Interrupt interrupts] are enabled. Default is 1.
|-
|OSDisableInterrupts
|<code>int OSDisableInterrupts(void)</code>
|Disables interrupts. Returns 1 on success otherwise, if already disabled, returns 0.
|-
|OSIsAddressValid
|<code>int OSIsAddressValid(int addr)</code>
|Determines whether the given address addr is readable. Returns 1 or 0.
|-
|OSIsHomeButtonMenuEnabled
|<code>int OSIsHomeButtonMenuEnabled(void)</code>
|Whether the home menu button is enabled. Default is 1.
|-
|OSGetConsoleType
|<code>uint32_t OSGetConsoleType(void)</code>
|Returns the console type e.g. 0x03000050.
|-
|OSSleepTicks
|<code>void OSSleepTicks(OSTime)</code>
|Makes the current thread sleep for a specified amount of ticks
|-
|_Exit
|<code>void _Exit(int status)</code>
|Makes the current process exit. Crashes when invoked in titles like Wii U games
|-
|OSEffectiveToPhysical
|<code>uint32_t OSEffectiveToPhysical(uint32_t addr)</code>
|Converts an effective address to its physical representation. For example 0x10000000 becomes 0x50000000
|-
|OSGetPFID
|<code>int OSGetPFID(void)</code>
|Returns the current process PFID e.g. 15 (Game)
|-
|OSGetUPID
|<code>int OSGetUPID(void)</code>
|Does the same as OSGetPFID
|-
|OSGetTitleID
|<code>uint64_t OSGetTitleID(void)</code>
|Returns the current title id e.g. 0x0005000E1010ED00 (Mario Kart 8 EUR). See [http://wiiubrew.org/wiki/Title_database]
|-
|OSGetOSID
|<code>uint64_t OSGetOSID(void)</code>
|Returns the current OS id e.g. 0x000500101000400A (OSv10). See [http://wiiubrew.org/wiki/Title_database]
|-
|__OSGetAppFlags
|<code>uint32_t __OSGetAppFlags(void)</code>
|Returns the flags set for the current app e.g. 0x00000200. Influences the control flow in OSSDKVersionInits
|-
|__OSGetProcessSDKVersion
|<code>uint32_t __OSGetProcessSDKVersion(void)</code>
|Returns the SDK version e.g. 0x000050DF
|-
|OSSDKVersionInits
|<code>? OSSDKVersionInits(?)</code>
|Initializes the OS SDK version using the results from __OSGetAppFlags and __OSGetProcessSDKVersion. Seems to crash when invoked
|-
|OSShutdown
|<code>int OSShutdown(int status)</code>
|Shuts down the console. Behaves identical to holding down the power button. Returns 1 on success
|}

===Boot=== <!-- TODO: Find better name?? -->

{| class="wikitable"
!Name
!Prototype
!Description
|-
|OSIsColdBoot
|<code>int OSIsColdBoot(void)</code>
|Probably allows for [https://en.wikipedia.org/wiki/Cold_boot_attack cold boot attacks]. Default is 0.
|-
|OSIsSelfRefreshBoot
|<code>int OSIsSelfRefreshBoot(void)</code>
|Probably handles [https://en.wikipedia.org/wiki/Memory_refresh memory refreshing]. Default is 0.
|-
|OSIsNormalBoot
|<code>int OSIsNormalBoot(void)</code>
|Determines the boot type (normal and ?). Default is 1.
|-
|OSIsECOBoot
|<code>int OSIsECOBoot(void)</code>
|Whether to save energy (at the expense of processing power). Default is 0.
|-
|OSIsStandbyBoot
|<code>int OSIsStandbyBoot(void)</code>
|Whether the boot is in [https://en.wikipedia.org/wiki/Sleep_mode sleep mode]. Default is 0.
|}

===IOS===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|IOS_Open
|<code>int IOS_Open(char *path, uint32_t mode)</code>
|Gets an handle to an IOS device node at the specified path whith the given mode
|-
|IOS_Close
|<code>int IOS_Close(int fd);</code>
|Closes an handle to an IOS device node fd (returned by IOS_Open)
|-
|IOS_Ioctl
|<code>int IOS_Ioctl(int fd, uint32_t request, void *input_buf, uint32_t input_buf_len, void *output_buf, uint32_t output_buf_len)</code>
|Sends an ioctl request to an IOS device node fd; input_buf contains the input data for the request, output_buf cointains what the request returns 
|}

===MCP===
{| class="wikitable"
!Name
!Prototype
!Description
|-
|MCP_Open
|int MCP_Open()
|Opens an handle to the MCP IOS node
|-
|MCP_Close
|int MCP_Close(int handle)
|Closes an handle to the MCP IOS node
|-
|MCP_DeviceList
|int MCP_DeviceList(int handle, int *numDevices, MCPDeviceList *outDevices, uint32_t outBufferSize)
|Gets a list of available devices
|-
|MCP_FullDeviceList
|int MCP_FullDeviceList(int handle, int *numDevices, MCPDeviceList *outDevices, uint32_t outBufferSize)
|Gets the full list of available devices
|-
|MCP_InstallSetTargetDevice
|int MCP_InstallSetTargetDevice(int handle, MCPInstallTarget device)
|Sets the the target device for title installation
|-
|MCP_InstallGetTargetDevice
|int MCP_InstallGetTargetDevice(int handle, MCPInstallTarget *deviceOut)
|Gets the target device for title installation
|-
|MCP_InstallSetTargetUsb
|int MCP_InstallSetTargetUsb(int handle, int usb)
|Sets the target USB device for installation
|-
|MCP_InstallGetInfo
|int MCP_InstallGetInfo(int handle, char *path, MCPInstallInfo *out)
|Gets informations about the install operation
|-
|MCP_InstallTitleAsync
|int MCP_InstallTitleAsync(int handle, char *path, MCPInstallInfo *out)
|Installs a title
|-
|MCP_InstallGetProgress
|int MCP_InstallGetProgress(int handle, MCPInstallProgress *installProgressOut)
|Gets installation progress
|-
|MCP_InstallTitleAbort
|int MCP_InstallTitleAbort(int handle)
|Aborts the installation of a title
|-
|MCP_UninstallTitleAsync
|int MCP_UninstallTitleAsync(int handle, char *path, MCPInstallInfo *out)
|Uninstalls a title
|}

==Filesystem==
The FS* functions appear to only be used by regular applications, while the FSA* functions appear to only be used by system rpls.
===Setup===
{| class="wikitable"
!Name
!Signature
!Description
!Notes
|-
|FSInit
|<code>void FSInit(void)</code> 
|Initializes the FS library
|Must be called before anything else! Can be called multiple times safely.
|-
|FSShutdown
|<code>void FSShutdown(void)</code>
|Deinitializes the FS library
|The current implementation of this function doesn't do anything.
|-
|FSAddClient
|<code>FSStatus FSAddClient(FSClient *client, FSRetflag flag)</code>
|Registers a new client for use
|Returns OK or MAX_CLIENTS(-3). Client size is 0x1700 bytes, should be 0x20 byte padded.
|-
|FSDelClient
|<code>FSStatus FSDelClient(FSClient *client, FSRetflag flag)</code>
|Unregisters an existing client
|See above for data size. The current implementation of this function never fails.
|-
|FSGetClientNum
|<code>int FSGetClientNum(void)</code>
|Gets the number of registered clients
|
|}

===Command Blocks===
{| class="wikitable"
!Name
!Prototype
!Description
!Notes
|-
|FSInitCmdBlock
|<code>void FSInitCmdBlock(FSCmdBlock *block)</code>
|Initializes a command block for use.
|Command Block size is 0xA80 bytes, should be 0x20 byte padded.
|-
|FSCancelCommand
|<code>void FSCancelCommand(FSClient *client, FSCmdBlock *block)</code>
|Cancels the pending command
|Cannot cancel an ongoing command, it has to complete.
|-
|FSCancelAllCommands
|<code>void FSCancelAllCommands(FSClient *client)
|Cancels all pending commands for the passed client.
|Cannot cancel an ongoing command, it has to complete.
|-
|FSSetUserData
|<code>void FSSetUserData(FSCmdBlock *block, void *user_data)</code>
|Sets the user data for the passed command block
|
|-
|FSGetUserData
|<code>void* FSGetUserData(FSCmdBlock *block)</code>
|Returns pointer to the user data
|Can return NULL if invalid, please error check.
|-
|FSSetCmdPriority
|<code>void FSSetCmdPriority(FSCmdBlock *block, uint8_t priority)</code>
|Sets the priority for the passed command block
|Priority 0 is highest, 31 is lowest, 16 is default.
|-
|FSGetCmdPriority
|<code>int FSGetCmdPriority(FSCmdBlock *block)</code>
|Gets the priority for the passed command block
|Priority 0 is highest, 31 is lowest, 16 is default.
|-
|FSGetCurrentCmdBlock
|<code>FSCmdBlock* FSGetCurrentCmdBlock(FSClient *client)
|Returns a pointer to the command block being processed.
|May return NULL if invalid client or if nothing's processed, please error check.
|}

===File Commands===
{| class="wikitable"
!Name
!Prototype
!Description
!Return Values: 0=FS_STATUS_OK -or- <0=[[#Defines| Error Codes]]
!Notes
|-
|FSOpenFile
|<code>FSStatus FSOpenFile( FSClient *client, FSCmdBlock *block, const char *path, const char *mode, FSFileHandle *fileHandle, FSRetFlag errHandling );
|Open file stream
| -1 -3 -4 -6 -7 -8 -9 -10 -12 -13 -15 -17 -18 -19
| 
|-
|FSCloseFile
|<code>FSStatus FSCloseFile( FSClient *client, FSCmdBlock *block, FSFileHandle fileHandle, FSRetFlag errHandling );
|Close file stream.
| -1 -17
|
|-
|FSReadFile
|<code>FSStatus FSReadFile( FSClient *client, FSCmdBlock *block, void *dest, FSSize size, FSCount count, FSFileHandle fileHandle, FSFlag flag, FSRetFlag errHandling );
|Read data from an open file.
|Non-negative value ( >= 0 ) = Number of elements read or -1 -9 -15 -17 -18 
|
|-
|FSWriteFile
|<code>FSStatus FSWriteFile( FSClient *client, FSCmdBlock *block, const void *source, FSSize size, FSCount count, FSFileHandle fileHandle, FSFlag flag, FSRetFlag errHandling ); 
|Write data to file
|Non-negative value ( >= 0 ) = Number of elements write or -1 -9 -11 -12 -13 -14 -15 -17 -18
|
|-
|FSAppendFile
|<code>FSStatus FSAppendFile( FSClient *client, FSCmdBlock *block, FSSize size, FSCount count, FSFileHandle fileHandle, FSRetFlag errHandling );
|Append file.
|Non-negative value ( >= 0 ) = Newly appended size (newly added preallocation area [Byte] divided by size) or -1 -9 -11 -12 -13 -15 -17 -18 -19
|
|-
|FSTruncateFile
|<code>FSStatus FSTruncateFile( FSClient *client, FSCmdBlock *block, FSFileHandle fileHandle, FSRetFlag errHandling );
|Truncate file at file position
| -1 -9 -12 -13 -14 -15 -17 -18 
|
|-
|FSFlushFile
|<code>FSStatus FSFlushFile( FSClient *client, FSCmdBlock *block, FSFileHandle fileHandle, FSRetFlag errHandling );
|Flush file.
| -1 -9 -15 -17 -18
|
|-
|FSGetPosFile
|<code>FSStatus FSGetPosFile( FSClient *client, FSCmdBlock *block, FSFileHandle fileHandle, FSFilePosition *returnedFpos, FSRetFlag errHandling );
|Get position of specified file stream.
| -1 -15 -17 -18
|
|-
|FSSetPosFile
|<code>FSStatus FSSetPosFile( FSClient *client, FSCmdBlock *block, FSFileHandle fileHandle, FSFilePosition fpos, FSRetFlag errHandling );
|Set position of specified file stream
| -1 -15 -17 -18
|
|-
|FSGetStatFile
|<code>FSStatus FSGetStatFile( FSClient *client, FSCmdBlock *block, FSFileHandle fileHandle, FSStat *returnedStat, FSRetFlag errHandling );
|Get stat information of specified file.
| -1 -15 -17 -18
|
|-
|FSIsEof
|<code>FSStatus FSIsEof( FSClient *client, FSCmdBlock *block, FSFileHandle fileHandle, FSRetFlag errHandling );
|Determine if the current file position of specified file stream is at the end-of-file(EOF).
| -1 -2 -15 -17 -18
|
|-
|FSOpenDir
|<code>FSStatus FSOpenDir( FSClient *client, FSCmdBlock *block, const char *path, FSDirHandle *dirHandle, FSRetFlag errHandling );
|Open directory stream
| -1 -3 -6 -8 -10 -15 -17 -18
|
|-
|FSCloseDir
|<code>FSStatus FSCloseDir( FSClient *client, FSCmdBlock *block, FSDirHandle dirHandle, FSRetFlag errHandling );
|Close directory stream.
| -1 -17
|
|-
|FSReadDir
|<code>FSStatus FSReadDir( FSClient *client, FSCmdBlock *block, FSDirHandle dirHandle, FSDirEntry *returnedDirEntry, FSRetFlag errHandling );
|Read next directory entry.
| -1 -2 -15 -17 -18
|
|-
|FSRewindDir
|<code>FSStatus FSRewindDir( FSClient *client, FSCmdBlock *block, FSDirHandle dirHandle, FSRetFlag errHandling );
|Set position of specified directory stream to the head.
| -1 -2 -15 -17 -18
|
|-
|FSGetCwd
|<code>FSStatus FSGetCwd( FSClient *client, FSCmdBlock *block, char *returnedPath, u32 bytes, FSRetFlag errHandling );
|Get current work directory.
| -1
|
|-
|FSMakeDir
|<code>FSStatus FSMakeDir( FSClient *client, FSCmdBlock *block, const char*path, FSRetFlag errHandling );
|Create directory.
| -1 -5 -6 -8 -10 -12 -13 -14 -17 -18 -19  
|
|-
|FSRemove
|<code>FSStatus FSRemove( FSClient *client, FSCmdBlock *block, const char *path, FSRetFlag errHandling );
|Remove file or directory.
| -1 -4 -6 -8 -9 -10 -12 -13 -14 -15 -17 -18 -19 
|
|-
|FSRename
|<code>FSStatus FSRename( FSClient *client, FSCmdBlock *block, const char *oldpath, const char *newpath, FSRetFlag errHandling );
|Rename file or directory.
| -1 -4 -5 -6 -8 -10 -12 -13 -14 -15 -17 -18 -19
|
|-
|FSFlushQuota
|<code>FSStatus FSFlushQuota( FSClient *client, FSCmdBlock *block, const char *path, FSRetFlag errHandling );
|Flush journaling data of quota.
| -1 -6 -14 -15 -17 -18 -19
|
|-
|FSRollbackQuota
|<code>FSStatus FSRollbackQuota( FSClient *client, FSCmdBlock *block, const char *path, FSRetFlag errHandling );
|Rollback journaling data of quota.
| -1 -4 -6 -14 -15 -17 -18
|
|-
|FSGetStat
|<code>FSStatus FSGetStat( FSClient *client, FSCmdBlock *block, const char *path, FSStat *returnedStat, FSRetFlag errHandling );
|Get stat information of specified entry.
| -1 -6 -10 -15 -16 -18 -19
|
|-
|FSGetFreeSpaceSize
|<code>FSStatus FSGetFreeSpaceSize( FSClient *client, FSCmdBlock *block, const char *path, FSFreeSpaceSize *returnedFreeSize, FSRetFlag errHandling );
|Get free space size in quota.
| -1 -6 -10 -15 -17 -18
|
|-
|}

== Structures ==
=== Threads ===

{| class="wikitable"
!Name
!Prototype

|-
|OSThreadQueue
|
<syntaxhighlight lang="C">
typedef struct {
    /* 0x00 */ OSThread* headThread;
    /* 0x04 */ OSThread* tailThread;
    /* 0x08 */ void* parent;
    /* 0x0C */ uint32_t _unknown0C;
} OSThreadQueue;                          /* 0x10 total length */
</syntaxhighlight>
|


|-
|OSThreadLink
|
<syntaxhighlight lang="C">
typedef struct {
    /* 0x00 */ OSThread* next;
    /* 0x04 */ OSThread* prev;
} OSThreadLink;                           /* 0x8 total length */
</syntaxhighlight>
|

|-
|OSContext
|
<syntaxhighlight lang="C">
typedef struct {
    /* 0x000 */ char     contextTag[8];          /* "OSContxt" */
    /* 0x008 */ int32_t  gpr[32];                /* ppc general purpose registers */
    /* 0x088 */ uint32_t cr;                     /* conditional register */
    /* 0x08c */ uint32_t lr;                     /* link register (SPR 8) */
    /* 0x090 */ uint32_t ctr;                    /* counter register (SPR 9) */
    /* 0x094 */ uint32_t xer;                    /* fixed-point exception register */
    /* 0x098 */ uint32_t srr0;                   /* machine status restore register 0, used to store instruction pointer */
    /* 0x09c */ uint32_t srr1;                   /* machine status restore register 1, ? */
    /* 0x0a0 */ uint32_t _unknown0A0;
    /* 0x0a4 */ uint32_t _unknown0A4;
    /* 0x0a8 */ uint32_t _unused0A8;
    /* 0x0ac */ uint32_t _unused0AC;
    /* 0x0b0 */ uint32_t fpscr_high;             /* floating point status & control register */
    /* 0x0b4 */ uint32_t fpscr_low;              /* floating point status & control register */
    /* 0x0b8 */ uint64_t fpr[32];                /* FPR double registers */
    /* 0x1b8 */ uint16_t spinLockCount;          /* counts number of acquired spinlocks? */
    /* 0x1ba */ uint16_t contextState;           /* purpose unknown, there is another state variable for threading logic */
    /* 0x1bc */ uint32_t ugqr[8];                /* user-mode graphics quantization registers (controls paired single load/store) */
    /* 0x1dc */ uint32_t pir;
    /* 0x1e0 */ uint64_t psf[32];                /* FPR registers (paired-single mode) */
    /* 0x2e0 */ int64_t  coretime[3];            /* number of cycles context was active per core? */
    /* 0x2f8 */ int64_t  starttime;              /* set on context creation to value of OSGetSystemTime() */
    /* 0x300 */ int32_t  error;                  /* used by OSGetLastError() and __OSSetLastError() */
    /* 0x304 */ uint32_t attributes;             /* contains per-context flags and affinity, similar to OSThread.attr */
    /* 0x308 */ uint32_t pmc1;
    /* 0x30C */ uint32_t pmc2;
    /* 0x310 */ uint32_t pmc3;
    /* 0x314 */ uint32_t pmc4;
    /* 0x318 */ uint32_t mmcr0;
    /* 0x31C */ uint32_t mmcr1;
} OSContext;                          /* 0x320 total length */
</syntaxhighlight>
|

|-
|OSThread
|
<syntaxhighlight lang="C">
typedef struct {
    /* 0x000 */ OSContext context;
    /* 0x320 */ uint32_t threadTag;              /* "tHrD" */
    /* 0x324 */ uint8_t  state;                  /* Thread state (0 None, 1 Ready, 2 Running, 4 Waiting, 8 Dead) */
    /* 0x325 */ uint8_t  attr;                   /* Thread affinity (bits 0-2) and flags */
    /* 0x326 */ int16_t  threadId;
    /* 0x328 */ int32_t  suspend;                /* suspend counter, thread is suspended if greater zero */
    /* 0x32C */ int32_t  priority;               /* effective priority */
    /* 0x330 */ int32_t  base;                   /* base priority, set on thread creation or via OSSetThreadPriority */
    /* 0x334 */ int32_t  val;                    /* thread exit value */
    /* 0x338 */ void*    runQueue[3];
    /* 0x344 */ OSThreadLink linkRun[3];
    /* 0x35C */ void*    queue;
    /* 0x360 */ OSThreadLink link;
    /* 0x368 */ OSThreadQueue queueJoin;	
    /* 0x378 */ void*    mutex;
    /* 0x37C */ OSMutexQueue queueMutex;
    /* 0x38C */ OSThreadLink linkActive; 
    /* 0x394 */ void*    stackBase;              /* high addr of stack area */
    /* 0x398 */ void*    stackEnd;               /* low addr of stack area */
    /* 0x39C */ void*    entryPoint;             /* initial entry point */
    /* 0x3A0 */ __crt    crt;                    /* used by GHS runtime */
    /* 0x578 */ int32_t  _unused578;
    /* 0x57C */ void*    specific[16];           /* used by OSSetThreadSpecific/OSGetThreadSpecific */
    /* 0x5BC */ int32_t  type;                   /* thread type (0 driver, 1 I/O, 2 application) */
    /* 0x5C0 */ char*    name;
    /* 0x5C4 */ void*    waitAlarm;
    /* 0x5C8 */ void*    userStackPointer;       /* initial stack pointer */
    /* 0x5CC */ void*	 cleanupCallback;
    /* 0x5D0 */ void(*deallocator)(OSThread* t, void* stack) /* called on thread termination */
    /* 0x5D4 */ uint32_t cancelState;
    /* 0x5D8 */ uint32_t requestFlag;            /* flags for state change request after timeslice finished */
    /* 0x5DC */ int32_t  pendingSuspend;
    /* 0x5E0 */ int32_t  suspendResult;
    /* 0x5E4 */ OSThreadQueue suspendQueue;
    /* 0x5F4 */ uint32_t _padding5F4;
    /* 0x5F8 */ uint64_t quantum; /* set by OSSetThreadRunQuantum, defines how long the thread will run before being rescheduled */
    /* 0x600 */ uint64_t _unknown600;
    /* 0x608 */ uint64_t wakeCount;
    /* 0x610 */ uint64_t _unknown610;
    /* 0x618 */ uint64_t awakeTimeSum;
    /* 0x620 */ uint64_t _unknown620;
    /* 0x628 */ uint64_t _unknown628;
    /* 0x630 */ char     _unknown630[0x6a0 - 0x630];
} OSThread;                          /* 0x6a0 total length */
</syntaxhighlight>
|}

===System Info===
{| class="wikitable"
!Name
!Prototype
|-
|OSSystemInfo
|
<syntaxhighlight lang="C">
typedef struct {
    /* 0x00 */ uint32_t busClockSpeed;
    /* 0x04 */ uint32_t coreClockSpeed;
    /* 0x08 */ OSTime   timeBase;
    /* 0x0C */ uint32_t L2Size[3];
    /* 0x18 */ uint32_t cpuRatio;
} OSSystemInfo;
</syntaxhighlight>
|}

===Filesystem===
<syntaxhighlight lang="C">
typedef struct {uint8_t buffer[FS_CLIENT_BUFFER_SIZE];} FSClient;
typedef struct {uint8_t buffer[FS_CMD_BLOCK_SIZE];} FSCmdBlock;

typedef enum {
    FS_VOLSTATE_INITIAL = 0,
    FS_VOLSTATE_READY,
	
    FS_VOLSTATE_NO_MEDIA,
	
    FS_VOLSTATE_INVALID_MEDIA,
    FS_VOLSTATE_DIRTY_MEDIA,
    FS_VOLSTATE_WRONG_MEDIA,
    FS_VOLSTATE_MEDIA_ERROR,
    FS_VOLSTATE_DATA_CORRUPTED,
    FS_VOLSTATE_WRITE_PROTECTED,
	
    FS_VOLSTATE_JOURNAL_FULL,
    FS_VOLSTATE_FATAL,
	
    FS_VOLSTATE_INVALID
} FSVolumeState;
</syntaxhighlight>

== Defines ==
===Filesystem===
<syntaxhighlight lang="C">
#define FS_CLIENT_BUFFER_SIZE   (5888) /* 0x1700 */
#define FS_CMD_BLOCK_SIZE       (2688) /* 0xA80 */

#define FS_STATUS_OK                0 /* Everything looks good */

#define FS_STATUS_BASE              (0)

#define FS_STATUS_CANCELED          (FS_STATUS_BASE - 1)
#define FS_STATUS_END               (FS_STATUS_BASE - 2)

#define FS_STATUS_MAX               (FS_STATUS_BASE - 3)
#define FS_STATUS_ALREADY_OPEN      (FS_STATUS_BASE - 4)
#define FS_STATUS_EXISTS            (FS_STATUS_BASE - 5)
#define FS_STATUS_NOT_FOUND         (FS_STATUS_BASE - 6)
#define FS_STATUS_NOT_FILE          (FS_STATUS_BASE - 7)
#define FS_STATUS_NOT_DIR           (FS_STATUS_BASE - 8)
#define FS_STATUS_ACCESS_ERROR      (FS_STATUS_BASE - 9)
#define FS_STATUS_PERMISSION_ERROR  (FS_STATUS_BASE -10)
#define FS_STATUS_FILE_TOO_BIG      (FS_STATUS_BASE -11)
#define FS_STATUS_STORAGE_FULL      (FS_STATUS_BASE -12)
#define FS_STATUS_JOURNAL_FULL      (FS_STATUS_BASE -13)
#define FS_STATUS_UNSUPPORTED_CMD   (FS_STATUS_BASE -14)

#define FS_STATUS_MEDIA_NOT_READY   (FS_STATUS_BASE -15)
#define FS_STATUS_INVALID_MEDIA     (FS_STATUS_BASE -16)
#define FS_STATUS_MEDIA_ERROR       (FS_STATUS_BASE -17)
#define FS_STATUS_DATA_CORRUPTED    (FS_STATUS_BASE -18)
#define FS_STATUS_WRITE_PROTECTED   (FS_STATUS_BASE -19)

#define FS_STATUS_FATAL_ERROR       (FS_STATUS_BASE -1024)

#define FS_RET_NO_ERROR         0x0000
#define FS_RET_MAX              0x0001
#define FS_RET_ALREADY_OPEN     0x0002
#define FS_RET_EXISTS           0x0004
#define FS_RET_NOT_FOUND        0x0008
#define FS_RET_NOT_FILE         0x0010
#define FS_RET_NOT_DIR          0x0020
#define FS_RET_ACCESS_ERROR     0x0040
#define FS_RET_PERMISSION_ERROR 0x0080
#define FS_RET_FILE_TOO_BIG     0x0100
#define FS_RET_STORAGE_FULL     0x0200
#define FS_RET_UNSUPPORTED_CMD  0x0400
#define FS_RET_JOURNAL_FULL     0x0800

#define FS_ERROR_BASE                   (-196608)           /* 0xFFFD0000 */
#define FS_ERROR_LIB_NOT_INIT           (FS_ERROR_BASE - 1)
#define FS_ERROR_INVALID_CLIENT_HANDLE  (FS_ERROR_BASE -37) /* ??? */
</syntaxhighlight>

=== Disassembler ===
printf_func() and find_symbol() have the following types:
<syntaxhighlight lang="C">
typedef int (*printf_t)(char *fmt, ...);
typedef uint32_t (*find_symbol_t)(uint32_t addr, char *name_buf, int name_len);
</syntaxhighlight>

The flags argument of DisassemblePPCRange() and DisassemblePPCOpcode() is a bitmask of the following options:
<syntaxhighlight lang="C">
#define DISASM_OMIT_ADDR      0x40     /* Don't print the address of the instruction */
#define DISASM_OMIT_OPCODE    0x80     /* Don't print the opcode of the instruction */
#define DISASM_GETSYM         0x100    /* Print the nearest symbol and the instruction's offset from it */
</syntaxhighlight>

===OSSystem===
<syntaxhighlight lang="C">
#define OSTime int64_t /* stored in timebase upper/lower */

typedef struct {
    int sec;
    int min;
    int hour;
    int mday;
    int mon;
    int year;
    int wday;
    int yday;
    int msec;
    int usec;
} OSCalendarTime;
</syntaxhighlight>

===OSDriver===
<syntaxhighlight lang="C">
#define OSDRIVER_SIZE 0x4c

typedef struct OSDriver {

  char drv_name[0x40];   // 0x00 - 0x40
  uint32_t unknown;      // 0x40 - 0x44
  uint32_t *save_area;   // 0x44 - 0x48
  struct OSDriver *next; // 0x48 - 0x4c

} OSDriver;
</syntaxhighlight>

I have no idea if registering an OSDriver return his struct pointer, i can't test it, my Wii U is bricked [[User:NexoCube|NexoCube]] ([[User talk:NexoCube|talk]]) 11:56, 19 March 2017 (CET)

=== Screen ===
{| class="wikitable"
!Name
!Value
!Description
|-
|SCREEN_BUF_TV
|0
|The buffer number for the TV
|-
|SCREEN_BUF_DRC0
|1
|The buffer number for the first Gamepad
|}

=== MCP ===
<syntaxhighlight lang="C">
typedef enum MCPInstallTarget {
   MCP_INSTALL_TARGET_MLC  = 0,
   MCP_INSTALL_TARGET_USB  = 1,
} MCPInstallTarget;

typedef struct MCPInstallProgress {
   uint32_t inProgress;
   uint64_t tid;
   uint64_t sizeTotal;
   uint64_t sizeProgress;
   uint32_t contentsTotal;
   uint32_t contentsProgress;
} MCPInstallProgress;

typedef struct MCPInstallInfo {
   char unknown[0x27F];
} MCPInstallInfo;

typedef struct MCPDevice {
   char name[0x31B];
} MCPDevice;

typedef struct MCPDeviceList {
   MCPDevice devices[32];
} MCPDeviceList;
</syntaxhighlight>