pmcstat_log.c revision 299826
1/*- 2 * Copyright (c) 2005-2007, Joseph Koshy 3 * Copyright (c) 2007 The FreeBSD Foundation 4 * All rights reserved. 5 * 6 * Portions of this software were developed by A. Joseph Koshy under 7 * sponsorship from the FreeBSD Foundation and Google, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31/* 32 * Transform a hwpmc(4) log into human readable form, and into 33 * gprof(1) compatible profiles. 34 */ 35 36#include <sys/cdefs.h> 37__FBSDID("$FreeBSD: stable/10/usr.sbin/pmcstat/pmcstat_log.c 299826 2016-05-15 03:15:36Z pfg $"); 38 39#include <sys/param.h> 40#include <sys/endian.h> 41#include <sys/cpuset.h> 42#include <sys/gmon.h> 43#include <sys/imgact_aout.h> 44#include <sys/imgact_elf.h> 45#include <sys/mman.h> 46#include <sys/pmc.h> 47#include <sys/queue.h> 48#include <sys/socket.h> 49#include <sys/stat.h> 50#include <sys/wait.h> 51 52#include <netinet/in.h> 53 54#include <assert.h> 55#include <curses.h> 56#include <err.h> 57#include <errno.h> 58#include <fcntl.h> 59#include <gelf.h> 60#include <libgen.h> 61#include <limits.h> 62#include <netdb.h> 63#include <pmc.h> 64#include <pmclog.h> 65#include <sysexits.h> 66#include <stdint.h> 67#include <stdio.h> 68#include <stdlib.h> 69#include <string.h> 70#include <unistd.h> 71 72#include "pmcstat.h" 73#include "pmcstat_log.h" 74#include "pmcstat_top.h" 75 76#define PMCSTAT_ALLOCATE 1 77 78/* 79 * PUBLIC INTERFACES 80 * 81 * pmcstat_initialize_logging() initialize this module, called first 82 * pmcstat_shutdown_logging() orderly shutdown, called last 83 * pmcstat_open_log() open an eventlog for processing 84 * pmcstat_process_log() print/convert an event log 85 * pmcstat_display_log() top mode display for the log 86 * pmcstat_close_log() finish processing an event log 87 * 88 * IMPLEMENTATION NOTES 89 * 90 * We correlate each 'callchain' or 'sample' entry seen in the event 91 * log back to an executable object in the system. Executable objects 92 * include: 93 * - program executables, 94 * - shared libraries loaded by the runtime loader, 95 * - dlopen()'ed objects loaded by the program, 96 * - the runtime loader itself, 97 * - the kernel and kernel modules. 98 * 99 * Each process that we know about is treated as a set of regions that 100 * map to executable objects. Processes are described by 101 * 'pmcstat_process' structures. Executable objects are tracked by 102 * 'pmcstat_image' structures. The kernel and kernel modules are 103 * common to all processes (they reside at the same virtual addresses 104 * for all processes). Individual processes can have their text 105 * segments and shared libraries loaded at process-specific locations. 106 * 107 * A given executable object can be in use by multiple processes 108 * (e.g., libc.so) and loaded at a different address in each. 109 * pmcstat_pcmap structures track per-image mappings. 110 * 111 * The sample log could have samples from multiple PMCs; we 112 * generate one 'gmon.out' profile per PMC. 113 * 114 * IMPLEMENTATION OF GMON OUTPUT 115 * 116 * Each executable object gets one 'gmon.out' profile, per PMC in 117 * use. Creation of 'gmon.out' profiles is done lazily. The 118 * 'gmon.out' profiles generated for a given sampling PMC are 119 * aggregates of all the samples for that particular executable 120 * object. 121 * 122 * IMPLEMENTATION OF SYSTEM-WIDE CALLGRAPH OUTPUT 123 * 124 * Each active pmcid has its own callgraph structure, described by a 125 * 'struct pmcstat_callgraph'. Given a process id and a list of pc 126 * values, we map each pc value to a tuple (image, symbol), where 127 * 'image' denotes an executable object and 'symbol' is the closest 128 * symbol that precedes the pc value. Each pc value in the list is 129 * also given a 'rank' that reflects its depth in the call stack. 130 */ 131 132struct pmcstat_pmcs pmcstat_pmcs = LIST_HEAD_INITIALIZER(pmcstat_pmcs); 133 134/* 135 * All image descriptors are kept in a hash table. 136 */ 137struct pmcstat_image_hash_list pmcstat_image_hash[PMCSTAT_NHASH]; 138 139/* 140 * All process descriptors are kept in a hash table. 141 */ 142struct pmcstat_process_hash_list pmcstat_process_hash[PMCSTAT_NHASH]; 143 144struct pmcstat_stats pmcstat_stats; /* statistics */ 145static int ps_samples_period; /* samples count between top refresh. */ 146 147struct pmcstat_process *pmcstat_kernproc; /* kernel 'process' */ 148 149#include "pmcpl_gprof.h" 150#include "pmcpl_callgraph.h" 151#include "pmcpl_annotate.h" 152#include "pmcpl_annotate_cg.h" 153#include "pmcpl_calltree.h" 154 155static struct pmc_plugins { 156 const char *pl_name; /* name */ 157 158 /* configure */ 159 int (*pl_configure)(char *opt); 160 161 /* init and shutdown */ 162 int (*pl_init)(void); 163 void (*pl_shutdown)(FILE *mf); 164 165 /* sample processing */ 166 void (*pl_process)(struct pmcstat_process *pp, 167 struct pmcstat_pmcrecord *pmcr, uint32_t nsamples, 168 uintfptr_t *cc, int usermode, uint32_t cpu); 169 170 /* image */ 171 void (*pl_initimage)(struct pmcstat_image *pi); 172 void (*pl_shutdownimage)(struct pmcstat_image *pi); 173 174 /* pmc */ 175 void (*pl_newpmc)(pmcstat_interned_string ps, 176 struct pmcstat_pmcrecord *pr); 177 178 /* top display */ 179 void (*pl_topdisplay)(void); 180 181 /* top keypress */ 182 int (*pl_topkeypress)(int c, WINDOW *w); 183 184} plugins[] = { 185 { 186 .pl_name = "none", 187 }, 188 { 189 .pl_name = "callgraph", 190 .pl_init = pmcpl_cg_init, 191 .pl_shutdown = pmcpl_cg_shutdown, 192 .pl_process = pmcpl_cg_process, 193 .pl_topkeypress = pmcpl_cg_topkeypress, 194 .pl_topdisplay = pmcpl_cg_topdisplay 195 }, 196 { 197 .pl_name = "gprof", 198 .pl_shutdown = pmcpl_gmon_shutdown, 199 .pl_process = pmcpl_gmon_process, 200 .pl_initimage = pmcpl_gmon_initimage, 201 .pl_shutdownimage = pmcpl_gmon_shutdownimage, 202 .pl_newpmc = pmcpl_gmon_newpmc 203 }, 204 { 205 .pl_name = "annotate", 206 .pl_process = pmcpl_annotate_process 207 }, 208 { 209 .pl_name = "calltree", 210 .pl_configure = pmcpl_ct_configure, 211 .pl_init = pmcpl_ct_init, 212 .pl_shutdown = pmcpl_ct_shutdown, 213 .pl_process = pmcpl_ct_process, 214 .pl_topkeypress = pmcpl_ct_topkeypress, 215 .pl_topdisplay = pmcpl_ct_topdisplay 216 }, 217 { 218 .pl_name = "annotate_cg", 219 .pl_process = pmcpl_annotate_cg_process 220 }, 221 222 { 223 .pl_name = NULL 224 } 225}; 226 227static int pmcstat_mergepmc; 228 229int pmcstat_pmcinfilter = 0; /* PMC filter for top mode. */ 230float pmcstat_threshold = 0.5; /* Cost filter for top mode. */ 231 232/* 233 * Prototypes 234 */ 235 236static struct pmcstat_image *pmcstat_image_from_path(pmcstat_interned_string 237 _path, int _iskernelmodule); 238static void pmcstat_image_get_aout_params(struct pmcstat_image *_image); 239static void pmcstat_image_get_elf_params(struct pmcstat_image *_image); 240static void pmcstat_image_link(struct pmcstat_process *_pp, 241 struct pmcstat_image *_i, uintfptr_t _lpc); 242 243static void pmcstat_pmcid_add(pmc_id_t _pmcid, 244 pmcstat_interned_string _name); 245 246static void pmcstat_process_aout_exec(struct pmcstat_process *_pp, 247 struct pmcstat_image *_image, uintfptr_t _entryaddr); 248static void pmcstat_process_elf_exec(struct pmcstat_process *_pp, 249 struct pmcstat_image *_image, uintfptr_t _entryaddr); 250static void pmcstat_process_exec(struct pmcstat_process *_pp, 251 pmcstat_interned_string _path, uintfptr_t _entryaddr); 252static struct pmcstat_process *pmcstat_process_lookup(pid_t _pid, 253 int _allocate); 254static int pmcstat_string_compute_hash(const char *_string); 255static void pmcstat_string_initialize(void); 256static int pmcstat_string_lookup_hash(pmcstat_interned_string _is); 257static void pmcstat_string_shutdown(void); 258static void pmcstat_stats_reset(int _reset_global); 259 260/* 261 * A simple implementation of interned strings. Each interned string 262 * is assigned a unique address, so that subsequent string compares 263 * can be done by a simple pointer comparison instead of using 264 * strcmp(). This speeds up hash table lookups and saves memory if 265 * duplicate strings are the norm. 266 */ 267struct pmcstat_string { 268 LIST_ENTRY(pmcstat_string) ps_next; /* hash link */ 269 int ps_len; 270 int ps_hash; 271 char *ps_string; 272}; 273 274static LIST_HEAD(,pmcstat_string) pmcstat_string_hash[PMCSTAT_NHASH]; 275 276/* 277 * PMC count. 278 */ 279int pmcstat_npmcs; 280 281/* 282 * PMC Top mode pause state. 283 */ 284static int pmcstat_pause; 285 286static void 287pmcstat_stats_reset(int reset_global) 288{ 289 struct pmcstat_pmcrecord *pr; 290 291 /* Flush PMCs stats. */ 292 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) { 293 pr->pr_samples = 0; 294 pr->pr_dubious_frames = 0; 295 } 296 ps_samples_period = 0; 297 298 /* Flush global stats. */ 299 if (reset_global) 300 bzero(&pmcstat_stats, sizeof(struct pmcstat_stats)); 301} 302 303/* 304 * Compute a 'hash' value for a string. 305 */ 306 307static int 308pmcstat_string_compute_hash(const char *s) 309{ 310 unsigned hash; 311 312 for (hash = 2166136261; *s; s++) 313 hash = (hash ^ *s) * 16777619; 314 315 return (hash & PMCSTAT_HASH_MASK); 316} 317 318/* 319 * Intern a copy of string 's', and return a pointer to the 320 * interned structure. 321 */ 322 323pmcstat_interned_string 324pmcstat_string_intern(const char *s) 325{ 326 struct pmcstat_string *ps; 327 const struct pmcstat_string *cps; 328 int hash, len; 329 330 if ((cps = pmcstat_string_lookup(s)) != NULL) 331 return (cps); 332 333 hash = pmcstat_string_compute_hash(s); 334 len = strlen(s); 335 336 if ((ps = malloc(sizeof(*ps))) == NULL) 337 err(EX_OSERR, "ERROR: Could not intern string"); 338 ps->ps_len = len; 339 ps->ps_hash = hash; 340 ps->ps_string = strdup(s); 341 LIST_INSERT_HEAD(&pmcstat_string_hash[hash], ps, ps_next); 342 return ((pmcstat_interned_string) ps); 343} 344 345const char * 346pmcstat_string_unintern(pmcstat_interned_string str) 347{ 348 const char *s; 349 350 s = ((const struct pmcstat_string *) str)->ps_string; 351 return (s); 352} 353 354pmcstat_interned_string 355pmcstat_string_lookup(const char *s) 356{ 357 struct pmcstat_string *ps; 358 int hash, len; 359 360 hash = pmcstat_string_compute_hash(s); 361 len = strlen(s); 362 363 LIST_FOREACH(ps, &pmcstat_string_hash[hash], ps_next) 364 if (ps->ps_len == len && ps->ps_hash == hash && 365 strcmp(ps->ps_string, s) == 0) 366 return (ps); 367 return (NULL); 368} 369 370static int 371pmcstat_string_lookup_hash(pmcstat_interned_string s) 372{ 373 const struct pmcstat_string *ps; 374 375 ps = (const struct pmcstat_string *) s; 376 return (ps->ps_hash); 377} 378 379/* 380 * Initialize the string interning facility. 381 */ 382 383static void 384pmcstat_string_initialize(void) 385{ 386 int i; 387 388 for (i = 0; i < PMCSTAT_NHASH; i++) 389 LIST_INIT(&pmcstat_string_hash[i]); 390} 391 392/* 393 * Destroy the string table, free'ing up space. 394 */ 395 396static void 397pmcstat_string_shutdown(void) 398{ 399 int i; 400 struct pmcstat_string *ps, *pstmp; 401 402 for (i = 0; i < PMCSTAT_NHASH; i++) 403 LIST_FOREACH_SAFE(ps, &pmcstat_string_hash[i], ps_next, 404 pstmp) { 405 LIST_REMOVE(ps, ps_next); 406 free(ps->ps_string); 407 free(ps); 408 } 409} 410 411/* 412 * Determine whether a given executable image is an A.OUT object, and 413 * if so, fill in its parameters from the text file. 414 * Sets image->pi_type. 415 */ 416 417static void 418pmcstat_image_get_aout_params(struct pmcstat_image *image) 419{ 420 int fd; 421 ssize_t nbytes; 422 struct exec ex; 423 const char *path; 424 char buffer[PATH_MAX]; 425 426 path = pmcstat_string_unintern(image->pi_execpath); 427 assert(path != NULL); 428 429 if (image->pi_iskernelmodule) 430 errx(EX_SOFTWARE, 431 "ERROR: a.out kernel modules are unsupported \"%s\"", path); 432 433 (void) snprintf(buffer, sizeof(buffer), "%s%s", 434 args.pa_fsroot, path); 435 436 if ((fd = open(buffer, O_RDONLY, 0)) < 0 || 437 (nbytes = read(fd, &ex, sizeof(ex))) < 0) { 438 if (args.pa_verbosity >= 2) 439 warn("WARNING: Cannot determine type of \"%s\"", 440 path); 441 image->pi_type = PMCSTAT_IMAGE_INDETERMINABLE; 442 if (fd != -1) 443 (void) close(fd); 444 return; 445 } 446 447 (void) close(fd); 448 449 if ((unsigned) nbytes != sizeof(ex) || 450 N_BADMAG(ex)) 451 return; 452 453 image->pi_type = PMCSTAT_IMAGE_AOUT; 454 455 /* TODO: the rest of a.out processing */ 456 457 return; 458} 459 460/* 461 * Helper function. 462 */ 463 464static int 465pmcstat_symbol_compare(const void *a, const void *b) 466{ 467 const struct pmcstat_symbol *sym1, *sym2; 468 469 sym1 = (const struct pmcstat_symbol *) a; 470 sym2 = (const struct pmcstat_symbol *) b; 471 472 if (sym1->ps_end <= sym2->ps_start) 473 return (-1); 474 if (sym1->ps_start >= sym2->ps_end) 475 return (1); 476 return (0); 477} 478 479/* 480 * Map an address to a symbol in an image. 481 */ 482 483struct pmcstat_symbol * 484pmcstat_symbol_search(struct pmcstat_image *image, uintfptr_t addr) 485{ 486 struct pmcstat_symbol sym; 487 488 if (image->pi_symbols == NULL) 489 return (NULL); 490 491 sym.ps_name = NULL; 492 sym.ps_start = addr; 493 sym.ps_end = addr + 1; 494 495 return (bsearch((void *) &sym, image->pi_symbols, 496 image->pi_symcount, sizeof(struct pmcstat_symbol), 497 pmcstat_symbol_compare)); 498} 499 500/* 501 * Add the list of symbols in the given section to the list associated 502 * with the object. 503 */ 504static void 505pmcstat_image_add_symbols(struct pmcstat_image *image, Elf *e, 506 Elf_Scn *scn, GElf_Shdr *sh) 507{ 508 int firsttime; 509 size_t n, newsyms, nshsyms, nfuncsyms; 510 struct pmcstat_symbol *symptr; 511 char *fnname; 512 GElf_Sym sym; 513 Elf_Data *data; 514 515 if ((data = elf_getdata(scn, NULL)) == NULL) 516 return; 517 518 /* 519 * Determine the number of functions named in this 520 * section. 521 */ 522 523 nshsyms = sh->sh_size / sh->sh_entsize; 524 for (n = nfuncsyms = 0; n < nshsyms; n++) { 525 if (gelf_getsym(data, (int) n, &sym) != &sym) 526 return; 527 if (GELF_ST_TYPE(sym.st_info) == STT_FUNC) 528 nfuncsyms++; 529 } 530 531 if (nfuncsyms == 0) 532 return; 533 534 /* 535 * Allocate space for the new entries. 536 */ 537 firsttime = image->pi_symbols == NULL; 538 symptr = realloc(image->pi_symbols, 539 sizeof(*symptr) * (image->pi_symcount + nfuncsyms)); 540 if (symptr == image->pi_symbols) /* realloc() failed. */ 541 return; 542 image->pi_symbols = symptr; 543 544 /* 545 * Append new symbols to the end of the current table. 546 */ 547 symptr += image->pi_symcount; 548 549 for (n = newsyms = 0; n < nshsyms; n++) { 550 if (gelf_getsym(data, (int) n, &sym) != &sym) 551 return; 552 if (GELF_ST_TYPE(sym.st_info) != STT_FUNC) 553 continue; 554 if (sym.st_shndx == STN_UNDEF) 555 continue; 556 557 if (!firsttime && pmcstat_symbol_search(image, sym.st_value)) 558 continue; /* We've seen this symbol already. */ 559 560 if ((fnname = elf_strptr(e, sh->sh_link, sym.st_name)) 561 == NULL) 562 continue; 563#ifdef __arm__ 564 /* Remove spurious ARM function name. */ 565 if (fnname[0] == '$' && 566 (fnname[1] == 'a' || fnname[1] == 't' || 567 fnname[1] == 'd') && 568 fnname[2] == '\0') 569 continue; 570#endif 571 572 symptr->ps_name = pmcstat_string_intern(fnname); 573 symptr->ps_start = sym.st_value - image->pi_vaddr; 574 symptr->ps_end = symptr->ps_start + sym.st_size; 575 symptr++; 576 577 newsyms++; 578 } 579 580 image->pi_symcount += newsyms; 581 if (image->pi_symcount == 0) 582 return; 583 584 assert(newsyms <= nfuncsyms); 585 586 /* 587 * Return space to the system if there were duplicates. 588 */ 589 if (newsyms < nfuncsyms) 590 image->pi_symbols = realloc(image->pi_symbols, 591 sizeof(*symptr) * image->pi_symcount); 592 593 /* 594 * Keep the list of symbols sorted. 595 */ 596 qsort(image->pi_symbols, image->pi_symcount, sizeof(*symptr), 597 pmcstat_symbol_compare); 598 599 /* 600 * Deal with function symbols that have a size of 'zero' by 601 * making them extend to the next higher address. These 602 * symbols are usually defined in assembly code. 603 */ 604 for (symptr = image->pi_symbols; 605 symptr < image->pi_symbols + (image->pi_symcount - 1); 606 symptr++) 607 if (symptr->ps_start == symptr->ps_end) 608 symptr->ps_end = (symptr+1)->ps_start; 609} 610 611/* 612 * Examine an ELF file to determine the size of its text segment. 613 * Sets image->pi_type if anything conclusive can be determined about 614 * this image. 615 */ 616 617static void 618pmcstat_image_get_elf_params(struct pmcstat_image *image) 619{ 620 int fd; 621 size_t i, nph, nsh; 622 const char *path, *elfbase; 623 char *p, *endp; 624 uintfptr_t minva, maxva; 625 Elf *e; 626 Elf_Scn *scn; 627 GElf_Ehdr eh; 628 GElf_Phdr ph; 629 GElf_Shdr sh; 630 enum pmcstat_image_type image_type; 631 char buffer[PATH_MAX]; 632 633 assert(image->pi_type == PMCSTAT_IMAGE_UNKNOWN); 634 635 image->pi_start = minva = ~(uintfptr_t) 0; 636 image->pi_end = maxva = (uintfptr_t) 0; 637 image->pi_type = image_type = PMCSTAT_IMAGE_INDETERMINABLE; 638 image->pi_isdynamic = 0; 639 image->pi_dynlinkerpath = NULL; 640 image->pi_vaddr = 0; 641 642 path = pmcstat_string_unintern(image->pi_execpath); 643 assert(path != NULL); 644 645 /* 646 * Look for kernel modules under FSROOT/KERNELPATH/NAME, 647 * and user mode executable objects under FSROOT/PATHNAME. 648 */ 649 if (image->pi_iskernelmodule) 650 (void) snprintf(buffer, sizeof(buffer), "%s%s/%s", 651 args.pa_fsroot, args.pa_kernel, path); 652 else 653 (void) snprintf(buffer, sizeof(buffer), "%s%s", 654 args.pa_fsroot, path); 655 656 e = NULL; 657 if ((fd = open(buffer, O_RDONLY, 0)) < 0 || 658 (e = elf_begin(fd, ELF_C_READ, NULL)) == NULL || 659 (elf_kind(e) != ELF_K_ELF)) { 660 if (args.pa_verbosity >= 2) 661 warnx("WARNING: Cannot determine the type of \"%s\".", 662 buffer); 663 goto done; 664 } 665 666 if (gelf_getehdr(e, &eh) != &eh) { 667 warnx( 668 "WARNING: Cannot retrieve the ELF Header for \"%s\": %s.", 669 buffer, elf_errmsg(-1)); 670 goto done; 671 } 672 673 if (eh.e_type != ET_EXEC && eh.e_type != ET_DYN && 674 !(image->pi_iskernelmodule && eh.e_type == ET_REL)) { 675 warnx("WARNING: \"%s\" is of an unsupported ELF type.", 676 buffer); 677 goto done; 678 } 679 680 image_type = eh.e_ident[EI_CLASS] == ELFCLASS32 ? 681 PMCSTAT_IMAGE_ELF32 : PMCSTAT_IMAGE_ELF64; 682 683 /* 684 * Determine the virtual address where an executable would be 685 * loaded. Additionally, for dynamically linked executables, 686 * save the pathname to the runtime linker. 687 */ 688 if (eh.e_type == ET_EXEC) { 689 if (elf_getphnum(e, &nph) == 0) { 690 warnx( 691"WARNING: Could not determine the number of program headers in \"%s\": %s.", 692 buffer, 693 elf_errmsg(-1)); 694 goto done; 695 } 696 for (i = 0; i < eh.e_phnum; i++) { 697 if (gelf_getphdr(e, i, &ph) != &ph) { 698 warnx( 699"WARNING: Retrieval of PHDR entry #%ju in \"%s\" failed: %s.", 700 (uintmax_t) i, buffer, elf_errmsg(-1)); 701 goto done; 702 } 703 switch (ph.p_type) { 704 case PT_DYNAMIC: 705 image->pi_isdynamic = 1; 706 break; 707 case PT_INTERP: 708 if ((elfbase = elf_rawfile(e, NULL)) == NULL) { 709 warnx( 710"WARNING: Cannot retrieve the interpreter for \"%s\": %s.", 711 buffer, elf_errmsg(-1)); 712 goto done; 713 } 714 image->pi_dynlinkerpath = 715 pmcstat_string_intern(elfbase + 716 ph.p_offset); 717 break; 718 case PT_LOAD: 719 if ((ph.p_flags & PF_X) != 0 && 720 (ph.p_offset & (-ph.p_align)) == 0) 721 image->pi_vaddr = ph.p_vaddr & (-ph.p_align); 722 break; 723 } 724 } 725 } 726 727 /* 728 * Get the min and max VA associated with this ELF object. 729 */ 730 if (elf_getshnum(e, &nsh) == 0) { 731 warnx( 732"WARNING: Could not determine the number of sections for \"%s\": %s.", 733 buffer, elf_errmsg(-1)); 734 goto done; 735 } 736 737 for (i = 0; i < nsh; i++) { 738 if ((scn = elf_getscn(e, i)) == NULL || 739 gelf_getshdr(scn, &sh) != &sh) { 740 warnx( 741"WARNING: Could not retrieve section header #%ju in \"%s\": %s.", 742 (uintmax_t) i, buffer, elf_errmsg(-1)); 743 goto done; 744 } 745 if (sh.sh_flags & SHF_EXECINSTR) { 746 minva = min(minva, sh.sh_addr); 747 maxva = max(maxva, sh.sh_addr + sh.sh_size); 748 } 749 if (sh.sh_type == SHT_SYMTAB || sh.sh_type == SHT_DYNSYM) 750 pmcstat_image_add_symbols(image, e, scn, &sh); 751 } 752 753 image->pi_start = minva; 754 image->pi_end = maxva; 755 image->pi_type = image_type; 756 image->pi_fullpath = pmcstat_string_intern(buffer); 757 758 /* Build display name 759 */ 760 endp = buffer; 761 for (p = buffer; *p; p++) 762 if (*p == '/') 763 endp = p+1; 764 image->pi_name = pmcstat_string_intern(endp); 765 766 done: 767 (void) elf_end(e); 768 if (fd >= 0) 769 (void) close(fd); 770 return; 771} 772 773/* 774 * Given an image descriptor, determine whether it is an ELF, or AOUT. 775 * If no handler claims the image, set its type to 'INDETERMINABLE'. 776 */ 777 778void 779pmcstat_image_determine_type(struct pmcstat_image *image) 780{ 781 assert(image->pi_type == PMCSTAT_IMAGE_UNKNOWN); 782 783 /* Try each kind of handler in turn */ 784 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 785 pmcstat_image_get_elf_params(image); 786 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 787 pmcstat_image_get_aout_params(image); 788 789 /* 790 * Otherwise, remember that we tried to determine 791 * the object's type and had failed. 792 */ 793 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 794 image->pi_type = PMCSTAT_IMAGE_INDETERMINABLE; 795} 796 797/* 798 * Locate an image descriptor given an interned path, adding a fresh 799 * descriptor to the cache if necessary. This function also finds a 800 * suitable name for this image's sample file. 801 * 802 * We defer filling in the file format specific parts of the image 803 * structure till the time we actually see a sample that would fall 804 * into this image. 805 */ 806 807static struct pmcstat_image * 808pmcstat_image_from_path(pmcstat_interned_string internedpath, 809 int iskernelmodule) 810{ 811 int hash; 812 struct pmcstat_image *pi; 813 814 hash = pmcstat_string_lookup_hash(internedpath); 815 816 /* First, look for an existing entry. */ 817 LIST_FOREACH(pi, &pmcstat_image_hash[hash], pi_next) 818 if (pi->pi_execpath == internedpath && 819 pi->pi_iskernelmodule == iskernelmodule) 820 return (pi); 821 822 /* 823 * Allocate a new entry and place it at the head of the hash 824 * and LRU lists. 825 */ 826 pi = malloc(sizeof(*pi)); 827 if (pi == NULL) 828 return (NULL); 829 830 pi->pi_type = PMCSTAT_IMAGE_UNKNOWN; 831 pi->pi_execpath = internedpath; 832 pi->pi_start = ~0; 833 pi->pi_end = 0; 834 pi->pi_entry = 0; 835 pi->pi_vaddr = 0; 836 pi->pi_isdynamic = 0; 837 pi->pi_iskernelmodule = iskernelmodule; 838 pi->pi_dynlinkerpath = NULL; 839 pi->pi_symbols = NULL; 840 pi->pi_symcount = 0; 841 pi->pi_addr2line = NULL; 842 843 if (plugins[args.pa_pplugin].pl_initimage != NULL) 844 plugins[args.pa_pplugin].pl_initimage(pi); 845 if (plugins[args.pa_plugin].pl_initimage != NULL) 846 plugins[args.pa_plugin].pl_initimage(pi); 847 848 LIST_INSERT_HEAD(&pmcstat_image_hash[hash], pi, pi_next); 849 850 return (pi); 851} 852 853/* 854 * Record the fact that PC values from 'start' to 'end' come from 855 * image 'image'. 856 */ 857 858static void 859pmcstat_image_link(struct pmcstat_process *pp, struct pmcstat_image *image, 860 uintfptr_t start) 861{ 862 struct pmcstat_pcmap *pcm, *pcmnew; 863 uintfptr_t offset; 864 865 assert(image->pi_type != PMCSTAT_IMAGE_UNKNOWN && 866 image->pi_type != PMCSTAT_IMAGE_INDETERMINABLE); 867 868 if ((pcmnew = malloc(sizeof(*pcmnew))) == NULL) 869 err(EX_OSERR, "ERROR: Cannot create a map entry"); 870 871 /* 872 * Adjust the map entry to only cover the text portion 873 * of the object. 874 */ 875 876 offset = start - image->pi_vaddr; 877 pcmnew->ppm_lowpc = image->pi_start + offset; 878 pcmnew->ppm_highpc = image->pi_end + offset; 879 pcmnew->ppm_image = image; 880 881 assert(pcmnew->ppm_lowpc < pcmnew->ppm_highpc); 882 883 /* Overlapped mmap()'s are assumed to never occur. */ 884 TAILQ_FOREACH(pcm, &pp->pp_map, ppm_next) 885 if (pcm->ppm_lowpc >= pcmnew->ppm_highpc) 886 break; 887 888 if (pcm == NULL) 889 TAILQ_INSERT_TAIL(&pp->pp_map, pcmnew, ppm_next); 890 else 891 TAILQ_INSERT_BEFORE(pcm, pcmnew, ppm_next); 892} 893 894/* 895 * Unmap images in the range [start..end) associated with process 896 * 'pp'. 897 */ 898 899static void 900pmcstat_image_unmap(struct pmcstat_process *pp, uintfptr_t start, 901 uintfptr_t end) 902{ 903 struct pmcstat_pcmap *pcm, *pcmtmp, *pcmnew; 904 905 assert(pp != NULL); 906 assert(start < end); 907 908 /* 909 * Cases: 910 * - we could have the range completely in the middle of an 911 * existing pcmap; in this case we have to split the pcmap 912 * structure into two (i.e., generate a 'hole'). 913 * - we could have the range covering multiple pcmaps; these 914 * will have to be removed. 915 * - we could have either 'start' or 'end' falling in the 916 * middle of a pcmap; in this case shorten the entry. 917 */ 918 TAILQ_FOREACH_SAFE(pcm, &pp->pp_map, ppm_next, pcmtmp) { 919 assert(pcm->ppm_lowpc < pcm->ppm_highpc); 920 if (pcm->ppm_highpc <= start) 921 continue; 922 if (pcm->ppm_lowpc >= end) 923 return; 924 if (pcm->ppm_lowpc >= start && pcm->ppm_highpc <= end) { 925 /* 926 * The current pcmap is completely inside the 927 * unmapped range: remove it entirely. 928 */ 929 TAILQ_REMOVE(&pp->pp_map, pcm, ppm_next); 930 free(pcm); 931 } else if (pcm->ppm_lowpc < start && pcm->ppm_highpc > end) { 932 /* 933 * Split this pcmap into two; curtail the 934 * current map to end at [start-1], and start 935 * the new one at [end]. 936 */ 937 if ((pcmnew = malloc(sizeof(*pcmnew))) == NULL) 938 err(EX_OSERR, 939 "ERROR: Cannot split a map entry"); 940 941 pcmnew->ppm_image = pcm->ppm_image; 942 943 pcmnew->ppm_lowpc = end; 944 pcmnew->ppm_highpc = pcm->ppm_highpc; 945 946 pcm->ppm_highpc = start; 947 948 TAILQ_INSERT_AFTER(&pp->pp_map, pcm, pcmnew, ppm_next); 949 950 return; 951 } else if (pcm->ppm_lowpc < start && pcm->ppm_highpc <= end) 952 pcm->ppm_highpc = start; 953 else if (pcm->ppm_lowpc >= start && pcm->ppm_highpc > end) 954 pcm->ppm_lowpc = end; 955 else 956 assert(0); 957 } 958} 959 960/* 961 * Resolve file name and line number for the given address. 962 */ 963int 964pmcstat_image_addr2line(struct pmcstat_image *image, uintfptr_t addr, 965 char *sourcefile, size_t sourcefile_len, unsigned *sourceline, 966 char *funcname, size_t funcname_len) 967{ 968 static int addr2line_warn = 0; 969 unsigned l; 970 971 char *sep, cmdline[PATH_MAX], imagepath[PATH_MAX]; 972 int fd; 973 974 if (image->pi_addr2line == NULL) { 975 snprintf(imagepath, sizeof(imagepath), "%s%s.symbols", 976 args.pa_fsroot, 977 pmcstat_string_unintern(image->pi_fullpath)); 978 fd = open(imagepath, O_RDONLY); 979 if (fd < 0) { 980 snprintf(imagepath, sizeof(imagepath), "%s%s", 981 args.pa_fsroot, 982 pmcstat_string_unintern(image->pi_fullpath)); 983 } else 984 close(fd); 985 /* 986 * New addr2line support recursive inline function with -i 987 * but the format does not add a marker when no more entries 988 * are available. 989 */ 990 snprintf(cmdline, sizeof(cmdline), "addr2line -Cfe \"%s\"", 991 imagepath); 992 image->pi_addr2line = popen(cmdline, "r+"); 993 if (image->pi_addr2line == NULL) { 994 if (!addr2line_warn) { 995 addr2line_warn = 1; 996 warnx( 997"WARNING: addr2line is needed for source code information." 998 ); 999 } 1000 return (0); 1001 } 1002 } 1003 1004 if (feof(image->pi_addr2line) || ferror(image->pi_addr2line)) { 1005 warnx("WARNING: addr2line pipe error"); 1006 pclose(image->pi_addr2line); 1007 image->pi_addr2line = NULL; 1008 return (0); 1009 } 1010 1011 fprintf(image->pi_addr2line, "%p\n", (void *)addr); 1012 1013 if (fgets(funcname, funcname_len, image->pi_addr2line) == NULL) { 1014 warnx("WARNING: addr2line function name read error"); 1015 return (0); 1016 } 1017 sep = strchr(funcname, '\n'); 1018 if (sep != NULL) 1019 *sep = '\0'; 1020 1021 if (fgets(sourcefile, sourcefile_len, image->pi_addr2line) == NULL) { 1022 warnx("WARNING: addr2line source file read error"); 1023 return (0); 1024 } 1025 sep = strchr(sourcefile, ':'); 1026 if (sep == NULL) { 1027 warnx("WARNING: addr2line source line separator missing"); 1028 return (0); 1029 } 1030 *sep = '\0'; 1031 l = atoi(sep+1); 1032 if (l == 0) 1033 return (0); 1034 *sourceline = l; 1035 return (1); 1036} 1037 1038/* 1039 * Add a {pmcid,name} mapping. 1040 */ 1041 1042static void 1043pmcstat_pmcid_add(pmc_id_t pmcid, pmcstat_interned_string ps) 1044{ 1045 struct pmcstat_pmcrecord *pr, *prm; 1046 1047 /* Replace an existing name for the PMC. */ 1048 prm = NULL; 1049 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1050 if (pr->pr_pmcid == pmcid) { 1051 pr->pr_pmcname = ps; 1052 return; 1053 } else if (pr->pr_pmcname == ps) 1054 prm = pr; 1055 1056 /* 1057 * Otherwise, allocate a new descriptor and call the 1058 * plugins hook. 1059 */ 1060 if ((pr = malloc(sizeof(*pr))) == NULL) 1061 err(EX_OSERR, "ERROR: Cannot allocate pmc record"); 1062 1063 pr->pr_pmcid = pmcid; 1064 pr->pr_pmcname = ps; 1065 pr->pr_pmcin = pmcstat_npmcs++; 1066 pr->pr_samples = 0; 1067 pr->pr_dubious_frames = 0; 1068 pr->pr_merge = prm == NULL ? pr : prm; 1069 1070 LIST_INSERT_HEAD(&pmcstat_pmcs, pr, pr_next); 1071 1072 if (plugins[args.pa_pplugin].pl_newpmc != NULL) 1073 plugins[args.pa_pplugin].pl_newpmc(ps, pr); 1074 if (plugins[args.pa_plugin].pl_newpmc != NULL) 1075 plugins[args.pa_plugin].pl_newpmc(ps, pr); 1076} 1077 1078/* 1079 * Given a pmcid in use, find its human-readable name. 1080 */ 1081 1082const char * 1083pmcstat_pmcid_to_name(pmc_id_t pmcid) 1084{ 1085 struct pmcstat_pmcrecord *pr; 1086 1087 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1088 if (pr->pr_pmcid == pmcid) 1089 return (pmcstat_string_unintern(pr->pr_pmcname)); 1090 1091 return NULL; 1092} 1093 1094/* 1095 * Convert PMC index to name. 1096 */ 1097 1098const char * 1099pmcstat_pmcindex_to_name(int pmcin) 1100{ 1101 struct pmcstat_pmcrecord *pr; 1102 1103 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1104 if (pr->pr_pmcin == pmcin) 1105 return pmcstat_string_unintern(pr->pr_pmcname); 1106 1107 return NULL; 1108} 1109 1110/* 1111 * Return PMC record with given index. 1112 */ 1113 1114struct pmcstat_pmcrecord * 1115pmcstat_pmcindex_to_pmcr(int pmcin) 1116{ 1117 struct pmcstat_pmcrecord *pr; 1118 1119 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1120 if (pr->pr_pmcin == pmcin) 1121 return pr; 1122 1123 return NULL; 1124} 1125 1126/* 1127 * Get PMC record by id, apply merge policy. 1128 */ 1129 1130static struct pmcstat_pmcrecord * 1131pmcstat_lookup_pmcid(pmc_id_t pmcid) 1132{ 1133 struct pmcstat_pmcrecord *pr; 1134 1135 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) { 1136 if (pr->pr_pmcid == pmcid) { 1137 if (pmcstat_mergepmc) 1138 return pr->pr_merge; 1139 return pr; 1140 } 1141 } 1142 1143 return NULL; 1144} 1145 1146/* 1147 * Associate an AOUT image with a process. 1148 */ 1149 1150static void 1151pmcstat_process_aout_exec(struct pmcstat_process *pp, 1152 struct pmcstat_image *image, uintfptr_t entryaddr) 1153{ 1154 (void) pp; 1155 (void) image; 1156 (void) entryaddr; 1157 /* TODO Implement a.out handling */ 1158} 1159 1160/* 1161 * Associate an ELF image with a process. 1162 */ 1163 1164static void 1165pmcstat_process_elf_exec(struct pmcstat_process *pp, 1166 struct pmcstat_image *image, uintfptr_t entryaddr) 1167{ 1168 uintmax_t libstart; 1169 struct pmcstat_image *rtldimage; 1170 1171 assert(image->pi_type == PMCSTAT_IMAGE_ELF32 || 1172 image->pi_type == PMCSTAT_IMAGE_ELF64); 1173 1174 /* Create a map entry for the base executable. */ 1175 pmcstat_image_link(pp, image, image->pi_vaddr); 1176 1177 /* 1178 * For dynamically linked executables we need to determine 1179 * where the dynamic linker was mapped to for this process, 1180 * Subsequent executable objects that are mapped in by the 1181 * dynamic linker will be tracked by log events of type 1182 * PMCLOG_TYPE_MAP_IN. 1183 */ 1184 1185 if (image->pi_isdynamic) { 1186 1187 /* 1188 * The runtime loader gets loaded just after the maximum 1189 * possible heap address. Like so: 1190 * 1191 * [ TEXT DATA BSS HEAP -->*RTLD SHLIBS <--STACK] 1192 * ^ ^ 1193 * 0 VM_MAXUSER_ADDRESS 1194 1195 * 1196 * The exact address where the loader gets mapped in 1197 * will vary according to the size of the executable 1198 * and the limits on the size of the process'es data 1199 * segment at the time of exec(). The entry address 1200 * recorded at process exec time corresponds to the 1201 * 'start' address inside the dynamic linker. From 1202 * this we can figure out the address where the 1203 * runtime loader's file object had been mapped to. 1204 */ 1205 rtldimage = pmcstat_image_from_path(image->pi_dynlinkerpath, 0); 1206 if (rtldimage == NULL) { 1207 warnx("WARNING: Cannot find image for \"%s\".", 1208 pmcstat_string_unintern(image->pi_dynlinkerpath)); 1209 pmcstat_stats.ps_exec_errors++; 1210 return; 1211 } 1212 1213 if (rtldimage->pi_type == PMCSTAT_IMAGE_UNKNOWN) 1214 pmcstat_image_get_elf_params(rtldimage); 1215 1216 if (rtldimage->pi_type != PMCSTAT_IMAGE_ELF32 && 1217 rtldimage->pi_type != PMCSTAT_IMAGE_ELF64) { 1218 warnx("WARNING: rtld not an ELF object \"%s\".", 1219 pmcstat_string_unintern(image->pi_dynlinkerpath)); 1220 return; 1221 } 1222 1223 libstart = entryaddr - rtldimage->pi_entry; 1224 pmcstat_image_link(pp, rtldimage, libstart); 1225 } 1226} 1227 1228/* 1229 * Find the process descriptor corresponding to a PID. If 'allocate' 1230 * is zero, we return a NULL if a pid descriptor could not be found or 1231 * a process descriptor process. If 'allocate' is non-zero, then we 1232 * will attempt to allocate a fresh process descriptor. Zombie 1233 * process descriptors are only removed if a fresh allocation for the 1234 * same PID is requested. 1235 */ 1236 1237static struct pmcstat_process * 1238pmcstat_process_lookup(pid_t pid, int allocate) 1239{ 1240 uint32_t hash; 1241 struct pmcstat_pcmap *ppm, *ppmtmp; 1242 struct pmcstat_process *pp, *pptmp; 1243 1244 hash = (uint32_t) pid & PMCSTAT_HASH_MASK; /* simplicity wins */ 1245 1246 LIST_FOREACH_SAFE(pp, &pmcstat_process_hash[hash], pp_next, pptmp) 1247 if (pp->pp_pid == pid) { 1248 /* Found a descriptor, check and process zombies */ 1249 if (allocate && pp->pp_isactive == 0) { 1250 /* remove maps */ 1251 TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, 1252 ppmtmp) { 1253 TAILQ_REMOVE(&pp->pp_map, ppm, 1254 ppm_next); 1255 free(ppm); 1256 } 1257 /* remove process entry */ 1258 LIST_REMOVE(pp, pp_next); 1259 free(pp); 1260 break; 1261 } 1262 return (pp); 1263 } 1264 1265 if (!allocate) 1266 return (NULL); 1267 1268 if ((pp = malloc(sizeof(*pp))) == NULL) 1269 err(EX_OSERR, "ERROR: Cannot allocate pid descriptor"); 1270 1271 pp->pp_pid = pid; 1272 pp->pp_isactive = 1; 1273 1274 TAILQ_INIT(&pp->pp_map); 1275 1276 LIST_INSERT_HEAD(&pmcstat_process_hash[hash], pp, pp_next); 1277 return (pp); 1278} 1279 1280/* 1281 * Associate an image and a process. 1282 */ 1283 1284static void 1285pmcstat_process_exec(struct pmcstat_process *pp, 1286 pmcstat_interned_string path, uintfptr_t entryaddr) 1287{ 1288 struct pmcstat_image *image; 1289 1290 if ((image = pmcstat_image_from_path(path, 0)) == NULL) { 1291 pmcstat_stats.ps_exec_errors++; 1292 return; 1293 } 1294 1295 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 1296 pmcstat_image_determine_type(image); 1297 1298 assert(image->pi_type != PMCSTAT_IMAGE_UNKNOWN); 1299 1300 switch (image->pi_type) { 1301 case PMCSTAT_IMAGE_ELF32: 1302 case PMCSTAT_IMAGE_ELF64: 1303 pmcstat_stats.ps_exec_elf++; 1304 pmcstat_process_elf_exec(pp, image, entryaddr); 1305 break; 1306 1307 case PMCSTAT_IMAGE_AOUT: 1308 pmcstat_stats.ps_exec_aout++; 1309 pmcstat_process_aout_exec(pp, image, entryaddr); 1310 break; 1311 1312 case PMCSTAT_IMAGE_INDETERMINABLE: 1313 pmcstat_stats.ps_exec_indeterminable++; 1314 break; 1315 1316 default: 1317 err(EX_SOFTWARE, 1318 "ERROR: Unsupported executable type for \"%s\"", 1319 pmcstat_string_unintern(path)); 1320 } 1321} 1322 1323 1324/* 1325 * Find the map entry associated with process 'p' at PC value 'pc'. 1326 */ 1327 1328struct pmcstat_pcmap * 1329pmcstat_process_find_map(struct pmcstat_process *p, uintfptr_t pc) 1330{ 1331 struct pmcstat_pcmap *ppm; 1332 1333 TAILQ_FOREACH(ppm, &p->pp_map, ppm_next) { 1334 if (pc >= ppm->ppm_lowpc && pc < ppm->ppm_highpc) 1335 return (ppm); 1336 if (pc < ppm->ppm_lowpc) 1337 return (NULL); 1338 } 1339 1340 return (NULL); 1341} 1342 1343/* 1344 * Convert a hwpmc(4) log to profile information. A system-wide 1345 * callgraph is generated if FLAG_DO_CALLGRAPHS is set. gmon.out 1346 * files usable by gprof(1) are created if FLAG_DO_GPROF is set. 1347 */ 1348static int 1349pmcstat_analyze_log(void) 1350{ 1351 uint32_t cpu, cpuflags; 1352 uintfptr_t pc; 1353 pid_t pid; 1354 struct pmcstat_image *image; 1355 struct pmcstat_process *pp, *ppnew; 1356 struct pmcstat_pcmap *ppm, *ppmtmp; 1357 struct pmclog_ev ev; 1358 struct pmcstat_pmcrecord *pmcr; 1359 pmcstat_interned_string image_path; 1360 1361 assert(args.pa_flags & FLAG_DO_ANALYSIS); 1362 1363 if (elf_version(EV_CURRENT) == EV_NONE) 1364 err(EX_UNAVAILABLE, "Elf library initialization failed"); 1365 1366 while (pmclog_read(args.pa_logparser, &ev) == 0) { 1367 assert(ev.pl_state == PMCLOG_OK); 1368 1369 switch (ev.pl_type) { 1370 case PMCLOG_TYPE_INITIALIZE: 1371 if ((ev.pl_u.pl_i.pl_version & 0xFF000000) != 1372 PMC_VERSION_MAJOR << 24 && args.pa_verbosity > 0) 1373 warnx( 1374"WARNING: Log version 0x%x does not match compiled version 0x%x.", 1375 ev.pl_u.pl_i.pl_version, PMC_VERSION_MAJOR); 1376 break; 1377 1378 case PMCLOG_TYPE_MAP_IN: 1379 /* 1380 * Introduce an address range mapping for a 1381 * userland process or the kernel (pid == -1). 1382 * 1383 * We always allocate a process descriptor so 1384 * that subsequent samples seen for this 1385 * address range are mapped to the current 1386 * object being mapped in. 1387 */ 1388 pid = ev.pl_u.pl_mi.pl_pid; 1389 if (pid == -1) 1390 pp = pmcstat_kernproc; 1391 else 1392 pp = pmcstat_process_lookup(pid, 1393 PMCSTAT_ALLOCATE); 1394 1395 assert(pp != NULL); 1396 1397 image_path = pmcstat_string_intern(ev.pl_u.pl_mi. 1398 pl_pathname); 1399 image = pmcstat_image_from_path(image_path, pid == -1); 1400 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 1401 pmcstat_image_determine_type(image); 1402 if (image->pi_type != PMCSTAT_IMAGE_INDETERMINABLE) 1403 pmcstat_image_link(pp, image, 1404 ev.pl_u.pl_mi.pl_start); 1405 break; 1406 1407 case PMCLOG_TYPE_MAP_OUT: 1408 /* 1409 * Remove an address map. 1410 */ 1411 pid = ev.pl_u.pl_mo.pl_pid; 1412 if (pid == -1) 1413 pp = pmcstat_kernproc; 1414 else 1415 pp = pmcstat_process_lookup(pid, 0); 1416 1417 if (pp == NULL) /* unknown process */ 1418 break; 1419 1420 pmcstat_image_unmap(pp, ev.pl_u.pl_mo.pl_start, 1421 ev.pl_u.pl_mo.pl_end); 1422 break; 1423 1424 case PMCLOG_TYPE_PCSAMPLE: 1425 /* 1426 * Note: the `PCSAMPLE' log entry is not 1427 * generated by hpwmc(4) after version 2. 1428 */ 1429 1430 /* 1431 * We bring in the gmon file for the image 1432 * currently associated with the PMC & pid 1433 * pair and increment the appropriate entry 1434 * bin inside this. 1435 */ 1436 pmcstat_stats.ps_samples_total++; 1437 ps_samples_period++; 1438 1439 pc = ev.pl_u.pl_s.pl_pc; 1440 pp = pmcstat_process_lookup(ev.pl_u.pl_s.pl_pid, 1441 PMCSTAT_ALLOCATE); 1442 1443 /* Get PMC record. */ 1444 pmcr = pmcstat_lookup_pmcid(ev.pl_u.pl_s.pl_pmcid); 1445 assert(pmcr != NULL); 1446 pmcr->pr_samples++; 1447 1448 /* 1449 * Call the plugins processing 1450 * TODO: move pmcstat_process_find_map inside plugins 1451 */ 1452 1453 if (plugins[args.pa_pplugin].pl_process != NULL) 1454 plugins[args.pa_pplugin].pl_process( 1455 pp, pmcr, 1, &pc, 1456 pmcstat_process_find_map(pp, pc) != NULL, 0); 1457 plugins[args.pa_plugin].pl_process( 1458 pp, pmcr, 1, &pc, 1459 pmcstat_process_find_map(pp, pc) != NULL, 0); 1460 break; 1461 1462 case PMCLOG_TYPE_CALLCHAIN: 1463 pmcstat_stats.ps_samples_total++; 1464 ps_samples_period++; 1465 1466 cpuflags = ev.pl_u.pl_cc.pl_cpuflags; 1467 cpu = PMC_CALLCHAIN_CPUFLAGS_TO_CPU(cpuflags); 1468 1469 /* Filter on the CPU id. */ 1470 if (!CPU_ISSET(cpu, &(args.pa_cpumask))) { 1471 pmcstat_stats.ps_samples_skipped++; 1472 break; 1473 } 1474 1475 pp = pmcstat_process_lookup(ev.pl_u.pl_cc.pl_pid, 1476 PMCSTAT_ALLOCATE); 1477 1478 /* Get PMC record. */ 1479 pmcr = pmcstat_lookup_pmcid(ev.pl_u.pl_cc.pl_pmcid); 1480 assert(pmcr != NULL); 1481 pmcr->pr_samples++; 1482 1483 /* 1484 * Call the plugins processing 1485 */ 1486 1487 if (plugins[args.pa_pplugin].pl_process != NULL) 1488 plugins[args.pa_pplugin].pl_process( 1489 pp, pmcr, 1490 ev.pl_u.pl_cc.pl_npc, 1491 ev.pl_u.pl_cc.pl_pc, 1492 PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags), 1493 cpu); 1494 plugins[args.pa_plugin].pl_process( 1495 pp, pmcr, 1496 ev.pl_u.pl_cc.pl_npc, 1497 ev.pl_u.pl_cc.pl_pc, 1498 PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags), 1499 cpu); 1500 break; 1501 1502 case PMCLOG_TYPE_PMCALLOCATE: 1503 /* 1504 * Record the association pmc id between this 1505 * PMC and its name. 1506 */ 1507 pmcstat_pmcid_add(ev.pl_u.pl_a.pl_pmcid, 1508 pmcstat_string_intern(ev.pl_u.pl_a.pl_evname)); 1509 break; 1510 1511 case PMCLOG_TYPE_PMCALLOCATEDYN: 1512 /* 1513 * Record the association pmc id between this 1514 * PMC and its name. 1515 */ 1516 pmcstat_pmcid_add(ev.pl_u.pl_ad.pl_pmcid, 1517 pmcstat_string_intern(ev.pl_u.pl_ad.pl_evname)); 1518 break; 1519 1520 case PMCLOG_TYPE_PROCEXEC: 1521 1522 /* 1523 * Change the executable image associated with 1524 * a process. 1525 */ 1526 pp = pmcstat_process_lookup(ev.pl_u.pl_x.pl_pid, 1527 PMCSTAT_ALLOCATE); 1528 1529 /* delete the current process map */ 1530 TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) { 1531 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next); 1532 free(ppm); 1533 } 1534 1535 /* associate this process image */ 1536 image_path = pmcstat_string_intern( 1537 ev.pl_u.pl_x.pl_pathname); 1538 assert(image_path != NULL); 1539 pmcstat_process_exec(pp, image_path, 1540 ev.pl_u.pl_x.pl_entryaddr); 1541 break; 1542 1543 case PMCLOG_TYPE_PROCEXIT: 1544 1545 /* 1546 * Due to the way the log is generated, the 1547 * last few samples corresponding to a process 1548 * may appear in the log after the process 1549 * exit event is recorded. Thus we keep the 1550 * process' descriptor and associated data 1551 * structures around, but mark the process as 1552 * having exited. 1553 */ 1554 pp = pmcstat_process_lookup(ev.pl_u.pl_e.pl_pid, 0); 1555 if (pp == NULL) 1556 break; 1557 pp->pp_isactive = 0; /* mark as a zombie */ 1558 break; 1559 1560 case PMCLOG_TYPE_SYSEXIT: 1561 pp = pmcstat_process_lookup(ev.pl_u.pl_se.pl_pid, 0); 1562 if (pp == NULL) 1563 break; 1564 pp->pp_isactive = 0; /* make a zombie */ 1565 break; 1566 1567 case PMCLOG_TYPE_PROCFORK: 1568 1569 /* 1570 * Allocate a process descriptor for the new 1571 * (child) process. 1572 */ 1573 ppnew = 1574 pmcstat_process_lookup(ev.pl_u.pl_f.pl_newpid, 1575 PMCSTAT_ALLOCATE); 1576 1577 /* 1578 * If we had been tracking the parent, clone 1579 * its address maps. 1580 */ 1581 pp = pmcstat_process_lookup(ev.pl_u.pl_f.pl_oldpid, 0); 1582 if (pp == NULL) 1583 break; 1584 TAILQ_FOREACH(ppm, &pp->pp_map, ppm_next) 1585 pmcstat_image_link(ppnew, ppm->ppm_image, 1586 ppm->ppm_lowpc); 1587 break; 1588 1589 default: /* other types of entries are not relevant */ 1590 break; 1591 } 1592 } 1593 1594 if (ev.pl_state == PMCLOG_EOF) 1595 return (PMCSTAT_FINISHED); 1596 else if (ev.pl_state == PMCLOG_REQUIRE_DATA) 1597 return (PMCSTAT_RUNNING); 1598 1599 err(EX_DATAERR, 1600 "ERROR: event parsing failed (record %jd, offset 0x%jx)", 1601 (uintmax_t) ev.pl_count + 1, ev.pl_offset); 1602} 1603 1604/* 1605 * Print log entries as text. 1606 */ 1607 1608static int 1609pmcstat_print_log(void) 1610{ 1611 struct pmclog_ev ev; 1612 uint32_t npc; 1613 1614 while (pmclog_read(args.pa_logparser, &ev) == 0) { 1615 assert(ev.pl_state == PMCLOG_OK); 1616 switch (ev.pl_type) { 1617 case PMCLOG_TYPE_CALLCHAIN: 1618 PMCSTAT_PRINT_ENTRY("callchain", 1619 "%d 0x%x %d %d %c", ev.pl_u.pl_cc.pl_pid, 1620 ev.pl_u.pl_cc.pl_pmcid, 1621 PMC_CALLCHAIN_CPUFLAGS_TO_CPU(ev.pl_u.pl_cc. \ 1622 pl_cpuflags), ev.pl_u.pl_cc.pl_npc, 1623 PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(ev.pl_u.pl_cc.\ 1624 pl_cpuflags) ? 'u' : 's'); 1625 for (npc = 0; npc < ev.pl_u.pl_cc.pl_npc; npc++) 1626 PMCSTAT_PRINT_ENTRY("...", "%p", 1627 (void *) ev.pl_u.pl_cc.pl_pc[npc]); 1628 break; 1629 case PMCLOG_TYPE_CLOSELOG: 1630 PMCSTAT_PRINT_ENTRY("closelog",); 1631 break; 1632 case PMCLOG_TYPE_DROPNOTIFY: 1633 PMCSTAT_PRINT_ENTRY("drop",); 1634 break; 1635 case PMCLOG_TYPE_INITIALIZE: 1636 PMCSTAT_PRINT_ENTRY("initlog","0x%x \"%s\"", 1637 ev.pl_u.pl_i.pl_version, 1638 pmc_name_of_cputype(ev.pl_u.pl_i.pl_arch)); 1639 if ((ev.pl_u.pl_i.pl_version & 0xFF000000) != 1640 PMC_VERSION_MAJOR << 24 && args.pa_verbosity > 0) 1641 warnx( 1642"WARNING: Log version 0x%x != expected version 0x%x.", 1643 ev.pl_u.pl_i.pl_version, PMC_VERSION); 1644 break; 1645 case PMCLOG_TYPE_MAP_IN: 1646 PMCSTAT_PRINT_ENTRY("map-in","%d %p \"%s\"", 1647 ev.pl_u.pl_mi.pl_pid, 1648 (void *) ev.pl_u.pl_mi.pl_start, 1649 ev.pl_u.pl_mi.pl_pathname); 1650 break; 1651 case PMCLOG_TYPE_MAP_OUT: 1652 PMCSTAT_PRINT_ENTRY("map-out","%d %p %p", 1653 ev.pl_u.pl_mo.pl_pid, 1654 (void *) ev.pl_u.pl_mo.pl_start, 1655 (void *) ev.pl_u.pl_mo.pl_end); 1656 break; 1657 case PMCLOG_TYPE_PCSAMPLE: 1658 PMCSTAT_PRINT_ENTRY("sample","0x%x %d %p %c", 1659 ev.pl_u.pl_s.pl_pmcid, 1660 ev.pl_u.pl_s.pl_pid, 1661 (void *) ev.pl_u.pl_s.pl_pc, 1662 ev.pl_u.pl_s.pl_usermode ? 'u' : 's'); 1663 break; 1664 case PMCLOG_TYPE_PMCALLOCATE: 1665 PMCSTAT_PRINT_ENTRY("allocate","0x%x \"%s\" 0x%x", 1666 ev.pl_u.pl_a.pl_pmcid, 1667 ev.pl_u.pl_a.pl_evname, 1668 ev.pl_u.pl_a.pl_flags); 1669 break; 1670 case PMCLOG_TYPE_PMCALLOCATEDYN: 1671 PMCSTAT_PRINT_ENTRY("allocatedyn","0x%x \"%s\" 0x%x", 1672 ev.pl_u.pl_ad.pl_pmcid, 1673 ev.pl_u.pl_ad.pl_evname, 1674 ev.pl_u.pl_ad.pl_flags); 1675 break; 1676 case PMCLOG_TYPE_PMCATTACH: 1677 PMCSTAT_PRINT_ENTRY("attach","0x%x %d \"%s\"", 1678 ev.pl_u.pl_t.pl_pmcid, 1679 ev.pl_u.pl_t.pl_pid, 1680 ev.pl_u.pl_t.pl_pathname); 1681 break; 1682 case PMCLOG_TYPE_PMCDETACH: 1683 PMCSTAT_PRINT_ENTRY("detach","0x%x %d", 1684 ev.pl_u.pl_d.pl_pmcid, 1685 ev.pl_u.pl_d.pl_pid); 1686 break; 1687 case PMCLOG_TYPE_PROCCSW: 1688 PMCSTAT_PRINT_ENTRY("cswval","0x%x %d %jd", 1689 ev.pl_u.pl_c.pl_pmcid, 1690 ev.pl_u.pl_c.pl_pid, 1691 ev.pl_u.pl_c.pl_value); 1692 break; 1693 case PMCLOG_TYPE_PROCEXEC: 1694 PMCSTAT_PRINT_ENTRY("exec","0x%x %d %p \"%s\"", 1695 ev.pl_u.pl_x.pl_pmcid, 1696 ev.pl_u.pl_x.pl_pid, 1697 (void *) ev.pl_u.pl_x.pl_entryaddr, 1698 ev.pl_u.pl_x.pl_pathname); 1699 break; 1700 case PMCLOG_TYPE_PROCEXIT: 1701 PMCSTAT_PRINT_ENTRY("exitval","0x%x %d %jd", 1702 ev.pl_u.pl_e.pl_pmcid, 1703 ev.pl_u.pl_e.pl_pid, 1704 ev.pl_u.pl_e.pl_value); 1705 break; 1706 case PMCLOG_TYPE_PROCFORK: 1707 PMCSTAT_PRINT_ENTRY("fork","%d %d", 1708 ev.pl_u.pl_f.pl_oldpid, 1709 ev.pl_u.pl_f.pl_newpid); 1710 break; 1711 case PMCLOG_TYPE_USERDATA: 1712 PMCSTAT_PRINT_ENTRY("userdata","0x%x", 1713 ev.pl_u.pl_u.pl_userdata); 1714 break; 1715 case PMCLOG_TYPE_SYSEXIT: 1716 PMCSTAT_PRINT_ENTRY("exit","%d", 1717 ev.pl_u.pl_se.pl_pid); 1718 break; 1719 default: 1720 fprintf(args.pa_printfile, "unknown event (type %d).\n", 1721 ev.pl_type); 1722 } 1723 } 1724 1725 if (ev.pl_state == PMCLOG_EOF) 1726 return (PMCSTAT_FINISHED); 1727 else if (ev.pl_state == PMCLOG_REQUIRE_DATA) 1728 return (PMCSTAT_RUNNING); 1729 1730 errx(EX_DATAERR, 1731 "ERROR: event parsing failed (record %jd, offset 0x%jx).", 1732 (uintmax_t) ev.pl_count + 1, ev.pl_offset); 1733 /*NOTREACHED*/ 1734} 1735 1736/* 1737 * Public Interfaces. 1738 */ 1739 1740/* 1741 * Close a logfile, after first flushing all in-module queued data. 1742 */ 1743 1744int 1745pmcstat_close_log(void) 1746{ 1747 /* If a local logfile is configured ask the kernel to stop 1748 * and flush data. Kernel will close the file when data is flushed 1749 * so keep the status to EXITING. 1750 */ 1751 if (args.pa_logfd != -1) { 1752 if (pmc_close_logfile() < 0) 1753 err(EX_OSERR, "ERROR: logging failed"); 1754 } 1755 1756 return (args.pa_flags & FLAG_HAS_PIPE ? PMCSTAT_EXITING : 1757 PMCSTAT_FINISHED); 1758} 1759 1760 1761 1762/* 1763 * Open a log file, for reading or writing. 1764 * 1765 * The function returns the fd of a successfully opened log or -1 in 1766 * case of failure. 1767 */ 1768 1769int 1770pmcstat_open_log(const char *path, int mode) 1771{ 1772 int error, fd, cfd; 1773 size_t hlen; 1774 const char *p, *errstr; 1775 struct addrinfo hints, *res, *res0; 1776 char hostname[MAXHOSTNAMELEN]; 1777 1778 errstr = NULL; 1779 fd = -1; 1780 1781 /* 1782 * If 'path' is "-" then open one of stdin or stdout depending 1783 * on the value of 'mode'. 1784 * 1785 * If 'path' contains a ':' and does not start with a '/' or '.', 1786 * and is being opened for writing, treat it as a "host:port" 1787 * specification and open a network socket. 1788 * 1789 * Otherwise, treat 'path' as a file name and open that. 1790 */ 1791 if (path[0] == '-' && path[1] == '\0') 1792 fd = (mode == PMCSTAT_OPEN_FOR_READ) ? 0 : 1; 1793 else if (path[0] != '/' && 1794 path[0] != '.' && strchr(path, ':') != NULL) { 1795 1796 p = strrchr(path, ':'); 1797 hlen = p - path; 1798 if (p == path || hlen >= sizeof(hostname)) { 1799 errstr = strerror(EINVAL); 1800 goto done; 1801 } 1802 1803 assert(hlen < sizeof(hostname)); 1804 (void) strncpy(hostname, path, hlen); 1805 hostname[hlen] = '\0'; 1806 1807 (void) memset(&hints, 0, sizeof(hints)); 1808 hints.ai_family = AF_UNSPEC; 1809 hints.ai_socktype = SOCK_STREAM; 1810 if ((error = getaddrinfo(hostname, p+1, &hints, &res0)) != 0) { 1811 errstr = gai_strerror(error); 1812 goto done; 1813 } 1814 1815 fd = -1; 1816 for (res = res0; res; res = res->ai_next) { 1817 if ((fd = socket(res->ai_family, res->ai_socktype, 1818 res->ai_protocol)) < 0) { 1819 errstr = strerror(errno); 1820 continue; 1821 } 1822 if (mode == PMCSTAT_OPEN_FOR_READ) { 1823 if (bind(fd, res->ai_addr, res->ai_addrlen) < 0) { 1824 errstr = strerror(errno); 1825 (void) close(fd); 1826 fd = -1; 1827 continue; 1828 } 1829 listen(fd, 1); 1830 cfd = accept(fd, NULL, NULL); 1831 (void) close(fd); 1832 if (cfd < 0) { 1833 errstr = strerror(errno); 1834 fd = -1; 1835 break; 1836 } 1837 fd = cfd; 1838 } else { 1839 if (connect(fd, res->ai_addr, res->ai_addrlen) < 0) { 1840 errstr = strerror(errno); 1841 (void) close(fd); 1842 fd = -1; 1843 continue; 1844 } 1845 } 1846 errstr = NULL; 1847 break; 1848 } 1849 freeaddrinfo(res0); 1850 1851 } else if ((fd = open(path, mode == PMCSTAT_OPEN_FOR_READ ? 1852 O_RDONLY : (O_WRONLY|O_CREAT|O_TRUNC), 1853 S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) 1854 errstr = strerror(errno); 1855 1856 done: 1857 if (errstr) 1858 errx(EX_OSERR, "ERROR: Cannot open \"%s\" for %s: %s.", path, 1859 (mode == PMCSTAT_OPEN_FOR_READ ? "reading" : "writing"), 1860 errstr); 1861 1862 return (fd); 1863} 1864 1865/* 1866 * Process a log file in offline analysis mode. 1867 */ 1868 1869int 1870pmcstat_process_log(void) 1871{ 1872 1873 /* 1874 * If analysis has not been asked for, just print the log to 1875 * the current output file. 1876 */ 1877 if (args.pa_flags & FLAG_DO_PRINT) 1878 return (pmcstat_print_log()); 1879 else 1880 return (pmcstat_analyze_log()); 1881} 1882 1883/* 1884 * Refresh top display. 1885 */ 1886 1887static void 1888pmcstat_refresh_top(void) 1889{ 1890 int v_attrs; 1891 float v; 1892 char pmcname[40]; 1893 struct pmcstat_pmcrecord *pmcpr; 1894 1895 /* If in pause mode do not refresh display. */ 1896 if (pmcstat_pause) 1897 return; 1898 1899 /* Wait until PMC pop in the log. */ 1900 pmcpr = pmcstat_pmcindex_to_pmcr(pmcstat_pmcinfilter); 1901 if (pmcpr == NULL) 1902 return; 1903 1904 /* Format PMC name. */ 1905 if (pmcstat_mergepmc) 1906 snprintf(pmcname, sizeof(pmcname), "[%s]", 1907 pmcstat_string_unintern(pmcpr->pr_pmcname)); 1908 else 1909 snprintf(pmcname, sizeof(pmcname), "%s.%d", 1910 pmcstat_string_unintern(pmcpr->pr_pmcname), 1911 pmcstat_pmcinfilter); 1912 1913 /* Format samples count. */ 1914 if (ps_samples_period > 0) 1915 v = (pmcpr->pr_samples * 100.0) / ps_samples_period; 1916 else 1917 v = 0.; 1918 v_attrs = PMCSTAT_ATTRPERCENT(v); 1919 1920 PMCSTAT_PRINTBEGIN(); 1921 PMCSTAT_PRINTW("PMC: %s Samples: %u ", 1922 pmcname, 1923 pmcpr->pr_samples); 1924 PMCSTAT_ATTRON(v_attrs); 1925 PMCSTAT_PRINTW("(%.1f%%) ", v); 1926 PMCSTAT_ATTROFF(v_attrs); 1927 PMCSTAT_PRINTW(", %u unresolved\n\n", 1928 pmcpr->pr_dubious_frames); 1929 if (plugins[args.pa_plugin].pl_topdisplay != NULL) 1930 plugins[args.pa_plugin].pl_topdisplay(); 1931 PMCSTAT_PRINTEND(); 1932} 1933 1934/* 1935 * Find the next pmc index to display. 1936 */ 1937 1938static void 1939pmcstat_changefilter(void) 1940{ 1941 int pmcin; 1942 struct pmcstat_pmcrecord *pmcr; 1943 1944 /* 1945 * Find the next merge target. 1946 */ 1947 if (pmcstat_mergepmc) { 1948 pmcin = pmcstat_pmcinfilter; 1949 1950 do { 1951 pmcr = pmcstat_pmcindex_to_pmcr(pmcstat_pmcinfilter); 1952 if (pmcr == NULL || pmcr == pmcr->pr_merge) 1953 break; 1954 1955 pmcstat_pmcinfilter++; 1956 if (pmcstat_pmcinfilter >= pmcstat_npmcs) 1957 pmcstat_pmcinfilter = 0; 1958 1959 } while (pmcstat_pmcinfilter != pmcin); 1960 } 1961} 1962 1963/* 1964 * Top mode keypress. 1965 */ 1966 1967int 1968pmcstat_keypress_log(void) 1969{ 1970 int c, ret = 0; 1971 WINDOW *w; 1972 1973 w = newwin(1, 0, 1, 0); 1974 c = wgetch(w); 1975 wprintw(w, "Key: %c => ", c); 1976 switch (c) { 1977 case 'c': 1978 wprintw(w, "enter mode 'd' or 'a' => "); 1979 c = wgetch(w); 1980 if (c == 'd') { 1981 args.pa_topmode = PMCSTAT_TOP_DELTA; 1982 wprintw(w, "switching to delta mode"); 1983 } else { 1984 args.pa_topmode = PMCSTAT_TOP_ACCUM; 1985 wprintw(w, "switching to accumulation mode"); 1986 } 1987 break; 1988 case 'm': 1989 pmcstat_mergepmc = !pmcstat_mergepmc; 1990 /* 1991 * Changing merge state require data reset. 1992 */ 1993 if (plugins[args.pa_plugin].pl_shutdown != NULL) 1994 plugins[args.pa_plugin].pl_shutdown(NULL); 1995 pmcstat_stats_reset(0); 1996 if (plugins[args.pa_plugin].pl_init != NULL) 1997 plugins[args.pa_plugin].pl_init(); 1998 1999 /* Update filter to be on a merge target. */ 2000 pmcstat_changefilter(); 2001 wprintw(w, "merge PMC %s", pmcstat_mergepmc ? "on" : "off"); 2002 break; 2003 case 'n': 2004 /* Close current plugin. */ 2005 if (plugins[args.pa_plugin].pl_shutdown != NULL) 2006 plugins[args.pa_plugin].pl_shutdown(NULL); 2007 2008 /* Find next top display available. */ 2009 do { 2010 args.pa_plugin++; 2011 if (plugins[args.pa_plugin].pl_name == NULL) 2012 args.pa_plugin = 0; 2013 } while (plugins[args.pa_plugin].pl_topdisplay == NULL); 2014 2015 /* Open new plugin. */ 2016 pmcstat_stats_reset(0); 2017 if (plugins[args.pa_plugin].pl_init != NULL) 2018 plugins[args.pa_plugin].pl_init(); 2019 wprintw(w, "switching to plugin %s", 2020 plugins[args.pa_plugin].pl_name); 2021 break; 2022 case 'p': 2023 pmcstat_pmcinfilter++; 2024 if (pmcstat_pmcinfilter >= pmcstat_npmcs) 2025 pmcstat_pmcinfilter = 0; 2026 pmcstat_changefilter(); 2027 wprintw(w, "switching to PMC %s.%d", 2028 pmcstat_pmcindex_to_name(pmcstat_pmcinfilter), 2029 pmcstat_pmcinfilter); 2030 break; 2031 case ' ': 2032 pmcstat_pause = !pmcstat_pause; 2033 if (pmcstat_pause) 2034 wprintw(w, "pause => press space again to continue"); 2035 break; 2036 case 'q': 2037 wprintw(w, "exiting..."); 2038 ret = 1; 2039 break; 2040 default: 2041 if (plugins[args.pa_plugin].pl_topkeypress != NULL) 2042 if (plugins[args.pa_plugin].pl_topkeypress(c, w)) 2043 ret = 1; 2044 } 2045 2046 wrefresh(w); 2047 delwin(w); 2048 return ret; 2049} 2050 2051 2052/* 2053 * Top mode display. 2054 */ 2055 2056void 2057pmcstat_display_log(void) 2058{ 2059 2060 pmcstat_refresh_top(); 2061 2062 /* Reset everythings if delta mode. */ 2063 if (args.pa_topmode == PMCSTAT_TOP_DELTA) { 2064 if (plugins[args.pa_plugin].pl_shutdown != NULL) 2065 plugins[args.pa_plugin].pl_shutdown(NULL); 2066 pmcstat_stats_reset(0); 2067 if (plugins[args.pa_plugin].pl_init != NULL) 2068 plugins[args.pa_plugin].pl_init(); 2069 } 2070 2071} 2072 2073/* 2074 * Configure a plugins. 2075 */ 2076 2077void 2078pmcstat_pluginconfigure_log(char *opt) 2079{ 2080 2081 if (strncmp(opt, "threshold=", 10) == 0) { 2082 pmcstat_threshold = atof(opt+10); 2083 } else { 2084 if (plugins[args.pa_plugin].pl_configure != NULL) { 2085 if (!plugins[args.pa_plugin].pl_configure(opt)) 2086 err(EX_USAGE, 2087 "ERROR: unknown option <%s>.", opt); 2088 } 2089 } 2090} 2091 2092/* 2093 * Initialize module. 2094 */ 2095 2096void 2097pmcstat_initialize_logging(void) 2098{ 2099 int i; 2100 2101 /* use a convenient format for 'ldd' output */ 2102 if (setenv("LD_TRACE_LOADED_OBJECTS_FMT1","%o \"%p\" %x\n",1) != 0) 2103 err(EX_OSERR, "ERROR: Cannot setenv"); 2104 2105 /* Initialize hash tables */ 2106 pmcstat_string_initialize(); 2107 for (i = 0; i < PMCSTAT_NHASH; i++) { 2108 LIST_INIT(&pmcstat_image_hash[i]); 2109 LIST_INIT(&pmcstat_process_hash[i]); 2110 } 2111 2112 /* 2113 * Create a fake 'process' entry for the kernel with pid -1. 2114 * hwpmc(4) will subsequently inform us about where the kernel 2115 * and any loaded kernel modules are mapped. 2116 */ 2117 if ((pmcstat_kernproc = pmcstat_process_lookup((pid_t) -1, 2118 PMCSTAT_ALLOCATE)) == NULL) 2119 err(EX_OSERR, "ERROR: Cannot initialize logging"); 2120 2121 /* PMC count. */ 2122 pmcstat_npmcs = 0; 2123 2124 /* Merge PMC with same name. */ 2125 pmcstat_mergepmc = args.pa_mergepmc; 2126 2127 /* 2128 * Initialize plugins 2129 */ 2130 2131 if (plugins[args.pa_pplugin].pl_init != NULL) 2132 plugins[args.pa_pplugin].pl_init(); 2133 if (plugins[args.pa_plugin].pl_init != NULL) 2134 plugins[args.pa_plugin].pl_init(); 2135} 2136 2137/* 2138 * Shutdown module. 2139 */ 2140 2141void 2142pmcstat_shutdown_logging(void) 2143{ 2144 int i; 2145 FILE *mf; 2146 struct pmcstat_image *pi, *pitmp; 2147 struct pmcstat_process *pp, *pptmp; 2148 struct pmcstat_pcmap *ppm, *ppmtmp; 2149 2150 /* determine where to send the map file */ 2151 mf = NULL; 2152 if (args.pa_mapfilename != NULL) 2153 mf = (strcmp(args.pa_mapfilename, "-") == 0) ? 2154 args.pa_printfile : fopen(args.pa_mapfilename, "w"); 2155 2156 if (mf == NULL && args.pa_flags & FLAG_DO_GPROF && 2157 args.pa_verbosity >= 2) 2158 mf = args.pa_printfile; 2159 2160 if (mf) 2161 (void) fprintf(mf, "MAP:\n"); 2162 2163 /* 2164 * Shutdown the plugins 2165 */ 2166 2167 if (plugins[args.pa_plugin].pl_shutdown != NULL) 2168 plugins[args.pa_plugin].pl_shutdown(mf); 2169 if (plugins[args.pa_pplugin].pl_shutdown != NULL) 2170 plugins[args.pa_pplugin].pl_shutdown(mf); 2171 2172 for (i = 0; i < PMCSTAT_NHASH; i++) { 2173 LIST_FOREACH_SAFE(pi, &pmcstat_image_hash[i], pi_next, 2174 pitmp) { 2175 if (plugins[args.pa_plugin].pl_shutdownimage != NULL) 2176 plugins[args.pa_plugin].pl_shutdownimage(pi); 2177 if (plugins[args.pa_pplugin].pl_shutdownimage != NULL) 2178 plugins[args.pa_pplugin].pl_shutdownimage(pi); 2179 2180 free(pi->pi_symbols); 2181 if (pi->pi_addr2line != NULL) 2182 pclose(pi->pi_addr2line); 2183 LIST_REMOVE(pi, pi_next); 2184 free(pi); 2185 } 2186 2187 LIST_FOREACH_SAFE(pp, &pmcstat_process_hash[i], pp_next, 2188 pptmp) { 2189 TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) { 2190 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next); 2191 free(ppm); 2192 } 2193 LIST_REMOVE(pp, pp_next); 2194 free(pp); 2195 } 2196 } 2197 2198 pmcstat_string_shutdown(); 2199 2200 /* 2201 * Print errors unless -q was specified. Print all statistics 2202 * if verbosity > 1. 2203 */ 2204#define PRINT(N,V) do { \ 2205 if (pmcstat_stats.ps_##V || args.pa_verbosity >= 2) \ 2206 (void) fprintf(args.pa_printfile, " %-40s %d\n",\ 2207 N, pmcstat_stats.ps_##V); \ 2208 } while (0) 2209 2210 if (args.pa_verbosity >= 1 && (args.pa_flags & FLAG_DO_ANALYSIS)) { 2211 (void) fprintf(args.pa_printfile, "CONVERSION STATISTICS:\n"); 2212 PRINT("#exec/a.out", exec_aout); 2213 PRINT("#exec/elf", exec_elf); 2214 PRINT("#exec/unknown", exec_indeterminable); 2215 PRINT("#exec handling errors", exec_errors); 2216 PRINT("#samples/total", samples_total); 2217 PRINT("#samples/unclaimed", samples_unknown_offset); 2218 PRINT("#samples/unknown-object", samples_indeterminable); 2219 PRINT("#samples/unknown-function", samples_unknown_function); 2220 PRINT("#callchain/dubious-frames", callchain_dubious_frames); 2221 } 2222 2223 if (mf) 2224 (void) fclose(mf); 2225} 2226