![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_break.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / ddb|
Return to db_break.c CVS log | Up to [GnuMach] / Gnu-Mach / ddb |
1.1 root 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 "AS IS"
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 [email protected]
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 Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * Author: David B. Golub, Carnegie Mellon University
28: * Date: 7/90
29: */
30: #include "mach_kdb.h"
31: #if MACH_KDB
32:
33:
34: /*
35: * Breakpoints.
36: */
37: #include <mach/boolean.h>
38: #include <machine/db_machdep.h>
39: #include <ddb/db_lex.h>
40: #include <ddb/db_break.h>
41: #include <ddb/db_access.h>
42: #include <ddb/db_sym.h>
43: #include <ddb/db_variables.h>
44: #include <ddb/db_command.h>
45: #include <ddb/db_task_thread.h>
46:
47: #define NBREAKPOINTS 100
48: #define NTHREAD_LIST (NBREAKPOINTS*3)
49:
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: static struct db_thread_breakpoint db_thread_break_list[NTHREAD_LIST];
56: static db_thread_breakpoint_t db_free_thread_break_list = 0;
57: static boolean_t db_thread_break_init = FALSE;
58: static int db_breakpoint_number = 0;
59:
60: 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: 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 int
88: db_add_thread_breakpoint(bkpt, task_thd, count, task_bpt)
89: register db_breakpoint_t bkpt;
90: vm_offset_t task_thd;
91: boolean_t task_bpt;
92: {
93: register db_thread_breakpoint_t tp;
94:
95: if (db_thread_break_init == FALSE) {
96: for (tp = db_thread_break_list;
97: tp < &db_thread_break_list[NTHREAD_LIST-1]; tp++)
98: tp->tb_next = tp+1;
99: tp->tb_next = 0;
100: db_free_thread_break_list = db_thread_break_list;
101: db_thread_break_init = TRUE;
102: }
103: if (db_free_thread_break_list == 0)
104: return (-1);
105: tp = db_free_thread_break_list;
106: db_free_thread_break_list = tp->tb_next;
107: tp->tb_is_task = task_bpt;
108: tp->tb_task_thd = task_thd;
109: tp->tb_count = count;
110: tp->tb_init_count = count;
111: tp->tb_cond = 0;
112: tp->tb_number = ++db_breakpoint_number;
113: tp->tb_next = bkpt->threads;
114: bkpt->threads = tp;
115: return(0);
116: }
117:
118: static int
119: db_delete_thread_breakpoint(bkpt, task_thd)
120: register db_breakpoint_t bkpt;
121: vm_offset_t task_thd;
122: {
123: register db_thread_breakpoint_t tp;
124: register db_thread_breakpoint_t *tpp;
125: void db_cond_free();
126:
127: if (task_thd == 0) {
128: /* delete all the thread-breakpoints */
129:
130: for (tpp = &bkpt->threads; (tp = *tpp) != 0; tpp = &tp->tb_next)
131: db_cond_free(tp);
132:
133: *tpp = db_free_thread_break_list;
134: db_free_thread_break_list = bkpt->threads;
135: bkpt->threads = 0;
136: return 0;
137: } else {
138: /* delete the specified thread-breakpoint */
139:
140: for (tpp = &bkpt->threads; (tp = *tpp) != 0; tpp = &tp->tb_next)
141: if (tp->tb_task_thd == task_thd) {
142: db_cond_free(tp);
143: *tpp = tp->tb_next;
144: tp->tb_next = db_free_thread_break_list;
145: db_free_thread_break_list = tp;
146: return 0;
147: }
148:
149: return -1; /* not found */
150: }
151: }
152:
153: static db_thread_breakpoint_t
154: db_find_thread_breakpoint(bkpt, thread)
155: db_breakpoint_t bkpt;
156: thread_t thread;
157: {
158: register db_thread_breakpoint_t tp;
159: register task_t task = (thread == THREAD_NULL)? TASK_NULL: thread->task;
160:
161: for (tp = bkpt->threads; tp; tp = tp->tb_next) {
162: if (tp->tb_is_task) {
163: if (tp->tb_task_thd == (vm_offset_t)task)
164: break;
165: continue;
166: }
167: if (tp->tb_task_thd == (vm_offset_t)thread || tp->tb_task_thd == 0)
168: break;
169: }
170: return(tp);
171: }
172:
173: db_thread_breakpoint_t
174: db_find_thread_breakpoint_here(task, addr)
175: task_t task;
176: db_addr_t addr;
177: {
178: db_breakpoint_t bkpt;
179:
180: bkpt = db_find_breakpoint(task, (db_addr_t)addr);
181: if (bkpt == 0)
182: return(0);
183: return(db_find_thread_breakpoint(bkpt, current_thread()));
184: }
185:
186: db_thread_breakpoint_t
187: db_find_breakpoint_number(num, bkptp)
188: int num;
189: db_breakpoint_t *bkptp;
190: {
191: register db_thread_breakpoint_t tp;
192: register db_breakpoint_t bkpt;
193:
194: for (bkpt = db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) {
195: for (tp = bkpt->threads; tp; tp = tp->tb_next) {
196: if (tp->tb_number == num) {
197: if (bkptp)
198: *bkptp = bkpt;
199: return(tp);
200: }
201: }
202: }
203: return(0);
204: }
205:
206: static void
207: db_force_delete_breakpoint(bkpt, task_thd, is_task)
208: db_breakpoint_t bkpt;
209: vm_offset_t task_thd;
210: boolean_t is_task;
211: {
212: db_printf("deleted a stale breakpoint at ");
213: if (bkpt->task == TASK_NULL || db_lookup_task(bkpt->task) >= 0)
214: db_task_printsym(bkpt->address, DB_STGY_PROC, bkpt->task);
215: else
216: db_printf("%#X", bkpt->address);
217: if (bkpt->task)
218: db_printf(" in task %X", bkpt->task);
219: if (task_thd)
220: db_printf(" for %s %X", (is_task)? "task": "thread", task_thd);
221: db_printf("\n");
222: db_delete_thread_breakpoint(bkpt, task_thd);
223: }
224:
225: void
226: db_check_breakpoint_valid()
227: {
228: register db_thread_breakpoint_t tbp, tbp_next;
229: register db_breakpoint_t bkpt, *bkptp;
230:
231: bkptp = &db_breakpoint_list;
232: for (bkpt = *bkptp; bkpt; bkpt = *bkptp) {
233: if (bkpt->task != TASK_NULL) {
234: if (db_lookup_task(bkpt->task) < 0) {
235: db_force_delete_breakpoint(bkpt, 0, FALSE);
236: *bkptp = bkpt->link;
237: db_breakpoint_free(bkpt);
238: continue;
239: }
240: } else {
241: for (tbp = bkpt->threads; tbp; tbp = tbp_next) {
242: tbp_next = tbp->tb_next;
243: if (tbp->tb_task_thd == 0)
244: continue;
245: if ((tbp->tb_is_task &&
246: db_lookup_task((task_t)(tbp->tb_task_thd)) < 0) ||
247: (!tbp->tb_is_task &&
248: db_lookup_thread((thread_t)(tbp->tb_task_thd)) < 0)) {
249: db_force_delete_breakpoint(bkpt,
250: tbp->tb_task_thd, tbp->tb_is_task);
251: }
252: }
253: if (bkpt->threads == 0) {
254: db_put_task_value(bkpt->address, BKPT_SIZE,
255: bkpt->bkpt_inst, bkpt->task);
256: *bkptp = bkpt->link;
257: db_breakpoint_free(bkpt);
258: continue;
259: }
260: }
261: bkptp = &bkpt->link;
262: }
263: }
264:
265: void
266: db_set_breakpoint(task, addr, count, thread, task_bpt)
267: task_t task;
268: db_addr_t addr;
269: int count;
270: thread_t thread;
271: boolean_t task_bpt;
272: {
273: register db_breakpoint_t bkpt;
274: db_breakpoint_t alloc_bkpt = 0;
275: vm_offset_t task_thd;
276:
277: bkpt = db_find_breakpoint(task, addr);
278: if (bkpt) {
279: if (thread == THREAD_NULL
280: || db_find_thread_breakpoint(bkpt, thread)) {
281: db_printf("Already set.\n");
282: return;
283: }
284: } else {
285: if (!DB_CHECK_ACCESS(addr, BKPT_SIZE, task)) {
286: db_printf("Cannot set break point at %X\n", addr);
287: return;
288: }
289: alloc_bkpt = bkpt = db_breakpoint_alloc();
290: if (bkpt == 0) {
291: db_printf("Too many breakpoints.\n");
292: return;
293: }
294: bkpt->task = task;
295: bkpt->flags = (task && thread == THREAD_NULL)?
296: (BKPT_USR_GLOBAL|BKPT_1ST_SET): 0;
297: bkpt->address = addr;
298: bkpt->threads = 0;
299: }
300: if (db_breakpoint_list == 0)
301: db_breakpoint_number = 0;
302: task_thd = (task_bpt)? (vm_offset_t)(thread->task): (vm_offset_t)thread;
303: if (db_add_thread_breakpoint(bkpt, task_thd, count, task_bpt) < 0) {
304: if (alloc_bkpt)
305: db_breakpoint_free(alloc_bkpt);
306: db_printf("Too many thread_breakpoints.\n");
307: } else {
308: db_printf("set breakpoint #%d\n", db_breakpoint_number);
309: if (alloc_bkpt) {
310: bkpt->link = db_breakpoint_list;
311: db_breakpoint_list = bkpt;
312: }
313: }
314: }
315:
316: void
317: db_delete_breakpoint(task, addr, task_thd)
318: task_t task;
319: db_addr_t addr;
320: vm_offset_t task_thd;
321: {
322: register db_breakpoint_t bkpt;
323: register db_breakpoint_t *prev;
324:
325: for (prev = &db_breakpoint_list; (bkpt = *prev) != 0;
326: prev = &bkpt->link) {
327: if ((bkpt->task == task
328: || (task != TASK_NULL && (bkpt->flags & BKPT_USR_GLOBAL)))
329: && bkpt->address == addr)
330: break;
331: }
332: if (bkpt && (bkpt->flags & BKPT_SET_IN_MEM)) {
333: db_printf("cannot delete it now.\n");
334: return;
335: }
336: if (bkpt == 0
337: || db_delete_thread_breakpoint(bkpt, task_thd) < 0) {
338: db_printf("Not set.\n");
339: return;
340: }
341: if (bkpt->threads == 0) {
342: *prev = bkpt->link;
343: db_breakpoint_free(bkpt);
344: }
345: }
346:
347: db_breakpoint_t
348: db_find_breakpoint(task, addr)
349: task_t task;
350: db_addr_t addr;
351: {
352: register db_breakpoint_t bkpt;
353:
354: for (bkpt = db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) {
355: if ((bkpt->task == task
356: || (task != TASK_NULL && (bkpt->flags & BKPT_USR_GLOBAL)))
357: && bkpt->address == addr)
358: return (bkpt);
359: }
360: return (0);
361: }
362:
363: boolean_t
364: db_find_breakpoint_here(task, addr)
365: task_t task;
366: db_addr_t addr;
367: {
368: register db_breakpoint_t bkpt;
369:
370: for (bkpt = db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) {
371: if ((bkpt->task == task
372: || (task != TASK_NULL && (bkpt->flags & BKPT_USR_GLOBAL)))
373: && bkpt->address == addr)
374: return(TRUE);
375: if ((bkpt->flags & BKPT_USR_GLOBAL) == 0 &&
376: DB_PHYS_EQ(task, (vm_offset_t)addr, bkpt->task, (vm_offset_t)bkpt->address))
377: return (TRUE);
378: }
379: return(FALSE);
380: }
381:
382: boolean_t db_breakpoints_inserted = TRUE;
383:
384: void
385: db_set_breakpoints()
386: {
387: register db_breakpoint_t bkpt;
388: register task_t task;
389: db_expr_t inst;
390: task_t cur_task;
391:
392: cur_task = (current_thread())? current_thread()->task: TASK_NULL;
393: if (!db_breakpoints_inserted) {
394: for (bkpt = db_breakpoint_list; bkpt != 0; bkpt = bkpt->link) {
395: if (bkpt->flags & BKPT_SET_IN_MEM)
396: continue;
397: task = bkpt->task;
398: if (bkpt->flags & BKPT_USR_GLOBAL) {
399: if ((bkpt->flags & BKPT_1ST_SET) == 0) {
400: if (cur_task == TASK_NULL)
401: continue;
402: task = cur_task;
403: } else
404: bkpt->flags &= ~BKPT_1ST_SET;
405: }
406: if (DB_CHECK_ACCESS(bkpt->address, BKPT_SIZE, task)) {
407: inst = db_get_task_value(bkpt->address, BKPT_SIZE, FALSE,
408: task);
409: if (inst == BKPT_SET(inst))
410: continue;
411: bkpt->bkpt_inst = inst;
412: db_put_task_value(bkpt->address,
413: BKPT_SIZE,
414: BKPT_SET(bkpt->bkpt_inst), task);
415: bkpt->flags |= BKPT_SET_IN_MEM;
416: } else {
417: db_printf("Warning: cannot set breakpoint at %X ",
418: bkpt->address);
419: if (task)
420: db_printf("in task %X\n", task);
421: else
422: db_printf("in kernel space\n");
423: }
424: }
425: db_breakpoints_inserted = TRUE;
426: }
427: }
428:
429: void
430: db_clear_breakpoints()
431: {
432: register db_breakpoint_t bkpt, *bkptp;
433: register task_t task;
434: task_t cur_task;
435: db_expr_t inst;
436:
437: cur_task = (current_thread())? current_thread()->task: TASK_NULL;
438: if (db_breakpoints_inserted) {
439: bkptp = &db_breakpoint_list;
440: for (bkpt = *bkptp; bkpt; bkpt = *bkptp) {
441: task = bkpt->task;
442: if (bkpt->flags & BKPT_USR_GLOBAL) {
443: if (cur_task == TASK_NULL) {
444: bkptp = &bkpt->link;
445: continue;
446: }
447: task = cur_task;
448: }
449: if ((bkpt->flags & BKPT_SET_IN_MEM)
450: && DB_CHECK_ACCESS(bkpt->address, BKPT_SIZE, task)) {
451: inst = db_get_task_value(bkpt->address, BKPT_SIZE, FALSE,
452: task);
453: if (inst != BKPT_SET(inst)) {
454: if (bkpt->flags & BKPT_USR_GLOBAL) {
455: bkptp = &bkpt->link;
456: continue;
457: }
458: db_force_delete_breakpoint(bkpt, 0, FALSE);
459: *bkptp = bkpt->link;
460: db_breakpoint_free(bkpt);
461: continue;
462: }
463: db_put_task_value(bkpt->address, BKPT_SIZE,
464: bkpt->bkpt_inst, task);
465: bkpt->flags &= ~BKPT_SET_IN_MEM;
466: }
467: bkptp = &bkpt->link;
468: }
469: db_breakpoints_inserted = FALSE;
470: }
471: }
472:
473: /*
474: * Set a temporary breakpoint.
475: * The instruction is changed immediately,
476: * so the breakpoint does not have to be on the breakpoint list.
477: */
478: db_breakpoint_t
479: db_set_temp_breakpoint(task, addr)
480: task_t task;
481: db_addr_t addr;
482: {
483: register db_breakpoint_t bkpt;
484:
485: bkpt = db_breakpoint_alloc();
486: if (bkpt == 0) {
487: db_printf("Too many breakpoints.\n");
488: return 0;
489: }
490: bkpt->task = task;
491: bkpt->address = addr;
492: bkpt->flags = BKPT_TEMP;
493: bkpt->threads = 0;
494: if (db_add_thread_breakpoint(bkpt, 0, 1, FALSE) < 0) {
495: if (bkpt)
496: db_breakpoint_free(bkpt);
497: db_printf("Too many thread_breakpoints.\n");
498: return 0;
499: }
500: bkpt->bkpt_inst = db_get_task_value(bkpt->address, BKPT_SIZE,
501: FALSE, task);
502: db_put_task_value(bkpt->address, BKPT_SIZE,
503: BKPT_SET(bkpt->bkpt_inst), task);
504: return bkpt;
505: }
506:
507: void
508: db_delete_temp_breakpoint(task, bkpt)
509: task_t task;
510: db_breakpoint_t bkpt;
511: {
512: db_put_task_value(bkpt->address, BKPT_SIZE, bkpt->bkpt_inst, task);
513: db_delete_thread_breakpoint(bkpt, 0);
514: db_breakpoint_free(bkpt);
515: }
516:
517: /*
518: * List breakpoints.
519: */
520: void
521: db_list_breakpoints()
522: {
523: register db_breakpoint_t bkpt;
524:
525: if (db_breakpoint_list == 0) {
526: db_printf("No breakpoints set\n");
527: return;
528: }
529:
530: db_printf(" No Space Thread Cnt Address(Cond)\n");
531: for (bkpt = db_breakpoint_list;
532: bkpt != 0;
533: bkpt = bkpt->link)
534: {
535: register db_thread_breakpoint_t tp;
536: int task_id;
537: int thread_id;
538:
539: if (bkpt->threads) {
540: for (tp = bkpt->threads; tp; tp = tp->tb_next) {
541: db_printf("%3d ", tp->tb_number);
542: if (bkpt->flags & BKPT_USR_GLOBAL)
543: db_printf("user ");
544: else if (bkpt->task == TASK_NULL)
545: db_printf("kernel ");
546: else if ((task_id = db_lookup_task(bkpt->task)) < 0)
547: db_printf("%0*X ", 2*sizeof(vm_offset_t), bkpt->task);
548: else
549: db_printf("task%-3d ", task_id);
550: if (tp->tb_task_thd == 0) {
551: db_printf("all ");
552: } else {
553: if (tp->tb_is_task) {
554: task_id = db_lookup_task((task_t)(tp->tb_task_thd));
555: if (task_id < 0)
556: db_printf("%0*X ", 2*sizeof(vm_offset_t),
557: tp->tb_task_thd);
558: else
559: db_printf("task%03d ", task_id);
560: } else {
561: thread_t thd = (thread_t)(tp->tb_task_thd);
562: task_id = db_lookup_task(thd->task);
563: thread_id = db_lookup_task_thread(thd->task, thd);
564: if (task_id < 0 || thread_id < 0)
565: db_printf("%0*X ", 2*sizeof(vm_offset_t),
566: tp->tb_task_thd);
567: else
568: db_printf("task%03d.%-3d ", task_id, thread_id);
569: }
570: }
571: db_printf("%3d ", tp->tb_init_count);
572: db_task_printsym(bkpt->address, DB_STGY_PROC, bkpt->task);
573: if (tp->tb_cond > 0) {
574: db_printf("(");
575: db_cond_print(tp);
576: db_printf(")");
577: }
578: db_printf("\n");
579: }
580: } else {
581: if (bkpt->task == TASK_NULL)
582: db_printf(" ? kernel ");
583: else
584: db_printf("%*X ", 2*sizeof(vm_offset_t), bkpt->task);
585: db_printf("(?) ");
586: db_task_printsym(bkpt->address, DB_STGY_PROC, bkpt->task);
587: db_printf("\n");
588: }
589: }
590: }
591:
592: /* Delete breakpoint */
593: /*ARGSUSED*/
594: void
595: db_delete_cmd()
596: {
597: register n;
598: thread_t thread;
599: vm_offset_t task_thd;
600: boolean_t user_global = FALSE;
601: boolean_t task_bpt = FALSE;
602: boolean_t user_space = FALSE;
603: boolean_t thd_bpt = FALSE;
604: db_expr_t addr;
605: int t;
606:
607: t = db_read_token();
608: if (t == tSLASH) {
609: t = db_read_token();
610: if (t != tIDENT) {
611: db_printf("Bad modifier \"%s\"\n", db_tok_string);
612: db_error(0);
613: }
614: user_global = db_option(db_tok_string, 'U');
615: user_space = (user_global)? TRUE: db_option(db_tok_string, 'u');
616: task_bpt = db_option(db_tok_string, 'T');
617: thd_bpt = db_option(db_tok_string, 't');
618: if (task_bpt && user_global)
619: db_error("Cannot specify both 'T' and 'U' option\n");
620: t = db_read_token();
621: }
622: if (t == tHASH) {
623: db_thread_breakpoint_t tbp;
624: db_breakpoint_t bkpt;
625:
626: if (db_read_token() != tNUMBER) {
627: db_printf("Bad break point number #%s\n", db_tok_string);
628: db_error(0);
629: }
630: if ((tbp = db_find_breakpoint_number(db_tok_number, &bkpt)) == 0) {
631: db_printf("No such break point #%d\n", db_tok_number);
632: db_error(0);
633: }
634: db_delete_breakpoint(bkpt->task, bkpt->address, tbp->tb_task_thd);
635: return;
636: }
637: db_unread_token(t);
638: if (!db_expression(&addr)) {
639: /*
640: * We attempt to pick up the user_space indication from db_dot,
641: * so that a plain "d" always works.
642: */
643: addr = (db_expr_t)db_dot;
644: if (!user_space && !DB_VALID_ADDRESS((vm_offset_t)addr, FALSE))
645: user_space = TRUE;
646: }
647: if (!DB_VALID_ADDRESS((vm_offset_t) addr, user_space)) {
648: db_printf("Address %#X is not in %s space\n", addr,
649: (user_space)? "user": "kernel");
650: db_error(0);
651: }
652: if (thd_bpt || task_bpt) {
653: for (n = 0; db_get_next_thread(&thread, n); n++) {
654: if (thread == THREAD_NULL)
655: db_error("No active thread\n");
656: if (task_bpt) {
657: if (thread->task == TASK_NULL)
658: db_error("No task\n");
659: task_thd = (vm_offset_t) (thread->task);
660: } else
661: task_thd = (user_global)? 0: (vm_offset_t) thread;
662: db_delete_breakpoint(db_target_space(thread, user_space),
663: (db_addr_t)addr, task_thd);
664: }
665: } else {
666: db_delete_breakpoint(db_target_space(THREAD_NULL, user_space),
667: (db_addr_t)addr, 0);
668: }
669: }
670:
671: /* Set breakpoint with skip count */
672: /*ARGSUSED*/
673: void
674: db_breakpoint_cmd(addr, have_addr, count, modif)
675: db_expr_t addr;
676: int have_addr;
677: db_expr_t count;
678: char * modif;
679: {
680: register n;
681: thread_t thread;
682: boolean_t user_global = db_option(modif, 'U');
683: boolean_t task_bpt = db_option(modif, 'T');
684: boolean_t user_space;
685:
686: if (count == -1)
687: count = 1;
688:
689: if (!task_bpt && db_option(modif,'t'))
690: task_bpt = TRUE;
691:
692: if (task_bpt && user_global)
693: db_error("Cannot specify both 'T' and 'U'\n");
694: user_space = (user_global)? TRUE: db_option(modif, 'u');
695: if (user_space && db_access_level < DB_ACCESS_CURRENT)
696: db_error("User space break point is not supported\n");
697: if (!task_bpt && !DB_VALID_ADDRESS((vm_offset_t)addr, user_space)) {
698: /* if the user has explicitly specified user space,
699: do not insert a breakpoint into the kernel */
700: if (user_space)
701: db_error("Invalid user space address\n");
702: user_space = TRUE;
703: db_printf("%#X is in user space\n", addr);
704: }
705: if (db_option(modif, 't') || task_bpt) {
706: for (n = 0; db_get_next_thread(&thread, n); n++) {
707: if (thread == THREAD_NULL)
708: db_error("No active thread\n");
709: if (task_bpt && thread->task == TASK_NULL)
710: db_error("No task\n");
711: if (db_access_level <= DB_ACCESS_CURRENT && user_space
712: && thread->task != db_current_task())
713: db_error("Cannot set break point in inactive user space\n");
714: db_set_breakpoint(db_target_space(thread, user_space),
715: (db_addr_t)addr, count,
716: (user_global)? THREAD_NULL: thread,
717: task_bpt);
718: }
719: } else {
720: db_set_breakpoint(db_target_space(THREAD_NULL, user_space),
721: (db_addr_t)addr,
722: count, THREAD_NULL, FALSE);
723: }
724: }
725:
726: /* list breakpoints */
727: void
728: db_listbreak_cmd()
729: {
730: db_list_breakpoints();
731: }
732:
733: #endif MACH_KDB
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.