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 } 605