]> git.saurik.com Git - apple/xnu.git/blame_incremental - bsd/sys/kdebug.h
xnu-3247.10.11.tar.gz
[apple/xnu.git] / bsd / sys / kdebug.h
... / ...
CommitLineData
1/*
2 * Copyright (c) 2000-2014 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29/* Copyright (c) 1997 Apple Computer, Inc. All rights reserved.
30 *
31 * kdebug.h - kernel_debug definitions
32 *
33 */
34
35#ifndef BSD_SYS_KDEBUG_H
36#define BSD_SYS_KDEBUG_H
37
38#include <sys/appleapiopts.h>
39#include <sys/cdefs.h>
40__BEGIN_DECLS
41
42#ifdef __APPLE_API_UNSTABLE
43
44#include <mach/clock_types.h>
45#include <stdint.h>
46
47#ifndef KERNEL
48#include <Availability.h>
49#endif
50
51#ifdef XNU_KERNEL_PRIVATE
52#include <stdint.h>
53#include <mach/branch_predicates.h>
54#endif
55
56/*
57 * Kdebug is a facility for tracing events occurring on a system.
58 *
59 * All events are tagged with a debugid, consisting of the following:
60 *
61 * +----------------+----------------+----------------------------+----+
62 * | Class (8) | Subclass (8) | Code (14) |Func|
63 * | | | |(2) |
64 * +----------------+----------------+----------------------------+----+
65 * \______________________________________________________________/
66 * Eventid
67 * \___________________________________________________________________/
68 * Debugid
69 *
70 * The eventid is a hierarchical ID, indicating which components an event is
71 * referring to. The debugid includes an eventid and two function qualifier
72 * bits, to determine the structural significance of an event (whether it
73 * starts or ends a series of grouped events).
74 */
75
76#define KDBG_CLASS_MASK (0xff000000)
77#define KDBG_CLASS_OFFSET (24)
78#define KDBG_CLASS_MAX (0xff)
79
80#define KDBG_SUBCLASS_MASK (0x00ff0000)
81#define KDBG_SUBCLASS_OFFSET (16)
82#define KDBG_SUBCLASS_MAX (0xff)
83
84/* class and subclass mask */
85#define KDBG_CSC_MASK (0xffff0000)
86#define KDBG_CSC_OFFSET (KDBG_SUBCLASS_OFFSET)
87
88#define KDBG_CODE_MASK (0x0000fffc)
89#define KDBG_CODE_OFFSET (2)
90#define KDBG_CODE_MAX (0x3fff)
91
92#define KDBG_EVENTID_MASK (0xfffffffc)
93
94/* Generate an eventid corresponding to Class, SubClass, and Code. */
95#define KDBG_EVENTID(Class, SubClass, Code) \
96 ((((Class) & 0xff) << KDBG_CLASS_OFFSET) | \
97 (((SubClass) & 0xff) << KDBG_SUBCLASS_OFFSET) | \
98 (((Code) & 0x3fff) << KDBG_CODE_OFFSET))
99/* Deprecated macro using old naming convention. */
100#define KDBG_CODE(Class, SubClass, Code) \
101 KDBG_EVENTID(Class, SubClass, Code)
102
103/* Extract pieces of the debug code. */
104#define KDBG_EXTRACT_CLASS(Debugid) \
105 ((uint8_t)(((Debugid) & KDBG_CLASS_MASK) >> KDBG_CLASS_OFFSET))
106#define KDBG_EXTRACT_SUBCLASS(Debugid) \
107 ((uint8_t)(((Debugid) & KDBG_SUBCLASS_MASK) >> KDBG_SUBCLASS_OFFSET))
108#define KDBG_EXTRACT_CSC(Debugid) \
109 ((uint16_t)(((Debugid) & KDBG_CSC_MASK) >> KDBG_CSC_OFFSET))
110#define KDBG_EXTRACT_CODE(Debugid) \
111 ((uint16_t)(((Debugid) & KDBG_CODE_MASK) >> KDBG_CODE_OFFSET))
112
113#ifdef KERNEL_PRIVATE
114
115typedef enum
116{
117 KD_CALLBACK_KDEBUG_ENABLED, // Trace is now enabled. No arguments
118 KD_CALLBACK_KDEBUG_DISABLED, // Trace is now disabled. No arguments
119 KD_CALLBACK_SYNC_FLUSH, // Request the latest entries from the IOP, and block until complete. No arguments
120 KD_CALLBACK_TYPEFILTER_CHANGED, // Typefilter is enabled. A read-only pointer to the typefilter is provided, but is only valid while in the callback.
121} kd_callback_type;
122typedef void (*kd_callback_fn) (void* context, kd_callback_type reason, void* arg);
123
124struct kd_callback {
125 kd_callback_fn func;
126 void* context;
127 char iop_name[8]; // null-terminated string with name of core.
128};
129
130typedef struct kd_callback kd_callback_t;
131
132/*
133 * Registers an IOP for participation in tracing.
134 *
135 * The registered callback function will be called with the
136 * supplied context as the first argument, followed by a
137 * kd_callback_type and an associated void* argument.
138 *
139 * The return value is a nonzero coreid that shall be used in
140 * kernel_debug_enter() to refer to your IOP. If the allocation
141 * failed, then 0 will be returned.
142 *
143 *
144 * Caveats:
145 * Note that not all callback calls will indicate a change in
146 * state (e.g. disabling trace twice would send two disable
147 * notifications).
148 *
149 */
150extern int kernel_debug_register_callback(kd_callback_t callback);
151
152extern void kernel_debug_enter(
153 uint32_t coreid,
154 uint32_t debugid,
155 uint64_t timestamp,
156 uintptr_t arg1,
157 uintptr_t arg2,
158 uintptr_t arg3,
159 uintptr_t arg4,
160 uintptr_t threadid
161 );
162
163#endif /* KERNEL_PRIVATE */
164
165/* The Function qualifiers */
166#define DBG_FUNC_START 1
167#define DBG_FUNC_END 2
168#define DBG_FUNC_NONE 0
169
170/* The Kernel Debug Classes */
171#define DBG_MACH 1
172#define DBG_NETWORK 2
173#define DBG_FSYSTEM 3
174#define DBG_BSD 4
175#define DBG_IOKIT 5
176#define DBG_DRIVERS 6
177#define DBG_TRACE 7
178#define DBG_DLIL 8
179#define DBG_WORKQUEUE 9
180#define DBG_CORESTORAGE 10
181#define DBG_CG 11
182#define DBG_MISC 20
183#define DBG_SECURITY 30
184#define DBG_DYLD 31
185#define DBG_QT 32
186#define DBG_APPS 33
187#define DBG_LAUNCHD 34
188#define DBG_PERF 37
189#define DBG_IMPORTANCE 38
190#define DBG_BANK 40
191#define DBG_XPC 41
192#define DBG_ATM 42
193#define DBG_ARIADNE 43
194#define DBG_DAEMON 44
195#define DBG_ENERGYTRACE 45
196
197
198#define DBG_MIG 255
199
200#ifdef PRIVATE
201/*
202 * OS components can use the full precision of the "code" field
203 * (Class, SubClass, Code) to inject events using kdebug_trace() by
204 * using:
205 *
206 * kdebug_trace(KDBG_CODE(DBG_XPC, 15, 1) | DBG_FUNC_NONE, 1, 2, 3, 4);
207 *
208 * These trace points can be included in production code, since they
209 * use reserved, non-overlapping ranges. The performance impact when
210 * kernel tracing is not enabled is minimal. Classes can be reserved
211 * by filing a Radar in xnu|all.
212 *
213 * 64-bit arguments may be truncated if the system is using a 32-bit
214 * kernel.
215 *
216 * On error, -1 will be returned and errno will indicate the error.
217 */
218#ifndef KERNEL
219extern int kdebug_trace(uint32_t code, uint64_t arg1, uint64_t arg2, uint64_t arg3, uint64_t arg4) __OSX_AVAILABLE_STARTING(__MAC_10_10_2, __IPHONE_8_2);
220#endif
221
222/*!
223 * @function kdebug_trace_string
224 *
225 * @discussion
226 * This function emits strings to kdebug trace along with an ID and allows
227 * for previously-traced strings to be overwritten and invalidated.
228 *
229 * To start tracing a string and generate an ID to use to refer to it:
230 *
231 * string_id = kdebug_trace_string(debugid, 0, "string");
232 *
233 * To replace a string previously traced:
234 *
235 * string_id = kdebug_trace_string(debugid, string_id, "new string");
236 *
237 * To invalidate a string ID:
238 *
239 * string_id = kdebug_trace_string(debugid, string_id, NULL);
240 *
241 * To check for errors:
242 *
243 * if ((int64_t)string_id == -1) { perror("string error") }
244 *
245 * @param debugid
246 * The `debugid` to check if its enabled before tracing and include as
247 * an argument in the event containing the string.
248 *
249 * Some classes or subclasses are reserved for specific uses and are not
250 * allowed to be used with this function. No function qualifiers are
251 * allowed on `debugid`.
252 *
253 * @param str_id
254 * When 0, a new ID will be generated and returned if tracing is
255 * enabled.
256 *
257 * Otherwise `str_id` must contain an ID that was previously generated
258 * with this function. Clents should pass NULL in `str` if `str_id`
259 * is no longer in use. Otherwise, the string previously mapped to
260 * `str_id` will be overwritten with the contents of `str`.
261 *
262 * @param str
263 * A NUL-terminated 'C' string containing the characters that should be
264 * traced alongside `str_id`.
265 *
266 * If necessary, the string will be truncated at an
267 * implementation-defined length. The string must not be the empty
268 * string, but can be NULL if a valid `str_id` is provided.
269 *
270 * @return
271 * 0 if tracing is disabled or `debugid` is being filtered out of trace.
272 * It can also return (int64_t)-1 if an error occured. Otherwise,
273 * it returns the ID to use to refer to the string in future
274 * kdebug_trace(2) calls.
275 *
276 * The errors that can occur are:
277 *
278 * EINVAL
279 * There are function qualifiers on `debugid`, `str` is empty, or
280 * `str_id` was not generated by this function.
281 * EPERM
282 * The `debugid`'s class or subclass is reserved for internal use.
283 * EFAULT
284 * `str` is an invalid address or NULL when `str_id` is 0.
285 */
286#ifndef KERNEL
287extern uint64_t kdebug_trace_string(uint32_t debugid, uint64_t str_id,
288 const char *str)
289__OSX_AVAILABLE_STARTING(__MAC_10_11, __IPHONE_9_0);
290#endif
291#endif /* PRIVATE */
292
293#ifdef XNU_KERNEL_PRIVATE
294/* Used in early boot to log strings spanning only a single tracepoint. */
295extern void kernel_debug_string_simple(const char *message);
296#endif /* XNU_KERNEL_PRIVATE */
297
298/* **** The Kernel Debug Sub Classes for Mach (DBG_MACH) **** */
299#define DBG_MACH_EXCP_KTRAP_x86 0x02 /* Kernel Traps on x86 */
300#define DBG_MACH_EXCP_DFLT 0x03 /* Data Translation Fault */
301#define DBG_MACH_EXCP_IFLT 0x04 /* Inst Translation Fault */
302#define DBG_MACH_EXCP_INTR 0x05 /* Interrupts */
303#define DBG_MACH_EXCP_ALNG 0x06 /* Alignment Exception */
304#define DBG_MACH_EXCP_UTRAP_x86 0x07 /* User Traps on x86 */
305#define DBG_MACH_EXCP_FP 0x08 /* FP Unavail */
306#define DBG_MACH_EXCP_DECI 0x09 /* Decrementer Interrupt */
307#define DBG_MACH_CHUD 0x0A /* CHUD */
308#define DBG_MACH_EXCP_SC 0x0C /* System Calls */
309#define DBG_MACH_EXCP_TRACE 0x0D /* Trace exception */
310#define DBG_MACH_EXCP_EMUL 0x0E /* Instruction emulated */
311#define DBG_MACH_IHDLR 0x10 /* Interrupt Handlers */
312#define DBG_MACH_IPC 0x20 /* Inter Process Comm */
313#define DBG_MACH_VM 0x30 /* Virtual Memory */
314#define DBG_MACH_LEAKS 0x31 /* alloc/free */
315#define DBG_MACH_SCHED 0x40 /* Scheduler */
316#define DBG_MACH_MSGID_INVALID 0x50 /* Messages - invalid */
317#define DBG_MACH_LOCKS 0x60 /* new lock APIs */
318#define DBG_MACH_PMAP 0x70 /* pmap */
319#define DBG_MACH_CLOCK 0x80 /* clock */
320#define DBG_MACH_MP 0x90 /* MP related */
321#define DBG_MACH_VM_PRESSURE 0xA0 /* Memory Pressure Events */
322#define DBG_MACH_STACKSHOT 0xA1 /* Stackshot/Microstackshot subsystem */
323#define DBG_MACH_SFI 0xA2 /* Selective Forced Idle (SFI) */
324#define DBG_MACH_ENERGY_PERF 0xA3 /* Energy/performance resource stats */
325#define DBG_MACH_SYSDIAGNOSE 0xA4 /* sysdiagnose keychord */
326
327/* Codes for Scheduler (DBG_MACH_SCHED) */
328#define MACH_SCHED 0x0 /* Scheduler */
329#define MACH_STACK_ATTACH 0x1 /* stack_attach() */
330#define MACH_STACK_HANDOFF 0x2 /* stack_handoff() */
331#define MACH_CALL_CONT 0x3 /* call_continuation() */
332#define MACH_CALLOUT 0x4 /* callouts */
333#define MACH_STACK_DETACH 0x5
334#define MACH_MAKE_RUNNABLE 0x6 /* make thread runnable */
335#define MACH_PROMOTE 0x7 /* promoted due to resource */
336#define MACH_DEMOTE 0x8 /* promotion undone */
337#define MACH_IDLE 0x9 /* processor idling */
338#define MACH_STACK_DEPTH 0xa /* stack depth at switch */
339#define MACH_MOVED 0xb /* did not use original scheduling decision */
340/* unused 0xc */
341/* unused 0xd */
342#define MACH_FAILSAFE 0xe /* tripped fixed-pri/RT failsafe */
343#define MACH_BLOCK 0xf /* thread block */
344#define MACH_WAIT 0x10 /* thread wait assertion */
345#define MACH_GET_URGENCY 0x14 /* Urgency queried by platform */
346#define MACH_URGENCY 0x15 /* Urgency (RT/BG/NORMAL) communicated
347 * to platform
348 */
349#define MACH_REDISPATCH 0x16 /* "next thread" thread redispatched */
350#define MACH_REMOTE_AST 0x17 /* AST signal issued to remote processor */
351#define MACH_SCHED_CHOOSE_PROCESSOR 0x18 /* Result of choose_processor */
352#define MACH_DEEP_IDLE 0x19 /* deep idle on master processor */
353/* unused 0x1a was MACH_SCHED_DECAY_PRIORITY */
354#define MACH_CPU_THROTTLE_DISABLE 0x1b /* Global CPU Throttle Disable */
355#define MACH_RW_PROMOTE 0x1c /* promoted due to RW lock promotion */
356#define MACH_RW_DEMOTE 0x1d /* promotion due to RW lock undone */
357#define MACH_SCHED_MAINTENANCE 0x1f /* periodic maintenance thread */
358#define MACH_DISPATCH 0x20 /* context switch completed */
359#define MACH_QUANTUM_HANDOFF 0x21 /* quantum handoff occurred */
360#define MACH_MULTIQ_DEQUEUE 0x22 /* Result of multiq dequeue */
361#define MACH_SCHED_THREAD_SWITCH 0x23 /* attempt direct context switch to hinted thread */
362#define MACH_SCHED_SMT_BALANCE 0x24 /* SMT load balancing ASTs */
363#define MACH_REMOTE_DEFERRED_AST 0x25 /* Deferred AST started against remote processor */
364#define MACH_REMOTE_CANCEL_AST 0x26 /* Canceled deferred AST for remote processor */
365#define MACH_SCHED_CHANGE_PRIORITY 0x27 /* thread sched priority changed */
366#define MACH_SCHED_UPDATE_REC_CORES 0x28 /* Change to recommended processor bitmask */
367#define MACH_STACK_WAIT 0x29 /* Thread could not be switched-to because of kernel stack shortage */
368#define MACH_THREAD_BIND 0x2a /* Thread was bound (or unbound) to a processor */
369#define MACH_WAITQ_PROMOTE 0x2b /* Thread promoted by waitq boost */
370#define MACH_WAITQ_DEMOTE 0x2c /* Thread demoted from waitq boost */
371
372/* Variants for MACH_MULTIQ_DEQUEUE */
373#define MACH_MULTIQ_BOUND 1
374#define MACH_MULTIQ_GROUP 2
375#define MACH_MULTIQ_GLOBAL 3
376
377/* Arguments for vm_fault (DBG_MACH_VM) */
378#define DBG_ZERO_FILL_FAULT 1
379#define DBG_PAGEIN_FAULT 2
380#define DBG_COW_FAULT 3
381#define DBG_CACHE_HIT_FAULT 4
382#define DBG_NZF_PAGE_FAULT 5
383#define DBG_GUARD_FAULT 6
384#define DBG_PAGEINV_FAULT 7
385#define DBG_PAGEIND_FAULT 8
386#define DBG_COMPRESSOR_FAULT 9
387#define DBG_COMPRESSOR_SWAPIN_FAULT 10
388
389/* Codes for IPC (DBG_MACH_IPC) */
390#define MACH_TASK_SUSPEND 0x0 /* Suspended a task */
391#define MACH_TASK_RESUME 0x1 /* Resumed a task */
392#define MACH_THREAD_SET_VOUCHER 0x2
393#define MACH_IPC_MSG_SEND 0x3 /* mach msg send, uniq msg info */
394#define MACH_IPC_MSG_RECV 0x4 /* mach_msg receive */
395#define MACH_IPC_MSG_RECV_VOUCHER_REFUSED 0x5 /* mach_msg receive, voucher refused */
396#define MACH_IPC_KMSG_FREE 0x6 /* kernel free of kmsg data */
397#define MACH_IPC_VOUCHER_CREATE 0x7 /* Voucher added to global voucher hashtable */
398#define MACH_IPC_VOUCHER_CREATE_ATTR_DATA 0x8 /* Attr data for newly created voucher */
399#define MACH_IPC_VOUCHER_DESTROY 0x9 /* Voucher removed from global voucher hashtable */
400
401/* Codes for pmap (DBG_MACH_PMAP) */
402#define PMAP__CREATE 0x0
403#define PMAP__DESTROY 0x1
404#define PMAP__PROTECT 0x2
405#define PMAP__PAGE_PROTECT 0x3
406#define PMAP__ENTER 0x4
407#define PMAP__REMOVE 0x5
408#define PMAP__NEST 0x6
409#define PMAP__UNNEST 0x7
410#define PMAP__FLUSH_TLBS 0x8
411#define PMAP__UPDATE_INTERRUPT 0x9
412#define PMAP__ATTRIBUTE_CLEAR 0xa
413#define PMAP__REUSABLE 0xb
414#define PMAP__QUERY_RESIDENT 0xc
415#define PMAP__FLUSH_KERN_TLBS 0xd
416#define PMAP__FLUSH_DELAYED_TLBS 0xe
417#define PMAP__FLUSH_TLBS_TO 0xf
418#define PMAP__FLUSH_EPT 0x10
419
420/* Codes for clock (DBG_MACH_CLOCK) */
421#define MACH_EPOCH_CHANGE 0x0 /* wake epoch change */
422
423
424/* Codes for Stackshot/Microstackshot (DBG_MACH_STACKSHOT) */
425#define MICROSTACKSHOT_RECORD 0x0
426#define MICROSTACKSHOT_GATHER 0x1
427
428/* Codes for sysdiagnose */
429#define SYSDIAGNOSE_NOTIFY_USER 0x0
430
431/* Codes for Selective Forced Idle (DBG_MACH_SFI) */
432#define SFI_SET_WINDOW 0x0
433#define SFI_CANCEL_WINDOW 0x1
434#define SFI_SET_CLASS_OFFTIME 0x2
435#define SFI_CANCEL_CLASS_OFFTIME 0x3
436#define SFI_THREAD_DEFER 0x4
437#define SFI_OFF_TIMER 0x5
438#define SFI_ON_TIMER 0x6
439#define SFI_WAIT_CANCELED 0x7
440#define SFI_PID_SET_MANAGED 0x8
441#define SFI_PID_CLEAR_MANAGED 0x9
442#define SFI_GLOBAL_DEFER 0xa
443/* **** The Kernel Debug Sub Classes for Network (DBG_NETWORK) **** */
444#define DBG_NETIP 1 /* Internet Protocol */
445#define DBG_NETARP 2 /* Address Resolution Protocol */
446#define DBG_NETUDP 3 /* User Datagram Protocol */
447#define DBG_NETTCP 4 /* Transmission Control Protocol */
448#define DBG_NETICMP 5 /* Internet Control Message Protocol */
449#define DBG_NETIGMP 6 /* Internet Group Management Protocol */
450#define DBG_NETRIP 7 /* Routing Information Protocol */
451#define DBG_NETOSPF 8 /* Open Shortest Path First */
452#define DBG_NETISIS 9 /* Intermediate System to Intermediate System */
453#define DBG_NETSNMP 10 /* Simple Network Management Protocol */
454#define DBG_NETSOCK 11 /* Socket Layer */
455
456/* For Apple talk */
457#define DBG_NETAARP 100 /* Apple ARP */
458#define DBG_NETDDP 101 /* Datagram Delivery Protocol */
459#define DBG_NETNBP 102 /* Name Binding Protocol */
460#define DBG_NETZIP 103 /* Zone Information Protocol */
461#define DBG_NETADSP 104 /* Name Binding Protocol */
462#define DBG_NETATP 105 /* Apple Transaction Protocol */
463#define DBG_NETASP 106 /* Apple Session Protocol */
464#define DBG_NETAFP 107 /* Apple Filing Protocol */
465#define DBG_NETRTMP 108 /* Routing Table Maintenance Protocol */
466#define DBG_NETAURP 109 /* Apple Update Routing Protocol */
467
468#define DBG_NETIPSEC 128 /* IPsec Protocol */
469#define DBG_NETVMNET 129 /* VMNet */
470
471/* **** The Kernel Debug Sub Classes for IOKIT (DBG_IOKIT) **** */
472#define DBG_IOINTC 0 /* Interrupt controller */
473#define DBG_IOWORKLOOP 1 /* Work from work loop */
474#define DBG_IOINTES 2 /* Interrupt event source */
475#define DBG_IOCLKES 3 /* Clock event source */
476#define DBG_IOCMDQ 4 /* Command queue latencies */
477#define DBG_IOMCURS 5 /* Memory Cursor */
478#define DBG_IOMDESC 6 /* Memory Descriptors */
479#define DBG_IOPOWER 7 /* Power Managerment */
480#define DBG_IOSERVICE 8 /* Matching etc. */
481
482/* **** 9-32 reserved for internal IOKit usage **** */
483
484#define DBG_IOSTORAGE 32 /* Storage layers */
485#define DBG_IONETWORK 33 /* Network layers */
486#define DBG_IOKEYBOARD 34 /* Keyboard */
487#define DBG_IOHID 35 /* HID Devices */
488#define DBG_IOAUDIO 36 /* Audio */
489#define DBG_IOSERIAL 37 /* Serial */
490#define DBG_IOTTY 38 /* TTY layers */
491#define DBG_IOSAM 39 /* SCSI Architecture Model layers */
492#define DBG_IOPARALLELATA 40 /* Parallel ATA */
493#define DBG_IOPARALLELSCSI 41 /* Parallel SCSI */
494#define DBG_IOSATA 42 /* Serial-ATA */
495#define DBG_IOSAS 43 /* SAS */
496#define DBG_IOFIBRECHANNEL 44 /* FiberChannel */
497#define DBG_IOUSB 45 /* USB */
498#define DBG_IOBLUETOOTH 46 /* Bluetooth */
499#define DBG_IOFIREWIRE 47 /* FireWire */
500#define DBG_IOINFINIBAND 48 /* Infiniband */
501#define DBG_IOCPUPM 49 /* CPU Power Management */
502#define DBG_IOGRAPHICS 50 /* Graphics */
503#define DBG_HIBERNATE 51 /* hibernation related events */
504#define DBG_IOTHUNDERBOLT 52 /* Thunderbolt */
505
506
507/* Backwards compatibility */
508#define DBG_IOPOINTING DBG_IOHID /* OBSOLETE: Use DBG_IOHID instead */
509#define DBG_IODISK DBG_IOSTORAGE /* OBSOLETE: Use DBG_IOSTORAGE instead */
510
511/* **** The Kernel Debug Sub Classes for Device Drivers (DBG_DRIVERS) **** */
512#define DBG_DRVSTORAGE 1 /* Storage layers */
513#define DBG_DRVNETWORK 2 /* Network layers */
514#define DBG_DRVKEYBOARD 3 /* Keyboard */
515#define DBG_DRVHID 4 /* HID Devices */
516#define DBG_DRVAUDIO 5 /* Audio */
517#define DBG_DRVSERIAL 7 /* Serial */
518#define DBG_DRVSAM 8 /* SCSI Architecture Model layers */
519#define DBG_DRVPARALLELATA 9 /* Parallel ATA */
520#define DBG_DRVPARALLELSCSI 10 /* Parallel SCSI */
521#define DBG_DRVSATA 11 /* Serial ATA */
522#define DBG_DRVSAS 12 /* SAS */
523#define DBG_DRVFIBRECHANNEL 13 /* FiberChannel */
524#define DBG_DRVUSB 14 /* USB */
525#define DBG_DRVBLUETOOTH 15 /* Bluetooth */
526#define DBG_DRVFIREWIRE 16 /* FireWire */
527#define DBG_DRVINFINIBAND 17 /* Infiniband */
528#define DBG_DRVGRAPHICS 18 /* Graphics */
529#define DBG_DRVSD 19 /* Secure Digital */
530#define DBG_DRVNAND 20 /* NAND drivers and layers */
531#define DBG_SSD 21 /* SSD */
532#define DBG_DRVSPI 22 /* SPI */
533
534/* Backwards compatibility */
535#define DBG_DRVPOINTING DBG_DRVHID /* OBSOLETE: Use DBG_DRVHID instead */
536#define DBG_DRVDISK DBG_DRVSTORAGE /* OBSOLETE: Use DBG_DRVSTORAGE instead */
537
538/* **** The Kernel Debug Sub Classes for the DLIL Layer (DBG_DLIL) **** */
539#define DBG_DLIL_STATIC 1 /* Static DLIL code */
540#define DBG_DLIL_PR_MOD 2 /* DLIL Protocol Module */
541#define DBG_DLIL_IF_MOD 3 /* DLIL Interface Module */
542#define DBG_DLIL_PR_FLT 4 /* DLIL Protocol Filter */
543#define DBG_DLIL_IF_FLT 5 /* DLIL Interface FIlter */
544
545/* The Kernel Debug Sub Classes for File System (DBG_FSYSTEM) */
546#define DBG_FSRW 1 /* reads and writes to the filesystem */
547#define DBG_DKRW 2 /* reads and writes to the disk */
548#define DBG_FSVN 3 /* vnode operations (inc. locking/unlocking) */
549#define DBG_FSLOOOKUP 4 /* namei and other lookup-related operations */
550#define DBG_JOURNAL 5 /* journaling operations */
551#define DBG_IOCTL 6 /* ioctl to the disk */
552#define DBG_BOOTCACHE 7 /* bootcache operations */
553#define DBG_HFS 8 /* HFS-specific events; see bsd/hfs/hfs_kdebug.h */
554#define DBG_EXFAT 0xE /* ExFAT-specific events; see the exfat project */
555#define DBG_MSDOS 0xF /* FAT-specific events; see the msdosfs project */
556#define DBG_ACFS 0x10 /* Xsan-specific events; see the XsanFS project */
557#define DBG_THROTTLE 0x11 /* I/O Throttling events */
558#define DBG_CONTENT_PROT 0xCF /* Content Protection Events: see bsd/sys/cprotect.h */
559
560/*
561 * For Kernel Debug Sub Class DBG_HFS, state bits for hfs_update event
562 */
563#define DBG_HFS_UPDATE_ACCTIME 0x01
564#define DBG_HFS_UPDATE_MODTIME 0x02
565#define DBG_HFS_UPDATE_CHGTIME 0x04
566#define DBG_HFS_UPDATE_MODIFIED 0x08
567#define DBG_HFS_UPDATE_FORCE 0x10
568#define DBG_HFS_UPDATE_DATEADDED 0x20
569#define DBG_HFS_UPDATE_MINOR 0x40
570#define DBG_HFS_UPDATE_SKIPPED 0x80
571
572/* The Kernel Debug Sub Classes for BSD */
573#define DBG_BSD_PROC 0x01 /* process/signals related */
574#define DBG_BSD_MEMSTAT 0x02 /* memorystatus / jetsam operations */
575#define DBG_BSD_EXCP_SC 0x0C /* System Calls */
576#define DBG_BSD_AIO 0x0D /* aio (POSIX async IO) */
577#define DBG_BSD_SC_EXTENDED_INFO 0x0E /* System Calls, extended info */
578#define DBG_BSD_SC_EXTENDED_INFO2 0x0F /* System Calls, extended info */
579
580
581/* The Codes for BSD subcode class DBG_BSD_PROC */
582#define BSD_PROC_EXIT 1 /* process exit */
583#define BSD_PROC_FRCEXIT 2 /* Kernel force termination */
584
585/* Codes for BSD subcode class DBG_BSD_MEMSTAT */
586#define BSD_MEMSTAT_SCAN 1 /* memorystatus thread awake */
587#define BSD_MEMSTAT_JETSAM 2 /* LRU jetsam */
588#define BSD_MEMSTAT_JETSAM_HIWAT 3 /* highwater jetsam */
589#define BSD_MEMSTAT_FREEZE 4 /* freeze process */
590#define BSD_MEMSTAT_LATENCY_COALESCE 5 /* delay imposed to coalesce jetsam reports */
591#define BSD_MEMSTAT_UPDATE 6 /* priority update */
592#define BSD_MEMSTAT_IDLE_DEMOTE 7 /* idle demotion fired */
593#define BSD_MEMSTAT_CLEAR_ERRORS 8 /* reset termination error state */
594#define BSD_MEMSTAT_DIRTY_TRACK 9 /* track the process state */
595#define BSD_MEMSTAT_DIRTY_SET 10 /* set the process state */
596#define BSD_MEMSTAT_DIRTY_CLEAR 11 /* clear the process state */
597#ifdef PRIVATE
598#define BSD_MEMSTAT_GRP_SET_PROP 12 /* set group properties */
599#define BSD_MEMSTAT_DO_KILL 13 /* memorystatus kills */
600#endif /* PRIVATE */
601
602/* The Kernel Debug Sub Classes for DBG_TRACE */
603#define DBG_TRACE_DATA 0
604#define DBG_TRACE_STRING 1
605#define DBG_TRACE_INFO 2
606
607/* The Kernel Debug events: */
608#define TRACE_DATA_NEWTHREAD (TRACEDBG_CODE(DBG_TRACE_DATA, 1))
609#define TRACE_DATA_EXEC (TRACEDBG_CODE(DBG_TRACE_DATA, 2))
610#define TRACE_DATA_THREAD_TERMINATE (TRACEDBG_CODE(DBG_TRACE_DATA, 3))
611#define TRACE_STRING_GLOBAL (TRACEDBG_CODE(DBG_TRACE_STRING, 0))
612#define TRACE_STRING_NEWTHREAD (TRACEDBG_CODE(DBG_TRACE_STRING, 1))
613#define TRACE_STRING_EXEC (TRACEDBG_CODE(DBG_TRACE_STRING, 2))
614#define TRACE_PANIC (TRACEDBG_CODE(DBG_TRACE_INFO, 0))
615#define TRACE_TIMESTAMPS (TRACEDBG_CODE(DBG_TRACE_INFO, 1))
616#define TRACE_LOST_EVENTS (TRACEDBG_CODE(DBG_TRACE_INFO, 2))
617#define TRACE_WRITING_EVENTS (TRACEDBG_CODE(DBG_TRACE_INFO, 3))
618#define TRACE_INFO_STRING (TRACEDBG_CODE(DBG_TRACE_INFO, 4))
619
620/* The Kernel Debug Sub Classes for DBG_CORESTORAGE */
621#define DBG_CS_IO 0
622
623/* The Kernel Debug Sub Classes for DBG_SECURITY */
624#define DBG_SEC_KERNEL 0 /* raw entropy collected by the kernel */
625
626/* Sub-class codes for CoreGraphics (DBG_CG) are defined in its component. */
627
628/* The Kernel Debug Sub Classes for DBG_MISC */
629#define DBG_EVENT 0x10
630#define DBG_BUFFER 0x20
631
632/* The Kernel Debug Sub Classes for DBG_DYLD */
633#define DBG_DYLD_STRING 5
634
635/* The Kernel Debug modifiers for the DBG_DKRW sub class */
636#define DKIO_DONE 0x01
637#define DKIO_READ 0x02
638#define DKIO_ASYNC 0x04
639#define DKIO_META 0x08
640#define DKIO_PAGING 0x10
641#define DKIO_THROTTLE 0x20 /* Deprecated, still provided so fs_usage doesn't break */
642#define DKIO_PASSIVE 0x40
643#define DKIO_NOCACHE 0x80
644#define DKIO_TIER_MASK 0xF00
645#define DKIO_TIER_SHIFT 8
646
647/* Kernel Debug Sub Classes for Applications (DBG_APPS) */
648#define DBG_APP_LOGINWINDOW 0x03
649#define DBG_APP_AUDIO 0x04
650#define DBG_APP_SIGPOST 0x0A
651#define DBG_APP_APPKIT 0x0C
652#define DBG_APP_SAMBA 0x80
653
654/* Kernel Debug codes for Throttling (DBG_THROTTLE) */
655#define OPEN_THROTTLE_WINDOW 0x1
656#define PROCESS_THROTTLED 0x2
657#define IO_THROTTLE_DISABLE 0x3
658
659
660/* Subclasses for MACH Importance Policies (DBG_IMPORTANCE) */
661/* TODO: Split up boost and task policy? */
662#define IMP_ASSERTION 0x10 /* Task takes/drops a boost assertion */
663#define IMP_BOOST 0x11 /* Task boost level changed */
664#define IMP_MSG 0x12 /* boosting message sent by donating task on donating port */
665#define IMP_WATCHPORT 0x13 /* port marked as watchport, and boost was transferred to the watched task */
666#define IMP_TASK_SUPPRESSION 0x17 /* Task changed suppression behaviors */
667#define IMP_TASK_APPTYPE 0x18 /* Task launched with apptype */
668#define IMP_UPDATE 0x19 /* Requested -> effective calculation */
669#define IMP_USYNCH_QOS_OVERRIDE 0x1A /* Userspace synchronization applied QoS override to resource owning thread */
670#define IMP_DONOR_CHANGE 0x1B /* The iit_donor bit changed */
671#define IMP_MAIN_THREAD_QOS 0x1C /* The task's main thread QoS was set */
672/* DBG_IMPORTANCE subclasses 0x20 - 0x3F reserved for task policy flavors */
673
674/* Codes for IMP_ASSERTION */
675#define IMP_HOLD 0x2 /* Task holds a boost assertion */
676#define IMP_DROP 0x4 /* Task drops a boost assertion */
677#define IMP_EXTERN 0x8 /* boost assertion moved from kernel to userspace responsibility (externalized) */
678
679/* Codes for IMP_BOOST */
680#define IMP_BOOSTED 0x1
681#define IMP_UNBOOSTED 0x2 /* Task drops a boost assertion */
682
683/* Codes for IMP_MSG */
684#define IMP_MSG_SEND 0x1 /* boosting message sent by donating task on donating port */
685#define IMP_MSG_DELV 0x2 /* boosting message delivered to task */
686
687/* Codes for IMP_UPDATE */
688#define IMP_UPDATE_TASK_CREATE 0x1
689
690/* Codes for IMP_USYNCH_QOS_OVERRIDE */
691#define IMP_USYNCH_ADD_OVERRIDE 0x0 /* add override for a contended resource */
692#define IMP_USYNCH_REMOVE_OVERRIDE 0x1 /* remove override for a contended resource */
693
694/* Codes for IMP_DONOR_CHANGE */
695#define IMP_DONOR_UPDATE_LIVE_DONOR_STATE 0x0
696#define IMP_DONOR_INIT_DONOR_STATE 0x1
697
698/* Subclasses for MACH Bank Voucher Attribute Manager (DBG_BANK) */
699#define BANK_ACCOUNT_INFO 0x10 /* Trace points related to bank account struct */
700#define BANK_TASK_INFO 0x11 /* Trace points related to bank task struct */
701
702/* Subclasses for MACH ATM Voucher Attribute Manager (ATM) */
703#define ATM_SUBAID_INFO 0x10
704#define ATM_GETVALUE_INFO 0x20
705#define ATM_UNREGISTER_INFO 0x30
706
707/* Codes for BANK_ACCOUNT_INFO */
708#define BANK_SETTLE_CPU_TIME 0x1 /* Bank ledger(chit) rolled up to tasks. */
709
710/* Codes for ATM_SUBAID_INFO */
711#define ATM_MIN_CALLED 0x1
712#define ATM_LINK_LIST_TRIM 0x2
713
714/* Codes for ATM_GETVALUE_INFO */
715#define ATM_VALUE_REPLACED 0x1
716#define ATM_VALUE_ADDED 0x2
717
718/* Codes for ATM_UNREGISTER_INFO */
719#define ATM_VALUE_UNREGISTERED 0x1
720#define ATM_VALUE_DIFF_MAILBOX 0x2
721
722/* Kernel Debug Sub Classes for daemons (DBG_DAEMON) */
723#define DBG_DAEMON_COREDUET 0x1
724
725/**********************************************************************/
726
727#define KDBG_MIGCODE(msgid) ((DBG_MIG << KDBG_CLASS_OFFSET) | \
728 (((msgid) & 0x3fffff) << KDBG_CODE_OFFSET))
729
730#define MACHDBG_CODE(SubClass, code) KDBG_CODE(DBG_MACH, SubClass, code)
731#define NETDBG_CODE(SubClass, code) KDBG_CODE(DBG_NETWORK, SubClass, code)
732#define FSDBG_CODE(SubClass, code) KDBG_CODE(DBG_FSYSTEM, SubClass, code)
733#define BSDDBG_CODE(SubClass, code) KDBG_CODE(DBG_BSD, SubClass, code)
734#define IOKDBG_CODE(SubClass, code) KDBG_CODE(DBG_IOKIT, SubClass, code)
735#define DRVDBG_CODE(SubClass, code) KDBG_CODE(DBG_DRIVERS, SubClass, code)
736#define TRACEDBG_CODE(SubClass,code) KDBG_CODE(DBG_TRACE, SubClass, code)
737#define MISCDBG_CODE(SubClass,code) KDBG_CODE(DBG_MISC, SubClass, code)
738#define DLILDBG_CODE(SubClass,code) KDBG_CODE(DBG_DLIL, SubClass, code)
739#define SECURITYDBG_CODE(SubClass,code) KDBG_CODE(DBG_SECURITY, SubClass, code)
740#define DYLDDBG_CODE(SubClass,code) KDBG_CODE(DBG_DYLD, SubClass, code)
741#define QTDBG_CODE(SubClass,code) KDBG_CODE(DBG_QT, SubClass, code)
742#define APPSDBG_CODE(SubClass,code) KDBG_CODE(DBG_APPS, SubClass, code)
743#define ARIADNEDBG_CODE(SubClass, code) KDBG_CODE(DBG_ARIADNE, SubClass, code)
744#define DAEMONDBG_CODE(SubClass, code) KDBG_CODE(DBG_DAEMON, SubClass, code)
745#define CPUPM_CODE(code) IOKDBG_CODE(DBG_IOCPUPM, code)
746
747#define KMEM_ALLOC_CODE MACHDBG_CODE(DBG_MACH_LEAKS, 0)
748#define KMEM_ALLOC_CODE_2 MACHDBG_CODE(DBG_MACH_LEAKS, 1)
749#define KMEM_FREE_CODE MACHDBG_CODE(DBG_MACH_LEAKS, 2)
750#define KMEM_FREE_CODE_2 MACHDBG_CODE(DBG_MACH_LEAKS, 3)
751#define ZALLOC_CODE MACHDBG_CODE(DBG_MACH_LEAKS, 4)
752#define ZALLOC_CODE_2 MACHDBG_CODE(DBG_MACH_LEAKS, 5)
753#define ZFREE_CODE MACHDBG_CODE(DBG_MACH_LEAKS, 6)
754#define ZFREE_CODE_2 MACHDBG_CODE(DBG_MACH_LEAKS, 7)
755
756#define PMAP_CODE(code) MACHDBG_CODE(DBG_MACH_PMAP, code)
757
758
759#define IMPORTANCE_CODE(SubClass, code) KDBG_CODE(DBG_IMPORTANCE, (SubClass), (code))
760#define BANK_CODE(SubClass, code) KDBG_CODE(DBG_BANK, (SubClass), (code))
761#define ATM_CODE(SubClass, code) KDBG_CODE(DBG_ATM, (SubClass), (code))
762
763/* Kernel Debug Macros for specific daemons */
764#define COREDUETDBG_CODE(code) DAEMONDBG_CODE(DBG_DAEMON_COREDUET, code)
765
766/* Usage:
767* kernel_debug((KDBG_CODE(DBG_NETWORK, DNET_PROTOCOL, 51) | DBG_FUNC_START),
768* offset, 0, 0, 0,0)
769*
770* For ex,
771*
772* #include <sys/kdebug.h>
773*
774* #define DBG_NETIPINIT NETDBG_CODE(DBG_NETIP,1)
775*
776*
777* void
778* ip_init()
779* {
780* register struct protosw *pr;
781* register int i;
782*
783* KERNEL_DEBUG(DBG_NETIPINIT | DBG_FUNC_START, 0,0,0,0,0)
784* --------
785* KERNEL_DEBUG(DBG_NETIPINIT, 0,0,0,0,0)
786* --------
787* KERNEL_DEBUG(DBG_NETIPINIT | DBG_FUNC_END, 0,0,0,0,0)
788* }
789*
790
791*/
792
793extern unsigned int kdebug_enable;
794#define KDEBUG_ENABLE_TRACE 0x1
795#define KDEBUG_ENABLE_ENTROPY 0x2 /* Obsolescent */
796#define KDEBUG_ENABLE_CHUD 0x4
797#define KDEBUG_ENABLE_PPT 0x8
798#define KDEBUG_ENABLE_SERIAL 0x10
799
800/*
801 * Infer the supported kernel debug event level from config option.
802 * Use (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD) as a guard to protect
803 * unaudited debug code.
804 */
805#define KDEBUG_LEVEL_NONE 0
806#define KDEBUG_LEVEL_IST 1
807#define KDEBUG_LEVEL_STANDARD 2
808#define KDEBUG_LEVEL_FULL 3
809
810#if NO_KDEBUG
811#define KDEBUG_LEVEL KDEBUG_LEVEL_NONE
812#elif IST_KDEBUG
813#define KDEBUG_LEVEL KDEBUG_LEVEL_IST
814 // currently configured for the iOS release kernel
815#elif KDEBUG
816#define KDEBUG_LEVEL KDEBUG_LEVEL_FULL
817#else
818#define KDEBUG_LEVEL KDEBUG_LEVEL_STANDARD
819/* Currently, all other kernel configurations (development, etc)
820 build with KDEBUG_LEVEL_STANDARD. As a result, KERNEL_DEBUG_CONSTANT*()
821 are on by default but KERNEL_DEBUG*() are not.
822*/
823#endif
824
825#if (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD)
826#ifdef XNU_KERNEL_PRIVATE
827#define KERNEL_DEBUG_CONSTANT(x,a,b,c,d,e) \
828do { \
829 if (__improbable(kdebug_enable & ~KDEBUG_ENABLE_PPT)) \
830 kernel_debug(x,(uintptr_t)a,(uintptr_t)b,(uintptr_t)c, \
831 (uintptr_t)d,(uintptr_t)e); \
832} while(0)
833
834#define KERNEL_DEBUG_CONSTANT1(x,a,b,c,d,e) \
835do { \
836 if (__improbable(kdebug_enable & ~KDEBUG_ENABLE_PPT)) \
837 kernel_debug1(x,(uintptr_t)a,(uintptr_t)b,(uintptr_t)c, \
838 (uintptr_t)d,(uintptr_t)e); \
839} while(0)
840
841#define KERNEL_DEBUG_EARLY(x,a,b,c,d) \
842do { \
843 kernel_debug_early((uint32_t)x, (uintptr_t)a, (uintptr_t)b, \
844 (uintptr_t)c, (uintptr_t)d); \
845} while(0)
846#else /* XNU_KERNEL_PRIVATE */
847#define KERNEL_DEBUG_CONSTANT(x,a,b,c,d,e) \
848do { \
849 if (kdebug_enable & ~KDEBUG_ENABLE_PPT) \
850 kernel_debug(x,(uintptr_t)a,(uintptr_t)b,(uintptr_t)c, \
851 (uintptr_t)d,(uintptr_t)e); \
852} while(0)
853
854#define KERNEL_DEBUG_CONSTANT1(x,a,b,c,d,e) \
855do { \
856 if (kdebug_enable & ~KDEBUG_ENABLE_PPT) \
857 kernel_debug1(x,(uintptr_t)a,(uintptr_t)b,(uintptr_t)c, \
858 (uintptr_t)d,(uintptr_t)e); \
859} while(0)
860
861#define KERNEL_DEBUG_EARLY(x,a,b,c,d) \
862do { \
863 kernel_debug_early((uint32_t)x, (uintptr_t)a, (uintptr_t)b, \
864 (uintptr_t)c, (uintptr_t)d); \
865} while(0)
866#endif /* XNU_KERNEL_PRIVATE */
867#else /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD) */
868#define KERNEL_DEBUG_CONSTANT(x,a,b,c,d,e) do { } while(0)
869#define KERNEL_DEBUG_CONSTANT1(x,a,b,c,d,e) do { } while(0)
870#define KERNEL_DEBUG_EARLY(x,a,b,c,d) do { } while(0)
871#endif /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_STANDARD) */
872
873#ifdef KERNEL_PRIVATE
874
875// Abbreviated version of above
876#define KDBG(x, ...) KDBG_(x, ## __VA_ARGS__, 5, 4, 3, 2, 1, 0)
877#define KDBG_(x, a, b, c, d, e, n, ...) KDBG##n(x, a, b, c, d, e)
878#define KDBG0(x, a, b, c, d, e) KERNEL_DEBUG_CONSTANT(x, 0, 0, 0, 0, 0)
879#define KDBG1(x, a, b, c, d, e) KERNEL_DEBUG_CONSTANT(x, a, 0, 0, 0, 0)
880#define KDBG2(x, a, b, c, d, e) KERNEL_DEBUG_CONSTANT(x, a, b, 0, 0, 0)
881#define KDBG3(x, a, b, c, d, e) KERNEL_DEBUG_CONSTANT(x, a, b, c, 0, 0)
882#define KDBG4(x, a, b, c, d, e) KERNEL_DEBUG_CONSTANT(x, a, b, c, d, 0)
883#define KDBG5(x, a, b, c, d, e) KERNEL_DEBUG_CONSTANT(x, a, b, c, d, e)
884
885#endif // KERNEL_PRIVATE
886
887/*
888 * Specify KDEBUG_PPT to indicate that the event belongs to the
889 * limited PPT set.
890 */
891#define KDEBUG_COMMON (KDEBUG_ENABLE_TRACE|KDEBUG_ENABLE_CHUD|KDEBUG_ENABLE_PPT)
892#define KDEBUG_TRACE (KDEBUG_ENABLE_TRACE|KDEBUG_ENABLE_CHUD)
893#define KDEBUG_PPT (KDEBUG_ENABLE_PPT)
894
895/*
896 KERNEL_DEBUG_CONSTANT_IST events provide an audited subset of
897 tracepoints for userland system tracing tools. This tracing level was
898 created by 8857227 to protect fairplayd and other PT_DENY_ATTACH
899 processes. It has two effects: only KERNEL_DEBUG_CONSTANT_IST() traces
900 are emitted and any PT_DENY_ATTACH processes will only emit basic
901 traces as defined by the kernel_debug_filter() routine.
902 */
903#if (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST)
904#ifdef XNU_KERNEL_PRIVATE
905#define KERNEL_DEBUG_CONSTANT_IST(type,x,a,b,c,d,e) \
906do { \
907 if (__improbable(kdebug_enable & type)) \
908 kernel_debug(x,(uintptr_t)a,(uintptr_t)b,(uintptr_t)c, \
909 (uintptr_t)d,(uintptr_t)e); \
910} while(0)
911#else /* XNU_KERNEL_PRIVATE */
912#define KERNEL_DEBUG_CONSTANT_IST(type,x,a,b,c,d,e) \
913do { \
914 if (kdebug_enable & type) \
915 kernel_debug(x,(uintptr_t)a,(uintptr_t)b,(uintptr_t)c, \
916 (uintptr_t)d,(uintptr_t)e); \
917} while(0)
918#endif /* XNU_KERNEL_PRIVATE */
919
920// whether to bother calculating EnergyTracing inputs
921// could chnage in future to see if DBG_ENERGYTRACE is active
922#define ENTR_SHOULDTRACE kdebug_enable
923// encode logical EnergyTracing into 32/64 KDebug trace
924#define ENTR_KDTRACE(component, opcode, lifespan, id, quality, value) \
925do { \
926 uint32_t kdcode__; \
927 uintptr_t highval__, lowval__, mask__ = 0xffffffff; \
928 kdcode__ = KDBG_CODE(DBG_ENERGYTRACE,component,opcode)|(lifespan); \
929 highval__ = ((value) >> 32) & mask__; \
930 lowval__ = (value) & mask__; \
931 ENTR_KDTRACEFUNC(kdcode__, id, quality, highval__, lowval__); \
932} while(0)
933
934/*
935 Trace the association of two existing activations.
936
937 An association is traced as a modification to the parent activation.
938 In order to fit the sub-activation's component, activation code, and
939 activation ID into a kdebug tracepoint, the arguments that would hold
940 the value are left separate, and one stores the component and opcode
941 of the sub-activation, while the other stores the pointer-sized
942 activation ID.
943
944 arg2 arg3 arg4
945 +-----------------+ +~+----+----+--------+ +----------+
946 |kEnTrModAssociate| | | | | | | |
947 +-----------------+ +~+----+----+--------+ +----------+
948 8-bits unused sub-activation ID
949 8-bit sub-component
950 16-bit sub-opcode
951
952*/
953#define kEnTrModAssociate (1 << 28)
954#define ENTR_KDASSOCIATE(par_comp, par_opcode, par_act_id, \
955 sub_comp, sub_opcode, sub_act_id) \
956do { \
957 unsigned sub_compcode = ((unsigned)sub_comp << 16) | sub_opcode; \
958 ENTR_KDTRACEFUNC(KDBG_CODE(DBG_ENERGYTRACE,par_comp,par_opcode), \
959 par_act_id, kEnTrModAssociate, sub_compcode, \
960 sub_act_id); \
961} while(0)
962
963#else /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST) */
964
965#define KERNEL_DEBUG_CONSTANT_IST(type,x,a,b,c,d,e) do { } while(0)
966#define ENTR_SHOULDTRACE FALSE
967#define ENTR_KDTRACE(component, opcode, lifespan, id, quality, value) \
968 do {} while (0)
969#define ENTR_KDASSOCIATE(par_comp, par_opcode, par_act_id, \
970 sub_comp, sub_opcode, sub_act_id) \
971 do {} while (0)
972
973#endif /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_IST) */
974
975#if NO_KDEBUG
976#define __kdebug_constant_only __unused
977#endif
978
979extern void kernel_debug(
980 uint32_t debugid,
981 uintptr_t arg1,
982 uintptr_t arg2,
983 uintptr_t arg3,
984 uintptr_t arg4,
985 uintptr_t arg5);
986
987extern void kernel_debug1(
988 uint32_t debugid,
989 uintptr_t arg1,
990 uintptr_t arg2,
991 uintptr_t arg3,
992 uintptr_t arg4,
993 uintptr_t arg5);
994
995extern void kernel_debug_early(
996 uint32_t debugid,
997 uintptr_t arg1,
998 uintptr_t arg2,
999 uintptr_t arg3,
1000 uintptr_t arg4);
1001
1002#ifdef KERNEL_PRIVATE
1003/*
1004 * kernel_debug_string provides the same functionality as the
1005 * kdebug_trace_string syscall as a KPI. str_id is an in/out
1006 * parameter that, if it's pointing to a string ID of 0, will
1007 * receive a generated ID. If it provides a value in str_id,
1008 * then that will be used, instead.
1009 *
1010 * Returns an errno indicating the type of failure.
1011 */
1012extern int
1013kernel_debug_string(uint32_t debugid, uint64_t *str_id, const char *str);
1014#endif
1015
1016#if (KDEBUG_LEVEL >= KDEBUG_LEVEL_FULL)
1017#ifdef XNU_KERNEL_PRIVATE
1018#define KERNEL_DEBUG(x,a,b,c,d,e) \
1019do { \
1020 if (__improbable(kdebug_enable & ~KDEBUG_ENABLE_PPT)) \
1021 kernel_debug((uint32_t)x, (uintptr_t)a, (uintptr_t)b, \
1022 (uintptr_t)c, (uintptr_t)d, (uintptr_t)e); \
1023} while(0)
1024
1025#define KERNEL_DEBUG1(x,a,b,c,d,e) \
1026do { \
1027 if (__improbable(kdebug_enable & ~KDEBUG_ENABLE_PPT)) \
1028 kernel_debug1((uint32_t)x, (uintptr_t)a, (uintptr_t)b, \
1029 (uintptr_t)c, (uintptr_t)d, (uintptr_t)e); \
1030} while(0)
1031
1032#define __kdebug_only
1033#else /* !XNU_KERNEL_PRIVATE */
1034#define KERNEL_DEBUG(x,a,b,c,d,e) \
1035do { \
1036 if (kdebug_enable & ~KDEBUG_ENABLE_PPT) \
1037 kernel_debug((uint32_t)x, (uintptr_t)a, (uintptr_t)b, \
1038 (uintptr_t)c, (uintptr_t)d, (uintptr_t)e); \
1039} while(0)
1040
1041#define KERNEL_DEBUG1(x,a,b,c,d,e) \
1042do { \
1043 if (kdebug_enable & ~KDEBUG_ENABLE_PPT) \
1044 kernel_debug1((uint32_t)x, (uintptr_t)a, (uintptr_t)b, \
1045 (uintptr_t)c, (uintptr_t)d, (uintptr_t)e); \
1046} while(0)
1047#endif /* XNU_KERNEL_PRIVATE */
1048
1049#else /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_FULL) */
1050
1051#define KERNEL_DEBUG(x,a,b,c,d,e) do {} while (0)
1052#define KERNEL_DEBUG1(x,a,b,c,d,e) do {} while (0)
1053
1054#define __kdebug_only __unused
1055#endif /* (KDEBUG_LEVEL >= KDEBUG_LEVEL_FULL) */
1056
1057
1058// for EnergyTracing user space & clients
1059#define kEnTrCompKernel 2
1060
1061/*
1062 EnergyTracing opcodes
1063
1064 Activations use DBG_FUNC_START/END.
1065 Events are DBG_FUNC_NONE.
1066 */
1067
1068/* Socket reads and writes are uniquely identified by the (sanitized)
1069 pointer to the socket struct in question. To associate this address
1070 with the user space file descriptor, we have a socket activation with
1071 the FD as its identifier and the socket struct pointer as its value.
1072*/
1073#define kEnTrActKernSocket 1
1074#define kEnTrActKernSockRead 2
1075#define kEnTrActKernSockWrite 3
1076
1077#define kEnTrActKernPoll 10
1078#define kEnTrActKernSelect 11
1079#define kEnTrActKernKQWait 12
1080
1081// events
1082#define kEnTrEvUnblocked 256
1083
1084// EnergyTracing flags (the low-order 16 bits of 'quality')
1085#define kEnTrFlagNonBlocking 1 << 0
1086#define kEnTrFlagNoWork 1 << 1
1087
1088// and now the internal mechanism
1089#ifdef KERNEL_PRIVATE
1090
1091// 20452597 requests that the trace macros not take an argument it throws away
1092#define KERNEL_DBG_IST_SANE(x, a, b, c, d) \
1093 KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, x, a, b, c, d, \
1094 0 /*__unused in kernel_debug()*/)
1095#define ENTR_KDTRACEFUNC KERNEL_DBG_IST_SANE
1096
1097// value is int64_t, quality is uint32_t
1098#define KERNEL_ENERGYTRACE(opcode, lifespan, id, quality, value) \
1099 ENTR_KDTRACE(kEnTrCompKernel, opcode, lifespan, id, \
1100 quality, value)
1101#define KERNEL_ENTR_ASSOCIATE(par_opcode, par_act_id, sub_opcode, sub_act_id) \
1102 ENTR_KDASSOCIATE(kEnTrCompKernel, par_opcode, par_act_id, \
1103 kEnTrCompKernel, sub_opcode, sub_act_id)
1104
1105// end EnergyTracing
1106
1107
1108#include <mach/boolean.h>
1109
1110#define NUMPARMS 23
1111
1112struct proc;
1113
1114extern void kdebug_lookup_gen_events(long *dbg_parms, int dbg_namelen, void *dp, boolean_t lookup);
1115extern void kdbg_trace_data(struct proc *proc, long *arg_pid);
1116
1117extern void kdbg_trace_string(struct proc *proc, long *arg1, long *arg2, long *arg3, long *arg4);
1118
1119extern void kdbg_dump_trace_to_file(const char *);
1120void start_kern_tracing(unsigned int, boolean_t);
1121void start_kern_tracing_with_typefilter(unsigned int, boolean_t, unsigned int);
1122struct task;
1123extern void kdbg_get_task_name(char*, int, struct task *task);
1124void disable_wrap(uint32_t *old_slowcheck, uint32_t *old_flags);
1125void enable_wrap(uint32_t old_slowcheck, boolean_t lostevents);
1126void release_storage_unit(int cpu, uint32_t storage_unit);
1127int allocate_storage_unit(int cpu);
1128
1129#define KDBG_CLASS_ENCODE(Class, SubClass) KDBG_EVENTID(Class, SubClass, 0)
1130#define KDBG_CLASS_DECODE(Debugid) (Debugid & KDBG_CSC_MASK)
1131
1132
1133#endif /* KERNEL_PRIVATE */
1134
1135
1136#endif /* __APPLE_API_UNSTABLE */
1137__END_DECLS
1138
1139
1140#ifdef PRIVATE
1141#ifdef __APPLE_API_PRIVATE
1142/*
1143 * private kernel_debug definitions
1144 */
1145
1146typedef struct {
1147 uint64_t timestamp;
1148 uintptr_t arg1;
1149 uintptr_t arg2;
1150 uintptr_t arg3;
1151 uintptr_t arg4;
1152 uintptr_t arg5; /* will hold current thread */
1153 uint32_t debugid;
1154#if defined(__LP64__)
1155 uint32_t cpuid;
1156 uintptr_t unused;
1157#endif
1158} kd_buf;
1159
1160#if !defined(__LP64__)
1161#define KDBG_TIMESTAMP_MASK 0x00ffffffffffffffULL
1162#define KDBG_CPU_MASK 0xff00000000000000ULL
1163#define KDBG_CPU_SHIFT 56
1164static inline void
1165kdbg_set_cpu(kd_buf *kp, int cpu)
1166{
1167 kp->timestamp = (kp->timestamp & KDBG_TIMESTAMP_MASK) |
1168 (((uint64_t) cpu) << KDBG_CPU_SHIFT);
1169}
1170static inline int
1171kdbg_get_cpu(kd_buf *kp)
1172{
1173 return (int) (((kp)->timestamp & KDBG_CPU_MASK) >> KDBG_CPU_SHIFT);
1174}
1175static inline void
1176kdbg_set_timestamp(kd_buf *kp, uint64_t thetime)
1177{
1178 kp->timestamp = thetime & KDBG_TIMESTAMP_MASK;
1179}
1180static inline uint64_t
1181kdbg_get_timestamp(kd_buf *kp)
1182{
1183 return kp->timestamp & KDBG_TIMESTAMP_MASK;
1184}
1185static inline void
1186kdbg_set_timestamp_and_cpu(kd_buf *kp, uint64_t thetime, int cpu)
1187{
1188 kp->timestamp = (thetime & KDBG_TIMESTAMP_MASK) |
1189 (((uint64_t) cpu) << KDBG_CPU_SHIFT);
1190}
1191#else
1192#define KDBG_TIMESTAMP_MASK 0xffffffffffffffffULL
1193static inline void
1194kdbg_set_cpu(kd_buf *kp, int cpu)
1195{
1196 kp->cpuid = cpu;
1197}
1198static inline int
1199kdbg_get_cpu(kd_buf *kp)
1200{
1201 return kp->cpuid;
1202}
1203static inline void
1204kdbg_set_timestamp(kd_buf *kp, uint64_t thetime)
1205{
1206 kp->timestamp = thetime;
1207}
1208static inline uint64_t
1209kdbg_get_timestamp(kd_buf *kp)
1210{
1211 return kp->timestamp;
1212}
1213static inline void
1214kdbg_set_timestamp_and_cpu(kd_buf *kp, uint64_t thetime, int cpu)
1215{
1216 kdbg_set_timestamp(kp, thetime);
1217 kdbg_set_cpu(kp, cpu);
1218}
1219#endif
1220
1221/* 2^16 bits (8 kilobytes), one for each possible class/subclass combination */
1222#define KDBG_TYPEFILTER_BITMAP_SIZE ( (256 * 256) / 8 )
1223
1224/* Debug Flags */
1225#define KDBG_INIT 0x001
1226#define KDBG_NOWRAP 0x002
1227#define KDBG_FREERUN 0x004
1228#define KDBG_WRAPPED 0x008
1229#define KDBG_USERFLAGS (KDBG_FREERUN|KDBG_NOWRAP|KDBG_INIT)
1230#define KDBG_PIDCHECK 0x010
1231#define KDBG_MAPINIT 0x020
1232#define KDBG_PIDEXCLUDE 0x040
1233#define KDBG_LOCKINIT 0x080
1234#define KDBG_LP64 0x100
1235
1236typedef struct {
1237 unsigned int type;
1238 unsigned int value1;
1239 unsigned int value2;
1240 unsigned int value3;
1241 unsigned int value4;
1242
1243} kd_regtype;
1244
1245typedef struct
1246{
1247 int nkdbufs;
1248 int nolog;
1249 int flags;
1250 int nkdthreads;
1251 int bufid;
1252} kbufinfo_t;
1253
1254typedef struct {
1255 uintptr_t thread;
1256 int valid;
1257 char command[20];
1258} kd_threadmap;
1259
1260typedef struct {
1261 uint32_t version_no;
1262 uint32_t cpu_count;
1263} kd_cpumap_header;
1264
1265/* cpumap flags */
1266#define KDBG_CPUMAP_IS_IOP 0x1
1267
1268typedef struct {
1269 uint32_t cpu_id;
1270 uint32_t flags;
1271 char name[8];
1272} kd_cpumap;
1273
1274/*
1275 * TRACE file formats...
1276 *
1277 * RAW_VERSION0
1278 *
1279 * uint32_t #threadmaps
1280 * kd_threadmap[]
1281 * kd_buf[]
1282 *
1283 * RAW_VERSION1
1284 *
1285 * RAW_header, with version_no set to RAW_VERSION1
1286 * kd_threadmap[]
1287 * Empty space to pad alignment to the nearest page boundary.
1288 * kd_buf[]
1289 *
1290 * RAW_VERSION1+
1291 *
1292 * RAW_header, with version_no set to RAW_VERSION1
1293 * kd_threadmap[]
1294 * kd_cpumap_header, with version_no set to RAW_VERSION1
1295 * kd_cpumap[]
1296 * Empty space to pad alignment to the nearest page boundary.
1297 * kd_buf[]
1298 *
1299 * V1+ implementation details...
1300 *
1301 * It would have been nice to add the cpumap data "correctly", but there were
1302 * several obstacles. Existing code attempts to parse both V1 and V0 files.
1303 * Due to the fact that V0 has no versioning or header, the test looks like
1304 * this:
1305 *
1306 * // Read header
1307 * if (header.version_no != RAW_VERSION1) { // Assume V0 }
1308 *
1309 * If we add a VERSION2 file format, all existing code is going to treat that
1310 * as a VERSION0 file when reading it, and crash terribly when trying to read
1311 * RAW_VERSION2 threadmap entries.
1312 *
1313 * To differentiate between a V1 and V1+ file, read as V1 until you reach
1314 * the padding bytes. Then:
1315 *
1316 * boolean_t is_v1plus = FALSE;
1317 * if (padding_bytes >= sizeof(kd_cpumap_header)) {
1318 * kd_cpumap_header header = // read header;
1319 * if (header.version_no == RAW_VERSION1) {
1320 * is_v1plus = TRUE;
1321 * }
1322 * }
1323 *
1324 */
1325
1326typedef struct {
1327 int version_no;
1328 int thread_count;
1329 uint64_t TOD_secs;
1330 uint32_t TOD_usecs;
1331} RAW_header;
1332
1333// Version 3 header
1334// The header chunk has the tag 0x00001000 which also serves as a magic word
1335// that identifies the file as a version 3 trace file. The header payload is
1336// a set of fixed fields followed by a variable number of sub-chunks:
1337/*
1338 ____________________________________________________________________________
1339 | Offset | Size | Field |
1340 ----------------------------------------------------------------------------
1341 | 0 | 4 | Tag (0x00001000) |
1342 | 4 | 4 | Sub-tag. Represents the version of the header. |
1343 | 8 | 8 | Length of header payload (40+8x) |
1344 | 16 | 8 | Time base info. Two 32-bit numbers, numer/denom, |
1345 | | | for converting timestamps to nanoseconds. |
1346 | 24 | 8 | Timestamp of trace start. |
1347 | 32 | 8 | Wall time seconds since Unix epoch. |
1348 | | | As returned by gettimeofday(). |
1349 | 40 | 4 | Wall time microseconds. As returned by gettimeofday(). |
1350 | 44 | 4 | Local time zone offset in minutes. ( " ) |
1351 | 48 | 4 | Type of daylight savings time correction to apply. ( " ) |
1352 | 52 | 4 | Flags. 1 = 64-bit. Remaining bits should be written |
1353 | | | as 0 and ignored when reading. |
1354 | 56 | 8x | Variable number of sub-chunks. None are required. |
1355 | | | Ignore unknown chunks. |
1356 ----------------------------------------------------------------------------
1357*/
1358// NOTE: The header sub-chunks are considered part of the header chunk,
1359// so they must be included in the header chunk’s length field.
1360// The CPU map is an optional sub-chunk of the header chunk. It provides
1361// information about the CPUs that are referenced from the trace events.
1362typedef struct {
1363 uint32_t tag;
1364 uint32_t sub_tag;
1365 uint64_t length;
1366 uint32_t timebase_numer;
1367 uint32_t timebase_denom;
1368 uint64_t timestamp;
1369 uint64_t walltime_secs;
1370 uint32_t walltime_usecs;
1371 uint32_t timezone_minuteswest;
1372 uint32_t timezone_dst;
1373 uint32_t flags;
1374} kd_header_v3;
1375
1376typedef struct {
1377 uint32_t tag;
1378 uint32_t sub_tag;
1379 uint64_t length;
1380} kd_chunk_header_v3;
1381
1382#define RAW_VERSION0 0x55aa0000
1383#define RAW_VERSION1 0x55aa0101
1384#define RAW_VERSION2 0x55aa0200 /* Only used by kperf and Instruments */
1385#define RAW_VERSION3 0x00001000
1386
1387#define V3_CONFIG 0x00001b00
1388#define V3_CPU_MAP 0x00001c00
1389#define V3_THREAD_MAP 0x00001d00
1390#define V3_RAW_EVENTS 0x00001e00
1391#define V3_NULL_CHUNK 0x00002000
1392
1393// The current version of all kernel managed chunks is 1. The
1394// V3_CURRENT_CHUNK_VERSION is added to ease the simple case
1395// when most/all the kernel managed chunks have the same version.
1396
1397#define V3_CURRENT_CHUNK_VERSION 1
1398#define V3_HEADER_VERSION V3_CURRENT_CHUNK_VERSION
1399#define V3_CPUMAP_VERSION V3_CURRENT_CHUNK_VERSION
1400#define V3_THRMAP_VERSION V3_CURRENT_CHUNK_VERSION
1401#define V3_EVENT_DATA_VERSION V3_CURRENT_CHUNK_VERSION
1402
1403// Apis to support writing v3 chunks in the kernel
1404int kdbg_write_v3_chunk_header_to_buffer(void *buffer, uint32_t tag, uint32_t sub_tag, uint64_t length);
1405int kdbg_write_v3_chunk_to_fd(uint32_t tag, uint32_t sub_tag, uint64_t length, void *payload, uint64_t payload_size, int fd);
1406
1407#define KDBG_CLASSTYPE 0x10000
1408#define KDBG_SUBCLSTYPE 0x20000
1409#define KDBG_RANGETYPE 0x40000
1410#define KDBG_TYPENONE 0x80000
1411#define KDBG_CKTYPES 0xF0000
1412
1413#define KDBG_RANGECHECK 0x100000
1414#define KDBG_VALCHECK 0x200000 /* Check up to 4 individual values */
1415
1416#define KDBG_TYPEFILTER_CHECK ((uint32_t) 0x400000) /* Check class and subclass against a bitmap */
1417
1418#define KDBG_BUFINIT 0x80000000
1419
1420/* Minimum value allowed when setting decrementer ticks */
1421#define KDBG_MINRTCDEC 2500
1422
1423/* VFS lookup events for serial traces */
1424#define VFS_LOOKUP (FSDBG_CODE(DBG_FSRW,36))
1425#define VFS_LOOKUP_DONE (FSDBG_CODE(DBG_FSRW,39))
1426
1427#ifdef XNU_KERNEL_PRIVATE
1428#if (DEVELOPMENT || DEBUG)
1429#define KDEBUG_MOJO_TRACE 1
1430#endif
1431#endif
1432
1433#endif /* __APPLE_API_PRIVATE */
1434#endif /* PRIVATE */
1435
1436#endif /* !BSD_SYS_KDEBUG_H */