static void * stats_thread(void *user) { struct timespec ts = { .tv_sec = STATS_FREQUENCY, .tv_nsec = 0 }; for (;;) { nmsg_timespec_sleep(&ts); if (shut_down) break; print_stats(); } return (NULL); } void setup_threads(void) { if (is_live) { /* create stats thread */ assert(pthread_create(&thr_stats, NULL, stats_thread, NULL) == 0); } } void cleanup(void) { nmsg_io_destroy(&io); print_stats(); argv_cleanup(args); }
int main(int argc, char **argv) { nmsg_res res; /* parse command line arguments */ argv_process(args, argc, argv); if (ctx.debug < 1) ctx.debug = 1; nmsg_set_debug(ctx.debug); res = nmsg_init(); if (res != nmsg_res_success) { fprintf(stderr, "nmsgtool: unable to initialize libnmsg\n"); return (EXIT_FAILURE); } if (ctx.debug >= 2) #ifdef HAVE_LIBXS fprintf(stderr, "nmsgtool: version " VERSION "\n"); #else /* HAVE_LIBXS */ fprintf(stderr, "nmsgtool: version " VERSION " (without libxs support)\n"); #endif /* HAVE_LIBXS */ /* initialize the nmsg_io engine */ ctx.io = nmsg_io_init(); assert(ctx.io != NULL); nmsg_io_set_close_fp(ctx.io, io_close); /* process arguments and load inputs/outputs into the nmsg_io engine */ process_args(&ctx); setup_signals(); /* run the nmsg_io engine */ res = nmsg_io_loop(ctx.io); /* cleanup */ if (ctx.pidfile != NULL) { if (unlink(ctx.pidfile) != 0) { fprintf(stderr, "nmsgtool: unlink() failed: %s\n", strerror(errno)); } } nmsg_io_destroy(&ctx.io); #ifdef HAVE_LIBXS if (ctx.xs_ctx) xs_term(ctx.xs_ctx); #endif /* HAVE_LIBXS */ free(ctx.endline_str); argv_cleanup(args); return (res); }
int main(int argc, char **argv) { char buf[1024]; int set_b = 0; char *log_path, *loc_start_file; const char *env_str; DMALLOC_PNT addr; unsigned long inter, limit_val, loc_start_size, loc_start_iter; long addr_count; int lock_on; int loc_start_line; unsigned int flags; argv_help_string = "Sets dmalloc library env variables. Also try --usage."; argv_version_string = dmalloc_version; argv_process(args, argc, argv); if (help_b) { header(); (void)fprintf(stderr, " For a list of the command-line options enter: %s --usage\n", argv_argv[0]); exit(0); } if (usage_b) { header(); argv_usage(args, ARGV_USAGE_ALL); exit(0); } if (very_verbose_b) { verbose_b = 1; } /* try to figure out the shell we are using */ if ((! bourne_b) && (! cshell_b) && (! gdb_b) && (! rcshell_b)) { choose_shell(); } /* get the current debug information from the env variable */ env_str = getenv(OPTIONS_ENVIRON); if (env_str == NULL) { env_str = ""; } _dmalloc_environ_process(env_str, &addr, &addr_count, &flags, &inter, &lock_on, &log_path, &loc_start_file, &loc_start_line, &loc_start_iter, &loc_start_size, &limit_val); /* * So, if a tag was specified on the command line then we set the * debug from it. If it was not then we see if the debug flags were * set as a hex value from the -d. If this was not used then take * the current value. */ if (tag == NULL) { if (argv_was_used(args, DEBUG_ARG)) { set_b = 1; /* should we clear the rest? */ if (remove_auto_b && (! keep_b)) { clear_b = 1; } } else { debug = flags; } } else { if (argv_was_used(args, DEBUG_ARG)) { (void)fprintf(stderr, "%s: warning -d ignored, processing tag '%s'\n", argv_program, tag); } set_b = 1; debug = find_tag(0L, tag, NULL, 0); /* should we clear the rest? */ if (remove_auto_b && (! keep_b)) { clear_b = 1; } } if (plus.aa_entry_n > 0) { int plus_c; for (plus_c = 0; plus_c < plus.aa_entry_n; plus_c++) { BIT_SET(debug, token_to_value(ARGV_ARRAY_ENTRY(plus, char *, plus_c))); set_b = 1; } } if (minus.aa_entry_n > 0) { int minus_c; for (minus_c = 0; minus_c < minus.aa_entry_n; minus_c++) { BIT_CLEAR(debug, token_to_value(ARGV_ARRAY_ENTRY(minus, char *, minus_c))); set_b = 1; } } if (address != NULL) { _dmalloc_address_break(address, &addr, &addr_count); set_b = 1; } else if (clear_b) { addr = NULL; } if (argv_was_used(args, INTERVAL_ARG)) { inter = interval; set_b = 1; } else if (clear_b) { inter = 0; } /* * NOTE: this should be after the debug setting which this tests. */ if (argv_was_used(args, THREAD_LOCK_ON_ARG)) { lock_on = thread_lock_on; set_b = 1; } else if (clear_b) { lock_on = 0; } if (logpath != NULL) { log_path = logpath; set_b = 1; } else if (clear_b) { log_path = NULL; } if (start_file != NULL) { _dmalloc_start_break(start_file, &loc_start_file, &loc_start_line, &loc_start_iter, &loc_start_size); set_b = 1; } else if (start_iter > 0) { loc_start_file = NULL; loc_start_line = 0; loc_start_iter = start_iter; loc_start_size = 0; set_b = 1; } else if (start_size > 0) { loc_start_file = NULL; loc_start_line = 0; loc_start_iter = 0; loc_start_size = start_size; set_b = 1; } else if (clear_b) { loc_start_file = NULL; loc_start_line = 0; loc_start_iter = 0; loc_start_size = 0; } if (argv_was_used(args, LIMIT_ARG)) { limit_val = limit_arg; set_b = 1; } if (errno_to_print > 0) { (void)fprintf(stderr, "%s: dmalloc_errno value '%d' = \n", argv_program, errno_to_print); (void)fprintf(stderr, " '%s'\n", local_strerror(errno_to_print)); } if (list_tags_b) { list_tags(); } if (debug_tokens_b) { attr_t *attr_p; unsigned int left = 0x7fffffff; (void)fprintf(stderr, "Debug Tokens:\n"); for (attr_p = attributes; attr_p->at_string != NULL; attr_p++) { /* skip any disabled tokens */ if (attr_p->at_value == 0 && strcmp(attr_p->at_string, "none") != 0) { continue; } if (attr_p->at_value != 0 && (! BIT_IS_SET(left, attr_p->at_value))) { /* skip any tokens we've seen before */ continue; } if (very_verbose_b) { (void)fprintf(stderr, "%s -- %s (%#lx)\n", attr_p->at_string, attr_p->at_desc, attr_p->at_value); } else if (verbose_b) { (void)fprintf(stderr, "%s -- %s\n", attr_p->at_string, attr_p->at_desc); } else { (void)fprintf(stderr, "%s\n", attr_p->at_string); } BIT_CLEAR(left, attr_p->at_value); } } if (clear_b || set_b) { _dmalloc_environ_set(buf, sizeof(buf), long_tokens_b, addr, addr_count, debug, inter, lock_on, log_path, loc_start_file, loc_start_line, loc_start_iter, loc_start_size, limit_val); set_variable(OPTIONS_ENVIRON, buf); } else if (errno_to_print == 0 && (! list_tags_b) && (! debug_tokens_b)) { dump_current(); } argv_cleanup(args); exit(0); }