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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Libkvm Kernel Target 28 * 29 * The libkvm kernel target provides access to both crash dumps and live 30 * kernels through /dev/ksyms and /dev/kmem, using the facilities provided by 31 * the libkvm.so library. The target-specific data structures are shared 32 * between this file (common code) and the ISA-dependent parts of the target, 33 * and so they are defined in the mdb_kvm.h header. The target processes an 34 * "executable" (/dev/ksyms or the unix.X file) which contains a primary 35 * .symtab and .dynsym, and then also iterates over the krtld module chain in 36 * the kernel in order to obtain a list of loaded modules and per-module symbol 37 * tables. To improve startup performance, the per-module symbol tables are 38 * instantiated on-the-fly whenever an address lookup falls within the text 39 * section of a given module. The target also relies on services from the 40 * mdb_ks (kernel support) module, which contains pieces of the implementation 41 * that must be compiled against the kernel implementation. 42 */ 43 44 #include <sys/modctl.h> 45 #include <sys/kobj.h> 46 #include <sys/kobj_impl.h> 47 #include <sys/utsname.h> 48 #include <sys/panic.h> 49 #include <sys/dumphdr.h> 50 #include <sys/dumpadm.h> 51 52 #include <dlfcn.h> 53 #include <libctf.h> 54 #include <string.h> 55 #include <fcntl.h> 56 #include <errno.h> 57 58 #include <mdb/mdb_target_impl.h> 59 #include <mdb/mdb_err.h> 60 #include <mdb/mdb_debug.h> 61 #include <mdb/mdb_string.h> 62 #include <mdb/mdb_modapi.h> 63 #include <mdb/mdb_io_impl.h> 64 #include <mdb/mdb_ctf.h> 65 #include <mdb/mdb_kvm.h> 66 #include <mdb/mdb_module.h> 67 #include <mdb/mdb_kb.h> 68 #include <mdb/mdb.h> 69 70 #define KT_RELOC_BUF(buf, obase, nbase) \ 71 ((uintptr_t)(buf) - (uintptr_t)(obase) + (uintptr_t)(nbase)) 72 73 #define KT_BAD_BUF(buf, base, size) \ 74 ((uintptr_t)(buf) < (uintptr_t)(base) || \ 75 ((uintptr_t)(buf) >= (uintptr_t)(base) + (uintptr_t)(size))) 76 77 typedef struct kt_symarg { 78 mdb_tgt_sym_f *sym_cb; /* Caller's callback function */ 79 void *sym_data; /* Callback function argument */ 80 uint_t sym_type; /* Symbol type/binding filter */ 81 mdb_syminfo_t sym_info; /* Symbol id and table id */ 82 const char *sym_obj; /* Containing object */ 83 } kt_symarg_t; 84 85 typedef struct kt_maparg { 86 mdb_tgt_t *map_target; /* Target used for mapping iter */ 87 mdb_tgt_map_f *map_cb; /* Caller's callback function */ 88 void *map_data; /* Callback function argument */ 89 } kt_maparg_t; 90 91 static const char KT_MODULE[] = "mdb_ks"; 92 static const char KT_CTFPARENT[] = "genunix"; 93 94 static void 95 kt_load_module(kt_data_t *kt, mdb_tgt_t *t, kt_module_t *km) 96 { 97 km->km_data = mdb_alloc(km->km_datasz, UM_SLEEP); 98 99 (void) mdb_tgt_vread(t, km->km_data, km->km_datasz, km->km_symspace_va); 100 101 km->km_symbuf = (void *) 102 KT_RELOC_BUF(km->km_symtab_va, km->km_symspace_va, km->km_data); 103 104 km->km_strtab = (char *) 105 KT_RELOC_BUF(km->km_strtab_va, km->km_symspace_va, km->km_data); 106 107 km->km_symtab = mdb_gelf_symtab_create_raw(&kt->k_file->gf_ehdr, 108 &km->km_symtab_hdr, km->km_symbuf, 109 &km->km_strtab_hdr, km->km_strtab, MDB_TGT_SYMTAB); 110 } 111 112 static void 113 kt_load_modules(kt_data_t *kt, mdb_tgt_t *t) 114 { 115 char name[MAXNAMELEN]; 116 uintptr_t addr, head; 117 118 struct module kmod; 119 struct modctl ctl; 120 Shdr symhdr, strhdr; 121 GElf_Sym sym; 122 123 kt_module_t *km; 124 125 if (mdb_tgt_lookup_by_name(t, MDB_TGT_OBJ_EXEC, 126 "modules", &sym, NULL) == -1) { 127 warn("failed to get 'modules' symbol"); 128 return; 129 } 130 131 if (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, &ctl, sizeof (ctl), 132 MDB_TGT_OBJ_EXEC, "modules") != sizeof (ctl)) { 133 warn("failed to read 'modules' struct"); 134 return; 135 } 136 137 addr = head = (uintptr_t)sym.st_value; 138 139 do { 140 if (addr == NULL) 141 break; /* Avoid spurious NULL pointers in list */ 142 143 if (mdb_tgt_vread(t, &ctl, sizeof (ctl), addr) == -1) { 144 warn("failed to read modctl at %p", (void *)addr); 145 return; 146 } 147 148 if (ctl.mod_mp == NULL) 149 continue; /* No associated krtld structure */ 150 151 if (mdb_tgt_readstr(t, MDB_TGT_AS_VIRT, name, MAXNAMELEN, 152 (uintptr_t)ctl.mod_modname) <= 0) { 153 warn("failed to read module name at %p", 154 (void *)ctl.mod_modname); 155 continue; 156 } 157 158 mdb_dprintf(MDB_DBG_KMOD, "reading mod %s (%p)\n", 159 name, (void *)addr); 160 161 if (mdb_nv_lookup(&kt->k_modules, name) != NULL) { 162 warn("skipping duplicate module '%s', id=%d\n", 163 name, ctl.mod_id); 164 continue; 165 } 166 167 if (mdb_tgt_vread(t, &kmod, sizeof (kmod), 168 (uintptr_t)ctl.mod_mp) == -1) { 169 warn("failed to read module at %p\n", 170 (void *)ctl.mod_mp); 171 continue; 172 } 173 174 if (kmod.symspace == NULL || kmod.symhdr == NULL || 175 kmod.strhdr == NULL) { 176 /* 177 * If no buffer for the symbols has been allocated, 178 * or the shdrs for .symtab and .strtab are missing, 179 * then we're out of luck. 180 */ 181 continue; 182 } 183 184 if (mdb_tgt_vread(t, &symhdr, sizeof (Shdr), 185 (uintptr_t)kmod.symhdr) == -1) { 186 warn("failed to read .symtab header for '%s', id=%d", 187 name, ctl.mod_id); 188 continue; 189 } 190 191 if (mdb_tgt_vread(t, &strhdr, sizeof (Shdr), 192 (uintptr_t)kmod.strhdr) == -1) { 193 warn("failed to read .strtab header for '%s', id=%d", 194 name, ctl.mod_id); 195 continue; 196 } 197 198 /* 199 * Now get clever: f(*^ing krtld didn't used to bother updating 200 * its own kmod.symsize value. We know that prior to this bug 201 * being fixed, symspace was a contiguous buffer containing 202 * .symtab, .strtab, and the symbol hash table in that order. 203 * So if symsize is zero, recompute it as the size of .symtab 204 * plus the size of .strtab. We don't need to load the hash 205 * table anyway since we re-hash all the symbols internally. 206 */ 207 if (kmod.symsize == 0) 208 kmod.symsize = symhdr.sh_size + strhdr.sh_size; 209 210 /* 211 * Similar logic can be used to make educated guesses 212 * at the values of kmod.symtbl and kmod.strings. 213 */ 214 if (kmod.symtbl == NULL) 215 kmod.symtbl = kmod.symspace; 216 if (kmod.strings == NULL) 217 kmod.strings = kmod.symspace + symhdr.sh_size; 218 219 /* 220 * Make sure things seem reasonable before we proceed 221 * to actually read and decipher the symspace. 222 */ 223 if (KT_BAD_BUF(kmod.symtbl, kmod.symspace, kmod.symsize) || 224 KT_BAD_BUF(kmod.strings, kmod.symspace, kmod.symsize)) { 225 warn("skipping module '%s', id=%d (corrupt symspace)\n", 226 name, ctl.mod_id); 227 continue; 228 } 229 230 km = mdb_zalloc(sizeof (kt_module_t), UM_SLEEP); 231 km->km_name = strdup(name); 232 233 (void) mdb_nv_insert(&kt->k_modules, km->km_name, NULL, 234 (uintptr_t)km, MDB_NV_EXTNAME); 235 236 km->km_datasz = kmod.symsize; 237 km->km_symspace_va = (uintptr_t)kmod.symspace; 238 km->km_symtab_va = (uintptr_t)kmod.symtbl; 239 km->km_strtab_va = (uintptr_t)kmod.strings; 240 km->km_symtab_hdr = symhdr; 241 km->km_strtab_hdr = strhdr; 242 km->km_text_va = (uintptr_t)kmod.text; 243 km->km_text_size = kmod.text_size; 244 km->km_data_va = (uintptr_t)kmod.data; 245 km->km_data_size = kmod.data_size; 246 km->km_bss_va = (uintptr_t)kmod.bss; 247 km->km_bss_size = kmod.bss_size; 248 249 if (kt->k_ctfvalid) { 250 km->km_ctf_va = (uintptr_t)kmod.ctfdata; 251 km->km_ctf_size = kmod.ctfsize; 252 } 253 254 /* 255 * Add the module to the end of the list of modules in load- 256 * dependency order. This is needed to load the corresponding 257 * debugger modules in the same order for layering purposes. 258 */ 259 mdb_list_append(&kt->k_modlist, km); 260 261 if (t->t_flags & MDB_TGT_F_PRELOAD) { 262 mdb_iob_printf(mdb.m_out, " %s", name); 263 mdb_iob_flush(mdb.m_out); 264 kt_load_module(kt, t, km); 265 } 266 267 } while ((addr = (uintptr_t)ctl.mod_next) != head); 268 } 269 270 int 271 kt_setflags(mdb_tgt_t *t, int flags) 272 { 273 int iochg = ((flags ^ t->t_flags) & MDB_TGT_F_ALLOWIO) && 274 !mdb_prop_postmortem; 275 int rwchg = (flags ^ t->t_flags) & MDB_TGT_F_RDWR; 276 kt_data_t *kt = t->t_data; 277 const char *kvmfile; 278 void *cookie; 279 int mode; 280 281 if (!iochg && !rwchg) 282 return (0); 283 284 if (kt->k_xpv_domu) { 285 warn("read-only target"); 286 return (-1); 287 } 288 289 if (iochg) { 290 kvmfile = (flags & MDB_TGT_F_ALLOWIO) ? "/dev/allkmem" : 291 "/dev/kmem"; 292 } else { 293 kvmfile = kt->k_kvmfile; 294 } 295 296 mode = (flags & MDB_TGT_F_RDWR) ? O_RDWR : O_RDONLY; 297 298 if ((cookie = kt->k_kb_ops->kb_open(kt->k_symfile, kvmfile, NULL, mode, 299 mdb.m_pname)) == NULL) { 300 /* We failed to re-open, so don't change t_flags */ 301 warn("failed to re-open target"); 302 return (-1); 303 } 304 305 /* 306 * We successfully reopened the target, so update k_kvmfile. Also set 307 * the RDWR and ALLOWIO bits in t_flags to match those in flags. 308 */ 309 (void) kt->k_kb_ops->kb_close(kt->k_cookie); 310 kt->k_cookie = cookie; 311 312 if (kvmfile != kt->k_kvmfile) { 313 strfree(kt->k_kvmfile); 314 kt->k_kvmfile = strdup(kvmfile); 315 } 316 317 t->t_flags = (t->t_flags & ~(MDB_TGT_F_RDWR | MDB_TGT_F_ALLOWIO)) | 318 (flags & (MDB_TGT_F_RDWR | MDB_TGT_F_ALLOWIO)); 319 320 return (0); 321 } 322 323 /* 324 * Determine which PIDs (if any) have their pages saved in the dump. We 325 * do this by looking for content flags in dump_flags in the header. These 326 * flags, which won't be set in older dumps, tell us whether a single process 327 * has had its pages included in the dump. If a single process has been 328 * included, we need to get the PID for that process from the dump_pids 329 * array in the dump. 330 */ 331 static int 332 kt_find_dump_contents(kt_data_t *kt) 333 { 334 dumphdr_t *dh = kt->k_dumphdr; 335 pid_t pid = -1; 336 337 if (dh->dump_flags & DF_ALL) 338 return (KT_DUMPCONTENT_ALL); 339 340 if (dh->dump_flags & DF_CURPROC) { 341 if ((pid = kt->k_dump_find_curproc()) == -1) 342 return (KT_DUMPCONTENT_INVALID); 343 else 344 return (pid); 345 } else { 346 return (KT_DUMPCONTENT_KERNEL); 347 } 348 } 349 350 static int 351 kt_dump_contains_proc(mdb_tgt_t *t, void *context) 352 { 353 kt_data_t *kt = t->t_data; 354 pid_t (*f_pid)(uintptr_t); 355 pid_t reqpid; 356 357 switch (kt->k_dumpcontent) { 358 case KT_DUMPCONTENT_KERNEL: 359 return (0); 360 case KT_DUMPCONTENT_ALL: 361 return (1); 362 case KT_DUMPCONTENT_INVALID: 363 goto procnotfound; 364 default: 365 f_pid = (pid_t (*)()) dlsym(RTLD_NEXT, "mdb_kproc_pid"); 366 if (f_pid == NULL) 367 goto procnotfound; 368 369 reqpid = f_pid((uintptr_t)context); 370 if (reqpid == -1) 371 goto procnotfound; 372 373 return (kt->k_dumpcontent == reqpid); 374 } 375 376 procnotfound: 377 warn("unable to determine whether dump contains proc %p\n", context); 378 return (1); 379 } 380 381 int 382 kt_setcontext(mdb_tgt_t *t, void *context) 383 { 384 if (context != NULL) { 385 const char *argv[2]; 386 int argc = 0; 387 mdb_tgt_t *ct; 388 kt_data_t *kt = t->t_data; 389 390 argv[argc++] = (const char *)context; 391 argv[argc] = NULL; 392 393 if (kt->k_dumphdr != NULL && 394 !kt_dump_contains_proc(t, context)) { 395 warn("dump does not contain pages for proc %p\n", 396 context); 397 return (-1); 398 } 399 400 if ((ct = mdb_tgt_create(mdb_kproc_tgt_create, 401 t->t_flags, argc, argv)) == NULL) 402 return (-1); 403 404 mdb_printf("debugger context set to proc %p\n", context); 405 mdb_tgt_activate(ct); 406 } else 407 mdb_printf("debugger context set to kernel\n"); 408 409 return (0); 410 } 411 412 static int 413 kt_stack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 414 { 415 kt_data_t *kt = mdb.m_target->t_data; 416 return (kt->k_dcmd_stack(addr, flags, argc, argv)); 417 } 418 419 static int 420 kt_stackv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 421 { 422 kt_data_t *kt = mdb.m_target->t_data; 423 return (kt->k_dcmd_stackv(addr, flags, argc, argv)); 424 } 425 426 static int 427 kt_stackr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 428 { 429 kt_data_t *kt = mdb.m_target->t_data; 430 return (kt->k_dcmd_stackr(addr, flags, argc, argv)); 431 } 432 433 static int 434 kt_regs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 435 { 436 kt_data_t *kt = mdb.m_target->t_data; 437 438 if (argc != 0 || (flags & DCMD_ADDRSPEC)) 439 return (DCMD_USAGE); 440 441 addr = (uintptr_t)kt->k_regs; 442 443 return (kt->k_dcmd_regs(addr, flags, argc, argv)); 444 } 445 446 #ifdef __x86 447 static int 448 kt_cpustack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 449 { 450 kt_data_t *kt = mdb.m_target->t_data; 451 return (kt->k_dcmd_cpustack(addr, flags, argc, argv)); 452 } 453 454 static int 455 kt_cpuregs(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 456 { 457 kt_data_t *kt = mdb.m_target->t_data; 458 return (kt->k_dcmd_cpuregs(addr, flags, argc, argv)); 459 } 460 #endif /* __x86 */ 461 462 /*ARGSUSED*/ 463 static int 464 kt_status_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 465 { 466 kt_data_t *kt = mdb.m_target->t_data; 467 struct utsname uts; 468 469 bzero(&uts, sizeof (uts)); 470 (void) strcpy(uts.nodename, "unknown machine"); 471 (void) kt_uname(mdb.m_target, &uts); 472 473 if (mdb_prop_postmortem) { 474 mdb_printf("debugging %scrash dump %s (%d-bit) from %s\n", 475 kt->k_xpv_domu ? "domain " : "", kt->k_kvmfile, 476 (int)(sizeof (void *) * NBBY), uts.nodename); 477 } else { 478 mdb_printf("debugging live kernel (%d-bit) on %s\n", 479 (int)(sizeof (void *) * NBBY), uts.nodename); 480 } 481 482 mdb_printf("operating system: %s %s (%s)\n", 483 uts.release, uts.version, uts.machine); 484 485 if (kt->k_dumphdr) { 486 dumphdr_t *dh = kt->k_dumphdr; 487 488 mdb_printf("panic message: %s\n", dh->dump_panicstring); 489 490 kt->k_dump_print_content(dh, kt->k_dumpcontent); 491 } 492 493 return (DCMD_OK); 494 } 495 496 static const mdb_dcmd_t kt_dcmds[] = { 497 { "$c", "?[cnt]", "print stack backtrace", kt_stack }, 498 { "$C", "?[cnt]", "print stack backtrace", kt_stackv }, 499 { "$r", NULL, "print general-purpose registers", kt_regs }, 500 { "$?", NULL, "print status and registers", kt_regs }, 501 { "regs", NULL, "print general-purpose registers", kt_regs }, 502 { "stack", "?[cnt]", "print stack backtrace", kt_stack }, 503 { "stackregs", "?", "print stack backtrace and registers", kt_stackr }, 504 #ifdef __x86 505 { "cpustack", "?[-v] [-c cpuid] [cnt]", "print stack backtrace for a " 506 "specific CPU", kt_cpustack }, 507 { "cpuregs", "?[-c cpuid]", "print general-purpose registers for a " 508 "specific CPU", kt_cpuregs }, 509 #endif 510 { "status", NULL, "print summary of current target", kt_status_dcmd }, 511 { NULL } 512 }; 513 514 static uintmax_t 515 reg_disc_get(const mdb_var_t *v) 516 { 517 mdb_tgt_t *t = MDB_NV_COOKIE(v); 518 kt_data_t *kt = t->t_data; 519 mdb_tgt_reg_t r = 0; 520 521 (void) mdb_tgt_getareg(t, kt->k_tid, mdb_nv_get_name(v), &r); 522 return (r); 523 } 524 525 static kt_module_t * 526 kt_module_by_name(kt_data_t *kt, const char *name) 527 { 528 kt_module_t *km; 529 530 for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) { 531 if (strcmp(name, km->km_name) == 0) 532 return (km); 533 } 534 535 return (NULL); 536 } 537 538 void 539 kt_activate(mdb_tgt_t *t) 540 { 541 static const mdb_nv_disc_t reg_disc = { NULL, reg_disc_get }; 542 kt_data_t *kt = t->t_data; 543 void *sym; 544 545 int oflag; 546 547 mdb_prop_postmortem = kt->k_xpv_domu || (kt->k_dumphdr != NULL); 548 mdb_prop_kernel = TRUE; 549 mdb_prop_datamodel = MDB_TGT_MODEL_NATIVE; 550 551 if (kt->k_activated == FALSE) { 552 struct utsname u1, u2; 553 /* 554 * If we're examining a crash dump, root is /, and uname(2) 555 * does not match the utsname in the dump, issue a warning. 556 * Note that we are assuming that the modules and macros in 557 * /usr/lib are compiled against the kernel from uname -rv. 558 */ 559 if (mdb_prop_postmortem && strcmp(mdb.m_root, "/") == 0 && 560 uname(&u1) >= 0 && kt_uname(t, &u2) >= 0 && 561 (strcmp(u1.release, u2.release) || 562 strcmp(u1.version, u2.version))) { 563 mdb_warn("warning: dump is from %s %s %s; dcmds and " 564 "macros may not match kernel implementation\n", 565 u2.sysname, u2.release, u2.version); 566 } 567 568 if (mdb_module_load(KT_MODULE, MDB_MOD_GLOBAL) < 0) { 569 warn("failed to load kernel support module -- " 570 "some modules may not load\n"); 571 } 572 573 if (mdb_prop_postmortem && kt->k_dumphdr != NULL) { 574 sym = dlsym(RTLD_NEXT, "mdb_dump_print_content"); 575 if (sym != NULL) 576 kt->k_dump_print_content = (void (*)())sym; 577 578 sym = dlsym(RTLD_NEXT, "mdb_dump_find_curproc"); 579 if (sym != NULL) 580 kt->k_dump_find_curproc = (int (*)())sym; 581 582 kt->k_dumpcontent = kt_find_dump_contents(kt); 583 } 584 585 if (t->t_flags & MDB_TGT_F_PRELOAD) { 586 oflag = mdb_iob_getflags(mdb.m_out) & MDB_IOB_PGENABLE; 587 588 mdb_iob_clrflags(mdb.m_out, oflag); 589 mdb_iob_puts(mdb.m_out, "Preloading module symbols: ["); 590 mdb_iob_flush(mdb.m_out); 591 } 592 593 if (!(t->t_flags & MDB_TGT_F_NOLOAD)) { 594 kt_load_modules(kt, t); 595 596 /* 597 * Determine where the CTF data for krtld is. If krtld 598 * is rolled into unix, force load the MDB krtld 599 * module. 600 */ 601 kt->k_rtld_name = "krtld"; 602 603 if (kt_module_by_name(kt, "krtld") == NULL) { 604 (void) mdb_module_load("krtld", MDB_MOD_SILENT); 605 kt->k_rtld_name = "unix"; 606 } 607 } 608 609 610 if (t->t_flags & MDB_TGT_F_PRELOAD) { 611 mdb_iob_puts(mdb.m_out, " ]\n"); 612 mdb_iob_setflags(mdb.m_out, oflag); 613 } 614 615 kt->k_activated = TRUE; 616 } 617 618 (void) mdb_tgt_register_dcmds(t, &kt_dcmds[0], MDB_MOD_FORCE); 619 620 /* Export some of our registers as named variables */ 621 mdb_tgt_register_regvars(t, kt->k_rds, ®_disc, MDB_NV_RDONLY); 622 623 mdb_tgt_elf_export(kt->k_file); 624 } 625 626 void 627 kt_deactivate(mdb_tgt_t *t) 628 { 629 kt_data_t *kt = t->t_data; 630 631 const mdb_tgt_regdesc_t *rdp; 632 const mdb_dcmd_t *dcp; 633 634 for (rdp = kt->k_rds; rdp->rd_name != NULL; rdp++) { 635 mdb_var_t *v; 636 637 if (!(rdp->rd_flags & MDB_TGT_R_EXPORT)) 638 continue; /* Didn't export register as a variable */ 639 640 if ((v = mdb_nv_lookup(&mdb.m_nv, rdp->rd_name)) != NULL) { 641 v->v_flags &= ~MDB_NV_PERSIST; 642 mdb_nv_remove(&mdb.m_nv, v); 643 } 644 } 645 646 for (dcp = &kt_dcmds[0]; dcp->dc_name != NULL; dcp++) { 647 if (mdb_module_remove_dcmd(t->t_module, dcp->dc_name) == -1) 648 warn("failed to remove dcmd %s", dcp->dc_name); 649 } 650 651 mdb_prop_postmortem = FALSE; 652 mdb_prop_kernel = FALSE; 653 mdb_prop_datamodel = MDB_TGT_MODEL_UNKNOWN; 654 } 655 656 /*ARGSUSED*/ 657 const char * 658 kt_name(mdb_tgt_t *t) 659 { 660 return ("kvm"); 661 } 662 663 const char * 664 kt_platform(mdb_tgt_t *t) 665 { 666 kt_data_t *kt = t->t_data; 667 return (kt->k_platform); 668 } 669 670 int 671 kt_uname(mdb_tgt_t *t, struct utsname *utsp) 672 { 673 return (mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, utsp, 674 sizeof (struct utsname), MDB_TGT_OBJ_EXEC, "utsname")); 675 } 676 677 /*ARGSUSED*/ 678 int 679 kt_dmodel(mdb_tgt_t *t) 680 { 681 return (MDB_TGT_MODEL_NATIVE); 682 } 683 684 ssize_t 685 kt_aread(mdb_tgt_t *t, mdb_tgt_as_t as, void *buf, 686 size_t nbytes, mdb_tgt_addr_t addr) 687 { 688 kt_data_t *kt = t->t_data; 689 ssize_t rval; 690 691 if ((rval = kt->k_kb_ops->kb_aread(kt->k_cookie, addr, buf, 692 nbytes, as)) == -1) 693 return (set_errno(EMDB_NOMAP)); 694 695 return (rval); 696 } 697 698 ssize_t 699 kt_awrite(mdb_tgt_t *t, mdb_tgt_as_t as, const void *buf, 700 size_t nbytes, mdb_tgt_addr_t addr) 701 { 702 kt_data_t *kt = t->t_data; 703 ssize_t rval; 704 705 if ((rval = kt->k_kb_ops->kb_awrite(kt->k_cookie, addr, buf, 706 nbytes, as)) == -1) 707 return (set_errno(EMDB_NOMAP)); 708 709 return (rval); 710 } 711 712 ssize_t 713 kt_vread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr) 714 { 715 kt_data_t *kt = t->t_data; 716 ssize_t rval; 717 718 if ((rval = kt->k_kb_ops->kb_kread(kt->k_cookie, addr, buf, 719 nbytes)) == -1) 720 return (set_errno(EMDB_NOMAP)); 721 722 return (rval); 723 } 724 725 ssize_t 726 kt_vwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr) 727 { 728 kt_data_t *kt = t->t_data; 729 ssize_t rval; 730 731 if ((rval = kt->k_kb_ops->kb_kwrite(kt->k_cookie, addr, buf, 732 nbytes)) == -1) 733 return (set_errno(EMDB_NOMAP)); 734 735 return (rval); 736 } 737 738 ssize_t 739 kt_fread(mdb_tgt_t *t, void *buf, size_t nbytes, uintptr_t addr) 740 { 741 return (kt_vread(t, buf, nbytes, addr)); 742 } 743 744 ssize_t 745 kt_fwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, uintptr_t addr) 746 { 747 return (kt_vwrite(t, buf, nbytes, addr)); 748 } 749 750 ssize_t 751 kt_pread(mdb_tgt_t *t, void *buf, size_t nbytes, physaddr_t addr) 752 { 753 kt_data_t *kt = t->t_data; 754 ssize_t rval; 755 756 if ((rval = kt->k_kb_ops->kb_pread(kt->k_cookie, addr, buf, 757 nbytes)) == -1) 758 return (set_errno(EMDB_NOMAP)); 759 760 return (rval); 761 } 762 763 ssize_t 764 kt_pwrite(mdb_tgt_t *t, const void *buf, size_t nbytes, physaddr_t addr) 765 { 766 kt_data_t *kt = t->t_data; 767 ssize_t rval; 768 769 if ((rval = kt->k_kb_ops->kb_pwrite(kt->k_cookie, addr, buf, 770 nbytes)) == -1) 771 return (set_errno(EMDB_NOMAP)); 772 773 return (rval); 774 } 775 776 int 777 kt_vtop(mdb_tgt_t *t, mdb_tgt_as_t as, uintptr_t va, physaddr_t *pap) 778 { 779 kt_data_t *kt = t->t_data; 780 781 struct as *asp; 782 physaddr_t pa; 783 mdb_module_t *mod; 784 mdb_var_t *v; 785 int (*fptr)(uintptr_t, struct as *, physaddr_t *); 786 787 switch ((uintptr_t)as) { 788 case (uintptr_t)MDB_TGT_AS_PHYS: 789 case (uintptr_t)MDB_TGT_AS_FILE: 790 case (uintptr_t)MDB_TGT_AS_IO: 791 return (set_errno(EINVAL)); 792 case (uintptr_t)MDB_TGT_AS_VIRT: 793 asp = kt->k_as; 794 break; 795 default: 796 asp = (struct as *)as; 797 } 798 799 if ((pa = kt->k_kb_ops->kb_vtop(kt->k_cookie, asp, va)) != -1ULL) { 800 *pap = pa; 801 return (0); 802 } 803 804 if ((v = mdb_nv_lookup(&mdb.m_modules, "unix")) != NULL && 805 (mod = mdb_nv_get_cookie(v)) != NULL) { 806 807 fptr = (int (*)(uintptr_t, struct as *, physaddr_t *)) 808 dlsym(mod->mod_hdl, "platform_vtop"); 809 810 if ((fptr != NULL) && ((*fptr)(va, asp, pap) == 0)) 811 return (0); 812 } 813 814 return (set_errno(EMDB_NOMAP)); 815 } 816 817 int 818 kt_lookup_by_name(mdb_tgt_t *t, const char *obj, const char *name, 819 GElf_Sym *symp, mdb_syminfo_t *sip) 820 { 821 kt_data_t *kt = t->t_data; 822 kt_module_t *km, kmod; 823 mdb_var_t *v; 824 int n; 825 826 /* 827 * To simplify the implementation, we create a fake module on the stack 828 * which is "prepended" to k_modlist and whose symtab is kt->k_symtab. 829 */ 830 kmod.km_symtab = kt->k_symtab; 831 kmod.km_list.ml_next = mdb_list_next(&kt->k_modlist); 832 833 switch ((uintptr_t)obj) { 834 case (uintptr_t)MDB_TGT_OBJ_EXEC: 835 km = &kmod; 836 n = 1; 837 break; 838 839 case (uintptr_t)MDB_TGT_OBJ_EVERY: 840 km = &kmod; 841 n = mdb_nv_size(&kt->k_modules) + 1; 842 break; 843 844 case (uintptr_t)MDB_TGT_OBJ_RTLD: 845 obj = kt->k_rtld_name; 846 /*FALLTHRU*/ 847 848 default: 849 if ((v = mdb_nv_lookup(&kt->k_modules, obj)) == NULL) 850 return (set_errno(EMDB_NOOBJ)); 851 852 km = mdb_nv_get_cookie(v); 853 n = 1; 854 855 if (km->km_symtab == NULL) 856 kt_load_module(kt, t, km); 857 } 858 859 for (; n > 0; n--, km = mdb_list_next(km)) { 860 if (mdb_gelf_symtab_lookup_by_name(km->km_symtab, name, 861 symp, &sip->sym_id) == 0) { 862 sip->sym_table = MDB_TGT_SYMTAB; 863 return (0); 864 } 865 } 866 867 return (set_errno(EMDB_NOSYM)); 868 } 869 870 int 871 kt_lookup_by_addr(mdb_tgt_t *t, uintptr_t addr, uint_t flags, 872 char *buf, size_t nbytes, GElf_Sym *symp, mdb_syminfo_t *sip) 873 { 874 kt_data_t *kt = t->t_data; 875 kt_module_t kmods[3], *kmods_begin = &kmods[0], *kmods_end; 876 const char *name; 877 878 kt_module_t *km = &kmods[0]; /* Point km at first fake module */ 879 kt_module_t *sym_km = NULL; /* Module associated with best sym */ 880 GElf_Sym sym; /* Best symbol found so far if !exact */ 881 uint_t symid; /* ID of best symbol found so far */ 882 883 /* 884 * To simplify the implementation, we create fake modules on the stack 885 * that are "prepended" to k_modlist and whose symtab is set to 886 * each of three special symbol tables, in order of precedence. 887 */ 888 km->km_symtab = mdb.m_prsym; 889 890 if (kt->k_symtab != NULL) { 891 km->km_list.ml_next = (mdb_list_t *)(km + 1); 892 km = mdb_list_next(km); 893 km->km_symtab = kt->k_symtab; 894 } 895 896 if (kt->k_dynsym != NULL) { 897 km->km_list.ml_next = (mdb_list_t *)(km + 1); 898 km = mdb_list_next(km); 899 km->km_symtab = kt->k_dynsym; 900 } 901 902 km->km_list.ml_next = mdb_list_next(&kt->k_modlist); 903 kmods_end = km; 904 905 /* 906 * Now iterate over the list of fake and real modules. If the module 907 * has no symbol table and the address is in the text section, 908 * instantiate the module's symbol table. In exact mode, we can 909 * jump to 'found' immediately if we match. Otherwise we continue 910 * looking and improve our choice if we find a closer symbol. 911 */ 912 for (km = &kmods[0]; km != NULL; km = mdb_list_next(km)) { 913 if (km->km_symtab == NULL && addr >= km->km_text_va && 914 addr < km->km_text_va + km->km_text_size) 915 kt_load_module(kt, t, km); 916 917 if (mdb_gelf_symtab_lookup_by_addr(km->km_symtab, addr, 918 flags, buf, nbytes, symp, &sip->sym_id) != 0 || 919 symp->st_value == 0) 920 continue; 921 922 if (flags & MDB_TGT_SYM_EXACT) { 923 sym_km = km; 924 goto found; 925 } 926 927 if (sym_km == NULL || mdb_gelf_sym_closer(symp, &sym, addr)) { 928 sym_km = km; 929 sym = *symp; 930 symid = sip->sym_id; 931 } 932 } 933 934 if (sym_km == NULL) 935 return (set_errno(EMDB_NOSYMADDR)); 936 937 *symp = sym; /* Copy our best symbol into the caller's symbol */ 938 sip->sym_id = symid; 939 found: 940 /* 941 * Once we've found something, copy the final name into the caller's 942 * buffer and prefix it with the load object name if appropriate. 943 */ 944 if (sym_km != NULL) { 945 name = mdb_gelf_sym_name(sym_km->km_symtab, symp); 946 947 if (sym_km < kmods_begin || sym_km > kmods_end) { 948 (void) mdb_snprintf(buf, nbytes, "%s`%s", 949 sym_km->km_name, name); 950 } else if (nbytes > 0) { 951 (void) strncpy(buf, name, nbytes); 952 buf[nbytes - 1] = '\0'; 953 } 954 955 if (sym_km->km_symtab == mdb.m_prsym) 956 sip->sym_table = MDB_TGT_PRVSYM; 957 else 958 sip->sym_table = MDB_TGT_SYMTAB; 959 } else { 960 sip->sym_table = MDB_TGT_SYMTAB; 961 } 962 963 return (0); 964 } 965 966 static int 967 kt_symtab_func(void *data, const GElf_Sym *sym, const char *name, uint_t id) 968 { 969 kt_symarg_t *argp = data; 970 971 if (mdb_tgt_sym_match(sym, argp->sym_type)) { 972 argp->sym_info.sym_id = id; 973 974 return (argp->sym_cb(argp->sym_data, sym, name, 975 &argp->sym_info, argp->sym_obj)); 976 } 977 978 return (0); 979 } 980 981 static void 982 kt_symtab_iter(mdb_gelf_symtab_t *gst, uint_t type, const char *obj, 983 mdb_tgt_sym_f *cb, void *p) 984 { 985 kt_symarg_t arg; 986 987 arg.sym_cb = cb; 988 arg.sym_data = p; 989 arg.sym_type = type; 990 arg.sym_info.sym_table = gst->gst_tabid; 991 arg.sym_obj = obj; 992 993 mdb_gelf_symtab_iter(gst, kt_symtab_func, &arg); 994 } 995 996 int 997 kt_symbol_iter(mdb_tgt_t *t, const char *obj, uint_t which, uint_t type, 998 mdb_tgt_sym_f *cb, void *data) 999 { 1000 kt_data_t *kt = t->t_data; 1001 kt_module_t *km; 1002 1003 mdb_gelf_symtab_t *symtab = NULL; 1004 mdb_var_t *v; 1005 1006 switch ((uintptr_t)obj) { 1007 case (uintptr_t)MDB_TGT_OBJ_EXEC: 1008 if (which == MDB_TGT_SYMTAB) 1009 symtab = kt->k_symtab; 1010 else 1011 symtab = kt->k_dynsym; 1012 break; 1013 1014 case (uintptr_t)MDB_TGT_OBJ_EVERY: 1015 if (which == MDB_TGT_DYNSYM) { 1016 symtab = kt->k_dynsym; 1017 obj = MDB_TGT_OBJ_EXEC; 1018 break; 1019 } 1020 1021 mdb_nv_rewind(&kt->k_modules); 1022 while ((v = mdb_nv_advance(&kt->k_modules)) != NULL) { 1023 km = mdb_nv_get_cookie(v); 1024 1025 if (km->km_symtab == NULL) 1026 kt_load_module(kt, t, km); 1027 1028 if (km->km_symtab != NULL) 1029 kt_symtab_iter(km->km_symtab, type, 1030 km->km_name, cb, data); 1031 } 1032 break; 1033 1034 case (uintptr_t)MDB_TGT_OBJ_RTLD: 1035 obj = kt->k_rtld_name; 1036 /*FALLTHRU*/ 1037 1038 default: 1039 v = mdb_nv_lookup(&kt->k_modules, obj); 1040 1041 if (v == NULL) 1042 return (set_errno(EMDB_NOOBJ)); 1043 1044 km = mdb_nv_get_cookie(v); 1045 1046 if (km->km_symtab == NULL) 1047 kt_load_module(kt, t, km); 1048 1049 symtab = km->km_symtab; 1050 } 1051 1052 if (symtab) 1053 kt_symtab_iter(symtab, type, obj, cb, data); 1054 1055 return (0); 1056 } 1057 1058 static int 1059 kt_mapping_walk(uintptr_t addr, const void *data, kt_maparg_t *marg) 1060 { 1061 /* 1062 * This is a bit sketchy but avoids problematic compilation of this 1063 * target against the current VM implementation. Now that we have 1064 * vmem, we can make this less broken and more informative by changing 1065 * this code to invoke the vmem walker in the near future. 1066 */ 1067 const struct kt_seg { 1068 caddr_t s_base; 1069 size_t s_size; 1070 } *segp = (const struct kt_seg *)data; 1071 1072 mdb_map_t map; 1073 GElf_Sym sym; 1074 mdb_syminfo_t info; 1075 1076 map.map_base = (uintptr_t)segp->s_base; 1077 map.map_size = segp->s_size; 1078 map.map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X; 1079 1080 if (kt_lookup_by_addr(marg->map_target, addr, MDB_TGT_SYM_EXACT, 1081 map.map_name, MDB_TGT_MAPSZ, &sym, &info) == -1) { 1082 1083 (void) mdb_iob_snprintf(map.map_name, MDB_TGT_MAPSZ, 1084 "%lr", addr); 1085 } 1086 1087 return (marg->map_cb(marg->map_data, &map, map.map_name)); 1088 } 1089 1090 int 1091 kt_mapping_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 1092 { 1093 kt_data_t *kt = t->t_data; 1094 kt_maparg_t m; 1095 1096 m.map_target = t; 1097 m.map_cb = func; 1098 m.map_data = private; 1099 1100 return (mdb_pwalk("seg", (mdb_walk_cb_t)kt_mapping_walk, &m, 1101 (uintptr_t)kt->k_as)); 1102 } 1103 1104 static const mdb_map_t * 1105 kt_module_to_map(kt_module_t *km, mdb_map_t *map) 1106 { 1107 (void) strncpy(map->map_name, km->km_name, MDB_TGT_MAPSZ); 1108 map->map_name[MDB_TGT_MAPSZ - 1] = '\0'; 1109 map->map_base = km->km_text_va; 1110 map->map_size = km->km_text_size; 1111 map->map_flags = MDB_TGT_MAP_R | MDB_TGT_MAP_W | MDB_TGT_MAP_X; 1112 1113 return (map); 1114 } 1115 1116 int 1117 kt_object_iter(mdb_tgt_t *t, mdb_tgt_map_f *func, void *private) 1118 { 1119 kt_data_t *kt = t->t_data; 1120 kt_module_t *km; 1121 mdb_map_t m; 1122 1123 for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) { 1124 if (func(private, kt_module_to_map(km, &m), km->km_name) == -1) 1125 break; 1126 } 1127 1128 return (0); 1129 } 1130 1131 const mdb_map_t * 1132 kt_addr_to_map(mdb_tgt_t *t, uintptr_t addr) 1133 { 1134 kt_data_t *kt = t->t_data; 1135 kt_module_t *km; 1136 1137 for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) { 1138 if (addr - km->km_text_va < km->km_text_size || 1139 addr - km->km_data_va < km->km_data_size || 1140 addr - km->km_bss_va < km->km_bss_size) 1141 return (kt_module_to_map(km, &kt->k_map)); 1142 } 1143 1144 (void) set_errno(EMDB_NOMAP); 1145 return (NULL); 1146 } 1147 1148 const mdb_map_t * 1149 kt_name_to_map(mdb_tgt_t *t, const char *name) 1150 { 1151 kt_data_t *kt = t->t_data; 1152 kt_module_t *km; 1153 mdb_map_t m; 1154 1155 /* 1156 * If name is MDB_TGT_OBJ_EXEC, return the first module on the list, 1157 * which will be unix since we keep k_modlist in load order. 1158 */ 1159 if (name == MDB_TGT_OBJ_EXEC) 1160 return (kt_module_to_map(mdb_list_next(&kt->k_modlist), &m)); 1161 1162 if (name == MDB_TGT_OBJ_RTLD) 1163 name = kt->k_rtld_name; 1164 1165 if ((km = kt_module_by_name(kt, name)) != NULL) 1166 return (kt_module_to_map(km, &m)); 1167 1168 (void) set_errno(EMDB_NOOBJ); 1169 return (NULL); 1170 } 1171 1172 static ctf_file_t * 1173 kt_load_ctfdata(mdb_tgt_t *t, kt_module_t *km) 1174 { 1175 kt_data_t *kt = t->t_data; 1176 int err; 1177 1178 if (km->km_ctfp != NULL) 1179 return (km->km_ctfp); 1180 1181 if (km->km_ctf_va == NULL) { 1182 (void) set_errno(EMDB_NOCTF); 1183 return (NULL); 1184 } 1185 1186 if (km->km_symtab == NULL) 1187 kt_load_module(t->t_data, t, km); 1188 1189 if ((km->km_ctf_buf = mdb_alloc(km->km_ctf_size, UM_NOSLEEP)) == NULL) { 1190 warn("failed to allocate memory to load %s debugging " 1191 "information", km->km_name); 1192 return (NULL); 1193 } 1194 1195 if (mdb_tgt_vread(t, km->km_ctf_buf, km->km_ctf_size, 1196 km->km_ctf_va) != km->km_ctf_size) { 1197 warn("failed to read %lu bytes of debug data for %s at %p", 1198 (ulong_t)km->km_ctf_size, km->km_name, 1199 (void *)km->km_ctf_va); 1200 mdb_free(km->km_ctf_buf, km->km_ctf_size); 1201 km->km_ctf_buf = NULL; 1202 return (NULL); 1203 } 1204 1205 if ((km->km_ctfp = mdb_ctf_bufopen((const void *)km->km_ctf_buf, 1206 km->km_ctf_size, km->km_symbuf, &km->km_symtab_hdr, 1207 km->km_strtab, &km->km_strtab_hdr, &err)) == NULL) { 1208 mdb_free(km->km_ctf_buf, km->km_ctf_size); 1209 km->km_ctf_buf = NULL; 1210 (void) set_errno(ctf_to_errno(err)); 1211 return (NULL); 1212 } 1213 1214 mdb_dprintf(MDB_DBG_KMOD, "loaded %lu bytes of CTF data for %s\n", 1215 (ulong_t)km->km_ctf_size, km->km_name); 1216 1217 if (ctf_parent_name(km->km_ctfp) != NULL) { 1218 mdb_var_t *v; 1219 1220 if ((v = mdb_nv_lookup(&kt->k_modules, 1221 ctf_parent_name(km->km_ctfp))) == NULL) { 1222 warn("failed to load CTF data for %s - parent %s not " 1223 "loaded\n", km->km_name, 1224 ctf_parent_name(km->km_ctfp)); 1225 } 1226 1227 if (v != NULL) { 1228 kt_module_t *pm = mdb_nv_get_cookie(v); 1229 1230 if (pm->km_ctfp == NULL) 1231 (void) kt_load_ctfdata(t, pm); 1232 1233 if (pm->km_ctfp != NULL && ctf_import(km->km_ctfp, 1234 pm->km_ctfp) == CTF_ERR) { 1235 warn("failed to import parent types into " 1236 "%s: %s\n", km->km_name, 1237 ctf_errmsg(ctf_errno(km->km_ctfp))); 1238 } 1239 } 1240 } 1241 1242 return (km->km_ctfp); 1243 } 1244 1245 ctf_file_t * 1246 kt_addr_to_ctf(mdb_tgt_t *t, uintptr_t addr) 1247 { 1248 kt_data_t *kt = t->t_data; 1249 kt_module_t *km; 1250 1251 for (km = mdb_list_next(&kt->k_modlist); km; km = mdb_list_next(km)) { 1252 if (addr - km->km_text_va < km->km_text_size || 1253 addr - km->km_data_va < km->km_data_size || 1254 addr - km->km_bss_va < km->km_bss_size) 1255 return (kt_load_ctfdata(t, km)); 1256 } 1257 1258 (void) set_errno(EMDB_NOMAP); 1259 return (NULL); 1260 } 1261 1262 ctf_file_t * 1263 kt_name_to_ctf(mdb_tgt_t *t, const char *name) 1264 { 1265 kt_data_t *kt = t->t_data; 1266 kt_module_t *km; 1267 1268 if (name == MDB_TGT_OBJ_EXEC) 1269 name = KT_CTFPARENT; 1270 else if (name == MDB_TGT_OBJ_RTLD) 1271 name = kt->k_rtld_name; 1272 1273 if ((km = kt_module_by_name(kt, name)) != NULL) 1274 return (kt_load_ctfdata(t, km)); 1275 1276 (void) set_errno(EMDB_NOOBJ); 1277 return (NULL); 1278 } 1279 1280 /*ARGSUSED*/ 1281 int 1282 kt_status(mdb_tgt_t *t, mdb_tgt_status_t *tsp) 1283 { 1284 kt_data_t *kt = t->t_data; 1285 bzero(tsp, sizeof (mdb_tgt_status_t)); 1286 tsp->st_state = (kt->k_xpv_domu || (kt->k_dumphdr != NULL)) ? 1287 MDB_TGT_DEAD : MDB_TGT_RUNNING; 1288 return (0); 1289 } 1290 1291 static ssize_t 1292 kt_xd_dumphdr(mdb_tgt_t *t, void *buf, size_t nbytes) 1293 { 1294 kt_data_t *kt = t->t_data; 1295 1296 if (buf == NULL && nbytes == 0) 1297 return (sizeof (dumphdr_t)); 1298 1299 if (kt->k_dumphdr == NULL) 1300 return (set_errno(ENODATA)); 1301 1302 nbytes = MIN(nbytes, sizeof (dumphdr_t)); 1303 bcopy(kt->k_dumphdr, buf, nbytes); 1304 1305 return (nbytes); 1306 } 1307 1308 void 1309 kt_destroy(mdb_tgt_t *t) 1310 { 1311 kt_data_t *kt = t->t_data; 1312 kt_module_t *km, *nkm; 1313 1314 (void) mdb_module_unload(KT_MODULE, 0); 1315 1316 if (kt->k_regs != NULL) 1317 mdb_free(kt->k_regs, kt->k_regsize); 1318 1319 if (kt->k_symtab != NULL) 1320 mdb_gelf_symtab_destroy(kt->k_symtab); 1321 1322 if (kt->k_dynsym != NULL) 1323 mdb_gelf_symtab_destroy(kt->k_dynsym); 1324 1325 if (kt->k_dumphdr != NULL) 1326 mdb_free(kt->k_dumphdr, sizeof (dumphdr_t)); 1327 1328 mdb_gelf_destroy(kt->k_file); 1329 1330 (void) kt->k_kb_ops->kb_close(kt->k_cookie); 1331 1332 for (km = mdb_list_next(&kt->k_modlist); km; km = nkm) { 1333 if (km->km_symtab) 1334 mdb_gelf_symtab_destroy(km->km_symtab); 1335 1336 if (km->km_data) 1337 mdb_free(km->km_data, km->km_datasz); 1338 1339 if (km->km_ctfp) 1340 ctf_close(km->km_ctfp); 1341 1342 if (km->km_ctf_buf != NULL) 1343 mdb_free(km->km_ctf_buf, km->km_ctf_size); 1344 1345 nkm = mdb_list_next(km); 1346 strfree(km->km_name); 1347 mdb_free(km, sizeof (kt_module_t)); 1348 } 1349 1350 mdb_nv_destroy(&kt->k_modules); 1351 1352 strfree(kt->k_kvmfile); 1353 if (kt->k_symfile != NULL) 1354 strfree(kt->k_symfile); 1355 1356 mdb_free(kt, sizeof (kt_data_t)); 1357 } 1358 1359 static int 1360 kt_data_stub(void) 1361 { 1362 return (-1); 1363 } 1364 1365 int 1366 mdb_kvm_tgt_create(mdb_tgt_t *t, int argc, const char *argv[]) 1367 { 1368 kt_data_t *kt = mdb_zalloc(sizeof (kt_data_t), UM_SLEEP); 1369 mdb_kb_ops_t *kvm_kb_ops = libkvm_kb_ops(); 1370 int oflag = (t->t_flags & MDB_TGT_F_RDWR) ? O_RDWR : O_RDONLY; 1371 struct utsname uts; 1372 GElf_Sym sym; 1373 pgcnt_t pmem; 1374 1375 1376 if (argc == 2) { 1377 kt->k_symfile = strdup(argv[0]); 1378 kt->k_kvmfile = strdup(argv[1]); 1379 1380 kt->k_cookie = kvm_kb_ops->kb_open(kt->k_symfile, 1381 kt->k_kvmfile, NULL, oflag, (char *)mdb.m_pname); 1382 1383 if (kt->k_cookie == NULL) 1384 goto err; 1385 1386 kt->k_xpv_domu = 0; 1387 kt->k_kb_ops = kvm_kb_ops; 1388 } else { 1389 #ifndef __x86 1390 return (set_errno(EINVAL)); 1391 #else 1392 mdb_kb_ops_t *(*getops)(void); 1393 1394 kt->k_symfile = NULL; 1395 kt->k_kvmfile = strdup(argv[0]); 1396 1397 getops = (mdb_kb_ops_t *(*)())dlsym(RTLD_NEXT, "mdb_kb_ops"); 1398 1399 /* 1400 * Load mdb_kb if it's not already loaded during 1401 * identification. 1402 */ 1403 if (getops == NULL) { 1404 (void) mdb_module_load("mdb_kb", 1405 MDB_MOD_GLOBAL | MDB_MOD_SILENT); 1406 getops = (mdb_kb_ops_t *(*)()) 1407 dlsym(RTLD_NEXT, "mdb_kb_ops"); 1408 } 1409 1410 if (getops == NULL || (kt->k_kb_ops = getops()) == NULL) { 1411 warn("failed to load KVM backend ops\n"); 1412 goto err; 1413 } 1414 1415 kt->k_cookie = kt->k_kb_ops->kb_open(NULL, kt->k_kvmfile, NULL, 1416 oflag, (char *)mdb.m_pname); 1417 1418 if (kt->k_cookie == NULL) 1419 goto err; 1420 1421 kt->k_xpv_domu = 1; 1422 #endif 1423 } 1424 1425 if ((kt->k_fio = kt->k_kb_ops->kb_sym_io(kt->k_cookie, 1426 kt->k_symfile)) == NULL) 1427 goto err; 1428 1429 if ((kt->k_file = mdb_gelf_create(kt->k_fio, 1430 ET_EXEC, GF_FILE)) == NULL) { 1431 mdb_io_destroy(kt->k_fio); 1432 goto err; 1433 } 1434 1435 kt->k_symtab = 1436 mdb_gelf_symtab_create_file(kt->k_file, SHT_SYMTAB, MDB_TGT_SYMTAB); 1437 1438 kt->k_dynsym = 1439 mdb_gelf_symtab_create_file(kt->k_file, SHT_DYNSYM, MDB_TGT_DYNSYM); 1440 1441 if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "kas", 1442 &sym, NULL) == -1) { 1443 warn("'kas' symbol is missing from kernel\n"); 1444 goto err; 1445 } 1446 1447 kt->k_as = (struct as *)(uintptr_t)sym.st_value; 1448 1449 if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "platform", 1450 &sym, NULL) == -1) { 1451 warn("'platform' symbol is missing from kernel\n"); 1452 goto err; 1453 } 1454 1455 if (kt->k_kb_ops->kb_kread(kt->k_cookie, sym.st_value, 1456 kt->k_platform, MAXNAMELEN) <= 0) { 1457 warn("failed to read 'platform' string from kernel"); 1458 goto err; 1459 } 1460 1461 if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "utsname", 1462 &sym, NULL) == -1) { 1463 warn("'utsname' symbol is missing from kernel\n"); 1464 goto err; 1465 } 1466 1467 if (kt->k_kb_ops->kb_kread(kt->k_cookie, sym.st_value, &uts, 1468 sizeof (uts)) <= 0) { 1469 warn("failed to read 'utsname' struct from kernel"); 1470 goto err; 1471 } 1472 1473 kt->k_dump_print_content = (void (*)())kt_data_stub; 1474 kt->k_dump_find_curproc = kt_data_stub; 1475 1476 /* 1477 * We set k_ctfvalid based on the presence of the CTF vmem arena 1478 * symbol. The CTF members were added to the end of struct module at 1479 * the same time, so this allows us to know whether we can use them. 1480 */ 1481 if (mdb_gelf_symtab_lookup_by_name(kt->k_symtab, "ctf_arena", &sym, 1482 NULL) == 0 && !(mdb.m_flags & MDB_FL_NOCTF)) 1483 kt->k_ctfvalid = 1; 1484 1485 (void) mdb_nv_create(&kt->k_modules, UM_SLEEP); 1486 t->t_pshandle = kt->k_cookie; 1487 t->t_data = kt; 1488 1489 #if defined(__sparc) 1490 #if defined(__sparcv9) 1491 kt_sparcv9_init(t); 1492 #else 1493 kt_sparcv7_init(t); 1494 #endif 1495 #elif defined(__amd64) 1496 kt_amd64_init(t); 1497 #elif defined(__i386) 1498 kt_ia32_init(t); 1499 #else 1500 #error "unknown ISA" 1501 #endif 1502 1503 /* 1504 * We read our representative thread ID (address) from the kernel's 1505 * global panic_thread. It will remain 0 if this is a live kernel. 1506 */ 1507 (void) mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, &kt->k_tid, sizeof (void *), 1508 MDB_TGT_OBJ_EXEC, "panic_thread"); 1509 1510 if ((mdb.m_flags & MDB_FL_ADB) && mdb_tgt_readsym(t, MDB_TGT_AS_VIRT, 1511 &pmem, sizeof (pmem), MDB_TGT_OBJ_EXEC, "physmem") == sizeof (pmem)) 1512 mdb_printf("physmem %lx\n", (ulong_t)pmem); 1513 1514 /* 1515 * If this is not a live kernel or a hypervisor dump, read the dump 1516 * header. We don't have to sanity-check the header, as the open would 1517 * not have succeeded otherwise. 1518 */ 1519 if (!kt->k_xpv_domu && strcmp(kt->k_symfile, "/dev/ksyms") != 0) { 1520 mdb_io_t *vmcore; 1521 1522 kt->k_dumphdr = mdb_alloc(sizeof (dumphdr_t), UM_SLEEP); 1523 1524 if ((vmcore = mdb_fdio_create_path(NULL, kt->k_kvmfile, 1525 O_RDONLY, 0)) == NULL) { 1526 mdb_warn("failed to open %s", kt->k_kvmfile); 1527 goto err; 1528 } 1529 1530 if (IOP_READ(vmcore, kt->k_dumphdr, sizeof (dumphdr_t)) != 1531 sizeof (dumphdr_t)) { 1532 mdb_warn("failed to read dump header"); 1533 mdb_io_destroy(vmcore); 1534 goto err; 1535 } 1536 1537 mdb_io_destroy(vmcore); 1538 1539 (void) mdb_tgt_xdata_insert(t, "dumphdr", 1540 "dump header structure", kt_xd_dumphdr); 1541 } 1542 1543 return (0); 1544 1545 err: 1546 if (kt->k_dumphdr != NULL) 1547 mdb_free(kt->k_dumphdr, sizeof (dumphdr_t)); 1548 1549 if (kt->k_symtab != NULL) 1550 mdb_gelf_symtab_destroy(kt->k_symtab); 1551 1552 if (kt->k_dynsym != NULL) 1553 mdb_gelf_symtab_destroy(kt->k_dynsym); 1554 1555 if (kt->k_file != NULL) 1556 mdb_gelf_destroy(kt->k_file); 1557 1558 if (kt->k_cookie != NULL) 1559 (void) kt->k_kb_ops->kb_close(kt->k_cookie); 1560 1561 mdb_free(kt, sizeof (kt_data_t)); 1562 return (-1); 1563 } 1564 1565 int 1566 mdb_kvm_is_compressed_dump(mdb_io_t *io) 1567 { 1568 dumphdr_t h; 1569 1570 return (IOP_READ(io, &h, sizeof (dumphdr_t)) == sizeof (dumphdr_t) && 1571 h.dump_magic == DUMP_MAGIC && 1572 (h.dump_flags & DF_COMPRESSED) != 0); 1573 } 1574