/* $NetBSD: tprof_top.c,v 1.11 2024/02/07 04:20:28 msaitoh Exp $ */
/*-
* Copyright (c) 2022 Ryo Shimizu
* 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 ``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 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_top.c,v 1.11 2024/02/07 04:20:28 msaitoh Exp $");
#endif /* not lint */
#include <sys/param.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/rbtree.h>
#include <sys/select.h>
#include <sys/time.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <math.h>
#include <signal.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <term.h>
#include <termios.h>
#include <unistd.h>
#include <util.h>
#include <dev/tprof/tprof_ioctl.h>
#include "tprof.h"
#include "ksyms.h"
#define SAMPLE_MODE_ACCUMULATIVE 0
#define SAMPLE_MODE_INSTANTANEOUS 1
#define SAMPLE_MODE_NUM 2
#define LINESTR "-------------------------------------------------------------"
#define SYMBOL_LEN 32 /* symbol and event name */
struct sample_elm {
struct rb_node node;
uint64_t addr;
const char *name;
uint32_t flags;
#define SAMPLE_ELM_FLAGS_USER 0x00000001
uint32_t num[SAMPLE_MODE_NUM];
uint32_t num_cpu[]; /* [SAMPLE_MODE_NUM][ncpu] */
#define SAMPLE_ELM_NUM_CPU(e, k) \
((e)->num_cpu + (k) * ncpu)
};
struct ptrarray {
void **pa_ptrs;
size_t pa_allocnum;
size_t pa_inuse;
};
static int opt_mode = SAMPLE_MODE_INSTANTANEOUS;
static int opt_userland = 0;
static int opt_showcounter = 0;
/* for display */
static char *term;
static struct winsize win;
static int nontty;
static struct termios termios_save;
static bool termios_saved;
static long top_interval = 1;
static bool do_redraw;
static u_int nshow;
/* for profiling and counting samples */
static sig_atomic_t sigalrm;
static struct sym **ksyms;
static size_t nksyms;
static u_int nevent;
static const char *eventname[TPROF_MAXCOUNTERS];
static size_t sizeof_sample_elm;
static rb_tree_t rb_tree_sample;
struct ptrarray sample_list[SAMPLE_MODE_NUM];
static u_int sample_n_kern[SAMPLE_MODE_NUM];
static u_int sample_n_user[SAMPLE_MODE_NUM];
static u_int sample_event_width = 7;
static u_int *sample_cpu_width; /* [ncpu] */
static uint32_t *sample_n_kern_per_cpu[SAMPLE_MODE_NUM]; /* [ncpu] */
static uint32_t *sample_n_user_per_cpu[SAMPLE_MODE_NUM]; /* [ncpu] */
static uint64_t *sample_n_per_event[SAMPLE_MODE_NUM]; /* [nevent] */
static uint64_t *sample_n_per_event_cpu[SAMPLE_MODE_NUM]; /* [ncpu] */
/* raw event counter */
static uint64_t *counters; /* counters[2][ncpu][nevent] */
static u_int counters_i;
static void
reset_cursor_pos(void)
{
int i;
char *p;
if (nontty || term == NULL)
return;
printf("\r");
/* cursor_up * n */
if ((p = tigetstr("cuu")) != NULL) {
putp(tparm(p, win.ws_row - 1, 0, 0, 0, 0, 0, 0, 0, 0));
} else if ((p = tigetstr("cuu1")) != NULL) {
for (i = win.ws_row - 1; i > 0; i--)
putp(p);
}
}
static void
clr_to_eol(void)
{
char *p;
if (nontty || term == NULL)
return;
if ((p = tigetstr("el")) != NULL)
putp(p);
}
/* newline, and clearing to end of line if needed */
static void
lim_newline(int *lim)
{
if (*lim >= 1)
clr_to_eol();
printf("\n");
*lim = win.ws_col;
}
static int
lim_printf(int *lim, const char *fmt, ...)
{
va_list ap;
size_t written;
char *p;
if (*lim <= 0)
return 0;
p = malloc(*lim + 1);
if (p == NULL)
return -1;
va_start(ap, fmt);
vsnprintf(p, *lim + 1, fmt, ap);
va_end(ap);
written = strlen(p);
if (written == 0) {
free(p);
*lim = 0;
return 0;
}
fwrite(p, written, 1, stdout);
*lim -= written;
free(p);
return written;
}
static void
sigwinch_handler(int signo)
{
char *p;
win.ws_col = tigetnum("lines");
win.ws_row = tigetnum("cols");
nontty = ioctl(STDOUT_FILENO, TIOCGWINSZ, &win);
if (nontty != 0) {
nontty = !isatty(STDOUT_FILENO);
win.ws_col = 65535;
win.ws_row = 65535;
}
if ((p = getenv("LINES")) != NULL)
win.ws_row = strtoul(p, NULL, 0);
if ((p = getenv("COLUMNS")) != NULL)
win.ws_col = strtoul(p, NULL, 0);
do_redraw = true;
}
static void
tty_setup(void)
{
struct termios termios;
term = getenv("TERM");
if (term != NULL)
setupterm(term, 0, NULL);
sigwinch_handler(0);
if (tcgetattr(STDOUT_FILENO, &termios_save) == 0) {
termios_saved = true;
/* stty cbreak */
termios = termios_save;
termios.c_iflag |= BRKINT|IXON|IMAXBEL;
termios.c_oflag |= OPOST;
termios.c_lflag |= ISIG|IEXTEN;
termios.c_lflag &= ~(ICANON|ECHO);
tcsetattr(STDOUT_FILENO, TCSADRAIN, &termios);
}
}
static void
tty_restore(void)
{
if (termios_saved) {
tcsetattr(STDOUT_FILENO, TCSADRAIN, &termios_save);
termios_saved = false;
}
}
static void
sigtstp_handler(int signo)
{
tty_restore();
signal(SIGWINCH, SIG_DFL);
signal(SIGINT, SIG_DFL);
signal(SIGQUIT, SIG_DFL);
signal(SIGTERM, SIG_DFL);
signal(SIGTSTP, SIG_DFL);
kill(0, SIGTSTP);
nshow = 0;
}
static void
sigalrm_handler(int signo)
{
sigalrm = 1;
}
__dead static void
die(int signo)
{
tty_restore();
printf("\n");
exit(EXIT_SUCCESS);
}
__dead static void
die_errc(int status, int code, const char *fmt, ...)
{
va_list ap;
tty_restore();
va_start(ap, fmt);
if (code == 0)
verrx(status, fmt, ap);
else
verrc(status, code, fmt, ap);
va_end(ap);
}
static void
ptrarray_push(struct ptrarray *ptrarray, void *ptr)
{
int error;
if (ptrarray->pa_inuse >= ptrarray->pa_allocnum) {
/* increase buffer */
ptrarray->pa_allocnum += 1024;
error = reallocarr(&ptrarray->pa_ptrs, ptrarray->pa_allocnum,
sizeof(*ptrarray->pa_ptrs));
if (error != 0)
die_errc(EXIT_FAILURE, error, "rellocarr failed");
}
ptrarray->pa_ptrs[ptrarray->pa_inuse++] = ptr;
}
static void
ptrarray_iterate(struct ptrarray *ptrarray, void (*ifunc)(void *))
{
size_t i;
for (i = 0; i < ptrarray->pa_inuse; i++) {
(*ifunc)(ptrarray->pa_ptrs[i]);
}
}
static void
ptrarray_clear(struct ptrarray *ptrarray)
{
ptrarray->pa_inuse = 0;
}
static int
sample_compare_key(void *ctx, const void *n1, const void *keyp)
{
const struct sample_elm *a1 = n1;
const struct sample_elm *a2 = (const struct sample_elm *)keyp;
return a1->addr - a2->addr;
}
static signed int
sample_compare_nodes(void *ctx, const void *n1, const void *n2)
{
const struct addr *a2 = n2;
return sample_compare_key(ctx, n1, a2);
}
static const rb_tree_ops_t sample_ops = {
.rbto_compare_nodes = sample_compare_nodes,
.rbto_compare_key = sample_compare_key
};
static u_int
n_align(u_int n, u_int align)
{
return (n + align - 1) / align * align;
}
static void
sample_init(void)
{
const struct sample_elm *e;
int l, mode, n;
u_int size;
char buf[16];
size = sizeof(struct sample_elm) +
sizeof(e->num_cpu[0]) * SAMPLE_MODE_NUM * ncpu;
sizeof_sample_elm = n_align(size, __alignof(struct sample_elm));
sample_cpu_width = ecalloc(1, sizeof(*sample_cpu_width) * ncpu);
for (n = 0; n < ncpu; n++) {
sample_cpu_width[n] = 5;
l = snprintf(buf, sizeof(buf), "CPU%d", n);
if (sample_cpu_width[n] < (u_int)l)
sample_cpu_width[n] = l;
}
for (mode = 0; mode < SAMPLE_MODE_NUM; mode++) {
sample_n_kern_per_cpu[mode] = ecalloc(1,
sizeof(typeof(*sample_n_kern_per_cpu[mode])) * ncpu);
sample_n_user_per_cpu[mode] = ecalloc(1,
sizeof(typeof(*sample_n_user_per_cpu[mode])) * ncpu);
sample_n_per_event[mode] = ecalloc(1,
sizeof(typeof(*sample_n_per_event[mode])) * nevent);
sample_n_per_event_cpu[mode] = ecalloc(1,
sizeof(typeof(*sample_n_per_event_cpu[mode])) *
nevent * ncpu);
}
}
static void
sample_clear_instantaneous(void *arg)
{
struct sample_elm *e = (void *)arg;
e->num[SAMPLE_MODE_INSTANTANEOUS] = 0;
memset(SAMPLE_ELM_NUM_CPU(e, SAMPLE_MODE_INSTANTANEOUS),
0, sizeof(e->num_cpu[0]) * ncpu);
}
static void
sample_reset(bool reset_accumulative)
{
int mode;
for (mode = 0; mode < SAMPLE_MODE_NUM; mode++) {
if (mode == SAMPLE_MODE_ACCUMULATIVE && !reset_accumulative)
continue;
sample_n_kern[mode] = 0;
sample_n_user[mode] = 0;
memset(sample_n_kern_per_cpu[mode], 0,
sizeof(typeof(*sample_n_kern_per_cpu[mode])) * ncpu);
memset(sample_n_user_per_cpu[mode], 0,
sizeof(typeof(*sample_n_user_per_cpu[mode])) * ncpu);
memset(sample_n_per_event[mode], 0,
sizeof(typeof(*sample_n_per_event[mode])) * nevent);
memset(sample_n_per_event_cpu[mode], 0,
sizeof(typeof(*sample_n_per_event_cpu[mode])) *
nevent * ncpu);
}
if (reset_accumulative) {
rb_tree_init(&rb_tree_sample, &sample_ops);
ptrarray_iterate(&sample_list[SAMPLE_MODE_ACCUMULATIVE], free);
ptrarray_clear(&sample_list[SAMPLE_MODE_ACCUMULATIVE]);
ptrarray_clear(&sample_list[SAMPLE_MODE_INSTANTANEOUS]);
} else {
ptrarray_iterate(&sample_list[SAMPLE_MODE_INSTANTANEOUS],
sample_clear_instantaneous);
ptrarray_clear(&sample_list[SAMPLE_MODE_INSTANTANEOUS]);
}
}
static int __unused
sample_sortfunc_accumulative(const void *a, const void *b)
{
struct sample_elm * const *ea = a;
struct sample_elm * const *eb = b;
return (*eb)->num[SAMPLE_MODE_ACCUMULATIVE] -
(*ea)->num[SAMPLE_MODE_ACCUMULATIVE];
}
static int
sample_sortfunc_instantaneous(const void *a, const void *b)
{
struct sample_elm * const *ea = a;
struct sample_elm * const *eb = b;
return (*eb)->num[SAMPLE_MODE_INSTANTANEOUS] -
(*ea)->num[SAMPLE_MODE_INSTANTANEOUS];
}
static void
sample_sort_accumulative(void)
{
qsort(sample_list[SAMPLE_MODE_ACCUMULATIVE].pa_ptrs,
sample_list[SAMPLE_MODE_ACCUMULATIVE].pa_inuse,
sizeof(struct sample_elm *), sample_sortfunc_accumulative);
}
static void
sample_sort_instantaneous(void)
{
qsort(sample_list[SAMPLE_MODE_INSTANTANEOUS].pa_ptrs,
sample_list[SAMPLE_MODE_INSTANTANEOUS].pa_inuse,
sizeof(struct sample_elm *), sample_sortfunc_instantaneous);
}
static void
sample_collect(tprof_sample_t *s)
{
struct sample_elm *e, *o;
const char *name;
size_t symid;
uint64_t addr, offset;
uint32_t flags = 0;
uint32_t eventid, cpuid;
int mode;
eventid = __SHIFTOUT(s->s_flags, TPROF_SAMPLE_COUNTER_MASK);
cpuid = s->s_cpuid;
if (eventid >= nevent) /* unknown event from tprof? */
return;
for (mode = 0; mode < SAMPLE_MODE_NUM; mode++) {
sample_n_per_event[mode][eventid]++;
sample_n_per_event_cpu[mode][nevent * cpuid + eventid]++;
}
if ((s->s_flags & TPROF_SAMPLE_INKERNEL) == 0) {
sample_n_user[SAMPLE_MODE_ACCUMULATIVE]++;
sample_n_user[SAMPLE_MODE_INSTANTANEOUS]++;
sample_n_user_per_cpu[SAMPLE_MODE_ACCUMULATIVE][cpuid]++;
sample_n_user_per_cpu[SAMPLE_MODE_INSTANTANEOUS][cpuid]++;
name = NULL;
addr = s->s_pid; /* XXX */
flags |= SAMPLE_ELM_FLAGS_USER;
if (!opt_userland)
return;
} else {
sample_n_kern[SAMPLE_MODE_ACCUMULATIVE]++;
sample_n_kern[SAMPLE_MODE_INSTANTANEOUS]++;
sample_n_kern_per_cpu[SAMPLE_MODE_ACCUMULATIVE][cpuid]++;
sample_n_kern_per_cpu[SAMPLE_MODE_INSTANTANEOUS][cpuid]++;
name = ksymlookup(s->s_pc, &offset, &symid);
if (name != NULL) {
addr = ksyms[symid]->value;
} else {
addr = s->s_pc;
}
}
e = ecalloc(1, sizeof_sample_elm);
e->addr = addr;
e->name = name;
e->flags = flags;
e->num[SAMPLE_MODE_ACCUMULATIVE] = 1;
e->num[SAMPLE_MODE_INSTANTANEOUS] = 1;
SAMPLE_ELM_NUM_CPU(e, SAMPLE_MODE_ACCUMULATIVE)[cpuid] = 1;
SAMPLE_ELM_NUM_CPU(e, SAMPLE_MODE_INSTANTANEOUS)[cpuid] = 1;
o = rb_tree_insert_node(&rb_tree_sample, e);
if (o == e) {
/* new symbol. add to list for sort */
ptrarray_push(&sample_list[SAMPLE_MODE_ACCUMULATIVE], o);
ptrarray_push(&sample_list[SAMPLE_MODE_INSTANTANEOUS], o);
} else {
/* already exists */
free(e);
o->num[SAMPLE_MODE_ACCUMULATIVE]++;
if (o->num[SAMPLE_MODE_INSTANTANEOUS]++ == 0) {
/* new instantaneous symbols. add to list for sort */
ptrarray_push(&sample_list[SAMPLE_MODE_INSTANTANEOUS],
o);
}
SAMPLE_ELM_NUM_CPU(o, SAMPLE_MODE_ACCUMULATIVE)[cpuid]++;
SAMPLE_ELM_NUM_CPU(o, SAMPLE_MODE_INSTANTANEOUS)[cpuid]++;
}
}
static void
show_tprof_stat(int *lim)
{
static struct tprof_stat tsbuf[2], *ts0, *ts;
static u_int ts_i = 0;
static int tprofstat_width[6];
int ret, l;
char tmpbuf[128];
ts0 = &tsbuf[ts_i++ & 1];
ts = &tsbuf[ts_i & 1];
ret = ioctl(devfd, TPROF_IOC_GETSTAT, ts);
if (ret == -1)
die_errc(EXIT_FAILURE, errno, "TPROF_IOC_GETSTAT");
#define TS_PRINT(idx, label, _m) \
do { \
__CTASSERT(idx < __arraycount(tprofstat_width)); \
lim_printf(lim, "%s", label); \
l = snprintf(tmpbuf, sizeof(tmpbuf), "%"PRIu64, ts->_m);\
if (ts->_m != ts0->_m) \
l += snprintf(tmpbuf + l, sizeof(tmpbuf) - l, \
"(+%"PRIu64")", ts->_m - ts0->_m); \
assert(l < (int)sizeof(tmpbuf)); \
if (tprofstat_width[idx] < l) \
tprofstat_width[idx] = l; \
lim_printf(lim, "%-*.*s ", tprofstat_width[idx], \
tprofstat_width[idx], tmpbuf); \
} while (0)
lim_printf(lim, "tprof ");
TS_PRINT(0, "sample:", ts_sample);
TS_PRINT(1, "overflow:", ts_overflow);
TS_PRINT(2, "buf:", ts_buf);
TS_PRINT(3, "emptybuf:", ts_emptybuf);
TS_PRINT(4, "dropbuf:", ts_dropbuf);
TS_PRINT(5, "dropbuf_sample:", ts_dropbuf_sample);
}
static void
show_timestamp(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
printf("%-8.8s", &(ctime((time_t *)&tv.tv_sec)[11]));
}
static void
show_counters_alloc(void)
{
size_t sz = 2 * ncpu * nevent * sizeof(*counters);
counters = ecalloc(1, sz);
}
static void
show_counters(int *lim)
{
tprof_counts_t countsbuf;
uint64_t *cn[2], *c0, *c;
u_int i;
int n, ret;
cn[0] = counters;
cn[1] = counters + ncpu * nevent;
c0 = cn[counters_i++ & 1];
c = cn[counters_i & 1];
for (n = 0; n < ncpu; n++) {
countsbuf.c_cpu = n;
ret = ioctl(devfd, TPROF_IOC_GETCOUNTS, &countsbuf);
if (ret == -1)
die_errc(EXIT_FAILURE, errno, "TPROF_IOC_GETCOUNTS");
for (i = 0; i < nevent; i++)
c[n * nevent + i] = countsbuf.c_count[i];
}
if (do_redraw) {
lim_printf(lim, "%-22s", "Event counter (delta)");
for (n = 0; n < ncpu; n++) {
char cpuname[16];
snprintf(cpuname, sizeof(cpuname), "CPU%u", n);
lim_printf(lim, "%11s", cpuname);
}
lim_newline(lim);
} else {
printf("\n");
}
for (i = 0; i < nevent; i++) {
lim_printf(lim, "%-22.22s", eventname[i]);
for (n = 0; n < ncpu; n++) {
lim_printf(lim, "%11"PRIu64,
c[n * nevent + i] - c0[n * nevent + i]);
}
lim_newline(lim);
}
lim_newline(lim);
}
static void
show_count_per_event(int *lim)
{
u_int i, nsample_total;
int n, l;
char buf[32];
nsample_total = sample_n_kern[opt_mode] + sample_n_user[opt_mode];
if (nsample_total == 0)
nsample_total = 1;
/* calc width in advance */
for (i = 0; i < nevent; i++) {
l = snprintf(buf, sizeof(buf), "%"PRIu64,
sample_n_per_event[opt_mode][i]);
if (sample_event_width < (u_int)l) {
sample_event_width = l;
do_redraw = true;
}
}
for (n = 0; n < ncpu; n++) {
uint64_t sum = 0;
for (i = 0; i < nevent; i++)
sum += sample_n_per_event_cpu[opt_mode][nevent * n + i];
l = snprintf(buf, sizeof(buf), "%"PRIu64, sum);
if (sample_cpu_width[n] < (u_int)l) {
sample_cpu_width[n] = l;
do_redraw = true;
}
}
if (do_redraw) {
lim_printf(lim, " Rate %*s %-*s",
sample_event_width, "Sample#",
SYMBOL_LEN, "Eventname");
for (n = 0; n < ncpu; n++) {
snprintf(buf, sizeof(buf), "CPU%d", n);
lim_printf(lim, " %*s", sample_cpu_width[n], buf);
}
lim_newline(lim);
lim_printf(lim, "------ %*.*s %*.*s",
sample_event_width, sample_event_width, LINESTR,
SYMBOL_LEN, SYMBOL_LEN, LINESTR);
for (n = 0; n < ncpu; n++) {
lim_printf(lim, " %*.*s",
sample_cpu_width[n], sample_cpu_width[n], LINESTR);
}
lim_newline(lim);
} else {
printf("\n\n");
}
for (i = 0; i < nevent; i++) {
if (sample_n_per_event[opt_mode][i] >= nsample_total) {
lim_printf(lim, "%5.1f%%", 100.0 *
sample_n_per_event[opt_mode][i] / nsample_total);
} else {
lim_printf(lim, "%5.2f%%", 100.0 *
sample_n_per_event[opt_mode][i] / nsample_total);
}
lim_printf(lim, " %*"PRIu64" ", sample_event_width,
sample_n_per_event[opt_mode][i]);
lim_printf(lim, "%-32.32s", eventname[i]);
for (n = 0; n < ncpu; n++) {
lim_printf(lim, " %*"PRIu64, sample_cpu_width[n],
sample_n_per_event_cpu[opt_mode][nevent * n + i]);
}
lim_newline(lim);
}
}
static void
sample_show(void)
{
struct sample_elm *e;
struct ptrarray *samples;
u_int nsample_total;
int i, l, lim, n, ndisp;
char namebuf[32];
const char *name;
if (nshow++ == 0) {
printf("\n");
if (!nontty) {
signal(SIGWINCH, sigwinch_handler);
signal(SIGINT, die);
signal(SIGQUIT, die);
signal(SIGTERM, die);
signal(SIGTSTP, sigtstp_handler);
tty_setup();
}
} else {
reset_cursor_pos();
}
int margin_lines = 7;
margin_lines += 3 + nevent; /* show_counter_per_event() */
if (opt_mode == SAMPLE_MODE_INSTANTANEOUS)
sample_sort_instantaneous();
else
sample_sort_accumulative();
samples = &sample_list[opt_mode];
if (opt_showcounter)
margin_lines += 2 + nevent;
if (opt_userland)
margin_lines += 1;
ndisp = samples->pa_inuse;
if (!nontty && ndisp > (win.ws_row - margin_lines))
ndisp = win.ws_row - margin_lines;
lim = win.ws_col;
if (opt_mode == SAMPLE_MODE_ACCUMULATIVE)
lim_printf(&lim, "[Accumulative mode] ");
show_tprof_stat(&lim);
if (lim >= 16) {
l = win.ws_col - lim;
if (!nontty) {
clr_to_eol();
for (; l <= win.ws_col - 17; l = ((l + 8) & -8))
printf("\t");
}
show_timestamp();
}
lim_newline(&lim);
lim_newline(&lim);
if (opt_showcounter)
show_counters(&lim);
show_count_per_event(&lim);
lim_newline(&lim);
if (do_redraw) {
lim_printf(&lim, " Rate %*s %-*s",
sample_event_width, "Sample#",
SYMBOL_LEN, "Symbol");
for (n = 0; n < ncpu; n++) {
snprintf(namebuf, sizeof(namebuf), "CPU%d", n);
lim_printf(&lim, " %*s", sample_cpu_width[n], namebuf);
}
lim_newline(&lim);
lim_printf(&lim, "------ %*.*s %*.*s",
sample_event_width, sample_event_width, LINESTR,
SYMBOL_LEN, SYMBOL_LEN, LINESTR);
for (n = 0; n < ncpu; n++) {
lim_printf(&lim, " %*.*s", sample_cpu_width[n],
sample_cpu_width[n], LINESTR);
}
lim_newline(&lim);
} else {
printf("\n\n");
}
for (i = 0; i < ndisp; i++) {
e = (struct sample_elm *)samples->pa_ptrs[i];
name = e->name;
if (name == NULL) {
if (e->flags & SAMPLE_ELM_FLAGS_USER) {
snprintf(namebuf, sizeof(namebuf),
"<PID:%"PRIu64">", e->addr);
} else {
snprintf(namebuf, sizeof(namebuf),
"0x%016"PRIx64, e->addr);
}
name = namebuf;
}
nsample_total = sample_n_kern[opt_mode];
if (opt_userland)
nsample_total += sample_n_user[opt_mode];
/*
* even when only kernel mode events are configured,
* interrupts may still occur in the user mode state.
*/
if (nsample_total == 0)
nsample_total = 1;
if (e->num[opt_mode] >= nsample_total) {
lim_printf(&lim, "%5.1f%%", 100.0 *
e->num[opt_mode] / nsample_total);
} else {
lim_printf(&lim, "%5.2f%%", 100.0 *
e->num[opt_mode] / nsample_total);
}
lim_printf(&lim, " %*u %-32.32s", sample_event_width,
e->num[opt_mode], name);
for (n = 0; n < ncpu; n++) {
if (SAMPLE_ELM_NUM_CPU(e, opt_mode)[n] == 0) {
lim_printf(&lim, " %*s", sample_cpu_width[n],
".");
} else {
lim_printf(&lim, " %*u", sample_cpu_width[n],
SAMPLE_ELM_NUM_CPU(e, opt_mode)[n]);
}
}
lim_newline(&lim);
}
if ((u_int)ndisp != samples->pa_inuse) {
lim_printf(&lim, " : %*s (more %zu symbols omitted)",
sample_event_width, ":", samples->pa_inuse - ndisp);
lim_newline(&lim);
} else if (!nontty) {
for (i = ndisp; i <= win.ws_row - margin_lines; i++) {
printf("~");
lim_newline(&lim);
}
}
if (do_redraw) {
lim_printf(&lim, "------ %*.*s %*.*s",
sample_event_width, sample_event_width, LINESTR,
SYMBOL_LEN, SYMBOL_LEN, LINESTR);
for (n = 0; n < ncpu; n++) {
lim_printf(&lim, " %*.*s",
sample_cpu_width[n], sample_cpu_width[n], LINESTR);
}
lim_newline(&lim);
} else {
printf("\n");
}
lim_printf(&lim, "Total %*u %-32.32s",
sample_event_width, sample_n_kern[opt_mode], "in-kernel");
for (n = 0; n < ncpu; n++) {
lim_printf(&lim, " %*u", sample_cpu_width[n],
sample_n_kern_per_cpu[opt_mode][n]);
}
if (opt_userland) {
lim_newline(&lim);
lim_printf(&lim, " %*u %-32.32s",
sample_event_width, sample_n_user[opt_mode], "userland");
for (n = 0; n < ncpu; n++) {
lim_printf(&lim, " %*u", sample_cpu_width[n],
sample_n_user_per_cpu[opt_mode][n]);
}
}
if (nontty)
printf("\n");
else
clr_to_eol();
}
__dead static void
tprof_top_usage(void)
{
fprintf(stderr, "%s top [-acu] [-e name[,scale] [-e ...]]"
" [-i interval]\n", getprogname());
exit(EXIT_FAILURE);
}
__dead void
tprof_top(int argc, char **argv)
{
tprof_param_t params[TPROF_MAXCOUNTERS];
struct itimerval it;
ssize_t tprof_bufsize, len;
u_int i;
int ch, ret;
char *tprof_buf, *p, *errmsg;
bool noinput = false;
memset(params, 0, sizeof(params));
nevent = 0;
while ((ch = getopt(argc, argv, "ace:i:L:u")) != -1) {
switch (ch) {
case 'a':
opt_mode = SAMPLE_MODE_ACCUMULATIVE;
break;
case 'c':
opt_showcounter = 1;
break;
case 'e':
if (tprof_parse_event(¶ms[nevent], optarg,
TPROF_PARSE_EVENT_F_ALLOWSCALE,
&eventname[nevent], &errmsg) != 0) {
die_errc(EXIT_FAILURE, 0, "%s", errmsg);
}
nevent++;
if (nevent > __arraycount(params) ||
nevent > ncounters)
die_errc(EXIT_FAILURE, 0,
"Too many events. Only a maximum of %d "
"counters can be used.", ncounters);
break;
case 'i':
top_interval = strtol(optarg, &p, 10);
if (*p != '\0' || top_interval <= 0)
die_errc(EXIT_FAILURE, 0,
"Bad/invalid interval: %s", optarg);
break;
case 'u':
opt_userland = 1;
break;
default:
tprof_top_usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0)
tprof_top_usage();
if (nevent == 0) {
const char *defaultevent = tprof_cycle_event_name();
if (defaultevent == NULL)
die_errc(EXIT_FAILURE, 0, "cpu not supported");
tprof_event_lookup(defaultevent, ¶ms[nevent]);
eventname[nevent] = defaultevent;
nevent++;
}
sample_init();
show_counters_alloc();
for (i = 0; i < nevent; i++) {
params[i].p_counter = i;
params[i].p_flags |= TPROF_PARAM_KERN | TPROF_PARAM_PROFILE;
if (opt_userland)
params[i].p_flags |= TPROF_PARAM_USER;
ret = ioctl(devfd, TPROF_IOC_CONFIGURE_EVENT, ¶ms[i]);
if (ret == -1)
die_errc(EXIT_FAILURE, errno,
"TPROF_IOC_CONFIGURE_EVENT: %s", eventname[i]);
}
tprof_countermask_t mask = TPROF_COUNTERMASK_ALL;
ret = ioctl(devfd, TPROF_IOC_START, &mask);
if (ret == -1)
die_errc(EXIT_FAILURE, errno, "TPROF_IOC_START");
ksyms = ksymload(&nksyms);
signal(SIGALRM, sigalrm_handler);
it.it_interval.tv_sec = it.it_value.tv_sec = top_interval;
it.it_interval.tv_usec = it.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &it, NULL);
sample_reset(true);
printf("collecting samples...");
fflush(stdout);
tprof_bufsize = sizeof(tprof_sample_t) * 1024 * 32;
tprof_buf = emalloc(tprof_bufsize);
do {
bool force_update = false;
while (sigalrm == 0 && !force_update) {
fd_set r;
int nfound;
char c;
FD_ZERO(&r);
if (!noinput)
FD_SET(STDIN_FILENO, &r);
FD_SET(devfd, &r);
nfound = select(devfd + 1, &r, NULL, NULL, NULL);
if (nfound == -1) {
if (errno == EINTR)
break;
die_errc(EXIT_FAILURE, errno, "select");
}
if (FD_ISSET(STDIN_FILENO, &r)) {
len = read(STDIN_FILENO, &c, 1);
if (len <= 0) {
noinput = true;
continue;
}
switch (c) {
case 0x0c: /* ^L */
do_redraw = true;
break;
case 'a':
/* toggle mode */
opt_mode = (opt_mode + 1) %
SAMPLE_MODE_NUM;
do_redraw = true;
break;
case 'c':
/* toggle mode */
opt_showcounter ^= 1;
do_redraw = true;
break;
case 'q':
goto done;
case 'z':
sample_reset(true);
break;
default:
continue;
}
force_update = true;
}
if (FD_ISSET(devfd, &r)) {
len = read(devfd, tprof_buf, tprof_bufsize);
if (len == -1 && errno != EINTR)
die_errc(EXIT_FAILURE, errno, "read");
if (len > 0) {
tprof_sample_t *s =
(tprof_sample_t *)tprof_buf;
while (s <
(tprof_sample_t *)(tprof_buf + len))
sample_collect(s++);
}
}
}
sigalrm = 0;
/* update screen */
sample_show();
fflush(stdout);
do_redraw = false;
if (force_update)
continue;
sample_reset(false);
} while (!nontty);
done:
die(0);
}
