[apple/xnu.git] / osfmk / ppc / db_interface.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * 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.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */

#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];		/* Debugger active on CPU */
extern int debugger_cpu;				/* Current cpu running debugger	*/

int		db_all_set_up = 0;


#if !MACH_KDP
void kdp_register_send_receive(void);
#endif

/*
 *	Enter KDB through a keyboard trap.
 *	We show the registers as of the keyboard interrupt
 *	instead of those at its call to KDB.
 */
struct int_regs {
	/* XXX more registers ? */
	struct ppc_interrupt_state *is;
};

extern char *	trap_type[];
extern int	TRAP_TYPES;

/*
 * Code used to synchronize kdb among all cpus, one active at a time, switch
 * from on to another using kdb_on! #cpu or cpu #cpu
 */

decl_simple_lock_data(, kdb_lock)	/* 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;	/* counter for number of cpus holding
						   breakpoints (ie: cpus that did not
						   insert back breakpoints) */
extern boolean_t	db_breakpoints_inserted;

/* Forward */

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 /* DB_MACHINE_COMMANDS */

#if !MACH_KDP
void kdp_register_send_receive(void) {}
#endif

extern jmp_buf_t *db_recover;
spl_t	saved_ipl[NCPUS];	/* just to know what IPL was before trap */
struct savearea *saved_state[NCPUS];

/*
 *  kdb_trap - field a TRACE or BPT trap
 */
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:	/* single_step */
	    case T_PROGRAM:	/* breakpoint */
#if 0
	    case T_WATCHPOINT:	/* watchpoint */
#endif
	    case -1:	/* keyboard interrupt */
		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("");
		    /*NOTREACHED*/
		}
		kdbprinttrap(type, code, (int *)&regs->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);

}


/*
 * Print trap reason.
 */

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);					/* Couldn't find it */
	
	pa = ((addr64_t)pp << 12) | (addr64_t)(va & 0xFFF);	/* Get physical address */

	return(pa);
}

/*
 * Read bytes from task address space for debugger.
 */
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);
			/* NOTREACHED */
		}

		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);
			/* NOTREACHED */
		}
		
		/* don't over-run any page boundaries - check src range */
		max = round_page_64(phys_src + 1) - phys_src;
		if (max > size)
			max = size;
		/* Check destination won't run over boundary either */
		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);

		/* resync I+D caches */
		sync_cache64(phys_dst, max);

		phys_src += max;
		phys_dst += max;
	}
}

/*
 * Write bytes to task address space for debugger.
 */
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);
			/* NOTREACHED */
		}
		
		/* space stays as kernel space unless in another task */
		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);
			/* NOTREACHED */
		}

		/* don't over-run any page boundaries - check src range */
		max = round_page_64(phys_src + 1) - phys_src;
		if (max > size)
			max = size;
		/* Check destination won't run over boundary either */
		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);

		/* resync I+D caches */
		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);	/* Fail if page not mapped */
	    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)))	/* Is byte displacement the same? */
		return FALSE;

	if (task1 == TASK_NULL) {						/* See if there is a task active */
		if (current_act() == THR_ACT_NULL)			/* See if there is a current task */
			return FALSE;
		task1 = current_act()->task;				/* If so, use that one */
	}
	
	if(!(physa = db_vtophys(task1->map->pmap, (vm_offset_t)trunc_page_32(addr1)))) return FALSE;	/* Get real address of the first */
	if(!(physb = db_vtophys(task2->map->pmap, (vm_offset_t)trunc_page_32(addr2)))) return FALSE;	/* Get real address of the second */
	
	return (physa == physb);						/* Check if they are equal, then return... */
}

#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));	/* Point to task name */
	
	if(p) {
		for(i = 0; i < 32; i++) {			/* Move no more than 32 bytes */
			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	/* __STDC__ */
#define KDB_SAVE(type, name) extern type name; type name/**/_save = name
#define KDB_RESTORE(name) name = name/**/_save
#endif	/* __STDC__ */

#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); 

/*
 * switch to another cpu
 */
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)  {/* someone continued */
		debugger_cpu = cpu_number();
		db_continue_cmd(0, 0, 0, "");
	}
}

/*
 * system reboot
 */
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 */
			reboot = TRUE;
		if (c == 'h')	/* halt */
			reboot = FALSE;
	}
	halt_all_cpus(reboot);
}

/*
 * Switch to gdb
 */
void
db_to_gdb(
	void)
{
	extern unsigned int switch_debugger;

	switch_debugger=1;
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
	26	* @OSF_COPYRIGHT@
	27	*/
	28
	29	#include <cpus.h>
	30	#include <platforms.h>
	31	#include <time_stamp.h>
	32	#include <mach_mp_debug.h>
	33	#include <mach_ldebug.h>
	34	#include <db_machine_commands.h>
	35
	36	#include <kern/spl.h>
	37	#include <kern/cpu_number.h>
	38	#include <kern/kern_types.h>
	39	#include <kern/misc_protos.h>
	40	#include <vm/pmap.h>
	41
	42	#include <ppc/mem.h>
	43	#include <ppc/thread.h>
	44	#include <ppc/db_machdep.h>
	45	#include <ppc/trap.h>
	46	#include <ppc/setjmp.h>
	47	#include <ppc/pmap.h>
	48	#include <ppc/misc_protos.h>
	49	#include <ppc/exception.h>
	50	#include <ppc/db_machdep.h>
	51	#include <ppc/mappings.h>
	52	#include <ppc/Firmware.h>
	53
	54	#include <mach/vm_param.h>
	55	#include <mach/machine/vm_types.h>
	56	#include <vm/vm_map.h>
	57	#include <kern/thread.h>
	58	#include <kern/task.h>
	59	#include <kern/debug.h>
	60
	61	#include <ddb/db_command.h>
	62	#include <ddb/db_task_thread.h>
	63	#include <ddb/db_run.h>
	64	#include <ddb/db_trap.h>
	65	#include <ddb/db_output.h>
	66	#include <ddb/db_access.h>
	67	#include <ddb/db_sym.h>
	68	#include <ddb/db_break.h>
	69	#include <ddb/db_watch.h>
	70
9bccf70c A	71	struct savearea *ppc_last_saved_statep;
9bccf70c A	72	struct savearea ppc_nested_saved_state;
1c79356b A	73	unsigned ppc_last_kdb_sp;
	74
	75	extern int debugger_active[NCPUS]; /* Debugger active on CPU */
	76	extern int debugger_cpu; /* Current cpu running debugger */
	77
	78	int db_all_set_up = 0;
	79
	80
	81	#if !MACH_KDP
	82	void kdp_register_send_receive(void);
	83	#endif
	84
	85	/*
	86	* Enter KDB through a keyboard trap.
	87	* We show the registers as of the keyboard interrupt
	88	* instead of those at its call to KDB.
	89	*/
	90	struct int_regs {
	91	/* XXX more registers ? */
	92	struct ppc_interrupt_state *is;
	93	};
	94
	95	extern char * trap_type[];
	96	extern int TRAP_TYPES;
	97
	98	/*
	99	* Code used to synchronize kdb among all cpus, one active at a time, switch
	100	* from on to another using kdb_on! #cpu or cpu #cpu
	101	*/
	102
	103	decl_simple_lock_data(, kdb_lock) /* kdb lock */
	104
	105	#define db_simple_lock_init(l, e) hw_lock_init(&((l)->interlock))
	106	#define db_simple_lock_try(l) hw_lock_try(&((l)->interlock))
	107	#define db_simple_unlock(l) hw_lock_unlock(&((l)->interlock))
	108
	109	extern volatile unsigned int cpus_holding_bkpts; /* counter for number of cpus holding
	110	breakpoints (ie: cpus that did not
	111	insert back breakpoints) */
	112	extern boolean_t db_breakpoints_inserted;
	113
	114	/* Forward */
	115
	116	extern void kdbprinttrap(
	117	int type,
	118	int code,
	119	int *pc,
	120	int sp);
1c79356b A	121	extern void db_write_bytes_user_space(
	122	vm_offset_t addr,
	123	int size,
	124	char *data,
	125	task_t task);
	126	extern int db_search_null(
	127	task_t task,
	128	unsigned *svaddr,
	129	unsigned evaddr,
	130	unsigned *skaddr,
	131	int flag);
	132	extern int kdb_enter(int);
	133	extern void kdb_leave(void);
	134	extern void lock_kdb(void);
	135	extern void unlock_kdb(void);
	136
	137	#if DB_MACHINE_COMMANDS
	138	struct db_command ppc_db_commands[] = {
	139	{ "lt", db_low_trace, CS_MORE\|CS_SET_DOT, 0 },
	140	{ (char *)0, 0, 0, 0 }
	141	};
	142	#endif /* DB_MACHINE_COMMANDS */
	143
	144	#if !MACH_KDP
	145	void kdp_register_send_receive(void) {}
	146	#endif
	147
	148	extern jmp_buf_t *db_recover;
	149	spl_t saved_ipl[NCPUS]; /* just to know what IPL was before trap */
9bccf70c	150	struct savearea *saved_state[NCPUS];
1c79356b A	151
	152	/*
	153	* kdb_trap - field a TRACE or BPT trap
	154	*/
	155	void
	156	kdb_trap(
	157	int type,
9bccf70c	158	struct savearea *regs)
1c79356b A	159	{
	160	boolean_t trap_from_user;
	161	int previous_console_device;
	162	int code=0;
	163
	164	previous_console_device=switch_to_serial_console();
	165
	166	switch (type) {
	167	case T_TRACE: /* single_step */
	168	case T_PROGRAM: /* breakpoint */
	169	#if 0
	170	case T_WATCHPOINT: /* watchpoint */
	171	#endif
	172	case -1: /* keyboard interrupt */
	173	break;
	174
	175	default:
	176	if (db_recover) {
	177	ppc_nested_saved_state = *regs;
	178	db_printf("Caught ");
	179	if (type > TRAP_TYPES)
	180	db_printf("type %d", type);
	181	else
	182	db_printf("%s", trap_type[type]);
	183	db_printf(" trap, pc = %x\n",
9bccf70c	184	regs->save_srr0);
1c79356b A	185	db_error("");
	186	/NOTREACHED/
	187	}
9bccf70c	188	kdbprinttrap(type, code, (int *)&regs->save_srr0, regs->save_r1);
1c79356b A	189	}
	190
	191	saved_state[cpu_number()] = regs;
	192
	193	ppc_last_saved_statep = regs;
	194	ppc_last_kdb_sp = (unsigned) &type;
	195
	196	if (!IS_USER_TRAP(regs)) {
	197	bzero((char *)&ddb_regs, sizeof (ddb_regs));
	198	ddb_regs = *regs;
	199	trap_from_user = FALSE;
	200
	201	}
	202	else {
	203	ddb_regs = *regs;
	204	trap_from_user = TRUE;
	205	}
	206
	207	db_task_trap(type, code, trap_from_user);
	208
	209	*regs = ddb_regs;
	210
	211	if ((type == T_PROGRAM) &&
9bccf70c	212	(db_get_task_value(regs->save_srr0,
1c79356b A	213	BKPT_SIZE,
	214	FALSE,
	215	db_target_space(current_act(),
	216	trap_from_user))
	217	== BKPT_INST))
9bccf70c	218	regs->save_srr0 += BKPT_SIZE;
1c79356b A	219
	220	kdb_exit:
	221	saved_state[cpu_number()] = 0;
	222	switch_to_old_console(previous_console_device);
	223
	224	}
	225
	226
	227	/*
	228	* Print trap reason.
	229	*/
	230
	231	void
	232	kdbprinttrap(
	233	int type,
	234	int code,
	235	int *pc,
	236	int sp)
	237	{
	238	printf("kernel: ");
	239	if (type > TRAP_TYPES)
	240	db_printf("type %d", type);
	241	else
	242	db_printf("%s", trap_type[type]);
	243	db_printf(" trap, code=%x pc@%x = %x sp=%x\n",
	244	code, pc, (int )pc, sp);
	245	db_run_mode = STEP_CONTINUE;
	246	}
	247
	248	/*
	249	*
	250	*/
55e303ae	251	addr64_t db_vtophys(
1c79356b A	252	pmap_t pmap,
	253	vm_offset_t va)
	254	{
55e303ae A	255	ppnum_t pp;
55e303ae A	256	addr64_t pa;
1c79356b	257
55e303ae	258	pp = pmap_find_phys(pmap, (addr64_t)va);
de355530	259
55e303ae A	260	if (pp == 0) return(0); /* Couldn't find it */
	261
	262	pa = ((addr64_t)pp << 12) \| (addr64_t)(va & 0xFFF); /* Get physical address */
1c79356b A	263
	264	return(pa);
	265	}
	266
1c79356b A	267	/*
	268	* Read bytes from task address space for debugger.
	269	*/
	270	void
	271	db_read_bytes(
	272	vm_offset_t addr,
	273	int size,
	274	char *data,
	275	task_t task)
	276	{
	277	int n,max;
55e303ae A	278	addr64_t phys_dst;
55e303ae A	279	addr64_t phys_src;
1c79356b A	280	pmap_t pmap;
	281
	282	while (size > 0) {
	283	if (task != NULL)
	284	pmap = task->map->pmap;
	285	else
	286	pmap = kernel_pmap;
	287
55e303ae	288	phys_src = db_vtophys(pmap, (vm_offset_t)addr);
1c79356b A	289	if (phys_src == 0) {
	290	db_printf("\nno memory is assigned to src address %08x\n",
	291	addr);
	292	db_error(0);
	293	/* NOTREACHED */
	294	}
1c79356b	295
55e303ae	296	phys_dst = db_vtophys(kernel_pmap, (vm_offset_t)data);
1c79356b A	297	if (phys_dst == 0) {
	298	db_printf("\nno memory is assigned to dst address %08x\n",
	299	data);
	300	db_error(0);
	301	/* NOTREACHED */
	302	}
	303
1c79356b	304	/* don't over-run any page boundaries - check src range */
55e303ae	305	max = round_page_64(phys_src + 1) - phys_src;
1c79356b A	306	if (max > size)
	307	max = size;
	308	/* Check destination won't run over boundary either */
55e303ae A	309	n = round_page_64(phys_dst + 1) - phys_dst;
	310
	311	if (n < max) max = n;
1c79356b A	312	size -= max;
	313	addr += max;
	314	phys_copy(phys_src, phys_dst, max);
	315
	316	/* resync I+D caches */
55e303ae	317	sync_cache64(phys_dst, max);
1c79356b A	318
	319	phys_src += max;
	320	phys_dst += max;
	321	}
	322	}
	323
	324	/*
	325	* Write bytes to task address space for debugger.
	326	*/
	327	void
	328	db_write_bytes(
	329	vm_offset_t addr,
	330	int size,
	331	char *data,
	332	task_t task)
	333	{
	334	int n,max;
55e303ae A	335	addr64_t phys_dst;
55e303ae A	336	addr64_t phys_src;
1c79356b A	337	pmap_t pmap;
	338
	339	while (size > 0) {
	340
55e303ae	341	phys_src = db_vtophys(kernel_pmap, (vm_offset_t)data);
1c79356b A	342	if (phys_src == 0) {
	343	db_printf("\nno memory is assigned to src address %08x\n",
	344	data);
	345	db_error(0);
	346	/* NOTREACHED */
	347	}
	348
1c79356b A	349	/* space stays as kernel space unless in another task */
	350	if (task == NULL) pmap = kernel_pmap;
	351	else pmap = task->map->pmap;
	352
55e303ae	353	phys_dst = db_vtophys(pmap, (vm_offset_t)addr);
1c79356b A	354	if (phys_dst == 0) {
	355	db_printf("\nno memory is assigned to dst address %08x\n",
	356	addr);
	357	db_error(0);
	358	/* NOTREACHED */
	359	}
1c79356b A	360
1c79356b A	361	/* don't over-run any page boundaries - check src range */
55e303ae	362	max = round_page_64(phys_src + 1) - phys_src;
1c79356b A	363	if (max > size)
	364	max = size;
	365	/* Check destination won't run over boundary either */
55e303ae	366	n = round_page_64(phys_dst + 1) - phys_dst;
1c79356b A	367	if (n < max)
	368	max = n;
	369	size -= max;
	370	addr += max;
	371	phys_copy(phys_src, phys_dst, max);
	372
	373	/* resync I+D caches */
55e303ae	374	sync_cache64(phys_dst, max);
1c79356b A	375
	376	phys_src += max;
	377	phys_dst += max;
	378	}
	379	}
	380
	381	boolean_t
	382	db_check_access(
	383	vm_offset_t addr,
	384	int size,
	385	task_t task)
	386	{
	387	register int n;
	388	unsigned int kern_addr;
	389
	390	if (task == kernel_task \|\| task == TASK_NULL) {
55e303ae	391	if (kernel_task == TASK_NULL) return(TRUE);
1c79356b A	392	task = kernel_task;
1c79356b A	393	} else if (task == TASK_NULL) {
55e303ae	394	if (current_act() == THR_ACT_NULL) return(FALSE);
1c79356b A	395	task = current_act()->task;
1c79356b A	396	}
55e303ae	397
1c79356b	398	while (size > 0) {
55e303ae A	399	if(!pmap_find_phys(task->map->pmap, (addr64_t)addr)) return (FALSE); /* Fail if page not mapped */
55e303ae A	400	n = trunc_page_32(addr+PPC_PGBYTES) - addr;
1c79356b A	401	if (n > size)
	402	n = size;
	403	size -= n;
	404	addr += n;
	405	}
	406	return(TRUE);
	407	}
	408
	409	boolean_t
	410	db_phys_eq(
	411	task_t task1,
	412	vm_offset_t addr1,
	413	task_t task2,
	414	vm_offset_t addr2)
	415	{
55e303ae	416	addr64_t physa, physb;
1c79356b A	417
	418	if ((addr1 & (PPC_PGBYTES-1)) != (addr2 & (PPC_PGBYTES-1))) /* Is byte displacement the same? */
	419	return FALSE;
	420
	421	if (task1 == TASK_NULL) { /* See if there is a task active */
	422	if (current_act() == THR_ACT_NULL) /* See if there is a current task */
	423	return FALSE;
	424	task1 = current_act()->task; /* If so, use that one */
	425	}
	426
55e303ae A	427	if(!(physa = db_vtophys(task1->map->pmap, (vm_offset_t)trunc_page_32(addr1)))) return FALSE; /* Get real address of the first */
55e303ae A	428	if(!(physb = db_vtophys(task2->map->pmap, (vm_offset_t)trunc_page_32(addr2)))) return FALSE; /* Get real address of the second */
1c79356b A	429
	430	return (physa == physb); /* Check if they are equal, then return... */
	431	}
	432
	433	#define DB_USER_STACK_ADDR (0xc0000000)
	434	#define DB_NAME_SEARCH_LIMIT (DB_USER_STACK_ADDR-(PPC_PGBYTES*3))
	435
55e303ae A	436	boolean_t db_phys_cmp(
	437	vm_offset_t a1,
	438	vm_offset_t a2,
	439	vm_size_t s1) {
	440
	441	db_printf("db_phys_cmp: not implemented\n");
	442	return 0;
	443	}
	444
	445
1c79356b A	446	int
	447	db_search_null(
	448	task_t task,
	449	unsigned *svaddr,
	450	unsigned evaddr,
	451	unsigned *skaddr,
	452	int flag)
	453	{
	454	register unsigned vaddr;
	455	register unsigned *kaddr;
	456
55e303ae A	457	db_printf("db_search_null: not implemented\n");
55e303ae A	458
1c79356b A	459	return(-1);
	460	}
	461
55e303ae A	462	unsigned char getProcName(struct proc proc);
55e303ae A	463
1c79356b A	464	void
	465	db_task_name(
	466	task_t task)
	467	{
55e303ae	468	register unsigned char *p;
1c79356b A	469	register int n;
1c79356b A	470	unsigned int vaddr, kaddr;
55e303ae A	471	unsigned char tname[33];
55e303ae A	472	int i;
1c79356b	473
55e303ae A	474	p = 0;
	475	tname[0] = 0;
	476
	477	if(task->bsd_info) p = getProcName((struct proc )(task->bsd_info)); / Point to task name */
	478
	479	if(p) {
	480	for(i = 0; i < 32; i++) { /* Move no more than 32 bytes */
	481	tname[i] = p[i];
	482	if(p[i] == 0) break;
	483	}
	484	tname[i] = 0;
	485	db_printf("%s", tname);
1c79356b	486	}
55e303ae	487	else db_printf("no name");
1c79356b A	488	}
	489
	490	void
	491	db_machdep_init(void) {
	492	#define KDB_READY 0x1
	493	extern int kdb_flag;
	494
	495	kdb_flag \|= KDB_READY;
	496	}
	497
	498
	499	#ifdef __STDC__
	500	#define KDB_SAVE(type, name) extern type name; type name##_save = name
	501	#define KDB_RESTORE(name) name = name##_save
	502	#else /* __STDC__ */
	503	#define KDB_SAVE(type, name) extern type name; type name/**/_save = name
	504	#define KDB_RESTORE(name) name = name/**/_save
	505	#endif /* __STDC__ */
	506
	507	#define KDB_SAVE_CTXT() \
	508	KDB_SAVE(int, db_run_mode); \
	509	KDB_SAVE(boolean_t, db_sstep_print); \
	510	KDB_SAVE(int, db_loop_count); \
	511	KDB_SAVE(int, db_call_depth); \
	512	KDB_SAVE(int, db_inst_count); \
	513	KDB_SAVE(int, db_last_inst_count); \
	514	KDB_SAVE(int, db_load_count); \
	515	KDB_SAVE(int, db_store_count); \
	516	KDB_SAVE(boolean_t, db_cmd_loop_done); \
	517	KDB_SAVE(jmp_buf_t *, db_recover); \
	518	KDB_SAVE(db_addr_t, db_dot); \
	519	KDB_SAVE(db_addr_t, db_last_addr); \
	520	KDB_SAVE(db_addr_t, db_prev); \
	521	KDB_SAVE(db_addr_t, db_next); \
	522	KDB_SAVE(db_regs_t, ddb_regs);
	523
	524	#define KDB_RESTORE_CTXT() \
	525	KDB_RESTORE(db_run_mode); \
	526	KDB_RESTORE(db_sstep_print); \
	527	KDB_RESTORE(db_loop_count); \
	528	KDB_RESTORE(db_call_depth); \
	529	KDB_RESTORE(db_inst_count); \
	530	KDB_RESTORE(db_last_inst_count); \
	531	KDB_RESTORE(db_load_count); \
	532	KDB_RESTORE(db_store_count); \
	533	KDB_RESTORE(db_cmd_loop_done); \
	534	KDB_RESTORE(db_recover); \
	535	KDB_RESTORE(db_dot); \
	536	KDB_RESTORE(db_last_addr); \
	537	KDB_RESTORE(db_prev); \
	538	KDB_RESTORE(db_next); \
	539	KDB_RESTORE(ddb_regs);
	540
	541	/*
	542	* switch to another cpu
	543	*/
	544	void
	545	kdb_on(
	546	int cpu)
	547	{
	548	KDB_SAVE_CTXT();
	549	if (cpu < 0 \|\| cpu >= NCPUS \|\| !debugger_active[cpu])
	550	return;
	551	db_set_breakpoints();
552	db_set_watchpoints();
553	debugger_cpu = cpu;
554	unlock_debugger();
555	lock_debugger();
556	db_clear_breakpoints();
557	db_clear_watchpoints();
558	KDB_RESTORE_CTXT();
559	if (debugger_cpu == -1) {/* someone continued */
560	debugger_cpu = cpu_number();
561	db_continue_cmd(0, 0, 0, "");
562	}
563	}
564
565	/*
566	* system reboot
567	*/
568	void db_reboot(
569	db_expr_t addr,
570	boolean_t have_addr,
571	db_expr_t count,
572	char *modif)
573	{
574	boolean_t reboot = TRUE;
575	char *cp, c;
576
577	cp = modif;
578	while ((c = *cp++) != 0) {
579	if (c == 'r') /* reboot */
580	reboot = TRUE;
581	if (c == 'h') /* halt */
582	reboot = FALSE;
583	}
584	halt_all_cpus(reboot);
585	}
586
587	/*
588	* Switch to gdb
589	*/
590	void
591	db_to_gdb(
592	void)
593	{
594	extern unsigned int switch_debugger;
595
596	switch_debugger=1;
597	}