X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/d7e50217d7adf6e52786a38bcaa4cd698cb9a79e..15129b1c8dbb3650c63b70adb1cad9af601c6c17:/osfmk/kern/debug.h?ds=sidebyside diff --git a/osfmk/kern/debug.h b/osfmk/kern/debug.h index a2d96f047..a61206294 100644 --- a/osfmk/kern/debug.h +++ b/osfmk/kern/debug.h @@ -1,16 +1,19 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2007 Apple Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ - * - * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in - * compliance with the License. Please obtain a copy of the License at - * http://www.opensource.apple.com/apsl/ and read it before using this - * file. + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER @@ -20,17 +23,195 @@ * Please see the License for the specific language governing rights and * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ #ifndef _KERN_DEBUG_H_ #define _KERN_DEBUG_H_ -#include +#include +#include +#include + +#ifndef XNU_KERNEL_PRIVATE +#include +#endif + +#ifdef __APPLE_API_PRIVATE +#ifdef __APPLE_API_UNSTABLE + +struct thread_snapshot { + uint32_t snapshot_magic; + uint32_t nkern_frames; + uint32_t nuser_frames; + uint64_t wait_event; + uint64_t continuation; + uint64_t thread_id; + uint64_t user_time; + uint64_t system_time; + int32_t state; + int32_t priority; // static priority + int32_t sched_pri; // scheduled (current) priority + int32_t sched_flags; // scheduler flags + char ss_flags; +} __attribute__ ((packed)); + +struct task_snapshot { + uint32_t snapshot_magic; + int32_t pid; + uint64_t uniqueid; + uint64_t user_time_in_terminated_threads; + uint64_t system_time_in_terminated_threads; + uint8_t shared_cache_identifier[16]; + uint64_t shared_cache_slide; + uint32_t nloadinfos; + int suspend_count; + int task_size; // pages + int faults; // number of page faults + int pageins; // number of actual pageins + int cow_faults; // number of copy-on-write faults + uint32_t ss_flags; + /* We restrict ourselves to a statically defined + * (current as of 2009) length for the + * p_comm string, due to scoping issues (osfmk/bsd and user/kernel + * binary compatibility). + */ + char p_comm[17]; + uint32_t was_throttled; + uint32_t did_throttle; + uint32_t latency_qos; +} __attribute__ ((packed)); + +struct micro_snapshot { + uint32_t snapshot_magic; + uint32_t ms_cpu; /* cpu number this snapshot was recorded on */ + uint64_t ms_time; /* time at sample (seconds) */ + uint64_t ms_time_microsecs; + uint8_t ms_flags; + uint16_t ms_opaque_flags; /* managed by external entity, e.g. fdrmicrod */ +} __attribute__ ((packed)); + +struct mem_and_io_snapshot { + uint32_t snapshot_magic; + uint32_t free_pages; + uint32_t active_pages; + uint32_t inactive_pages; + uint32_t purgeable_pages; + uint32_t wired_pages; + uint32_t speculative_pages; + uint32_t throttled_pages; + uint32_t filebacked_pages; + uint32_t compressions; + uint32_t decompressions; + uint32_t compressor_size; + int busy_buffer_count; + uint32_t pages_wanted; + uint32_t pages_reclaimed; + uint8_t pages_wanted_reclaimed_valid; // did mach_vm_pressure_monitor succeed? +} __attribute__((packed)); + +struct stack_snapshot_frame32 { + uint32_t lr; + uint32_t sp; +}; + +struct stack_snapshot_frame64 { + uint64_t lr; + uint64_t sp; +}; + +struct _dyld_cache_header +{ + char magic[16]; // e.g. "dyld_v0 i386" + uint32_t mappingOffset; // file offset to first dyld_cache_mapping_info + uint32_t mappingCount; // number of dyld_cache_mapping_info entries + uint32_t imagesOffset; // file offset to first dyld_cache_image_info + uint32_t imagesCount; // number of dyld_cache_image_info entries + uint64_t dyldBaseAddress; // base address of dyld when cache was built + uint64_t codeSignatureOffset; // file offset of code signature blob + uint64_t codeSignatureSize; // size of code signature blob (zero means to end of file) + uint64_t slideInfoOffset; // file offset of kernel slid info + uint64_t slideInfoSize; // size of kernel slid info + uint64_t localSymbolsOffset; // file offset of where local symbols are stored + uint64_t localSymbolsSize; // size of local symbols information + uint8_t uuid[16]; // unique value for each shared cache file +}; + +struct dyld_uuid_info_32 { + uint32_t imageLoadAddress; /* base address image is mapped at */ + uuid_t imageUUID; +}; + +struct dyld_uuid_info_64 { + uint64_t imageLoadAddress; /* base address image is mapped at */ + uuid_t imageUUID; +}; + +enum micro_snapshot_flags { + kInterruptRecord = 0x1, + kTimerArmingRecord = 0x2, + kUserMode = 0x4, /* interrupted usermode, or armed by usermode */ +}; + +/* + * Flags used in the following assortment of snapshots. + */ +enum generic_snapshot_flags { + kUser64_p = 0x1, + kKernel64_p = 0x2 +}; + + enum task_snapshot_flags { + kTaskRsrcFlagged = 0x4, // In the EXC_RESOURCE danger zone? + kTerminatedSnapshot = 0x8, + kPidSuspended = 0x10, // true for suspended task + kFrozen = 0x20, // true for hibernated task (along with pidsuspended) + kTaskDarwinBG = 0x40, + kTaskExtDarwinBG = 0x80, + kTaskVisVisible = 0x100, + kTaskVisNonvisible = 0x200, + kTaskIsForeground = 0x400, + kTaskIsBoosted = 0x800, + kTaskIsSuppressed = 0x1000, + kTaskIsTimerThrottled = 0x2000 /* deprecated */ + }; + +enum thread_snapshot_flags { + kHasDispatchSerial = 0x4, + kStacksPCOnly = 0x8, /* Stack traces have no frame pointers. */ + kThreadDarwinBG = 0x10 /* Thread is darwinbg */ +}; -#ifdef __APPLE_API_PRIVATE +#define VM_PRESSURE_TIME_WINDOW 5 /* seconds */ + +enum { + STACKSHOT_GET_DQ = 0x01, + STACKSHOT_SAVE_LOADINFO = 0x02, + STACKSHOT_GET_GLOBAL_MEM_STATS = 0x04, + STACKSHOT_SAVE_KEXT_LOADINFO = 0x08, + STACKSHOT_GET_MICROSTACKSHOT = 0x10, + STACKSHOT_GLOBAL_MICROSTACKSHOT_ENABLE = 0x20, + STACKSHOT_GLOBAL_MICROSTACKSHOT_DISABLE = 0x40, + STACKSHOT_SET_MICROSTACKSHOT_MARK = 0x80, + STACKSHOT_SAVE_KERNEL_FRAMES_ONLY = 0x100, + STACKSHOT_GET_BOOT_PROFILE = 0x200, +}; + +#define STACKSHOT_THREAD_SNAPSHOT_MAGIC 0xfeedface +#define STACKSHOT_TASK_SNAPSHOT_MAGIC 0xdecafbad +#define STACKSHOT_MEM_AND_IO_SNAPSHOT_MAGIC 0xbfcabcde +#define STACKSHOT_MICRO_SNAPSHOT_MAGIC 0x31c54011 + +#endif /* __APPLE_API_UNSTABLE */ +#endif /* __APPLE_API_PRIVATE */ + +#ifdef KERNEL_PRIVATE extern unsigned int systemLogDiags; +extern char debug_buf[]; +extern unsigned int debug_boot_arg; +extern unsigned char *kernel_uuid; +extern char kernel_uuid_string[]; #ifdef MACH_KERNEL_PRIVATE @@ -43,12 +224,12 @@ extern unsigned int current_debugger; #define KDP_CUR_DB 0x1 #define KDB_CUR_DB 0x2 -extern unsigned int active_debugger; +extern unsigned int active_debugger; extern unsigned int debug_mode; -extern unsigned int disableDebugOuput; +extern unsigned int disable_debug_output; -extern unsigned int panicDebugging; -extern unsigned int logPanicDataToScreen; +extern unsigned int panicDebugging; +extern unsigned int logPanicDataToScreen; extern int db_run_mode; @@ -63,17 +244,27 @@ extern int db_run_mode; #define STEP_COUNT 6 #define STEP_TRACE 7 /* Show all calls to functions and returns */ -extern char *panicstr; - -extern unsigned int nestedpanic; +extern const char *panicstr; +extern volatile unsigned int nestedpanic; +extern int unsigned long panic_caller; -extern char *debug_buf; extern char *debug_buf_ptr; extern unsigned int debug_buf_size; extern void debug_log_init(void); extern void debug_putc(char); +extern void panic_init(void); + +int packA(char *inbuf, uint32_t length, uint32_t buflen); +void unpackA(char *inbuf, uint32_t length); + +void panic_display_system_configuration(void); +void panic_display_zprint(void); +void panic_display_kernel_aslr(void); +#if CONFIG_ZLEAKS +void panic_display_ztrace(void); +#endif /* CONFIG_ZLEAKS */ #endif /* MACH_KERNEL_PRIVATE */ #define DB_HALT 0x1 @@ -85,7 +276,94 @@ extern void debug_putc(char); #define DB_ARP 0x40 #define DB_KDP_BP_DIS 0x80 #define DB_LOG_PI_SCRN 0x100 +#define DB_KDP_GETC_ENA 0x200 + +#define DB_KERN_DUMP_ON_PANIC 0x400 /* Trigger core dump on panic*/ +#define DB_KERN_DUMP_ON_NMI 0x800 /* Trigger core dump on NMI */ +#define DB_DBG_POST_CORE 0x1000 /*Wait in debugger after NMI core */ +#define DB_PANICLOG_DUMP 0x2000 /* Send paniclog on panic,not core*/ +#define DB_REBOOT_POST_CORE 0x4000 /* Attempt to reboot after + * post-panic crashdump/paniclog + * dump. + */ +#define DB_NMI_BTN_ENA 0x8000 /* Enable button to directly trigger NMI */ + +#if DEBUG +/* + * For the DEBUG kernel, support the following: + * sysctl -w debug.kprint_syscall= + * sysctl -w debug.kprint_syscall_process= + * should be an OR of the masks below + * for UNIX, MACH, MDEP, or IPC. This debugging aid + * assumes the task/process is locked/wired and will + * not go away during evaluation. If no process is + * specified, all processes will be traced + */ +extern int debug_kprint_syscall; +extern int debug_kprint_current_process(const char **namep); +#define DEBUG_KPRINT_SYSCALL_PREDICATE_INTERNAL(mask, namep) \ + ( (debug_kprint_syscall & (mask)) && debug_kprint_current_process(namep) ) +#define DEBUG_KPRINT_SYSCALL_MASK(mask, fmt, args...) do { \ + const char *dks_name = NULL; \ + if (DEBUG_KPRINT_SYSCALL_PREDICATE_INTERNAL(mask, &dks_name)) { \ + kprintf("[%s%s%p]" fmt, dks_name ? dks_name : "", \ + dks_name ? "@" : "", current_thread(), args); \ + } \ + } while (0) +#else /* !DEBUG */ +#define DEBUG_KPRINT_SYSCALL_PREDICATE_INTERNAL(mask, namep) (0) +#define DEBUG_KPRINT_SYSCALL_MASK(mask, fmt, args...) do { } while (0) /* kprintf(fmt, args) */ +#endif /* !DEBUG */ + +enum { + DEBUG_KPRINT_SYSCALL_UNIX_MASK = 1 << 0, + DEBUG_KPRINT_SYSCALL_MACH_MASK = 1 << 1, + DEBUG_KPRINT_SYSCALL_MDEP_MASK = 1 << 2, + DEBUG_KPRINT_SYSCALL_IPC_MASK = 1 << 3 +}; + +#define DEBUG_KPRINT_SYSCALL_PREDICATE(mask) \ + DEBUG_KPRINT_SYSCALL_PREDICATE_INTERNAL(mask, NULL) +#define DEBUG_KPRINT_SYSCALL_UNIX(fmt, args...) \ + DEBUG_KPRINT_SYSCALL_MASK(DEBUG_KPRINT_SYSCALL_UNIX_MASK,fmt,args) +#define DEBUG_KPRINT_SYSCALL_MACH(fmt, args...) \ + DEBUG_KPRINT_SYSCALL_MASK(DEBUG_KPRINT_SYSCALL_MACH_MASK,fmt,args) +#define DEBUG_KPRINT_SYSCALL_MDEP(fmt, args...) \ + DEBUG_KPRINT_SYSCALL_MASK(DEBUG_KPRINT_SYSCALL_MDEP_MASK,fmt,args) +#define DEBUG_KPRINT_SYSCALL_IPC(fmt, args...) \ + DEBUG_KPRINT_SYSCALL_MASK(DEBUG_KPRINT_SYSCALL_IPC_MASK,fmt,args) + +#endif /* KERNEL_PRIVATE */ + +__BEGIN_DECLS + +extern void panic(const char *string, ...) __printflike(1,2); + +#if KERNEL_PRIVATE +void _consume_panic_args(int, ...); +void panic_context(unsigned int reason, void *ctx, const char *string, ...); +#endif + +#if CONFIG_NO_PANIC_STRINGS +#if KERNEL_PRIVATE +#define panic_plain(x, ...) _consume_panic_args( 0, ## __VA_ARGS__ ) +#define panic(x, ...) _consume_panic_args( 0, ## __VA_ARGS__ ) +#else +#define panic_plain(...) (panic)((char *)0) +#define panic(...) (panic)((char *)0) +#endif +#else /* CONFIGS_NO_PANIC_STRINGS */ +#define panic_plain(ex, ...) \ + (panic)(ex, ## __VA_ARGS__) +#define __STRINGIFY(x) #x +#define LINE_NUMBER(x) __STRINGIFY(x) +#define PANIC_LOCATION __FILE__ ":" LINE_NUMBER(__LINE__) +#define panic(ex, ...) \ + (panic)(# ex "@" PANIC_LOCATION, ## __VA_ARGS__) +#endif /* CONFIGS_NO_PANIC_STRINGS */ -#endif /* __APPLE_API_PRIVATE */ +void populate_model_name(char *); +unsigned panic_active(void); +__END_DECLS #endif /* _KERN_DEBUG_H_ */