Changeset da1bafb in mainline for kernel/arch/mips32/src/debugger.c


Ignore:
Timestamp:
2010-05-24T18:57:31Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0095368
Parents:
666f492
Message:

major code revision

  • replace spinlocks taken with interrupts disabled with irq_spinlocks
  • change spacing (not indendation) to be tab-size independent
  • use unsigned integer types where appropriate (especially bit flags)
  • visual separation
  • remove argument names in function prototypes
  • string changes
  • correct some formating directives
  • replace various cryptic single-character variables (t, a, m, c, b, etc.) with proper identifiers (thread, task, timeout, as, itm, itc, etc.)
  • unify some assembler constructs
  • unused page table levels are now optimized out in compile time
  • replace several ints (with boolean semantics) with bools
  • use specifically sized types instead of generic types where appropriate (size_t, uint32_t, btree_key_t)
  • improve comments
  • split asserts with conjuction into multiple independent asserts
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/mips32/src/debugger.c

    r666f492 rda1bafb  
    4646
    4747bpinfo_t breakpoints[BKPOINTS_MAX];
    48 SPINLOCK_INITIALIZE(bkpoint_lock);
     48IRQ_SPINLOCK_STATIC_INITIALIZE(bkpoint_lock);
    4949
    5050#ifdef CONFIG_KCONSOLE
    5151
    52 static int cmd_print_breakpoints(cmd_arg_t *argv);
     52static int cmd_print_breakpoints(cmd_arg_t *);
     53static int cmd_del_breakpoint(cmd_arg_t *);
     54static int cmd_add_breakpoint(cmd_arg_t *);
     55
    5356static cmd_info_t bkpts_info = {
    5457        .name = "bkpts",
    … …  
    5861};
    5962
    60 static int cmd_del_breakpoint(cmd_arg_t *argv);
    6163static cmd_arg_t del_argv = {
    6264        .type = ARG_TYPE_INT
    6365};
     66
    6467static cmd_info_t delbkpt_info = {
    6568        .name = "delbkpt",
    66         .description = "delbkpt <number> - Delete breakpoint.",
     69        .description = "Delete breakpoint.",
    6770        .func = cmd_del_breakpoint,
    6871        .argc = 1,
    … …  
    7073};
    7174
    72 static int cmd_add_breakpoint(cmd_arg_t *argv);
    7375static cmd_arg_t add_argv = {
    7476        .type = ARG_TYPE_INT
    7577};
     78
    7679static cmd_info_t addbkpt_info = {
    7780        .name = "addbkpt",
    78         .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch "
    79             "insts unsupported.",
     81        .description = "Add bkpoint (break on J/Branch insts unsupported).",
    8082        .func = cmd_add_breakpoint,
    8183        .argc = 1,
    … …  
    8991static cmd_info_t addbkpte_info = {
    9092        .name = "addbkpte",
    91         .description = "addebkpte <&symbol> <&func> - new bkpoint. Call "
    92             "func(or Nothing if 0).",
     93        .description = "Add bkpoint with a trigger function.",
    9394        .func = cmd_add_breakpoint,
    9495        .argc = 2,
    … …  
    100101        uint32_t value;
    101102} jmpinstr[] = {
    102         {0xf3ff0000, 0x41000000}, /* BCzF */
    103         {0xf3ff0000, 0x41020000}, /* BCzFL */
    104         {0xf3ff0000, 0x41010000}, /* BCzT */
    105         {0xf3ff0000, 0x41030000}, /* BCzTL */
    106         {0xfc000000, 0x10000000}, /* BEQ */
    107         {0xfc000000, 0x50000000}, /* BEQL */
    108         {0xfc1f0000, 0x04010000}, /* BEQL */
    109         {0xfc1f0000, 0x04110000}, /* BGEZAL */
    110         {0xfc1f0000, 0x04130000}, /* BGEZALL */
    111         {0xfc1f0000, 0x04030000}, /* BGEZL */
    112         {0xfc1f0000, 0x1c000000}, /* BGTZ */
    113         {0xfc1f0000, 0x5c000000}, /* BGTZL */
    114         {0xfc1f0000, 0x18000000}, /* BLEZ */
    115         {0xfc1f0000, 0x58000000}, /* BLEZL */
    116         {0xfc1f0000, 0x04000000}, /* BLTZ */
    117         {0xfc1f0000, 0x04100000}, /* BLTZAL */
    118         {0xfc1f0000, 0x04120000}, /* BLTZALL */
    119         {0xfc1f0000, 0x04020000}, /* BLTZL */
    120         {0xfc000000, 0x14000000}, /* BNE */
    121         {0xfc000000, 0x54000000}, /* BNEL */
    122         {0xfc000000, 0x08000000}, /* J */
    123         {0xfc000000, 0x0c000000}, /* JAL */
    124         {0xfc1f07ff, 0x00000009}, /* JALR */
    125         {0, 0} /* EndOfTable */
    126 };
    127 
     103        {0xf3ff0000, 0x41000000},  /* BCzF */
     104        {0xf3ff0000, 0x41020000},  /* BCzFL */
     105        {0xf3ff0000, 0x41010000},  /* BCzT */
     106        {0xf3ff0000, 0x41030000},  /* BCzTL */
     107        {0xfc000000, 0x10000000},  /* BEQ */
     108        {0xfc000000, 0x50000000},  /* BEQL */
     109        {0xfc1f0000, 0x04010000},  /* BEQL */
     110        {0xfc1f0000, 0x04110000},  /* BGEZAL */
     111        {0xfc1f0000, 0x04130000},  /* BGEZALL */
     112        {0xfc1f0000, 0x04030000},  /* BGEZL */
     113        {0xfc1f0000, 0x1c000000},  /* BGTZ */
     114        {0xfc1f0000, 0x5c000000},  /* BGTZL */
     115        {0xfc1f0000, 0x18000000},  /* BLEZ */
     116        {0xfc1f0000, 0x58000000},  /* BLEZL */
     117        {0xfc1f0000, 0x04000000},  /* BLTZ */
     118        {0xfc1f0000, 0x04100000},  /* BLTZAL */
     119        {0xfc1f0000, 0x04120000},  /* BLTZALL */
     120        {0xfc1f0000, 0x04020000},  /* BLTZL */
     121        {0xfc000000, 0x14000000},  /* BNE */
     122        {0xfc000000, 0x54000000},  /* BNEL */
     123        {0xfc000000, 0x08000000},  /* J */
     124        {0xfc000000, 0x0c000000},  /* JAL */
     125        {0xfc1f07ff, 0x00000009},  /* JALR */
     126        {0, 0}                     /* end of table */
     127};
    128128
    129129/** Test, if the given instruction is a jump or branch instruction
    130130 *
    131131 * @param instr Instruction code
    132  * @return true - it is jump instruction, false otherwise
     132 *
     133 * @return true if it is jump instruction, false otherwise
    133134 *
    134135 */
    135136static bool is_jump(unative_t instr)
    136137{
    137         int i;
    138 
     138        unsigned int i;
     139       
    139140        for (i = 0; jmpinstr[i].andmask; i++) {
    140141                if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value)
    141142                        return true;
    142143        }
    143 
     144       
    144145        return false;
    145146}
    146147
    147 /** Add new breakpoint to table */
     148/** Add new breakpoint to table
     149 *
     150 */
    148151int cmd_add_breakpoint(cmd_arg_t *argv)
    149152{
    150         bpinfo_t *cur = NULL;
    151         ipl_t ipl;
    152         int i;
    153 
    154153        if (argv->intval & 0x3) {
    155154                printf("Not aligned instruction, forgot to use &symbol?\n");
    156155                return 1;
    157156        }
    158         ipl = interrupts_disable();
    159         spinlock_lock(&bkpoint_lock);
    160 
     157       
     158        irq_spinlock_lock(&bkpoint_lock, true);
     159       
    161160        /* Check, that the breakpoints do not conflict */
     161        unsigned int i;
    162162        for (i = 0; i < BKPOINTS_MAX; i++) {
    163                 if (breakpoints[i].address == (uintptr_t)argv->intval) {
     163                if (breakpoints[i].address == (uintptr_t) argv->intval) {
    164164                        printf("Duplicate breakpoint %d.\n", i);
    165                         spinlock_unlock(&bkpoint_lock);
    166                         interrupts_restore(ipl);
     165                        irq_spinlock_unlock(&bkpoint_lock, true);
    167166                        return 0;
    168                 } else if (breakpoints[i].address == (uintptr_t)argv->intval +
    169                     sizeof(unative_t) || breakpoints[i].address ==
    170                     (uintptr_t)argv->intval - sizeof(unative_t)) {
     167                } else if ((breakpoints[i].address == (uintptr_t) argv->intval +
     168                    sizeof(unative_t)) || (breakpoints[i].address ==
     169                    (uintptr_t) argv->intval - sizeof(unative_t))) {
    171170                        printf("Adjacent breakpoints not supported, conflict "
    172171                            "with %d.\n", i);
    173                         spinlock_unlock(&bkpoint_lock);
    174                         interrupts_restore(ipl);
     172                        irq_spinlock_unlock(&bkpoint_lock, true);
    175173                        return 0;
    176174                }
    177175               
    178176        }
    179 
    180         for (i = 0; i < BKPOINTS_MAX; i++)
     177       
     178        bpinfo_t *cur = NULL;
     179       
     180        for (i = 0; i < BKPOINTS_MAX; i++) {
    181181                if (!breakpoints[i].address) {
    182182                        cur = &breakpoints[i];
    183183                        break;
    184184                }
     185        }
     186       
    185187        if (!cur) {
    186188                printf("Too many breakpoints.\n");
    187                 spinlock_unlock(&bkpoint_lock);
    188                 interrupts_restore(ipl);
     189                irq_spinlock_unlock(&bkpoint_lock, true);
    189190                return 0;
    190191        }
     192       
     193        printf("Adding breakpoint on address %p\n", argv->intval);
     194       
    191195        cur->address = (uintptr_t) argv->intval;
    192         printf("Adding breakpoint on address: %p\n", argv->intval);
    193         cur->instruction = ((unative_t *)cur->address)[0];
    194         cur->nextinstruction = ((unative_t *)cur->address)[1];
     196        cur->instruction = ((unative_t *) cur->address)[0];
     197        cur->nextinstruction = ((unative_t *) cur->address)[1];
    195198        if (argv == &add_argv) {
    196199                cur->flags = 0;
    197         } else { /* We are add extended */
     200        } else {  /* We are add extended */
    198201                cur->flags = BKPOINT_FUNCCALL;
    199202                cur->bkfunc = (void (*)(void *, istate_t *)) argv[1].intval;
    200203        }
     204       
    201205        if (is_jump(cur->instruction))
    202206                cur->flags |= BKPOINT_ONESHOT;
     207       
    203208        cur->counter = 0;
    204 
     209       
    205210        /* Set breakpoint */
    206         *((unative_t *)cur->address) = 0x0d;
     211        *((unative_t *) cur->address) = 0x0d;
    207212        smc_coherence(cur->address);
    208 
    209         spinlock_unlock(&bkpoint_lock);
    210         interrupts_restore(ipl);
    211 
     213       
     214        irq_spinlock_unlock(&bkpoint_lock, true);
     215       
    212216        return 1;
    213217}
    214218
    215 /** Remove breakpoint from table */
     219/** Remove breakpoint from table
     220 *
     221 */
    216222int cmd_del_breakpoint(cmd_arg_t *argv)
    217223{
    218         bpinfo_t *cur;
    219         ipl_t ipl;
    220 
    221224        if (argv->intval > BKPOINTS_MAX) {
    222225                printf("Invalid breakpoint number.\n");
    223226                return 0;
    224227        }
    225         ipl = interrupts_disable();
    226         spinlock_lock(&bkpoint_lock);
    227 
    228         cur = &breakpoints[argv->intval];
     228       
     229        irq_spinlock_lock(&bkpoint_lock, true);
     230       
     231        bpinfo_t *cur = &breakpoints[argv->intval];
    229232        if (!cur->address) {
    230233                printf("Breakpoint does not exist.\n");
    231                 spinlock_unlock(&bkpoint_lock);
    232                 interrupts_restore(ipl);
     234                irq_spinlock_unlock(&bkpoint_lock, true);
    233235                return 0;
    234236        }
     237       
    235238        if ((cur->flags & BKPOINT_INPROG) && (cur->flags & BKPOINT_ONESHOT)) {
    236239                printf("Cannot remove one-shot breakpoint in-progress\n");
    237                 spinlock_unlock(&bkpoint_lock);
    238                 interrupts_restore(ipl);
     240                irq_spinlock_unlock(&bkpoint_lock, true);
    239241                return 0;
    240242        }
    241         ((uint32_t *)cur->address)[0] = cur->instruction;
    242         smc_coherence(((uint32_t *)cur->address)[0]);
    243         ((uint32_t *)cur->address)[1] = cur->nextinstruction;
    244         smc_coherence(((uint32_t *)cur->address)[1]);
    245 
     243       
     244        ((uint32_t *) cur->address)[0] = cur->instruction;
     245        smc_coherence(((uint32_t *) cur->address)[0]);
     246        ((uint32_t *) cur->address)[1] = cur->nextinstruction;
     247        smc_coherence(((uint32_t *) cur->address)[1]);
     248       
    246249        cur->address = NULL;
    247 
    248         spinlock_unlock(&bkpoint_lock);
    249         interrupts_restore(ipl);
     250       
     251        irq_spinlock_unlock(&bkpoint_lock, true);
    250252        return 1;
    251253}
    252254
    253 /** Print table of active breakpoints */
     255/** Print table of active breakpoints
     256 *
     257 */
    254258int cmd_print_breakpoints(cmd_arg_t *argv)
    255259{
    … …  
    276280}
    277281
    278 #endif
    279 
    280 /** Initialize debugger */
     282#endif /* CONFIG_KCONSOLE */
     283
     284/** Initialize debugger
     285 *
     286 */
    281287void debugger_init()
    282288{
    283         int i;
    284 
     289        unsigned int i;
     290       
    285291        for (i = 0; i < BKPOINTS_MAX; i++)
    286292                breakpoints[i].address = NULL;
    287 
     293       
    288294#ifdef CONFIG_KCONSOLE
    289295        cmd_initialize(&bkpts_info);
    290296        if (!cmd_register(&bkpts_info))
    291297                printf("Cannot register command %s\n", bkpts_info.name);
    292 
     298       
    293299        cmd_initialize(&delbkpt_info);
    294300        if (!cmd_register(&delbkpt_info))
    295301                printf("Cannot register command %s\n", delbkpt_info.name);
    296 
     302       
    297303        cmd_initialize(&addbkpt_info);
    298304        if (!cmd_register(&addbkpt_info))
    299305                printf("Cannot register command %s\n", addbkpt_info.name);
    300 
     306       
    301307        cmd_initialize(&addbkpte_info);
    302308        if (!cmd_register(&addbkpte_info))
    303309                printf("Cannot register command %s\n", addbkpte_info.name);
    304 #endif
     310#endif /* CONFIG_KCONSOLE */
    305311}
    306312
    307313/** Handle breakpoint
    308314 *
    309  * Find breakpoint in breakpoint table. 
     315 * Find breakpoint in breakpoint table.
    310316 * If found, call kconsole, set break on next instruction and reexecute.
    311317 * If we are on "next instruction", set it back on the first and reexecute.
    312318 * If breakpoint not found in breakpoint table, call kconsole and start
    313319 * next instruction.
     320 *
    314321 */
    315322void debugger_bpoint(istate_t *istate)
    316323{
    317         bpinfo_t *cur = NULL;
    318         uintptr_t fireaddr = istate->epc;
    319         int i;
    320 
    321324        /* test branch delay slot */
    322325        if (cp0_cause_read() & 0x80000000)
    323326                panic("Breakpoint in branch delay slot not supported.");
    324 
    325         spinlock_lock(&bkpoint_lock);
     327       
     328        irq_spinlock_lock(&bkpoint_lock, false);
     329       
     330        bpinfo_t *cur = NULL;
     331        uintptr_t fireaddr = istate->epc;
     332        unsigned int i;
     333       
    326334        for (i = 0; i < BKPOINTS_MAX; i++) {
    327335                /* Normal breakpoint */
    328                 if (fireaddr == breakpoints[i].address &&
    329                     !(breakpoints[i].flags & BKPOINT_REINST)) {
     336                if ((fireaddr == breakpoints[i].address) &&
     337                    (!(breakpoints[i].flags & BKPOINT_REINST))) {
    330338                        cur = &breakpoints[i];
    331339                        break;
    332340                }
     341               
    333342                /* Reinst only breakpoint */
    334343                if ((breakpoints[i].flags & BKPOINT_REINST) &&
    … …  
    338347                }
    339348        }
     349       
    340350        if (cur) {
    341351                if (cur->flags & BKPOINT_REINST) {
    342352                        /* Set breakpoint on first instruction */
    343                         ((uint32_t *)cur->address)[0] = 0x0d;
     353                        ((uint32_t *) cur->address)[0] = 0x0d;
    344354                        smc_coherence(((uint32_t *)cur->address)[0]);
     355                       
    345356                        /* Return back the second */
    346                         ((uint32_t *)cur->address)[1] = cur->nextinstruction;
    347                         smc_coherence(((uint32_t *)cur->address)[1]);
     357                        ((uint32_t *) cur->address)[1] = cur->nextinstruction;
     358                        smc_coherence(((uint32_t *) cur->address)[1]);
     359                       
    348360                        cur->flags &= ~BKPOINT_REINST;
    349                         spinlock_unlock(&bkpoint_lock);
     361                        irq_spinlock_unlock(&bkpoint_lock, false);
    350362                        return;
    351                 }
     363                }
     364               
    352365                if (cur->flags & BKPOINT_INPROG)
    353366                        printf("Warning: breakpoint recursion\n");
    354367               
    355368                if (!(cur->flags & BKPOINT_FUNCCALL)) {
    356                         printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
    357                             symtab_fmt_name_lookup(istate->epc));
    358                 }
    359 
     369                        printf("***Breakpoint %u: %p in %s.\n", i, fireaddr,
     370                            symtab_fmt_name_lookup(fireaddr));
     371                }
     372               
    360373                /* Return first instruction back */
    361374                ((uint32_t *)cur->address)[0] = cur->instruction;
    … …  
    371384                printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
    372385                    symtab_fmt_name_lookup(fireaddr));
    373 
     386               
    374387                /* Move on to next instruction */
    375388                istate->epc += 4;
    376389        }
     390       
    377391        if (cur)
    378392                cur->counter++;
     393       
    379394        if (cur && (cur->flags & BKPOINT_FUNCCALL)) {
    380395                /* Allow zero bkfunc, just for counting */
    … …  
    383398        } else {
    384399#ifdef CONFIG_KCONSOLE
    385                 /* This disables all other processors - we are not SMP,
     400                /*
     401                 * This disables all other processors - we are not SMP,
    386402                 * actually this gets us to cpu_halt, if scheduler() is run
    387403                 * - we generally do not want scheduler to be run from debug,
    388404                 *   so this is a good idea
    389                  */     
     405                 */
    390406                atomic_set(&haltstate, 1);
    391                 spinlock_unlock(&bkpoint_lock);
     407                irq_spinlock_unlock(&bkpoint_lock, false);
    392408               
    393409                kconsole("debug", "Debug console ready.\n", false);
    394410               
    395                 spinlock_lock(&bkpoint_lock);
     411                irq_spinlock_lock(&bkpoint_lock, false);
    396412                atomic_set(&haltstate, 0);
    397413#endif
    398414        }
    399         if (cur && cur->address == fireaddr && (cur->flags & BKPOINT_INPROG)) {
     415       
     416        if ((cur) && (cur->address == fireaddr)
     417            && ((cur->flags & BKPOINT_INPROG))) {
    400418                /* Remove one-shot breakpoint */
    401419                if ((cur->flags & BKPOINT_ONESHOT))
    402420                        cur->address = NULL;
     421               
    403422                /* Remove in-progress flag */
    404423                cur->flags &= ~BKPOINT_INPROG;
    405         }
    406         spinlock_unlock(&bkpoint_lock);
     424        }
     425       
     426        irq_spinlock_unlock(&bkpoint_lock, false);
    407427}
    408428
Note: See TracChangeset for help on using the changeset viewer.