static void
ks_selector_arg(ks_returner_t *ret, ks_pattern_t *pattern, ERL_NIF_TERM arg)
{
unsigned size;
char *string;
int result;
ErlNifSInt64 integer;
if (ret->ready != B_TRUE) {
if (enif_is_atom(ret->env, arg)) {
enif_get_atom_length(ret->env, arg, &size, ERL_NIF_LATIN1);
string = (char *)(malloc(sizeof (char) * (size + 1)));
if (string == NULL) {
ret->term = EKSTAT_ERROR("atom malloc");
ret->ready = B_TRUE;
return;
}
result = enif_get_atom(ret->env, arg, string, size + 1, ERL_NIF_LATIN1);
if (result == 0) {
ret->term = enif_make_badarg(ret->env);
ret->ready = B_TRUE;
} else {
if (strncmp(string, "_", result) == 0) {
pattern->pstr = "*";
pattern->free = B_FALSE;
} else {
ret->term = enif_make_badarg(ret->env);
ret->ready = B_TRUE;
}
free(string);
}
} else if (enif_is_list(ret->env, arg)) {
enif_get_list_length(ret->env, arg, &size);
string = (char *)(malloc(sizeof (char) * (size + 1)));
if (string == NULL) {
ret->term = EKSTAT_ERROR("list malloc");
ret->ready = B_TRUE;
return;
}
result = enif_get_string(ret->env, arg, string, size + 1, ERL_NIF_LATIN1);
if (result == 0) {
ret->term = enif_make_badarg(ret->env);
ret->ready = B_TRUE;
} else {
pattern->pstr = (char *)(ks_safe_strdup(ret, string));
pattern->free = B_TRUE;
}
free(string);
} else if (enif_is_number(ret->env, arg)) {
if (enif_get_int64(ret->env, arg, &integer)) {
(void) asprintf(&string, "%d", integer);
pattern->pstr = (char *)(ks_safe_strdup(ret, string));
pattern->free = B_TRUE;
} else {
ret->term = enif_make_badarg(ret->env);
ret->ready = B_TRUE;
}
free(string);
} else {
ret->term = enif_make_badarg(ret->env);
ret->ready = B_TRUE;
}
}
}
int
main(int argc, char **argv)
{
ks_selector_t *nselector;
ks_selector_t *uselector;
kstat_ctl_t *kc;
hrtime_t start_n;
hrtime_t period_n;
boolean_t errflg = B_FALSE;
boolean_t nselflg = B_FALSE;
boolean_t uselflg = B_FALSE;
char *q;
int count = 1;
int infinite_cycles = 0;
int interval = 0;
int n = 0;
int c, m, tmp;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */
#endif
(void) textdomain(TEXT_DOMAIN);
/*
* Create the selector list and a dummy default selector to match
* everything. While we process the cmdline options we will add
* selectors to this list.
*/
list_create(&selector_list, sizeof (ks_selector_t),
offsetof(ks_selector_t, ks_next));
nselector = new_selector();
/*
* Parse named command line arguments.
*/
while ((c = getopt(argc, argv, "h?Cqjlpx:H:T:m:i:n:s:c:")) != EOF)
switch (c) {
case 'h':
case '?':
usage();
exit(0);
break;
case 'C':
g_pflg = g_cflg = B_TRUE;
break;
case 'q':
g_qflg = B_TRUE;
break;
case 'j':
g_jflg = B_TRUE;
break;
case 'l':
g_pflg = g_lflg = B_TRUE;
break;
case 'H':
g_host = B_TRUE;
tachyon_host = (char *)ks_safe_strdup(optarg);
break;
case 'x':
g_url = g_pflg = g_nflg = B_TRUE;
// If we use nsq we need to init curl globaly.
tm_curl_global_init();
tachyon_url = (char *)ks_safe_strdup(optarg);
break;
case 'p':
g_pflg = B_TRUE;
break;
case 'T':
switch (*optarg) {
case 'd':
g_timestamp_fmt = DDATE;
break;
case 'u':
g_timestamp_fmt = UDATE;
break;
default:
errflg = B_TRUE;
}
break;
case 'm':
nselflg = B_TRUE;
nselector->ks_module.pstr =
(char *)ks_safe_strdup(optarg);
break;
case 'i':
nselflg = B_TRUE;
nselector->ks_instance.pstr =
(char *)ks_safe_strdup(optarg);
break;
case 'n':
nselflg = B_TRUE;
nselector->ks_name.pstr =
(char *)ks_safe_strdup(optarg);
break;
case 's':
nselflg = B_TRUE;
nselector->ks_statistic.pstr =
(char *)ks_safe_strdup(optarg);
break;
case 'c':
g_ks_class.pstr =
(char *)ks_safe_strdup(optarg);
break;
default:
errflg = B_TRUE;
break;
}
if (g_qflg && (g_jflg || g_pflg || g_nflg)) {
(void) fprintf(stderr, gettext(
"-q and -lpjn are mutually exclusive\n"));
errflg = B_TRUE;
}
if (g_url ^ g_host) {
(void) fprintf(stderr, gettext(
"-H and -x must both be set.\n"));
errflg = B_TRUE;
}
if (errflg) {
usage();
exit(2);
}
argc -= optind;
argv += optind;
/*
* Consume the rest of the command line. Parsing the
* unnamed command line arguments.
*/
while (argc--) {
errno = 0;
tmp = strtoul(*argv, &q, 10);
if (tmp == ULONG_MAX && errno == ERANGE) {
if (n == 0) {
(void) fprintf(stderr, gettext(
"Interval is too large\n"));
} else if (n == 1) {
(void) fprintf(stderr, gettext(
"Count is too large\n"));
}
usage();
exit(2);
}
if (errno != 0 || *q != '\0') {
m = 0;
uselector = new_selector();
while ((q = (char *)strsep(argv, ":")) != NULL) {
m++;
if (m > 4) {
free(uselector);
usage();
exit(2);
}
if (*q != '\0') {
switch (m) {
case 1:
uselector->ks_module.pstr =
(char *)ks_safe_strdup(q);
break;
case 2:
uselector->ks_instance.pstr =
(char *)ks_safe_strdup(q);
break;
case 3:
uselector->ks_name.pstr =
(char *)ks_safe_strdup(q);
break;
case 4:
uselector->ks_statistic.pstr =
(char *)ks_safe_strdup(q);
break;
default:
assert(B_FALSE);
}
}
}
uselflg = B_TRUE;
list_insert_tail(&selector_list, uselector);
} else {
if (tmp < 1) {
if (n == 0) {
(void) fprintf(stderr, gettext(
"Interval must be an "
"integer >= 1"));
} else if (n == 1) {
(void) fprintf(stderr, gettext(
"Count must be an integer >= 1"));
}
usage();
exit(2);
} else {
if (n == 0) {
interval = tmp;
count = -1;
} else if (n == 1) {
count = tmp;
} else {
usage();
exit(2);
}
}
n++;
}
argv++;
}
/*
* Check if we founded a named selector on the cmdline.
*/
if (uselflg) {
if (nselflg) {
(void) fprintf(stderr, gettext(
"[module[:instance[:name[:statistic]]]] and "
"-m -i -n -s are mutually exclusive"));
usage();
exit(2);
} else {
free(nselector);
}
} else {
list_insert_tail(&selector_list, nselector);
}
assert(!list_is_empty(&selector_list));
list_create(&instances_list, sizeof (ks_instance_t),
offsetof(ks_instance_t, ks_next));
while ((kc = kstat_open()) == NULL) {
if (errno == EAGAIN) {
(void) poll(NULL, 0, 200);
} else {
perror("kstat_open");
exit(3);
}
}
if (count > 1) {
if (signal(SIGCONT, cont_handler) == SIG_ERR) {
(void) fprintf(stderr, gettext(
"signal failed"));
exit(3);
}
}
period_n = (hrtime_t)interval * NANOSEC;
start_n = gethrtime();
while (count == -1 || count-- > 0) {
ks_instances_read(kc);
kstat_time = time(NULL);
ks_instances_print();
if (interval && count) {
ks_sleep_until(&start_n, period_n, infinite_cycles,
&caught_cont);
(void) kstat_chain_update(kc);
if (! g_nflg)
(void) putchar('\n');
}
}
(void) kstat_close(kc);
return (g_matched);
}
