Home | History | Annotate | Line # | Download | only in tprof
tprof_analyze.c revision 1.9 
      1 /*	$NetBSD: tprof_analyze.c,v 1.9 2024/11/03 10:43:27 rillig Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 2010,2011,2012 YAMAMOTO Takashi,
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     26  * SUCH DAMAGE.
     27  */
     28 
     29 #include <sys/cdefs.h>
     30 #ifndef lint
     31 __RCSID("$NetBSD: tprof_analyze.c,v 1.9 2024/11/03 10:43:27 rillig Exp $");
     32 #endif /* not lint */
     33 
     34 #include <assert.h>
     35 #include <err.h>
     36 #include <errno.h>
     37 #include <fcntl.h>
     38 #include <gelf.h>
     39 #include <inttypes.h>
     40 #include <libelf.h>
     41 #include <stdbool.h>
     42 #include <stdlib.h>
     43 #include <stdio.h>
     44 #include <unistd.h>
     45 #include <string.h>
     46 #include <util.h>
     47 #include <dev/tprof/tprof_ioctl.h>
     48 #include "tprof.h"
     49 #include "ksyms.h"
     50 
     51 #include <sys/rbtree.h>
     52 
     53 static bool filter_by_pid;
     54 static pid_t target_pid;
     55 static bool per_symbol;
     56 
     57 struct addr {
     58 	struct rb_node node;
     59 	uint64_t addr;		/* address */
     60 	uint32_t pid;		/* process id */
     61 	uint32_t lwpid;		/* lwp id */
     62 	uint32_t cpuid;		/* cpu id */
     63 	bool in_kernel;		/* if addr is in the kernel address space */
     64 	unsigned int nsamples;	/* number of samples taken for the address */
     65 	unsigned int ncount[TPROF_MAXCOUNTERS];	/* count per event */
     66 };
     67 
     68 static rb_tree_t addrtree;
     69 
     70 static signed int
     71 addrtree_compare_key(void *ctx, const void *n1, const void *keyp)
     72 {
     73 	const struct addr *a1 = n1;
     74 	const struct addr *a2 = (const struct addr *)keyp;
     75 
     76 	if (a1->addr > a2->addr) {
     77 		return 1;
     78 	} else if (a1->addr < a2->addr) {
     79 		return -1;
     80 	}
     81 	if (a1->pid > a2->pid) {
     82 		return -1;
     83 	} else if (a1->pid < a2->pid) {
     84 		return 1;
     85 	}
     86 	if (a1->lwpid > a2->lwpid) {
     87 		return -1;
     88 	} else if (a1->lwpid < a2->lwpid) {
     89 		return 1;
     90 	}
     91 	if (a1->cpuid > a2->cpuid) {
     92 		return -1;
     93 	} else if (a1->cpuid < a2->cpuid) {
     94 		return 1;
     95 	}
     96 	if (a1->in_kernel > a2->in_kernel) {
     97 		return -1;
     98 	} else if (a1->in_kernel < a2->in_kernel) {
     99 		return 1;
    100 	}
    101 	return 0;
    102 }
    103 
    104 static signed int
    105 addrtree_compare_nodes(void *ctx, const void *n1, const void *n2)
    106 {
    107 	const struct addr *a2 = n2;
    108 
    109 	return addrtree_compare_key(ctx, n1, a2);
    110 }
    111 
    112 static const rb_tree_ops_t addrtree_ops = {
    113 	.rbto_compare_nodes = addrtree_compare_nodes,
    114 	.rbto_compare_key = addrtree_compare_key,
    115 };
    116 
    117 static int
    118 compare_nsamples(const void *p1, const void *p2)
    119 {
    120 	const struct addr *a1 = *(const struct addr * const *)p1;
    121 	const struct addr *a2 = *(const struct addr * const *)p2;
    122 
    123 	if (a1->nsamples > a2->nsamples) {
    124 		return -1;
    125 	} else if (a1->nsamples < a2->nsamples) {
    126 		return 1;
    127 	}
    128 	return 0;
    129 }
    130 
    131 void
    132 tprof_analyze(int argc, char **argv)
    133 {
    134 	struct addr *a;
    135 	struct addr **l;
    136 	struct addr **p;
    137 	size_t naddrs, nsamples, i;
    138 	float perc;
    139 	int ch;
    140 	u_int c, maxevent = 0;
    141 	bool distinguish_processes = true;
    142 	bool distinguish_cpus = true;
    143 	bool distinguish_lwps = true;
    144 	bool kernel_only = false;
    145 	FILE *f;
    146 
    147 	while ((ch = getopt(argc, argv, "CkLPp:s")) != -1) {
    148 		uintmax_t val;
    149 		char *ep;
    150 
    151 		switch (ch) {
    152 		case 'C':	/* don't distinguish cpus */
    153 			distinguish_cpus = false;
    154 			break;
    155 		case 'k':	/* kernel only */
    156 			kernel_only = true;
    157 			break;
    158 		case 'L':	/* don't distinguish lwps */
    159 			distinguish_lwps = false;
    160 			break;
    161 		case 'p':	/* only for the process for the given pid */
    162 			errno = 0;
    163 			val = strtoumax(optarg, &ep, 10);
    164 			if (optarg[0] == 0 || *ep != 0 ||
    165 			    val > INT32_MAX) {
    166 				errx(EXIT_FAILURE, "invalid p option");
    167 			}
    168 			target_pid = val;
    169 			filter_by_pid = true;
    170 			break;
    171 		case 'P':	/* don't distinguish processes */
    172 			distinguish_processes = false;
    173 			break;
    174 		case 's':	/* per symbol */
    175 			per_symbol = true;
    176 			break;
    177 		default:
    178 			exit(EXIT_FAILURE);
    179 		}
    180 	}
    181 	argc -= optind;
    182 	argv += optind;
    183 
    184 	if (argc == 0) {
    185 		errx(EXIT_FAILURE, "missing file name");
    186 	}
    187 
    188 	f = fopen(argv[0], "rb");
    189 	if (f == NULL) {
    190 		errx(EXIT_FAILURE, "fopen");
    191 	}
    192 
    193 	ksymload(NULL);
    194 	rb_tree_init(&addrtree, &addrtree_ops);
    195 
    196 	/*
    197 	 * read and count samples.
    198 	 */
    199 
    200 	naddrs = 0;
    201 	nsamples = 0;
    202 	while (/*CONSTCOND*/true) {
    203 		struct addr *o;
    204 		tprof_sample_t sample;
    205 		size_t n = fread(&sample, sizeof(sample), 1, f);
    206 		bool in_kernel;
    207 
    208 		if (n == 0) {
    209 			if (feof(f)) {
    210 				break;
    211 			}
    212 			if (ferror(f)) {
    213 				err(EXIT_FAILURE, "fread");
    214 			}
    215 		}
    216 		if (filter_by_pid && (pid_t)sample.s_pid != target_pid) {
    217 			continue;
    218 		}
    219 		in_kernel = (sample.s_flags & TPROF_SAMPLE_INKERNEL) != 0;
    220 		if (kernel_only && !in_kernel) {
    221 			continue;
    222 		}
    223 		a = emalloc(sizeof(*a));
    224 		memset(a, 0, sizeof(*a));
    225 		a->addr = (uint64_t)sample.s_pc;
    226 		if (distinguish_processes) {
    227 			a->pid = sample.s_pid;
    228 		} else {
    229 			a->pid = 0;
    230 		}
    231 		if (distinguish_lwps) {
    232 			a->lwpid = sample.s_lwpid;
    233 		} else {
    234 			a->lwpid = 0;
    235 		}
    236 		if (distinguish_cpus) {
    237 			a->cpuid = sample.s_cpuid;
    238 		} else {
    239 			a->cpuid = 0;
    240 		}
    241 		a->in_kernel = in_kernel;
    242 		if (per_symbol) {
    243 			const char *name;
    244 			uint64_t offset;
    245 
    246 			name = ksymlookup(a->addr, &offset, NULL);
    247 			if (name != NULL) {
    248 				a->addr -= offset;
    249 			}
    250 		}
    251 		c = __SHIFTOUT(sample.s_flags, TPROF_SAMPLE_COUNTER_MASK);
    252 		assert(c < TPROF_MAXCOUNTERS);
    253 		if (maxevent < c)
    254 			maxevent = c;
    255 
    256 		a->nsamples = 1;
    257 		a->ncount[c] = 1;
    258 		o = rb_tree_insert_node(&addrtree, a);
    259 		if (o != a) {
    260 			assert(a->addr == o->addr);
    261 			assert(a->pid == o->pid);
    262 			assert(a->lwpid == o->lwpid);
    263 			assert(a->cpuid == o->cpuid);
    264 			assert(a->in_kernel == o->in_kernel);
    265 			free(a);
    266 
    267 			o->nsamples++;
    268 			o->ncount[c]++;
    269 		} else {
    270 			naddrs++;
    271 		}
    272 		nsamples++;
    273 	}
    274 
    275 	/*
    276 	 * sort samples by addresses.
    277 	 */
    278 
    279 	l = emalloc(naddrs * sizeof(*l));
    280 	p = l;
    281 	RB_TREE_FOREACH(a, &addrtree) {
    282 		*p++ = a;
    283 	}
    284 	assert(l + naddrs == p);
    285 	qsort(l, naddrs, sizeof(*l), compare_nsamples);
    286 
    287 	/*
    288 	 * print addresses and number of samples, preferably with
    289 	 * resolved symbol names.
    290 	 */
    291 	printf("File: %s\n", argv[0]);
    292 	printf("Number of samples: %zu\n\n", nsamples);
    293 
    294 	printf("percentage   nsamples ");
    295 	for (c = 0; c <= maxevent; c++)
    296 		printf("event#%02u ", c);
    297 	printf("pid    lwp    cpu  k address          symbol\n");
    298 
    299 	printf("------------ -------- ");
    300 	for (c = 0; c <= maxevent; c++)
    301 		printf("-------- ");
    302 
    303 	printf("------ ------ ---- - ---------------- ------\n");
    304 	for (i = 0; i < naddrs; i++) {
    305 		const char *name;
    306 		char buf[100];
    307 		uint64_t offset;
    308 
    309 		a = l[i];
    310 		if (a->in_kernel) {
    311 			name = ksymlookup(a->addr, &offset, NULL);
    312 		} else {
    313 			name = NULL;
    314 		}
    315 		if (name == NULL) {
    316 			(void)snprintf(buf, sizeof(buf), "<%016" PRIx64 ">",
    317 			    a->addr);
    318 			name = buf;
    319 		} else if (offset != 0) {
    320 			(void)snprintf(buf, sizeof(buf), "%s+0x%" PRIx64, name,
    321 			    offset);
    322 			name = buf;
    323 		}
    324 
    325 		perc = ((float)a->nsamples / (float)nsamples) * 100.0;
    326 
    327 		printf("%11f%% %8u", perc, a->nsamples);
    328 
    329 		for (c = 0; c <= maxevent; c++)
    330 			printf(" %8u", a->ncount[c]);
    331 
    332 		printf(" %6" PRIu32 " %6" PRIu32 " %4" PRIu32 " %u %016"
    333 		    PRIx64" %s",
    334 		    a->pid, a->lwpid, a->cpuid, a->in_kernel, a->addr, name);
    335 
    336 
    337 		printf("\n");
    338 	}
    339 
    340 	fclose(f);
    341 }
    342