usr/src/cmd/latencytop/common/dwrapper.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  * Copyright (c) 2008-2009, Intel Corporation.
  23  * All Rights Reserved.
  24  */
  25
  26 #include <unistd.h>
  27 #include <stdio.h>
  28 #include <dtrace.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <memory.h>
  32 #include <limits.h>
  33
  34 #include "latencytop.h"
  35
  36 static dtrace_hdl_t *g_dtp = NULL;      /* dtrace handle */
  37 static pid_t pid_self = -1;             /* PID of our own process */
  38
  39 /*
  40  * Ignore sched if sched is not tracked.
  41  * Also ignore ourselves (i.e., latencytop).
  42  */
  43 #define SHOULD_IGNORE(pid)              \
  44         ((!g_config.lt_cfg_trace_sched && 0 == (pid)) || pid_self == (pid))
  45
  46 /*
  47  * Get an integer value from dtrace record.
  48  */
  49 static uint64_t
  50 rec_get_value(void *a, size_t b)
  51 {
  52         uint64_t ret = 0;
  53
  54         switch (b) {
  55         case sizeof (uint64_t):
  56                 ret = *((uint64_t *)(a));
  57                 break;
  58         case sizeof (uint32_t):
  59                 ret = *((uint32_t *)(a));
  60                 break;
  61         case sizeof (uint16_t):
  62                 ret = *((uint16_t *)(a));
  63                 break;
  64         case sizeof (uint8_t):
  65                 ret = *((uint8_t *)(a));
  66                 break;
  67         default:
  68                 break;
  69         }
  70
  71         return (ret);
  72 }
  73
  74 /*
  75  * Callback to process aggregation lt_call_* (related to on/off cpu
  76  * activities) in the snapshot.
  77  */
  78 static int
  79 aggwalk_call(const dtrace_aggdata_t *data, lt_stat_type_t stat_type)
  80 {
  81         dtrace_aggdesc_t *aggdesc = data->dtada_desc;
  82         dtrace_syminfo_t dts;
  83         GElf_Sym sym;
  84         caddr_t addr;
  85         pid_t pid;
  86         id_t tid;
  87         unsigned int stack_depth;
  88         unsigned int pc_size;
  89         uint64_t pc;
  90         uint64_t agg_value;
  91         char *ptr = NULL;
  92         char *buffer = NULL;
  93         int ptrsize;
  94         unsigned int buffersize;
  95         char *tag = NULL;
  96         unsigned int priority;
  97         enum { REC_PID = 1, REC_TID, REC_STACK, REC_TAG, REC_PRIO, REC_AGG,
  98             NREC };
  99
 100         /* Check action type */
 101         if ((aggdesc->dtagd_nrecs < NREC) ||
 102             (aggdesc->dtagd_rec[REC_PID].dtrd_action != DTRACEACT_DIFEXPR) ||
 103             (aggdesc->dtagd_rec[REC_TID].dtrd_action != DTRACEACT_DIFEXPR) ||
 104             (aggdesc->dtagd_rec[REC_TAG].dtrd_action != DTRACEACT_DIFEXPR) ||
 105             (aggdesc->dtagd_rec[REC_PRIO].dtrd_action != DTRACEACT_DIFEXPR) ||
 106             (!DTRACEACT_ISAGG(aggdesc->dtagd_rec[REC_AGG].dtrd_action)) ||
 107             (aggdesc->dtagd_rec[REC_STACK].dtrd_action != DTRACEACT_STACK)) {
 108
 109                 return (-1);
 110         }
 111
 112         pid = rec_get_value(
 113             data->dtada_data + aggdesc->dtagd_rec[REC_PID].dtrd_offset,
 114             aggdesc->dtagd_rec[REC_PID].dtrd_size);
 115
 116         if (SHOULD_IGNORE(pid)) {
 117                 return (0);
 118         }
 119
 120         tid = rec_get_value(
 121             data->dtada_data + aggdesc->dtagd_rec[REC_TID].dtrd_offset,
 122             aggdesc->dtagd_rec[REC_TID].dtrd_size);
 123
 124         /* Parse stack array from dtagd_rec */
 125         stack_depth = aggdesc->dtagd_rec[REC_STACK].dtrd_arg;
 126         pc_size = aggdesc->dtagd_rec[REC_STACK].dtrd_size / stack_depth;
 127         addr = data->dtada_data + aggdesc->dtagd_rec[REC_STACK].dtrd_offset;
 128         buffersize = (stack_depth * (2 * PATH_MAX + 2) + 1) * sizeof (char);
 129         buffer = (char *)lt_malloc(buffersize);
 130         ptr = buffer;
 131         ptrsize = buffersize;
 132
 133         /* Print the stack */
 134         while (stack_depth > 0) {
 135                 pc = rec_get_value(addr, pc_size);
 136
 137                 if (pc == 0) {
 138                         break;
 139                 }
 140
 141                 addr += pc_size;
 142
 143                 if (dtrace_lookup_by_addr(g_dtp, pc, &sym, &dts) == 0) {
 144                         int len;
 145                         len = snprintf(ptr, ptrsize,
 146                             "%s`%s ", dts.dts_object, dts.dts_name);
 147                         ptrsize -= len;
 148
 149                         if (ptrsize <= 0) {
 150                                 /*
 151                                  * snprintf returns "desired" length, so
 152                                  * reaching here means our buffer is full.
 153                                  * Move ptr to the last byte of the buffer and
 154                                  * break.
 155                                  */
 156                                 ptr = &buffer[buffersize-1];
 157                                 break;
 158                         } else {
 159                                 ptr += len;
 160                         }
 161                 }
 162         }
 163
 164         if (ptr != buffer) {
 165                 /*
 166                  * We have printed something, so it is safe to remove
 167                  * the last ' '.
 168                  */
 169                 *(ptr-1) = '\0';
 170         }
 171
 172         tag = (char *)data->dtada_data +
 173             aggdesc->dtagd_rec[REC_TAG].dtrd_offset;
 174
 175         priority = rec_get_value(
 176             data->dtada_data + aggdesc->dtagd_rec[REC_PRIO].dtrd_offset,
 177             aggdesc->dtagd_rec[REC_PRIO].dtrd_size);
 178
 179         agg_value = rec_get_value(
 180             data->dtada_data + aggdesc->dtagd_rec[REC_AGG].dtrd_offset,
 181             aggdesc->dtagd_rec[REC_AGG].dtrd_size);
 182
 183         lt_stat_update(pid, tid, buffer, tag, priority, stat_type, agg_value);
 184
 185         if (buffer != NULL)  {
 186                 free(buffer);
 187         }
 188
 189         return (0);
 190 }
 191
 192 /*
 193  * Callback to process aggregation lt_named_* (related to lock spinning etc.),
 194  * in the snapshot.
 195  */
 196 static int
 197 aggwalk_named(const dtrace_aggdata_t *data, lt_stat_type_t stat_type)
 198 {
 199         dtrace_aggdesc_t *aggdesc = data->dtada_desc;
 200         pid_t pid;
 201         id_t tid;
 202         uint64_t agg_value;
 203         int cause_id;
 204         char *type = NULL;
 205         enum { REC_PID = 1, REC_TID, REC_TYPE, REC_AGG, NREC };
 206
 207         /* Check action type */
 208         if ((aggdesc->dtagd_nrecs < NREC) ||
 209             (aggdesc->dtagd_rec[REC_PID].dtrd_action != DTRACEACT_DIFEXPR) ||
 210             (aggdesc->dtagd_rec[REC_TID].dtrd_action != DTRACEACT_DIFEXPR) ||
 211             (aggdesc->dtagd_rec[REC_TYPE].dtrd_action != DTRACEACT_DIFEXPR) ||
 212             (!DTRACEACT_ISAGG(aggdesc->dtagd_rec[REC_AGG].dtrd_action))) {
 213
 214                 return (-1);
 215         }
 216
 217         pid = rec_get_value(
 218             data->dtada_data + aggdesc->dtagd_rec[REC_PID].dtrd_offset,
 219             aggdesc->dtagd_rec[REC_PID].dtrd_size);
 220
 221         if (SHOULD_IGNORE(pid)) {
 222                 return (0);
 223         }
 224
 225         tid = rec_get_value(
 226             data->dtada_data + aggdesc->dtagd_rec[REC_TID].dtrd_offset,
 227             aggdesc->dtagd_rec[REC_TID].dtrd_size);
 228
 229         type = (char *)data->dtada_data
 230             + aggdesc->dtagd_rec[REC_TYPE].dtrd_offset;
 231         cause_id = lt_table_cause_from_name(type, 1, CAUSE_FLAG_SPECIAL);
 232
 233         agg_value = rec_get_value(
 234             data->dtada_data + aggdesc->dtagd_rec[REC_AGG].dtrd_offset,
 235             aggdesc->dtagd_rec[REC_AGG].dtrd_size);
 236
 237         lt_stat_update_cause(pid, tid, cause_id, stat_type, agg_value);
 238
 239         return (0);
 240
 241 }
 242
 243 /*
 244  * Callback to process aggregation lt_sync_* (related to synchronization
 245  * objects), in the snapshot.
 246  */
 247 static int
 248 aggwalk_sync(const dtrace_aggdata_t *data, lt_stat_type_t stat_type)
 249 {
 250         dtrace_aggdesc_t *aggdesc = data->dtada_desc;
 251         pid_t pid;
 252         id_t tid;
 253         uint64_t agg_value;
 254         int stype;
 255         unsigned long long wchan;
 256         enum { REC_PID = 1, REC_TID, REC_STYPE, REC_WCHAN, REC_AGG, NREC };
 257
 258         /* Check action type */
 259         if ((aggdesc->dtagd_nrecs < NREC) ||
 260             (aggdesc->dtagd_rec[REC_PID].dtrd_action != DTRACEACT_DIFEXPR) ||
 261             (aggdesc->dtagd_rec[REC_TID].dtrd_action != DTRACEACT_DIFEXPR) ||
 262             (aggdesc->dtagd_rec[REC_STYPE].dtrd_action != DTRACEACT_DIFEXPR) ||
 263             (aggdesc->dtagd_rec[REC_WCHAN].dtrd_action != DTRACEACT_DIFEXPR) ||
 264             (!DTRACEACT_ISAGG(aggdesc->dtagd_rec[REC_AGG].dtrd_action))) {
 265
 266                 return (-1);
 267         }
 268
 269         pid = rec_get_value(
 270             data->dtada_data + aggdesc->dtagd_rec[REC_PID].dtrd_offset,
 271             aggdesc->dtagd_rec[REC_PID].dtrd_size);
 272
 273         if (SHOULD_IGNORE(pid)) {
 274                 return (0);
 275         }
 276
 277         tid = rec_get_value(
 278             data->dtada_data + aggdesc->dtagd_rec[REC_TID].dtrd_offset,
 279             aggdesc->dtagd_rec[REC_TID].dtrd_size);
 280
 281         stype = rec_get_value(
 282             data->dtada_data + aggdesc->dtagd_rec[REC_STYPE].dtrd_offset,
 283             aggdesc->dtagd_rec[REC_STYPE].dtrd_size);
 284
 285         wchan = rec_get_value(
 286             data->dtada_data + aggdesc->dtagd_rec[REC_WCHAN].dtrd_offset,
 287             aggdesc->dtagd_rec[REC_WCHAN].dtrd_size);
 288
 289         agg_value = rec_get_value(
 290             data->dtada_data + aggdesc->dtagd_rec[REC_AGG].dtrd_offset,
 291             aggdesc->dtagd_rec[REC_AGG].dtrd_size);
 292
 293         lt_stat_update_sobj(pid, tid, stype, wchan, stat_type, agg_value);
 294
 295         return (0);
 296 }
 297
 298 /*
 299  * Callback to process various aggregations in the snapshot. Called by
 300  * different aggwalk_* functions.
 301  */
 302 /* ARGSUSED */
 303 static int
 304 aggwalk(const dtrace_aggdata_t *data, void *arg)
 305 {
 306         char *tmp;
 307         char buffer[32];
 308         lt_stat_type_t stat_type;
 309         int (*func)(const dtrace_aggdata_t *, lt_stat_type_t);
 310
 311         (void) strncpy(buffer, data->dtada_desc->dtagd_name, sizeof (buffer));
 312         buffer[sizeof (buffer) - 1] = '\0';
 313         tmp = strtok(buffer, "_");
 314
 315         if (tmp == NULL || strcmp(tmp, "lt") != 0) {
 316                 goto done;
 317         }
 318
 319         tmp = strtok(NULL, "_");
 320
 321         if (tmp == NULL) {
 322                 goto done;
 323         } else if (strcmp(tmp, "call") == 0) {
 324                 func = aggwalk_call;
 325         } else if (strcmp(tmp, "named") == 0) {
 326                 func = aggwalk_named;
 327         } else if (strcmp(tmp, "sync") == 0) {
 328                 func = aggwalk_sync;
 329         } else {
 330                 goto done;
 331         }
 332
 333         tmp = strtok(NULL, "_");
 334
 335         if (tmp == NULL) {
 336                 goto done;
 337         } else if (strcmp(tmp, "count") == 0) {
 338                 stat_type = LT_STAT_COUNT;
 339         } else if (strcmp(tmp, "sum") == 0) {
 340                 stat_type = LT_STAT_SUM;
 341         } else if (strcmp(tmp, "max") == 0) {
 342                 stat_type = LT_STAT_MAX;
 343         } else {
 344                 goto done;
 345         }
 346
 347         (void) func(data, stat_type);
 348
 349 done:
 350         /* We have our data, so remove it from DTrace now */
 351         return (DTRACE_AGGWALK_REMOVE);
 352 }
 353
 354 /*
 355  * Callback to handle event caused by DTrace dropping data.
 356  */
 357 /*ARGSUSED*/
 358 static int
 359 drop_handler(const dtrace_dropdata_t *data, void *user)
 360 {
 361         lt_display_error("Drop: %s\n", data->dtdda_msg);
 362         lt_drop_detected = B_TRUE;
 363
 364         /* Pretend nothing happened, so just continue */
 365         return (DTRACE_HANDLE_OK);
 366 }
 367
 368 #ifndef EMBED_CONFIGS
 369 /*
 370  * Copy the content from a "real" file into a temp file.
 371  */
 372 static int
 373 copy_tmp_file(const char *src, FILE *dst)
 374 {
 375         FILE *tmp = NULL;
 376         char buffer[256];
 377         int bytes;
 378
 379         if ((tmp = fopen(src, "r")) == NULL) {
 380                 return (-1);
 381         }
 382
 383         while ((bytes = fread(buffer, 1, sizeof (buffer), tmp)) > 0) {
 384                 if (fwrite(buffer, bytes, 1, dst) != 1) {
 385                         return (-1);
 386                 }
 387         }
 388
 389         (void) fclose(tmp);
 390
 391         return (0);
 392 }
 393 #endif
 394
 395 /*
 396  * DTrace initialization. D script starts running when this function returns.
 397  */
 398 int
 399 lt_dtrace_init(void)
 400 {
 401         dtrace_prog_t *prog;
 402         dtrace_proginfo_t info;
 403         int err;
 404         FILE *fp_script = NULL;
 405         char tmp[64];
 406
 407         pid_self = getpid();
 408
 409         if ((g_dtp = dtrace_open(DTRACE_VERSION, 0, &err)) == NULL) {
 410                 lt_display_error("Cannot open dtrace library: %s\n",
 411                     dtrace_errmsg(NULL, err));
 412                 return (-1);
 413         }
 414
 415         if (dtrace_handle_drop(g_dtp, &drop_handler, NULL) == -1) {
 416                 lt_display_error("Cannot install DTrace handle: %s\n",
 417                     dtrace_errmsg(NULL, err));
 418                 return (-1);
 419         }
 420
 421         if (g_config.lt_cfg_enable_filter) {
 422                 if ((err = dtrace_setopt(g_dtp, "define",
 423                     "ENABLE_FILTER")) != 0) {
 424                         lt_display_error(
 425                             "Failed to set option ENABLE_FILTER.\n");
 426                         return (err);
 427                 }
 428         }
 429
 430         if (g_config.lt_cfg_trace_syncobj) {
 431                 if ((err = dtrace_setopt(g_dtp, "define",
 432                     "ENABLE_SYNCOBJ")) != 0) {
 433                         lt_display_error(
 434                             "Failed to set option ENABLE_SYNCOBJ.\n");
 435                         return (err);
 436                 }
 437         }
 438
 439         if (g_config.lt_cfg_trace_sched) {
 440                 if ((err = dtrace_setopt(g_dtp, "define",
 441                     "ENABLE_SCHED")) != 0) {
 442                         lt_display_error(
 443                             "Failed to set option ENABLE_SCHED.\n");
 444                         return (err);
 445                 }
 446         }
 447
 448         if (g_config.lt_cfg_trace_pid != 0) {
 449                 (void) snprintf(tmp, sizeof (tmp), "TRACE_PID=%u",
 450                     g_config.lt_cfg_trace_pid);
 451                 if ((err = dtrace_setopt(g_dtp, "define", tmp)) != 0) {
 452                         lt_display_error(
 453                             "Failed to set option TRACE_PID.\n");
 454                         return (err);
 455                 }
 456         }
 457
 458         if (g_config.lt_cfg_trace_pgid != 0) {
 459                 (void) snprintf(tmp, sizeof (tmp), "TRACE_PGID=%u",
 460                     g_config.lt_cfg_trace_pgid);
 461                 if ((err = dtrace_setopt(g_dtp, "define", tmp)) != 0) {
 462                         lt_display_error(
 463                             "Failed to set option TRACE_PGID.\n");
 464                         return (err);
 465                 }
 466         }
 467
 468         if (g_config.lt_cfg_low_overhead_mode) {
 469                 if ((err = dtrace_setopt(g_dtp, "define",
 470                     "ENABLE_LOW_OVERHEAD")) != 0) {
 471                         lt_display_error(
 472                             "Failed to set option ENABLE_LOW_OVERHEAD.\n");
 473                         return (err);
 474                 }
 475         }
 476
 477         /* Create a temp file; libdtrace needs it for cpp(1) */
 478         if ((fp_script = tmpfile()) == NULL) {
 479                 lt_display_error("Cannot create tmp file\n");
 480                 return (-1);
 481         }
 482
 483         /* Copy the main D script into the temp file */
 484 #ifdef EMBED_CONFIGS
 485         if (fwrite(&latencytop_d_start,
 486             (size_t)(&latencytop_d_end - &latencytop_d_start), 1, fp_script)
 487             != 1) {
 488                 lt_display_error("Could not copy D script, fwrite() failed\n");
 489                 (void) fclose(fp_script);
 490                 return (-1);
 491         }
 492 #else
 493         if (copy_tmp_file(DEFAULT_D_SCRIPT_NAME, fp_script) != 0) {
 494                 lt_display_error("Cannot open script file %s\n",
 495                     DEFAULT_D_SCRIPT_NAME);
 496                 (void) fclose(fp_script);
 497                 return (-1);
 498         }
 499 #endif  /* EMBED_CONFIGS */
 500
 501         if (lt_table_append_trans(fp_script) != 0) {
 502                 (void) fclose(fp_script);
 503                 return (-1);
 504         }
 505
 506         (void) fseek(fp_script, 0, SEEK_SET);
 507
 508         if ((prog = dtrace_program_fcompile(g_dtp, fp_script,
 509             DTRACE_C_CPP, 0, NULL)) == NULL) {
 510                 lt_display_error("Failed to compile D script.\n");
 511                 (void) fclose(fp_script);
 512                 return (dtrace_errno(g_dtp));
 513         }
 514
 515         (void) fclose(fp_script);
 516
 517         /* Execute the D script */
 518         if (dtrace_program_exec(g_dtp, prog, &info) == -1) {
 519                 lt_display_error("Failed to enable probes.\n");
 520                 return (dtrace_errno(g_dtp));
 521         }
 522
 523         if (dtrace_go(g_dtp) != 0) {
 524                 lt_display_error("Failed to run D script.\n");
 525                 return (dtrace_errno(g_dtp));
 526         }
 527
 528         return (0);
 529 }
 530
 531 /*
 532  * Worker function to move aggregate data to user space. Called periodically
 533  * to prevent the kernel from running out of memory.
 534  */
 535 int
 536 lt_dtrace_work(int force)
 537 {
 538         static uint64_t last_snap = 0;
 539         uint64_t now = lt_millisecond();
 540
 541         if (!force && now - last_snap < g_config.lt_cfg_snap_interval) {
 542                 return (last_snap + g_config.lt_cfg_snap_interval - now);
 543         }
 544
 545         if (dtrace_status(g_dtp) == -1) {
 546                 lt_display_error("Failed when getting status: %s\n",
 547                     dtrace_errmsg(g_dtp, dtrace_errno(g_dtp)));
 548                 return (-1);
 549         }
 550
 551         if (dtrace_aggregate_snap(g_dtp) != 0) {
 552                 lt_display_error("Failed to snap aggregate: %s\n",
 553                     dtrace_errmsg(g_dtp, dtrace_errno(g_dtp)));
 554                 return (-1);
 555         }
 556
 557         last_snap = now;
 558         return (0);
 559 }
 560
 561 /*
 562  * Walk through dtrace aggregator and collect data for latencytop to display.
 563  * Called immediately before UI update.
 564  */
 565 int
 566 lt_dtrace_collect(void)
 567 {
 568         if (lt_dtrace_work(1) != 0) {
 569                 return (-1);
 570         }
 571
 572         if (dtrace_aggregate_walk(g_dtp, aggwalk, NULL) != 0) {
 573                 lt_display_error("Failed to sort aggregate: %s\n",
 574                     dtrace_errmsg(g_dtp, dtrace_errno(g_dtp)));
 575                 return (-1);
 576         }
 577
 578         /*
 579          * Probably we don't need to clear again, because we have removed
 580          * everything. Paranoid ?
 581          */
 582         dtrace_aggregate_clear(g_dtp);
 583
 584         return (0);
 585 }
 586
 587 /*
 588  * dtrace clean up.
 589  */
 590 int
 591 lt_dtrace_deinit(void)
 592 {
 593         int ret = 0;
 594
 595         if (dtrace_stop(g_dtp) != 0) {
 596                 lt_display_error("dtrace_stop failed: %s\n",
 597                     dtrace_errmsg(g_dtp, dtrace_errno(g_dtp)));
 598                 ret = -1;
 599         }
 600
 601         dtrace_close(g_dtp);
 602
 603         return (ret);
 604 }