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>
109extern volatile struct xnu_hw_shmem_dbg_command_info *hwsd_info;
110#endif
111
112#if CONFIG_XNUPOST
113#include <tests/xnupost.h>
114extern int vsnprintf(char *, size_t, const char *, va_list);
115#endif
116
117unsigned int halt_in_debugger = 0;
118unsigned int current_debugger = 0;
119unsigned int active_debugger = 0;
120unsigned int panicDebugging = FALSE;
121unsigned int kdebug_serial = FALSE;
122unsigned 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) \
157MACRO_BEGIN \
158 if (requested) { \
159 volatile int *badpointer = (int *)4; \
160 *badpointer = 0; \
161 } \
162MACRO_END
163#endif /* DEVELOPMENT || DEBUG */
164
165debugger_op debugger_current_op = DBOP_NONE;
166const char *debugger_panic_str = NULL;
167va_list *debugger_panic_args = NULL;
168void *debugger_panic_data = NULL;
169uint64_t debugger_panic_options = 0;
170const char *debugger_message = NULL;
171unsigned long debugger_panic_caller = 0;
172
173void 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);
175static void kdp_machine_reboot_type(unsigned int type);
176__attribute__((noreturn)) void panic_spin_forever(void);
177extern kern_return_t do_stackshot(void);
178
179int 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
191static_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
197char *debug_buf_base = NULL;
198char *debug_buf_ptr = NULL;
199unsigned int debug_buf_size = 0;
200#else
201char debug_buf[DEBUG_BUF_SIZE];
202struct macos_panic_header *panic_info = (struct macos_panic_header *)debug_buf;
203char *debug_buf_base = (debug_buf + offsetof(struct macos_panic_header, mph_data));
204char *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 */
211unsigned int debug_buf_size = (DEBUG_BUF_SIZE - offsetof(struct macos_panic_header, mph_data));
212
213boolean_t extended_debug_log_enabled = FALSE;
214#endif
215
216/* Debugger state */
217atomic_int debugger_cpu = ATOMIC_VAR_INIT(DEBUGGER_NO_CPU);
218boolean_t debugger_allcpus_halted = FALSE;
219boolean_t debugger_safe_to_return = TRUE;
220unsigned int debugger_context = 0;
221
222static char model_name[64];
223unsigned char *kernel_uuid;
224
225boolean_t kernelcache_uuid_valid = FALSE;
226uuid_t kernelcache_uuid;
227uuid_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 */
236static boolean_t debugger_is_panic = TRUE;
237
238#if DEVELOPMENT || DEBUG
239boolean_t debug_boot_arg_inited = FALSE;
240#endif
241
242SECURITY_READ_ONLY_LATE(unsigned int) debug_boot_arg;
243
244char kernel_uuid_string[37]; /* uuid_string_t */
245char kernelcache_uuid_string[37]; /* uuid_string_t */
246char panic_disk_error_description[512];
247size_t panic_disk_error_description_size = sizeof(panic_disk_error_description);
248
249extern unsigned int write_trace_on_panic;
250int kext_assertions_enable =
251#if DEBUG || DEVELOPMENT
252 TRUE;
253#else
254 FALSE;
255#endif
256
257void
258panic_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__)
321void
322extended_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
346void
347debug_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
367static void
368DebuggerLock()
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
385static void
386DebuggerUnlock()
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
403static kern_return_t
404DebuggerHaltOtherCores(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
415static void
416DebuggerResumeOtherCores()
417{
418#if CONFIG_EMBEDDED
419 DebuggerXCallReturn();
420#else /* CONFIG_EMBEDDED */
421 mp_kdp_exit();
422#endif
423}
424
425static void
426DebuggerSaveState(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 */
458kern_return_t
459DebuggerTrapWithState(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
479void __attribute__((noinline))
480Assert(
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
495void
496Debugger(const char *message)
497{
498 DebuggerWithContext(0, NULL, message, DEBUGGER_OPTION_NONE);
499}
500
501void
502DebuggerWithContext(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
556static 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 */
566void
567kdp_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
587static void
588kdp_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
614void
615panic(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
624void
625panic_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 */
644void
645panic_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"
668void
669panic_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))
765void
766panic_spin_forever()
767{
768 paniclog_append_noflush("\nPlease go to https://panic.apple.com to report this panic\n");
769
770 for (;;) { }
771}
772
773static void
774kdp_machine_reboot_type(unsigned int type)
775{
776 printf("Attempting system restart...");
777 PEHaltRestart(type);
778 halt_all_cpus(TRUE);
779}
780
781void
782kdp_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 */
797static void
798debugger_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
987uint64_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
993void
994handle_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))
1107void 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
1143boolean_t
1144oslog_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
1151boolean_t
1152debug_mode_active(void)
1153{
1154 return ((0 != kernel_debugger_entry_count != 0) || (0 == not_in_kdp));
1155}
1156
1157void
1158debug_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__)
1168struct 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
1179typedef 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 */
1185int
1186packA(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
1209void
1210unpackA(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
1231extern void *proc_name_address(void *p);
1232
1233static void
1234panic_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)&current_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
1247unsigned
1248panic_active(void) {
1249 return ((debugger_panic_str != (char *) 0));
1250}
1251
1252void
1253populate_model_name(char *model_string) {
1254 strlcpy(model_name, model_string, sizeof(model_name));
1255}
1256
1257void
1258panic_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
1270void
1271panic_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
1281void
1282panic_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
1289void
1290panic_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
1296static void
1297panic_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
1304static void
1305panic_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
1313extern const char version[];
1314extern char osversion[];
1315
1316static volatile uint32_t config_displayed = 0;
1317
1318__private_extern__ void
1319panic_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
1348extern unsigned int stack_total;
1349extern unsigned long long stack_allocs;
1350
1351#if defined (__x86_64__)
1352extern unsigned int inuse_ptepages_count;
1353extern long long alloc_ptepages_count;
1354#endif
1355
1356extern boolean_t panic_include_zprint;
1357extern mach_memory_info_t *panic_kext_memory_info;
1358extern vm_size_t panic_kext_memory_size;
1359
1360__private_extern__ void
1361panic_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
1398panic_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
1409extern boolean_t panic_include_ztrace;
1410extern struct ztrace* top_ztrace;
1411void 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
1418panic_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
1450int
1451telemetry_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
1459uint32_t kern_feature_overrides = 0;
1460
1461boolean_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