sys/ddb/db_break.c

   1 /*
   2  * Mach Operating System
   3  * Copyright (c) 1991,1990 Carnegie Mellon University
   4  * All Rights Reserved.
   5  *
   6  * Permission to use, copy, modify and distribute this software and its
   7  * documentation is hereby granted, provided that both the copyright
   8  * notice and this permission notice appear in all copies of the
   9  * software, derivative works or modified versions, and any portions
  10  * thereof, and that both notices appear in supporting documentation.
  11  *
  12  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
  13  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  14  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  15  *
  16  * Carnegie Mellon requests users of this software to return to
  17  *
  18  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  19  *  School of Computer Science
  20  *  Carnegie Mellon University
  21  *  Pittsburgh PA 15213-3890
  22  *
  23  * any improvements or extensions that they make and grant Carnegie the
  24  * rights to redistribute these changes.
  25  *
  26  * $FreeBSD: src/sys/ddb/db_break.c,v 1.18 1999/08/28 00:41:05 peter Exp $
  27  */
  28
  29 /*
  30  *      Author: David B. Golub, Carnegie Mellon University
  31  *      Date:   7/90
  32  */
  33 /*
  34  * Breakpoints.
  35  */
  36 #include <sys/param.h>
  37
  38 #include <vm/vm.h>
  39 #include <vm/vm_kern.h>
  40
  41 #include <ddb/ddb.h>
  42 #include <ddb/db_break.h>
  43 #include <ddb/db_access.h>
  44 #include <ddb/db_sym.h>
  45
  46 #define NBREAKPOINTS    100
  47 static struct db_breakpoint     db_break_table[NBREAKPOINTS];
  48 static db_breakpoint_t          db_next_free_breakpoint = &db_break_table[0];
  49 static db_breakpoint_t          db_free_breakpoints = 0;
  50 static db_breakpoint_t          db_breakpoint_list = 0;
  51
  52 static db_breakpoint_t  db_breakpoint_alloc __P((void));
  53 static void     db_breakpoint_free __P((db_breakpoint_t bkpt));
  54 static void     db_delete_breakpoint __P((vm_map_t map, db_addr_t addr));
  55 static db_breakpoint_t  db_find_breakpoint __P((vm_map_t map, db_addr_t addr));
  56 static void     db_list_breakpoints __P((void));
  57 static void     db_set_breakpoint __P((vm_map_t map, db_addr_t addr,
  58                                        int count));
  59
  60 static db_breakpoint_t
  61 db_breakpoint_alloc()
  62 {
  63         register db_breakpoint_t        bkpt;
  64
  65         if ((bkpt = db_free_breakpoints) != 0) {
  66             db_free_breakpoints = bkpt->link;
  67             return (bkpt);
  68         }
  69         if (db_next_free_breakpoint == &db_break_table[NBREAKPOINTS]) {
  70             db_printf("All breakpoints used.\n");
  71             return (0);
  72         }
  73         bkpt = db_next_free_breakpoint;
  74         db_next_free_breakpoint++;
  75
  76         return (bkpt);
  77 }
  78
  79 static void
  80 db_breakpoint_free(bkpt)
  81         register db_breakpoint_t        bkpt;
  82 {
  83         bkpt->link = db_free_breakpoints;
  84         db_free_breakpoints = bkpt;
  85 }
  86
  87 static void
  88 db_set_breakpoint(map, addr, count)
  89         vm_map_t        map;
  90         db_addr_t       addr;
  91         int             count;
  92 {
  93         register db_breakpoint_t        bkpt;
  94
  95         if (db_find_breakpoint(map, addr)) {
  96             db_printf("Already set.\n");
  97             return;
  98         }
  99
 100         bkpt = db_breakpoint_alloc();
 101         if (bkpt == 0) {
 102             db_printf("Too many breakpoints.\n");
 103             return;
 104         }
 105
 106         bkpt->map = map;
 107         bkpt->address = addr;
 108         bkpt->flags = 0;
 109         bkpt->init_count = count;
 110         bkpt->count = count;
 111
 112         bkpt->link = db_breakpoint_list;
 113         db_breakpoint_list = bkpt;
 114 }
 115
 116 static void
 117 db_delete_breakpoint(map, addr)
 118         vm_map_t        map;
 119         db_addr_t       addr;
 120 {
 121         register db_breakpoint_t        bkpt;
 122         register db_breakpoint_t        *prev;
 123
 124         for (prev = &db_breakpoint_list;
 125              (bkpt = *prev) != 0;
 126              prev = &bkpt->link) {
 127             if (db_map_equal(bkpt->map, map) &&
 128                 (bkpt->address == addr)) {
 129                 *prev = bkpt->link;
 130                 break;
 131             }
 132         }
 133         if (bkpt == 0) {
 134             db_printf("Not set.\n");
 135             return;
 136         }
 137
 138         db_breakpoint_free(bkpt);
 139 }
 140
 141 static db_breakpoint_t
 142 db_find_breakpoint(map, addr)
 143         vm_map_t        map;
 144         db_addr_t       addr;
 145 {
 146         register db_breakpoint_t        bkpt;
 147
 148         for (bkpt = db_breakpoint_list;
 149              bkpt != 0;
 150              bkpt = bkpt->link)
 151         {
 152             if (db_map_equal(bkpt->map, map) &&
 153                 (bkpt->address == addr))
 154                 return (bkpt);
 155         }
 156         return (0);
 157 }
 158
 159 db_breakpoint_t
 160 db_find_breakpoint_here(addr)
 161         db_addr_t       addr;
 162 {
 163     return db_find_breakpoint(db_map_addr(addr), addr);
 164 }
 165
 166 static boolean_t        db_breakpoints_inserted = TRUE;
 167
 168 void
 169 db_set_breakpoints()
 170 {
 171         register db_breakpoint_t        bkpt;
 172
 173         if (!db_breakpoints_inserted) {
 174
 175             for (bkpt = db_breakpoint_list;
 176                  bkpt != 0;
 177                  bkpt = bkpt->link)
 178                 if (db_map_current(bkpt->map)) {
 179                     bkpt->bkpt_inst = db_get_value(bkpt->address,
 180                                                    BKPT_SIZE,
 181                                                    FALSE);
 182                     db_put_value(bkpt->address,
 183                                  BKPT_SIZE,
 184                                  BKPT_SET(bkpt->bkpt_inst));
 185                 }
 186             db_breakpoints_inserted = TRUE;
 187         }
 188 }
 189
 190 void
 191 db_clear_breakpoints()
 192 {
 193         register db_breakpoint_t        bkpt;
 194
 195         if (db_breakpoints_inserted) {
 196
 197             for (bkpt = db_breakpoint_list;
 198                  bkpt != 0;
 199                  bkpt = bkpt->link)
 200                 if (db_map_current(bkpt->map)) {
 201                     db_put_value(bkpt->address, BKPT_SIZE, bkpt->bkpt_inst);
 202                 }
 203             db_breakpoints_inserted = FALSE;
 204         }
 205 }
 206
 207 #ifdef SOFTWARE_SSTEP
 208 /*
 209  * Set a temporary breakpoint.
 210  * The instruction is changed immediately,
 211  * so the breakpoint does not have to be on the breakpoint list.
 212  */
 213 db_breakpoint_t
 214 db_set_temp_breakpoint(addr)
 215         db_addr_t       addr;
 216 {
 217         register db_breakpoint_t        bkpt;
 218
 219         bkpt = db_breakpoint_alloc();
 220         if (bkpt == 0) {
 221             db_printf("Too many breakpoints.\n");
 222             return 0;
 223         }
 224
 225         bkpt->map = NULL;
 226         bkpt->address = addr;
 227         bkpt->flags = BKPT_TEMP;
 228         bkpt->init_count = 1;
 229         bkpt->count = 1;
 230
 231         bkpt->bkpt_inst = db_get_value(bkpt->address, BKPT_SIZE, FALSE);
 232         db_put_value(bkpt->address, BKPT_SIZE, BKPT_SET(bkpt->bkpt_inst));
 233         return bkpt;
 234 }
 235
 236 void
 237 db_delete_temp_breakpoint(bkpt)
 238         db_breakpoint_t bkpt;
 239 {
 240         db_put_value(bkpt->address, BKPT_SIZE, bkpt->bkpt_inst);
 241         db_breakpoint_free(bkpt);
 242 }
 243 #endif /* SOFTWARE_SSTEP */
 244
 245 /*
 246  * List breakpoints.
 247  */
 248 static void
 249 db_list_breakpoints()
 250 {
 251         register db_breakpoint_t        bkpt;
 252
 253         if (db_breakpoint_list == 0) {
 254             db_printf("No breakpoints set\n");
 255             return;
 256         }
 257
 258         db_printf(" Map      Count    Address\n");
 259         for (bkpt = db_breakpoint_list;
 260              bkpt != 0;
 261              bkpt = bkpt->link) {
 262             db_printf("%s%8p %5d    ",
 263                       db_map_current(bkpt->map) ? "*" : " ",
 264                       (void *)bkpt->map, bkpt->init_count);
 265             db_printsym(bkpt->address, DB_STGY_PROC);
 266             db_printf("\n");
 267         }
 268 }
 269
 270 /* Delete breakpoint */
 271 /*ARGSUSED*/
 272 void
 273 db_delete_cmd(addr, have_addr, count, modif)
 274         db_expr_t       addr;
 275         boolean_t       have_addr;
 276         db_expr_t       count;
 277         char *          modif;
 278 {
 279         db_delete_breakpoint(db_map_addr(addr), (db_addr_t)addr);
 280 }
 281
 282 /* Set breakpoint with skip count */
 283 /*ARGSUSED*/
 284 void
 285 db_breakpoint_cmd(addr, have_addr, count, modif)
 286         db_expr_t       addr;
 287         boolean_t       have_addr;
 288         db_expr_t       count;
 289         char *          modif;
 290 {
 291         if (count == -1)
 292             count = 1;
 293
 294         db_set_breakpoint(db_map_addr(addr), (db_addr_t)addr, count);
 295 }
 296
 297 /* list breakpoints */
 298 void
 299 db_listbreak_cmd(dummy1, dummy2, dummy3, dummy4)
 300         db_expr_t       dummy1;
 301         boolean_t       dummy2;
 302         db_expr_t       dummy3;
 303         char *          dummy4;
 304 {
 305         db_list_breakpoints();
 306 }
 307
 308 /*
 309  *      We want ddb to be usable before most of the kernel has been
 310  *      initialized.  In particular, current_thread() or kernel_map
 311  *      (or both) may be null.
 312  */
 313
 314 boolean_t
 315 db_map_equal(map1, map2)
 316         vm_map_t        map1, map2;
 317 {
 318         return ((map1 == map2) ||
 319                 ((map1 == NULL) && (map2 == kernel_map)) ||
 320                 ((map1 == kernel_map) && (map2 == NULL)));
 321 }
 322
 323 boolean_t
 324 db_map_current(map)
 325         vm_map_t        map;
 326 {
 327 #if 0
 328         thread_t        thread;
 329
 330         return ((map == NULL) ||
 331                 (map == kernel_map) ||
 332                 (((thread = current_thread()) != NULL) &&
 333                  (map == thread->task->map)));
 334 #else
 335         return (1);
 336 #endif
 337 }
 338
 339 vm_map_t
 340 db_map_addr(addr)
 341         vm_offset_t addr;
 342 {
 343 #if 0
 344         thread_t        thread;
 345
 346         /*
 347          *      We want to return kernel_map for all
 348          *      non-user addresses, even when debugging
 349          *      kernel tasks with their own maps.
 350          */
 351
 352         if ((VM_MIN_ADDRESS <= addr) &&
 353             (addr < VM_MAX_ADDRESS) &&
 354             ((thread = current_thread()) != NULL))
 355             return thread->task->map;
 356         else
 357 #endif
 358             return kernel_map;
 359 }