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 /* 23 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2013, Joyent, Inc. All rights reserved. 25 */ 26 27 #include <assert.h> 28 #include <stdio.h> 29 #include <stdlib.h> 30 #include <stddef.h> 31 #include <unistd.h> 32 #include <ctype.h> 33 #include <fcntl.h> 34 #include <string.h> 35 #include <strings.h> 36 #include <memory.h> 37 #include <errno.h> 38 #include <dirent.h> 39 #include <signal.h> 40 #include <limits.h> 41 #include <libgen.h> 42 #include <sys/types.h> 43 #include <sys/stat.h> 44 #include <sys/systeminfo.h> 45 #include <sys/sysmacros.h> 46 47 #include "libproc.h" 48 #include "Pcontrol.h" 49 #include "Putil.h" 50 #include "Psymtab_machelf.h" 51 52 static file_info_t *build_map_symtab(struct ps_prochandle *, map_info_t *); 53 static map_info_t *exec_map(struct ps_prochandle *); 54 static map_info_t *object_to_map(struct ps_prochandle *, Lmid_t, const char *); 55 static map_info_t *object_name_to_map(struct ps_prochandle *, 56 Lmid_t, const char *); 57 static GElf_Sym *sym_by_name(sym_tbl_t *, const char *, GElf_Sym *, uint_t *); 58 static int read_ehdr32(struct ps_prochandle *, Elf32_Ehdr *, uint_t *, 59 uintptr_t); 60 #ifdef _LP64 61 static int read_ehdr64(struct ps_prochandle *, Elf64_Ehdr *, uint_t *, 62 uintptr_t); 63 #endif 64 65 #define DATA_TYPES \ 66 ((1 << STT_OBJECT) | (1 << STT_FUNC) | \ 67 (1 << STT_COMMON) | (1 << STT_TLS)) 68 #define IS_DATA_TYPE(tp) (((1 << (tp)) & DATA_TYPES) != 0) 69 70 #define MA_RWX (MA_READ | MA_WRITE | MA_EXEC) 71 72 typedef enum { 73 PRO_NATURAL, 74 PRO_BYADDR, 75 PRO_BYNAME 76 } pr_order_t; 77 78 static int 79 addr_cmp(const void *aa, const void *bb) 80 { 81 uintptr_t a = *((uintptr_t *)aa); 82 uintptr_t b = *((uintptr_t *)bb); 83 84 if (a > b) 85 return (1); 86 if (a < b) 87 return (-1); 88 return (0); 89 } 90 91 /* 92 * This function creates a list of addresses for a load object's sections. 93 * The list is in ascending address order and alternates start address 94 * then end address for each section we're interested in. The function 95 * returns a pointer to the list, which must be freed by the caller. 96 */ 97 static uintptr_t * 98 get_saddrs(struct ps_prochandle *P, uintptr_t ehdr_start, uint_t *n) 99 { 100 uintptr_t a, addr, *addrs, last = 0; 101 uint_t i, naddrs = 0, unordered = 0; 102 103 if (P->status.pr_dmodel == PR_MODEL_ILP32) { 104 Elf32_Ehdr ehdr; 105 Elf32_Phdr phdr; 106 uint_t phnum; 107 108 if (read_ehdr32(P, &ehdr, &phnum, ehdr_start) != 0) 109 return (NULL); 110 111 addrs = malloc(sizeof (uintptr_t) * phnum * 2); 112 a = ehdr_start + ehdr.e_phoff; 113 for (i = 0; i < phnum; i++, a += ehdr.e_phentsize) { 114 if (Pread(P, &phdr, sizeof (phdr), a) != 115 sizeof (phdr)) { 116 free(addrs); 117 return (NULL); 118 } 119 if (phdr.p_type != PT_LOAD || phdr.p_memsz == 0) 120 continue; 121 122 addr = phdr.p_vaddr; 123 if (ehdr.e_type == ET_DYN) 124 addr += ehdr_start; 125 if (last > addr) 126 unordered = 1; 127 addrs[naddrs++] = addr; 128 addrs[naddrs++] = last = addr + phdr.p_memsz - 1; 129 } 130 #ifdef _LP64 131 } else { 132 Elf64_Ehdr ehdr; 133 Elf64_Phdr phdr; 134 uint_t phnum; 135 136 if (read_ehdr64(P, &ehdr, &phnum, ehdr_start) != 0) 137 return (NULL); 138 139 addrs = malloc(sizeof (uintptr_t) * phnum * 2); 140 a = ehdr_start + ehdr.e_phoff; 141 for (i = 0; i < phnum; i++, a += ehdr.e_phentsize) { 142 if (Pread(P, &phdr, sizeof (phdr), a) != 143 sizeof (phdr)) { 144 free(addrs); 145 return (NULL); 146 } 147 if (phdr.p_type != PT_LOAD || phdr.p_memsz == 0) 148 continue; 149 150 addr = phdr.p_vaddr; 151 if (ehdr.e_type == ET_DYN) 152 addr += ehdr_start; 153 if (last > addr) 154 unordered = 1; 155 addrs[naddrs++] = addr; 156 addrs[naddrs++] = last = addr + phdr.p_memsz - 1; 157 } 158 #endif 159 } 160 161 if (unordered) 162 qsort(addrs, naddrs, sizeof (uintptr_t), addr_cmp); 163 164 *n = naddrs; 165 return (addrs); 166 } 167 168 /* 169 * Allocation function for a new file_info_t 170 */ 171 file_info_t * 172 file_info_new(struct ps_prochandle *P, map_info_t *mptr) 173 { 174 file_info_t *fptr; 175 map_info_t *mp; 176 uintptr_t mstart, mend, sstart, send; 177 uint_t i; 178 179 if ((fptr = calloc(1, sizeof (file_info_t))) == NULL) 180 return (NULL); 181 182 list_link(fptr, &P->file_head); 183 (void) strcpy(fptr->file_pname, mptr->map_pmap.pr_mapname); 184 mptr->map_file = fptr; 185 fptr->file_ref = 1; 186 fptr->file_fd = -1; 187 P->num_files++; 188 189 /* 190 * To figure out which map_info_t instances correspond to the mappings 191 * for this load object we try to obtain the start and end address 192 * for each section of our in-memory ELF image. If successful, we 193 * walk down the list of addresses and the list of map_info_t 194 * instances in lock step to correctly find the mappings that 195 * correspond to this load object. 196 */ 197 if ((fptr->file_saddrs = get_saddrs(P, mptr->map_pmap.pr_vaddr, 198 &fptr->file_nsaddrs)) == NULL) 199 return (fptr); 200 201 mp = P->mappings; 202 i = 0; 203 while (mp < P->mappings + P->map_count && i < fptr->file_nsaddrs) { 204 205 /* Calculate the start and end of the mapping and section */ 206 mstart = mp->map_pmap.pr_vaddr; 207 mend = mp->map_pmap.pr_vaddr + mp->map_pmap.pr_size; 208 sstart = fptr->file_saddrs[i]; 209 send = fptr->file_saddrs[i + 1]; 210 211 if (mend <= sstart) { 212 /* This mapping is below the current section */ 213 mp++; 214 } else if (mstart >= send) { 215 /* This mapping is above the current section */ 216 i += 2; 217 } else { 218 /* This mapping overlaps the current section */ 219 if (mp->map_file == NULL) { 220 dprintf("file_info_new: associating " 221 "segment at %p\n", 222 (void *)mp->map_pmap.pr_vaddr); 223 mp->map_file = fptr; 224 fptr->file_ref++; 225 } else { 226 dprintf("file_info_new: segment at %p " 227 "already associated with %s\n", 228 (void *)mp->map_pmap.pr_vaddr, 229 (mp == mptr ? "this file" : 230 mp->map_file->file_pname)); 231 } 232 mp++; 233 } 234 } 235 236 return (fptr); 237 } 238 239 /* 240 * Deallocation function for a file_info_t 241 */ 242 static void 243 file_info_free(struct ps_prochandle *P, file_info_t *fptr) 244 { 245 if (--fptr->file_ref == 0) { 246 list_unlink(fptr); 247 if (fptr->file_symtab.sym_elf) { 248 (void) elf_end(fptr->file_symtab.sym_elf); 249 free(fptr->file_symtab.sym_elfmem); 250 } 251 if (fptr->file_symtab.sym_byname) 252 free(fptr->file_symtab.sym_byname); 253 if (fptr->file_symtab.sym_byaddr) 254 free(fptr->file_symtab.sym_byaddr); 255 256 if (fptr->file_dynsym.sym_elf) { 257 (void) elf_end(fptr->file_dynsym.sym_elf); 258 free(fptr->file_dynsym.sym_elfmem); 259 } 260 if (fptr->file_dynsym.sym_byname) 261 free(fptr->file_dynsym.sym_byname); 262 if (fptr->file_dynsym.sym_byaddr) 263 free(fptr->file_dynsym.sym_byaddr); 264 265 if (fptr->file_lo) 266 free(fptr->file_lo); 267 if (fptr->file_lname) 268 free(fptr->file_lname); 269 if (fptr->file_rname) 270 free(fptr->file_rname); 271 if (fptr->file_elf) 272 (void) elf_end(fptr->file_elf); 273 if (fptr->file_elfmem != NULL) 274 free(fptr->file_elfmem); 275 if (fptr->file_fd >= 0) 276 (void) close(fptr->file_fd); 277 if (fptr->file_ctfp) { 278 ctf_close(fptr->file_ctfp); 279 free(fptr->file_ctf_buf); 280 } 281 if (fptr->file_saddrs) 282 free(fptr->file_saddrs); 283 free(fptr); 284 P->num_files--; 285 } 286 } 287 288 /* 289 * Deallocation function for a map_info_t 290 */ 291 static void 292 map_info_free(struct ps_prochandle *P, map_info_t *mptr) 293 { 294 file_info_t *fptr; 295 296 if ((fptr = mptr->map_file) != NULL) { 297 if (fptr->file_map == mptr) 298 fptr->file_map = NULL; 299 file_info_free(P, fptr); 300 } 301 if (P->execname && mptr == P->map_exec) { 302 free(P->execname); 303 P->execname = NULL; 304 } 305 if (P->auxv && (mptr == P->map_exec || mptr == P->map_ldso)) { 306 free(P->auxv); 307 P->auxv = NULL; 308 P->nauxv = 0; 309 } 310 if (mptr == P->map_exec) 311 P->map_exec = NULL; 312 if (mptr == P->map_ldso) 313 P->map_ldso = NULL; 314 } 315 316 /* 317 * Call-back function for librtld_db to iterate through all of its shared 318 * libraries. We use this to get the load object names for the mappings. 319 */ 320 static int 321 map_iter(const rd_loadobj_t *lop, void *cd) 322 { 323 char buf[PATH_MAX]; 324 struct ps_prochandle *P = cd; 325 map_info_t *mptr; 326 file_info_t *fptr; 327 328 dprintf("encountered rd object at %p\n", (void *)lop->rl_base); 329 330 if ((mptr = Paddr2mptr(P, lop->rl_base)) == NULL) { 331 dprintf("map_iter: base address doesn't match any mapping\n"); 332 return (1); /* Base address does not match any mapping */ 333 } 334 335 if ((fptr = mptr->map_file) == NULL && 336 (fptr = file_info_new(P, mptr)) == NULL) { 337 dprintf("map_iter: failed to allocate a new file_info_t\n"); 338 return (1); /* Failed to allocate a new file_info_t */ 339 } 340 341 if ((fptr->file_lo == NULL) && 342 (fptr->file_lo = malloc(sizeof (rd_loadobj_t))) == NULL) { 343 dprintf("map_iter: failed to allocate rd_loadobj_t\n"); 344 file_info_free(P, fptr); 345 return (1); /* Failed to allocate rd_loadobj_t */ 346 } 347 348 fptr->file_map = mptr; 349 *fptr->file_lo = *lop; 350 351 fptr->file_lo->rl_plt_base = fptr->file_plt_base; 352 fptr->file_lo->rl_plt_size = fptr->file_plt_size; 353 354 if (fptr->file_lname) { 355 free(fptr->file_lname); 356 fptr->file_lname = NULL; 357 fptr->file_lbase = NULL; 358 } 359 if (fptr->file_rname) { 360 free(fptr->file_rname); 361 fptr->file_rname = NULL; 362 fptr->file_rbase = NULL; 363 } 364 365 if (Pread_string(P, buf, sizeof (buf), lop->rl_nameaddr) > 0) { 366 if ((fptr->file_lname = strdup(buf)) != NULL) 367 fptr->file_lbase = basename(fptr->file_lname); 368 } else { 369 dprintf("map_iter: failed to read string at %p\n", 370 (void *)lop->rl_nameaddr); 371 } 372 373 if ((Pfindmap(P, mptr, buf, sizeof (buf)) != NULL) && 374 ((fptr->file_rname = strdup(buf)) != NULL)) 375 fptr->file_rbase = basename(fptr->file_rname); 376 377 dprintf("loaded rd object %s lmid %lx\n", 378 fptr->file_lname ? buf : "<NULL>", lop->rl_lmident); 379 return (1); 380 } 381 382 static void 383 map_set(struct ps_prochandle *P, map_info_t *mptr, const char *lname) 384 { 385 file_info_t *fptr; 386 char buf[PATH_MAX]; 387 388 if ((fptr = mptr->map_file) == NULL && 389 (fptr = file_info_new(P, mptr)) == NULL) 390 return; /* Failed to allocate a new file_info_t */ 391 392 fptr->file_map = mptr; 393 394 if ((fptr->file_lo == NULL) && 395 (fptr->file_lo = malloc(sizeof (rd_loadobj_t))) == NULL) { 396 file_info_free(P, fptr); 397 return; /* Failed to allocate rd_loadobj_t */ 398 } 399 400 (void) memset(fptr->file_lo, 0, sizeof (rd_loadobj_t)); 401 fptr->file_lo->rl_base = mptr->map_pmap.pr_vaddr; 402 fptr->file_lo->rl_bend = 403 mptr->map_pmap.pr_vaddr + mptr->map_pmap.pr_size; 404 405 fptr->file_lo->rl_plt_base = fptr->file_plt_base; 406 fptr->file_lo->rl_plt_size = fptr->file_plt_size; 407 408 if ((fptr->file_lname == NULL) && 409 (fptr->file_lname = strdup(lname)) != NULL) 410 fptr->file_lbase = basename(fptr->file_lname); 411 412 if ((Pfindmap(P, mptr, buf, sizeof (buf)) != NULL) && 413 ((fptr->file_rname = strdup(buf)) != NULL)) 414 fptr->file_rbase = basename(fptr->file_rname); 415 } 416 417 static void 418 load_static_maps(struct ps_prochandle *P) 419 { 420 map_info_t *mptr; 421 422 /* 423 * Construct the map for the a.out. 424 */ 425 if ((mptr = object_name_to_map(P, PR_LMID_EVERY, PR_OBJ_EXEC)) != NULL) 426 map_set(P, mptr, "a.out"); 427 428 /* 429 * If the dynamic linker exists for this process, 430 * construct the map for it. 431 */ 432 if (Pgetauxval(P, AT_BASE) != -1L && 433 (mptr = object_name_to_map(P, PR_LMID_EVERY, PR_OBJ_LDSO)) != NULL) 434 map_set(P, mptr, "ld.so.1"); 435 } 436 437 /* 438 * Go through all the address space mappings, validating or updating 439 * the information already gathered, or gathering new information. 440 * 441 * This function is only called when we suspect that the mappings have changed 442 * because this is the first time we're calling it or because of rtld activity. 443 */ 444 void 445 Pupdate_maps(struct ps_prochandle *P) 446 { 447 char mapfile[PATH_MAX]; 448 int mapfd; 449 struct stat statb; 450 prmap_t *Pmap = NULL; 451 prmap_t *pmap; 452 ssize_t nmap; 453 int i; 454 uint_t oldmapcount; 455 map_info_t *newmap, *newp; 456 map_info_t *mptr; 457 458 if (P->info_valid || P->state == PS_UNDEAD) 459 return; 460 461 Preadauxvec(P); 462 463 (void) snprintf(mapfile, sizeof (mapfile), "%s/%d/map", 464 procfs_path, (int)P->pid); 465 if ((mapfd = open(mapfile, O_RDONLY)) < 0 || 466 fstat(mapfd, &statb) != 0 || 467 statb.st_size < sizeof (prmap_t) || 468 (Pmap = malloc(statb.st_size)) == NULL || 469 (nmap = pread(mapfd, Pmap, statb.st_size, 0L)) <= 0 || 470 (nmap /= sizeof (prmap_t)) == 0) { 471 if (Pmap != NULL) 472 free(Pmap); 473 if (mapfd >= 0) 474 (void) close(mapfd); 475 Preset_maps(P); /* utter failure; destroy tables */ 476 return; 477 } 478 (void) close(mapfd); 479 480 if ((newmap = calloc(1, nmap * sizeof (map_info_t))) == NULL) 481 return; 482 483 /* 484 * We try to merge any file information we may have for existing 485 * mappings, to avoid having to rebuild the file info. 486 */ 487 mptr = P->mappings; 488 pmap = Pmap; 489 newp = newmap; 490 oldmapcount = P->map_count; 491 for (i = 0; i < nmap; i++, pmap++, newp++) { 492 493 if (oldmapcount == 0) { 494 /* 495 * We've exhausted all the old mappings. Every new 496 * mapping should be added. 497 */ 498 newp->map_pmap = *pmap; 499 500 } else if (pmap->pr_vaddr == mptr->map_pmap.pr_vaddr && 501 pmap->pr_size == mptr->map_pmap.pr_size && 502 pmap->pr_offset == mptr->map_pmap.pr_offset && 503 (pmap->pr_mflags & ~(MA_BREAK | MA_STACK)) == 504 (mptr->map_pmap.pr_mflags & ~(MA_BREAK | MA_STACK)) && 505 pmap->pr_pagesize == mptr->map_pmap.pr_pagesize && 506 pmap->pr_shmid == mptr->map_pmap.pr_shmid && 507 strcmp(pmap->pr_mapname, mptr->map_pmap.pr_mapname) == 0) { 508 509 /* 510 * This mapping matches exactly. Copy over the old 511 * mapping, taking care to get the latest flags. 512 * Make sure the associated file_info_t is updated 513 * appropriately. 514 */ 515 *newp = *mptr; 516 if (P->map_exec == mptr) 517 P->map_exec = newp; 518 if (P->map_ldso == mptr) 519 P->map_ldso = newp; 520 newp->map_pmap.pr_mflags = pmap->pr_mflags; 521 if (mptr->map_file != NULL && 522 mptr->map_file->file_map == mptr) 523 mptr->map_file->file_map = newp; 524 oldmapcount--; 525 mptr++; 526 527 } else if (pmap->pr_vaddr + pmap->pr_size > 528 mptr->map_pmap.pr_vaddr) { 529 530 /* 531 * The old mapping doesn't exist any more, remove it 532 * from the list. 533 */ 534 map_info_free(P, mptr); 535 oldmapcount--; 536 i--; 537 newp--; 538 pmap--; 539 mptr++; 540 541 } else { 542 543 /* 544 * This is a new mapping, add it directly. 545 */ 546 newp->map_pmap = *pmap; 547 } 548 } 549 550 /* 551 * Free any old maps 552 */ 553 while (oldmapcount) { 554 map_info_free(P, mptr); 555 oldmapcount--; 556 mptr++; 557 } 558 559 free(Pmap); 560 if (P->mappings != NULL) 561 free(P->mappings); 562 P->mappings = newmap; 563 P->map_count = P->map_alloc = nmap; 564 P->info_valid = 1; 565 566 /* 567 * Consult librtld_db to get the load object 568 * names for all of the shared libraries. 569 */ 570 if (P->rap != NULL) 571 (void) rd_loadobj_iter(P->rap, map_iter, P); 572 } 573 574 /* 575 * Update all of the mappings and rtld_db as if by Pupdate_maps(), and then 576 * forcibly cache all of the symbol tables associated with all object files. 577 */ 578 void 579 Pupdate_syms(struct ps_prochandle *P) 580 { 581 file_info_t *fptr; 582 int i; 583 584 Pupdate_maps(P); 585 586 for (i = 0, fptr = list_next(&P->file_head); i < P->num_files; 587 i++, fptr = list_next(fptr)) { 588 Pbuild_file_symtab(P, fptr); 589 (void) Pbuild_file_ctf(P, fptr); 590 } 591 } 592 593 /* 594 * Return the librtld_db agent handle for the victim process. 595 * The handle will become invalid at the next successful exec() and the 596 * client (caller of proc_rd_agent()) must not use it beyond that point. 597 * If the process is already dead, we've already tried our best to 598 * create the agent during core file initialization. 599 */ 600 rd_agent_t * 601 Prd_agent(struct ps_prochandle *P) 602 { 603 if (P->rap == NULL && P->state != PS_DEAD && P->state != PS_IDLE) { 604 Pupdate_maps(P); 605 if (P->num_files == 0) 606 load_static_maps(P); 607 rd_log(_libproc_debug); 608 if ((P->rap = rd_new(P)) != NULL) 609 (void) rd_loadobj_iter(P->rap, map_iter, P); 610 } 611 return (P->rap); 612 } 613 614 /* 615 * Return the prmap_t structure containing 'addr', but only if it 616 * is in the dynamic linker's link map and is the text section. 617 */ 618 const prmap_t * 619 Paddr_to_text_map(struct ps_prochandle *P, uintptr_t addr) 620 { 621 map_info_t *mptr; 622 623 if (!P->info_valid) 624 Pupdate_maps(P); 625 626 if ((mptr = Paddr2mptr(P, addr)) != NULL) { 627 file_info_t *fptr = build_map_symtab(P, mptr); 628 const prmap_t *pmp = &mptr->map_pmap; 629 630 /* 631 * Assume that if rl_data_base is NULL, it means that no 632 * data section was found for this load object, and that 633 * a section must be text. Otherwise, a section will be 634 * text unless it ends above the start of the data 635 * section. 636 */ 637 if (fptr != NULL && fptr->file_lo != NULL && 638 (fptr->file_lo->rl_data_base == NULL || 639 pmp->pr_vaddr + pmp->pr_size <= 640 fptr->file_lo->rl_data_base)) 641 return (pmp); 642 } 643 644 return (NULL); 645 } 646 647 /* 648 * Return the prmap_t structure containing 'addr' (no restrictions on 649 * the type of mapping). 650 */ 651 const prmap_t * 652 Paddr_to_map(struct ps_prochandle *P, uintptr_t addr) 653 { 654 map_info_t *mptr; 655 656 if (!P->info_valid) 657 Pupdate_maps(P); 658 659 if ((mptr = Paddr2mptr(P, addr)) != NULL) 660 return (&mptr->map_pmap); 661 662 return (NULL); 663 } 664 665 /* 666 * Convert a full or partial load object name to the prmap_t for its 667 * corresponding primary text mapping. 668 */ 669 const prmap_t * 670 Plmid_to_map(struct ps_prochandle *P, Lmid_t lmid, const char *name) 671 { 672 map_info_t *mptr; 673 674 if (name == PR_OBJ_EVERY) 675 return (NULL); /* A reasonable mistake */ 676 677 if ((mptr = object_name_to_map(P, lmid, name)) != NULL) 678 return (&mptr->map_pmap); 679 680 return (NULL); 681 } 682 683 const prmap_t * 684 Pname_to_map(struct ps_prochandle *P, const char *name) 685 { 686 return (Plmid_to_map(P, PR_LMID_EVERY, name)); 687 } 688 689 const rd_loadobj_t * 690 Paddr_to_loadobj(struct ps_prochandle *P, uintptr_t addr) 691 { 692 map_info_t *mptr; 693 694 if (!P->info_valid) 695 Pupdate_maps(P); 696 697 if ((mptr = Paddr2mptr(P, addr)) == NULL) 698 return (NULL); 699 700 /* 701 * By building the symbol table, we implicitly bring the PLT 702 * information up to date in the load object. 703 */ 704 (void) build_map_symtab(P, mptr); 705 706 return (mptr->map_file->file_lo); 707 } 708 709 const rd_loadobj_t * 710 Plmid_to_loadobj(struct ps_prochandle *P, Lmid_t lmid, const char *name) 711 { 712 map_info_t *mptr; 713 714 if (name == PR_OBJ_EVERY) 715 return (NULL); 716 717 if ((mptr = object_name_to_map(P, lmid, name)) == NULL) 718 return (NULL); 719 720 /* 721 * By building the symbol table, we implicitly bring the PLT 722 * information up to date in the load object. 723 */ 724 (void) build_map_symtab(P, mptr); 725 726 return (mptr->map_file->file_lo); 727 } 728 729 const rd_loadobj_t * 730 Pname_to_loadobj(struct ps_prochandle *P, const char *name) 731 { 732 return (Plmid_to_loadobj(P, PR_LMID_EVERY, name)); 733 } 734 735 ctf_file_t * 736 Pbuild_file_ctf(struct ps_prochandle *P, file_info_t *fptr) 737 { 738 ctf_sect_t ctdata, symtab, strtab; 739 sym_tbl_t *symp; 740 int err; 741 742 if (fptr->file_ctfp != NULL) 743 return (fptr->file_ctfp); 744 745 Pbuild_file_symtab(P, fptr); 746 747 if (fptr->file_ctf_size == 0) 748 return (NULL); 749 750 symp = fptr->file_ctf_dyn ? &fptr->file_dynsym : &fptr->file_symtab; 751 if (symp->sym_data_pri == NULL) 752 return (NULL); 753 754 /* 755 * The buffer may alread be allocated if this is a core file that 756 * contained CTF data for this file. 757 */ 758 if (fptr->file_ctf_buf == NULL) { 759 fptr->file_ctf_buf = malloc(fptr->file_ctf_size); 760 if (fptr->file_ctf_buf == NULL) { 761 dprintf("failed to allocate ctf buffer\n"); 762 return (NULL); 763 } 764 765 if (pread(fptr->file_fd, fptr->file_ctf_buf, 766 fptr->file_ctf_size, fptr->file_ctf_off) != 767 fptr->file_ctf_size) { 768 free(fptr->file_ctf_buf); 769 fptr->file_ctf_buf = NULL; 770 dprintf("failed to read ctf data\n"); 771 return (NULL); 772 } 773 } 774 775 ctdata.cts_name = ".SUNW_ctf"; 776 ctdata.cts_type = SHT_PROGBITS; 777 ctdata.cts_flags = 0; 778 ctdata.cts_data = fptr->file_ctf_buf; 779 ctdata.cts_size = fptr->file_ctf_size; 780 ctdata.cts_entsize = 1; 781 ctdata.cts_offset = 0; 782 783 symtab.cts_name = fptr->file_ctf_dyn ? ".dynsym" : ".symtab"; 784 symtab.cts_type = symp->sym_hdr_pri.sh_type; 785 symtab.cts_flags = symp->sym_hdr_pri.sh_flags; 786 symtab.cts_data = symp->sym_data_pri->d_buf; 787 symtab.cts_size = symp->sym_hdr_pri.sh_size; 788 symtab.cts_entsize = symp->sym_hdr_pri.sh_entsize; 789 symtab.cts_offset = symp->sym_hdr_pri.sh_offset; 790 791 strtab.cts_name = fptr->file_ctf_dyn ? ".dynstr" : ".strtab"; 792 strtab.cts_type = symp->sym_strhdr.sh_type; 793 strtab.cts_flags = symp->sym_strhdr.sh_flags; 794 strtab.cts_data = symp->sym_strs; 795 strtab.cts_size = symp->sym_strhdr.sh_size; 796 strtab.cts_entsize = symp->sym_strhdr.sh_entsize; 797 strtab.cts_offset = symp->sym_strhdr.sh_offset; 798 799 fptr->file_ctfp = ctf_bufopen(&ctdata, &symtab, &strtab, &err); 800 if (fptr->file_ctfp == NULL) { 801 dprintf("ctf_bufopen() failed, error code %d\n", err); 802 free(fptr->file_ctf_buf); 803 fptr->file_ctf_buf = NULL; 804 return (NULL); 805 } 806 807 dprintf("loaded %lu bytes of CTF data for %s\n", 808 (ulong_t)fptr->file_ctf_size, fptr->file_pname); 809 810 return (fptr->file_ctfp); 811 } 812 813 ctf_file_t * 814 Paddr_to_ctf(struct ps_prochandle *P, uintptr_t addr) 815 { 816 map_info_t *mptr; 817 file_info_t *fptr; 818 819 if (!P->info_valid) 820 Pupdate_maps(P); 821 822 if ((mptr = Paddr2mptr(P, addr)) == NULL || 823 (fptr = mptr->map_file) == NULL) 824 return (NULL); 825 826 return (Pbuild_file_ctf(P, fptr)); 827 } 828 829 ctf_file_t * 830 Plmid_to_ctf(struct ps_prochandle *P, Lmid_t lmid, const char *name) 831 { 832 map_info_t *mptr; 833 file_info_t *fptr; 834 835 if (name == PR_OBJ_EVERY) 836 return (NULL); 837 838 if ((mptr = object_name_to_map(P, lmid, name)) == NULL || 839 (fptr = mptr->map_file) == NULL) 840 return (NULL); 841 842 return (Pbuild_file_ctf(P, fptr)); 843 } 844 845 ctf_file_t * 846 Pname_to_ctf(struct ps_prochandle *P, const char *name) 847 { 848 return (Plmid_to_ctf(P, PR_LMID_EVERY, name)); 849 } 850 851 /* 852 * If we're not a core file, re-read the /proc/<pid>/auxv file and store 853 * its contents in P->auxv. In the case of a core file, we either 854 * initialized P->auxv in Pcore() from the NT_AUXV, or we don't have an 855 * auxv because the note was missing. 856 */ 857 void 858 Preadauxvec(struct ps_prochandle *P) 859 { 860 char auxfile[64]; 861 struct stat statb; 862 ssize_t naux; 863 int fd; 864 865 if (P->state == PS_DEAD) 866 return; /* Already read during Pgrab_core() */ 867 if (P->state == PS_IDLE) 868 return; /* No aux vec for Pgrab_file() */ 869 870 if (P->auxv != NULL) { 871 free(P->auxv); 872 P->auxv = NULL; 873 P->nauxv = 0; 874 } 875 876 (void) snprintf(auxfile, sizeof (auxfile), "%s/%d/auxv", 877 procfs_path, (int)P->pid); 878 if ((fd = open(auxfile, O_RDONLY)) < 0) 879 return; 880 881 if (fstat(fd, &statb) == 0 && 882 statb.st_size >= sizeof (auxv_t) && 883 (P->auxv = malloc(statb.st_size + sizeof (auxv_t))) != NULL) { 884 if ((naux = read(fd, P->auxv, statb.st_size)) < 0 || 885 (naux /= sizeof (auxv_t)) < 1) { 886 free(P->auxv); 887 P->auxv = NULL; 888 } else { 889 P->auxv[naux].a_type = AT_NULL; 890 P->auxv[naux].a_un.a_val = 0L; 891 P->nauxv = (int)naux; 892 } 893 } 894 895 (void) close(fd); 896 } 897 898 /* 899 * Return a requested element from the process's aux vector. 900 * Return -1 on failure (this is adequate for our purposes). 901 */ 902 long 903 Pgetauxval(struct ps_prochandle *P, int type) 904 { 905 auxv_t *auxv; 906 907 if (P->auxv == NULL) 908 Preadauxvec(P); 909 910 if (P->auxv == NULL) 911 return (-1); 912 913 for (auxv = P->auxv; auxv->a_type != AT_NULL; auxv++) { 914 if (auxv->a_type == type) 915 return (auxv->a_un.a_val); 916 } 917 918 return (-1); 919 } 920 921 /* 922 * Return a pointer to our internal copy of the process's aux vector. 923 * The caller should not hold on to this pointer across any libproc calls. 924 */ 925 const auxv_t * 926 Pgetauxvec(struct ps_prochandle *P) 927 { 928 static const auxv_t empty = { AT_NULL, 0L }; 929 930 if (P->auxv == NULL) 931 Preadauxvec(P); 932 933 if (P->auxv == NULL) 934 return (&empty); 935 936 return (P->auxv); 937 } 938 939 /* 940 * Return 1 if the given mapping corresponds to the given file_info_t's 941 * load object; return 0 otherwise. 942 */ 943 static int 944 is_mapping_in_file(struct ps_prochandle *P, map_info_t *mptr, file_info_t *fptr) 945 { 946 prmap_t *pmap = &mptr->map_pmap; 947 rd_loadobj_t *lop = fptr->file_lo; 948 uint_t i; 949 uintptr_t mstart, mend, sstart, send; 950 951 /* 952 * We can get for free the start address of the text and data 953 * sections of the load object. Start by seeing if the mapping 954 * encloses either of these. 955 */ 956 if ((pmap->pr_vaddr <= lop->rl_base && 957 lop->rl_base < pmap->pr_vaddr + pmap->pr_size) || 958 (pmap->pr_vaddr <= lop->rl_data_base && 959 lop->rl_data_base < pmap->pr_vaddr + pmap->pr_size)) 960 return (1); 961 962 /* 963 * It's still possible that this mapping correponds to the load 964 * object. Consider the example of a mapping whose start and end 965 * addresses correspond to those of the load object's text section. 966 * If the mapping splits, e.g. as a result of a segment demotion, 967 * then although both mappings are still backed by the same section, 968 * only one will be seen to enclose that section's start address. 969 * Thus, to be rigorous, we ask not whether this mapping encloses 970 * the start of a section, but whether there exists a section that 971 * overlaps this mapping. 972 * 973 * If we don't already have the section addresses, and we successfully 974 * get them, then we cache them in case we come here again. 975 */ 976 if (fptr->file_saddrs == NULL && 977 (fptr->file_saddrs = get_saddrs(P, 978 fptr->file_map->map_pmap.pr_vaddr, &fptr->file_nsaddrs)) == NULL) 979 return (0); 980 981 mstart = mptr->map_pmap.pr_vaddr; 982 mend = mptr->map_pmap.pr_vaddr + mptr->map_pmap.pr_size; 983 for (i = 0; i < fptr->file_nsaddrs; i += 2) { 984 /* Does this section overlap the mapping? */ 985 sstart = fptr->file_saddrs[i]; 986 send = fptr->file_saddrs[i + 1]; 987 if (!(mend <= sstart || mstart >= send)) 988 return (1); 989 } 990 991 return (0); 992 } 993 994 /* 995 * Find or build the symbol table for the given mapping. 996 */ 997 static file_info_t * 998 build_map_symtab(struct ps_prochandle *P, map_info_t *mptr) 999 { 1000 prmap_t *pmap = &mptr->map_pmap; 1001 file_info_t *fptr; 1002 uint_t i; 1003 1004 if ((fptr = mptr->map_file) != NULL) { 1005 Pbuild_file_symtab(P, fptr); 1006 return (fptr); 1007 } 1008 1009 if (pmap->pr_mapname[0] == '\0') 1010 return (NULL); 1011 1012 /* 1013 * Attempt to find a matching file. 1014 * (A file can be mapped at several different addresses.) 1015 */ 1016 for (i = 0, fptr = list_next(&P->file_head); i < P->num_files; 1017 i++, fptr = list_next(fptr)) { 1018 if (strcmp(fptr->file_pname, pmap->pr_mapname) == 0 && 1019 fptr->file_lo && is_mapping_in_file(P, mptr, fptr)) { 1020 mptr->map_file = fptr; 1021 fptr->file_ref++; 1022 Pbuild_file_symtab(P, fptr); 1023 return (fptr); 1024 } 1025 } 1026 1027 /* 1028 * If we need to create a new file_info structure, iterate 1029 * through the load objects in order to attempt to connect 1030 * this new file with its primary text mapping. We again 1031 * need to handle ld.so as a special case because we need 1032 * to be able to bootstrap librtld_db. 1033 */ 1034 if ((fptr = file_info_new(P, mptr)) == NULL) 1035 return (NULL); 1036 1037 if (P->map_ldso != mptr) { 1038 if (P->rap != NULL) 1039 (void) rd_loadobj_iter(P->rap, map_iter, P); 1040 else 1041 (void) Prd_agent(P); 1042 } else { 1043 fptr->file_map = mptr; 1044 } 1045 1046 /* 1047 * If librtld_db wasn't able to help us connect the file to a primary 1048 * text mapping, set file_map to the current mapping because we require 1049 * fptr->file_map to be set in Pbuild_file_symtab. librtld_db may be 1050 * unaware of what's going on in the rare case that a legitimate ELF 1051 * file has been mmap(2)ed into the process address space *without* 1052 * the use of dlopen(3x). 1053 */ 1054 if (fptr->file_map == NULL) 1055 fptr->file_map = mptr; 1056 1057 Pbuild_file_symtab(P, fptr); 1058 1059 return (fptr); 1060 } 1061 1062 static int 1063 read_ehdr32(struct ps_prochandle *P, Elf32_Ehdr *ehdr, uint_t *phnum, 1064 uintptr_t addr) 1065 { 1066 if (Pread(P, ehdr, sizeof (*ehdr), addr) != sizeof (*ehdr)) 1067 return (-1); 1068 1069 if (ehdr->e_ident[EI_MAG0] != ELFMAG0 || 1070 ehdr->e_ident[EI_MAG1] != ELFMAG1 || 1071 ehdr->e_ident[EI_MAG2] != ELFMAG2 || 1072 ehdr->e_ident[EI_MAG3] != ELFMAG3 || 1073 ehdr->e_ident[EI_CLASS] != ELFCLASS32 || 1074 #ifdef _BIG_ENDIAN 1075 ehdr->e_ident[EI_DATA] != ELFDATA2MSB || 1076 #else 1077 ehdr->e_ident[EI_DATA] != ELFDATA2LSB || 1078 #endif 1079 ehdr->e_ident[EI_VERSION] != EV_CURRENT) 1080 return (-1); 1081 1082 if ((*phnum = ehdr->e_phnum) == PN_XNUM) { 1083 Elf32_Shdr shdr0; 1084 1085 if (ehdr->e_shoff == 0 || ehdr->e_shentsize < sizeof (shdr0) || 1086 Pread(P, &shdr0, sizeof (shdr0), addr + ehdr->e_shoff) != 1087 sizeof (shdr0)) 1088 return (-1); 1089 1090 if (shdr0.sh_info != 0) 1091 *phnum = shdr0.sh_info; 1092 } 1093 1094 return (0); 1095 } 1096 1097 static int 1098 read_dynamic_phdr32(struct ps_prochandle *P, const Elf32_Ehdr *ehdr, 1099 uint_t phnum, Elf32_Phdr *phdr, uintptr_t addr) 1100 { 1101 uint_t i; 1102 1103 for (i = 0; i < phnum; i++) { 1104 uintptr_t a = addr + ehdr->e_phoff + i * ehdr->e_phentsize; 1105 if (Pread(P, phdr, sizeof (*phdr), a) != sizeof (*phdr)) 1106 return (-1); 1107 1108 if (phdr->p_type == PT_DYNAMIC) 1109 return (0); 1110 } 1111 1112 return (-1); 1113 } 1114 1115 #ifdef _LP64 1116 static int 1117 read_ehdr64(struct ps_prochandle *P, Elf64_Ehdr *ehdr, uint_t *phnum, 1118 uintptr_t addr) 1119 { 1120 if (Pread(P, ehdr, sizeof (Elf64_Ehdr), addr) != sizeof (Elf64_Ehdr)) 1121 return (-1); 1122 1123 if (ehdr->e_ident[EI_MAG0] != ELFMAG0 || 1124 ehdr->e_ident[EI_MAG1] != ELFMAG1 || 1125 ehdr->e_ident[EI_MAG2] != ELFMAG2 || 1126 ehdr->e_ident[EI_MAG3] != ELFMAG3 || 1127 ehdr->e_ident[EI_CLASS] != ELFCLASS64 || 1128 #ifdef _BIG_ENDIAN 1129 ehdr->e_ident[EI_DATA] != ELFDATA2MSB || 1130 #else 1131 ehdr->e_ident[EI_DATA] != ELFDATA2LSB || 1132 #endif 1133 ehdr->e_ident[EI_VERSION] != EV_CURRENT) 1134 return (-1); 1135 1136 if ((*phnum = ehdr->e_phnum) == PN_XNUM) { 1137 Elf64_Shdr shdr0; 1138 1139 if (ehdr->e_shoff == 0 || ehdr->e_shentsize < sizeof (shdr0) || 1140 Pread(P, &shdr0, sizeof (shdr0), addr + ehdr->e_shoff) != 1141 sizeof (shdr0)) 1142 return (-1); 1143 1144 if (shdr0.sh_info != 0) 1145 *phnum = shdr0.sh_info; 1146 } 1147 1148 return (0); 1149 } 1150 1151 static int 1152 read_dynamic_phdr64(struct ps_prochandle *P, const Elf64_Ehdr *ehdr, 1153 uint_t phnum, Elf64_Phdr *phdr, uintptr_t addr) 1154 { 1155 uint_t i; 1156 1157 for (i = 0; i < phnum; i++) { 1158 uintptr_t a = addr + ehdr->e_phoff + i * ehdr->e_phentsize; 1159 if (Pread(P, phdr, sizeof (*phdr), a) != sizeof (*phdr)) 1160 return (-1); 1161 1162 if (phdr->p_type == PT_DYNAMIC) 1163 return (0); 1164 } 1165 1166 return (-1); 1167 } 1168 #endif /* _LP64 */ 1169 1170 /* 1171 * The text segment for each load object contains the elf header and 1172 * program headers. We can use this information to determine if the 1173 * file that corresponds to the load object is the same file that 1174 * was loaded into the process's address space. There can be a discrepency 1175 * if a file is recompiled after the process is started or if the target 1176 * represents a core file from a differently configured system -- two 1177 * common examples. The DT_CHECKSUM entry in the dynamic section 1178 * provides an easy method of comparison. It is important to note that 1179 * the dynamic section usually lives in the data segment, but the meta 1180 * data we use to find the dynamic section lives in the text segment so 1181 * if either of those segments is absent we can't proceed. 1182 * 1183 * We're looking through the elf file for several items: the symbol tables 1184 * (both dynsym and symtab), the procedure linkage table (PLT) base, 1185 * size, and relocation base, and the CTF information. Most of this can 1186 * be recovered from the loaded image of the file itself, the exceptions 1187 * being the symtab and CTF data. 1188 * 1189 * First we try to open the file that we think corresponds to the load 1190 * object, if the DT_CHECKSUM values match, we're all set, and can simply 1191 * recover all the information we need from the file. If the values of 1192 * DT_CHECKSUM don't match, or if we can't access the file for whatever 1193 * reasaon, we fake up a elf file to use in its stead. If we can't read 1194 * the elf data in the process's address space, we fall back to using 1195 * the file even though it may give inaccurate information. 1196 * 1197 * The elf file that we fake up has to consist of sections for the 1198 * dynsym, the PLT and the dynamic section. Note that in the case of a 1199 * core file, we'll get the CTF data in the file_info_t later on from 1200 * a section embedded the core file (if it's present). 1201 * 1202 * file_differs() conservatively looks for mismatched files, identifying 1203 * a match when there is any ambiguity (since that's the legacy behavior). 1204 */ 1205 static int 1206 file_differs(struct ps_prochandle *P, Elf *elf, file_info_t *fptr) 1207 { 1208 Elf_Scn *scn; 1209 GElf_Shdr shdr; 1210 GElf_Dyn dyn; 1211 Elf_Data *data; 1212 uint_t i, ndyn; 1213 GElf_Xword cksum; 1214 uintptr_t addr; 1215 1216 if (fptr->file_map == NULL) 1217 return (0); 1218 1219 if ((Pcontent(P) & (CC_CONTENT_TEXT | CC_CONTENT_DATA)) != 1220 (CC_CONTENT_TEXT | CC_CONTENT_DATA)) 1221 return (0); 1222 1223 /* 1224 * First, we find the checksum value in the elf file. 1225 */ 1226 scn = NULL; 1227 while ((scn = elf_nextscn(elf, scn)) != NULL) { 1228 if (gelf_getshdr(scn, &shdr) != NULL && 1229 shdr.sh_type == SHT_DYNAMIC) 1230 goto found_shdr; 1231 } 1232 return (0); 1233 1234 found_shdr: 1235 if ((data = elf_getdata(scn, NULL)) == NULL) 1236 return (0); 1237 1238 if (P->status.pr_dmodel == PR_MODEL_ILP32) 1239 ndyn = shdr.sh_size / sizeof (Elf32_Dyn); 1240 #ifdef _LP64 1241 else if (P->status.pr_dmodel == PR_MODEL_LP64) 1242 ndyn = shdr.sh_size / sizeof (Elf64_Dyn); 1243 #endif 1244 else 1245 return (0); 1246 1247 for (i = 0; i < ndyn; i++) { 1248 if (gelf_getdyn(data, i, &dyn) != NULL && 1249 dyn.d_tag == DT_CHECKSUM) 1250 goto found_cksum; 1251 } 1252 1253 /* 1254 * The in-memory ELF has no DT_CHECKSUM section, but we will report it 1255 * as matching the file anyhow. 1256 */ 1257 return (0); 1258 1259 found_cksum: 1260 cksum = dyn.d_un.d_val; 1261 dprintf("elf cksum value is %llx\n", (u_longlong_t)cksum); 1262 1263 /* 1264 * Get the base of the text mapping that corresponds to this file. 1265 */ 1266 addr = fptr->file_map->map_pmap.pr_vaddr; 1267 1268 if (P->status.pr_dmodel == PR_MODEL_ILP32) { 1269 Elf32_Ehdr ehdr; 1270 Elf32_Phdr phdr; 1271 Elf32_Dyn dync, *dynp; 1272 uint_t phnum, i; 1273 1274 if (read_ehdr32(P, &ehdr, &phnum, addr) != 0 || 1275 read_dynamic_phdr32(P, &ehdr, phnum, &phdr, addr) != 0) 1276 return (0); 1277 1278 if (ehdr.e_type == ET_DYN) 1279 phdr.p_vaddr += addr; 1280 if ((dynp = malloc(phdr.p_filesz)) == NULL) 1281 return (0); 1282 dync.d_tag = DT_NULL; 1283 if (Pread(P, dynp, phdr.p_filesz, phdr.p_vaddr) != 1284 phdr.p_filesz) { 1285 free(dynp); 1286 return (0); 1287 } 1288 1289 for (i = 0; i < phdr.p_filesz / sizeof (Elf32_Dyn); i++) { 1290 if (dynp[i].d_tag == DT_CHECKSUM) 1291 dync = dynp[i]; 1292 } 1293 1294 free(dynp); 1295 1296 if (dync.d_tag != DT_CHECKSUM) 1297 return (0); 1298 1299 dprintf("image cksum value is %llx\n", 1300 (u_longlong_t)dync.d_un.d_val); 1301 return (dync.d_un.d_val != cksum); 1302 #ifdef _LP64 1303 } else if (P->status.pr_dmodel == PR_MODEL_LP64) { 1304 Elf64_Ehdr ehdr; 1305 Elf64_Phdr phdr; 1306 Elf64_Dyn dync, *dynp; 1307 uint_t phnum, i; 1308 1309 if (read_ehdr64(P, &ehdr, &phnum, addr) != 0 || 1310 read_dynamic_phdr64(P, &ehdr, phnum, &phdr, addr) != 0) 1311 return (0); 1312 1313 if (ehdr.e_type == ET_DYN) 1314 phdr.p_vaddr += addr; 1315 if ((dynp = malloc(phdr.p_filesz)) == NULL) 1316 return (0); 1317 dync.d_tag = DT_NULL; 1318 if (Pread(P, dynp, phdr.p_filesz, phdr.p_vaddr) != 1319 phdr.p_filesz) { 1320 free(dynp); 1321 return (0); 1322 } 1323 1324 for (i = 0; i < phdr.p_filesz / sizeof (Elf64_Dyn); i++) { 1325 if (dynp[i].d_tag == DT_CHECKSUM) 1326 dync = dynp[i]; 1327 } 1328 1329 free(dynp); 1330 1331 if (dync.d_tag != DT_CHECKSUM) 1332 return (0); 1333 1334 dprintf("image cksum value is %llx\n", 1335 (u_longlong_t)dync.d_un.d_val); 1336 return (dync.d_un.d_val != cksum); 1337 #endif /* _LP64 */ 1338 } 1339 1340 return (0); 1341 } 1342 1343 /* 1344 * Read data from the specified process and construct an in memory 1345 * image of an ELF file that represents it well enough to let 1346 * us probe it for information. 1347 */ 1348 static Elf * 1349 fake_elf(struct ps_prochandle *P, file_info_t *fptr) 1350 { 1351 Elf *elf; 1352 uintptr_t addr; 1353 uint_t phnum; 1354 1355 if (fptr->file_map == NULL) 1356 return (NULL); 1357 1358 if ((Pcontent(P) & (CC_CONTENT_TEXT | CC_CONTENT_DATA)) != 1359 (CC_CONTENT_TEXT | CC_CONTENT_DATA)) 1360 return (NULL); 1361 1362 addr = fptr->file_map->map_pmap.pr_vaddr; 1363 1364 if (P->status.pr_dmodel == PR_MODEL_ILP32) { 1365 Elf32_Ehdr ehdr; 1366 Elf32_Phdr phdr; 1367 1368 if ((read_ehdr32(P, &ehdr, &phnum, addr) != 0) || 1369 read_dynamic_phdr32(P, &ehdr, phnum, &phdr, addr) != 0) 1370 return (NULL); 1371 1372 elf = fake_elf32(P, fptr, addr, &ehdr, phnum, &phdr); 1373 #ifdef _LP64 1374 } else { 1375 Elf64_Ehdr ehdr; 1376 Elf64_Phdr phdr; 1377 1378 if (read_ehdr64(P, &ehdr, &phnum, addr) != 0 || 1379 read_dynamic_phdr64(P, &ehdr, phnum, &phdr, addr) != 0) 1380 return (NULL); 1381 1382 elf = fake_elf64(P, fptr, addr, &ehdr, phnum, &phdr); 1383 #endif 1384 } 1385 1386 return (elf); 1387 } 1388 1389 /* 1390 * We wouldn't need these if qsort(3C) took an argument for the callback... 1391 */ 1392 static mutex_t sort_mtx = DEFAULTMUTEX; 1393 static char *sort_strs; 1394 static GElf_Sym *sort_syms; 1395 1396 int 1397 byaddr_cmp_common(GElf_Sym *a, char *aname, GElf_Sym *b, char *bname) 1398 { 1399 if (a->st_value < b->st_value) 1400 return (-1); 1401 if (a->st_value > b->st_value) 1402 return (1); 1403 1404 /* 1405 * Prefer the function to the non-function. 1406 */ 1407 if (GELF_ST_TYPE(a->st_info) != GELF_ST_TYPE(b->st_info)) { 1408 if (GELF_ST_TYPE(a->st_info) == STT_FUNC) 1409 return (-1); 1410 if (GELF_ST_TYPE(b->st_info) == STT_FUNC) 1411 return (1); 1412 } 1413 1414 /* 1415 * Prefer the weak or strong global symbol to the local symbol. 1416 */ 1417 if (GELF_ST_BIND(a->st_info) != GELF_ST_BIND(b->st_info)) { 1418 if (GELF_ST_BIND(b->st_info) == STB_LOCAL) 1419 return (-1); 1420 if (GELF_ST_BIND(a->st_info) == STB_LOCAL) 1421 return (1); 1422 } 1423 1424 /* 1425 * Prefer the symbol that doesn't begin with a '$' since compilers and 1426 * other symbol generators often use it as a prefix. 1427 */ 1428 if (*bname == '$') 1429 return (-1); 1430 if (*aname == '$') 1431 return (1); 1432 1433 /* 1434 * Prefer the name with fewer leading underscores in the name. 1435 */ 1436 while (*aname == '_' && *bname == '_') { 1437 aname++; 1438 bname++; 1439 } 1440 1441 if (*bname == '_') 1442 return (-1); 1443 if (*aname == '_') 1444 return (1); 1445 1446 /* 1447 * Prefer the symbol with the smaller size. 1448 */ 1449 if (a->st_size < b->st_size) 1450 return (-1); 1451 if (a->st_size > b->st_size) 1452 return (1); 1453 1454 /* 1455 * All other factors being equal, fall back to lexicographic order. 1456 */ 1457 return (strcmp(aname, bname)); 1458 } 1459 1460 static int 1461 byaddr_cmp(const void *aa, const void *bb) 1462 { 1463 GElf_Sym *a = &sort_syms[*(uint_t *)aa]; 1464 GElf_Sym *b = &sort_syms[*(uint_t *)bb]; 1465 char *aname = sort_strs + a->st_name; 1466 char *bname = sort_strs + b->st_name; 1467 1468 return (byaddr_cmp_common(a, aname, b, bname)); 1469 } 1470 1471 static int 1472 byname_cmp(const void *aa, const void *bb) 1473 { 1474 GElf_Sym *a = &sort_syms[*(uint_t *)aa]; 1475 GElf_Sym *b = &sort_syms[*(uint_t *)bb]; 1476 char *aname = sort_strs + a->st_name; 1477 char *bname = sort_strs + b->st_name; 1478 1479 return (strcmp(aname, bname)); 1480 } 1481 1482 /* 1483 * Given a symbol index, look up the corresponding symbol from the 1484 * given symbol table. 1485 * 1486 * This function allows the caller to treat the symbol table as a single 1487 * logical entity even though there may be 2 actual ELF symbol tables 1488 * involved. See the comments in Pcontrol.h for details. 1489 */ 1490 static GElf_Sym * 1491 symtab_getsym(sym_tbl_t *symtab, int ndx, GElf_Sym *dst) 1492 { 1493 /* If index is in range of primary symtab, look it up there */ 1494 if (ndx >= symtab->sym_symn_aux) { 1495 return (gelf_getsym(symtab->sym_data_pri, 1496 ndx - symtab->sym_symn_aux, dst)); 1497 } 1498 1499 /* Not in primary: Look it up in the auxiliary symtab */ 1500 return (gelf_getsym(symtab->sym_data_aux, ndx, dst)); 1501 } 1502 1503 void 1504 optimize_symtab(sym_tbl_t *symtab) 1505 { 1506 GElf_Sym *symp, *syms; 1507 uint_t i, *indexa, *indexb; 1508 size_t symn, strsz, count; 1509 1510 if (symtab == NULL || symtab->sym_data_pri == NULL || 1511 symtab->sym_byaddr != NULL) 1512 return; 1513 1514 symn = symtab->sym_symn; 1515 strsz = symtab->sym_strsz; 1516 1517 symp = syms = malloc(sizeof (GElf_Sym) * symn); 1518 if (symp == NULL) { 1519 dprintf("optimize_symtab: failed to malloc symbol array"); 1520 return; 1521 } 1522 1523 /* 1524 * First record all the symbols into a table and count up the ones 1525 * that we're interested in. We mark symbols as invalid by setting 1526 * the st_name to an illegal value. 1527 */ 1528 for (i = 0, count = 0; i < symn; i++, symp++) { 1529 if (symtab_getsym(symtab, i, symp) != NULL && 1530 symp->st_name < strsz && 1531 IS_DATA_TYPE(GELF_ST_TYPE(symp->st_info))) 1532 count++; 1533 else 1534 symp->st_name = strsz; 1535 } 1536 1537 /* 1538 * Allocate sufficient space for both tables and populate them 1539 * with the same symbols we just counted. 1540 */ 1541 symtab->sym_count = count; 1542 indexa = symtab->sym_byaddr = calloc(sizeof (uint_t), count); 1543 indexb = symtab->sym_byname = calloc(sizeof (uint_t), count); 1544 if (indexa == NULL || indexb == NULL) { 1545 dprintf( 1546 "optimize_symtab: failed to malloc symbol index arrays"); 1547 symtab->sym_count = 0; 1548 if (indexa != NULL) { /* First alloc succeeded. Free it */ 1549 free(indexa); 1550 symtab->sym_byaddr = NULL; 1551 } 1552 free(syms); 1553 return; 1554 } 1555 for (i = 0, symp = syms; i < symn; i++, symp++) { 1556 if (symp->st_name < strsz) 1557 *indexa++ = *indexb++ = i; 1558 } 1559 1560 /* 1561 * Sort the two tables according to the appropriate criteria, 1562 * unless the user has overridden this behaviour. 1563 * 1564 * An example where we might not sort the tables is the relatively 1565 * unusual case of a process with very large symbol tables in which 1566 * we perform few lookups. In such a case the total time would be 1567 * dominated by the sort. It is difficult to determine a priori 1568 * how many lookups an arbitrary client will perform, and 1569 * hence whether the symbol tables should be sorted. We therefore 1570 * sort the tables by default, but provide the user with a 1571 * "chicken switch" in the form of the LIBPROC_NO_QSORT 1572 * environment variable. 1573 */ 1574 if (!_libproc_no_qsort) { 1575 (void) mutex_lock(&sort_mtx); 1576 sort_strs = symtab->sym_strs; 1577 sort_syms = syms; 1578 1579 qsort(symtab->sym_byaddr, count, sizeof (uint_t), byaddr_cmp); 1580 qsort(symtab->sym_byname, count, sizeof (uint_t), byname_cmp); 1581 1582 sort_strs = NULL; 1583 sort_syms = NULL; 1584 (void) mutex_unlock(&sort_mtx); 1585 } 1586 1587 free(syms); 1588 } 1589 1590 1591 static Elf * 1592 build_fake_elf(struct ps_prochandle *P, file_info_t *fptr, GElf_Ehdr *ehdr, 1593 size_t *nshdrs, Elf_Data **shdata) 1594 { 1595 size_t shstrndx; 1596 Elf_Scn *scn; 1597 Elf *elf; 1598 1599 if ((elf = fake_elf(P, fptr)) == NULL || 1600 elf_kind(elf) != ELF_K_ELF || 1601 gelf_getehdr(elf, ehdr) == NULL || 1602 elf_getshdrnum(elf, nshdrs) == -1 || 1603 elf_getshdrstrndx(elf, &shstrndx) == -1 || 1604 (scn = elf_getscn(elf, shstrndx)) == NULL || 1605 (*shdata = elf_getdata(scn, NULL)) == NULL) { 1606 if (elf != NULL) 1607 (void) elf_end(elf); 1608 dprintf("failed to fake up ELF file\n"); 1609 return (NULL); 1610 } 1611 1612 return (elf); 1613 } 1614 1615 /* 1616 * Build the symbol table for the given mapped file. 1617 */ 1618 void 1619 Pbuild_file_symtab(struct ps_prochandle *P, file_info_t *fptr) 1620 { 1621 char objectfile[PATH_MAX]; 1622 uint_t i; 1623 1624 GElf_Ehdr ehdr; 1625 GElf_Sym s; 1626 1627 Elf_Data *shdata; 1628 Elf_Scn *scn; 1629 Elf *elf; 1630 size_t nshdrs, shstrndx; 1631 1632 struct { 1633 GElf_Shdr c_shdr; 1634 Elf_Data *c_data; 1635 const char *c_name; 1636 } *cp, *cache = NULL, *dyn = NULL, *plt = NULL, *ctf = NULL; 1637 1638 if (fptr->file_init) 1639 return; /* We've already processed this file */ 1640 1641 /* 1642 * Mark the file_info struct as having the symbol table initialized 1643 * even if we fail below. We tried once; we don't try again. 1644 */ 1645 fptr->file_init = 1; 1646 1647 if (elf_version(EV_CURRENT) == EV_NONE) { 1648 dprintf("libproc ELF version is more recent than libelf\n"); 1649 return; 1650 } 1651 1652 if (P->state == PS_DEAD || P->state == PS_IDLE) { 1653 char *name; 1654 /* 1655 * If we're a not live, we can't open files from the /proc 1656 * object directory; we have only the mapping and file names 1657 * to guide us. We prefer the file_lname, but need to handle 1658 * the case of it being NULL in order to bootstrap: we first 1659 * come here during rd_new() when the only information we have 1660 * is interpreter name associated with the AT_BASE mapping. 1661 * 1662 * Also, if the zone associated with the core file seems 1663 * to exists on this machine we'll try to open the object 1664 * file within the zone. 1665 */ 1666 if (fptr->file_rname != NULL) 1667 name = fptr->file_rname; 1668 else if (fptr->file_lname != NULL) 1669 name = fptr->file_lname; 1670 else 1671 name = fptr->file_pname; 1672 (void) strlcpy(objectfile, name, sizeof (objectfile)); 1673 } else { 1674 (void) snprintf(objectfile, sizeof (objectfile), 1675 "%s/%d/object/%s", 1676 procfs_path, (int)P->pid, fptr->file_pname); 1677 } 1678 1679 /* 1680 * Open the object file, create the elf file, and then get the elf 1681 * header and .shstrtab data buffer so we can process sections by 1682 * name. If anything goes wrong try to fake up an elf file from 1683 * the in-core elf image. 1684 */ 1685 1686 if (_libproc_incore_elf) { 1687 dprintf("Pbuild_file_symtab: using in-core data for: %s\n", 1688 fptr->file_pname); 1689 1690 if ((elf = build_fake_elf(P, fptr, &ehdr, &nshdrs, &shdata)) == 1691 NULL) 1692 return; 1693 1694 } else if ((fptr->file_fd = open(objectfile, O_RDONLY)) < 0) { 1695 dprintf("Pbuild_file_symtab: failed to open %s: %s\n", 1696 objectfile, strerror(errno)); 1697 1698 if ((elf = build_fake_elf(P, fptr, &ehdr, &nshdrs, &shdata)) == 1699 NULL) 1700 return; 1701 1702 } else if ((elf = elf_begin(fptr->file_fd, ELF_C_READ, NULL)) == NULL || 1703 elf_kind(elf) != ELF_K_ELF || 1704 gelf_getehdr(elf, &ehdr) == NULL || 1705 elf_getshdrnum(elf, &nshdrs) == -1 || 1706 elf_getshdrstrndx(elf, &shstrndx) == -1 || 1707 (scn = elf_getscn(elf, shstrndx)) == NULL || 1708 (shdata = elf_getdata(scn, NULL)) == NULL) { 1709 int err = elf_errno(); 1710 1711 dprintf("failed to process ELF file %s: %s\n", 1712 objectfile, (err == 0) ? "<null>" : elf_errmsg(err)); 1713 (void) elf_end(elf); 1714 1715 if ((elf = build_fake_elf(P, fptr, &ehdr, &nshdrs, &shdata)) == 1716 NULL) 1717 return; 1718 1719 } else if (file_differs(P, elf, fptr)) { 1720 Elf *newelf; 1721 1722 /* 1723 * Before we get too excited about this elf file, we'll check 1724 * its checksum value against the value we have in memory. If 1725 * they don't agree, we try to fake up a new elf file and 1726 * proceed with that instead. 1727 */ 1728 dprintf("ELF file %s (%lx) doesn't match in-core image\n", 1729 fptr->file_pname, 1730 (ulong_t)fptr->file_map->map_pmap.pr_vaddr); 1731 1732 if ((newelf = build_fake_elf(P, fptr, &ehdr, &nshdrs, &shdata)) 1733 != NULL) { 1734 (void) elf_end(elf); 1735 elf = newelf; 1736 dprintf("switched to faked up ELF file\n"); 1737 1738 /* 1739 * Check to see if the file that we just discovered 1740 * to be an imposter matches the execname that was 1741 * determined by Pfindexec(). If it does, we (clearly) 1742 * don't have the right binary, and we zero out 1743 * execname before anyone gets hurt. 1744 */ 1745 if (fptr->file_rname != NULL && P->execname != NULL && 1746 strcmp(fptr->file_rname, P->execname) == 0) { 1747 dprintf("file/in-core image mismatch was " 1748 "on P->execname; discarding\n"); 1749 free(P->execname); 1750 P->execname = NULL; 1751 } 1752 } 1753 } 1754 1755 if ((cache = malloc(nshdrs * sizeof (*cache))) == NULL) { 1756 dprintf("failed to malloc section cache for %s\n", objectfile); 1757 goto bad; 1758 } 1759 1760 dprintf("processing ELF file %s\n", objectfile); 1761 fptr->file_class = ehdr.e_ident[EI_CLASS]; 1762 fptr->file_etype = ehdr.e_type; 1763 fptr->file_elf = elf; 1764 fptr->file_shstrs = shdata->d_buf; 1765 fptr->file_shstrsz = shdata->d_size; 1766 1767 /* 1768 * Iterate through each section, caching its section header, data 1769 * pointer, and name. We use this for handling sh_link values below. 1770 */ 1771 for (cp = cache + 1, scn = NULL; scn = elf_nextscn(elf, scn); cp++) { 1772 if (gelf_getshdr(scn, &cp->c_shdr) == NULL) { 1773 dprintf("Pbuild_file_symtab: Failed to get section " 1774 "header\n"); 1775 goto bad; /* Failed to get section header */ 1776 } 1777 1778 if ((cp->c_data = elf_getdata(scn, NULL)) == NULL) { 1779 dprintf("Pbuild_file_symtab: Failed to get section " 1780 "data\n"); 1781 goto bad; /* Failed to get section data */ 1782 } 1783 1784 if (cp->c_shdr.sh_name >= shdata->d_size) { 1785 dprintf("Pbuild_file_symtab: corrupt section name"); 1786 goto bad; /* Corrupt section name */ 1787 } 1788 1789 cp->c_name = (const char *)shdata->d_buf + cp->c_shdr.sh_name; 1790 } 1791 1792 /* 1793 * Now iterate through the section cache in order to locate info 1794 * for the .symtab, .dynsym, .SUNW_ldynsym, .dynamic, .plt, 1795 * and .SUNW_ctf sections: 1796 */ 1797 for (i = 1, cp = cache + 1; i < nshdrs; i++, cp++) { 1798 GElf_Shdr *shp = &cp->c_shdr; 1799 1800 if (shp->sh_type == SHT_SYMTAB || shp->sh_type == SHT_DYNSYM) { 1801 sym_tbl_t *symp = shp->sh_type == SHT_SYMTAB ? 1802 &fptr->file_symtab : &fptr->file_dynsym; 1803 /* 1804 * It's possible that the we already got the symbol 1805 * table from the core file itself. Either the file 1806 * differs in which case our faked up elf file will 1807 * only contain the dynsym (not the symtab) or the 1808 * file matches in which case we'll just be replacing 1809 * the symbol table we pulled out of the core file 1810 * with an equivalent one. In either case, this 1811 * check isn't essential, but it's a good idea. 1812 */ 1813 if (symp->sym_data_pri == NULL) { 1814 dprintf("Symbol table found for %s\n", 1815 objectfile); 1816 symp->sym_data_pri = cp->c_data; 1817 symp->sym_symn += 1818 shp->sh_size / shp->sh_entsize; 1819 symp->sym_strs = 1820 cache[shp->sh_link].c_data->d_buf; 1821 symp->sym_strsz = 1822 cache[shp->sh_link].c_data->d_size; 1823 symp->sym_hdr_pri = cp->c_shdr; 1824 symp->sym_strhdr = cache[shp->sh_link].c_shdr; 1825 } else { 1826 dprintf("Symbol table already there for %s\n", 1827 objectfile); 1828 } 1829 } else if (shp->sh_type == SHT_SUNW_LDYNSYM) { 1830 /* .SUNW_ldynsym section is auxiliary to .dynsym */ 1831 if (fptr->file_dynsym.sym_data_aux == NULL) { 1832 dprintf(".SUNW_ldynsym symbol table" 1833 " found for %s\n", objectfile); 1834 fptr->file_dynsym.sym_data_aux = cp->c_data; 1835 fptr->file_dynsym.sym_symn_aux = 1836 shp->sh_size / shp->sh_entsize; 1837 fptr->file_dynsym.sym_symn += 1838 fptr->file_dynsym.sym_symn_aux; 1839 fptr->file_dynsym.sym_hdr_aux = cp->c_shdr; 1840 } else { 1841 dprintf(".SUNW_ldynsym symbol table already" 1842 " there for %s\n", objectfile); 1843 } 1844 } else if (shp->sh_type == SHT_DYNAMIC) { 1845 dyn = cp; 1846 } else if (strcmp(cp->c_name, ".plt") == 0) { 1847 plt = cp; 1848 } else if (strcmp(cp->c_name, ".SUNW_ctf") == 0) { 1849 /* 1850 * Skip over bogus CTF sections so they don't come back 1851 * to haunt us later. 1852 */ 1853 if (shp->sh_link == 0 || 1854 shp->sh_link >= nshdrs || 1855 (cache[shp->sh_link].c_shdr.sh_type != SHT_DYNSYM && 1856 cache[shp->sh_link].c_shdr.sh_type != SHT_SYMTAB)) { 1857 dprintf("Bad sh_link %d for " 1858 "CTF\n", shp->sh_link); 1859 continue; 1860 } 1861 ctf = cp; 1862 } 1863 } 1864 1865 /* 1866 * At this point, we've found all the symbol tables we're ever going 1867 * to find: the ones in the loop above and possibly the symtab that 1868 * was included in the core file. Before we perform any lookups, we 1869 * create sorted versions to optimize for lookups. 1870 */ 1871 optimize_symtab(&fptr->file_symtab); 1872 optimize_symtab(&fptr->file_dynsym); 1873 1874 /* 1875 * Fill in the base address of the text mapping for shared libraries. 1876 * This allows us to translate symbols before librtld_db is ready. 1877 */ 1878 if (fptr->file_etype == ET_DYN) { 1879 fptr->file_dyn_base = fptr->file_map->map_pmap.pr_vaddr - 1880 fptr->file_map->map_pmap.pr_offset; 1881 dprintf("setting file_dyn_base for %s to %lx\n", 1882 objectfile, (long)fptr->file_dyn_base); 1883 } 1884 1885 /* 1886 * Record the CTF section information in the file info structure. 1887 */ 1888 if (ctf != NULL) { 1889 fptr->file_ctf_off = ctf->c_shdr.sh_offset; 1890 fptr->file_ctf_size = ctf->c_shdr.sh_size; 1891 if (ctf->c_shdr.sh_link != 0 && 1892 cache[ctf->c_shdr.sh_link].c_shdr.sh_type == SHT_DYNSYM) 1893 fptr->file_ctf_dyn = 1; 1894 } 1895 1896 if (fptr->file_lo == NULL) 1897 goto done; /* Nothing else to do if no load object info */ 1898 1899 /* 1900 * If the object is a shared library and we have a different rl_base 1901 * value, reset file_dyn_base according to librtld_db's information. 1902 */ 1903 if (fptr->file_etype == ET_DYN && 1904 fptr->file_lo->rl_base != fptr->file_dyn_base) { 1905 dprintf("resetting file_dyn_base for %s to %lx\n", 1906 objectfile, (long)fptr->file_lo->rl_base); 1907 fptr->file_dyn_base = fptr->file_lo->rl_base; 1908 } 1909 1910 /* 1911 * Fill in the PLT information for this file if a PLT symbol is found. 1912 */ 1913 if (sym_by_name(&fptr->file_dynsym, "_PROCEDURE_LINKAGE_TABLE_", &s, 1914 NULL) != NULL) { 1915 fptr->file_plt_base = s.st_value + fptr->file_dyn_base; 1916 fptr->file_plt_size = (plt != NULL) ? plt->c_shdr.sh_size : 0; 1917 1918 /* 1919 * Bring the load object up to date; it is the only way the 1920 * user has to access the PLT data. The PLT information in the 1921 * rd_loadobj_t is not set in the call to map_iter() (the 1922 * callback for rd_loadobj_iter) where we set file_lo. 1923 */ 1924 fptr->file_lo->rl_plt_base = fptr->file_plt_base; 1925 fptr->file_lo->rl_plt_size = fptr->file_plt_size; 1926 1927 dprintf("PLT found at %p, size = %lu\n", 1928 (void *)fptr->file_plt_base, (ulong_t)fptr->file_plt_size); 1929 } 1930 1931 /* 1932 * Fill in the PLT information. 1933 */ 1934 if (dyn != NULL) { 1935 uintptr_t dynaddr = dyn->c_shdr.sh_addr + fptr->file_dyn_base; 1936 size_t ndyn = dyn->c_shdr.sh_size / dyn->c_shdr.sh_entsize; 1937 GElf_Dyn d; 1938 1939 for (i = 0; i < ndyn; i++) { 1940 if (gelf_getdyn(dyn->c_data, i, &d) == NULL) 1941 continue; 1942 1943 switch (d.d_tag) { 1944 case DT_JMPREL: 1945 dprintf("DT_JMPREL is %p\n", 1946 (void *)(uintptr_t)d.d_un.d_ptr); 1947 fptr->file_jmp_rel = 1948 d.d_un.d_ptr + fptr->file_dyn_base; 1949 break; 1950 case DT_STRTAB: 1951 dprintf("DT_STRTAB is %p\n", 1952 (void *)(uintptr_t)d.d_un.d_ptr); 1953 break; 1954 case DT_PLTGOT: 1955 dprintf("DT_PLTGOT is %p\n", 1956 (void *)(uintptr_t)d.d_un.d_ptr); 1957 break; 1958 case DT_SUNW_SYMTAB: 1959 dprintf("DT_SUNW_SYMTAB is %p\n", 1960 (void *)(uintptr_t)d.d_un.d_ptr); 1961 break; 1962 case DT_SYMTAB: 1963 dprintf("DT_SYMTAB is %p\n", 1964 (void *)(uintptr_t)d.d_un.d_ptr); 1965 break; 1966 case DT_HASH: 1967 dprintf("DT_HASH is %p\n", 1968 (void *)(uintptr_t)d.d_un.d_ptr); 1969 break; 1970 } 1971 } 1972 1973 dprintf("_DYNAMIC found at %p, %lu entries, DT_JMPREL = %p\n", 1974 (void *)dynaddr, (ulong_t)ndyn, (void *)fptr->file_jmp_rel); 1975 } 1976 1977 done: 1978 free(cache); 1979 return; 1980 1981 bad: 1982 if (cache != NULL) 1983 free(cache); 1984 1985 (void) elf_end(elf); 1986 fptr->file_elf = NULL; 1987 if (fptr->file_elfmem != NULL) { 1988 free(fptr->file_elfmem); 1989 fptr->file_elfmem = NULL; 1990 } 1991 (void) close(fptr->file_fd); 1992 fptr->file_fd = -1; 1993 } 1994 1995 /* 1996 * Given a process virtual address, return the map_info_t containing it. 1997 * If none found, return NULL. 1998 */ 1999 map_info_t * 2000 Paddr2mptr(struct ps_prochandle *P, uintptr_t addr) 2001 { 2002 int lo = 0; 2003 int hi = P->map_count - 1; 2004 int mid; 2005 map_info_t *mp; 2006 2007 while (lo <= hi) { 2008 2009 mid = (lo + hi) / 2; 2010 mp = &P->mappings[mid]; 2011 2012 /* check that addr is in [vaddr, vaddr + size) */ 2013 if ((addr - mp->map_pmap.pr_vaddr) < mp->map_pmap.pr_size) 2014 return (mp); 2015 2016 if (addr < mp->map_pmap.pr_vaddr) 2017 hi = mid - 1; 2018 else 2019 lo = mid + 1; 2020 } 2021 2022 return (NULL); 2023 } 2024 2025 /* 2026 * Return the map_info_t for the executable file. 2027 * If not found, return NULL. 2028 */ 2029 static map_info_t * 2030 exec_map(struct ps_prochandle *P) 2031 { 2032 uint_t i; 2033 map_info_t *mptr; 2034 map_info_t *mold = NULL; 2035 file_info_t *fptr; 2036 uintptr_t base; 2037 2038 for (i = 0, mptr = P->mappings; i < P->map_count; i++, mptr++) { 2039 if (mptr->map_pmap.pr_mapname[0] == '\0') 2040 continue; 2041 if (strcmp(mptr->map_pmap.pr_mapname, "a.out") == 0) { 2042 if ((fptr = mptr->map_file) != NULL && 2043 fptr->file_lo != NULL) { 2044 base = fptr->file_lo->rl_base; 2045 if (base >= mptr->map_pmap.pr_vaddr && 2046 base < mptr->map_pmap.pr_vaddr + 2047 mptr->map_pmap.pr_size) /* text space */ 2048 return (mptr); 2049 mold = mptr; /* must be the data */ 2050 continue; 2051 } 2052 /* This is a poor way to test for text space */ 2053 if (!(mptr->map_pmap.pr_mflags & MA_EXEC) || 2054 (mptr->map_pmap.pr_mflags & MA_WRITE)) { 2055 mold = mptr; 2056 continue; 2057 } 2058 return (mptr); 2059 } 2060 } 2061 2062 return (mold); 2063 } 2064 2065 /* 2066 * Given a shared object name, return the map_info_t for it. If no matching 2067 * object is found, return NULL. Normally, the link maps contain the full 2068 * object pathname, e.g. /usr/lib/libc.so.1. We allow the object name to 2069 * take one of the following forms: 2070 * 2071 * 1. An exact match (i.e. a full pathname): "/usr/lib/libc.so.1" 2072 * 2. An exact basename match: "libc.so.1" 2073 * 3. An initial basename match up to a '.' suffix: "libc.so" or "libc" 2074 * 4. The literal string "a.out" is an alias for the executable mapping 2075 * 2076 * The third case is a convenience for callers and may not be necessary. 2077 * 2078 * As the exact same object name may be loaded on different link maps (see 2079 * dlmopen(3DL)), we also allow the caller to resolve the object name by 2080 * specifying a particular link map id. If lmid is PR_LMID_EVERY, the 2081 * first matching name will be returned, regardless of the link map id. 2082 */ 2083 static map_info_t * 2084 object_to_map(struct ps_prochandle *P, Lmid_t lmid, const char *objname) 2085 { 2086 map_info_t *mp; 2087 file_info_t *fp; 2088 size_t objlen; 2089 uint_t i; 2090 2091 /* 2092 * If we have no rtld_db, then always treat a request as one for all 2093 * link maps. 2094 */ 2095 if (P->rap == NULL) 2096 lmid = PR_LMID_EVERY; 2097 2098 /* 2099 * First pass: look for exact matches of the entire pathname or 2100 * basename (cases 1 and 2 above): 2101 */ 2102 for (i = 0, mp = P->mappings; i < P->map_count; i++, mp++) { 2103 2104 if (mp->map_pmap.pr_mapname[0] == '\0' || 2105 (fp = mp->map_file) == NULL || 2106 ((fp->file_lname == NULL) && (fp->file_rname == NULL))) 2107 continue; 2108 2109 if (lmid != PR_LMID_EVERY && 2110 (fp->file_lo == NULL || lmid != fp->file_lo->rl_lmident)) 2111 continue; 2112 2113 /* 2114 * If we match, return the primary text mapping; otherwise 2115 * just return the mapping we matched. 2116 */ 2117 if ((fp->file_lbase && strcmp(fp->file_lbase, objname) == 0) || 2118 (fp->file_rbase && strcmp(fp->file_rbase, objname) == 0) || 2119 (fp->file_lname && strcmp(fp->file_lname, objname) == 0) || 2120 (fp->file_rname && strcmp(fp->file_rname, objname) == 0)) 2121 return (fp->file_map ? fp->file_map : mp); 2122 } 2123 2124 objlen = strlen(objname); 2125 2126 /* 2127 * Second pass: look for partial matches (case 3 above): 2128 */ 2129 for (i = 0, mp = P->mappings; i < P->map_count; i++, mp++) { 2130 2131 if (mp->map_pmap.pr_mapname[0] == '\0' || 2132 (fp = mp->map_file) == NULL || 2133 ((fp->file_lname == NULL) && (fp->file_rname == NULL))) 2134 continue; 2135 2136 if (lmid != PR_LMID_EVERY && 2137 (fp->file_lo == NULL || lmid != fp->file_lo->rl_lmident)) 2138 continue; 2139 2140 /* 2141 * If we match, return the primary text mapping; otherwise 2142 * just return the mapping we matched. 2143 */ 2144 if ((fp->file_lbase != NULL) && 2145 (strncmp(fp->file_lbase, objname, objlen) == 0) && 2146 (fp->file_lbase[objlen] == '.')) 2147 return (fp->file_map ? fp->file_map : mp); 2148 if ((fp->file_rbase != NULL) && 2149 (strncmp(fp->file_rbase, objname, objlen) == 0) && 2150 (fp->file_rbase[objlen] == '.')) 2151 return (fp->file_map ? fp->file_map : mp); 2152 } 2153 2154 /* 2155 * One last check: we allow "a.out" to always alias the executable, 2156 * assuming this name was not in use for something else. 2157 */ 2158 if ((lmid == PR_LMID_EVERY || lmid == LM_ID_BASE) && 2159 (strcmp(objname, "a.out") == 0)) 2160 return (P->map_exec); 2161 2162 return (NULL); 2163 } 2164 2165 static map_info_t * 2166 object_name_to_map(struct ps_prochandle *P, Lmid_t lmid, const char *name) 2167 { 2168 map_info_t *mptr; 2169 2170 if (!P->info_valid) 2171 Pupdate_maps(P); 2172 2173 if (P->map_exec == NULL && ((mptr = Paddr2mptr(P, 2174 Pgetauxval(P, AT_ENTRY))) != NULL || (mptr = exec_map(P)) != NULL)) 2175 P->map_exec = mptr; 2176 2177 if (P->map_ldso == NULL && (mptr = Paddr2mptr(P, 2178 Pgetauxval(P, AT_BASE))) != NULL) 2179 P->map_ldso = mptr; 2180 2181 if (name == PR_OBJ_EXEC) 2182 mptr = P->map_exec; 2183 else if (name == PR_OBJ_LDSO) 2184 mptr = P->map_ldso; 2185 else if (Prd_agent(P) != NULL || P->state == PS_IDLE) 2186 mptr = object_to_map(P, lmid, name); 2187 else 2188 mptr = NULL; 2189 2190 return (mptr); 2191 } 2192 2193 /* 2194 * When two symbols are found by address, decide which one is to be preferred. 2195 */ 2196 static GElf_Sym * 2197 sym_prefer(GElf_Sym *sym1, char *name1, GElf_Sym *sym2, char *name2) 2198 { 2199 /* 2200 * Prefer the non-NULL symbol. 2201 */ 2202 if (sym1 == NULL) 2203 return (sym2); 2204 if (sym2 == NULL) 2205 return (sym1); 2206 2207 /* 2208 * Defer to the sort ordering... 2209 */ 2210 return (byaddr_cmp_common(sym1, name1, sym2, name2) <= 0 ? sym1 : sym2); 2211 } 2212 2213 /* 2214 * Use a binary search to do the work of sym_by_addr(). 2215 */ 2216 static GElf_Sym * 2217 sym_by_addr_binary(sym_tbl_t *symtab, GElf_Addr addr, GElf_Sym *symp, 2218 uint_t *idp) 2219 { 2220 GElf_Sym sym, osym; 2221 uint_t i, oid, *byaddr = symtab->sym_byaddr; 2222 int min, max, mid, omid, found = 0; 2223 2224 if (symtab->sym_data_pri == NULL || symtab->sym_count == 0) 2225 return (NULL); 2226 2227 min = 0; 2228 max = symtab->sym_count - 1; 2229 osym.st_value = 0; 2230 2231 /* 2232 * We can't return when we've found a match, we have to continue 2233 * searching for the closest matching symbol. 2234 */ 2235 while (min <= max) { 2236 mid = (max + min) / 2; 2237 2238 i = byaddr[mid]; 2239 (void) symtab_getsym(symtab, i, &sym); 2240 2241 if (addr >= sym.st_value && 2242 addr < sym.st_value + sym.st_size && 2243 (!found || sym.st_value > osym.st_value)) { 2244 osym = sym; 2245 omid = mid; 2246 oid = i; 2247 found = 1; 2248 } 2249 2250 if (addr < sym.st_value) 2251 max = mid - 1; 2252 else 2253 min = mid + 1; 2254 } 2255 2256 if (!found) 2257 return (NULL); 2258 2259 /* 2260 * There may be many symbols with identical values so we walk 2261 * backward in the byaddr table to find the best match. 2262 */ 2263 do { 2264 sym = osym; 2265 i = oid; 2266 2267 if (omid == 0) 2268 break; 2269 2270 oid = byaddr[--omid]; 2271 (void) symtab_getsym(symtab, oid, &osym); 2272 } while (addr >= osym.st_value && 2273 addr < sym.st_value + osym.st_size && 2274 osym.st_value == sym.st_value); 2275 2276 *symp = sym; 2277 if (idp != NULL) 2278 *idp = i; 2279 return (symp); 2280 } 2281 2282 /* 2283 * Use a linear search to do the work of sym_by_addr(). 2284 */ 2285 static GElf_Sym * 2286 sym_by_addr_linear(sym_tbl_t *symtab, GElf_Addr addr, GElf_Sym *symbolp, 2287 uint_t *idp) 2288 { 2289 size_t symn = symtab->sym_symn; 2290 char *strs = symtab->sym_strs; 2291 GElf_Sym sym, *symp = NULL; 2292 GElf_Sym osym, *osymp = NULL; 2293 int i, id; 2294 2295 if (symtab->sym_data_pri == NULL || symn == 0 || strs == NULL) 2296 return (NULL); 2297 2298 for (i = 0; i < symn; i++) { 2299 if ((symp = symtab_getsym(symtab, i, &sym)) != NULL) { 2300 if (addr >= sym.st_value && 2301 addr < sym.st_value + sym.st_size) { 2302 if (osymp) 2303 symp = sym_prefer( 2304 symp, strs + symp->st_name, 2305 osymp, strs + osymp->st_name); 2306 if (symp != osymp) { 2307 osym = sym; 2308 osymp = &osym; 2309 id = i; 2310 } 2311 } 2312 } 2313 } 2314 if (osymp) { 2315 *symbolp = osym; 2316 if (idp) 2317 *idp = id; 2318 return (symbolp); 2319 } 2320 return (NULL); 2321 } 2322 2323 /* 2324 * Look up a symbol by address in the specified symbol table. 2325 * Adjustment to 'addr' must already have been made for the 2326 * offset of the symbol if this is a dynamic library symbol table. 2327 * 2328 * Use a linear or a binary search depending on whether or not we 2329 * chose to sort the table in optimize_symtab(). 2330 */ 2331 static GElf_Sym * 2332 sym_by_addr(sym_tbl_t *symtab, GElf_Addr addr, GElf_Sym *symp, uint_t *idp) 2333 { 2334 if (_libproc_no_qsort) { 2335 return (sym_by_addr_linear(symtab, addr, symp, idp)); 2336 } else { 2337 return (sym_by_addr_binary(symtab, addr, symp, idp)); 2338 } 2339 } 2340 2341 /* 2342 * Use a binary search to do the work of sym_by_name(). 2343 */ 2344 static GElf_Sym * 2345 sym_by_name_binary(sym_tbl_t *symtab, const char *name, GElf_Sym *symp, 2346 uint_t *idp) 2347 { 2348 char *strs = symtab->sym_strs; 2349 uint_t i, *byname = symtab->sym_byname; 2350 int min, mid, max, cmp; 2351 2352 if (symtab->sym_data_pri == NULL || strs == NULL || 2353 symtab->sym_count == 0) 2354 return (NULL); 2355 2356 min = 0; 2357 max = symtab->sym_count - 1; 2358 2359 while (min <= max) { 2360 mid = (max + min) / 2; 2361 2362 i = byname[mid]; 2363 (void) symtab_getsym(symtab, i, symp); 2364 2365 if ((cmp = strcmp(name, strs + symp->st_name)) == 0) { 2366 if (idp != NULL) 2367 *idp = i; 2368 return (symp); 2369 } 2370 2371 if (cmp < 0) 2372 max = mid - 1; 2373 else 2374 min = mid + 1; 2375 } 2376 2377 return (NULL); 2378 } 2379 2380 /* 2381 * Use a linear search to do the work of sym_by_name(). 2382 */ 2383 static GElf_Sym * 2384 sym_by_name_linear(sym_tbl_t *symtab, const char *name, GElf_Sym *symp, 2385 uint_t *idp) 2386 { 2387 size_t symn = symtab->sym_symn; 2388 char *strs = symtab->sym_strs; 2389 int i; 2390 2391 if (symtab->sym_data_pri == NULL || symn == 0 || strs == NULL) 2392 return (NULL); 2393 2394 for (i = 0; i < symn; i++) { 2395 if (symtab_getsym(symtab, i, symp) && 2396 strcmp(name, strs + symp->st_name) == 0) { 2397 if (idp) 2398 *idp = i; 2399 return (symp); 2400 } 2401 } 2402 2403 return (NULL); 2404 } 2405 2406 /* 2407 * Look up a symbol by name in the specified symbol table. 2408 * 2409 * Use a linear or a binary search depending on whether or not we 2410 * chose to sort the table in optimize_symtab(). 2411 */ 2412 static GElf_Sym * 2413 sym_by_name(sym_tbl_t *symtab, const char *name, GElf_Sym *symp, uint_t *idp) 2414 { 2415 if (_libproc_no_qsort) { 2416 return (sym_by_name_linear(symtab, name, symp, idp)); 2417 } else { 2418 return (sym_by_name_binary(symtab, name, symp, idp)); 2419 } 2420 } 2421 2422 /* 2423 * Search the process symbol tables looking for a symbol whose 2424 * value to value+size contain the address specified by addr. 2425 * Return values are: 2426 * sym_name_buffer containing the symbol name 2427 * GElf_Sym symbol table entry 2428 * prsyminfo_t ancillary symbol information 2429 * Returns 0 on success, -1 on failure. 2430 */ 2431 static int 2432 i_Pxlookup_by_addr( 2433 struct ps_prochandle *P, 2434 int lmresolve, /* use resolve linker object names */ 2435 uintptr_t addr, /* process address being sought */ 2436 char *sym_name_buffer, /* buffer for the symbol name */ 2437 size_t bufsize, /* size of sym_name_buffer */ 2438 GElf_Sym *symbolp, /* returned symbol table entry */ 2439 prsyminfo_t *sip) /* returned symbol info */ 2440 { 2441 GElf_Sym *symp; 2442 char *name; 2443 GElf_Sym sym1, *sym1p = NULL; 2444 GElf_Sym sym2, *sym2p = NULL; 2445 char *name1 = NULL; 2446 char *name2 = NULL; 2447 uint_t i1; 2448 uint_t i2; 2449 map_info_t *mptr; 2450 file_info_t *fptr; 2451 2452 (void) Prd_agent(P); 2453 2454 if ((mptr = Paddr2mptr(P, addr)) == NULL || /* no such address */ 2455 (fptr = build_map_symtab(P, mptr)) == NULL || /* no mapped file */ 2456 fptr->file_elf == NULL) /* not an ELF file */ 2457 return (-1); 2458 2459 /* 2460 * Adjust the address by the load object base address in 2461 * case the address turns out to be in a shared library. 2462 */ 2463 addr -= fptr->file_dyn_base; 2464 2465 /* 2466 * Search both symbol tables, symtab first, then dynsym. 2467 */ 2468 if ((sym1p = sym_by_addr(&fptr->file_symtab, addr, &sym1, &i1)) != NULL) 2469 name1 = fptr->file_symtab.sym_strs + sym1.st_name; 2470 if ((sym2p = sym_by_addr(&fptr->file_dynsym, addr, &sym2, &i2)) != NULL) 2471 name2 = fptr->file_dynsym.sym_strs + sym2.st_name; 2472 2473 if ((symp = sym_prefer(sym1p, name1, sym2p, name2)) == NULL) 2474 return (-1); 2475 2476 name = (symp == sym1p) ? name1 : name2; 2477 if (bufsize > 0) { 2478 (void) strncpy(sym_name_buffer, name, bufsize); 2479 sym_name_buffer[bufsize - 1] = '\0'; 2480 } 2481 2482 *symbolp = *symp; 2483 if (sip != NULL) { 2484 sip->prs_name = bufsize == 0 ? NULL : sym_name_buffer; 2485 if (lmresolve && (fptr->file_rname != NULL)) 2486 sip->prs_object = fptr->file_rbase; 2487 else 2488 sip->prs_object = fptr->file_lbase; 2489 sip->prs_id = (symp == sym1p) ? i1 : i2; 2490 sip->prs_table = (symp == sym1p) ? PR_SYMTAB : PR_DYNSYM; 2491 sip->prs_lmid = (fptr->file_lo == NULL) ? LM_ID_BASE : 2492 fptr->file_lo->rl_lmident; 2493 } 2494 2495 if (GELF_ST_TYPE(symbolp->st_info) != STT_TLS) 2496 symbolp->st_value += fptr->file_dyn_base; 2497 2498 return (0); 2499 } 2500 2501 int 2502 Pxlookup_by_addr(struct ps_prochandle *P, uintptr_t addr, char *buf, 2503 size_t bufsize, GElf_Sym *symp, prsyminfo_t *sip) 2504 { 2505 return (i_Pxlookup_by_addr(P, B_FALSE, addr, buf, bufsize, symp, sip)); 2506 } 2507 2508 int 2509 Pxlookup_by_addr_resolved(struct ps_prochandle *P, uintptr_t addr, char *buf, 2510 size_t bufsize, GElf_Sym *symp, prsyminfo_t *sip) 2511 { 2512 return (i_Pxlookup_by_addr(P, B_TRUE, addr, buf, bufsize, symp, sip)); 2513 } 2514 2515 int 2516 Plookup_by_addr(struct ps_prochandle *P, uintptr_t addr, char *buf, 2517 size_t size, GElf_Sym *symp) 2518 { 2519 return (i_Pxlookup_by_addr(P, B_FALSE, addr, buf, size, symp, NULL)); 2520 } 2521 2522 /* 2523 * Search the process symbol tables looking for a symbol whose name matches the 2524 * specified name and whose object and link map optionally match the specified 2525 * parameters. On success, the function returns 0 and fills in the GElf_Sym 2526 * symbol table entry. On failure, -1 is returned. 2527 */ 2528 int 2529 Pxlookup_by_name( 2530 struct ps_prochandle *P, 2531 Lmid_t lmid, /* link map to match, or -1 for any */ 2532 const char *oname, /* load object name */ 2533 const char *sname, /* symbol name */ 2534 GElf_Sym *symp, /* returned symbol table entry */ 2535 prsyminfo_t *sip) /* returned symbol info */ 2536 { 2537 map_info_t *mptr; 2538 file_info_t *fptr; 2539 int cnt; 2540 2541 GElf_Sym sym; 2542 prsyminfo_t si; 2543 int rv = -1; 2544 uint_t id; 2545 2546 if (oname == PR_OBJ_EVERY) { 2547 /* create all the file_info_t's for all the mappings */ 2548 (void) Prd_agent(P); 2549 cnt = P->num_files; 2550 fptr = list_next(&P->file_head); 2551 } else { 2552 cnt = 1; 2553 if ((mptr = object_name_to_map(P, lmid, oname)) == NULL || 2554 (fptr = build_map_symtab(P, mptr)) == NULL) 2555 return (-1); 2556 } 2557 2558 /* 2559 * Iterate through the loaded object files and look for the symbol 2560 * name in the .symtab and .dynsym of each. If we encounter a match 2561 * with SHN_UNDEF, keep looking in hopes of finding a better match. 2562 * This means that a name such as "puts" will match the puts function 2563 * in libc instead of matching the puts PLT entry in the a.out file. 2564 */ 2565 for (; cnt > 0; cnt--, fptr = list_next(fptr)) { 2566 Pbuild_file_symtab(P, fptr); 2567 2568 if (fptr->file_elf == NULL) 2569 continue; 2570 2571 if (lmid != PR_LMID_EVERY && fptr->file_lo != NULL && 2572 lmid != fptr->file_lo->rl_lmident) 2573 continue; 2574 2575 if (fptr->file_symtab.sym_data_pri != NULL && 2576 sym_by_name(&fptr->file_symtab, sname, symp, &id)) { 2577 if (sip != NULL) { 2578 sip->prs_id = id; 2579 sip->prs_table = PR_SYMTAB; 2580 sip->prs_object = oname; 2581 sip->prs_name = sname; 2582 sip->prs_lmid = fptr->file_lo == NULL ? 2583 LM_ID_BASE : fptr->file_lo->rl_lmident; 2584 } 2585 } else if (fptr->file_dynsym.sym_data_pri != NULL && 2586 sym_by_name(&fptr->file_dynsym, sname, symp, &id)) { 2587 if (sip != NULL) { 2588 sip->prs_id = id; 2589 sip->prs_table = PR_DYNSYM; 2590 sip->prs_object = oname; 2591 sip->prs_name = sname; 2592 sip->prs_lmid = fptr->file_lo == NULL ? 2593 LM_ID_BASE : fptr->file_lo->rl_lmident; 2594 } 2595 } else { 2596 continue; 2597 } 2598 2599 if (GELF_ST_TYPE(symp->st_info) != STT_TLS) 2600 symp->st_value += fptr->file_dyn_base; 2601 2602 if (symp->st_shndx != SHN_UNDEF) 2603 return (0); 2604 2605 if (rv != 0) { 2606 if (sip != NULL) 2607 si = *sip; 2608 sym = *symp; 2609 rv = 0; 2610 } 2611 } 2612 2613 if (rv == 0) { 2614 if (sip != NULL) 2615 *sip = si; 2616 *symp = sym; 2617 } 2618 2619 return (rv); 2620 } 2621 2622 /* 2623 * Search the process symbol tables looking for a symbol whose name matches the 2624 * specified name, but without any restriction on the link map id. 2625 */ 2626 int 2627 Plookup_by_name(struct ps_prochandle *P, const char *object, 2628 const char *symbol, GElf_Sym *symp) 2629 { 2630 return (Pxlookup_by_name(P, PR_LMID_EVERY, object, symbol, symp, NULL)); 2631 } 2632 2633 /* 2634 * Iterate over the process's address space mappings. 2635 */ 2636 static int 2637 i_Pmapping_iter(struct ps_prochandle *P, boolean_t lmresolve, 2638 proc_map_f *func, void *cd) 2639 { 2640 map_info_t *mptr; 2641 file_info_t *fptr; 2642 char *object_name; 2643 int rc = 0; 2644 int i; 2645 2646 /* create all the file_info_t's for all the mappings */ 2647 (void) Prd_agent(P); 2648 2649 for (i = 0, mptr = P->mappings; i < P->map_count; i++, mptr++) { 2650 if ((fptr = mptr->map_file) == NULL) 2651 object_name = NULL; 2652 else if (lmresolve && (fptr->file_rname != NULL)) 2653 object_name = fptr->file_rname; 2654 else 2655 object_name = fptr->file_lname; 2656 if ((rc = func(cd, &mptr->map_pmap, object_name)) != 0) 2657 return (rc); 2658 } 2659 return (0); 2660 } 2661 2662 int 2663 Pmapping_iter(struct ps_prochandle *P, proc_map_f *func, void *cd) 2664 { 2665 return (i_Pmapping_iter(P, B_FALSE, func, cd)); 2666 } 2667 2668 int 2669 Pmapping_iter_resolved(struct ps_prochandle *P, proc_map_f *func, void *cd) 2670 { 2671 return (i_Pmapping_iter(P, B_TRUE, func, cd)); 2672 } 2673 2674 /* 2675 * Iterate over the process's mapped objects. 2676 */ 2677 static int 2678 i_Pobject_iter(struct ps_prochandle *P, boolean_t lmresolve, 2679 proc_map_f *func, void *cd) 2680 { 2681 map_info_t *mptr; 2682 file_info_t *fptr; 2683 uint_t cnt; 2684 int rc = 0; 2685 2686 (void) Prd_agent(P); /* create file_info_t's for all the mappings */ 2687 Pupdate_maps(P); 2688 2689 for (cnt = P->num_files, fptr = list_next(&P->file_head); 2690 cnt; cnt--, fptr = list_next(fptr)) { 2691 const char *lname; 2692 2693 if (lmresolve && (fptr->file_rname != NULL)) 2694 lname = fptr->file_rname; 2695 else if (fptr->file_lname != NULL) 2696 lname = fptr->file_lname; 2697 else 2698 lname = ""; 2699 2700 if ((mptr = fptr->file_map) == NULL) 2701 continue; 2702 2703 if ((rc = func(cd, &mptr->map_pmap, lname)) != 0) 2704 return (rc); 2705 2706 if (!P->info_valid) 2707 Pupdate_maps(P); 2708 } 2709 return (0); 2710 } 2711 2712 int 2713 Pobject_iter(struct ps_prochandle *P, proc_map_f *func, void *cd) 2714 { 2715 return (i_Pobject_iter(P, B_FALSE, func, cd)); 2716 } 2717 2718 int 2719 Pobject_iter_resolved(struct ps_prochandle *P, proc_map_f *func, void *cd) 2720 { 2721 return (i_Pobject_iter(P, B_TRUE, func, cd)); 2722 } 2723 2724 static char * 2725 i_Pobjname(struct ps_prochandle *P, boolean_t lmresolve, uintptr_t addr, 2726 char *buffer, size_t bufsize) 2727 { 2728 map_info_t *mptr; 2729 file_info_t *fptr; 2730 2731 /* create all the file_info_t's for all the mappings */ 2732 (void) Prd_agent(P); 2733 2734 if ((mptr = Paddr2mptr(P, addr)) == NULL) 2735 return (NULL); 2736 2737 if (!lmresolve) { 2738 if (((fptr = mptr->map_file) == NULL) || 2739 (fptr->file_lname == NULL)) 2740 return (NULL); 2741 (void) strlcpy(buffer, fptr->file_lname, bufsize); 2742 return (buffer); 2743 } 2744 2745 /* Check for a cached copy of the resolved path */ 2746 if (Pfindmap(P, mptr, buffer, bufsize) != NULL) 2747 return (buffer); 2748 2749 return (NULL); 2750 } 2751 2752 /* 2753 * Given a virtual address, return the name of the underlying 2754 * mapped object (file) as provided by the dynamic linker. 2755 * Return NULL if we can't find any name information for the object. 2756 */ 2757 char * 2758 Pobjname(struct ps_prochandle *P, uintptr_t addr, 2759 char *buffer, size_t bufsize) 2760 { 2761 return (i_Pobjname(P, B_FALSE, addr, buffer, bufsize)); 2762 } 2763 2764 /* 2765 * Given a virtual address, try to return a filesystem path to the 2766 * underlying mapped object (file). If we're in the global zone, 2767 * this path could resolve to an object in another zone. If we're 2768 * unable return a valid filesystem path, we'll fall back to providing 2769 * the mapped object (file) name provided by the dynamic linker in 2770 * the target process (ie, the object reported by Pobjname()). 2771 */ 2772 char * 2773 Pobjname_resolved(struct ps_prochandle *P, uintptr_t addr, 2774 char *buffer, size_t bufsize) 2775 { 2776 return (i_Pobjname(P, B_TRUE, addr, buffer, bufsize)); 2777 } 2778 2779 /* 2780 * Given a virtual address, return the link map id of the underlying mapped 2781 * object (file), as provided by the dynamic linker. Return -1 on failure. 2782 */ 2783 int 2784 Plmid(struct ps_prochandle *P, uintptr_t addr, Lmid_t *lmidp) 2785 { 2786 map_info_t *mptr; 2787 file_info_t *fptr; 2788 2789 /* create all the file_info_t's for all the mappings */ 2790 (void) Prd_agent(P); 2791 2792 if ((mptr = Paddr2mptr(P, addr)) != NULL && 2793 (fptr = mptr->map_file) != NULL && fptr->file_lo != NULL) { 2794 *lmidp = fptr->file_lo->rl_lmident; 2795 return (0); 2796 } 2797 2798 return (-1); 2799 } 2800 2801 /* 2802 * Given an object name and optional lmid, iterate over the object's symbols. 2803 * If which == PR_SYMTAB, search the normal symbol table. 2804 * If which == PR_DYNSYM, search the dynamic symbol table. 2805 */ 2806 static int 2807 Psymbol_iter_com(struct ps_prochandle *P, Lmid_t lmid, const char *object_name, 2808 int which, int mask, pr_order_t order, proc_xsym_f *func, void *cd) 2809 { 2810 #if STT_NUM != (STT_TLS + 1) 2811 #error "STT_NUM has grown. update Psymbol_iter_com()" 2812 #endif 2813 2814 GElf_Sym sym; 2815 GElf_Shdr shdr; 2816 map_info_t *mptr; 2817 file_info_t *fptr; 2818 sym_tbl_t *symtab; 2819 size_t symn; 2820 const char *strs; 2821 size_t strsz; 2822 prsyminfo_t si; 2823 int rv; 2824 uint_t *map, i, count, ndx; 2825 2826 if ((mptr = object_name_to_map(P, lmid, object_name)) == NULL) 2827 return (-1); 2828 2829 if ((fptr = build_map_symtab(P, mptr)) == NULL || /* no mapped file */ 2830 fptr->file_elf == NULL) /* not an ELF file */ 2831 return (-1); 2832 2833 /* 2834 * Search the specified symbol table. 2835 */ 2836 switch (which) { 2837 case PR_SYMTAB: 2838 symtab = &fptr->file_symtab; 2839 si.prs_table = PR_SYMTAB; 2840 break; 2841 case PR_DYNSYM: 2842 symtab = &fptr->file_dynsym; 2843 si.prs_table = PR_DYNSYM; 2844 break; 2845 default: 2846 return (-1); 2847 } 2848 2849 si.prs_object = object_name; 2850 si.prs_lmid = fptr->file_lo == NULL ? 2851 LM_ID_BASE : fptr->file_lo->rl_lmident; 2852 2853 symn = symtab->sym_symn; 2854 strs = symtab->sym_strs; 2855 strsz = symtab->sym_strsz; 2856 2857 switch (order) { 2858 case PRO_NATURAL: 2859 map = NULL; 2860 count = symn; 2861 break; 2862 case PRO_BYNAME: 2863 map = symtab->sym_byname; 2864 count = symtab->sym_count; 2865 break; 2866 case PRO_BYADDR: 2867 map = symtab->sym_byaddr; 2868 count = symtab->sym_count; 2869 break; 2870 default: 2871 return (-1); 2872 } 2873 2874 if (symtab->sym_data_pri == NULL || strs == NULL || count == 0) 2875 return (-1); 2876 2877 rv = 0; 2878 2879 for (i = 0; i < count; i++) { 2880 ndx = map == NULL ? i : map[i]; 2881 if (symtab_getsym(symtab, ndx, &sym) != NULL) { 2882 uint_t s_bind, s_type, type; 2883 2884 if (sym.st_name >= strsz) /* invalid st_name */ 2885 continue; 2886 2887 s_bind = GELF_ST_BIND(sym.st_info); 2888 s_type = GELF_ST_TYPE(sym.st_info); 2889 2890 /* 2891 * In case you haven't already guessed, this relies on 2892 * the bitmask used in <libproc.h> for encoding symbol 2893 * type and binding matching the order of STB and STT 2894 * constants in <sys/elf.h>. Changes to ELF must 2895 * maintain binary compatibility, so I think this is 2896 * reasonably fair game. 2897 */ 2898 if (s_bind < STB_NUM && s_type < STT_NUM) { 2899 type = (1 << (s_type + 8)) | (1 << s_bind); 2900 if ((type & ~mask) != 0) 2901 continue; 2902 } else 2903 continue; /* Invalid type or binding */ 2904 2905 if (GELF_ST_TYPE(sym.st_info) != STT_TLS) 2906 sym.st_value += fptr->file_dyn_base; 2907 2908 si.prs_name = strs + sym.st_name; 2909 2910 /* 2911 * If symbol's type is STT_SECTION, then try to lookup 2912 * the name of the corresponding section. 2913 */ 2914 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION && 2915 fptr->file_shstrs != NULL && 2916 gelf_getshdr(elf_getscn(fptr->file_elf, 2917 sym.st_shndx), &shdr) != NULL && 2918 shdr.sh_name != 0 && 2919 shdr.sh_name < fptr->file_shstrsz) 2920 si.prs_name = fptr->file_shstrs + shdr.sh_name; 2921 2922 si.prs_id = ndx; 2923 if ((rv = func(cd, &sym, si.prs_name, &si)) != 0) 2924 break; 2925 } 2926 } 2927 2928 return (rv); 2929 } 2930 2931 int 2932 Pxsymbol_iter(struct ps_prochandle *P, Lmid_t lmid, const char *object_name, 2933 int which, int mask, proc_xsym_f *func, void *cd) 2934 { 2935 return (Psymbol_iter_com(P, lmid, object_name, which, mask, 2936 PRO_NATURAL, func, cd)); 2937 } 2938 2939 int 2940 Psymbol_iter_by_lmid(struct ps_prochandle *P, Lmid_t lmid, 2941 const char *object_name, int which, int mask, proc_sym_f *func, void *cd) 2942 { 2943 return (Psymbol_iter_com(P, lmid, object_name, which, mask, 2944 PRO_NATURAL, (proc_xsym_f *)func, cd)); 2945 } 2946 2947 int 2948 Psymbol_iter(struct ps_prochandle *P, 2949 const char *object_name, int which, int mask, proc_sym_f *func, void *cd) 2950 { 2951 return (Psymbol_iter_com(P, PR_LMID_EVERY, object_name, which, mask, 2952 PRO_NATURAL, (proc_xsym_f *)func, cd)); 2953 } 2954 2955 int 2956 Psymbol_iter_by_addr(struct ps_prochandle *P, 2957 const char *object_name, int which, int mask, proc_sym_f *func, void *cd) 2958 { 2959 return (Psymbol_iter_com(P, PR_LMID_EVERY, object_name, which, mask, 2960 PRO_BYADDR, (proc_xsym_f *)func, cd)); 2961 } 2962 2963 int 2964 Psymbol_iter_by_name(struct ps_prochandle *P, 2965 const char *object_name, int which, int mask, proc_sym_f *func, void *cd) 2966 { 2967 return (Psymbol_iter_com(P, PR_LMID_EVERY, object_name, which, mask, 2968 PRO_BYNAME, (proc_xsym_f *)func, cd)); 2969 } 2970 2971 /* 2972 * Get the platform string from the core file if we have it; 2973 * just perform the system call for the caller if this is a live process. 2974 */ 2975 char * 2976 Pplatform(struct ps_prochandle *P, char *s, size_t n) 2977 { 2978 if (P->state == PS_IDLE) { 2979 errno = ENODATA; 2980 return (NULL); 2981 } 2982 2983 if (P->state == PS_DEAD) { 2984 if (P->core->core_platform == NULL) { 2985 errno = ENODATA; 2986 return (NULL); 2987 } 2988 (void) strncpy(s, P->core->core_platform, n - 1); 2989 s[n - 1] = '\0'; 2990 2991 } else if (sysinfo(SI_PLATFORM, s, n) == -1) 2992 return (NULL); 2993 2994 return (s); 2995 } 2996 2997 /* 2998 * Get the uname(2) information from the core file if we have it; 2999 * just perform the system call for the caller if this is a live process. 3000 */ 3001 int 3002 Puname(struct ps_prochandle *P, struct utsname *u) 3003 { 3004 if (P->state == PS_IDLE) { 3005 errno = ENODATA; 3006 return (-1); 3007 } 3008 3009 if (P->state == PS_DEAD) { 3010 if (P->core->core_uts == NULL) { 3011 errno = ENODATA; 3012 return (-1); 3013 } 3014 (void) memcpy(u, P->core->core_uts, sizeof (struct utsname)); 3015 return (0); 3016 } 3017 return (uname(u)); 3018 } 3019 3020 /* 3021 * Called from Pcreate(), Pgrab(), and Pfgrab_core() to initialize 3022 * the symbol table heads in the new ps_prochandle. 3023 */ 3024 void 3025 Pinitsym(struct ps_prochandle *P) 3026 { 3027 P->num_files = 0; 3028 list_link(&P->file_head, NULL); 3029 } 3030 3031 /* 3032 * Called from Prelease() to destroy the symbol tables. 3033 * Must be called by the client after an exec() in the victim process. 3034 */ 3035 void 3036 Preset_maps(struct ps_prochandle *P) 3037 { 3038 int i; 3039 3040 if (P->rap != NULL) { 3041 rd_delete(P->rap); 3042 P->rap = NULL; 3043 } 3044 3045 if (P->execname != NULL) { 3046 free(P->execname); 3047 P->execname = NULL; 3048 } 3049 3050 if (P->auxv != NULL) { 3051 free(P->auxv); 3052 P->auxv = NULL; 3053 P->nauxv = 0; 3054 } 3055 3056 for (i = 0; i < P->map_count; i++) 3057 map_info_free(P, &P->mappings[i]); 3058 3059 if (P->mappings != NULL) { 3060 free(P->mappings); 3061 P->mappings = NULL; 3062 } 3063 P->map_count = P->map_alloc = 0; 3064 3065 P->info_valid = 0; 3066 } 3067 3068 typedef struct getenv_data { 3069 char *buf; 3070 size_t bufsize; 3071 const char *search; 3072 size_t searchlen; 3073 } getenv_data_t; 3074 3075 /*ARGSUSED*/ 3076 static int 3077 getenv_func(void *data, struct ps_prochandle *P, uintptr_t addr, 3078 const char *nameval) 3079 { 3080 getenv_data_t *d = data; 3081 size_t len; 3082 3083 if (nameval == NULL) 3084 return (0); 3085 3086 if (d->searchlen < strlen(nameval) && 3087 strncmp(nameval, d->search, d->searchlen) == 0 && 3088 nameval[d->searchlen] == '=') { 3089 len = MIN(strlen(nameval), d->bufsize - 1); 3090 (void) strncpy(d->buf, nameval, len); 3091 d->buf[len] = '\0'; 3092 return (1); 3093 } 3094 3095 return (0); 3096 } 3097 3098 char * 3099 Pgetenv(struct ps_prochandle *P, const char *name, char *buf, size_t buflen) 3100 { 3101 getenv_data_t d; 3102 3103 d.buf = buf; 3104 d.bufsize = buflen; 3105 d.search = name; 3106 d.searchlen = strlen(name); 3107 3108 if (Penv_iter(P, getenv_func, &d) == 1) { 3109 char *equals = strchr(d.buf, '='); 3110 3111 if (equals != NULL) { 3112 (void) memmove(d.buf, equals + 1, 3113 d.buf + buflen - equals - 1); 3114 d.buf[d.buf + buflen - equals] = '\0'; 3115 3116 return (buf); 3117 } 3118 } 3119 3120 return (NULL); 3121 } 3122 3123 /* number of argument or environment pointers to read all at once */ 3124 #define NARG 100 3125 3126 int 3127 Penv_iter(struct ps_prochandle *P, proc_env_f *func, void *data) 3128 { 3129 const psinfo_t *psp; 3130 uintptr_t envpoff; 3131 GElf_Sym sym; 3132 int ret; 3133 char *buf, *nameval; 3134 size_t buflen; 3135 3136 int nenv = NARG; 3137 long envp[NARG]; 3138 3139 /* 3140 * Attempt to find the "_environ" variable in the process. 3141 * Failing that, use the original value provided by Ppsinfo(). 3142 */ 3143 if ((psp = Ppsinfo(P)) == NULL) 3144 return (-1); 3145 3146 envpoff = psp->pr_envp; /* Default if no _environ found */ 3147 3148 if (Plookup_by_name(P, PR_OBJ_EXEC, "_environ", &sym) == 0) { 3149 if (P->status.pr_dmodel == PR_MODEL_NATIVE) { 3150 if (Pread(P, &envpoff, sizeof (envpoff), 3151 sym.st_value) != sizeof (envpoff)) 3152 envpoff = psp->pr_envp; 3153 } else if (P->status.pr_dmodel == PR_MODEL_ILP32) { 3154 uint32_t envpoff32; 3155 3156 if (Pread(P, &envpoff32, sizeof (envpoff32), 3157 sym.st_value) != sizeof (envpoff32)) 3158 envpoff = psp->pr_envp; 3159 else 3160 envpoff = envpoff32; 3161 } 3162 } 3163 3164 buflen = 128; 3165 buf = malloc(buflen); 3166 3167 ret = 0; 3168 for (;;) { 3169 uintptr_t envoff; 3170 3171 if (nenv == NARG) { 3172 (void) memset(envp, 0, sizeof (envp)); 3173 if (P->status.pr_dmodel == PR_MODEL_NATIVE) { 3174 if (Pread(P, envp, 3175 sizeof (envp), envpoff) <= 0) { 3176 ret = -1; 3177 break; 3178 } 3179 } else if (P->status.pr_dmodel == PR_MODEL_ILP32) { 3180 uint32_t e32[NARG]; 3181 int i; 3182 3183 (void) memset(e32, 0, sizeof (e32)); 3184 if (Pread(P, e32, sizeof (e32), envpoff) <= 0) { 3185 ret = -1; 3186 break; 3187 } 3188 for (i = 0; i < NARG; i++) 3189 envp[i] = e32[i]; 3190 } 3191 nenv = 0; 3192 } 3193 3194 if ((envoff = envp[nenv++]) == NULL) 3195 break; 3196 3197 /* 3198 * Attempt to read the string from the process. 3199 */ 3200 again: 3201 ret = Pread_string(P, buf, buflen, envoff); 3202 3203 if (ret <= 0) { 3204 nameval = NULL; 3205 } else if (ret == buflen - 1) { 3206 free(buf); 3207 /* 3208 * Bail if we have a corrupted environment 3209 */ 3210 if (buflen >= ARG_MAX) 3211 return (-1); 3212 buflen *= 2; 3213 buf = malloc(buflen); 3214 goto again; 3215 } else { 3216 nameval = buf; 3217 } 3218 3219 if ((ret = func(data, P, envoff, nameval)) != 0) 3220 break; 3221 3222 envpoff += (P->status.pr_dmodel == PR_MODEL_LP64)? 8 : 4; 3223 } 3224 3225 free(buf); 3226 3227 return (ret); 3228 } 3229