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  * 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  * Copyright (c) 1997 Apple Computer, Inc.  All rights reserved.
  24  * Copyright (c) 1994 NeXT Computer, Inc.  All rights reserved.
  25  *
  26  * machdep/ppc/kdp_machdep.c
  27  *
  28  * Machine-dependent code for Remote Debugging Protocol
  29  *
  30  * March, 1997  Created.        Umesh Vaishampayan [umeshv@NeXT.com]
  31  *
  32  */
  33
  34 #include <mach/mach_types.h>
  35 #include <mach/exception_types.h>
  36 #include <ppc/exception.h>
  37 #include <ppc/proc_reg.h>
  38 #include <kdp/kdp_internal.h>
  39 #include <ppc/savearea.h>
  40 #include <kern/debug.h>
  41
  42 #define KDP_TEST_HARNESS 0
  43 #if KDP_TEST_HARNESS
  44 #define dprintf(x) kprintf x
  45 #else
  46 #define dprintf(x)
  47 #endif
  48
  49 void print_saved_state(void *);
  50 void kdp_call(void);
  51 void kdp_trap( unsigned int, struct ppc_thread_state *);
  52 int kdp_getc(void);
  53 boolean_t kdp_call_kdb(void);
  54
  55 void
  56 kdp_exception(
  57     unsigned char       *pkt,
  58     int *len,
  59     unsigned short      *remote_port,
  60     unsigned int        exception,
  61     unsigned int        code,
  62     unsigned int        subcode
  63 )
  64 {
  65     struct {
  66         kdp_exception_t pkt;
  67         kdp_exc_info_t  exc;
  68     }                   aligned_pkt;
  69     kdp_exception_t     *rq = (kdp_exception_t *)&aligned_pkt;
  70
  71     bcopy((char *)pkt, (char *)rq, sizeof(*rq));
  72     rq->hdr.request = KDP_EXCEPTION;
  73     rq->hdr.is_reply = 0;
  74     rq->hdr.seq = kdp.exception_seq;
  75     rq->hdr.key = 0;
  76     rq->hdr.len = sizeof (*rq) + sizeof(kdp_exc_info_t);
  77
  78     rq->n_exc_info = 1;
  79     rq->exc_info[0].cpu = 0;
  80     rq->exc_info[0].exception = exception;
  81     rq->exc_info[0].code = code;
  82     rq->exc_info[0].subcode = subcode;
  83
  84     rq->hdr.len += rq->n_exc_info * sizeof (kdp_exc_info_t);
  85
  86     bcopy((char *)rq, (char *)pkt, rq->hdr.len);
  87
  88     kdp.exception_ack_needed = TRUE;
  89
  90     *remote_port = kdp.exception_port;
  91     *len = rq->hdr.len;
  92 }
  93
  94 boolean_t
  95 kdp_exception_ack(
  96     unsigned char       *pkt,
  97     int                 len
  98 )
  99 {
 100     kdp_exception_ack_t aligned_pkt;
 101     kdp_exception_ack_t *rq = (kdp_exception_ack_t *)&aligned_pkt;
 102
 103     if (len < sizeof (*rq))
 104         return(FALSE);
 105
 106     bcopy((char *)pkt, (char *)rq, sizeof(*rq));
 107
 108     if (!rq->hdr.is_reply || rq->hdr.request != KDP_EXCEPTION)
 109         return(FALSE);
 110
 111     dprintf(("kdp_exception_ack seq %x %x\n", rq->hdr.seq, kdp.exception_seq));
 112
 113     if (rq->hdr.seq == kdp.exception_seq) {
 114         kdp.exception_ack_needed = FALSE;
 115         kdp.exception_seq++;
 116     }
 117     return(TRUE);
 118 }
 119
 120 static void
 121 kdp_getintegerstate(
 122     struct ppc_thread_state             *state
 123 )
 124 {
 125     struct ppc_thread_state     *saved_state;
 126
 127     saved_state = kdp.saved_state;
 128
 129     bzero((char *)state,sizeof (struct ppc_thread_state)) ;
 130
 131     state->srr0 = saved_state->srr0;
 132     state->srr1 = saved_state->srr1;
 133     state->r0   = saved_state->r0;
 134     state->r1   = saved_state->r1;
 135     state->r2   = saved_state->r2;
 136     state->r3   = saved_state->r3;
 137     state->r4   = saved_state->r4;
 138     state->r5   = saved_state->r5;
 139     state->r6   = saved_state->r6;
 140     state->r7   = saved_state->r7;
 141     state->r8   = saved_state->r8;
 142     state->r9   = saved_state->r9;
 143     state->r10  = saved_state->r10;
 144     state->r11  = saved_state->r11;
 145     state->r12  = saved_state->r12;
 146     state->r13  = saved_state->r13;
 147     state->r14  = saved_state->r14;
 148     state->r15  = saved_state->r15;
 149     state->r16  = saved_state->r16;
 150     state->r17  = saved_state->r17;
 151     state->r18  = saved_state->r18;
 152     state->r19  = saved_state->r19;
 153     state->r20  = saved_state->r20;
 154     state->r21  = saved_state->r21;
 155     state->r22  = saved_state->r22;
 156     state->r23  = saved_state->r23;
 157     state->r24  = saved_state->r24;
 158     state->r25  = saved_state->r25;
 159     state->r26  = saved_state->r26;
 160     state->r27  = saved_state->r27;
 161     state->r28  = saved_state->r28;
 162     state->r29  = saved_state->r29;
 163     state->r30  = saved_state->r30;
 164     state->r31  = saved_state->r31;
 165     state->cr   = saved_state->cr;
 166     state->xer  = saved_state->xer;
 167     state->lr   = saved_state->lr;
 168     state->ctr  = saved_state->ctr;
 169     state->mq   = saved_state->mq; /* This is BOGUS ! (601) ONLY */
 170 }
 171
 172 kdp_error_t
 173 kdp_machine_read_regs(
 174     unsigned int cpu,
 175     unsigned int flavor,
 176     char *data,
 177     int *size
 178 )
 179 {
 180     switch (flavor) {
 181
 182     case PPC_THREAD_STATE:
 183                 dprintf(("kdp_readregs THREAD_STATE\n"));
 184                 kdp_getintegerstate((struct ppc_thread_state *)data);
 185                 *size = PPC_THREAD_STATE_COUNT * sizeof(int);
 186                 return KDPERR_NO_ERROR;
 187
 188     case PPC_FLOAT_STATE:
 189                 dprintf(("kdp_readregs THREAD_FPSTATE\n"));
 190                 bzero((char *)data ,sizeof(struct ppc_float_state));
 191                 *size = PPC_FLOAT_STATE_COUNT * sizeof(int);
 192                 return KDPERR_NO_ERROR;
 193
 194     default:
 195                 dprintf(("kdp_readregs bad flavor %d\n"));
 196                 return KDPERR_BADFLAVOR;
 197     }
 198 }
 199
 200 static void
 201 kdp_setintegerstate(
 202     struct ppc_thread_state             *state
 203 )
 204 {
 205     struct ppc_thread_state     *saved_state;
 206
 207     saved_state = kdp.saved_state;
 208
 209     saved_state->srr0   = state->srr0;
 210     saved_state->srr1   = state->srr1;
 211     saved_state->r0     = state->r0;
 212     saved_state->r1     = state->r1;
 213     saved_state->r2     = state->r2;
 214     saved_state->r3     = state->r3;
 215     saved_state->r4     = state->r4;
 216     saved_state->r5     = state->r5;
 217     saved_state->r6     = state->r6;
 218     saved_state->r7     = state->r7;
 219     saved_state->r8     = state->r8;
 220     saved_state->r9     = state->r9;
 221     saved_state->r10    = state->r10;
 222     saved_state->r11    = state->r11;
 223     saved_state->r12    = state->r12;
 224     saved_state->r13    = state->r13;
 225     saved_state->r14    = state->r14;
 226     saved_state->r15    = state->r15;
 227     saved_state->r16    = state->r16;
 228     saved_state->r17    = state->r17;
 229     saved_state->r18    = state->r18;
 230     saved_state->r19    = state->r19;
 231     saved_state->r20    = state->r20;
 232     saved_state->r21    = state->r21;
 233     saved_state->r22    = state->r22;
 234     saved_state->r23    = state->r23;
 235     saved_state->r24    = state->r24;
 236     saved_state->r25    = state->r25;
 237     saved_state->r26    = state->r26;
 238     saved_state->r27    = state->r27;
 239     saved_state->r28    = state->r28;
 240     saved_state->r29    = state->r29;
 241     saved_state->r30    = state->r30;
 242     saved_state->r31    = state->r31;
 243     saved_state->cr     = state->cr;
 244     saved_state->xer    = state->xer;
 245     saved_state->lr     = state->lr;
 246     saved_state->ctr    = state->ctr;
 247     saved_state->mq     = state->mq; /* BOGUS! (601)ONLY */
 248 }
 249
 250 kdp_error_t
 251 kdp_machine_write_regs(
 252     unsigned int cpu,
 253     unsigned int flavor,
 254     char *data,
 255     int *size
 256 )
 257 {
 258     switch (flavor) {
 259
 260     case PPC_THREAD_STATE:
 261                 dprintf(("kdp_writeregs THREAD_STATE\n"));
 262                 kdp_setintegerstate((struct ppc_thread_state *)data);
 263
 264 #if KDP_TEST_HARNESS
 265                 DumpTheSave((struct savearea *)data);           /* (TEST/DEBUG) */
 266 #endif
 267                 return KDPERR_NO_ERROR;
 268
 269     case PPC_FLOAT_STATE:
 270                 dprintf(("kdp_writeregs THREAD_FPSTATE\n"));
 271                 return KDPERR_NO_ERROR;
 272
 273     default:
 274                 dprintf(("kdp_writeregs bad flavor %d\n"));
 275                 return KDPERR_BADFLAVOR;
 276     }
 277 }
 278
 279 void
 280 kdp_machine_hostinfo(
 281     kdp_hostinfo_t *hostinfo
 282 )
 283 {
 284     machine_slot_t      m;
 285     int                 i;
 286
 287     hostinfo->cpus_mask = 0;
 288
 289     for (i = 0; i < machine_info.max_cpus; i++) {
 290         m = &machine_slot[i];
 291         if (!m->is_cpu)
 292             continue;
 293
 294         hostinfo->cpus_mask |= (1 << i);
 295         if (hostinfo->cpu_type == 0) {
 296             hostinfo->cpu_type = m->cpu_type;
 297             hostinfo->cpu_subtype = m->cpu_subtype;
 298         }
 299     }
 300 }
 301
 302 void
 303 kdp_panic(
 304     const char          *msg
 305 )
 306 {
 307     printf("kdp panic: %s\n", msg);
 308     while(1) {}
 309 }
 310
 311
 312 void
 313 kdp_reboot(void)
 314 {
 315         halt_all_cpus(TRUE);;
 316 }
 317
 318 int
 319 kdp_intr_disbl(void)
 320 {
 321     return (splhigh());
 322 }
 323
 324 void
 325 kdp_intr_enbl(int s)
 326 {
 327     splx(s);
 328 }
 329
 330 void
 331 kdp_us_spin(int usec)
 332 {
 333     extern void delay(int);
 334
 335     delay(usec/100);
 336 }
 337
 338 void print_saved_state(void *state)
 339 {
 340     struct ppc_thread_state     *saved_state;
 341
 342     saved_state = state;
 343
 344         printf("pc = 0x%x\n", saved_state->srr0);
 345         printf("msr = 0x%x\n", saved_state->srr1);
 346         printf("rp = 0x%x\n", saved_state->lr);
 347         printf("sp = 0x%x\n", saved_state->r1);
 348
 349 }
 350
 351 void
 352 kdp_call()
 353 {
 354         Debugger("inline call to debugger(machine_startup)");
 355 }
 356
 357 /*
 358  * table to convert system specific code to generic codes for kdb
 359  */
 360 int kdp_trap_codes[] = {
 361         EXC_BAD_ACCESS, /* 0x0000  INVALID EXCEPTION */
 362         EXC_BAD_ACCESS, /* 0x0100  System reset */
 363         EXC_BAD_ACCESS, /* 0x0200  Machine check */
 364         EXC_BAD_ACCESS, /* 0x0300  Data access */
 365         EXC_BAD_ACCESS, /* 0x0400  Instruction access */
 366         EXC_BAD_ACCESS, /* 0x0500  External interrupt */
 367         EXC_BAD_ACCESS, /* 0x0600  Alignment */
 368         EXC_BREAKPOINT, /* 0x0700  Program - fp exc, ill/priv instr, trap */
 369         EXC_ARITHMETIC, /* 0x0800  Floating point disabled */
 370         EXC_SOFTWARE,   /* 0x0900  Decrementer */
 371         EXC_BAD_ACCESS, /* 0x0A00  I/O controller interface */
 372         EXC_BAD_ACCESS, /* 0x0B00  INVALID EXCEPTION */
 373         EXC_SOFTWARE,   /* 0x0C00  System call exception */
 374         EXC_BREAKPOINT, /* 0x0D00  Trace */
 375         EXC_SOFTWARE,   /* 0x0E00  FP assist */
 376         EXC_SOFTWARE,   /* 0x0F00  Performance monitoring */
 377         EXC_ARITHMETIC, /* 0x0F20  Altivec disabled */
 378         EXC_BAD_ACCESS, /* 0x1000  Instruction PTE miss */
 379         EXC_BAD_ACCESS, /* 0x1100  Data load PTE miss */
 380         EXC_BAD_ACCESS, /* 0x1200  Data store PTE miss */
 381         EXC_BREAKPOINT, /* 0x1300  Instruction bkpt */
 382         EXC_SOFTWARE,   /* 0x1400  System management */
 383         EXC_BAD_ACCESS, /* 0x1500  INVALID EXCEPTION */
 384         EXC_ARITHMETIC, /* 0x1600  Altivec Assist */
 385         EXC_BAD_ACCESS, /* 0x1700  INVALID EXCEPTION */
 386         EXC_BAD_ACCESS, /* 0x1800  INVALID EXCEPTION */
 387         EXC_BAD_ACCESS, /* 0x1900  INVALID EXCEPTION */
 388         EXC_BAD_ACCESS, /* 0x1A00  INVALID EXCEPTION */
 389         EXC_BAD_ACCESS, /* 0x1B00  INVALID EXCEPTION */
 390         EXC_BAD_ACCESS, /* 0x1C00  INVALID EXCEPTION */
 391         EXC_BAD_ACCESS, /* 0x1D00  INVALID EXCEPTION */
 392         EXC_BAD_ACCESS, /* 0x1E00  INVALID EXCEPTION */
 393         EXC_BAD_ACCESS, /* 0x1F00  INVALID EXCEPTION */
 394         EXC_BREAKPOINT, /* 0x2000  Run Mode/Trace */
 395         EXC_BAD_ACCESS, /* 0x2100  INVALID EXCEPTION */
 396         EXC_BAD_ACCESS, /* 0x2200  INVALID EXCEPTION */
 397         EXC_BAD_ACCESS, /* 0x2300  INVALID EXCEPTION */
 398         EXC_BAD_ACCESS, /* 0x2400  INVALID EXCEPTION */
 399         EXC_BAD_ACCESS, /* 0x2500  INVALID EXCEPTION */
 400         EXC_BAD_ACCESS, /* 0x2600  INVALID EXCEPTION */
 401         EXC_BAD_ACCESS, /* 0x2700  INVALID EXCEPTION */
 402         EXC_BAD_ACCESS, /* 0x2800  INVALID EXCEPTION */
 403         EXC_BAD_ACCESS, /* 0x2900  INVALID EXCEPTION */
 404         EXC_BAD_ACCESS, /* 0x2A00  INVALID EXCEPTION */
 405         EXC_BAD_ACCESS, /* 0x2B00  INVALID EXCEPTION */
 406         EXC_BAD_ACCESS, /* 0x2C00  INVALID EXCEPTION */
 407         EXC_BAD_ACCESS, /* 0x2D00  INVALID EXCEPTION */
 408         EXC_BAD_ACCESS, /* 0x2E00  INVALID EXCEPTION */
 409         EXC_BAD_ACCESS, /* 0x2F00  INVALID EXCEPTION */
 410         EXC_SOFTWARE    /* 0x3000  AST trap (software) */
 411 };
 412
 413 int
 414 kdp_getc()
 415 {
 416         return(cnmaygetc());
 417 }
 418
 419 int kdp_backtrace;
 420 int kdp_sr_dump;
 421 int kdp_dabr;
 422 int kdp_noisy;
 423
 424 #define kdp_code(x) kdp_trap_codes[((x)==T_AST?0x31:(x)/T_VECTOR_SIZE)]
 425
 426 void
 427 kdp_trap(
 428     unsigned int                exception,
 429     struct ppc_thread_state     *saved_state
 430 )
 431 {
 432         unsigned int *fp;
 433         unsigned int register sp;
 434         struct ppc_thread_state *state;
 435
 436         if (kdp_noisy) {
 437                 if (kdp_backtrace) {
 438                         printf("\nvector=%x, \n", exception/4);
 439 #ifdef XXX
 440                         regDump(saved_state);
 441 #endif
 442                         sp = saved_state->r1;
 443                         printf("stack backtrace - sp(%x)  ", sp);
 444                         fp = (unsigned int *) *((unsigned int *)sp);
 445                         while (fp) {
 446                                 printf("0x%08x ", fp[2]);
 447                                 fp = (unsigned int *)*fp;
 448                         }
 449                         printf("\n");
 450                 }
 451 #ifdef XXX
 452                 if (kdp_sr_dump) {
 453                         dump_segment_registers();
 454                 }
 455 #endif
 456
 457         printf("vector=%d  ", exception/4);
 458         }
 459
 460         kdp_raise_exception(kdp_code(exception), 0, 0, saved_state);
 461
 462         if (kdp_noisy)
 463                 printf("kdp_trap: kdp_raise_exception() ret\n");
 464
 465         if (*((int *)saved_state->srr0) == 0x7c800008)
 466                 saved_state->srr0 += 4; /* BKPT_SIZE */
 467
 468         if(saved_state->srr1 & (MASK(MSR_SE) | MASK(MSR_BE))) { /* Are we just stepping or continuing */
 469                 db_run_mode = STEP_ONCE;                                /* We are stepping */
 470         }
 471         else db_run_mode = STEP_CONTINUE;                       /* Otherwise we are continuing */
 472
 473
 474 #ifdef XXX
 475         mtspr(dabr, kdp_dabr);
 476 #endif
 477 }
 478
 479 boolean_t
 480 kdp_call_kdb(
 481         void)
 482 {
 483         switch_debugger=1;
 484         return(TRUE);
 485 }
 486
 487 void kdp_print_registers(struct ppc_saved_state *state)
 488 {
 489         int i;
 490         for (i=0; i<32; i++) {
 491                 if ((i % 8) == 0)
 492                         printf("\n%4d :",i);
 493                         printf(" %08x",*(&state->r0+i));
 494         }
 495         printf("\n");
 496         printf("cr        = 0x%08x\t\t",state->cr);
 497         printf("xer       = 0x%08x\n",state->xer);
 498         printf("lr        = 0x%08x\t\t",state->lr);
 499         printf("ctr       = 0x%08x\n",state->ctr);
 500         printf("srr0(iar) = 0x%08x\t\t",state->srr0);
 501         printf("srr1(msr) = 0x%08B\n",state->srr1,
 502                 "\x10\x11""EE\x12PR\x13""FP\x14ME\x15""FE0\x16SE\x18"
 503                 "FE1\x19""AL\x1a""EP\x1bIT\x1c""DT");
 504         printf("mq        = 0x%08x\t\t",state->mq);
 505         printf("sr_copyin = 0x%08x\n",state->sr_copyin);
 506         printf("\n");
 507 }
 508
 509 void
 510 kdp_print_backtrace(
 511     unsigned int                exception,
 512     struct ppc_saved_state     *saved_state)
 513 {
 514         extern void kdp_print_registers(struct ppc_saved_state *);
 515         extern void print_backtrace(struct ppc_saved_state *);
 516         extern unsigned int debug_mode, disableDebugOuput;
 517
 518         disableDebugOuput = FALSE;
 519         debug_mode = TRUE;
 520         printf("re-entering kdp:\n");
 521         printf("vector=%x, \n", exception/4);
 522         kdp_print_registers(saved_state);
 523         print_backtrace(saved_state);
 524         printf("panic: We are hanging here...\n");
 525         while(1);
 526 }