![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_watch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / ddb|
Return to db_watch.c CVS log | Up to [Apple XNU] / XNU / osfmk / ddb |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * HISTORY
27: *
28: * Revision 1.1.1.1 1998/09/22 21:05:48 wsanchez
29: * Import of Mac OS X kernel (~semeria)
30: *
31: * Revision 1.1.1.1 1998/03/07 02:26:09 wsanchez
32: * Import of OSF Mach kernel (~mburg)
33: *
34: * Revision 1.1.12.2 1995/01/06 19:11:06 devrcs
35: * mk6 CR668 - 1.3b26 merge
36: * * Revision 1.1.3.5 1994/05/06 18:40:29 tmt
37: * Merged osc1.3dec/shared with osc1.3b19
38: * Merge Alpha changes into osc1.312b source code.
39: * 64bit cleanup.
40: * * End1.3merge
41: * [1994/11/04 08:50:16 dwm]
42: *
43: * Revision 1.1.12.1 1994/09/23 01:22:53 ezf
44: * change marker to not FREE
45: * [1994/09/22 21:11:33 ezf]
46: *
47: * Revision 1.1.10.1 1994/01/05 19:28:22 bolinger
48: * Be sure to count kernel-loaded tasks as part of kernel address space
49: * in locating watchpoints.
50: * [1994/01/04 17:43:33 bolinger]
51: *
52: * Revision 1.1.3.3 1993/07/27 18:28:31 elliston
53: * Add ANSI prototypes. CR #9523.
54: * [1993/07/27 18:13:30 elliston]
55: *
56: * Revision 1.1.3.2 1993/06/02 23:13:14 jeffc
57: * Added to OSF/1 R1.3 from NMK15.0.
58: * [1993/06/02 20:57:54 jeffc]
59: *
60: * Revision 1.1 1992/09/30 02:01:33 robert
61: * Initial revision
62: *
63: * $EndLog$
64: */
65: /* CMU_HIST */
66: /*
67: * Revision 2.7 91/10/09 16:04:32 af
68: * Revision 2.6.3.1 91/10/05 13:08:50 jeffreyh
69: * Added user space watch point support including non current task.
70: * Changed "map" field of db_watchpoint structure to "task"
71: * for a user to easily understand the target space.
72: * [91/08/29 tak]
73: *
74: * Revision 2.6.3.1 91/10/05 13:08:50 jeffreyh
75: * Added user space watch point support including non current task.
76: * Changed "map" field of db_watchpoint structure to "task"
77: * for a user to easily understand the target space.
78: * [91/08/29 tak]
79: *
80: * Revision 2.6 91/05/14 15:37:30 mrt
81: * Correcting copyright
82: *
83: * Revision 2.5 91/02/05 17:07:27 mrt
84: * Changed to new Mach copyright
85: * [91/01/31 16:20:02 mrt]
86: *
87: * Revision 2.4 91/01/08 15:09:24 rpd
88: * Use db_map_equal, db_map_current, db_map_addr.
89: * [90/11/10 rpd]
90: *
91: * Revision 2.3 90/11/05 14:26:39 rpd
92: * Initialize db_watchpoints_inserted to TRUE.
93: * [90/11/04 rpd]
94: *
95: * Revision 2.2 90/10/25 14:44:16 rwd
96: * Made db_watchpoint_cmd parse a size argument.
97: * [90/10/17 rpd]
98: * Generalized the watchpoint support.
99: * [90/10/16 rwd]
100: * Created.
101: * [90/10/16 rpd]
102: *
103: */
104: /* CMU_ENDHIST */
105: /*
106: * Mach Operating System
107: * Copyright (c) 1991,1990 Carnegie Mellon University
108: * All Rights Reserved.
109: *
110: * Permission to use, copy, modify and distribute this software and its
111: * documentation is hereby granted, provided that both the copyright
112: * notice and this permission notice appear in all copies of the
113: * software, derivative works or modified versions, and any portions
114: * thereof, and that both notices appear in supporting documentation.
115: *
116: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
117: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
118: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
119: *
120: * Carnegie Mellon requests users of this software to return to
121: *
122: * Software Distribution Coordinator or [email protected]
123: * School of Computer Science
124: * Carnegie Mellon University
125: * Pittsburgh PA 15213-3890
126: *
127: * any improvements or extensions that they make and grant Carnegie Mellon
128: * the rights to redistribute these changes.
129: */
130: /*
131: */
132: /*
133: * Author: Richard P. Draves, Carnegie Mellon University
134: * Date: 10/90
135: */
136:
137: #include <mach/boolean.h>
138: #include <mach/vm_param.h>
139: #include <mach/machine/vm_types.h>
140: #include <mach/machine/vm_param.h>
141: #include <vm/vm_map.h>
142:
143: #include <machine/db_machdep.h>
144: #include <ddb/db_lex.h>
145: #include <ddb/db_watch.h>
146: #include <ddb/db_access.h>
147: #include <ddb/db_sym.h>
148: #include <ddb/db_task_thread.h>
149: #include <ddb/db_command.h>
150: #include <ddb/db_expr.h>
151: #include <ddb/db_output.h> /* For db_printf() */
152: #include <ddb/db_run.h> /* For db_single_step() */
153:
154: /*
155: * Watchpoints.
156: */
157:
158: boolean_t db_watchpoints_inserted = TRUE;
159:
160: #define NWATCHPOINTS 100
161: struct db_watchpoint db_watch_table[NWATCHPOINTS];
162: db_watchpoint_t db_next_free_watchpoint = &db_watch_table[0];
163: db_watchpoint_t db_free_watchpoints = 0;
164: db_watchpoint_t db_watchpoint_list = 0;
165:
166: extern vm_map_t kernel_map;
167:
168:
169:
170: /* Prototypes for functions local to this file. XXX -- should be static.
171: */
172:
173: db_watchpoint_t db_watchpoint_alloc(void);
174:
175: void db_watchpoint_free(register db_watchpoint_t watch);
176:
177: void db_set_watchpoint(
178: task_t task,
179: db_addr_t addr,
180: vm_size_t size);
181:
182: void db_delete_watchpoint(
183: task_t task,
184: db_addr_t addr);
185:
186: static int db_get_task(
187: char *modif,
188: task_t *taskp,
189: db_addr_t addr);
190:
191: void db_list_watchpoints(void);
192:
193:
194:
195: db_watchpoint_t
196: db_watchpoint_alloc(void)
197: {
198: register db_watchpoint_t watch;
199:
200: if ((watch = db_free_watchpoints) != 0) {
201: db_free_watchpoints = watch->link;
202: return (watch);
203: }
204: if (db_next_free_watchpoint == &db_watch_table[NWATCHPOINTS]) {
205: db_printf("All watchpoints used.\n");
206: return (0);
207: }
208: watch = db_next_free_watchpoint;
209: db_next_free_watchpoint++;
210:
211: return (watch);
212: }
213:
214: void
215: db_watchpoint_free(register db_watchpoint_t watch)
216: {
217: watch->link = db_free_watchpoints;
218: db_free_watchpoints = watch;
219: }
220:
221: void
222: db_set_watchpoint(
223: task_t task,
224: db_addr_t addr,
225: vm_size_t size)
226: {
227: register db_watchpoint_t watch;
228:
229: /*
230: * Should we do anything fancy with overlapping regions?
231: */
232:
233: for (watch = db_watchpoint_list; watch != 0; watch = watch->link) {
234: if (watch->task == task &&
235: (watch->loaddr == addr) &&
236: (watch->hiaddr == addr+size)) {
237: db_printf("Already set.\n");
238: return;
239: }
240: }
241:
242: watch = db_watchpoint_alloc();
243: if (watch == 0) {
244: db_printf("Too many watchpoints.\n");
245: return;
246: }
247:
248: watch->task = task;
249: watch->loaddr = addr;
250: watch->hiaddr = addr+size;
251:
252: watch->link = db_watchpoint_list;
253: db_watchpoint_list = watch;
254:
255: db_watchpoints_inserted = FALSE;
256: }
257:
258: void
259: db_delete_watchpoint(
260: task_t task,
261: db_addr_t addr)
262: {
263: register db_watchpoint_t watch;
264: register db_watchpoint_t *prev;
265:
266: for (prev = &db_watchpoint_list; (watch = *prev) != 0;
267: prev = &watch->link) {
268: if (watch->task == task &&
269: (watch->loaddr <= addr) &&
270: (addr < watch->hiaddr)) {
271: *prev = watch->link;
272: db_watchpoint_free(watch);
273: return;
274: }
275: }
276:
277: db_printf("Not set.\n");
278: }
279:
280: void
281: db_list_watchpoints(void)
282: {
283: register db_watchpoint_t watch;
284: int task_id;
285:
286: if (db_watchpoint_list == 0) {
287: db_printf("No watchpoints set\n");
288: return;
289: }
290:
291: db_printf("Space Address Size\n");
292: for (watch = db_watchpoint_list; watch != 0; watch = watch->link) {
293: if (watch->task == TASK_NULL)
294: db_printf("kernel ");
295: else {
296: task_id = db_lookup_task(watch->task);
297: if (task_id < 0)
298: db_printf("%*X", 2*sizeof(vm_offset_t), watch->task);
299: else
300: db_printf("task%-3d ", task_id);
301: }
302: db_printf(" %*X %X\n", 2*sizeof(vm_offset_t), watch->loaddr,
303: watch->hiaddr - watch->loaddr);
304: }
305: }
306:
307: static int
308: db_get_task(
309: char *modif,
310: task_t *taskp,
311: db_addr_t addr)
312: {
313: task_t task = TASK_NULL;
314: db_expr_t value;
315: boolean_t user_space;
316:
317: user_space = db_option(modif, 'T');
318: if (user_space) {
319: if (db_expression(&value)) {
320: task = (task_t)value;
321: if (db_lookup_task(task) < 0) {
322: db_printf("bad task address %X\n", task);
323: return(-1);
324: }
325: } else {
326: task = db_default_task;
327: if (task == TASK_NULL) {
328: if ((task = db_current_task()) == TASK_NULL) {
329: db_printf("no task\n");
330: return(-1);
331: }
332: }
333: }
334: }
335: if (!DB_VALID_ADDRESS(addr, user_space)) {
336: db_printf("Address %#X is not in %s space\n", addr,
337: (user_space)? "user": "kernel");
338: return(-1);
339: }
340: *taskp = task;
341: return(0);
342: }
343:
344: /* Delete watchpoint */
345: void
346: db_deletewatch_cmd(
347: db_expr_t addr,
348: int have_addr,
349: db_expr_t count,
350: char * modif)
351: {
352: task_t task;
353:
354: if (db_get_task(modif, &task, addr) < 0)
355: return;
356: db_delete_watchpoint(task, addr);
357: }
358:
359: /* Set watchpoint */
360: void
361: db_watchpoint_cmd(
362: db_expr_t addr,
363: int have_addr,
364: db_expr_t count,
365: char * modif)
366: {
367: vm_size_t size;
368: db_expr_t value;
369: task_t task;
370:
371: if (db_get_task(modif, &task, addr) < 0)
372: return;
373: if (db_expression(&value))
374: size = (vm_size_t) value;
375: else
376: size = sizeof(int);
377: db_set_watchpoint(task, addr, size);
378: }
379:
380: /* list watchpoints */
381: void
382: db_listwatch_cmd(void)
383: {
384: db_list_watchpoints();
385: }
386:
387: void
388: db_set_watchpoints(void)
389: {
390: register db_watchpoint_t watch;
391: vm_map_t map;
392:
393: if (!db_watchpoints_inserted) {
394: for (watch = db_watchpoint_list; watch != 0; watch = watch->link) {
395: map = (watch->task)? watch->task->map: kernel_map;
396: pmap_protect(map->pmap,
397: trunc_page(watch->loaddr),
398: round_page(watch->hiaddr),
399: VM_PROT_READ);
400: }
401: db_watchpoints_inserted = TRUE;
402: }
403: }
404:
405: void
406: db_clear_watchpoints(void)
407: {
408: db_watchpoints_inserted = FALSE;
409: }
410:
411: boolean_t
412: db_find_watchpoint(
413: vm_map_t map,
414: db_addr_t addr,
415: db_regs_t *regs)
416: {
417: register db_watchpoint_t watch;
418: db_watchpoint_t found = 0;
419: register task_t task_space;
420:
421: task_space = (vm_map_pmap(map) == kernel_pmap)?
422: TASK_NULL: db_current_space();
423: for (watch = db_watchpoint_list; watch != 0; watch = watch->link) {
424: if (watch->task == task_space) {
425: if ((watch->loaddr <= addr) && (addr < watch->hiaddr))
426: return (TRUE);
427: else if ((trunc_page(watch->loaddr) <= addr) &&
428: (addr < round_page(watch->hiaddr)))
429: found = watch;
430: }
431: }
432:
433: /*
434: * We didn't hit exactly on a watchpoint, but we are
435: * in a protected region. We want to single-step
436: * and then re-protect.
437: */
438:
439: if (found) {
440: db_watchpoints_inserted = FALSE;
441: db_single_step(regs, task_space);
442: }
443:
444: return (FALSE);
445: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.