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 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/elf.h> 27 #include <sys/elf_SPARC.h> 28 29 #include <libproc.h> 30 #include <libctf.h> 31 #include <stdlib.h> 32 #include <string.h> 33 #include <fcntl.h> 34 #include <errno.h> 35 36 #include <mdb/mdb_string.h> 37 #include <mdb/mdb_argvec.h> 38 #include <mdb/mdb_nv.h> 39 #include <mdb/mdb_fmt.h> 40 #include <mdb/mdb_target.h> 41 #include <mdb/mdb_err.h> 42 #include <mdb/mdb_debug.h> 43 #include <mdb/mdb_conf.h> 44 #include <mdb/mdb_module.h> 45 #include <mdb/mdb_modapi.h> 46 #include <mdb/mdb_stdlib.h> 47 #include <mdb/mdb_lex.h> 48 #include <mdb/mdb_io_impl.h> 49 #include <mdb/mdb_help.h> 50 #include <mdb/mdb_disasm.h> 51 #include <mdb/mdb_frame.h> 52 #include <mdb/mdb_evset.h> 53 #include <mdb/mdb_print.h> 54 #include <mdb/mdb_nm.h> 55 #include <mdb/mdb_set.h> 56 #include <mdb/mdb_demangle.h> 57 #include <mdb/mdb.h> 58 59 enum { 60 NM_FMT_INDEX = 0x0001, /* -f ndx */ 61 NM_FMT_VALUE = 0x0002, /* -f val */ 62 NM_FMT_SIZE = 0x0004, /* -f size */ 63 NM_FMT_TYPE = 0x0008, /* -f type */ 64 NM_FMT_BIND = 0x0010, /* -f bind */ 65 NM_FMT_OTHER = 0x0020, /* -f oth */ 66 NM_FMT_SHNDX = 0x0040, /* -f shndx */ 67 NM_FMT_NAME = 0x0080, /* -f name */ 68 NM_FMT_CTYPE = 0x0100, /* -f ctype */ 69 NM_FMT_OBJECT = 0x0200, /* -f obj */ 70 71 NM_FMT_CTFID = 0x1000 /* -f ctfid */ 72 }; 73 74 enum { 75 NM_TYPE_NOTY = 1 << STT_NOTYPE, /* -t noty */ 76 NM_TYPE_OBJT = 1 << STT_OBJECT, /* -t objt */ 77 NM_TYPE_FUNC = 1 << STT_FUNC, /* -t func */ 78 NM_TYPE_SECT = 1 << STT_SECTION, /* -t sect */ 79 NM_TYPE_FILE = 1 << STT_FILE, /* -t file */ 80 NM_TYPE_COMM = 1 << STT_COMMON, /* -t comm */ 81 NM_TYPE_TLS = 1 << STT_TLS, /* -t tls */ 82 NM_TYPE_REGI = 1 << STT_SPARC_REGISTER /* -t regi */ 83 }; 84 85 typedef struct { 86 GElf_Sym nm_sym; 87 const char *nm_name; 88 mdb_syminfo_t nm_si; 89 const char *nm_object; 90 ctf_file_t *nm_fp; 91 } nm_sym_t; 92 93 typedef struct { 94 ctf_file_t *nii_fp; 95 96 uint_t nii_flags; 97 uint_t nii_types; 98 ulong_t nii_id; 99 const char *nii_pfmt; 100 const char *nii_ofmt; 101 102 const GElf_Sym *nii_symp; 103 104 nm_sym_t **nii_sympp; 105 } nm_iter_info_t; 106 107 typedef struct { 108 mdb_tgt_sym_f *ngs_cb; 109 void *ngs_arg; 110 mdb_syminfo_t ngs_si; 111 const char *ngs_object; 112 } nm_gelf_symtab_t; 113 114 typedef struct { 115 uint_t noi_which; 116 uint_t noi_type; 117 mdb_tgt_sym_f *noi_cb; 118 nm_iter_info_t *noi_niip; 119 } nm_object_iter_t; 120 121 static const char * 122 nm_type2str(uchar_t info) 123 { 124 switch (GELF_ST_TYPE(info)) { 125 case STT_NOTYPE: 126 return ("NOTY"); 127 case STT_OBJECT: 128 return ("OBJT"); 129 case STT_FUNC: 130 return ("FUNC"); 131 case STT_SECTION: 132 return ("SECT"); 133 case STT_FILE: 134 return ("FILE"); 135 case STT_COMMON: 136 return ("COMM"); 137 case STT_TLS: 138 return ("TLS"); 139 case STT_SPARC_REGISTER: 140 return ("REGI"); 141 default: 142 return ("?"); 143 } 144 } 145 146 static const char * 147 nm_bind2str(uchar_t info) 148 { 149 switch (GELF_ST_BIND(info)) { 150 case STB_LOCAL: 151 return ("LOCL"); 152 case STB_GLOBAL: 153 return ("GLOB"); 154 case STB_WEAK: 155 return ("WEAK"); 156 default: 157 return ("?"); 158 } 159 } 160 161 static const char * 162 nm_sect2str(GElf_Half shndx) 163 { 164 static char buf[16]; 165 166 switch (shndx) { 167 case SHN_UNDEF: 168 return ("UNDEF"); 169 case SHN_ABS: 170 return ("ABS"); 171 case SHN_COMMON: 172 return ("COMMON"); 173 default: 174 (void) mdb_iob_snprintf(buf, sizeof (buf), "%hu", shndx); 175 return (buf); 176 } 177 } 178 179 static char * 180 nm_func_signature(ctf_file_t *fp, uint_t index, char *buf, size_t len) 181 { 182 int n; 183 ctf_funcinfo_t f; 184 ctf_id_t argv[32]; 185 char arg[32]; 186 char *start = buf; 187 char *sep = ""; 188 int i; 189 190 if (ctf_func_info(fp, index, &f) == CTF_ERR) 191 return (NULL); 192 193 if (ctf_type_name(fp, f.ctc_return, arg, sizeof (arg)) != NULL) 194 n = mdb_snprintf(buf, len, "%s (*)(", arg); 195 else 196 n = mdb_snprintf(buf, len, "<%ld> (*)(", f.ctc_return); 197 198 if (len <= n) 199 return (start); 200 201 buf += n; 202 len -= n; 203 204 (void) ctf_func_args(fp, index, sizeof (argv) / sizeof (argv[0]), argv); 205 206 for (i = 0; i < f.ctc_argc; i++) { 207 if (ctf_type_name(fp, argv[i], arg, sizeof (arg)) != NULL) 208 n = mdb_snprintf(buf, len, "%s%s", sep, arg); 209 else 210 n = mdb_snprintf(buf, len, "%s<%ld>", sep, argv[i]); 211 212 if (len <= n) 213 return (start); 214 215 buf += n; 216 len -= n; 217 218 sep = ", "; 219 } 220 221 if (f.ctc_flags & CTF_FUNC_VARARG) { 222 n = mdb_snprintf(buf, len, "%s...", sep); 223 if (len <= n) 224 return (start); 225 buf += n; 226 len -= n; 227 } else if (f.ctc_argc == 0) { 228 n = mdb_snprintf(buf, len, "void"); 229 if (len <= n) 230 return (start); 231 buf += n; 232 len -= n; 233 } 234 235 (void) mdb_snprintf(buf, len, ")"); 236 237 return (start); 238 } 239 240 static void 241 nm_print_ctype(void *data) 242 { 243 nm_iter_info_t *niip = data; 244 char buf[256]; 245 ctf_id_t id; 246 char *str = NULL; 247 uint_t index = niip->nii_id; 248 ctf_file_t *fp = niip->nii_fp; 249 250 if (fp != NULL) { 251 if (GELF_ST_TYPE(niip->nii_symp->st_info) == STT_FUNC) 252 str = nm_func_signature(fp, index, buf, sizeof (buf)); 253 else if ((id = ctf_lookup_by_symbol(fp, index)) != CTF_ERR) 254 str = ctf_type_name(fp, id, buf, sizeof (buf)); 255 } 256 257 if (str == NULL) 258 str = "<unknown type>"; 259 260 mdb_printf("%-50s", str); 261 } 262 263 static void 264 nm_print_ctfid(void *data) 265 { 266 nm_iter_info_t *niip = data; 267 ctf_id_t id; 268 uint_t index = niip->nii_id; 269 ctf_file_t *fp = niip->nii_fp; 270 271 if (fp != NULL && (id = ctf_lookup_by_symbol(fp, index)) != CTF_ERR) { 272 mdb_printf("%-9ld", id); 273 } else { 274 mdb_printf("%9s", ""); 275 } 276 } 277 278 static void 279 nm_print_obj(void *data) 280 { 281 const char *obj = (const char *)data; 282 283 if (obj == MDB_TGT_OBJ_EXEC) 284 obj = "exec"; 285 else if (obj == MDB_TGT_OBJ_RTLD) 286 obj = "rtld"; 287 else if (obj == MDB_TGT_OBJ_EVERY) 288 obj = ""; 289 290 mdb_printf("%-15s", obj); 291 } 292 293 /*ARGSUSED*/ 294 static int 295 nm_print(void *data, const GElf_Sym *sym, const char *name, 296 const mdb_syminfo_t *sip, const char *obj) 297 { 298 nm_iter_info_t *niip = data; 299 300 if (!((1 << GELF_ST_TYPE(sym->st_info)) & niip->nii_types)) 301 return (0); 302 303 niip->nii_id = sip->sym_id; 304 niip->nii_symp = sym; 305 306 mdb_table_print(niip->nii_flags, "|", 307 MDB_TBL_PRNT, NM_FMT_INDEX, "%5u", sip->sym_id, 308 MDB_TBL_FUNC, NM_FMT_OBJECT, nm_print_obj, obj, 309 MDB_TBL_PRNT, NM_FMT_VALUE, niip->nii_pfmt, sym->st_value, 310 MDB_TBL_PRNT, NM_FMT_SIZE, niip->nii_pfmt, sym->st_size, 311 MDB_TBL_PRNT, NM_FMT_TYPE, "%-5s", nm_type2str(sym->st_info), 312 MDB_TBL_PRNT, NM_FMT_BIND, "%-5s", nm_bind2str(sym->st_info), 313 MDB_TBL_PRNT, NM_FMT_OTHER, niip->nii_ofmt, sym->st_other, 314 MDB_TBL_PRNT, NM_FMT_SHNDX, "%-8s", nm_sect2str(sym->st_shndx), 315 MDB_TBL_FUNC, NM_FMT_CTFID, nm_print_ctfid, niip, 316 MDB_TBL_FUNC, NM_FMT_CTYPE, nm_print_ctype, niip, 317 MDB_TBL_PRNT, NM_FMT_NAME, "%s", name, 318 MDB_TBL_DONE); 319 320 mdb_printf("\n"); 321 322 return (0); 323 } 324 325 /*ARGSUSED*/ 326 static int 327 nm_any(void *data, const GElf_Sym *sym, const char *name, 328 const mdb_syminfo_t *sip, const char *obj) 329 { 330 return (nm_print(data, sym, name, sip, obj)); 331 } 332 333 /*ARGSUSED*/ 334 static int 335 nm_undef(void *data, const GElf_Sym *sym, const char *name, 336 const mdb_syminfo_t *sip, const char *obj) 337 { 338 if (sym->st_shndx == SHN_UNDEF) 339 return (nm_print(data, sym, name, sip, obj)); 340 341 return (0); 342 } 343 344 /*ARGSUSED*/ 345 static int 346 nm_asgn(void *data, const GElf_Sym *sym, const char *name, 347 const mdb_syminfo_t *sip, const char *obj) 348 { 349 const char *opts; 350 351 switch (GELF_ST_TYPE(sym->st_info)) { 352 case STT_FUNC: 353 opts = "-f"; 354 break; 355 case STT_OBJECT: 356 opts = "-o"; 357 break; 358 default: 359 opts = ""; 360 } 361 362 mdb_printf("%#llr::nmadd %s -s %#llr %s\n", 363 sym->st_value, opts, sym->st_size, name); 364 365 return (0); 366 } 367 368 /*ARGSUSED*/ 369 static int 370 nm_cnt_any(void *data, const GElf_Sym *sym, const char *name, 371 const mdb_syminfo_t *sip, const char *obj) 372 { 373 size_t *cntp = (size_t *)data; 374 (*cntp)++; 375 return (0); 376 } 377 378 /*ARGSUSED*/ 379 static int 380 nm_cnt_undef(void *data, const GElf_Sym *sym, const char *name, 381 const mdb_syminfo_t *sip, const char *obj) 382 { 383 if (sym->st_shndx == SHN_UNDEF) 384 return (nm_cnt_any(data, sym, name, sip, obj)); 385 386 return (0); 387 } 388 389 /*ARGSUSED*/ 390 static int 391 nm_get_any(void *data, const GElf_Sym *sym, const char *name, 392 const mdb_syminfo_t *sip, const char *obj) 393 { 394 nm_iter_info_t *niip = data; 395 nm_sym_t **sympp = niip->nii_sympp; 396 397 (*sympp)->nm_sym = *sym; 398 (*sympp)->nm_name = name; 399 (*sympp)->nm_si = *sip; 400 (*sympp)->nm_object = obj; 401 (*sympp)->nm_fp = niip->nii_fp; 402 (*sympp)++; 403 404 return (0); 405 } 406 407 /*ARGSUSED*/ 408 static int 409 nm_get_undef(void *data, const GElf_Sym *sym, const char *name, 410 const mdb_syminfo_t *sip, const char *obj) 411 { 412 if (sym->st_shndx == SHN_UNDEF) 413 return (nm_get_any(data, sym, name, sip, obj)); 414 415 return (0); 416 } 417 418 static int 419 nm_compare_name(const void *lp, const void *rp) 420 { 421 const nm_sym_t *lhs = (nm_sym_t *)lp; 422 const nm_sym_t *rhs = (nm_sym_t *)rp; 423 424 return (strcmp(lhs->nm_name, rhs->nm_name)); 425 } 426 427 static int 428 nm_compare_val(const void *lp, const void *rp) 429 { 430 const nm_sym_t *lhs = (nm_sym_t *)lp; 431 const nm_sym_t *rhs = (nm_sym_t *)rp; 432 433 return (lhs->nm_sym.st_value < rhs->nm_sym.st_value ? -1 : 434 (lhs->nm_sym.st_value > rhs->nm_sym.st_value ? 1 : 0)); 435 } 436 437 static int 438 nm_gelf_symtab_cb(void *data, const GElf_Sym *symp, const char *name, uint_t id) 439 { 440 nm_gelf_symtab_t *ngsp = data; 441 442 ngsp->ngs_si.sym_id = id; 443 444 return (ngsp->ngs_cb(ngsp->ngs_arg, symp, name, &ngsp->ngs_si, 445 ngsp->ngs_object)); 446 } 447 448 static void 449 nm_gelf_symtab_iter(mdb_gelf_symtab_t *gst, const char *object, uint_t table, 450 mdb_tgt_sym_f *cb, void *arg) 451 { 452 nm_gelf_symtab_t ngs; 453 454 ngs.ngs_cb = cb; 455 ngs.ngs_arg = arg; 456 457 ngs.ngs_si.sym_table = table; 458 ngs.ngs_object = object; 459 460 mdb_gelf_symtab_iter(gst, nm_gelf_symtab_cb, &ngs); 461 } 462 463 static int nm_symbol_iter(const char *, uint_t, uint_t, mdb_tgt_sym_f *, 464 nm_iter_info_t *); 465 466 /*ARGSUSED*/ 467 static int 468 nm_object_iter_cb(void *data, const mdb_map_t *mp, const char *name) 469 { 470 nm_object_iter_t *noip = data; 471 472 /* 473 * Since we're interating over all the objects in a target, 474 * don't return an error if we hit an object that we can't 475 * get symbol data for. 476 */ 477 if (nm_symbol_iter(name, noip->noi_which, noip->noi_type, 478 noip->noi_cb, noip->noi_niip) != 0) 479 mdb_warn("unable to dump symbol data for: %s\n", name); 480 return (0); 481 } 482 483 int 484 nm_symbol_iter(const char *object, uint_t which, uint_t type, 485 mdb_tgt_sym_f *cb, nm_iter_info_t *niip) 486 { 487 mdb_tgt_t *t = mdb.m_target; 488 489 if (object == MDB_TGT_OBJ_EVERY) { 490 nm_object_iter_t noi; 491 492 noi.noi_which = which; 493 noi.noi_type = type; 494 noi.noi_cb = cb; 495 noi.noi_niip = niip; 496 497 return (mdb_tgt_object_iter(t, nm_object_iter_cb, &noi)); 498 } 499 500 niip->nii_fp = mdb_tgt_name_to_ctf(t, object); 501 502 return (mdb_tgt_symbol_iter(t, object, which, type, cb, niip)); 503 } 504 505 /*ARGSUSED*/ 506 int 507 cmd_nm(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 508 { 509 enum { 510 NM_DYNSYM = 0x0001, /* -D (use dynsym) */ 511 NM_DEC = 0x0002, /* -d (decimal output) */ 512 NM_GLOBAL = 0x0004, /* -g (globals only) */ 513 NM_NOHDRS = 0x0008, /* -h (suppress header) */ 514 NM_OCT = 0x0010, /* -o (octal output) */ 515 NM_UNDEF = 0x0020, /* -u (undefs only) */ 516 NM_HEX = 0x0040, /* -x (hex output) */ 517 NM_SORT_NAME = 0x0080, /* -n (sort by name) */ 518 NM_SORT_VALUE = 0x0100, /* -v (sort by value) */ 519 NM_PRVSYM = 0x0200, /* -P (use private symtab) */ 520 NM_PRTASGN = 0x0400 /* -p (print in asgn syntax) */ 521 }; 522 523 mdb_subopt_t opt_fmt_opts[] = { 524 { NM_FMT_INDEX, "ndx" }, 525 { NM_FMT_VALUE, "val" }, 526 { NM_FMT_SIZE, "sz" }, 527 { NM_FMT_TYPE, "type" }, 528 { NM_FMT_BIND, "bind" }, 529 { NM_FMT_OTHER, "oth" }, 530 { NM_FMT_SHNDX, "shndx" }, 531 { NM_FMT_NAME, "name" }, 532 { NM_FMT_CTYPE, "ctype" }, 533 { NM_FMT_OBJECT, "obj" }, 534 { NM_FMT_CTFID, "ctfid" }, 535 { 0, NULL } 536 }; 537 538 mdb_subopt_t opt_type_opts[] = { 539 { NM_TYPE_NOTY, "noty" }, 540 { NM_TYPE_OBJT, "objt" }, 541 { NM_TYPE_FUNC, "func" }, 542 { NM_TYPE_SECT, "sect" }, 543 { NM_TYPE_FILE, "file" }, 544 { NM_TYPE_COMM, "comm" }, 545 { NM_TYPE_TLS, "tls" }, 546 { NM_TYPE_REGI, "regi" }, 547 { 0, NULL } 548 }; 549 550 uint_t optf = 0; 551 uint_t opt_fmt; 552 uint_t opt_types; 553 int i; 554 555 mdb_tgt_sym_f *callback; 556 uint_t which, type; 557 558 char *object = (char *)MDB_TGT_OBJ_EVERY; 559 int hwidth; 560 size_t nsyms = 0; 561 562 nm_sym_t *syms, *symp; 563 564 nm_iter_info_t nii; 565 566 /* default output columns */ 567 opt_fmt = NM_FMT_VALUE | NM_FMT_SIZE | NM_FMT_TYPE | NM_FMT_BIND | 568 NM_FMT_OTHER | NM_FMT_SHNDX | NM_FMT_NAME; 569 570 /* default output types */ 571 opt_types = NM_TYPE_NOTY | NM_TYPE_OBJT | NM_TYPE_FUNC | NM_TYPE_SECT | 572 NM_TYPE_FILE | NM_TYPE_COMM | NM_TYPE_TLS | NM_TYPE_REGI; 573 574 i = mdb_getopts(argc, argv, 575 'D', MDB_OPT_SETBITS, NM_DYNSYM, &optf, 576 'P', MDB_OPT_SETBITS, NM_PRVSYM, &optf, 577 'd', MDB_OPT_SETBITS, NM_DEC, &optf, 578 'g', MDB_OPT_SETBITS, NM_GLOBAL, &optf, 579 'h', MDB_OPT_SETBITS, NM_NOHDRS, &optf, 580 'n', MDB_OPT_SETBITS, NM_SORT_NAME, &optf, 581 'o', MDB_OPT_SETBITS, NM_OCT, &optf, 582 'p', MDB_OPT_SETBITS, NM_PRTASGN | NM_NOHDRS, &optf, 583 'u', MDB_OPT_SETBITS, NM_UNDEF, &optf, 584 'v', MDB_OPT_SETBITS, NM_SORT_VALUE, &optf, 585 'x', MDB_OPT_SETBITS, NM_HEX, &optf, 586 'f', MDB_OPT_SUBOPTS, opt_fmt_opts, &opt_fmt, 587 't', MDB_OPT_SUBOPTS, opt_type_opts, &opt_types, 588 NULL); 589 590 if (i != argc) { 591 if (flags & DCMD_ADDRSPEC) 592 return (DCMD_USAGE); 593 594 if (argc != 0 && (argc - i) == 1) { 595 if (argv[i].a_type != MDB_TYPE_STRING || 596 argv[i].a_un.a_str[0] == '-') 597 return (DCMD_USAGE); 598 else 599 object = (char *)argv[i].a_un.a_str; 600 } else 601 return (DCMD_USAGE); 602 } 603 604 if ((optf & (NM_DEC | NM_HEX | NM_OCT)) == 0) { 605 switch (mdb.m_radix) { 606 case 8: 607 optf |= NM_OCT; 608 break; 609 case 10: 610 optf |= NM_DEC; 611 break; 612 default: 613 optf |= NM_HEX; 614 } 615 } 616 617 switch (optf & (NM_DEC | NM_HEX | NM_OCT)) { 618 case NM_DEC: 619 #ifdef _LP64 620 nii.nii_pfmt = "%-20llu"; 621 nii.nii_ofmt = "%-5u"; 622 hwidth = 20; 623 #else 624 nii.nii_pfmt = "%-10llu"; 625 nii.nii_ofmt = "%-5u"; 626 hwidth = 10; 627 #endif 628 break; 629 case NM_HEX: 630 #ifdef _LP64 631 nii.nii_pfmt = "0x%016llx"; 632 nii.nii_ofmt = "0x%-3x"; 633 hwidth = 18; 634 #else 635 nii.nii_pfmt = "0x%08llx"; 636 nii.nii_ofmt = "0x%-3x"; 637 hwidth = 10; 638 #endif 639 break; 640 case NM_OCT: 641 #ifdef _LP64 642 nii.nii_pfmt = "%-22llo"; 643 nii.nii_ofmt = "%-5o"; 644 hwidth = 22; 645 #else 646 nii.nii_pfmt = "%-11llo"; 647 nii.nii_ofmt = "%-5o"; 648 hwidth = 11; 649 #endif 650 break; 651 default: 652 mdb_warn("-d/-o/-x options are mutually exclusive\n"); 653 return (DCMD_USAGE); 654 } 655 656 if (object != MDB_TGT_OBJ_EVERY && (optf & NM_PRVSYM)) { 657 mdb_warn("-P/object options are mutually exclusive\n"); 658 return (DCMD_USAGE); 659 } 660 661 if ((flags & DCMD_ADDRSPEC) && (optf & NM_PRVSYM)) { 662 mdb_warn("-P/address options are mutually exclusive\n"); 663 return (DCMD_USAGE); 664 } 665 666 if (!(optf & NM_NOHDRS)) { 667 mdb_printf("%<u>"); 668 mdb_table_print(opt_fmt, " ", 669 MDB_TBL_PRNT, NM_FMT_INDEX, "Index", 670 MDB_TBL_PRNT, NM_FMT_OBJECT, "%-15s", "Object", 671 MDB_TBL_PRNT, NM_FMT_VALUE, "%-*s", hwidth, "Value", 672 MDB_TBL_PRNT, NM_FMT_SIZE, "%-*s", hwidth, "Size", 673 MDB_TBL_PRNT, NM_FMT_TYPE, "%-5s", "Type", 674 MDB_TBL_PRNT, NM_FMT_BIND, "%-5s", "Bind", 675 MDB_TBL_PRNT, NM_FMT_OTHER, "%-5s", "Other", 676 MDB_TBL_PRNT, NM_FMT_SHNDX, "%-8s", "Shndx", 677 MDB_TBL_PRNT, NM_FMT_CTFID, "%-9s", "CTF ID", 678 MDB_TBL_PRNT, NM_FMT_CTYPE, "%-50s", "C Type", 679 MDB_TBL_PRNT, NM_FMT_NAME, "%s", "Name", 680 MDB_TBL_DONE); 681 682 mdb_printf("%</u>\n"); 683 } 684 685 nii.nii_flags = opt_fmt; 686 nii.nii_types = opt_types; 687 688 if (optf & NM_DYNSYM) 689 which = MDB_TGT_DYNSYM; 690 else 691 which = MDB_TGT_SYMTAB; 692 693 if (optf & NM_GLOBAL) 694 type = MDB_TGT_BIND_GLOBAL | MDB_TGT_TYPE_ANY; 695 else 696 type = MDB_TGT_BIND_ANY | MDB_TGT_TYPE_ANY; 697 698 if (flags & DCMD_ADDRSPEC) 699 optf |= NM_SORT_NAME; /* use sorting path if only one symbol */ 700 701 if (optf & (NM_SORT_NAME | NM_SORT_VALUE)) { 702 char name[MDB_SYM_NAMLEN]; 703 GElf_Sym sym; 704 mdb_syminfo_t si; 705 706 if (optf & NM_UNDEF) 707 callback = nm_cnt_undef; 708 else 709 callback = nm_cnt_any; 710 711 if (flags & DCMD_ADDRSPEC) { 712 const mdb_map_t *mp; 713 /* gather relevant data for the specified addr */ 714 715 nii.nii_fp = mdb_tgt_addr_to_ctf(mdb.m_target, addr); 716 717 if (mdb_tgt_lookup_by_addr(mdb.m_target, addr, 718 MDB_SYM_FUZZY, name, sizeof (name), &sym, 719 &si) == -1) { 720 mdb_warn("%lr", addr); 721 return (DCMD_ERR); 722 } 723 724 if ((mp = mdb_tgt_addr_to_map(mdb.m_target, addr)) 725 != NULL) { 726 object = mdb_alloc(strlen(mp->map_name) + 1, 727 UM_SLEEP | UM_GC); 728 729 (void) strcpy(object, mp->map_name); 730 731 /* 732 * Try to find a better match for the syminfo. 733 */ 734 (void) mdb_tgt_lookup_by_name(mdb.m_target, 735 object, name, &sym, &si); 736 } 737 738 (void) callback(&nsyms, &sym, name, &si, object); 739 740 } else if (optf & NM_PRVSYM) { 741 nsyms = mdb_gelf_symtab_size(mdb.m_prsym); 742 } else { 743 (void) mdb_tgt_symbol_iter(mdb.m_target, object, 744 which, type, callback, &nsyms); 745 } 746 747 if (nsyms == 0) 748 return (DCMD_OK); 749 750 syms = symp = mdb_alloc(sizeof (nm_sym_t) * nsyms, 751 UM_SLEEP | UM_GC); 752 753 nii.nii_sympp = &symp; 754 755 if (optf & NM_UNDEF) 756 callback = nm_get_undef; 757 else 758 callback = nm_get_any; 759 760 if (flags & DCMD_ADDRSPEC) { 761 (void) callback(&nii, &sym, name, &si, object); 762 } else if (optf & NM_PRVSYM) { 763 nm_gelf_symtab_iter(mdb.m_prsym, object, MDB_TGT_PRVSYM, 764 callback, &nii); 765 } else if (nm_symbol_iter(object, which, type, callback, 766 &nii) == -1) { 767 mdb_warn("failed to iterate over symbols"); 768 return (DCMD_ERR); 769 } 770 771 if (optf & NM_SORT_NAME) 772 qsort(syms, nsyms, sizeof (nm_sym_t), nm_compare_name); 773 else 774 qsort(syms, nsyms, sizeof (nm_sym_t), nm_compare_val); 775 } 776 777 if ((optf & (NM_PRVSYM | NM_PRTASGN)) == (NM_PRVSYM | NM_PRTASGN)) 778 callback = nm_asgn; 779 else if (optf & NM_UNDEF) 780 callback = nm_undef; 781 else 782 callback = nm_any; 783 784 if (optf & (NM_SORT_NAME | NM_SORT_VALUE)) { 785 for (symp = syms; nsyms-- != 0; symp++) { 786 nii.nii_fp = symp->nm_fp; 787 788 callback(&nii, &symp->nm_sym, symp->nm_name, 789 &symp->nm_si, symp->nm_object); 790 } 791 792 } else { 793 if (optf & NM_PRVSYM) { 794 nm_gelf_symtab_iter(mdb.m_prsym, object, MDB_TGT_PRVSYM, 795 callback, &nii); 796 797 } else if (nm_symbol_iter(object, which, type, callback, &nii) 798 == -1) { 799 mdb_warn("failed to iterate over symbols"); 800 return (DCMD_ERR); 801 } 802 } 803 804 return (DCMD_OK); 805 } 806 807 int 808 cmd_nmadd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 809 { 810 uintptr_t opt_e = 0, opt_s = 0; 811 uint_t opt_f = FALSE, opt_o = FALSE; 812 813 GElf_Sym sym; 814 int i; 815 816 if (!(flags & DCMD_ADDRSPEC)) 817 return (DCMD_USAGE); 818 819 i = mdb_getopts(argc, argv, 820 'f', MDB_OPT_SETBITS, TRUE, &opt_f, 821 'o', MDB_OPT_SETBITS, TRUE, &opt_o, 822 'e', MDB_OPT_UINTPTR, &opt_e, 823 's', MDB_OPT_UINTPTR, &opt_s, NULL); 824 825 if (i != (argc - 1) || argv[i].a_type != MDB_TYPE_STRING || 826 argv[i].a_un.a_str[0] == '-' || argv[i].a_un.a_str[0] == '+') 827 return (DCMD_USAGE); 828 829 if (opt_e && opt_e < addr) { 830 mdb_warn("end (%p) is less than start address (%p)\n", 831 (void *)opt_e, (void *)addr); 832 return (DCMD_USAGE); 833 } 834 835 if (mdb_gelf_symtab_lookup_by_name(mdb.m_prsym, 836 argv[i].a_un.a_str, &sym, NULL) == -1) { 837 bzero(&sym, sizeof (sym)); 838 sym.st_info = GELF_ST_INFO(STB_GLOBAL, STT_NOTYPE); 839 } 840 841 if (opt_f) 842 sym.st_info = GELF_ST_INFO(STB_GLOBAL, STT_FUNC); 843 if (opt_o) 844 sym.st_info = GELF_ST_INFO(STB_GLOBAL, STT_OBJECT); 845 if (opt_e) 846 sym.st_size = (GElf_Xword)(opt_e - addr); 847 if (opt_s) 848 sym.st_size = (GElf_Xword)(opt_s); 849 sym.st_value = (GElf_Addr)addr; 850 851 mdb_gelf_symtab_insert(mdb.m_prsym, argv[i].a_un.a_str, &sym); 852 853 mdb_iob_printf(mdb.m_out, "added %s, value=%llr size=%llr\n", 854 argv[i].a_un.a_str, sym.st_value, sym.st_size); 855 856 return (DCMD_OK); 857 } 858 859 /*ARGSUSED*/ 860 int 861 cmd_nmdel(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 862 { 863 const char *name; 864 GElf_Sym sym; 865 uint_t id; 866 867 if (argc != 1 || argv->a_type != MDB_TYPE_STRING || 868 argv->a_un.a_str[0] == '-' || (flags & DCMD_ADDRSPEC)) 869 return (DCMD_USAGE); 870 871 name = argv->a_un.a_str; 872 873 if (mdb_gelf_symtab_lookup_by_name(mdb.m_prsym, name, &sym, &id) == 0) { 874 mdb_gelf_symtab_delete(mdb.m_prsym, name, &sym); 875 mdb_printf("deleted %s, value=%llr size=%llr\n", 876 name, sym.st_value, sym.st_size); 877 return (DCMD_OK); 878 } 879 880 mdb_warn("symbol '%s' not found in private symbol table\n", name); 881 return (DCMD_ERR); 882 } 883 884 void 885 nm_help(void) 886 { 887 mdb_printf("-D print .dynsym instead of .symtab\n" 888 "-P print private symbol table instead of .symtab\n" 889 "-d print value and size in decimal\n" 890 "-g only print global symbols\n" 891 "-h suppress header line\n" 892 "-n sort symbols by name\n" 893 "-o print value and size in octal\n" 894 "-p print symbols as a series of ::nmadd commands\n" 895 "-u only print undefined symbols\n" 896 "-v sort symbols by value\n" 897 "-x print value and size in hexadecimal\n" 898 "-f format use specified format\n" 899 " ndx, val, sz, type, bind, oth, shndx, " 900 "name, ctype, obj\n" 901 "-t types display symbols with the specified types\n" 902 " noty, objt, func, sect, file, regi\n" 903 "obj specify object whose symbol table should be used\n"); 904 } 905 906 void 907 nmadd_help(void) 908 { 909 mdb_printf("-f set type of symbol to STT_FUNC\n" 910 "-o set type of symbol to STT_OBJECT\n" 911 "-e end set size of symbol to end - start address\n" 912 "-s size set size of symbol to explicit value\n" 913 "name specify symbol name to add\n"); 914 } 915