1 | /* |
2 | * Copyright (c) 2000-2016 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 | * @OSF_COPYRIGHT@ |
30 | */ |
31 | /* |
32 | * Mach Operating System |
33 | * Copyright (c) 1991,1990,1989 Carnegie Mellon University |
34 | * All Rights Reserved. |
35 | * |
36 | * Permission to use, copy, modify and distribute this software and its |
37 | * documentation is hereby granted, provided that both the copyright |
38 | * notice and this permission notice appear in all copies of the |
39 | * software, derivative works or modified versions, and any portions |
40 | * thereof, and that both notices appear in supporting documentation. |
41 | * |
42 | * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" |
43 | * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR |
44 | * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. |
45 | * |
46 | * Carnegie Mellon requests users of this software to return to |
47 | * |
48 | * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU |
49 | * School of Computer Science |
50 | * Carnegie Mellon University |
51 | * Pittsburgh PA 15213-3890 |
52 | * |
53 | * any improvements or extensions that they make and grant Carnegie Mellon |
54 | * the rights to redistribute these changes. |
55 | */ |
56 | |
57 | #include <mach_assert.h> |
58 | #include <mach_kdp.h> |
59 | #include <kdp/kdp.h> |
60 | #include <kdp/kdp_core.h> |
61 | #include <kdp/kdp_internal.h> |
62 | #include <kdp/kdp_callout.h> |
63 | #include <kern/cpu_number.h> |
64 | #include <kern/kalloc.h> |
65 | #include <kern/spl.h> |
66 | #include <kern/thread.h> |
67 | #include <kern/assert.h> |
68 | #include <kern/sched_prim.h> |
69 | #include <kern/misc_protos.h> |
70 | #include <kern/clock.h> |
71 | #include <kern/telemetry.h> |
72 | #include <kern/ecc.h> |
73 | #include <kern/kern_cdata.h> |
74 | #include <kern/zalloc.h> |
75 | #include <vm/vm_kern.h> |
76 | #include <vm/pmap.h> |
77 | #include <stdarg.h> |
78 | #include <stdatomic.h> |
79 | #include <sys/pgo.h> |
80 | #include <console/serial_protos.h> |
81 | |
82 | #if !(MACH_KDP && CONFIG_KDP_INTERACTIVE_DEBUGGING) |
83 | #include <kdp/kdp_udp.h> |
84 | #endif |
85 | #include <kern/processor.h> |
86 | |
87 | #if defined(__i386__) || defined(__x86_64__) |
88 | #include <i386/cpu_threads.h> |
89 | #include <i386/pmCPU.h> |
90 | #endif |
91 | |
92 | #include <IOKit/IOPlatformExpert.h> |
93 | #include <machine/pal_routines.h> |
94 | |
95 | #include <sys/kdebug.h> |
96 | #include <libkern/OSKextLibPrivate.h> |
97 | #include <libkern/OSAtomic.h> |
98 | #include <libkern/kernel_mach_header.h> |
99 | #include <libkern/section_keywords.h> |
100 | #include <uuid/uuid.h> |
101 | #include <mach_debug/zone_info.h> |
102 | |
103 | #include <os/log_private.h> |
104 | |
105 | #if CONFIG_EMBEDDED |
106 | #include <pexpert/pexpert.h> /* For gPanicBase */ |
107 | #include <arm/caches_internal.h> |
108 | #include <arm/misc_protos.h> |
109 | extern volatile struct xnu_hw_shmem_dbg_command_info *hwsd_info; |
110 | #endif |
111 | |
112 | #if CONFIG_XNUPOST |
113 | #include <tests/xnupost.h> |
114 | extern int vsnprintf(char *, size_t, const char *, va_list); |
115 | #endif |
116 | |
117 | unsigned int halt_in_debugger = 0; |
118 | unsigned int current_debugger = 0; |
119 | unsigned int active_debugger = 0; |
120 | unsigned int panicDebugging = FALSE; |
121 | unsigned int kdebug_serial = FALSE; |
122 | unsigned int kernel_debugger_entry_count = 0; |
123 | |
124 | |
125 | #if defined(__arm__) |
126 | #define TRAP_DEBUGGER __asm__ volatile("trap") |
127 | #elif defined(__arm64__) |
128 | /* |
129 | * Magic number; this should be identical to the __arm__ encoding for trap. |
130 | */ |
131 | #define TRAP_DEBUGGER __asm__ volatile(".long 0xe7ffdeff") |
132 | #elif defined (__x86_64__) |
133 | #define TRAP_DEBUGGER __asm__("int3") |
134 | #else |
135 | #error No TRAP_DEBUGGER for this architecture |
136 | #endif |
137 | |
138 | #if defined(__i386__) || defined(__x86_64__) |
139 | #define panic_stop() pmCPUHalt(PM_HALT_PANIC) |
140 | #else |
141 | #define panic_stop() panic_spin_forever() |
142 | #endif |
143 | |
144 | #define CPUDEBUGGEROP PROCESSOR_DATA(current_processor(), debugger_state).db_current_op |
145 | #define CPUDEBUGGERMSG PROCESSOR_DATA(current_processor(), debugger_state).db_message |
146 | #define CPUPANICSTR PROCESSOR_DATA(current_processor(), debugger_state).db_panic_str |
147 | #define CPUPANICARGS PROCESSOR_DATA(current_processor(), debugger_state).db_panic_args |
148 | #define CPUPANICOPTS PROCESSOR_DATA(current_processor(), debugger_state).db_panic_options |
149 | #define CPUPANICDATAPTR PROCESSOR_DATA(current_processor(), debugger_state).db_panic_data_ptr |
150 | #define CPUDEBUGGERSYNC PROCESSOR_DATA(current_processor(), debugger_state).db_proceed_on_sync_failure |
151 | #define CPUDEBUGGERCOUNT PROCESSOR_DATA(current_processor(), debugger_state).db_entry_count |
152 | #define CPUDEBUGGERRET PROCESSOR_DATA(current_processor(), debugger_state).db_op_return |
153 | #define CPUPANICCALLER PROCESSOR_DATA(current_processor(), debugger_state).db_panic_caller |
154 | |
155 | #if DEVELOPMENT || DEBUG |
156 | #define DEBUGGER_DEBUGGING_NESTED_PANIC_IF_REQUESTED(requested) \ |
157 | MACRO_BEGIN \ |
158 | if (requested) { \ |
159 | volatile int *badpointer = (int *)4; \ |
160 | *badpointer = 0; \ |
161 | } \ |
162 | MACRO_END |
163 | #endif /* DEVELOPMENT || DEBUG */ |
164 | |
165 | debugger_op debugger_current_op = DBOP_NONE; |
166 | const char *debugger_panic_str = NULL; |
167 | va_list *debugger_panic_args = NULL; |
168 | void *debugger_panic_data = NULL; |
169 | uint64_t debugger_panic_options = 0; |
170 | const char *debugger_message = NULL; |
171 | unsigned long debugger_panic_caller = 0; |
172 | |
173 | void panic_trap_to_debugger(const char *panic_format_str, va_list *panic_args, unsigned int reason, void *ctx, |
174 | uint64_t panic_options_mask, void *panic_data, unsigned long panic_caller); |
175 | static void kdp_machine_reboot_type(unsigned int type); |
176 | __attribute__((noreturn)) void panic_spin_forever(void); |
177 | extern kern_return_t do_stackshot(void); |
178 | |
179 | int mach_assert = 1; |
180 | |
181 | #define NESTEDDEBUGGERENTRYMAX 5 |
182 | |
183 | #if CONFIG_EMBEDDED |
184 | #define DEBUG_BUF_SIZE (4096) |
185 | #define KDBG_TRACE_PANIC_FILENAME "/var/log/panic.trace" |
186 | #else |
187 | /* |
188 | * EXTENDED_/DEBUG_BUF_SIZE can't grow without updates to SMC and iBoot to store larger panic logs on co-processor systems */ |
189 | #define DEBUG_BUF_SIZE ((3 * PAGE_SIZE) + offsetof(struct macos_panic_header, mph_data)) |
190 | #define EXTENDED_DEBUG_BUF_SIZE 0x0013ff80 |
191 | static_assert(((EXTENDED_DEBUG_BUF_SIZE % PANIC_FLUSH_BOUNDARY) == 0), "Extended debug buf size must match SMC alignment requirements" ); |
192 | #define KDBG_TRACE_PANIC_FILENAME "/var/tmp/panic.trace" |
193 | #endif |
194 | |
195 | /* debug_buf is directly linked with iBoot panic region for embedded targets */ |
196 | #if CONFIG_EMBEDDED |
197 | char *debug_buf_base = NULL; |
198 | char *debug_buf_ptr = NULL; |
199 | unsigned int debug_buf_size = 0; |
200 | #else |
201 | char debug_buf[DEBUG_BUF_SIZE]; |
202 | struct macos_panic_header *panic_info = (struct macos_panic_header *)debug_buf; |
203 | char *debug_buf_base = (debug_buf + offsetof(struct macos_panic_header, mph_data)); |
204 | char *debug_buf_ptr = (debug_buf + offsetof(struct macos_panic_header, mph_data)); |
205 | |
206 | /* |
207 | * We don't include the size of the panic header in the length of the data we actually write. |
208 | * On co-processor platforms, we lose sizeof(struct macos_panic_header) bytes from the end of |
209 | * the end of the log because we only support writing (3*PAGESIZE) bytes. |
210 | */ |
211 | unsigned int debug_buf_size = (DEBUG_BUF_SIZE - offsetof(struct macos_panic_header, mph_data)); |
212 | |
213 | boolean_t extended_debug_log_enabled = FALSE; |
214 | #endif |
215 | |
216 | /* Debugger state */ |
217 | atomic_int debugger_cpu = ATOMIC_VAR_INIT(DEBUGGER_NO_CPU); |
218 | boolean_t debugger_allcpus_halted = FALSE; |
219 | boolean_t debugger_safe_to_return = TRUE; |
220 | unsigned int debugger_context = 0; |
221 | |
222 | static char model_name[64]; |
223 | unsigned char *kernel_uuid; |
224 | |
225 | boolean_t kernelcache_uuid_valid = FALSE; |
226 | uuid_t kernelcache_uuid; |
227 | uuid_string_t kernelcache_uuid_string; |
228 | |
229 | /* |
230 | * By default we treat Debugger() the same as calls to panic(), unless |
231 | * we have debug boot-args present and the DB_KERN_DUMP_ON_NMI *NOT* set. |
232 | * If DB_KERN_DUMP_ON_NMI is *NOT* set, return from Debugger() is supported. |
233 | * |
234 | * Return from Debugger() is currently only implemented on x86 |
235 | */ |
236 | static boolean_t debugger_is_panic = TRUE; |
237 | |
238 | #if DEVELOPMENT || DEBUG |
239 | boolean_t debug_boot_arg_inited = FALSE; |
240 | #endif |
241 | |
242 | SECURITY_READ_ONLY_LATE(unsigned int) debug_boot_arg; |
243 | |
244 | char kernel_uuid_string[37]; /* uuid_string_t */ |
245 | char kernelcache_uuid_string[37]; /* uuid_string_t */ |
246 | char panic_disk_error_description[512]; |
247 | size_t panic_disk_error_description_size = sizeof(panic_disk_error_description); |
248 | |
249 | extern unsigned int write_trace_on_panic; |
250 | int kext_assertions_enable = |
251 | #if DEBUG || DEVELOPMENT |
252 | TRUE; |
253 | #else |
254 | FALSE; |
255 | #endif |
256 | |
257 | void |
258 | panic_init(void) |
259 | { |
260 | unsigned long uuidlen = 0; |
261 | void *uuid; |
262 | |
263 | uuid = getuuidfromheader(&_mh_execute_header, &uuidlen); |
264 | if ((uuid != NULL) && (uuidlen == sizeof(uuid_t))) { |
265 | kernel_uuid = uuid; |
266 | uuid_unparse_upper(*(uuid_t *)uuid, kernel_uuid_string); |
267 | } |
268 | |
269 | if (!PE_parse_boot_argn("assertions" , &mach_assert, sizeof(mach_assert))) { |
270 | mach_assert = 1; |
271 | } |
272 | |
273 | /* |
274 | * Initialize the value of the debug boot-arg |
275 | */ |
276 | debug_boot_arg = 0; |
277 | #if ((CONFIG_EMBEDDED && MACH_KDP) || defined(__x86_64__)) |
278 | if (PE_parse_boot_argn("debug" , &debug_boot_arg, sizeof (debug_boot_arg))) { |
279 | #if DEVELOPMENT || DEBUG |
280 | if (debug_boot_arg & DB_HALT) { |
281 | halt_in_debugger=1; |
282 | } |
283 | #endif |
284 | |
285 | #if CONFIG_EMBEDDED |
286 | if (debug_boot_arg & DB_NMI) { |
287 | panicDebugging = TRUE; |
288 | } |
289 | #else |
290 | panicDebugging = TRUE; |
291 | #if KDEBUG_MOJO_TRACE |
292 | if (debug_boot_arg & DB_PRT_KDEBUG) { |
293 | kdebug_serial = TRUE; |
294 | } |
295 | #endif |
296 | #endif /* CONFIG_EMBEDDED */ |
297 | } |
298 | #endif /* ((CONFIG_EMBEDDED && MACH_KDP) || defined(__x86_64__)) */ |
299 | |
300 | #if DEVELOPMENT || DEBUG |
301 | debug_boot_arg_inited = TRUE; |
302 | #endif |
303 | |
304 | #if !CONFIG_EMBEDDED |
305 | /* |
306 | * By default we treat Debugger() the same as calls to panic(), unless |
307 | * we have debug boot-args present and the DB_KERN_DUMP_ON_NMI *NOT* set. |
308 | * If DB_KERN_DUMP_ON_NMI is *NOT* set, return from Debugger() is supported. |
309 | * This is because writing an on-device corefile is a destructive operation. |
310 | * |
311 | * Return from Debugger() is currently only implemented on x86 |
312 | */ |
313 | if (PE_i_can_has_debugger(NULL) && !(debug_boot_arg & DB_KERN_DUMP_ON_NMI)) { |
314 | debugger_is_panic = FALSE; |
315 | } |
316 | #endif |
317 | |
318 | } |
319 | |
320 | #if defined (__x86_64__) |
321 | void |
322 | extended_debug_log_init(void) |
323 | { |
324 | assert(coprocessor_paniclog_flush); |
325 | /* |
326 | * Allocate an extended panic log buffer that has space for the panic |
327 | * stackshot at the end. Update the debug buf pointers appropriately |
328 | * to point at this new buffer. |
329 | */ |
330 | char *new_debug_buf = kalloc(EXTENDED_DEBUG_BUF_SIZE); |
331 | /* |
332 | * iBoot pre-initializes the panic region with the NULL character. We set this here |
333 | * so we can accurately calculate the CRC for the region without needing to flush the |
334 | * full region over SMC. |
335 | */ |
336 | memset(new_debug_buf, '\0', EXTENDED_DEBUG_BUF_SIZE); |
337 | |
338 | panic_info = (struct macos_panic_header *)new_debug_buf; |
339 | debug_buf_ptr = debug_buf_base = (new_debug_buf + offsetof(struct macos_panic_header, mph_data)); |
340 | debug_buf_size = (EXTENDED_DEBUG_BUF_SIZE - offsetof(struct macos_panic_header, mph_data)); |
341 | |
342 | extended_debug_log_enabled = TRUE; |
343 | } |
344 | #endif /* defined (__x86_64__) */ |
345 | |
346 | void |
347 | debug_log_init(void) |
348 | { |
349 | #if CONFIG_EMBEDDED |
350 | if (!gPanicBase) { |
351 | printf("debug_log_init: Error!! gPanicBase is still not initialized\n" ); |
352 | return; |
353 | } |
354 | /* Shift debug buf start location and size by the length of the panic header */ |
355 | debug_buf_base = (char *)gPanicBase + sizeof(struct embedded_panic_header); |
356 | debug_buf_ptr = debug_buf_base; |
357 | debug_buf_size = gPanicSize - sizeof(struct embedded_panic_header); |
358 | #else |
359 | bzero(panic_info, DEBUG_BUF_SIZE); |
360 | |
361 | assert(debug_buf_base != NULL); |
362 | assert(debug_buf_ptr != NULL); |
363 | assert(debug_buf_size != 0); |
364 | #endif |
365 | } |
366 | |
367 | static void |
368 | DebuggerLock() |
369 | { |
370 | int my_cpu = cpu_number(); |
371 | int debugger_exp_cpu = DEBUGGER_NO_CPU; |
372 | assert(ml_get_interrupts_enabled() == FALSE); |
373 | |
374 | if (debugger_cpu == my_cpu) { |
375 | return; |
376 | } |
377 | |
378 | while(!atomic_compare_exchange_strong(&debugger_cpu, &debugger_exp_cpu, my_cpu)) { |
379 | debugger_exp_cpu = DEBUGGER_NO_CPU; |
380 | } |
381 | |
382 | return; |
383 | } |
384 | |
385 | static void |
386 | DebuggerUnlock() |
387 | { |
388 | assert(debugger_cpu == cpu_number()); |
389 | |
390 | /* |
391 | * We don't do an atomic exchange here in case |
392 | * there's another CPU spinning to acquire the debugger_lock |
393 | * and we never get a chance to update it. We already have the |
394 | * lock so we can simply store DEBUGGER_NO_CPU and follow with |
395 | * a barrier. |
396 | */ |
397 | debugger_cpu = DEBUGGER_NO_CPU; |
398 | OSMemoryBarrier(); |
399 | |
400 | return; |
401 | } |
402 | |
403 | static kern_return_t |
404 | DebuggerHaltOtherCores(boolean_t proceed_on_failure) |
405 | { |
406 | #if CONFIG_EMBEDDED |
407 | return DebuggerXCallEnter(proceed_on_failure); |
408 | #else /* CONFIG_EMBEDDED */ |
409 | #pragma unused(proceed_on_failure) |
410 | mp_kdp_enter(proceed_on_failure); |
411 | return KERN_SUCCESS; |
412 | #endif |
413 | } |
414 | |
415 | static void |
416 | DebuggerResumeOtherCores() |
417 | { |
418 | #if CONFIG_EMBEDDED |
419 | DebuggerXCallReturn(); |
420 | #else /* CONFIG_EMBEDDED */ |
421 | mp_kdp_exit(); |
422 | #endif |
423 | } |
424 | |
425 | static void |
426 | DebuggerSaveState(debugger_op db_op, const char *db_message, const char *db_panic_str, |
427 | va_list *db_panic_args, uint64_t db_panic_options, void *db_panic_data_ptr, |
428 | boolean_t db_proceed_on_sync_failure, unsigned long db_panic_caller) |
429 | { |
430 | CPUDEBUGGEROP = db_op; |
431 | |
432 | /* Preserve the original panic message */ |
433 | if (CPUDEBUGGERCOUNT == 1 || CPUPANICSTR == NULL) { |
434 | CPUDEBUGGERMSG = db_message; |
435 | CPUPANICSTR = db_panic_str; |
436 | CPUPANICARGS = db_panic_args; |
437 | CPUPANICDATAPTR = db_panic_data_ptr; |
438 | CPUPANICCALLER = db_panic_caller; |
439 | } else if (CPUDEBUGGERCOUNT > 1 && db_panic_str != NULL) { |
440 | kprintf("Nested panic detected:" ); |
441 | if (db_panic_str != NULL) |
442 | _doprnt(db_panic_str, db_panic_args, PE_kputc, 0); |
443 | } |
444 | |
445 | CPUDEBUGGERSYNC = db_proceed_on_sync_failure; |
446 | CPUDEBUGGERRET = KERN_SUCCESS; |
447 | |
448 | /* Reset these on any nested panics */ |
449 | CPUPANICOPTS = db_panic_options; |
450 | |
451 | return; |
452 | } |
453 | |
454 | /* |
455 | * Save the requested debugger state/action into the current processor's processor_data |
456 | * and trap to the debugger. |
457 | */ |
458 | kern_return_t |
459 | DebuggerTrapWithState(debugger_op db_op, const char *db_message, const char *db_panic_str, |
460 | va_list *db_panic_args, uint64_t db_panic_options, void *db_panic_data_ptr, |
461 | boolean_t db_proceed_on_sync_failure, unsigned long db_panic_caller) |
462 | { |
463 | kern_return_t ret; |
464 | |
465 | assert(ml_get_interrupts_enabled() == FALSE); |
466 | DebuggerSaveState(db_op, db_message, db_panic_str, db_panic_args, |
467 | db_panic_options, db_panic_data_ptr, |
468 | db_proceed_on_sync_failure, db_panic_caller); |
469 | |
470 | TRAP_DEBUGGER; |
471 | |
472 | ret = CPUDEBUGGERRET; |
473 | |
474 | DebuggerSaveState(DBOP_NONE, NULL, NULL, NULL, 0, NULL, FALSE, 0); |
475 | |
476 | return ret; |
477 | } |
478 | |
479 | void __attribute__((noinline)) |
480 | Assert( |
481 | const char *file, |
482 | int line, |
483 | const char *expression |
484 | ) |
485 | { |
486 | if (!mach_assert) { |
487 | kprintf("%s:%d non-fatal Assertion: %s" , file, line, expression); |
488 | return; |
489 | } |
490 | |
491 | panic_plain("%s:%d Assertion failed: %s" , file, line, expression); |
492 | } |
493 | |
494 | |
495 | void |
496 | Debugger(const char *message) |
497 | { |
498 | DebuggerWithContext(0, NULL, message, DEBUGGER_OPTION_NONE); |
499 | } |
500 | |
501 | void |
502 | DebuggerWithContext(unsigned int reason, void *ctx, const char *message, |
503 | uint64_t debugger_options_mask) |
504 | { |
505 | spl_t previous_interrupts_state; |
506 | boolean_t old_doprnt_hide_pointers = doprnt_hide_pointers; |
507 | |
508 | previous_interrupts_state = ml_set_interrupts_enabled(FALSE); |
509 | disable_preemption(); |
510 | |
511 | CPUDEBUGGERCOUNT++; |
512 | |
513 | if (CPUDEBUGGERCOUNT > NESTEDDEBUGGERENTRYMAX) { |
514 | static boolean_t in_panic_kprintf = FALSE; |
515 | |
516 | /* Notify any listeners that we've started a panic */ |
517 | PEHaltRestart(kPEPanicBegin); |
518 | |
519 | if (!in_panic_kprintf) { |
520 | in_panic_kprintf = TRUE; |
521 | kprintf("Detected nested debugger entry count exceeding %d\n" , |
522 | NESTEDDEBUGGERENTRYMAX); |
523 | in_panic_kprintf = FALSE; |
524 | } |
525 | |
526 | if (!panicDebugging) { |
527 | kdp_machine_reboot_type(kPEPanicRestartCPU); |
528 | } |
529 | |
530 | panic_spin_forever(); |
531 | } |
532 | |
533 | #if DEVELOPMENT || DEBUG |
534 | DEBUGGER_DEBUGGING_NESTED_PANIC_IF_REQUESTED((debugger_options_mask & DEBUGGER_OPTION_RECURPANIC_ENTRY)); |
535 | #endif |
536 | |
537 | doprnt_hide_pointers = FALSE; |
538 | |
539 | if (ctx != NULL) { |
540 | DebuggerSaveState(DBOP_DEBUGGER, message, |
541 | NULL, NULL, debugger_options_mask, NULL, TRUE, 0); |
542 | handle_debugger_trap(reason, 0, 0, ctx); |
543 | DebuggerSaveState(DBOP_NONE, NULL, NULL, |
544 | NULL, 0, NULL, FALSE, 0); |
545 | } else { |
546 | DebuggerTrapWithState(DBOP_DEBUGGER, message, |
547 | NULL, NULL, debugger_options_mask, NULL, TRUE, 0); |
548 | } |
549 | |
550 | CPUDEBUGGERCOUNT--; |
551 | doprnt_hide_pointers = old_doprnt_hide_pointers; |
552 | enable_preemption(); |
553 | ml_set_interrupts_enabled(previous_interrupts_state); |
554 | } |
555 | |
556 | static struct kdp_callout { |
557 | struct kdp_callout * callout_next; |
558 | kdp_callout_fn_t callout_fn; |
559 | boolean_t callout_in_progress; |
560 | void * callout_arg; |
561 | } * kdp_callout_list = NULL; |
562 | |
563 | /* |
564 | * Called from kernel context to register a kdp event callout. |
565 | */ |
566 | void |
567 | kdp_register_callout(kdp_callout_fn_t fn, void * arg) |
568 | { |
569 | struct kdp_callout * kcp; |
570 | struct kdp_callout * list_head; |
571 | |
572 | kcp = kalloc(sizeof(*kcp)); |
573 | if (kcp == NULL) |
574 | panic("kdp_register_callout() kalloc failed" ); |
575 | |
576 | kcp->callout_fn = fn; |
577 | kcp->callout_arg = arg; |
578 | kcp->callout_in_progress = FALSE; |
579 | |
580 | /* Lock-less list insertion using compare and exchange. */ |
581 | do { |
582 | list_head = kdp_callout_list; |
583 | kcp->callout_next = list_head; |
584 | } while (!OSCompareAndSwapPtr(list_head, kcp, &kdp_callout_list)); |
585 | } |
586 | |
587 | static void |
588 | kdp_callouts(kdp_event_t event) |
589 | { |
590 | struct kdp_callout *kcp = kdp_callout_list; |
591 | |
592 | while (kcp) { |
593 | if (!kcp->callout_in_progress) { |
594 | kcp->callout_in_progress = TRUE; |
595 | kcp->callout_fn(kcp->callout_arg, event); |
596 | kcp->callout_in_progress = FALSE; |
597 | } |
598 | kcp = kcp->callout_next; |
599 | } |
600 | } |
601 | |
602 | /* |
603 | * An overview of the xnu panic path: |
604 | * |
605 | * Several panic wrappers (panic(), panic_with_options(), etc.) all funnel into panic_trap_to_debugger(). |
606 | * panic_trap_to_debugger() sets the panic state in the current processor's processor_data_t prior |
607 | * to trapping into the debugger. Once we trap to the debugger, we end up in handle_debugger_trap() |
608 | * which tries to acquire the panic lock by atomically swapping the current CPU number into debugger_cpu. |
609 | * debugger_cpu acts as a synchronization point, from which the winning CPU can halt the other cores and |
610 | * continue to debugger_collect_diagnostics() where we write the paniclog, corefile (if appropriate) and proceed |
611 | * according to the device's boot-args. |
612 | */ |
613 | #undef panic |
614 | void |
615 | panic(const char *str, ...) |
616 | { |
617 | va_list panic_str_args; |
618 | |
619 | va_start(panic_str_args, str); |
620 | panic_trap_to_debugger(str, &panic_str_args, 0, NULL, 0, NULL, (unsigned long)(char *)__builtin_return_address(0)); |
621 | va_end(panic_str_args); |
622 | } |
623 | |
624 | void |
625 | panic_with_options(unsigned int reason, void *ctx, uint64_t debugger_options_mask, const char *str, ...) |
626 | { |
627 | va_list panic_str_args; |
628 | |
629 | va_start(panic_str_args, str); |
630 | panic_trap_to_debugger(str, &panic_str_args, reason, ctx, (debugger_options_mask & ~DEBUGGER_INTERNAL_OPTIONS_MASK), |
631 | NULL, (unsigned long)(char *)__builtin_return_address(0)); |
632 | va_end(panic_str_args); |
633 | } |
634 | |
635 | #if defined (__x86_64__) |
636 | /* |
637 | * panic_with_thread_context() is used on x86 platforms to specify a different thread that should be backtraced in the paniclog. |
638 | * We don't generally need this functionality on embedded platforms because embedded platforms include a panic time stackshot |
639 | * from customer devices. We plumb the thread pointer via the debugger trap mechanism and backtrace the kernel stack from the |
640 | * thread when writing the panic log. |
641 | * |
642 | * NOTE: panic_with_thread_context() should be called with an explicit thread reference held on the passed thread. |
643 | */ |
644 | void |
645 | panic_with_thread_context(unsigned int reason, void *ctx, uint64_t debugger_options_mask, thread_t thread, const char *str, ...) |
646 | { |
647 | va_list panic_str_args; |
648 | __assert_only uint32_t th_ref_count; |
649 | |
650 | assert_thread_magic(thread); |
651 | th_ref_count = atomic_load_explicit(&thread->ref_count, memory_order_acquire); |
652 | assertf(th_ref_count > 0, "panic_with_thread_context called with invalid thread %p with refcount %u" , thread, th_ref_count); |
653 | |
654 | /* Take a reference on the thread so it doesn't disappear by the time we try to backtrace it */ |
655 | thread_reference(thread); |
656 | |
657 | va_start(panic_str_args, str); |
658 | panic_trap_to_debugger(str, &panic_str_args, reason, ctx, ((debugger_options_mask & ~DEBUGGER_INTERNAL_OPTIONS_MASK) | DEBUGGER_INTERNAL_OPTION_THREAD_BACKTRACE), |
659 | thread, (unsigned long)(char *)__builtin_return_address(0)); |
660 | |
661 | va_end(panic_str_args); |
662 | |
663 | } |
664 | #endif /* defined (__x86_64__) */ |
665 | |
666 | #pragma clang diagnostic push |
667 | #pragma clang diagnostic ignored "-Wmissing-noreturn" |
668 | void |
669 | panic_trap_to_debugger(const char *panic_format_str, va_list *panic_args, unsigned int reason, void *ctx, |
670 | uint64_t panic_options_mask, void *panic_data_ptr, unsigned long panic_caller) |
671 | { |
672 | #pragma clang diagnostic pop |
673 | |
674 | if (ml_wants_panic_trap_to_debugger()) { |
675 | ml_panic_trap_to_debugger(panic_format_str, panic_args, reason, ctx, panic_options_mask, panic_caller); |
676 | |
677 | /* |
678 | * This should not return, but we return here for the tail call |
679 | * as it simplifies the backtrace. |
680 | */ |
681 | return; |
682 | } |
683 | |
684 | CPUDEBUGGERCOUNT++; |
685 | |
686 | if (CPUDEBUGGERCOUNT > NESTEDDEBUGGERENTRYMAX) { |
687 | static boolean_t in_panic_kprintf = FALSE; |
688 | |
689 | /* Notify any listeners that we've started a panic */ |
690 | PEHaltRestart(kPEPanicBegin); |
691 | |
692 | if (!in_panic_kprintf) { |
693 | in_panic_kprintf = TRUE; |
694 | kprintf("Detected nested debugger entry count exceeding %d\n" , |
695 | NESTEDDEBUGGERENTRYMAX); |
696 | in_panic_kprintf = FALSE; |
697 | } |
698 | |
699 | if (!panicDebugging) { |
700 | kdp_machine_reboot_type(kPEPanicRestartCPU); |
701 | } |
702 | |
703 | panic_spin_forever(); |
704 | } |
705 | |
706 | #if DEVELOPMENT || DEBUG |
707 | DEBUGGER_DEBUGGING_NESTED_PANIC_IF_REQUESTED((panic_options_mask & DEBUGGER_OPTION_RECURPANIC_ENTRY)); |
708 | #endif |
709 | |
710 | #if CONFIG_EMBEDDED |
711 | if (PE_arm_debug_panic_hook) |
712 | PE_arm_debug_panic_hook(panic_format_str); |
713 | #endif |
714 | |
715 | #if defined (__x86_64__) |
716 | plctrace_disable(); |
717 | #endif |
718 | |
719 | if (write_trace_on_panic && kdebug_enable) { |
720 | if (get_preemption_level() == 0 && !ml_at_interrupt_context()) { |
721 | ml_set_interrupts_enabled(TRUE); |
722 | KDBG_RELEASE(TRACE_PANIC); |
723 | kdbg_dump_trace_to_file(KDBG_TRACE_PANIC_FILENAME); |
724 | } |
725 | } |
726 | |
727 | ml_set_interrupts_enabled(FALSE); |
728 | disable_preemption(); |
729 | |
730 | #if defined (__x86_64__) |
731 | pmSafeMode(x86_lcpu(), PM_SAFE_FL_SAFE); |
732 | #endif /* defined (__x86_64__) */ |
733 | |
734 | /* Never hide pointers from panic logs. */ |
735 | doprnt_hide_pointers = FALSE; |
736 | |
737 | if (ctx != NULL) { |
738 | /* |
739 | * We called into panic from a trap, no need to trap again. Set the |
740 | * state on the current CPU and then jump to handle_debugger_trap. |
741 | */ |
742 | DebuggerSaveState(DBOP_PANIC, "panic" , |
743 | panic_format_str, panic_args, |
744 | panic_options_mask, panic_data_ptr, TRUE, panic_caller); |
745 | handle_debugger_trap(reason, 0, 0, ctx); |
746 | } |
747 | |
748 | #if defined(__arm64__) |
749 | /* |
750 | * Signal to fastsim that it should open debug ports (nop on hardware) |
751 | */ |
752 | __asm__ volatile("HINT 0x45" ); |
753 | #endif /* defined(__arm64__) */ |
754 | |
755 | DebuggerTrapWithState(DBOP_PANIC, "panic" , panic_format_str, |
756 | panic_args, panic_options_mask, panic_data_ptr, TRUE, panic_caller); |
757 | |
758 | /* |
759 | * Not reached. |
760 | */ |
761 | panic_stop(); |
762 | } |
763 | |
764 | __attribute__((noreturn)) |
765 | void |
766 | panic_spin_forever() |
767 | { |
768 | paniclog_append_noflush("\nPlease go to https://panic.apple.com to report this panic\n" ); |
769 | |
770 | for (;;) { } |
771 | } |
772 | |
773 | static void |
774 | kdp_machine_reboot_type(unsigned int type) |
775 | { |
776 | printf("Attempting system restart..." ); |
777 | PEHaltRestart(type); |
778 | halt_all_cpus(TRUE); |
779 | } |
780 | |
781 | void |
782 | kdp_machine_reboot(void) |
783 | { |
784 | kdp_machine_reboot_type(kPEPanicRestartCPU); |
785 | } |
786 | |
787 | /* |
788 | * Gather and save diagnostic information about a panic (or Debugger call). |
789 | * |
790 | * On embedded, Debugger and Panic are treated very similarly -- WDT uses Debugger so we can |
791 | * theoretically return from it. On desktop, Debugger is treated as a conventional debugger -- i.e no |
792 | * paniclog is written and no core is written unless we request a core on NMI. |
793 | * |
794 | * This routine handles kicking off local coredumps, paniclogs, calling into the Debugger/KDP (if it's configured), |
795 | * and calling out to any other functions we have for collecting diagnostic info. |
796 | */ |
797 | static void |
798 | debugger_collect_diagnostics(unsigned int exception, unsigned int code, unsigned int subcode, void *state) |
799 | { |
800 | #if DEVELOPMENT || DEBUG |
801 | DEBUGGER_DEBUGGING_NESTED_PANIC_IF_REQUESTED((debugger_panic_options & DEBUGGER_OPTION_RECURPANIC_PRELOG)); |
802 | #endif |
803 | |
804 | #if defined(__x86_64__) |
805 | kprintf("Debugger called: <%s>\n" , debugger_message ? debugger_message : "" ); |
806 | #endif |
807 | /* |
808 | * DB_HALT (halt_in_debugger) can be requested on startup, we shouldn't generate |
809 | * a coredump/paniclog for this type of debugger entry. If KDP isn't configured, |
810 | * we'll just spin in kdp_raise_exception. |
811 | */ |
812 | if (debugger_current_op == DBOP_DEBUGGER && halt_in_debugger) { |
813 | kdp_raise_exception(exception, code, subcode, state); |
814 | if (debugger_safe_to_return && !debugger_is_panic) { |
815 | return; |
816 | } |
817 | } |
818 | |
819 | if ((debugger_current_op == DBOP_PANIC) || |
820 | ((debugger_current_op == DBOP_DEBUGGER) && debugger_is_panic)) { |
821 | /* |
822 | * Attempt to notify listeners once and only once that we've started |
823 | * panicking. Only do this for Debugger() calls if we're treating |
824 | * Debugger() calls like panic(). |
825 | */ |
826 | PEHaltRestart(kPEPanicBegin); |
827 | |
828 | /* |
829 | * Set the begin pointer in the panic log structure. We key off of this |
830 | * static variable rather than contents from the panic header itself in case someone |
831 | * has stomped over the panic_info structure. Also initializes the header magic. |
832 | */ |
833 | static boolean_t began_writing_paniclog = FALSE; |
834 | if (!began_writing_paniclog) { |
835 | PE_init_panicheader(); |
836 | began_writing_paniclog = TRUE; |
837 | } else { |
838 | /* |
839 | * If we reached here, update the panic header to keep it as consistent |
840 | * as possible during a nested panic |
841 | */ |
842 | PE_update_panicheader_nestedpanic(); |
843 | } |
844 | } |
845 | |
846 | /* |
847 | * Write panic string if this was a panic. |
848 | * |
849 | * TODO: Consider moving to SavePanicInfo as this is part of the panic log. |
850 | */ |
851 | if (debugger_current_op == DBOP_PANIC) { |
852 | paniclog_append_noflush("panic(cpu %d caller 0x%lx): " , (unsigned) cpu_number(), debugger_panic_caller); |
853 | if (debugger_panic_str) { |
854 | _doprnt(debugger_panic_str, debugger_panic_args, consdebug_putc, 0); |
855 | } |
856 | paniclog_append_noflush("\n" ); |
857 | } |
858 | #if defined(__x86_64__) |
859 | else if (((debugger_current_op == DBOP_DEBUGGER) && debugger_is_panic)) { |
860 | paniclog_append_noflush("Debugger called: <%s>\n" , debugger_message ? debugger_message : "" ); |
861 | } |
862 | |
863 | /* |
864 | * Debugger() is treated like panic() on embedded -- for example we use it for WDT |
865 | * panics (so we need to write a paniclog). On desktop Debugger() is used in the |
866 | * conventional sense. |
867 | */ |
868 | if (debugger_current_op == DBOP_PANIC || ((debugger_current_op == DBOP_DEBUGGER) && debugger_is_panic)) |
869 | #endif |
870 | { |
871 | kdp_callouts(KDP_EVENT_PANICLOG); |
872 | |
873 | /* |
874 | * Write paniclog and panic stackshot (if supported) |
875 | * TODO: Need to clear panic log when return from debugger |
876 | * hooked up for embedded |
877 | */ |
878 | SavePanicInfo(debugger_message, debugger_panic_data, debugger_panic_options); |
879 | |
880 | #if DEVELOPMENT || DEBUG |
881 | DEBUGGER_DEBUGGING_NESTED_PANIC_IF_REQUESTED((debugger_panic_options & DEBUGGER_OPTION_RECURPANIC_POSTLOG)); |
882 | #endif |
883 | |
884 | /* DEBUGGER_OPTION_PANICLOGANDREBOOT is used for two finger resets on embedded so we get a paniclog */ |
885 | if (debugger_panic_options & DEBUGGER_OPTION_PANICLOGANDREBOOT) |
886 | PEHaltRestart(kPEPanicRestartCPU); |
887 | } |
888 | |
889 | #if CONFIG_KDP_INTERACTIVE_DEBUGGING |
890 | /* |
891 | * If reboot on panic is enabled and the caller of panic indicated that we should skip |
892 | * local coredumps, don't try to write these and instead go straight to reboot. This |
893 | * allows us to persist any data that's stored in the panic log. |
894 | */ |
895 | if ((debugger_panic_options & DEBUGGER_OPTION_SKIP_LOCAL_COREDUMP) && |
896 | (debug_boot_arg & DB_REBOOT_POST_CORE)) { |
897 | kdp_machine_reboot_type(kPEPanicRestartCPU); |
898 | } |
899 | |
900 | /* |
901 | * Consider generating a local corefile if the infrastructure is configured |
902 | * and we haven't disabled on-device coredumps. |
903 | */ |
904 | if (!(debug_boot_arg & DB_DISABLE_LOCAL_CORE)) { |
905 | if (!kdp_has_polled_corefile()) { |
906 | if (debug_boot_arg & (DB_KERN_DUMP_ON_PANIC | DB_KERN_DUMP_ON_NMI)) { |
907 | paniclog_append_noflush("skipping local kernel core because core file could not be opened prior to panic (error : 0x%x)" , |
908 | kdp_polled_corefile_error()); |
909 | #if CONFIG_EMBEDDED |
910 | panic_info->eph_panic_flags |= EMBEDDED_PANIC_HEADER_FLAG_COREDUMP_FAILED; |
911 | paniclog_flush(); |
912 | #else /* CONFIG_EMBEDDED */ |
913 | if (panic_info->mph_panic_log_offset != 0) { |
914 | panic_info->mph_panic_flags |= MACOS_PANIC_HEADER_FLAG_COREDUMP_FAILED; |
915 | paniclog_flush(); |
916 | } |
917 | #endif /* CONFIG_EMBEDDED */ |
918 | } |
919 | } else { |
920 | int ret = -1; |
921 | |
922 | #if defined (__x86_64__) |
923 | /* On x86 we don't do a coredump on Debugger unless the DB_KERN_DUMP_ON_NMI boot-arg is specified. */ |
924 | if (debugger_current_op != DBOP_DEBUGGER || (debug_boot_arg & DB_KERN_DUMP_ON_NMI)) |
925 | #endif |
926 | { |
927 | /* |
928 | * Doing an on-device coredump leaves the disk driver in a state |
929 | * that can not be resumed. |
930 | */ |
931 | debugger_safe_to_return = FALSE; |
932 | begin_panic_transfer(); |
933 | ret = kern_dump(KERN_DUMP_DISK); |
934 | abort_panic_transfer(); |
935 | |
936 | #if DEVELOPMENT || DEBUG |
937 | DEBUGGER_DEBUGGING_NESTED_PANIC_IF_REQUESTED((debugger_panic_options & DEBUGGER_OPTION_RECURPANIC_POSTCORE)); |
938 | #endif |
939 | } |
940 | |
941 | /* |
942 | * If DB_REBOOT_POST_CORE is set, then reboot if coredump is sucessfully saved |
943 | * or if option to ignore failures is set. |
944 | */ |
945 | if ((debug_boot_arg & DB_REBOOT_POST_CORE) && |
946 | ((ret == 0) || (debugger_panic_options & DEBUGGER_OPTION_ATTEMPTCOREDUMPANDREBOOT))) { |
947 | kdp_machine_reboot_type(kPEPanicRestartCPU); |
948 | } |
949 | } |
950 | } |
951 | |
952 | if (debug_boot_arg & DB_REBOOT_ALWAYS) { |
953 | kdp_machine_reboot_type(kPEPanicRestartCPU); |
954 | } |
955 | |
956 | /* If KDP is configured, try to trap to the debugger */ |
957 | if (current_debugger != NO_CUR_DB) { |
958 | kdp_raise_exception(exception, code, subcode, state); |
959 | /* |
960 | * Only return if we entered via Debugger and it's safe to return |
961 | * (we halted the other cores successfully, this isn't a nested panic, etc) |
962 | */ |
963 | if (debugger_current_op == DBOP_DEBUGGER && |
964 | debugger_safe_to_return && |
965 | kernel_debugger_entry_count == 1 && |
966 | !debugger_is_panic) { |
967 | return; |
968 | } |
969 | } |
970 | |
971 | #if CONFIG_EMBEDDED |
972 | if (panicDebugging) { |
973 | /* If panic debugging is configured, spin for astris to connect */ |
974 | panic_spin_shmcon(); |
975 | } |
976 | #endif /* CONFIG_EMBEDDED */ |
977 | #endif /* CONFIG_KDP_INTERACTIVE_DEBUGGING */ |
978 | |
979 | if (!panicDebugging) { |
980 | kdp_machine_reboot_type(kPEPanicRestartCPU); |
981 | } |
982 | |
983 | panic_spin_forever(); |
984 | } |
985 | |
986 | #if INTERRUPT_MASKED_DEBUG |
987 | uint64_t debugger_trap_timestamps[9]; |
988 | # define DEBUGGER_TRAP_TIMESTAMP(i) debugger_trap_timestamps[i] = mach_absolute_time(); |
989 | #else |
990 | # define DEBUGGER_TRAP_TIMESTAMP(i) |
991 | #endif |
992 | |
993 | void |
994 | handle_debugger_trap(unsigned int exception, unsigned int code, unsigned int subcode, void *state) |
995 | { |
996 | unsigned int initial_not_in_kdp = not_in_kdp; |
997 | kern_return_t ret; |
998 | debugger_op db_prev_op = debugger_current_op; |
999 | |
1000 | DEBUGGER_TRAP_TIMESTAMP(0); |
1001 | |
1002 | DebuggerLock(); |
1003 | ret = DebuggerHaltOtherCores(CPUDEBUGGERSYNC); |
1004 | |
1005 | DEBUGGER_TRAP_TIMESTAMP(1); |
1006 | |
1007 | #if INTERRUPT_MASKED_DEBUG |
1008 | if (serialmode & SERIALMODE_OUTPUT) { |
1009 | ml_spin_debug_reset(current_thread()); |
1010 | } |
1011 | #endif |
1012 | if (ret != KERN_SUCCESS) { |
1013 | CPUDEBUGGERRET = ret; |
1014 | DebuggerUnlock(); |
1015 | return; |
1016 | } |
1017 | |
1018 | /* Update the global panic/debugger nested entry level */ |
1019 | kernel_debugger_entry_count = CPUDEBUGGERCOUNT; |
1020 | |
1021 | /* |
1022 | * TODO: Should we do anything special for nested panics here? i.e. if we've trapped more than twice |
1023 | * should we call into the debugger if it's configured and then reboot if the panic log has been written? |
1024 | */ |
1025 | |
1026 | if (CPUDEBUGGEROP == DBOP_NONE) { |
1027 | /* If there was no debugger context setup, we trapped due to a software breakpoint */ |
1028 | debugger_current_op = DBOP_BREAKPOINT; |
1029 | } else { |
1030 | /* Not safe to return from a nested panic/debugger call */ |
1031 | if (debugger_current_op == DBOP_PANIC || |
1032 | debugger_current_op == DBOP_DEBUGGER) { |
1033 | debugger_safe_to_return = FALSE; |
1034 | } |
1035 | |
1036 | debugger_current_op = CPUDEBUGGEROP; |
1037 | |
1038 | /* Only overwrite the panic message if there is none already - save the data from the first call */ |
1039 | if (debugger_panic_str == NULL) { |
1040 | debugger_panic_str = CPUPANICSTR; |
1041 | debugger_panic_args = CPUPANICARGS; |
1042 | debugger_panic_data = CPUPANICDATAPTR; |
1043 | debugger_message = CPUDEBUGGERMSG; |
1044 | debugger_panic_caller = CPUPANICCALLER; |
1045 | } |
1046 | |
1047 | debugger_panic_options = CPUPANICOPTS; |
1048 | } |
1049 | |
1050 | /* |
1051 | * Clear the op from the processor debugger context so we can handle |
1052 | * breakpoints in the debugger |
1053 | */ |
1054 | CPUDEBUGGEROP = DBOP_NONE; |
1055 | |
1056 | DEBUGGER_TRAP_TIMESTAMP(2); |
1057 | |
1058 | kdp_callouts(KDP_EVENT_ENTER); |
1059 | not_in_kdp = 0; |
1060 | |
1061 | DEBUGGER_TRAP_TIMESTAMP(3); |
1062 | |
1063 | if (debugger_current_op == DBOP_BREAKPOINT) { |
1064 | kdp_raise_exception(exception, code, subcode, state); |
1065 | } else if (debugger_current_op == DBOP_STACKSHOT) { |
1066 | CPUDEBUGGERRET = do_stackshot(); |
1067 | #if PGO |
1068 | } else if (debugger_current_op == DBOP_RESET_PGO_COUNTERS) { |
1069 | CPUDEBUGGERRET = do_pgo_reset_counters(); |
1070 | #endif |
1071 | } else { |
1072 | debugger_collect_diagnostics(exception, code, subcode, state); |
1073 | } |
1074 | |
1075 | DEBUGGER_TRAP_TIMESTAMP(4); |
1076 | |
1077 | not_in_kdp = initial_not_in_kdp; |
1078 | kdp_callouts(KDP_EVENT_EXIT); |
1079 | |
1080 | DEBUGGER_TRAP_TIMESTAMP(5); |
1081 | |
1082 | if (debugger_current_op != DBOP_BREAKPOINT) { |
1083 | debugger_panic_str = NULL; |
1084 | debugger_panic_args = NULL; |
1085 | debugger_panic_data = NULL; |
1086 | debugger_panic_options = 0; |
1087 | debugger_message = NULL; |
1088 | } |
1089 | |
1090 | /* Restore the previous debugger state */ |
1091 | debugger_current_op = db_prev_op; |
1092 | |
1093 | DEBUGGER_TRAP_TIMESTAMP(6); |
1094 | |
1095 | DebuggerResumeOtherCores(); |
1096 | |
1097 | DEBUGGER_TRAP_TIMESTAMP(7); |
1098 | |
1099 | DebuggerUnlock(); |
1100 | |
1101 | DEBUGGER_TRAP_TIMESTAMP(8); |
1102 | |
1103 | return; |
1104 | } |
1105 | |
1106 | __attribute__((noinline,not_tail_called)) |
1107 | void log(__unused int level, char *fmt, ...) |
1108 | { |
1109 | void *caller = __builtin_return_address(0); |
1110 | va_list listp; |
1111 | va_list listp2; |
1112 | |
1113 | |
1114 | #ifdef lint |
1115 | level++; |
1116 | #endif /* lint */ |
1117 | #ifdef MACH_BSD |
1118 | va_start(listp, fmt); |
1119 | va_copy(listp2, listp); |
1120 | |
1121 | disable_preemption(); |
1122 | _doprnt(fmt, &listp, cons_putc_locked, 0); |
1123 | enable_preemption(); |
1124 | |
1125 | va_end(listp); |
1126 | |
1127 | os_log_with_args(OS_LOG_DEFAULT, OS_LOG_TYPE_DEFAULT, fmt, listp2, caller); |
1128 | va_end(listp2); |
1129 | #endif |
1130 | } |
1131 | |
1132 | /* |
1133 | * Per <rdar://problem/24974766>, skip appending log messages to |
1134 | * the new logging infrastructure in contexts where safety is |
1135 | * uncertain. These contexts include: |
1136 | * - When we're in the debugger |
1137 | * - We're in a panic |
1138 | * - Interrupts are disabled |
1139 | * - Or Pre-emption is disabled |
1140 | * In all the above cases, it is potentially unsafe to log messages. |
1141 | */ |
1142 | |
1143 | boolean_t |
1144 | oslog_is_safe(void) { |
1145 | return (kernel_debugger_entry_count == 0 && |
1146 | not_in_kdp == 1 && |
1147 | get_preemption_level() == 0 && |
1148 | ml_get_interrupts_enabled() == TRUE); |
1149 | } |
1150 | |
1151 | boolean_t |
1152 | debug_mode_active(void) |
1153 | { |
1154 | return ((0 != kernel_debugger_entry_count != 0) || (0 == not_in_kdp)); |
1155 | } |
1156 | |
1157 | void |
1158 | debug_putc(char c) |
1159 | { |
1160 | if ((debug_buf_size != 0) && |
1161 | ((debug_buf_ptr - debug_buf_base) < (int)debug_buf_size)) { |
1162 | *debug_buf_ptr=c; |
1163 | debug_buf_ptr++; |
1164 | } |
1165 | } |
1166 | |
1167 | #if defined (__x86_64__) |
1168 | struct pasc { |
1169 | unsigned a: 7; |
1170 | unsigned b: 7; |
1171 | unsigned c: 7; |
1172 | unsigned d: 7; |
1173 | unsigned e: 7; |
1174 | unsigned f: 7; |
1175 | unsigned g: 7; |
1176 | unsigned h: 7; |
1177 | } __attribute__((packed)); |
1178 | |
1179 | typedef struct pasc pasc_t; |
1180 | |
1181 | /* |
1182 | * In-place packing routines -- inefficient, but they're called at most once. |
1183 | * Assumes "buflen" is a multiple of 8. Used for compressing paniclogs on x86. |
1184 | */ |
1185 | int |
1186 | packA(char *inbuf, uint32_t length, uint32_t buflen) |
1187 | { |
1188 | unsigned int i, j = 0; |
1189 | pasc_t pack; |
1190 | |
1191 | length = MIN(((length + 7) & ~7), buflen); |
1192 | |
1193 | for (i = 0; i < length; i+=8) |
1194 | { |
1195 | pack.a = inbuf[i]; |
1196 | pack.b = inbuf[i+1]; |
1197 | pack.c = inbuf[i+2]; |
1198 | pack.d = inbuf[i+3]; |
1199 | pack.e = inbuf[i+4]; |
1200 | pack.f = inbuf[i+5]; |
1201 | pack.g = inbuf[i+6]; |
1202 | pack.h = inbuf[i+7]; |
1203 | bcopy ((char *) &pack, inbuf + j, 7); |
1204 | j += 7; |
1205 | } |
1206 | return j; |
1207 | } |
1208 | |
1209 | void |
1210 | unpackA(char *inbuf, uint32_t length) |
1211 | { |
1212 | pasc_t packs; |
1213 | unsigned i = 0; |
1214 | length = (length * 8)/7; |
1215 | |
1216 | while (i < length) { |
1217 | packs = *(pasc_t *)&inbuf[i]; |
1218 | bcopy(&inbuf[i+7], &inbuf[i+8], MAX(0, (int) (length - i - 8))); |
1219 | inbuf[i++] = packs.a; |
1220 | inbuf[i++] = packs.b; |
1221 | inbuf[i++] = packs.c; |
1222 | inbuf[i++] = packs.d; |
1223 | inbuf[i++] = packs.e; |
1224 | inbuf[i++] = packs.f; |
1225 | inbuf[i++] = packs.g; |
1226 | inbuf[i++] = packs.h; |
1227 | } |
1228 | } |
1229 | #endif /* defined (__x86_64__) */ |
1230 | |
1231 | extern void *proc_name_address(void *p); |
1232 | |
1233 | static void |
1234 | panic_display_process_name(void) { |
1235 | /* because of scoping issues len(p_comm) from proc_t is hard coded here */ |
1236 | char proc_name[17] = "Unknown" ; |
1237 | task_t ctask = 0; |
1238 | void *cbsd_info = 0; |
1239 | |
1240 | if (ml_nofault_copy((vm_offset_t)¤t_thread()->task, (vm_offset_t) &ctask, sizeof(task_t)) == sizeof(task_t)) |
1241 | if(ml_nofault_copy((vm_offset_t)&ctask->bsd_info, (vm_offset_t)&cbsd_info, sizeof(cbsd_info)) == sizeof(cbsd_info)) |
1242 | if (cbsd_info && (ml_nofault_copy((vm_offset_t) proc_name_address(cbsd_info), (vm_offset_t) &proc_name, sizeof(proc_name)) > 0)) |
1243 | proc_name[sizeof(proc_name) - 1] = '\0'; |
1244 | paniclog_append_noflush("\nBSD process name corresponding to current thread: %s\n" , proc_name); |
1245 | } |
1246 | |
1247 | unsigned |
1248 | panic_active(void) { |
1249 | return ((debugger_panic_str != (char *) 0)); |
1250 | } |
1251 | |
1252 | void |
1253 | populate_model_name(char *model_string) { |
1254 | strlcpy(model_name, model_string, sizeof(model_name)); |
1255 | } |
1256 | |
1257 | void |
1258 | panic_display_model_name(void) { |
1259 | char tmp_model_name[sizeof(model_name)]; |
1260 | |
1261 | if (ml_nofault_copy((vm_offset_t) &model_name, (vm_offset_t) &tmp_model_name, sizeof(model_name)) != sizeof(model_name)) |
1262 | return; |
1263 | |
1264 | tmp_model_name[sizeof(tmp_model_name) - 1] = '\0'; |
1265 | |
1266 | if (tmp_model_name[0] != 0) |
1267 | paniclog_append_noflush("System model name: %s\n" , tmp_model_name); |
1268 | } |
1269 | |
1270 | void |
1271 | panic_display_kernel_uuid(void) { |
1272 | char tmp_kernel_uuid[sizeof(kernel_uuid_string)]; |
1273 | |
1274 | if (ml_nofault_copy((vm_offset_t) &kernel_uuid_string, (vm_offset_t) &tmp_kernel_uuid, sizeof(kernel_uuid_string)) != sizeof(kernel_uuid_string)) |
1275 | return; |
1276 | |
1277 | if (tmp_kernel_uuid[0] != '\0') |
1278 | paniclog_append_noflush("Kernel UUID: %s\n" , tmp_kernel_uuid); |
1279 | } |
1280 | |
1281 | void |
1282 | panic_display_kernel_aslr(void) { |
1283 | if (vm_kernel_slide) { |
1284 | paniclog_append_noflush("Kernel slide: 0x%016lx\n" , (unsigned long) vm_kernel_slide); |
1285 | paniclog_append_noflush("Kernel text base: %p\n" , (void *) vm_kernel_stext); |
1286 | } |
1287 | } |
1288 | |
1289 | void |
1290 | panic_display_hibb(void) { |
1291 | #if defined(__i386__) || defined (__x86_64__) |
1292 | paniclog_append_noflush("__HIB text base: %p\n" , (void *) vm_hib_base); |
1293 | #endif |
1294 | } |
1295 | |
1296 | static void |
1297 | panic_display_uptime(void) { |
1298 | uint64_t uptime; |
1299 | absolutetime_to_nanoseconds(mach_absolute_time(), &uptime); |
1300 | |
1301 | paniclog_append_noflush("\nSystem uptime in nanoseconds: %llu\n" , uptime); |
1302 | } |
1303 | |
1304 | static void |
1305 | panic_display_disk_errors(void) { |
1306 | |
1307 | if (panic_disk_error_description[0]) { |
1308 | panic_disk_error_description[sizeof(panic_disk_error_description) - 1] = '\0'; |
1309 | paniclog_append_noflush("Root disk errors: \"%s\"\n" , panic_disk_error_description); |
1310 | } |
1311 | }; |
1312 | |
1313 | extern const char version[]; |
1314 | extern char osversion[]; |
1315 | |
1316 | static volatile uint32_t config_displayed = 0; |
1317 | |
1318 | __private_extern__ void |
1319 | panic_display_system_configuration(boolean_t launchd_exit) { |
1320 | |
1321 | if (!launchd_exit) panic_display_process_name(); |
1322 | if (OSCompareAndSwap(0, 1, &config_displayed)) { |
1323 | char buf[256]; |
1324 | if (!launchd_exit && strlcpy(buf, PE_boot_args(), sizeof(buf))) |
1325 | paniclog_append_noflush("Boot args: %s\n" , buf); |
1326 | paniclog_append_noflush("\nMac OS version:\n%s\n" , |
1327 | (osversion[0] != 0) ? osversion : "Not yet set" ); |
1328 | paniclog_append_noflush("\nKernel version:\n%s\n" ,version); |
1329 | panic_display_kernel_uuid(); |
1330 | if (!launchd_exit) { |
1331 | panic_display_kernel_aslr(); |
1332 | panic_display_hibb(); |
1333 | panic_display_pal_info(); |
1334 | } |
1335 | panic_display_model_name(); |
1336 | panic_display_disk_errors(); |
1337 | if (!launchd_exit) { |
1338 | panic_display_uptime(); |
1339 | panic_display_zprint(); |
1340 | #if CONFIG_ZLEAKS |
1341 | panic_display_ztrace(); |
1342 | #endif /* CONFIG_ZLEAKS */ |
1343 | kext_dump_panic_lists(&paniclog_append_noflush); |
1344 | } |
1345 | } |
1346 | } |
1347 | |
1348 | extern unsigned int stack_total; |
1349 | extern unsigned long long stack_allocs; |
1350 | |
1351 | #if defined (__x86_64__) |
1352 | extern unsigned int inuse_ptepages_count; |
1353 | extern long long alloc_ptepages_count; |
1354 | #endif |
1355 | |
1356 | extern boolean_t panic_include_zprint; |
1357 | extern mach_memory_info_t *panic_kext_memory_info; |
1358 | extern vm_size_t panic_kext_memory_size; |
1359 | |
1360 | __private_extern__ void |
1361 | panic_display_zprint() |
1362 | { |
1363 | if(panic_include_zprint == TRUE) { |
1364 | |
1365 | unsigned int i; |
1366 | struct zone zone_copy; |
1367 | |
1368 | paniclog_append_noflush("%-20s %10s %10s\n" , "Zone Name" , "Cur Size" , "Free Size" ); |
1369 | for (i = 0; i < num_zones; i++) { |
1370 | if(ml_nofault_copy((vm_offset_t)(&zone_array[i]), (vm_offset_t)&zone_copy, sizeof(struct zone)) == sizeof(struct zone)) { |
1371 | if(zone_copy.cur_size > (1024*1024)) { |
1372 | paniclog_append_noflush("%-20s %10lu %10lu\n" ,zone_copy.zone_name, (uintptr_t)zone_copy.cur_size,(uintptr_t)(zone_copy.countfree * zone_copy.elem_size)); |
1373 | } |
1374 | } |
1375 | } |
1376 | |
1377 | paniclog_append_noflush("%-20s %10lu\n" , "Kernel Stacks" , (uintptr_t)(kernel_stack_size * stack_total)); |
1378 | |
1379 | #if defined (__x86_64__) |
1380 | paniclog_append_noflush("%-20s %10lu\n" , "PageTables" ,(uintptr_t)(PAGE_SIZE * inuse_ptepages_count)); |
1381 | #endif |
1382 | |
1383 | paniclog_append_noflush("%-20s %10lu\n" , "Kalloc.Large" , (uintptr_t)kalloc_large_total); |
1384 | if (panic_kext_memory_info) { |
1385 | mach_memory_info_t *mem_info = panic_kext_memory_info; |
1386 | paniclog_append_noflush("\n%-5s %10s\n" , "Kmod" , "Size" ); |
1387 | for (i = 0; i < (panic_kext_memory_size / sizeof(mach_zone_info_t)); i++) { |
1388 | if (((mem_info[i].flags & VM_KERN_SITE_TYPE) == VM_KERN_SITE_KMOD) && (mem_info[i].size > (1024 * 1024))) { |
1389 | paniclog_append_noflush("%-5lld %10lld\n" , mem_info[i].site, mem_info[i].size); |
1390 | } |
1391 | } |
1392 | } |
1393 | } |
1394 | } |
1395 | |
1396 | #if CONFIG_ECC_LOGGING |
1397 | __private_extern__ void |
1398 | panic_display_ecc_errors() |
1399 | { |
1400 | uint32_t count = ecc_log_get_correction_count(); |
1401 | |
1402 | if (count > 0) { |
1403 | paniclog_append_noflush("ECC Corrections:%u\n" , count); |
1404 | } |
1405 | } |
1406 | #endif /* CONFIG_ECC_LOGGING */ |
1407 | |
1408 | #if CONFIG_ZLEAKS |
1409 | extern boolean_t panic_include_ztrace; |
1410 | extern struct ztrace* top_ztrace; |
1411 | void panic_print_symbol_name(vm_address_t search); |
1412 | |
1413 | /* |
1414 | * Prints the backtrace most suspected of being a leaker, if we paniced in the zone allocator. |
1415 | * top_ztrace and panic_include_ztrace comes from osfmk/kern/zalloc.c |
1416 | */ |
1417 | __private_extern__ void |
1418 | panic_display_ztrace(void) |
1419 | { |
1420 | if(panic_include_ztrace == TRUE) { |
1421 | unsigned int i = 0; |
1422 | boolean_t keepsyms = FALSE; |
1423 | |
1424 | PE_parse_boot_argn("keepsyms" , &keepsyms, sizeof (keepsyms)); |
1425 | struct ztrace top_ztrace_copy; |
1426 | |
1427 | /* Make sure not to trip another panic if there's something wrong with memory */ |
1428 | if(ml_nofault_copy((vm_offset_t)top_ztrace, (vm_offset_t)&top_ztrace_copy, sizeof(struct ztrace)) == sizeof(struct ztrace)) { |
1429 | paniclog_append_noflush("\nBacktrace suspected of leaking: (outstanding bytes: %lu)\n" , (uintptr_t)top_ztrace_copy.zt_size); |
1430 | /* Print the backtrace addresses */ |
1431 | for (i = 0; (i < top_ztrace_copy.zt_depth && i < MAX_ZTRACE_DEPTH) ; i++) { |
1432 | paniclog_append_noflush("%p " , top_ztrace_copy.zt_stack[i]); |
1433 | if (keepsyms) { |
1434 | panic_print_symbol_name((vm_address_t)top_ztrace_copy.zt_stack[i]); |
1435 | } |
1436 | paniclog_append_noflush("\n" ); |
1437 | } |
1438 | /* Print any kexts in that backtrace, along with their link addresses so we can properly blame them */ |
1439 | kmod_panic_dump((vm_offset_t *)&top_ztrace_copy.zt_stack[0], top_ztrace_copy.zt_depth); |
1440 | } |
1441 | else { |
1442 | paniclog_append_noflush("\nCan't access top_ztrace...\n" ); |
1443 | } |
1444 | paniclog_append_noflush("\n" ); |
1445 | } |
1446 | } |
1447 | #endif /* CONFIG_ZLEAKS */ |
1448 | |
1449 | #if !CONFIG_TELEMETRY |
1450 | int |
1451 | telemetry_gather(user_addr_t buffer __unused, uint32_t *length __unused, boolean_t mark __unused) |
1452 | { |
1453 | return KERN_NOT_SUPPORTED; |
1454 | } |
1455 | #endif |
1456 | |
1457 | #include <machine/machine_cpu.h> |
1458 | |
1459 | uint32_t kern_feature_overrides = 0; |
1460 | |
1461 | boolean_t kern_feature_override(uint32_t fmask) { |
1462 | if (kern_feature_overrides == 0) { |
1463 | uint32_t fdisables = 0; |
1464 | /* Expected to be first invoked early, in a single-threaded |
1465 | * environment |
1466 | */ |
1467 | if (PE_parse_boot_argn("validation_disables" , &fdisables, sizeof(fdisables))) { |
1468 | fdisables |= KF_INITIALIZED; |
1469 | kern_feature_overrides = fdisables; |
1470 | } else { |
1471 | kern_feature_overrides |= KF_INITIALIZED; |
1472 | } |
1473 | } |
1474 | return ((kern_feature_overrides & fmask) == fmask); |
1475 | } |
1476 | |