![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_interface.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / i386|
Return to db_interface.c CVS log | Up to [Apple XNU] / XNU / osfmk / i386 |
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: * Mach Operating System ! 27: * Copyright (c) 1991,1990 Carnegie Mellon University ! 28: * All Rights Reserved. ! 29: * ! 30: * Permission to use, copy, modify and distribute this software and its ! 31: * documentation is hereby granted, provided that both the copyright ! 32: * notice and this permission notice appear in all copies of the ! 33: * software, derivative works or modified versions, and any portions ! 34: * thereof, and that both notices appear in supporting documentation. ! 35: * ! 36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 39: * ! 40: * Carnegie Mellon requests users of this software to return to ! 41: * ! 42: * Software Distribution Coordinator or [email protected] ! 43: * School of Computer Science ! 44: * Carnegie Mellon University ! 45: * Pittsburgh PA 15213-3890 ! 46: * ! 47: * any improvements or extensions that they make and grant Carnegie Mellon ! 48: * the rights to redistribute these changes. ! 49: */ ! 50: /* ! 51: */ ! 52: ! 53: /* ! 54: * Interface to new debugger. ! 55: */ ! 56: #include <cpus.h> ! 57: #include <platforms.h> ! 58: #include <time_stamp.h> ! 59: #include <mach_mp_debug.h> ! 60: #include <mach_ldebug.h> ! 61: #include <kern/spl.h> ! 62: #include <kern/cpu_number.h> ! 63: #include <kern/kern_types.h> ! 64: #include <kern/misc_protos.h> ! 65: #include <vm/pmap.h> ! 66: ! 67: #include <i386/thread.h> ! 68: #include <i386/db_machdep.h> ! 69: #include <i386/seg.h> ! 70: #include <i386/trap.h> ! 71: #include <i386/setjmp.h> ! 72: #include <i386/pmap.h> ! 73: #include <i386/misc_protos.h> ! 74: ! 75: #include <mach/vm_param.h> ! 76: #include <vm/vm_map.h> ! 77: #include <kern/thread.h> ! 78: #include <kern/task.h> ! 79: ! 80: #include <ddb/db_command.h> ! 81: #include <ddb/db_task_thread.h> ! 82: #include <ddb/db_run.h> ! 83: #include <ddb/db_trap.h> ! 84: #include <ddb/db_output.h> ! 85: #include <ddb/db_access.h> ! 86: #include <ddb/db_sym.h> ! 87: #include <ddb/db_break.h> ! 88: #include <ddb/db_watch.h> ! 89: ! 90: int db_active = 0; ! 91: int db_pass_thru[NCPUS]; ! 92: struct i386_saved_state *i386_last_saved_statep; ! 93: struct i386_saved_state i386_nested_saved_state; ! 94: unsigned i386_last_kdb_sp; ! 95: ! 96: vm_offset_t db_stacks[NCPUS]; ! 97: ! 98: extern thread_act_t db_default_act; ! 99: ! 100: #if MACH_MP_DEBUG ! 101: extern int masked_state_cnt[]; ! 102: #endif /* MACH_MP_DEBUG */ ! 103: ! 104: /* ! 105: * Enter KDB through a keyboard trap. ! 106: * We show the registers as of the keyboard interrupt ! 107: * instead of those at its call to KDB. ! 108: */ ! 109: struct int_regs { ! 110: int gs; ! 111: int fs; ! 112: int edi; ! 113: int esi; ! 114: int ebp; ! 115: int ebx; ! 116: struct i386_interrupt_state *is; ! 117: }; ! 118: ! 119: extern char * trap_type[]; ! 120: extern int TRAP_TYPES; ! 121: ! 122: /* Forward */ ! 123: ! 124: extern void kdbprinttrap( ! 125: int type, ! 126: int code, ! 127: int *pc, ! 128: int sp); ! 129: extern void kdb_kentry( ! 130: struct int_regs *int_regs); ! 131: extern int db_user_to_kernel_address( ! 132: task_t task, ! 133: vm_offset_t addr, ! 134: unsigned *kaddr, ! 135: int flag); ! 136: extern void db_write_bytes_user_space( ! 137: vm_offset_t addr, ! 138: int size, ! 139: char *data, ! 140: task_t task); ! 141: extern int db_search_null( ! 142: task_t task, ! 143: unsigned *svaddr, ! 144: unsigned evaddr, ! 145: unsigned *skaddr, ! 146: int flag); ! 147: extern int kdb_enter(int); ! 148: extern void kdb_leave(void); ! 149: extern void lock_kdb(void); ! 150: extern void unlock_kdb(void); ! 151: ! 152: /* ! 153: * kdb_trap - field a TRACE or BPT trap ! 154: */ ! 155: ! 156: ! 157: extern jmp_buf_t *db_recover; ! 158: spl_t saved_ipl[NCPUS]; /* just to know what IPL was before trap */ ! 159: struct i386_saved_state *saved_state[NCPUS]; ! 160: ! 161: /* ! 162: * Translate the state saved in a task state segment into an ! 163: * exception frame. Since we "know" we always want the state ! 164: * in a ktss, we hard-wire that in, rather than indexing the gdt ! 165: * with tss_sel to derive a pointer to the desired tss. ! 166: */ ! 167: void ! 168: db_tss_to_frame( ! 169: int tss_sel, ! 170: struct i386_saved_state *regs) ! 171: { ! 172: extern struct i386_tss ktss; ! 173: int mycpu = cpu_number(); ! 174: struct i386_tss *tss; ! 175: ! 176: #if NCPUS == 1 ! 177: tss = &ktss; /* XXX */ ! 178: #else /* NCPUS > 1 */ ! 179: tss = mp_ktss[mycpu]; /* XXX */ ! 180: #endif /* NCPUS > 1 */ ! 181: ! 182: /* ! 183: * ddb will overwrite whatever's in esp, so put esp0 elsewhere, too. ! 184: */ ! 185: regs->esp = tss->esp0; ! 186: regs->efl = tss->eflags; ! 187: regs->eip = tss->eip; ! 188: regs->trapno = tss->ss0; /* XXX */ ! 189: regs->err = tss->esp0; /* XXX */ ! 190: regs->eax = tss->eax; ! 191: regs->ecx = tss->ecx; ! 192: regs->edx = tss->edx; ! 193: regs->ebx = tss->ebx; ! 194: regs->uesp = tss->esp; ! 195: regs->ebp = tss->ebp; ! 196: regs->esi = tss->esi; ! 197: regs->edi = tss->edi; ! 198: regs->es = tss->es; ! 199: regs->ss = tss->ss; ! 200: regs->cs = tss->cs; ! 201: regs->ds = tss->ds; ! 202: regs->fs = tss->fs; ! 203: regs->gs = tss->gs; ! 204: } ! 205: ! 206: /* ! 207: * Compose a call to the debugger from the saved state in regs. (No ! 208: * reason not to do this in C.) ! 209: */ ! 210: boolean_t ! 211: db_trap_from_asm( ! 212: struct i386_saved_state *regs) ! 213: { ! 214: int code; ! 215: int type; ! 216: ! 217: type = regs->trapno; ! 218: code = regs->err; ! 219: return (kdb_trap(type, code, regs)); ! 220: } ! 221: ! 222: int ! 223: kdb_trap( ! 224: int type, ! 225: int code, ! 226: struct i386_saved_state *regs) ! 227: { ! 228: extern char etext; ! 229: boolean_t trap_from_user; ! 230: spl_t s = splhigh(); ! 231: ! 232: switch (type) { ! 233: case T_DEBUG: /* single_step */ ! 234: { ! 235: extern int dr_addr[]; ! 236: int addr; ! 237: int status = dr6(); ! 238: ! 239: if (status & 0xf) { /* hmm hdw break */ ! 240: addr = status & 0x8 ? dr_addr[3] : ! 241: status & 0x4 ? dr_addr[2] : ! 242: status & 0x2 ? dr_addr[1] : ! 243: dr_addr[0]; ! 244: regs->efl |= EFL_RF; ! 245: db_single_step_cmd(addr, 0, 1, "p"); ! 246: } ! 247: } ! 248: case T_INT3: /* breakpoint */ ! 249: case T_WATCHPOINT: /* watchpoint */ ! 250: case -1: /* keyboard interrupt */ ! 251: break; ! 252: ! 253: default: ! 254: if (db_recover) { ! 255: i386_nested_saved_state = *regs; ! 256: db_printf("Caught "); ! 257: if (type < 0 || type > TRAP_TYPES) ! 258: db_printf("type %d", type); ! 259: else ! 260: db_printf("%s", trap_type[type]); ! 261: db_printf(" trap, code = %x, pc = %x\n", ! 262: code, regs->eip); ! 263: splx(s); ! 264: db_error(""); ! 265: /*NOTREACHED*/ ! 266: } ! 267: kdbprinttrap(type, code, (int *)®s->eip, regs->uesp); ! 268: } ! 269: ! 270: #if NCPUS > 1 ! 271: disable_preemption(); ! 272: #endif /* NCPUS > 1 */ ! 273: ! 274: saved_ipl[cpu_number()] = s; ! 275: saved_state[cpu_number()] = regs; ! 276: ! 277: i386_last_saved_statep = regs; ! 278: i386_last_kdb_sp = (unsigned) &type; ! 279: ! 280: #if NCPUS > 1 ! 281: if (!kdb_enter(regs->eip)) ! 282: goto kdb_exit; ! 283: #endif /* NCPUS > 1 */ ! 284: ! 285: /* Should switch to kdb's own stack here. */ ! 286: ! 287: if (!IS_USER_TRAP(regs, &etext)) { ! 288: bzero((char *)&ddb_regs, sizeof (ddb_regs)); ! 289: *(struct i386_saved_state_from_kernel *)&ddb_regs = ! 290: *(struct i386_saved_state_from_kernel *)regs; ! 291: trap_from_user = FALSE; ! 292: } ! 293: else { ! 294: ddb_regs = *regs; ! 295: trap_from_user = TRUE; ! 296: } ! 297: if (!trap_from_user) { ! 298: /* ! 299: * Kernel mode - esp and ss not saved ! 300: */ ! 301: ddb_regs.uesp = (int)®s->uesp; /* kernel stack pointer */ ! 302: ddb_regs.ss = KERNEL_DS; ! 303: } ! 304: ! 305: db_active++; ! 306: db_task_trap(type, code, trap_from_user); ! 307: db_active--; ! 308: ! 309: regs->eip = ddb_regs.eip; ! 310: regs->efl = ddb_regs.efl; ! 311: regs->eax = ddb_regs.eax; ! 312: regs->ecx = ddb_regs.ecx; ! 313: regs->edx = ddb_regs.edx; ! 314: regs->ebx = ddb_regs.ebx; ! 315: if (trap_from_user) { ! 316: /* ! 317: * user mode - saved esp and ss valid ! 318: */ ! 319: regs->uesp = ddb_regs.uesp; /* user stack pointer */ ! 320: regs->ss = ddb_regs.ss & 0xffff; /* user stack segment */ ! 321: } ! 322: regs->ebp = ddb_regs.ebp; ! 323: regs->esi = ddb_regs.esi; ! 324: regs->edi = ddb_regs.edi; ! 325: regs->es = ddb_regs.es & 0xffff; ! 326: regs->cs = ddb_regs.cs & 0xffff; ! 327: regs->ds = ddb_regs.ds & 0xffff; ! 328: regs->fs = ddb_regs.fs & 0xffff; ! 329: regs->gs = ddb_regs.gs & 0xffff; ! 330: ! 331: if ((type == T_INT3) && ! 332: (db_get_task_value(regs->eip, ! 333: BKPT_SIZE, ! 334: FALSE, ! 335: db_target_space(current_act(), ! 336: trap_from_user)) ! 337: == BKPT_INST)) ! 338: regs->eip += BKPT_SIZE; ! 339: ! 340: #if NCPUS > 1 ! 341: kdb_exit: ! 342: kdb_leave(); ! 343: #endif /* NCPUS > 1 */ ! 344: ! 345: saved_state[cpu_number()] = 0; ! 346: ! 347: #if MACH_MP_DEBUG ! 348: masked_state_cnt[cpu_number()] = 0; ! 349: #endif /* MACH_MP_DEBUG */ ! 350: ! 351: #if NCPUS > 1 ! 352: enable_preemption(); ! 353: #endif /* NCPUS > 1 */ ! 354: ! 355: splx(s); ! 356: ! 357: /* Allow continue to upper layers of exception handling if ! 358: * trap was not a debugging trap. ! 359: */ ! 360: ! 361: if (trap_from_user && type != T_DEBUG && type != T_INT3 ! 362: && type != T_WATCHPOINT) ! 363: return 0; ! 364: else ! 365: return (1); ! 366: } ! 367: ! 368: /* ! 369: * Enter KDB through a keyboard trap. ! 370: * We show the registers as of the keyboard interrupt ! 371: * instead of those at its call to KDB. ! 372: */ ! 373: ! 374: spl_t kdb_oldspl; ! 375: ! 376: void ! 377: kdb_kentry( ! 378: struct int_regs *int_regs) ! 379: { ! 380: extern char etext; ! 381: boolean_t trap_from_user; ! 382: struct i386_interrupt_state *is = int_regs->is; ! 383: struct i386_saved_state regs; ! 384: spl_t s; ! 385: ! 386: s = splhigh(); ! 387: kdb_oldspl = s; ! 388: ! 389: if (IS_USER_TRAP(is, &etext)) ! 390: { ! 391: regs.uesp = ((int *)(is+1))[0]; ! 392: regs.ss = ((int *)(is+1))[1]; ! 393: } ! 394: else { ! 395: regs.ss = KERNEL_DS; ! 396: regs.uesp= (int)(is+1); ! 397: } ! 398: regs.efl = is->efl; ! 399: regs.cs = is->cs; ! 400: regs.eip = is->eip; ! 401: regs.eax = is->eax; ! 402: regs.ecx = is->ecx; ! 403: regs.edx = is->edx; ! 404: regs.ebx = int_regs->ebx; ! 405: regs.ebp = int_regs->ebp; ! 406: regs.esi = int_regs->esi; ! 407: regs.edi = int_regs->edi; ! 408: regs.ds = is->ds; ! 409: regs.es = is->es; ! 410: regs.fs = int_regs->fs; ! 411: regs.gs = int_regs->gs; ! 412: ! 413: #if NCPUS > 1 ! 414: disable_preemption(); ! 415: #endif /* NCPUS > 1 */ ! 416: ! 417: saved_state[cpu_number()] = ®s; ! 418: ! 419: #if NCPUS > 1 ! 420: if (!kdb_enter(regs.eip)) ! 421: goto kdb_exit; ! 422: #endif /* NCPUS > 1 */ ! 423: ! 424: bcopy((char *)®s, (char *)&ddb_regs, sizeof (ddb_regs)); ! 425: trap_from_user = IS_USER_TRAP(&ddb_regs, &etext); ! 426: ! 427: db_active++; ! 428: db_task_trap(-1, 0, trap_from_user); ! 429: db_active--; ! 430: ! 431: if (trap_from_user) { ! 432: ((int *)(is+1))[0] = ddb_regs.uesp; ! 433: ((int *)(is+1))[1] = ddb_regs.ss & 0xffff; ! 434: } ! 435: is->efl = ddb_regs.efl; ! 436: is->cs = ddb_regs.cs & 0xffff; ! 437: is->eip = ddb_regs.eip; ! 438: is->eax = ddb_regs.eax; ! 439: is->ecx = ddb_regs.ecx; ! 440: is->edx = ddb_regs.edx; ! 441: int_regs->ebx = ddb_regs.ebx; ! 442: int_regs->ebp = ddb_regs.ebp; ! 443: int_regs->esi = ddb_regs.esi; ! 444: int_regs->edi = ddb_regs.edi; ! 445: is->ds = ddb_regs.ds & 0xffff; ! 446: is->es = ddb_regs.es & 0xffff; ! 447: int_regs->fs = ddb_regs.fs & 0xffff; ! 448: int_regs->gs = ddb_regs.gs & 0xffff; ! 449: ! 450: #if NCPUS > 1 ! 451: kdb_exit: ! 452: kdb_leave(); ! 453: #endif /* NCPUS > 1 */ ! 454: saved_state[cpu_number()] = 0; ! 455: ! 456: #if NCPUS > 1 ! 457: enable_preemption(); ! 458: #endif /* NCPUS > 1 */ ! 459: ! 460: splx(s); ! 461: } ! 462: ! 463: /* ! 464: * Print trap reason. ! 465: */ ! 466: ! 467: void ! 468: kdbprinttrap( ! 469: int type, ! 470: int code, ! 471: int *pc, ! 472: int sp) ! 473: { ! 474: printf("kernel: "); ! 475: if (type < 0 || type > TRAP_TYPES) ! 476: db_printf("type %d", type); ! 477: else ! 478: db_printf("%s", trap_type[type]); ! 479: db_printf(" trap, code=%x eip@%x = %x esp=%x\n", ! 480: code, pc, *(int *)pc, sp); ! 481: db_run_mode = STEP_CONTINUE; ! 482: } ! 483: ! 484: int ! 485: db_user_to_kernel_address( ! 486: task_t task, ! 487: vm_offset_t addr, ! 488: unsigned *kaddr, ! 489: int flag) ! 490: { ! 491: register pt_entry_t *ptp; ! 492: ! 493: ptp = pmap_pte(task->map->pmap, addr); ! 494: if (ptp == PT_ENTRY_NULL || (*ptp & INTEL_PTE_VALID) == 0) { ! 495: if (flag) { ! 496: db_printf("\nno memory is assigned to address %08x\n", addr); ! 497: db_error(0); ! 498: /* NOTREACHED */ ! 499: } ! 500: return(-1); ! 501: } ! 502: *kaddr = (unsigned)ptetokv(*ptp) + (addr & (INTEL_PGBYTES-1)); ! 503: return(0); ! 504: } ! 505: ! 506: /* ! 507: * Read bytes from kernel address space for debugger. ! 508: */ ! 509: ! 510: void ! 511: db_read_bytes( ! 512: vm_offset_t addr, ! 513: int size, ! 514: char *data, ! 515: task_t task) ! 516: { ! 517: register char *src; ! 518: register int n; ! 519: unsigned kern_addr; ! 520: ! 521: src = (char *)addr; ! 522: if (task == kernel_task || task == TASK_NULL) { ! 523: while (--size >= 0) { ! 524: if (addr++ > VM_MAX_KERNEL_ADDRESS) { ! 525: db_printf("\nbad address %x\n", addr); ! 526: db_error(0); ! 527: /* NOTREACHED */ ! 528: } ! 529: *data++ = *src++; ! 530: } ! 531: return; ! 532: } ! 533: while (size > 0) { ! 534: if (db_user_to_kernel_address(task, addr, &kern_addr, 1) < 0) ! 535: return; ! 536: src = (char *)kern_addr; ! 537: n = intel_trunc_page(addr+INTEL_PGBYTES) - addr; ! 538: if (n > size) ! 539: n = size; ! 540: size -= n; ! 541: addr += n; ! 542: while (--n >= 0) ! 543: *data++ = *src++; ! 544: } ! 545: } ! 546: ! 547: /* ! 548: * Write bytes to kernel address space for debugger. ! 549: */ ! 550: ! 551: void ! 552: db_write_bytes( ! 553: vm_offset_t addr, ! 554: int size, ! 555: char *data, ! 556: task_t task) ! 557: { ! 558: register char *dst; ! 559: ! 560: register pt_entry_t *ptep0 = 0; ! 561: pt_entry_t oldmap0 = 0; ! 562: vm_offset_t addr1; ! 563: register pt_entry_t *ptep1 = 0; ! 564: pt_entry_t oldmap1 = 0; ! 565: extern char etext; ! 566: ! 567: if (task && task != kernel_task) { ! 568: db_write_bytes_user_space(addr, size, data, task); ! 569: return; ! 570: } ! 571: ! 572: ! 573: if (addr >= VM_MIN_KERNEL_LOADED_ADDRESS) { ! 574: db_write_bytes_user_space(addr, size, data, kernel_task); ! 575: return; ! 576: } ! 577: ! 578: if (addr >= VM_MIN_KERNEL_ADDRESS && ! 579: addr <= (vm_offset_t)&etext) ! 580: { ! 581: ptep0 = pmap_pte(kernel_pmap, addr); ! 582: oldmap0 = *ptep0; ! 583: *ptep0 |= INTEL_PTE_WRITE; ! 584: ! 585: addr1 = i386_trunc_page(addr + size - 1); ! 586: if (i386_trunc_page(addr) != addr1) { ! 587: /* data crosses a page boundary */ ! 588: ! 589: ptep1 = pmap_pte(kernel_pmap, addr1); ! 590: oldmap1 = *ptep1; ! 591: *ptep1 |= INTEL_PTE_WRITE; ! 592: } ! 593: flush_tlb(); ! 594: } ! 595: ! 596: dst = (char *)addr; ! 597: ! 598: while (--size >= 0) { ! 599: if (addr++ > VM_MAX_KERNEL_ADDRESS) { ! 600: db_printf("\nbad address %x\n", addr); ! 601: db_error(0); ! 602: /* NOTREACHED */ ! 603: } ! 604: *dst++ = *data++; ! 605: } ! 606: ! 607: if (ptep0) { ! 608: *ptep0 = oldmap0; ! 609: if (ptep1) { ! 610: *ptep1 = oldmap1; ! 611: } ! 612: flush_tlb(); ! 613: } ! 614: } ! 615: ! 616: void ! 617: db_write_bytes_user_space( ! 618: vm_offset_t addr, ! 619: int size, ! 620: char *data, ! 621: task_t task) ! 622: { ! 623: register char *dst; ! 624: register int n; ! 625: unsigned kern_addr; ! 626: ! 627: while (size > 0) { ! 628: if (db_user_to_kernel_address(task, addr, &kern_addr, 1) < 0) ! 629: return; ! 630: dst = (char *)kern_addr; ! 631: n = intel_trunc_page(addr+INTEL_PGBYTES) - addr; ! 632: if (n > size) ! 633: n = size; ! 634: size -= n; ! 635: addr += n; ! 636: while (--n >= 0) ! 637: *dst++ = *data++; ! 638: } ! 639: } ! 640: ! 641: boolean_t ! 642: db_check_access( ! 643: vm_offset_t addr, ! 644: int size, ! 645: task_t task) ! 646: { ! 647: register n; ! 648: unsigned kern_addr; ! 649: ! 650: if (task == kernel_task || task == TASK_NULL) { ! 651: if (kernel_task == TASK_NULL) ! 652: return(TRUE); ! 653: task = kernel_task; ! 654: } else if (task == TASK_NULL) { ! 655: if (current_act() == THR_ACT_NULL) ! 656: return(FALSE); ! 657: task = current_act()->task; ! 658: } ! 659: while (size > 0) { ! 660: if (db_user_to_kernel_address(task, addr, &kern_addr, 0) < 0) ! 661: return(FALSE); ! 662: n = intel_trunc_page(addr+INTEL_PGBYTES) - addr; ! 663: if (n > size) ! 664: n = size; ! 665: size -= n; ! 666: addr += n; ! 667: } ! 668: return(TRUE); ! 669: } ! 670: ! 671: boolean_t ! 672: db_phys_eq( ! 673: task_t task1, ! 674: vm_offset_t addr1, ! 675: task_t task2, ! 676: vm_offset_t addr2) ! 677: { ! 678: unsigned kern_addr1, kern_addr2; ! 679: ! 680: if ((addr1 & (INTEL_PGBYTES-1)) != (addr2 & (INTEL_PGBYTES-1))) ! 681: return(FALSE); ! 682: if (task1 == TASK_NULL) { ! 683: if (current_act() == THR_ACT_NULL) ! 684: return(FALSE); ! 685: task1 = current_act()->task; ! 686: } ! 687: if (db_user_to_kernel_address(task1, addr1, &kern_addr1, 0) < 0 || ! 688: db_user_to_kernel_address(task2, addr2, &kern_addr2, 0) < 0) ! 689: return(FALSE); ! 690: return(kern_addr1 == kern_addr2); ! 691: } ! 692: ! 693: #define DB_USER_STACK_ADDR (VM_MIN_KERNEL_ADDRESS) ! 694: #define DB_NAME_SEARCH_LIMIT (DB_USER_STACK_ADDR-(INTEL_PGBYTES*3)) ! 695: ! 696: int ! 697: db_search_null( ! 698: task_t task, ! 699: unsigned *svaddr, ! 700: unsigned evaddr, ! 701: unsigned *skaddr, ! 702: int flag) ! 703: { ! 704: register unsigned vaddr; ! 705: register unsigned *kaddr; ! 706: ! 707: kaddr = (unsigned *)*skaddr; ! 708: for (vaddr = *svaddr; vaddr > evaddr; vaddr -= sizeof(unsigned)) { ! 709: if (vaddr % INTEL_PGBYTES == 0) { ! 710: vaddr -= sizeof(unsigned); ! 711: if (db_user_to_kernel_address(task, vaddr, skaddr, 0) < 0) ! 712: return(-1); ! 713: kaddr = (unsigned *)*skaddr; ! 714: } else { ! 715: vaddr -= sizeof(unsigned); ! 716: kaddr--; ! 717: } ! 718: if ((*kaddr == 0) ^ (flag == 0)) { ! 719: *svaddr = vaddr; ! 720: *skaddr = (unsigned)kaddr; ! 721: return(0); ! 722: } ! 723: } ! 724: return(-1); ! 725: } ! 726: ! 727: void ! 728: db_task_name( ! 729: task_t task) ! 730: { ! 731: register char *p; ! 732: register n; ! 733: unsigned vaddr, kaddr; ! 734: ! 735: vaddr = DB_USER_STACK_ADDR; ! 736: kaddr = 0; ! 737: ! 738: /* ! 739: * skip nulls at the end ! 740: */ ! 741: if (db_search_null(task, &vaddr, DB_NAME_SEARCH_LIMIT, &kaddr, 0) < 0) { ! 742: db_printf(DB_NULL_TASK_NAME); ! 743: return; ! 744: } ! 745: /* ! 746: * search start of args ! 747: */ ! 748: if (db_search_null(task, &vaddr, DB_NAME_SEARCH_LIMIT, &kaddr, 1) < 0) { ! 749: db_printf(DB_NULL_TASK_NAME); ! 750: return; ! 751: } ! 752: ! 753: n = DB_TASK_NAME_LEN-1; ! 754: p = (char *)kaddr + sizeof(unsigned); ! 755: for (vaddr += sizeof(int); vaddr < DB_USER_STACK_ADDR && n > 0; ! 756: vaddr++, p++, n--) { ! 757: if (vaddr % INTEL_PGBYTES == 0) { ! 758: (void)db_user_to_kernel_address(task, vaddr, &kaddr, 0); ! 759: p = (char*)kaddr; ! 760: } ! 761: db_printf("%c", (*p < ' ' || *p > '~')? ' ': *p); ! 762: } ! 763: while (n-- >= 0) /* compare with >= 0 for one more space */ ! 764: db_printf(" "); ! 765: } ! 766: ! 767: #if NCPUS == 1 ! 768: ! 769: void ! 770: db_machdep_init(void) ! 771: { ! 772: db_stacks[0] = (vm_offset_t)(db_stack_store + ! 773: INTSTACK_SIZE - sizeof (natural_t)); ! 774: dbtss.esp0 = (int)(db_task_stack_store + ! 775: INTSTACK_SIZE - sizeof (natural_t)); ! 776: dbtss.esp = dbtss.esp0; ! 777: dbtss.eip = (int)&db_task_start; ! 778: } ! 779: ! 780: #else /* NCPUS > 1 */ ! 781: ! 782: /* ! 783: * Code used to synchronize kdb among all cpus, one active at a time, switch ! 784: * from on to another using kdb_on! #cpu or cpu #cpu ! 785: */ ! 786: ! 787: decl_simple_lock_data(, kdb_lock) /* kdb lock */ ! 788: ! 789: #define db_simple_lock_init(l, e) hw_lock_init(&((l)->interlock)) ! 790: #define db_simple_lock_try(l) hw_lock_try(&((l)->interlock)) ! 791: #define db_simple_unlock(l) hw_lock_unlock(&((l)->interlock)) ! 792: ! 793: int kdb_cpu = -1; /* current cpu running kdb */ ! 794: int kdb_debug = 0; ! 795: int kdb_is_slave[NCPUS]; ! 796: int kdb_active[NCPUS]; ! 797: volatile unsigned int cpus_holding_bkpts; /* counter for number of cpus holding ! 798: breakpoints (ie: cpus that did not ! 799: insert back breakpoints) */ ! 800: extern boolean_t db_breakpoints_inserted; ! 801: ! 802: void ! 803: db_machdep_init(void) ! 804: { ! 805: int c; ! 806: ! 807: db_simple_lock_init(&kdb_lock, ETAP_MISC_KDB); ! 808: for (c = 0; c < NCPUS; ++c) { ! 809: db_stacks[c] = (vm_offset_t) (db_stack_store + ! 810: (INTSTACK_SIZE * (c + 1)) - sizeof (natural_t)); ! 811: if (c == master_cpu) { ! 812: dbtss.esp0 = (int)(db_task_stack_store + ! 813: (INTSTACK_SIZE * (c + 1)) - sizeof (natural_t)); ! 814: dbtss.esp = dbtss.esp0; ! 815: dbtss.eip = (int)&db_task_start; ! 816: /* ! 817: * The TSS for the debugging task on each slave CPU ! 818: * is set up in mp_desc_init(). ! 819: */ ! 820: } ! 821: } ! 822: } ! 823: ! 824: /* ! 825: * Called when entering kdb: ! 826: * Takes kdb lock. If if we were called remotely (slave state) we just ! 827: * wait for kdb_cpu to be equal to cpu_number(). Otherwise enter kdb if ! 828: * not active on another cpu. ! 829: * If db_pass_thru[cpu_number()] > 0, then kdb can't stop now. ! 830: */ ! 831: ! 832: int ! 833: kdb_enter(int pc) ! 834: { ! 835: int my_cpu; ! 836: int retval; ! 837: ! 838: #if NCPUS > 1 ! 839: disable_preemption(); ! 840: #endif /* NCPUS > 1 */ ! 841: ! 842: my_cpu = cpu_number(); ! 843: ! 844: if (db_pass_thru[my_cpu]) { ! 845: retval = 0; ! 846: goto kdb_exit; ! 847: } ! 848: ! 849: kdb_active[my_cpu]++; ! 850: lock_kdb(); ! 851: ! 852: if (kdb_debug) ! 853: db_printf("kdb_enter: cpu %d, is_slave %d, kdb_cpu %d, run mode %d pc %x (%x) holds %d\n", ! 854: my_cpu, kdb_is_slave[my_cpu], kdb_cpu, ! 855: db_run_mode, pc, *(int *)pc, cpus_holding_bkpts); ! 856: if (db_breakpoints_inserted) ! 857: cpus_holding_bkpts++; ! 858: if (kdb_cpu == -1 && !kdb_is_slave[my_cpu]) { ! 859: kdb_cpu = my_cpu; ! 860: remote_kdb(); /* stop other cpus */ ! 861: retval = 1; ! 862: } else if (kdb_cpu == my_cpu) ! 863: retval = 1; ! 864: else ! 865: retval = 0; ! 866: ! 867: kdb_exit: ! 868: #if NCPUS > 1 ! 869: enable_preemption(); ! 870: #endif /* NCPUS > 1 */ ! 871: ! 872: return (retval); ! 873: } ! 874: ! 875: void ! 876: kdb_leave(void) ! 877: { ! 878: int my_cpu; ! 879: boolean_t wait = FALSE; ! 880: ! 881: #if NCPUS > 1 ! 882: disable_preemption(); ! 883: #endif /* NCPUS > 1 */ ! 884: ! 885: my_cpu = cpu_number(); ! 886: ! 887: if (db_run_mode == STEP_CONTINUE) { ! 888: wait = TRUE; ! 889: kdb_cpu = -1; ! 890: } ! 891: if (db_breakpoints_inserted) ! 892: cpus_holding_bkpts--; ! 893: if (kdb_is_slave[my_cpu]) ! 894: kdb_is_slave[my_cpu]--; ! 895: if (kdb_debug) ! 896: db_printf("kdb_leave: cpu %d, kdb_cpu %d, run_mode %d pc %x (%x) holds %d\n", ! 897: my_cpu, kdb_cpu, db_run_mode, ! 898: ddb_regs.eip, *(int *)ddb_regs.eip, ! 899: cpus_holding_bkpts); ! 900: clear_kdb_intr(); ! 901: unlock_kdb(); ! 902: kdb_active[my_cpu]--; ! 903: ! 904: #if NCPUS > 1 ! 905: enable_preemption(); ! 906: #endif /* NCPUS > 1 */ ! 907: ! 908: if (wait) { ! 909: while(cpus_holding_bkpts); ! 910: } ! 911: } ! 912: ! 913: void ! 914: lock_kdb(void) ! 915: { ! 916: int my_cpu; ! 917: register i; ! 918: extern void kdb_console(void); ! 919: ! 920: #if NCPUS > 1 ! 921: disable_preemption(); ! 922: #endif /* NCPUS > 1 */ ! 923: ! 924: my_cpu = cpu_number(); ! 925: ! 926: for(;;) { ! 927: kdb_console(); ! 928: if (kdb_cpu != -1 && kdb_cpu != my_cpu) { ! 929: continue; ! 930: } ! 931: if (db_simple_lock_try(&kdb_lock)) { ! 932: if (kdb_cpu == -1 || kdb_cpu == my_cpu) ! 933: break; ! 934: db_simple_unlock(&kdb_lock); ! 935: } ! 936: } ! 937: ! 938: #if NCPUS > 1 ! 939: enable_preemption(); ! 940: #endif /* NCPUS > 1 */ ! 941: } ! 942: ! 943: #if TIME_STAMP ! 944: extern unsigned old_time_stamp; ! 945: #endif /* TIME_STAMP */ ! 946: ! 947: void ! 948: unlock_kdb(void) ! 949: { ! 950: db_simple_unlock(&kdb_lock); ! 951: #if TIME_STAMP ! 952: old_time_stamp = 0; ! 953: #endif /* TIME_STAMP */ ! 954: } ! 955: ! 956: ! 957: #ifdef __STDC__ ! 958: #define KDB_SAVE(type, name) extern type name; type name##_save = name ! 959: #define KDB_RESTORE(name) name = name##_save ! 960: #else /* __STDC__ */ ! 961: #define KDB_SAVE(type, name) extern type name; type name/**/_save = name ! 962: #define KDB_RESTORE(name) name = name/**/_save ! 963: #endif /* __STDC__ */ ! 964: ! 965: #define KDB_SAVE_CTXT() \ ! 966: KDB_SAVE(int, db_run_mode); \ ! 967: KDB_SAVE(boolean_t, db_sstep_print); \ ! 968: KDB_SAVE(int, db_loop_count); \ ! 969: KDB_SAVE(int, db_call_depth); \ ! 970: KDB_SAVE(int, db_inst_count); \ ! 971: KDB_SAVE(int, db_last_inst_count); \ ! 972: KDB_SAVE(int, db_load_count); \ ! 973: KDB_SAVE(int, db_store_count); \ ! 974: KDB_SAVE(boolean_t, db_cmd_loop_done); \ ! 975: KDB_SAVE(jmp_buf_t *, db_recover); \ ! 976: KDB_SAVE(db_addr_t, db_dot); \ ! 977: KDB_SAVE(db_addr_t, db_last_addr); \ ! 978: KDB_SAVE(db_addr_t, db_prev); \ ! 979: KDB_SAVE(db_addr_t, db_next); \ ! 980: KDB_SAVE(db_regs_t, ddb_regs); ! 981: ! 982: #define KDB_RESTORE_CTXT() \ ! 983: KDB_RESTORE(db_run_mode); \ ! 984: KDB_RESTORE(db_sstep_print); \ ! 985: KDB_RESTORE(db_loop_count); \ ! 986: KDB_RESTORE(db_call_depth); \ ! 987: KDB_RESTORE(db_inst_count); \ ! 988: KDB_RESTORE(db_last_inst_count); \ ! 989: KDB_RESTORE(db_load_count); \ ! 990: KDB_RESTORE(db_store_count); \ ! 991: KDB_RESTORE(db_cmd_loop_done); \ ! 992: KDB_RESTORE(db_recover); \ ! 993: KDB_RESTORE(db_dot); \ ! 994: KDB_RESTORE(db_last_addr); \ ! 995: KDB_RESTORE(db_prev); \ ! 996: KDB_RESTORE(db_next); \ ! 997: KDB_RESTORE(ddb_regs); ! 998: ! 999: /* ! 1000: * switch to another cpu ! 1001: */ ! 1002: ! 1003: void ! 1004: kdb_on( ! 1005: int cpu) ! 1006: { ! 1007: KDB_SAVE_CTXT(); ! 1008: if (cpu < 0 || cpu >= NCPUS || !kdb_active[cpu]) ! 1009: return; ! 1010: db_set_breakpoints(); ! 1011: db_set_watchpoints(); ! 1012: kdb_cpu = cpu; ! 1013: unlock_kdb(); ! 1014: lock_kdb(); ! 1015: db_clear_breakpoints(); ! 1016: db_clear_watchpoints(); ! 1017: KDB_RESTORE_CTXT(); ! 1018: if (kdb_cpu == -1) {/* someone continued */ ! 1019: kdb_cpu = cpu_number(); ! 1020: db_continue_cmd(0, 0, 0, ""); ! 1021: } ! 1022: } ! 1023: ! 1024: #endif /* NCPUS > 1 */ ! 1025: ! 1026: void db_reboot( ! 1027: db_expr_t addr, ! 1028: boolean_t have_addr, ! 1029: db_expr_t count, ! 1030: char *modif) ! 1031: { ! 1032: boolean_t reboot = TRUE; ! 1033: char *cp, c; ! 1034: ! 1035: cp = modif; ! 1036: while ((c = *cp++) != 0) { ! 1037: if (c == 'r') /* reboot */ ! 1038: reboot = TRUE; ! 1039: if (c == 'h') /* halt */ ! 1040: reboot = FALSE; ! 1041: } ! 1042: halt_all_cpus(reboot); ! 1043: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.