Subversion Repositories HelenOS

Rev

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