Subversion Repositories HelenOS-historic

Rev

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

  1. /*
  2.  * Copyright (C) 2006 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 <console/kconsole.h>
  31. #include <console/cmd.h>
  32. #include <symtab.h>
  33. #include <print.h>
  34. #include <panic.h>
  35. #include <interrupt.h>
  36. #include <arch/asm.h>
  37. #include <arch/cpu.h>
  38. #include <debug.h>
  39. #include <func.h>
  40.  
  41. typedef struct  {
  42.     __address address;      /**< Breakpoint address */
  43.     int flags;              /**< Flags regarding breakpoint */
  44.     int counter;            /**< How many times the exception occured */
  45. } bpinfo_t;
  46.  
  47. static bpinfo_t breakpoints[BKPOINTS_MAX];
  48. SPINLOCK_INITIALIZE(bkpoint_lock);
  49.  
  50. static int cmd_print_breakpoints(cmd_arg_t *argv);
  51. static cmd_info_t bkpts_info = {
  52.     .name = "bkpts",
  53.     .description = "Print breakpoint table.",
  54.     .func = cmd_print_breakpoints,
  55.     .argc = 0,
  56. };
  57.  
  58. static int cmd_del_breakpoint(cmd_arg_t *argv);
  59. static cmd_arg_t del_argv = {
  60.     .type = ARG_TYPE_INT
  61. };
  62. static cmd_info_t delbkpt_info = {
  63.     .name = "delbkpt",
  64.     .description = "delbkpt <number> - Delete breakpoint.",
  65.     .func = cmd_del_breakpoint,
  66.     .argc = 1,
  67.     .argv = &del_argv
  68. };
  69.  
  70. static int cmd_add_breakpoint(cmd_arg_t *argv);
  71. static cmd_arg_t add_argv = {
  72.     .type = ARG_TYPE_INT
  73. };
  74. static cmd_info_t addbkpt_info = {
  75.     .name = "addbkpt",
  76.     .description = "addbkpt <&symbol> - new breakpoint.",
  77.     .func = cmd_add_breakpoint,
  78.     .argc = 1,
  79.     .argv = &add_argv
  80. };
  81.  
  82. static cmd_arg_t addw_argv = {
  83.     .type = ARG_TYPE_INT
  84. };
  85. static cmd_info_t addwatchp_info = {
  86.     .name = "addwatchp",
  87.     .description = "addbwatchp <&symbol> - new write watchpoint.",
  88.     .func = cmd_add_breakpoint,
  89.     .argc = 1,
  90.     .argv = &addw_argv
  91. };
  92.  
  93.  
  94. /** Print table of active breakpoints */
  95. int cmd_print_breakpoints(cmd_arg_t *argv)
  96. {
  97.     int i;
  98.     char *symbol;
  99.  
  100.     printf("Breakpoint table.\n");
  101.     for (i=0; i < BKPOINTS_MAX; i++)
  102.         if (breakpoints[i].address) {
  103.             symbol = get_symtab_entry(breakpoints[i].address);
  104.             printf("%d. 0x%p in %s\n",i,
  105.                    breakpoints[i].address, symbol);
  106.             printf("     Count(%d) ", breakpoints[i].counter);
  107.             printf("\n");
  108.         }
  109.     return 1;
  110. }
  111.  
  112. /** Enable hardware breakpoint
  113.  *
  114.  *
  115.  * @param where Address of HW breakpoint
  116.  * @param flags Type of breakpoint (EXECUTE, WRITE)
  117.  * @return Debug slot on success, -1 - no available HW breakpoint
  118.  */
  119. int breakpoint_add(void * where, int flags)
  120. {
  121.     bpinfo_t *cur = NULL;
  122.     int curidx;
  123.     ipl_t ipl;
  124.     int i;
  125.     __native dr7;
  126.  
  127.     ASSERT( flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE));
  128.  
  129.     ipl = interrupts_disable();
  130.     spinlock_lock(&bkpoint_lock);
  131.    
  132.     /* Find free space in slots */
  133.     for (i=0; i<BKPOINTS_MAX; i++)
  134.         if (!breakpoints[i].address) {
  135.             cur = &breakpoints[i];
  136.             curidx = i;
  137.             break;
  138.         }
  139.     if (!cur) {
  140.         /* Too many breakpoints */
  141.         spinlock_unlock(&bkpoint_lock);
  142.         interrupts_restore(ipl);
  143.         return -1;
  144.     }
  145.     cur->address = (__address) where;
  146.     cur->flags = flags;
  147.     cur->counter = 0;
  148.  
  149.     /* Set breakpoint to debug registers */
  150.     switch (curidx) {
  151.     case 0:
  152.         write_dr0(cur->address);
  153.         break;
  154.     case 1:
  155.         write_dr1(cur->address);
  156.         break;
  157.     case 2:
  158.         write_dr2(cur->address);
  159.         break;
  160.     case 3:
  161.         write_dr3(cur->address);
  162.         break;
  163.     }
  164.     dr7 = read_dr7();
  165.     /* Set type to requested breakpoint & length*/
  166.     dr7 &= ~ (0x3 << (16 + 4*curidx));
  167.     dr7 &= ~ (0x3 << (18 + 4*curidx));
  168.     if ((flags & BKPOINT_INSTR)) {
  169.         printf("Instr breakpoint\n");
  170.         ;
  171.     } else {
  172.         if (sizeof(int) == 4)
  173.             dr7 |= 0x3 << (18 + 4*curidx);
  174.         else /* 8 */
  175.             dr7 |= 0x2 << (18 + 4*curidx);
  176.            
  177.         if ((flags & BKPOINT_WRITE))
  178.             dr7 |= 0x1 << (16 + 4*curidx);
  179.         else if ((flags & BKPOINT_READ_WRITE))
  180.             dr7 |= 0x3 << (16 + 4*curidx);
  181.     }
  182.  
  183.     /* Enable global breakpoint */
  184.     dr7 |= 0x2 << (curidx*2);
  185.  
  186.     write_dr7(dr7);
  187.  
  188.     spinlock_unlock(&bkpoint_lock);
  189.     interrupts_restore(ipl);
  190.  
  191.     return curidx;
  192. }
  193.  
  194. #ifdef amd64
  195. # define getip(x)  ((x)->rip)
  196. #else
  197. # define getip(x)  ((x)->eip)
  198. #endif
  199.  
  200. static void handle_exception(int slot, istate_t *istate)
  201. {
  202.     ASSERT(breakpoints[slot].address);
  203.  
  204.     /* Handle zero checker */
  205.     if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
  206.         if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
  207.             if (*((__native *) breakpoints[slot].address) != 0)
  208.                 return;
  209.             printf("**** Found ZERO on address %P ****\n",
  210.                    slot, breakpoints[slot].address);
  211.         } else {
  212.             printf("Data watchpoint - new data: %P\n",
  213.                    *((__native *) breakpoints[slot].address));
  214.         }
  215.     }
  216.     printf("Reached breakpoint %d:%P(%s)\n", slot, getip(istate),
  217.            get_symtab_entry(getip(istate)));
  218.     printf("***Type 'exit' to exit kconsole.\n");
  219.     atomic_set(&haltstate,1);
  220.     kconsole("debug");
  221.     atomic_set(&haltstate,0);
  222. }
  223.  
  224. static void debug_exception(int n, istate_t *istate)
  225. {
  226.     __native dr6;
  227.     int i;
  228.    
  229.     /* Set RF to restart the instruction  */
  230. #ifdef amd64      
  231.     istate->rflags |= RFLAGS_RF;
  232. #else
  233.     istate->eflags |= EFLAGS_RF;
  234. #endif
  235.  
  236.     dr6 = read_dr6();
  237.     for (i=0; i < BKPOINTS_MAX; i++) {
  238.         if (dr6 & (1 << i)) {
  239.             dr6 &= ~ (1 << i);
  240.             write_dr6(dr6);
  241.            
  242.             handle_exception(i, istate);
  243.         }
  244.     }
  245. }
  246.  
  247. void breakpoint_del(int slot)
  248. {
  249.     bpinfo_t *cur;
  250.     ipl_t ipl;
  251.     __native dr7;
  252.  
  253.     ipl = interrupts_disable();
  254.     spinlock_lock(&bkpoint_lock);
  255.  
  256.     cur = &breakpoints[slot];
  257.     if (!cur->address) {
  258.         spinlock_unlock(&bkpoint_lock);
  259.         interrupts_restore(ipl);
  260.         return;
  261.     }
  262.  
  263.     cur->address = NULL;
  264.  
  265.     /* Disable breakpoint in DR7 */
  266.     dr7 = read_dr7();
  267.     dr7 &= ~(0x2 << (slot*2));
  268.     write_dr7(dr7);
  269.  
  270.     spinlock_unlock(&bkpoint_lock);
  271.     interrupts_restore(ipl);
  272. }
  273.  
  274. /** Remove breakpoint from table */
  275. int cmd_del_breakpoint(cmd_arg_t *argv)
  276. {
  277.     if (argv->intval < 0 || argv->intval > BKPOINTS_MAX) {
  278.         printf("Invalid breakpoint number.\n");
  279.         return 0;
  280.     }
  281.     breakpoint_del(argv->intval);
  282.     return 1;
  283. }
  284.  
  285. /** Add new breakpoint to table */
  286. static int cmd_add_breakpoint(cmd_arg_t *argv)
  287. {
  288.     int flags;
  289.  
  290.     if (argv == &add_argv) {
  291.         flags = BKPOINT_INSTR;
  292.     } else { /* addwatchp */
  293.         flags = BKPOINT_WRITE;
  294.     }
  295.     printf("Adding breakpoint on address: %p\n", argv->intval);
  296.     if (breakpoint_add((void *)argv->intval, flags))
  297.         printf("Add breakpoint failed.\n");
  298.    
  299.     return 1;
  300. }
  301.  
  302. /** Initialize debugger */
  303. void debugger_init()
  304. {
  305.     int i;
  306.  
  307.     for (i=0; i<BKPOINTS_MAX; i++)
  308.         breakpoints[i].address = NULL;
  309.    
  310.     cmd_initialize(&bkpts_info);
  311.     if (!cmd_register(&bkpts_info))
  312.         panic("could not register command %s\n", bkpts_info.name);
  313.  
  314.     cmd_initialize(&delbkpt_info);
  315.     if (!cmd_register(&delbkpt_info))
  316.         panic("could not register command %s\n", delbkpt_info.name);
  317.  
  318.     cmd_initialize(&addbkpt_info);
  319.     if (!cmd_register(&addbkpt_info))
  320.         panic("could not register command %s\n", addbkpt_info.name);
  321.  
  322.     cmd_initialize(&addwatchp_info);
  323.     if (!cmd_register(&addwatchp_info))
  324.         panic("could not register command %s\n", addwatchp_info.name);
  325.    
  326.     exc_register(VECTOR_DEBUG, "debugger",
  327.              debug_exception);
  328. }
  329.