common/kgdb.c

   1 /* taken from arch/powerpc/kernel/ppc-stub.c */
   2
   3 /****************************************************************************
   4
   5                 THIS SOFTWARE IS NOT COPYRIGHTED
   6
   7    HP offers the following for use in the public domain.  HP makes no
   8    warranty with regard to the software or its performance and the
   9    user accepts the software "AS IS" with all faults.
  10
  11    HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
  12    TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  13    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  14
  15 ****************************************************************************/
  16
  17 /****************************************************************************
  18  *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
  19  *
  20  *  Module name: remcom.c $
  21  *  Revision: 1.34 $
  22  *  Date: 91/03/09 12:29:49 $
  23  *  Contributor:     Lake Stevens Instrument Division$
  24  *
  25  *  Description:     low level support for gdb debugger. $
  26  *
  27  *  Considerations:  only works on target hardware $
  28  *
  29  *  Written by:      Glenn Engel $
  30  *  ModuleState:     Experimental $
  31  *
  32  *  NOTES:           See Below $
  33  *
  34  *  Modified for SPARC by Stu Grossman, Cygnus Support.
  35  *
  36  *  This code has been extensively tested on the Fujitsu SPARClite demo board.
  37  *
  38  *  To enable debugger support, two things need to happen.  One, a
  39  *  call to set_debug_traps() is necessary in order to allow any breakpoints
  40  *  or error conditions to be properly intercepted and reported to gdb.
  41  *  Two, a breakpoint needs to be generated to begin communication.  This
  42  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
  43  *  simulates a breakpoint by executing a trap #1.
  44  *
  45  *************
  46  *
  47  *    The following gdb commands are supported:
  48  *
  49  * command          function                               Return value
  50  *
  51  *    g             return the value of the CPU registers  hex data or ENN
  52  *    G             set the value of the CPU registers     OK or ENN
  53  *    qOffsets      Get section offsets.  Reply is Text=xxx;Data=yyy;Bss=zzz
  54  *
  55  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
  56  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
  57  *
  58  *    c             Resume at current address              SNN   ( signal NN)
  59  *    cAA..AA       Continue at address AA..AA             SNN
  60  *
  61  *    s             Step one instruction                   SNN
  62  *    sAA..AA       Step one instruction from AA..AA       SNN
  63  *
  64  *    k             kill
  65  *
  66  *    ?             What was the last sigval ?             SNN   (signal NN)
  67  *
  68  *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
  69  *                                                         baud rate
  70  *
  71  * All commands and responses are sent with a packet which includes a
  72  * checksum.  A packet consists of
  73  *
  74  * $<packet info>#<checksum>.
  75  *
  76  * where
  77  * <packet info> :: <characters representing the command or response>
  78  * <checksum>    :: <two hex digits computed as modulo 256 sum of <packetinfo>>
  79  *
  80  * When a packet is received, it is first acknowledged with either '+' or '-'.
  81  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
  82  *
  83  * Example:
  84  *
  85  * Host:                  Reply:
  86  * $m0,10#2a               +$00010203040506070809101112131415#42
  87  *
  88  ****************************************************************************/
  89
  90 #include <common.h>
  91
  92 #include <kgdb.h>
  93 #include <command.h>
  94
  95 #undef KGDB_DEBUG
  96
  97 /*
  98  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
  99  */
 100 #define BUFMAX 1024
 101 static char remcomInBuffer[BUFMAX];
 102 static char remcomOutBuffer[BUFMAX];
 103 static char remcomRegBuffer[BUFMAX];
 104
 105 static int initialized = 0;
 106 static int kgdb_active;
 107 static struct pt_regs entry_regs;
 108 static long error_jmp_buf[BUFMAX/2];
 109 static int longjmp_on_fault = 0;
 110 #ifdef KGDB_DEBUG
 111 static int kdebug = 1;
 112 #endif
 113
 114 static const char hexchars[]="0123456789abcdef";
 115
 116 /* Convert ch from a hex digit to an int */
 117 static int
 118 hex(unsigned char ch)
 119 {
 120         if (ch >= 'a' && ch <= 'f')
 121                 return ch-'a'+10;
 122         if (ch >= '0' && ch <= '9')
 123                 return ch-'0';
 124         if (ch >= 'A' && ch <= 'F')
 125                 return ch-'A'+10;
 126         return -1;
 127 }
 128
 129 /* Convert the memory pointed to by mem into hex, placing result in buf.
 130  * Return a pointer to the last char put in buf (null).
 131  */
 132 static unsigned char *
 133 mem2hex(char *mem, char *buf, int count)
 134 {
 135         char *tmp;
 136         unsigned char ch;
 137
 138         /*
 139          * We use the upper half of buf as an intermediate buffer for the
 140          * raw memory copy.  Hex conversion will work against this one.
 141          */
 142         tmp = buf + count;
 143         longjmp_on_fault = 1;
 144
 145         memcpy(tmp, mem, count);
 146
 147         while (count-- > 0) {
 148                 ch = *tmp++;
 149                 *buf++ = hexchars[ch >> 4];
 150                 *buf++ = hexchars[ch & 0xf];
 151         }
 152         *buf = 0;
 153         longjmp_on_fault = 0;
 154         return (unsigned char *)buf;
 155 }
 156
 157 /* convert the hex array pointed to by buf into binary to be placed in mem
 158  * return a pointer to the character AFTER the last byte fetched from buf.
 159 */
 160 static char *
 161 hex2mem(char *buf, char *mem, int count)
 162 {
 163         int hexValue;
 164         char *tmp_raw, *tmp_hex;
 165
 166         /*
 167          * We use the upper half of buf as an intermediate buffer for the
 168          * raw memory that is converted from hex.
 169          */
 170         tmp_raw = buf + count * 2;
 171         tmp_hex = tmp_raw - 1;
 172
 173         longjmp_on_fault = 1;
 174         while (tmp_hex >= buf) {
 175                 tmp_raw--;
 176                 hexValue = hex(*tmp_hex--);
 177                 if (hexValue < 0)
 178                         kgdb_error(KGDBERR_NOTHEXDIG);
 179                 *tmp_raw = hexValue;
 180                 hexValue = hex(*tmp_hex--);
 181                 if (hexValue < 0)
 182                         kgdb_error(KGDBERR_NOTHEXDIG);
 183                 *tmp_raw |= hexValue << 4;
 184
 185         }
 186
 187         memcpy(mem, tmp_raw, count);
 188
 189         kgdb_flush_cache_range((void *)mem, (void *)(mem+count));
 190         longjmp_on_fault = 0;
 191
 192         return buf;
 193 }
 194
 195 /*
 196  * While we find nice hex chars, build an int.
 197  * Return number of chars processed.
 198  */
 199 static int
 200 hexToInt(char **ptr, int *intValue)
 201 {
 202         int numChars = 0;
 203         int hexValue;
 204
 205         *intValue = 0;
 206
 207         longjmp_on_fault = 1;
 208         while (**ptr) {
 209                 hexValue = hex(**ptr);
 210                 if (hexValue < 0)
 211                         break;
 212
 213                 *intValue = (*intValue << 4) | hexValue;
 214                 numChars ++;
 215
 216                 (*ptr)++;
 217         }
 218         longjmp_on_fault = 0;
 219
 220         return (numChars);
 221 }
 222
 223 /* scan for the sequence $<data>#<checksum>     */
 224 static void
 225 getpacket(char *buffer)
 226 {
 227         unsigned char checksum;
 228         unsigned char xmitcsum;
 229         int i;
 230         int count;
 231         unsigned char ch;
 232
 233         do {
 234                 /* wait around for the start character, ignore all other
 235                  * characters */
 236                 while ((ch = (getDebugChar() & 0x7f)) != '$') {
 237 #ifdef KGDB_DEBUG
 238                         if (kdebug)
 239                                 putc(ch);
 240 #endif
 241                         ;
 242                 }
 243
 244                 checksum = 0;
 245                 xmitcsum = -1;
 246
 247                 count = 0;
 248
 249                 /* now, read until a # or end of buffer is found */
 250                 while (count < BUFMAX) {
 251                         ch = getDebugChar() & 0x7f;
 252                         if (ch == '#')
 253                                 break;
 254                         checksum = checksum + ch;
 255                         buffer[count] = ch;
 256                         count = count + 1;
 257                 }
 258
 259                 if (count >= BUFMAX)
 260                         continue;
 261
 262                 buffer[count] = 0;
 263
 264                 if (ch == '#') {
 265                         xmitcsum = hex(getDebugChar() & 0x7f) << 4;
 266                         xmitcsum |= hex(getDebugChar() & 0x7f);
 267                         if (checksum != xmitcsum)
 268                                 putDebugChar('-');      /* failed checksum */
 269                         else {
 270                                 putDebugChar('+'); /* successful transfer */
 271                                 /* if a sequence char is present, reply the ID */
 272                                 if (buffer[2] == ':') {
 273                                         putDebugChar(buffer[0]);
 274                                         putDebugChar(buffer[1]);
 275                                         /* remove sequence chars from buffer */
 276                                         count = strlen(buffer);
 277                                         for (i=3; i <= count; i++)
 278                                                 buffer[i-3] = buffer[i];
 279                                 }
 280                         }
 281                 }
 282         } while (checksum != xmitcsum);
 283 }
 284
 285 /* send the packet in buffer.  */
 286 static void
 287 putpacket(unsigned char *buffer)
 288 {
 289         unsigned char checksum;
 290         int count;
 291         unsigned char ch, recv;
 292
 293         /*  $<packet info>#<checksum>. */
 294         do {
 295                 putDebugChar('$');
 296                 checksum = 0;
 297                 count = 0;
 298
 299                 while ((ch = buffer[count])) {
 300                         putDebugChar(ch);
 301                         checksum += ch;
 302                         count += 1;
 303                 }
 304
 305                 putDebugChar('#');
 306                 putDebugChar(hexchars[checksum >> 4]);
 307                 putDebugChar(hexchars[checksum & 0xf]);
 308                 recv = getDebugChar();
 309         } while ((recv & 0x7f) != '+');
 310 }
 311
 312 /*
 313  * This function does all command processing for interfacing to gdb.
 314  */
 315 static int
 316 handle_exception (struct pt_regs *regs)
 317 {
 318         int addr;
 319         int length;
 320         char *ptr;
 321         kgdb_data kd;
 322         int i;
 323
 324         if (!initialized) {
 325                 printf("kgdb: exception before kgdb is initialized! huh?\n");
 326                 return (0);
 327         }
 328
 329         /* probably should check which exception occurred as well */
 330         if (longjmp_on_fault) {
 331                 longjmp_on_fault = 0;
 332                 kgdb_longjmp(error_jmp_buf, KGDBERR_MEMFAULT);
 333                 panic("kgdb longjump failed!\n");
 334         }
 335
 336         if (kgdb_active) {
 337                 printf("kgdb: unexpected exception from within kgdb\n");
 338                 return (0);
 339         }
 340         kgdb_active = 1;
 341
 342         kgdb_interruptible(0);
 343
 344         printf("kgdb: handle_exception; trap [0x%x]\n", kgdb_trap(regs));
 345
 346         if (kgdb_setjmp(error_jmp_buf) != 0)
 347                 panic("kgdb: error or fault in entry init!\n");
 348
 349         kgdb_enter(regs, &kd);
 350
 351         entry_regs = *regs;
 352
 353         ptr = remcomOutBuffer;
 354
 355         *ptr++ = 'T';
 356
 357         *ptr++ = hexchars[kd.sigval >> 4];
 358         *ptr++ = hexchars[kd.sigval & 0xf];
 359
 360         for (i = 0; i < kd.nregs; i++) {
 361                 kgdb_reg *rp = &kd.regs[i];
 362
 363                 *ptr++ = hexchars[rp->num >> 4];
 364                 *ptr++ = hexchars[rp->num & 0xf];
 365                 *ptr++ = ':';
 366                 ptr = (char *)mem2hex((char *)&rp->val, ptr, 4);
 367                 *ptr++ = ';';
 368         }
 369
 370         *ptr = 0;
 371
 372 #ifdef KGDB_DEBUG
 373         if (kdebug)
 374                 printf("kgdb: remcomOutBuffer: %s\n", remcomOutBuffer);
 375 #endif
 376
 377         putpacket((unsigned char *)&remcomOutBuffer);
 378
 379         while (1) {
 380                 volatile int errnum;
 381
 382                 remcomOutBuffer[0] = 0;
 383
 384                 getpacket(remcomInBuffer);
 385                 ptr = &remcomInBuffer[1];
 386
 387 #ifdef KGDB_DEBUG
 388                 if (kdebug)
 389                         printf("kgdb:  remcomInBuffer: %s\n", remcomInBuffer);
 390 #endif
 391
 392                 errnum = kgdb_setjmp(error_jmp_buf);
 393
 394                 if (errnum == 0) switch (remcomInBuffer[0]) {
 395
 396                 case '?':               /* report most recent signal */
 397                         remcomOutBuffer[0] = 'S';
 398                         remcomOutBuffer[1] = hexchars[kd.sigval >> 4];
 399                         remcomOutBuffer[2] = hexchars[kd.sigval & 0xf];
 400                         remcomOutBuffer[3] = 0;
 401                         break;
 402
 403 #ifdef KGDB_DEBUG
 404                 case 'd':
 405                         /* toggle debug flag */
 406                         kdebug ^= 1;
 407                         break;
 408 #endif
 409
 410                 case 'g':       /* return the value of the CPU registers. */
 411                         length = kgdb_getregs(regs, remcomRegBuffer, BUFMAX);
 412                         mem2hex(remcomRegBuffer, remcomOutBuffer, length);
 413                         break;
 414
 415                 case 'G':   /* set the value of the CPU registers */
 416                         length = strlen(ptr);
 417                         if ((length & 1) != 0) kgdb_error(KGDBERR_BADPARAMS);
 418                         hex2mem(ptr, remcomRegBuffer, length/2);
 419                         kgdb_putregs(regs, remcomRegBuffer, length/2);
 420                         strcpy(remcomOutBuffer,"OK");
 421                         break;
 422
 423                 case 'm':       /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 424                                 /* Try to read %x,%x.  */
 425
 426                         if (hexToInt(&ptr, &addr)
 427                             && *ptr++ == ','
 428                             && hexToInt(&ptr, &length)) {
 429                                 mem2hex((char *)addr, remcomOutBuffer, length);
 430                         } else {
 431                                 kgdb_error(KGDBERR_BADPARAMS);
 432                         }
 433                         break;
 434
 435                 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 436                         /* Try to read '%x,%x:'.  */
 437
 438                         if (hexToInt(&ptr, &addr)
 439                             && *ptr++ == ','
 440                             && hexToInt(&ptr, &length)
 441                             && *ptr++ == ':') {
 442                                 hex2mem(ptr, (char *)addr, length);
 443                                 strcpy(remcomOutBuffer, "OK");
 444                         } else {
 445                                 kgdb_error(KGDBERR_BADPARAMS);
 446                         }
 447                         break;
 448
 449
 450                 case 'k':    /* kill the program, actually return to monitor */
 451                         kd.extype = KGDBEXIT_KILL;
 452                         *regs = entry_regs;
 453                         goto doexit;
 454
 455                 case 'C':    /* CSS  continue with signal SS */
 456                         *ptr = '\0';    /* ignore the signal number for now */
 457                         /* fall through */
 458
 459                 case 'c':    /* cAA..AA  Continue; address AA..AA optional */
 460                         /* try to read optional parameter, pc unchanged if no parm */
 461                         kd.extype = KGDBEXIT_CONTINUE;
 462
 463                         if (hexToInt(&ptr, &addr)) {
 464                                 kd.exaddr = addr;
 465                                 kd.extype |= KGDBEXIT_WITHADDR;
 466                         }
 467
 468                         goto doexit;
 469
 470                 case 'S':    /* SSS  single step with signal SS */
 471                         *ptr = '\0';    /* ignore the signal number for now */
 472                         /* fall through */
 473
 474                 case 's':
 475                         kd.extype = KGDBEXIT_SINGLE;
 476
 477                         if (hexToInt(&ptr, &addr)) {
 478                                 kd.exaddr = addr;
 479                                 kd.extype |= KGDBEXIT_WITHADDR;
 480                         }
 481
 482                 doexit:
 483 /* Need to flush the instruction cache here, as we may have deposited a
 484  * breakpoint, and the icache probably has no way of knowing that a data ref to
 485  * some location may have changed something that is in the instruction cache.
 486  */
 487                         kgdb_flush_cache_all();
 488                         kgdb_exit(regs, &kd);
 489                         kgdb_active = 0;
 490                         kgdb_interruptible(1);
 491                         return (1);
 492
 493                 case 'r':               /* Reset (if user process..exit ???)*/
 494                         panic("kgdb reset.");
 495                         break;
 496
 497                 case 'P':    /* Pr=v  set reg r to value v (r and v are hex) */
 498                         if (hexToInt(&ptr, &addr)
 499                             && *ptr++ == '='
 500                             && ((length = strlen(ptr)) & 1) == 0) {
 501                                 hex2mem(ptr, remcomRegBuffer, length/2);
 502                                 kgdb_putreg(regs, addr,
 503                                         remcomRegBuffer, length/2);
 504                                 strcpy(remcomOutBuffer,"OK");
 505                         } else {
 506                                 kgdb_error(KGDBERR_BADPARAMS);
 507                         }
 508                         break;
 509                 }                       /* switch */
 510
 511                 if (errnum != 0)
 512                         sprintf(remcomOutBuffer, "E%02d", errnum);
 513
 514 #ifdef KGDB_DEBUG
 515                 if (kdebug)
 516                         printf("kgdb: remcomOutBuffer: %s\n", remcomOutBuffer);
 517 #endif
 518
 519                 /* reply to the request */
 520                 putpacket((unsigned char *)&remcomOutBuffer);
 521
 522         } /* while(1) */
 523 }
 524
 525 /*
 526  * kgdb_init must be called *after* the
 527  * monitor is relocated into ram
 528  */
 529 void
 530 kgdb_init(void)
 531 {
 532         kgdb_serial_init();
 533         debugger_exception_handler = handle_exception;
 534         initialized = 1;
 535
 536         putDebugStr("kgdb ready\n");
 537         puts("ready\n");
 538 }
 539
 540 void
 541 kgdb_error(int errnum)
 542 {
 543         longjmp_on_fault = 0;
 544         kgdb_longjmp(error_jmp_buf, errnum);
 545         panic("kgdb_error: longjmp failed!\n");
 546 }
 547
 548 /* Output string in GDB O-packet format if GDB has connected. If nothing
 549    output, returns 0 (caller must then handle output). */
 550 int
 551 kgdb_output_string (const char* s, unsigned int count)
 552 {
 553         char buffer[512];
 554
 555         count = (count <= (sizeof(buffer) / 2 - 2))
 556                 ? count : (sizeof(buffer) / 2 - 2);
 557
 558         buffer[0] = 'O';
 559         mem2hex ((char *)s, &buffer[1], count);
 560         putpacket((unsigned char *)&buffer);
 561
 562         return 1;
 563 }
 564
 565 void
 566 breakpoint(void)
 567 {
 568         if (!initialized) {
 569                 printf("breakpoint() called b4 kgdb init\n");
 570                 return;
 571         }
 572
 573         kgdb_breakpoint(0, 0);
 574 }
 575
 576 int
 577 do_kgdb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 578 {
 579     printf("Entering KGDB mode via exception handler...\n\n");
 580     kgdb_breakpoint(argc - 1, argv + 1);
 581     printf("\nReturned from KGDB mode\n");
 582     return 0;
 583 }
 584
 585 U_BOOT_CMD(
 586         kgdb, CONFIG_SYS_MAXARGS, 1,    do_kgdb,
 587         "enter gdb remote debug mode",
 588         "[arg0 arg1 .. argN]\n"
 589         "    - executes a breakpoint so that kgdb mode is\n"
 590         "      entered via the exception handler. To return\n"
 591         "      to the monitor, the remote gdb debugger must\n"
 592         "      execute a \"continue\" or \"quit\" command.\n"
 593         "\n"
 594         "      if a program is loaded by the remote gdb, any args\n"
 595         "      passed to the kgdb command are given to the loaded\n"
 596         "      program if it is executed (see the \"hello_world\"\n"
 597         "      example program in the U-Boot examples directory)."
 598 );