/*      $NetBSD: tprof_analyze.c,v 1.9 2024/11/03 10:43:27 rillig Exp $ */

/*
* Copyright (c) 2010,2011,2012 YAMAMOTO Takashi,
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: tprof_analyze.c,v 1.9 2024/11/03 10:43:27 rillig Exp $");
#endif /* not lint */

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <gelf.h>
#include <inttypes.h>
#include <libelf.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <util.h>
#include <dev/tprof/tprof_ioctl.h>
#include "tprof.h"
#include "ksyms.h"

#include <sys/rbtree.h>

static bool filter_by_pid;
static pid_t target_pid;
static bool per_symbol;

struct addr {
       struct rb_node node;
       uint64_t addr;          /* address */
       uint32_t pid;           /* process id */
       uint32_t lwpid;         /* lwp id */
       uint32_t cpuid;         /* cpu id */
       bool in_kernel;         /* if addr is in the kernel address space */
       unsigned int nsamples;  /* number of samples taken for the address */
       unsigned int ncount[TPROF_MAXCOUNTERS]; /* count per event */
};

static rb_tree_t addrtree;

static signed int
addrtree_compare_key(void *ctx, const void *n1, const void *keyp)
{
       const struct addr *a1 = n1;
       const struct addr *a2 = (const struct addr *)keyp;

       if (a1->addr > a2->addr) {
               return 1;
       } else if (a1->addr < a2->addr) {
               return -1;
       }
       if (a1->pid > a2->pid) {
               return -1;
       } else if (a1->pid < a2->pid) {
               return 1;
       }
       if (a1->lwpid > a2->lwpid) {
               return -1;
       } else if (a1->lwpid < a2->lwpid) {
               return 1;
       }
       if (a1->cpuid > a2->cpuid) {
               return -1;
       } else if (a1->cpuid < a2->cpuid) {
               return 1;
       }
       if (a1->in_kernel > a2->in_kernel) {
               return -1;
       } else if (a1->in_kernel < a2->in_kernel) {
               return 1;
       }
       return 0;
}

static signed int
addrtree_compare_nodes(void *ctx, const void *n1, const void *n2)
{
       const struct addr *a2 = n2;

       return addrtree_compare_key(ctx, n1, a2);
}

static const rb_tree_ops_t addrtree_ops = {
       .rbto_compare_nodes = addrtree_compare_nodes,
       .rbto_compare_key = addrtree_compare_key,
};

static int
compare_nsamples(const void *p1, const void *p2)
{
       const struct addr *a1 = *(const struct addr * const *)p1;
       const struct addr *a2 = *(const struct addr * const *)p2;

       if (a1->nsamples > a2->nsamples) {
               return -1;
       } else if (a1->nsamples < a2->nsamples) {
               return 1;
       }
       return 0;
}

void
tprof_analyze(int argc, char **argv)
{
       struct addr *a;
       struct addr **l;
       struct addr **p;
       size_t naddrs, nsamples, i;
       float perc;
       int ch;
       u_int c, maxevent = 0;
       bool distinguish_processes = true;
       bool distinguish_cpus = true;
       bool distinguish_lwps = true;
       bool kernel_only = false;
       FILE *f;

       while ((ch = getopt(argc, argv, "CkLPp:s")) != -1) {
               uintmax_t val;
               char *ep;

               switch (ch) {
               case 'C':       /* don't distinguish cpus */
                       distinguish_cpus = false;
                       break;
               case 'k':       /* kernel only */
                       kernel_only = true;
                       break;
               case 'L':       /* don't distinguish lwps */
                       distinguish_lwps = false;
                       break;
               case 'p':       /* only for the process for the given pid */
                       errno = 0;
                       val = strtoumax(optarg, &ep, 10);
                       if (optarg[0] == 0 || *ep != 0 ||
                           val > INT32_MAX) {
                               errx(EXIT_FAILURE, "invalid p option");
                       }
                       target_pid = val;
                       filter_by_pid = true;
                       break;
               case 'P':       /* don't distinguish processes */
                       distinguish_processes = false;
                       break;
               case 's':       /* per symbol */
                       per_symbol = true;
                       break;
               default:
                       exit(EXIT_FAILURE);
               }
       }
       argc -= optind;
       argv += optind;

       if (argc == 0) {
               errx(EXIT_FAILURE, "missing file name");
       }

       f = fopen(argv[0], "rb");
       if (f == NULL) {
               errx(EXIT_FAILURE, "fopen");
       }

       ksymload(NULL);
       rb_tree_init(&addrtree, &addrtree_ops);

       /*
        * read and count samples.
        */

       naddrs = 0;
       nsamples = 0;
       while (/*CONSTCOND*/true) {
               struct addr *o;
               tprof_sample_t sample;
               size_t n = fread(&sample, sizeof(sample), 1, f);
               bool in_kernel;

               if (n == 0) {
                       if (feof(f)) {
                               break;
                       }
                       if (ferror(f)) {
                               err(EXIT_FAILURE, "fread");
                       }
               }
               if (filter_by_pid && (pid_t)sample.s_pid != target_pid) {
                       continue;
               }
               in_kernel = (sample.s_flags & TPROF_SAMPLE_INKERNEL) != 0;
               if (kernel_only && !in_kernel) {
                       continue;
               }
               a = emalloc(sizeof(*a));
               memset(a, 0, sizeof(*a));
               a->addr = (uint64_t)sample.s_pc;
               if (distinguish_processes) {
                       a->pid = sample.s_pid;
               } else {
                       a->pid = 0;
               }
               if (distinguish_lwps) {
                       a->lwpid = sample.s_lwpid;
               } else {
                       a->lwpid = 0;
               }
               if (distinguish_cpus) {
                       a->cpuid = sample.s_cpuid;
               } else {
                       a->cpuid = 0;
               }
               a->in_kernel = in_kernel;
               if (per_symbol) {
                       const char *name;
                       uint64_t offset;

                       name = ksymlookup(a->addr, &offset, NULL);
                       if (name != NULL) {
                               a->addr -= offset;
                       }
               }
               c = __SHIFTOUT(sample.s_flags, TPROF_SAMPLE_COUNTER_MASK);
               assert(c < TPROF_MAXCOUNTERS);
               if (maxevent < c)
                       maxevent = c;

               a->nsamples = 1;
               a->ncount[c] = 1;
               o = rb_tree_insert_node(&addrtree, a);
               if (o != a) {
                       assert(a->addr == o->addr);
                       assert(a->pid == o->pid);
                       assert(a->lwpid == o->lwpid);
                       assert(a->cpuid == o->cpuid);
                       assert(a->in_kernel == o->in_kernel);
                       free(a);

                       o->nsamples++;
                       o->ncount[c]++;
               } else {
                       naddrs++;
               }
               nsamples++;
       }

       /*
        * sort samples by addresses.
        */

       l = emalloc(naddrs * sizeof(*l));
       p = l;
       RB_TREE_FOREACH(a, &addrtree) {
               *p++ = a;
       }
       assert(l + naddrs == p);
       qsort(l, naddrs, sizeof(*l), compare_nsamples);

       /*
        * print addresses and number of samples, preferably with
        * resolved symbol names.
        */
       printf("File: %s\n", argv[0]);
       printf("Number of samples: %zu\n\n", nsamples);

       printf("percentage   nsamples ");
       for (c = 0; c <= maxevent; c++)
               printf("event#%02u ", c);
       printf("pid    lwp    cpu  k address          symbol\n");

       printf("------------ -------- ");
       for (c = 0; c <= maxevent; c++)
               printf("-------- ");

       printf("------ ------ ---- - ---------------- ------\n");
       for (i = 0; i < naddrs; i++) {
               const char *name;
               char buf[100];
               uint64_t offset;

               a = l[i];
               if (a->in_kernel) {
                       name = ksymlookup(a->addr, &offset, NULL);
               } else {
                       name = NULL;
               }
               if (name == NULL) {
                       (void)snprintf(buf, sizeof(buf), "<%016" PRIx64 ">",
                           a->addr);
                       name = buf;
               } else if (offset != 0) {
                       (void)snprintf(buf, sizeof(buf), "%s+0x%" PRIx64, name,
                           offset);
                       name = buf;
               }

               perc = ((float)a->nsamples / (float)nsamples) * 100.0;

               printf("%11f%% %8u", perc, a->nsamples);

               for (c = 0; c <= maxevent; c++)
                       printf(" %8u", a->ncount[c]);

               printf(" %6" PRIu32 " %6" PRIu32 " %4" PRIu32 " %u %016"
                   PRIx64" %s",
                   a->pid, a->lwpid, a->cpuid, a->in_kernel, a->addr, name);


               printf("\n");
       }

       fclose(f);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.