usr/src/cmd/plockstat/plockstat.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <assert.h>
  30 #include <dtrace.h>
  31 #include <limits.h>
  32 #include <link.h>
  33 #include <priv.h>
  34 #include <signal.h>
  35 #include <stdlib.h>
  36 #include <stdarg.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include <strings.h>
  40 #include <errno.h>
  41 #include <sys/wait.h>
  42 #include <libgen.h>
  43 #include <libproc.h>
  44
  45 static char *g_pname;
  46 static dtrace_hdl_t *g_dtp;
  47 struct ps_prochandle *g_pr;
  48
  49 #define E_SUCCESS       0
  50 #define E_ERROR         1
  51 #define E_USAGE         2
  52
  53 /*
  54  * For hold times we use a global associative array since for mutexes, in
  55  * user-land, it's not invalid to release a sychonization primitive that
  56  * another thread acquired; rwlocks require a thread-local associative array
  57  * since multiple thread can hold the same lock for reading. Note that we
  58  * ignore recursive mutex acquisitions and releases as they don't truly
  59  * affect lock contention.
  60  */
  61 static const char *g_hold_init =
  62 "plockstat$target:::rw-acquire\n"
  63 "{\n"
  64 "       self->rwhold[arg0] = timestamp;\n"
  65 "}\n"
  66 "plockstat$target:::mutex-acquire\n"
  67 "/arg1 == 0/\n"
  68 "{\n"
  69 "       mtxhold[arg0] = timestamp;\n"
  70 "}\n";
  71
  72 static const char *g_hold_histogram =
  73 "plockstat$target:::rw-release\n"
  74 "/self->rwhold[arg0] && arg1 == 1/\n"
  75 "{\n"
  76 "       @rw_w_hold[arg0, ustack()] =\n"
  77 "           quantize(timestamp - self->rwhold[arg0]);\n"
  78 "       self->rwhold[arg0] = 0;\n"
  79 "       rw_w_hold_found = 1;\n"
  80 "}\n"
  81 "plockstat$target:::rw-release\n"
  82 "/self->rwhold[arg0]/\n"
  83 "{\n"
  84 "       @rw_r_hold[arg0, ustack()] =\n"
  85 "           quantize(timestamp - self->rwhold[arg0]);\n"
  86 "       self->rwhold[arg0] = 0;\n"
  87 "       rw_r_hold_found = 1;\n"
  88 "}\n"
  89 "plockstat$target:::mutex-release\n"
  90 "/mtxhold[arg0] && arg1 == 0/\n"
  91 "{\n"
  92 "       @mtx_hold[arg0, ustack()] = quantize(timestamp - mtxhold[arg0]);\n"
  93 "       mtxhold[arg0] = 0;\n"
  94 "       mtx_hold_found = 1;\n"
  95 "}\n"
  96 "\n"
  97 "END\n"
  98 "/mtx_hold_found/\n"
  99 "{\n"
 100 "       trace(\"Mutex hold\");\n"
 101 "       printa(@mtx_hold);\n"
 102 "}\n"
 103 "END\n"
 104 "/rw_r_hold_found/\n"
 105 "{\n"
 106 "       trace(\"R/W reader hold\");\n"
 107 "       printa(@rw_r_hold);\n"
 108 "}\n"
 109 "END\n"
 110 "/rw_w_hold_found/\n"
 111 "{\n"
 112 "       trace(\"R/W writer hold\");\n"
 113 "       printa(@rw_w_hold);\n"
 114 "}\n";
 115
 116 static const char *g_hold_times =
 117 "plockstat$target:::rw-release\n"
 118 "/self->rwhold[arg0] && arg1 == 1/\n"
 119 "{\n"
 120 "       @rw_w_hold[arg0, ustack(5)] = sum(timestamp - self->rwhold[arg0]);\n"
 121 "       @rw_w_hold_count[arg0, ustack(5)] = count();\n"
 122 "       self->rwhold[arg0] = 0;\n"
 123 "       rw_w_hold_found = 1;\n"
 124 "}\n"
 125 "plockstat$target:::rw-release\n"
 126 "/self->rwhold[arg0]/\n"
 127 "{\n"
 128 "       @rw_r_hold[arg0, ustack(5)] = sum(timestamp - self->rwhold[arg0]);\n"
 129 "       @rw_r_hold_count[arg0, ustack(5)] = count();\n"
 130 "       self->rwhold[arg0] = 0;\n"
 131 "       rw_r_hold_found = 1;\n"
 132 "}\n"
 133 "plockstat$target:::mutex-release\n"
 134 "/mtxhold[arg0] && arg1 == 0/\n"
 135 "{\n"
 136 "       @mtx_hold[arg0, ustack(5)] = sum(timestamp - mtxhold[arg0]);\n"
 137 "       @mtx_hold_count[arg0, ustack(5)] = count();\n"
 138 "       mtxhold[arg0] = 0;\n"
 139 "       mtx_hold_found = 1;\n"
 140 "}\n"
 141 "\n"
 142 "END\n"
 143 "/mtx_hold_found/\n"
 144 "{\n"
 145 "       trace(\"Mutex hold\");\n"
 146 "       printa(@mtx_hold, @mtx_hold_count);\n"
 147 "}\n"
 148 "END\n"
 149 "/rw_r_hold_found/\n"
 150 "{\n"
 151 "       trace(\"R/W reader hold\");\n"
 152 "       printa(@rw_r_hold, @rw_r_hold_count);\n"
 153 "}\n"
 154 "END\n"
 155 "/rw_w_hold_found/\n"
 156 "{\n"
 157 "       trace(\"R/W writer hold\");\n"
 158 "       printa(@rw_w_hold, @rw_w_hold_count);\n"
 159 "}\n";
 160
 161
 162 /*
 163  * For contention, we use thread-local associative arrays since we're tracing
 164  * a single thread's activity in libc and multiple threads can be blocking or
 165  * spinning on the same sychonization primitive.
 166  */
 167 static const char *g_ctnd_init =
 168 "plockstat$target:::rw-block\n"
 169 "{\n"
 170 "       self->rwblock[arg0] = timestamp;\n"
 171 "}\n"
 172 "plockstat$target:::mutex-block\n"
 173 "{\n"
 174 "       self->mtxblock[arg0] = timestamp;\n"
 175 "}\n"
 176 "plockstat$target:::mutex-spin\n"
 177 "{\n"
 178 "       self->mtxspin[arg0] = timestamp;\n"
 179 "}\n";
 180
 181 static const char *g_ctnd_histogram =
 182 "plockstat$target:::rw-blocked\n"
 183 "/self->rwblock[arg0] && arg1 == 1 && arg2 != 0/\n"
 184 "{\n"
 185 "       @rw_w_block[arg0, ustack()] =\n"
 186 "           quantize(timestamp - self->rwblock[arg0]);\n"
 187 "       self->rwblock[arg0] = 0;\n"
 188 "       rw_w_block_found = 1;\n"
 189 "}\n"
 190 "plockstat$target:::rw-blocked\n"
 191 "/self->rwblock[arg0] && arg2 != 0/\n"
 192 "{\n"
 193 "       @rw_r_block[arg0, ustack()] =\n"
 194 "           quantize(timestamp - self->rwblock[arg0]);\n"
 195 "       self->rwblock[arg0] = 0;\n"
 196 "       rw_r_block_found = 1;\n"
 197 "}\n"
 198 "plockstat$target:::rw-blocked\n"
 199 "/self->rwblock[arg0]/\n"
 200 "{\n"
 201 "       self->rwblock[arg0] = 0;\n"
 202 "}\n"
 203 "plockstat$target:::mutex-spun\n"
 204 "/self->mtxspin[arg0] && arg1 != 0/\n"
 205 "{\n"
 206 "       @mtx_spin[arg0, ustack()] =\n"
 207 "           quantize(timestamp - self->mtxspin[arg0]);\n"
 208 "       self->mtxspin[arg0] = 0;\n"
 209 "       mtx_spin_found = 1;\n"
 210 "}\n"
 211 "plockstat$target:::mutex-spun\n"
 212 "/self->mtxspin[arg0]/\n"
 213 "{\n"
 214 "       @mtx_vain_spin[arg0, ustack()] =\n"
 215 "           quantize(timestamp - self->mtxspin[arg0]);\n"
 216 "       self->mtxspin[arg0] = 0;\n"
 217 "       mtx_vain_spin_found = 1;\n"
 218 "}\n"
 219 "plockstat$target:::mutex-blocked\n"
 220 "/self->mtxblock[arg0] && arg1 != 0/\n"
 221 "{\n"
 222 "       @mtx_block[arg0, ustack()] =\n"
 223 "           quantize(timestamp - self->mtxblock[arg0]);\n"
 224 "       self->mtxblock[arg0] = 0;\n"
 225 "       mtx_block_found = 1;\n"
 226 "}\n"
 227 "plockstat$target:::mutex-blocked\n"
 228 "/self->mtxblock[arg0]/\n"
 229 "{\n"
 230 "       self->mtxblock[arg0] = 0;\n"
 231 "}\n"
 232 "\n"
 233 "END\n"
 234 "/mtx_block_found/\n"
 235 "{\n"
 236 "       trace(\"Mutex block\");\n"
 237 "       printa(@mtx_block);\n"
 238 "}\n"
 239 "END\n"
 240 "/mtx_spin_found/\n"
 241 "{\n"
 242 "       trace(\"Mutex spin\");\n"
 243 "       printa(@mtx_spin);\n"
 244 "}\n"
 245 "END\n"
 246 "/mtx_vain_spin_found/\n"
 247 "{\n"
 248 "       trace(\"Mutex unsuccessful spin\");\n"
 249 "       printa(@mtx_vain_spin);\n"
 250 "}\n"
 251 "END\n"
 252 "/rw_r_block_found/\n"
 253 "{\n"
 254 "       trace(\"R/W reader block\");\n"
 255 "       printa(@rw_r_block);\n"
 256 "}\n"
 257 "END\n"
 258 "/rw_w_block_found/\n"
 259 "{\n"
 260 "       trace(\"R/W writer block\");\n"
 261 "       printa(@rw_w_block);\n"
 262 "}\n";
 263
 264
 265 static const char *g_ctnd_times =
 266 "plockstat$target:::rw-blocked\n"
 267 "/self->rwblock[arg0] && arg1 == 1 && arg2 != 0/\n"
 268 "{\n"
 269 "       @rw_w_block[arg0, ustack(5)] =\n"
 270 "           sum(timestamp - self->rwblock[arg0]);\n"
 271 "       @rw_w_block_count[arg0, ustack(5)] = count();\n"
 272 "       self->rwblock[arg0] = 0;\n"
 273 "       rw_w_block_found = 1;\n"
 274 "}\n"
 275 "plockstat$target:::rw-blocked\n"
 276 "/self->rwblock[arg0] && arg2 != 0/\n"
 277 "{\n"
 278 "       @rw_r_block[arg0, ustack(5)] =\n"
 279 "           sum(timestamp - self->rwblock[arg0]);\n"
 280 "       @rw_r_block_count[arg0, ustack(5)] = count();\n"
 281 "       self->rwblock[arg0] = 0;\n"
 282 "       rw_r_block_found = 1;\n"
 283 "}\n"
 284 "plockstat$target:::rw-blocked\n"
 285 "/self->rwblock[arg0]/\n"
 286 "{\n"
 287 "       self->rwblock[arg0] = 0;\n"
 288 "}\n"
 289 "plockstat$target:::mutex-spun\n"
 290 "/self->mtxspin[arg0] && arg1 != 0/\n"
 291 "{\n"
 292 "       @mtx_spin[arg0, ustack(5)] =\n"
 293 "           sum(timestamp - self->mtxspin[arg0]);\n"
 294 "       @mtx_spin_count[arg0, ustack(5)] = count();\n"
 295 "       self->mtxspin[arg0] = 0;\n"
 296 "       mtx_spin_found = 1;\n"
 297 "}\n"
 298 "plockstat$target:::mutex-spun\n"
 299 "/self->mtxspin[arg0]/\n"
 300 "{\n"
 301 "       @mtx_vain_spin[arg0, ustack(5)] =\n"
 302 "           sum(timestamp - self->mtxspin[arg0]);\n"
 303 "       @mtx_vain_spin_count[arg0, ustack(5)] = count();\n"
 304 "       self->mtxspin[arg0] = 0;\n"
 305 "       mtx_vain_spin_found = 1;\n"
 306 "}\n"
 307 "plockstat$target:::mutex-blocked\n"
 308 "/self->mtxblock[arg0] && arg1 != 0/\n"
 309 "{\n"
 310 "       @mtx_block[arg0, ustack(5)] =\n"
 311 "           sum(timestamp - self->mtxblock[arg0]);\n"
 312 "       @mtx_block_count[arg0, ustack(5)] = count();\n"
 313 "       self->mtxblock[arg0] = 0;\n"
 314 "       mtx_block_found = 1;\n"
 315 "}\n"
 316 "plockstat$target:::mutex-blocked\n"
 317 "/self->mtxblock[arg0]/\n"
 318 "{\n"
 319 "       self->mtxblock[arg0] = 0;\n"
 320 "}\n"
 321 "\n"
 322 "END\n"
 323 "/mtx_block_found/\n"
 324 "{\n"
 325 "       trace(\"Mutex block\");\n"
 326 "       printa(@mtx_block, @mtx_block_count);\n"
 327 "}\n"
 328 "END\n"
 329 "/mtx_spin_found/\n"
 330 "{\n"
 331 "       trace(\"Mutex spin\");\n"
 332 "       printa(@mtx_spin, @mtx_spin_count);\n"
 333 "}\n"
 334 "END\n"
 335 "/mtx_vain_spin_found/\n"
 336 "{\n"
 337 "       trace(\"Mutex unsuccessful spin\");\n"
 338 "       printa(@mtx_vain_spin, @mtx_vain_spin_count);\n"
 339 "}\n"
 340 "END\n"
 341 "/rw_r_block_found/\n"
 342 "{\n"
 343 "       trace(\"R/W reader block\");\n"
 344 "       printa(@rw_r_block, @rw_r_block_count);\n"
 345 "}\n"
 346 "END\n"
 347 "/rw_w_block_found/\n"
 348 "{\n"
 349 "       trace(\"R/W writer block\");\n"
 350 "       printa(@rw_w_block, @rw_w_block_count);\n"
 351 "}\n";
 352
 353 static char g_prog[4096];
 354 static size_t g_proglen;
 355 static int g_opt_V, g_opt_s;
 356 static int g_intr;
 357 static int g_exited;
 358 static dtrace_optval_t g_nframes;
 359 static ulong_t g_nent = ULONG_MAX;
 360
 361 #define PLOCKSTAT_OPTSTR        "n:ps:e:vx:ACHV"
 362
 363 static void
 364 usage(void)
 365 {
 366         (void) fprintf(stderr, "Usage:\n"
 367             "\t%s [-vACHV] [-n count] [-s depth] [-e secs] [-x opt[=val]]\n"
 368             "\t    command [arg...]\n"
 369             "\t%s [-vACHV] [-n count] [-s depth] [-e secs] [-x opt[=val]]\n"
 370             "\t    -p pid\n", g_pname, g_pname);
 371
 372         exit(E_USAGE);
 373 }
 374
 375 static void
 376 verror(const char *fmt, va_list ap)
 377 {
 378         int error = errno;
 379
 380         (void) fprintf(stderr, "%s: ", g_pname);
 381         (void) vfprintf(stderr, fmt, ap);
 382
 383         if (fmt[strlen(fmt) - 1] != '\n')
 384                 (void) fprintf(stderr, ": %s\n", strerror(error));
 385 }
 386
 387 /*PRINTFLIKE1*/
 388 static void
 389 fatal(const char *fmt, ...)
 390 {
 391         va_list ap;
 392
 393         va_start(ap, fmt);
 394         verror(fmt, ap);
 395         va_end(ap);
 396
 397         if (g_pr != NULL && g_dtp != NULL)
 398                 dtrace_proc_release(g_dtp, g_pr);
 399
 400         exit(E_ERROR);
 401 }
 402
 403 /*PRINTFLIKE1*/
 404 static void
 405 dfatal(const char *fmt, ...)
 406 {
 407         va_list ap;
 408
 409         va_start(ap, fmt);
 410
 411         (void) fprintf(stderr, "%s: ", g_pname);
 412         if (fmt != NULL)
 413                 (void) vfprintf(stderr, fmt, ap);
 414
 415         va_end(ap);
 416
 417         if (fmt != NULL && fmt[strlen(fmt) - 1] != '\n') {
 418                 (void) fprintf(stderr, ": %s\n",
 419                     dtrace_errmsg(g_dtp, dtrace_errno(g_dtp)));
 420         } else if (fmt == NULL) {
 421                 (void) fprintf(stderr, "%s\n",
 422                     dtrace_errmsg(g_dtp, dtrace_errno(g_dtp)));
 423         }
 424
 425         if (g_pr != NULL) {
 426                 dtrace_proc_continue(g_dtp, g_pr);
 427                 dtrace_proc_release(g_dtp, g_pr);
 428         }
 429
 430         exit(E_ERROR);
 431 }
 432
 433 /*PRINTFLIKE1*/
 434 static void
 435 notice(const char *fmt, ...)
 436 {
 437         va_list ap;
 438
 439         va_start(ap, fmt);
 440         verror(fmt, ap);
 441         va_end(ap);
 442 }
 443
 444 static void
 445 dprog_add(const char *prog)
 446 {
 447         size_t len = strlen(prog);
 448         bcopy(prog, g_prog + g_proglen, len + 1);
 449         g_proglen += len;
 450         assert(g_proglen < sizeof (g_prog));
 451 }
 452
 453 static void
 454 dprog_compile(void)
 455 {
 456         dtrace_prog_t *prog;
 457         dtrace_proginfo_t info;
 458
 459         if (g_opt_V) {
 460                 (void) fprintf(stderr, "%s: vvvv D program vvvv\n", g_pname);
 461                 (void) fputs(g_prog, stderr);
 462                 (void) fprintf(stderr, "%s: ^^^^ D program ^^^^\n", g_pname);
 463         }
 464
 465         if ((prog = dtrace_program_strcompile(g_dtp, g_prog,
 466             DTRACE_PROBESPEC_NAME, 0, 0, NULL)) == NULL)
 467                 dfatal("failed to compile program");
 468
 469         if (dtrace_program_exec(g_dtp, prog, &info) == -1)
 470                 dfatal("failed to enable probes");
 471 }
 472
 473 void
 474 print_legend(void)
 475 {
 476         (void) printf("%5s %8s %-28s %s\n", "Count", "nsec", "Lock", "Caller");
 477 }
 478
 479 void
 480 print_bar(void)
 481 {
 482         (void) printf("---------------------------------------"
 483             "----------------------------------------\n");
 484 }
 485
 486 void
 487 print_histogram_header(void)
 488 {
 489         (void) printf("\n%10s ---- Time Distribution --- %5s %s\n",
 490             "nsec", "count", "Stack");
 491 }
 492
 493 /*
 494  * Convert an address to a symbolic string or a numeric string. If nolocks
 495  * is set, we return an error code if this symbol appears to be a mutex- or
 496  * rwlock-related symbol in libc so the caller has a chance to find a more
 497  * helpful symbol.
 498  */
 499 static int
 500 getsym(struct ps_prochandle *P, uintptr_t addr, char *buf, size_t size,
 501     int nolocks)
 502 {
 503         char name[256];
 504         GElf_Sym sym;
 505         prsyminfo_t info;
 506         size_t len;
 507
 508         if (P == NULL || Pxlookup_by_addr(P, addr, name, sizeof (name),
 509             &sym, &info) != 0) {
 510                 (void) snprintf(buf, size, "%#lx", addr);
 511                 return (0);
 512         }
 513         if (info.prs_object == NULL)
 514                 info.prs_object = "<unknown>";
 515
 516         if (info.prs_lmid != LM_ID_BASE) {
 517                 len = snprintf(buf, size, "LM%lu`", info.prs_lmid);
 518                 buf += len;
 519                 size -= len;
 520         }
 521
 522         len = snprintf(buf, size, "%s`%s", info.prs_object, info.prs_name);
 523         buf += len;
 524         size -= len;
 525
 526         if (sym.st_value != addr)
 527                 len = snprintf(buf, size, "+%#lx", addr - sym.st_value);
 528
 529         if (nolocks && strcmp("libc.so.1", info.prs_object) == 0 &&
 530             (strstr("mutex", info.prs_name) == 0 ||
 531             strstr("rw", info.prs_name) == 0))
 532                 return (-1);
 533
 534         return (0);
 535 }
 536
 537 /*ARGSUSED*/
 538 static int
 539 process_aggregate(const dtrace_aggdata_t **aggsdata, int naggvars, void *arg)
 540 {
 541         const dtrace_recdesc_t *rec;
 542         uintptr_t lock;
 543         uint64_t *stack;
 544         caddr_t data;
 545         pid_t pid;
 546         struct ps_prochandle *P;
 547         char buf[256];
 548         int i, j;
 549         uint64_t sum, count, avg;
 550
 551         if ((*(uint_t *)arg)++ >= g_nent)
 552                 return (DTRACE_AGGWALK_NEXT);
 553
 554         rec = aggsdata[0]->dtada_desc->dtagd_rec;
 555         data = aggsdata[0]->dtada_data;
 556
 557         /*LINTED - alignment*/
 558         lock = (uintptr_t)*(uint64_t *)(data + rec[1].dtrd_offset);
 559         /*LINTED - alignment*/
 560         stack = (uint64_t *)(data + rec[2].dtrd_offset);
 561
 562         if (!g_opt_s) {
 563                 /*LINTED - alignment*/
 564                 sum = *(uint64_t *)(aggsdata[1]->dtada_data +
 565                     aggsdata[1]->dtada_desc->dtagd_rec[3].dtrd_offset);
 566                 /*LINTED - alignment*/
 567                 count = *(uint64_t *)(aggsdata[2]->dtada_data +
 568                     aggsdata[2]->dtada_desc->dtagd_rec[3].dtrd_offset);
 569         } else {
 570                 uint64_t *a;
 571
 572                 /*LINTED - alignment*/
 573                 a = (uint64_t *)(aggsdata[1]->dtada_data +
 574                     aggsdata[1]->dtada_desc->dtagd_rec[3].dtrd_offset);
 575
 576                 print_bar();
 577                 print_legend();
 578
 579                 for (count = sum = 0, i = DTRACE_QUANTIZE_ZEROBUCKET, j = 0;
 580                     i < DTRACE_QUANTIZE_NBUCKETS; i++, j++) {
 581                         count += a[i];
 582                         sum += a[i] << (j - 64);
 583                 }
 584         }
 585
 586         avg = sum / count;
 587         (void) printf("%5llu %8llu ", (u_longlong_t)count, (u_longlong_t)avg);
 588
 589         pid = stack[0];
 590         P = dtrace_proc_grab(g_dtp, pid, PGRAB_RDONLY);
 591
 592         (void) getsym(P, lock, buf, sizeof (buf), 0);
 593         (void) printf("%-28s ", buf);
 594
 595         for (i = 2; i <= 5; i++) {
 596                 if (getsym(P, stack[i], buf, sizeof (buf), 1) == 0)
 597                         break;
 598         }
 599         (void) printf("%s\n", buf);
 600
 601         if (g_opt_s) {
 602                 int stack_done = 0;
 603                 int quant_done = 0;
 604                 int first_bin, last_bin;
 605                 uint64_t bin_size, *a;
 606
 607                 /*LINTED - alignment*/
 608                 a = (uint64_t *)(aggsdata[1]->dtada_data +
 609                     aggsdata[1]->dtada_desc->dtagd_rec[3].dtrd_offset);
 610
 611                 print_histogram_header();
 612
 613                 for (first_bin = DTRACE_QUANTIZE_ZEROBUCKET;
 614                     a[first_bin] == 0; first_bin++)
 615                         continue;
 616                 for (last_bin = DTRACE_QUANTIZE_ZEROBUCKET + 63;
 617                     a[last_bin] == 0; last_bin--)
 618                         continue;
 619
 620                 for (i = 0; !stack_done || !quant_done; i++) {
 621                         if (!stack_done) {
 622                                 (void) getsym(P, stack[i + 2], buf,
 623                                     sizeof (buf), 0);
 624                         } else {
 625                                 buf[0] = '\0';
 626                         }
 627
 628                         if (!quant_done) {
 629                                 bin_size = a[first_bin];
 630
 631                                 (void) printf("%10llu |%-24.*s| %5llu %s\n",
 632                                     1ULL <<
 633                                     (first_bin - DTRACE_QUANTIZE_ZEROBUCKET),
 634                                     (int)(24.0 * bin_size / count),
 635                                     "@@@@@@@@@@@@@@@@@@@@@@@@@@",
 636                                     (u_longlong_t)bin_size, buf);
 637                         } else {
 638                                 (void) printf("%43s %s\n", "", buf);
 639                         }
 640
 641                         if (i + 1 >= g_nframes || stack[i + 3] == 0)
 642                                 stack_done = 1;
 643
 644                         if (first_bin++ == last_bin)
 645                                 quant_done = 1;
 646                 }
 647         }
 648
 649         dtrace_proc_release(g_dtp, P);
 650
 651         return (DTRACE_AGGWALK_NEXT);
 652 }
 653
 654 /*ARGSUSED*/
 655 static void
 656 prochandler(struct ps_prochandle *P, const char *msg, void *arg)
 657 {
 658         const psinfo_t *prp = Ppsinfo(P);
 659         int pid = Pstatus(P)->pr_pid;
 660         char name[SIG2STR_MAX];
 661
 662         if (msg != NULL) {
 663                 notice("pid %d: %s\n", pid, msg);
 664                 return;
 665         }
 666
 667         switch (Pstate(P)) {
 668         case PS_UNDEAD:
 669                 /*
 670                  * Ideally we would like to always report pr_wstat here, but it
 671                  * isn't possible given current /proc semantics.  If we grabbed
 672                  * the process, Ppsinfo() will either fail or return a zeroed
 673                  * psinfo_t depending on how far the parent is in reaping it.
 674                  * When /proc provides a stable pr_wstat in the status file,
 675                  * this code can be improved by examining this new pr_wstat.
 676                  */
 677                 if (prp != NULL && WIFSIGNALED(prp->pr_wstat)) {
 678                         notice("pid %d terminated by %s\n", pid,
 679                             proc_signame(WTERMSIG(prp->pr_wstat),
 680                             name, sizeof (name)));
 681                 } else if (prp != NULL && WEXITSTATUS(prp->pr_wstat) != 0) {
 682                         notice("pid %d exited with status %d\n",
 683                             pid, WEXITSTATUS(prp->pr_wstat));
 684                 } else {
 685                         notice("pid %d has exited\n", pid);
 686                 }
 687                 g_exited = 1;
 688                 break;
 689
 690         case PS_LOST:
 691                 notice("pid %d exec'd a set-id or unobservable program\n", pid);
 692                 g_exited = 1;
 693                 break;
 694         }
 695 }
 696
 697 /*ARGSUSED*/
 698 static int
 699 chewrec(const dtrace_probedata_t *data, const dtrace_recdesc_t *rec, void *arg)
 700 {
 701         dtrace_eprobedesc_t *epd = data->dtpda_edesc;
 702         dtrace_aggvarid_t aggvars[2];
 703         const void *buf;
 704         int i, nagv;
 705
 706         /*
 707          * A NULL rec indicates that we've processed the last record.
 708          */
 709         if (rec == NULL)
 710                 return (DTRACE_CONSUME_NEXT);
 711
 712         buf = data->dtpda_data - rec->dtrd_offset;
 713
 714         switch (rec->dtrd_action) {
 715         case DTRACEACT_DIFEXPR:
 716                 (void) printf("\n%s\n\n", (char *)buf + rec->dtrd_offset);
 717                 if (!g_opt_s) {
 718                         print_legend();
 719                         print_bar();
 720                 }
 721                 return (DTRACE_CONSUME_NEXT);
 722
 723         case DTRACEACT_PRINTA:
 724                 for (nagv = 0, i = 0; i < epd->dtepd_nrecs - 1; i++) {
 725                         const dtrace_recdesc_t *nrec = &rec[i];
 726
 727                         if (nrec->dtrd_uarg != rec->dtrd_uarg)
 728                                 break;
 729
 730                         /*LINTED - alignment*/
 731                         aggvars[nagv++] = *(dtrace_aggvarid_t *)((caddr_t)buf +
 732                             nrec->dtrd_offset);
 733                 }
 734
 735                 if (nagv == (g_opt_s ? 1 : 2)) {
 736                         uint_t nent = 0;
 737                         if (dtrace_aggregate_walk_joined(g_dtp, aggvars, nagv,
 738                             process_aggregate, &nent) != 0)
 739                                 dfatal("failed to walk aggregate");
 740                 }
 741
 742                 return (DTRACE_CONSUME_NEXT);
 743         }
 744
 745         return (DTRACE_CONSUME_THIS);
 746 }
 747
 748 /*ARGSUSED*/
 749 static void
 750 intr(int signo)
 751 {
 752         g_intr = 1;
 753 }
 754
 755 int
 756 main(int argc, char **argv)
 757 {
 758         ucred_t *ucp;
 759         int err;
 760         int opt_C = 0, opt_H = 0, opt_p = 0, opt_v = 0;
 761         char c, *p, *end;
 762         struct sigaction act;
 763         int done = 0;
 764
 765         g_pname = basename(argv[0]);
 766         argv[0] = g_pname; /* rewrite argv[0] for getopt errors */
 767
 768         /*
 769          * Make sure we have the required dtrace_proc privilege.
 770          */
 771         if ((ucp = ucred_get(getpid())) != NULL) {
 772                 const priv_set_t *psp;
 773                 if ((psp = ucred_getprivset(ucp, PRIV_EFFECTIVE)) != NULL &&
 774                     !priv_ismember(psp, PRIV_DTRACE_PROC)) {
 775                         fatal("dtrace_proc privilege required\n");
 776                 }
 777
 778                 ucred_free(ucp);
 779         }
 780
 781         while ((c = getopt(argc, argv, PLOCKSTAT_OPTSTR)) != EOF) {
 782                 switch (c) {
 783                 case 'n':
 784                         errno = 0;
 785                         g_nent = strtoul(optarg, &end, 10);
 786                         if (*end != '\0' || errno != 0) {
 787                                 (void) fprintf(stderr, "%s: invalid count "
 788                                     "'%s'\n", g_pname, optarg);
 789                                 usage();
 790                         }
 791                         break;
 792
 793                 case 'p':
 794                         opt_p = 1;
 795                         break;
 796
 797                 case 'v':
 798                         opt_v = 1;
 799                         break;
 800
 801                 case 'A':
 802                         opt_C = opt_H = 1;
 803                         break;
 804
 805                 case 'C':
 806                         opt_C = 1;
 807                         break;
 808
 809                 case 'H':
 810                         opt_H = 1;
 811                         break;
 812
 813                 case 'V':
 814                         g_opt_V = 1;
 815                         break;
 816
 817                 default:
 818                         if (strchr(PLOCKSTAT_OPTSTR, c) == NULL)
 819                                 usage();
 820                 }
 821         }
 822
 823         /*
 824          * We need a command or at least one pid.
 825          */
 826         if (argc == optind)
 827                 usage();
 828
 829         if (opt_C == 0 && opt_H == 0)
 830                 opt_C = 1;
 831
 832         if ((g_dtp = dtrace_open(DTRACE_VERSION, 0, &err)) == NULL)
 833                 fatal("failed to initialize dtrace: %s\n",
 834                     dtrace_errmsg(NULL, err));
 835
 836         /*
 837          * The longest string we trace is 23 bytes long -- so 32 is plenty.
 838          */
 839         if (dtrace_setopt(g_dtp, "strsize", "32") == -1)
 840                 dfatal("failed to set 'strsize'");
 841
 842         /*
 843          * 1k should be more than enough for all trace() and printa() actions.
 844          */
 845         if (dtrace_setopt(g_dtp, "bufsize", "1k") == -1)
 846                 dfatal("failed to set 'bufsize'");
 847
 848         /*
 849          * The table we produce has the hottest locks at the top.
 850          */
 851         if (dtrace_setopt(g_dtp, "aggsortrev", NULL) == -1)
 852                 dfatal("failed to set 'aggsortrev'");
 853
 854         /*
 855          * These are two reasonable defaults which should suffice.
 856          */
 857         if (dtrace_setopt(g_dtp, "aggsize", "256k") == -1)
 858                 dfatal("failed to set 'aggsize'");
 859         if (dtrace_setopt(g_dtp, "aggrate", "1sec") == -1)
 860                 dfatal("failed to set 'aggrate'");
 861
 862         /*
 863          * Take a second pass through to look for options that set options now
 864          * that we have an open dtrace handle.
 865          */
 866         optind = 1;
 867         while ((c = getopt(argc, argv, PLOCKSTAT_OPTSTR)) != EOF) {
 868                 switch (c) {
 869                 case 's':
 870                         g_opt_s = 1;
 871                         if (dtrace_setopt(g_dtp, "ustackframes", optarg) == -1)
 872                                 dfatal("failed to set 'ustackframes'");
 873                         break;
 874
 875                 case 'x':
 876                         if ((p = strchr(optarg, '=')) != NULL)
 877                                 *p++ = '\0';
 878
 879                         if (dtrace_setopt(g_dtp, optarg, p) != 0)
 880                                 dfatal("failed to set -x %s", optarg);
 881                         break;
 882
 883                 case 'e':
 884                         errno = 0;
 885                         (void) strtoul(optarg, &end, 10);
 886                         if (*optarg == '-' || *end != '\0' || errno != 0) {
 887                                 (void) fprintf(stderr, "%s: invalid timeout "
 888                                     "'%s'\n", g_pname, optarg);
 889                                 usage();
 890                         }
 891
 892                         /*
 893                          * Construct a DTrace enabling that will exit after
 894                          * the specified number of seconds.
 895                          */
 896                         dprog_add("BEGIN\n{\n\tend = timestamp + ");
 897                         dprog_add(optarg);
 898                         dprog_add(" * 1000000000;\n}\n");
 899                         dprog_add("tick-10hz\n/timestamp >= end/\n");
 900                         dprog_add("{\n\texit(0);\n}\n");
 901                         break;
 902                 }
 903         }
 904
 905         argc -= optind;
 906         argv += optind;
 907
 908         if (opt_H) {
 909                 dprog_add(g_hold_init);
 910                 if (g_opt_s == NULL)
 911                         dprog_add(g_hold_times);
 912                 else
 913                         dprog_add(g_hold_histogram);
 914         }
 915
 916         if (opt_C) {
 917                 dprog_add(g_ctnd_init);
 918                 if (g_opt_s == NULL)
 919                         dprog_add(g_ctnd_times);
 920                 else
 921                         dprog_add(g_ctnd_histogram);
 922         }
 923
 924         if (opt_p) {
 925                 ulong_t pid;
 926
 927                 if (argc > 1) {
 928                         (void) fprintf(stderr, "%s: only one pid is allowed\n",
 929                             g_pname);
 930                         usage();
 931                 }
 932
 933                 errno = 0;
 934                 pid = strtoul(argv[0], &end, 10);
 935                 if (*end != '\0' || errno != 0 || (pid_t)pid != pid) {
 936                         (void) fprintf(stderr, "%s: invalid pid '%s'\n",
 937                             g_pname, argv[0]);
 938                         usage();
 939                 }
 940
 941                 if ((g_pr = dtrace_proc_grab(g_dtp, (pid_t)pid, 0)) == NULL)
 942                         dfatal(NULL);
 943         } else {
 944                 if ((g_pr = dtrace_proc_create(g_dtp, argv[0], argv)) == NULL)
 945                         dfatal(NULL);
 946         }
 947
 948         dprog_compile();
 949
 950         if (dtrace_handle_proc(g_dtp, &prochandler, NULL) == -1)
 951                 dfatal("failed to establish proc handler");
 952
 953         (void) sigemptyset(&act.sa_mask);
 954         act.sa_flags = 0;
 955         act.sa_handler = intr;
 956         (void) sigaction(SIGINT, &act, NULL);
 957         (void) sigaction(SIGTERM, &act, NULL);
 958
 959         if (dtrace_go(g_dtp) != 0)
 960                 dfatal("dtrace_go()");
 961
 962         if (dtrace_getopt(g_dtp, "ustackframes", &g_nframes) != 0)
 963                 dfatal("failed to get 'ustackframes'");
 964
 965         dtrace_proc_continue(g_dtp, g_pr);
 966
 967         if (opt_v)
 968                 (void) printf("%s: tracing enabled for pid %d\n", g_pname,
 969                     (int)Pstatus(g_pr)->pr_pid);
 970
 971         do {
 972                 if (!g_intr && !done)
 973                         dtrace_sleep(g_dtp);
 974
 975                 if (done || g_intr || g_exited) {
 976                         done = 1;
 977                         if (dtrace_stop(g_dtp) == -1)
 978                                 dfatal("couldn't stop tracing");
 979                 }
 980
 981                 switch (dtrace_work(g_dtp, stdout, NULL, chewrec, NULL)) {
 982                 case DTRACE_WORKSTATUS_DONE:
 983                         done = 1;
 984                         break;
 985                 case DTRACE_WORKSTATUS_OKAY:
 986                         break;
 987                 default:
 988                         dfatal("processing aborted");
 989                 }
 990
 991         } while (!done);
 992
 993         dtrace_close(g_dtp);
 994
 995         return (0);
 996 }