lib/libpmcstat/libpmcstat_logging.c

   1 /*-
   2  * Copyright (c) 2003-2008 Joseph Koshy
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/types.h>
  31 #include <sys/cpuset.h>
  32 #include <sys/param.h>
  33 #include <sys/socket.h>
  34 #include <sys/stat.h>
  35 #include <sys/pmc.h>
  36
  37 #include <assert.h>
  38 #include <ctype.h>
  39 #include <err.h>
  40 #include <errno.h>
  41 #include <fcntl.h>
  42 #include <limits.h>
  43 #include <netdb.h>
  44 #include <pmc.h>
  45 #include <pmclog.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <strings.h>
  50 #include <sysexits.h>
  51 #include <unistd.h>
  52
  53 #include "libpmcstat.h"
  54
  55 /*
  56  * Get PMC record by id, apply merge policy.
  57  */
  58
  59 static struct pmcstat_pmcrecord *
  60 pmcstat_lookup_pmcid(pmc_id_t pmcid, int pmcstat_mergepmc)
  61 {
  62         struct pmcstat_pmcrecord *pr;
  63
  64         LIST_FOREACH(pr, &pmcstat_pmcs, pr_next) {
  65                 if (pr->pr_pmcid == pmcid) {
  66                         if (pmcstat_mergepmc)
  67                                 return pr->pr_merge;
  68                         return pr;
  69                 }
  70         }
  71
  72         return NULL;
  73 }
  74
  75 /*
  76  * Add a {pmcid,name} mapping.
  77  */
  78
  79 static void
  80 pmcstat_pmcid_add(pmc_id_t pmcid, pmcstat_interned_string ps,
  81     struct pmcstat_args *args, struct pmc_plugins *plugins,
  82     int *pmcstat_npmcs)
  83 {
  84         struct pmcstat_pmcrecord *pr, *prm;
  85
  86         /* Replace an existing name for the PMC. */
  87         prm = NULL;
  88         LIST_FOREACH(pr, &pmcstat_pmcs, pr_next)
  89                 if (pr->pr_pmcid == pmcid) {
  90                         pr->pr_pmcname = ps;
  91                         return;
  92                 } else if (pr->pr_pmcname == ps)
  93                         prm = pr;
  94
  95         /*
  96          * Otherwise, allocate a new descriptor and call the
  97          * plugins hook.
  98          */
  99         if ((pr = malloc(sizeof(*pr))) == NULL)
 100                 err(EX_OSERR, "ERROR: Cannot allocate pmc record");
 101
 102         pr->pr_pmcid = pmcid;
 103         pr->pr_pmcname = ps;
 104         pr->pr_pmcin = (*pmcstat_npmcs)++;
 105         pr->pr_samples = 0;
 106         pr->pr_dubious_frames = 0;
 107         pr->pr_merge = prm == NULL ? pr : prm;
 108
 109         LIST_INSERT_HEAD(&pmcstat_pmcs, pr, pr_next);
 110
 111         if (plugins[args->pa_pplugin].pl_newpmc != NULL)
 112                 plugins[args->pa_pplugin].pl_newpmc(ps, pr);
 113         if (plugins[args->pa_plugin].pl_newpmc != NULL)
 114                 plugins[args->pa_plugin].pl_newpmc(ps, pr);
 115 }
 116
 117 /*
 118  * Unmap images in the range [start..end) associated with process
 119  * 'pp'.
 120  */
 121
 122 static void
 123 pmcstat_image_unmap(struct pmcstat_process *pp, uintfptr_t start,
 124     uintfptr_t end)
 125 {
 126         struct pmcstat_pcmap *pcm, *pcmtmp, *pcmnew;
 127
 128         assert(pp != NULL);
 129         assert(start < end);
 130
 131         /*
 132          * Cases:
 133          * - we could have the range completely in the middle of an
 134          *   existing pcmap; in this case we have to split the pcmap
 135          *   structure into two (i.e., generate a 'hole').
 136          * - we could have the range covering multiple pcmaps; these
 137          *   will have to be removed.
 138          * - we could have either 'start' or 'end' falling in the
 139          *   middle of a pcmap; in this case shorten the entry.
 140          */
 141         TAILQ_FOREACH_SAFE(pcm, &pp->pp_map, ppm_next, pcmtmp) {
 142                 assert(pcm->ppm_lowpc < pcm->ppm_highpc);
 143                 if (pcm->ppm_highpc <= start)
 144                         continue;
 145                 if (pcm->ppm_lowpc >= end)
 146                         return;
 147                 if (pcm->ppm_lowpc >= start && pcm->ppm_highpc <= end) {
 148                         /*
 149                          * The current pcmap is completely inside the
 150                          * unmapped range: remove it entirely.
 151                          */
 152                         TAILQ_REMOVE(&pp->pp_map, pcm, ppm_next);
 153                         free(pcm);
 154                 } else if (pcm->ppm_lowpc < start && pcm->ppm_highpc > end) {
 155                         /*
 156                          * Split this pcmap into two; curtail the
 157                          * current map to end at [start-1], and start
 158                          * the new one at [end].
 159                          */
 160                         if ((pcmnew = malloc(sizeof(*pcmnew))) == NULL)
 161                                 err(EX_OSERR,
 162                                     "ERROR: Cannot split a map entry");
 163
 164                         pcmnew->ppm_image = pcm->ppm_image;
 165
 166                         pcmnew->ppm_lowpc = end;
 167                         pcmnew->ppm_highpc = pcm->ppm_highpc;
 168
 169                         pcm->ppm_highpc = start;
 170
 171                         TAILQ_INSERT_AFTER(&pp->pp_map, pcm, pcmnew, ppm_next);
 172
 173                         return;
 174                 } else if (pcm->ppm_lowpc < start && pcm->ppm_highpc <= end)
 175                         pcm->ppm_highpc = start;
 176                 else if (pcm->ppm_lowpc >= start && pcm->ppm_highpc > end)
 177                         pcm->ppm_lowpc = end;
 178                 else
 179                         assert(0);
 180         }
 181 }
 182
 183 /*
 184  * Convert a hwpmc(4) log to profile information.  A system-wide
 185  * callgraph is generated if FLAG_DO_CALLGRAPHS is set.  gmon.out
 186  * files usable by gprof(1) are created if FLAG_DO_GPROF is set.
 187  */
 188 int
 189 pmcstat_analyze_log(struct pmcstat_args *args,
 190     struct pmc_plugins *plugins,
 191     struct pmcstat_stats *pmcstat_stats,
 192     struct pmcstat_process *pmcstat_kernproc,
 193     int pmcstat_mergepmc,
 194     int *pmcstat_npmcs,
 195     int *ps_samples_period)
 196 {
 197         uint32_t cpu, cpuflags;
 198         pid_t pid;
 199         struct pmcstat_image *image;
 200         struct pmcstat_process *pp, *ppnew;
 201         struct pmcstat_pcmap *ppm, *ppmtmp;
 202         struct pmclog_ev ev;
 203         struct pmcstat_pmcrecord *pmcr;
 204         pmcstat_interned_string image_path;
 205
 206         assert(args->pa_flags & FLAG_DO_ANALYSIS);
 207
 208         if (elf_version(EV_CURRENT) == EV_NONE)
 209                 err(EX_UNAVAILABLE, "Elf library initialization failed");
 210
 211         while (pmclog_read(args->pa_logparser, &ev) == 0) {
 212                 assert(ev.pl_state == PMCLOG_OK);
 213
 214                 switch (ev.pl_type) {
 215                 case PMCLOG_TYPE_INITIALIZE:
 216                         if ((ev.pl_u.pl_i.pl_version & 0xFF000000) !=
 217                             PMC_VERSION_MAJOR << 24 && args->pa_verbosity > 0)
 218                                 warnx(
 219 "WARNING: Log version 0x%x does not match compiled version 0x%x.",
 220                                     ev.pl_u.pl_i.pl_version, PMC_VERSION_MAJOR);
 221                         break;
 222
 223                 case PMCLOG_TYPE_MAP_IN:
 224                         /*
 225                          * Introduce an address range mapping for a
 226                          * userland process or the kernel (pid == -1).
 227                          *
 228                          * We always allocate a process descriptor so
 229                          * that subsequent samples seen for this
 230                          * address range are mapped to the current
 231                          * object being mapped in.
 232                          */
 233                         pid = ev.pl_u.pl_mi.pl_pid;
 234                         if (pid == -1)
 235                                 pp = pmcstat_kernproc;
 236                         else
 237                                 pp = pmcstat_process_lookup(pid,
 238                                     PMCSTAT_ALLOCATE);
 239
 240                         assert(pp != NULL);
 241
 242                         image_path = pmcstat_string_intern(ev.pl_u.pl_mi.
 243                             pl_pathname);
 244                         image = pmcstat_image_from_path(image_path, pid == -1,
 245                             args, plugins);
 246                         if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN)
 247                                 pmcstat_image_determine_type(image, args);
 248                         if (image->pi_type != PMCSTAT_IMAGE_INDETERMINABLE)
 249                                 pmcstat_image_link(pp, image,
 250                                     ev.pl_u.pl_mi.pl_start);
 251                         break;
 252
 253                 case PMCLOG_TYPE_MAP_OUT:
 254                         /*
 255                          * Remove an address map.
 256                          */
 257                         pid = ev.pl_u.pl_mo.pl_pid;
 258                         if (pid == -1)
 259                                 pp = pmcstat_kernproc;
 260                         else
 261                                 pp = pmcstat_process_lookup(pid, 0);
 262
 263                         if (pp == NULL) /* unknown process */
 264                                 break;
 265
 266                         pmcstat_image_unmap(pp, ev.pl_u.pl_mo.pl_start,
 267                             ev.pl_u.pl_mo.pl_end);
 268                         break;
 269
 270                 case PMCLOG_TYPE_CALLCHAIN:
 271                         pmcstat_stats->ps_samples_total++;
 272                         *ps_samples_period += 1;
 273
 274                         cpuflags = ev.pl_u.pl_cc.pl_cpuflags;
 275                         cpu = PMC_CALLCHAIN_CPUFLAGS_TO_CPU(cpuflags);
 276
 277                         if ((args->pa_flags & FLAG_FILTER_THREAD_ID) &&
 278                                 args->pa_tid != ev.pl_u.pl_cc.pl_tid) {
 279                                 pmcstat_stats->ps_samples_skipped++;
 280                                 break;
 281                         }
 282                         /* Filter on the CPU id. */
 283                         if (!CPU_ISSET(cpu, &(args->pa_cpumask))) {
 284                                 pmcstat_stats->ps_samples_skipped++;
 285                                 break;
 286                         }
 287
 288                         pp = pmcstat_process_lookup(ev.pl_u.pl_cc.pl_pid,
 289                             PMCSTAT_ALLOCATE);
 290
 291                         /* Get PMC record. */
 292                         pmcr = pmcstat_lookup_pmcid(ev.pl_u.pl_cc.pl_pmcid, pmcstat_mergepmc);
 293                         assert(pmcr != NULL);
 294                         pmcr->pr_samples++;
 295
 296                         /*
 297                          * Call the plugins processing
 298                          */
 299
 300                         if (plugins[args->pa_pplugin].pl_process != NULL)
 301                                 plugins[args->pa_pplugin].pl_process(
 302                                     pp, pmcr,
 303                                     ev.pl_u.pl_cc.pl_npc,
 304                                     ev.pl_u.pl_cc.pl_pc,
 305                                     PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags),
 306                                     cpu);
 307                         plugins[args->pa_plugin].pl_process(
 308                             pp, pmcr,
 309                             ev.pl_u.pl_cc.pl_npc,
 310                             ev.pl_u.pl_cc.pl_pc,
 311                             PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags),
 312                             cpu);
 313                         break;
 314
 315                 case PMCLOG_TYPE_PMCALLOCATE:
 316                         /*
 317                          * Record the association pmc id between this
 318                          * PMC and its name.
 319                          */
 320                         pmcstat_pmcid_add(ev.pl_u.pl_a.pl_pmcid,
 321                             pmcstat_string_intern(ev.pl_u.pl_a.pl_evname),
 322                             args, plugins, pmcstat_npmcs);
 323                         break;
 324
 325                 case PMCLOG_TYPE_PMCALLOCATEDYN:
 326                         /*
 327                          * Record the association pmc id between this
 328                          * PMC and its name.
 329                          */
 330                         pmcstat_pmcid_add(ev.pl_u.pl_ad.pl_pmcid,
 331                             pmcstat_string_intern(ev.pl_u.pl_ad.pl_evname),
 332                             args, plugins, pmcstat_npmcs);
 333                         break;
 334
 335                 case PMCLOG_TYPE_PROCEXEC:
 336                         /*
 337                          * Change the executable image associated with
 338                          * a process.
 339                          */
 340                         pp = pmcstat_process_lookup(ev.pl_u.pl_x.pl_pid,
 341                             PMCSTAT_ALLOCATE);
 342
 343                         /* delete the current process map */
 344                         TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) {
 345                                 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next);
 346                                 free(ppm);
 347                         }
 348
 349                         /*
 350                          * Associate this process image.
 351                          */
 352                         image_path = pmcstat_string_intern(
 353                                 ev.pl_u.pl_x.pl_pathname);
 354                         assert(image_path != NULL);
 355                         pmcstat_process_exec(pp, image_path,
 356                             ev.pl_u.pl_x.pl_entryaddr, args,
 357                             plugins, pmcstat_stats);
 358                         break;
 359
 360                 case PMCLOG_TYPE_PROCEXIT:
 361
 362                         /*
 363                          * Due to the way the log is generated, the
 364                          * last few samples corresponding to a process
 365                          * may appear in the log after the process
 366                          * exit event is recorded.  Thus we keep the
 367                          * process' descriptor and associated data
 368                          * structures around, but mark the process as
 369                          * having exited.
 370                          */
 371                         pp = pmcstat_process_lookup(ev.pl_u.pl_e.pl_pid, 0);
 372                         if (pp == NULL)
 373                                 break;
 374                         pp->pp_isactive = 0;    /* mark as a zombie */
 375                         break;
 376
 377                 case PMCLOG_TYPE_SYSEXIT:
 378                         pp = pmcstat_process_lookup(ev.pl_u.pl_se.pl_pid, 0);
 379                         if (pp == NULL)
 380                                 break;
 381                         pp->pp_isactive = 0;    /* make a zombie */
 382                         break;
 383
 384                 case PMCLOG_TYPE_PROCFORK:
 385
 386                         /*
 387                          * Allocate a process descriptor for the new
 388                          * (child) process.
 389                          */
 390                         ppnew =
 391                             pmcstat_process_lookup(ev.pl_u.pl_f.pl_newpid,
 392                                 PMCSTAT_ALLOCATE);
 393
 394                         /*
 395                          * If we had been tracking the parent, clone
 396                          * its address maps.
 397                          */
 398                         pp = pmcstat_process_lookup(ev.pl_u.pl_f.pl_oldpid, 0);
 399                         if (pp == NULL)
 400                                 break;
 401                         TAILQ_FOREACH(ppm, &pp->pp_map, ppm_next)
 402                             pmcstat_image_link(ppnew, ppm->ppm_image,
 403                                 ppm->ppm_lowpc);
 404                         break;
 405
 406                 default:        /* other types of entries are not relevant */
 407                         break;
 408                 }
 409         }
 410
 411         if (ev.pl_state == PMCLOG_EOF)
 412                 return (PMCSTAT_FINISHED);
 413         else if (ev.pl_state == PMCLOG_REQUIRE_DATA)
 414                 return (PMCSTAT_RUNNING);
 415
 416         err(EX_DATAERR,
 417             "ERROR: event parsing failed state: %d type: %d (record %jd, offset 0x%jx)",
 418             ev.pl_state, ev.pl_type, (uintmax_t) ev.pl_count + 1, ev.pl_offset);
 419 }
 420
 421 /*
 422  * Open a log file, for reading or writing.
 423  *
 424  * The function returns the fd of a successfully opened log or -1 in
 425  * case of failure.
 426  */
 427
 428 int
 429 pmcstat_open_log(const char *path, int mode)
 430 {
 431         int error, fd, cfd;
 432         size_t hlen;
 433         const char *p, *errstr;
 434         struct addrinfo hints, *res, *res0;
 435         char hostname[MAXHOSTNAMELEN];
 436
 437         errstr = NULL;
 438         fd = -1;
 439
 440         /*
 441          * If 'path' is "-" then open one of stdin or stdout depending
 442          * on the value of 'mode'.
 443          *
 444          * If 'path' contains a ':' and does not start with a '/' or '.',
 445          * and is being opened for writing, treat it as a "host:port"
 446          * specification and open a network socket.
 447          *
 448          * Otherwise, treat 'path' as a file name and open that.
 449          */
 450         if (path[0] == '-' && path[1] == '\0')
 451                 fd = (mode == PMCSTAT_OPEN_FOR_READ) ? 0 : 1;
 452         else if (path[0] != '/' &&
 453             path[0] != '.' && strchr(path, ':') != NULL) {
 454
 455                 p = strrchr(path, ':');
 456                 hlen = p - path;
 457                 if (p == path || hlen >= sizeof(hostname)) {
 458                         errstr = strerror(EINVAL);
 459                         goto done;
 460                 }
 461
 462                 assert(hlen < sizeof(hostname));
 463                 (void) strncpy(hostname, path, hlen);
 464                 hostname[hlen] = '\0';
 465
 466                 (void) memset(&hints, 0, sizeof(hints));
 467                 hints.ai_family = AF_UNSPEC;
 468                 hints.ai_socktype = SOCK_STREAM;
 469                 if ((error = getaddrinfo(hostname, p+1, &hints, &res0)) != 0) {
 470                         errstr = gai_strerror(error);
 471                         goto done;
 472                 }
 473
 474                 fd = -1;
 475                 for (res = res0; res; res = res->ai_next) {
 476                         if ((fd = socket(res->ai_family, res->ai_socktype,
 477                             res->ai_protocol)) < 0) {
 478                                 errstr = strerror(errno);
 479                                 continue;
 480                         }
 481                         if (mode == PMCSTAT_OPEN_FOR_READ) {
 482                                 if (bind(fd, res->ai_addr, res->ai_addrlen) < 0) {
 483                                         errstr = strerror(errno);
 484                                         (void) close(fd);
 485                                         fd = -1;
 486                                         continue;
 487                                 }
 488                                 listen(fd, 1);
 489                                 cfd = accept(fd, NULL, NULL);
 490                                 (void) close(fd);
 491                                 if (cfd < 0) {
 492                                         errstr = strerror(errno);
 493                                         fd = -1;
 494                                         break;
 495                                 }
 496                                 fd = cfd;
 497                         } else {
 498                                 if (connect(fd, res->ai_addr, res->ai_addrlen) < 0) {
 499                                         errstr = strerror(errno);
 500                                         (void) close(fd);
 501                                         fd = -1;
 502                                         continue;
 503                                 }
 504                         }
 505                         errstr = NULL;
 506                         break;
 507                 }
 508                 freeaddrinfo(res0);
 509
 510         } else if ((fd = open(path, mode == PMCSTAT_OPEN_FOR_READ ?
 511                     O_RDONLY : (O_WRONLY|O_CREAT|O_TRUNC),
 512                     S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
 513                         errstr = strerror(errno);
 514
 515   done:
 516         if (errstr)
 517                 errx(EX_OSERR, "ERROR: Cannot open \"%s\" for %s: %s.", path,
 518                     (mode == PMCSTAT_OPEN_FOR_READ ? "reading" : "writing"),
 519                     errstr);
 520
 521         return (fd);
 522 }
 523
 524 /*
 525  * Close a logfile, after first flushing all in-module queued data.
 526  */
 527
 528 int
 529 pmcstat_close_log(struct pmcstat_args *args)
 530 {
 531         /* If a local logfile is configured ask the kernel to stop
 532          * and flush data. Kernel will close the file when data is flushed
 533          * so keep the status to EXITING.
 534          */
 535         if (args->pa_logfd != -1) {
 536                 if (pmc_close_logfile() < 0)
 537                         err(EX_OSERR, "ERROR: logging failed");
 538         }
 539
 540         return (args->pa_flags & FLAG_HAS_PIPE ? PMCSTAT_EXITING :
 541             PMCSTAT_FINISHED);
 542 }
 543
 544 /*
 545  * Initialize module.
 546  */
 547
 548 void
 549 pmcstat_initialize_logging(struct pmcstat_process **pmcstat_kernproc,
 550     struct pmcstat_args *args, struct pmc_plugins *plugins,
 551     int *pmcstat_npmcs, int *pmcstat_mergepmc)
 552 {
 553         struct pmcstat_process *pmcstat_kp;
 554         int i;
 555
 556         /* use a convenient format for 'ldd' output */
 557         if (setenv("LD_TRACE_LOADED_OBJECTS_FMT1","%o \"%p\" %x\n",1) != 0)
 558                 err(EX_OSERR, "ERROR: Cannot setenv");
 559
 560         /* Initialize hash tables */
 561         pmcstat_string_initialize();
 562         for (i = 0; i < PMCSTAT_NHASH; i++) {
 563                 LIST_INIT(&pmcstat_image_hash[i]);
 564                 LIST_INIT(&pmcstat_process_hash[i]);
 565         }
 566
 567         /*
 568          * Create a fake 'process' entry for the kernel with pid -1.
 569          * hwpmc(4) will subsequently inform us about where the kernel
 570          * and any loaded kernel modules are mapped.
 571          */
 572         if ((pmcstat_kp = pmcstat_process_lookup((pid_t) -1,
 573             PMCSTAT_ALLOCATE)) == NULL)
 574                 err(EX_OSERR, "ERROR: Cannot initialize logging");
 575
 576         *pmcstat_kernproc = pmcstat_kp;
 577
 578         /* PMC count. */
 579         *pmcstat_npmcs = 0;
 580
 581         /* Merge PMC with same name. */
 582         *pmcstat_mergepmc = args->pa_mergepmc;
 583
 584         /*
 585          * Initialize plugins
 586          */
 587
 588         if (plugins[args->pa_pplugin].pl_init != NULL)
 589                 plugins[args->pa_pplugin].pl_init();
 590         if (plugins[args->pa_plugin].pl_init != NULL)
 591                 plugins[args->pa_plugin].pl_init();
 592 }
 593
 594 /*
 595  * Shutdown module.
 596  */
 597
 598 void
 599 pmcstat_shutdown_logging(struct pmcstat_args *args,
 600     struct pmc_plugins *plugins,
 601     struct pmcstat_stats *pmcstat_stats)
 602 {
 603         struct pmcstat_image *pi, *pitmp;
 604         struct pmcstat_process *pp, *pptmp;
 605         struct pmcstat_pcmap *ppm, *ppmtmp;
 606         FILE *mf;
 607         int i;
 608
 609         /* determine where to send the map file */
 610         mf = NULL;
 611         if (args->pa_mapfilename != NULL)
 612                 mf = (strcmp(args->pa_mapfilename, "-") == 0) ?
 613                     args->pa_printfile : fopen(args->pa_mapfilename, "w");
 614
 615         if (mf == NULL && args->pa_flags & FLAG_DO_GPROF &&
 616             args->pa_verbosity >= 2)
 617                 mf = args->pa_printfile;
 618
 619         if (mf)
 620                 (void) fprintf(mf, "MAP:\n");
 621
 622         /*
 623          * Shutdown the plugins
 624          */
 625
 626         if (plugins[args->pa_plugin].pl_shutdown != NULL)
 627                 plugins[args->pa_plugin].pl_shutdown(mf);
 628         if (plugins[args->pa_pplugin].pl_shutdown != NULL)
 629                 plugins[args->pa_pplugin].pl_shutdown(mf);
 630
 631         for (i = 0; i < PMCSTAT_NHASH; i++) {
 632                 LIST_FOREACH_SAFE(pi, &pmcstat_image_hash[i], pi_next,
 633                     pitmp) {
 634                         if (plugins[args->pa_plugin].pl_shutdownimage != NULL)
 635                                 plugins[args->pa_plugin].pl_shutdownimage(pi);
 636                         if (plugins[args->pa_pplugin].pl_shutdownimage != NULL)
 637                                 plugins[args->pa_pplugin].pl_shutdownimage(pi);
 638
 639                         free(pi->pi_symbols);
 640                         if (pi->pi_addr2line != NULL)
 641                                 pclose(pi->pi_addr2line);
 642                         LIST_REMOVE(pi, pi_next);
 643                         free(pi);
 644                 }
 645
 646                 LIST_FOREACH_SAFE(pp, &pmcstat_process_hash[i], pp_next,
 647                     pptmp) {
 648                         TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) {
 649                                 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next);
 650                                 free(ppm);
 651                         }
 652                         LIST_REMOVE(pp, pp_next);
 653                         free(pp);
 654                 }
 655         }
 656
 657         pmcstat_string_shutdown();
 658
 659         /*
 660          * Print errors unless -q was specified.  Print all statistics
 661          * if verbosity > 1.
 662          */
 663 #define PRINT(N,V) do {                                                 \
 664                 if (pmcstat_stats->ps_##V || args->pa_verbosity >= 2)   \
 665                         (void) fprintf(args->pa_printfile, " %-40s %d\n",\
 666                             N, pmcstat_stats->ps_##V);                  \
 667         } while (0)
 668
 669         if (args->pa_verbosity >= 1 && (args->pa_flags & FLAG_DO_ANALYSIS)) {
 670                 (void) fprintf(args->pa_printfile, "CONVERSION STATISTICS:\n");
 671                 PRINT("#exec/a.out", exec_aout);
 672                 PRINT("#exec/elf", exec_elf);
 673                 PRINT("#exec/unknown", exec_indeterminable);
 674                 PRINT("#exec handling errors", exec_errors);
 675                 PRINT("#samples/total", samples_total);
 676                 PRINT("#samples/unclaimed", samples_unknown_offset);
 677                 PRINT("#samples/unknown-object", samples_indeterminable);
 678                 PRINT("#samples/unknown-function", samples_unknown_function);
 679                 PRINT("#callchain/dubious-frames", callchain_dubious_frames);
 680         }
 681
 682         if (mf)
 683                 (void) fclose(mf);
 684 }