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