usr/src/cmd/latencytop/common/latencytop.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 <getopt.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <limits.h>
  32 #include <libgen.h>
  33 #include <signal.h>
  34 #include "latencytop.h"
  35
  36 #define CMPOPT(a, b)    strncmp((a), (b), sizeof (b))
  37
  38 /*
  39  * This variable is used to check if "dynamic variable drop" in dtrace
  40  * has happened.
  41  */
  42 boolean_t lt_drop_detected = 0;
  43
  44 lt_config_t g_config;
  45
  46 typedef enum {
  47         LT_CMDOPT_INTERVAL,
  48         LT_CMDOPT_LOG_FILE,
  49         LT_CMDOPT_LOG_LEVEL,
  50         LT_CMDOPT_LOG_INTERVAL,
  51         LT_CMDOPT_CONFIG_FILE,
  52         LT_CMDOPT_F_FILTER,
  53         LT_CMDOPT_F_SCHED,
  54         LT_CMDOPT_F_SOBJ,
  55         LT_CMDOPT_F_LOW,
  56         LT_CMDOPT_SELECT,
  57         LT_CMDOPT__LAST /* Must be the last one */
  58 } lt_cmd_option_id_t;
  59
  60 /*
  61  * Check for duplicate command line options.
  62  * Returns TRUE if duplicate options with different values are found,
  63  * returns FALSE otherwise.
  64  */
  65 static int
  66 check_opt_dup(lt_cmd_option_id_t id, uint64_t value) {
  67
  68         static int opt_set[(int)LT_CMDOPT__LAST];
  69         static uint64_t opt_val[(int)LT_CMDOPT__LAST];
  70
  71         const char *errmsg[] = {
  72                 "-t is set more than once with different values.",
  73                 "-o is set more than once.",
  74                 "-k is set more than once with different values.",
  75                 "-l is set more than once with different values.",
  76                 "-c is set more than once.",
  77                 "-f [no]filter is set more than once with different values.",
  78                 "-f [no]sched is set more than once with different values.",
  79                 "-f [no]sobj is set more than once with different values.",
  80                 "-f [no]low is set more than once with different values.",
  81                 "-s is set more than once with different values."
  82         };
  83
  84         g_assert(sizeof (errmsg)/sizeof (errmsg[0]) == (int)LT_CMDOPT__LAST);
  85
  86         if (!opt_set[(int)id]) {
  87                 opt_set[(int)id] = TRUE;
  88                 opt_val[(int)id] = value;
  89                 return (FALSE);
  90         }
  91
  92         if (opt_val[(int)id] != value) {
  93                 (void) fprintf(stderr, "%s\n", errmsg[(int)id]);
  94                 return (TRUE);
  95         }
  96
  97         return (FALSE);
  98 }
  99
 100 /*
 101  * Print command-line help message.
 102  */
 103 static void
 104 print_usage(const char *execname, int long_help)
 105 {
 106         char buffer[PATH_MAX];
 107         (void) snprintf(buffer, sizeof (buffer), "%s", execname);
 108
 109         if (!long_help) {
 110                 /* Print short help to stderr. */
 111                 (void) fprintf(stderr, "Usage: %s [option(s)], ",
 112                     basename(buffer));
 113                 (void) fprintf(stderr, "use '%s -h' for details.\n",
 114                     basename(buffer));
 115                 return;
 116         }
 117
 118         (void) printf("Usage: %s [option(s)]\n", basename(buffer));
 119         (void) printf("Options:\n"
 120             "    -h, --help\n"
 121             "        Print this help.\n"
 122             "    -t, --interval TIME\n"
 123             "        Set refresh interval to TIME. "
 124             "Valid range [1...60] seconds, default = 5\n"
 125         /*
 126          * Option "-c, --config FILE" is not user-visible for now.
 127          * When we have chance to properly document the format of translation
 128          * rules, we'll make it user-visible.
 129          */
 130             "    -o, --output-log-file FILE\n"
 131             "        Output kernel log to FILE. Default = "
 132             DEFAULT_KLOG_FILE "\n"
 133             "    -k, --kernel-log-level LEVEL\n"
 134             "        Set kernel log level to LEVEL.\n"
 135             "        0(default) = None, 1 = Unmapped, 2 = Mapped, 3 = All.\n"
 136             "    -f, --feature [no]feature1,[no]feature2,...\n"
 137             "        Enable/disable features in LatencyTOP.\n"
 138             "        [no]filter:\n"
 139             "        Filter large interruptible latencies, e.g. sleep.\n"
 140             "        [no]sched:\n"
 141             "        Monitors sched (PID=0).\n"
 142             "        [no]sobj:\n"
 143             "        Monitors synchronization objects.\n"
 144             "        [no]low:\n"
 145             "        Lower overhead by sampling small latencies.\n"
 146             "    -l, --log-period TIME\n"
 147             "        Write and restart log every TIME seconds, TIME >= 60\n"
 148             "    -s --select [ pid=<pid> | pgid=<pgid> ]\n"
 149             "        Monitor only the given process or processes in the "
 150             "given process group.\n");
 151 }
 152
 153 /*
 154  * Properly exit latencytop when it receives SIGINT or SIGTERM.
 155  */
 156 /* ARGSUSED */
 157 static void
 158 signal_handler(int sig)
 159 {
 160         lt_gpipe_break("q");
 161 }
 162
 163 /*
 164  * Convert string to integer. It returns error if extra characters are found.
 165  */
 166 static int
 167 to_int(const char *str, int *result)
 168 {
 169         char *tail = NULL;
 170         long ret;
 171
 172         if (str == NULL || result == NULL) {
 173                 return (-1);
 174         }
 175
 176         ret = strtol(str, &tail, 10);
 177
 178         if (tail != NULL && *tail != '\0') {
 179                 return (-1);
 180         }
 181
 182         *result = (int)ret;
 183
 184         return (0);
 185 }
 186
 187 /*
 188  * The main function.
 189  */
 190 int
 191 main(int argc, char *argv[])
 192 {
 193         const char *opt_string = "t:o:k:hf:l:c:s:";
 194         struct option const longopts[] = {
 195                 {"interval", required_argument, NULL, 't'},
 196                 {"output-log-file", required_argument, NULL, 'o'},
 197                 {"kernel-log-level", required_argument, NULL, 'k'},
 198                 {"help", no_argument, NULL, 'h'},
 199                 {"feature", required_argument, NULL, 'f'},
 200                 {"log-period", required_argument, NULL, 'l'},
 201                 {"config", required_argument, NULL, 'c'},
 202                 {"select", required_argument, NULL, 's'},
 203                 {NULL, 0, NULL, 0}
 204         };
 205
 206         int optc;
 207         int longind = 0;
 208         int running = 1;
 209         int unknown_option = FALSE;
 210         int refresh_interval = 5;
 211         int klog_level = 0;
 212         int log_interval = 0;
 213         long long last_logged = 0;
 214         char *token = NULL;
 215         int retval = 0;
 216         int gpipe;
 217         int err;
 218         uint64_t collect_end;
 219         uint64_t current_time;
 220         uint64_t delta_time;
 221         char logfile[PATH_MAX] = "";
 222         int select_id;
 223         int select_value;
 224         char *select_str;
 225         boolean_t no_dtrace_cleanup = B_TRUE;
 226
 227         lt_gpipe_init();
 228         (void) signal(SIGINT, signal_handler);
 229         (void) signal(SIGTERM, signal_handler);
 230
 231         /* Default global settings */
 232         g_config.lt_cfg_enable_filter = 0;
 233         g_config.lt_cfg_trace_sched = 0;
 234         g_config.lt_cfg_trace_syncobj = 1;
 235         g_config.lt_cfg_low_overhead_mode = 0;
 236         g_config.lt_cfg_trace_pid = 0;
 237         g_config.lt_cfg_trace_pgid = 0;
 238         /* dtrace snapshot every 1 second */
 239         g_config.lt_cfg_snap_interval = 1000;
 240 #ifdef EMBED_CONFIGS
 241         g_config.lt_cfg_config_name = NULL;
 242 #else
 243         g_config.lt_cfg_config_name = lt_strdup(DEFAULT_CONFIG_NAME);
 244 #endif
 245
 246         /* Parse command line arguments. */
 247         while ((optc = getopt_long(argc, argv, opt_string,
 248             longopts, &longind)) != -1) {
 249                 switch (optc) {
 250                 case 'h':
 251                         print_usage(argv[0], TRUE);
 252                         goto end_none;
 253                 case 't':
 254                         if (to_int(optarg, &refresh_interval) != 0 ||
 255                             refresh_interval < 1 || refresh_interval > 60) {
 256                                 lt_display_error(
 257                                     "Invalid refresh interval: %s\n", optarg);
 258                                 unknown_option = TRUE;
 259                         } else if (check_opt_dup(LT_CMDOPT_INTERVAL,
 260                             refresh_interval)) {
 261                                 unknown_option = TRUE;
 262                         }
 263
 264                         break;
 265                 case 'k':
 266                         if (to_int(optarg, &klog_level) != 0 ||
 267                             lt_klog_set_log_level(klog_level) != 0) {
 268                                 lt_display_error(
 269                                     "Invalid log level: %s\n", optarg);
 270                                 unknown_option = TRUE;
 271                         } else if (check_opt_dup(LT_CMDOPT_LOG_LEVEL,
 272                             refresh_interval)) {
 273                                 unknown_option = TRUE;
 274                         }
 275
 276                         break;
 277                 case 'o':
 278                         if (check_opt_dup(LT_CMDOPT_LOG_FILE, optind)) {
 279                                 unknown_option = TRUE;
 280                         } else if (strlen(optarg) >= sizeof (logfile)) {
 281                                 lt_display_error(
 282                                     "Log file name is too long: %s\n",
 283                                     optarg);
 284                                 unknown_option = TRUE;
 285                         } else {
 286                                 (void) strncpy(logfile, optarg,
 287                                     sizeof (logfile));
 288                         }
 289
 290                         break;
 291                 case 'f':
 292                         for (token = strtok(optarg, ","); token != NULL;
 293                             token = strtok(NULL, ",")) {
 294                                 int v = TRUE;
 295
 296                                 if (strncmp(token, "no", 2) == 0) {
 297                                         v = FALSE;
 298                                         token = &token[2];
 299                                 }
 300
 301                                 if (CMPOPT(token, "filter") == 0) {
 302                                         if (check_opt_dup(LT_CMDOPT_F_FILTER,
 303                                             v)) {
 304                                                 unknown_option = TRUE;
 305                                         } else {
 306                                                 g_config.lt_cfg_enable_filter
 307                                                     = v;
 308                                         }
 309                                 } else if (CMPOPT(token, "sched") == 0) {
 310                                         if (check_opt_dup(LT_CMDOPT_F_SCHED,
 311                                             v)) {
 312                                                 unknown_option = TRUE;
 313                                         } else {
 314                                                 g_config.lt_cfg_trace_sched
 315                                                     = v;
 316                                         }
 317                                 } else if (CMPOPT(token, "sobj") == 0) {
 318                                         if (check_opt_dup(LT_CMDOPT_F_SOBJ,
 319                                             v)) {
 320                                                 unknown_option = TRUE;
 321                                         } else {
 322                                                 g_config.lt_cfg_trace_syncobj
 323                                                     = v;
 324                                         }
 325                                 } else if (CMPOPT(token, "low") == 0) {
 326                                         if (check_opt_dup(LT_CMDOPT_F_LOW,
 327                                             v)) {
 328                                                 unknown_option = TRUE;
 329                                         } else {
 330                                                 g_config.
 331                                                     lt_cfg_low_overhead_mode
 332                                                     = v;
 333                                         }
 334                                 } else {
 335                                         lt_display_error(
 336                                             "Unknown feature: %s\n", token);
 337                                         unknown_option = TRUE;
 338                                 }
 339                         }
 340
 341                         break;
 342                 case 'l':
 343                         if (to_int(optarg, &log_interval) != 0 ||
 344                             log_interval < 60) {
 345                                 lt_display_error(
 346                                     "Invalid log interval: %s\n", optarg);
 347                                 unknown_option = TRUE;
 348                         } else if (check_opt_dup(LT_CMDOPT_LOG_INTERVAL,
 349                             log_interval)) {
 350                                 unknown_option = TRUE;
 351                         }
 352
 353                         break;
 354                 case 'c':
 355                         if (strlen(optarg) >= PATH_MAX) {
 356                                 lt_display_error(
 357                                     "Configuration name is too long.\n");
 358                                 unknown_option = TRUE;
 359                         } else if (check_opt_dup(LT_CMDOPT_CONFIG_FILE,
 360                             optind)) {
 361                                 unknown_option = TRUE;
 362                         } else {
 363                                 g_config.lt_cfg_config_name =
 364                                     lt_strdup(optarg);
 365                         }
 366
 367                         break;
 368                 case 's':
 369                         if (strncmp(optarg, "pid=", 4) == 0) {
 370                                 select_id = 0;
 371                                 select_str = &optarg[4];
 372                         } else if (strncmp(optarg, "pgid=", 5) == 0) {
 373                                 select_id = 1;
 374                                 select_str = &optarg[5];
 375                         } else {
 376                                 lt_display_error(
 377                                     "Invalid select option: %s\n", optarg);
 378                                 unknown_option = TRUE;
 379                                 break;
 380                         }
 381
 382                         if (to_int(select_str, &select_value) != 0) {
 383                                 lt_display_error(
 384                                     "Invalid select option: %s\n", optarg);
 385                                 unknown_option = TRUE;
 386                                 break;
 387                         }
 388
 389                         if (select_value <= 0) {
 390                                 lt_display_error(
 391                                     "Process/process group ID must be "
 392                                     "greater than 0: %s\n", optarg);
 393                                 unknown_option = TRUE;
 394                                 break;
 395                         }
 396
 397                         if (check_opt_dup(LT_CMDOPT_SELECT,
 398                             (((uint64_t)select_id) << 32) | select_value)) {
 399                                 unknown_option = TRUE;
 400                                 break;
 401                         }
 402
 403                         if (select_id == 0) {
 404                                 g_config.lt_cfg_trace_pid = select_value;
 405                         } else {
 406                                 g_config.lt_cfg_trace_pgid = select_value;
 407                         }
 408                         break;
 409                 default:
 410                         unknown_option = TRUE;
 411                         break;
 412                 }
 413         }
 414
 415         if (!unknown_option && strlen(logfile) > 0) {
 416                 err = lt_klog_set_log_file(logfile);
 417
 418                 if (err == -1) {
 419                         lt_display_error("Log file name is too long: %s\n",
 420                             logfile);
 421                         unknown_option = TRUE;
 422                 } else if (err == -2) {
 423                         lt_display_error("Cannot write to log file: %s\n",
 424                             logfile);
 425                         unknown_option = TRUE;
 426                 }
 427         }
 428
 429         /* Throw error for invalid/junk arguments */
 430         if (optind  < argc) {
 431                 int tmpind = optind;
 432                 (void) fprintf(stderr, "Unknown option(s): ");
 433
 434                 while (tmpind < argc) {
 435                         (void) fprintf(stderr, "%s ", argv[tmpind++]);
 436                 }
 437
 438                 (void) fprintf(stderr, "\n");
 439                 unknown_option = TRUE;
 440         }
 441
 442         if (unknown_option) {
 443                 print_usage(argv[0], FALSE);
 444                 retval = 1;
 445                 goto end_none;
 446         }
 447
 448         (void) printf("%s\n%s\n", TITLE, COPYRIGHT);
 449
 450         /*
 451          * Initialization
 452          */
 453         lt_klog_init();
 454
 455         if (lt_table_init() != 0) {
 456                 lt_display_error("Unable to load configuration table.\n");
 457                 retval = 1;
 458                 goto end_notable;
 459         }
 460
 461         if (lt_dtrace_init() != 0) {
 462                 lt_display_error("Unable to initialize dtrace.\n");
 463                 retval = 1;
 464                 goto end_nodtrace;
 465         }
 466
 467         last_logged = lt_millisecond();
 468
 469         (void) printf("Collecting data for %d seconds...\n",
 470             refresh_interval);
 471
 472         gpipe = lt_gpipe_readfd();
 473         collect_end = last_logged + refresh_interval * 1000;
 474         for (;;) {
 475                 fd_set read_fd;
 476                 struct timeval timeout;
 477                 int tsleep = collect_end - lt_millisecond();
 478
 479                 if (tsleep <= 0) {
 480                         break;
 481                 }
 482
 483                 /*
 484                  * Interval when we call dtrace_status() and collect
 485                  * aggregated data.
 486                  */
 487                 if (tsleep > g_config.lt_cfg_snap_interval) {
 488                         tsleep = g_config.lt_cfg_snap_interval;
 489                 }
 490
 491                 timeout.tv_sec = tsleep / 1000;
 492                 timeout.tv_usec = (tsleep % 1000) * 1000;
 493
 494                 FD_ZERO(&read_fd);
 495                 FD_SET(gpipe, &read_fd);
 496
 497                 if (select(gpipe + 1, &read_fd, NULL, NULL, &timeout) > 0) {
 498                         goto end_ubreak;
 499                 }
 500
 501                 (void) lt_dtrace_work(0);
 502         }
 503
 504         lt_display_init();
 505
 506         do {
 507                 current_time = lt_millisecond();
 508
 509                 lt_stat_clear_all();
 510                 (void) lt_dtrace_collect();
 511
 512                 delta_time = current_time;
 513                 current_time = lt_millisecond();
 514                 delta_time = current_time - delta_time;
 515
 516                 if (log_interval > 0 &&
 517                     current_time - last_logged > log_interval * 1000) {
 518                         lt_klog_write();
 519                         last_logged = current_time;
 520                 }
 521
 522                 running = lt_display_loop(refresh_interval * 1000 -
 523                     delta_time);
 524
 525                 /*
 526                  * This is to avoid dynamic variable drop
 527                  * in DTrace.
 528                  */
 529                 if (lt_drop_detected == B_TRUE) {
 530                         if (lt_dtrace_deinit() != 0) {
 531                                 no_dtrace_cleanup = B_FALSE;
 532                                 retval = 1;
 533                                 break;
 534                         }
 535
 536                         lt_drop_detected = B_FALSE;
 537                         if (lt_dtrace_init() != 0) {
 538                                 retval = 1;
 539                                 break;
 540                         }
 541                 }
 542         } while (running != 0);
 543
 544         lt_klog_write();
 545
 546         /* Cleanup */
 547         lt_display_deinit();
 548
 549 end_ubreak:
 550         if (no_dtrace_cleanup == B_FALSE || lt_dtrace_deinit() != 0)
 551                 retval = 1;
 552
 553         lt_stat_free_all();
 554
 555 end_nodtrace:
 556         lt_table_deinit();
 557
 558 end_notable:
 559         lt_klog_deinit();
 560
 561 end_none:
 562         lt_gpipe_deinit();
 563
 564         if (g_config.lt_cfg_config_name != NULL) {
 565                 free(g_config.lt_cfg_config_name);
 566         }
 567
 568         return (retval);
 569 }