#include <cpus.h>
#include <platforms.h>
#include <time_stamp.h>
#include <mach_mp_debug.h>
#include <mach_ldebug.h>
#include <db_machine_commands.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 <ppc/mem.h>
#include <ppc/thread.h>
#include <ppc/db_machdep.h>
#include <ppc/trap.h>
#include <ppc/setjmp.h>
#include <ppc/pmap.h>
#include <ppc/misc_protos.h>
#include <ppc/exception.h>
#include <ppc/db_machdep.h>
#include <ppc/mappings.h>
#include <ppc/Firmware.h>
#include <mach/vm_param.h>
#include <mach/machine/vm_types.h>
#include <vm/vm_map.h>
#include <kern/thread.h>
#include <kern/task.h>
#include <kern/debug.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>
struct savearea *ppc_last_saved_statep;
struct savearea ppc_nested_saved_state;
unsigned ppc_last_kdb_sp;
extern int debugger_active[NCPUS];
extern int debugger_cpu;
int db_all_set_up = 0;
#if !MACH_KDP
void kdp_register_send_receive(void);
#endif
struct int_regs {
struct ppc_interrupt_state *is;
};
extern char * trap_type[];
extern int TRAP_TYPES;
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))
extern volatile unsigned int cpus_holding_bkpts;
extern boolean_t db_breakpoints_inserted;
extern void kdbprinttrap(
int type,
int code,
int *pc,
int sp);
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);
#if DB_MACHINE_COMMANDS
struct db_command ppc_db_commands[] = {
{ "lt", db_low_trace, CS_MORE|CS_SET_DOT, 0 },
{ (char *)0, 0, 0, 0 }
};
#endif
#if !MACH_KDP
void kdp_register_send_receive(void) {}
#endif
extern jmp_buf_t *db_recover;
spl_t saved_ipl[NCPUS];
struct savearea *saved_state[NCPUS];
void
kdb_trap(
int type,
struct savearea *regs)
{
boolean_t trap_from_user;
int previous_console_device;
int code=0;
previous_console_device=switch_to_serial_console();
switch (type) {
case T_TRACE:
case T_PROGRAM:
#if 0
case T_WATCHPOINT:
#endif
case -1:
break;
default:
if (db_recover) {
ppc_nested_saved_state = *regs;
db_printf("Caught ");
if (type > TRAP_TYPES)
db_printf("type %d", type);
else
db_printf("%s", trap_type[type]);
db_printf(" trap, pc = %x\n",
regs->save_srr0);
db_error("");
}
kdbprinttrap(type, code, (int *)®s->save_srr0, regs->save_r1);
}
saved_state[cpu_number()] = regs;
ppc_last_saved_statep = regs;
ppc_last_kdb_sp = (unsigned) &type;
if (!IS_USER_TRAP(regs)) {
bzero((char *)&ddb_regs, sizeof (ddb_regs));
ddb_regs = *regs;
trap_from_user = FALSE;
}
else {
ddb_regs = *regs;
trap_from_user = TRUE;
}
db_task_trap(type, code, trap_from_user);
*regs = ddb_regs;
if ((type == T_PROGRAM) &&
(db_get_task_value(regs->save_srr0,
BKPT_SIZE,
FALSE,
db_target_space(current_act(),
trap_from_user))
== BKPT_INST))
regs->save_srr0 += BKPT_SIZE;
kdb_exit:
saved_state[cpu_number()] = 0;
switch_to_old_console(previous_console_device);
}
void
kdbprinttrap(
int type,
int code,
int *pc,
int sp)
{
printf("kernel: ");
if (type > TRAP_TYPES)
db_printf("type %d", type);
else
db_printf("%s", trap_type[type]);
db_printf(" trap, code=%x pc@%x = %x sp=%x\n",
code, pc, *(int *)pc, sp);
db_run_mode = STEP_CONTINUE;
}
addr64_t db_vtophys(
pmap_t pmap,
vm_offset_t va)
{
ppnum_t pp;
addr64_t pa;
pp = pmap_find_phys(pmap, (addr64_t)va);
if (pp == 0) return(0);
pa = ((addr64_t)pp << 12) | (addr64_t)(va & 0xFFF);
return(pa);
}
void
db_read_bytes(
vm_offset_t addr,
int size,
char *data,
task_t task)
{
int n,max;
addr64_t phys_dst;
addr64_t phys_src;
pmap_t pmap;
while (size > 0) {
if (task != NULL)
pmap = task->map->pmap;
else
pmap = kernel_pmap;
phys_src = db_vtophys(pmap, (vm_offset_t)addr);
if (phys_src == 0) {
db_printf("\nno memory is assigned to src address %08x\n",
addr);
db_error(0);
}
phys_dst = db_vtophys(kernel_pmap, (vm_offset_t)data);
if (phys_dst == 0) {
db_printf("\nno memory is assigned to dst address %08x\n",
data);
db_error(0);
}
max = round_page_64(phys_src + 1) - phys_src;
if (max > size)
max = size;
n = round_page_64(phys_dst + 1) - phys_dst;
if (n < max) max = n;
size -= max;
addr += max;
phys_copy(phys_src, phys_dst, max);
sync_cache64(phys_dst, max);
phys_src += max;
phys_dst += max;
}
}
void
db_write_bytes(
vm_offset_t addr,
int size,
char *data,
task_t task)
{
int n,max;
addr64_t phys_dst;
addr64_t phys_src;
pmap_t pmap;
while (size > 0) {
phys_src = db_vtophys(kernel_pmap, (vm_offset_t)data);
if (phys_src == 0) {
db_printf("\nno memory is assigned to src address %08x\n",
data);
db_error(0);
}
if (task == NULL) pmap = kernel_pmap;
else pmap = task->map->pmap;
phys_dst = db_vtophys(pmap, (vm_offset_t)addr);
if (phys_dst == 0) {
db_printf("\nno memory is assigned to dst address %08x\n",
addr);
db_error(0);
}
max = round_page_64(phys_src + 1) - phys_src;
if (max > size)
max = size;
n = round_page_64(phys_dst + 1) - phys_dst;
if (n < max)
max = n;
size -= max;
addr += max;
phys_copy(phys_src, phys_dst, max);
sync_cache64(phys_dst, max);
phys_src += max;
phys_dst += max;
}
}
boolean_t
db_check_access(
vm_offset_t addr,
int size,
task_t task)
{
register int n;
unsigned int 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_act() == THR_ACT_NULL) return(FALSE);
task = current_act()->task;
}
while (size > 0) {
if(!pmap_find_phys(task->map->pmap, (addr64_t)addr)) return (FALSE);
n = trunc_page_32(addr+PPC_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)
{
addr64_t physa, physb;
if ((addr1 & (PPC_PGBYTES-1)) != (addr2 & (PPC_PGBYTES-1)))
return FALSE;
if (task1 == TASK_NULL) {
if (current_act() == THR_ACT_NULL)
return FALSE;
task1 = current_act()->task;
}
if(!(physa = db_vtophys(task1->map->pmap, (vm_offset_t)trunc_page_32(addr1)))) return FALSE;
if(!(physb = db_vtophys(task2->map->pmap, (vm_offset_t)trunc_page_32(addr2)))) return FALSE;
return (physa == physb);
}
#define DB_USER_STACK_ADDR (0xc0000000)
#define DB_NAME_SEARCH_LIMIT (DB_USER_STACK_ADDR-(PPC_PGBYTES*3))
boolean_t db_phys_cmp(
vm_offset_t a1,
vm_offset_t a2,
vm_size_t s1) {
db_printf("db_phys_cmp: not implemented\n");
return 0;
}
int
db_search_null(
task_t task,
unsigned *svaddr,
unsigned evaddr,
unsigned *skaddr,
int flag)
{
register unsigned vaddr;
register unsigned *kaddr;
db_printf("db_search_null: not implemented\n");
return(-1);
}
unsigned char *getProcName(struct proc *proc);
void
db_task_name(
task_t task)
{
register unsigned char *p;
register int n;
unsigned int vaddr, kaddr;
unsigned char tname[33];
int i;
p = 0;
tname[0] = 0;
if(task->bsd_info) p = getProcName((struct proc *)(task->bsd_info));
if(p) {
for(i = 0; i < 32; i++) {
tname[i] = p[i];
if(p[i] == 0) break;
}
tname[i] = 0;
db_printf("%s", tname);
}
else db_printf("no name");
}
void
db_machdep_init(void) {
#define KDB_READY 0x1
extern int kdb_flag;
kdb_flag |= KDB_READY;
}
#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 >= NCPUS || !debugger_active[cpu])
return;
db_set_breakpoints();
db_set_watchpoints();
debugger_cpu = cpu;
unlock_debugger();
lock_debugger();
db_clear_breakpoints();
db_clear_watchpoints();
KDB_RESTORE_CTXT();
if (debugger_cpu == -1) {
debugger_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);
}
void
db_to_gdb(
void)
{
extern unsigned int switch_debugger;
switch_debugger=1;
}