#include <platforms.h>
#include <time_stamp.h>
#include <mach_mp_debug.h>
#include <mach_ldebug.h>
#include <kern/spl.h>
#include <kern/cpu_number.h>
#include <kern/kern_types.h>
#include <kern/misc_protos.h>
#include <vm/pmap.h>
#include <i386/thread.h>
#include <i386/db_machdep.h>
#include <i386/seg.h>
#include <i386/trap.h>
#include <i386/setjmp.h>
#include <i386/pmap.h>
#include <i386/misc_protos.h>
#include <mach/vm_param.h>
#include <vm/vm_map.h>
#include <kern/thread.h>
#include <kern/task.h>
#include <ddb/db_command.h>
#include <ddb/db_task_thread.h>
#include <ddb/db_run.h>
#include <ddb/db_trap.h>
#include <ddb/db_output.h>
#include <ddb/db_access.h>
#include <ddb/db_sym.h>
#include <ddb/db_break.h>
#include <ddb/db_watch.h>
int db_active = 0;
struct i386_saved_state *i386_last_saved_statep;
struct i386_saved_state i386_nested_saved_state;
unsigned i386_last_kdb_sp;
extern thread_t db_default_act;
extern pt_entry_t *DMAP1;
extern caddr_t DADDR1;
#if MACH_MP_DEBUG
extern int masked_state_cnt[];
#endif
struct int_regs {
int gs;
int fs;
int edi;
int esi;
int ebp;
int ebx;
struct i386_interrupt_state *is;
};
extern char * trap_type[];
extern int TRAP_TYPES;
extern void kdbprinttrap(
int type,
int code,
int *pc,
int sp);
extern void kdb_kentry(
struct int_regs *int_regs);
extern int db_user_to_kernel_address(
task_t task,
vm_offset_t addr,
unsigned *kaddr,
int flag);
extern void db_write_bytes_user_space(
vm_offset_t addr,
int size,
char *data,
task_t task);
extern int db_search_null(
task_t task,
unsigned *svaddr,
unsigned evaddr,
unsigned *skaddr,
int flag);
extern int kdb_enter(int);
extern void kdb_leave(void);
extern void lock_kdb(void);
extern void unlock_kdb(void);
extern jmp_buf_t *db_recover;
void
db_tss_to_frame(
int tss_sel,
struct i386_saved_state *regs)
{
extern struct i386_tss ktss;
int mycpu = cpu_number();
struct i386_tss *tss;
tss = cpu_datap(mycpu)->cpu_desc_index.cdi_ktss;
regs->esp = tss->esp0;
regs->efl = tss->eflags;
regs->eip = tss->eip;
regs->trapno = tss->ss0;
regs->err = tss->esp0;
regs->eax = tss->eax;
regs->ecx = tss->ecx;
regs->edx = tss->edx;
regs->ebx = tss->ebx;
regs->uesp = tss->esp;
regs->ebp = tss->ebp;
regs->esi = tss->esi;
regs->edi = tss->edi;
regs->es = tss->es;
regs->ss = tss->ss;
regs->cs = tss->cs;
regs->ds = tss->ds;
regs->fs = tss->fs;
regs->gs = tss->gs;
}
boolean_t
db_trap_from_asm(
struct i386_saved_state *regs)
{
int code;
int type;
type = regs->trapno;
code = regs->err;
return (kdb_trap(type, code, regs));
}
int
kdb_trap(
int type,
int code,
struct i386_saved_state *regs)
{
extern char etext;
boolean_t trap_from_user;
spl_t s = splhigh();
switch (type) {
case T_DEBUG:
{
extern int dr_addr[];
int addr;
int status = dr6();
if (status & 0xf) {
addr = status & 0x8 ? dr_addr[3] :
status & 0x4 ? dr_addr[2] :
status & 0x2 ? dr_addr[1] :
dr_addr[0];
regs->efl |= EFL_RF;
db_single_step_cmd(addr, 0, 1, "p");
}
}
case T_INT3:
case T_WATCHPOINT:
case -1:
break;
default:
if (db_recover) {
i386_nested_saved_state = *regs;
db_printf("Caught ");
if (type < 0 || type > TRAP_TYPES)
db_printf("type %d", type);
else
db_printf("%s", trap_type[type]);
db_printf(" trap, code = %x, pc = %x\n",
code, regs->eip);
splx(s);
db_error("");
}
kdbprinttrap(type, code, (int *)®s->eip, regs->uesp);
}
disable_preemption();
current_cpu_datap()->cpu_kdb_saved_ipl = s;
current_cpu_datap()->cpu_kdb_saved_state = regs;
i386_last_saved_statep = regs;
i386_last_kdb_sp = (unsigned) &type;
if (!kdb_enter(regs->eip))
goto kdb_exit;
if (!IS_USER_TRAP(regs, &etext)) {
bzero((char *)&ddb_regs, sizeof (ddb_regs));
*(struct i386_saved_state_from_kernel *)&ddb_regs =
*(struct i386_saved_state_from_kernel *)regs;
trap_from_user = FALSE;
}
else {
ddb_regs = *regs;
trap_from_user = TRUE;
}
if (!trap_from_user) {
ddb_regs.uesp = (int)®s->uesp;
ddb_regs.ss = KERNEL_DS;
}
db_active++;
db_task_trap(type, code, trap_from_user);
db_active--;
regs->eip = ddb_regs.eip;
regs->efl = ddb_regs.efl;
regs->eax = ddb_regs.eax;
regs->ecx = ddb_regs.ecx;
regs->edx = ddb_regs.edx;
regs->ebx = ddb_regs.ebx;
if (trap_from_user) {
regs->uesp = ddb_regs.uesp;
regs->ss = ddb_regs.ss & 0xffff;
}
regs->ebp = ddb_regs.ebp;
regs->esi = ddb_regs.esi;
regs->edi = ddb_regs.edi;
regs->es = ddb_regs.es & 0xffff;
regs->cs = ddb_regs.cs & 0xffff;
regs->ds = ddb_regs.ds & 0xffff;
regs->fs = ddb_regs.fs & 0xffff;
regs->gs = ddb_regs.gs & 0xffff;
if ((type == T_INT3) &&
(db_get_task_value(regs->eip,
BKPT_SIZE,
FALSE,
db_target_space(current_thread(),
trap_from_user))
== BKPT_INST))
regs->eip += BKPT_SIZE;
kdb_exit:
kdb_leave();
current_cpu_datap()->cpu_kdb_saved_state = 0;
#if MACH_MP_DEBUG
current_cpu_datap()->cpu_masked_state_cnt = 0;
#endif
enable_preemption();
splx(s);
if (trap_from_user && type != T_DEBUG && type != T_INT3
&& type != T_WATCHPOINT)
return 0;
else
return (1);
}
spl_t kdb_oldspl;
void
kdb_kentry(
struct int_regs *int_regs)
{
extern char etext;
boolean_t trap_from_user;
struct i386_interrupt_state *is = int_regs->is;
struct i386_saved_state regs;
spl_t s;
s = splhigh();
kdb_oldspl = s;
if (IS_USER_TRAP(is, &etext))
{
regs.uesp = ((int *)(is+1))[0];
regs.ss = ((int *)(is+1))[1];
}
else {
regs.ss = KERNEL_DS;
regs.uesp= (int)(is+1);
}
regs.efl = is->efl;
regs.cs = is->cs;
regs.eip = is->eip;
regs.eax = is->eax;
regs.ecx = is->ecx;
regs.edx = is->edx;
regs.ebx = int_regs->ebx;
regs.ebp = int_regs->ebp;
regs.esi = int_regs->esi;
regs.edi = int_regs->edi;
regs.ds = is->ds;
regs.es = is->es;
regs.fs = int_regs->fs;
regs.gs = int_regs->gs;
disable_preemption();
current_cpu_datap()->cpu_kdb_saved_state = ®s;
if (!kdb_enter(regs.eip))
goto kdb_exit;
bcopy((char *)®s, (char *)&ddb_regs, sizeof (ddb_regs));
trap_from_user = IS_USER_TRAP(&ddb_regs, &etext);
db_active++;
db_task_trap(-1, 0, trap_from_user);
db_active--;
if (trap_from_user) {
((int *)(is+1))[0] = ddb_regs.uesp;
((int *)(is+1))[1] = ddb_regs.ss & 0xffff;
}
is->efl = ddb_regs.efl;
is->cs = ddb_regs.cs & 0xffff;
is->eip = ddb_regs.eip;
is->eax = ddb_regs.eax;
is->ecx = ddb_regs.ecx;
is->edx = ddb_regs.edx;
int_regs->ebx = ddb_regs.ebx;
int_regs->ebp = ddb_regs.ebp;
int_regs->esi = ddb_regs.esi;
int_regs->edi = ddb_regs.edi;
is->ds = ddb_regs.ds & 0xffff;
is->es = ddb_regs.es & 0xffff;
int_regs->fs = ddb_regs.fs & 0xffff;
int_regs->gs = ddb_regs.gs & 0xffff;
kdb_exit:
kdb_leave();
current_cpu_datap()->cpu_kdb_saved_state = 0;
enable_preemption();
splx(s);
}
void
kdbprinttrap(
int type,
int code,
int *pc,
int sp)
{
printf("kernel: ");
if (type < 0 || type > TRAP_TYPES)
db_printf("type %d", type);
else
db_printf("%s", trap_type[type]);
db_printf(" trap, code=%x eip@%x = %x esp=%x\n",
code, pc, *(int *)pc, sp);
db_run_mode = STEP_CONTINUE;
}
int
db_user_to_kernel_address(
task_t task,
vm_offset_t addr,
unsigned *kaddr,
int flag)
{
register pt_entry_t *ptp;
ptp = pmap_pte(task->map->pmap, addr);
if (ptp == PT_ENTRY_NULL || (*ptp & INTEL_PTE_VALID) == 0) {
if (flag) {
db_printf("\nno memory is assigned to address %08x\n", addr);
db_error(0);
}
return(-1);
}
src = (vm_offset_t)pte_to_pa(*ptp);
*(int *) DMAP1 = INTEL_PTE_VALID | INTEL_PTE_RW | (src & PG_FRAME) |
INTEL_PTE_REF | INTEL_PTE_MOD;
#if defined(I386_CPU)
if (cpu_class == CPUCLASS_386) {
invltlb();
} else
#endif
{
invlpg((u_int)DADDR1);
}
*kaddr = (unsigned)DADDR1 + (addr & PAGE_MASK);
return(0);
}
void
db_read_bytes(
vm_offset_t addr,
int size,
char *data,
task_t task)
{
register char *src;
register int n;
unsigned kern_addr;
src = (char *)addr;
if (task == kernel_task || task == TASK_NULL) {
while (--size >= 0) {
if (addr++ > VM_MAX_KERNEL_ADDRESS) {
db_printf("\nbad address %x\n", addr);
db_error(0);
}
*data++ = *src++;
}
return;
}
while (size > 0) {
if (db_user_to_kernel_address(task, addr, &kern_addr, 1) < 0)
return;
src = (char *)kern_addr;
n = intel_trunc_page(addr+INTEL_PGBYTES) - addr;
if (n > size)
n = size;
size -= n;
addr += n;
while (--n >= 0)
*data++ = *src++;
}
}
void
db_write_bytes(
vm_offset_t addr,
int size,
char *data,
task_t task)
{
register char *dst;
register pt_entry_t *ptep0 = 0;
pt_entry_t oldmap0 = 0;
vm_offset_t addr1;
register pt_entry_t *ptep1 = 0;
pt_entry_t oldmap1 = 0;
extern char etext;
if (task && task != kernel_task) {
db_write_bytes_user_space(addr, size, data, task);
return;
}
if (addr >= VM_MIN_KERNEL_LOADED_ADDRESS) {
db_write_bytes_user_space(addr, size, data, kernel_task);
return;
}
if (addr >= VM_MIN_KERNEL_ADDRESS &&
addr <= (vm_offset_t)&etext)
{
ptep0 = pmap_pte(kernel_pmap, addr);
oldmap0 = *ptep0;
*ptep0 |= INTEL_PTE_WRITE;
addr1 = i386_trunc_page(addr + size - 1);
if (i386_trunc_page(addr) != addr1) {
ptep1 = pmap_pte(kernel_pmap, addr1);
oldmap1 = *ptep1;
*ptep1 |= INTEL_PTE_WRITE;
}
flush_tlb();
}
dst = (char *)addr;
while (--size >= 0) {
if (addr++ > VM_MAX_KERNEL_ADDRESS) {
db_printf("\nbad address %x\n", addr);
db_error(0);
}
*dst++ = *data++;
}
if (ptep0) {
*ptep0 = oldmap0;
if (ptep1) {
*ptep1 = oldmap1;
}
flush_tlb();
}
}
void
db_write_bytes_user_space(
vm_offset_t addr,
int size,
char *data,
task_t task)
{
register char *dst;
register int n;
unsigned kern_addr;
while (size > 0) {
if (db_user_to_kernel_address(task, addr, &kern_addr, 1) < 0)
return;
dst = (char *)kern_addr;
n = intel_trunc_page(addr+INTEL_PGBYTES) - addr;
if (n > size)
n = size;
size -= n;
addr += n;
while (--n >= 0)
*dst++ = *data++;
}
}
boolean_t
db_check_access(
vm_offset_t addr,
int size,
task_t task)
{
register n;
unsigned kern_addr;
if (task == kernel_task || task == TASK_NULL) {
if (kernel_task == TASK_NULL)
return(TRUE);
task = kernel_task;
} else if (task == TASK_NULL) {
if (current_thread() == THREAD_NULL)
return(FALSE);
task = current_thread()->task;
}
while (size > 0) {
if (db_user_to_kernel_address(task, addr, &kern_addr, 0) < 0)
return(FALSE);
n = intel_trunc_page(addr+INTEL_PGBYTES) - addr;
if (n > size)
n = size;
size -= n;
addr += n;
}
return(TRUE);
}
boolean_t
db_phys_eq(
task_t task1,
vm_offset_t addr1,
task_t task2,
vm_offset_t addr2)
{
unsigned kern_addr1, kern_addr2;
if ((addr1 & (INTEL_PGBYTES-1)) != (addr2 & (INTEL_PGBYTES-1)))
return(FALSE);
if (task1 == TASK_NULL) {
if (current_thread() == THREAD_NULL)
return(FALSE);
task1 = current_thread()->task;
}
if (db_user_to_kernel_address(task1, addr1, &kern_addr1, 0) < 0 ||
db_user_to_kernel_address(task2, addr2, &kern_addr2, 0) < 0)
return(FALSE);
return(kern_addr1 == kern_addr2);
}
#define DB_USER_STACK_ADDR (VM_MIN_KERNEL_ADDRESS)
#define DB_NAME_SEARCH_LIMIT (DB_USER_STACK_ADDR-(INTEL_PGBYTES*3))
int
db_search_null(
task_t task,
unsigned *svaddr,
unsigned evaddr,
unsigned *skaddr,
int flag)
{
register unsigned vaddr;
register unsigned *kaddr;
kaddr = (unsigned *)*skaddr;
for (vaddr = *svaddr; vaddr > evaddr; vaddr -= sizeof(unsigned)) {
if (vaddr % INTEL_PGBYTES == 0) {
vaddr -= sizeof(unsigned);
if (db_user_to_kernel_address(task, vaddr, skaddr, 0) < 0)
return(-1);
kaddr = (unsigned *)*skaddr;
} else {
vaddr -= sizeof(unsigned);
kaddr--;
}
if ((*kaddr == 0) ^ (flag == 0)) {
*svaddr = vaddr;
*skaddr = (unsigned)kaddr;
return(0);
}
}
return(-1);
}
void
db_task_name(
task_t task)
{
register char *p;
register n;
unsigned vaddr, kaddr;
vaddr = DB_USER_STACK_ADDR;
kaddr = 0;
if (db_search_null(task, &vaddr, DB_NAME_SEARCH_LIMIT, &kaddr, 0) < 0) {
db_printf(DB_NULL_TASK_NAME);
return;
}
if (db_search_null(task, &vaddr, DB_NAME_SEARCH_LIMIT, &kaddr, 1) < 0) {
db_printf(DB_NULL_TASK_NAME);
return;
}
n = DB_TASK_NAME_LEN-1;
p = (char *)kaddr + sizeof(unsigned);
for (vaddr += sizeof(int); vaddr < DB_USER_STACK_ADDR && n > 0;
vaddr++, p++, n--) {
if (vaddr % INTEL_PGBYTES == 0) {
(void)db_user_to_kernel_address(task, vaddr, &kaddr, 0);
p = (char*)kaddr;
}
db_printf("%c", (*p < ' ' || *p > '~')? ' ': *p);
}
while (n-- >= 0)
db_printf(" ");
}
decl_simple_lock_data(, kdb_lock)
#define db_simple_lock_init(l, e) hw_lock_init(&((l)->interlock))
#define db_simple_lock_try(l) hw_lock_try(&((l)->interlock))
#define db_simple_unlock(l) hw_lock_unlock(&((l)->interlock))
int kdb_cpu = -1;
int kdb_debug = 0;
volatile unsigned int cpus_holding_bkpts;
extern boolean_t db_breakpoints_inserted;
void
db_machdep_init(void)
{
int c;
db_simple_lock_init(&kdb_lock, 0);
for (c = 0; c < real_ncpus; ++c) {
db_stacks[c] = (vm_offset_t) (db_stack_store +
(INTSTACK_SIZE * (c + 1)) - sizeof (natural_t));
if (c == master_cpu) {
dbtss.esp0 = (int)(db_task_stack_store +
(INTSTACK_SIZE * (c + 1)) - sizeof (natural_t));
dbtss.esp = dbtss.esp0;
dbtss.eip = (int)&db_task_start;
}
}
}
int
kdb_enter(int pc)
{
int mycpu;
int retval;
disable_preemption();
mycpu = cpu_number();
if (current_cpu_datap()->cpu_db_pass_thru) {
retval = 0;
goto kdb_exit;
}
current_cpu_datap()->cpu_kdb_active++;
lock_kdb();
if (kdb_debug)
db_printf("kdb_enter: cpu %d, is_slave %d, kdb_cpu %d, run mode %d pc %x (%x) holds %d\n",
my_cpu, current_cpu_datap()->cpu_kdb_is_slave, kdb_cpu,
db_run_mode, pc, *(int *)pc, cpus_holding_bkpts);
if (db_breakpoints_inserted)
cpus_holding_bkpts++;
if (kdb_cpu == -1 && !current_cpu_datap()->cpu_kdb_is_slave) {
kdb_cpu = my_cpu;
remote_kdb();
retval = 1;
} else if (kdb_cpu == my_cpu)
retval = 1;
else
retval = 0;
kdb_exit:
enable_preemption();
return (retval);
}
void
kdb_leave(void)
{
int my_cpu;
boolean_t wait = FALSE;
disable_preemption();
my_cpu = cpu_number();
if (db_run_mode == STEP_CONTINUE) {
wait = TRUE;
kdb_cpu = -1;
}
if (db_breakpoints_inserted)
cpus_holding_bkpts--;
if (current_cpu_datap()->cpu_kdb_is_slave)
current_cpu_datap()->cpu_kdb_is_slave--;
if (kdb_debug)
db_printf("kdb_leave: cpu %d, kdb_cpu %d, run_mode %d pc %x (%x) holds %d\n",
my_cpu, kdb_cpu, db_run_mode,
ddb_regs.eip, *(int *)ddb_regs.eip,
cpus_holding_bkpts);
clear_kdb_intr();
unlock_kdb();
current_cpu_datap()->cpu_kdb_active--;
enable_preemption();
if (wait) {
while(cpus_holding_bkpts);
}
}
void
lock_kdb(void)
{
int my_cpu;
register i;
extern void kdb_console(void);
disable_preemption();
my_cpu = cpu_number();
for(;;) {
kdb_console();
if (kdb_cpu != -1 && kdb_cpu != my_cpu) {
continue;
}
if (db_simple_lock_try(&kdb_lock)) {
if (kdb_cpu == -1 || kdb_cpu == my_cpu)
break;
db_simple_unlock(&kdb_lock);
}
}
enable_preemption();
}
#if TIME_STAMP
extern unsigned old_time_stamp;
#endif
void
unlock_kdb(void)
{
db_simple_unlock(&kdb_lock);
#if TIME_STAMP
old_time_stamp = 0;
#endif
}
#ifdef __STDC__
#define KDB_SAVE(type, name) extern type name; type name##_save = name
#define KDB_RESTORE(name) name = name##_save
#else
#define KDB_SAVE(type, name) extern type name; type name_save = name
#define KDB_RESTORE(name) name = name_save
#endif
#define KDB_SAVE_CTXT() \
KDB_SAVE(int, db_run_mode); \
KDB_SAVE(boolean_t, db_sstep_print); \
KDB_SAVE(int, db_loop_count); \
KDB_SAVE(int, db_call_depth); \
KDB_SAVE(int, db_inst_count); \
KDB_SAVE(int, db_last_inst_count); \
KDB_SAVE(int, db_load_count); \
KDB_SAVE(int, db_store_count); \
KDB_SAVE(boolean_t, db_cmd_loop_done); \
KDB_SAVE(jmp_buf_t *, db_recover); \
KDB_SAVE(db_addr_t, db_dot); \
KDB_SAVE(db_addr_t, db_last_addr); \
KDB_SAVE(db_addr_t, db_prev); \
KDB_SAVE(db_addr_t, db_next); \
KDB_SAVE(db_regs_t, ddb_regs);
#define KDB_RESTORE_CTXT() \
KDB_RESTORE(db_run_mode); \
KDB_RESTORE(db_sstep_print); \
KDB_RESTORE(db_loop_count); \
KDB_RESTORE(db_call_depth); \
KDB_RESTORE(db_inst_count); \
KDB_RESTORE(db_last_inst_count); \
KDB_RESTORE(db_load_count); \
KDB_RESTORE(db_store_count); \
KDB_RESTORE(db_cmd_loop_done); \
KDB_RESTORE(db_recover); \
KDB_RESTORE(db_dot); \
KDB_RESTORE(db_last_addr); \
KDB_RESTORE(db_prev); \
KDB_RESTORE(db_next); \
KDB_RESTORE(ddb_regs);
void
kdb_on(
int cpu)
{
KDB_SAVE_CTXT();
if (cpu < 0 || cpu >= real_ncpus || !cpu_datap(cpu)->cpu_kdb_active)
return;
db_set_breakpoints();
db_set_watchpoints();
kdb_cpu = cpu;
unlock_kdb();
lock_kdb();
db_clear_breakpoints();
db_clear_watchpoints();
KDB_RESTORE_CTXT();
if (kdb_cpu == -1) {
kdb_cpu = cpu_number();
db_continue_cmd(0, 0, 0, "");
}
}
void db_reboot(
db_expr_t addr,
boolean_t have_addr,
db_expr_t count,
char *modif)
{
boolean_t reboot = TRUE;
char *cp, c;
cp = modif;
while ((c = *cp++) != 0) {
if (c == 'r')
reboot = TRUE;
if (c == 'h')
reboot = FALSE;
}
halt_all_cpus(reboot);
}