int main(int argc, char **argv)
{
int i;
int config_loaded = 0;
int dont_fork = 0;
size_t wanted_stacksize = 0, stacksize = 0;
pthread_attr_t attr;
// global initialization
get_HZ();
// set the name for logging
program_name = "netdata";
// parse command line.
// parse depercated options
// TODO: Remove this block with the next major release.
{
i = 1;
while(i < argc) {
if(strcmp(argv[i], "-pidfile") == 0 && (i+1) < argc) {
strncpyz(pidfile, argv[i+1], FILENAME_MAX);
fprintf(stderr, "%s: deprecated option -- %s -- please use -P instead.\n", argv[0], argv[i]);
remove_option(i, &argc, argv);
}
else if(strcmp(argv[i], "-nodaemon") == 0 || strcmp(argv[i], "-nd") == 0) {
dont_fork = 1;
fprintf(stderr, "%s: deprecated option -- %s -- please use -D instead.\n ", argv[0], argv[i]);
remove_option(i, &argc, argv);
}
else if(strcmp(argv[i], "-ch") == 0 && (i+1) < argc) {
config_set("global", "host access prefix", argv[i+1]);
fprintf(stderr, "%s: deprecated option -- %s -- please use -s instead.\n", argv[0], argv[i]);
remove_option(i, &argc, argv);
}
else if(strcmp(argv[i], "-l") == 0 && (i+1) < argc) {
config_set("global", "history", argv[i+1]);
fprintf(stderr, "%s: deprecated option -- %s -- This option will be removed with V2.*.\n", argv[0], argv[i]);
remove_option(i, &argc, argv);
}
else i++;
}
}
// parse options
{
int num_opts = sizeof(options) / sizeof(struct option_def);
char optstring[(num_opts * 2) + 1];
int string_i = 0;
for( i = 0; i < num_opts; i++ ) {
optstring[string_i] = options[i].val;
string_i++;
if(options[i].arg_name) {
optstring[string_i] = ':';
string_i++;
}
}
int opt;
while( (opt = getopt(argc, argv, optstring)) != -1 ) {
switch(opt) {
case 'c':
if(load_config(optarg, 1) != 1) {
error("Cannot load configuration file %s.", optarg);
exit(1);
}
else {
debug(D_OPTIONS, "Configuration loaded from %s.", optarg);
config_loaded = 1;
}
break;
case 'D':
dont_fork = 1;
break;
case 'h':
help(0);
break;
case 'i':
config_set("global", "bind to", optarg);
break;
case 'P':
strncpy(pidfile, optarg, FILENAME_MAX);
pidfile[FILENAME_MAX] = '\0';
break;
case 'p':
config_set("global", "default port", optarg);
break;
case 's':
config_set("global", "host access prefix", optarg);
break;
case 't':
config_set("global", "update every", optarg);
break;
case 'u':
config_set("global", "run as user", optarg);
break;
case 'v':
// TODO: Outsource version to makefile which can compute version from git.
printf("netdata 1.2.1_master\n");
return 0;
break;
case 'W':
{
char* stacksize = "stacksize=";
char* debug_flags_string = "debug_flags=";
if(strcmp(optarg, "unittest") == 0) {
rrd_update_every = 1;
if(run_all_mockup_tests()) exit(1);
if(unit_test_storage()) exit(1);
fprintf(stderr, "\n\nALL TESTS PASSED\n\n");
exit(0);
} else if(strncmp(optarg, stacksize, strlen(stacksize)) == 0) {
optarg += strlen(stacksize);
config_set("global", "pthread stack size", optarg);
} else if(strncmp(optarg, debug_flags_string, strlen(debug_flags_string)) == 0) {
optarg += strlen(debug_flags_string);
config_set("global", "debug flags", optarg);
debug_flags = strtoull(optarg, NULL, 0);
}
}
break;
default: /* ? */
help(1);
break;
}
}
}
if(!config_loaded) load_config(NULL, 0);
// prepare configuration environment variables for the plugins
setenv("NETDATA_CONFIG_DIR" , config_get("global", "config directory" , CONFIG_DIR) , 1);
setenv("NETDATA_PLUGINS_DIR", config_get("global", "plugins directory" , PLUGINS_DIR), 1);
setenv("NETDATA_WEB_DIR" , config_get("global", "web files directory", WEB_DIR) , 1);
setenv("NETDATA_CACHE_DIR" , config_get("global", "cache directory" , CACHE_DIR) , 1);
setenv("NETDATA_LIB_DIR" , config_get("global", "lib directory" , VARLIB_DIR) , 1);
setenv("NETDATA_LOG_DIR" , config_get("global", "log directory" , LOG_DIR) , 1);
setenv("NETDATA_HOST_PREFIX", config_get("global", "host access prefix" , "") , 1);
setenv("HOME" , config_get("global", "home directory" , CACHE_DIR) , 1);
// disable buffering for python plugins
setenv("PYTHONUNBUFFERED", "1", 1);
// avoid flood calls to stat(/etc/localtime)
// http://stackoverflow.com/questions/4554271/how-to-avoid-excessive-stat-etc-localtime-calls-in-strftime-on-linux
setenv("TZ", ":/etc/localtime", 0);
{
char path[1024 + 1], *p = getenv("PATH");
if(!p) p = "/bin:/usr/bin";
snprintfz(path, 1024, "%s:%s", p, "/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin");
setenv("PATH", config_get("plugins", "PATH environment variable", path), 1);
}
// cd to /tmp to avoid any plugins writing files at random places
if(chdir("/tmp")) error("netdata: ERROR: Cannot cd to /tmp");
char *input_log_file = NULL;
char *output_log_file = NULL;
char *error_log_file = NULL;
char *access_log_file = NULL;
char *user = NULL;
{
char *flags = config_get("global", "debug flags", "0x00000000");
setenv("NETDATA_DEBUG_FLAGS", flags, 1);
debug_flags = strtoull(flags, NULL, 0);
debug(D_OPTIONS, "Debug flags set to '0x%8llx'.", debug_flags);
if(debug_flags != 0) {
struct rlimit rl = { RLIM_INFINITY, RLIM_INFINITY };
if(setrlimit(RLIMIT_CORE, &rl) != 0)
info("Cannot request unlimited core dumps for debugging... Proceeding anyway...");
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
// --------------------------------------------------------------------
#ifdef MADV_MERGEABLE
enable_ksm = config_get_boolean("global", "memory deduplication (ksm)", enable_ksm);
#else
#warning "Kernel memory deduplication (KSM) is not available"
#endif
// --------------------------------------------------------------------
global_host_prefix = config_get("global", "host access prefix", "");
setenv("NETDATA_HOST_PREFIX", global_host_prefix, 1);
// --------------------------------------------------------------------
output_log_file = config_get("global", "debug log", LOG_DIR "/debug.log");
if(strcmp(output_log_file, "syslog") == 0) {
output_log_syslog = 1;
output_log_file = NULL;
}
else if(strcmp(output_log_file, "none") == 0) {
output_log_syslog = 0;
output_log_file = NULL;
}
else output_log_syslog = 0;
// --------------------------------------------------------------------
error_log_file = config_get("global", "error log", LOG_DIR "/error.log");
if(strcmp(error_log_file, "syslog") == 0) {
error_log_syslog = 1;
error_log_file = NULL;
}
else if(strcmp(error_log_file, "none") == 0) {
error_log_syslog = 0;
error_log_file = NULL;
// optimization - do not even generate debug log entries
}
else error_log_syslog = 0;
error_log_throttle_period = config_get_number("global", "errors flood protection period", error_log_throttle_period);
setenv("NETDATA_ERRORS_THROTTLE_PERIOD", config_get("global", "errors flood protection period" , ""), 1);
error_log_errors_per_period = (unsigned long)config_get_number("global", "errors to trigger flood protection", error_log_errors_per_period);
setenv("NETDATA_ERRORS_PER_PERIOD" , config_get("global", "errors to trigger flood protection", ""), 1);
// --------------------------------------------------------------------
access_log_file = config_get("global", "access log", LOG_DIR "/access.log");
if(strcmp(access_log_file, "syslog") == 0) {
access_log_syslog = 1;
access_log_file = NULL;
}
else if(strcmp(access_log_file, "none") == 0) {
access_log_syslog = 0;
access_log_file = NULL;
}
else access_log_syslog = 0;
// --------------------------------------------------------------------
rrd_memory_mode = rrd_memory_mode_id(config_get("global", "memory mode", rrd_memory_mode_name(rrd_memory_mode)));
// --------------------------------------------------------------------
{
char hostnamebuf[HOSTNAME_MAX + 1];
if(gethostname(hostnamebuf, HOSTNAME_MAX) == -1)
error("WARNING: Cannot get machine hostname.");
hostname = config_get("global", "hostname", hostnamebuf);
debug(D_OPTIONS, "hostname set to '%s'", hostname);
}
// --------------------------------------------------------------------
rrd_default_history_entries = (int) config_get_number("global", "history", RRD_DEFAULT_HISTORY_ENTRIES);
if(rrd_default_history_entries < 5 || rrd_default_history_entries > RRD_HISTORY_ENTRIES_MAX) {
info("Invalid save lines %d given. Defaulting to %d.", rrd_default_history_entries, RRD_DEFAULT_HISTORY_ENTRIES);
rrd_default_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
}
else {
debug(D_OPTIONS, "save lines set to %d.", rrd_default_history_entries);
}
// --------------------------------------------------------------------
rrd_update_every = (int) config_get_number("global", "update every", UPDATE_EVERY);
if(rrd_update_every < 1 || rrd_update_every > 600) {
info("Invalid update timer %d given. Defaulting to %d.", rrd_update_every, UPDATE_EVERY_MAX);
rrd_update_every = UPDATE_EVERY;
}
else debug(D_OPTIONS, "update timer set to %d.", rrd_update_every);
// let the plugins know the min update_every
{
char buf[16];
snprintfz(buf, 15, "%d", rrd_update_every);
setenv("NETDATA_UPDATE_EVERY", buf, 1);
}
// --------------------------------------------------------------------
// block signals while initializing threads.
// this causes the threads to block signals.
sigset_t sigset;
sigfillset(&sigset);
if(pthread_sigmask(SIG_BLOCK, &sigset, NULL) == -1) {
error("Could not block signals for threads");
}
// Catch signals which we want to use to quit savely
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, SIGHUP);
sigaddset(&sa.sa_mask, SIGINT);
sigaddset(&sa.sa_mask, SIGTERM);
sa.sa_handler = sig_handler_exit;
sa.sa_flags = 0;
if(sigaction(SIGHUP, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGHUP");
}
if(sigaction(SIGINT, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGINT");
}
if(sigaction(SIGTERM, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGTERM");
}
// save database on SIGUSR1
sa.sa_handler = sig_handler_save;
if(sigaction(SIGUSR1, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGUSR1");
}
// Ignore SIGPIPE completely.
// INFO: If we add signals here we have to unblock them
// at popen.c when running a external plugin.
sa.sa_handler = SIG_IGN;
if(sigaction(SIGPIPE, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGPIPE");
}
// --------------------------------------------------------------------
i = pthread_attr_init(&attr);
if(i != 0)
fatal("pthread_attr_init() failed with code %d.", i);
i = pthread_attr_getstacksize(&attr, &stacksize);
if(i != 0)
fatal("pthread_attr_getstacksize() failed with code %d.", i);
else
debug(D_OPTIONS, "initial pthread stack size is %zu bytes", stacksize);
wanted_stacksize = config_get_number("global", "pthread stack size", stacksize);
// --------------------------------------------------------------------
for (i = 0; static_threads[i].name != NULL ; i++) {
struct netdata_static_thread *st = &static_threads[i];
if(st->config_name) st->enabled = config_get_boolean(st->config_section, st->config_name, st->enabled);
if(st->enabled && st->init_routine) st->init_routine();
}
// --------------------------------------------------------------------
// get the user we should run
// IMPORTANT: this is required before web_files_uid()
user = config_get("global", "run as user" , (getuid() == 0)?NETDATA_USER:"");
// IMPORTANT: these have to run once, while single threaded
web_files_uid(); // IMPORTANT: web_files_uid() before web_files_gid()
web_files_gid();
// --------------------------------------------------------------------
create_listen_sockets();
}
// never become a problem
if(nice(20) == -1) error("Cannot lower my CPU priority.");
if(become_daemon(dont_fork, 0, user, input_log_file, output_log_file, error_log_file, access_log_file, &access_fd, &stdaccess) == -1)
fatal("Cannot demonize myself.");
#ifdef NETDATA_INTERNAL_CHECKS
if(debug_flags != 0) {
struct rlimit rl = { RLIM_INFINITY, RLIM_INFINITY };
if(setrlimit(RLIMIT_CORE, &rl) != 0)
info("Cannot request unlimited core dumps for debugging... Proceeding anyway...");
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
#endif /* NETDATA_INTERNAL_CHECKS */
if(output_log_syslog || error_log_syslog || access_log_syslog)
openlog("netdata", LOG_PID, LOG_DAEMON);
info("NetData started on pid %d", getpid());
// ------------------------------------------------------------------------
// get default pthread stack size
if(stacksize < wanted_stacksize) {
i = pthread_attr_setstacksize(&attr, wanted_stacksize);
if(i != 0)
fatal("pthread_attr_setstacksize() to %zu bytes, failed with code %d.", wanted_stacksize, i);
else
info("Successfully set pthread stacksize to %zu bytes", wanted_stacksize);
}
// --------------------------------------------------------------------
// initialize the registry
registry_init();
// ------------------------------------------------------------------------
// spawn the threads
web_server_threading_selection();
for (i = 0; static_threads[i].name != NULL ; i++) {
struct netdata_static_thread *st = &static_threads[i];
if(st->enabled) {
st->thread = malloc(sizeof(pthread_t));
if(!st->thread)
fatal("Cannot allocate pthread_t memory");
info("Starting thread %s.", st->name);
if(pthread_create(st->thread, &attr, st->start_routine, NULL))
error("failed to create new thread for %s.", st->name);
else if(pthread_detach(*st->thread))
error("Cannot request detach of newly created %s thread.", st->name);
}
else info("Not starting thread %s.", st->name);
}
// ------------------------------------------------------------------------
// block signals while initializing threads.
sigset_t sigset;
sigfillset(&sigset);
if(pthread_sigmask(SIG_UNBLOCK, &sigset, NULL) == -1) {
error("Could not unblock signals for threads");
}
// Handle flags set in the signal handler.
while(1) {
pause();
if(netdata_exit) {
info("Exit main loop of netdata.");
netdata_cleanup_and_exit(0);
exit(0);
}
}
}
/*
***************************************************************************
* Main entry to the iostat program.
***************************************************************************
*/
int main(int argc, char **argv)
{
int it = 0;
int opt = 1;
int i, report_set = FALSE;
long count = 1;
struct utsname header;
struct io_dlist *st_dev_list_i;
struct tm rectime;
char *t, *persist_devname, *devname;
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
/* Get HZ */
get_HZ();
/* Allocate structures for device list */
if (argc > 1) {
salloc_dev_list(argc - 1 + count_csvalues(argc, argv));
}
/* Process args... */
while (opt < argc) {
/* -p option used individually. See below for grouped use */
if (!strcmp(argv[opt], "-p")) {
flags |= I_D_PARTITIONS;
if (argv[++opt] &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt])) &&
(strncmp(argv[opt], "-", 1))) {
flags |= I_D_UNFILTERED;
for (t = strtok(argv[opt], ","); t; t = strtok(NULL, ",")) {
if (!strcmp(t, K_ALL)) {
flags |= I_D_PART_ALL;
}
else {
devname = device_name(t);
if (DISPLAY_PERSIST_NAME_I(flags)) {
/* Get device persistent name */
persist_devname = get_pretty_name_from_persistent(devname);
if (persist_devname != NULL) {
devname = persist_devname;
}
}
/* Store device name */
i = update_dev_list(&dlist_idx, devname);
st_dev_list_i = st_dev_list + i;
st_dev_list_i->disp_part = TRUE;
}
}
opt++;
}
else {
flags |= I_D_PART_ALL;
}
}
else if (!strcmp(argv[opt], "-g")) {
/*
* Option -g: Stats for a group of devices.
* group_name contains the last group name entered on
* the command line. If we define an additional one, save
* the previous one in the list. We do that this way because we
* want the group name to appear in the list _after_ all
* the devices included in that group. The last group name
* will be saved in the list later, in presave_device_list() function.
*/
if (group_nr > 0) {
update_dev_list(&dlist_idx, group_name);
}
if (argv[++opt]) {
/*
* MAX_NAME_LEN - 2: one char for the heading space,
* and one for the trailing '\0'.
*/
snprintf(group_name, MAX_NAME_LEN, " %-.*s", MAX_NAME_LEN - 2, argv[opt++]);
}
else {
usage(argv[0]);
}
group_nr++;
}
else if (!strcmp(argv[opt], "-j")) {
if (argv[++opt]) {
if (strnlen(argv[opt], MAX_FILE_LEN) >= MAX_FILE_LEN - 1) {
usage(argv[0]);
}
strncpy(persistent_name_type, argv[opt], MAX_FILE_LEN - 1);
persistent_name_type[MAX_FILE_LEN - 1] = '\0';
strtolower(persistent_name_type);
/* Check that this is a valid type of persistent device name */
if (!get_persistent_type_dir(persistent_name_type)) {
fprintf(stderr, _("Invalid type of persistent device name\n"));
exit(1);
}
/*
* Persistent names are usually long: Display
* them as human readable by default.
*/
flags |= I_D_PERSIST_NAME + I_D_HUMAN_READ;
opt++;
}
else {
usage(argv[0]);
}
}
#ifdef DEBUG
else if (!strcmp(argv[opt], "--debuginfo")) {
flags |= I_D_DEBUG;
opt++;
}
#endif
else if (!strncmp(argv[opt], "-", 1)) {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'c':
/* Display cpu usage */
flags |= I_D_CPU;
report_set = TRUE;
break;
case 'd':
/* Display disk utilization */
flags |= I_D_DISK;
report_set = TRUE;
break;
case 'h':
/*
* Display device utilization report
* in a human readable format.
*/
flags |= I_D_HUMAN_READ;
break;
case 'k':
if (DISPLAY_MEGABYTES(flags)) {
usage(argv[0]);
}
/* Display stats in kB/s */
flags |= I_D_KILOBYTES;
break;
case 'm':
if (DISPLAY_KILOBYTES(flags)) {
usage(argv[0]);
}
/* Display stats in MB/s */
flags |= I_D_MEGABYTES;
break;
case 'N':
/* Display device mapper logical name */
flags |= I_D_DEVMAP_NAME;
break;
case 'p':
/* If option -p is grouped then it cannot take an arg */
flags |= I_D_PARTITIONS + I_D_PART_ALL;
break;
case 'T':
/* Display stats only for the groups */
flags |= I_D_GROUP_TOTAL_ONLY;
break;
case 't':
/* Display timestamp */
flags |= I_D_TIMESTAMP;
break;
case 'x':
/* Display extended stats */
flags |= I_D_EXTENDED;
break;
case 'y':
/* Don't display stats since system restart */
flags |= I_D_OMIT_SINCE_BOOT;
break;
case 'z':
/* Omit output for devices with no activity */
flags |= I_D_ZERO_OMIT;
break;
case 'V':
/* Print version number and exit */
print_version();
break;
default:
usage(argv[0]);
}
}
opt++;
}
else if (!isdigit(argv[opt][0])) {
/*
* By default iostat doesn't display unused devices.
* If some devices are explictly entered on the command line
* then don't apply this rule any more.
*/
flags |= I_D_UNFILTERED;
if (strcmp(argv[opt], K_ALL)) {
/* Store device name entered on the command line */
devname = device_name(argv[opt++]);
if (DISPLAY_PERSIST_NAME_I(flags)) {
persist_devname = get_pretty_name_from_persistent(devname);
if (persist_devname != NULL) {
devname = persist_devname;
}
}
update_dev_list(&dlist_idx, devname);
}
else {
opt++;
}
}
else if (!it) {
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
count = -1;
it = 1;
}
else if (it > 0) {
count = atol(argv[opt++]);
if ((count < 1) || !interval) {
usage(argv[0]);
}
it = -1;
}
else {
usage(argv[0]);
}
}
if (!interval) {
count = 1;
}
/* Default: Display CPU and DISK reports */
if (!report_set) {
flags |= I_D_CPU + I_D_DISK;
}
/*
* Also display DISK reports if options -p, -x or a device has been entered
* on the command line.
*/
if (DISPLAY_PARTITIONS(flags) || DISPLAY_EXTENDED(flags) ||
DISPLAY_UNFILTERED(flags)) {
flags |= I_D_DISK;
}
/* Option -T can only be used with option -g */
if (DISPLAY_GROUP_TOTAL_ONLY(flags) && !group_nr) {
usage(argv[0]);
}
/* Select disk output unit (kB/s or blocks/s) */
set_disk_output_unit();
/* Ignore device list if '-p ALL' entered on the command line */
if (DISPLAY_PART_ALL(flags)) {
dlist_idx = 0;
}
if (DISPLAY_DEVMAP_NAME(flags)) {
dm_major = get_devmap_major();
}
/* Init structures according to machine architecture */
io_sys_init();
if (group_nr > 0) {
/*
* If groups of devices have been defined
* then save devices and groups in the list.
*/
presave_device_list();
}
get_localtime(&rectime, 0);
/* Get system name, release number and hostname */
uname(&header);
if (print_gal_header(&rectime, header.sysname, header.release,
header.nodename, header.machine, cpu_nr)) {
flags |= I_D_ISO;
}
printf("\n");
/* Set a handler for SIGALRM */
memset(&alrm_act, 0, sizeof(alrm_act));
alrm_act.sa_handler = alarm_handler;
sigaction(SIGALRM, &alrm_act, NULL);
alarm(interval);
/* Main loop */
rw_io_stat_loop(count, &rectime);
/* Free structures */
io_sys_free();
sfree_dev_list();
return 0;
}
/*
***************************************************************************
* Main entry to the sar program.
***************************************************************************
*/
int main(int argc, char **argv)
{
int i, rc, opt = 1, args_idx = 2;
int fd[2];
int day_offset = 0;
char from_file[MAX_FILE_LEN], to_file[MAX_FILE_LEN];
char ltemp[20];
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
from_file[0] = to_file[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt]) {
/* Parse -I option */
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-D")) {
/* Option to tell sar to write to saYYYYMMDD data files */
flags |= S_F_SA_YYYYMMDD;
opt++;
}
else if (!strcmp(argv[opt], "-P")) {
/* Parse -P option */
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-o")) {
if (to_file[0]) {
/* Output file already specified */
usage(argv[0]);
}
/* Save stats to a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(to_file, argv[opt++], MAX_FILE_LEN);
to_file[MAX_FILE_LEN - 1] = '\0';
}
else {
strcpy(to_file, "-");
}
}
else if (!strcmp(argv[opt], "-f")) {
if (from_file[0]) {
/* Input file already specified */
usage(argv[0]);
}
/* Read stats from a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(from_file, argv[opt++], MAX_FILE_LEN);
from_file[MAX_FILE_LEN - 1] = '\0';
/* Check if this is an alternate directory for sa files */
check_alt_sa_dir(from_file, day_offset, -1);
}
else {
set_default_file(from_file, day_offset, -1);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-h")) {
/* Display help message */
display_help(argv[0]);
}
else if (!strcmp(argv[opt], "-i")) {
if (!argv[++opt] || (strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 1) {
usage(argv[0]);
}
flags |= S_F_INTERVAL_SET;
}
else if (!strcmp(argv[opt], "-m")) {
if (argv[++opt]) {
/* Parse option -m */
if (parse_sar_m_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt]) {
/* Parse option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if ((strlen(argv[opt]) > 1) &&
(strlen(argv[opt]) < 4) &&
!strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt] + 1, DIGITS) == (strlen(argv[opt]) - 1))) {
day_offset = atoi(argv[opt++] + 1);
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if ((rc = parse_sar_opt(argv, &opt, act, &flags, C_SAR)) != 0) {
if (rc == 1) {
usage(argv[0]);
}
exit(1);
}
opt++;
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if ((strspn(argv[opt], DIGITS) != strlen(argv[opt])) ||
!interval) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 1) {
usage(argv[0]);
}
}
}
/* 'sar' is equivalent to 'sar -f' */
if ((argc == 1) ||
((interval < 0) && !from_file[0] && !to_file[0])) {
set_default_file(from_file, day_offset, -1);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
/*
* Check option dependencies.
*/
/* You read from a file OR you write to it... */
if (from_file[0] && to_file[0]) {
fprintf(stderr, _("-f and -o options are mutually exclusive\n"));
exit(1);
}
/* Use time start or option -i only when reading stats from a file */
if ((tm_start.use || INTERVAL_SET(flags)) && !from_file[0]) {
fprintf(stderr,
_("Not reading from a system activity file (use -f option)\n"));
exit(1);
}
/* Don't print stats since boot time if -o or -f options are used */
if (!interval && (from_file[0] || to_file[0])) {
usage(argv[0]);
}
/* Cannot enter a day shift with -o option */
if (to_file[0] && day_offset) {
usage(argv[0]);
}
if (USE_PRETTY_OPTION(flags)) {
dm_major = get_devmap_major();
}
if (!count) {
/*
* count parameter not set: Display all the contents of the file
* or generate a report continuously.
*/
count = -1;
}
/* Default is CPU activity... */
select_default_activity(act);
/* Reading stats from file: */
if (from_file[0]) {
if (interval < 0) {
interval = 1;
}
/* Read stats from file */
read_stats_from_file(from_file);
/* Free stuctures and activity bitmaps */
free_bitmaps(act);
free_structures(act);
return 0;
}
/* Reading stats from sadc: */
/* Create anonymous pipe */
if (pipe(fd) == -1) {
perror("pipe");
exit(4);
}
switch (fork()) {
case -1:
perror("fork");
exit(4);
break;
case 0: /* Child */
if (dup2(fd[1], STDOUT_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/*
* Prepare options for sadc.
*/
/* Program name */
salloc(0, SADC);
/* Interval value */
if (interval < 0) {
usage(argv[0]);
}
else if (!interval) {
strcpy(ltemp, "1");
}
else {
sprintf(ltemp, "%ld", interval);
}
salloc(1, ltemp);
/* Count number */
if (count >= 0) {
sprintf(ltemp, "%ld", count + 1);
salloc(args_idx++, ltemp);
}
/* Flags to be passed to sadc */
salloc(args_idx++, "-z");
/* Writing data to a file (option -o) */
if (to_file[0]) {
/* Set option -D if entered */
if (USE_SA_YYYYMMDD(flags)) {
salloc(args_idx++, "-D");
}
/* Collect all possible activities (option -S XALL for sadc) */
salloc(args_idx++, "-S");
salloc(args_idx++, K_XALL);
/* Outfile arg */
salloc(args_idx++, to_file);
}
else {
/*
* If option -o hasn't been used, then tell sadc
* to collect only activities that will be displayed.
*/
int act_id = 0;
for (i = 0; i < NR_ACT; i++) {
if (IS_SELECTED(act[i]->options)) {
act_id |= act[i]->group;
}
}
if (act_id) {
act_id <<= 8;
snprintf(ltemp, 19, "%d", act_id);
ltemp[19] = '\0';
salloc(args_idx++, "-S");
salloc(args_idx++, ltemp);
}
}
/* Last arg is NULL */
args[args_idx] = NULL;
/* Call now the data collector */
execv(SADC_PATH, args);
execvp(SADC, args);
/*
* Note: Don't use execl/execlp since we don't have a fixed number of
* args to give to sadc.
*/
fprintf(stderr, _("Cannot find the data collector (%s)\n"), SADC);
perror("exec");
exit(4);
break;
default: /* Parent */
if (dup2(fd[0], STDIN_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/* Get now the statistics */
read_stats();
break;
}
/* Free structures and activity bitmaps */
free_bitmaps(act);
free_structures(act);
return 0;
}
/*
***************************************************************************
* Main entry to the cifsiostat program.
***************************************************************************
*/
int main(int argc, char **argv)
{
int it = 0;
int opt = 1;
int i;
long count = 1;
struct utsname header;
struct tm rectime;
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
/* Get HZ */
get_HZ();
/* Process args... */
while (opt < argc) {
#ifdef DEBUG
if (!strcmp(argv[opt], "--debuginfo")) {
flags |= I_D_DEBUG;
opt++;
} else
#endif
if (!strncmp(argv[opt], "-", 1)) {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'h':
/* Display an easy-to-read CIFS report */
flags |= I_D_HUMAN_READ;
break;
case 'k':
if (DISPLAY_MEGABYTES(flags)) {
usage(argv[0]);
}
/* Display stats in kB/s */
flags |= I_D_KILOBYTES;
break;
case 'm':
if (DISPLAY_KILOBYTES(flags)) {
usage(argv[0]);
}
/* Display stats in MB/s */
flags |= I_D_MEGABYTES;
break;
case 't':
/* Display timestamp */
flags |= I_D_TIMESTAMP;
break;
case 'V':
/* Print version number and exit */
print_version();
break;
default:
usage(argv[0]);
}
}
opt++;
}
else if (!it) {
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
count = -1;
it = 1;
}
else if (it > 0) {
count = atol(argv[opt++]);
if ((count < 1) || !interval) {
usage(argv[0]);
}
it = -1;
}
else {
usage(argv[0]);
}
}
if (!interval) {
count = 1;
}
/* Init structures according to machine architecture */
io_sys_init();
get_localtime(&rectime);
/* Get system name, release number and hostname */
uname(&header);
if (print_gal_header(&rectime, header.sysname, header.release,
header.nodename, header.machine, cpu_nr)) {
flags |= I_D_ISO;
}
printf("\n");
/* Set a handler for SIGALRM */
alarm_handler(0);
/* Main loop */
rw_io_stat_loop(count, &rectime);
/* Free structures */
io_sys_free();
return 0;
}
int main(int argc, char **argv)
{
int i;
int config_loaded = 0;
int dont_fork = 0;
size_t wanted_stacksize = 0, stacksize = 0;
pthread_attr_t attr;
// global initialization
get_HZ();
// set the name for logging
program_name = "netdata";
// parse the arguments
for(i = 1; i < argc ; i++) {
if(strcmp(argv[i], "-c") == 0 && (i+1) < argc) {
if(load_config(argv[i+1], 1) != 1) {
error("Cannot load configuration file %s.", argv[i+1]);
exit(1);
}
else {
debug(D_OPTIONS, "Configuration loaded from %s.", argv[i+1]);
config_loaded = 1;
}
i++;
}
else if(strcmp(argv[i], "-df") == 0 && (i+1) < argc) { config_set("global", "debug flags", argv[i+1]); debug_flags = strtoull(argv[i+1], NULL, 0); i++; }
else if(strcmp(argv[i], "-p") == 0 && (i+1) < argc) { config_set("global", "port", argv[i+1]); i++; }
else if(strcmp(argv[i], "-u") == 0 && (i+1) < argc) { config_set("global", "run as user", argv[i+1]); i++; }
else if(strcmp(argv[i], "-l") == 0 && (i+1) < argc) { config_set("global", "history", argv[i+1]); i++; }
else if(strcmp(argv[i], "-t") == 0 && (i+1) < argc) { config_set("global", "update every", argv[i+1]); i++; }
else if(strcmp(argv[i], "-ch") == 0 && (i+1) < argc) { config_set("global", "host access prefix", argv[i+1]); i++; }
else if(strcmp(argv[i], "-stacksize") == 0 && (i+1) < argc) { config_set("global", "pthread stack size", argv[i+1]); i++; }
else if(strcmp(argv[i], "-nodaemon") == 0 || strcmp(argv[i], "-nd") == 0) dont_fork = 1;
else if(strcmp(argv[i], "-pidfile") == 0 && (i+1) < argc) {
i++;
strncpy(pidfile, argv[i], FILENAME_MAX);
pidfile[FILENAME_MAX] = '\0';
}
else if(strcmp(argv[i], "--unittest") == 0) {
rrd_update_every = 1;
if(run_all_mockup_tests()) exit(1);
if(unit_test_storage()) exit(1);
fprintf(stderr, "\n\nALL TESTS PASSED\n\n");
exit(0);
}
else {
fprintf(stderr, "Cannot understand option '%s'.\n", argv[i]);
fprintf(stderr, "\nUSAGE: %s [-d] [-l LINES_TO_SAVE] [-u UPDATE_TIMER] [-p LISTEN_PORT] [-df debug flags].\n\n", argv[0]);
fprintf(stderr, " -c CONFIG FILE the configuration file to load. Default: %s.\n", CONFIG_DIR "/" CONFIG_FILENAME);
fprintf(stderr, " -l LINES_TO_SAVE can be from 5 to %d lines in JSON data. Default: %d.\n", RRD_HISTORY_ENTRIES_MAX, RRD_DEFAULT_HISTORY_ENTRIES);
fprintf(stderr, " -t UPDATE_TIMER can be from 1 to %d seconds. Default: %d.\n", UPDATE_EVERY_MAX, UPDATE_EVERY);
fprintf(stderr, " -p LISTEN_PORT can be from 1 to %d. Default: %d.\n", 65535, LISTEN_PORT);
fprintf(stderr, " -u USERNAME can be any system username to run as. Default: none.\n");
fprintf(stderr, " -ch path to access host /proc and /sys when running in a container. Default: empty.\n");
fprintf(stderr, " -nd or -nodeamon to disable forking in the background. Default: unset.\n");
fprintf(stderr, " -df FLAGS debug options. Default: 0x%08llx.\n", debug_flags);
fprintf(stderr, " -stacksize BYTES to overwrite the pthread stack size.\n");
fprintf(stderr, " -pidfile FILENAME to save a pid while running.\n");
exit(1);
}
}
if(!config_loaded) load_config(NULL, 0);
// prepare configuration environment variables for the plugins
setenv("NETDATA_CONFIG_DIR" , config_get("global", "config directory" , CONFIG_DIR) , 1);
setenv("NETDATA_PLUGINS_DIR", config_get("global", "plugins directory" , PLUGINS_DIR), 1);
setenv("NETDATA_WEB_DIR" , config_get("global", "web files directory", WEB_DIR) , 1);
setenv("NETDATA_CACHE_DIR" , config_get("global", "cache directory" , CACHE_DIR) , 1);
setenv("NETDATA_LOG_DIR" , config_get("global", "log directory" , LOG_DIR) , 1);
setenv("NETDATA_HOST_PREFIX", config_get("global", "host access prefix" , "") , 1);
setenv("HOME" , config_get("global", "home directory" , CACHE_DIR) , 1);
// avoid extended to stat(/etc/localtime)
// http://stackoverflow.com/questions/4554271/how-to-avoid-excessive-stat-etc-localtime-calls-in-strftime-on-linux
setenv("TZ", ":/etc/localtime", 0);
// cd to /tmp to avoid any plugins writing files at random places
if(chdir("/tmp")) error("netdata: ERROR: Cannot cd to /tmp");
char *input_log_file = NULL;
char *output_log_file = NULL;
char *error_log_file = NULL;
char *access_log_file = NULL;
char *user = NULL;
{
char buffer[1024];
// --------------------------------------------------------------------
sprintf(buffer, "0x%08llx", 0ULL);
char *flags = config_get("global", "debug flags", buffer);
setenv("NETDATA_DEBUG_FLAGS", flags, 1);
debug_flags = strtoull(flags, NULL, 0);
debug(D_OPTIONS, "Debug flags set to '0x%8llx'.", debug_flags);
if(debug_flags != 0) {
struct rlimit rl = { RLIM_INFINITY, RLIM_INFINITY };
if(setrlimit(RLIMIT_CORE, &rl) != 0)
info("Cannot request unlimited core dumps for debugging... Proceeding anyway...");
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
// --------------------------------------------------------------------
#ifdef MADV_MERGEABLE
enable_ksm = config_get_boolean("global", "memory deduplication (ksm)", enable_ksm);
#else
#warning "Kernel memory deduplication (KSM) is not available"
#endif
// --------------------------------------------------------------------
global_host_prefix = config_get("global", "host access prefix", "");
setenv("NETDATA_HOST_PREFIX", global_host_prefix, 1);
// --------------------------------------------------------------------
output_log_file = config_get("global", "debug log", LOG_DIR "/debug.log");
if(strcmp(output_log_file, "syslog") == 0) {
output_log_syslog = 1;
output_log_file = NULL;
}
else if(strcmp(output_log_file, "none") == 0) {
output_log_syslog = 0;
output_log_file = NULL;
}
else output_log_syslog = 0;
// --------------------------------------------------------------------
error_log_file = config_get("global", "error log", LOG_DIR "/error.log");
if(strcmp(error_log_file, "syslog") == 0) {
error_log_syslog = 1;
error_log_file = NULL;
}
else if(strcmp(error_log_file, "none") == 0) {
error_log_syslog = 0;
error_log_file = NULL;
// optimization - do not even generate debug log entries
}
else error_log_syslog = 0;
error_log_throttle_period = config_get_number("global", "errors flood protection period", error_log_throttle_period);
setenv("NETDATA_ERRORS_THROTTLE_PERIOD", config_get("global", "errors flood protection period" , ""), 1);
error_log_errors_per_period = config_get_number("global", "errors to trigger flood protection", error_log_errors_per_period);
setenv("NETDATA_ERRORS_PER_PERIOD" , config_get("global", "errors to trigger flood protection", ""), 1);
// --------------------------------------------------------------------
access_log_file = config_get("global", "access log", LOG_DIR "/access.log");
if(strcmp(access_log_file, "syslog") == 0) {
access_log_syslog = 1;
access_log_file = NULL;
}
else if(strcmp(access_log_file, "none") == 0) {
access_log_syslog = 0;
access_log_file = NULL;
}
else access_log_syslog = 0;
// --------------------------------------------------------------------
rrd_memory_mode = rrd_memory_mode_id(config_get("global", "memory mode", rrd_memory_mode_name(rrd_memory_mode)));
// --------------------------------------------------------------------
if(gethostname(buffer, HOSTNAME_MAX) == -1)
error("WARNING: Cannot get machine hostname.");
hostname = config_get("global", "hostname", buffer);
debug(D_OPTIONS, "hostname set to '%s'", hostname);
// --------------------------------------------------------------------
rrd_default_history_entries = (int) config_get_number("global", "history", RRD_DEFAULT_HISTORY_ENTRIES);
if(rrd_default_history_entries < 5 || rrd_default_history_entries > RRD_HISTORY_ENTRIES_MAX) {
info("Invalid save lines %d given. Defaulting to %d.", rrd_default_history_entries, RRD_DEFAULT_HISTORY_ENTRIES);
rrd_default_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
}
else {
debug(D_OPTIONS, "save lines set to %d.", rrd_default_history_entries);
}
// --------------------------------------------------------------------
rrd_update_every = (int) config_get_number("global", "update every", UPDATE_EVERY);
if(rrd_update_every < 1 || rrd_update_every > 600) {
info("Invalid update timer %d given. Defaulting to %d.", rrd_update_every, UPDATE_EVERY_MAX);
rrd_update_every = UPDATE_EVERY;
}
else debug(D_OPTIONS, "update timer set to %d.", rrd_update_every);
// let the plugins know the min update_every
{
char buf[50];
snprintf(buf, 50, "%d", rrd_update_every);
setenv("NETDATA_UPDATE_EVERY", buf, 1);
}
// --------------------------------------------------------------------
// block signals while initializing threads.
// this causes the threads to block signals.
sigset_t sigset;
sigfillset(&sigset);
if(pthread_sigmask(SIG_BLOCK, &sigset, NULL) == -1) {
error("Could not block signals for threads");
}
// Catch signals which we want to use to quit savely
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, SIGHUP);
sigaddset(&sa.sa_mask, SIGINT);
sigaddset(&sa.sa_mask, SIGTERM);
sa.sa_handler = sig_handler;
sa.sa_flags = 0;
if(sigaction(SIGHUP, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGHUP");
}
if(sigaction(SIGINT, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGINT");
}
if(sigaction(SIGTERM, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGTERM");
}
// Ignore SIGPIPE completely.
// INFO: If we add signals here we have to unblock them
// at popen.c when running a external plugin.
sa.sa_handler = SIG_IGN;
if(sigaction(SIGPIPE, &sa, NULL) == -1) {
error("Failed to change signal handler for SIGTERM");
}
// --------------------------------------------------------------------
i = pthread_attr_init(&attr);
if(i != 0)
fatal("pthread_attr_init() failed with code %d.", i);
i = pthread_attr_getstacksize(&attr, &stacksize);
if(i != 0)
fatal("pthread_attr_getstacksize() failed with code %d.", i);
else
debug(D_OPTIONS, "initial pthread stack size is %zu bytes", stacksize);
wanted_stacksize = config_get_number("global", "pthread stack size", stacksize);
// --------------------------------------------------------------------
for (i = 0; static_threads[i].name != NULL ; i++) {
struct netdata_static_thread *st = &static_threads[i];
if(st->config_name) st->enabled = config_get_boolean(st->config_section, st->config_name, st->enabled);
if(st->enabled && st->init_routine) st->init_routine();
}
// --------------------------------------------------------------------
// get the user we should run
// IMPORTANT: this is required before web_files_uid()
user = config_get("global", "run as user" , (getuid() == 0)?NETDATA_USER:"");
// IMPORTANT: these have to run once, while single threaded
web_files_uid(); // IMPORTANT: web_files_uid() before web_files_gid()
web_files_gid();
// --------------------------------------------------------------------
listen_backlog = (int) config_get_number("global", "http port listen backlog", LISTEN_BACKLOG);
listen_port = (int) config_get_number("global", "port", LISTEN_PORT);
if(listen_port < 1 || listen_port > 65535) {
info("Invalid listen port %d given. Defaulting to %d.", listen_port, LISTEN_PORT);
listen_port = LISTEN_PORT;
}
else debug(D_OPTIONS, "Listen port set to %d.", listen_port);
int ip = 0;
char *ipv = config_get("global", "ip version", "any");
if(!strcmp(ipv, "any") || !strcmp(ipv, "both") || !strcmp(ipv, "all")) ip = 0;
else if(!strcmp(ipv, "ipv4") || !strcmp(ipv, "IPV4") || !strcmp(ipv, "IPv4") || !strcmp(ipv, "4")) ip = 4;
else if(!strcmp(ipv, "ipv6") || !strcmp(ipv, "IPV6") || !strcmp(ipv, "IPv6") || !strcmp(ipv, "6")) ip = 6;
else info("Cannot understand ip version '%s'. Assuming 'any'.", ipv);
if(ip == 0 || ip == 6) listen_fd = create_listen_socket6(config_get("global", "bind socket to IP", "*"), listen_port, listen_backlog);
if(listen_fd < 0) {
listen_fd = create_listen_socket4(config_get("global", "bind socket to IP", "*"), listen_port, listen_backlog);
if(listen_fd >= 0 && ip != 4) info("Managed to open an IPv4 socket on port %d.", listen_port);
}
if(listen_fd < 0) fatal("Cannot listen socket.");
}
// never become a problem
if(nice(20) == -1) error("Cannot lower my CPU priority.");
if(become_daemon(dont_fork, 0, user, input_log_file, output_log_file, error_log_file, access_log_file, &access_fd, &stdaccess) == -1) {
fatal("Cannot demonize myself.");
exit(1);
}
if(debug_flags != 0) {
struct rlimit rl = { RLIM_INFINITY, RLIM_INFINITY };
if(setrlimit(RLIMIT_CORE, &rl) != 0)
info("Cannot request unlimited core dumps for debugging... Proceeding anyway...");
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
if(output_log_syslog || error_log_syslog || access_log_syslog)
openlog("netdata", LOG_PID, LOG_DAEMON);
info("NetData started on pid %d", getpid());
// ------------------------------------------------------------------------
// get default pthread stack size
if(stacksize < wanted_stacksize) {
i = pthread_attr_setstacksize(&attr, wanted_stacksize);
if(i != 0)
fatal("pthread_attr_setstacksize() to %zu bytes, failed with code %d.", wanted_stacksize, i);
else
info("Successfully set pthread stacksize to %zu bytes", wanted_stacksize);
}
// ------------------------------------------------------------------------
// spawn the threads
for (i = 0; static_threads[i].name != NULL ; i++) {
struct netdata_static_thread *st = &static_threads[i];
if(st->enabled) {
st->thread = malloc(sizeof(pthread_t));
if(!st->thread)
fatal("Cannot allocate pthread_t memory");
info("Starting thread %s.", st->name);
if(pthread_create(st->thread, &attr, st->start_routine, NULL))
error("failed to create new thread for %s.", st->name);
else if(pthread_detach(*st->thread))
error("Cannot request detach of newly created %s thread.", st->name);
}
else info("Not starting thread %s.", st->name);
}
// ------------------------------------------------------------------------
// block signals while initializing threads.
sigset_t sigset;
sigfillset(&sigset);
if(pthread_sigmask(SIG_UNBLOCK, &sigset, NULL) == -1) {
error("Could not unblock signals for threads");
}
// Handle flags set in the signal handler.
while(1) {
pause();
if(netdata_exit) {
info("Exit main loop of netdata.");
netdata_cleanup_and_exit(0);
exit(0);
}
}
}
/*
***************************************************************************
* Main entry to the sar program
***************************************************************************
*/
int main(int argc, char **argv)
{
int opt = 1, args_idx = 2;
int fd[2];
char from_file[MAX_FILE_LEN], to_file[MAX_FILE_LEN];
char ltemp[20];
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
from_file[0] = to_file[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt]) {
/* Parse -I option */
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-P")) {
/* Parse -P option */
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-o")) {
/* Save stats to a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(to_file, argv[opt++], MAX_FILE_LEN);
to_file[MAX_FILE_LEN - 1] = '\0';
}
else {
strcpy(to_file, "-");
}
}
else if (!strcmp(argv[opt], "-f")) {
/* Read stats from a file */
if ((argv[++opt]) && strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
strncpy(from_file, argv[opt++], MAX_FILE_LEN);
from_file[MAX_FILE_LEN - 1] = '\0';
}
else {
set_default_file(&rectime, from_file);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-i")) {
if (!argv[++opt] || (strspn(argv[opt], DIGITS) != strlen(argv[opt]))) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 1) {
usage(argv[0]);
}
flags |= S_F_INTERVAL_SET;
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt]) {
/* Parse option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if (parse_sar_opt(argv, &opt, act, &flags, C_SAR)) {
usage(argv[0]);
}
opt++;
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval < 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if ((strspn(argv[opt], DIGITS) != strlen(argv[opt])) ||
!interval) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 1) {
usage(argv[0]);
}
}
}
/* 'sar' is equivalent to 'sar -f' */
if ((argc == 1) ||
((interval < 0) && !from_file[0] && !to_file[0])) {
set_default_file(&rectime, from_file);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
/*
* Check option dependencies
*/
/* You read from a file OR you write to it... */
if (from_file[0] && to_file[0]) {
fprintf(stderr, _("-f and -o options are mutually exclusive\n"));
exit(1);
}
/* Use time start or option -i only when reading stats from a file */
if ((tm_start.use || INTERVAL_SET(flags)) && !from_file[0]) {
fprintf(stderr,
_("Not reading from a system activity file (use -f option)\n"));
exit(1);
}
/* Don't print stats since boot time if -o or -f options are used */
if (!interval && (from_file[0] || to_file[0])) {
usage(argv[0]);
}
if (!count) {
/*
* count parameter not set: Display all the contents of the file
* or generate a report continuously.
*/
count = -1;
}
/* Default is CPU activity... */
select_default_activity(act);
/* ---Reading stats from file */
if (from_file[0]) {
if (interval < 0) {
interval = 1;
}
/* Read stats from file */
read_stats_from_file(from_file);
return 0;
}
/* ---Reading stats from sadc */
/* Create anonymous pipe */
if (pipe(fd) == -1) {
perror("pipe");
exit(4);
}
switch (fork()) {
case -1:
perror("fork");
exit(4);
break;
case 0: /* Child */
if (dup2(fd[1], STDOUT_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/*
* Prepare options for sadc
*/
/* Program name */
salloc(0, SADC);
/* Interval value */
if (interval < 0) {
usage(argv[0]);
}
else if (!interval) {
strcpy(ltemp, "1");
}
else {
sprintf(ltemp, "%ld", interval);
}
salloc(1, ltemp);
/* Count number */
if (count >= 0) {
sprintf(ltemp, "%ld", count + 1);
salloc(args_idx++, ltemp);
}
/* Flags to be passed to sadc */
salloc(args_idx++, "-z");
salloc(args_idx++, "-S");
salloc(args_idx++, K_ALL);
/* Outfile arg */
if (to_file[0]) {
salloc(args_idx++, to_file);
}
/* Last arg is NULL */
args[args_idx] = NULL;
/* Call now the data collector */
execv(SADC_PATH, args);
execvp(SADC, args);
/*
* Note: don't use execl/execlp since we don't have a fixed number of
* args to give to sadc.
*/
fprintf(stderr, _("Cannot find the data collector (%s)\n"), SADC);
perror("exec");
exit(4);
break;
default: /* Parent */
if (dup2(fd[0], STDIN_FILENO) < 0) {
perror("dup2");
exit(4);
}
CLOSE_ALL(fd);
/* Get now the statistics */
read_stats();
break;
}
return 0;
}
int main(int argc, char **argv)
{
int i;
int config_loaded = 0;
int dont_fork = 0;
// global initialization
get_HZ();
// set the name for logging
program_name = "netdata";
// parse the arguments
for(i = 1; i < argc ; i++) {
if(strcmp(argv[i], "-c") == 0 && (i+1) < argc) {
if(load_config(argv[i+1], 1) != 1) {
error("Cannot load configuration file %s.", argv[i+1]);
exit(1);
}
else {
debug(D_OPTIONS, "Configuration loaded from %s.", argv[i+1]);
config_loaded = 1;
}
i++;
}
else if(strcmp(argv[i], "-df") == 0 && (i+1) < argc) { config_set("global", "debug flags", argv[i+1]); debug_flags = strtoull(argv[i+1], NULL, 0); i++; }
else if(strcmp(argv[i], "-p") == 0 && (i+1) < argc) { config_set("global", "port", argv[i+1]); i++; }
else if(strcmp(argv[i], "-u") == 0 && (i+1) < argc) { config_set("global", "run as user", argv[i+1]); i++; }
else if(strcmp(argv[i], "-l") == 0 && (i+1) < argc) { config_set("global", "history", argv[i+1]); i++; }
else if(strcmp(argv[i], "-t") == 0 && (i+1) < argc) { config_set("global", "update every", argv[i+1]); i++; }
else if(strcmp(argv[i], "-ch") == 0 && (i+1) < argc) { config_set("global", "host access prefix", argv[i+1]); i++; }
else if(strcmp(argv[i], "-nodaemon") == 0 || strcmp(argv[i], "-nd") == 0) dont_fork = 1;
else if(strcmp(argv[i], "--unittest") == 0) {
rrd_update_every = 1;
if(run_all_mockup_tests()) exit(1);
if(unit_test_storage()) exit(1);
fprintf(stderr, "\n\nALL TESTS PASSED\n\n");
exit(0);
}
else {
fprintf(stderr, "Cannot understand option '%s'.\n", argv[i]);
fprintf(stderr, "\nUSAGE: %s [-d] [-l LINES_TO_SAVE] [-u UPDATE_TIMER] [-p LISTEN_PORT] [-df debug flags].\n\n", argv[0]);
fprintf(stderr, " -c CONFIG FILE the configuration file to load. Default: %s.\n", CONFIG_DIR "/" CONFIG_FILENAME);
fprintf(stderr, " -l LINES_TO_SAVE can be from 5 to %d lines in JSON data. Default: %d.\n", RRD_HISTORY_ENTRIES_MAX, RRD_DEFAULT_HISTORY_ENTRIES);
fprintf(stderr, " -t UPDATE_TIMER can be from 1 to %d seconds. Default: %d.\n", UPDATE_EVERY_MAX, UPDATE_EVERY);
fprintf(stderr, " -p LISTEN_PORT can be from 1 to %d. Default: %d.\n", 65535, LISTEN_PORT);
fprintf(stderr, " -u USERNAME can be any system username to run as. Default: none.\n");
fprintf(stderr, " -ch path to access host /proc and /sys when running in a container. Default: empty.\n");
fprintf(stderr, " -nd or -nodeamon to disable forking in the background. Default: unset.\n");
fprintf(stderr, " -df FLAGS debug options. Default: 0x%08llx.\n", debug_flags);
exit(1);
}
}
if(!config_loaded) load_config(NULL, 0);
// prepare configuration environment variables for the plugins
setenv("NETDATA_CONFIG_DIR" , config_get("global", "config directory" , CONFIG_DIR) , 1);
setenv("NETDATA_PLUGINS_DIR", config_get("global", "plugins directory" , PLUGINS_DIR), 1);
setenv("NETDATA_WEB_DIR" , config_get("global", "web files directory", WEB_DIR) , 1);
setenv("NETDATA_CACHE_DIR" , config_get("global", "cache directory" , CACHE_DIR) , 1);
setenv("NETDATA_LOG_DIR" , config_get("global", "log directory" , LOG_DIR) , 1);
setenv("NETDATA_HOST_PREFIX", config_get("global", "host access prefix" , "") , 1);
// avoid extended to stat(/etc/localtime)
// http://stackoverflow.com/questions/4554271/how-to-avoid-excessive-stat-etc-localtime-calls-in-strftime-on-linux
setenv("TZ", ":/etc/localtime", 0);
// cd to /tmp to avoid any plugins writing files at random places
if(chdir("/tmp")) error("netdata: ERROR: Cannot cd to /tmp");
char *input_log_file = NULL;
char *output_log_file = NULL;
char *error_log_file = NULL;
char *access_log_file = NULL;
char *user = NULL;
{
char buffer[1024];
// --------------------------------------------------------------------
sprintf(buffer, "0x%08llx", 0ULL);
char *flags = config_get("global", "debug flags", buffer);
setenv("NETDATA_DEBUG_FLAGS", flags, 1);
debug_flags = strtoull(flags, NULL, 0);
debug(D_OPTIONS, "Debug flags set to '0x%8llx'.", debug_flags);
if(debug_flags != 0) {
struct rlimit rl = { RLIM_INFINITY, RLIM_INFINITY };
if(setrlimit(RLIMIT_CORE, &rl) != 0)
info("Cannot request unlimited core dumps for debugging... Proceeding anyway...");
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
// --------------------------------------------------------------------
#ifdef MADV_MERGEABLE
enable_ksm = config_get_boolean("global", "memory deduplication (ksm)", enable_ksm);
#else
#warning "Kernel memory deduplication (KSM) is not available"
#endif
// --------------------------------------------------------------------
global_host_prefix = config_get("global", "host access prefix", "");
setenv("NETDATA_HOST_PREFIX", global_host_prefix, 1);
// --------------------------------------------------------------------
output_log_file = config_get("global", "debug log", LOG_DIR "/debug.log");
if(strcmp(output_log_file, "syslog") == 0) {
output_log_syslog = 1;
output_log_file = NULL;
}
else if(strcmp(output_log_file, "none") == 0) {
output_log_syslog = 0;
output_log_file = NULL;
}
else output_log_syslog = 0;
// --------------------------------------------------------------------
error_log_file = config_get("global", "error log", LOG_DIR "/error.log");
if(strcmp(error_log_file, "syslog") == 0) {
error_log_syslog = 1;
error_log_file = NULL;
}
else if(strcmp(error_log_file, "none") == 0) {
error_log_syslog = 0;
error_log_file = NULL;
// optimization - do not even generate debug log entries
}
else error_log_syslog = 0;
// --------------------------------------------------------------------
access_log_file = config_get("global", "access log", LOG_DIR "/access.log");
if(strcmp(access_log_file, "syslog") == 0) {
access_log_syslog = 1;
access_log_file = NULL;
}
else if(strcmp(access_log_file, "none") == 0) {
access_log_syslog = 0;
access_log_file = NULL;
}
else access_log_syslog = 0;
// --------------------------------------------------------------------
rrd_memory_mode = rrd_memory_mode_id(config_get("global", "memory mode", rrd_memory_mode_name(rrd_memory_mode)));
// --------------------------------------------------------------------
if(gethostname(buffer, HOSTNAME_MAX) == -1)
error("WARNING: Cannot get machine hostname.");
hostname = config_get("global", "hostname", buffer);
debug(D_OPTIONS, "hostname set to '%s'", hostname);
// --------------------------------------------------------------------
rrd_default_history_entries = (int) config_get_number("global", "history", RRD_DEFAULT_HISTORY_ENTRIES);
if(rrd_default_history_entries < 5 || rrd_default_history_entries > RRD_HISTORY_ENTRIES_MAX) {
fprintf(stderr, "Invalid save lines %d given. Defaulting to %d.\n", rrd_default_history_entries, RRD_DEFAULT_HISTORY_ENTRIES);
rrd_default_history_entries = RRD_DEFAULT_HISTORY_ENTRIES;
}
else {
debug(D_OPTIONS, "save lines set to %d.", rrd_default_history_entries);
}
// --------------------------------------------------------------------
rrd_update_every = (int) config_get_number("global", "update every", UPDATE_EVERY);
if(rrd_update_every < 1 || rrd_update_every > 600) {
fprintf(stderr, "Invalid update timer %d given. Defaulting to %d.\n", rrd_update_every, UPDATE_EVERY_MAX);
rrd_update_every = UPDATE_EVERY;
}
else debug(D_OPTIONS, "update timer set to %d.", rrd_update_every);
// let the plugins know the min update_every
{
char buf[50];
snprintf(buf, 50, "%d", rrd_update_every);
setenv("NETDATA_UPDATE_EVERY", buf, 1);
}
// --------------------------------------------------------------------
for (i = 0; static_threads[i].name != NULL ; i++) {
struct netdata_static_thread *st = &static_threads[i];
if(st->config_name) st->enabled = config_get_boolean(st->config_section, st->config_name, st->enabled);
if(st->enabled && st->init_routine) st->init_routine();
}
// --------------------------------------------------------------------
prepare_rundir();
user = config_get("global", "run as user" , (getuid() == 0)?NETDATA_USER:"");
web_files_uid();
// --------------------------------------------------------------------
listen_backlog = (int) config_get_number("global", "http port listen backlog", LISTEN_BACKLOG);
listen_port = (int) config_get_number("global", "port", LISTEN_PORT);
if(listen_port < 1 || listen_port > 65535) {
fprintf(stderr, "Invalid listen port %d given. Defaulting to %d.\n", listen_port, LISTEN_PORT);
listen_port = LISTEN_PORT;
}
else debug(D_OPTIONS, "Listen port set to %d.", listen_port);
int ip = 0;
char *ipv = config_get("global", "ip version", "any");
if(!strcmp(ipv, "any") || !strcmp(ipv, "both") || !strcmp(ipv, "all")) ip = 0;
else if(!strcmp(ipv, "ipv4") || !strcmp(ipv, "IPV4") || !strcmp(ipv, "IPv4") || !strcmp(ipv, "4")) ip = 4;
else if(!strcmp(ipv, "ipv6") || !strcmp(ipv, "IPV6") || !strcmp(ipv, "IPv6") || !strcmp(ipv, "6")) ip = 6;
else fprintf(stderr, "Cannot understand ip version '%s'. Assumming 'any'.", ipv);
if(ip == 0 || ip == 6) listen_fd = create_listen_socket6(listen_port, listen_backlog);
if(listen_fd < 0) {
listen_fd = create_listen_socket4(listen_port, listen_backlog);
if(listen_fd >= 0 && ip != 4) fprintf(stderr, "Managed to open an IPv4 socket on port %d.", listen_port);
}
if(listen_fd < 0) fatal("Cannot listen socket.");
}
// never become a problem
if(nice(20) == -1) error("Cannot lower my CPU priority.");
if(become_daemon(dont_fork, 0, user, input_log_file, output_log_file, error_log_file, access_log_file, &access_fd, &stdaccess) == -1) {
fatal("Cannot demonize myself.");
exit(1);
}
if(debug_flags != 0) {
struct rlimit rl = { RLIM_INFINITY, RLIM_INFINITY };
if(setrlimit(RLIMIT_CORE, &rl) != 0)
info("Cannot request unlimited core dumps for debugging... Proceeding anyway...");
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
if(output_log_syslog || error_log_syslog || access_log_syslog)
openlog("netdata", LOG_PID, LOG_DAEMON);
info("NetData started on pid %d", getpid());
// catch all signals
for (i = 1 ; i < 65 ;i++) {
switch(i) {
case SIGKILL: // not catchable
case SIGSTOP: // not catchable
break;
case SIGSEGV:
case SIGFPE:
case SIGCHLD:
signal(i, SIG_DFL);
break;
default:
signal(i, sig_handler);
break;
}
}
for (i = 0; static_threads[i].name != NULL ; i++) {
struct netdata_static_thread *st = &static_threads[i];
if(st->enabled) {
st->thread = malloc(sizeof(pthread_t));
if(!st->thread)
fatal("Cannot allocate pthread_t memory");
info("Starting thread %s.", st->name);
if(pthread_create(st->thread, NULL, st->start_routine, NULL))
error("failed to create new thread for %s.", st->name);
else if(pthread_detach(*st->thread))
error("Cannot request detach of newly created %s thread.", st->name);
}
else info("Not starting thread %s.", st->name);
}
// for future use - the main thread
while(1) {
if(netdata_exit != 0) {
netdata_exit++;
if(netdata_exit > 5) {
netdata_cleanup_and_exit(0);
exit(0);
}
}
sleep(2);
}
exit(0);
}
int main(int argc, char* argv[])
{
struct stats st, st_prev;
struct ext_stats ext_st;
unsigned long long interval;
char *logfile = LOG_FILE;
int speed = -1, duplex = -1;
/* Usage: ./sysmon [real-time logging switch] [log filename] [print flag] (netif speed) (netif duplex)
netif duplex takes C_DUPLEX_HALF=1 or C_DUPLEX_FULL=2 */
if (2 <= argc) realtime_logging = (strcmp("1", argv[1]) == 0);
if (3 <= argc) logfile = argv[2];
if (4 <= argc && (strncmp("0x", argv[3], 2) == 0))
print_flag = (int)strtol(argv[3], NULL, 0); /* Expecting 0x... */
if (5 <= argc) speed = atoi(argv[4]);
if (6 <= argc) duplex = atoi(argv[5]);
printf ("realtime logging : %s\n", realtime_logging ? "enabled" : "disabled");
printf ("log file : %s\n", logfile);
printf ("print flag : 0x%08x\n", print_flag);
printf ("speed : %d\n", speed);
printf ("duplex : %d\n", duplex);
#ifndef DEBUG
if ((fp = fopen(logfile, "w+")) == NULL) {
fprintf(stderr, "opening logfile failed\n");
exit(EXIT_FAILURE);
}
#else
fp = stdout;
#endif
/* Initialization */
signal(SIGINT, signal_callback_handler); /* Set up a signal handler */
read_stats(&base_stats);
clock_gettime(CLOCK_MONOTONIC, &base_time);
/* Obtain speed/duplex info for eth0 */
read_net_dev(&st.net, 1);
read_if_info(&st.net, 1);
/* VMs on Google Clouds do not let you read files under /sys/class/net/eth0/
See also: http://unix.stackexchange.com/questions/77750/checking-the-speed-of-active-network-connections */
base_stats.net.speed = (0 < speed) ? speed : st.net.speed;
base_stats.net.duplex = (0 < duplex) ? duplex : st.net.duplex;
st = st_prev = base_stats;
/* Initialize variables for min/max/mean/var computation */
num_samples = 1;
set_max_ext_stats(&min);
memset((void *)&max, 0x00, sizeof(struct ext_stats));
memset((void *)&mean, 0x00, sizeof(struct ext_stats));
memset((void *)&var, 0x00, sizeof(struct ext_stats));
/* For real-time logging */
if (realtime_logging) fprint_header(fp, print_flag);
/* Get HZ */
get_HZ();
while (1) { /* Anyways, we record stats for average computation */
usleep(INTERVAL_SEC * SEC_TO_MSEC);
read_stats(&st);
interval = get_interval(st_prev.uptime, st.uptime);
/* Compute extended stats from raw stats */
compute_ext_stats(interval, &st, &st_prev, &ext_st);
update_ext_stats(num_samples, &ext_st, &min, &max, &mean, &var);
if (realtime_logging) fprint_stats(fp, print_flag, &st, &ext_st);
/* Update stats (min/max/mean/var) for ext_stats */
st_prev = st;
num_samples++;
}
/* Program never gets here */
printf("Waiting for the SIGINT signal\n");
pause();
return EXIT_SUCCESS;
}
/*
***************************************************************************
* Main entry to the sadf program
***************************************************************************
*/
int main(int argc, char **argv)
{
int opt = 1, sar_options = 0;
int i;
char dfile[MAX_FILE_LEN];
struct tm rectime;
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
dfile[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
/* Init some structures */
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt] && sar_options) {
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-P")) {
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "--")) {
sar_options = 1;
opt++;
}
else if (!strcmp(argv[opt], "-m")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -m */
if (parse_sar_m_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if (sar_options) {
if (parse_sar_opt(argv, &opt, act, &flags, C_SADF)) {
usage(argv[0]);
}
}
else {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'C':
flags |= S_F_COMMENT;
break;
case 'd':
if (format) {
usage(argv[0]);
}
format = F_DB_OUTPUT;
break;
case 'h':
flags |= S_F_HORIZONTALLY;
break;
case 'H':
flags |= S_F_HDR_ONLY;
break;
case 'j':
if (format) {
usage(argv[0]);
}
format = F_JSON_OUTPUT;
break;
case 'p':
if (format) {
usage(argv[0]);
}
format = F_PPC_OUTPUT;
break;
case 't':
flags |= S_F_TRUE_TIME;
break;
case 'T':
flags |= S_F_SEC_EPOCH;
break;
case 'x':
if (format) {
usage(argv[0]);
}
format = F_XML_OUTPUT;
break;
case 'V':
print_version();
break;
default:
usage(argv[0]);
}
}
}
opt++;
}
/* Get data file name */
else if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
if (!dfile[0]) {
if (!strcmp(argv[opt], "-")) {
/* File name set to '-' */
set_default_file(&rectime, dfile);
opt++;
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Bad option */
usage(argv[0]);
}
else {
/* Write data to file */
strncpy(dfile, argv[opt++], MAX_FILE_LEN);
dfile[MAX_FILE_LEN - 1] = '\0';
}
}
else {
/* File already specified */
usage(argv[0]);
}
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval <= 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 0) {
usage(argv[0]);
}
else if (!count) {
count = -1; /* To generate a report continuously */
}
}
}
/* sadf reads current daily data file by default */
if (!dfile[0]) {
set_default_file(&rectime, dfile);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
if (USE_PRETTY_OPTION(flags)) {
dm_major = get_devmap_major();
}
/*
* Display all the contents of the daily data file if the count parameter
* was not set on the command line.
*/
if (!count) {
count = -1;
}
/* Default is CPU activity */
select_default_activity(act);
/* Check options consistency with selected output format. Default is PPC display */
check_format_options();
if (interval < 0) {
interval = 1;
}
/* Read stats from file */
read_stats_from_file(dfile);
/* Free bitmaps */
free_bitmaps(act);
return 0;
}
/*
* The main function.
*/
int main(int argc, char *argv[]) {
int ret = 0, it = 0, opt = 1;
int i, j = 0;
long count = 1;
unsigned int flags;
char* t;
cg_group* group = NULL;
/* Get HZ */
get_HZ();
/* parse arguments */
while (opt < argc) {
if (!strcmp(argv[opt], "-g")) {
flags |= I_D_GROUP;
if (argv[++opt] && (strspn(argv[opt], DIGITS) != strlen(argv[opt]))
&& (strncmp(argv[opt], "-", 1))) {
for (t = strtok(argv[opt], ","); t; t = strtok(NULL, ",")) {
/* Store device name */
strncpy(group_name[j++], t, strlen(t));
}
opt++;
} else {
flags |= I_D_ALL;
}
} else if (!strncmp(argv[opt], "-", 1)) {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'h':
usage(0, argv[0]);
ret = 0;
goto err;
case 'a':
flags |= I_D_ACTIVE;
break;
case 'b':
flags |= I_D_BYTES;
break;
case 'k':
flags |= I_D_KILOBYTES;
break;
case 'm':
flags |= I_D_MEGABYTES;
break;
case 'n':
flags |= I_D_UNHEADER;
case 'G':
flags |= I_D_GIGABYTES;
break;
case 'V':
show_version();
return 0;
default:
usage(1, argv[0]);
ret = 1;
goto err;
}
}
opt++;
} else if (!isdigit(argv[opt][0])) {
if (strcmp(argv[opt], K_ALL)) {
/* Store device name */
strncpy(group_name[j++], argv[opt], strlen(argv[opt]));
opt++;
} else {
opt++;
}
} else if (!it) {
interval = atol(argv[opt++]);
if (interval < 0) {
usage(1, argv[0]);
}
count = -1;
it = 1;
} else if (it > 0) {
count = atol(argv[opt++]);
if ((count < 1) || !interval) {
usage(1, argv[0]);
}
it = -1;
} else {
usage(1, argv[0]);
}
}
if (!interval) {
count = 1;
}
/* Set a handler for SIGALRM */
alarm_handler(0);
if (init_stats()) {
fprintf(stderr, "cgvmstat: initialize the stats failed.\n");
printf("error: Initialize the stats failed.\n");
goto err;
}
/** Read all of the groups from CPUSET.*/
if (read_all_groups(mem_groups, CG_MEMORY)) {
fprintf(stderr, "cgvmstat: read all of the groups in %s failed.\n",
CG_CPUSET);
printf("error: Read all of the groups in %s failed.\n", CG_CPUSET);
goto err;
}
/** If no group to display, then display all of the group statistics information.*/
if (!j && mem_groups && !TAILQ_EMPTY(mem_groups))
TAILQ_FOREACH(group, mem_groups,next)
strncpy(group_name[j++], group->name, strlen(group->name));
/* Main loop */
if (j)
rw_stats_loop(count, flags, j);
err: uninit_stats();
return ret;
}
/*
***************************************************************************
* Main entry to the sadf program
***************************************************************************
*/
int main(int argc, char **argv)
{
int opt = 1, sar_options = 0;
int day_offset = 0;
int i, rc;
char dfile[MAX_FILE_LEN];
char *t;
/* Get HZ */
get_HZ();
/* Compute page shift in kB */
get_kb_shift();
dfile[0] = '\0';
#ifdef USE_NLS
/* Init National Language Support */
init_nls();
#endif
tm_start.use = tm_end.use = FALSE;
/* Allocate and init activity bitmaps */
allocate_bitmaps(act);
/* Init some structures */
init_structures();
/* Process options */
while (opt < argc) {
if (!strcmp(argv[opt], "-I")) {
if (argv[++opt] && sar_options) {
if (parse_sar_I_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-P")) {
if (parse_sa_P_opt(argv, &opt, &flags, act)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-s")) {
/* Get time start */
if (parse_timestamp(argv, &opt, &tm_start, DEF_TMSTART)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-e")) {
/* Get time end */
if (parse_timestamp(argv, &opt, &tm_end, DEF_TMEND)) {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-O")) {
/* Parse SVG options */
if (!argv[++opt] || sar_options) {
usage(argv[0]);
}
for (t = strtok(argv[opt], ","); t; t = strtok(NULL, ",")) {
if (!strcmp(t, K_SKIP_EMPTY)) {
flags |= S_F_SVG_SKIP;
}
else if (!strcmp(t, K_AUTOSCALE)) {
flags |= S_F_SVG_AUTOSCALE;
}
else {
usage(argv[0]);
}
}
opt++;
}
else if ((strlen(argv[opt]) > 1) &&
(strlen(argv[opt]) < 4) &&
!strncmp(argv[opt], "-", 1) &&
(strspn(argv[opt] + 1, DIGITS) == (strlen(argv[opt]) - 1))) {
if (dfile[0] || day_offset) {
/* File already specified */
usage(argv[0]);
}
day_offset = atoi(argv[opt++] + 1);
}
else if (!strcmp(argv[opt], "--")) {
sar_options = 1;
opt++;
}
else if (!strcmp(argv[opt], "-m")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -m */
if (parse_sar_m_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strcmp(argv[opt], "-n")) {
if (argv[++opt] && sar_options) {
/* Parse sar's option -n */
if (parse_sar_n_opt(argv, &opt, act)) {
usage(argv[0]);
}
}
else {
usage(argv[0]);
}
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Other options not previously tested */
if (sar_options) {
if ((rc = parse_sar_opt(argv, &opt, act, &flags, C_SADF)) != 0) {
if (rc == 1) {
usage(argv[0]);
}
exit(1);
}
}
else {
for (i = 1; *(argv[opt] + i); i++) {
switch (*(argv[opt] + i)) {
case 'C':
flags |= S_F_COMMENT;
break;
case 'c':
if (format) {
usage(argv[0]);
}
format = F_CONV_OUTPUT;
break;
case 'd':
if (format) {
usage(argv[0]);
}
format = F_DB_OUTPUT;
break;
case 'g':
if (format) {
usage(argv[0]);
}
format = F_SVG_OUTPUT;
break;
case 'h':
flags |= S_F_HORIZONTALLY;
break;
case 'H':
flags |= S_F_HDR_ONLY;
break;
case 'j':
if (format) {
usage(argv[0]);
}
format = F_JSON_OUTPUT;
break;
case 'p':
if (format) {
usage(argv[0]);
}
format = F_PPC_OUTPUT;
break;
case 'T':
flags |= S_F_LOCAL_TIME;
break;
case 't':
flags |= S_F_TRUE_TIME;
break;
case 'U':
flags |= S_F_SEC_EPOCH;
break;
case 'x':
if (format) {
usage(argv[0]);
}
format = F_XML_OUTPUT;
break;
case 'V':
print_version();
break;
default:
usage(argv[0]);
}
}
}
opt++;
}
/* Get data file name */
else if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
if (dfile[0] || day_offset) {
/* File already specified */
usage(argv[0]);
}
if (!strcmp(argv[opt], "-")) {
/* File name set to '-' */
set_default_file(dfile, 0, -1);
opt++;
}
else if (!strncmp(argv[opt], "-", 1)) {
/* Bad option */
usage(argv[0]);
}
else {
/* Write data to file */
strncpy(dfile, argv[opt++], MAX_FILE_LEN);
dfile[MAX_FILE_LEN - 1] = '\0';
/* Check if this is an alternate directory for sa files */
check_alt_sa_dir(dfile, 0, -1);
}
}
else if (interval < 0) {
/* Get interval */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
interval = atol(argv[opt++]);
if (interval <= 0) {
usage(argv[0]);
}
}
else {
/* Get count value */
if (strspn(argv[opt], DIGITS) != strlen(argv[opt])) {
usage(argv[0]);
}
if (count) {
/* Count parameter already set */
usage(argv[0]);
}
count = atol(argv[opt++]);
if (count < 0) {
usage(argv[0]);
}
else if (!count) {
count = -1; /* To generate a report continuously */
}
}
}
/* sadf reads current daily data file by default */
if (!dfile[0]) {
set_default_file(dfile, day_offset, -1);
}
if (tm_start.use && tm_end.use && (tm_end.tm_hour < tm_start.tm_hour)) {
tm_end.tm_hour += 24;
}
if (USE_PRETTY_OPTION(flags)) {
dm_major = get_devmap_major();
}
/* Options -T, -t and -U are mutually exclusive */
if ((PRINT_LOCAL_TIME(flags) + PRINT_TRUE_TIME(flags) +
PRINT_SEC_EPOCH(flags)) > 1) {
usage(argv[0]);
}
/*
* Display all the contents of the daily data file if the count parameter
* was not set on the command line.
*/
if (!count) {
count = -1;
}
/* Default is CPU activity */
select_default_activity(act);
/* Check options consistency with selected output format. Default is PPC display */
check_format_options();
if (interval < 0) {
interval = 1;
}
if (format == F_CONV_OUTPUT) {
/* Convert file to current format */
convert_file(dfile, act);
}
else {
/* Read stats from file */
read_stats_from_file(dfile);
}
/* Free bitmaps */
free_bitmaps(act);
return 0;
}
