rom/exec/debug.c

   1 /*
   2     Copyright © 1995-2017, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Internal debugger.
   6     Lang: english
   7 */
   8
   9 #include <aros/debug.h>
  10 #include <exec/interrupts.h>
  11 #include <libraries/debug.h>
  12 #include <proto/exec.h>
  13 #include <proto/debug.h>
  14
  15 #include <ctype.h>
  16 #include <string.h>
  17
  18 #include "exec_intern.h"
  19 #include "exec_util.h"
  20
  21 /****************************************************************************************/
  22
  23 char    GetK();
  24 UQUAD   GetQ(char *);
  25 ULONG   GetL(char *);
  26 UWORD   GetW(char *);
  27 UBYTE   GetB(char *);
  28 int     get_irq_list(char *buf);
  29
  30 #if __WORDSIZE == 64
  31 #define GetA (APTR)GetQ
  32 #else
  33 #define GetA (APTR)GetL
  34 #endif
  35
  36 /****************************************************************************************/
  37
  38 static char *NextWord(char *s)
  39 {
  40     /* Skip to first space or EOL */
  41     while (*s != ' ')
  42     {
  43         if (!*s)
  44             return s;
  45         s++;
  46     }
  47
  48     /* Then skip to first non-space */
  49     while (*++s == ' ');
  50
  51     return s;
  52 }
  53
  54 /*****************************************************************************
  55
  56     NAME */
  57
  58         AROS_LH1(void, Debug,
  59
  60 /*  SYNOPSIS */
  61         AROS_LHA(unsigned long, flags, D0),
  62
  63 /*  LOCATION */
  64         struct ExecBase *, SysBase, 19, Exec)
  65
  66 /*  FUNCTION
  67         Runs SAD - internal debuger.
  68
  69     INPUTS
  70         flags   not used. Should be 0 now.
  71
  72     RESULT
  73
  74     NOTES
  75
  76     EXAMPLE
  77
  78     BUGS
  79
  80     SEE ALSO
  81
  82     INTERNALS
  83
  84     HISTORY
  85         18-01-99    initial PC version.
  86
  87 *****************************************************************************/
  88 {
  89     AROS_LIBFUNC_INIT
  90
  91     char comm[128];
  92     char *data;
  93     BOOL ignorelf = FALSE;
  94
  95     /*
  96      * Try to obtain debug input from the kernel.
  97      * If it failed, we will hang up in RawMayGetChar(), so exit immediately.
  98      */
  99     if (!KrnObtainInput())
 100         return;
 101
 102     RawIOInit();
 103
 104     for (;;)
 105     {
 106         int i = 0;
 107
 108         kprintf("SAD(%d,%d)>", TDNESTCOUNT_GET, IDNESTCOUNT_GET);
 109
 110         /* Get Command code */
 111         do
 112         {
 113             char key = GetK(SysBase);
 114             BOOL t = ignorelf;
 115
 116             /* We skip only single LF which immediately follows the CR. So we remember
 117                previous value of the flag and reset it when any character arrives. */
 118             ignorelf = FALSE;
 119             if (key == '\n') {
 120                 if (t)
 121                     continue;
 122                 else
 123                     break;
 124             }
 125
 126             /* TABs are problematic to deal with, we ignore them */
 127             else if (key == 0x09)
 128                 continue;
 129
 130             /* If we've just got CR, we may get LF next and we'll need to skip it */
 131             else if (key == '\r') {
 132                 ignorelf = TRUE;
 133                 break;
 134             }
 135
 136             /* Process backspace */
 137             else if (key == 0x08)
 138             {
 139                 if (i > 0) {
 140                     /* Go backwards, erase the character, then go backwards again */
 141                     RawPutChar(key);
 142                     RawPutChar(' ');
 143                     RawPutChar(key);
 144                     i--;
 145                 }
 146                 continue;
 147             }
 148
 149             RawPutChar(key);
 150             comm[i++] = key;
 151         }
 152         while (i < (int)sizeof(comm)-1);
 153         comm[i] = 0;
 154         RawPutChar('\n');
 155
 156         /* Now get data for command */
 157         data = NextWord(comm);
 158         comm[2] = 0;
 159
 160         /* Reboot command */
 161         if (strcmp(comm, "RE") == 0 && strcmp(data, "AAAAAAAA") == 0)
 162             ColdReboot();
 163         /* Restart command */
 164         else if (strcmp(comm, "RS") == 0 && strcmp(data, "FFFFFFFF") == 0)
 165             ShutdownA(SD_ACTION_COLDREBOOT);
 166         /* Forbid command */
 167         else if (strcmp(comm, "FO") == 0)
 168             Forbid();
 169         /* Permit command */
 170         else if (strcmp(comm, "PE") == 0)
 171             Permit();
 172         /* Disable command */
 173         else if (strcmp(comm, "DI") == 0)
 174             Disable();
 175         /* Show task information */
 176         else if (strcmp(comm, "TI") == 0)
 177         {
 178             struct Task *t = GetA(data);
 179
 180             if (!Exec_CheckTask(t, SysBase))
 181             {
 182                 kprintf("Task 0x%P not found\n", t);
 183                 continue;
 184             }
 185
 186             kprintf("Task status (%p = '%s'):\n"
 187                             "tc_Node.ln_Pri = %d\n"
 188                             "tc_Flags       = %p\n"
 189                             "tc_SigAlloc    = %04.4lx\n"
 190                             "tc_SigWait     = %04.4lx\n"
 191                             "tc_SPLower     = %p\n"
 192                             "tc_SPReg       = %p\n"
 193                             "tc_SPUpper     = %p\n"
 194                             "tc_IDNestCnt   = %d\n"
 195                             "tc_TDNestCnt   = %d\n",
 196                             t, t->tc_Node.ln_Name,
 197                             t->tc_Node.ln_Pri,
 198                             t->tc_Flags,
 199                             t->tc_SigAlloc,
 200                             t->tc_SigWait,
 201                             t->tc_SPLower,
 202                             t->tc_SPReg,
 203                             t->tc_SPUpper,
 204                             t->tc_IDNestCnt,
 205                             t->tc_TDNestCnt);
 206         }
 207         else if (strcmp(comm,"RI") == 0)
 208         {
 209             struct Task *t = GetA(data);
 210
 211             if (!Exec_CheckTask(t, SysBase))
 212             {
 213                 kprintf("Task 0x%P not found\n", t);
 214                 continue;
 215             }
 216
 217             kprintf("Task context (%p = '%s'):\n", t, t->tc_Node.ln_Name);
 218             FormatCPUContext(NULL, t->tc_UnionETask.tc_ETask->et_RegFrame, SysBase);
 219             RawPutChar('\n');
 220         }
 221         /* Enable command */
 222         else if (strcmp(comm, "EN") == 0)
 223             Enable();
 224         /* ShowLibs command */
 225         else if (strcmp(comm, "SL") == 0)
 226         {
 227             struct Node * node;
 228
 229             kprintf("Available libraries:\n");
 230
 231             /* Look through the list */
 232             for (node = GetHead(&SysBase->LibList); node; node = GetSucc(node))
 233             {
 234                 kprintf("0x%p : %s\n", node, node->ln_Name);
 235             }
 236         }
 237         else if (strcmp(comm, "SI") == 0)
 238         {
 239 /*          char buf[512];
 240
 241             kprintf("Available interrupts:\n");
 242
 243             get_irq_list(&buf);
 244             kprintf(buf);*/
 245             kprintf("Not implemented\n");
 246         }
 247         /* ShowResources command */
 248         else if (strcmp(comm, "SR") == 0)
 249         {
 250             struct Node * node;
 251
 252             kprintf("Available resources:\n");
 253
 254             /* Look through the list */
 255             for (node = GetHead(&SysBase->ResourceList); node; node = GetSucc(node))
 256             {
 257                 kprintf("0x%p : %s\n", node, node->ln_Name);
 258             }
 259         }
 260         /* ShowDevices command */
 261         else if (strcmp(comm,"SD") == 0)
 262         {
 263             struct Node * node;
 264
 265             kprintf("Available devices:\n");
 266
 267             /* Look through the list */
 268             for (node=GetHead(&SysBase->DeviceList); node; node = GetSucc(node))
 269             {
 270                 kprintf("0x%p : %s\n", node, node->ln_Name);
 271             }
 272         }
 273         /* ShowTasks command */
 274         else if (strcmp(comm, "ST") == 0)
 275         {
 276             struct Node * node;
 277
 278             kprintf("Task List:\n");
 279
 280 #if defined(__AROSEXEC_SMP__)
 281             ForeachNode(&PrivExecBase(SysBase)->TaskRunning, node)
 282             {
 283 #else
 284             node = (struct Node *)GET_THIS_TASK;
 285 #endif
 286             kprintf("0x%p T %d %s\n", node, node->ln_Pri, node->ln_Name);
 287 #if defined(__AROSEXEC_SMP__)
 288             }
 289 #endif
 290             /* Look through the list */
 291             for (node = GetHead(&SysBase->TaskReady); node; node = GetSucc(node))
 292             {
 293                 kprintf("0x%p R %d %s\n", node, node->ln_Pri, node->ln_Name);
 294             }
 295
 296             for (node = GetHead(&SysBase->TaskWait); node; node = GetSucc(node))
 297             {
 298                 kprintf("0x%p W %d %s\n", node, node->ln_Pri, node->ln_Name);
 299             }
 300
 301             kprintf("Idle called %d times\n", SysBase->IdleCount);
 302         }
 303         /* Help command */
 304         else if (strcmp(comm, "HE") == 0)
 305         {
 306             kprintf("SAD Help:\n");
 307             kprintf("RE AAAAAAAA - reboots AROS - ColdReboot()\n"
 308                     "RS FFFFFFFF - RESET\n"
 309                     "FO - Forbid()\n"
 310                     "PE - Permit()\n"
 311                     "DI - Disable()\n"
 312                     "EN - Enable()\n"
 313                     "SI - Show IRQ lines status\n"
 314                     "TI - Show Active task info\n"
 315                     "RI xxxxxxxx - Show registers inside task's context\n"
 316                     "AM xxxxxxxx yyyyyyyy - AllocVec - size=xxxxxxxx, "
 317                     "requiments=yyyyyyyy\n"
 318                     "FM xxxxxxxx - FreeVec from xxxxxxxx\n"
 319                     "RB xxxxxxxx - read byte from xxxxxxxx\n"
 320                     "RW xxxxxxxx - read word from xxxxxxxx\n"
 321                     "RL xxxxxxxx - read long from xxxxxxxx\n"
 322                     "WB xxxxxxxx bb - write byte bb at xxxxxxxx\n"
 323                     "WW xxxxxxxx wwww - write word wwww at xxxxxxxx\n"
 324                     "WL xxxxxxxx llllllll - write long llllllll at xxxxxxxx\n"
 325                     "RA xxxxxxxx ssssssss - read array(ssssssss bytes long) "
 326                     "from xxxxxxxx\n"
 327                     "RC xxxxxxxx ssssssss - read ascii (ssssssss bytes long) "
 328                     "from xxxxxxxx\n"
 329                     "QT 00000000 - quit SAD\n"
 330                     "SL - show all available libraries (libbase : libname)\n"
 331                     "SR - show all available resources (resbase : resname)\n"
 332                     "SD - show all available devices (devbase : devname)\n"
 333                     "SS xxxxxxxx - show symbol for xxxxxxxx\n"
 334                     "ST - show tasks (T - this, R - ready, W - wait)\n"
 335                     "HE - this help.\n");
 336         }
 337         /* AllocMem command */
 338         else if (strcmp(comm, "AM") == 0)
 339         {
 340             ULONG size = GetL(data);
 341             ULONG requim = GetL(NextWord(data));
 342
 343             kprintf("Allocated at 0x%p\n", AllocVec(size, requim));
 344         }
 345         /* FreeMem command */
 346         else if (strcmp(comm, "FM") == 0)
 347         {
 348             APTR base = GetA(&data[0]);
 349
 350             kprintf("Freed at 0x%p\n", base);
 351             FreeVec(base);
 352         }
 353         /* ReadByte */
 354         else if (strcmp(comm, "RB") == 0)
 355         {
 356             UBYTE *addr = GetA(data);
 357
 358             kprintf("Byte at 0x%p: %02X\n", addr, *addr);
 359         }
 360         /* ReadWord */
 361         else if (strcmp(comm, "RW") == 0)
 362         {
 363             UWORD *addr = GetA(data);
 364
 365             kprintf("Word at 0x%p: %04X\n", addr, *addr);
 366         }
 367         /* ReadLong */
 368         else if (strcmp(comm, "RL") == 0)
 369         {
 370             ULONG *addr = GetA(data);
 371
 372             kprintf("Long at 0x%p: %08X\n", addr, *addr);
 373         }
 374         /* WriteByte */
 375         else if (strcmp(comm,"WB") == 0)
 376         {
 377             UBYTE *addr = GetA(data);
 378             UBYTE val = GetB(NextWord(data));
 379
 380             kprintf("Byte at 0x%p: %02X\n", addr, val);
 381             *addr = val;
 382         }
 383         /* WriteWord */
 384         else if (strcmp(comm, "WW") == 0)
 385         {
 386             UWORD *addr = GetA(data);
 387             UWORD val = GetW(NextWord(data));
 388
 389             kprintf("Word at 0x%p: %04X\n", addr, val);
 390             *addr = val;
 391         }
 392         /* WriteLong */
 393         else if (strcmp(comm, "WL") == 0)
 394         {
 395             ULONG *addr = GetA(data);
 396             ULONG val = GetL(NextWord(data));
 397
 398             kprintf("Long at 0x%p: %08X\n", addr, val);
 399             *addr = val;
 400         }
 401         /* ReadArray */
 402         else if (strcmp(comm, "RA") == 0)
 403         {
 404             UBYTE *ptr = GetA(data);
 405             ULONG cnt = GetL(NextWord(data));
 406             ULONG t;
 407
 408             kprintf("Array from 0x%p (size=0x%08lX):\n", ptr, cnt);
 409
 410             for(t = 1; t <= cnt; t++)
 411             {
 412                 kprintf("%02X ", *ptr++);
 413                 if(!(t % 16)) kprintf("\n");
 414             }
 415             kprintf("\n");
 416         }
 417         /* ReadASCII */
 418         else if (strcmp(comm, "RC") == 0)
 419         {
 420             char *ptr = GetA(data);
 421             ULONG cnt = GetL(NextWord(data));
 422             ULONG t;
 423
 424             kprintf("ASCII from 0x%p (size=%08X):\n", ptr, cnt);
 425
 426             for(t = 1; t <= cnt; t++)
 427             {
 428                 RawPutChar(*ptr++);
 429                 if(!(t % 70)) kprintf(" \n");
 430             }
 431             kprintf(" \n");
 432         }
 433         else if (strcmp(comm, "SS") == 0) {
 434             char *ptr = GetA(data);
 435             STRPTR modname = "(unknown)";
 436             STRPTR symname = "(unknown)";
 437             APTR   sym_l   = (APTR)(IPTR)0;
 438             APTR   sym_h   = (APTR)~(IPTR)0;
 439             struct TagItem tags[] = {
 440                 { DL_ModuleName, (IPTR)&modname },
 441                 { DL_SymbolName, (IPTR)&symname },
 442                 { DL_SymbolStart, (IPTR)&sym_l  },
 443                 { DL_SymbolEnd, (IPTR)&sym_h },
 444                 { TAG_END }
 445             };
 446
 447             if (DebugBase) {
 448                 DecodeLocationA(ptr, tags);
 449             }
 450
 451             kprintf("%p %s %s+0x%x\n", sym_l, sym_h, modname, symname, (APTR)ptr - (APTR)sym_l);
 452         }
 453         else if (strcmp(comm, "QT") == 0 && strcmp(data, "00000000") == 0)
 454         {
 455             kprintf("Quitting SAD...\n");
 456             KrnReleaseInput(); /* Release debug input */
 457             return;
 458         }
 459         else kprintf("?? Type HE for help\n");
 460     }
 461
 462     AROS_LIBFUNC_EXIT
 463 } /* Debug */
 464
 465 /****************************************************************************************/
 466
 467 char GetK(struct ExecBase *SysBase)
 468 {
 469     int i;
 470
 471     do
 472     {
 473         i = RawMayGetChar();
 474     } while(i == -1);
 475
 476     return (char)i;
 477 }
 478
 479 /****************************************************************************************/
 480
 481 UQUAD GetQ(char* string)
 482 {
 483     UQUAD       ret = 0;
 484     int         i;
 485     char        digit;
 486
 487     for(i = 0; i < 16; i++)
 488     {
 489         digit = toupper(string[i]);
 490
 491         if (!isxdigit(digit))
 492             break;
 493
 494         digit -= '0';
 495         if (digit > 9) digit -= 'A' - '0' - 10;
 496         ret = (ret << 4) + digit;
 497     }
 498
 499     return ret;
 500 }
 501
 502 /****************************************************************************************/
 503
 504 ULONG GetL(char* string)
 505 {
 506     ULONG       ret = 0;
 507     int         i;
 508     char        digit;
 509
 510     for(i = 0; i < 8; i++)
 511     {
 512         digit = toupper(string[i]);
 513
 514         if (!isxdigit(digit))
 515             break;
 516
 517         digit -= '0';
 518         if (digit > 9) digit -= 'A' - '0' - 10;
 519         ret = (ret << 4) + digit;
 520     }
 521
 522     return ret;
 523 }
 524
 525 /****************************************************************************************/
 526
 527 UWORD GetW(char* string)
 528 {
 529     UWORD       ret = 0;
 530     int         i;
 531     char        digit;
 532
 533     for(i = 0; i < 4; i++)
 534     {
 535         digit = toupper(string[i]);
 536
 537         if (!isxdigit(digit))
 538             break;
 539
 540         digit -= '0';
 541         if (digit > 9) digit -= 'A' - '0' - 10;
 542         ret = (ret << 4) + digit;
 543     }
 544
 545     return ret;
 546 }
 547
 548 /****************************************************************************************/
 549
 550 UBYTE GetB(char* string)
 551 {
 552     UBYTE       ret = 0;
 553     int         i;
 554     char        digit;
 555
 556     for(i = 0; i < 2; i++)
 557     {
 558         digit = toupper(string[i]);
 559
 560         if (!isxdigit(digit))
 561             break;
 562
 563         digit -= '0';
 564         if (digit > 9) digit -= 'A' - '0' - 10;
 565         ret = (ret << 4) + digit;
 566     }
 567
 568     return ret;
 569 }