Subversion Repositories HelenOS

Rev

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