diff --git a/sys/ddb/db_break.c b/sys/ddb/db_break.c index 91d927f03eaf..65045d909890 100644 --- a/sys/ddb/db_break.c +++ b/sys/ddb/db_break.c @@ -1,303 +1,325 @@ /*- * SPDX-License-Identifier: MIT-CMU * * Mach Operating System * Copyright (c) 1991,1990 Carnegie Mellon University * All Rights Reserved. * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. * */ /* * Author: David B. Golub, Carnegie Mellon University * Date: 7/90 */ /* * Breakpoints. */ #include #include #include #include #include #include #include +struct db_breakpoint_type { + db_breakpoint_t db_next_free_breakpoint; + db_breakpoint_t db_breakpoint_limit; + db_breakpoint_t db_free_breakpoints; + db_breakpoint_t db_breakpoint_list; +}; + #define NBREAKPOINTS 100 static struct db_breakpoint db_break_table[NBREAKPOINTS]; -static db_breakpoint_t db_next_free_breakpoint = &db_break_table[0]; -static db_breakpoint_t db_free_breakpoints = 0; -static db_breakpoint_t db_breakpoint_list = 0; - -static db_breakpoint_t db_breakpoint_alloc(void); -static void db_breakpoint_free(db_breakpoint_t bkpt); -static void db_delete_breakpoint(vm_map_t map, db_addr_t addr); -static db_breakpoint_t db_find_breakpoint(vm_map_t map, db_addr_t addr); + +static struct db_breakpoint_type db_breakpoint = { + .db_next_free_breakpoint = &db_break_table[0], + .db_breakpoint_limit = &db_break_table[NBREAKPOINTS], + .db_free_breakpoints = NULL, + .db_breakpoint_list = NULL, +}; + +static db_breakpoint_t db_breakpoint_alloc( + struct db_breakpoint_type *bkpt_type); +static void db_breakpoint_free(struct db_breakpoint_type *bkpt_typ, + db_breakpoint_t bkpt); +static void db_delete_breakpoint(struct db_breakpoint_type *bkpt_type, + vm_map_t map, db_addr_t addr); +static db_breakpoint_t db_find_breakpoint(struct db_breakpoint_type *bkpt_type, + vm_map_t map, db_addr_t addr); static void db_list_breakpoints(void); -static void db_set_breakpoint(vm_map_t map, db_addr_t addr, int count); +static void db_set_breakpoint(struct db_breakpoint_type *bkpt_type, + vm_map_t map, db_addr_t addr, int count); static db_breakpoint_t -db_breakpoint_alloc(void) +db_breakpoint_alloc(struct db_breakpoint_type *bkpt_type) { register db_breakpoint_t bkpt; - if ((bkpt = db_free_breakpoints) != 0) { - db_free_breakpoints = bkpt->link; + if ((bkpt = bkpt_type->db_free_breakpoints) != 0) { + bkpt_type->db_free_breakpoints = bkpt->link; return (bkpt); } - if (db_next_free_breakpoint == &db_break_table[NBREAKPOINTS]) { + if (bkpt_type->db_next_free_breakpoint == + bkpt_type->db_breakpoint_limit) { db_printf("All breakpoints used.\n"); return (0); } - bkpt = db_next_free_breakpoint; - db_next_free_breakpoint++; + bkpt = bkpt_type->db_next_free_breakpoint; + bkpt_type->db_next_free_breakpoint++; return (bkpt); } static void -db_breakpoint_free(db_breakpoint_t bkpt) +db_breakpoint_free(struct db_breakpoint_type *bkpt_type, db_breakpoint_t bkpt) { - bkpt->link = db_free_breakpoints; - db_free_breakpoints = bkpt; + bkpt->link = bkpt_type->db_free_breakpoints; + bkpt_type->db_free_breakpoints = bkpt; } static void -db_set_breakpoint(vm_map_t map, db_addr_t addr, int count) +db_set_breakpoint(struct db_breakpoint_type *bkpt_type, vm_map_t map, + db_addr_t addr, int count) { register db_breakpoint_t bkpt; - if (db_find_breakpoint(map, addr)) { + if (db_find_breakpoint(bkpt_type, map, addr)) { db_printf("Already set.\n"); return; } - bkpt = db_breakpoint_alloc(); + bkpt = db_breakpoint_alloc(bkpt_type); if (bkpt == 0) { db_printf("Too many breakpoints.\n"); return; } bkpt->map = map; bkpt->address = addr; bkpt->flags = 0; bkpt->init_count = count; bkpt->count = count; - bkpt->link = db_breakpoint_list; - db_breakpoint_list = bkpt; + bkpt->link = bkpt_type->db_breakpoint_list; + bkpt_type->db_breakpoint_list = bkpt; } static void -db_delete_breakpoint(vm_map_t map, db_addr_t addr) +db_delete_breakpoint(struct db_breakpoint_type *bkpt_type, vm_map_t map, + db_addr_t addr) { register db_breakpoint_t bkpt; register db_breakpoint_t *prev; - for (prev = &db_breakpoint_list; + for (prev = &bkpt_type->db_breakpoint_list; (bkpt = *prev) != 0; prev = &bkpt->link) { if (db_map_equal(bkpt->map, map) && (bkpt->address == addr)) { *prev = bkpt->link; break; } } if (bkpt == 0) { db_printf("Not set.\n"); return; } - db_breakpoint_free(bkpt); + db_breakpoint_free(bkpt_type, bkpt); } static db_breakpoint_t -db_find_breakpoint(vm_map_t map, db_addr_t addr) +db_find_breakpoint(struct db_breakpoint_type *bkpt_type, vm_map_t map, + db_addr_t addr) { register db_breakpoint_t bkpt; - for (bkpt = db_breakpoint_list; + for (bkpt = bkpt_type->db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) { if (db_map_equal(bkpt->map, map) && (bkpt->address == addr)) return (bkpt); } return (0); } db_breakpoint_t db_find_breakpoint_here(db_addr_t addr) { - return db_find_breakpoint(db_map_addr(addr), addr); + return db_find_breakpoint(&db_breakpoint, db_map_addr(addr), addr); } static bool db_breakpoints_inserted = true; #ifndef BKPT_WRITE #define BKPT_WRITE(addr, storage) \ do { \ *storage = db_get_value(addr, BKPT_SIZE, false); \ db_put_value(addr, BKPT_SIZE, BKPT_SET(*storage)); \ } while (0) #endif #ifndef BKPT_CLEAR #define BKPT_CLEAR(addr, storage) \ db_put_value(addr, BKPT_SIZE, *storage) #endif void db_set_breakpoints(void) { register db_breakpoint_t bkpt; if (!db_breakpoints_inserted) { - for (bkpt = db_breakpoint_list; + for (bkpt = db_breakpoint.db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) if (db_map_current(bkpt->map)) { BKPT_WRITE(bkpt->address, &bkpt->bkpt_inst); } db_breakpoints_inserted = true; } } void db_clear_breakpoints(void) { register db_breakpoint_t bkpt; if (db_breakpoints_inserted) { - for (bkpt = db_breakpoint_list; + for (bkpt = db_breakpoint.db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) if (db_map_current(bkpt->map)) { BKPT_CLEAR(bkpt->address, &bkpt->bkpt_inst); } db_breakpoints_inserted = false; } } /* * List breakpoints. */ static void db_list_breakpoints(void) { register db_breakpoint_t bkpt; - if (db_breakpoint_list == 0) { + if (db_breakpoint.db_breakpoint_list == 0) { db_printf("No breakpoints set\n"); return; } db_printf(" Map Count Address\n"); - for (bkpt = db_breakpoint_list; + for (bkpt = db_breakpoint.db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) { db_printf("%s%8p %5d ", db_map_current(bkpt->map) ? "*" : " ", (void *)bkpt->map, bkpt->init_count); db_printsym(bkpt->address, DB_STGY_PROC); db_printf("\n"); } } /* Delete breakpoint */ /*ARGSUSED*/ void db_delete_cmd(db_expr_t addr, bool have_addr, db_expr_t count, char *modif) { - db_delete_breakpoint(db_map_addr(addr), (db_addr_t)addr); + db_delete_breakpoint(&db_breakpoint, db_map_addr(addr), + (db_addr_t)addr); } /* Set breakpoint with skip count */ /*ARGSUSED*/ void db_breakpoint_cmd(db_expr_t addr, bool have_addr, db_expr_t count, char *modif) { if (count == -1) count = 1; - db_set_breakpoint(db_map_addr(addr), (db_addr_t)addr, count); + db_set_breakpoint(&db_breakpoint, db_map_addr(addr), (db_addr_t)addr, + count); } /* list breakpoints */ void db_listbreak_cmd(db_expr_t dummy1, bool dummy2, db_expr_t dummy3, char *dummy4) { db_list_breakpoints(); } /* * We want ddb to be usable before most of the kernel has been * initialized. In particular, current_thread() or kernel_map * (or both) may be null. */ bool db_map_equal(vm_map_t map1, vm_map_t map2) { return ((map1 == map2) || ((map1 == NULL) && (map2 == kernel_map)) || ((map1 == kernel_map) && (map2 == NULL))); } bool db_map_current(vm_map_t map) { #if 0 thread_t thread; return ((map == NULL) || (map == kernel_map) || (((thread = current_thread()) != NULL) && (map == thread->task->map))); #else return (true); #endif } vm_map_t db_map_addr(vm_offset_t addr) { #if 0 thread_t thread; /* * We want to return kernel_map for all * non-user addresses, even when debugging * kernel tasks with their own maps. */ if ((VM_MIN_ADDRESS <= addr) && (addr < VM_MAX_ADDRESS) && ((thread = current_thread()) != NULL)) return thread->task->map; else #endif return kernel_map; }