/*
- * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2016 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#include <kern/clock.h>
#include <kern/telemetry.h>
#include <kern/ecc.h>
+#include <kern/kern_cdata.h>
+#include <kern/zalloc.h>
#include <vm/vm_kern.h>
#include <vm/pmap.h>
#include <stdarg.h>
#include <libkern/OSAtomic.h>
#include <libkern/kernel_mach_header.h>
#include <uuid/uuid.h>
+#include <mach_debug/zone_info.h>
+
+#include <os/log_private.h>
#if (defined(__arm64__) || defined(NAND_PANIC_DEVICE)) && !defined(LEGACY_PANIC_LOGS)
#include <pexpert/pexpert.h> /* For gPanicBase */
#endif
+
unsigned int halt_in_debugger = 0;
unsigned int switch_debugger = 0;
unsigned int current_debugger = 0;
unsigned int panicDebugging = FALSE;
unsigned int logPanicDataToScreen = FALSE;
unsigned int kdebug_serial = FALSE;
+boolean_t lock_panic_mode = FALSE;
int mach_assert = 1;
unsigned int debug_buf_size = sizeof(debug_buf);
#endif
+char *debug_buf_stackshot_start;
+char *debug_buf_stackshot_end;
+
static char model_name[64];
unsigned char *kernel_uuid;
/* uuid_string_t */ char kernel_uuid_string[37];
typedef struct pasc pasc_t;
/* Prevent CPP from breaking the definition below */
-#if CONFIG_NO_PANIC_STRINGS
+#ifdef CONFIG_NO_PANIC_STRINGS
#undef Assert
#endif
+int kext_assertions_enable =
+#if DEBUG || DEVELOPMENT
+ TRUE;
+#else
+ FALSE;
+#endif
+
void __attribute__((noinline))
Assert(
const char *file,
int saved_return_on_panic;
if (!mach_assert) {
+ kprintf("%s:%d non-fatal Assertion: %s", file, line, expression);
return;
}
simple_lock_init(&panic_lock, 0);
panic_is_inited = 1;
panic_caller = 0;
+
+ if (!PE_parse_boot_argn("assertions", &mach_assert, sizeof(mach_assert))) {
+ mach_assert = 1;
+ }
}
void
s = splhigh();
disable_preemption();
+ /* Locking code should relax some checks at panic time */
+ lock_panic_mode = TRUE;
#if defined(__i386__) || defined(__x86_64__)
/* Attempt to display the unparsed panic string */
} else {
nestedpanic +=1;
PANIC_UNLOCK();
+ // Other cores will not be resumed on double panic
Debugger("double panic");
- printf("double panic: We are hanging here...\n");
+ // a printf statement here was removed to avoid a panic-loop caused
+ // by a panic from printf
panic_stop();
/* NOTREACHED */
}
panicwait = 1;
PANIC_UNLOCK();
+
+ // halt other cores now in anticipation of the debugger call
return(s);
}
-
+#if DEVELOPMENT || DEBUG
static void
panic_epilogue(spl_t s)
+#else
+#if !defined(__i386__) && !defined(__x86_64__)
+__attribute__((noreturn))
+#endif
+static void
+panic_epilogue(__unused spl_t s)
+#endif
{
/*
* Release panicstr so that we can handle normally other panics.
panicstr = (char *)0;
PANIC_UNLOCK();
+#if DEVELOPMENT || DEBUG
if (return_on_panic) {
+ // resume other cores as we are returning
panic_normal();
enable_preemption();
splx(s);
return;
}
+#endif
kdb_printf("panic: We are hanging here...\n");
panic_stop();
/* NOTREACHED */
}
+#if !DEVELOPMENT && !DEBUG && !defined(__i386__) && !defined(__x86_64__)
+__attribute__((noreturn))
+#endif
void
panic(const char *str, ...)
{
va_list listp;
spl_t s;
+ boolean_t old_doprnt_hide_pointers = doprnt_hide_pointers;
-
+#if defined (__x86_64__)
+ plctrace_disable();
+#endif
/* panic_caller is initialized to 0. If set, don't change it */
if ( ! panic_caller )
panic_caller = (unsigned long)(char *)__builtin_return_address(0);
-
+
+
s = panic_prologue(str);
+
+ /* Never hide pointers from panic logs. */
+ doprnt_hide_pointers = FALSE;
+
kdb_printf("panic(cpu %d caller 0x%lx): ", (unsigned) paniccpu, panic_caller);
if (str) {
va_start(listp, str);
*/
panicwait = 0;
Debugger("panic");
+
+ doprnt_hide_pointers = old_doprnt_hide_pointers;
+
+ panic_epilogue(s);
+}
+
+/*
+ * panic_with_options: wraps the panic call in a way that allows us to pass
+ * a bitmask of specific debugger options.
+ */
+#if !DEVELOPMENT && !DEBUG && !defined(__i386__) && !defined(__x86_64__)
+__attribute__((noreturn))
+#endif
+void
+panic_with_options(unsigned int reason, void *ctx, uint64_t debugger_options_mask, const char *str, ...)
+{
+ va_list listp;
+ spl_t s;
+
+
+ /* panic_caller is initialized to 0. If set, don't change it */
+ if ( ! panic_caller )
+ panic_caller = (unsigned long)(char *)__builtin_return_address(0);
+
+ s = panic_prologue(str);
+ kdb_printf("panic(cpu %d caller 0x%lx): ", (unsigned) paniccpu, panic_caller);
+ if (str) {
+ va_start(listp, str);
+ _doprnt(str, &listp, consdebug_putc, 0);
+ va_end(listp);
+ }
+ kdb_printf("\n");
+
+ /*
+ * Release panicwait indicator so that other cpus may call Debugger().
+ */
+ panicwait = 0;
+ DebuggerWithContext(reason, ctx, "panic", debugger_options_mask);
panic_epilogue(s);
}
+#if !DEVELOPMENT && !DEBUG && !defined(__i386__) && !defined(__x86_64__)
+__attribute__((noreturn))
+#endif
void
panic_context(unsigned int reason, void *ctx, const char *str, ...)
{
* Release panicwait indicator so that other cpus may call Debugger().
*/
panicwait = 0;
- DebuggerWithContext(reason, ctx, "panic");
+ DebuggerWithContext(reason, ctx, "panic", DEBUGGER_OPTION_NONE);
panic_epilogue(s);
}
-void
-log(__unused int level, char *fmt, ...)
+__attribute__((noinline,not_tail_called))
+void log(__unused int level, char *fmt, ...)
{
+ void *caller = __builtin_return_address(0);
va_list listp;
+ va_list listp2;
+
#ifdef lint
level++;
#endif /* lint */
#ifdef MACH_BSD
- disable_preemption();
va_start(listp, fmt);
- _doprnt(fmt, &listp, conslog_putc, 0);
- va_end(listp);
+ va_copy(listp2, listp);
+
+ disable_preemption();
+ _doprnt(fmt, &listp, cons_putc_locked, 0);
enable_preemption();
+
+ va_end(listp);
+
+ os_log_with_args(OS_LOG_DEFAULT, OS_LOG_TYPE_DEFAULT, fmt, listp2, caller);
+ va_end(listp2);
#endif
}
+/*
+ * Skip appending log messages to the new logging infrastructure in contexts
+ * where safety is uncertain. These contexts include:
+ * - When we're in the debugger
+ * - We're in a panic
+ * - Interrupts are disabled
+ * - Or Pre-emption is disabled
+ * In all the above cases, it is potentially unsafe to log messages.
+ */
+
+boolean_t oslog_is_safe(void) {
+ return (debug_mode == 0 &&
+ not_in_kdp == 1 &&
+ get_preemption_level() == 0 &&
+ ml_get_interrupts_enabled() == TRUE);
+}
+
void
debug_putc(char c)
{
static void
panic_display_process_name(void) {
- char proc_name[32] = "Unknown";
+ /* because of scoping issues len(p_comm) from proc_t is hard coded here */
+ char proc_name[17] = "Unknown";
task_t ctask = 0;
void *cbsd_info = 0;
if (ml_nofault_copy((vm_offset_t)¤t_thread()->task, (vm_offset_t) &ctask, sizeof(task_t)) == sizeof(task_t))
- if(ml_nofault_copy((vm_offset_t)&ctask->bsd_info, (vm_offset_t)&cbsd_info, sizeof(&ctask->bsd_info)) == sizeof(&ctask->bsd_info))
+ if(ml_nofault_copy((vm_offset_t)&ctask->bsd_info, (vm_offset_t)&cbsd_info, sizeof(cbsd_info)) == sizeof(cbsd_info))
if (cbsd_info && (ml_nofault_copy((vm_offset_t) proc_name_address(cbsd_info), (vm_offset_t) &proc_name, sizeof(proc_name)) > 0))
proc_name[sizeof(proc_name) - 1] = '\0';
kdb_printf("\nBSD process name corresponding to current thread: %s\n", proc_name);
}
}
-extern zone_t first_zone;
-extern unsigned int num_zones, stack_total;
+extern unsigned int stack_total;
extern unsigned long long stack_allocs;
#if defined(__i386__) || defined (__x86_64__)
#endif
extern boolean_t panic_include_zprint;
+extern vm_offset_t panic_kext_memory_info;
+extern vm_size_t panic_kext_memory_size;
__private_extern__ void panic_display_zprint()
{
unsigned int i;
struct zone zone_copy;
- if(first_zone!=NULL) {
- if(ml_nofault_copy((vm_offset_t)first_zone, (vm_offset_t)&zone_copy, sizeof(struct zone)) == sizeof(struct zone)) {
- for (i = 0; i < num_zones; i++) {
- if(zone_copy.cur_size > (1024*1024)) {
- kdb_printf("%.20s:%lu\n",zone_copy.zone_name,(uintptr_t)zone_copy.cur_size);
- }
-
- if(zone_copy.next_zone == NULL) {
- break;
- }
-
- if(ml_nofault_copy((vm_offset_t)zone_copy.next_zone, (vm_offset_t)&zone_copy, sizeof(struct zone)) != sizeof(struct zone)) {
- break;
- }
+ kdb_printf("%-20s %10s %10s\n", "Zone Name", "Cur Size", "Free Size");
+ for (i = 0; i < num_zones; i++) {
+ if(ml_nofault_copy((vm_offset_t)(&zone_array[i]), (vm_offset_t)&zone_copy, sizeof(struct zone)) == sizeof(struct zone)) {
+ if(zone_copy.cur_size > (1024*1024)) {
+ kdb_printf("%-20s %10lu %10lu\n",zone_copy.zone_name, (uintptr_t)zone_copy.cur_size,(uintptr_t)(zone_copy.countfree * zone_copy.elem_size));
}
- }
+ }
}
- kdb_printf("Kernel Stacks:%lu\n",(uintptr_t)(kernel_stack_size * stack_total));
+ kdb_printf("%-20s %10lu\n", "Kernel Stacks", (uintptr_t)(kernel_stack_size * stack_total));
#if defined(__i386__) || defined (__x86_64__)
- kdb_printf("PageTables:%lu\n",(uintptr_t)(PAGE_SIZE * inuse_ptepages_count));
+ kdb_printf("%-20s %10lu\n", "PageTables",(uintptr_t)(PAGE_SIZE * inuse_ptepages_count));
#endif
- kdb_printf("Kalloc.Large:%lu\n",(uintptr_t)kalloc_large_total);
+ kdb_printf("%-20s %10lu\n", "Kalloc.Large", (uintptr_t)kalloc_large_total);
+ if (panic_kext_memory_info) {
+ mach_memory_info_t *mem_info = (mach_memory_info_t *)panic_kext_memory_info;
+ kdb_printf("\n%-5s %10s\n", "Kmod", "Size");
+ for (i = 0; i < VM_KERN_MEMORY_COUNT + VM_KERN_COUNTER_COUNT; i++) {
+ if (((mem_info[i].flags & VM_KERN_SITE_TYPE) == VM_KERN_SITE_KMOD) && (mem_info[i].size > (1024 * 1024))) {
+ kdb_printf("%-5lld %10lld\n", mem_info[i].site, mem_info[i].size);
+ }
+ }
+ }
}
}
void kdp_set_interface(void *);
void kdp_register_send_receive(void *, void *);
void kdp_unregister_send_receive(void *, void *);
-void kdp_snapshot_preflight(int, void *, uint32_t, uint32_t);
+
int kdp_stack_snapshot_geterror(void);
-int kdp_stack_snapshot_bytes_traced(void);
+uint32_t kdp_stack_snapshot_bytes_traced(void);
void *
kdp_get_interface( void)
projects / apple / xnu.git / blobdiff