tprof.c revision 1.15
1 /* $NetBSD: tprof.c,v 1.15 2022/12/01 00:40:05 ryo Exp $ */ 2 3 /* 4 * Copyright (c) 2018 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Maxime Villard. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c)2008 YAMAMOTO Takashi, 34 * All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * 2. Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in the 43 * documentation and/or other materials provided with the distribution. 44 * 45 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 46 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 47 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 48 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 49 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 50 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 51 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 52 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 53 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 54 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 55 * SUCH DAMAGE. 56 */ 57 58 #include <sys/cdefs.h> 59 #ifndef lint 60 __RCSID("$NetBSD: tprof.c,v 1.15 2022/12/01 00:40:05 ryo Exp $"); 61 #endif /* not lint */ 62 63 #include <sys/atomic.h> 64 #include <sys/ioctl.h> 65 #include <sys/sysctl.h> 66 #include <sys/wait.h> 67 68 #include <dev/tprof/tprof_ioctl.h> 69 70 #include <err.h> 71 #include <errno.h> 72 #include <fcntl.h> 73 #include <inttypes.h> 74 #include <math.h> 75 #include <pthread.h> 76 #include <signal.h> 77 #include <stdbool.h> 78 #include <stdio.h> 79 #include <stdlib.h> 80 #include <string.h> 81 #include <time.h> 82 #include <unistd.h> 83 #include <util.h> 84 #include "tprof.h" 85 86 #define _PATH_TPROF "/dev/tprof" 87 88 struct tprof_info tprof_info; 89 u_int ncounters; 90 int devfd; 91 int outfd; 92 int ncpu; 93 u_int nevent; 94 double interval = 0xffffffff; /* XXX */ 95 const char *eventname[TPROF_MAXCOUNTERS]; 96 u_int eventnamewidth[TPROF_MAXCOUNTERS]; 97 #define COUNTER_COLUMNS_WIDTH 11 98 99 static void tprof_list(int, char **); 100 static void tprof_monitor_common(bool, int, char **) __dead; 101 static void tprof_monitor(int, char **); 102 static void tprof_count(int, char **); 103 104 static struct cmdtab { 105 const char *label; 106 bool takesargs; 107 bool argsoptional; 108 void (*func)(int, char **); 109 } const tprof_cmdtab[] = { 110 { "list", false, false, tprof_list }, 111 { "monitor", true, false, tprof_monitor }, 112 { "count", true, false, tprof_count }, 113 { "analyze", true, true, tprof_analyze }, 114 { NULL, false, false, NULL }, 115 }; 116 117 __dead static void 118 usage(void) 119 { 120 121 fprintf(stderr, "%s op [arguments]\n", getprogname()); 122 fprintf(stderr, "\n"); 123 fprintf(stderr, "\tlist\n"); 124 fprintf(stderr, "\t\tList the available events.\n"); 125 fprintf(stderr, "\tmonitor -e name[:option] [-e ...] [-o outfile] command\n"); 126 fprintf(stderr, "\t\tMonitor the event 'name' with option 'option'\n" 127 "\t\tcounted during the execution of 'command'.\n"); 128 fprintf(stderr, "\tcount -e name[:option] [-e ...] [-i interval]" 129 " command\n"); 130 fprintf(stderr, "\t\tSame as monitor, but does not profile," 131 " only outputs a counter.\n"); 132 fprintf(stderr, "\tanalyze [-CkLPs] [-p pid] file\n"); 133 fprintf(stderr, "\t\tAnalyze the samples of the file 'file'.\n"); 134 135 exit(EXIT_FAILURE); 136 } 137 138 static int 139 getncpu(void) 140 { 141 size_t size; 142 int mib[2]; 143 144 mib[0] = CTL_HW; 145 mib[1] = HW_NCPU; 146 size = sizeof(ncpu); 147 if (sysctl(mib, 2, &ncpu, &size, NULL, 0) == -1) 148 ncpu = 1; 149 return ncpu; 150 } 151 152 static void * 153 process_samples(void *dummy) 154 { 155 156 for (;;) { 157 char buf[4096]; 158 const char *cp; 159 ssize_t ssz; 160 161 ssz = read(devfd, buf, sizeof(buf)); 162 if (ssz == -1) { 163 err(EXIT_FAILURE, "read"); 164 } 165 if (ssz == 0) { 166 break; 167 } 168 cp = buf; 169 while (ssz) { 170 ssize_t wsz; 171 172 wsz = write(outfd, cp, ssz); 173 if (wsz == -1) { 174 err(EXIT_FAILURE, "write"); 175 } 176 ssz -= wsz; 177 cp += wsz; 178 } 179 } 180 return NULL; 181 } 182 183 static void 184 show_counters(void) 185 { 186 unsigned int i; 187 int n, ret; 188 189 fprintf(stderr, " "); 190 for (i = 0; i < nevent; i++) 191 fprintf(stderr, " %*s", eventnamewidth[i], eventname[i]); 192 fprintf(stderr, "\n"); 193 194 for (n = 0; n < ncpu; n++) { 195 tprof_counts_t counts; 196 197 memset(&counts, 0, sizeof(counts)); 198 counts.c_cpu = n; 199 ret = ioctl(devfd, TPROF_IOC_GETCOUNTS, &counts); 200 if (ret == -1) 201 err(EXIT_FAILURE, "TPROF_IOC_GETCOUNTS"); 202 203 fprintf(stderr, "CPU%-3d", n); 204 for (i = 0; i < nevent; i++) { 205 fprintf(stderr, " %*"PRIu64, 206 eventnamewidth[i], counts.c_count[i]); 207 } 208 fprintf(stderr, "\n"); 209 } 210 } 211 212 /* XXX: avoid mixing with the output of the child process SIGINFO handler... */ 213 static void 214 output_delay(void) 215 { 216 struct timespec delay_ts; 217 218 delay_ts.tv_sec = 0; 219 delay_ts.tv_nsec = 100000000; 220 nanosleep(&delay_ts, NULL); 221 } 222 223 static void 224 siginfo_nothing(int signo) 225 { 226 __nothing; 227 } 228 229 static void 230 siginfo_showcount(int signo) 231 { 232 output_delay(); 233 show_counters(); 234 } 235 236 static void * 237 process_stat(void *arg) 238 { 239 unsigned int *done = arg; 240 double ival, fval; 241 struct timespec ts; 242 243 ival = floor(interval); 244 fval = (1000000000 * (interval - ival)); 245 ts.tv_sec = ival; 246 ts.tv_nsec = fval; 247 248 while (atomic_add_int_nv(done, 0) == 0) { 249 show_counters(); 250 nanosleep(&ts, NULL); 251 if (errno == EINTR) /* interrupted by SIGINFO? */ 252 output_delay(); 253 } 254 return NULL; 255 } 256 257 static void 258 tprof_list(int argc, char **argv) 259 { 260 tprof_event_list(); 261 } 262 263 static void 264 tprof_monitor_common(bool do_profile, int argc, char **argv) 265 { 266 const char *outfile = "tprof.out"; 267 struct tprof_stat ts; 268 tprof_param_t params[TPROF_MAXCOUNTERS]; 269 pid_t pid; 270 pthread_t pt; 271 int ret, ch, i; 272 char *tokens[2], *p; 273 tprof_countermask_t mask = TPROF_COUNTERMASK_ALL; 274 275 memset(params, 0, sizeof(params)); 276 277 while ((ch = getopt(argc, argv, do_profile ? "o:e:" : "e:i:")) != -1) { 278 switch (ch) { 279 case 'o': 280 outfile = optarg; 281 break; 282 case 'i': 283 interval = strtod(optarg, &p); 284 if (*p != '\0' || interval <= 0) 285 errx(EXIT_FAILURE, "Bad/invalid interval: %s", 286 optarg); 287 break; 288 case 'e': 289 p = estrdup(optarg); 290 tokens[0] = strtok(p, ":"); 291 tokens[1] = strtok(NULL, ":"); 292 tprof_event_lookup(tokens[0], ¶ms[nevent]); 293 294 if (tokens[1] == NULL) { 295 params[nevent].p_flags |= 296 (TPROF_PARAM_USER | TPROF_PARAM_KERN); 297 } else { 298 if (strchr(tokens[1], 'u')) 299 params[nevent].p_flags |= 300 TPROF_PARAM_USER; 301 if (strchr(tokens[1], 'k')) 302 params[nevent].p_flags |= 303 TPROF_PARAM_KERN; 304 } 305 eventname[nevent] = tokens[0]; 306 eventnamewidth[nevent] = strlen(eventname[nevent]); 307 if (eventnamewidth[nevent] < COUNTER_COLUMNS_WIDTH) 308 eventnamewidth[nevent] = COUNTER_COLUMNS_WIDTH; 309 nevent++; 310 if (nevent > __arraycount(params) || 311 nevent > ncounters) 312 errx(EXIT_FAILURE, "Too many events"); 313 break; 314 default: 315 usage(); 316 } 317 } 318 argc -= optind; 319 argv += optind; 320 if (argc == 0 || nevent == 0) { 321 usage(); 322 } 323 324 if (do_profile) { 325 outfd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, 0666); 326 if (outfd == -1) { 327 err(EXIT_FAILURE, "%s", outfile); 328 } 329 } 330 331 for (i = 0; i < (int)nevent; i++) { 332 params[i].p_counter = i; 333 if (do_profile) 334 params[i].p_flags |= TPROF_PARAM_PROFILE; 335 ret = ioctl(devfd, TPROF_IOC_CONFIGURE_EVENT, ¶ms[i]); 336 if (ret == -1) 337 err(EXIT_FAILURE, "TPROF_IOC_CONFIGURE_EVENT"); 338 } 339 340 ret = ioctl(devfd, TPROF_IOC_START, &mask); 341 if (ret == -1) { 342 err(EXIT_FAILURE, "TPROF_IOC_START"); 343 } 344 345 pid = fork(); 346 switch (pid) { 347 case -1: 348 err(EXIT_FAILURE, "fork"); 349 case 0: 350 close(devfd); 351 execvp(argv[0], argv); 352 _Exit(EXIT_FAILURE); 353 } 354 355 signal(SIGINT, SIG_IGN); 356 if (do_profile) 357 signal(SIGINFO, siginfo_showcount); 358 else 359 signal(SIGINFO, siginfo_nothing); 360 361 unsigned int done = 0; 362 if (do_profile) 363 ret = pthread_create(&pt, NULL, process_samples, NULL); 364 else 365 ret = pthread_create(&pt, NULL, process_stat, &done); 366 if (ret != 0) 367 errx(1, "pthread_create: %s", strerror(ret)); 368 369 for (;;) { 370 int status; 371 372 pid = wait4(-1, &status, 0, NULL); 373 if (pid == -1) { 374 if (errno == ECHILD) { 375 break; 376 } 377 err(EXIT_FAILURE, "wait4"); 378 } 379 if (pid != 0 && WIFEXITED(status)) { 380 break; 381 } 382 } 383 384 ret = ioctl(devfd, TPROF_IOC_STOP, &mask); 385 if (ret == -1) { 386 err(EXIT_FAILURE, "TPROF_IOC_STOP"); 387 } 388 389 if (!do_profile) { 390 atomic_add_int(&done, 1); /* terminate thread */ 391 kill(0, SIGINFO); 392 } 393 394 pthread_join(pt, NULL); 395 396 if (do_profile) { 397 ret = ioctl(devfd, TPROF_IOC_GETSTAT, &ts); 398 if (ret == -1) 399 err(EXIT_FAILURE, "TPROF_IOC_GETSTAT"); 400 401 fprintf(stderr, "\n%s statistics:\n", getprogname()); 402 fprintf(stderr, "\tsample %" PRIu64 "\n", ts.ts_sample); 403 fprintf(stderr, "\toverflow %" PRIu64 "\n", ts.ts_overflow); 404 fprintf(stderr, "\tbuf %" PRIu64 "\n", ts.ts_buf); 405 fprintf(stderr, "\temptybuf %" PRIu64 "\n", ts.ts_emptybuf); 406 fprintf(stderr, "\tdropbuf %" PRIu64 "\n", ts.ts_dropbuf); 407 fprintf(stderr, "\tdropbuf_sample %" PRIu64 "\n", ts.ts_dropbuf_sample); 408 409 fprintf(stderr, "\n"); 410 } 411 show_counters(); 412 413 exit(EXIT_SUCCESS); 414 } 415 416 static void 417 tprof_monitor(int argc, char **argv) 418 { 419 tprof_monitor_common(true, argc, argv); 420 } 421 422 static void 423 tprof_count(int argc, char **argv) 424 { 425 tprof_monitor_common(false, argc, argv); 426 } 427 428 int 429 main(int argc, char *argv[]) 430 { 431 const struct cmdtab *ct; 432 int ret; 433 434 getncpu(); 435 setprogname(argv[0]); 436 argv += 1, argc -= 1; 437 438 devfd = open(_PATH_TPROF, O_RDWR); 439 if (devfd == -1) { 440 err(EXIT_FAILURE, "%s", _PATH_TPROF); 441 } 442 443 ret = ioctl(devfd, TPROF_IOC_GETINFO, &tprof_info); 444 if (ret == -1) { 445 err(EXIT_FAILURE, "TPROF_IOC_GETINFO"); 446 } 447 if (tprof_info.ti_version != TPROF_VERSION) { 448 errx(EXIT_FAILURE, "version mismatch: version=%d, expected=%d", 449 tprof_info.ti_version, TPROF_VERSION); 450 } 451 if (tprof_event_init(tprof_info.ti_ident) == -1) { 452 errx(EXIT_FAILURE, "cpu not supported"); 453 } 454 455 ret = ioctl(devfd, TPROF_IOC_GETNCOUNTERS, &ncounters); 456 if (ret == -1) { 457 err(EXIT_FAILURE, "TPROF_IOC_GETNCOUNTERS"); 458 } 459 if (ncounters == 0) { 460 errx(EXIT_FAILURE, "no available counters"); 461 } 462 463 if (argc == 0) 464 usage(); 465 466 for (ct = tprof_cmdtab; ct->label != NULL; ct++) { 467 if (strcmp(argv[0], ct->label) == 0) { 468 if (!ct->argsoptional && 469 ((ct->takesargs == 0) ^ (argv[1] == NULL))) 470 { 471 usage(); 472 } 473 (*ct->func)(argc, argv); 474 break; 475 } 476 } 477 if (ct->label == NULL) { 478 usage(); 479 } 480 } 481
Indexes created Wed Sep 24 05:09:52 GMT 2025