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