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