xref: /onnv-gate/usr/src/cmd/latencytop/common/latencytop.c (revision 10673:b22eb20aa9ca)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2008-2009, Intel Corporation.
 * All Rights Reserved.
 */

#include <unistd.h>
#include <getopt.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <libgen.h>
#include <signal.h>
#include "latencytop.h"

#define	CMPOPT(a, b)	strncmp((a), (b), sizeof (b))

lt_config_t g_config;

typedef enum {
	LT_CMDOPT_INTERVAL,
	LT_CMDOPT_LOG_FILE,
	LT_CMDOPT_LOG_LEVEL,
	LT_CMDOPT_LOG_INTERVAL,
	LT_CMDOPT_CONFIG_FILE,
	LT_CMDOPT_F_FILTER,
	LT_CMDOPT_F_SCHED,
	LT_CMDOPT_F_SOBJ,
	LT_CMDOPT_F_LOW,
	LT_CMDOPT__LAST	/* Must be last one */
} lt_cmd_option_id_t;

/*
 * Check for duplicate command line options.
 * Returns TRUE if duplicate options with different values are found,
 * returns FALSE otherwise.
 */
static int
check_opt_dup(lt_cmd_option_id_t id, uint64_t value) {

	static int opt_set[(int)LT_CMDOPT__LAST];
	static uint64_t opt_val[(int)LT_CMDOPT__LAST];

	const char *errmsg[] = {
		"-t is set more than once with different values.",
		"-o is set more than once.",
		"-k is set more than once with different values.",
		"-l is set more than once with different values.",
		"-c is set more than once.",
		"-f [no]filter is set more than once with different values.",
		"-f [no]sched is set more than once with different values.",
		"-f [no]sobj is set more than once with different values.",
		"-f [no]low is set more than once with different values.",
	};

	g_assert(sizeof (errmsg)/sizeof (errmsg[0]) == (int)LT_CMDOPT__LAST);

	if (!opt_set[(int)id]) {
		opt_set[(int)id] = TRUE;
		opt_val[(int)id] = value;
		return (FALSE);
	}

	if (opt_val[(int)id] != value) {
		(void) fprintf(stderr, "%s\n", errmsg[(int)id]);
		return (TRUE);
	}

	return (FALSE);
}

/*
 * Print command-line help message.
 */
static void
print_usage(const char *execname, int long_help)
{
	char buffer[PATH_MAX];
	(void) snprintf(buffer, sizeof (buffer), "%s", execname);

	if (!long_help) {
		/* Print short help to stderr. */
		(void) fprintf(stderr, "Usage: %s [option(s)], ",
		    basename(buffer));
		(void) fprintf(stderr, "use '%s -h' for details.\n",
		    basename(buffer));
		return;
	}

	(void) printf("Usage: %s [option(s)]\n", basename(buffer));
	(void) printf("Options:\n"
	    "    -h, --help\n"
	    "        Print this help.\n"
	    "    -t, --interval TIME\n"
	    "        Set refresh interval to TIME. "
	    "Valid range [1...60] seconds, default = 5\n"
	/*
	 * Option "-c, --config FILE" is not user-visible for now.
	 * When we have chance to properly document the format of translation
	 * rules, we'll make it user-visible.
	 */
	    "    -o, --output-log-file FILE\n"
	    "        Output kernel log to FILE. Default = "
	    DEFAULT_KLOG_FILE "\n"
	    "    -k, --kernel-log-level LEVEL\n"
	    "        Set kernel log level to LEVEL.\n"
	    "        0(default) = None, 1 = Unmapped, 2 = Mapped, 3 = All.\n"
	    "    -f, --feature [no]feature1,[no]feature2,...\n"
	    "        Enable/disable features in LatencyTOP.\n"
	    "        [no]filter:\n"
	    "        Filter large interruptible latencies, e.g. sleep.\n"
	    "        [no]sched:\n"
	    "        Monitors sched (PID=0).\n"
	    "        [no]sobj:\n"
	    "        Monitors synchronization objects.\n"
	    "        [no]low:\n"
	    "        Lower overhead by sampling small latencies.\n"
	    "    -l, --log-period TIME\n"
	    "        Write and restart log every TIME seconds, TIME >= 60\n");
}

/*
 * Properly exit latencytop when it receives SIGINT or SIGTERM.
 */
/* ARGSUSED */
static void
signal_handler(int sig)
{
	lt_gpipe_break("q");
}

/*
 * Convert string to integer. It returns error if extra characters are found.
 */
static int
to_int(const char *str, int *result)
{
	char *tail = NULL;
	long ret;

	if (str == NULL || result == NULL) {
		return (-1);
	}

	ret = strtol(str, &tail, 10);

	if (tail != NULL && *tail != '\0') {
		return (-1);
	}

	*result = (int)ret;

	return (0);
}

/*
 * The main function.
 */
int
main(int argc, char *argv[])
{
	const char *opt_string = "t:o:k:hf:l:c:";
	struct option const longopts[] = {
		{"interval", required_argument, NULL, 't'},
		{"output-log-file", required_argument, NULL, 'o'},
		{"kernel-log-level", required_argument, NULL, 'k'},
		{"help", no_argument, NULL, 'h'},
		{"feature", required_argument, NULL, 'f'},
		{"log-period", required_argument, NULL, 'l'},
		{"config", required_argument, NULL, 'c'},
		{NULL, 0, NULL, 0}
	};

	int optc;
	int longind = 0;
	int running = 1;
	int unknown_option = FALSE;
	int refresh_interval = 5;
	int klog_level = 0;
	int log_interval = 0;
	long long last_logged = 0;
	char *token = NULL;
	int retval = 0;
	int gpipe;
	int err;
	uint64_t collect_end;
	uint64_t current_time;
	uint64_t delta_time;
	char logfile[PATH_MAX] = "";

	lt_gpipe_init();
	(void) signal(SIGINT, signal_handler);
	(void) signal(SIGTERM, signal_handler);

	/* Default global settings */
	g_config.lt_cfg_enable_filter = 0;
	g_config.lt_cfg_trace_sched = 0;
	g_config.lt_cfg_trace_syncobj = 1;
	g_config.lt_cfg_low_overhead_mode = 0;
	/* dtrace snapshot every 1 second */
	g_config.lt_cfg_snap_interval = 1000;
#ifdef EMBED_CONFIGS
	g_config.lt_cfg_config_name = NULL;
#else
	g_config.lt_cfg_config_name = lt_strdup(DEFAULT_CONFIG_NAME);
#endif

	/* Parse command line arguments. */
	while ((optc = getopt_long(argc, argv, opt_string,
	    longopts, &longind)) != -1) {
		switch (optc) {
		case 'h':
			print_usage(argv[0], TRUE);
			goto end_none;
		case 't':
			if (to_int(optarg, &refresh_interval) != 0 ||
			    refresh_interval < 1 || refresh_interval > 60) {
				lt_display_error(
				    "Invalid refresh interval: %s\n", optarg);
				unknown_option = TRUE;
			} else if (check_opt_dup(LT_CMDOPT_INTERVAL,
			    refresh_interval)) {
				unknown_option = TRUE;
			}

			break;
		case 'k':
			if (to_int(optarg, &klog_level) != 0 ||
			    lt_klog_set_log_level(klog_level) != 0) {
				lt_display_error(
				    "Invalid log level: %s\n", optarg);
				unknown_option = TRUE;
			} else if (check_opt_dup(LT_CMDOPT_LOG_LEVEL,
			    refresh_interval)) {
				unknown_option = TRUE;
			}

			break;
		case 'o':
			if (check_opt_dup(LT_CMDOPT_LOG_FILE, optind)) {
				unknown_option = TRUE;
			} else if (strlen(optarg) >= sizeof (logfile)) {
				lt_display_error(
				    "Log file name is too long: %s\n",
				    optarg);
				unknown_option = TRUE;
			} else {
				(void) strncpy(logfile, optarg,
				    sizeof (logfile));
			}

			break;
		case 'f':
			for (token = strtok(optarg, ","); token != NULL;
			    token = strtok(NULL, ",")) {
				int v = TRUE;

				if (strncmp(token, "no", 2) == 0) {
					v = FALSE;
					token = &token[2];
				}

				if (CMPOPT(token, "filter") == 0) {
					if (check_opt_dup(LT_CMDOPT_F_FILTER,
					    v)) {
						unknown_option = TRUE;
					} else {
						g_config.lt_cfg_enable_filter
						    = v;
					}
				} else if (CMPOPT(token, "sched") == 0) {
					if (check_opt_dup(LT_CMDOPT_F_SCHED,
					    v)) {
						unknown_option = TRUE;
					} else {
						g_config.lt_cfg_trace_sched
						    = v;
					}
				} else if (CMPOPT(token, "sobj") == 0) {
					if (check_opt_dup(LT_CMDOPT_F_SOBJ,
					    v)) {
						unknown_option = TRUE;
					} else {
						g_config.lt_cfg_trace_syncobj
						    = v;
					}
				} else if (CMPOPT(token, "low") == 0) {
					if (check_opt_dup(LT_CMDOPT_F_LOW,
					    v)) {
						unknown_option = TRUE;
					} else {
						g_config.
						    lt_cfg_low_overhead_mode
						    = v;
					}
				} else {
					lt_display_error(
					    "Unknown feature: %s\n", token);
					unknown_option = TRUE;
				}
			}

			break;
		case 'l':
			if (to_int(optarg, &log_interval) != 0 ||
			    log_interval < 60) {
				lt_display_error(
				    "Invalid log interval: %s\n", optarg);
				unknown_option = TRUE;
			} else if (check_opt_dup(LT_CMDOPT_LOG_INTERVAL,
			    log_interval)) {
				unknown_option = TRUE;
			}

			break;
		case 'c':
			if (strlen(optarg) >= PATH_MAX) {
				lt_display_error(
				    "Configuration name is too long.\n");
				unknown_option = TRUE;
			} else if (check_opt_dup(LT_CMDOPT_CONFIG_FILE,
			    optind)) {
				unknown_option = TRUE;
			} else {
				g_config.lt_cfg_config_name =
				    lt_strdup(optarg);
			}

			break;
		default:
			unknown_option = TRUE;
			break;
		}
	}

	if (!unknown_option && strlen(logfile) > 0) {
		err = lt_klog_set_log_file(logfile);

		if (err == -1) {
			lt_display_error("Log file name is too long: %s\n",
			    logfile);
			unknown_option = TRUE;
		} else if (err == -2) {
			lt_display_error("Cannot write to log file: %s\n",
			    logfile);
			unknown_option = TRUE;
		}
	}

	/* Throw error for invalid/junk arguments */
	if (optind  < argc) {
		int tmpind = optind;
		(void) fprintf(stderr, "Unknown option(s): ");

		while (tmpind < argc) {
			(void) fprintf(stderr, "%s ", argv[tmpind++]);
		}

		(void) fprintf(stderr, "\n");
		unknown_option = TRUE;
	}

	if (unknown_option) {
		print_usage(argv[0], FALSE);
		retval = 1;
		goto end_none;
	}

	(void) printf("%s\n%s\n", TITLE, COPYRIGHT);

	/*
	 * Initialization
	 */
	lt_klog_init();

	if (lt_table_init() != 0) {
		lt_display_error("Unable to load configuration table.\n");
		retval = 1;
		goto end_notable;
	}

	if (lt_dtrace_init() != 0) {
		lt_display_error("Unable to initialize dtrace.\n");
		retval = 1;
		goto end_nodtrace;
	}

	last_logged = lt_millisecond();

	(void) printf("Collecting data for %d seconds...\n",
	    refresh_interval);

	gpipe = lt_gpipe_readfd();
	collect_end = last_logged + refresh_interval * 1000;
	for (;;) {
		fd_set read_fd;
		struct timeval timeout;
		int tsleep = collect_end - lt_millisecond();

		if (tsleep <= 0) {
			break;
		}

		if (tsleep > g_config.lt_cfg_snap_interval * 1000) {
			tsleep = g_config.lt_cfg_snap_interval * 1000;
		}

		timeout.tv_sec = tsleep / 1000;
		timeout.tv_usec = (tsleep % 1000) * 1000;

		FD_ZERO(&read_fd);
		FD_SET(gpipe, &read_fd);

		if (select(gpipe + 1, &read_fd, NULL, NULL, &timeout) > 0) {
			goto end_ubreak;
		}

		(void) lt_dtrace_work(0);
	}

	lt_display_init();

	do {
		current_time = lt_millisecond();

		lt_stat_clear_all();
		(void) lt_dtrace_collect();

		delta_time = current_time;
		current_time = lt_millisecond();
		delta_time = current_time - delta_time;

		if (log_interval > 0 &&
		    current_time - last_logged > log_interval * 1000) {
			lt_klog_write();
			last_logged = current_time;
		}

		running = lt_display_loop(refresh_interval * 1000 -
		    delta_time);
	} while (running != 0);

	lt_klog_write();

	/* Cleanup */
	lt_display_deinit();

end_ubreak:
	lt_dtrace_deinit();
	lt_stat_free_all();

end_nodtrace:
	lt_table_deinit();

end_notable:
	lt_klog_deinit();

end_none:
	lt_gpipe_deinit();

	if (g_config.lt_cfg_config_name != NULL) {
		free(g_config.lt_cfg_config_name);
	}

	return (retval);
}