]> git.saurik.com Git - apple/xnu.git/blob - osfmk/kdp/ml/ppc/kdp_machdep.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-517.tar.gz
[apple/xnu.git] / osfmk / kdp / ml / ppc / kdp_machdep.c
1 /*
2 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
7 *
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
17 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
18 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
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.
22 *
23 * @APPLE_LICENSE_HEADER_END@
24 */
25
26 #include <mach/mach_types.h>
27 #include <mach/exception_types.h>
28 #include <ppc/exception.h>
29 #include <ppc/proc_reg.h>
30 #include <kdp/kdp_internal.h>
31 #include <ppc/savearea.h>
32 #include <kern/debug.h>
33
34 #define KDP_TEST_HARNESS 0
35 #if KDP_TEST_HARNESS
36 #define dprintf(x) kprintf x
37 #else
38 #define dprintf(x)
39 #endif
40
41 void print_saved_state(void *);
42 void kdp_call(void);
43 void kdp_trap( unsigned int, struct savearea *saved_state);
44 int kdp_getc(void);
45 boolean_t kdp_call_kdb(void);
46
47 void
48 kdp_exception(
49 unsigned char *pkt,
50 int *len,
51 unsigned short *remote_port,
52 unsigned int exception,
53 unsigned int code,
54 unsigned int subcode
55 )
56 {
57 struct {
58 kdp_exception_t pkt;
59 kdp_exc_info_t exc;
60 } aligned_pkt;
61 kdp_exception_t *rq = (kdp_exception_t *)&aligned_pkt;
62
63 bcopy((char *)pkt, (char *)rq, sizeof(*rq));
64 rq->hdr.request = KDP_EXCEPTION;
65 rq->hdr.is_reply = 0;
66 rq->hdr.seq = kdp.exception_seq;
67 rq->hdr.key = 0;
68 rq->hdr.len = sizeof (*rq) + sizeof(kdp_exc_info_t);
69
70 rq->n_exc_info = 1;
71 rq->exc_info[0].cpu = 0;
72 rq->exc_info[0].exception = exception;
73 rq->exc_info[0].code = code;
74 rq->exc_info[0].subcode = subcode;
75
76 rq->hdr.len += rq->n_exc_info * sizeof (kdp_exc_info_t);
77
78 bcopy((char *)rq, (char *)pkt, rq->hdr.len);
79
80 kdp.exception_ack_needed = TRUE;
81
82 *remote_port = kdp.exception_port;
83 *len = rq->hdr.len;
84 }
85
86 boolean_t
87 kdp_exception_ack(
88 unsigned char *pkt,
89 int len
90 )
91 {
92 kdp_exception_ack_t aligned_pkt;
93 kdp_exception_ack_t *rq = (kdp_exception_ack_t *)&aligned_pkt;
94
95 if (len < sizeof (*rq))
96 return(FALSE);
97
98 bcopy((char *)pkt, (char *)rq, sizeof(*rq));
99
100 if (!rq->hdr.is_reply || rq->hdr.request != KDP_EXCEPTION)
101 return(FALSE);
102
103 dprintf(("kdp_exception_ack seq %x %x\n", rq->hdr.seq, kdp.exception_seq));
104
105 if (rq->hdr.seq == kdp.exception_seq) {
106 kdp.exception_ack_needed = FALSE;
107 kdp.exception_seq++;
108 }
109 return(TRUE);
110 }
111
112 static void
113 kdp_getintegerstate(
114 struct ppc_thread_state *state
115 )
116 {
117 struct savearea *saved_state;
118
119 saved_state = kdp.saved_state;
120
121 bzero((char *)state,sizeof (struct ppc_thread_state)) ;
122
123 state->srr0 = (unsigned int)saved_state->save_srr0;
124 state->srr1 = (unsigned int)saved_state->save_srr1;
125 state->r0 = (unsigned int)saved_state->save_r0;
126 state->r1 = (unsigned int)saved_state->save_r1;
127 state->r2 = (unsigned int)saved_state->save_r2;
128 state->r3 = (unsigned int)saved_state->save_r3;
129 state->r4 = (unsigned int)saved_state->save_r4;
130 state->r5 = (unsigned int)saved_state->save_r5;
131 state->r6 = (unsigned int)saved_state->save_r6;
132 state->r7 = (unsigned int)saved_state->save_r7;
133 state->r8 = (unsigned int)saved_state->save_r8;
134 state->r9 = (unsigned int)saved_state->save_r9;
135 state->r10 = (unsigned int)saved_state->save_r10;
136 state->r11 = (unsigned int)saved_state->save_r11;
137 state->r12 = (unsigned int)saved_state->save_r12;
138 state->r13 = (unsigned int)saved_state->save_r13;
139 state->r14 = (unsigned int)saved_state->save_r14;
140 state->r15 = (unsigned int)saved_state->save_r15;
141 state->r16 = (unsigned int)saved_state->save_r16;
142 state->r17 = (unsigned int)saved_state->save_r17;
143 state->r18 = (unsigned int)saved_state->save_r18;
144 state->r19 = (unsigned int)saved_state->save_r19;
145 state->r20 = (unsigned int)saved_state->save_r20;
146 state->r21 = (unsigned int)saved_state->save_r21;
147 state->r22 = (unsigned int)saved_state->save_r22;
148 state->r23 = (unsigned int)saved_state->save_r23;
149 state->r24 = (unsigned int)saved_state->save_r24;
150 state->r25 = (unsigned int)saved_state->save_r25;
151 state->r26 = (unsigned int)saved_state->save_r26;
152 state->r27 = (unsigned int)saved_state->save_r27;
153 state->r28 = (unsigned int)saved_state->save_r28;
154 state->r29 = (unsigned int)saved_state->save_r29;
155 state->r30 = (unsigned int)saved_state->save_r30;
156 state->r31 = (unsigned int)saved_state->save_r31;
157 state->cr = (unsigned int)saved_state->save_cr;
158 state->xer = (unsigned int)saved_state->save_xer;
159 state->lr = (unsigned int)saved_state->save_lr;
160 state->ctr = (unsigned int)saved_state->save_ctr;
161 }
162
163 static void
164 kdp_getintegerstate64(
165 struct ppc_thread_state64 *state
166 )
167 {
168 struct savearea *saved_state;
169
170 saved_state = kdp.saved_state;
171
172 bzero((char *)state,sizeof (struct ppc_thread_state64)) ;
173
174 state->srr0 = saved_state->save_srr0;
175 state->srr1 = saved_state->save_srr1;
176 state->r0 = saved_state->save_r0;
177 state->r1 = saved_state->save_r1;
178 state->r2 = saved_state->save_r2;
179 state->r3 = saved_state->save_r3;
180 state->r4 = saved_state->save_r4;
181 state->r5 = saved_state->save_r5;
182 state->r6 = saved_state->save_r6;
183 state->r7 = saved_state->save_r7;
184 state->r8 = saved_state->save_r8;
185 state->r9 = saved_state->save_r9;
186 state->r10 = saved_state->save_r10;
187 state->r11 = saved_state->save_r11;
188 state->r12 = saved_state->save_r12;
189 state->r13 = saved_state->save_r13;
190 state->r14 = saved_state->save_r14;
191 state->r15 = saved_state->save_r15;
192 state->r16 = saved_state->save_r16;
193 state->r17 = saved_state->save_r17;
194 state->r18 = saved_state->save_r18;
195 state->r19 = saved_state->save_r19;
196 state->r20 = saved_state->save_r20;
197 state->r21 = saved_state->save_r21;
198 state->r22 = saved_state->save_r22;
199 state->r23 = saved_state->save_r23;
200 state->r24 = saved_state->save_r24;
201 state->r25 = saved_state->save_r25;
202 state->r26 = saved_state->save_r26;
203 state->r27 = saved_state->save_r27;
204 state->r28 = saved_state->save_r28;
205 state->r29 = saved_state->save_r29;
206 state->r30 = saved_state->save_r30;
207 state->r31 = saved_state->save_r31;
208 state->cr = saved_state->save_cr;
209 state->xer = saved_state->save_xer;
210 state->lr = saved_state->save_lr;
211 state->ctr = saved_state->save_ctr;
212 }
213
214 kdp_error_t
215 kdp_machine_read_regs(
216 unsigned int cpu,
217 unsigned int flavor,
218 char *data,
219 int *size
220 )
221 {
222 switch (flavor) {
223
224 case PPC_THREAD_STATE:
225 dprintf(("kdp_readregs THREAD_STATE\n"));
226 kdp_getintegerstate((struct ppc_thread_state *)data);
227 *size = PPC_THREAD_STATE_COUNT * sizeof(int);
228 return KDPERR_NO_ERROR;
229
230 case PPC_THREAD_STATE64:
231 dprintf(("kdp_readregs THREAD_STATE\n"));
232 kdp_getintegerstate64((struct ppc_thread_state64 *)data);
233 *size = PPC_THREAD_STATE64_COUNT * sizeof(int);
234 return KDPERR_NO_ERROR;
235
236 case PPC_FLOAT_STATE:
237 dprintf(("kdp_readregs THREAD_FPSTATE\n"));
238 bzero((char *)data ,sizeof(struct ppc_float_state));
239 *size = PPC_FLOAT_STATE_COUNT * sizeof(int);
240 return KDPERR_NO_ERROR;
241
242 default:
243 dprintf(("kdp_readregs bad flavor %d\n"));
244 return KDPERR_BADFLAVOR;
245 }
246 }
247
248 static void
249 kdp_setintegerstate(
250 struct ppc_thread_state *state
251 )
252 {
253 struct savearea *saved_state;
254
255 saved_state = kdp.saved_state;
256
257 saved_state->save_srr0 = state->srr0;
258 saved_state->save_srr1 = state->srr1;
259 saved_state->save_r0 = state->r0;
260 saved_state->save_r1 = state->r1;
261 saved_state->save_r2 = state->r2;
262 saved_state->save_r3 = state->r3;
263 saved_state->save_r4 = state->r4;
264 saved_state->save_r5 = state->r5;
265 saved_state->save_r6 = state->r6;
266 saved_state->save_r7 = state->r7;
267 saved_state->save_r8 = state->r8;
268 saved_state->save_r9 = state->r9;
269 saved_state->save_r10 = state->r10;
270 saved_state->save_r11 = state->r11;
271 saved_state->save_r12 = state->r12;
272 saved_state->save_r13 = state->r13;
273 saved_state->save_r14 = state->r14;
274 saved_state->save_r15 = state->r15;
275 saved_state->save_r16 = state->r16;
276 saved_state->save_r17 = state->r17;
277 saved_state->save_r18 = state->r18;
278 saved_state->save_r19 = state->r19;
279 saved_state->save_r20 = state->r20;
280 saved_state->save_r21 = state->r21;
281 saved_state->save_r22 = state->r22;
282 saved_state->save_r23 = state->r23;
283 saved_state->save_r24 = state->r24;
284 saved_state->save_r25 = state->r25;
285 saved_state->save_r26 = state->r26;
286 saved_state->save_r27 = state->r27;
287 saved_state->save_r28 = state->r28;
288 saved_state->save_r29 = state->r29;
289 saved_state->save_r30 = state->r30;
290 saved_state->save_r31 = state->r31;
291 saved_state->save_cr = state->cr;
292 saved_state->save_xer = state->xer;
293 saved_state->save_lr = state->lr;
294 saved_state->save_ctr = state->ctr;
295 }
296
297 static void
298 kdp_setintegerstate64(
299 struct ppc_thread_state64 *state
300 )
301 {
302 struct savearea *saved_state;
303
304 saved_state = kdp.saved_state;
305
306 saved_state->save_srr0 = state->srr0;
307 saved_state->save_srr1 = state->srr1;
308 saved_state->save_r0 = state->r0;
309 saved_state->save_r1 = state->r1;
310 saved_state->save_r2 = state->r2;
311 saved_state->save_r3 = state->r3;
312 saved_state->save_r4 = state->r4;
313 saved_state->save_r5 = state->r5;
314 saved_state->save_r6 = state->r6;
315 saved_state->save_r7 = state->r7;
316 saved_state->save_r8 = state->r8;
317 saved_state->save_r9 = state->r9;
318 saved_state->save_r10 = state->r10;
319 saved_state->save_r11 = state->r11;
320 saved_state->save_r12 = state->r12;
321 saved_state->save_r13 = state->r13;
322 saved_state->save_r14 = state->r14;
323 saved_state->save_r15 = state->r15;
324 saved_state->save_r16 = state->r16;
325 saved_state->save_r17 = state->r17;
326 saved_state->save_r18 = state->r18;
327 saved_state->save_r19 = state->r19;
328 saved_state->save_r20 = state->r20;
329 saved_state->save_r21 = state->r21;
330 saved_state->save_r22 = state->r22;
331 saved_state->save_r23 = state->r23;
332 saved_state->save_r24 = state->r24;
333 saved_state->save_r25 = state->r25;
334 saved_state->save_r26 = state->r26;
335 saved_state->save_r27 = state->r27;
336 saved_state->save_r28 = state->r28;
337 saved_state->save_r29 = state->r29;
338 saved_state->save_r30 = state->r30;
339 saved_state->save_r31 = state->r31;
340 saved_state->save_cr = state->cr;
341 saved_state->save_xer = state->xer;
342 saved_state->save_lr = state->lr;
343 saved_state->save_ctr = state->ctr;
344 }
345
346 kdp_error_t
347 kdp_machine_write_regs(
348 unsigned int cpu,
349 unsigned int flavor,
350 char *data,
351 int *size
352 )
353 {
354 switch (flavor) {
355
356 case PPC_THREAD_STATE:
357 dprintf(("kdp_writeregs THREAD_STATE\n"));
358 kdp_setintegerstate((struct ppc_thread_state *)data);
359
360 #if KDP_TEST_HARNESS
361 DumpTheSave((struct savearea *)data); /* (TEST/DEBUG) */
362 #endif
363 return KDPERR_NO_ERROR;
364
365 case PPC_THREAD_STATE64:
366 dprintf(("kdp_writeregs THREAD_STATE64\n"));
367 kdp_setintegerstate64((struct ppc_thread_state64 *)data);
368
369 #if KDP_TEST_HARNESS
370 DumpTheSave((struct savearea *)data); /* (TEST/DEBUG) */
371 #endif
372 return KDPERR_NO_ERROR;
373 case PPC_FLOAT_STATE:
374 dprintf(("kdp_writeregs THREAD_FPSTATE\n"));
375 return KDPERR_NO_ERROR;
376
377 default:
378 dprintf(("kdp_writeregs bad flavor %d\n"));
379 return KDPERR_BADFLAVOR;
380 }
381 }
382
383 void
384 kdp_machine_hostinfo(
385 kdp_hostinfo_t *hostinfo
386 )
387 {
388 machine_slot_t m;
389 int i;
390
391 hostinfo->cpus_mask = 0;
392 hostinfo->cpu_type = 0;
393
394 for (i = 0; i < machine_info.max_cpus; i++) {
395 m = &machine_slot[i];
396 if (!m->is_cpu)
397 continue;
398
399 hostinfo->cpus_mask |= (1 << i);
400 if (hostinfo->cpu_type == 0) {
401 hostinfo->cpu_type = m->cpu_type;
402 hostinfo->cpu_subtype = m->cpu_subtype;
403 }
404 }
405 }
406
407 void
408 kdp_panic(
409 const char *msg
410 )
411 {
412 printf("kdp panic: %s\n", msg);
413 while(1) {}
414 }
415
416
417 void
418 kdp_reboot(void)
419 {
420 halt_all_cpus(TRUE);;
421 }
422
423 int
424 kdp_intr_disbl(void)
425 {
426 return (splhigh());
427 }
428
429 void
430 kdp_intr_enbl(int s)
431 {
432 splx(s);
433 }
434
435 void
436 kdp_us_spin(int usec)
437 {
438 extern void delay(int);
439
440 delay(usec/100);
441 }
442
443 void print_saved_state(void *state)
444 {
445 struct ppc_thread_state *saved_state;
446
447 saved_state = state;
448
449 printf("pc = 0x%x\n", saved_state->srr0);
450 printf("msr = 0x%x\n", saved_state->srr1);
451 printf("rp = 0x%x\n", saved_state->lr);
452 printf("sp = 0x%x\n", saved_state->r1);
453
454 }
455
456 void
457 kdp_call()
458 {
459 Debugger("inline call to debugger(machine_startup)");
460 }
461
462 /*
463 * table to convert system specific code to generic codes for kdb
464 */
465 int kdp_trap_codes[] = {
466 EXC_BAD_ACCESS, /* 0x0000 INVALID EXCEPTION */
467 EXC_BAD_ACCESS, /* 0x0100 System reset */
468 EXC_BAD_ACCESS, /* 0x0200 Machine check */
469 EXC_BAD_ACCESS, /* 0x0300 Data access */
470 EXC_BAD_ACCESS, /* 0x0400 Instruction access */
471 EXC_BAD_ACCESS, /* 0x0500 External interrupt */
472 EXC_BAD_ACCESS, /* 0x0600 Alignment */
473 EXC_BREAKPOINT, /* 0x0700 Program - fp exc, ill/priv instr, trap */
474 EXC_ARITHMETIC, /* 0x0800 Floating point disabled */
475 EXC_SOFTWARE, /* 0x0900 Decrementer */
476 EXC_BAD_ACCESS, /* 0x0A00 I/O controller interface */
477 EXC_BAD_ACCESS, /* 0x0B00 INVALID EXCEPTION */
478 EXC_SOFTWARE, /* 0x0C00 System call exception */
479 EXC_BREAKPOINT, /* 0x0D00 Trace */
480 EXC_SOFTWARE, /* 0x0E00 FP assist */
481 EXC_SOFTWARE, /* 0x0F00 Performance monitoring */
482 EXC_ARITHMETIC, /* 0x0F20 Altivec disabled */
483 EXC_BAD_ACCESS, /* 0x1000 Instruction PTE miss */
484 EXC_BAD_ACCESS, /* 0x1100 Data load PTE miss */
485 EXC_BAD_ACCESS, /* 0x1200 Data store PTE miss */
486 EXC_BREAKPOINT, /* 0x1300 Instruction bkpt */
487 EXC_SOFTWARE, /* 0x1400 System management */
488 EXC_BAD_ACCESS, /* 0x1500 INVALID EXCEPTION */
489 EXC_ARITHMETIC, /* 0x1600 Altivec Assist */
490 EXC_BAD_ACCESS, /* 0x1700 INVALID EXCEPTION */
491 EXC_BAD_ACCESS, /* 0x1800 INVALID EXCEPTION */
492 EXC_BAD_ACCESS, /* 0x1900 INVALID EXCEPTION */
493 EXC_BAD_ACCESS, /* 0x1A00 INVALID EXCEPTION */
494 EXC_BAD_ACCESS, /* 0x1B00 INVALID EXCEPTION */
495 EXC_BAD_ACCESS, /* 0x1C00 INVALID EXCEPTION */
496 EXC_BAD_ACCESS, /* 0x1D00 INVALID EXCEPTION */
497 EXC_BAD_ACCESS, /* 0x1E00 INVALID EXCEPTION */
498 EXC_BAD_ACCESS, /* 0x1F00 INVALID EXCEPTION */
499 EXC_BREAKPOINT, /* 0x2000 Run Mode/Trace */
500 EXC_BAD_ACCESS, /* 0x2100 INVALID EXCEPTION */
501 EXC_BAD_ACCESS, /* 0x2200 INVALID EXCEPTION */
502 EXC_BAD_ACCESS, /* 0x2300 INVALID EXCEPTION */
503 EXC_BAD_ACCESS, /* 0x2400 INVALID EXCEPTION */
504 EXC_BAD_ACCESS, /* 0x2500 INVALID EXCEPTION */
505 EXC_BAD_ACCESS, /* 0x2600 INVALID EXCEPTION */
506 EXC_BAD_ACCESS, /* 0x2700 INVALID EXCEPTION */
507 EXC_BAD_ACCESS, /* 0x2800 INVALID EXCEPTION */
508 EXC_BAD_ACCESS, /* 0x2900 INVALID EXCEPTION */
509 EXC_BAD_ACCESS, /* 0x2A00 INVALID EXCEPTION */
510 EXC_BAD_ACCESS, /* 0x2B00 INVALID EXCEPTION */
511 EXC_BAD_ACCESS, /* 0x2C00 INVALID EXCEPTION */
512 EXC_BAD_ACCESS, /* 0x2D00 INVALID EXCEPTION */
513 EXC_BAD_ACCESS, /* 0x2E00 INVALID EXCEPTION */
514 EXC_BAD_ACCESS, /* 0x2F00 INVALID EXCEPTION */
515 EXC_SOFTWARE /* 0x3000 AST trap (software) */
516 };
517
518 int
519 kdp_getc()
520 {
521 return(cnmaygetc());
522 }
523
524 int kdp_backtrace;
525 int kdp_sr_dump;
526 int kdp_dabr;
527 int kdp_noisy;
528
529 #define kdp_code(x) kdp_trap_codes[((x)==T_AST?0x31:(x)/T_VECTOR_SIZE)]
530
531 void
532 kdp_trap(
533 unsigned int exception,
534 struct savearea *saved_state
535 )
536 {
537 unsigned int *fp;
538 unsigned int sp;
539 struct savearea *state;
540
541 if (kdp_noisy) {
542 if (kdp_backtrace) {
543 printf("\nvector=%x, \n", exception/4);
544 sp = saved_state->save_r1;
545 printf("stack backtrace - sp(%x) ", sp);
546 fp = (unsigned int *) *((unsigned int *)sp);
547 while (fp) {
548 printf("0x%08x ", fp[2]);
549 fp = (unsigned int *)*fp;
550 }
551 printf("\n");
552 }
553 #ifdef XXX
554 if (kdp_sr_dump) {
555 dump_segment_registers();
556 }
557 #endif
558
559 printf("vector=%d ", exception/4);
560 }
561 kdp_raise_exception(kdp_code(exception), 0, 0, saved_state);
562
563 if (kdp_noisy)
564 printf("kdp_trap: kdp_raise_exception() ret\n");
565
566 if ((unsigned int)(saved_state->save_srr0) == 0x7c800008)
567 saved_state->save_srr0 += 4; /* BKPT_SIZE */
568
569 if(saved_state->save_srr1 & (MASK(MSR_SE) | MASK(MSR_BE))) { /* Are we just stepping or continuing */
570 db_run_mode = STEP_ONCE; /* We are stepping */
571 }
572 else db_run_mode = STEP_CONTINUE; /* Otherwise we are continuing */
573
574 #ifdef XXX
575 mtspr(dabr, kdp_dabr);
576 #endif
577 }
578
579 boolean_t
580 kdp_call_kdb(
581 void)
582 {
583 switch_debugger=1;
584 return(TRUE);
585 }
586
587 void kdp_print_registers(struct savearea *state)
588 {
589 int i;
590 for (i=0; i<32; i++) {
591 if ((i % 8) == 0)
592 printf("\n%4d :",i);
593 printf(" %08x",*(&state->save_r0+i));
594 }
595 printf("\n");
596 printf("cr = 0x%08x\t\t",state->save_cr);
597 printf("xer = 0x%08x\n",state->save_xer);
598 printf("lr = 0x%08x\t\t",state->save_lr);
599 printf("ctr = 0x%08x\n",state->save_ctr);
600 printf("srr0(iar) = 0x%08x\t\t",state->save_srr0);
601 printf("srr1(msr) = 0x%08B\n",state->save_srr1,
602 "\x10\x11""EE\x12PR\x13""FP\x14ME\x15""FE0\x16SE\x18"
603 "FE1\x19""AL\x1a""EP\x1bIT\x1c""DT");
604 printf("\n");
605 }
606
607 void
608 kdp_print_backtrace(
609 unsigned int exception,
610 struct savearea *saved_state)
611 {
612 extern void kdp_print_registers(struct savearea *);
613 extern void print_backtrace(struct savearea *);
614 extern unsigned int debug_mode, disableDebugOuput;
615
616 disableDebugOuput = FALSE;
617 debug_mode = TRUE;
618 printf("re-entering kdp:\n");
619 printf("vector=%x, \n", exception/4);
620 kdp_print_registers(saved_state);
621 print_backtrace(saved_state);
622 printf("panic: We are hanging here...\n");
623 while(1);
624 }
625
626 unsigned int kdp_ml_get_breakinsn()
627 {
628 return 0x7fe00008;
629 }
mirror of XNU