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