libnx v4.9.0
Loading...
Searching...
No Matches
svc.h
Go to the documentation of this file.
1/**
2 * @file svc.h
3 * @brief Wrappers for kernel syscalls.
4 * @copyright libnx Authors
5 */
6#pragma once
7#include "../types.h"
8#include "../arm/thread_context.h"
9
10/// Pseudo handle for the current process.
11#define CUR_PROCESS_HANDLE 0xFFFF8001
12
13/// Pseudo handle for the current thread.
14#define CUR_THREAD_HANDLE 0xFFFF8000
15
16/// Maximum number of objects that can be waited on by \ref svcWaitSynchronization (Horizon kernel limitation).
17#define MAX_WAIT_OBJECTS 0x40
18
19/// Memory type enumeration (lower 8 bits of \ref MemoryState)
20typedef enum {
21 MemType_Unmapped=0x00, ///< Unmapped memory.
22 MemType_Io=0x01, ///< Mapped by kernel capability parsing in \ref svcCreateProcess.
23 MemType_Normal=0x02, ///< Mapped by kernel capability parsing in \ref svcCreateProcess.
24 MemType_CodeStatic=0x03, ///< Mapped during \ref svcCreateProcess.
25 MemType_CodeMutable=0x04, ///< Transition from MemType_CodeStatic performed by \ref svcSetProcessMemoryPermission.
26 MemType_Heap=0x05, ///< Mapped using \ref svcSetHeapSize.
27 MemType_SharedMem=0x06, ///< Mapped using \ref svcMapSharedMemory.
28 MemType_WeirdMappedMem=0x07, ///< Mapped using \ref svcMapMemory.
29 MemType_ModuleCodeStatic=0x08, ///< Mapped using \ref svcMapProcessCodeMemory.
30 MemType_ModuleCodeMutable=0x09, ///< Transition from \ref MemType_ModuleCodeStatic performed by \ref svcSetProcessMemoryPermission.
31 MemType_IpcBuffer0=0x0A, ///< IPC buffers with descriptor flags=0.
32 MemType_MappedMemory=0x0B, ///< Mapped using \ref svcMapMemory.
33 MemType_ThreadLocal=0x0C, ///< Mapped during \ref svcCreateThread.
34 MemType_TransferMemIsolated=0x0D, ///< Mapped using \ref svcMapTransferMemory when the owning process has perm=0.
35 MemType_TransferMem=0x0E, ///< Mapped using \ref svcMapTransferMemory when the owning process has perm!=0.
36 MemType_ProcessMem=0x0F, ///< Mapped using \ref svcMapProcessMemory.
37 MemType_Reserved=0x10, ///< Reserved.
38 MemType_IpcBuffer1=0x11, ///< IPC buffers with descriptor flags=1.
39 MemType_IpcBuffer3=0x12, ///< IPC buffers with descriptor flags=3.
40 MemType_KernelStack=0x13, ///< Mapped in kernel during \ref svcCreateThread.
41 MemType_CodeReadOnly=0x14, ///< Mapped in kernel during \ref svcControlCodeMemory.
42 MemType_CodeWritable=0x15, ///< Mapped in kernel during \ref svcControlCodeMemory.
43 MemType_Coverage=0x16, ///< Not available.
44 MemType_Insecure=0x17, ///< Mapped in kernel during \ref svcMapInsecurePhysicalMemory.
46
47/// Memory state bitmasks.
48typedef enum {
49 MemState_Type=0xFF, ///< Type field (see \ref MemoryType).
50 MemState_PermChangeAllowed=BIT(8), ///< Permission change allowed.
51 MemState_ForceRwByDebugSyscalls=BIT(9), ///< Force read/writable by debug syscalls.
52 MemState_IpcSendAllowed_Type0=BIT(10), ///< IPC type 0 send allowed.
53 MemState_IpcSendAllowed_Type3=BIT(11), ///< IPC type 3 send allowed.
54 MemState_IpcSendAllowed_Type1=BIT(12), ///< IPC type 1 send allowed.
55 MemState_ProcessPermChangeAllowed=BIT(14), ///< Process permission change allowed.
56 MemState_MapAllowed=BIT(15), ///< Map allowed.
57 MemState_UnmapProcessCodeMemAllowed=BIT(16), ///< Unmap process code memory allowed.
58 MemState_TransferMemAllowed=BIT(17), ///< Transfer memory allowed.
59 MemState_QueryPAddrAllowed=BIT(18), ///< Query physical address allowed.
60 MemState_MapDeviceAllowed=BIT(19), ///< Map device allowed (\ref svcMapDeviceAddressSpace and \ref svcMapDeviceAddressSpaceByForce).
61 MemState_MapDeviceAlignedAllowed=BIT(20), ///< Map device aligned allowed.
62 MemState_IpcBufferAllowed=BIT(21), ///< IPC buffer allowed.
63 MemState_IsPoolAllocated=BIT(22), ///< Is pool allocated.
64 MemState_IsRefCounted=MemState_IsPoolAllocated, ///< Alias for \ref MemState_IsPoolAllocated.
65 MemState_MapProcessAllowed=BIT(23), ///< Map process allowed.
66 MemState_AttrChangeAllowed=BIT(24), ///< Attribute change allowed.
67 MemState_CodeMemAllowed=BIT(25), ///< Code memory allowed.
69
70/// Memory attribute bitmasks.
71typedef enum {
72 MemAttr_IsBorrowed=BIT(0), ///< Is borrowed memory.
73 MemAttr_IsIpcMapped=BIT(1), ///< Is IPC mapped (when IpcRefCount > 0).
74 MemAttr_IsDeviceMapped=BIT(2), ///< Is device mapped (when DeviceRefCount > 0).
75 MemAttr_IsUncached=BIT(3), ///< Is uncached.
76 MemAttr_IsPermissionLocked=BIT(4), ///< Is permission locked.
78
79/// Memory permission bitmasks.
80typedef enum {
81 Perm_None = 0, ///< No permissions.
82 Perm_R = BIT(0), ///< Read permission.
83 Perm_W = BIT(1), ///< Write permission.
84 Perm_X = BIT(2), ///< Execute permission.
85 Perm_Rw = Perm_R | Perm_W, ///< Read/write permissions.
86 Perm_Rx = Perm_R | Perm_X, ///< Read/execute permissions.
87 Perm_DontCare = BIT(28), ///< Don't care
89
90/// Memory information structure.
91typedef struct {
92 u64 addr; ///< Base address.
93 u64 size; ///< Size.
94 u32 type; ///< Memory type (see lower 8 bits of \ref MemoryState).
95 u32 attr; ///< Memory attributes (see \ref MemoryAttribute).
96 u32 perm; ///< Memory permissions (see \ref Permission).
97 u32 ipc_refcount; ///< IPC reference count.
98 u32 device_refcount; ///< Device reference count.
99 u32 padding; ///< Padding.
100} MemoryInfo;
101
102/// Physical memory information structure.
103typedef struct {
104 u64 physical_address; ///< Physical address.
105 u64 virtual_address; ///< Virtual address.
106 u64 size; ///< Size.
108
109/// Secure monitor arguments.
110typedef struct {
111 u64 X[8]; ///< Values of X0 through X7.
113
114/// Break reasons
115typedef enum {
116 BreakReason_Panic = 0,
117 BreakReason_Assert = 1,
118 BreakReason_User = 2,
119 BreakReason_PreLoadDll = 3,
120 BreakReason_PostLoadDll = 4,
121 BreakReason_PreUnloadDll = 5,
122 BreakReason_PostUnloadDll = 6,
123 BreakReason_CppException = 7,
124
125 BreakReason_NotificationOnlyFlag = 0x80000000,
127
128/// Code memory mapping operations
129typedef enum {
130 CodeMapOperation_MapOwner=0, ///< Map owner.
131 CodeMapOperation_MapSlave=1, ///< Map slave.
132 CodeMapOperation_UnmapOwner=2, ///< Unmap owner.
133 CodeMapOperation_UnmapSlave=3, ///< Unmap slave.
135
136/// Limitable Resources.
137typedef enum {
138 LimitableResource_Memory=0, ///<How much memory can a process map.
139 LimitableResource_Threads=1, ///<How many threads can a process spawn.
140 LimitableResource_Events=2, ///<How many events can a process have.
141 LimitableResource_TransferMemories=3, ///<How many transfer memories can a process make.
142 LimitableResource_Sessions=4, ///<How many sessions can a process own.
144
145/// Thread Activity.
146typedef enum {
147 ThreadActivity_Runnable = 0, ///< Thread can run.
148 ThreadActivity_Paused = 1, ///< Thread is paused.
150
151/// Process Information.
152typedef enum {
153 ProcessInfoType_ProcessState=0, ///<What state is a process in.
155
156/// Process States.
157typedef enum {
158 ProcessState_Created=0, ///<Newly-created process, not yet started.
159 ProcessState_CreatedAttached=1, ///<Newly-created process, not yet started but attached to debugger.
160 ProcessState_Running=2, ///<Process that is running normally (and detached from any debugger).
161 ProcessState_Crashed=3, ///<Process that has just crashed.
162 ProcessState_RunningAttached=4, ///<Process that is running normally, attached to a debugger.
163 ProcessState_Exiting=5, ///<Process has begun exiting.
164 ProcessState_Exited=6, ///<Process has finished exiting.
165 ProcessState_DebugSuspended=7, ///<Process execution suspended by debugger.
167
168/// Process Activity.
169typedef enum {
170 ProcessActivity_Runnable = 0, ///< Process can run.
171 ProcessActivity_Paused = 1, ///< Process is paused.
173
174/// Debug Thread Parameters.
175typedef enum {
176 DebugThreadParam_ActualPriority=0,
177 DebugThreadParam_State=1,
178 DebugThreadParam_IdealCore=2,
179 DebugThreadParam_CurrentCore=3,
180 DebugThreadParam_CoreMask=4,
182
183/// GetInfo IDs.
184typedef enum {
185 InfoType_CoreMask = 0, ///< Bitmask of allowed Core IDs.
186 InfoType_PriorityMask = 1, ///< Bitmask of allowed Thread Priorities.
187 InfoType_AliasRegionAddress = 2, ///< Base of the Alias memory region.
188 InfoType_AliasRegionSize = 3, ///< Size of the Alias memory region.
189 InfoType_HeapRegionAddress = 4, ///< Base of the Heap memory region.
190 InfoType_HeapRegionSize = 5, ///< Size of the Heap memory region.
191 InfoType_TotalMemorySize = 6, ///< Total amount of memory available for process.
192 InfoType_UsedMemorySize = 7, ///< Amount of memory currently used by process.
193 InfoType_DebuggerAttached = 8, ///< Whether current process is being debugged.
194 InfoType_ResourceLimit = 9, ///< Current process's resource limit handle.
195 InfoType_IdleTickCount = 10, ///< Number of idle ticks on CPU.
196 InfoType_RandomEntropy = 11, ///< [2.0.0+] Random entropy for current process.
197 InfoType_AslrRegionAddress = 12, ///< [2.0.0+] Base of the process's address space.
198 InfoType_AslrRegionSize = 13, ///< [2.0.0+] Size of the process's address space.
199 InfoType_StackRegionAddress = 14, ///< [2.0.0+] Base of the Stack memory region.
200 InfoType_StackRegionSize = 15, ///< [2.0.0+] Size of the Stack memory region.
201 InfoType_SystemResourceSizeTotal = 16, ///< [3.0.0+] Total memory allocated for process memory management.
202 InfoType_SystemResourceSizeUsed = 17, ///< [3.0.0+] Amount of memory currently used by process memory management.
203 InfoType_ProgramId = 18, ///< [3.0.0+] Program ID for the process.
204 InfoType_InitialProcessIdRange = 19, ///< [4.0.0-4.1.0] Min/max initial process IDs.
205 InfoType_UserExceptionContextAddress = 20, ///< [5.0.0+] Address of the process's exception context (for break).
206 InfoType_TotalNonSystemMemorySize = 21, ///< [6.0.0+] Total amount of memory available for process, excluding that for process memory management.
207 InfoType_UsedNonSystemMemorySize = 22, ///< [6.0.0+] Amount of memory used by process, excluding that for process memory management.
208 InfoType_IsApplication = 23, ///< [9.0.0+] Whether the specified process is an Application.
209 InfoType_FreeThreadCount = 24, ///< [11.0.0+] The number of free threads available to the process's resource limit.
210 InfoType_ThreadTickCount = 25, ///< [13.0.0+] Number of ticks spent on thread.
211 InfoType_IsSvcPermitted = 26, ///< [14.0.0+] Does process have access to SVC (only usable with \ref svcSynchronizePreemptionState at present).
212 InfoType_IoRegionHint = 27, ///< [16.0.0+] Low bits of the physical address for a KIoRegion.
213 InfoType_AliasRegionExtraSize = 28, ///< [18.0.0+] Extra size added to the reserved region.
214
215 InfoType_TransferMemoryHint = 34, ///< [19.0.0+] Low bits of the process address for a KTransferMemory.
216
217 InfoType_ThreadTickCountDeprecated = 0xF0000002, ///< [1.0.0-12.1.0] Number of ticks spent on thread.
218} InfoType;
219
220/// GetSystemInfo IDs.
221typedef enum {
222 SystemInfoType_TotalPhysicalMemorySize = 0, ///< Total amount of DRAM available to system.
223 SystemInfoType_UsedPhysicalMemorySize = 1, ///< Current amount of DRAM used by system.
224 SystemInfoType_InitialProcessIdRange = 2, ///< Min/max initial process IDs.
226
227/// GetInfo Idle/Thread Tick Count Sub IDs.
228typedef enum {
229 TickCountInfo_Core0 = 0, ///< Tick count on core 0.
230 TickCountInfo_Core1 = 1, ///< Tick count on core 1.
231 TickCountInfo_Core2 = 2, ///< Tick count on core 2.
232 TickCountInfo_Core3 = 3, ///< Tick count on core 3.
233
234 TickCountInfo_Total = UINT64_MAX, ///< Tick count on all cores.
236
237/// GetInfo InitialProcessIdRange Sub IDs.
238typedef enum {
239 InitialProcessIdRangeInfo_Minimum = 0, ///< Lowest initial process ID.
240 InitialProcessIdRangeInfo_Maximum = 1, ///< Highest initial process ID.
242
243/// GetSystemInfo PhysicalMemory Sub IDs.
244typedef enum {
245 PhysicalMemorySystemInfo_Application = 0, ///< Memory allocated for application usage.
246 PhysicalMemorySystemInfo_Applet = 1, ///< Memory allocated for applet usage.
247 PhysicalMemorySystemInfo_System = 2, ///< Memory allocated for system usage.
248 PhysicalMemorySystemInfo_SystemUnsafe = 3, ///< Memory allocated for unsafe system usage (accessible to devices).
250
251/// SleepThread yield types.
252typedef enum {
253 YieldType_WithoutCoreMigration = 0l, ///< Yields to another thread on the same core.
254 YieldType_WithCoreMigration = -1l, ///< Yields to another thread (possibly on a different core).
255 YieldType_ToAnyThread = -2l, ///< Yields and performs forced load-balancing.
256} YieldType;
257
258/// SignalToAddress behaviors.
259typedef enum {
260 SignalType_Signal = 0, ///< Signals the address.
261 SignalType_SignalAndIncrementIfEqual = 1, ///< Signals the address and increments its value if equal to argument.
262 SignalType_SignalAndModifyBasedOnWaitingThreadCountIfEqual = 2, ///< Signals the address and updates its value if equal to argument.
263} SignalType;
264
265/// WaitForAddress behaviors.
266typedef enum {
267 ArbitrationType_WaitIfLessThan = 0, ///< Wait if the 32-bit value is less than argument.
268 ArbitrationType_DecrementAndWaitIfLessThan = 1, ///< Decrement the 32-bit value and wait if it is less than argument.
269 ArbitrationType_WaitIfEqual = 2, ///< Wait if the 32-bit value is equal to argument.
270 ArbitrationType_WaitIfEqual64 = 3, ///< [19.0.0+] Wait if the 64-bit value is equal to argument.
272
273/// Context of a scheduled thread.
274typedef struct {
275 u64 fp; ///< Frame Pointer for the thread.
276 u64 sp; ///< Stack Pointer for the thread.
277 u64 lr; ///< Link Register for the thread.
278 u64 pc; ///< Program Counter for the thread.
280
281/// Memory mapping type.
282typedef enum {
283 MemoryMapping_IoRegister = 0, ///< Mapping IO registers.
284 MemoryMapping_Uncached = 1, ///< Mapping normal memory without cache.
285 MemoryMapping_Memory = 2, ///< Mapping normal memory.
287
288/// Io Pools.
289typedef enum {
290 IoPoolType_PcieA2 = 0, ///< Physical address range 0x12000000-0x1FFFFFFF
291} IoPoolType;
292
293///@name Memory management
294///@{
295
296/**
297 * @brief Set the process heap to a given size. It can both extend and shrink the heap.
298 * @param[out] out_addr Variable to which write the address of the heap (which is randomized and fixed by the kernel)
299 * @param[in] size Size of the heap, must be a multiple of 0x200000 and [2.0.0+] less than 0x18000000.
300 * @return Result code.
301 * @note Syscall number 0x01.
302 */
303Result svcSetHeapSize(void** out_addr, u64 size);
304
305/**
306 * @brief Set the memory permissions of a (page-aligned) range of memory.
307 * @param[in] addr Start address of the range.
308 * @param[in] size Size of the range, in bytes.
309 * @param[in] perm Permissions (see \ref Permission).
310 * @return Result code.
311 * @remark Perm_X is not allowed. Setting write-only is not allowed either (Perm_W).
312 * This can be used to move back and forth between Perm_None, Perm_R and Perm_Rw.
313 * @note Syscall number 0x02.
314 */
315Result svcSetMemoryPermission(void* addr, u64 size, u32 perm);
316
317/**
318 * @brief Set the memory attributes of a (page-aligned) range of memory.
319 * @param[in] addr Start address of the range.
320 * @param[in] size Size of the range, in bytes.
321 * @param[in] val0 State0
322 * @param[in] val1 State1
323 * @return Result code.
324 * @remark See <a href="https://switchbrew.org/wiki/SVC#svcSetMemoryAttribute">switchbrew.org Wiki</a> for more details.
325 * @note Syscall number 0x03.
326 */
327Result svcSetMemoryAttribute(void* addr, u64 size, u32 val0, u32 val1);
328
329/**
330 * @brief Maps a memory range into a different range. Mainly used for adding guard pages around stack.
331 * Source range gets reprotected to Perm_None (it can no longer be accessed), and \ref MemAttr_IsBorrowed is set in the source \ref MemoryAttribute.
332 * @param[in] dst_addr Destination address.
333 * @param[in] src_addr Source address.
334 * @param[in] size Size of the range.
335 * @return Result code.
336 * @note Syscall number 0x04.
337 */
338Result svcMapMemory(void* dst_addr, void* src_addr, u64 size);
339
340/**
341 * @brief Unmaps a region that was previously mapped with \ref svcMapMemory.
342 * @param[in] dst_addr Destination address.
343 * @param[in] src_addr Source address.
344 * @param[in] size Size of the range.
345 * @return Result code.
346 * @note Syscall number 0x05.
347 */
348Result svcUnmapMemory(void* dst_addr, void* src_addr, u64 size);
349
350/**
351 * @brief Query information about an address. Will always fetch the lowest page-aligned mapping that contains the provided address.
352 * @param[out] meminfo_ptr \ref MemoryInfo structure which will be filled in.
353 * @param[out] pageinfo Page information which will be filled in.
354 * @param[in] addr Address to query.
355 * @return Result code.
356 * @note Syscall number 0x06.
357 */
358Result svcQueryMemory(MemoryInfo* meminfo_ptr, u32 *pageinfo, u64 addr);
359
360///@}
361
362///@name Process and thread management
363///@{
364
365/**
366 * @brief Exits the current process.
367 * @note Syscall number 0x07.
368 */
369
371
372/**
373 * @brief Creates a thread.
374 * @return Result code.
375 * @note Syscall number 0x08.
376 */
377Result svcCreateThread(Handle* out, void* entry, void* arg, void* stack_top, int prio, int cpuid);
378
379/**
380 * @brief Starts a freshly created thread.
381 * @return Result code.
382 * @note Syscall number 0x09.
383 */
385
386/**
387 * @brief Exits the current thread.
388 * @note Syscall number 0x0A.
389 */
391
392/**
393 * @brief Sleeps the current thread for the specified amount of time.
394 * @param[in] nano Number of nanoseconds to sleep, or \ref YieldType for yield.
395 * @note Syscall number 0x0B.
396 */
398
399/**
400 * @brief Gets a thread's priority.
401 * @return Result code.
402 * @note Syscall number 0x0C.
403 */
405
406/**
407 * @brief Sets a thread's priority.
408 * @return Result code.
409 * @note Syscall number 0x0D.
410 */
412
413/**
414 * @brief Gets a thread's core mask.
415 * @return Result code.
416 * @note Syscall number 0x0E.
417 */
418Result svcGetThreadCoreMask(s32* preferred_core, u64* affinity_mask, Handle handle);
419
420/**
421 * @brief Sets a thread's core mask.
422 * @return Result code.
423 * @note Syscall number 0x0F.
424 */
425Result svcSetThreadCoreMask(Handle handle, s32 preferred_core, u32 affinity_mask);
426
427/**
428 * @brief Gets the current processor's number.
429 * @return The current processor's number.
430 * @note Syscall number 0x10.
431 */
433
434///@}
435
436///@name Synchronization
437///@{
438
439/**
440 * @brief Sets an event's signalled status.
441 * @return Result code.
442 * @note Syscall number 0x11.
443 */
445
446/**
447 * @brief Clears an event's signalled status.
448 * @return Result code.
449 * @note Syscall number 0x12.
450 */
452
453///@}
454
455///@name Inter-process memory sharing
456///@{
457
458/**
459 * @brief Maps a block of shared memory.
460 * @return Result code.
461 * @note Syscall number 0x13.
462 */
463Result svcMapSharedMemory(Handle handle, void* addr, size_t size, u32 perm);
464
465/**
466 * @brief Unmaps a block of shared memory.
467 * @return Result code.
468 * @note Syscall number 0x14.
469 */
470Result svcUnmapSharedMemory(Handle handle, void* addr, size_t size);
471
472/**
473 * @brief Creates a block of transfer memory.
474 * @return Result code.
475 * @note Syscall number 0x15.
476 */
477Result svcCreateTransferMemory(Handle* out, void* addr, size_t size, u32 perm);
478
479///@}
480
481///@name Miscellaneous
482///@{
483
484/**
485 * @brief Closes a handle, decrementing the reference count of the corresponding kernel object.
486 * This might result in the kernel freeing the object.
487 * @param handle Handle to close.
488 * @return Result code.
489 * @note Syscall number 0x16.
490 */
492
493///@}
494
495///@name Synchronization
496///@{
497
498/**
499 * @brief Resets a signal.
500 * @return Result code.
501 * @note Syscall number 0x17.
502 */
504
505///@}
506
507///@name Synchronization
508///@{
509
510/**
511 * @brief Waits on one or more synchronization objects, optionally with a timeout.
512 * @return Result code.
513 * @note Syscall number 0x18.
514 * @note \p handleCount must not be greater than \ref MAX_WAIT_OBJECTS. This is a Horizon kernel limitation.
515 * @note This is the raw syscall, which can be cancelled by \ref svcCancelSynchronization or other means. \ref waitHandles or \ref waitMultiHandle should normally be used instead.
516 */
517Result svcWaitSynchronization(s32* index, const Handle* handles, s32 handleCount, u64 timeout);
518
519/**
520 * @brief Waits on a single synchronization object, optionally with a timeout.
521 * @return Result code.
522 * @note Wrapper for \ref svcWaitSynchronization.
523 * @note This is the raw syscall, which can be cancelled by \ref svcCancelSynchronization or other means. \ref waitSingleHandle should normally be used instead.
524 */
525static inline Result svcWaitSynchronizationSingle(Handle handle, u64 timeout) {
526 s32 tmp;
527 return svcWaitSynchronization(&tmp, &handle, 1, timeout);
528}
529
530/**
531 * @brief Waits a \ref svcWaitSynchronization operation being done on a synchronization object in another thread.
532 * @return Result code.
533 * @note Syscall number 0x19.
534 */
536
537/**
538 * @brief Arbitrates a mutex lock operation in userspace.
539 * @return Result code.
540 * @note Syscall number 0x1A.
541 */
542Result svcArbitrateLock(u32 wait_tag, u32* tag_location, u32 self_tag);
543
544/**
545 * @brief Arbitrates a mutex unlock operation in userspace.
546 * @return Result code.
547 * @note Syscall number 0x1B.
548 */
550
551/**
552 * @brief Performs a condition variable wait operation in userspace.
553 * @return Result code.
554 * @note Syscall number 0x1C.
555 */
556Result svcWaitProcessWideKeyAtomic(u32* key, u32* tag_location, u32 self_tag, u64 timeout);
557
558/**
559 * @brief Performs a condition variable wake-up operation in userspace.
560 * @note Syscall number 0x1D.
561 */
563
564///@}
565
566///@name Miscellaneous
567///@{
568
569/**
570 * @brief Gets the current system tick.
571 * @return The current system tick.
572 * @note Syscall number 0x1E.
573 */
575
576///@}
577
578///@name Inter-process communication (IPC)
579///@{
580
581/**
582 * @brief Connects to a registered named port.
583 * @return Result code.
584 * @note Syscall number 0x1F.
585 */
586Result svcConnectToNamedPort(Handle* session, const char* name);
587
588/**
589 * @brief Sends a light IPC synchronization request to a session.
590 * @return Result code.
591 * @note Syscall number 0x20.
592 */
594
595/**
596 * @brief Sends an IPC synchronization request to a session.
597 * @return Result code.
598 * @note Syscall number 0x21.
599 */
601
602/**
603 * @brief Sends an IPC synchronization request to a session from an user allocated buffer.
604 * @return Result code.
605 * @remark size must be allocated to 0x1000 bytes.
606 * @note Syscall number 0x22.
607 */
608Result svcSendSyncRequestWithUserBuffer(void* usrBuffer, u64 size, Handle session);
609
610/**
611 * @brief Sends an IPC synchronization request to a session from an user allocated buffer (asynchronous version).
612 * @return Result code.
613 * @remark size must be allocated to 0x1000 bytes.
614 * @note Syscall number 0x23.
615 */
616Result svcSendAsyncRequestWithUserBuffer(Handle* handle, void* usrBuffer, u64 size, Handle session);
617
618///@}
619
620///@name Process and thread management
621///@{
622
623/**
624 * @brief Gets the PID associated with a process.
625 * @return Result code.
626 * @note Syscall number 0x24.
627 */
628Result svcGetProcessId(u64 *processID, Handle handle);
629
630/**
631 * @brief Gets the TID associated with a process.
632 * @return Result code.
633 * @note Syscall number 0x25.
634 */
635Result svcGetThreadId(u64 *threadID, Handle handle);
636
637///@}
638
639///@name Miscellaneous
640///@{
641
642/**
643 * @brief Breaks execution.
644 * @param[in] breakReason Break reason (see \ref BreakReason).
645 * @param[in] address Address of the buffer to pass to the debugger.
646 * @param[in] size Size of the buffer to pass to the debugger.
647 * @return Result code.
648 * @note Syscall number 0x26.
649 */
650Result svcBreak(u32 breakReason, uintptr_t address, uintptr_t size);
651
652///@}
653
654///@name Debugging
655///@{
656
657/**
658 * @brief Outputs debug text, if used during debugging.
659 * @param[in] str Text to output.
660 * @param[in] size Size of the text in bytes.
661 * @return Result code.
662 * @note Syscall number 0x27.
663 */
664Result svcOutputDebugString(const char *str, u64 size);
665
666///@}
667
668///@name Miscellaneous
669///@{
670
671/**
672 * @brief Returns from an exception.
673 * @param[in] res Result code.
674 * @note Syscall number 0x28.
675 */
677
678/**
679 * @brief Retrieves information about the system, or a certain kernel object.
680 * @param[out] out Variable to which store the information.
681 * @param[in] id0 First ID of the property to retrieve.
682 * @param[in] handle Handle of the object to retrieve information from, or \ref INVALID_HANDLE to retrieve information about the system.
683 * @param[in] id1 Second ID of the property to retrieve.
684 * @return Result code.
685 * @remark The full list of property IDs can be found on the <a href="https://switchbrew.org/wiki/SVC#svcGetInfo">switchbrew.org wiki</a>.
686 * @note Syscall number 0x29.
687 */
688Result svcGetInfo(u64* out, u32 id0, Handle handle, u64 id1);
689
690///@}
691
692///@name Cache Management
693///@{
694
695/**
696 * @brief Flushes the entire data cache (by set/way).
697 * @note Syscall number 0x2A.
698 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
699 * @warning This syscall is dangerous, and should not be used.
700 */
702
703/**
704 * @brief Flushes data cache for a virtual address range.
705 * @param[in] address Address of region to flush.
706 * @param[in] size Size of region to flush.
707 * @remark armDCacheFlush should be used instead of this syscall whenever possible.
708 * @note Syscall number 0x2B.
709 */
710Result svcFlushDataCache(void *address, size_t size);
711
712///@}
713
714///@name Memory management
715///@{
716
717/**
718 * @brief Maps new heap memory at the desired address. [3.0.0+]
719 * @return Result code.
720 * @note Syscall number 0x2C.
721 */
722Result svcMapPhysicalMemory(void *address, u64 size);
723
724/**
725 * @brief Undoes the effects of \ref svcMapPhysicalMemory. [3.0.0+]
726 * @return Result code.
727 * @note Syscall number 0x2D.
728 */
729Result svcUnmapPhysicalMemory(void *address, u64 size);
730
731///@}
732
733///@name Process and thread management
734///@{
735
736/**
737 * @brief Gets information about a thread that will be scheduled in the future. [5.0.0+]
738 * @param[out] out_context Output \ref LastThreadContext for the thread that will be scheduled.
739 * @param[out] out_thread_id Output thread id for the thread that will be scheduled.
740 * @param[in] debug Debug handle.
741 * @param[in] ns Nanoseconds in the future to get scheduled thread at.
742 * @return Result code.
743 * @note Syscall number 0x2E.
744 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
745 */
746Result svcGetDebugFutureThreadInfo(LastThreadContext *out_context, u64 *out_thread_id, Handle debug, s64 ns);
747
748/**
749 * @brief Gets information about the previously-scheduled thread.
750 * @param[out] out_context Output \ref LastThreadContext for the previously scheduled thread.
751 * @param[out] out_tls_address Output tls address for the previously scheduled thread.
752 * @param[out] out_flags Output flags for the previously scheduled thread.
753 * @return Result code.
754 * @note Syscall number 0x2F.
755 */
756Result svcGetLastThreadInfo(LastThreadContext *out_context, u64 *out_tls_address, u32 *out_flags);
757
758///@}
759
760///@name Resource Limit Management
761///@{
762
763/**
764 * @brief Gets the maximum value a LimitableResource can have, for a Resource Limit handle.
765 * @return Result code.
766 * @note Syscall number 0x30.
767 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
768 */
770
771/**
772 * @brief Gets the maximum value a LimitableResource can have, for a Resource Limit handle.
773 * @return Result code.
774 * @note Syscall number 0x31.
775 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
776 */
778
779///@}
780
781///@name Process and thread management
782///@{
783
784/**
785 * @brief Configures the pause/unpause status of a thread.
786 * @return Result code.
787 * @note Syscall number 0x32.
788 */
790
791/**
792 * @brief Dumps the registers of a thread paused by @ref svcSetThreadActivity (register groups: all).
793 * @param[out] ctx Output thread context (register dump).
794 * @param[in] thread Thread handle.
795 * @return Result code.
796 * @note Syscall number 0x33.
797 * @warning Official kernel will not dump x0..x18 if the thread is currently executing a system call, and prior to 6.0.0 doesn't dump TPIDR_EL0.
798 */
800
801///@}
802
803///@name Synchronization
804///@{
805
806/**
807 * @brief Arbitrates an address depending on type and value. [4.0.0+]
808 * @param[in] address Address to arbitrate.
809 * @param[in] arb_type \ref ArbitrationType to use.
810 * @param[in] value Value to arbitrate on.
811 * @param[in] timeout Maximum time in nanoseconds to wait.
812 * @return Result code.
813 * @note Syscall number 0x34.
814 */
815Result svcWaitForAddress(void *address, u32 arb_type, s64 value, s64 timeout);
816
817/**
818 * @brief Signals (and updates) an address depending on type and value. [4.0.0+]
819 * @param[in] address Address to arbitrate.
820 * @param[in] signal_type \ref SignalType to use.
821 * @param[in] value Value to arbitrate on.
822 * @param[in] count Number of waiting threads to signal.
823 * @return Result code.
824 * @note Syscall number 0x35.
825 */
826Result svcSignalToAddress(void *address, u32 signal_type, s32 value, s32 count);
827
828///@}
829
830///@name Miscellaneous
831///@{
832
833/**
834 * @brief Sets thread preemption state (used during abort/panic). [8.0.0+]
835 * @note Syscall number 0x36.
836 */
838
839///@}
840
841///@name Resource Limit Management
842///@{
843
844/**
845 * @brief Gets the peak value a LimitableResource has had, for a Resource Limit handle. [11.0.0+]
846 * @return Result code.
847 * @note Syscall number 0x37.
848 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
849 */
851
852///@}
853
854///@name Memory Management
855///@{
856
857/**
858 * @brief Creates an IO Pool. [13.0.0+]
859 * @return Result code.
860 * @note Syscall number 0x39.
861 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
862 */
863Result svcCreateIoPool(Handle *out_handle, u32 pool_type);
864
865/**
866 * @brief Creates an IO Region. [13.0.0+]
867 * @return Result code.
868 * @note Syscall number 0x3A.
869 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
870 */
871Result svcCreateIoRegion(Handle *out_handle, Handle io_pool_h, u64 physical_address, u64 size, u32 memory_mapping, u32 perm);
872
873///@}
874
875///@name Debugging
876///@{
877/**
878 * @brief Causes the kernel to dump debug information. [1.0.0-3.0.2]
879 * @param[in] dump_info_type Type of information to dump.
880 * @param[in] arg0 Argument to the debugging operation.
881 * @note Syscall number 0x3C.
882 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
883 */
884void svcDumpInfo(u32 dump_info_type, u64 arg0);
885
886/**
887 * @brief Performs a debugging operation on the kernel. [4.0.0+]
888 * @param[in] kern_debug_type Type of debugging operation to perform.
889 * @param[in] arg0 First argument to the debugging operation.
890 * @param[in] arg1 Second argument to the debugging operation.
891 * @param[in] arg2 Third argument to the debugging operation.
892 * @note Syscall number 0x3C.
893 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
894 */
895void svcKernelDebug(u32 kern_debug_type, u64 arg0, u64 arg1, u64 arg2);
896
897/**
898 * @brief Performs a debugging operation on the kernel. [4.0.0+]
899 * @param[in] kern_trace_state Type of tracing the kernel should perform.
900 * @note Syscall number 0x3D.
901 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
902 */
903void svcChangeKernelTraceState(u32 kern_trace_state);
904
905///@}
906 \
907///@name Inter-process communication (IPC)
908///@{
909
910/**
911 * @brief Creates an IPC session.
912 * @return Result code.
913 * @note Syscall number 0x40.
914 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
915 */
916Result svcCreateSession(Handle *server_handle, Handle *client_handle, u32 unk0, u64 unk1);//unk* are normally 0?
917
918/**
919 * @brief Accepts an IPC session.
920 * @return Result code.
921 * @note Syscall number 0x41.
922 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
923 */
924Result svcAcceptSession(Handle *session_handle, Handle port_handle);
925
926/**
927 * @brief Performs light IPC input/output.
928 * @return Result code.
929 * @param[in] handle Server or port handle to act on.
930 * @note Syscall number 0x42.
931 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
932 */
934
935/**
936 * @brief Performs IPC input/output.
937 * @return Result code.
938 * @note Syscall number 0x43.
939 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
940 */
941Result svcReplyAndReceive(s32* index, const Handle* handles, s32 handleCount, Handle replyTarget, u64 timeout);
942
943/**
944 * @brief Performs IPC input/output from an user allocated buffer.
945 * @return Result code.
946 * @note Syscall number 0x44.
947 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
948 */
949Result svcReplyAndReceiveWithUserBuffer(s32* index, void* usrBuffer, u64 size, const Handle* handles, s32 handleCount, Handle replyTarget, u64 timeout);
950
951///@}
952
953///@name Synchronization
954///@{
955
956/**
957 * @brief Creates a system event.
958 * @return Result code.
959 * @note Syscall number 0x45.
960 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
961 */
962Result svcCreateEvent(Handle* server_handle, Handle* client_handle);
963
964///@}
965
966///@name Memory management
967///@{
968
969/**
970 * @brief Maps an IO Region. [13.0.0+]
971 * @return Result code.
972 * @note Syscall number 0x46.
973 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
974 */
975Result svcMapIoRegion(Handle io_region_h, void *address, u64 size, u32 perm);
976
977/**
978 * @brief Undoes the effects of \ref svcMapIoRegion. [13.0.0+]
979 * @return Result code.
980 * @note Syscall number 0x47.
981 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
982 */
983Result svcUnmapIoRegion(Handle io_region_h, void *address, u64 size);
984
985/**
986 * @brief Maps unsafe memory (usable for GPU DMA) for a system module at the desired address. [5.0.0+]
987 * @return Result code.
988 * @note Syscall number 0x48.
989 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
990 */
992
993/**
994 * @brief Undoes the effects of \ref svcMapPhysicalMemoryUnsafe. [5.0.0+]
995 * @return Result code.
996 * @note Syscall number 0x49.
997 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
998 */
1000
1001/**
1002 * @brief Sets the system-wide limit for unsafe memory mappable using \ref svcMapPhysicalMemoryUnsafe. [5.0.0+]
1003 * @return Result code.
1004 * @note Syscall number 0x4A.
1005 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1006 */
1008
1009///@}
1010
1011
1012///@name Code memory / Just-in-time (JIT) compilation support
1013///@{
1014
1015/**
1016 * @brief Creates code memory in the caller's address space [4.0.0+].
1017 * @return Result code.
1018 * @note Syscall number 0x4B.
1019 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1020 */
1021Result svcCreateCodeMemory(Handle* code_handle, void* src_addr, u64 size);
1022
1023/**
1024 * @brief Maps code memory in the caller's address space [4.0.0+].
1025 * @return Result code.
1026 * @note Syscall number 0x4C.
1027 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1028 */
1029Result svcControlCodeMemory(Handle code_handle, CodeMapOperation op, void* dst_addr, u64 size, u64 perm);
1030
1031///@}
1032
1033///@name Power Management
1034///@{
1035
1036/**
1037 * @brief Causes the system to enter deep sleep.
1038 * @note Syscall number 0x4D.
1039 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1040 */
1042
1043///@}
1044
1045///@name Device memory-mapped I/O (MMIO)
1046///@{
1047
1048/**
1049 * @brief Reads/writes a protected MMIO register.
1050 * @return Result code.
1051 * @note Syscall number 0x4E.
1052 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1053 */
1054Result svcReadWriteRegister(u32* outVal, u64 regAddr, u32 rwMask, u32 inVal);
1055
1056///@}
1057
1058///@name Process and thread management
1059///@{
1060
1061/**
1062 * @brief Configures the pause/unpause status of a process.
1063 * @return Result code.
1064 * @note Syscall number 0x4F.
1065 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1066 */
1068
1069///@}
1070
1071///@name Inter-process memory sharing
1072///@{
1073
1074/**
1075 * @brief Creates a block of shared memory.
1076 * @return Result code.
1077 * @note Syscall number 0x50.
1078 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1079 */
1080Result svcCreateSharedMemory(Handle* out, size_t size, u32 local_perm, u32 other_perm);
1081
1082/**
1083 * @brief Maps a block of transfer memory.
1084 * @return Result code.
1085 * @note Syscall number 0x51.
1086 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1087 */
1088Result svcMapTransferMemory(Handle tmem_handle, void* addr, size_t size, u32 perm);
1089
1090/**
1091 * @brief Unmaps a block of transfer memory.
1092 * @return Result code.
1093 * @note Syscall number 0x52.
1094 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1095 */
1096Result svcUnmapTransferMemory(Handle tmem_handle, void* addr, size_t size);
1097
1098///@}
1099
1100///@name Device memory-mapped I/O (MMIO)
1101///@{
1102
1103/**
1104 * @brief Creates an event and binds it to a specific hardware interrupt.
1105 * @return Result code.
1106 * @note Syscall number 0x53.
1107 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1108 */
1110
1111/**
1112 * @brief Queries information about a certain virtual address, including its physical address.
1113 * @return Result code.
1114 * @note Syscall number 0x54.
1115 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1116 */
1118
1119/**
1120 * @brief Returns a virtual address mapped to a given IO range.
1121 * @return Result code.
1122 * @note Syscall number 0x55.
1123 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1124 * @warning Only exists on [10.0.0+]. For older versions use \ref svcLegacyQueryIoMapping.
1125 */
1126Result svcQueryMemoryMapping(u64* virtaddr, u64* out_size, u64 physaddr, u64 size);
1127
1128/**
1129 * @brief Returns a virtual address mapped to a given IO range.
1130 * @return Result code.
1131 * @note Syscall number 0x55.
1132 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1133 * @warning Only exists on [1.0.0-9.2.0]. For newer versions use \ref svcQueryMemoryMapping.
1134 */
1135Result svcLegacyQueryIoMapping(u64* virtaddr, u64 physaddr, u64 size);
1136
1137///@}
1138
1139///@name I/O memory management unit (IOMMU)
1140///@{
1141
1142/**
1143 * @brief Creates a virtual address space for binding device address spaces.
1144 * @return Result code.
1145 * @note Syscall number 0x56.
1146 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1147 */
1148Result svcCreateDeviceAddressSpace(Handle *handle, u64 dev_addr, u64 dev_size);
1149
1150/**
1151 * @brief Attaches a device address space to a device.
1152 * @return Result code.
1153 * @note Syscall number 0x57.
1154 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1155 */
1157
1158/**
1159 * @brief Detaches a device address space from a device.
1160 * @return Result code.
1161 * @note Syscall number 0x58.
1162 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1163 */
1165
1166/**
1167 * @brief Maps an attached device address space to an userspace address.
1168 * @return Result code.
1169 * @remark The userspace destination address must have the \ref MemState_MapDeviceAllowed bit set.
1170 * @note Syscall number 0x59.
1171 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1172 */
1173Result svcMapDeviceAddressSpaceByForce(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 option);
1174
1175/**
1176 * @brief Maps an attached device address space to an userspace address.
1177 * @return Result code.
1178 * @remark The userspace destination address must have the \ref MemState_MapDeviceAlignedAllowed bit set.
1179 * @note Syscall number 0x5A.
1180 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1181 */
1182Result svcMapDeviceAddressSpaceAligned(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 option);
1183
1184/**
1185 * @brief Maps an attached device address space to an userspace address. [1.0.0-12.1.0]
1186 * @return Result code.
1187 * @remark The userspace destination address must have the \ref MemState_MapDeviceAlignedAllowed bit set.
1188 * @note Syscall number 0x5B.
1189 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1190 */
1191Result svcMapDeviceAddressSpace(u64 *out_mapped_size, Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 perm);
1192
1193/**
1194 * @brief Unmaps an attached device address space from an userspace address.
1195 * @return Result code.
1196 * @note Syscall number 0x5C.
1197 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1198 */
1199Result svcUnmapDeviceAddressSpace(Handle handle, Handle proc_handle, u64 map_addr, u64 map_size, u64 dev_addr);
1200
1201///@}
1202
1203///@name Cache Management
1204///@{
1205
1206/**
1207 * @brief Invalidates data cache for a virtual address range within a process.
1208 * @param[in] address Address of region to invalidate.
1209 * @param[in] size Size of region to invalidate.
1210 * @note Syscall number 0x5D.
1211 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1212 */
1213Result svcInvalidateProcessDataCache(Handle process, uintptr_t address, size_t size);
1214
1215/**
1216 * @brief Stores data cache for a virtual address range within a process.
1217 * @param[in] address Address of region to store.
1218 * @param[in] size Size of region to store.
1219 * @note Syscall number 0x5E.
1220 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1221 */
1222Result svcStoreProcessDataCache(Handle process, uintptr_t address, size_t size);
1223
1224/**
1225 * @brief Flushes data cache for a virtual address range within a process.
1226 * @param[in] address Address of region to flush.
1227 * @param[in] size Size of region to flush.
1228 * @note Syscall number 0x5F.
1229 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1230 */
1231Result svcFlushProcessDataCache(Handle process, uintptr_t address, size_t size);
1232
1233///@}
1234
1235///@name Debugging
1236///@{
1237
1238/**
1239 * @brief Debugs an active process.
1240 * @return Result code.
1241 * @note Syscall number 0x60.
1242 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1243 */
1245
1246/**
1247 * @brief Breaks an active debugging session.
1248 * @return Result code.
1249 * @note Syscall number 0x61.
1250 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1251 */
1253
1254/**
1255 * @brief Terminates the process of an active debugging session.
1256 * @return Result code.
1257 * @note Syscall number 0x62.
1258 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1259 */
1261
1262/**
1263 * @brief Gets an incoming debug event from a debugging session.
1264 * @return Result code.
1265 * @note Syscall number 0x63.
1266 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1267 */
1268Result svcGetDebugEvent(void* event_out, Handle debug);
1269
1270/**
1271 * @brief Continues a debugging session.
1272 * @return Result code.
1273 * @note Syscall number 0x64.
1274 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1275 * @warning Only exists on [3.0.0+]. For older versions use \ref svcLegacyContinueDebugEvent.
1276 */
1277Result svcContinueDebugEvent(Handle debug, u32 flags, u64* tid_list, u32 num_tids);
1278
1279/**
1280 * @brief Continues a debugging session.
1281 * @return Result code.
1282 * @note Syscall number 0x64.
1283 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1284 * @warning Only exists on [1.0.0-2.3.0]. For newer versions use \ref svcContinueDebugEvent.
1285 */
1287
1288/**
1289 * @brief Gets the context (dump the registers) of a thread in a debugging session.
1290 * @return Result code.
1291 * @param[out] ctx Output thread context (register dump).
1292 * @param[in] debug Debug handle.
1293 * @param[in] threadID ID of the thread to dump the context of.
1294 * @param[in] flags Register groups to select, combination of @ref RegisterGroup flags.
1295 * @note Syscall number 0x67.
1296 * @warning Official kernel will not dump any CPU GPR if the thread is currently executing a system call (except @ref svcBreak and @ref svcReturnFromException).
1297 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1298 */
1300
1301/**
1302 * @brief Gets the context (dump the registers) of a thread in a debugging session.
1303 * @return Result code.
1304 * @param[in] debug Debug handle.
1305 * @param[in] threadID ID of the thread to set the context of.
1306 * @param[in] ctx Input thread context (register dump).
1307 * @param[in] flags Register groups to select, combination of @ref RegisterGroup flags.
1308 * @note Syscall number 0x68.
1309 * @warning Official kernel will return an error if the thread is currently executing a system call (except @ref svcBreak and @ref svcReturnFromException).
1310 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1311 */
1312Result svcSetDebugThreadContext(Handle debug, u64 threadID, const ThreadContext* ctx, u32 flags);
1313
1314///@}
1315
1316///@name Process and thread management
1317///@{
1318
1319/**
1320 * @brief Retrieves a list of all running processes.
1321 * @return Result code.
1322 * @note Syscall number 0x65.
1323 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1324 */
1325Result svcGetProcessList(s32 *num_out, u64 *pids_out, u32 max_pids);
1326
1327/**
1328 * @brief Retrieves a list of all threads for a debug handle (or zero).
1329 * @return Result code.
1330 * @note Syscall number 0x66.
1331 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1332 */
1333Result svcGetThreadList(s32 *num_out, u64 *tids_out, u32 max_tids, Handle debug);
1334
1335///@}
1336
1337///@name Debugging
1338///@{
1339
1340/**
1341 * @brief Queries memory information from a process that is being debugged.
1342 * @return Result code.
1343 * @note Syscall number 0x69.
1344 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1345 */
1346Result svcQueryDebugProcessMemory(MemoryInfo* meminfo_ptr, u32* pageinfo, Handle debug, u64 addr);
1347
1348/**
1349 * @brief Reads memory from a process that is being debugged.
1350 * @return Result code.
1351 * @note Syscall number 0x6A.
1352 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1353 */
1354Result svcReadDebugProcessMemory(void* buffer, Handle debug, u64 addr, u64 size);
1355
1356/**
1357 * @brief Writes to memory in a process that is being debugged.
1358 * @return Result code.
1359 * @note Syscall number 0x6B.
1360 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1361 */
1362Result svcWriteDebugProcessMemory(Handle debug, const void* buffer, u64 addr, u64 size);
1363
1364/**
1365 * @brief Sets one of the hardware breakpoints.
1366 * @return Result code.
1367 * @note Syscall number 0x6C.
1368 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1369 */
1371
1372/**
1373 * @brief Gets parameters from a thread in a debugging session.
1374 * @return Result code.
1375 * @note Syscall number 0x6D.
1376 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1377 */
1378Result svcGetDebugThreadParam(u64* out_64, u32* out_32, Handle debug, u64 threadID, DebugThreadParam param);
1379
1380///@}
1381
1382///@name Miscellaneous
1383///@{
1384
1385/**
1386 * @brief Retrieves privileged information about the system, or a certain kernel object.
1387 * @param[out] out Variable to which store the information.
1388 * @param[in] id0 First ID of the property to retrieve.
1389 * @param[in] handle Handle of the object to retrieve information from, or \ref INVALID_HANDLE to retrieve information about the system.
1390 * @param[in] id1 Second ID of the property to retrieve.
1391 * @return Result code.
1392 * @remark The full list of property IDs can be found on the <a href="https://switchbrew.org/wiki/SVC#svcGetSystemInfo">switchbrew.org wiki</a>.
1393 * @note Syscall number 0x6F.
1394 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1395 */
1396Result svcGetSystemInfo(u64* out, u64 id0, Handle handle, u64 id1);
1397
1398///@}
1399
1400///@name Inter-process communication (IPC)
1401///@{
1402
1403/**
1404 * @brief Creates a port.
1405 * @return Result code.
1406 * @note Syscall number 0x70.
1407 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1408 */
1409Result svcCreatePort(Handle* portServer, Handle *portClient, s32 max_sessions, bool is_light, const char* name);
1410
1411/**
1412 * @brief Manages a named port.
1413 * @return Result code.
1414 * @note Syscall number 0x71.
1415 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1416 */
1417Result svcManageNamedPort(Handle* portServer, const char* name, s32 maxSessions);
1418
1419/**
1420 * @brief Manages a named port.
1421 * @return Result code.
1422 * @note Syscall number 0x72.
1423 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1424 */
1426
1427///@}
1428
1429///@name Memory management
1430///@{
1431
1432/**
1433 * @brief Sets the memory permissions for the specified memory with the supplied process handle.
1434 * @param[in] proc Process handle.
1435 * @param[in] addr Address of the memory.
1436 * @param[in] size Size of the memory.
1437 * @param[in] perm Permissions (see \ref Permission).
1438 * @return Result code.
1439 * @remark This returns an error (0xD801) when \p perm is >0x5, hence -WX and RWX are not allowed.
1440 * @note Syscall number 0x73.
1441 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1442 */
1444
1445/**
1446 * @brief Maps the src address from the supplied process handle into the current process.
1447 * @param[in] dst Address to which map the memory in the current process.
1448 * @param[in] proc Process handle.
1449 * @param[in] src Source mapping address.
1450 * @param[in] size Size of the memory.
1451 * @return Result code.
1452 * @remark This allows mapping code and rodata with RW- permission.
1453 * @note Syscall number 0x74.
1454 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1455 */
1456Result svcMapProcessMemory(void* dst, Handle proc, u64 src, u64 size);
1457
1458/**
1459 * @brief Undoes the effects of \ref svcMapProcessMemory.
1460 * @param[in] dst Destination mapping address
1461 * @param[in] proc Process handle.
1462 * @param[in] src Address of the memory in the process.
1463 * @param[in] size Size of the memory.
1464 * @return Result code.
1465 * @remark This allows mapping code and rodata with RW- permission.
1466 * @note Syscall number 0x75.
1467 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1468 */
1469Result svcUnmapProcessMemory(void* dst, Handle proc, u64 src, u64 size);
1470
1471/**
1472 * @brief Equivalent to \ref svcQueryMemory, for another process.
1473 * @param[out] meminfo_ptr \ref MemoryInfo structure which will be filled in.
1474 * @param[out] pageinfo Page information which will be filled in.
1475 * @param[in] proc Process handle.
1476 * @param[in] addr Address to query.
1477 * @return Result code.
1478 * @note Syscall number 0x76.
1479 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1480 */
1481Result svcQueryProcessMemory(MemoryInfo* meminfo_ptr, u32 *pageinfo, Handle proc, u64 addr);
1482
1483/**
1484 * @brief Maps normal heap in a certain process as executable code (used when loading NROs).
1485 * @param[in] proc Process handle (cannot be \ref CUR_PROCESS_HANDLE).
1486 * @param[in] dst Destination mapping address.
1487 * @param[in] src Source mapping address.
1488 * @param[in] size Size of the mapping.
1489 * @return Result code.
1490 * @note Syscall number 0x77.
1491 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1492 */
1494
1495/**
1496 * @brief Undoes the effects of \ref svcMapProcessCodeMemory.
1497 * @param[in] proc Process handle (cannot be \ref CUR_PROCESS_HANDLE).
1498 * @param[in] dst Destination mapping address.
1499 * @param[in] src Source mapping address.
1500 * @param[in] size Size of the mapping.
1501 * @return Result code.
1502 * @note Syscall number 0x78.
1503 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1504 */
1506
1507///@}
1508
1509///@name Process and thread management
1510///@{
1511
1512/**
1513 * @brief Creates a new process.
1514 * @return Result code.
1515 * @note Syscall number 0x79.
1516 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1517 */
1518Result svcCreateProcess(Handle* out, const void* proc_info, const u32* caps, u64 cap_num);
1519
1520/**
1521 * @brief Starts executing a freshly created process.
1522 * @return Result code.
1523 * @note Syscall number 0x7A.
1524 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1525 */
1526Result svcStartProcess(Handle proc, s32 main_prio, s32 default_cpu, u32 stack_size);
1527
1528/**
1529 * @brief Terminates a running process.
1530 * @return Result code.
1531 * @note Syscall number 0x7B.
1532 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1533 */
1535
1536/**
1537 * @brief Gets a \ref ProcessInfoType for a process.
1538 * @return Result code.
1539 * @note Syscall number 0x7C.
1540 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1541 */
1543
1544///@}
1545
1546///@name Resource Limit Management
1547///@{
1548
1549/**
1550 * @brief Creates a new Resource Limit handle.
1551 * @return Result code.
1552 * @note Syscall number 0x7D.
1553 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1554 */
1556
1557/**
1558 * @brief Sets the value for a \ref LimitableResource for a Resource Limit handle.
1559 * @return Result code.
1560 * @note Syscall number 0x7E.
1561 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1562 */
1564
1565///@}
1566
1567///@name ( ͡° ͜ʖ ͡°)
1568///@{
1569
1570/**
1571 * @brief Calls a secure monitor function (TrustZone, EL3).
1572 * @param regs Arguments to pass to the secure monitor.
1573 * @note Syscall number 0x7F.
1574 * @warning This is a privileged syscall. Use \ref envIsSyscallHinted to check if it is available.
1575 */
1577
1578///@}
1579
1580///@name Memory management
1581///@{
1582
1583/**
1584 * @brief Maps new insecure memory at the desired address. [15.0.0+]
1585 * @return Result code.
1586 * @note Syscall number 0x90.
1587 */
1589
1590/**
1591 * @brief Undoes the effects of \ref svcMapInsecureMemory. [15.0.0+]
1592 * @return Result code.
1593 * @note Syscall number 0x91.
1594 */
1596
1597///@}
Context of a scheduled thread.
Definition svc.h:274
u64 fp
Frame Pointer for the thread.
Definition svc.h:275
u64 lr
Link Register for the thread.
Definition svc.h:277
u64 sp
Stack Pointer for the thread.
Definition svc.h:276
u64 pc
Program Counter for the thread.
Definition svc.h:278
Memory information structure.
Definition svc.h:91
u32 attr
Memory attributes (see MemoryAttribute).
Definition svc.h:95
u32 type
Memory type (see lower 8 bits of MemoryState).
Definition svc.h:94
u32 ipc_refcount
IPC reference count.
Definition svc.h:97
u32 perm
Memory permissions (see Permission).
Definition svc.h:96
u64 addr
Base address.
Definition svc.h:92
u64 size
Size.
Definition svc.h:93
u32 padding
Padding.
Definition svc.h:99
u32 device_refcount
Device reference count.
Definition svc.h:98
Physical memory information structure.
Definition svc.h:103
u64 virtual_address
Virtual address.
Definition svc.h:105
u64 physical_address
Physical address.
Definition svc.h:104
u64 size
Size.
Definition svc.h:106
Secure monitor arguments.
Definition svc.h:110
Thread context structure (register dump)
Definition thread_context.h:49
void svcChangeKernelTraceState(u32 kern_trace_state)
Performs a debugging operation on the kernel.
ArbitrationType
WaitForAddress behaviors.
Definition svc.h:266
@ ArbitrationType_WaitIfEqual64
[19.0.0+] Wait if the 64-bit value is equal to argument.
Definition svc.h:270
@ ArbitrationType_WaitIfEqual
Wait if the 32-bit value is equal to argument.
Definition svc.h:269
@ ArbitrationType_DecrementAndWaitIfLessThan
Decrement the 32-bit value and wait if it is less than argument.
Definition svc.h:268
@ ArbitrationType_WaitIfLessThan
Wait if the 32-bit value is less than argument.
Definition svc.h:267
Result svcSetMemoryPermission(void *addr, u64 size, u32 perm)
Set the memory permissions of a (page-aligned) range of memory.
void svcSleepThread(s64 nano)
Sleeps the current thread for the specified amount of time.
Result svcSetProcessActivity(Handle process, ProcessActivity paused)
Configures the pause/unpause status of a process.
Result svcCloseHandle(Handle handle)
Closes a handle, decrementing the reference count of the corresponding kernel object.
Result svcSetHeapSize(void **out_addr, u64 size)
Set the process heap to a given size.
Result svcGetThreadCoreMask(s32 *preferred_core, u64 *affinity_mask, Handle handle)
Gets a thread's core mask.
Result svcMapInsecurePhysicalMemory(void *address, u64 size)
Maps new insecure memory at the desired address.
Result svcSetUnsafeLimit(u64 size)
Sets the system-wide limit for unsafe memory mappable using svcMapPhysicalMemoryUnsafe.
void svcExitProcess(void)
Exits the current process.
Permission
Memory permission bitmasks.
Definition svc.h:80
@ Perm_W
Write permission.
Definition svc.h:83
@ Perm_Rx
Read/execute permissions.
Definition svc.h:86
@ Perm_None
No permissions.
Definition svc.h:81
@ Perm_X
Execute permission.
Definition svc.h:84
@ Perm_Rw
Read/write permissions.
Definition svc.h:85
@ Perm_R
Read permission.
Definition svc.h:82
@ Perm_DontCare
Don't care.
Definition svc.h:87
Result svcUnmapInsecurePhysicalMemory(void *address, u64 size)
Undoes the effects of svcMapInsecureMemory.
Result svcSetThreadPriority(Handle handle, u32 priority)
Sets a thread's priority.
Result svcStoreProcessDataCache(Handle process, uintptr_t address, size_t size)
Stores data cache for a virtual address range within a process.
Result svcWaitSynchronization(s32 *index, const Handle *handles, s32 handleCount, u64 timeout)
Waits on one or more synchronization objects, optionally with a timeout.
LimitableResource
Limitable Resources.
Definition svc.h:137
@ LimitableResource_Memory
How much memory can a process map.
Definition svc.h:138
@ LimitableResource_Sessions
How many sessions can a process own.
Definition svc.h:142
@ LimitableResource_Events
How many events can a process have.
Definition svc.h:140
@ LimitableResource_Threads
How many threads can a process spawn.
Definition svc.h:139
@ LimitableResource_TransferMemories
How many transfer memories can a process make.
Definition svc.h:141
Result svcSetDebugThreadContext(Handle debug, u64 threadID, const ThreadContext *ctx, u32 flags)
Gets the context (dump the registers) of a thread in a debugging session.
void svcReturnFromException(Result res)
Returns from an exception.
void svcDumpInfo(u32 dump_info_type, u64 arg0)
Causes the kernel to dump debug information.
Result svcReadWriteRegister(u32 *outVal, u64 regAddr, u32 rwMask, u32 inVal)
Reads/writes a protected MMIO register.
void svcSignalProcessWideKey(u32 *key, s32 num)
Performs a condition variable wake-up operation in userspace.
Result svcUnmapSharedMemory(Handle handle, void *addr, size_t size)
Unmaps a block of shared memory.
Result svcSetThreadCoreMask(Handle handle, s32 preferred_core, u32 affinity_mask)
Sets a thread's core mask.
Result svcMapDeviceAddressSpaceByForce(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 option)
Maps an attached device address space to an userspace address.
Result svcCancelSynchronization(Handle thread)
Waits a svcWaitSynchronization operation being done on a synchronization object in another thread.
Result svcCreateCodeMemory(Handle *code_handle, void *src_addr, u64 size)
Creates code memory in the caller's address space [4.0.0+].
PhysicalMemorySystemInfo
GetSystemInfo PhysicalMemory Sub IDs.
Definition svc.h:244
@ PhysicalMemorySystemInfo_SystemUnsafe
Memory allocated for unsafe system usage (accessible to devices).
Definition svc.h:248
@ PhysicalMemorySystemInfo_Applet
Memory allocated for applet usage.
Definition svc.h:246
@ PhysicalMemorySystemInfo_System
Memory allocated for system usage.
Definition svc.h:247
@ PhysicalMemorySystemInfo_Application
Memory allocated for application usage.
Definition svc.h:245
ProcessState
Process States.
Definition svc.h:157
@ ProcessState_RunningAttached
Process that is running normally, attached to a debugger.
Definition svc.h:162
@ ProcessState_DebugSuspended
Process execution suspended by debugger.
Definition svc.h:165
@ ProcessState_Crashed
Process that has just crashed.
Definition svc.h:161
@ ProcessState_Created
Newly-created process, not yet started.
Definition svc.h:158
@ ProcessState_Exited
Process has finished exiting.
Definition svc.h:164
@ ProcessState_Running
Process that is running normally (and detached from any debugger).
Definition svc.h:160
@ ProcessState_CreatedAttached
Newly-created process, not yet started but attached to debugger.
Definition svc.h:159
@ ProcessState_Exiting
Process has begun exiting.
Definition svc.h:163
YieldType
SleepThread yield types.
Definition svc.h:252
@ YieldType_WithCoreMigration
Yields to another thread (possibly on a different core).
Definition svc.h:254
@ YieldType_ToAnyThread
Yields and performs forced load-balancing.
Definition svc.h:255
@ YieldType_WithoutCoreMigration
Yields to another thread on the same core.
Definition svc.h:253
MemoryMapping
Memory mapping type.
Definition svc.h:282
@ MemoryMapping_Memory
Mapping normal memory.
Definition svc.h:285
@ MemoryMapping_Uncached
Mapping normal memory without cache.
Definition svc.h:284
@ MemoryMapping_IoRegister
Mapping IO registers.
Definition svc.h:283
u64 svcGetSystemTick(void)
Gets the current system tick.
Result svcArbitrateUnlock(u32 *tag_location)
Arbitrates a mutex unlock operation in userspace.
Result svcWriteDebugProcessMemory(Handle debug, const void *buffer, u64 addr, u64 size)
Writes to memory in a process that is being debugged.
Result svcGetProcessId(u64 *processID, Handle handle)
Gets the PID associated with a process.
Result svcSendSyncRequest(Handle session)
Sends an IPC synchronization request to a session.
Result svcReadDebugProcessMemory(void *buffer, Handle debug, u64 addr, u64 size)
Reads memory from a process that is being debugged.
BreakReason
Break reasons.
Definition svc.h:115
MemoryType
Memory type enumeration (lower 8 bits of MemoryState)
Definition svc.h:20
@ MemType_Normal
Mapped by kernel capability parsing in svcCreateProcess.
Definition svc.h:23
@ MemType_Heap
Mapped using svcSetHeapSize.
Definition svc.h:26
@ MemType_CodeReadOnly
Mapped in kernel during svcControlCodeMemory.
Definition svc.h:41
@ MemType_Unmapped
Unmapped memory.
Definition svc.h:21
@ MemType_IpcBuffer0
IPC buffers with descriptor flags=0.
Definition svc.h:31
@ MemType_CodeWritable
Mapped in kernel during svcControlCodeMemory.
Definition svc.h:42
@ MemType_WeirdMappedMem
Mapped using svcMapMemory.
Definition svc.h:28
@ MemType_Insecure
Mapped in kernel during svcMapInsecurePhysicalMemory.
Definition svc.h:44
@ MemType_MappedMemory
Mapped using svcMapMemory.
Definition svc.h:32
@ MemType_IpcBuffer1
IPC buffers with descriptor flags=1.
Definition svc.h:38
@ MemType_ModuleCodeMutable
Transition from MemType_ModuleCodeStatic performed by svcSetProcessMemoryPermission.
Definition svc.h:30
@ MemType_CodeStatic
Mapped during svcCreateProcess.
Definition svc.h:24
@ MemType_Coverage
Not available.
Definition svc.h:43
@ MemType_Reserved
Reserved.
Definition svc.h:37
@ MemType_TransferMem
Mapped using svcMapTransferMemory when the owning process has perm!=0.
Definition svc.h:35
@ MemType_ModuleCodeStatic
Mapped using svcMapProcessCodeMemory.
Definition svc.h:29
@ MemType_ThreadLocal
Mapped during svcCreateThread.
Definition svc.h:33
@ MemType_IpcBuffer3
IPC buffers with descriptor flags=3.
Definition svc.h:39
@ MemType_ProcessMem
Mapped using svcMapProcessMemory.
Definition svc.h:36
@ MemType_TransferMemIsolated
Mapped using svcMapTransferMemory when the owning process has perm=0.
Definition svc.h:34
@ MemType_CodeMutable
Transition from MemType_CodeStatic performed by svcSetProcessMemoryPermission.
Definition svc.h:25
@ MemType_KernelStack
Mapped in kernel during svcCreateThread.
Definition svc.h:40
@ MemType_SharedMem
Mapped using svcMapSharedMemory.
Definition svc.h:27
@ MemType_Io
Mapped by kernel capability parsing in svcCreateProcess.
Definition svc.h:22
Result svcGetResourceLimitCurrentValue(s64 *out, Handle reslimit_h, LimitableResource which)
Gets the maximum value a LimitableResource can have, for a Resource Limit handle.
Result svcLegacyQueryIoMapping(u64 *virtaddr, u64 physaddr, u64 size)
Returns a virtual address mapped to a given IO range.
Result svcAcceptSession(Handle *session_handle, Handle port_handle)
Accepts an IPC session.
Result svcSendSyncRequestWithUserBuffer(void *usrBuffer, u64 size, Handle session)
Sends an IPC synchronization request to a session from an user allocated buffer.
Result svcUnmapProcessMemory(void *dst, Handle proc, u64 src, u64 size)
Undoes the effects of svcMapProcessMemory.
InfoType
GetInfo IDs.
Definition svc.h:184
@ InfoType_HeapRegionSize
Size of the Heap memory region.
Definition svc.h:190
@ InfoType_TransferMemoryHint
[19.0.0+] Low bits of the process address for a KTransferMemory.
Definition svc.h:215
@ InfoType_SystemResourceSizeUsed
[3.0.0+] Amount of memory currently used by process memory management.
Definition svc.h:202
@ InfoType_StackRegionAddress
[2.0.0+] Base of the Stack memory region.
Definition svc.h:199
@ InfoType_SystemResourceSizeTotal
[3.0.0+] Total memory allocated for process memory management.
Definition svc.h:201
@ InfoType_PriorityMask
Bitmask of allowed Thread Priorities.
Definition svc.h:186
@ InfoType_IoRegionHint
[16.0.0+] Low bits of the physical address for a KIoRegion.
Definition svc.h:212
@ InfoType_IsSvcPermitted
[14.0.0+] Does process have access to SVC (only usable with svcSynchronizePreemptionState at present)...
Definition svc.h:211
@ InfoType_TotalMemorySize
Total amount of memory available for process.
Definition svc.h:191
@ InfoType_AslrRegionSize
[2.0.0+] Size of the process's address space.
Definition svc.h:198
@ InfoType_ThreadTickCountDeprecated
[1.0.0-12.1.0] Number of ticks spent on thread.
Definition svc.h:217
@ InfoType_AslrRegionAddress
[2.0.0+] Base of the process's address space.
Definition svc.h:197
@ InfoType_ResourceLimit
Current process's resource limit handle.
Definition svc.h:194
@ InfoType_UsedNonSystemMemorySize
[6.0.0+] Amount of memory used by process, excluding that for process memory management.
Definition svc.h:207
@ InfoType_DebuggerAttached
Whether current process is being debugged.
Definition svc.h:193
@ InfoType_RandomEntropy
[2.0.0+] Random entropy for current process.
Definition svc.h:196
@ InfoType_IdleTickCount
Number of idle ticks on CPU.
Definition svc.h:195
@ InfoType_IsApplication
[9.0.0+] Whether the specified process is an Application.
Definition svc.h:208
@ InfoType_FreeThreadCount
[11.0.0+] The number of free threads available to the process's resource limit.
Definition svc.h:209
@ InfoType_ThreadTickCount
[13.0.0+] Number of ticks spent on thread.
Definition svc.h:210
@ InfoType_ProgramId
[3.0.0+] Program ID for the process.
Definition svc.h:203
@ InfoType_AliasRegionSize
Size of the Alias memory region.
Definition svc.h:188
@ InfoType_StackRegionSize
[2.0.0+] Size of the Stack memory region.
Definition svc.h:200
@ InfoType_UsedMemorySize
Amount of memory currently used by process.
Definition svc.h:192
@ InfoType_HeapRegionAddress
Base of the Heap memory region.
Definition svc.h:189
@ InfoType_InitialProcessIdRange
[4.0.0-4.1.0] Min/max initial process IDs.
Definition svc.h:204
@ InfoType_AliasRegionExtraSize
[18.0.0+] Extra size added to the reserved region.
Definition svc.h:213
@ InfoType_TotalNonSystemMemorySize
[6.0.0+] Total amount of memory available for process, excluding that for process memory management.
Definition svc.h:206
@ InfoType_CoreMask
Bitmask of allowed Core IDs.
Definition svc.h:185
@ InfoType_AliasRegionAddress
Base of the Alias memory region.
Definition svc.h:187
@ InfoType_UserExceptionContextAddress
[5.0.0+] Address of the process's exception context (for break).
Definition svc.h:205
void svcSynchronizePreemptionState(void)
Sets thread preemption state (used during abort/panic).
InitialProcessIdRangeInfo
GetInfo InitialProcessIdRange Sub IDs.
Definition svc.h:238
@ InitialProcessIdRangeInfo_Maximum
Highest initial process ID.
Definition svc.h:240
@ InitialProcessIdRangeInfo_Minimum
Lowest initial process ID.
Definition svc.h:239
Result svcReplyAndReceiveWithUserBuffer(s32 *index, void *usrBuffer, u64 size, const Handle *handles, s32 handleCount, Handle replyTarget, u64 timeout)
Performs IPC input/output from an user allocated buffer.
Result svcGetProcessInfo(s64 *out, Handle proc, ProcessInfoType which)
Gets a ProcessInfoType for a process.
ProcessActivity
Process Activity.
Definition svc.h:169
@ ProcessActivity_Runnable
Process can run.
Definition svc.h:170
@ ProcessActivity_Paused
Process is paused.
Definition svc.h:171
CodeMapOperation
Code memory mapping operations.
Definition svc.h:129
@ CodeMapOperation_UnmapSlave
Unmap slave.
Definition svc.h:133
@ CodeMapOperation_UnmapOwner
Unmap owner.
Definition svc.h:132
@ CodeMapOperation_MapSlave
Map slave.
Definition svc.h:131
@ CodeMapOperation_MapOwner
Map owner.
Definition svc.h:130
Result svcCreateInterruptEvent(Handle *handle, u64 irqNum, u32 flag)
Creates an event and binds it to a specific hardware interrupt.
Result svcMapSharedMemory(Handle handle, void *addr, size_t size, u32 perm)
Maps a block of shared memory.
Result svcMapMemory(void *dst_addr, void *src_addr, u64 size)
Maps a memory range into a different range.
Result svcStartProcess(Handle proc, s32 main_prio, s32 default_cpu, u32 stack_size)
Starts executing a freshly created process.
Result svcCreateIoPool(Handle *out_handle, u32 pool_type)
Creates an IO Pool.
Result svcTerminateProcess(Handle proc)
Terminates a running process.
Result svcSetMemoryAttribute(void *addr, u64 size, u32 val0, u32 val1)
Set the memory attributes of a (page-aligned) range of memory.
Result svcSetResourceLimitLimitValue(Handle reslimit, LimitableResource which, u64 value)
Sets the value for a LimitableResource for a Resource Limit handle.
Result svcSignalToAddress(void *address, u32 signal_type, s32 value, s32 count)
Signals (and updates) an address depending on type and value.
void svcExitThread(void)
Exits the current thread.
DebugThreadParam
Debug Thread Parameters.
Definition svc.h:175
Result svcGetThreadList(s32 *num_out, u64 *tids_out, u32 max_tids, Handle debug)
Retrieves a list of all threads for a debug handle (or zero).
u32 svcGetCurrentProcessorNumber(void)
Gets the current processor's number.
Result svcMapDeviceAddressSpaceAligned(Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 option)
Maps an attached device address space to an userspace address.
Result svcCreateSharedMemory(Handle *out, size_t size, u32 local_perm, u32 other_perm)
Creates a block of shared memory.
Result svcArbitrateLock(u32 wait_tag, u32 *tag_location, u32 self_tag)
Arbitrates a mutex lock operation in userspace.
Result svcFlushProcessDataCache(Handle process, uintptr_t address, size_t size)
Flushes data cache for a virtual address range within a process.
Result svcGetLastThreadInfo(LastThreadContext *out_context, u64 *out_tls_address, u32 *out_flags)
Gets information about the previously-scheduled thread.
Result svcDebugActiveProcess(Handle *debug, u64 processID)
Debugs an active process.
static Result svcWaitSynchronizationSingle(Handle handle, u64 timeout)
Waits on a single synchronization object, optionally with a timeout.
Definition svc.h:525
Result svcGetDebugThreadContext(ThreadContext *ctx, Handle debug, u64 threadID, u32 flags)
Gets the context (dump the registers) of a thread in a debugging session.
Result svcMapPhysicalMemoryUnsafe(void *address, u64 size)
Maps unsafe memory (usable for GPU DMA) for a system module at the desired address.
Result svcAttachDeviceAddressSpace(u64 device, Handle handle)
Attaches a device address space to a device.
ThreadActivity
Thread Activity.
Definition svc.h:146
@ ThreadActivity_Paused
Thread is paused.
Definition svc.h:148
@ ThreadActivity_Runnable
Thread can run.
Definition svc.h:147
Result svcGetThreadContext3(ThreadContext *ctx, Handle thread)
Dumps the registers of a thread paused by svcSetThreadActivity (register groups: all).
Result svcSetHardwareBreakPoint(u32 which, u64 flags, u64 value)
Sets one of the hardware breakpoints.
MemoryAttribute
Memory attribute bitmasks.
Definition svc.h:71
@ MemAttr_IsUncached
Is uncached.
Definition svc.h:75
@ MemAttr_IsPermissionLocked
Is permission locked.
Definition svc.h:76
@ MemAttr_IsBorrowed
Is borrowed memory.
Definition svc.h:72
@ MemAttr_IsDeviceMapped
Is device mapped (when DeviceRefCount > 0).
Definition svc.h:74
@ MemAttr_IsIpcMapped
Is IPC mapped (when IpcRefCount > 0).
Definition svc.h:73
Result svcGetSystemInfo(u64 *out, u64 id0, Handle handle, u64 id1)
Retrieves privileged information about the system, or a certain kernel object.
Result svcMapProcessMemory(void *dst, Handle proc, u64 src, u64 size)
Maps the src address from the supplied process handle into the current process.
void svcSleepSystem(void)
Causes the system to enter deep sleep.
Result svcStartThread(Handle handle)
Starts a freshly created thread.
Result svcUnmapIoRegion(Handle io_region_h, void *address, u64 size)
Undoes the effects of svcMapIoRegion.
Result svcGetDebugFutureThreadInfo(LastThreadContext *out_context, u64 *out_thread_id, Handle debug, s64 ns)
Gets information about a thread that will be scheduled in the future.
Result svcGetThreadId(u64 *threadID, Handle handle)
Gets the TID associated with a process.
Result svcWaitProcessWideKeyAtomic(u32 *key, u32 *tag_location, u32 self_tag, u64 timeout)
Performs a condition variable wait operation in userspace.
Result svcBreakDebugProcess(Handle debug)
Breaks an active debugging session.
Result svcUnmapMemory(void *dst_addr, void *src_addr, u64 size)
Unmaps a region that was previously mapped with svcMapMemory.
Result svcFlushDataCache(void *address, size_t size)
Flushes data cache for a virtual address range.
Result svcGetDebugEvent(void *event_out, Handle debug)
Gets an incoming debug event from a debugging session.
Result svcCreateEvent(Handle *server_handle, Handle *client_handle)
Creates a system event.
Result svcQueryMemory(MemoryInfo *meminfo_ptr, u32 *pageinfo, u64 addr)
Query information about an address.
Result svcUnmapDeviceAddressSpace(Handle handle, Handle proc_handle, u64 map_addr, u64 map_size, u64 dev_addr)
Unmaps an attached device address space from an userspace address.
Result svcInvalidateProcessDataCache(Handle process, uintptr_t address, size_t size)
Invalidates data cache for a virtual address range within a process.
Result svcMapDeviceAddressSpace(u64 *out_mapped_size, Handle handle, Handle proc_handle, u64 map_addr, u64 dev_size, u64 dev_addr, u32 perm)
Maps an attached device address space to an userspace address.
Result svcUnmapProcessCodeMemory(Handle proc, u64 dst, u64 src, u64 size)
Undoes the effects of svcMapProcessCodeMemory.
Result svcMapIoRegion(Handle io_region_h, void *address, u64 size, u32 perm)
Maps an IO Region.
Result svcControlCodeMemory(Handle code_handle, CodeMapOperation op, void *dst_addr, u64 size, u64 perm)
Maps code memory in the caller's address space [4.0.0+].
Result svcConnectToNamedPort(Handle *session, const char *name)
Connects to a registered named port.
Result svcUnmapPhysicalMemory(void *address, u64 size)
Undoes the effects of svcMapPhysicalMemory.
SignalType
SignalToAddress behaviors.
Definition svc.h:259
@ SignalType_Signal
Signals the address.
Definition svc.h:260
@ SignalType_SignalAndModifyBasedOnWaitingThreadCountIfEqual
Signals the address and updates its value if equal to argument.
Definition svc.h:262
@ SignalType_SignalAndIncrementIfEqual
Signals the address and increments its value if equal to argument.
Definition svc.h:261
void svcCallSecureMonitor(SecmonArgs *regs)
Calls a secure monitor function (TrustZone, EL3).
Result svcWaitForAddress(void *address, u32 arb_type, s64 value, s64 timeout)
Arbitrates an address depending on type and value.
Result svcCreateIoRegion(Handle *out_handle, Handle io_pool_h, u64 physical_address, u64 size, u32 memory_mapping, u32 perm)
Creates an IO Region.
ProcessInfoType
Process Information.
Definition svc.h:152
@ ProcessInfoType_ProcessState
What state is a process in.
Definition svc.h:153
Result svcResetSignal(Handle handle)
Resets a signal.
Result svcUnmapTransferMemory(Handle tmem_handle, void *addr, size_t size)
Unmaps a block of transfer memory.
Result svcLegacyContinueDebugEvent(Handle debug, u32 flags, u64 threadID)
Continues a debugging session.
Result svcOutputDebugString(const char *str, u64 size)
Outputs debug text, if used during debugging.
Result svcQueryPhysicalAddress(PhysicalMemoryInfo *out, u64 virtaddr)
Queries information about a certain virtual address, including its physical address.
Result svcCreateSession(Handle *server_handle, Handle *client_handle, u32 unk0, u64 unk1)
Creates an IPC session.
Result svcCreateTransferMemory(Handle *out, void *addr, size_t size, u32 perm)
Creates a block of transfer memory.
IoPoolType
Io Pools.
Definition svc.h:289
@ IoPoolType_PcieA2
Physical address range 0x12000000-0x1FFFFFFF.
Definition svc.h:290
Result svcReplyAndReceive(s32 *index, const Handle *handles, s32 handleCount, Handle replyTarget, u64 timeout)
Performs IPC input/output.
SystemInfoType
GetSystemInfo IDs.
Definition svc.h:221
@ SystemInfoType_TotalPhysicalMemorySize
Total amount of DRAM available to system.
Definition svc.h:222
@ SystemInfoType_UsedPhysicalMemorySize
Current amount of DRAM used by system.
Definition svc.h:223
@ SystemInfoType_InitialProcessIdRange
Min/max initial process IDs.
Definition svc.h:224
Result svcMapTransferMemory(Handle tmem_handle, void *addr, size_t size, u32 perm)
Maps a block of transfer memory.
Result svcConnectToPort(Handle *session, Handle port)
Manages a named port.
Result svcClearEvent(Handle handle)
Clears an event's signalled status.
Result svcUnmapPhysicalMemoryUnsafe(void *address, u64 size)
Undoes the effects of svcMapPhysicalMemoryUnsafe.
MemoryState
Memory state bitmasks.
Definition svc.h:48
@ MemState_MapAllowed
Map allowed.
Definition svc.h:56
@ MemState_IpcSendAllowed_Type0
IPC type 0 send allowed.
Definition svc.h:52
@ MemState_MapDeviceAlignedAllowed
Map device aligned allowed.
Definition svc.h:61
@ MemState_IsRefCounted
Alias for MemState_IsPoolAllocated.
Definition svc.h:64
@ MemState_AttrChangeAllowed
Attribute change allowed.
Definition svc.h:66
@ MemState_CodeMemAllowed
Code memory allowed.
Definition svc.h:67
@ MemState_IpcSendAllowed_Type1
IPC type 1 send allowed.
Definition svc.h:54
@ MemState_IpcBufferAllowed
IPC buffer allowed.
Definition svc.h:62
@ MemState_IpcSendAllowed_Type3
IPC type 3 send allowed.
Definition svc.h:53
@ MemState_TransferMemAllowed
Transfer memory allowed.
Definition svc.h:58
@ MemState_Type
Type field (see MemoryType).
Definition svc.h:49
@ MemState_ProcessPermChangeAllowed
Process permission change allowed.
Definition svc.h:55
@ MemState_UnmapProcessCodeMemAllowed
Unmap process code memory allowed.
Definition svc.h:57
@ MemState_IsPoolAllocated
Is pool allocated.
Definition svc.h:63
@ MemState_QueryPAddrAllowed
Query physical address allowed.
Definition svc.h:59
@ MemState_PermChangeAllowed
Permission change allowed.
Definition svc.h:50
@ MemState_ForceRwByDebugSyscalls
Force read/writable by debug syscalls.
Definition svc.h:51
@ MemState_MapDeviceAllowed
Map device allowed (svcMapDeviceAddressSpace and svcMapDeviceAddressSpaceByForce).
Definition svc.h:60
@ MemState_MapProcessAllowed
Map process allowed.
Definition svc.h:65
Result svcReplyAndReceiveLight(Handle handle)
Performs light IPC input/output.
Result svcContinueDebugEvent(Handle debug, u32 flags, u64 *tid_list, u32 num_tids)
Continues a debugging session.
void svcFlushEntireDataCache(void)
Flushes the entire data cache (by set/way).
Result svcCreatePort(Handle *portServer, Handle *portClient, s32 max_sessions, bool is_light, const char *name)
Creates a port.
Result svcQueryMemoryMapping(u64 *virtaddr, u64 *out_size, u64 physaddr, u64 size)
Returns a virtual address mapped to a given IO range.
Result svcGetInfo(u64 *out, u32 id0, Handle handle, u64 id1)
Retrieves information about the system, or a certain kernel object.
Result svcSetThreadActivity(Handle thread, ThreadActivity paused)
Configures the pause/unpause status of a thread.
Result svcSendSyncRequestLight(Handle session)
Sends a light IPC synchronization request to a session.
TickCountInfo
GetInfo Idle/Thread Tick Count Sub IDs.
Definition svc.h:228
@ TickCountInfo_Core3
Tick count on core 3.
Definition svc.h:232
@ TickCountInfo_Core2
Tick count on core 2.
Definition svc.h:231
@ TickCountInfo_Core0
Tick count on core 0.
Definition svc.h:229
@ TickCountInfo_Core1
Tick count on core 1.
Definition svc.h:230
@ TickCountInfo_Total
Tick count on all cores.
Definition svc.h:234
Result svcGetResourceLimitLimitValue(s64 *out, Handle reslimit_h, LimitableResource which)
Gets the maximum value a LimitableResource can have, for a Resource Limit handle.
Result svcCreateResourceLimit(Handle *out)
Creates a new Resource Limit handle.
Result svcMapProcessCodeMemory(Handle proc, u64 dst, u64 src, u64 size)
Maps normal heap in a certain process as executable code (used when loading NROs).
Result svcGetDebugThreadParam(u64 *out_64, u32 *out_32, Handle debug, u64 threadID, DebugThreadParam param)
Gets parameters from a thread in a debugging session.
Result svcCreateProcess(Handle *out, const void *proc_info, const u32 *caps, u64 cap_num)
Creates a new process.
void svcKernelDebug(u32 kern_debug_type, u64 arg0, u64 arg1, u64 arg2)
Performs a debugging operation on the kernel.
Result svcSendAsyncRequestWithUserBuffer(Handle *handle, void *usrBuffer, u64 size, Handle session)
Sends an IPC synchronization request to a session from an user allocated buffer (asynchronous version...
Result svcTerminateDebugProcess(Handle debug)
Terminates the process of an active debugging session.
Result svcGetThreadPriority(s32 *priority, Handle handle)
Gets a thread's priority.
Result svcManageNamedPort(Handle *portServer, const char *name, s32 maxSessions)
Manages a named port.
Result svcSetProcessMemoryPermission(Handle proc, u64 addr, u64 size, u32 perm)
Sets the memory permissions for the specified memory with the supplied process handle.
Result svcCreateDeviceAddressSpace(Handle *handle, u64 dev_addr, u64 dev_size)
Creates a virtual address space for binding device address spaces.
Result svcMapPhysicalMemory(void *address, u64 size)
Maps new heap memory at the desired address.
Result svcBreak(u32 breakReason, uintptr_t address, uintptr_t size)
Breaks execution.
Result svcSignalEvent(Handle handle)
Sets an event's signalled status.
Result svcGetProcessList(s32 *num_out, u64 *pids_out, u32 max_pids)
Retrieves a list of all running processes.
Result svcGetResourceLimitPeakValue(s64 *out, Handle reslimit_h, LimitableResource which)
Gets the peak value a LimitableResource has had, for a Resource Limit handle.
Result svcQueryDebugProcessMemory(MemoryInfo *meminfo_ptr, u32 *pageinfo, Handle debug, u64 addr)
Queries memory information from a process that is being debugged.
Result svcQueryProcessMemory(MemoryInfo *meminfo_ptr, u32 *pageinfo, Handle proc, u64 addr)
Equivalent to svcQueryMemory, for another process.
Result svcCreateThread(Handle *out, void *entry, void *arg, void *stack_top, int prio, int cpuid)
Creates a thread.
Result svcDetachDeviceAddressSpace(u64 device, Handle handle)
Detaches a device address space from a device.
int64_t s64
64-bit signed integer.
Definition types.h:28
#define BIT(n)
Creates a bitmask from a bit number.
Definition types.h:54
uint64_t u64
64-bit unsigned integer.
Definition types.h:22
#define NX_PACKED
Packs a struct so that it won't include padding bytes.
Definition types.h:63
u32 Handle
Kernel object handle.
Definition types.h:43
u32 Result
Function error code result type.
Definition types.h:44
#define NX_NORETURN
Marks a function as not returning, for the purposes of compiler optimization.
Definition types.h:68
int32_t s32
32-bit signed integer.
Definition types.h:27
uint32_t u32
32-bit unsigned integer.
Definition types.h:21