1 /* $NetBSD: kgmon.c,v 1.28 2025/06/28 07:04:52 andvar Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1992, 1993 5 * The Regents of the University of California. 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 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __COPYRIGHT("@(#) Copyright (c) 1983, 1992, 1993\ 35 The Regents of the University of California. All rights reserved."); 36 #endif /* not lint */ 37 38 #ifndef lint 39 #if 0 40 static char sccsid[] = "from: @(#)kgmon.c 8.1 (Berkeley) 6/6/93"; 41 #else 42 __RCSID("$NetBSD: kgmon.c,v 1.28 2025/06/28 07:04:52 andvar Exp $"); 43 #endif 44 #endif /* not lint */ 45 46 #include <sys/param.h> 47 #include <sys/file.h> 48 #include <sys/sysctl.h> 49 #include <sys/gmon.h> 50 51 #include <ctype.h> 52 #include <errno.h> 53 #include <kvm.h> 54 #include <err.h> 55 #include <limits.h> 56 #include <nlist.h> 57 #include <stdio.h> 58 #include <stdlib.h> 59 #include <string.h> 60 #include <unistd.h> 61 62 static struct nlist nl[] = { 63 #define N_GMONPARAM 0 64 { "__gmonparam", 0, 0, 0, 0 }, 65 #define N_PROFHZ 1 66 { "_profhz", 0, 0, 0, 0 }, 67 { 0, 0, 0, 0, 0 } 68 }; 69 70 struct kvmvars { 71 kvm_t *kd; 72 struct gmonparam gpm; 73 }; 74 75 static int ncpu_mib[2] = { CTL_HW, HW_NCPU }; 76 static int bflag, cflag_all, hflag, kflag, rflag, pflag; 77 static int debug = 0; 78 static void setprof(struct kvmvars *kvp, int state, int cpuid); 79 static void dumpstate(struct kvmvars *kvp, int cpuid); 80 static void reset(struct kvmvars *kvp, int cpuid); 81 static int openfiles(char *, char *, struct kvmvars *); 82 static int getprof(struct kvmvars *, int); 83 static void kern_readonly(int); 84 static int getprofhz(struct kvmvars *); 85 86 int 87 main(int argc, char **argv) 88 { 89 int ch, mode, disp, accessmode, ncpu, cpuid = -1; 90 struct kvmvars kvmvars; 91 size_t size; 92 char *sys, *kmemf; 93 char on_cpu[sizeof(" on cpuXXXXXXXXX")]; 94 95 size = sizeof(ncpu); 96 if (sysctl(ncpu_mib, 2, &ncpu, &size, NULL, 0) < 0) 97 ncpu = 1; 98 99 setprogname(argv[0]); 100 (void)seteuid(getuid()); 101 kmemf = NULL; 102 sys = NULL; 103 while ((ch = getopt(argc, argv, "M:N:bc:dhpr")) != -1) { 104 switch((char)ch) { 105 106 case 'M': 107 kmemf = optarg; 108 kflag = 1; 109 break; 110 111 case 'N': 112 sys = optarg; 113 break; 114 115 case 'b': 116 bflag = 1; 117 break; 118 119 case 'c': 120 if (strcmp(optarg, "all") == 0) { 121 cflag_all = 1; 122 cpuid = 0; 123 } else { 124 cpuid = strtol(optarg, NULL, 10); 125 if (cpuid >= ncpu) 126 errx(1, "illegal CPU id %s", optarg); 127 } 128 break; 129 130 case 'h': 131 hflag = 1; 132 break; 133 134 case 'p': 135 pflag = 1; 136 break; 137 138 case 'r': 139 rflag = 1; 140 break; 141 142 case 'd': 143 debug = 1; 144 break; 145 146 default: 147 (void)fprintf(stderr, 148 "usage: %s [-bdhrp] [-c cpuid] [-M core] [-N system]\n", 149 getprogname()); 150 exit(1); 151 } 152 } 153 argc -= optind; 154 argv += optind; 155 156 #define BACKWARD_COMPATIBILITY 157 #ifdef BACKWARD_COMPATIBILITY 158 if (*argv) { 159 sys = *argv; 160 if (*++argv) { 161 kmemf = *argv; 162 ++kflag; 163 } 164 } 165 #endif 166 accessmode = openfiles(sys, kmemf, &kvmvars); 167 168 do { 169 if (cpuid == -1) 170 on_cpu[0] = '\0'; 171 else 172 snprintf(on_cpu, sizeof(on_cpu), " on cpu%d", cpuid); 173 174 mode = getprof(&kvmvars, cpuid); 175 if (hflag) 176 disp = GMON_PROF_OFF; 177 else if (bflag) 178 disp = GMON_PROF_ON; 179 else 180 disp = mode; 181 if (pflag) 182 dumpstate(&kvmvars, cpuid); 183 if (rflag) 184 reset(&kvmvars, cpuid); 185 if (accessmode == O_RDWR) 186 setprof(&kvmvars, disp, cpuid); 187 (void)fprintf(stdout, "%s: kernel profiling is %s%s.\n", 188 getprogname(), disp == GMON_PROF_OFF ? "off" : "running", 189 on_cpu); 190 191 } while (cflag_all && ++cpuid < ncpu); 192 return (0); 193 } 194 195 /* 196 * Check that profiling is enabled and open any necessary files. 197 */ 198 static int 199 openfiles(char *sys, char *kmemf, struct kvmvars *kvp) 200 { 201 int mib[3], state, openmode; 202 size_t size; 203 char errbuf[_POSIX2_LINE_MAX]; 204 205 if (!kflag) { 206 mib[0] = CTL_KERN; 207 mib[1] = KERN_PROF; 208 mib[2] = GPROF_STATE; 209 size = sizeof state; 210 if (sysctl(mib, 3, &state, &size, NULL, 0) < 0) 211 err(EXIT_FAILURE, "profiling not defined in kernel"); 212 if (!(bflag || hflag || rflag || 213 (pflag && state == GMON_PROF_ON))) 214 return (O_RDONLY); 215 (void)seteuid(0); 216 if (sysctl(mib, 3, NULL, NULL, &state, size) >= 0) 217 return (O_RDWR); 218 (void)seteuid(getuid()); 219 kern_readonly(state); 220 return (O_RDONLY); 221 } 222 openmode = (bflag || hflag || pflag || rflag) ? O_RDWR : O_RDONLY; 223 kvp->kd = kvm_openfiles(sys, kmemf, NULL, openmode, errbuf); 224 if (kvp->kd == NULL) { 225 if (openmode == O_RDWR) { 226 openmode = O_RDONLY; 227 kvp->kd = kvm_openfiles(sys, kmemf, NULL, O_RDONLY, 228 errbuf); 229 } 230 if (kvp->kd == NULL) 231 errx(EXIT_FAILURE, "kvm_openfiles: %s", errbuf); 232 kern_readonly(GMON_PROF_ON); 233 } 234 if (kvm_nlist(kvp->kd, nl) < 0) 235 errx(EXIT_FAILURE, "%s: no namelist", sys); 236 if (!nl[N_GMONPARAM].n_value) 237 errx(EXIT_FAILURE, "profiling not defined in kernel"); 238 return (openmode); 239 } 240 241 /* 242 * Suppress options that require a writable kernel. 243 */ 244 static void 245 kern_readonly(int mode) 246 { 247 248 (void)fprintf(stderr, "%s: kernel read-only: ", getprogname()); 249 if (pflag && mode == GMON_PROF_ON) 250 (void)fprintf(stderr, "data may be inconsistent\n"); 251 if (rflag) 252 (void)fprintf(stderr, "-r suppressed\n"); 253 if (bflag) 254 (void)fprintf(stderr, "-b suppressed\n"); 255 if (hflag) 256 (void)fprintf(stderr, "-h suppressed\n"); 257 rflag = bflag = hflag = 0; 258 } 259 260 /* 261 * Get the state of kernel profiling. 262 */ 263 static int 264 getprof(struct kvmvars *kvp, int cpuid) 265 { 266 int mib[5], miblen, mibparam; 267 size_t size; 268 269 if (kflag) { 270 size = kvm_read(kvp->kd, nl[N_GMONPARAM].n_value, &kvp->gpm, 271 sizeof kvp->gpm); 272 } else { 273 mib[0] = CTL_KERN; 274 mib[1] = KERN_PROF; 275 if (cpuid < 0) { 276 mibparam = 2; 277 miblen = 3; 278 } else { 279 mib[2] = GPROF_PERCPU; 280 mib[3] = cpuid; 281 mibparam = 4; 282 miblen = 5; 283 } 284 mib[mibparam] = GPROF_GMONPARAM; 285 size = sizeof kvp->gpm; 286 if (sysctl(mib, miblen, &kvp->gpm, &size, NULL, 0) < 0) 287 size = 0; 288 } 289 if (size != sizeof kvp->gpm) 290 errx(EXIT_FAILURE, "cannot get gmonparam: %s", 291 kflag ? kvm_geterr(kvp->kd) : strerror(errno)); 292 return (kvp->gpm.state); 293 } 294 295 /* 296 * Enable or disable kernel profiling according to the state variable. 297 */ 298 static void 299 setprof(struct kvmvars *kvp, int state, int cpuid) 300 { 301 struct gmonparam *p = (struct gmonparam *)nl[N_GMONPARAM].n_value; 302 int mib[5], miblen, mibparam, oldstate; 303 size_t sz; 304 305 sz = sizeof(state); 306 if (!kflag) { 307 mib[0] = CTL_KERN; 308 mib[1] = KERN_PROF; 309 if (cpuid < 0) { 310 mibparam = 2; 311 miblen = 3; 312 } else { 313 mib[2] = GPROF_PERCPU; 314 mib[3] = cpuid; 315 mibparam = 4; 316 miblen = 5; 317 } 318 mib[mibparam] = GPROF_STATE; 319 if (sysctl(mib, miblen, &oldstate, &sz, NULL, 0) < 0) 320 goto bad; 321 if (oldstate == state) 322 return; 323 (void)seteuid(0); 324 if (sysctl(mib, miblen, NULL, NULL, &state, sz) >= 0) { 325 (void)seteuid(getuid()); 326 return; 327 } 328 (void)seteuid(getuid()); 329 } else if ((size_t)kvm_write(kvp->kd, (u_long)&p->state, (void *)&state, sz) 330 == sz) 331 return; 332 bad: 333 warnx("cannot turn profiling %s", state == GMON_PROF_OFF ? 334 "off" : "on"); 335 } 336 337 /* 338 * Build the gmon.out file. 339 */ 340 static void 341 dumpstate(struct kvmvars *kvp, int cpuid) 342 { 343 FILE *fp; 344 struct rawarc rawarc; 345 struct tostruct *tos; 346 u_long frompc; 347 u_short *froms, *tickbuf; 348 int mib[5], miblen, mibparam; 349 size_t i; 350 struct gmonhdr h; 351 int fromindex, endfrom, toindex; 352 size_t kcountsize; 353 char gmon_out[sizeof("gmon-XXXXXXXXXXX.out")]; 354 355 mib[0] = CTL_KERN; 356 mib[1] = KERN_PROF; 357 if (cpuid < 0) { 358 mibparam = 2; 359 miblen = 3; 360 } else { 361 mib[2] = GPROF_PERCPU; 362 mib[3] = cpuid; 363 mibparam = 4; 364 miblen = 5; 365 } 366 367 setprof(kvp, GMON_PROF_OFF, cpuid); 368 if (cpuid < 0) 369 strlcpy(gmon_out, "gmon.out", sizeof(gmon_out)); 370 else 371 snprintf(gmon_out, sizeof(gmon_out), "gmon-%d.out", cpuid); 372 373 fp = fopen(gmon_out, "w"); 374 if (fp == NULL) { 375 warn("cannot open `%s'", gmon_out); 376 return; 377 } 378 379 /* 380 * Build the gmon header and write it to a file. 381 */ 382 bzero(&h, sizeof(h)); 383 h.lpc = kvp->gpm.lowpc; 384 h.hpc = kvp->gpm.highpc; 385 h.ncnt = kvp->gpm.kcountsize + sizeof(h); 386 h.version = GMONVERSION; 387 h.profrate = getprofhz(kvp); 388 if (fwrite(&h, sizeof(h), 1, fp) != 1) 389 err(EXIT_FAILURE, "writing header to gmon.out"); 390 391 kcountsize = (size_t)kvp->gpm.kcountsize; 392 393 /* 394 * Write out the tick buffer. 395 */ 396 if ((tickbuf = malloc(kcountsize)) == NULL) 397 err(EXIT_FAILURE, "Cannot allocate %zu kcount space", 398 kcountsize); 399 if (kflag) { 400 i = kvm_read(kvp->kd, (u_long)kvp->gpm.kcount, tickbuf, 401 kcountsize); 402 } else { 403 mib[mibparam] = GPROF_COUNT; 404 i = kcountsize; 405 if (sysctl(mib, miblen, tickbuf, &i, NULL, 0) < 0) 406 i = 0; 407 } 408 if (i != kcountsize) 409 errx(EXIT_FAILURE, "read ticks: read %zu, got %zu: %s", 410 kcountsize, i, 411 kflag ? kvm_geterr(kvp->kd) : strerror(errno)); 412 if ((fwrite(tickbuf, kcountsize, 1, fp)) != 1) 413 err(EXIT_FAILURE, "writing ticks to gmon.out"); 414 free(tickbuf); 415 416 /* 417 * Write out the arc info. 418 */ 419 if ((froms = malloc((size_t)kvp->gpm.fromssize)) == NULL) 420 err(EXIT_FAILURE, "cannot allocate %zu froms space", 421 (size_t)kvp->gpm.fromssize); 422 if (kflag) { 423 i = kvm_read(kvp->kd, (u_long)kvp->gpm.froms, froms, 424 (size_t)kvp->gpm.fromssize); 425 } else { 426 mib[mibparam] = GPROF_FROMS; 427 i = kvp->gpm.fromssize; 428 if (sysctl(mib, miblen, froms, &i, NULL, 0) < 0) 429 i = 0; 430 } 431 if (i != kvp->gpm.fromssize) 432 errx(EXIT_FAILURE, "read froms: read %lu, got %lu: %s", 433 kvp->gpm.fromssize, (u_long)i, 434 kflag ? kvm_geterr(kvp->kd) : strerror(errno)); 435 if ((tos = malloc((size_t)kvp->gpm.tossize)) == NULL) 436 err(EXIT_FAILURE, "cannot allocate %zu tos space", 437 (size_t)kvp->gpm.tossize); 438 if (kflag) { 439 i = kvm_read(kvp->kd, (u_long)kvp->gpm.tos, (void *)tos, 440 (size_t)kvp->gpm.tossize); 441 } else { 442 mib[mibparam] = GPROF_TOS; 443 i = kvp->gpm.tossize; 444 if (sysctl(mib, miblen, tos, &i, NULL, 0) < 0) 445 i = 0; 446 } 447 if (i != kvp->gpm.tossize) 448 errx(EXIT_FAILURE, "read tos: read %zu, got %zu: %s", 449 (size_t)kvp->gpm.tossize, i, 450 kflag ? kvm_geterr(kvp->kd) : strerror(errno)); 451 if (debug) 452 (void)fprintf(stderr, "%s: lowpc 0x%lx, textsize 0x%lx\n", 453 getprogname(), kvp->gpm.lowpc, kvp->gpm.textsize); 454 endfrom = kvp->gpm.fromssize / sizeof(*froms); 455 for (fromindex = 0; fromindex < endfrom; ++fromindex) { 456 if (froms[fromindex] == 0) 457 continue; 458 frompc = (u_long)kvp->gpm.lowpc + 459 (fromindex * kvp->gpm.hashfraction * sizeof(*froms)); 460 for (toindex = froms[fromindex]; toindex != 0; 461 toindex = tos[toindex].link) { 462 if (debug) 463 (void)fprintf(stderr, 464 "%s: [mcleanup] frompc 0x%lx selfpc 0x%lx count %ld\n", 465 getprogname(), frompc, tos[toindex].selfpc, 466 tos[toindex].count); 467 rawarc.raw_frompc = frompc; 468 rawarc.raw_selfpc = (u_long)tos[toindex].selfpc; 469 rawarc.raw_count = tos[toindex].count; 470 if (fwrite(&rawarc, sizeof(rawarc), 1,fp) != 1){ 471 err(EXIT_FAILURE, 472 "writing raw arc to gmon.out"); 473 } 474 } 475 } 476 free(tos); 477 (void)fclose(fp); 478 } 479 480 /* 481 * Get the profiling rate. 482 */ 483 static int 484 getprofhz(struct kvmvars *kvp) 485 { 486 int mib[2], profrate; 487 size_t size; 488 struct clockinfo clockrate; 489 490 if (kflag) { 491 profrate = 1; 492 if (kvm_read(kvp->kd, nl[N_PROFHZ].n_value, &profrate, 493 sizeof profrate) != sizeof profrate) 494 warnx("get clockrate: %s", kvm_geterr(kvp->kd)); 495 return (profrate); 496 } 497 mib[0] = CTL_KERN; 498 mib[1] = KERN_CLOCKRATE; 499 clockrate.profhz = 1; 500 size = sizeof clockrate; 501 if (sysctl(mib, 2, &clockrate, &size, NULL, 0) < 0) 502 warn("get clockrate"); 503 return (clockrate.profhz); 504 } 505 506 /* 507 * Reset the kernel profiling date structures. 508 */ 509 static void 510 reset(struct kvmvars *kvp, int cpuid) 511 { 512 char *zbuf; 513 size_t biggest; 514 int mib[5], miblen, mibparam; 515 516 mib[0] = CTL_KERN; 517 mib[1] = KERN_PROF; 518 if (cpuid < 0) { 519 mibparam = 2; 520 miblen = 3; 521 } else { 522 mib[2] = GPROF_PERCPU; 523 mib[3] = cpuid; 524 mibparam = 4; 525 miblen = 5; 526 } 527 528 setprof(kvp, GMON_PROF_OFF, cpuid); 529 530 biggest = (size_t)kvp->gpm.kcountsize; 531 if ((size_t)kvp->gpm.fromssize > biggest) 532 biggest = (size_t)kvp->gpm.fromssize; 533 if ((size_t)kvp->gpm.tossize > biggest) 534 biggest = (size_t)kvp->gpm.tossize; 535 if ((zbuf = malloc(biggest)) == NULL) 536 err(EXIT_FAILURE, "cannot allocate zbuf space"); 537 (void)memset(zbuf, 0, biggest); 538 if (kflag) { 539 if ((size_t)kvm_write(kvp->kd, (u_long)kvp->gpm.kcount, zbuf, 540 (size_t)kvp->gpm.kcountsize) != kvp->gpm.kcountsize) 541 errx(EXIT_FAILURE, "tickbuf zero: %s", 542 kvm_geterr(kvp->kd)); 543 if ((size_t)kvm_write(kvp->kd, (u_long)kvp->gpm.froms, zbuf, 544 (size_t)kvp->gpm.fromssize) != kvp->gpm.fromssize) 545 errx(EXIT_FAILURE, "froms zero: %s", 546 kvm_geterr(kvp->kd)); 547 if ((size_t)kvm_write(kvp->kd, (u_long)kvp->gpm.tos, zbuf, 548 (size_t)kvp->gpm.tossize) != kvp->gpm.tossize) 549 errx(EXIT_FAILURE, "tos zero: %s", kvm_geterr(kvp->kd)); 550 free(zbuf); 551 return; 552 } 553 (void)seteuid(0); 554 mib[mibparam] = GPROF_COUNT; 555 if (sysctl(mib, miblen, NULL, NULL, zbuf, (size_t)kvp->gpm.kcountsize) < 0) 556 err(EXIT_FAILURE, "tickbuf zero"); 557 mib[mibparam] = GPROF_FROMS; 558 if (sysctl(mib, miblen, NULL, NULL, zbuf, (size_t)kvp->gpm.fromssize) < 0) 559 err(EXIT_FAILURE, "froms zero"); 560 mib[mibparam] = GPROF_TOS; 561 if (sysctl(mib, miblen, NULL, NULL, zbuf, (size_t)kvp->gpm.tossize) < 0) 562 err(EXIT_FAILURE, "tos zero"); 563 (void)seteuid(getuid()); 564 free(zbuf); 565 } 566
Indexes created Wed Sep 24 15:09:51 GMT 2025