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