]> 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-792.25.20.tar.gz
[apple/xnu.git] / osfmk / kdp / ml / ppc / kdp_machdep.c
1 /*
2 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
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.
11 *
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
18 * under the License.
19 *
20 * @APPLE_LICENSE_HEADER_END@
21 */
22
23 #include <mach/mach_types.h>
24 #include <mach/exception_types.h>
25 #include <ppc/exception.h>
26 #include <ppc/proc_reg.h>
27 #include <kdp/kdp_internal.h>
28 #include <ppc/savearea.h>
29 #include <kern/debug.h>
30 #include <IOKit/IOPlatformExpert.h>
31
32
33 #include <kern/thread.h>
34 #include <ppc/thread.h>
35 #include <vm/vm_map.h>
36 #include <ppc/pmap.h>
37
38 #define KDP_TEST_HARNESS 0
39 #if KDP_TEST_HARNESS
40 #define dprintf(x) kprintf x
41 #else
42 #define dprintf(x)
43 #endif
44
45 void print_saved_state(void *);
46 void kdp_call(void);
47 void kdp_trap( unsigned int, struct savearea *saved_state);
48 int kdp_getc(void);
49 boolean_t kdp_call_kdb(void);
50
51 extern pmap_t kdp_pmap;
52 extern uint32_t kdp_src_high32;
53
54
55 extern unsigned kdp_vm_read(caddr_t src, caddr_t dst, unsigned len);
56
57 int
58 machine_trace_thread(thread_t thread, uint32_t tracepos, uint32_t tracebound, int nframes, boolean_t user_p);
59
60 int
61 machine_trace_thread64(thread_t thread, uint32_t tracepos, uint32_t tracebound, int nframes, boolean_t user_p);
62
63 unsigned
64 machine_read64(addr64_t srcaddr, caddr_t dstaddr, uint32_t len);
65
66 void
67 kdp_exception(
68 unsigned char *pkt,
69 int *len,
70 unsigned short *remote_port,
71 unsigned int exception,
72 unsigned int code,
73 unsigned int subcode
74 )
75 {
76 struct {
77 kdp_exception_t pkt;
78 kdp_exc_info_t exc;
79 } aligned_pkt;
80 kdp_exception_t *rq = (kdp_exception_t *)&aligned_pkt;
81
82 bcopy((char *)pkt, (char *)rq, sizeof(*rq));
83 rq->hdr.request = KDP_EXCEPTION;
84 rq->hdr.is_reply = 0;
85 rq->hdr.seq = kdp.exception_seq;
86 rq->hdr.key = 0;
87 rq->hdr.len = sizeof (*rq) + sizeof(kdp_exc_info_t);
88
89 rq->n_exc_info = 1;
90 rq->exc_info[0].cpu = 0;
91 rq->exc_info[0].exception = exception;
92 rq->exc_info[0].code = code;
93 rq->exc_info[0].subcode = subcode;
94
95 rq->hdr.len += rq->n_exc_info * sizeof (kdp_exc_info_t);
96
97 bcopy((char *)rq, (char *)pkt, rq->hdr.len);
98
99 kdp.exception_ack_needed = TRUE;
100
101 *remote_port = kdp.exception_port;
102 *len = rq->hdr.len;
103 }
104
105 boolean_t
106 kdp_exception_ack(
107 unsigned char *pkt,
108 int len
109 )
110 {
111 kdp_exception_ack_t aligned_pkt;
112 kdp_exception_ack_t *rq = (kdp_exception_ack_t *)&aligned_pkt;
113
114 if (len < sizeof (*rq))
115 return(FALSE);
116
117 bcopy((char *)pkt, (char *)rq, sizeof(*rq));
118
119 if (!rq->hdr.is_reply || rq->hdr.request != KDP_EXCEPTION)
120 return(FALSE);
121
122 dprintf(("kdp_exception_ack seq %x %x\n", rq->hdr.seq, kdp.exception_seq));
123
124 if (rq->hdr.seq == kdp.exception_seq) {
125 kdp.exception_ack_needed = FALSE;
126 kdp.exception_seq++;
127 }
128 return(TRUE);
129 }
130
131 static void
132 kdp_getintegerstate(
133 struct ppc_thread_state *state
134 )
135 {
136 struct savearea *saved_state;
137
138 saved_state = kdp.saved_state;
139
140 bzero((char *)state,sizeof (struct ppc_thread_state)) ;
141
142 state->srr0 = (unsigned int)saved_state->save_srr0;
143 state->srr1 = (unsigned int)saved_state->save_srr1;
144 state->r0 = (unsigned int)saved_state->save_r0;
145 state->r1 = (unsigned int)saved_state->save_r1;
146 state->r2 = (unsigned int)saved_state->save_r2;
147 state->r3 = (unsigned int)saved_state->save_r3;
148 state->r4 = (unsigned int)saved_state->save_r4;
149 state->r5 = (unsigned int)saved_state->save_r5;
150 state->r6 = (unsigned int)saved_state->save_r6;
151 state->r7 = (unsigned int)saved_state->save_r7;
152 state->r8 = (unsigned int)saved_state->save_r8;
153 state->r9 = (unsigned int)saved_state->save_r9;
154 state->r10 = (unsigned int)saved_state->save_r10;
155 state->r11 = (unsigned int)saved_state->save_r11;
156 state->r12 = (unsigned int)saved_state->save_r12;
157 state->r13 = (unsigned int)saved_state->save_r13;
158 state->r14 = (unsigned int)saved_state->save_r14;
159 state->r15 = (unsigned int)saved_state->save_r15;
160 state->r16 = (unsigned int)saved_state->save_r16;
161 state->r17 = (unsigned int)saved_state->save_r17;
162 state->r18 = (unsigned int)saved_state->save_r18;
163 state->r19 = (unsigned int)saved_state->save_r19;
164 state->r20 = (unsigned int)saved_state->save_r20;
165 state->r21 = (unsigned int)saved_state->save_r21;
166 state->r22 = (unsigned int)saved_state->save_r22;
167 state->r23 = (unsigned int)saved_state->save_r23;
168 state->r24 = (unsigned int)saved_state->save_r24;
169 state->r25 = (unsigned int)saved_state->save_r25;
170 state->r26 = (unsigned int)saved_state->save_r26;
171 state->r27 = (unsigned int)saved_state->save_r27;
172 state->r28 = (unsigned int)saved_state->save_r28;
173 state->r29 = (unsigned int)saved_state->save_r29;
174 state->r30 = (unsigned int)saved_state->save_r30;
175 state->r31 = (unsigned int)saved_state->save_r31;
176 state->cr = (unsigned int)saved_state->save_cr;
177 state->xer = (unsigned int)saved_state->save_xer;
178 state->lr = (unsigned int)saved_state->save_lr;
179 state->ctr = (unsigned int)saved_state->save_ctr;
180 }
181
182 static void
183 kdp_getintegerstate64(
184 struct ppc_thread_state64 *state
185 )
186 {
187 struct savearea *saved_state;
188
189 saved_state = kdp.saved_state;
190
191 bzero((char *)state,sizeof (struct ppc_thread_state64)) ;
192
193 state->srr0 = saved_state->save_srr0;
194 state->srr1 = saved_state->save_srr1;
195 state->r0 = saved_state->save_r0;
196 state->r1 = saved_state->save_r1;
197 state->r2 = saved_state->save_r2;
198 state->r3 = saved_state->save_r3;
199 state->r4 = saved_state->save_r4;
200 state->r5 = saved_state->save_r5;
201 state->r6 = saved_state->save_r6;
202 state->r7 = saved_state->save_r7;
203 state->r8 = saved_state->save_r8;
204 state->r9 = saved_state->save_r9;
205 state->r10 = saved_state->save_r10;
206 state->r11 = saved_state->save_r11;
207 state->r12 = saved_state->save_r12;
208 state->r13 = saved_state->save_r13;
209 state->r14 = saved_state->save_r14;
210 state->r15 = saved_state->save_r15;
211 state->r16 = saved_state->save_r16;
212 state->r17 = saved_state->save_r17;
213 state->r18 = saved_state->save_r18;
214 state->r19 = saved_state->save_r19;
215 state->r20 = saved_state->save_r20;
216 state->r21 = saved_state->save_r21;
217 state->r22 = saved_state->save_r22;
218 state->r23 = saved_state->save_r23;
219 state->r24 = saved_state->save_r24;
220 state->r25 = saved_state->save_r25;
221 state->r26 = saved_state->save_r26;
222 state->r27 = saved_state->save_r27;
223 state->r28 = saved_state->save_r28;
224 state->r29 = saved_state->save_r29;
225 state->r30 = saved_state->save_r30;
226 state->r31 = saved_state->save_r31;
227 state->cr = saved_state->save_cr;
228 state->xer = saved_state->save_xer;
229 state->lr = saved_state->save_lr;
230 state->ctr = saved_state->save_ctr;
231 }
232
233 kdp_error_t
234 kdp_machine_read_regs(
235 unsigned int cpu,
236 unsigned int flavor,
237 char *data,
238 int *size
239 )
240 {
241 switch (flavor) {
242
243 case PPC_THREAD_STATE:
244 dprintf(("kdp_readregs THREAD_STATE\n"));
245 kdp_getintegerstate((struct ppc_thread_state *)data);
246 *size = PPC_THREAD_STATE_COUNT * sizeof(int);
247 return KDPERR_NO_ERROR;
248
249 case PPC_THREAD_STATE64:
250 dprintf(("kdp_readregs THREAD_STATE\n"));
251 kdp_getintegerstate64((struct ppc_thread_state64 *)data);
252 *size = PPC_THREAD_STATE64_COUNT * sizeof(int);
253 return KDPERR_NO_ERROR;
254
255 case PPC_FLOAT_STATE:
256 dprintf(("kdp_readregs THREAD_FPSTATE\n"));
257 bzero((char *)data ,sizeof(struct ppc_float_state));
258 *size = PPC_FLOAT_STATE_COUNT * sizeof(int);
259 return KDPERR_NO_ERROR;
260
261 default:
262 dprintf(("kdp_readregs bad flavor %d\n"));
263 return KDPERR_BADFLAVOR;
264 }
265 }
266
267 static void
268 kdp_setintegerstate(
269 struct ppc_thread_state *state
270 )
271 {
272 struct savearea *saved_state;
273
274 saved_state = kdp.saved_state;
275
276 saved_state->save_srr0 = state->srr0;
277 saved_state->save_srr1 = state->srr1;
278 saved_state->save_r0 = state->r0;
279 saved_state->save_r1 = state->r1;
280 saved_state->save_r2 = state->r2;
281 saved_state->save_r3 = state->r3;
282 saved_state->save_r4 = state->r4;
283 saved_state->save_r5 = state->r5;
284 saved_state->save_r6 = state->r6;
285 saved_state->save_r7 = state->r7;
286 saved_state->save_r8 = state->r8;
287 saved_state->save_r9 = state->r9;
288 saved_state->save_r10 = state->r10;
289 saved_state->save_r11 = state->r11;
290 saved_state->save_r12 = state->r12;
291 saved_state->save_r13 = state->r13;
292 saved_state->save_r14 = state->r14;
293 saved_state->save_r15 = state->r15;
294 saved_state->save_r16 = state->r16;
295 saved_state->save_r17 = state->r17;
296 saved_state->save_r18 = state->r18;
297 saved_state->save_r19 = state->r19;
298 saved_state->save_r20 = state->r20;
299 saved_state->save_r21 = state->r21;
300 saved_state->save_r22 = state->r22;
301 saved_state->save_r23 = state->r23;
302 saved_state->save_r24 = state->r24;
303 saved_state->save_r25 = state->r25;
304 saved_state->save_r26 = state->r26;
305 saved_state->save_r27 = state->r27;
306 saved_state->save_r28 = state->r28;
307 saved_state->save_r29 = state->r29;
308 saved_state->save_r30 = state->r30;
309 saved_state->save_r31 = state->r31;
310 saved_state->save_cr = state->cr;
311 saved_state->save_xer = state->xer;
312 saved_state->save_lr = state->lr;
313 saved_state->save_ctr = state->ctr;
314 }
315
316 static void
317 kdp_setintegerstate64(
318 struct ppc_thread_state64 *state
319 )
320 {
321 struct savearea *saved_state;
322
323 saved_state = kdp.saved_state;
324
325 saved_state->save_srr0 = state->srr0;
326 saved_state->save_srr1 = state->srr1;
327 saved_state->save_r0 = state->r0;
328 saved_state->save_r1 = state->r1;
329 saved_state->save_r2 = state->r2;
330 saved_state->save_r3 = state->r3;
331 saved_state->save_r4 = state->r4;
332 saved_state->save_r5 = state->r5;
333 saved_state->save_r6 = state->r6;
334 saved_state->save_r7 = state->r7;
335 saved_state->save_r8 = state->r8;
336 saved_state->save_r9 = state->r9;
337 saved_state->save_r10 = state->r10;
338 saved_state->save_r11 = state->r11;
339 saved_state->save_r12 = state->r12;
340 saved_state->save_r13 = state->r13;
341 saved_state->save_r14 = state->r14;
342 saved_state->save_r15 = state->r15;
343 saved_state->save_r16 = state->r16;
344 saved_state->save_r17 = state->r17;
345 saved_state->save_r18 = state->r18;
346 saved_state->save_r19 = state->r19;
347 saved_state->save_r20 = state->r20;
348 saved_state->save_r21 = state->r21;
349 saved_state->save_r22 = state->r22;
350 saved_state->save_r23 = state->r23;
351 saved_state->save_r24 = state->r24;
352 saved_state->save_r25 = state->r25;
353 saved_state->save_r26 = state->r26;
354 saved_state->save_r27 = state->r27;
355 saved_state->save_r28 = state->r28;
356 saved_state->save_r29 = state->r29;
357 saved_state->save_r30 = state->r30;
358 saved_state->save_r31 = state->r31;
359 saved_state->save_cr = state->cr;
360 saved_state->save_xer = state->xer;
361 saved_state->save_lr = state->lr;
362 saved_state->save_ctr = state->ctr;
363 }
364
365 kdp_error_t
366 kdp_machine_write_regs(
367 unsigned int cpu,
368 unsigned int flavor,
369 char *data,
370 int *size
371 )
372 {
373 switch (flavor) {
374
375 case PPC_THREAD_STATE:
376 dprintf(("kdp_writeregs THREAD_STATE\n"));
377 kdp_setintegerstate((struct ppc_thread_state *)data);
378
379 #if KDP_TEST_HARNESS
380 DumpTheSave((struct savearea *)data); /* (TEST/DEBUG) */
381 #endif
382 return KDPERR_NO_ERROR;
383
384 case PPC_THREAD_STATE64:
385 dprintf(("kdp_writeregs THREAD_STATE64\n"));
386 kdp_setintegerstate64((struct ppc_thread_state64 *)data);
387
388 #if KDP_TEST_HARNESS
389 DumpTheSave((struct savearea *)data); /* (TEST/DEBUG) */
390 #endif
391 return KDPERR_NO_ERROR;
392 case PPC_FLOAT_STATE:
393 dprintf(("kdp_writeregs THREAD_FPSTATE\n"));
394 return KDPERR_NO_ERROR;
395
396 default:
397 dprintf(("kdp_writeregs bad flavor %d\n"));
398 return KDPERR_BADFLAVOR;
399 }
400 }
401
402 void
403 kdp_machine_hostinfo(
404 kdp_hostinfo_t *hostinfo
405 )
406 {
407 int i;
408
409 hostinfo->cpus_mask = 0;
410 hostinfo->cpu_type = 0;
411
412 for (i = 0; i < machine_info.max_cpus; i++) {
413 if ((PerProcTable[i].ppe_vaddr == (struct per_proc_info *)NULL) ||
414 !(PerProcTable[i].ppe_vaddr->running))
415 continue;
416
417 hostinfo->cpus_mask |= (1 << i);
418 if (hostinfo->cpu_type == 0) {
419 hostinfo->cpu_type = slot_type(i);
420 hostinfo->cpu_subtype = slot_subtype(i);
421 }
422 }
423 }
424
425 void
426 kdp_panic(
427 const char *msg
428 )
429 {
430 printf("kdp panic: %s\n", msg);
431 while(1) {}
432 }
433
434
435 void
436 kdp_reboot(void)
437 {
438 printf("Attempting system restart...");
439 /* Call the platform specific restart*/
440 if (PE_halt_restart)
441 (*PE_halt_restart)(kPERestartCPU);
442 /* If we do reach this, give up */
443 halt_all_cpus(TRUE);
444 }
445
446 int
447 kdp_intr_disbl(void)
448 {
449 return (splhigh());
450 }
451
452 void
453 kdp_intr_enbl(int s)
454 {
455 splx(s);
456 }
457
458 void
459 kdp_us_spin(int usec)
460 {
461 extern void delay(int);
462
463 delay(usec/100);
464 }
465
466 void print_saved_state(void *state)
467 {
468 struct ppc_thread_state *saved_state;
469
470 saved_state = state;
471
472 printf("pc = 0x%x\n", saved_state->srr0);
473 printf("msr = 0x%x\n", saved_state->srr1);
474 printf("rp = 0x%x\n", saved_state->lr);
475 printf("sp = 0x%x\n", saved_state->r1);
476
477 }
478
479 void
480 kdp_call()
481 {
482 Debugger("inline call to debugger(machine_startup)");
483 }
484
485 /*
486 * table to convert system specific code to generic codes for kdb
487 */
488 int kdp_trap_codes[] = {
489 EXC_BAD_ACCESS, /* 0x0000 INVALID EXCEPTION */
490 EXC_BAD_ACCESS, /* 0x0100 System reset */
491 EXC_BAD_ACCESS, /* 0x0200 Machine check */
492 EXC_BAD_ACCESS, /* 0x0300 Data access */
493 EXC_BAD_ACCESS, /* 0x0400 Instruction access */
494 EXC_BAD_ACCESS, /* 0x0500 External interrupt */
495 EXC_BAD_ACCESS, /* 0x0600 Alignment */
496 EXC_BREAKPOINT, /* 0x0700 Program - fp exc, ill/priv instr, trap */
497 EXC_ARITHMETIC, /* 0x0800 Floating point disabled */
498 EXC_SOFTWARE, /* 0x0900 Decrementer */
499 EXC_BAD_ACCESS, /* 0x0A00 I/O controller interface */
500 EXC_BAD_ACCESS, /* 0x0B00 INVALID EXCEPTION */
501 EXC_SOFTWARE, /* 0x0C00 System call exception */
502 EXC_BREAKPOINT, /* 0x0D00 Trace */
503 EXC_SOFTWARE, /* 0x0E00 FP assist */
504 EXC_SOFTWARE, /* 0x0F00 Performance monitoring */
505 EXC_ARITHMETIC, /* 0x0F20 Altivec disabled */
506 EXC_BAD_ACCESS, /* 0x1000 Instruction PTE miss */
507 EXC_BAD_ACCESS, /* 0x1100 Data load PTE miss */
508 EXC_BAD_ACCESS, /* 0x1200 Data store PTE miss */
509 EXC_BREAKPOINT, /* 0x1300 Instruction bkpt */
510 EXC_SOFTWARE, /* 0x1400 System management */
511 EXC_BAD_ACCESS, /* 0x1500 INVALID EXCEPTION */
512 EXC_ARITHMETIC, /* 0x1600 Altivec Assist */
513 EXC_BAD_ACCESS, /* 0x1700 INVALID EXCEPTION */
514 EXC_BAD_ACCESS, /* 0x1800 INVALID EXCEPTION */
515 EXC_BAD_ACCESS, /* 0x1900 INVALID EXCEPTION */
516 EXC_BAD_ACCESS, /* 0x1A00 INVALID EXCEPTION */
517 EXC_BAD_ACCESS, /* 0x1B00 INVALID EXCEPTION */
518 EXC_BAD_ACCESS, /* 0x1C00 INVALID EXCEPTION */
519 EXC_BAD_ACCESS, /* 0x1D00 INVALID EXCEPTION */
520 EXC_BAD_ACCESS, /* 0x1E00 INVALID EXCEPTION */
521 EXC_BAD_ACCESS, /* 0x1F00 INVALID EXCEPTION */
522 EXC_BREAKPOINT, /* 0x2000 Run Mode/Trace */
523 EXC_BAD_ACCESS, /* 0x2100 INVALID EXCEPTION */
524 EXC_BAD_ACCESS, /* 0x2200 INVALID EXCEPTION */
525 EXC_BAD_ACCESS, /* 0x2300 INVALID EXCEPTION */
526 EXC_BAD_ACCESS, /* 0x2400 INVALID EXCEPTION */
527 EXC_BAD_ACCESS, /* 0x2500 INVALID EXCEPTION */
528 EXC_BAD_ACCESS, /* 0x2600 INVALID EXCEPTION */
529 EXC_BAD_ACCESS, /* 0x2700 INVALID EXCEPTION */
530 EXC_BAD_ACCESS, /* 0x2800 INVALID EXCEPTION */
531 EXC_BAD_ACCESS, /* 0x2900 INVALID EXCEPTION */
532 EXC_BAD_ACCESS, /* 0x2A00 INVALID EXCEPTION */
533 EXC_BAD_ACCESS, /* 0x2B00 INVALID EXCEPTION */
534 EXC_BAD_ACCESS, /* 0x2C00 INVALID EXCEPTION */
535 EXC_BAD_ACCESS, /* 0x2D00 INVALID EXCEPTION */
536 EXC_BAD_ACCESS, /* 0x2E00 INVALID EXCEPTION */
537 EXC_BAD_ACCESS, /* 0x2F00 INVALID EXCEPTION */
538 EXC_SOFTWARE /* 0x3000 AST trap (software) */
539 };
540
541 int
542 kdp_getc()
543 {
544 return(cnmaygetc());
545 }
546
547 int kdp_backtrace;
548 int kdp_sr_dump;
549 int kdp_dabr;
550 int kdp_noisy;
551
552 #define kdp_code(x) kdp_trap_codes[((x)==T_AST?0x31:(x)/T_VECTOR_SIZE)]
553
554 void
555 kdp_trap(
556 unsigned int exception,
557 struct savearea *saved_state
558 )
559 {
560 unsigned int *fp;
561 unsigned int sp;
562 struct savearea *state;
563
564 if (kdp_noisy) {
565 if (kdp_backtrace) {
566 printf("\nvector=%x, \n", exception/4);
567 sp = saved_state->save_r1;
568 printf("stack backtrace - sp(%x) ", sp);
569 fp = (unsigned int *) *((unsigned int *)sp);
570 while (fp) {
571 printf("0x%08x ", fp[2]);
572 fp = (unsigned int *)*fp;
573 }
574 printf("\n");
575 }
576 #ifdef XXX
577 if (kdp_sr_dump) {
578 dump_segment_registers();
579 }
580 #endif
581
582 printf("vector=%d ", exception/4);
583 }
584 kdp_raise_exception(kdp_code(exception), 0, 0, saved_state);
585
586 if (kdp_noisy)
587 printf("kdp_trap: kdp_raise_exception() ret\n");
588
589 if ((unsigned int)(saved_state->save_srr0) == 0x7c800008)
590 saved_state->save_srr0 += 4; /* BKPT_SIZE */
591
592 if(saved_state->save_srr1 & (MASK(MSR_SE) | MASK(MSR_BE))) { /* Are we just stepping or continuing */
593 db_run_mode = STEP_ONCE; /* We are stepping */
594 }
595 else db_run_mode = STEP_CONTINUE; /* Otherwise we are continuing */
596
597 #ifdef XXX
598 mtspr(dabr, kdp_dabr);
599 #endif
600 }
601
602 boolean_t
603 kdp_call_kdb(
604 void)
605 {
606 switch_debugger=1;
607 return(TRUE);
608 }
609
610 void kdp_print_registers(struct savearea *state)
611 {
612 int i;
613 for (i=0; i<32; i++) {
614 if ((i % 8) == 0)
615 printf("\n%4d :",i);
616 printf(" %08x",*(&state->save_r0+i));
617 }
618 printf("\n");
619 printf("cr = 0x%08x\t\t",state->save_cr);
620 printf("xer = 0x%08x\n",state->save_xer);
621 printf("lr = 0x%08x\t\t",state->save_lr);
622 printf("ctr = 0x%08x\n",state->save_ctr);
623 printf("srr0(iar) = 0x%08x\t\t",state->save_srr0);
624 printf("srr1(msr) = 0x%08B\n",state->save_srr1,
625 "\x10\x11""EE\x12PR\x13""FP\x14ME\x15""FE0\x16SE\x18"
626 "FE1\x19""AL\x1a""EP\x1bIT\x1c""DT");
627 printf("\n");
628 }
629
630 void
631 kdp_print_backtrace(
632 unsigned int exception,
633 struct savearea *saved_state)
634 {
635 extern void kdp_print_registers(struct savearea *);
636 extern void print_backtrace(struct savearea *);
637
638 disableDebugOuput = FALSE;
639 debug_mode = TRUE;
640 printf("re-entering kdp:\n");
641 printf("vector=%x, \n", exception/4);
642 kdp_print_registers(saved_state);
643 print_backtrace(saved_state);
644 printf("panic: We are hanging here...\n");
645 while(1);
646 }
647
648 unsigned int kdp_ml_get_breakinsn(void)
649 {
650 return 0x7fe00008;
651 }
652 #define LR_OFFSET 8
653 #define LR_OFFSET64 16
654
655 int
656 machine_trace_thread(thread_t thread, uint32_t tracepos, uint32_t tracebound, int nframes, boolean_t user_p)
657 {
658 uint32_t *tracebuf = (uint32_t *)tracepos;
659 uint32_t fence = 0;
660 uint32_t stackptr = 0;
661 uint32_t stacklimit = 0xb0000000;
662 int framecount = 0;
663 uint32_t init_srr0 = 0;
664 uint32_t prevsp = 0;
665 uint32_t framesize = 2 * sizeof(vm_offset_t);
666
667 if (user_p) {
668 /* Examine the user savearea */
669 init_srr0 = thread->machine.upcb->save_srr0;
670 stackptr = thread->machine.upcb->save_r1;
671 /* This bound isn't useful, but it doesn't hinder us */
672 stacklimit = 0xffffffff;
673 kdp_pmap = thread->task->map->pmap;
674 }
675 else {
676 stackptr = thread->machine.pcb->save_r1;
677 init_srr0 = thread->machine.pcb->save_srr0;
678 }
679 /* Fill in the "current" program counter */
680 *tracebuf++ = init_srr0;
681
682 for (framecount = 0; framecount < nframes; framecount++) {
683 /* Bounds check */
684 if ((tracebound - ((uint32_t) tracebuf)) < (4 * framesize)) {
685 tracebuf--;
686 break;
687 }
688
689 *tracebuf++ = stackptr;
690 /* Invalid frame, or hit fence */
691 if (!stackptr || (stackptr == fence)) {
692 break;
693 }
694 /* Stack grows downward */
695 if (stackptr < prevsp) {
696 break;
697 }
698 /* Unaligned frame */
699 if (stackptr & 0x000000F) {
700 break;
701 }
702 if (stackptr > stacklimit) {
703 break;
704 }
705 /* Assume there's a saved link register, and read it */
706 if (kdp_vm_read((caddr_t) (stackptr + LR_OFFSET), (caddr_t) tracebuf, sizeof(caddr_t)) != sizeof(caddr_t)) {
707 break;
708 }
709
710 tracebuf++;
711 prevsp = stackptr;
712 /* Next frame */
713 if (kdp_vm_read((caddr_t) stackptr, (caddr_t) &stackptr, sizeof(caddr_t)) != sizeof(caddr_t)) {
714 *tracebuf++ = 0;
715 break;
716 }
717 }
718 /* Reset the target pmap */
719 kdp_pmap = 0;
720 return ((uint32_t) tracebuf - tracepos);
721 }
722
723 /* Routine to encapsulate the 64-bit address read hack*/
724 unsigned
725 machine_read64(addr64_t srcaddr, caddr_t dstaddr, uint32_t len)
726 {
727 uint32_t kdp_vm_read_low32;
728 unsigned retval;
729
730 kdp_src_high32 = srcaddr >> 32;
731 kdp_vm_read_low32 = srcaddr & 0x00000000FFFFFFFFUL;
732 retval = kdp_vm_read((caddr_t)kdp_vm_read_low32, dstaddr, len);
733 kdp_src_high32 = 0;
734 return retval;
735 }
736
737 int
738 machine_trace_thread64(thread_t thread, uint32_t tracepos, uint32_t tracebound, int nframes, boolean_t user_p)
739 {
740 uint64_t *tracebuf = (uint64_t *)tracepos;
741 uint32_t fence = 0;
742 addr64_t stackptr = 0;
743 uint64_t stacklimit = 0xb0000000;
744 int framecount = 0;
745 addr64_t init_srr0 = 0;
746 addr64_t prevsp = 0;
747 unsigned framesize = 2 * sizeof(addr64_t);
748
749 if (user_p) {
750 init_srr0 = thread->machine.upcb->save_srr0;
751 stackptr = thread->machine.upcb->save_r1;
752 stacklimit = 0xffffffffffffffffULL;
753 kdp_pmap = thread->task->map->pmap;
754 }
755 else {
756 stackptr = thread->machine.pcb->save_r1;
757 init_srr0 = thread->machine.pcb->save_srr0;
758 }
759
760 *tracebuf++ = init_srr0;
761
762 for (framecount = 0; framecount < nframes; framecount++) {
763
764 if ((tracebound - ((uint32_t) tracebuf)) < (4 * framesize)) {
765 tracebuf--;
766 break;
767 }
768
769 *tracebuf++ = stackptr;
770
771 if (!stackptr || (stackptr == fence)){
772 break;
773 }
774 if (stackptr < prevsp) {
775 break;
776 }
777 if (stackptr & 0x000000F) {
778 break;
779 }
780 if (stackptr > stacklimit) {
781 break;
782 }
783
784 if (machine_read64(stackptr+LR_OFFSET64, (caddr_t) tracebuf, sizeof(addr64_t)) != sizeof(addr64_t)) {
785 break;
786 }
787 tracebuf++;
788
789 prevsp = stackptr;
790 if (machine_read64(stackptr, (caddr_t) &stackptr, sizeof(addr64_t)) != sizeof(addr64_t)) {
791 *tracebuf++ = 0;
792 break;
793 }
794 }
795
796 kdp_pmap = 0;
797
798 return ((uint32_t) tracebuf - tracepos);
799 }
mirror of XNU