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         uintfptr_t pc;
 199         pid_t pid;
 200         struct pmcstat_image *image;
 201         struct pmcstat_process *pp, *ppnew;
 202         struct pmcstat_pcmap *ppm, *ppmtmp;
 203         struct pmclog_ev ev;
 204         struct pmcstat_pmcrecord *pmcr;
 205         pmcstat_interned_string image_path;
 206
 207         assert(args->pa_flags & FLAG_DO_ANALYSIS);
 208
 209         if (elf_version(EV_CURRENT) == EV_NONE)
 210                 err(EX_UNAVAILABLE, "Elf library initialization failed");
 211
 212         while (pmclog_read(args->pa_logparser, &ev) == 0) {
 213                 assert(ev.pl_state == PMCLOG_OK);
 214
 215                 switch (ev.pl_type) {
 216                 case PMCLOG_TYPE_INITIALIZE:
 217                         if ((ev.pl_u.pl_i.pl_version & 0xFF000000) !=
 218                             PMC_VERSION_MAJOR << 24 && args->pa_verbosity > 0)
 219                                 warnx(
 220 "WARNING: Log version 0x%x does not match compiled version 0x%x.",
 221                                     ev.pl_u.pl_i.pl_version, PMC_VERSION_MAJOR);
 222                         break;
 223
 224                 case PMCLOG_TYPE_MAP_IN:
 225                         /*
 226                          * Introduce an address range mapping for a
 227                          * userland process or the kernel (pid == -1).
 228                          *
 229                          * We always allocate a process descriptor so
 230                          * that subsequent samples seen for this
 231                          * address range are mapped to the current
 232                          * object being mapped in.
 233                          */
 234                         pid = ev.pl_u.pl_mi.pl_pid;
 235                         if (pid == -1)
 236                                 pp = pmcstat_kernproc;
 237                         else
 238                                 pp = pmcstat_process_lookup(pid,
 239                                     PMCSTAT_ALLOCATE);
 240
 241                         assert(pp != NULL);
 242
 243                         image_path = pmcstat_string_intern(ev.pl_u.pl_mi.
 244                             pl_pathname);
 245                         image = pmcstat_image_from_path(image_path, pid == -1,
 246                             args, plugins);
 247                         if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN)
 248                                 pmcstat_image_determine_type(image, args);
 249                         if (image->pi_type != PMCSTAT_IMAGE_INDETERMINABLE)
 250                                 pmcstat_image_link(pp, image,
 251                                     ev.pl_u.pl_mi.pl_start);
 252                         break;
 253
 254                 case PMCLOG_TYPE_MAP_OUT:
 255                         /*
 256                          * Remove an address map.
 257                          */
 258                         pid = ev.pl_u.pl_mo.pl_pid;
 259                         if (pid == -1)
 260                                 pp = pmcstat_kernproc;
 261                         else
 262                                 pp = pmcstat_process_lookup(pid, 0);
 263
 264                         if (pp == NULL) /* unknown process */
 265                                 break;
 266
 267                         pmcstat_image_unmap(pp, ev.pl_u.pl_mo.pl_start,
 268                             ev.pl_u.pl_mo.pl_end);
 269                         break;
 270
 271                 case PMCLOG_TYPE_PCSAMPLE:
 272                         /*
 273                          * Note: the `PCSAMPLE' log entry is not
 274                          * generated by hpwmc(4) after version 2.
 275                          */
 276
 277                         /*
 278                          * We bring in the gmon file for the image
 279                          * currently associated with the PMC & pid
 280                          * pair and increment the appropriate entry
 281                          * bin inside this.
 282                          */
 283                         pmcstat_stats->ps_samples_total++;
 284                         *ps_samples_period += 1;
 285
 286                         pc = ev.pl_u.pl_s.pl_pc;
 287                         pp = pmcstat_process_lookup(ev.pl_u.pl_s.pl_pid,
 288                             PMCSTAT_ALLOCATE);
 289
 290                         /* Get PMC record. */
 291                         pmcr = pmcstat_lookup_pmcid(ev.pl_u.pl_s.pl_pmcid, pmcstat_mergepmc);
 292                         assert(pmcr != NULL);
 293                         pmcr->pr_samples++;
 294
 295                         /*
 296                          * Call the plugins processing
 297                          * TODO: move pmcstat_process_find_map inside plugins
 298                          */
 299
 300                         if (plugins[args->pa_pplugin].pl_process != NULL)
 301                                 plugins[args->pa_pplugin].pl_process(
 302                                     pp, pmcr, 1, &pc,
 303                                     pmcstat_process_find_map(pp, pc) != NULL, 0);
 304                         plugins[args->pa_plugin].pl_process(
 305                             pp, pmcr, 1, &pc,
 306                             pmcstat_process_find_map(pp, pc) != NULL, 0);
 307                         break;
 308
 309                 case PMCLOG_TYPE_CALLCHAIN:
 310                         pmcstat_stats->ps_samples_total++;
 311                         *ps_samples_period += 1;
 312
 313                         cpuflags = ev.pl_u.pl_cc.pl_cpuflags;
 314                         cpu = PMC_CALLCHAIN_CPUFLAGS_TO_CPU(cpuflags);
 315
 316                         /* Filter on the CPU id. */
 317                         if (!CPU_ISSET(cpu, &(args->pa_cpumask))) {
 318                                 pmcstat_stats->ps_samples_skipped++;
 319                                 break;
 320                         }
 321
 322                         pp = pmcstat_process_lookup(ev.pl_u.pl_cc.pl_pid,
 323                             PMCSTAT_ALLOCATE);
 324
 325                         /* Get PMC record. */
 326                         pmcr = pmcstat_lookup_pmcid(ev.pl_u.pl_cc.pl_pmcid, pmcstat_mergepmc);
 327                         assert(pmcr != NULL);
 328                         pmcr->pr_samples++;
 329
 330                         /*
 331                          * Call the plugins processing
 332                          */
 333
 334                         if (plugins[args->pa_pplugin].pl_process != NULL)
 335                                 plugins[args->pa_pplugin].pl_process(
 336                                     pp, pmcr,
 337                                     ev.pl_u.pl_cc.pl_npc,
 338                                     ev.pl_u.pl_cc.pl_pc,
 339                                     PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags),
 340                                     cpu);
 341                         plugins[args->pa_plugin].pl_process(
 342                             pp, pmcr,
 343                             ev.pl_u.pl_cc.pl_npc,
 344                             ev.pl_u.pl_cc.pl_pc,
 345                             PMC_CALLCHAIN_CPUFLAGS_TO_USERMODE(cpuflags),
 346                             cpu);
 347                         break;
 348
 349                 case PMCLOG_TYPE_PMCALLOCATE:
 350                         /*
 351                          * Record the association pmc id between this
 352                          * PMC and its name.
 353                          */
 354                         pmcstat_pmcid_add(ev.pl_u.pl_a.pl_pmcid,
 355                             pmcstat_string_intern(ev.pl_u.pl_a.pl_evname),
 356                             args, plugins, pmcstat_npmcs);
 357                         break;
 358
 359                 case PMCLOG_TYPE_PMCALLOCATEDYN:
 360                         /*
 361                          * Record the association pmc id between this
 362                          * PMC and its name.
 363                          */
 364                         pmcstat_pmcid_add(ev.pl_u.pl_ad.pl_pmcid,
 365                             pmcstat_string_intern(ev.pl_u.pl_ad.pl_evname),
 366                             args, plugins, pmcstat_npmcs);
 367                         break;
 368
 369                 case PMCLOG_TYPE_PROCEXEC:
 370                         /*
 371                          * Change the executable image associated with
 372                          * a process.
 373                          */
 374                         pp = pmcstat_process_lookup(ev.pl_u.pl_x.pl_pid,
 375                             PMCSTAT_ALLOCATE);
 376
 377                         /* delete the current process map */
 378                         TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) {
 379                                 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next);
 380                                 free(ppm);
 381                         }
 382
 383                         /*
 384                          * Associate this process image.
 385                          */
 386                         image_path = pmcstat_string_intern(
 387                                 ev.pl_u.pl_x.pl_pathname);
 388                         assert(image_path != NULL);
 389                         pmcstat_process_exec(pp, image_path,
 390                             ev.pl_u.pl_x.pl_entryaddr, args,
 391                             plugins, pmcstat_stats);
 392                         break;
 393
 394                 case PMCLOG_TYPE_PROCEXIT:
 395
 396                         /*
 397                          * Due to the way the log is generated, the
 398                          * last few samples corresponding to a process
 399                          * may appear in the log after the process
 400                          * exit event is recorded.  Thus we keep the
 401                          * process' descriptor and associated data
 402                          * structures around, but mark the process as
 403                          * having exited.
 404                          */
 405                         pp = pmcstat_process_lookup(ev.pl_u.pl_e.pl_pid, 0);
 406                         if (pp == NULL)
 407                                 break;
 408                         pp->pp_isactive = 0;    /* mark as a zombie */
 409                         break;
 410
 411                 case PMCLOG_TYPE_SYSEXIT:
 412                         pp = pmcstat_process_lookup(ev.pl_u.pl_se.pl_pid, 0);
 413                         if (pp == NULL)
 414                                 break;
 415                         pp->pp_isactive = 0;    /* make a zombie */
 416                         break;
 417
 418                 case PMCLOG_TYPE_PROCFORK:
 419
 420                         /*
 421                          * Allocate a process descriptor for the new
 422                          * (child) process.
 423                          */
 424                         ppnew =
 425                             pmcstat_process_lookup(ev.pl_u.pl_f.pl_newpid,
 426                                 PMCSTAT_ALLOCATE);
 427
 428                         /*
 429                          * If we had been tracking the parent, clone
 430                          * its address maps.
 431                          */
 432                         pp = pmcstat_process_lookup(ev.pl_u.pl_f.pl_oldpid, 0);
 433                         if (pp == NULL)
 434                                 break;
 435                         TAILQ_FOREACH(ppm, &pp->pp_map, ppm_next)
 436                             pmcstat_image_link(ppnew, ppm->ppm_image,
 437                                 ppm->ppm_lowpc);
 438                         break;
 439
 440                 default:        /* other types of entries are not relevant */
 441                         break;
 442                 }
 443         }
 444
 445         if (ev.pl_state == PMCLOG_EOF)
 446                 return (PMCSTAT_FINISHED);
 447         else if (ev.pl_state == PMCLOG_REQUIRE_DATA)
 448                 return (PMCSTAT_RUNNING);
 449
 450         err(EX_DATAERR,
 451             "ERROR: event parsing failed (record %jd, offset 0x%jx)",
 452             (uintmax_t) ev.pl_count + 1, ev.pl_offset);
 453 }
 454
 455 /*
 456  * Open a log file, for reading or writing.
 457  *
 458  * The function returns the fd of a successfully opened log or -1 in
 459  * case of failure.
 460  */
 461
 462 int
 463 pmcstat_open_log(const char *path, int mode)
 464 {
 465         int error, fd, cfd;
 466         size_t hlen;
 467         const char *p, *errstr;
 468         struct addrinfo hints, *res, *res0;
 469         char hostname[MAXHOSTNAMELEN];
 470
 471         errstr = NULL;
 472         fd = -1;
 473
 474         /*
 475          * If 'path' is "-" then open one of stdin or stdout depending
 476          * on the value of 'mode'.
 477          *
 478          * If 'path' contains a ':' and does not start with a '/' or '.',
 479          * and is being opened for writing, treat it as a "host:port"
 480          * specification and open a network socket.
 481          *
 482          * Otherwise, treat 'path' as a file name and open that.
 483          */
 484         if (path[0] == '-' && path[1] == '\0')
 485                 fd = (mode == PMCSTAT_OPEN_FOR_READ) ? 0 : 1;
 486         else if (path[0] != '/' &&
 487             path[0] != '.' && strchr(path, ':') != NULL) {
 488
 489                 p = strrchr(path, ':');
 490                 hlen = p - path;
 491                 if (p == path || hlen >= sizeof(hostname)) {
 492                         errstr = strerror(EINVAL);
 493                         goto done;
 494                 }
 495
 496                 assert(hlen < sizeof(hostname));
 497                 (void) strncpy(hostname, path, hlen);
 498                 hostname[hlen] = '\0';
 499
 500                 (void) memset(&hints, 0, sizeof(hints));
 501                 hints.ai_family = AF_UNSPEC;
 502                 hints.ai_socktype = SOCK_STREAM;
 503                 if ((error = getaddrinfo(hostname, p+1, &hints, &res0)) != 0) {
 504                         errstr = gai_strerror(error);
 505                         goto done;
 506                 }
 507
 508                 fd = -1;
 509                 for (res = res0; res; res = res->ai_next) {
 510                         if ((fd = socket(res->ai_family, res->ai_socktype,
 511                             res->ai_protocol)) < 0) {
 512                                 errstr = strerror(errno);
 513                                 continue;
 514                         }
 515                         if (mode == PMCSTAT_OPEN_FOR_READ) {
 516                                 if (bind(fd, res->ai_addr, res->ai_addrlen) < 0) {
 517                                         errstr = strerror(errno);
 518                                         (void) close(fd);
 519                                         fd = -1;
 520                                         continue;
 521                                 }
 522                                 listen(fd, 1);
 523                                 cfd = accept(fd, NULL, NULL);
 524                                 (void) close(fd);
 525                                 if (cfd < 0) {
 526                                         errstr = strerror(errno);
 527                                         fd = -1;
 528                                         break;
 529                                 }
 530                                 fd = cfd;
 531                         } else {
 532                                 if (connect(fd, res->ai_addr, res->ai_addrlen) < 0) {
 533                                         errstr = strerror(errno);
 534                                         (void) close(fd);
 535                                         fd = -1;
 536                                         continue;
 537                                 }
 538                         }
 539                         errstr = NULL;
 540                         break;
 541                 }
 542                 freeaddrinfo(res0);
 543
 544         } else if ((fd = open(path, mode == PMCSTAT_OPEN_FOR_READ ?
 545                     O_RDONLY : (O_WRONLY|O_CREAT|O_TRUNC),
 546                     S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
 547                         errstr = strerror(errno);
 548
 549   done:
 550         if (errstr)
 551                 errx(EX_OSERR, "ERROR: Cannot open \"%s\" for %s: %s.", path,
 552                     (mode == PMCSTAT_OPEN_FOR_READ ? "reading" : "writing"),
 553                     errstr);
 554
 555         return (fd);
 556 }
 557
 558 /*
 559  * Close a logfile, after first flushing all in-module queued data.
 560  */
 561
 562 int
 563 pmcstat_close_log(struct pmcstat_args *args)
 564 {
 565         /* If a local logfile is configured ask the kernel to stop
 566          * and flush data. Kernel will close the file when data is flushed
 567          * so keep the status to EXITING.
 568          */
 569         if (args->pa_logfd != -1) {
 570                 if (pmc_close_logfile() < 0)
 571                         err(EX_OSERR, "ERROR: logging failed");
 572         }
 573
 574         return (args->pa_flags & FLAG_HAS_PIPE ? PMCSTAT_EXITING :
 575             PMCSTAT_FINISHED);
 576 }
 577
 578 /*
 579  * Initialize module.
 580  */
 581
 582 void
 583 pmcstat_initialize_logging(struct pmcstat_process **pmcstat_kernproc,
 584     struct pmcstat_args *args, struct pmc_plugins *plugins,
 585     int *pmcstat_npmcs, int *pmcstat_mergepmc)
 586 {
 587         struct pmcstat_process *pmcstat_kp;
 588         int i;
 589
 590         /* use a convenient format for 'ldd' output */
 591         if (setenv("LD_TRACE_LOADED_OBJECTS_FMT1","%o \"%p\" %x\n",1) != 0)
 592                 err(EX_OSERR, "ERROR: Cannot setenv");
 593
 594         /* Initialize hash tables */
 595         pmcstat_string_initialize();
 596         for (i = 0; i < PMCSTAT_NHASH; i++) {
 597                 LIST_INIT(&pmcstat_image_hash[i]);
 598                 LIST_INIT(&pmcstat_process_hash[i]);
 599         }
 600
 601         /*
 602          * Create a fake 'process' entry for the kernel with pid -1.
 603          * hwpmc(4) will subsequently inform us about where the kernel
 604          * and any loaded kernel modules are mapped.
 605          */
 606         if ((pmcstat_kp = pmcstat_process_lookup((pid_t) -1,
 607             PMCSTAT_ALLOCATE)) == NULL)
 608                 err(EX_OSERR, "ERROR: Cannot initialize logging");
 609
 610         *pmcstat_kernproc = pmcstat_kp;
 611
 612         /* PMC count. */
 613         *pmcstat_npmcs = 0;
 614
 615         /* Merge PMC with same name. */
 616         *pmcstat_mergepmc = args->pa_mergepmc;
 617
 618         /*
 619          * Initialize plugins
 620          */
 621
 622         if (plugins[args->pa_pplugin].pl_init != NULL)
 623                 plugins[args->pa_pplugin].pl_init();
 624         if (plugins[args->pa_plugin].pl_init != NULL)
 625                 plugins[args->pa_plugin].pl_init();
 626 }
 627
 628 /*
 629  * Shutdown module.
 630  */
 631
 632 void
 633 pmcstat_shutdown_logging(struct pmcstat_args *args,
 634     struct pmc_plugins *plugins,
 635     struct pmcstat_stats *pmcstat_stats)
 636 {
 637         struct pmcstat_image *pi, *pitmp;
 638         struct pmcstat_process *pp, *pptmp;
 639         struct pmcstat_pcmap *ppm, *ppmtmp;
 640         FILE *mf;
 641         int i;
 642
 643         /* determine where to send the map file */
 644         mf = NULL;
 645         if (args->pa_mapfilename != NULL)
 646                 mf = (strcmp(args->pa_mapfilename, "-") == 0) ?
 647                     args->pa_printfile : fopen(args->pa_mapfilename, "w");
 648
 649         if (mf == NULL && args->pa_flags & FLAG_DO_GPROF &&
 650             args->pa_verbosity >= 2)
 651                 mf = args->pa_printfile;
 652
 653         if (mf)
 654                 (void) fprintf(mf, "MAP:\n");
 655
 656         /*
 657          * Shutdown the plugins
 658          */
 659
 660         if (plugins[args->pa_plugin].pl_shutdown != NULL)
 661                 plugins[args->pa_plugin].pl_shutdown(mf);
 662         if (plugins[args->pa_pplugin].pl_shutdown != NULL)
 663                 plugins[args->pa_pplugin].pl_shutdown(mf);
 664
 665         for (i = 0; i < PMCSTAT_NHASH; i++) {
 666                 LIST_FOREACH_SAFE(pi, &pmcstat_image_hash[i], pi_next,
 667                     pitmp) {
 668                         if (plugins[args->pa_plugin].pl_shutdownimage != NULL)
 669                                 plugins[args->pa_plugin].pl_shutdownimage(pi);
 670                         if (plugins[args->pa_pplugin].pl_shutdownimage != NULL)
 671                                 plugins[args->pa_pplugin].pl_shutdownimage(pi);
 672
 673                         free(pi->pi_symbols);
 674                         if (pi->pi_addr2line != NULL)
 675                                 pclose(pi->pi_addr2line);
 676                         LIST_REMOVE(pi, pi_next);
 677                         free(pi);
 678                 }
 679
 680                 LIST_FOREACH_SAFE(pp, &pmcstat_process_hash[i], pp_next,
 681                     pptmp) {
 682                         TAILQ_FOREACH_SAFE(ppm, &pp->pp_map, ppm_next, ppmtmp) {
 683                                 TAILQ_REMOVE(&pp->pp_map, ppm, ppm_next);
 684                                 free(ppm);
 685                         }
 686                         LIST_REMOVE(pp, pp_next);
 687                         free(pp);
 688                 }
 689         }
 690
 691         pmcstat_string_shutdown();
 692
 693         /*
 694          * Print errors unless -q was specified.  Print all statistics
 695          * if verbosity > 1.
 696          */
 697 #define PRINT(N,V) do {                                                 \
 698                 if (pmcstat_stats->ps_##V || args->pa_verbosity >= 2)   \
 699                         (void) fprintf(args->pa_printfile, " %-40s %d\n",\
 700                             N, pmcstat_stats->ps_##V);                  \
 701         } while (0)
 702
 703         if (args->pa_verbosity >= 1 && (args->pa_flags & FLAG_DO_ANALYSIS)) {
 704                 (void) fprintf(args->pa_printfile, "CONVERSION STATISTICS:\n");
 705                 PRINT("#exec/a.out", exec_aout);
 706                 PRINT("#exec/elf", exec_elf);
 707                 PRINT("#exec/unknown", exec_indeterminable);
 708                 PRINT("#exec handling errors", exec_errors);
 709                 PRINT("#samples/total", samples_total);
 710                 PRINT("#samples/unclaimed", samples_unknown_offset);
 711                 PRINT("#samples/unknown-object", samples_indeterminable);
 712                 PRINT("#samples/unknown-function", samples_unknown_function);
 713                 PRINT("#callchain/dubious-frames", callchain_dubious_frames);
 714         }
 715
 716         if (mf)
 717                 (void) fclose(mf);
 718 }