2 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
4 * @APPLE_LICENSE_HEADER_START@
6 * The contents of this file constitute Original Code as defined in and
7 * are subject to the Apple Public Source License Version 1.1 (the
8 * "License"). You may not use this file except in compliance with the
9 * License. Please obtain a copy of the License at
10 * http://www.apple.com/publicsource and read it before using this file.
12 * This Original Code and all software distributed under the License are
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17 * License for the specific language governing rights and limitations
20 * @APPLE_LICENSE_HEADER_END@
26 * @APPLE_FREE_COPYRIGHT@
29 * (c) Copyright 1988 HEWLETT-PACKARD COMPANY
31 * To anyone who acknowledges that this file is provided "AS IS"
32 * without any express or implied warranty:
33 * permission to use, copy, modify, and distribute this file
34 * for any purpose is hereby granted without fee, provided that
35 * the above copyright notice and this notice appears in all
36 * copies, and that the name of Hewlett-Packard Company not be
37 * used in advertising or publicity pertaining to distribution
38 * of the software without specific, written prior permission.
39 * Hewlett-Packard Company makes no representations about the
40 * suitability of this software for any purpose.
43 * Copyright (c) 1990,1991,1992,1994 The University of Utah and
44 * the Computer Systems Laboratory (CSL). All rights reserved.
46 * THE UNIVERSITY OF UTAH AND CSL PROVIDE THIS SOFTWARE IN ITS "AS IS"
47 * CONDITION, AND DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES
48 * WHATSOEVER RESULTING FROM ITS USE.
50 * CSL requests users of this software to return to csl-dist@cs.utah.edu any
51 * improvements that they make and grant CSL redistribution rights.
53 * Utah $Hdr: model_dep.c 1.34 94/12/14$
59 #include <db_machine_commands.h>
62 #include <kern/thread.h>
63 #include <machine/pmap.h>
64 #include <machine/mach_param.h>
65 #include <device/device_types.h>
67 #include <mach/vm_param.h>
68 #include <mach/clock_types.h>
69 #include <mach/machine.h>
70 #include <mach/kmod.h>
73 #include <kern/misc_protos.h>
74 #include <kern/startup.h>
75 #include <ppc/misc_protos.h>
76 #include <ppc/proc_reg.h>
77 #include <ppc/thread.h>
80 #include <ppc/Firmware.h>
81 #include <ppc/low_trace.h>
82 #include <ppc/mappings.h>
83 #include <ppc/FirmwareCalls.h>
84 #include <ppc/setjmp.h>
85 #include <ppc/exception.h>
87 #include <kern/clock.h>
88 #include <kern/debug.h>
89 #include <machine/trap.h>
91 #include <pexpert/pexpert.h>
94 #include <IOKit/IOPlatformExpert.h>
96 #include <mach/vm_prot.h>
98 #include <mach/time_value.h>
99 #include <machine/machparam.h> /* for btop */
102 #include <ddb/db_aout.h>
103 #include <ddb/db_output.h>
104 #include <ddb/db_command.h>
105 #include <machine/db_machdep.h>
107 extern struct db_command ppc_db_commands
[];
108 #endif /* MACH_KDB */
110 char kernel_args_buf
[256] = "/mach_kernel";
111 char boot_args_buf
[256] = "/mach_servers/bootstrap";
114 #define TRAP_DEBUGGER __asm__ volatile("tw 4,r3,r3");
115 #define TRAP_DEBUGGER_INST 0x7c831808
116 #define TRAP_DIRECT __asm__ volatile("tw 4,r4,r4");
117 #define TRAP_DIRECT_INST 0x7c842008
118 #define TRAP_INST_SIZE 4
119 #define BREAK_TO_KDP0 0x7fe00008
120 #define BREAK_TO_KDP1 0x7c800008
121 #define BREAK_TO_KDB0 0x7c810808
124 * Code used to synchronize debuggers among all cpus, one active at a time, switch
125 * from on to another using kdb_on! #cpu or cpu #cpu
128 decl_simple_lock_data(, debugger_lock
) /* debugger lock */
130 int debugger_cpu
= -1; /* current cpu running debugger */
131 int debugger_debug
= 0; /* Debug debugger */
132 int debugger_is_slave
[NCPUS
]; /* Show that we were entered via sigp */
133 int debugger_active
[NCPUS
]; /* Debugger active on CPU */
134 int debugger_pending
[NCPUS
]; /* Debugger entry pending on CPU (this is a HACK) */
135 int debugger_holdoff
[NCPUS
]; /* Holdoff debugger entry on this CPU (this is a HACK) */
136 int db_run_mode
; /* Debugger run mode */
137 unsigned int debugger_sync
= 0; /* Cross processor debugger entry sync */
138 extern unsigned int NMIss
; /* NMI debounce switch */
140 unsigned int lastTrace
; /* Value of low-level exception trace controls */
142 volatile unsigned int cpus_holding_bkpts
; /* counter for number of cpus holding
143 breakpoints (ie: cpus that did not
144 insert back breakpoints) */
145 void unlock_debugger(void);
146 void lock_debugger(void);
149 boolean_t db_breakpoints_inserted
= TRUE
;
150 jmp_buf_t
*db_recover
= 0;
154 #include <ddb/db_run.h>
156 extern boolean_t db_breakpoints_inserted
;
157 extern jmp_buf_t
*db_recover
;
158 #define KDB_READY 0x1
163 #define KDP_READY 0x1
166 boolean_t db_im_stepping
= 0xFFFFFFFF; /* Remember if we were stepping */
168 extern const char version
[];
171 void kdb_trap(int type
, struct ppc_saved_state
*regs
);
172 void kdb_trap(int type
, struct ppc_saved_state
*regs
) {
178 void kdp_trap(int type
, struct ppc_saved_state
*regs
);
179 void kdp_trap(int type
, struct ppc_saved_state
*regs
) {
185 machine_startup(boot_args
*args
)
189 if (PE_parse_boot_arg("cpus", &wncpu
)) {
190 if (!((wncpu
> 0) && (wncpu
< NCPUS
)))
195 if( PE_get_hotkey( kPEControlKey
))
196 halt_in_debugger
= halt_in_debugger
? 0 : 1;
198 if (PE_parse_boot_arg("debug", &boot_arg
)) {
199 if (boot_arg
& DB_HALT
) halt_in_debugger
=1;
200 if (boot_arg
& DB_PRT
) disableDebugOuput
=FALSE
;
201 if (boot_arg
& DB_SLOG
) systemLogDiags
=TRUE
;
204 hw_lock_init(&debugger_lock
); /* initialized debugger lock */
210 #if DB_MACHINE_COMMANDS
211 db_machine_commands_install(ppc_db_commands
);
212 #endif /* DB_MACHINE_COMMANDS */
215 if (boot_arg
& DB_KDB
)
216 current_debugger
= KDB_CUR_DB
;
219 * Cause a breakpoint trap to the debugger before proceeding
220 * any further if the proper option bit was specified in
223 if (halt_in_debugger
&& (current_debugger
== KDB_CUR_DB
)) {
224 Debugger("inline call to debugger(machine_startup)");
225 halt_in_debugger
= 0;
228 #endif /* MACH_KDB */
229 if (PE_parse_boot_arg("preempt", &boot_arg
)) {
230 extern int default_preemption_rate
;
232 default_preemption_rate
= boot_arg
;
234 if (PE_parse_boot_arg("kpreempt", &boot_arg
)) {
235 extern int kernel_preemption_mode
;
236 extern boolean_t zone_gc_allowed
;
238 kernel_preemption_mode
= boot_arg
;
239 zone_gc_allowed
= FALSE
; /* XXX: TO BE REMOVED */
244 ml_thrm_init(); /* Start thermal monitoring on this processor */
251 /* Should never return */
259 return(PE_boot_args());
265 machine_info
.max_cpus
= NCPUS
;
266 machine_info
.avail_cpus
= 1;
267 machine_info
.memory_size
= mem_size
;
276 void slave_machine_init(void)
278 (void) ml_set_interrupts_enabled(FALSE
); /* Make sure we are disabled */
279 clock_init(); /* Init the clock */
280 cpu_machine_init(); /* Initialize the processor */
284 halt_all_cpus(boolean_t reboot
)
288 printf("MACH Reboot\n");
289 PEHaltRestart(kPERestartCPU
);
293 printf("CPU halted\n");
294 PEHaltRestart(kPEHaltCPU
);
302 halt_all_cpus(FALSE
);
307 * Machine-dependent routine to fill in an array with up to callstack_max
308 * levels of return pc information.
310 void machine_callstack(
312 vm_size_t callstack_max
)
315 #endif /* MACH_ASSERT */
319 print_backtrace(struct ppc_saved_state
*ssp
)
321 unsigned int *stackptr
, *raddr
, *rstack
, trans
;
322 int i
, frames_cnt
, skip_top_frames
, frames_max
;
323 unsigned int store
[8]; /* Buffer for real storage reads */
324 vm_offset_t backtrace_entries
[32];
326 printf("backtrace: ");
329 /* Get our stackpointer for backtrace */
331 __asm__
volatile("mr %0, r1" : "=r" (stackptr
));
334 stackptr
= (unsigned int *)(ssp
->r1
);
336 backtrace_entries
[frames_cnt
] = ssp
->srr0
;
338 printf("0x%08x ", ssp
->srr0
);
341 frames_max
= 32-frames_cnt
;
342 for (i
= 0; i
< frames_max
; i
++) {
344 if(!stackptr
) break; /* No more to get... */
346 /* Avoid causing page fault */
347 if (!(raddr
= LRA(PPC_SID_KERNEL
, (void *)((unsigned int)stackptr
+FM_LR_SAVE
))))
349 ReadReal((unsigned int)raddr
, &store
[0]);
353 backtrace_entries
[frames_cnt
] = store
[0];
355 printf("0x%08x ",store
[0]);
357 if (!(raddr
= LRA(PPC_SID_KERNEL
, (void *)stackptr
)))
359 ReadReal((unsigned int)raddr
, &store
[0]);
360 stackptr
=(unsigned int *)store
[0];
365 kmod_dump((vm_offset_t
*)&backtrace_entries
[0], frames_cnt
);
369 Debugger(const char *message
) {
372 unsigned int store
[8];
375 spl
= splhigh(); /* No interruptions from here on */
378 * backtrace for Debugger() call from panic() if no current debugger
379 * backtrace and return for double panic() call
381 if ((panicstr
!= (char *)0) &&
382 (((nestedpanic
!= 0) && (current_debugger
== 1)) || (active_debugger
== 0))) {
383 print_backtrace(NULL
);
384 if (nestedpanic
!= 0) {
386 return; /* Yeah, don't enter again... */
390 if (debug_mode
&& debugger_active
[cpu_number()]) { /* Are we already on debugger on this processor? */
392 return; /* Yeah, don't do it again... */
395 if ((current_debugger
!= NO_CUR_DB
)) { /* If there is a debugger configured, enter it */
396 printf("Debugger(%s)\n", message
);
399 return; /* Done debugging for a while */
402 printf("\nNo debugger configured - dumping debug information\n");
403 printf("\nversion string : %s\n",version
);
412 printf("DBAT0: %08X %08X\n", store
[0], store
[1]);
413 printf("DBAT1: %08X %08X\n", store
[2], store
[3]);
414 printf("DBAT2: %08X %08X\n", store
[4], store
[5]);
415 printf("DBAT3: %08X %08X\n", store
[6], store
[7]);
416 printf("MSR=%08X\n",mfmsr());
417 print_backtrace(NULL
);
423 * When we get here, interruptions are disabled and we are on the debugger stack
424 * Never, ever, ever, ever enable interruptions from here on
429 struct ppc_saved_state
*saved_state
)
431 int directcall
, wait
;
432 vm_offset_t instr_ptr
;
436 my_cpu
= cpu_number(); /* Get our CPU */
439 if((debugger_cpu
== my_cpu
) && /* Do we already own debugger? */
440 debugger_active
[my_cpu
] && /* and are we really active? */
441 db_recover
&& /* and have we set up recovery? */
442 (current_debugger
== KDB_CUR_DB
)) { /* and are we in KDB (only it handles recovery) */
443 kdb_trap(type
, saved_state
); /* Then reenter it... */
447 hw_atomic_add(&debug_mode
, 1); /* Indicate we are in debugger */
448 debugger_active
[my_cpu
]++; /* Show active on our CPU */
449 lock_debugger(); /* Insure that only one CPU is in debugger */
451 if(db_im_stepping
== my_cpu
) { /* Are we just back from a step? */
452 enable_preemption_no_check(); /* Enable preemption now */
453 db_im_stepping
= 0xFFFFFFFF; /* Nobody stepping right now */
456 if (debugger_debug
) {
458 kprintf("Call_DebuggerC(%d): %08X %08X, debact = %d\n", my_cpu
, type
, saved_state
, debug_mode
); /* (TEST/DEBUG) */
460 printf("Call_Debugger: enter - cpu %d, is_slave %d, debugger_cpu %d, pc %08X\n",
461 my_cpu
, debugger_is_slave
[my_cpu
], debugger_cpu
, saved_state
->srr0
);
464 if (instr_ptr
= (vm_offset_t
)LRA(PPC_SID_KERNEL
, (void *)(saved_state
->srr0
))) {
465 instr
= ml_phys_read(instr_ptr
); /* Get the trap that caused entry */
470 if (debugger_debug
) kprintf("Call_DebuggerC(%d): instr_ptr = %08X, instr = %08X\n", my_cpu
, instr_ptr
, instr
); /* (TEST/DEBUG) */
473 if (db_breakpoints_inserted
) cpus_holding_bkpts
++; /* Bump up the holding count */
474 if (debugger_cpu
== -1 && !debugger_is_slave
[my_cpu
]) {
476 if (debugger_debug
) kprintf("Call_DebuggerC(%d): lasttrace = %08X\n", my_cpu
, lastTrace
); /* (TEST/DEBUG) */
478 debugger_cpu
= my_cpu
; /* Show that we are debugger */
479 lastTrace
= LLTraceSet(0); /* Disable low-level tracing */
481 for(tcpu
= 0; tcpu
< NCPUS
; tcpu
++) { /* Stop all the other guys */
482 if(tcpu
== my_cpu
) continue; /* Don't diddle ourselves */
483 hw_atomic_add(&debugger_sync
, 1); /* Count signal sent */
484 (void)cpu_signal(tcpu
, SIGPdebug
, 0 ,0); /* Tell 'em to enter debugger */
486 (void)hw_cpu_sync(&debugger_sync
, LockTimeOut
); /* Wait for the other processors to enter debug */
487 debugger_sync
= 0; /* We're done with it */
489 else if (debugger_cpu
!= my_cpu
) goto debugger_exit
; /* We are not debugger, don't continue... */
492 if (instr
== TRAP_DIRECT_INST
) {
493 disableDebugOuput
= FALSE
;
494 print_backtrace(saved_state
);
497 switch_debugger
= 0; /* Make sure switch request is off */
498 directcall
= 1; /* Assume direct call */
500 if (saved_state
->srr1
& MASK(SRR1_PRG_TRAP
)) { /* Trap instruction? */
502 directcall
= 0; /* We had a trap not a direct call */
504 switch (instr
) { /* Select trap type */
507 case BREAK_TO_KDP0
: /* Breakpoint into KDP? */
508 case BREAK_TO_KDP1
: /* Breakpoint into KDP? */
509 current_debugger
= KDP_CUR_DB
; /* Yes, set KDP */
510 kdp_trap(type
, saved_state
); /* Enter it */
515 case BREAK_TO_KDB0
: /* Breakpoint to KDB (the "good" debugger)? */
516 current_debugger
= KDB_CUR_DB
; /* Yes, set it */
517 kdb_trap(type
, saved_state
); /* Enter it */
521 case TRAP_DEBUGGER_INST
: /* Should we enter the current debugger? */
522 case TRAP_DIRECT_INST
: /* Should we enter the current debugger? */
523 if (current_debugger
== KDP_CUR_DB
) /* Is current KDP? */
524 kdp_trap(type
, saved_state
); /* Yes, enter it */
525 else if (current_debugger
== KDB_CUR_DB
) /* Is this KDB? */
526 kdb_trap(type
, saved_state
); /* Yes, go ahead and enter */
527 else goto debugger_error
; /* No debugger active */
530 default: /* Unknown/bogus trap type */
535 while(1) { /* We are here to handle debugger switches */
537 if(!directcall
) { /* Was this a direct call? */
538 if(!switch_debugger
) break; /* No, then leave if no switch requested... */
541 * Note: we can only switch to a debugger we have. Ignore bogus switch requests.
544 if (debugger_debug
) kprintf("Call_DebuggerC(%d): switching debuggers\n", my_cpu
); /* (TEST/DEBUG) */
547 if(current_debugger
== KDP_CUR_DB
) current_debugger
= KDB_CUR_DB
; /* Switch to KDB */
553 if(current_debugger
== KDB_CUR_DB
) current_debugger
= KDP_CUR_DB
; /* Switch to KDP */
557 switch_debugger
= 0; /* Clear request */
558 directcall
= 0; /* Clear first-time direct call indication */
560 switch (current_debugger
) { /* Enter correct debugger */
562 case KDP_CUR_DB
: /* Enter KDP */
563 kdp_trap(type
, saved_state
);
566 case KDB_CUR_DB
: /* Enter KDB */
567 kdb_trap(type
, saved_state
);
570 default: /* No debugger installed */
578 if (debugger_debug
) kprintf("Call_DebuggerC(%d): exit - inst = %08X, cpu=%d(%d), run=%d\n", my_cpu
,
579 instr
, my_cpu
, debugger_cpu
, db_run_mode
); /* (TEST/DEBUG) */
581 if ((instr
== TRAP_DEBUGGER_INST
) || /* Did we trap to enter debugger? */
582 (instr
== TRAP_DIRECT_INST
)) saved_state
->srr0
+= TRAP_INST_SIZE
; /* Yes, point past trap */
584 if(debugger_cpu
== my_cpu
) LLTraceSet(lastTrace
); /* Enable tracing on the way out if we are debugger */
586 wait
= FALSE
; /* Assume we are not going to wait */
587 if (db_run_mode
== STEP_CONTINUE
) { /* Are we going to run? */
588 wait
= TRUE
; /* Yeah, remember to wait for breakpoints to clear */
589 debugger_cpu
= -1; /* Release other processor's debuggers */
590 debugger_pending
[0] = 0; /* Release request (this is a HACK) */
591 debugger_pending
[1] = 0; /* Release request (this is a HACK) */
592 NMIss
= 0; /* Let NMI bounce */
595 if(db_run_mode
== STEP_ONCE
) { /* Are we about to step? */
596 disable_preemption(); /* Disable preemption for the step */
597 db_im_stepping
= my_cpu
; /* Remember that I am about to step */
600 if (db_breakpoints_inserted
) cpus_holding_bkpts
--; /* If any breakpoints, back off count */
601 if (debugger_is_slave
[my_cpu
]) debugger_is_slave
[my_cpu
]--; /* If we were a slove, uncount us */
603 printf("Call_Debugger: exit - cpu %d, debugger_cpu %d, run_mode %d holds %d\n",
604 my_cpu
, debugger_cpu
, db_run_mode
,
607 unlock_debugger(); /* Release the lock */
608 debugger_active
[my_cpu
]--; /* Say we aren't active anymore */
610 if (wait
) while(cpus_holding_bkpts
); /* Wait for breakpoints to clear */
612 hw_atomic_sub(&debug_mode
, 1); /* Set out of debug now */
614 return(1); /* Exit debugger normally */
617 if(db_run_mode
!= STEP_ONCE
) enable_preemption_no_check(); /* Enable preemption, but don't preempt here */
618 hw_atomic_sub(&debug_mode
, 1); /* Set out of debug now */
619 return(0); /* Return in shame... */
623 void lock_debugger(void) {
627 my_cpu
= cpu_number(); /* Get our CPU number */
629 while(1) { /* Check until we get it */
631 if (debugger_cpu
!= -1 && debugger_cpu
!= my_cpu
) continue; /* Someone, not us, is debugger... */
632 if (hw_lock_try(&debugger_lock
)) { /* Get the debug lock */
633 if (debugger_cpu
== -1 || debugger_cpu
== my_cpu
) break; /* Is it us? */
634 hw_lock_unlock(&debugger_lock
); /* Not us, release lock */
639 void unlock_debugger(void) {
641 hw_lock_unlock(&debugger_lock
);