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