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