int
vlib_unix_main (int argc, char *argv[])
{
vlib_main_t *vm = &vlib_global_main; /* one and only time for this! */
unformat_input_t input;
clib_error_t *e;
int i;
vm->argv = (u8 **) argv;
vm->name = argv[0];
vm->heap_base = clib_mem_get_heap ();
vm->heap_aligned_base = (void *)
(((uword) vm->heap_base) & ~(VLIB_FRAME_ALIGN - 1));
ASSERT (vm->heap_base);
unformat_init_command_line (&input, (char **) vm->argv);
if ((e = vlib_plugin_config (vm, &input)))
{
clib_error_report (e);
return 1;
}
unformat_free (&input);
i = vlib_plugin_early_init (vm);
if (i)
return i;
unformat_init_command_line (&input, (char **) vm->argv);
if (vm->init_functions_called == 0)
vm->init_functions_called = hash_create (0, /* value bytes */ 0);
e = vlib_call_all_config_functions (vm, &input, 1 /* early */ );
if (e != 0)
{
clib_error_report (e);
return 1;
}
unformat_free (&input);
/* always load symbols, for signal handler and mheap memory get/put backtrace */
clib_elf_main_init (vm->name);
vec_validate (vlib_thread_stacks, 0);
vlib_thread_stack_init (0);
__os_thread_index = 0;
vm->thread_index = 0;
i = clib_calljmp (thread0, (uword) vm,
(void *) (vlib_thread_stacks[0] +
VLIB_THREAD_STACK_SIZE));
return i;
}
int main (int argc, char * argv[])
{
unformat_input_t i;
int ret;
unformat_init_command_line (&i, argv);
ret = test_macros_main (&i);
unformat_free (&i);
return ret;
}
int main (int argc, char * argv [])
{
unformat_input_t i;
int r;
verbose = (argc > 1);
unformat_init_command_line (&i, argv);
r = test_socket_main (&i);
unformat_free (&i);
return r;
}
int main (int argc, char * argv[])
{
unformat_input_t i;
int ret;
clib_mem_init (0, 3ULL<<30);
unformat_init_command_line (&i, argv);
ret = test_random_main (&i);
unformat_free (&i);
return ret;
}
static uword
thread0 (uword arg)
{
vlib_main_t *vm = (vlib_main_t *) arg;
unformat_input_t input;
int i;
unformat_init_command_line (&input, (char **) vm->argv);
i = vlib_main (vm, &input);
unformat_free (&input);
return i;
}
int test_elog_main (unformat_input_t * input)
{
clib_error_t * error = 0;
u32 i, n_iter, seed, max_events;
elog_main_t _em, * em = &_em;
u32 verbose;
f64 min_sample_time;
char * dump_file, * load_file, * merge_file, ** merge_files;
u8 * tag, ** tags;
n_iter = 100;
max_events = 100000;
seed = 1;
verbose = 0;
dump_file = 0;
load_file = 0;
merge_files = 0;
tags = 0;
min_sample_time = 2;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "iter %d", &n_iter))
;
else if (unformat (input, "seed %d", &seed))
;
else if (unformat (input, "dump %s", &dump_file))
;
else if (unformat (input, "load %s", &load_file))
;
else if (unformat (input, "tag %s", &tag))
vec_add1 (tags, tag);
else if (unformat (input, "merge %s", &merge_file))
vec_add1 (merge_files, merge_file);
else if (unformat (input, "verbose %=", &verbose, 1))
;
else if (unformat (input, "max-events %d", &max_events))
;
else if (unformat (input, "sample-time %f", &min_sample_time))
;
else
{
error = clib_error_create ("unknown input `%U'\n",
format_unformat_error, input);
goto done;
}
}
#ifdef CLIB_UNIX
if (load_file)
{
if ((error = elog_read_file (em, load_file)))
goto done;
}
else if (merge_files)
{
uword i;
elog_main_t * ems;
vec_clone (ems, merge_files);
elog_init (em, max_events);
for (i = 0; i < vec_len (ems); i++)
{
if ((error = elog_read_file (i == 0 ? em : &ems[i], merge_files[i])))
goto done;
if (i > 0)
{
elog_merge (em, tags[0], &ems[i], tags[i]);
tags[0] = 0;
}
}
}
else
#endif /* CLIB_UNIX */
{
f64 t[2];
elog_init (em, max_events);
elog_enable_disable (em, 1);
t[0] = unix_time_now ();
for (i = 0; i < n_iter; i++)
{
u32 j, n, sum;
n = 1 + (random_u32 (&seed) % 128);
sum = 0;
for (j = 0; j < n; j++)
sum += random_u32 (&seed);
{
ELOG_TYPE_XF (e);
ELOG (em, e, sum);
}
{
ELOG_TYPE_XF (e);
ELOG (em, e, sum + 1);
}
{
struct { u32 string_index; f32 f; } * d;
ELOG_TYPE_DECLARE (e) = {
.format = "fumble %s %.9f",
.format_args = "t4f4",
.n_enum_strings = 4,
.enum_strings = {
"string0",
"string1",
"string2",
"string3",
},
};
d = ELOG_DATA (em, e);
d->string_index = sum & 3;
d->f = (sum & 0xff) / 128.;
}
{
ELOG_TYPE_DECLARE (e) = {
.format = "bar %d.%d.%d.%d",
.format_args = "i1i1i1i1",
};
ELOG_TRACK (my_track);
u8 * d = ELOG_TRACK_DATA (em, e, my_track);
d[0] = i + 0;
d[1] = i + 1;
d[2] = i + 2;
d[3] = i + 3;
}
{
ELOG_TYPE_DECLARE (e) = {
.format = "bar `%s'",
.format_args = "s20",
};
struct { char s[20]; } * d;
u8 * v;
d = ELOG_DATA (em, e);
v = format (0, "foo %d%c", i, 0);
memcpy (d->s, v, clib_min (vec_len (v), sizeof (d->s)));
}
{
ELOG_TYPE_DECLARE (e) = {
.format = "bar `%s'",
.format_args = "T4",
};
struct { u32 offset; } * d;
d = ELOG_DATA (em, e);
d->offset = elog_string (em, "string table %d", i);
}
}
do {
t[1] = unix_time_now ();
} while (t[1] - t[0] < min_sample_time);
}
#ifdef CLIB_UNIX
if (dump_file)
{
if ((error = elog_write_file (em, dump_file)))
goto done;
}
#endif
if (verbose)
{
elog_event_t * e, * es;
es = elog_get_events (em);
vec_foreach (e, es)
{
clib_warning ("%18.9f: %12U %U\n", e->time,
format_elog_track, em, e,
format_elog_event, em, e);
}
}
done:
if (error)
clib_error_report (error);
return 0;
}
#ifdef CLIB_UNIX
int main (int argc, char * argv [])
{
unformat_input_t i;
int r;
unformat_init_command_line (&i, argv);
r = test_elog_main (&i);
unformat_free (&i);
return r;
}
int
main (int argc, char **argv)
{
unformat_input_t input;
char *chroot_path = 0;
u8 *chroot_path_u8;
int interval = 0;
f64 *vector_ratep, *rx_ratep, *sig_error_ratep;
pid_t *vpp_pidp;
svmdb_map_args_t _ma, *ma = &_ma;
int uid, gid, rv;
struct passwd _pw, *pw;
struct group _grp, *grp;
char *s, buf[128];
unformat_init_command_line (&input, argv);
uid = geteuid ();
gid = getegid ();
while (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (&input, "chroot %s", &chroot_path_u8))
{
chroot_path = (char *) chroot_path_u8;
}
else if (unformat (&input, "interval %d", &interval))
;
else if (unformat (&input, "uid %d", &uid))
;
else if (unformat (&input, "gid %d", &gid))
;
else if (unformat (&input, "uid %s", &s))
{
/* lookup the username */
pw = NULL;
rv = getpwnam_r (s, &_pw, buf, sizeof (buf), &pw);
if (rv < 0)
{
fformat (stderr, "cannot fetch username %s", s);
exit (1);
}
if (pw == NULL)
{
fformat (stderr, "username %s does not exist", s);
exit (1);
}
vec_free (s);
uid = pw->pw_uid;
}
else if (unformat (&input, "gid %s", &s))
{
/* lookup the group name */
grp = NULL;
rv = getgrnam_r (s, &_grp, buf, sizeof (buf), &grp);
if (rv != 0)
{
fformat (stderr, "cannot fetch group %s", s);
exit (1);
}
if (grp == NULL)
{
fformat (stderr, "group %s does not exist", s);
exit (1);
}
vec_free (s);
gid = grp->gr_gid;
}
else
{
fformat (stderr,
"usage: vpp_get_metrics [chroot <path>] [interval <nn>]\n");
exit (1);
}
}
setup_signal_handlers ();
clib_memset (ma, 0, sizeof (*ma));
ma->root_path = chroot_path;
ma->uid = uid;
ma->gid = gid;
c = svmdb_map (ma);
vpp_pidp =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC, "vpp_pid");
vector_ratep =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC,
"vpp_vector_rate");
rx_ratep =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC,
"vpp_input_rate");
sig_error_ratep =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC,
"vpp_sig_error_rate");
/*
* Make sure vpp is actually running. Otherwise, there's every
* chance that the database region will be wiped out by the
* process monitor script
*/
if (vpp_pidp == 0 || vector_ratep == 0 || rx_ratep == 0
|| sig_error_ratep == 0)
{
fformat (stdout, "vpp not running\n");
exit (1);
}
do
{
/*
* Once vpp exits, the svm db region will be recreated...
* Can't use kill (*vpp_pidp, 0) if running as non-root /
* accessing the shared-VM database via group perms.
*/
if (*vpp_pidp == 0)
{
fformat (stdout, "vpp not running\n");
exit (1);
}
fformat (stdout,
"%d: vpp_vector_rate=%.2f, vpp_input_rate=%f, vpp_sig_error_rate=%f\n",
*vpp_pidp, *vector_ratep, *rx_ratep, *sig_error_ratep);
if (interval)
sleep (interval);
if (signal_received)
break;
}
while (interval);
svmdb_unmap (c);
exit (0);
}
