#include <mach_assert.h>
#include <mach_kdb.h>
#include <mach_kgdb.h>
#include <mach_kdp.h>
#include <kern/cpu_number.h>
#include <kern/lock.h>
#include <kern/spl.h>
#include <kern/thread.h>
#include <kern/assert.h>
#include <kern/sched_prim.h>
#include <kern/misc_protos.h>
#include <vm/vm_kern.h>
#include <vm/pmap.h>
#include <stdarg.h>
#if !MACH_KDP
#include <kdp/kdp_udp.h>
#endif
#ifdef __ppc__
#include <ppc/Firmware.h>
#include <ppc/low_trace.h>
#endif
#ifdef __i386__
#include <i386/cpu_threads.h>
#include <i386/pmCPU.h>
#endif
#include <IOKit/IOPlatformExpert.h>
unsigned int halt_in_debugger = 0;
unsigned int switch_debugger = 0;
unsigned int current_debugger = 0;
unsigned int active_debugger = 0;
unsigned int debug_mode=0;
unsigned int disable_debug_output = TRUE;
unsigned int systemLogDiags = FALSE;
unsigned int panicDebugging = FALSE;
unsigned int logPanicDataToScreen = FALSE;
int mach_assert = 1;
const char *panicstr = (char *) 0;
decl_simple_lock_data(,panic_lock)
int paniccpu;
volatile int panicwait;
volatile unsigned int nestedpanic= 0;
unsigned int panic_is_inited = 0;
unsigned int return_on_panic = 0;
unsigned long panic_caller;
char *debug_buf;
ppnum_t debug_buf_page;
char *debug_buf_ptr;
unsigned int debug_buf_size;
static char model_name[64];
struct pasc {
unsigned a: 7;
unsigned b: 7;
unsigned c: 7;
unsigned d: 7;
unsigned e: 7;
unsigned f: 7;
unsigned g: 7;
unsigned h: 7;
} __attribute__((packed));
typedef struct pasc pasc_t;
void
Assert(
const char *file,
int line,
#if CONFIG_NO_PANIC_STRINGS
__unused const char *expression
#else
const char *expression
#endif
)
{
int saved_return_on_panic;
if (!mach_assert) {
return;
}
saved_return_on_panic = return_on_panic;
return_on_panic = 1;
panic_plain("%s:%d Assertion failed: %s", file, line, expression);
return_on_panic = saved_return_on_panic;
}
#define PANIC_LOCK() \
MACRO_BEGIN \
if (panic_is_inited) \
simple_lock(&panic_lock); \
MACRO_END
#define PANIC_UNLOCK() \
MACRO_BEGIN \
if (panic_is_inited) \
simple_unlock(&panic_lock); \
MACRO_END
void
panic_init(void)
{
simple_lock_init(&panic_lock, 0);
panic_is_inited = 1;
panic_caller = 0;
}
void
debug_log_init(void)
{
if (debug_buf_size != 0)
return;
if (kmem_alloc(kernel_map, (vm_offset_t *) &debug_buf, PAGE_SIZE)
!= KERN_SUCCESS)
panic("cannot allocate debug_buf\n");
debug_buf_ptr = debug_buf;
debug_buf_size = PAGE_SIZE;
debug_buf_page = pmap_find_phys(kernel_pmap,
(addr64_t)(uintptr_t)debug_buf_ptr);
}
#if __i386__
#define panic_stop() pmCPUHalt(PM_HALT_PANIC)
#define panic_safe() pmSafeMode(x86_lcpu(), PM_SAFE_FL_SAFE)
#define panic_normal() pmSafeMode(x86_lcpu(), PM_SAFE_FL_NORMAL)
#else
#define panic_stop() { while (1) ; }
#define panic_safe()
#define panic_normal()
#endif
#undef panic(...)
void
panic(const char *str, ...)
{
va_list listp;
spl_t s;
thread_t thread;
wait_queue_t wq;
s = splhigh();
disable_preemption();
panic_safe();
#ifdef __ppc__
lastTrace = LLTraceSet(0);
#endif
thread = current_thread();
wq = thread->wait_queue;
thread->wait_queue = NULL;
if( logPanicDataToScreen )
disable_debug_output = FALSE;
debug_mode = TRUE;
if ( ! panic_caller )
panic_caller = (unsigned long)(char *)__builtin_return_address(0);
restart:
PANIC_LOCK();
if (panicstr) {
if (cpu_number() != paniccpu) {
PANIC_UNLOCK();
while (panicwait)
continue;
goto restart;
} else {
nestedpanic +=1;
PANIC_UNLOCK();
Debugger("double panic");
printf("double panic: We are hanging here...\n");
panic_stop();
}
}
panicstr = str;
paniccpu = cpu_number();
panicwait = 1;
PANIC_UNLOCK();
kdb_printf("panic(cpu %d caller 0x%08lX): ", (unsigned) paniccpu, panic_caller);
if (str) {
va_start(listp, str);
_doprnt(str, &listp, consdebug_putc, 0);
va_end(listp);
}
kdb_printf("\n");
panicwait = 0;
Debugger("panic");
PANIC_LOCK();
panicstr = (char *)0;
PANIC_UNLOCK();
thread->wait_queue = wq;
if (return_on_panic) {
panic_normal();
enable_preemption();
splx(s);
return;
}
kdb_printf("panic: We are hanging here...\n");
panic_stop();
}
void
log(__unused int level, char *fmt, ...)
{
va_list listp;
#ifdef lint
level++;
#endif
#ifdef MACH_BSD
disable_preemption();
va_start(listp, fmt);
_doprnt(fmt, &listp, conslog_putc, 0);
va_end(listp);
enable_preemption();
#endif
}
void
debug_putc(char c)
{
if ((debug_buf_size != 0) &&
((debug_buf_ptr-debug_buf) < (int)debug_buf_size)) {
*debug_buf_ptr=c;
debug_buf_ptr++;
}
}
int packA(char *inbuf, uint32_t length, uint32_t buflen)
{
unsigned int i, j = 0;
pasc_t pack;
length = MIN(((length & ~7) +8), buflen);
for (i = 0; i < length; i+=8)
{
pack.a = inbuf[i];
pack.b = inbuf[i+1];
pack.c = inbuf[i+2];
pack.d = inbuf[i+3];
pack.e = inbuf[i+4];
pack.f = inbuf[i+5];
pack.g = inbuf[i+6];
pack.h = inbuf[i+7];
bcopy ((char *) &pack, inbuf + j, 7);
j += 7;
}
return ((length * 7)/8);
}
void unpackA(char *inbuf, uint32_t length)
{
pasc_t packs;
unsigned i = 0;
length = (length * 8)/7;
while (i < length) {
packs = *(pasc_t *)&inbuf[i];
bcopy(&inbuf[i+7], &inbuf[i+8], MAX(0, (int) (length - i - 8)));
inbuf[i++] = packs.a;
inbuf[i++] = packs.b;
inbuf[i++] = packs.c;
inbuf[i++] = packs.d;
inbuf[i++] = packs.e;
inbuf[i++] = packs.f;
inbuf[i++] = packs.g;
inbuf[i++] = packs.h;
}
}
extern void *proc_name_address(void *p);
static void
panic_display_process_name(void) {
char proc_name[32] = "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 (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);
}
unsigned panic_active(void) {
return ((panicstr != (char *) 0));
}
void populate_model_name(char *model_string) {
strlcpy(model_name, model_string, sizeof(model_name));
}
static void panic_display_model_name(void) {
char tmp_model_name[sizeof(model_name)];
if (ml_nofault_copy((vm_offset_t) &model_name, (vm_offset_t) &tmp_model_name, sizeof(model_name)) != sizeof(model_name))
return;
model_name[sizeof(model_name) - 1] = '\0';
if (model_name[0] != 0)
kdb_printf("System model name: %s\n", model_name);
}
extern const char version[];
extern char osversion[];
__private_extern__ void panic_display_system_configuration(void) {
static boolean_t config_displayed = FALSE;
panic_display_process_name();
if (config_displayed == FALSE) {
kdb_printf("\nMac OS version:\n%s\n",
(osversion[0] != 0) ? osversion : "Not yet set");
kdb_printf("\nKernel version:\n%s\n",version);
panic_display_model_name();
config_displayed = TRUE;
}
}
#if !MACH_KDP
static struct ether_addr kdp_current_mac_address = {{0, 0, 0, 0, 0, 0}};
unsigned int not_in_kdp = 1;
void *kdp_get_interface(void);
void kdp_set_ip_and_mac_addresses(struct in_addr *, struct ether_addr *);
void kdp_set_gateway_mac(void *);
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);
void *
kdp_get_interface( void)
{
return(void *)0;
}
unsigned int
kdp_get_ip_address(void )
{ return 0; }
struct ether_addr
kdp_get_mac_addr(void)
{
return kdp_current_mac_address;
}
void
kdp_set_ip_and_mac_addresses(
__unused struct in_addr *ipaddr,
__unused struct ether_addr *macaddr)
{}
void
kdp_set_gateway_mac(__unused void *gatewaymac)
{}
void
kdp_set_interface(__unused void *ifp)
{}
void
kdp_register_send_receive(__unused void *send, __unused void *receive)
{}
void
kdp_unregister_send_receive(__unused void *send, __unused void *receive)
{}
void
kdp_snapshot_preflight(__unused int pid, __unused void * tracebuf,
__unused uint32_t tracebuf_size, __unused uint32_t options)
{}
int
kdp_stack_snapshot_geterror(void)
{
return -1;
}
int
kdp_stack_snapshot_bytes_traced(void)
{
return 0;
}
#endif