/*      $NetBSD: tprof.c,v 1.21 2023/04/17 08:37:24 msaitoh Exp $       */

/*
* Copyright (c) 2018 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Maxime Villard.
*
* 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

/*
* Copyright (c)2008 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.c,v 1.21 2023/04/17 08:37:24 msaitoh Exp $");
#endif /* not lint */

#include <sys/atomic.h>
#include <sys/ioctl.h>
#include <sys/sysctl.h>
#include <sys/wait.h>

#include <dev/tprof/tprof_ioctl.h>

#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <math.h>
#include <pthread.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <util.h>
#include "tprof.h"

#define _PATH_TPROF     "/dev/tprof"

struct tprof_info tprof_info;
u_int ncounters;
int devfd;
int outfd;
int ncpu;
u_int nevent;
double interval = 0xffffffff;   /* XXX */
const char *eventname[TPROF_MAXCOUNTERS];
u_int eventnamewidth[TPROF_MAXCOUNTERS];
#define COUNTER_COLUMNS_WIDTH   11

static void tprof_list(int, char **);
static void tprof_monitor_common(bool, int, char **) __dead;
static void tprof_monitor(int, char **) __dead;
static void tprof_count(int, char **) __dead;

static struct cmdtab {
       const char *label;
       bool takesargs;
       bool argsoptional;
       void (*func)(int, char **);
} const tprof_cmdtab[] = {
       { "list",       false, false, tprof_list },
       { "monitor",    true,  false, tprof_monitor },
       { "count",      true,  false, tprof_count },
       { "analyze",    true,  true,  tprof_analyze },
       { "top",        true,  true,  tprof_top },
       { NULL,         false, false, NULL },
};

__dead static void
usage(void)
{

       fprintf(stderr, "%s op [arguments]\n", getprogname());
       fprintf(stderr, "\n");
       fprintf(stderr, "\tlist\n");
       fprintf(stderr, "\t\tList the available events.\n");
       fprintf(stderr, "\tmonitor -e name[:option] [-e ...] [-o outfile]"
           " command\n");
       fprintf(stderr, "\t\tMonitor the event 'name' with option 'option'\n"
           "\t\tcounted during the execution of 'command'.\n");
       fprintf(stderr, "\tcount -e name[:option] [-e ...] [-i interval]"
           " command\n");
       fprintf(stderr, "\t\tSame as monitor, but does not profile,"
           " only outputs a counter.\n");
       fprintf(stderr, "\tanalyze [-CkLPs] [-p pid] file\n");
       fprintf(stderr, "\t\tAnalyze the samples of the file 'file'.\n");
       fprintf(stderr, "\ttop [-e name [-e ...]] [-i interval] [-acu]\n");
       fprintf(stderr, "\t\tDisplay profiling results in real-time.\n");
       exit(EXIT_FAILURE);
}

static int
getncpu(void)
{
       size_t size;
       int mib[2];

       mib[0] = CTL_HW;
       mib[1] = HW_NCPU;
       size = sizeof(ncpu);
       if (sysctl(mib, 2, &ncpu, &size, NULL, 0) == -1)
               ncpu = 1;
       return ncpu;
}

static void *
process_samples(void *dummy)
{

       for (;;) {
               char buf[4096];
               const char *cp;
               ssize_t ssz;

               ssz = read(devfd, buf, sizeof(buf));
               if (ssz == -1) {
                       err(EXIT_FAILURE, "read");
               }
               if (ssz == 0) {
                       break;
               }
               cp = buf;
               while (ssz) {
                       ssize_t wsz;

                       wsz = write(outfd, cp, ssz);
                       if (wsz == -1) {
                               err(EXIT_FAILURE, "write");
                       }
                       ssz -= wsz;
                       cp += wsz;
               }
       }
       return NULL;
}

static void
show_counters(void)
{
       unsigned int i;
       int n, ret;

       fprintf(stderr, "      ");
       for (i = 0; i < nevent; i++)
               fprintf(stderr, " %*s", eventnamewidth[i], eventname[i]);
       fprintf(stderr, "\n");

       for (n = 0; n < ncpu; n++) {
               tprof_counts_t counts;

               memset(&counts, 0, sizeof(counts));
               counts.c_cpu = n;
               ret = ioctl(devfd, TPROF_IOC_GETCOUNTS, &counts);
               if (ret == -1)
                       err(EXIT_FAILURE, "TPROF_IOC_GETCOUNTS");

               fprintf(stderr, "CPU%-3d", n);
               for (i = 0; i < nevent; i++) {
                       fprintf(stderr, " %*"PRIu64,
                           eventnamewidth[i], counts.c_count[i]);
               }
               fprintf(stderr, "\n");
       }
}

/* XXX: avoid mixing with the output of the child process SIGINFO handler... */
static void
output_delay(void)
{
       struct timespec delay_ts;

       delay_ts.tv_sec = 0;
       delay_ts.tv_nsec = 100000000;
       nanosleep(&delay_ts, NULL);
}

static void
siginfo_nothing(int signo)
{
       __nothing;
}

static void
siginfo_showcount(int signo)
{
       output_delay();
       show_counters();
}

static void *
process_stat(void *arg)
{
       unsigned int *done = arg;
       double ival, fval;
       struct timespec ts;

       ival = floor(interval);
       fval = (1000000000 * (interval - ival));
       ts.tv_sec = ival;
       ts.tv_nsec = fval;

       while (atomic_add_int_nv(done, 0) == 0) {
               show_counters();
               nanosleep(&ts, NULL);
               if (errno == EINTR)     /* interrupted by SIGINFO? */
                       output_delay();
       }
       return NULL;
}

static void
tprof_list(int argc, char **argv)
{
       const char *defaultevent = tprof_cycle_event_name();

       printf("%u events can be counted at the same time.\n", ncounters);
       if (defaultevent != NULL)
               printf("The default counter for monitor and top command is "
                   "\"%s\".\n", defaultevent);
       tprof_event_list();
}

int
tprof_parse_event(tprof_param_t *param, const char *str, uint32_t flags,
   const char **eventnamep, char **errmsgp)
{
       double d;
       uint64_t n;
       int error = 0;
       char *p, *event = NULL, *opt = NULL, *scale = NULL;
       bool allow_option, allow_scale;
       static char errmsgbuf[128];

       allow_option = flags & TPROF_PARSE_EVENT_F_ALLOWOPTION;
       allow_scale = flags & TPROF_PARSE_EVENT_F_ALLOWSCALE;

       p = estrdup(str);
       event = p;
       if (allow_option) {
               opt = strchr(p, ':');
               if (opt != NULL) {
                       *opt++ = '\0';
                       p = opt;
               }
       }
       if (allow_scale) {
               scale = strchr(p, ',');
               if (scale != NULL)
                       *scale++ = '\0';
       }

       tprof_event_lookup(event, param);

       if (opt != NULL) {
               while (*opt != '\0') {
                       switch (*opt) {
                       case 'u':
                               param->p_flags |= TPROF_PARAM_USER;
                               break;
                       case 'k':
                               param->p_flags |= TPROF_PARAM_KERN;
                               break;
                       default:
                               error = -1;
                               snprintf(errmsgbuf, sizeof(errmsgbuf),
                                   "invalid option: '%c'", *opt);
                               goto done;
                       }
                       opt++;
               }
       } else if (allow_option) {
               param->p_flags |= TPROF_PARAM_USER;
               param->p_flags |= TPROF_PARAM_KERN;
       }

       if (scale != NULL) {
               if (*scale == '=') {
                       scale++;
                       n = strtoull(scale, &p, 0);
                       if (*p != '\0') {
                               error = -1;
                       } else {
                               param->p_value2 = n;
                               param->p_flags |=
                                   TPROF_PARAM_VALUE2_TRIGGERCOUNT;
                       }
               } else {
                       if (strncasecmp("0x", scale, 2) == 0)
                               d = strtol(scale, &p, 0);
                       else
                               d = strtod(scale, &p);
                       if (*p != '\0' || d <= 0) {
                               error = -1;
                       } else {
                               param->p_value2 = 0x100000000ULL / d;
                               param->p_flags |= TPROF_PARAM_VALUE2_SCALE;
                       }
               }

               if (error != 0) {
                       snprintf(errmsgbuf, sizeof(errmsgbuf),
                           "invalid scale: %s", scale);
                       goto done;
               }
       }

done:
       if (eventnamep != NULL)
               *eventnamep = event;
       if (error != 0 && errmsgp != NULL)
               *errmsgp = errmsgbuf;
       return error;
}

const char *
tprof_cycle_event_name(void)
{
       const char *cycleevent;

       switch (tprof_info.ti_ident) {
       case TPROF_IDENT_INTEL_GENERIC:
               cycleevent = "unhalted-core-cycles";
               break;
       case TPROF_IDENT_AMD_GENERIC:
               cycleevent = "LsNotHaltedCyc";
               break;
       case TPROF_IDENT_ARMV8_GENERIC:
       case TPROF_IDENT_ARMV7_GENERIC:
               cycleevent = "CPU_CYCLES";
               break;
       default:
               cycleevent = NULL;
               break;
       }
       return cycleevent;
}

static void
tprof_monitor_common(bool do_profile, int argc, char **argv)
{
       const char *outfile = "tprof.out";
       struct tprof_stat ts;
       tprof_param_t params[TPROF_MAXCOUNTERS];
       pid_t pid;
       pthread_t pt;
       int ret, ch, i;
       char *p, *errmsg;
       tprof_countermask_t mask = TPROF_COUNTERMASK_ALL;

       memset(params, 0, sizeof(params));

       while ((ch = getopt(argc, argv, do_profile ? "o:e:" : "e:i:")) != -1) {
               switch (ch) {
               case 'o':
                       outfile = optarg;
                       break;
               case 'i':
                       interval = strtod(optarg, &p);
                       if (*p != '\0' || interval <= 0)
                               errx(EXIT_FAILURE, "Bad/invalid interval: %s",
                                   optarg);
                       break;
               case 'e':
                       if (tprof_parse_event(&params[nevent], optarg,
                           TPROF_PARSE_EVENT_F_ALLOWOPTION |
                           (do_profile ? TPROF_PARSE_EVENT_F_ALLOWSCALE : 0),
                           &eventname[nevent], &errmsg) != 0) {
                               errx(EXIT_FAILURE, "%s", errmsg);
                       }
                       eventnamewidth[nevent] = strlen(eventname[nevent]);
                       if (eventnamewidth[nevent] < COUNTER_COLUMNS_WIDTH)
                               eventnamewidth[nevent] = COUNTER_COLUMNS_WIDTH;
                       nevent++;
                       if (nevent > __arraycount(params) ||
                           nevent > ncounters)
                               errx(EXIT_FAILURE, "Too many events. Only a"
                                   " maximum of %d counters can be used.",
                                   ncounters);
                       break;
               default:
                       usage();
               }
       }
       argc -= optind;
       argv += optind;
       if (argc == 0)
               usage();
       if (nevent == 0) {
               const char *defaultevent = tprof_cycle_event_name();
               if (defaultevent == NULL)
                       errx(EXIT_FAILURE, "cpu not supported");

               tprof_event_lookup(defaultevent, &params[nevent]);
               eventname[nevent] = defaultevent;
               params[nevent].p_flags |= TPROF_PARAM_KERN;
               nevent++;
       }

       if (do_profile) {
               outfd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666);
               if (outfd == -1) {
                       err(EXIT_FAILURE, "%s", outfile);
               }
       }

       for (i = 0; i < (int)nevent; i++) {
               params[i].p_counter = i;
               if (do_profile)
                       params[i].p_flags |= TPROF_PARAM_PROFILE;
               ret = ioctl(devfd, TPROF_IOC_CONFIGURE_EVENT, &params[i]);
               if (ret == -1) {
                       err(EXIT_FAILURE, "TPROF_IOC_CONFIGURE_EVENT: %s",
                           eventname[i]);
               }
       }

       ret = ioctl(devfd, TPROF_IOC_START, &mask);
       if (ret == -1) {
               err(EXIT_FAILURE, "TPROF_IOC_START");
       }

       pid = fork();
       switch (pid) {
       case -1:
               err(EXIT_FAILURE, "fork");
       case 0:
               close(devfd);
               execvp(argv[0], argv);
               _Exit(EXIT_FAILURE);
       }

       signal(SIGINT, SIG_IGN);
       if (do_profile)
               signal(SIGINFO, siginfo_showcount);
       else
               signal(SIGINFO, siginfo_nothing);

       unsigned int done = 0;
       if (do_profile)
               ret = pthread_create(&pt, NULL, process_samples, NULL);
       else
               ret = pthread_create(&pt, NULL, process_stat, &done);
       if (ret != 0)
               errx(1, "pthread_create: %s", strerror(ret));

       for (;;) {
               int status;

               pid = wait4(-1, &status, 0, NULL);
               if (pid == -1) {
                       if (errno == ECHILD) {
                               break;
                       }
                       err(EXIT_FAILURE, "wait4");
               }
               if (pid != 0 && WIFEXITED(status)) {
                       break;
               }
       }

       ret = ioctl(devfd, TPROF_IOC_STOP, &mask);
       if (ret == -1) {
               err(EXIT_FAILURE, "TPROF_IOC_STOP");
       }

       if (!do_profile) {
               atomic_add_int(&done, 1);       /* terminate thread */
               kill(0, SIGINFO);
       }

       pthread_join(pt, NULL);

       if (do_profile) {
               ret = ioctl(devfd, TPROF_IOC_GETSTAT, &ts);
               if (ret == -1)
                       err(EXIT_FAILURE, "TPROF_IOC_GETSTAT");

               fprintf(stderr, "\n%s statistics:\n", getprogname());
               fprintf(stderr, "\tsample %" PRIu64 "\n", ts.ts_sample);
               fprintf(stderr, "\toverflow %" PRIu64 "\n", ts.ts_overflow);
               fprintf(stderr, "\tbuf %" PRIu64 "\n", ts.ts_buf);
               fprintf(stderr, "\temptybuf %" PRIu64 "\n", ts.ts_emptybuf);
               fprintf(stderr, "\tdropbuf %" PRIu64 "\n", ts.ts_dropbuf);
               fprintf(stderr, "\tdropbuf_sample %" PRIu64 "\n",
                   ts.ts_dropbuf_sample);

               fprintf(stderr, "\n");
       }
       show_counters();

       exit(EXIT_SUCCESS);
}

static void
tprof_monitor(int argc, char **argv)
{
       tprof_monitor_common(true, argc, argv);
}

static void
tprof_count(int argc, char **argv)
{
       tprof_monitor_common(false, argc, argv);
}

int
main(int argc, char *argv[])
{
       const struct cmdtab *ct;
       int ret;

       getncpu();
       setprogname(argv[0]);
       argv += 1, argc -= 1;

       devfd = open(_PATH_TPROF, O_RDWR);
       if (devfd == -1) {
               err(EXIT_FAILURE, "%s", _PATH_TPROF);
       }

       ret = ioctl(devfd, TPROF_IOC_GETINFO, &tprof_info);
       if (ret == -1) {
               err(EXIT_FAILURE, "TPROF_IOC_GETINFO");
       }
       if (tprof_info.ti_version != TPROF_VERSION) {
               errx(EXIT_FAILURE, "version mismatch: version=%d, expected=%d",
                   tprof_info.ti_version, TPROF_VERSION);
       }
       if (tprof_event_init(tprof_info.ti_ident) == -1) {
               errx(EXIT_FAILURE, "cpu not supported");
       }

       ret = ioctl(devfd, TPROF_IOC_GETNCOUNTERS, &ncounters);
       if (ret == -1) {
               err(EXIT_FAILURE, "TPROF_IOC_GETNCOUNTERS");
       }
       if (ncounters == 0) {
               errx(EXIT_FAILURE, "no available counters");
       }

       if (argc == 0)
               usage();

       for (ct = tprof_cmdtab; ct->label != NULL; ct++) {
               if (strcmp(argv[0], ct->label) == 0) {
                       if (!ct->argsoptional &&
                           ((ct->takesargs == 0) ^ (argv[1] == NULL)))
                       {
                               usage();
                       }
                       (*ct->func)(argc, argv);
                       break;
               }
       }
       if (ct->label == NULL) {
               usage();
       }
}

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.