kernel/gdb.c

   1 /*
   2 ** Copyright 2002, Manuel J. Petit. All rights reserved.
   3 ** Distributed under the terms of the NewOS License.
   4 */
   5 #include <string.h>
   6 #include <stdarg.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <kernel/vm.h>
  10 #include <kernel/smp.h>
  11 #include <kernel/debug.h>
  12 #include <kernel/gdb.h>
  13 #include <kernel/arch/dbg_console.h>
  14
  15
  16 enum { INIT= 0, CMDREAD, CKSUM1, CKSUM2, WAITACK, QUIT, GDBSTATES };
  17
  18
  19 static char cmd[512];
  20 static int  cmd_ptr;
  21 static int  checksum;
  22
  23 static char reply[512];
  24
  25 static char safe_mem[512];
  26
  27
  28 /*
  29  * utility functions
  30  */
  31 static
  32 int
  33 htons(short value)
  34 {
  35         return ((value>>8)&0xff) | ((value&0xff)<<8);
  36 }
  37
  38 static
  39 int
  40 htonl(int value)
  41 {
  42         return htons((value>>16)&0xffff) | (htons(value&0xffff)<<16);
  43 }
  44
  45 static
  46 int
  47 parse_nibble(int input)
  48 {
  49         int nibble= 0xff;
  50
  51         if((input>= '0') && (input<= '9')) {
  52                 nibble= input-'0';
  53         }
  54         if((input>= 'A') && (input<= 'F')) {
  55                 nibble= 0x0a+(input-'A');
  56         }
  57         if((input>= 'a') && (input<= 'f')) {
  58                 nibble= 0x0a+(input-'a');
  59         }
  60
  61         return nibble;
  62 }
  63
  64
  65
  66 /*
  67  * GDB protocol ACK & NAK & Reply
  68  *
  69  */
  70 static
  71 void
  72 gdb_ack(void)
  73 {
  74         dbg_putch('+');
  75 }
  76
  77 static
  78 void
  79 gdb_nak(void)
  80 {
  81         dbg_putch('-');
  82 }
  83
  84 static
  85 void
  86 gdb_resend_reply(void)
  87 {
  88         dbg_puts(reply);
  89 }
  90
  91 static
  92 void
  93 gdb_reply(char const *fmt, ...)
  94 {
  95         int i;
  96         int len;
  97         int sum;
  98         va_list args;
  99
 100         va_start(args, fmt);
 101         reply[0]= '$';
 102         vsprintf(reply+1, fmt, args);
 103         va_end(args);
 104
 105         len= strlen(reply);
 106         sum= 0;
 107         for(i= 1; i< len; i++) {
 108                 sum+= reply[i];
 109         }
 110         sum%= 256;
 111
 112         sprintf(reply+len, "#%02x", sum);
 113
 114         gdb_resend_reply();
 115 }
 116
 117 static
 118 void
 119 gdb_regreply(int const *regs, int numregs)
 120 {
 121         int i;
 122         int len;
 123         int sum;
 124
 125         reply[0]= '$';
 126         for(i= 0; i< numregs; i++) {
 127                 sprintf(reply+1+8*i, "%08x", htonl(regs[i]));
 128         }
 129
 130         len= strlen(reply);
 131         sum= 0;
 132         for(i= 1; i< len; i++) {
 133                 sum+= reply[i];
 134         }
 135         sum%= 256;
 136
 137         sprintf(reply+len, "#%02x", sum);
 138
 139         gdb_resend_reply();
 140 }
 141
 142 static
 143 void
 144 gdb_memreply(char const *bytes, int numbytes)
 145 {
 146         int i;
 147         int len;
 148         int sum;
 149
 150         reply[0]= '$';
 151         for(i= 0; i< numbytes; i++) {
 152                 sprintf(reply+1+2*i, "%02x", (unsigned char)bytes[i]);
 153         }
 154
 155         len= strlen(reply);
 156         sum= 0;
 157         for(i= 1; i< len; i++) {
 158                 sum+= reply[i];
 159         }
 160         sum%= 256;
 161
 162         sprintf(reply+len, "#%02x", sum);
 163
 164         gdb_resend_reply();
 165 }
 166
 167
 168
 169 /*
 170  * checksum verification
 171  */
 172 static
 173 int
 174 gdb_verify_checksum(void)
 175 {
 176         int i;
 177         int len;
 178         int sum;
 179
 180         len= strlen(cmd);
 181         sum= 0;
 182         for(i= 0; i< len; i++) {
 183                 sum+= cmd[i];
 184         }
 185         sum%= 256;
 186
 187         return (sum==checksum)?1:0;
 188 }
 189
 190
 191 /*
 192  * command parsing an dispatching
 193  */
 194 static
 195 int
 196 gdb_parse_command(unsigned int *regfile)
 197 {
 198         if(!gdb_verify_checksum()) {
 199                 gdb_nak();
 200                 return INIT;
 201         } else {
 202                 gdb_ack();
 203         }
 204
 205         switch(cmd[0]) {
 206
 207                 case 'H':
 208                         {
 209                                 /*
 210                                  * Command H (actually Hct) is used to select
 211                                  * the current thread (-1 meaning all threads)
 212                                  * We just fake we recognize the the command
 213                                  * and send an 'OK' response.
 214                                  */
 215                                 gdb_reply("OK");
 216                         } break;
 217
 218                 case 'q':
 219                         {
 220                                 extern unsigned __data_start;
 221                                 extern unsigned __bss_start;
 222
 223                                 /*
 224                                  * There are several q commands:
 225                                  *
 226                                  *     qXXXX        Request info about XXXX.
 227                                  *     QXXXX=yyyy   Set value of XXXX to yyyy.
 228                                  *     qOffsets     Get segment offsets
 229                                  *
 230                                  * Currently we only support the 'qOffsets'
 231                                  * form.
 232                                  *
 233                                  * *Note* that we actually have to lie,
 234                                  * At first thought looks like we should
 235                                  * return '_start', '__data_start' &
 236                                  * '__bss_start', however gdb gets
 237                                  * confused because the kernel link script
 238                                  * pre-links at 0x80000000. To keep gdb
 239                                  * gdb happy we just substract that amount.
 240                                  */
 241                                 if(strcmp(cmd+1, "Offsets")== 0) {
 242                                         gdb_reply(
 243                                                 "Text=%x;Data=%x;Bss=%x",
 244                                                 0,
 245                                                 ((unsigned)(&__data_start))-0x80000000,
 246                                                 ((unsigned)(&__bss_start))-0x80000000
 247                                         );
 248                                 } else {
 249                                         gdb_reply("ENS");
 250                                 }
 251                         } break;
 252
 253                 case '?':
 254                         {
 255                                 /*
 256                                  * command '?' is used for retrieving the signal
 257                                  * that stopped the program. Fully implemeting
 258                                  * this command requires help from the debugger,
 259                                  * by now we just fake a SIGKILL
 260                                  */
 261                                 gdb_reply("S09");       /* SIGKILL = 9 */
 262                         } break;
 263
 264                 case 'g':
 265                         {
 266                                 /*
 267                                  * command 'g' is used for reading the register
 268                                  * file. Faked by now.
 269                                  *
 270                                  * For x86 the register order is:
 271                                  *
 272                                  *    eax, ebx, ecx, edx,
 273                                  *    esp, ebp, esi, edi,
 274                                  *    eip, eflags,
 275                                  *    cs, ss, ds, es
 276                                  *
 277                                  * Note that even thought the segment descriptors
 278                                  * are actually 16 bits wide, gdb requires them
 279                                  * as 32 bit integers. Note also that for some
 280                                  * reason (unknown to me) gdb wants the register
 281                                  * dump in *big endian* format.
 282                                  */
 283                                 gdb_regreply(regfile, GDB_REGISTER_FILE_COUNT);
 284                         } break;
 285
 286                 case 'm':
 287                         {
 288                                 char *ptr;
 289                                 unsigned address;
 290                                 unsigned len;
 291
 292                                 /*
 293                                  * The 'm' command has the form mAAA,LLL
 294                                  * where AAA is the address and LLL is the
 295                                  * number of bytes.
 296                                  */
 297                                 ptr= cmd+1;
 298                                 address= 0;
 299                                 len= 0;
 300                                 while(ptr && *ptr && (*ptr!= ',')) {
 301                                         address<<= 4;
 302                                         address+= parse_nibble(*ptr);
 303                                         ptr+= 1;
 304                                 }
 305                                 if(*ptr== ',') {
 306                                         ptr+= 1;
 307                                 }
 308                                 while(ptr && *ptr) {
 309                                         len<<= 4;
 310                                         len+= parse_nibble(*ptr);
 311                                         ptr+= 1;
 312                                 }
 313
 314                                 if(len> 128) {
 315                                         len= 128;
 316                                 }
 317
 318                                 /*
 319                                  * We cannot directly access the requested memory
 320                                  * for gdb may be trying to access an stray pointer
 321                                  * We copy the memory to a safe buffer using
 322                                  * the bulletproof user_memcpy().
 323                                  */
 324                                 if(user_memcpy(safe_mem, (char*)address, len)< 0) {
 325                                         gdb_reply("E02");
 326                                 } else {
 327                                         gdb_memreply(safe_mem, len);
 328                                 }
 329                         } break;
 330
 331                 case 'k':
 332                         {
 333                                 /*
 334                                  * Command 'k' actual semantics is 'kill the damn thing'.
 335                                  * However gdb sends that command when you disconnect
 336                                  * from a debug session. I guess that 'kill' for the
 337                                  * kernel would map to reboot... however that's a
 338                                  * a very mean thing to do, instead we just quit
 339                                  * the gdb state machine and fallback to the regular
 340                                  * kernel debugger command prompt.
 341                                  */
 342                                 return QUIT;
 343                         } break;
 344
 345                 default:
 346                         {
 347                                 gdb_reply("E01");
 348                         } break;
 349         }
 350
 351         return WAITACK;
 352 }
 353
 354
 355
 356 /*
 357  * GDB protocol state machine
 358  */
 359 static
 360 int
 361 gdb_init_handler(int input, unsigned int *regfile)
 362 {
 363         (void)(regfile);
 364
 365         switch(input) {
 366                 case '$':
 367                         memset(cmd, 0, sizeof(cmd));
 368                         cmd_ptr= 0;
 369                         return CMDREAD;
 370                 default:
 371 #if 0
 372                         gdb_nak();
 373 #else
 374                         /*
 375                          * looks to me like we should send
 376                          * a NAK here but it kinda works
 377                          * better if we just gobble all
 378                          * junk chars silently
 379                          */
 380 #endif
 381                         return INIT;
 382         }
 383 }
 384
 385 static
 386 int
 387 gdb_cmdread_handler(int input, unsigned int *regfile)
 388 {
 389         (void)(regfile);
 390
 391         switch(input) {
 392                 case '#':
 393                         return CKSUM1;
 394                 default:
 395                         cmd[cmd_ptr]= input;
 396                         cmd_ptr+= 1;
 397                         return CMDREAD;
 398         }
 399 }
 400
 401 static
 402 int
 403 gdb_cksum1_handler(int input, unsigned int *regfile)
 404 {
 405         int nibble= parse_nibble(input);
 406
 407         (void)(regfile);
 408
 409         if(nibble== 0xff) {
 410 #if 0
 411                 gdb_nak();
 412                 return INIT;
 413 #else
 414                 /*
 415                  * looks to me like we should send
 416                  * a NAK here but it kinda works
 417                  * better if we just gobble all
 418                  * junk chars silently
 419                  */
 420 #endif
 421         }
 422
 423         checksum= nibble<< 4;
 424
 425         return CKSUM2;
 426 }
 427
 428 static
 429 int
 430 gdb_cksum2_handler(int input, unsigned int *regfile)
 431 {
 432         int nibble= parse_nibble(input);
 433
 434         if(nibble== 0xff) {
 435 #if 0
 436                 gdb_nak();
 437                 return INIT;
 438 #else
 439                 /*
 440                  * looks to me like we should send
 441                  * a NAK here but it kinda works
 442                  * better if we just gobble all
 443                  * junk chars silently
 444                  */
 445 #endif
 446         }
 447
 448         checksum+= nibble;
 449
 450         return gdb_parse_command(regfile);
 451 }
 452
 453 static
 454 int
 455 gdb_waitack_handler(int input, unsigned int *regfile)
 456 {
 457         (void)(regfile);
 458
 459         switch(input) {
 460                 case '+':
 461                         return INIT;
 462                 case '-':
 463                         gdb_resend_reply();
 464                         return WAITACK;
 465                 default:
 466                         /*
 467                          * looks like gdb and us are out of synch,
 468                          * send a NAK and retry from INIT state.
 469                          */
 470                         gdb_nak();
 471                         return INIT;
 472         }
 473 }
 474
 475 static
 476 int
 477 gdb_quit_handler(int input, unsigned int *regfile)
 478 {
 479         (void)(input);
 480         (void)(regfile);
 481
 482         /*
 483          * actually we should never be here
 484          */
 485         return QUIT;
 486 }
 487
 488 static int (*dispatch_table[GDBSTATES])(int, unsigned int*)=
 489 {
 490         &gdb_init_handler,
 491         &gdb_cmdread_handler,
 492         &gdb_cksum1_handler,
 493         &gdb_cksum2_handler,
 494         &gdb_waitack_handler,
 495         &gdb_quit_handler
 496 };
 497
 498 static
 499 int
 500 gdb_state_dispatch(int curr, int input, unsigned int *regfile)
 501 {
 502         if(curr< INIT) {
 503                 return QUIT;
 504         }
 505         if(curr>= GDBSTATES) {
 506                 return QUIT;
 507         }
 508
 509         return dispatch_table[curr](input, regfile);
 510 }
 511
 512 static
 513 int
 514 gdb_state_machine(unsigned int *regfile)
 515 {
 516         int state= INIT;
 517         int c;
 518
 519         while(state!= QUIT) {
 520                 c= arch_dbg_con_read();
 521                 state= gdb_state_dispatch(state, c, regfile);
 522         }
 523
 524         return 0;
 525 }
 526
 527 void
 528 cmd_gdb(int argc, char **argv)
 529 {
 530         struct iframe *interrupt_frame = NULL;
 531         unsigned int local_regfile[GDB_REGISTER_FILE_COUNT];
 532         if (argc > 1)
 533         {
 534                 // we want to work under a particular iframe.
 535                 if(strlen(argv[1]) > 2 && argv[1][0] == '0' && argv[1][1] == 'x')
 536                         interrupt_frame = (struct iframe*)atoul(argv[1]);
 537                 else
 538                         dprintf("warning: iframe used is not valid, using local stack.\n");
 539         }
 540         if (interrupt_frame)
 541         {
 542                 dbg_make_register_file(local_regfile, interrupt_frame);
 543         } else {
 544                 memcpy(local_regfile, dbg_register_file, sizeof(unsigned int) * GDB_REGISTER_FILE_COUNT);
 545         }
 546
 547         gdb_state_machine(local_regfile);
 548 }