pmcstat_log.c revision 266590
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 266590 2014-05-23 17:46:00Z emaste $"); 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_offset & (-ph.p_align)) == 0) 720 image->pi_vaddr = ph.p_vaddr & (-ph.p_align); 721 break; 722 } 723 } 724 } 725 726 /* 727 * Get the min and max VA associated with this ELF object. 728 */ 729 if (elf_getshnum(e, &nsh) == 0) { 730 warnx( 731"WARNING: Could not determine the number of sections for \"%s\": %s.", 732 buffer, elf_errmsg(-1)); 733 goto done; 734 } 735 736 for (i = 0; i < nsh; i++) { 737 if ((scn = elf_getscn(e, i)) == NULL || 738 gelf_getshdr(scn, &sh) != &sh) { 739 warnx( 740"WARNING: Could not retrieve section header #%ju in \"%s\": %s.", 741 (uintmax_t) i, buffer, elf_errmsg(-1)); 742 goto done; 743 } 744 if (sh.sh_flags & SHF_EXECINSTR) { 745 minva = min(minva, sh.sh_addr); 746 maxva = max(maxva, sh.sh_addr + sh.sh_size); 747 } 748 if (sh.sh_type == SHT_SYMTAB || sh.sh_type == SHT_DYNSYM) 749 pmcstat_image_add_symbols(image, e, scn, &sh); 750 } 751 752 image->pi_start = minva; 753 image->pi_end = maxva; 754 image->pi_type = image_type; 755 image->pi_fullpath = pmcstat_string_intern(buffer); 756 757 /* Build display name 758 */ 759 endp = buffer; 760 for (p = buffer; *p; p++) 761 if (*p == '/') 762 endp = p+1; 763 image->pi_name = pmcstat_string_intern(endp); 764 765 done: 766 (void) elf_end(e); 767 if (fd >= 0) 768 (void) close(fd); 769 return; 770} 771 772/* 773 * Given an image descriptor, determine whether it is an ELF, or AOUT. 774 * If no handler claims the image, set its type to 'INDETERMINABLE'. 775 */ 776 777void 778pmcstat_image_determine_type(struct pmcstat_image *image) 779{ 780 assert(image->pi_type == PMCSTAT_IMAGE_UNKNOWN); 781 782 /* Try each kind of handler in turn */ 783 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 784 pmcstat_image_get_elf_params(image); 785 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 786 pmcstat_image_get_aout_params(image); 787 788 /* 789 * Otherwise, remember that we tried to determine 790 * the object's type and had failed. 791 */ 792 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 793 image->pi_type = PMCSTAT_IMAGE_INDETERMINABLE; 794} 795 796/* 797 * Locate an image descriptor given an interned path, adding a fresh 798 * descriptor to the cache if necessary. This function also finds a 799 * suitable name for this image's sample file. 800 * 801 * We defer filling in the file format specific parts of the image 802 * structure till the time we actually see a sample that would fall 803 * into this image. 804 */ 805 806static struct pmcstat_image * 807pmcstat_image_from_path(pmcstat_interned_string internedpath, 808 int iskernelmodule) 809{ 810 int hash; 811 struct pmcstat_image *pi; 812 813 hash = pmcstat_string_lookup_hash(internedpath); 814 815 /* First, look for an existing entry. */ 816 LIST_FOREACH(pi, &pmcstat_image_hash[hash], pi_next) 817 if (pi->pi_execpath == internedpath && 818 pi->pi_iskernelmodule == iskernelmodule) 819 return (pi); 820 821 /* 822 * Allocate a new entry and place it at the head of the hash 823 * and LRU lists. 824 */ 825 pi = malloc(sizeof(*pi)); 826 if (pi == NULL) 827 return (NULL); 828 829 pi->pi_type = PMCSTAT_IMAGE_UNKNOWN; 830 pi->pi_execpath = internedpath; 831 pi->pi_start = ~0; 832 pi->pi_end = 0; 833 pi->pi_entry = 0; 834 pi->pi_vaddr = 0; 835 pi->pi_isdynamic = 0; 836 pi->pi_iskernelmodule = iskernelmodule; 837 pi->pi_dynlinkerpath = NULL; 838 pi->pi_symbols = NULL; 839 pi->pi_symcount = 0; 840 pi->pi_addr2line = NULL; 841 842 if (plugins[args.pa_pplugin].pl_initimage != NULL) 843 plugins[args.pa_pplugin].pl_initimage(pi); 844 if (plugins[args.pa_plugin].pl_initimage != NULL) 845 plugins[args.pa_plugin].pl_initimage(pi); 846 847 LIST_INSERT_HEAD(&pmcstat_image_hash[hash], pi, pi_next); 848 849 return (pi); 850} 851 852/* 853 * Record the fact that PC values from 'start' to 'end' come from 854 * image 'image'. 855 */ 856 857static void 858pmcstat_image_link(struct pmcstat_process *pp, struct pmcstat_image *image, 859 uintfptr_t start) 860{ 861 struct pmcstat_pcmap *pcm, *pcmnew; 862 uintfptr_t offset; 863 864 assert(image->pi_type != PMCSTAT_IMAGE_UNKNOWN && 865 image->pi_type != PMCSTAT_IMAGE_INDETERMINABLE); 866 867 if ((pcmnew = malloc(sizeof(*pcmnew))) == NULL) 868 err(EX_OSERR, "ERROR: Cannot create a map entry"); 869 870 /* 871 * Adjust the map entry to only cover the text portion 872 * of the object. 873 */ 874 875 offset = start - image->pi_vaddr; 876 pcmnew->ppm_lowpc = image->pi_start + offset; 877 pcmnew->ppm_highpc = image->pi_end + offset; 878 pcmnew->ppm_image = image; 879 880 assert(pcmnew->ppm_lowpc < pcmnew->ppm_highpc); 881 882 /* Overlapped mmap()'s are assumed to never occur. */ 883 TAILQ_FOREACH(pcm, &pp->pp_map, ppm_next) 884 if (pcm->ppm_lowpc >= pcmnew->ppm_highpc) 885 break; 886 887 if (pcm == NULL) 888 TAILQ_INSERT_TAIL(&pp->pp_map, pcmnew, ppm_next); 889 else 890 TAILQ_INSERT_BEFORE(pcm, pcmnew, ppm_next); 891} 892 893/* 894 * Unmap images in the range [start..end) associated with process 895 * 'pp'. 896 */ 897 898static void 899pmcstat_image_unmap(struct pmcstat_process *pp, uintfptr_t start, 900 uintfptr_t end) 901{ 902 struct pmcstat_pcmap *pcm, *pcmtmp, *pcmnew; 903 904 assert(pp != NULL); 905 assert(start < end); 906 907 /* 908 * Cases: 909 * - we could have the range completely in the middle of an 910 * existing pcmap; in this case we have to split the pcmap 911 * structure into two (i.e., generate a 'hole'). 912 * - we could have the range covering multiple pcmaps; these 913 * will have to be removed. 914 * - we could have either 'start' or 'end' falling in the 915 * middle of a pcmap; in this case shorten the entry. 916 */ 917 TAILQ_FOREACH_SAFE(pcm, &pp->pp_map, ppm_next, pcmtmp) { 918 assert(pcm->ppm_lowpc < pcm->ppm_highpc); 919 if (pcm->ppm_highpc <= start) 920 continue; 921 if (pcm->ppm_lowpc >= end) 922 return; 923 if (pcm->ppm_lowpc >= start && pcm->ppm_highpc <= end) { 924 /* 925 * The current pcmap is completely inside the 926 * unmapped range: remove it entirely. 927 */ 928 TAILQ_REMOVE(&pp->pp_map, pcm, ppm_next); 929 free(pcm); 930 } else if (pcm->ppm_lowpc < start && pcm->ppm_highpc > end) { 931 /* 932 * Split this pcmap into two; curtail the 933 * current map to end at [start-1], and start 934 * the new one at [end]. 935 */ 936 if ((pcmnew = malloc(sizeof(*pcmnew))) == NULL) 937 err(EX_OSERR, 938 "ERROR: Cannot split a map entry"); 939 940 pcmnew->ppm_image = pcm->ppm_image; 941 942 pcmnew->ppm_lowpc = end; 943 pcmnew->ppm_highpc = pcm->ppm_highpc; 944 945 pcm->ppm_highpc = start; 946 947 TAILQ_INSERT_AFTER(&pp->pp_map, pcm, pcmnew, ppm_next); 948 949 return; 950 } else if (pcm->ppm_lowpc < start && pcm->ppm_highpc <= end) 951 pcm->ppm_highpc = start; 952 else if (pcm->ppm_lowpc >= start && pcm->ppm_highpc > end) 953 pcm->ppm_lowpc = end; 954 else 955 assert(0); 956 } 957} 958 959/* 960 * Resolve file name and line number for the given address. 961 */ 962int 963pmcstat_image_addr2line(struct pmcstat_image *image, uintfptr_t addr, 964 char *sourcefile, size_t sourcefile_len, unsigned *sourceline, 965 char *funcname, size_t funcname_len) 966{ 967 static int addr2line_warn = 0; 968 unsigned l; 969 970 char *sep, cmdline[PATH_MAX], imagepath[PATH_MAX]; 971 int fd; 972 973 if (image->pi_addr2line == NULL) { 974 snprintf(imagepath, sizeof(imagepath), "%s%s.symbols", 975 args.pa_fsroot, 976 pmcstat_string_unintern(image->pi_fullpath)); 977 fd = open(imagepath, O_RDONLY); 978 if (fd < 0) { 979 snprintf(imagepath, sizeof(imagepath), "%s%s", 980 args.pa_fsroot, 981 pmcstat_string_unintern(image->pi_fullpath)); 982 } else 983 close(fd); 984 /* 985 * New addr2line support recursive inline function with -i 986 * but the format does not add a marker when no more entries 987 * are available. 988 */ 989 snprintf(cmdline, sizeof(cmdline), "addr2line -Cfe \"%s\"", 990 imagepath); 991 image->pi_addr2line = popen(cmdline, "r+"); 992 if (image->pi_addr2line == NULL) { 993 if (!addr2line_warn) { 994 addr2line_warn = 1; 995 warnx( 996"WARNING: addr2line is needed for source code information." 997 ); 998 } 999 return (0); 1000 } 1001 } 1002 1003 if (feof(image->pi_addr2line) || ferror(image->pi_addr2line)) { 1004 warnx("WARNING: addr2line pipe error"); 1005 pclose(image->pi_addr2line); 1006 image->pi_addr2line = NULL; 1007 return (0); 1008 } 1009 1010 fprintf(image->pi_addr2line, "%p\n", (void *)addr); 1011 1012 if (fgets(funcname, funcname_len, image->pi_addr2line) == NULL) { 1013 warnx("WARNING: addr2line function name read error"); 1014 return (0); 1015 } 1016 sep = strchr(funcname, '\n'); 1017 if (sep != NULL) 1018 *sep = '\0'; 1019 1020 if (fgets(sourcefile, sourcefile_len, image->pi_addr2line) == NULL) { 1021 warnx("WARNING: addr2line source file read error"); 1022 return (0); 1023 } 1024 sep = strchr(sourcefile, ':'); 1025 if (sep == NULL) { 1026 warnx("WARNING: addr2line source line separator missing"); 1027 return (0); 1028 } 1029 *sep = '\0'; 1030 l = atoi(sep+1); 1031 if (l == 0) 1032 return (0); 1033 *sourceline = l; 1034 return (1); 1035} 1036 1037/* 1038 * Add a {pmcid,name} mapping. 1039 */ 1040 1041static void 1042pmcstat_pmcid_add(pmc_id_t pmcid, pmcstat_interned_string ps) 1043{ 1044 struct pmcstat_pmcrecord *pr, *prm; 1045 1046 /* Replace an existing name for the PMC. */ 1047 prm = NULL; 1048 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1049 if (pr->pr_pmcid == pmcid) { 1050 pr->pr_pmcname = ps; 1051 return; 1052 } else if (pr->pr_pmcname == ps) 1053 prm = pr; 1054 1055 /* 1056 * Otherwise, allocate a new descriptor and call the 1057 * plugins hook. 1058 */ 1059 if ((pr = malloc(sizeof(*pr))) == NULL) 1060 err(EX_OSERR, "ERROR: Cannot allocate pmc record"); 1061 1062 pr->pr_pmcid = pmcid; 1063 pr->pr_pmcname = ps; 1064 pr->pr_pmcin = pmcstat_npmcs++; 1065 pr->pr_samples = 0; 1066 pr->pr_dubious_frames = 0; 1067 pr->pr_merge = prm == NULL ? pr : prm; 1068 1069 LIST_INSERT_HEAD(&pmcstat_pmcs, pr, pr_next); 1070 1071 if (plugins[args.pa_pplugin].pl_newpmc != NULL) 1072 plugins[args.pa_pplugin].pl_newpmc(ps, pr); 1073 if (plugins[args.pa_plugin].pl_newpmc != NULL) 1074 plugins[args.pa_plugin].pl_newpmc(ps, pr); 1075} 1076 1077/* 1078 * Given a pmcid in use, find its human-readable name. 1079 */ 1080 1081const char * 1082pmcstat_pmcid_to_name(pmc_id_t pmcid) 1083{ 1084 struct pmcstat_pmcrecord *pr; 1085 1086 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1087 if (pr->pr_pmcid == pmcid) 1088 return (pmcstat_string_unintern(pr->pr_pmcname)); 1089 1090 return NULL; 1091} 1092 1093/* 1094 * Convert PMC index to name. 1095 */ 1096 1097const char * 1098pmcstat_pmcindex_to_name(int pmcin) 1099{ 1100 struct pmcstat_pmcrecord *pr; 1101 1102 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1103 if (pr->pr_pmcin == pmcin) 1104 return pmcstat_string_unintern(pr->pr_pmcname); 1105 1106 return NULL; 1107} 1108 1109/* 1110 * Return PMC record with given index. 1111 */ 1112 1113struct pmcstat_pmcrecord * 1114pmcstat_pmcindex_to_pmcr(int pmcin) 1115{ 1116 struct pmcstat_pmcrecord *pr; 1117 1118 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) 1119 if (pr->pr_pmcin == pmcin) 1120 return pr; 1121 1122 return NULL; 1123} 1124 1125/* 1126 * Get PMC record by id, apply merge policy. 1127 */ 1128 1129static struct pmcstat_pmcrecord * 1130pmcstat_lookup_pmcid(pmc_id_t pmcid) 1131{ 1132 struct pmcstat_pmcrecord *pr; 1133 1134 LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) { 1135 if (pr->pr_pmcid == pmcid) { 1136 if (pmcstat_mergepmc) 1137 return pr->pr_merge; 1138 return pr; 1139 } 1140 } 1141 1142 return NULL; 1143} 1144 1145/* 1146 * Associate an AOUT image with a process. 1147 */ 1148 1149static void 1150pmcstat_process_aout_exec(struct pmcstat_process *pp, 1151 struct pmcstat_image *image, uintfptr_t entryaddr) 1152{ 1153 (void) pp; 1154 (void) image; 1155 (void) entryaddr; 1156 /* TODO Implement a.out handling */ 1157} 1158 1159/* 1160 * Associate an ELF image with a process. 1161 */ 1162 1163static void 1164pmcstat_process_elf_exec(struct pmcstat_process *pp, 1165 struct pmcstat_image *image, uintfptr_t entryaddr) 1166{ 1167 uintmax_t libstart; 1168 struct pmcstat_image *rtldimage; 1169 1170 assert(image->pi_type == PMCSTAT_IMAGE_ELF32 || 1171 image->pi_type == PMCSTAT_IMAGE_ELF64); 1172 1173 /* Create a map entry for the base executable. */ 1174 pmcstat_image_link(pp, image, image->pi_vaddr); 1175 1176 /* 1177 * For dynamically linked executables we need to determine 1178 * where the dynamic linker was mapped to for this process, 1179 * Subsequent executable objects that are mapped in by the 1180 * dynamic linker will be tracked by log events of type 1181 * PMCLOG_TYPE_MAP_IN. 1182 */ 1183 1184 if (image->pi_isdynamic) { 1185 1186 /* 1187 * The runtime loader gets loaded just after the maximum 1188 * possible heap address. Like so: 1189 * 1190 * [ TEXT DATA BSS HEAP -->*RTLD SHLIBS <--STACK] 1191 * ^ ^ 1192 * 0 VM_MAXUSER_ADDRESS 1193 1194 * 1195 * The exact address where the loader gets mapped in 1196 * will vary according to the size of the executable 1197 * and the limits on the size of the process'es data 1198 * segment at the time of exec(). The entry address 1199 * recorded at process exec time corresponds to the 1200 * 'start' address inside the dynamic linker. From 1201 * this we can figure out the address where the 1202 * runtime loader's file object had been mapped to. 1203 */ 1204 rtldimage = pmcstat_image_from_path(image->pi_dynlinkerpath, 0); 1205 if (rtldimage == NULL) { 1206 warnx("WARNING: Cannot find image for \"%s\".", 1207 pmcstat_string_unintern(image->pi_dynlinkerpath)); 1208 pmcstat_stats.ps_exec_errors++; 1209 return; 1210 } 1211 1212 if (rtldimage->pi_type == PMCSTAT_IMAGE_UNKNOWN) 1213 pmcstat_image_get_elf_params(rtldimage); 1214 1215 if (rtldimage->pi_type != PMCSTAT_IMAGE_ELF32 && 1216 rtldimage->pi_type != PMCSTAT_IMAGE_ELF64) { 1217 warnx("WARNING: rtld not an ELF object \"%s\".", 1218 pmcstat_string_unintern(image->pi_dynlinkerpath)); 1219 return; 1220 } 1221 1222 libstart = entryaddr - rtldimage->pi_entry; 1223 pmcstat_image_link(pp, rtldimage, libstart); 1224 } 1225} 1226 1227/* 1228 * Find the process descriptor corresponding to a PID. If 'allocate' 1229 * is zero, we return a NULL if a pid descriptor could not be found or 1230 * a process descriptor process. If 'allocate' is non-zero, then we 1231 * will attempt to allocate a fresh process descriptor. Zombie 1232 * process descriptors are only removed if a fresh allocation for the 1233 * same PID is requested. 1234 */ 1235 1236static struct pmcstat_process * 1237pmcstat_process_lookup(pid_t pid, int allocate) 1238{ 1239 uint32_t hash; 1240 struct pmcstat_pcmap *ppm, *ppmtmp; 1241 struct pmcstat_process *pp, *pptmp; 1242 1243 hash = (uint32_t) pid & PMCSTAT_HASH_MASK; /* simplicity wins */ 1244 1245 LIST_FOREACH_SAFE(pp, &pmcstat_process_hash[hash], pp_next, pptmp) 1246 if (pp->pp_pid == pid) { 1247 /* Found a descriptor, check and process zombies */ 1248 if (allocate && pp->pp_isactive == 0) { 1249 /* remove maps */ 1250 TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, 1251 ppmtmp) { 1252 TAILQ_REMOVE(&pp->pp_map, ppm, 1253 ppm_next); 1254 free(ppm); 1255 } 1256 /* remove process entry */ 1257 LIST_REMOVE(pp, pp_next); 1258 free(pp); 1259 break; 1260 } 1261 return (pp); 1262 } 1263 1264 if (!allocate) 1265 return (NULL); 1266 1267 if ((pp = malloc(sizeof(*pp))) == NULL) 1268 err(EX_OSERR, "ERROR: Cannot allocate pid descriptor"); 1269 1270 pp->pp_pid = pid; 1271 pp->pp_isactive = 1; 1272 1273 TAILQ_INIT(&pp->pp_map); 1274 1275 LIST_INSERT_HEAD(&pmcstat_process_hash[hash], pp, pp_next); 1276 return (pp); 1277} 1278 1279/* 1280 * Associate an image and a process. 1281 */ 1282 1283static void 1284pmcstat_process_exec(struct pmcstat_process *pp, 1285 pmcstat_interned_string path, uintfptr_t entryaddr) 1286{ 1287 struct pmcstat_image *image; 1288 1289 if ((image = pmcstat_image_from_path(path, 0)) == NULL) { 1290 pmcstat_stats.ps_exec_errors++; 1291 return; 1292 } 1293 1294 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 1295 pmcstat_image_determine_type(image); 1296 1297 assert(image->pi_type != PMCSTAT_IMAGE_UNKNOWN); 1298 1299 switch (image->pi_type) { 1300 case PMCSTAT_IMAGE_ELF32: 1301 case PMCSTAT_IMAGE_ELF64: 1302 pmcstat_stats.ps_exec_elf++; 1303 pmcstat_process_elf_exec(pp, image, entryaddr); 1304 break; 1305 1306 case PMCSTAT_IMAGE_AOUT: 1307 pmcstat_stats.ps_exec_aout++; 1308 pmcstat_process_aout_exec(pp, image, entryaddr); 1309 break; 1310 1311 case PMCSTAT_IMAGE_INDETERMINABLE: 1312 pmcstat_stats.ps_exec_indeterminable++; 1313 break; 1314 1315 default: 1316 err(EX_SOFTWARE, 1317 "ERROR: Unsupported executable type for \"%s\"", 1318 pmcstat_string_unintern(path)); 1319 } 1320} 1321 1322 1323/* 1324 * Find the map entry associated with process 'p' at PC value 'pc'. 1325 */ 1326 1327struct pmcstat_pcmap * 1328pmcstat_process_find_map(struct pmcstat_process *p, uintfptr_t pc) 1329{ 1330 struct pmcstat_pcmap *ppm; 1331 1332 TAILQ_FOREACH(ppm, &p->pp_map, ppm_next) { 1333 if (pc >= ppm->ppm_lowpc && pc < ppm->ppm_highpc) 1334 return (ppm); 1335 if (pc < ppm->ppm_lowpc) 1336 return (NULL); 1337 } 1338 1339 return (NULL); 1340} 1341 1342/* 1343 * Convert a hwpmc(4) log to profile information. A system-wide 1344 * callgraph is generated if FLAG_DO_CALLGRAPHS is set. gmon.out 1345 * files usable by gprof(1) are created if FLAG_DO_GPROF is set. 1346 */ 1347static int 1348pmcstat_analyze_log(void) 1349{ 1350 uint32_t cpu, cpuflags; 1351 uintfptr_t pc; 1352 pid_t pid; 1353 struct pmcstat_image *image; 1354 struct pmcstat_process *pp, *ppnew; 1355 struct pmcstat_pcmap *ppm, *ppmtmp; 1356 struct pmclog_ev ev; 1357 struct pmcstat_pmcrecord *pmcr; 1358 pmcstat_interned_string image_path; 1359 1360 assert(args.pa_flags & FLAG_DO_ANALYSIS); 1361 1362 if (elf_version(EV_CURRENT) == EV_NONE) 1363 err(EX_UNAVAILABLE, "Elf library intialization failed"); 1364 1365 while (pmclog_read(args.pa_logparser, &ev) == 0) { 1366 assert(ev.pl_state == PMCLOG_OK); 1367 1368 switch (ev.pl_type) { 1369 case PMCLOG_TYPE_INITIALIZE: 1370 if ((ev.pl_u.pl_i.pl_version & 0xFF000000) != 1371 PMC_VERSION_MAJOR << 24 && args.pa_verbosity > 0) 1372 warnx( 1373"WARNING: Log version 0x%x does not match compiled version 0x%x.", 1374 ev.pl_u.pl_i.pl_version, PMC_VERSION_MAJOR); 1375 break; 1376 1377 case PMCLOG_TYPE_MAP_IN: 1378 /* 1379 * Introduce an address range mapping for a 1380 * userland process or the kernel (pid == -1). 1381 * 1382 * We always allocate a process descriptor so 1383 * that subsequent samples seen for this 1384 * address range are mapped to the current 1385 * object being mapped in. 1386 */ 1387 pid = ev.pl_u.pl_mi.pl_pid; 1388 if (pid == -1) 1389 pp = pmcstat_kernproc; 1390 else 1391 pp = pmcstat_process_lookup(pid, 1392 PMCSTAT_ALLOCATE); 1393 1394 assert(pp != NULL); 1395 1396 image_path = pmcstat_string_intern(ev.pl_u.pl_mi. 1397 pl_pathname); 1398 image = pmcstat_image_from_path(image_path, pid == -1); 1399 if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN) 1400 pmcstat_image_determine_type(image); 1401 if (image->pi_type != PMCSTAT_IMAGE_INDETERMINABLE) 1402 pmcstat_image_link(pp, image, 1403 ev.pl_u.pl_mi.pl_start); 1404 break; 1405 1406 case PMCLOG_TYPE_MAP_OUT: 1407 /* 1408 * Remove an address map. 1409 */ 1410 pid = ev.pl_u.pl_mo.pl_pid; 1411 if (pid == -1) 1412 pp = pmcstat_kernproc; 1413 else 1414 pp = pmcstat_process_lookup(pid, 0); 1415 1416 if (pp == NULL) /* unknown process */ 1417 break; 1418 1419 pmcstat_image_unmap(pp, ev.pl_u.pl_mo.pl_start, 1420 ev.pl_u.pl_mo.pl_end); 1421 break; 1422 1423 case PMCLOG_TYPE_PCSAMPLE: 1424 /* 1425 * Note: the `PCSAMPLE' log entry is not 1426 * generated by hpwmc(4) after version 2. 1427 */ 1428 1429 /* 1430 * We bring in the gmon file for the image 1431 * currently associated with the PMC & pid 1432 * pair and increment the appropriate entry 1433 * bin inside this. 1434 */ 1435 pmcstat_stats.ps_samples_total++; 1436 ps_samples_period++; 1437 1438 pc = ev.pl_u.pl_s.pl_pc; 1439 pp = pmcstat_process_lookup(ev.pl_u.pl_s.pl_pid, 1440 PMCSTAT_ALLOCATE); 1441 1442 /* Get PMC record. */ 1443 pmcr = pmcstat_lookup_pmcid(ev.pl_u.pl_s.pl_pmcid); 1444 assert(pmcr != NULL); 1445 pmcr->pr_samples++; 1446 1447 /* 1448 * Call the plugins processing 1449 * TODO: move pmcstat_process_find_map inside plugins 1450 */ 1451 1452 if (plugins[args.pa_pplugin].pl_process != NULL) 1453 plugins[args.pa_pplugin].pl_process( 1454 pp, pmcr, 1, &pc, 1455 pmcstat_process_find_map(pp, pc) != NULL, 0); 1456 plugins[args.pa_plugin].pl_process( 1457 pp, pmcr, 1, &pc, 1458 pmcstat_process_find_map(pp, pc) != NULL, 0); 1459 break; 1460 1461 case PMCLOG_TYPE_CALLCHAIN: 1462 pmcstat_stats.ps_samples_total++; 1463 ps_samples_period++; 1464 1465 cpuflags = ev.pl_u.pl_cc.pl_cpuflags; 1466 cpu = PMC_CALLCHAIN_CPUFLAGS_TO_CPU(cpuflags); 1467 1468 /* Filter on the CPU id. */ 1469 if (!CPU_ISSET(cpu, &(args.pa_cpumask))) { 1470 pmcstat_stats.ps_samples_skipped++; 1471 break; 1472 } 1473 1474 pp = pmcstat_process_lookup(ev.pl_u.pl_cc.pl_pid, 1475 PMCSTAT_ALLOCATE); 1476 1477 /* Get PMC record. */ 1478 pmcr = pmcstat_lookup_pmcid(ev.pl_u.pl_cc.pl_pmcid); 1479 assert(pmcr != NULL); 1480 pmcr->pr_samples++; 1481 1482 /* 1483 * Call the plugins processing 1484 */ 1485 1486 if (plugins[args.pa_pplugin].pl_process != NULL) 1487 plugins[args.pa_pplugin].pl_process( 1488 pp, pmcr, 1489 ev.pl_u.pl_cc.pl_npc, 1490 ev.pl_u.pl_cc.pl_pc, 1491 PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags), 1492 cpu); 1493 plugins[args.pa_plugin].pl_process( 1494 pp, pmcr, 1495 ev.pl_u.pl_cc.pl_npc, 1496 ev.pl_u.pl_cc.pl_pc, 1497 PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags), 1498 cpu); 1499 break; 1500 1501 case PMCLOG_TYPE_PMCALLOCATE: 1502 /* 1503 * Record the association pmc id between this 1504 * PMC and its name. 1505 */ 1506 pmcstat_pmcid_add(ev.pl_u.pl_a.pl_pmcid, 1507 pmcstat_string_intern(ev.pl_u.pl_a.pl_evname)); 1508 break; 1509 1510 case PMCLOG_TYPE_PMCALLOCATEDYN: 1511 /* 1512 * Record the association pmc id between this 1513 * PMC and its name. 1514 */ 1515 pmcstat_pmcid_add(ev.pl_u.pl_ad.pl_pmcid, 1516 pmcstat_string_intern(ev.pl_u.pl_ad.pl_evname)); 1517 break; 1518 1519 case PMCLOG_TYPE_PROCEXEC: 1520 1521 /* 1522 * Change the executable image associated with 1523 * a process. 1524 */ 1525 pp = pmcstat_process_lookup(ev.pl_u.pl_x.pl_pid, 1526 PMCSTAT_ALLOCATE); 1527 1528 /* delete the current process map */ 1529 TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) { 1530 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next); 1531 free(ppm); 1532 } 1533 1534 /* associate this process image */ 1535 image_path = pmcstat_string_intern( 1536 ev.pl_u.pl_x.pl_pathname); 1537 assert(image_path != NULL); 1538 pmcstat_process_exec(pp, image_path, 1539 ev.pl_u.pl_x.pl_entryaddr); 1540 break; 1541 1542 case PMCLOG_TYPE_PROCEXIT: 1543 1544 /* 1545 * Due to the way the log is generated, the 1546 * last few samples corresponding to a process 1547 * may appear in the log after the process 1548 * exit event is recorded. Thus we keep the 1549 * process' descriptor and associated data 1550 * structures around, but mark the process as 1551 * having exited. 1552 */ 1553 pp = pmcstat_process_lookup(ev.pl_u.pl_e.pl_pid, 0); 1554 if (pp == NULL) 1555 break; 1556 pp->pp_isactive = 0; /* mark as a zombie */ 1557 break; 1558 1559 case PMCLOG_TYPE_SYSEXIT: 1560 pp = pmcstat_process_lookup(ev.pl_u.pl_se.pl_pid, 0); 1561 if (pp == NULL) 1562 break; 1563 pp->pp_isactive = 0; /* make a zombie */ 1564 break; 1565 1566 case PMCLOG_TYPE_PROCFORK: 1567 1568 /* 1569 * Allocate a process descriptor for the new 1570 * (child) process. 1571 */ 1572 ppnew = 1573 pmcstat_process_lookup(ev.pl_u.pl_f.pl_newpid, 1574 PMCSTAT_ALLOCATE); 1575 1576 /* 1577 * If we had been tracking the parent, clone 1578 * its address maps. 1579 */ 1580 pp = pmcstat_process_lookup(ev.pl_u.pl_f.pl_oldpid, 0); 1581 if (pp == NULL) 1582 break; 1583 TAILQ_FOREACH(ppm, &pp->pp_map, ppm_next) 1584 pmcstat_image_link(ppnew, ppm->ppm_image, 1585 ppm->ppm_lowpc); 1586 break; 1587 1588 default: /* other types of entries are not relevant */ 1589 break; 1590 } 1591 } 1592 1593 if (ev.pl_state == PMCLOG_EOF) 1594 return (PMCSTAT_FINISHED); 1595 else if (ev.pl_state == PMCLOG_REQUIRE_DATA) 1596 return (PMCSTAT_RUNNING); 1597 1598 err(EX_DATAERR, 1599 "ERROR: event parsing failed (record %jd, offset 0x%jx)", 1600 (uintmax_t) ev.pl_count + 1, ev.pl_offset); 1601} 1602 1603/* 1604 * Print log entries as text. 1605 */ 1606 1607static int 1608pmcstat_print_log(void) 1609{ 1610 struct pmclog_ev ev; 1611 uint32_t npc; 1612 1613 while (pmclog_read(args.pa_logparser, &ev) == 0) { 1614 assert(ev.pl_state == PMCLOG_OK); 1615 switch (ev.pl_type) { 1616 case PMCLOG_TYPE_CALLCHAIN: 1617 PMCSTAT_PRINT_ENTRY("callchain", 1618 "%d 0x%x %d %d %c", ev.pl_u.pl_cc.pl_pid, 1619 ev.pl_u.pl_cc.pl_pmcid, 1620 PMC_CALLCHAIN_CPUFLAGS_TO_CPU(ev.pl_u.pl_cc. \ 1621 pl_cpuflags), ev.pl_u.pl_cc.pl_npc, 1622 PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(ev.pl_u.pl_cc.\ 1623 pl_cpuflags) ? 'u' : 's'); 1624 for (npc = 0; npc < ev.pl_u.pl_cc.pl_npc; npc++) 1625 PMCSTAT_PRINT_ENTRY("...", "%p", 1626 (void *) ev.pl_u.pl_cc.pl_pc[npc]); 1627 break; 1628 case PMCLOG_TYPE_CLOSELOG: 1629 PMCSTAT_PRINT_ENTRY("closelog",); 1630 break; 1631 case PMCLOG_TYPE_DROPNOTIFY: 1632 PMCSTAT_PRINT_ENTRY("drop",); 1633 break; 1634 case PMCLOG_TYPE_INITIALIZE: 1635 PMCSTAT_PRINT_ENTRY("initlog","0x%x \"%s\"", 1636 ev.pl_u.pl_i.pl_version, 1637 pmc_name_of_cputype(ev.pl_u.pl_i.pl_arch)); 1638 if ((ev.pl_u.pl_i.pl_version & 0xFF000000) != 1639 PMC_VERSION_MAJOR << 24 && args.pa_verbosity > 0) 1640 warnx( 1641"WARNING: Log version 0x%x != expected version 0x%x.", 1642 ev.pl_u.pl_i.pl_version, PMC_VERSION); 1643 break; 1644 case PMCLOG_TYPE_MAP_IN: 1645 PMCSTAT_PRINT_ENTRY("map-in","%d %p \"%s\"", 1646 ev.pl_u.pl_mi.pl_pid, 1647 (void *) ev.pl_u.pl_mi.pl_start, 1648 ev.pl_u.pl_mi.pl_pathname); 1649 break; 1650 case PMCLOG_TYPE_MAP_OUT: 1651 PMCSTAT_PRINT_ENTRY("map-out","%d %p %p", 1652 ev.pl_u.pl_mo.pl_pid, 1653 (void *) ev.pl_u.pl_mo.pl_start, 1654 (void *) ev.pl_u.pl_mo.pl_end); 1655 break; 1656 case PMCLOG_TYPE_PCSAMPLE: 1657 PMCSTAT_PRINT_ENTRY("sample","0x%x %d %p %c", 1658 ev.pl_u.pl_s.pl_pmcid, 1659 ev.pl_u.pl_s.pl_pid, 1660 (void *) ev.pl_u.pl_s.pl_pc, 1661 ev.pl_u.pl_s.pl_usermode ? 'u' : 's'); 1662 break; 1663 case PMCLOG_TYPE_PMCALLOCATE: 1664 PMCSTAT_PRINT_ENTRY("allocate","0x%x \"%s\" 0x%x", 1665 ev.pl_u.pl_a.pl_pmcid, 1666 ev.pl_u.pl_a.pl_evname, 1667 ev.pl_u.pl_a.pl_flags); 1668 break; 1669 case PMCLOG_TYPE_PMCALLOCATEDYN: 1670 PMCSTAT_PRINT_ENTRY("allocatedyn","0x%x \"%s\" 0x%x", 1671 ev.pl_u.pl_ad.pl_pmcid, 1672 ev.pl_u.pl_ad.pl_evname, 1673 ev.pl_u.pl_ad.pl_flags); 1674 break; 1675 case PMCLOG_TYPE_PMCATTACH: 1676 PMCSTAT_PRINT_ENTRY("attach","0x%x %d \"%s\"", 1677 ev.pl_u.pl_t.pl_pmcid, 1678 ev.pl_u.pl_t.pl_pid, 1679 ev.pl_u.pl_t.pl_pathname); 1680 break; 1681 case PMCLOG_TYPE_PMCDETACH: 1682 PMCSTAT_PRINT_ENTRY("detach","0x%x %d", 1683 ev.pl_u.pl_d.pl_pmcid, 1684 ev.pl_u.pl_d.pl_pid); 1685 break; 1686 case PMCLOG_TYPE_PROCCSW: 1687 PMCSTAT_PRINT_ENTRY("cswval","0x%x %d %jd", 1688 ev.pl_u.pl_c.pl_pmcid, 1689 ev.pl_u.pl_c.pl_pid, 1690 ev.pl_u.pl_c.pl_value); 1691 break; 1692 case PMCLOG_TYPE_PROCEXEC: 1693 PMCSTAT_PRINT_ENTRY("exec","0x%x %d %p \"%s\"", 1694 ev.pl_u.pl_x.pl_pmcid, 1695 ev.pl_u.pl_x.pl_pid, 1696 (void *) ev.pl_u.pl_x.pl_entryaddr, 1697 ev.pl_u.pl_x.pl_pathname); 1698 break; 1699 case PMCLOG_TYPE_PROCEXIT: 1700 PMCSTAT_PRINT_ENTRY("exitval","0x%x %d %jd", 1701 ev.pl_u.pl_e.pl_pmcid, 1702 ev.pl_u.pl_e.pl_pid, 1703 ev.pl_u.pl_e.pl_value); 1704 break; 1705 case PMCLOG_TYPE_PROCFORK: 1706 PMCSTAT_PRINT_ENTRY("fork","%d %d", 1707 ev.pl_u.pl_f.pl_oldpid, 1708 ev.pl_u.pl_f.pl_newpid); 1709 break; 1710 case PMCLOG_TYPE_USERDATA: 1711 PMCSTAT_PRINT_ENTRY("userdata","0x%x", 1712 ev.pl_u.pl_u.pl_userdata); 1713 break; 1714 case PMCLOG_TYPE_SYSEXIT: 1715 PMCSTAT_PRINT_ENTRY("exit","%d", 1716 ev.pl_u.pl_se.pl_pid); 1717 break; 1718 default: 1719 fprintf(args.pa_printfile, "unknown event (type %d).\n", 1720 ev.pl_type); 1721 } 1722 } 1723 1724 if (ev.pl_state == PMCLOG_EOF) 1725 return (PMCSTAT_FINISHED); 1726 else if (ev.pl_state == PMCLOG_REQUIRE_DATA) 1727 return (PMCSTAT_RUNNING); 1728 1729 errx(EX_DATAERR, 1730 "ERROR: event parsing failed (record %jd, offset 0x%jx).", 1731 (uintmax_t) ev.pl_count + 1, ev.pl_offset); 1732 /*NOTREACHED*/ 1733} 1734 1735/* 1736 * Public Interfaces. 1737 */ 1738 1739/* 1740 * Close a logfile, after first flushing all in-module queued data. 1741 */ 1742 1743int 1744pmcstat_close_log(void) 1745{ 1746 /* If a local logfile is configured ask the kernel to stop 1747 * and flush data. Kernel will close the file when data is flushed 1748 * so keep the status to EXITING. 1749 */ 1750 if (args.pa_logfd != -1) { 1751 if (pmc_close_logfile() < 0) 1752 err(EX_OSERR, "ERROR: logging failed"); 1753 } 1754 1755 return (args.pa_flags & FLAG_HAS_PIPE ? PMCSTAT_EXITING : 1756 PMCSTAT_FINISHED); 1757} 1758 1759 1760 1761/* 1762 * Open a log file, for reading or writing. 1763 * 1764 * The function returns the fd of a successfully opened log or -1 in 1765 * case of failure. 1766 */ 1767 1768int 1769pmcstat_open_log(const char *path, int mode) 1770{ 1771 int error, fd, cfd; 1772 size_t hlen; 1773 const char *p, *errstr; 1774 struct addrinfo hints, *res, *res0; 1775 char hostname[MAXHOSTNAMELEN]; 1776 1777 errstr = NULL; 1778 fd = -1; 1779 1780 /* 1781 * If 'path' is "-" then open one of stdin or stdout depending 1782 * on the value of 'mode'. 1783 * 1784 * If 'path' contains a ':' and does not start with a '/' or '.', 1785 * and is being opened for writing, treat it as a "host:port" 1786 * specification and open a network socket. 1787 * 1788 * Otherwise, treat 'path' as a file name and open that. 1789 */ 1790 if (path[0] == '-' && path[1] == '\0') 1791 fd = (mode == PMCSTAT_OPEN_FOR_READ) ? 0 : 1; 1792 else if (path[0] != '/' && 1793 path[0] != '.' && strchr(path, ':') != NULL) { 1794 1795 p = strrchr(path, ':'); 1796 hlen = p - path; 1797 if (p == path || hlen >= sizeof(hostname)) { 1798 errstr = strerror(EINVAL); 1799 goto done; 1800 } 1801 1802 assert(hlen < sizeof(hostname)); 1803 (void) strncpy(hostname, path, hlen); 1804 hostname[hlen] = '\0'; 1805 1806 (void) memset(&hints, 0, sizeof(hints)); 1807 hints.ai_family = AF_UNSPEC; 1808 hints.ai_socktype = SOCK_STREAM; 1809 if ((error = getaddrinfo(hostname, p+1, &hints, &res0)) != 0) { 1810 errstr = gai_strerror(error); 1811 goto done; 1812 } 1813 1814 fd = -1; 1815 for (res = res0; res; res = res->ai_next) { 1816 if ((fd = socket(res->ai_family, res->ai_socktype, 1817 res->ai_protocol)) < 0) { 1818 errstr = strerror(errno); 1819 continue; 1820 } 1821 if (mode == PMCSTAT_OPEN_FOR_READ) { 1822 if (bind(fd, res->ai_addr, res->ai_addrlen) < 0) { 1823 errstr = strerror(errno); 1824 (void) close(fd); 1825 fd = -1; 1826 continue; 1827 } 1828 listen(fd, 1); 1829 cfd = accept(fd, NULL, NULL); 1830 (void) close(fd); 1831 if (cfd < 0) { 1832 errstr = strerror(errno); 1833 fd = -1; 1834 break; 1835 } 1836 fd = cfd; 1837 } else { 1838 if (connect(fd, res->ai_addr, res->ai_addrlen) < 0) { 1839 errstr = strerror(errno); 1840 (void) close(fd); 1841 fd = -1; 1842 continue; 1843 } 1844 } 1845 errstr = NULL; 1846 break; 1847 } 1848 freeaddrinfo(res0); 1849 1850 } else if ((fd = open(path, mode == PMCSTAT_OPEN_FOR_READ ? 1851 O_RDONLY : (O_WRONLY|O_CREAT|O_TRUNC), 1852 S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0) 1853 errstr = strerror(errno); 1854 1855 done: 1856 if (errstr) 1857 errx(EX_OSERR, "ERROR: Cannot open \"%s\" for %s: %s.", path, 1858 (mode == PMCSTAT_OPEN_FOR_READ ? "reading" : "writing"), 1859 errstr); 1860 1861 return (fd); 1862} 1863 1864/* 1865 * Process a log file in offline analysis mode. 1866 */ 1867 1868int 1869pmcstat_process_log(void) 1870{ 1871 1872 /* 1873 * If analysis has not been asked for, just print the log to 1874 * the current output file. 1875 */ 1876 if (args.pa_flags & FLAG_DO_PRINT) 1877 return (pmcstat_print_log()); 1878 else 1879 return (pmcstat_analyze_log()); 1880} 1881 1882/* 1883 * Refresh top display. 1884 */ 1885 1886static void 1887pmcstat_refresh_top(void) 1888{ 1889 int v_attrs; 1890 float v; 1891 char pmcname[40]; 1892 struct pmcstat_pmcrecord *pmcpr; 1893 1894 /* If in pause mode do not refresh display. */ 1895 if (pmcstat_pause) 1896 return; 1897 1898 /* Wait until PMC pop in the log. */ 1899 pmcpr = pmcstat_pmcindex_to_pmcr(pmcstat_pmcinfilter); 1900 if (pmcpr == NULL) 1901 return; 1902 1903 /* Format PMC name. */ 1904 if (pmcstat_mergepmc) 1905 snprintf(pmcname, sizeof(pmcname), "[%s]", 1906 pmcstat_string_unintern(pmcpr->pr_pmcname)); 1907 else 1908 snprintf(pmcname, sizeof(pmcname), "%s.%d", 1909 pmcstat_string_unintern(pmcpr->pr_pmcname), 1910 pmcstat_pmcinfilter); 1911 1912 /* Format samples count. */ 1913 if (ps_samples_period > 0) 1914 v = (pmcpr->pr_samples * 100.0) / ps_samples_period; 1915 else 1916 v = 0.; 1917 v_attrs = PMCSTAT_ATTRPERCENT(v); 1918 1919 PMCSTAT_PRINTBEGIN(); 1920 PMCSTAT_PRINTW("PMC: %s Samples: %u ", 1921 pmcname, 1922 pmcpr->pr_samples); 1923 PMCSTAT_ATTRON(v_attrs); 1924 PMCSTAT_PRINTW("(%.1f%%) ", v); 1925 PMCSTAT_ATTROFF(v_attrs); 1926 PMCSTAT_PRINTW(", %u unresolved\n\n", 1927 pmcpr->pr_dubious_frames); 1928 if (plugins[args.pa_plugin].pl_topdisplay != NULL) 1929 plugins[args.pa_plugin].pl_topdisplay(); 1930 PMCSTAT_PRINTEND(); 1931} 1932 1933/* 1934 * Find the next pmc index to display. 1935 */ 1936 1937static void 1938pmcstat_changefilter(void) 1939{ 1940 int pmcin; 1941 struct pmcstat_pmcrecord *pmcr; 1942 1943 /* 1944 * Find the next merge target. 1945 */ 1946 if (pmcstat_mergepmc) { 1947 pmcin = pmcstat_pmcinfilter; 1948 1949 do { 1950 pmcr = pmcstat_pmcindex_to_pmcr(pmcstat_pmcinfilter); 1951 if (pmcr == NULL || pmcr == pmcr->pr_merge) 1952 break; 1953 1954 pmcstat_pmcinfilter++; 1955 if (pmcstat_pmcinfilter >= pmcstat_npmcs) 1956 pmcstat_pmcinfilter = 0; 1957 1958 } while (pmcstat_pmcinfilter != pmcin); 1959 } 1960} 1961 1962/* 1963 * Top mode keypress. 1964 */ 1965 1966int 1967pmcstat_keypress_log(void) 1968{ 1969 int c, ret = 0; 1970 WINDOW *w; 1971 1972 w = newwin(1, 0, 1, 0); 1973 c = wgetch(w); 1974 wprintw(w, "Key: %c => ", c); 1975 switch (c) { 1976 case 'c': 1977 wprintw(w, "enter mode 'd' or 'a' => "); 1978 c = wgetch(w); 1979 if (c == 'd') { 1980 args.pa_topmode = PMCSTAT_TOP_DELTA; 1981 wprintw(w, "switching to delta mode"); 1982 } else { 1983 args.pa_topmode = PMCSTAT_TOP_ACCUM; 1984 wprintw(w, "switching to accumulation mode"); 1985 } 1986 break; 1987 case 'm': 1988 pmcstat_mergepmc = !pmcstat_mergepmc; 1989 /* 1990 * Changing merge state require data reset. 1991 */ 1992 if (plugins[args.pa_plugin].pl_shutdown != NULL) 1993 plugins[args.pa_plugin].pl_shutdown(NULL); 1994 pmcstat_stats_reset(0); 1995 if (plugins[args.pa_plugin].pl_init != NULL) 1996 plugins[args.pa_plugin].pl_init(); 1997 1998 /* Update filter to be on a merge target. */ 1999 pmcstat_changefilter(); 2000 wprintw(w, "merge PMC %s", pmcstat_mergepmc ? "on" : "off"); 2001 break; 2002 case 'n': 2003 /* Close current plugin. */ 2004 if (plugins[args.pa_plugin].pl_shutdown != NULL) 2005 plugins[args.pa_plugin].pl_shutdown(NULL); 2006 2007 /* Find next top display available. */ 2008 do { 2009 args.pa_plugin++; 2010 if (plugins[args.pa_plugin].pl_name == NULL) 2011 args.pa_plugin = 0; 2012 } while (plugins[args.pa_plugin].pl_topdisplay == NULL); 2013 2014 /* Open new plugin. */ 2015 pmcstat_stats_reset(0); 2016 if (plugins[args.pa_plugin].pl_init != NULL) 2017 plugins[args.pa_plugin].pl_init(); 2018 wprintw(w, "switching to plugin %s", 2019 plugins[args.pa_plugin].pl_name); 2020 break; 2021 case 'p': 2022 pmcstat_pmcinfilter++; 2023 if (pmcstat_pmcinfilter >= pmcstat_npmcs) 2024 pmcstat_pmcinfilter = 0; 2025 pmcstat_changefilter(); 2026 wprintw(w, "switching to PMC %s.%d", 2027 pmcstat_pmcindex_to_name(pmcstat_pmcinfilter), 2028 pmcstat_pmcinfilter); 2029 break; 2030 case ' ': 2031 pmcstat_pause = !pmcstat_pause; 2032 if (pmcstat_pause) 2033 wprintw(w, "pause => press space again to continue"); 2034 break; 2035 case 'q': 2036 wprintw(w, "exiting..."); 2037 ret = 1; 2038 break; 2039 default: 2040 if (plugins[args.pa_plugin].pl_topkeypress != NULL) 2041 if (plugins[args.pa_plugin].pl_topkeypress(c, w)) 2042 ret = 1; 2043 } 2044 2045 wrefresh(w); 2046 delwin(w); 2047 return ret; 2048} 2049 2050 2051/* 2052 * Top mode display. 2053 */ 2054 2055void 2056pmcstat_display_log(void) 2057{ 2058 2059 pmcstat_refresh_top(); 2060 2061 /* Reset everythings if delta mode. */ 2062 if (args.pa_topmode == PMCSTAT_TOP_DELTA) { 2063 if (plugins[args.pa_plugin].pl_shutdown != NULL) 2064 plugins[args.pa_plugin].pl_shutdown(NULL); 2065 pmcstat_stats_reset(0); 2066 if (plugins[args.pa_plugin].pl_init != NULL) 2067 plugins[args.pa_plugin].pl_init(); 2068 } 2069 2070} 2071 2072/* 2073 * Configure a plugins. 2074 */ 2075 2076void 2077pmcstat_pluginconfigure_log(char *opt) 2078{ 2079 2080 if (strncmp(opt, "threshold=", 10) == 0) { 2081 pmcstat_threshold = atof(opt+10); 2082 } else { 2083 if (plugins[args.pa_plugin].pl_configure != NULL) { 2084 if (!plugins[args.pa_plugin].pl_configure(opt)) 2085 err(EX_USAGE, 2086 "ERROR: unknown option <%s>.", opt); 2087 } 2088 } 2089} 2090 2091/* 2092 * Initialize module. 2093 */ 2094 2095void 2096pmcstat_initialize_logging(void) 2097{ 2098 int i; 2099 2100 /* use a convenient format for 'ldd' output */ 2101 if (setenv("LD_TRACE_LOADED_OBJECTS_FMT1","%o \"%p\" %x\n",1) != 0) 2102 err(EX_OSERR, "ERROR: Cannot setenv"); 2103 2104 /* Initialize hash tables */ 2105 pmcstat_string_initialize(); 2106 for (i = 0; i < PMCSTAT_NHASH; i++) { 2107 LIST_INIT(&pmcstat_image_hash[i]); 2108 LIST_INIT(&pmcstat_process_hash[i]); 2109 } 2110 2111 /* 2112 * Create a fake 'process' entry for the kernel with pid -1. 2113 * hwpmc(4) will subsequently inform us about where the kernel 2114 * and any loaded kernel modules are mapped. 2115 */ 2116 if ((pmcstat_kernproc = pmcstat_process_lookup((pid_t) -1, 2117 PMCSTAT_ALLOCATE)) == NULL) 2118 err(EX_OSERR, "ERROR: Cannot initialize logging"); 2119 2120 /* PMC count. */ 2121 pmcstat_npmcs = 0; 2122 2123 /* Merge PMC with same name. */ 2124 pmcstat_mergepmc = args.pa_mergepmc; 2125 2126 /* 2127 * Initialize plugins 2128 */ 2129 2130 if (plugins[args.pa_pplugin].pl_init != NULL) 2131 plugins[args.pa_pplugin].pl_init(); 2132 if (plugins[args.pa_plugin].pl_init != NULL) 2133 plugins[args.pa_plugin].pl_init(); 2134} 2135 2136/* 2137 * Shutdown module. 2138 */ 2139 2140void 2141pmcstat_shutdown_logging(void) 2142{ 2143 int i; 2144 FILE *mf; 2145 struct pmcstat_image *pi, *pitmp; 2146 struct pmcstat_process *pp, *pptmp; 2147 struct pmcstat_pcmap *ppm, *ppmtmp; 2148 2149 /* determine where to send the map file */ 2150 mf = NULL; 2151 if (args.pa_mapfilename != NULL) 2152 mf = (strcmp(args.pa_mapfilename, "-") == 0) ? 2153 args.pa_printfile : fopen(args.pa_mapfilename, "w"); 2154 2155 if (mf == NULL && args.pa_flags & FLAG_DO_GPROF && 2156 args.pa_verbosity >= 2) 2157 mf = args.pa_printfile; 2158 2159 if (mf) 2160 (void) fprintf(mf, "MAP:\n"); 2161 2162 /* 2163 * Shutdown the plugins 2164 */ 2165 2166 if (plugins[args.pa_plugin].pl_shutdown != NULL) 2167 plugins[args.pa_plugin].pl_shutdown(mf); 2168 if (plugins[args.pa_pplugin].pl_shutdown != NULL) 2169 plugins[args.pa_pplugin].pl_shutdown(mf); 2170 2171 for (i = 0; i < PMCSTAT_NHASH; i++) { 2172 LIST_FOREACH_SAFE(pi, &pmcstat_image_hash[i], pi_next, 2173 pitmp) { 2174 if (plugins[args.pa_plugin].pl_shutdownimage != NULL) 2175 plugins[args.pa_plugin].pl_shutdownimage(pi); 2176 if (plugins[args.pa_pplugin].pl_shutdownimage != NULL) 2177 plugins[args.pa_pplugin].pl_shutdownimage(pi); 2178 2179 free(pi->pi_symbols); 2180 if (pi->pi_addr2line != NULL) 2181 pclose(pi->pi_addr2line); 2182 LIST_REMOVE(pi, pi_next); 2183 free(pi); 2184 } 2185 2186 LIST_FOREACH_SAFE(pp, &pmcstat_process_hash[i], pp_next, 2187 pptmp) { 2188 TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) { 2189 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next); 2190 free(ppm); 2191 } 2192 LIST_REMOVE(pp, pp_next); 2193 free(pp); 2194 } 2195 } 2196 2197 pmcstat_string_shutdown(); 2198 2199 /* 2200 * Print errors unless -q was specified. Print all statistics 2201 * if verbosity > 1. 2202 */ 2203#define PRINT(N,V) do { \ 2204 if (pmcstat_stats.ps_##V || args.pa_verbosity >= 2) \ 2205 (void) fprintf(args.pa_printfile, " %-40s %d\n",\ 2206 N, pmcstat_stats.ps_##V); \ 2207 } while (0) 2208 2209 if (args.pa_verbosity >= 1 && (args.pa_flags & FLAG_DO_ANALYSIS)) { 2210 (void) fprintf(args.pa_printfile, "CONVERSION STATISTICS:\n"); 2211 PRINT("#exec/a.out", exec_aout); 2212 PRINT("#exec/elf", exec_elf); 2213 PRINT("#exec/unknown", exec_indeterminable); 2214 PRINT("#exec handling errors", exec_errors); 2215 PRINT("#samples/total", samples_total); 2216 PRINT("#samples/unclaimed", samples_unknown_offset); 2217 PRINT("#samples/unknown-object", samples_indeterminable); 2218 PRINT("#samples/unknown-function", samples_unknown_function); 2219 PRINT("#callchain/dubious-frames", callchain_dubious_frames); 2220 } 2221 2222 if (mf) 2223 (void) fclose(mf); 2224} 2225