9210 remove KMDB branch debugging support 9211 ::crregs could do with cr2/cr3 support 9209 ::ttrace should be able to filter by thread Reviewed by: Patrick Mooney <patrick.mooney@joyent.com> Reviewed by: Yuri Pankov <yuripv@yuripv.net>
1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2013 by Delphix. All rights reserved. 24 */ 25 26 #include <kmdb/kmdb_kvm.h> 27 #include <kmdb/kvm.h> 28 #include <kmdb/kmdb_kdi.h> 29 #include <kmdb/kmdb_promif.h> 30 #include <kmdb/kmdb_module.h> 31 #include <kmdb/kmdb_asmutil.h> 32 #include <mdb/mdb_types.h> 33 #include <mdb/mdb_conf.h> 34 #include <mdb/mdb_err.h> 35 #include <mdb/mdb_modapi.h> 36 #include <mdb/mdb_target_impl.h> 37 #include <mdb/mdb_debug.h> 38 #include <mdb/mdb_string.h> 39 #include <mdb/mdb_ctf.h> 40 #include <mdb/mdb_kreg_impl.h> 41 #include <mdb/mdb_ks.h> 42 #include <mdb/mdb.h> 43 44 #include <strings.h> 45 #include <dlfcn.h> 46 #include <sys/isa_defs.h> 47 #include <sys/kobj.h> 48 #include <sys/kobj_impl.h> 49 #include <sys/bitmap.h> 50 #include <vm/as.h> 51 52 static const char KMT_RTLD_NAME[] = "krtld"; 53 static const char KMT_MODULE[] = "mdb_ks"; 54 static const char KMT_CTFPARENT[] = "genunix"; 55 56 static mdb_list_t kmt_defbp_list; /* List of current deferred bp's */ 57 static int kmt_defbp_lock; /* For list, running kernel holds */ 58 static uint_t kmt_defbp_modchg_isload; /* Whether mod change is load/unload */ 59 static struct modctl *kmt_defbp_modchg_modctl; /* modctl for defbp checking */ 60 static uint_t kmt_defbp_num; /* Number of referenced def'd bp's */ 61 static int kmt_defbp_bpspec; /* vespec for def'd bp activation bp */ 62 63 static const mdb_se_ops_t kmt_brkpt_ops; 64 static const mdb_se_ops_t kmt_wapt_ops; 65 66 static void kmt_sync(mdb_tgt_t *); 67 68 typedef struct kmt_symarg { 69 mdb_tgt_sym_f *sym_cb; /* Caller's callback function */ 70 void *sym_data; /* Callback function argument */ 71 uint_t sym_type; /* Symbol type/binding filter */ 72 mdb_syminfo_t sym_info; /* Symbol id and table id */ 73 const char *sym_obj; /* Containing object */ 74 } kmt_symarg_t; 75 76 typedef struct kmt_maparg { 77 mdb_tgt_t *map_target; /* Target used for mapping iter */ 78 mdb_tgt_map_f *map_cb; /* Caller's callback function */ 79 void *map_data; /* Callback function argument */ 80 } kmt_maparg_t; 81 82 /*ARGSUSED*/ 83 int 84 kmt_setflags(mdb_tgt_t *t, int flags) 85 { 86 /* 87 * We only handle one flag (ALLOWIO), and we can't fail to set or clear 88 * it, so we just blindly replace the t_flags version with the one 89 * passed. 90 */ 91 t->t_flags = (t->t_flags & ~MDB_TGT_F_ALLOWIO) | 92 (flags & MDB_TGT_F_ALLOWIO); 93 94 return (0); 95 } 96 97 /*ARGSUSED*/ 98 const char * 99 kmt_name(mdb_tgt_t *t) 100 { 101 return ("kmdb_kvm"); 102 } 103 104 /*ARGSUSED*/ 105 static const char * 106 kmt_platform(mdb_tgt_t *t) 107 { 108 static char platform[SYS_NMLN]; 109 110 if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT) 111 return (mdb_conf_platform()); 112 113 if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, platform, 114 sizeof (platform), "unix", "platform") != sizeof (platform)) { 115 warn("'platform' symbol is missing from kernel\n"); 116 return ("unknown"); 117 } 118 119 return (platform); 120 } 121 122 static int 123 kmt_uname(mdb_tgt_t *t, struct utsname *utsp) 124 { 125 return (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, utsp, 126 sizeof (struct utsname), MDB_TGT_OBJ_EXEC, "utsname")); 127 } 128 129 /*ARGSUSED*/ 130 static int 131 kmt_dmodel(mdb_tgt_t *t) 132 { 133 return (MDB_TGT_MODEL_NATIVE); 134 } 135 136 /*ARGSUSED*/ 137 ssize_t 138 kmt_rw(mdb_tgt_t *t, void *buf, size_t nbytes, uint64_t addr, 139 ssize_t (*rw)(void *, size_t, uint64_t)) 140 { 141 /* 142 * chunksz needs to be volatile because of the use of setjmp() in this 143 * function. 144 */ 145 volatile size_t chunksz; 146 size_t n, ndone; 147 jmp_buf *oldpcb = NULL; 148 jmp_buf pcb; 149 ssize_t res; 150 151 kmdb_prom_check_interrupt(); 152 153 if (nbytes == 0) 154 return (0); 155 156 /* 157 * Try to process the entire buffer, as requested. If we catch a fault, 158 * try smaller chunks. This allows us to handle regions that cross 159 * mapping boundaries. 160 */ 161 chunksz = nbytes; 162 ndone = 0; 163 if (setjmp(pcb) != 0) { 164 if (chunksz == 1) { 165 /* We failed with the smallest chunk - give up */ 166 kmdb_dpi_restore_fault_hdlr(oldpcb); 167 return (ndone > 0 ? ndone : -1); /* errno set for us */ 168 } else if (chunksz > 4) 169 chunksz = 4; 170 else 171 chunksz = 1; 172 } 173 174 oldpcb = kmdb_dpi_set_fault_hdlr(&pcb); 175 while (nbytes > 0) { 176 n = MIN(chunksz, nbytes); 177 178 if ((res = rw(buf, n, addr)) != n) 179 return (res < 0 ? res : ndone + res); 180 181 addr += n; 182 nbytes -= n; 183 ndone += n; 184 buf = ((caddr_t)buf + n); 185 } 186 187 kmdb_dpi_restore_fault_hdlr(oldpcb); 188 189 return (ndone); 190 } 191 192 static void 193 kmt_bcopy(const void *s1, void *s2, size_t n) 194 { 195 /* 196 * We need to guarantee atomic accesses for certain sizes. bcopy won't 197 * make that guarantee, so we need to do it ourselves. 198 */ 199 #ifdef _LP64 200 if (n == 8 && ((uintptr_t)s1 & 7) == 0 && ((uintptr_t)s2 & 7) == 0) 201 *(uint64_t *)s2 = *(uint64_t *)s1; 202 else 203 #endif 204 if (n == 4 && ((uintptr_t)s1 & 3) == 0 && ((uintptr_t)s2 & 3) == 0) 205 *(uint32_t *)s2 = *(uint32_t *)s1; 206 else if (n == 2 && ((uintptr_t)s1 & 1) == 0 && ((uintptr_t)s2 & 1) == 0) 207 *(uint16_t *)s2 = *(uint16_t *)s1; 208 else if (n == 1) 209 *(uint8_t *)s2 = *(uint8_t *)s1; 210 else 211 bcopy(s1, s2, n); 212 } 213 214 static ssize_t 215 kmt_reader(void *buf, size_t nbytes, uint64_t addr) 216 { 217 kmt_bcopy((void *)(uintptr_t)addr, buf, nbytes); 218 return (nbytes); 219 } 220 221 ssize_t 222 kmt_writer(void *buf, size_t nbytes, uint64_t addr) 223 { 224 kmt_bcopy(buf, (void *)(uintptr_t)addr, nbytes); 225 return (nbytes); 226 } 227 228 /*ARGSUSED*/ 229 static ssize_t 230 kmt_read(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr) 231 { 232 /* 233 * We don't want to allow reads of I/O-mapped memory. Multi-page reads 234 * that cross into I/O-mapped memory should be restricted to the initial 235 * non-I/O region. Reads that begin in I/O-mapped memory are failed 236 * outright. 237 */ 238 if (!(t->t_flags & MDB_TGT_F_ALLOWIO) && 239 (nbytes = kmdb_kdi_range_is_nontoxic(addr, nbytes, 0)) == 0) 240 return (set_errno(EMDB_NOMAP)); 241 242 return (kmt_rw(t, buf, nbytes, addr, kmt_reader)); 243 } 244 245 /*ARGSUSED*/ 246 static ssize_t 247 kmt_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr) 248 { 249 return (kmt_rw(t, buf, nbytes, addr, kmdb_kdi_pread)); 250 } 251 252 /*ARGSUSED*/ 253 ssize_t 254 kmt_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr) 255 { 256 return (kmt_rw(t, (void *)buf, nbytes, addr, kmdb_kdi_pwrite)); 257 } 258 259 static uintptr_t 260 kmt_read_kas(mdb_tgt_t *t) 261 { 262 GElf_Sym sym; 263 264 if (mdb_tgt_lookup_by_name(t, "unix", "kas", &sym, NULL) < 0) { 265 warn("'kas' symbol is missing from kernel\n"); 266 (void) set_errno(EMDB_NOSYM); 267 return (0); 268 } 269 270 return ((uintptr_t)sym.st_value); 271 } 272 273 static int 274 kmt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap) 275 { 276 mdb_module_t *mod; 277 struct as *asp; 278 mdb_var_t *v; 279 280 switch ((uintptr_t)as) { 281 case (uintptr_t)MDB_TGT_AS_PHYS: 282 case (uintptr_t)MDB_TGT_AS_FILE: 283 case (uintptr_t)MDB_TGT_AS_IO: 284 return (set_errno(EINVAL)); 285 case (uintptr_t)MDB_TGT_AS_VIRT: 286 if ((asp = (struct as *)kmt_read_kas(t)) == NULL) 287 return (-1); /* errno is set for us */ 288 break; 289 default: 290 asp = (struct as *)as; 291 292 /* We don't support non-kas vtop */ 293 if (asp != (struct as *)kmt_read_kas(t)) 294 return (set_errno(EMDB_TGTNOTSUP)); 295 } 296 297 if (kmdb_prom_vtop(va, pap) == 0) 298 return (0); 299 300 if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL && 301 (mod = mdb_nv_get_cookie(v)) != NULL) { 302 int (*fptr)(uintptr_t, struct as *, physaddr_t *); 303 304 fptr = (int (*)(uintptr_t, struct as *, physaddr_t *)) 305 dlsym(mod->mod_hdl, "platform_vtop"); 306 307 if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0)) 308 return (0); 309 } 310 311 return (set_errno(EMDB_NOMAP)); 312 } 313 314 /*ARGSUSED*/ 315 static int 316 kmt_cpuregs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 317 { 318 const mdb_tgt_gregset_t *gregs; 319 intptr_t cpuid = DPI_MASTER_CPUID; 320 int i; 321 322 if (flags & DCMD_ADDRSPEC) { 323 if (argc != 0) 324 return (DCMD_USAGE); 325 if ((cpuid = mdb_cpu2cpuid(addr)) < 0) { 326 (void) set_errno(EMDB_NOMAP); 327 mdb_warn("failed to find cpuid for cpu at %p", addr); 328 return (DCMD_ERR); 329 } 330 } 331 332 i = mdb_getopts(argc, argv, 333 'c', MDB_OPT_UINTPTR, &cpuid, 334 NULL); 335 336 argc -= i; 337 argv += i; 338 339 if (argc != 0) 340 return (DCMD_USAGE); 341 342 if ((gregs = kmdb_dpi_get_gregs(cpuid)) == NULL) { 343 warn("failed to retrieve registers for cpu %d", (int)cpuid); 344 return (DCMD_ERR); 345 } 346 347 kmt_printregs(gregs); 348 349 return (DCMD_OK); 350 } 351 352 static int 353 kmt_regs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 354 { 355 if (flags & DCMD_ADDRSPEC) 356 return (DCMD_USAGE); 357 358 return (kmt_cpuregs(addr, flags, argc, argv)); 359 } 360 361 static int 362 kmt_cpustack_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 363 { 364 intptr_t cpuid = DPI_MASTER_CPUID; 365 uint_t verbose = 0; 366 int i; 367 368 if (flags & DCMD_ADDRSPEC) { 369 if ((cpuid = mdb_cpu2cpuid(addr)) < 0) { 370 (void) set_errno(EMDB_NOMAP); 371 mdb_warn("failed to find cpuid for cpu at %p", addr); 372 return (DCMD_ERR); 373 } 374 flags &= ~DCMD_ADDRSPEC; 375 } 376 377 i = mdb_getopts(argc, argv, 378 'c', MDB_OPT_UINTPTR, &cpuid, 379 'v', MDB_OPT_SETBITS, 1, &verbose, 380 NULL); 381 382 argc -= i; 383 argv += i; 384 385 return (kmt_cpustack(addr, flags, argc, argv, cpuid, verbose)); 386 } 387 388 /* 389 * Lasciate ogne speranza, voi ch'intrate. 390 */ 391 static int 392 kmt_call(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 393 { 394 uintptr_t *call_argv, rval; 395 int parse_strings = 1; 396 GElf_Sym sym; 397 jmp_buf *oldpcb = NULL; 398 jmp_buf pcb; 399 int i; 400 401 if (!(flags & DCMD_ADDRSPEC)) 402 return (DCMD_USAGE); 403 404 if (mdb_tgt_lookup_by_addr(mdb.m_target, addr, MDB_TGT_SYM_EXACT, 405 NULL, 0, &sym, NULL) == 0 && GELF_ST_TYPE(sym.st_info) != 406 STT_FUNC) { 407 warn("%a is not a function\n", addr); 408 return (DCMD_ERR); 409 } 410 411 if (argc > 1 && argv[0].a_type == MDB_TYPE_STRING && 412 strcmp(argv[0].a_un.a_str, "-s") == 0) { 413 parse_strings = 0; 414 argc--; 415 argv++; 416 } 417 418 call_argv = mdb_alloc(sizeof (uintptr_t) * argc, UM_SLEEP); 419 420 for (i = 0; i < argc; i++) { 421 switch (argv[i].a_type) { 422 case MDB_TYPE_STRING: 423 /* 424 * mdb_strtoull doesn't return on error, so we have to 425 * pre-check strings suspected to contain numbers. 426 */ 427 if (parse_strings && strisbasenum(argv[i].a_un.a_str)) { 428 call_argv[i] = (uintptr_t)mdb_strtoull( 429 argv[i].a_un.a_str); 430 } else 431 call_argv[i] = (uintptr_t)argv[i].a_un.a_str; 432 433 break; 434 435 case MDB_TYPE_IMMEDIATE: 436 call_argv[i] = argv[i].a_un.a_val; 437 break; 438 439 default: 440 mdb_free(call_argv, 441 sizeof (uintptr_t) * argc); 442 return (DCMD_USAGE); 443 } 444 } 445 446 if (setjmp(pcb) != 0) { 447 warn("call failed: caught a trap\n"); 448 449 kmdb_dpi_restore_fault_hdlr(oldpcb); 450 mdb_free(call_argv, sizeof (uintptr_t) * argc); 451 return (DCMD_ERR); 452 } 453 454 oldpcb = kmdb_dpi_set_fault_hdlr(&pcb); 455 rval = kmdb_dpi_call(addr, argc, call_argv); 456 kmdb_dpi_restore_fault_hdlr(oldpcb); 457 458 if (flags & DCMD_PIPE_OUT) { 459 mdb_printf("%p\n", rval); 460 } else { 461 /* pretty-print the results */ 462 mdb_printf("%p = %a(", rval, addr); 463 for (i = 0; i < argc; i++) { 464 if (i > 0) 465 mdb_printf(", "); 466 if (argv[i].a_type == MDB_TYPE_STRING) { 467 /* I'm ashamed but amused */ 468 char *quote = &("\""[parse_strings && 469 strisbasenum(argv[i].a_un.a_str)]); 470 471 mdb_printf("%s%s%s", quote, argv[i].a_un.a_str, 472 quote); 473 } else 474 mdb_printf("%p", argv[i].a_un.a_val); 475 } 476 mdb_printf(");\n"); 477 } 478 479 mdb_free(call_argv, sizeof (uintptr_t) * argc); 480 481 return (DCMD_OK); 482 } 483 484 /*ARGSUSED*/ 485 int 486 kmt_dump_crumbs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 487 { 488 intptr_t cpu = -1; 489 490 if (flags & DCMD_ADDRSPEC) { 491 if (argc != 0) 492 return (DCMD_USAGE); 493 } else { 494 addr = 0; 495 496 if (mdb_getopts(argc, argv, 497 'c', MDB_OPT_UINTPTR, &cpu, 498 NULL) != argc) 499 return (DCMD_USAGE); 500 } 501 502 kmdb_dpi_dump_crumbs(addr, cpu); 503 504 return (DCMD_OK); 505 } 506 507 /*ARGSUSED*/ 508 static int 509 kmt_noducttape(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 510 { 511 int a = 0; 512 513 return (a/a); 514 } 515 516 static int 517 kmt_dmod_status(char *msg, int state) 518 { 519 kmdb_modctl_t *kmc; 520 mdb_var_t *v; 521 int first = 1, n = 0; 522 523 mdb_nv_rewind(&mdb.m_dmodctl); 524 while ((v = mdb_nv_advance(&mdb.m_dmodctl)) != NULL) { 525 kmc = MDB_NV_COOKIE(v); 526 527 if (kmc->kmc_state != state) 528 continue; 529 530 n++; 531 532 if (msg != NULL) { 533 if (first) { 534 mdb_printf(msg, NULL); 535 first = 0; 536 } 537 538 mdb_printf(" %s", kmc->kmc_modname); 539 } 540 } 541 542 if (!first && msg != NULL) 543 mdb_printf("\n"); 544 545 return (n); 546 } 547 548 /*ARGSUSED*/ 549 static int 550 kmt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 551 { 552 kmt_data_t *kmt = mdb.m_target->t_data; 553 struct utsname uts; 554 char uuid[37]; 555 kreg_t tt; 556 557 if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, &uts, sizeof (uts), 558 "unix", "utsname") != sizeof (uts)) { 559 warn("failed to read 'utsname' struct from kernel\n"); 560 bzero(&uts, sizeof (uts)); 561 (void) strcpy(uts.nodename, "unknown machine"); 562 } 563 564 mdb_printf("debugging live kernel (%d-bit) on %s\n", 565 (int)(sizeof (void *) * NBBY), 566 (*uts.nodename == '\0' ? "(not set)" : uts.nodename)); 567 mdb_printf("operating system: %s %s (%s)\n", 568 uts.release, uts.version, uts.machine); 569 570 if (mdb_tgt_readsym(mdb.m_target, MDB_TGT_AS_VIRT, uuid, sizeof (uuid), 571 "genunix", "dump_osimage_uuid") != sizeof (uuid)) { 572 warn("failed to read 'dump_osimage_uuid' string from kernel\n"); 573 (void) strcpy(uuid, "(error)"); 574 } else if (*uuid == '\0') { 575 (void) strcpy(uuid, "(not set)"); 576 } else if (uuid[36] != '\0') { 577 (void) strcpy(uuid, "(invalid)"); 578 } 579 mdb_printf("image uuid: %s\n", uuid); 580 581 if (kmt->kmt_cpu != NULL) { 582 mdb_printf("CPU-specific support: %s\n", 583 kmt_cpu_name(kmt->kmt_cpu)); 584 } 585 586 mdb_printf("DTrace state: %s\n", (kmdb_kdi_dtrace_get_state() == 587 KDI_DTSTATE_DTRACE_ACTIVE ? "active (debugger breakpoints cannot " 588 "be armed)" : "inactive")); 589 590 (void) kmdb_dpi_get_register("tt", &tt); 591 mdb_printf("stopped on: %s\n", kmt_trapname(tt)); 592 593 (void) kmt_dmod_status("pending dmod loads:", KMDB_MC_STATE_LOADING); 594 (void) kmt_dmod_status("pending dmod unloads:", 595 KMDB_MC_STATE_UNLOADING); 596 597 return (DCMD_OK); 598 } 599 600 /*ARGSUSED*/ 601 static int 602 kmt_switch(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 603 { 604 if (!(flags & DCMD_ADDRSPEC) || argc != 0) 605 return (DCMD_USAGE); 606 607 if (kmdb_dpi_switch_master((int)addr) < 0) { 608 warn("failed to switch to CPU %d", (int)addr); 609 return (DCMD_ERR); 610 } 611 612 return (DCMD_OK); 613 } 614 615 static const mdb_dcmd_t kmt_dcmds[] = { 616 { "$c", "?[cnt]", "print stack backtrace", kmt_stack }, 617 { "$C", "?[cnt]", "print stack backtrace", kmt_stackv }, 618 { "$r", NULL, "print general-purpose registers", kmt_regs }, 619 { "$?", NULL, "print status and registers", kmt_regs }, 620 { ":x", ":", "change the active CPU", kmt_switch }, 621 { "call", ":[arg ...]", "call a kernel function", kmt_call }, 622 { "cpustack", "?[-v] [-c cpuid] [cnt]", "print stack backtrace for a " 623 "specific CPU", kmt_cpustack_dcmd }, 624 { "cpuregs", "?[-c cpuid]", "print general-purpose registers for a " 625 "specific CPU", kmt_cpuregs }, 626 { "crumbs", NULL, NULL, kmt_dump_crumbs }, 627 #if defined(__i386) || defined(__amd64) 628 { "in", ":[-L len]", "read from I/O port", kmt_in_dcmd }, 629 { "out", ":[-L len] val", "write to I/O port", kmt_out_dcmd }, 630 { "rdmsr", ":", "read an MSR", kmt_rdmsr }, 631 { "wrmsr", ": val", "write an MSR", kmt_wrmsr }, 632 { "rdpcicfg", ": bus dev func", "read a register in PCI config space", 633 kmt_rdpcicfg }, 634 { "wrpcicfg", ": bus dev func val", "write a register in PCI config " 635 "space", kmt_wrpcicfg }, 636 #endif 637 { "noducttape", NULL, NULL, kmt_noducttape }, 638 { "regs", NULL, "print general-purpose registers", kmt_regs }, 639 { "stack", "?[cnt]", "print stack backtrace", kmt_stack }, 640 { "stackregs", "?", "print stack backtrace and registers", kmt_stackr }, 641 { "status", NULL, "print summary of current target", kmt_status_dcmd }, 642 { "switch", ":", "change the active CPU", kmt_switch }, 643 { NULL } 644 }; 645 646 static uintmax_t 647 kmt_reg_disc_get(const mdb_var_t *v) 648 { 649 mdb_tgt_reg_t r = 0; 650 651 (void) mdb_tgt_getareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), &r); 652 653 return (r); 654 } 655 656 static void 657 kmt_reg_disc_set(mdb_var_t *v, uintmax_t r) 658 { 659 if (mdb_tgt_putareg(MDB_NV_COOKIE(v), 0, mdb_nv_get_name(v), r) == -1) 660 warn("failed to modify %%%s register", mdb_nv_get_name(v)); 661 } 662 663 static const mdb_nv_disc_t kmt_reg_disc = { 664 kmt_reg_disc_set, 665 kmt_reg_disc_get 666 }; 667 668 /*ARGSUSED*/ 669 static int 670 kmt_getareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, 671 mdb_tgt_reg_t *rp) 672 { 673 kreg_t val; 674 675 if (kmdb_dpi_get_register(rname, &val) < 0) 676 return (set_errno(EMDB_BADREG)); 677 678 *rp = val; 679 return (0); 680 } 681 682 /*ARGSUSED*/ 683 static int 684 kmt_putareg(mdb_tgt_t *t, mdb_tgt_tid_t tid, const char *rname, mdb_tgt_reg_t r) 685 { 686 if (kmdb_dpi_set_register(rname, r) < 0) 687 return (set_errno(EMDB_BADREG)); 688 689 return (0); 690 } 691 692 static void 693 kmt_mod_destroy(kmt_module_t *km) 694 { 695 if (km->km_name != NULL) 696 strfree(km->km_name); 697 if (km->km_symtab != NULL) 698 mdb_gelf_symtab_destroy(km->km_symtab); 699 if (km->km_ctfp != NULL) 700 mdb_ctf_close(km->km_ctfp); 701 } 702 703 static kmt_module_t * 704 kmt_mod_create(mdb_tgt_t *t, struct modctl *ctlp, char *name) 705 { 706 kmt_module_t *km = mdb_zalloc(sizeof (kmt_module_t), UM_SLEEP); 707 struct module *mod; 708 709 km->km_name = mdb_alloc(strlen(name) + 1, UM_SLEEP); 710 (void) strcpy(km->km_name, name); 711 712 bcopy(ctlp, &km->km_modctl, sizeof (struct modctl)); 713 714 if (mdb_tgt_vread(t, &km->km_module, sizeof (struct module), 715 (uintptr_t)km->km_modctl.mod_mp) != sizeof (struct module)) 716 goto create_module_cleanup; 717 mod = &km->km_module; 718 719 if (mod->symhdr != NULL && mod->strhdr != NULL && mod->symtbl != NULL && 720 mod->strings != NULL) { 721 mdb_gelf_ehdr_to_gehdr(&mod->hdr, &km->km_ehdr); 722 723 km->km_symtab = mdb_gelf_symtab_create_raw(&km->km_ehdr, 724 mod->symhdr, mod->symtbl, mod->strhdr, mod->strings, 725 MDB_TGT_SYMTAB); 726 727 km->km_symtab_va = mod->symtbl; 728 km->km_strtab_va = mod->strings; 729 730 if (mdb_tgt_vread(t, &km->km_symtab_hdr, sizeof (Shdr), 731 (uintptr_t)mod->symhdr) != sizeof (Shdr) || 732 mdb_tgt_vread(t, &km->km_strtab_hdr, sizeof (Shdr), 733 (uintptr_t)mod->strhdr) != sizeof (Shdr)) 734 goto create_module_cleanup; 735 } 736 737 /* 738 * We don't want everyone rooting around in the module structure, so we 739 * make copies of the interesting members. 740 */ 741 km->km_text_va = (uintptr_t)mod->text; 742 km->km_text_size = mod->text_size; 743 km->km_data_va = (uintptr_t)mod->data; 744 km->km_data_size = mod->data_size; 745 km->km_bss_va = (uintptr_t)mod->bss; 746 km->km_bss_size = mod->bss_size; 747 km->km_ctf_va = mod->ctfdata; 748 km->km_ctf_size = mod->ctfsize; 749 750 if (mod->flags & KOBJ_PRIM) 751 km->km_flags |= KM_F_PRIMARY; 752 753 return (km); 754 755 create_module_cleanup: 756 warn("failed to read module %s\n", name); 757 kmt_mod_destroy(km); 758 return (NULL); 759 } 760 761 static void 762 kmt_mod_remove(kmt_data_t *kmt, kmt_module_t *km) 763 { 764 mdb_var_t *v = mdb_nv_lookup(&kmt->kmt_modules, km->km_name); 765 766 ASSERT(v != NULL); 767 768 mdb_dprintf(MDB_DBG_KMOD, "removing module %s\n", km->km_name); 769 770 mdb_list_delete(&kmt->kmt_modlist, km); 771 mdb_nv_remove(&kmt->kmt_modules, v); 772 kmt_mod_destroy(km); 773 } 774 775 static int 776 kmt_modlist_update_cb(struct modctl *modp, void *arg) 777 { 778 mdb_tgt_t *t = arg; 779 kmt_data_t *kmt = t->t_data; 780 kmt_module_t *km; 781 mdb_var_t *v; 782 char name[MAXNAMELEN]; 783 784 if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name, MAXNAMELEN, 785 (uintptr_t)modp->mod_modname) <= 0) { 786 warn("failed to read module name at %p", 787 (void *)modp->mod_modname); 788 } 789 790 /* We only care about modules that are actually loaded */ 791 if (!kmdb_kdi_mod_isloaded(modp)) 792 return (0); 793 794 /* 795 * Skip the modules we already know about and that haven't 796 * changed since last time we were here. 797 */ 798 if ((v = mdb_nv_lookup(&kmt->kmt_modules, name)) != NULL) { 799 km = MDB_NV_COOKIE(v); 800 801 if (kmdb_kdi_mod_haschanged(&km->km_modctl, &km->km_module, 802 modp, modp->mod_mp)) { 803 /* 804 * The module has changed since last we saw it. For 805 * safety, remove our old version, and treat it as a 806 * new module. 807 */ 808 mdb_dprintf(MDB_DBG_KMOD, "stutter module %s\n", name); 809 kmt_mod_remove(kmt, km); 810 } else { 811 km->km_seen = 1; 812 return (0); 813 } 814 } 815 816 mdb_dprintf(MDB_DBG_KMOD, "found new module %s\n", name); 817 818 if ((km = kmt_mod_create(t, modp, name)) != NULL) { 819 mdb_list_append(&kmt->kmt_modlist, km); 820 (void) mdb_nv_insert(&kmt->kmt_modules, name, NULL, 821 (uintptr_t)km, 0); 822 km->km_seen = 1; 823 } 824 825 return (0); 826 } 827 828 static void 829 kmt_modlist_update(mdb_tgt_t *t) 830 { 831 kmt_data_t *kmt = t->t_data; 832 kmt_module_t *km, *kmn; 833 834 if (kmdb_kdi_mod_iter(kmt_modlist_update_cb, t) < 0) { 835 warn("failed to complete update of kernel module list\n"); 836 return; 837 } 838 839 km = mdb_list_next(&kmt->kmt_modlist); 840 while (km != NULL) { 841 kmn = mdb_list_next(km); 842 843 if (km->km_seen == 1) { 844 /* Reset the mark for next time */ 845 km->km_seen = 0; 846 } else { 847 /* 848 * We didn't see it on the kernel's module list, so 849 * remove it from our view of the world. 850 */ 851 kmt_mod_remove(kmt, km); 852 } 853 854 km = kmn; 855 } 856 } 857 858 static void 859 kmt_periodic(mdb_tgt_t *t) 860 { 861 (void) mdb_tgt_status(t, &t->t_status); 862 } 863 864 int 865 kmt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags, 866 char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip) 867 { 868 kmt_data_t *kmt = t->t_data; 869 kmt_module_t *km = mdb_list_next(&kmt->kmt_modlist); 870 kmt_module_t *sym_km = NULL; 871 kmt_module_t prmod; 872 GElf_Sym sym; 873 uint_t symid; 874 const char *name; 875 876 /* 877 * We look through the private symbols (if any), then through the module 878 * symbols. We can simplify the loop if we pretend the private symbols 879 * come from a module. 880 */ 881 if (mdb.m_prsym != NULL) { 882 bzero(&prmod, sizeof (kmt_module_t)); 883 prmod.km_name = "<<<prmod>>>"; 884 prmod.km_symtab = mdb.m_prsym; 885 prmod.km_list.ml_next = (mdb_list_t *)km; 886 km = &prmod; 887 } 888 889 /* Symbol resolution isn't available during initialization */ 890 if (kmdb_dpi_get_state(NULL) == DPI_STATE_INIT) 891 return (set_errno(EMDB_NOSYM)); 892 893 for (; km != NULL; km = mdb_list_next(km)) { 894 if (km != &prmod && !kmt->kmt_symavail) 895 continue; 896 897 if (km->km_symtab == NULL) 898 continue; 899 900 if (mdb_gelf_symtab_lookup_by_addr(km->km_symtab, addr, flags, 901 buf, nbytes, symp, &sip->sym_id) != 0 || 902 symp->st_value == 0) 903 continue; 904 905 if (flags & MDB_TGT_SYM_EXACT) { 906 sym_km = km; 907 goto found; 908 } 909 910 /* 911 * If this is the first match we've found, or if this symbol is 912 * closer to the specified address than the last one we found, 913 * use it. 914 */ 915 if (sym_km == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) { 916 sym_km = km; 917 sym = *symp; 918 symid = sip->sym_id; 919 } 920 } 921 922 /* 923 * kmdb dmods are normal kernel modules, loaded by krtld as such. To 924 * avoid polluting modinfo, and to keep from confusing the module 925 * subsystem (many dmods have the same names as real kernel modules), 926 * kmdb keeps their modctls separate, and doesn't allow their loading 927 * to be broadcast via the krtld module load/unload mechanism. As a 928 * result, kmdb_kvm doesn't find out about them, and can't turn their 929 * addresses into symbols. This can be most inconvenient during 930 * debugger faults, as the dmod frames will show up without names. 931 * We weren't able to turn the requested address into a symbol, so we'll 932 * take a spin through the dmods, trying to match our address against 933 * their symbols. 934 */ 935 if (sym_km == NULL) { 936 return (kmdb_module_lookup_by_addr(addr, flags, buf, nbytes, 937 symp, sip)); 938 } 939 940 *symp = sym; 941 sip->sym_id = symid; 942 943 found: 944 /* 945 * Once we've found something, copy the final name into the caller's 946 * buffer and prefix it with the load object name if appropriate. 947 */ 948 name = mdb_gelf_sym_name(sym_km->km_symtab, symp); 949 950 if (sym_km == &prmod) { 951 if (buf != NULL) { 952 (void) strncpy(buf, name, nbytes); 953 buf[nbytes - 1] = '\0'; 954 } 955 sip->sym_table = MDB_TGT_PRVSYM; 956 } else { 957 if (buf != NULL) { 958 if (sym_km->km_flags & KM_F_PRIMARY) { 959 (void) strncpy(buf, name, nbytes); 960 buf[nbytes - 1] = '\0'; 961 } else { 962 (void) mdb_snprintf(buf, nbytes, "%s`%s", 963 sym_km->km_name, name); 964 } 965 } 966 sip->sym_table = MDB_TGT_SYMTAB; 967 } 968 969 return (0); 970 } 971 972 static int 973 kmt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name, 974 GElf_Sym *symp, mdb_syminfo_t *sip) 975 { 976 kmt_data_t *kmt = t->t_data; 977 kmt_module_t *km; 978 mdb_var_t *v; 979 GElf_Sym sym; 980 uint_t symid; 981 int n; 982 983 if (!kmt->kmt_symavail) 984 return (set_errno(EMDB_NOSYM)); 985 986 switch ((uintptr_t)obj) { 987 case (uintptr_t)MDB_TGT_OBJ_EXEC: 988 case (uintptr_t)MDB_TGT_OBJ_EVERY: 989 km = mdb_list_next(&kmt->kmt_modlist); 990 n = mdb_nv_size(&kmt->kmt_modules); 991 break; 992 993 case (uintptr_t)MDB_TGT_OBJ_RTLD: 994 obj = kmt->kmt_rtld_name; 995 /*FALLTHROUGH*/ 996 997 default: 998 /* 999 * If this is a request for a dmod symbol, let kmdb_module 1000 * handle it. 1001 */ 1002 if (obj != NULL && strncmp(obj, "DMOD`", 5) == 0) { 1003 return (kmdb_module_lookup_by_name(obj + 5, name, 1004 symp, sip)); 1005 } 1006 1007 if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL) 1008 return (set_errno(EMDB_NOOBJ)); 1009 1010 km = mdb_nv_get_cookie(v); 1011 n = 1; 1012 } 1013 1014 /* 1015 * kmdb's kvm target is at a bit of a disadvantage compared to mdb's 1016 * kvm target when it comes to global symbol lookups. mdb has ksyms, 1017 * which hides pesky things like symbols that are undefined in unix, 1018 * but which are defined in genunix. We don't have such a facility - 1019 * we simply iterate through the modules, looking for a given symbol 1020 * in each. Unless we're careful, we'll return the undef in the 1021 * aforementioned case. 1022 */ 1023 for (; n > 0; n--, km = mdb_list_next(km)) { 1024 if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name, 1025 &sym, &symid) == 0 && sym.st_shndx != SHN_UNDEF) 1026 break; 1027 } 1028 1029 if (n == 0) 1030 return (set_errno(EMDB_NOSYM)); 1031 1032 found: 1033 bcopy(&sym, symp, sizeof (GElf_Sym)); 1034 sip->sym_id = symid; 1035 sip->sym_table = MDB_TGT_SYMTAB; 1036 1037 return (0); 1038 } 1039 1040 static int 1041 kmt_symtab_func(void *data, const GElf_Sym *sym, const char *name, uint_t id) 1042 { 1043 kmt_symarg_t *arg = data; 1044 1045 if (mdb_tgt_sym_match(sym, arg->sym_type)) { 1046 arg->sym_info.sym_id = id; 1047 1048 return (arg->sym_cb(arg->sym_data, sym, name, &arg->sym_info, 1049 arg->sym_obj)); 1050 } 1051 1052 return (0); 1053 } 1054 1055 static void 1056 kmt_symtab_iter(mdb_gelf_symtab_t *gst, uint_t type, const char *obj, 1057 mdb_tgt_sym_f *cb, void *p) 1058 { 1059 kmt_symarg_t arg; 1060 1061 arg.sym_cb = cb; 1062 arg.sym_data = p; 1063 arg.sym_type = type; 1064 arg.sym_info.sym_table = gst->gst_tabid; 1065 arg.sym_obj = obj; 1066 1067 mdb_gelf_symtab_iter(gst, kmt_symtab_func, &arg); 1068 } 1069 1070 static int 1071 kmt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type, 1072 mdb_tgt_sym_f *cb, void *data) 1073 { 1074 kmt_data_t *kmt = t->t_data; 1075 kmt_module_t *km; 1076 1077 mdb_gelf_symtab_t *symtab = NULL; 1078 mdb_var_t *v; 1079 1080 if (which == MDB_TGT_DYNSYM) 1081 return (set_errno(EMDB_TGTNOTSUP)); 1082 1083 switch ((uintptr_t)obj) { 1084 case (uintptr_t)MDB_TGT_OBJ_EXEC: 1085 case (uintptr_t)MDB_TGT_OBJ_EVERY: 1086 mdb_nv_rewind(&kmt->kmt_modules); 1087 while ((v = mdb_nv_advance(&kmt->kmt_modules)) != NULL) { 1088 km = mdb_nv_get_cookie(v); 1089 1090 if (km->km_symtab != NULL) { 1091 kmt_symtab_iter(km->km_symtab, type, 1092 km->km_name, cb, data); 1093 } 1094 } 1095 return (0); 1096 1097 case (uintptr_t)MDB_TGT_OBJ_RTLD: 1098 obj = kmt->kmt_rtld_name; 1099 /*FALLTHROUGH*/ 1100 1101 default: 1102 if (strncmp(obj, "DMOD`", 5) == 0) { 1103 return (kmdb_module_symbol_iter(obj + 5, type, 1104 cb, data)); 1105 } 1106 1107 if ((v = mdb_nv_lookup(&kmt->kmt_modules, obj)) == NULL) 1108 return (set_errno(EMDB_NOOBJ)); 1109 km = mdb_nv_get_cookie(v); 1110 1111 symtab = km->km_symtab; 1112 } 1113 1114 if (symtab != NULL) 1115 kmt_symtab_iter(symtab, type, obj, cb, data); 1116 1117 return (0); 1118 } 1119 1120 static int 1121 kmt_mapping_walk(uintptr_t addr, const void *data, kmt_maparg_t *marg) 1122 { 1123 /* 1124 * This is a bit sketchy but avoids problematic compilation of this 1125 * target against the current VM implementation. Now that we have 1126 * vmem, we can make this less broken and more informative by changing 1127 * this code to invoke the vmem walker in the near future. 1128 */ 1129 const struct kmt_seg { 1130 caddr_t s_base; 1131 size_t s_size; 1132 } *segp = (const struct kmt_seg *)data; 1133 1134 mdb_map_t map; 1135 GElf_Sym sym; 1136 mdb_syminfo_t info; 1137 1138 map.map_base = (uintptr_t)segp->s_base; 1139 map.map_size = segp->s_size; 1140 map.map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X; 1141 1142 if (kmt_lookup_by_addr(marg->map_target, addr, MDB_TGT_SYM_EXACT, 1143 map.map_name, MDB_TGT_MAPSZ, &sym, &info) == -1) { 1144 1145 (void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ, 1146 "%lr", addr); 1147 } 1148 1149 return (marg->map_cb(marg->map_data, &map, map.map_name)); 1150 } 1151 1152 static int 1153 kmt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 1154 { 1155 kmt_maparg_t m; 1156 uintptr_t kas; 1157 1158 m.map_target = t; 1159 m.map_cb = func; 1160 m.map_data = private; 1161 1162 if ((kas = kmt_read_kas(t)) == NULL) 1163 return (-1); /* errno is set for us */ 1164 1165 return (mdb_pwalk("seg", (mdb_walk_cb_t)kmt_mapping_walk, &m, kas)); 1166 } 1167 1168 static const mdb_map_t * 1169 kmt_mod_to_map(kmt_module_t *km, mdb_map_t *map) 1170 { 1171 (void) strncpy(map->map_name, km->km_name, MDB_TGT_MAPSZ); 1172 map->map_name[MDB_TGT_MAPSZ - 1] = '\0'; 1173 map->map_base = km->km_text_va; 1174 map->map_size = km->km_text_size; 1175 map->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X; 1176 1177 return (map); 1178 } 1179 1180 static int 1181 kmt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 1182 { 1183 kmt_data_t *kmt = t->t_data; 1184 kmt_module_t *km; 1185 mdb_map_t m; 1186 1187 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 1188 km = mdb_list_next(km)) { 1189 if (func(private, kmt_mod_to_map(km, &m), km->km_name) == -1) 1190 break; 1191 } 1192 1193 return (0); 1194 } 1195 1196 static const mdb_map_t * 1197 kmt_addr_to_map(mdb_tgt_t *t, uintptr_t addr) 1198 { 1199 kmt_data_t *kmt = t->t_data; 1200 kmt_module_t *km; 1201 1202 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 1203 km = mdb_list_next(km)) { 1204 if (addr - km->km_text_va < km->km_text_size || 1205 addr - km->km_data_va < km->km_data_size || 1206 addr - km->km_bss_va < km->km_bss_size) 1207 return (kmt_mod_to_map(km, &kmt->kmt_map)); 1208 } 1209 1210 (void) set_errno(EMDB_NOMAP); 1211 return (NULL); 1212 } 1213 1214 static kmt_module_t * 1215 kmt_module_by_name(kmt_data_t *kmt, const char *name) 1216 { 1217 kmt_module_t *km; 1218 1219 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 1220 km = mdb_list_next(km)) { 1221 if (strcmp(name, km->km_name) == 0) 1222 return (km); 1223 } 1224 1225 return (NULL); 1226 } 1227 1228 static const mdb_map_t * 1229 kmt_name_to_map(mdb_tgt_t *t, const char *name) 1230 { 1231 kmt_data_t *kmt = t->t_data; 1232 kmt_module_t *km; 1233 mdb_map_t m; 1234 1235 /* 1236 * If name is MDB_TGT_OBJ_EXEC, return the first module on the list, 1237 * which will be unix since we keep kmt_modlist in load order. 1238 */ 1239 if (name == MDB_TGT_OBJ_EXEC) { 1240 return (kmt_mod_to_map(mdb_list_next(&kmt->kmt_modlist), 1241 &m)); 1242 } 1243 1244 if (name == MDB_TGT_OBJ_RTLD) 1245 name = kmt->kmt_rtld_name; 1246 1247 if ((km = kmt_module_by_name(kmt, name)) != NULL) 1248 return (kmt_mod_to_map(km, &m)); 1249 1250 (void) set_errno(EMDB_NOOBJ); 1251 return (NULL); 1252 } 1253 1254 static ctf_file_t * 1255 kmt_load_ctfdata(mdb_tgt_t *t, kmt_module_t *km) 1256 { 1257 kmt_data_t *kmt = t->t_data; 1258 int err; 1259 1260 if (km->km_ctfp != NULL) 1261 return (km->km_ctfp); 1262 1263 if (km->km_ctf_va == NULL || km->km_symtab == NULL) { 1264 (void) set_errno(EMDB_NOCTF); 1265 return (NULL); 1266 } 1267 1268 if ((km->km_ctfp = mdb_ctf_bufopen(km->km_ctf_va, km->km_ctf_size, 1269 km->km_symtab_va, &km->km_symtab_hdr, km->km_strtab_va, 1270 &km->km_strtab_hdr, &err)) == NULL) { 1271 (void) set_errno(ctf_to_errno(err)); 1272 return (NULL); 1273 } 1274 1275 mdb_dprintf(MDB_DBG_KMOD, "loaded %lu bytes of CTF data for %s\n", 1276 (ulong_t)km->km_ctf_size, km->km_name); 1277 1278 if (ctf_parent_name(km->km_ctfp) != NULL) { 1279 mdb_var_t *v; 1280 1281 if ((v = mdb_nv_lookup(&kmt->kmt_modules, 1282 ctf_parent_name(km->km_ctfp))) != NULL) { 1283 kmt_module_t *pm = mdb_nv_get_cookie(v); 1284 1285 if (pm->km_ctfp == NULL) 1286 (void) kmt_load_ctfdata(t, pm); 1287 1288 if (pm->km_ctfp != NULL && ctf_import(km->km_ctfp, 1289 pm->km_ctfp) == CTF_ERR) { 1290 warn("failed to import parent types into " 1291 "%s: %s\n", km->km_name, 1292 ctf_errmsg(ctf_errno(km->km_ctfp))); 1293 } 1294 } else { 1295 warn("failed to load CTF data for %s - parent %s not " 1296 "loaded\n", km->km_name, 1297 ctf_parent_name(km->km_ctfp)); 1298 } 1299 } 1300 1301 return (km->km_ctfp); 1302 } 1303 1304 ctf_file_t * 1305 kmt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr) 1306 { 1307 kmt_data_t *kmt = t->t_data; 1308 kmt_module_t *km; 1309 1310 for (km = mdb_list_next(&kmt->kmt_modlist); km != NULL; 1311 km = mdb_list_next(km)) { 1312 if (addr - km->km_text_va < km->km_text_size || 1313 addr - km->km_data_va < km->km_data_size || 1314 addr - km->km_bss_va < km->km_bss_size) 1315 return (kmt_load_ctfdata(t, km)); 1316 } 1317 1318 return (kmdb_module_addr_to_ctf(addr)); 1319 } 1320 1321 ctf_file_t * 1322 kmt_name_to_ctf(mdb_tgt_t *t, const char *name) 1323 { 1324 kmt_data_t *kt = t->t_data; 1325 kmt_module_t *km; 1326 1327 if (name == MDB_TGT_OBJ_EXEC) { 1328 name = KMT_CTFPARENT; 1329 } else if (name == MDB_TGT_OBJ_RTLD) { 1330 name = kt->kmt_rtld_name; 1331 } else if (strncmp(name, "DMOD`", 5) == 0) { 1332 /* Request for CTF data for a DMOD symbol */ 1333 return (kmdb_module_name_to_ctf(name + 5)); 1334 } 1335 1336 if ((km = kmt_module_by_name(kt, name)) != NULL) 1337 return (kmt_load_ctfdata(t, km)); 1338 1339 (void) set_errno(EMDB_NOOBJ); 1340 return (NULL); 1341 } 1342 1343 /*ARGSUSED*/ 1344 static int 1345 kmt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 1346 { 1347 int state; 1348 1349 bzero(tsp, sizeof (mdb_tgt_status_t)); 1350 1351 switch ((state = kmdb_dpi_get_state(NULL))) { 1352 case DPI_STATE_INIT: 1353 tsp->st_state = MDB_TGT_RUNNING; 1354 tsp->st_pc = 0; 1355 break; 1356 1357 case DPI_STATE_STOPPED: 1358 tsp->st_state = MDB_TGT_STOPPED; 1359 1360 (void) kmdb_dpi_get_register("pc", &tsp->st_pc); 1361 break; 1362 1363 case DPI_STATE_FAULTED: 1364 tsp->st_state = MDB_TGT_STOPPED; 1365 1366 (void) kmdb_dpi_get_register("pc", &tsp->st_pc); 1367 1368 tsp->st_flags |= MDB_TGT_ISTOP; 1369 break; 1370 1371 case DPI_STATE_LOST: 1372 tsp->st_state = MDB_TGT_LOST; 1373 1374 (void) kmdb_dpi_get_register("pc", &tsp->st_pc); 1375 break; 1376 } 1377 1378 mdb_dprintf(MDB_DBG_KMOD, "kmt_status, dpi: %d tsp: %d, pc = %p %A\n", 1379 state, tsp->st_state, (void *)tsp->st_pc, tsp->st_pc); 1380 1381 return (0); 1382 } 1383 1384 /* 1385 * Invoked when kmt_defbp_enter_debugger is called, this routine activates and 1386 * deactivates deferred breakpoints in response to module load and unload 1387 * events. 1388 */ 1389 /*ARGSUSED*/ 1390 static void 1391 kmt_defbp_event(mdb_tgt_t *t, int vid, void *private) 1392 { 1393 if (kmt_defbp_modchg_isload) { 1394 if (!mdb_tgt_sespec_activate_all(t) && 1395 (mdb.m_flags & MDB_FL_BPTNOSYMSTOP)) { 1396 /* 1397 * We weren't able to activate the breakpoints. 1398 * If so requested, we'll return without calling 1399 * continue, thus throwing the user into the debugger. 1400 */ 1401 return; 1402 } 1403 1404 } else { 1405 mdb_sespec_t *sep, *nsep; 1406 const mdb_map_t *map, *bpmap; 1407 mdb_map_t modmap; 1408 1409 if ((map = kmt_addr_to_map(t, 1410 (uintptr_t)kmt_defbp_modchg_modctl->mod_text)) == NULL) { 1411 warn("module unload notification for unknown module %s", 1412 kmt_defbp_modchg_modctl->mod_modname); 1413 return; /* drop into the debugger */ 1414 } 1415 1416 bcopy(map, &modmap, sizeof (mdb_map_t)); 1417 1418 for (sep = mdb_list_next(&t->t_active); sep; sep = nsep) { 1419 nsep = mdb_list_next(sep); 1420 1421 if (sep->se_ops == &kmt_brkpt_ops) { 1422 kmt_brkpt_t *kb = sep->se_data; 1423 1424 if ((bpmap = kmt_addr_to_map(t, 1425 kb->kb_addr)) == NULL || 1426 (bpmap->map_base == modmap.map_base && 1427 bpmap->map_size == modmap.map_size)) { 1428 mdb_tgt_sespec_idle_one(t, sep, 1429 EMDB_NOMAP); 1430 } 1431 } 1432 } 1433 } 1434 1435 (void) mdb_tgt_continue(t, NULL); 1436 } 1437 1438 static void 1439 kmt_defbp_enter_debugger(void) 1440 { 1441 /* 1442 * The debugger places a breakpoint here. We can't have a simple 1443 * nop function here, because GCC knows much more than we do, and 1444 * will optimize away the call to it. 1445 */ 1446 (void) get_fp(); 1447 } 1448 1449 /* 1450 * This routine is called while the kernel is running. It attempts to determine 1451 * whether any deferred breakpoints exist for the module being changed (loaded 1452 * or unloaded). If any such breakpoints exist, the debugger will be entered to 1453 * process them. 1454 */ 1455 static void 1456 kmt_defbp_modchg(struct modctl *mctl, int isload) 1457 { 1458 kmt_defbp_t *dbp; 1459 1460 kmt_defbp_lock = 1; 1461 1462 for (dbp = mdb_list_next(&kmt_defbp_list); dbp; 1463 dbp = mdb_list_next(dbp)) { 1464 if (!dbp->dbp_ref) 1465 continue; 1466 1467 if (strcmp(mctl->mod_modname, dbp->dbp_objname) == 0) { 1468 /* 1469 * Activate the breakpoint 1470 */ 1471 kmt_defbp_modchg_isload = isload; 1472 kmt_defbp_modchg_modctl = mctl; 1473 1474 kmt_defbp_enter_debugger(); 1475 break; 1476 } 1477 } 1478 1479 kmt_defbp_lock = 0; 1480 } 1481 1482 /*ARGSUSED*/ 1483 static int 1484 kmt_continue(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 1485 { 1486 int n; 1487 1488 kmdb_dpi_resume(); 1489 1490 /* 1491 * The order of the following two calls is important. If there are 1492 * load acks on the work queue, we'll initialize the dmods they 1493 * represent. This will involve a call to _mdb_init, which may very 1494 * well result in a symbol lookup. If we haven't resynced our view 1495 * of symbols with the current state of the world, this lookup could 1496 * end very badly. We therefore make sure to sync before processing 1497 * the work queue. 1498 */ 1499 kmt_sync(t); 1500 kmdb_dpi_process_work_queue(); 1501 1502 if (kmdb_kdi_get_unload_request()) 1503 t->t_flags |= MDB_TGT_F_UNLOAD; 1504 1505 (void) mdb_tgt_status(t, &t->t_status); 1506 1507 if ((n = kmt_dmod_status(NULL, KMDB_MC_STATE_LOADING) + 1508 kmt_dmod_status(NULL, KMDB_MC_STATE_UNLOADING)) != 0) { 1509 mdb_warn("%d dmod load%c/unload%c pending\n", n, 1510 "s"[n == 1], "s"[n == 1]); 1511 } 1512 1513 return (0); 1514 } 1515 1516 /*ARGSUSED*/ 1517 static int 1518 kmt_step(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 1519 { 1520 int rc; 1521 1522 if ((rc = kmdb_dpi_step()) == 0) 1523 (void) mdb_tgt_status(t, &t->t_status); 1524 1525 return (rc); 1526 } 1527 1528 static int 1529 kmt_defbp_activate(mdb_tgt_t *t) 1530 { 1531 kmdb_dpi_modchg_register(kmt_defbp_modchg); 1532 1533 /* 1534 * The routines that add and arm breakpoints will check for the proper 1535 * DTrace state, but they'll just put this breakpoint on the idle list 1536 * if DTrace is active. It'll correctly move to the active list when 1537 * DTrace deactivates, but that's insufficient for our purposes -- we 1538 * need to do extra processing at that point. We won't get to do said 1539 * processing with with a normal idle->active transition, so we just 1540 * won't add it add it until we're sure that it'll stick. 1541 */ 1542 1543 if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE) 1544 return (set_errno(EMDB_DTACTIVE)); 1545 1546 kmt_defbp_bpspec = mdb_tgt_add_vbrkpt(t, 1547 (uintptr_t)kmt_defbp_enter_debugger, 1548 MDB_TGT_SPEC_HIDDEN, kmt_defbp_event, NULL); 1549 1550 return (0); 1551 } 1552 1553 static void 1554 kmt_defbp_deactivate(mdb_tgt_t *t) 1555 { 1556 kmdb_dpi_modchg_cancel(); 1557 1558 if (kmt_defbp_bpspec != 0) { 1559 if (t != NULL) 1560 (void) mdb_tgt_vespec_delete(t, kmt_defbp_bpspec); 1561 1562 kmt_defbp_bpspec = 0; 1563 } 1564 } 1565 1566 static kmt_defbp_t * 1567 kmt_defbp_create(mdb_tgt_t *t, const char *objname, const char *symname) 1568 { 1569 kmt_defbp_t *dbp = mdb_alloc(sizeof (kmt_defbp_t), UM_SLEEP); 1570 1571 mdb_dprintf(MDB_DBG_KMOD, "defbp_create %s`%s\n", objname, symname); 1572 1573 dbp->dbp_objname = strdup(objname); 1574 dbp->dbp_symname = strdup(symname); 1575 dbp->dbp_ref = 1; 1576 1577 kmt_defbp_num++; 1578 1579 if (kmt_defbp_num == 1 || kmt_defbp_bpspec == 0) { 1580 if (kmt_defbp_activate(t) < 0) 1581 warn("failed to activate deferred breakpoints"); 1582 } 1583 1584 mdb_list_append(&kmt_defbp_list, dbp); 1585 1586 return (dbp); 1587 } 1588 1589 static void 1590 kmt_defbp_destroy(kmt_defbp_t *dbp) 1591 { 1592 mdb_dprintf(MDB_DBG_KMOD, "defbp_destroy %s`%s\n", dbp->dbp_objname, 1593 dbp->dbp_symname); 1594 1595 mdb_list_delete(&kmt_defbp_list, dbp); 1596 1597 strfree(dbp->dbp_objname); 1598 strfree(dbp->dbp_symname); 1599 mdb_free(dbp, sizeof (kmt_defbp_t)); 1600 } 1601 1602 static void 1603 kmt_defbp_prune_common(int all) 1604 { 1605 kmt_defbp_t *dbp, *ndbp; 1606 1607 /* We can't remove items from the list while the driver is using it. */ 1608 if (kmt_defbp_lock) 1609 return; 1610 1611 for (dbp = mdb_list_next(&kmt_defbp_list); dbp != NULL; dbp = ndbp) { 1612 ndbp = mdb_list_next(dbp); 1613 1614 if (!all && dbp->dbp_ref) 1615 continue; 1616 1617 kmt_defbp_destroy(dbp); 1618 } 1619 } 1620 1621 static void 1622 kmt_defbp_prune(void) 1623 { 1624 kmt_defbp_prune_common(0); 1625 } 1626 1627 static void 1628 kmt_defbp_destroy_all(void) 1629 { 1630 kmt_defbp_prune_common(1); 1631 } 1632 1633 static void 1634 kmt_defbp_delete(mdb_tgt_t *t, kmt_defbp_t *dbp) 1635 { 1636 dbp->dbp_ref = 0; 1637 1638 ASSERT(kmt_defbp_num > 0); 1639 kmt_defbp_num--; 1640 1641 if (kmt_defbp_num == 0) 1642 kmt_defbp_deactivate(t); 1643 1644 kmt_defbp_prune(); 1645 } 1646 1647 static int 1648 kmt_brkpt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 1649 { 1650 mdb_tgt_status_t tsp; 1651 kmt_bparg_t *ka = args; 1652 kmt_brkpt_t *kb; 1653 GElf_Sym s; 1654 mdb_instr_t instr; 1655 1656 (void) mdb_tgt_status(t, &tsp); 1657 if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED) 1658 return (set_errno(EMDB_NOPROC)); 1659 1660 if (ka->ka_symbol != NULL) { 1661 if (mdb_tgt_lookup_by_scope(t, ka->ka_symbol, &s, NULL) == -1) { 1662 if (errno != EMDB_NOOBJ && !(errno == EMDB_NOSYM && 1663 !(mdb.m_flags & MDB_FL_BPTNOSYMSTOP))) { 1664 warn("breakpoint %s activation failed", 1665 ka->ka_symbol); 1666 } 1667 return (-1); /* errno is set for us */ 1668 } 1669 1670 ka->ka_addr = (uintptr_t)s.st_value; 1671 } 1672 1673 #ifdef __sparc 1674 if (ka->ka_addr & 3) 1675 return (set_errno(EMDB_BPALIGN)); 1676 #endif 1677 1678 if (mdb_vread(&instr, sizeof (instr), ka->ka_addr) != sizeof (instr)) 1679 return (-1); /* errno is set for us */ 1680 1681 if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE) 1682 warn("breakpoint will not arm until DTrace is inactive\n"); 1683 1684 kb = mdb_zalloc(sizeof (kmt_brkpt_t), UM_SLEEP); 1685 kb->kb_addr = ka->ka_addr; 1686 sep->se_data = kb; 1687 1688 return (0); 1689 } 1690 1691 /*ARGSUSED*/ 1692 static void 1693 kmt_brkpt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 1694 { 1695 mdb_free(sep->se_data, sizeof (kmt_brkpt_t)); 1696 } 1697 1698 /*ARGSUSED*/ 1699 static char * 1700 kmt_brkpt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 1701 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 1702 { 1703 uintptr_t addr = NULL; 1704 1705 if (vep != NULL) { 1706 kmt_bparg_t *ka = vep->ve_args; 1707 1708 if (ka->ka_symbol != NULL) { 1709 (void) mdb_iob_snprintf(buf, nbytes, "stop at %s", 1710 ka->ka_symbol); 1711 } else { 1712 (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", 1713 ka->ka_addr); 1714 addr = ka->ka_addr; 1715 } 1716 1717 } else { 1718 addr = ((kmt_brkpt_t *)sep->se_data)->kb_addr; 1719 (void) mdb_iob_snprintf(buf, nbytes, "stop at %a", addr); 1720 } 1721 1722 sp->spec_base = addr; 1723 sp->spec_size = sizeof (mdb_instr_t); 1724 1725 return (buf); 1726 } 1727 1728 static int 1729 kmt_brkpt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 1730 { 1731 kmt_brkpt_t *kb = sep->se_data; 1732 kmt_bparg_t *ka = args; 1733 GElf_Sym sym; 1734 1735 if (ka->ka_symbol != NULL) { 1736 return (mdb_tgt_lookup_by_scope(t, ka->ka_symbol, 1737 &sym, NULL) == 0 && sym.st_value == kb->kb_addr); 1738 } 1739 1740 return (ka->ka_addr == kb->kb_addr); 1741 } 1742 1743 /*ARGSUSED*/ 1744 static int 1745 kmt_brkpt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args) 1746 { 1747 kmt_bparg_t *ka1 = vep->ve_args; 1748 kmt_bparg_t *ka2 = args; 1749 1750 if (ka1->ka_symbol != NULL && ka2->ka_symbol != NULL) 1751 return (strcmp(ka1->ka_symbol, ka2->ka_symbol) == 0); 1752 1753 if (ka1->ka_symbol == NULL && ka2->ka_symbol == NULL) 1754 return (ka1->ka_addr == ka2->ka_addr); 1755 1756 return (0); /* fail if one is symbolic, other is an explicit address */ 1757 } 1758 1759 static int 1760 kmt_brkpt_arm(mdb_tgt_t *t, mdb_sespec_t *sep) 1761 { 1762 kmt_data_t *kmt = t->t_data; 1763 kmt_brkpt_t *kb = sep->se_data; 1764 int rv; 1765 1766 if (kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_DTRACE_ACTIVE) 1767 return (set_errno(EMDB_DTACTIVE)); 1768 1769 if ((rv = kmdb_dpi_brkpt_arm(kb->kb_addr, &kb->kb_oinstr)) != 0) 1770 return (rv); 1771 1772 if (kmt->kmt_narmedbpts++ == 0) 1773 (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_ACTIVATE); 1774 1775 return (0); 1776 } 1777 1778 static int 1779 kmt_brkpt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep) 1780 { 1781 kmt_data_t *kmt = t->t_data; 1782 kmt_brkpt_t *kb = sep->se_data; 1783 int rv; 1784 1785 ASSERT(kmdb_kdi_dtrace_get_state() == KDI_DTSTATE_KMDB_BPT_ACTIVE); 1786 1787 if ((rv = kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr)) != 0) 1788 return (rv); 1789 1790 if (--kmt->kmt_narmedbpts == 0) 1791 (void) kmdb_kdi_dtrace_set(KDI_DTSET_KMDB_BPT_DEACTIVATE); 1792 1793 return (0); 1794 } 1795 1796 /* 1797 * Determine whether the specified sespec is an armed watchpoint that overlaps 1798 * with the given breakpoint and has the given flags set. We use this to find 1799 * conflicts with breakpoints, below. 1800 */ 1801 static int 1802 kmt_wp_overlap(mdb_sespec_t *sep, kmt_brkpt_t *kb, int flags) 1803 { 1804 const kmdb_wapt_t *wp = sep->se_data; 1805 1806 return (sep->se_state == MDB_TGT_SPEC_ARMED && 1807 sep->se_ops == &kmt_wapt_ops && (wp->wp_wflags & flags) && 1808 kb->kb_addr - wp->wp_addr < wp->wp_size); 1809 } 1810 1811 /* 1812 * We step over breakpoints using our single-stepper. If a conflicting 1813 * watchpoint is present, we must temporarily remove it before stepping over the 1814 * breakpoint so we don't immediately re-trigger the watchpoint. We know the 1815 * watchpoint has already triggered on our trap instruction as part of fetching 1816 * it. Before we return, we must re-install any disabled watchpoints. 1817 */ 1818 static int 1819 kmt_brkpt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 1820 { 1821 kmt_brkpt_t *kb = sep->se_data; 1822 int status = -1; 1823 int error; 1824 1825 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 1826 if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X)) 1827 (void) kmdb_dpi_wapt_disarm(sep->se_data); 1828 } 1829 1830 if (kmdb_dpi_brkpt_disarm(kb->kb_addr, kb->kb_oinstr) == 0 && 1831 kmt_step(t, tsp) == 0) 1832 status = kmt_status(t, tsp); 1833 1834 error = errno; /* save errno from disarm, step, or status */ 1835 1836 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 1837 if (kmt_wp_overlap(sep, kb, MDB_TGT_WA_X)) 1838 kmdb_dpi_wapt_arm(sep->se_data); 1839 } 1840 1841 (void) set_errno(error); 1842 return (status); 1843 } 1844 1845 /*ARGSUSED*/ 1846 static int 1847 kmt_brkpt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 1848 { 1849 kmt_brkpt_t *kb = sep->se_data; 1850 int state, why; 1851 kreg_t pc; 1852 1853 state = kmdb_dpi_get_state(&why); 1854 (void) kmdb_dpi_get_register("pc", &pc); 1855 1856 return (state == DPI_STATE_FAULTED && why == DPI_STATE_WHY_BKPT && 1857 pc == kb->kb_addr); 1858 } 1859 1860 static const mdb_se_ops_t kmt_brkpt_ops = { 1861 kmt_brkpt_ctor, /* se_ctor */ 1862 kmt_brkpt_dtor, /* se_dtor */ 1863 kmt_brkpt_info, /* se_info */ 1864 kmt_brkpt_secmp, /* se_secmp */ 1865 kmt_brkpt_vecmp, /* se_vecmp */ 1866 kmt_brkpt_arm, /* se_arm */ 1867 kmt_brkpt_disarm, /* se_disarm */ 1868 kmt_brkpt_cont, /* se_cont */ 1869 kmt_brkpt_match /* se_match */ 1870 }; 1871 1872 static int 1873 kmt_wapt_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 1874 { 1875 mdb_tgt_status_t tsp; 1876 kmdb_wapt_t *vwp = args; 1877 kmdb_wapt_t *swp; 1878 1879 (void) mdb_tgt_status(t, &tsp); 1880 if (tsp.st_state != MDB_TGT_RUNNING && tsp.st_state != MDB_TGT_STOPPED) 1881 return (set_errno(EMDB_NOPROC)); 1882 1883 swp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP); 1884 bcopy(vwp, swp, sizeof (kmdb_wapt_t)); 1885 1886 if (kmdb_dpi_wapt_reserve(swp) < 0) { 1887 mdb_free(swp, sizeof (kmdb_wapt_t)); 1888 return (-1); /* errno is set for us */ 1889 } 1890 1891 sep->se_data = swp; 1892 1893 return (0); 1894 } 1895 1896 /*ARGSUSED*/ 1897 static void 1898 kmt_wapt_dtor(mdb_tgt_t *t, mdb_sespec_t *sep) 1899 { 1900 kmdb_wapt_t *wp = sep->se_data; 1901 1902 kmdb_dpi_wapt_release(wp); 1903 mdb_free(wp, sizeof (kmdb_wapt_t)); 1904 } 1905 1906 /*ARGSUSED*/ 1907 static char * 1908 kmt_wapt_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 1909 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 1910 { 1911 kmdb_wapt_t *wp = vep != NULL ? vep->ve_args : sep->se_data; 1912 const char *fmt; 1913 char desc[24]; 1914 1915 ASSERT(wp->wp_wflags != 0); 1916 desc[0] = '\0'; 1917 1918 switch (wp->wp_wflags) { 1919 case MDB_TGT_WA_R: 1920 (void) strcat(desc, "/read"); 1921 break; 1922 case MDB_TGT_WA_W: 1923 (void) strcat(desc, "/write"); 1924 break; 1925 case MDB_TGT_WA_X: 1926 (void) strcat(desc, "/exec"); 1927 break; 1928 default: 1929 if (wp->wp_wflags & MDB_TGT_WA_R) 1930 (void) strcat(desc, "/r"); 1931 if (wp->wp_wflags & MDB_TGT_WA_W) 1932 (void) strcat(desc, "/w"); 1933 if (wp->wp_wflags & MDB_TGT_WA_X) 1934 (void) strcat(desc, "/x"); 1935 } 1936 1937 switch (wp->wp_type) { 1938 case DPI_WAPT_TYPE_PHYS: 1939 fmt = "stop on %s of phys [%p, %p)"; 1940 break; 1941 1942 case DPI_WAPT_TYPE_VIRT: 1943 fmt = "stop on %s of [%la, %la)"; 1944 break; 1945 1946 case DPI_WAPT_TYPE_IO: 1947 if (wp->wp_size == 1) 1948 fmt = "stop on %s of I/O port %p"; 1949 else 1950 fmt = "stop on %s of I/O port [%p, %p)"; 1951 break; 1952 } 1953 1954 (void) mdb_iob_snprintf(buf, nbytes, fmt, desc + 1, wp->wp_addr, 1955 wp->wp_addr + wp->wp_size); 1956 1957 sp->spec_base = wp->wp_addr; 1958 sp->spec_size = wp->wp_size; 1959 1960 return (buf); 1961 } 1962 1963 /*ARGSUSED*/ 1964 static int 1965 kmt_wapt_secmp(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 1966 { 1967 kmdb_wapt_t *wp1 = sep->se_data; 1968 kmdb_wapt_t *wp2 = args; 1969 1970 return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size && 1971 wp1->wp_wflags == wp2->wp_wflags); 1972 } 1973 1974 /*ARGSUSED*/ 1975 static int 1976 kmt_wapt_vecmp(mdb_tgt_t *t, mdb_vespec_t *vep, void *args) 1977 { 1978 kmdb_wapt_t *wp1 = vep->ve_args; 1979 kmdb_wapt_t *wp2 = args; 1980 1981 return (wp1->wp_addr == wp2->wp_addr && wp1->wp_size == wp2->wp_size && 1982 wp1->wp_wflags == wp2->wp_wflags); 1983 } 1984 1985 /*ARGSUSED*/ 1986 static int 1987 kmt_wapt_arm(mdb_tgt_t *t, mdb_sespec_t *sep) 1988 { 1989 kmdb_dpi_wapt_arm(sep->se_data); 1990 1991 return (0); 1992 } 1993 1994 /*ARGSUSED*/ 1995 static int 1996 kmt_wapt_disarm(mdb_tgt_t *t, mdb_sespec_t *sep) 1997 { 1998 kmdb_dpi_wapt_disarm(sep->se_data); 1999 2000 return (0); 2001 } 2002 2003 /* 2004 * Determine whether the specified sespec is an armed breakpoint at the given 2005 * %pc. We use this to find conflicts with watchpoints below. 2006 */ 2007 static int 2008 kmt_bp_overlap(mdb_sespec_t *sep, uintptr_t pc) 2009 { 2010 kmt_brkpt_t *kb = sep->se_data; 2011 2012 return (sep->se_state == MDB_TGT_SPEC_ARMED && 2013 sep->se_ops == &kmt_brkpt_ops && kb->kb_addr == pc); 2014 } 2015 2016 /* 2017 * We step over watchpoints using our single-stepper. If a conflicting 2018 * breakpoint is present, we must temporarily disarm it before stepping over 2019 * the watchpoint so we do not immediately re-trigger the breakpoint. This is 2020 * similar to the case handled in kmt_brkpt_cont(), above. 2021 */ 2022 static int 2023 kmt_wapt_cont(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 2024 { 2025 mdb_sespec_t *bep = NULL; 2026 int status = -1; 2027 int error, why; 2028 2029 /* 2030 * If we stopped for anything other than a watchpoint, check to see 2031 * if there's a breakpoint here. 2032 */ 2033 if (!(kmdb_dpi_get_state(&why) == DPI_STATE_FAULTED && 2034 (why == DPI_STATE_WHY_V_WAPT || why == DPI_STATE_WHY_P_WAPT))) { 2035 kreg_t pc; 2036 2037 (void) kmdb_dpi_get_register("pc", &pc); 2038 2039 for (bep = mdb_list_next(&t->t_active); bep != NULL; 2040 bep = mdb_list_next(bep)) { 2041 if (kmt_bp_overlap(bep, pc)) { 2042 (void) bep->se_ops->se_disarm(t, bep); 2043 bep->se_state = MDB_TGT_SPEC_ACTIVE; 2044 break; 2045 } 2046 } 2047 } 2048 2049 kmdb_dpi_wapt_disarm(sep->se_data); 2050 if (kmt_step(t, tsp) == 0) 2051 status = kmt_status(t, tsp); 2052 2053 error = errno; /* save errno from step or status */ 2054 2055 if (bep != NULL) 2056 mdb_tgt_sespec_arm_one(t, bep); 2057 2058 (void) set_errno(error); 2059 return (status); 2060 } 2061 2062 /*ARGSUSED*/ 2063 static int 2064 kmt_wapt_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 2065 { 2066 return (kmdb_dpi_wapt_match(sep->se_data)); 2067 } 2068 2069 static const mdb_se_ops_t kmt_wapt_ops = { 2070 kmt_wapt_ctor, /* se_ctor */ 2071 kmt_wapt_dtor, /* se_dtor */ 2072 kmt_wapt_info, /* se_info */ 2073 kmt_wapt_secmp, /* se_secmp */ 2074 kmt_wapt_vecmp, /* se_vecmp */ 2075 kmt_wapt_arm, /* se_arm */ 2076 kmt_wapt_disarm, /* se_disarm */ 2077 kmt_wapt_cont, /* se_cont */ 2078 kmt_wapt_match /* se_match */ 2079 }; 2080 2081 /*ARGSUSED*/ 2082 static int 2083 kmt_trap_ctor(mdb_tgt_t *t, mdb_sespec_t *sep, void *args) 2084 { 2085 sep->se_data = args; /* trap number */ 2086 2087 return (0); 2088 } 2089 2090 /*ARGSUSED*/ 2091 static char * 2092 kmt_trap_info(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_vespec_t *vep, 2093 mdb_tgt_spec_desc_t *sp, char *buf, size_t nbytes) 2094 { 2095 const char *name; 2096 int trapnum; 2097 2098 if (vep != NULL) 2099 trapnum = (intptr_t)vep->ve_args; 2100 else 2101 trapnum = (intptr_t)sep->se_data; 2102 2103 if (trapnum == KMT_TRAP_ALL) 2104 name = "any trap"; 2105 else if (trapnum == KMT_TRAP_NOTENUM) 2106 name = "miscellaneous trap"; 2107 else 2108 name = kmt_trapname(trapnum); 2109 2110 (void) mdb_iob_snprintf(buf, nbytes, "single-step stop on %s", name); 2111 2112 return (buf); 2113 } 2114 2115 /*ARGSUSED2*/ 2116 static int 2117 kmt_trap_match(mdb_tgt_t *t, mdb_sespec_t *sep, mdb_tgt_status_t *tsp) 2118 { 2119 int spectt = (intptr_t)sep->se_data; 2120 kmt_data_t *kmt = t->t_data; 2121 kreg_t tt; 2122 2123 (void) kmdb_dpi_get_register("tt", &tt); 2124 2125 switch (spectt) { 2126 case KMT_TRAP_ALL: 2127 return (1); 2128 case KMT_TRAP_NOTENUM: 2129 return (tt > kmt->kmt_trapmax || 2130 !BT_TEST(kmt->kmt_trapmap, tt)); 2131 default: 2132 return (tt == spectt); 2133 } 2134 } 2135 2136 static const mdb_se_ops_t kmt_trap_ops = { 2137 kmt_trap_ctor, /* se_ctor */ 2138 no_se_dtor, /* se_dtor */ 2139 kmt_trap_info, /* se_info */ 2140 no_se_secmp, /* se_secmp */ 2141 no_se_vecmp, /* se_vecmp */ 2142 no_se_arm, /* se_arm */ 2143 no_se_disarm, /* se_disarm */ 2144 no_se_cont, /* se_cont */ 2145 kmt_trap_match /* se_match */ 2146 }; 2147 2148 static void 2149 kmt_bparg_dtor(mdb_vespec_t *vep) 2150 { 2151 kmt_bparg_t *ka = vep->ve_args; 2152 2153 if (ka->ka_symbol != NULL) 2154 strfree(ka->ka_symbol); 2155 2156 if (ka->ka_defbp != NULL) 2157 kmt_defbp_delete(mdb.m_target, ka->ka_defbp); 2158 2159 mdb_free(ka, sizeof (kmt_bparg_t)); 2160 } 2161 2162 static int 2163 kmt_add_vbrkpt(mdb_tgt_t *t, uintptr_t addr, 2164 int spec_flags, mdb_tgt_se_f *func, void *data) 2165 { 2166 kmt_bparg_t *ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP); 2167 2168 ka->ka_addr = addr; 2169 ka->ka_symbol = NULL; 2170 ka->ka_defbp = NULL; 2171 2172 return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags, 2173 func, data, ka, kmt_bparg_dtor)); 2174 } 2175 2176 static int 2177 kmt_add_sbrkpt(mdb_tgt_t *t, const char *fullname, 2178 int spec_flags, mdb_tgt_se_f *func, void *data) 2179 { 2180 kmt_bparg_t *ka; 2181 kmt_defbp_t *dbp; 2182 GElf_Sym sym; 2183 char *tick, *objname, *symname; 2184 int serrno; 2185 2186 if ((tick = strchr(fullname, '`')) == fullname) { 2187 (void) set_errno(EMDB_NOOBJ); 2188 return (0); 2189 } 2190 2191 /* 2192 * Deferred breakpoints are always scoped. If we didn't find a tick, 2193 * there's no scope. We'll create a vbrkpt, but only if we can turn the 2194 * provided string into an address. 2195 */ 2196 if (tick == NULL) { 2197 uintptr_t addr; 2198 2199 if (strisbasenum(fullname)) { 2200 addr = mdb_strtoull(fullname); /* a bare address */ 2201 } else if (mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EVERY, 2202 fullname, &sym, NULL) < 0) { 2203 (void) set_errno(EMDB_NOSYM); 2204 return (0); 2205 } else { 2206 addr = (uintptr_t)sym.st_value; /* unscoped sym name */ 2207 } 2208 2209 return (kmt_add_vbrkpt(t, addr, spec_flags, func, data)); 2210 } 2211 2212 if (*(tick + 1) == '\0') { 2213 (void) set_errno(EMDB_NOSYM); 2214 return (0); 2215 } 2216 2217 objname = strndup(fullname, tick - fullname); 2218 symname = tick + 1; 2219 2220 if (mdb_tgt_lookup_by_name(t, objname, symname, NULL, NULL) < 0 && 2221 errno != EMDB_NOOBJ) { 2222 serrno = errno; 2223 strfree(objname); 2224 2225 (void) set_errno(serrno); 2226 return (0); /* errno is set for us */ 2227 } 2228 2229 dbp = kmt_defbp_create(t, objname, symname); 2230 strfree(objname); 2231 2232 ka = mdb_alloc(sizeof (kmt_bparg_t), UM_SLEEP); 2233 ka->ka_symbol = strdup(fullname); 2234 ka->ka_addr = NULL; 2235 ka->ka_defbp = dbp; 2236 2237 return (mdb_tgt_vespec_insert(t, &kmt_brkpt_ops, spec_flags, 2238 func, data, ka, kmt_bparg_dtor)); 2239 } 2240 2241 static int 2242 kmt_wparg_overlap(const kmdb_wapt_t *wp1, const kmdb_wapt_t *wp2) 2243 { 2244 /* Assume the watchpoint spaces don't overlap */ 2245 if (wp1->wp_type != wp2->wp_type) 2246 return (0); 2247 2248 if (wp2->wp_addr + wp2->wp_size <= wp1->wp_addr) 2249 return (0); /* no range overlap */ 2250 2251 if (wp1->wp_addr + wp1->wp_size <= wp2->wp_addr) 2252 return (0); /* no range overlap */ 2253 2254 return (wp1->wp_addr != wp2->wp_addr || wp1->wp_size != wp2->wp_size || 2255 wp1->wp_wflags != wp2->wp_wflags); 2256 } 2257 2258 static void 2259 kmt_wparg_dtor(mdb_vespec_t *vep) 2260 { 2261 mdb_free(vep->ve_args, sizeof (kmdb_wapt_t)); 2262 } 2263 2264 static int 2265 kmt_add_wapt_common(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags, 2266 int spec_flags, mdb_tgt_se_f *func, void *data, int type) 2267 { 2268 kmdb_wapt_t *wp = mdb_alloc(sizeof (kmdb_wapt_t), UM_SLEEP); 2269 mdb_sespec_t *sep; 2270 2271 wp->wp_addr = addr; 2272 wp->wp_size = len; 2273 wp->wp_type = type; 2274 wp->wp_wflags = wflags; 2275 2276 if (kmdb_dpi_wapt_validate(wp) < 0) 2277 return (0); /* errno is set for us */ 2278 2279 for (sep = mdb_list_next(&t->t_active); sep; sep = mdb_list_next(sep)) { 2280 if (sep->se_ops == &kmt_wapt_ops && 2281 mdb_list_next(&sep->se_velist) != NULL && 2282 kmt_wparg_overlap(wp, sep->se_data)) 2283 goto wapt_dup; 2284 } 2285 2286 for (sep = mdb_list_next(&t->t_idle); sep; sep = mdb_list_next(sep)) { 2287 if (sep->se_ops == &kmt_wapt_ops && kmt_wparg_overlap(wp, 2288 ((mdb_vespec_t *)mdb_list_next(&sep->se_velist))->ve_args)) 2289 goto wapt_dup; 2290 } 2291 2292 return (mdb_tgt_vespec_insert(t, &kmt_wapt_ops, spec_flags, 2293 func, data, wp, kmt_wparg_dtor)); 2294 2295 wapt_dup: 2296 mdb_free(wp, sizeof (kmdb_wapt_t)); 2297 (void) set_errno(EMDB_WPDUP); 2298 return (0); 2299 } 2300 2301 static int 2302 kmt_add_pwapt(mdb_tgt_t *t, physaddr_t addr, size_t len, uint_t wflags, 2303 int spec_flags, mdb_tgt_se_f *func, void *data) 2304 { 2305 return (kmt_add_wapt_common(t, (uintptr_t)addr, len, wflags, spec_flags, 2306 func, data, DPI_WAPT_TYPE_PHYS)); 2307 } 2308 2309 static int 2310 kmt_add_vwapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags, 2311 int spec_flags, mdb_tgt_se_f *func, void *data) 2312 { 2313 return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func, 2314 data, DPI_WAPT_TYPE_VIRT)); 2315 } 2316 2317 static int 2318 kmt_add_iowapt(mdb_tgt_t *t, uintptr_t addr, size_t len, uint_t wflags, 2319 int spec_flags, mdb_tgt_se_f *func, void *data) 2320 { 2321 return (kmt_add_wapt_common(t, addr, len, wflags, spec_flags, func, 2322 data, DPI_WAPT_TYPE_IO)); 2323 } 2324 2325 static int 2326 kmt_add_trap(mdb_tgt_t *t, int trapnum, int spec_flags, mdb_tgt_se_f *func, 2327 void *data) 2328 { 2329 kmt_data_t *kmt = t->t_data; 2330 2331 if (trapnum != KMT_TRAP_ALL && trapnum != KMT_TRAP_NOTENUM) { 2332 if (trapnum < 0 || trapnum > kmt->kmt_trapmax) { 2333 (void) set_errno(EMDB_BADFLTNUM); 2334 return (0); 2335 } 2336 2337 BT_SET(kmt->kmt_trapmap, trapnum); 2338 } 2339 2340 return (mdb_tgt_vespec_insert(t, &kmt_trap_ops, spec_flags, func, data, 2341 (void *)(uintptr_t)trapnum, no_ve_dtor)); 2342 } 2343 2344 /*ARGSUSED*/ 2345 static uintmax_t 2346 kmt_cpuid_disc_get(const mdb_var_t *v) 2347 { 2348 return (kmdb_dpi_get_master_cpuid()); 2349 } 2350 2351 static const mdb_nv_disc_t kmt_cpuid_disc = { 2352 NULL, 2353 kmt_cpuid_disc_get 2354 }; 2355 2356 /* 2357 * This routine executes while the kernel is running. 2358 */ 2359 void 2360 kmt_activate(mdb_tgt_t *t) 2361 { 2362 kmt_data_t *kmt = t->t_data; 2363 2364 mdb_prop_postmortem = FALSE; 2365 mdb_prop_kernel = TRUE; 2366 2367 (void) mdb_tgt_register_dcmds(t, &kmt_dcmds[0], MDB_MOD_FORCE); 2368 mdb_tgt_register_regvars(t, kmt->kmt_rds, &kmt_reg_disc, 0); 2369 2370 /* 2371 * Force load of the MDB krtld module, in case it's been rolled into 2372 * unix. 2373 */ 2374 (void) mdb_module_load(KMT_RTLD_NAME, MDB_MOD_SILENT | MDB_MOD_DEFER); 2375 } 2376 2377 static void 2378 kmt_destroy(mdb_tgt_t *t) 2379 { 2380 kmt_data_t *kmt = t->t_data; 2381 kmt_module_t *km, *pkm; 2382 2383 mdb_nv_destroy(&kmt->kmt_modules); 2384 for (km = mdb_list_prev(&kmt->kmt_modlist); km != NULL; km = pkm) { 2385 pkm = mdb_list_prev(km); 2386 mdb_free(km, sizeof (kmt_module_t)); 2387 } 2388 2389 if (!kmt_defbp_lock) 2390 kmt_defbp_destroy_all(); 2391 2392 if (kmt->kmt_trapmap != NULL) 2393 mdb_free(kmt->kmt_trapmap, BT_SIZEOFMAP(kmt->kmt_trapmax)); 2394 2395 if (kmt->kmt_cpu != NULL) 2396 kmt_cpu_destroy(kmt->kmt_cpu); 2397 2398 if (kmt != NULL) 2399 mdb_free(kmt, sizeof (kmt_data_t)); 2400 } 2401 2402 static const mdb_tgt_ops_t kmt_ops = { 2403 kmt_setflags, /* t_setflags */ 2404 (int (*)()) mdb_tgt_notsup, /* t_setcontext */ 2405 kmt_activate, /* t_activate */ 2406 (void (*)()) mdb_tgt_nop, /* t_deactivate */ 2407 kmt_periodic, /* t_periodic */ 2408 kmt_destroy, /* t_destroy */ 2409 kmt_name, /* t_name */ 2410 (const char *(*)()) mdb_conf_isa, /* t_isa */ 2411 kmt_platform, /* t_platform */ 2412 kmt_uname, /* t_uname */ 2413 kmt_dmodel, /* t_dmodel */ 2414 (ssize_t (*)()) mdb_tgt_notsup, /* t_aread */ 2415 (ssize_t (*)()) mdb_tgt_notsup, /* t_awrite */ 2416 kmt_read, /* t_vread */ 2417 kmt_write, /* t_vwrite */ 2418 kmt_pread, /* t_pread */ 2419 kmt_pwrite, /* t_pwrite */ 2420 kmt_read, /* t_fread */ 2421 kmt_write, /* t_fwrite */ 2422 kmt_ioread, /* t_ioread */ 2423 kmt_iowrite, /* t_iowrite */ 2424 kmt_vtop, /* t_vtop */ 2425 kmt_lookup_by_name, /* t_lookup_by_name */ 2426 kmt_lookup_by_addr, /* t_lookup_by_addr */ 2427 kmt_symbol_iter, /* t_symbol_iter */ 2428 kmt_mapping_iter, /* t_mapping_iter */ 2429 kmt_object_iter, /* t_object_iter */ 2430 kmt_addr_to_map, /* t_addr_to_map */ 2431 kmt_name_to_map, /* t_name_to_map */ 2432 kmt_addr_to_ctf, /* t_addr_to_ctf */ 2433 kmt_name_to_ctf, /* t_name_to_ctf */ 2434 kmt_status, /* t_status */ 2435 (int (*)()) mdb_tgt_notsup, /* t_run */ 2436 kmt_step, /* t_step */ 2437 kmt_step_out, /* t_step_out */ 2438 kmt_step_branch, /* t_step_branch */ 2439 kmt_next, /* t_next */ 2440 kmt_continue, /* t_cont */ 2441 (int (*)()) mdb_tgt_notsup, /* t_signal */ 2442 kmt_add_vbrkpt, /* t_add_vbrkpt */ 2443 kmt_add_sbrkpt, /* t_add_sbrkpt */ 2444 kmt_add_pwapt, /* t_add_pwapt */ 2445 kmt_add_vwapt, /* t_add_vwapt */ 2446 kmt_add_iowapt, /* t_add_iowapt */ 2447 (int (*)()) mdb_tgt_null, /* t_add_sysenter */ 2448 (int (*)()) mdb_tgt_null, /* t_add_sysexit */ 2449 (int (*)()) mdb_tgt_null, /* t_add_signal */ 2450 kmt_add_trap, /* t_add_fault */ 2451 kmt_getareg, /* t_getareg */ 2452 kmt_putareg, /* t_putareg */ 2453 (int (*)()) mdb_tgt_nop, /* XXX t_stack_iter */ 2454 (int (*)()) mdb_tgt_notsup /* t_auxv */ 2455 }; 2456 2457 /* 2458 * Called immediately upon resumption of the system after a step or continue. 2459 * Allows us to synchronize kmt's view of the world with reality. 2460 */ 2461 /*ARGSUSED*/ 2462 static void 2463 kmt_sync(mdb_tgt_t *t) 2464 { 2465 kmt_data_t *kmt = t->t_data; 2466 int symavail; 2467 2468 mdb_dprintf(MDB_DBG_KMOD, "synchronizing with kernel\n"); 2469 2470 symavail = kmt->kmt_symavail; 2471 kmt->kmt_symavail = FALSE; 2472 2473 /* 2474 * Resync our view of the world if the modules have changed, or if we 2475 * didn't have any symbols coming into this function. The latter will 2476 * only happen on startup. 2477 */ 2478 if (kmdb_kdi_mods_changed() || !symavail) 2479 kmt_modlist_update(t); 2480 2481 /* 2482 * It would be nice if we could run this less frequently, perhaps 2483 * after a dvec-initiated trigger. 2484 */ 2485 kmdb_module_sync(); 2486 2487 kmt->kmt_symavail = TRUE; 2488 2489 mdb_dprintf(MDB_DBG_KMOD, "synchronization complete\n"); 2490 2491 kmt_defbp_prune(); 2492 2493 if (kmt_defbp_num > 0 && kmt_defbp_bpspec == 0 && 2494 kmdb_kdi_dtrace_get_state() != KDI_DTSTATE_DTRACE_ACTIVE) { 2495 /* 2496 * Deferred breakpoints were created while DTrace was active, 2497 * and consequently the deferred breakpoint enabling mechanism 2498 * wasn't activated. Activate it now, and then try to activate 2499 * the deferred breakpoints. We do this so that we can catch 2500 * the ones which may apply to modules that have been loaded 2501 * while they were waiting for DTrace to deactivate. 2502 */ 2503 (void) kmt_defbp_activate(t); 2504 (void) mdb_tgt_sespec_activate_all(t); 2505 } 2506 2507 if (kmt->kmt_cpu_retry && ((kmt->kmt_cpu = kmt_cpu_create(t)) != 2508 NULL || errno != EAGAIN)) 2509 kmt->kmt_cpu_retry = FALSE; 2510 2511 (void) mdb_tgt_status(t, &t->t_status); 2512 } 2513 2514 /* 2515 * This routine executes while the kernel is running. 2516 */ 2517 /*ARGSUSED*/ 2518 int 2519 kmdb_kvm_create(mdb_tgt_t *t, int argc, const char *argv[]) 2520 { 2521 kmt_data_t *kmt; 2522 2523 if (argc != 0) 2524 return (set_errno(EINVAL)); 2525 2526 kmt = mdb_zalloc(sizeof (kmt_data_t), UM_SLEEP); 2527 t->t_data = kmt; 2528 t->t_ops = &kmt_ops; 2529 t->t_flags |= MDB_TGT_F_RDWR; /* kmdb is always r/w */ 2530 2531 (void) mdb_nv_insert(&mdb.m_nv, "cpuid", &kmt_cpuid_disc, 0, 2532 MDB_NV_PERSIST | MDB_NV_RDONLY); 2533 2534 (void) mdb_nv_create(&kmt->kmt_modules, UM_SLEEP); 2535 2536 kmt_init_isadep(t); 2537 2538 kmt->kmt_symavail = FALSE; 2539 kmt->kmt_cpu_retry = TRUE; 2540 2541 bzero(&kmt_defbp_list, sizeof (mdb_list_t)); 2542 2543 return (0); 2544 2545 create_err: 2546 kmt_destroy(t); 2547 2548 return (-1); 2549 } 2550 2551 /* 2552 * This routine is called once, when kmdb first has control of the world. 2553 */ 2554 void 2555 kmdb_kvm_startup(void) 2556 { 2557 kmt_data_t *kmt = mdb.m_target->t_data; 2558 2559 mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm startup\n"); 2560 2561 kmt_sync(mdb.m_target); 2562 (void) mdb_module_load_builtin(KMT_MODULE); 2563 kmt_startup_isadep(mdb.m_target); 2564 2565 /* 2566 * This is here because we need to write the deferred breakpoint 2567 * breakpoint when the debugger starts. Our normal r/o write routines 2568 * don't work when the kernel is running, so we have to do it during 2569 * startup. 2570 */ 2571 (void) mdb_tgt_sespec_activate_all(mdb.m_target); 2572 2573 kmt->kmt_rtld_name = KMT_RTLD_NAME; 2574 2575 if (kmt_module_by_name(kmt, KMT_RTLD_NAME) == NULL) 2576 kmt->kmt_rtld_name = "unix"; 2577 } 2578 2579 /* 2580 * This routine is called after kmdb has loaded its initial set of modules. 2581 */ 2582 void 2583 kmdb_kvm_poststartup(void) 2584 { 2585 mdb_dprintf(MDB_DBG_KMOD, "kmdb_kvm post-startup\n"); 2586 2587 (void) mdb_dis_select(kmt_def_dismode()); 2588 } --- EOF ---