osfmk/i386/db_interface.c

   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  Software.Distribution@CS.CMU.EDU
  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 *)&regs->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)&regs->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()] = &regs;
 418
 419 #if     NCPUS > 1
 420         if (!kdb_enter(regs.eip))
 421                 goto kdb_exit;
 422 #endif  /* NCPUS > 1 */
 423
 424         bcopy((char *)&regs, (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 }