Subversion Repositories HelenOS-historic

Rev

Rev 614 | Rev 631 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (C) 2005 Ondrej Palkovsky
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. #include <arch/debugger.h>
  30. #include <memstr.h>
  31. #include <console/kconsole.h>
  32. #include <console/cmd.h>
  33. #include <symtab.h>
  34. #include <print.h>
  35. #include <panic.h>
  36. #include <arch.h>
  37. #include <arch/cp0.h>
  38. #include <func.h>
  39.  
  40. bpinfo_t breakpoints[BKPOINTS_MAX];
  41. spinlock_t bkpoint_lock;
  42.  
  43. static int cmd_print_breakpoints(cmd_arg_t *argv);
  44. static cmd_info_t pbkpt_info = {
  45.     .name = "pbkpt",
  46.     .description = "Print breakpoint table.",
  47.     .func = cmd_print_breakpoints,
  48.     .argc = 0,
  49. };
  50.  
  51. static int cmd_del_breakpoint(cmd_arg_t *argv);
  52. static cmd_arg_t del_argv = {
  53.     .type = ARG_TYPE_INT
  54. };
  55. static cmd_info_t delbkpt_info = {
  56.     .name = "delbkpt",
  57.     .description = "delbkpt <number> - Delete breakpoint.",
  58.     .func = cmd_del_breakpoint,
  59.     .argc = 1,
  60.     .argv = &del_argv
  61. };
  62.  
  63. static int cmd_add_breakpoint(cmd_arg_t *argv);
  64. static cmd_arg_t add_argv = {
  65.     .type = ARG_TYPE_INT
  66. };
  67. static cmd_info_t addbkpt_info = {
  68.     .name = "addbkpt",
  69.     .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch insts unsupported.",
  70.     .func = cmd_add_breakpoint,
  71.     .argc = 1,
  72.     .argv = &add_argv
  73. };
  74.  
  75. /** Add new breakpoint to table */
  76. int cmd_add_breakpoint(cmd_arg_t *argv)
  77. {
  78.     bpinfo_t *cur = NULL;
  79.     ipl_t ipl;
  80.     int i;
  81.  
  82.     if (argv->intval & 0x3) {
  83.         printf("Not aligned instruction, forgot to use &symbol?\n");
  84.         return 1;
  85.     }
  86.     ipl = interrupts_disable();
  87.     spinlock_lock(&bkpoint_lock);
  88.  
  89.     /* Check, that the breakpoints do not conflict */
  90.     for (i=0; i<BKPOINTS_MAX; i++) {
  91.         if (breakpoints[i].address == (__address)argv->intval) {
  92.             printf("Duplicate breakpoint %d.\n", i);
  93.             spinlock_unlock(&bkpoints_lock);
  94.             return 0;
  95.         } else if (breakpoints[i].address == (__address)argv->intval + sizeof(__native) || \
  96.                breakpoints[i].address == (__address)argv->intval - sizeof(__native)) {
  97.             printf("Adjacent breakpoints not supported, conflict with %d.\n", i);
  98.             spinlock_unlock(&bkpoints_lock);
  99.             return 0;
  100.         }
  101.            
  102.     }
  103.  
  104.     for (i=0; i<BKPOINTS_MAX; i++)
  105.         if (!breakpoints[i].address) {
  106.             cur = &breakpoints[i];
  107.             break;
  108.         }
  109.     if (!cur) {
  110.         printf("Too many breakpoints.\n");
  111.         spinlock_unlock(&bkpoint_lock);
  112.         interrupts_restore(ipl);
  113.         return 0;
  114.     }
  115.     cur->address = (__address) argv->intval;
  116.     printf("Adding breakpoint on address: %p\n", argv->intval);
  117.     cur->instruction = ((__native *)cur->address)[0];
  118.     cur->nextinstruction = ((__native *)cur->address)[1];
  119.     cur->executing = false;
  120.  
  121.     /* Set breakpoint */
  122.     *((__native *)cur->address) = 0x0d;
  123.  
  124.     spinlock_unlock(&bkpoint_lock);
  125.     interrupts_restore(ipl);
  126.  
  127.     return 1;
  128. }
  129.  
  130. /** Remove breakpoint from table */
  131. int cmd_del_breakpoint(cmd_arg_t *argv)
  132. {
  133.     bpinfo_t *cur;
  134.     ipl_t ipl;
  135.  
  136.     if (argv->intval < 0 || argv->intval > BKPOINTS_MAX) {
  137.         printf("Invalid breakpoint number.\n");
  138.         return 0;
  139.     }
  140.     ipl = interrupts_disable();
  141.     spinlock_lock(&bkpoint_lock);
  142.  
  143.     cur = &breakpoints[argv->intval];
  144.     if (!cur->address) {
  145.         printf("Breakpoint does not exist.\n");
  146.         spinlock_unlock(&bkpoint_lock);
  147.         interrupts_restore(ipl);
  148.         return 0;
  149.     }
  150.    
  151.     ((__u32 *)cur->address)[0] = cur->instruction;
  152.     ((__u32 *)cur->address)[1] = cur->nextinstruction;
  153.  
  154.     cur->address = NULL;
  155.  
  156.     spinlock_unlock(&bkpoint_lock);
  157.     interrupts_restore(ipl);
  158.     return 1;
  159. }
  160.  
  161. /** Print table of active breakpoints */
  162. int cmd_print_breakpoints(cmd_arg_t *argv)
  163. {
  164.     int i;
  165.     char *symbol;
  166.  
  167.     printf("Breakpoint table.\n");
  168.     for (i=0; i < BKPOINTS_MAX; i++)
  169.         if (breakpoints[i].address) {
  170.             symbol = get_symtab_entry(breakpoints[i].address);
  171.             printf("%d. 0x%p in %s\n",i,
  172.                    breakpoints[i].address, symbol);
  173.         }
  174.     return 1;
  175. }
  176.  
  177. /** Initialize debugger */
  178. void debugger_init()
  179. {
  180.     int i;
  181.  
  182.     for (i=0; i<BKPOINTS_MAX; i++)
  183.         breakpoints[i].address = NULL;
  184.     spinlock_initialize(&bkpoint_lock, "breakpoint_lock");
  185.    
  186.     cmd_initialize(&pbkpt_info);
  187.     if (!cmd_register(&pbkpt_info))
  188.         panic("could not register command %s\n", pbkpt_info.name);
  189.  
  190.     cmd_initialize(&delbkpt_info);
  191.     if (!cmd_register(&delbkpt_info))
  192.         panic("could not register command %s\n", delbkpt_info.name);
  193.  
  194.     cmd_initialize(&addbkpt_info);
  195.     if (!cmd_register(&addbkpt_info))
  196.         panic("could not register command %s\n", addbkpt_info.name);
  197. }
  198.  
  199. /** Handle breakpoint
  200.  *
  201.  * Find breakpoint in breakpoint table.
  202.  * If found, call kconsole, set break on next instruction and reexecute.
  203.  * If we are on "next instruction", set it back on the first and reexecute.
  204.  * If breakpoint not found in breakpoint table, call kconsole and start
  205.  * next instruction.
  206.  */
  207. void debugger_bpoint(struct exception_regdump *pstate)
  208. {
  209.     char *symbol;
  210.     bpinfo_t *cur = NULL;
  211.     int i;
  212.  
  213.     symbol = get_symtab_entry(pstate->epc);
  214.    
  215.  
  216.     /* test branch delay slot */
  217.     if (cp0_cause_read() & 0x80000000)
  218.         panic("Breakpoint in branch delay slot not supported.\n");
  219.  
  220.     spinlock_lock(&bkpoint_lock);
  221.     for (i=0; i<BKPOINTS_MAX; i++) {
  222.         if (pstate->epc == breakpoints[i].address || \
  223.             (pstate->epc == breakpoints[i].address+sizeof(__native) &&\
  224.              breakpoints[i].executing))
  225.             cur = &breakpoints[i];
  226.         break;
  227.  
  228.     }
  229.     if (cur) {
  230.         if ((cur->executing && pstate->epc==cur->address) ||
  231.             (!cur->executing && pstate->epc==cur->address+sizeof(__native)))
  232.             panic("Weird breakpoint state.\n");
  233.         if (!cur->executing) {
  234.             printf("***Breakpoint %d: 0x%p in %s.\n", i,
  235.                    pstate->epc,symbol);
  236.             /* Return first instruction back */
  237.             ((__u32 *)cur->address)[0] = cur->instruction;
  238.             /* Set Breakpoint on second */
  239.             ((__u32 *)cur->address)[1] = 0x0d;
  240.             cur->executing = true;
  241.         } else {
  242.             /* Set breakpoint on first instruction */
  243.             ((__u32 *)cur->address)[0] = 0x0d;
  244.             /* Return back the second */
  245.             ((__u32 *)cur->address)[1] = cur->nextinstruction;
  246.             cur->executing = false;
  247.             spinlock_unlock(&bkpoint_lock);
  248.             return;
  249.         }
  250.     } else {
  251.         printf("***Breakpoint 0x%p in %s.\n", pstate->epc, symbol);
  252.         /* Move on to next instruction */
  253.         pstate->epc += 4;
  254.     }
  255.     spinlock_unlock(&bkpoint_lock);
  256.  
  257.            
  258.     printf("***Type 'exit' to exit kconsole.\n");
  259.     /* Umm..we should rather set some 'debugstate' here */
  260.     haltstate = 1;
  261.     kconsole("debug");
  262.     haltstate = 0;
  263. }
  264.