static clib_error_t *
abf_policy_cmd (vlib_main_t * vm,
unformat_input_t * main_input, vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
u32 acl_index, policy_id;
fib_route_path_t *rpaths = NULL, rpath;
u32 is_del;
is_del = 0;
acl_index = INDEX_INVALID;
policy_id = INDEX_INVALID;
/* Get a line of input. */
if (!unformat_user (main_input, unformat_line_input, line_input))
return 0;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "acl %d", &acl_index))
;
else if (unformat (line_input, "id %d", &policy_id))
;
else if (unformat (line_input, "del"))
is_del = 1;
else if (unformat (line_input, "add"))
is_del = 0;
else if (unformat (line_input, "via %U",
unformat_fib_route_path, &rpath))
vec_add1 (rpaths, rpath);
else
return (clib_error_return (0, "unknown input '%U'",
format_unformat_error, line_input));
}
if (INDEX_INVALID == policy_id)
{
vlib_cli_output (vm, "Specify a Policy ID");
return 0;
}
if (!is_del)
{
if (INDEX_INVALID == acl_index)
{
vlib_cli_output (vm, "ACL index must be set");
return 0;
}
abf_policy_update (policy_id, acl_index, rpaths);
}
else
{
abf_policy_delete (policy_id, rpaths);
}
unformat_free (line_input);
return (NULL);
}
static clib_error_t *
show_errors (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
vlib_error_main_t *em = &vm->error_main;
vlib_node_t *n;
u32 code, i, ni;
u64 c;
int index = 0;
int verbose = 0;
u64 *sums = 0;
if (unformat (input, "verbose %d", &verbose))
;
else if (unformat (input, "verbose"))
verbose = 1;
vec_validate (sums, vec_len (em->counters));
if (verbose)
vlib_cli_output (vm, "%=10s%=40s%=20s%=6s", "Count", "Node", "Reason",
"Index");
else
vlib_cli_output (vm, "%=10s%=40s%=6s", "Count", "Node", "Reason");
/* *INDENT-OFF* */
foreach_vlib_main(({
em = &this_vlib_main->error_main;
if (verbose)
vlib_cli_output(vm, "Thread %u (%v):", index,
vlib_worker_threads[index].name);
for (ni = 0; ni < vec_len (this_vlib_main->node_main.nodes); ni++)
{
n = vlib_get_node (this_vlib_main, ni);
for (code = 0; code < n->n_errors; code++)
{
i = n->error_heap_index + code;
c = em->counters[i];
if (i < vec_len (em->counters_last_clear))
c -= em->counters_last_clear[i];
sums[i] += c;
if (c == 0 && verbose < 2)
continue;
if (verbose)
vlib_cli_output (vm, "%10Ld%=40v%=20s%=6d", c, n->name,
em->error_strings_heap[i], i);
else
vlib_cli_output (vm, "%10d%=40v%s", c, n->name,
em->error_strings_heap[i]);
}
}
index++;
}));
void cj_enable_disable (int is_enable)
{
cj_main_t * cjm = &cj_main;
if (cjm->num_records)
cjm->enable = is_enable;
else
vlib_cli_output (cjm->vlib_main, "CJ not configured...");
}
static clib_error_t *
netmap_create_command_fn (vlib_main_t * vm, unformat_input_t * input,
vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, * line_input = &_line_input;
u8 * host_if_name = NULL;
u8 hwaddr [6];
u8 * hw_addr_ptr = 0;
int r;
u8 is_pipe = 0;
u8 is_master = 0;
u32 sw_if_index = ~0;
/* Get a line of input. */
if (! unformat_user (input, unformat_line_input, line_input))
return 0;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "name %s", &host_if_name))
;
else if (unformat (line_input, "hw-addr %U", unformat_ethernet_address, hwaddr))
hw_addr_ptr = hwaddr;
else if (unformat (line_input, "pipe"))
is_pipe = 1;
else if (unformat (line_input, "master"))
is_master = 1;
else if (unformat (line_input, "slave"))
is_master = 0;
else
return clib_error_return (0, "unknown input `%U'", format_unformat_error, input);
}
unformat_free (line_input);
if (host_if_name == NULL)
return clib_error_return (0, "missing host interface name");
r = netmap_create_if(vm, host_if_name, hw_addr_ptr, is_pipe, is_master, &sw_if_index);
if (r == VNET_API_ERROR_SYSCALL_ERROR_1)
return clib_error_return(0, "%s (errno %d)", strerror (errno), errno);
if (r == VNET_API_ERROR_INVALID_INTERFACE)
return clib_error_return(0, "Invalid interface name");
if (r == VNET_API_ERROR_SUBIF_ALREADY_EXISTS)
return clib_error_return(0, "Interface already exists");
vlib_cli_output(vm, "%U\n", format_vnet_sw_if_index_name, vnet_get_main(), sw_if_index);
return 0;
}
static clib_error_t *
test_sparse_vec_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
/* A sparse vector ... */
int *spv = 0;
int i, c0, c1;
u32 i0, i1;
/* set one member */
sparse_vec_validate (spv, 42)[0] = 0x4242;
/* count how many times we can find it */
c0 = 0;
for (i = 0; i <= 0xffff; i++)
{
c0 += (sparse_vec_index (spv, i) != 0);
}
if (c0 != 1)
vlib_cli_output (vm, "sparse_vec_index failed: c0 is %d != 1", c0);
c0 = 0;
c1 = 0;
for (i = 0; i <= 0xffff; i++)
{
sparse_vec_index2 (spv, i, 0xffff ^ i, &i0, &i1);
c0 += (i0 != 0);
c1 += (i1 != 0);
}
if (c0 != 1)
vlib_cli_output (vm, "sparse_vec_index2 failed: c0 is %d != 1", c0);
if (c1 != 1)
vlib_cli_output (vm, "sparse_vec_index2 failed: c1 is %d != 1", c1);
return 0;
}
static clib_error_t *
set_ioam_export_ipfix_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
ioam_export_main_t *em = &ioam_export_main;
ip4_address_t collector, src;
u8 is_disable = 0;
collector.as_u32 = 0;
src.as_u32 = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "collector %U", unformat_ip4_address, &collector))
;
else if (unformat (input, "src %U", unformat_ip4_address, &src))
;
else if (unformat (input, "disable"))
is_disable = 1;
else
break;
}
if (collector.as_u32 == 0)
return clib_error_return (0, "collector address required");
if (src.as_u32 == 0)
return clib_error_return (0, "src address required");
em->ipfix_collector.as_u32 = collector.as_u32;
em->src_address.as_u32 = src.as_u32;
vlib_cli_output (vm, "Collector %U, src address %U",
format_ip4_address, &em->ipfix_collector,
format_ip4_address, &em->src_address);
/* Turn on the export timer process */
// vlib_process_signal_event (vm, flow_report_process_node.index,
//1, 0);
ioam_export_ip6_enable_disable (em, is_disable, &collector, &src);
return 0;
}
static void
vl_msg_api_process_file (vlib_main_t * vm, u8 * filename,
u32 first_index, u32 last_index,
vl_api_replay_t which)
{
vl_api_trace_file_header_t *hp;
int i, fd;
struct stat statb;
size_t file_size;
u8 *msg;
u8 endian_swap_needed = 0;
api_main_t *am = &api_main;
static u8 *tmpbuf;
u32 nitems;
void **saved_print_handlers = 0;
fd = open ((char *) filename, O_RDONLY);
if (fd < 0)
{
vlib_cli_output (vm, "Couldn't open %s\n", filename);
return;
}
if (fstat (fd, &statb) < 0)
{
vlib_cli_output (vm, "Couldn't stat %s\n", filename);
return;
}
if (!(statb.st_mode & S_IFREG) || (statb.st_size < sizeof (*hp)))
{
vlib_cli_output (vm, "File not plausible: %s\n", filename);
close(fd);
return;
}
file_size = statb.st_size;
file_size = (file_size + 4095) & ~(4096);
hp = mmap (0, file_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (hp == (vl_api_trace_file_header_t *) MAP_FAILED)
{
vlib_cli_output (vm, "mmap failed: %s\n", filename);
close (fd);
return;
}
close (fd);
if ((clib_arch_is_little_endian && hp->endian == VL_API_BIG_ENDIAN)
|| (clib_arch_is_big_endian && hp->endian == VL_API_LITTLE_ENDIAN))
endian_swap_needed = 1;
if (endian_swap_needed)
nitems = ntohl (hp->nitems);
else
nitems = hp->nitems;
if (last_index == (u32) ~ 0)
{
last_index = nitems - 1;
}
if (first_index >= nitems || last_index >= nitems)
{
vlib_cli_output (vm, "Range (%d, %d) outside file range (0, %d)\n",
first_index, last_index, nitems - 1);
munmap (hp, file_size);
return;
}
if (hp->wrapped)
vlib_cli_output (vm,
"Note: wrapped/incomplete trace, results may vary\n");
if (which == CUSTOM_DUMP)
{
saved_print_handlers = (void **) vec_dup (am->msg_print_handlers);
vl_msg_api_custom_dump_configure (am);
}
msg = (u8 *) (hp + 1);
for (i = 0; i < first_index; i++)
{
trace_cfg_t *cfgp;
int size;
u16 msg_id;
if (clib_arch_is_little_endian)
msg_id = ntohs (*((u16 *) msg));
else
msg_id = *((u16 *) msg);
cfgp = am->api_trace_cfg + msg_id;
if (!cfgp)
{
vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
return;
}
size = cfgp->size;
msg += size;
}
for (; i <= last_index; i++)
{
trace_cfg_t *cfgp;
u16 *msg_idp;
u16 msg_id;
int size;
if (which == DUMP)
vlib_cli_output (vm, "---------- trace %d -----------\n", i);
if (clib_arch_is_little_endian)
msg_id = ntohs (*((u16 *) msg));
else
msg_id = *((u16 *) msg);
cfgp = am->api_trace_cfg + msg_id;
if (!cfgp)
{
vlib_cli_output (vm, "Ugh: msg id %d no trace config\n", msg_id);
return;
}
size = cfgp->size;
/* Copy the buffer (from the read-only mmap'ed file) */
vec_validate (tmpbuf, size - 1 + sizeof (uword));
clib_memcpy (tmpbuf + sizeof (uword), msg, size);
memset (tmpbuf, 0xf, sizeof (uword));
/*
* Endian swap if needed. All msg data is supposed to be
* in network byte order. All msg handlers are supposed to
* know that. The generic message dumpers don't know that.
* One could fix apigen, I suppose.
*/
if ((which == DUMP && clib_arch_is_little_endian) || endian_swap_needed)
{
void (*endian_fp) (void *);
if (msg_id >= vec_len (am->msg_endian_handlers)
|| (am->msg_endian_handlers[msg_id] == 0))
{
vlib_cli_output (vm, "Ugh: msg id %d no endian swap\n", msg_id);
return;
}
endian_fp = am->msg_endian_handlers[msg_id];
(*endian_fp) (tmpbuf + sizeof (uword));
}
/* msg_id always in network byte order */
if (clib_arch_is_little_endian)
{
msg_idp = (u16 *) (tmpbuf + sizeof (uword));
*msg_idp = msg_id;
}
switch (which)
{
case CUSTOM_DUMP:
case DUMP:
if (msg_id < vec_len (am->msg_print_handlers) &&
am->msg_print_handlers[msg_id])
{
u8 *(*print_fp) (void *, void *);
print_fp = (void *) am->msg_print_handlers[msg_id];
(*print_fp) (tmpbuf + sizeof (uword), vm);
}
else
{
vlib_cli_output (vm, "Skipping msg id %d: no print fcn\n",
msg_id);
break;
}
break;
case INITIALIZERS:
if (msg_id < vec_len (am->msg_print_handlers) &&
am->msg_print_handlers[msg_id])
{
u8 *s;
int j;
u8 *(*print_fp) (void *, void *);
print_fp = (void *) am->msg_print_handlers[msg_id];
vlib_cli_output (vm, "/*");
(*print_fp) (tmpbuf + sizeof (uword), vm);
vlib_cli_output (vm, "*/\n");
s = format (0, "static u8 * vl_api_%s_%d[%d] = {",
am->msg_names[msg_id], i,
am->api_trace_cfg[msg_id].size);
for (j = 0; j < am->api_trace_cfg[msg_id].size; j++)
{
if ((j & 7) == 0)
s = format (s, "\n ");
s = format (s, "0x%02x,", tmpbuf[sizeof (uword) + j]);
}
s = format (s, "\n};\n%c", 0);
vlib_cli_output (vm, (char *) s);
vec_free (s);
}
break;
case REPLAY:
if (msg_id < vec_len (am->msg_print_handlers) &&
am->msg_print_handlers[msg_id] && cfgp->replay_enable)
{
void (*handler) (void *);
handler = (void *) am->msg_handlers[msg_id];
if (!am->is_mp_safe[msg_id])
vl_msg_api_barrier_sync ();
(*handler) (tmpbuf + sizeof (uword));
if (!am->is_mp_safe[msg_id])
vl_msg_api_barrier_release ();
}
else
{
if (cfgp->replay_enable)
vlib_cli_output (vm, "Skipping msg id %d: no handler\n",
msg_id);
break;
}
break;
}
_vec_len (tmpbuf) = 0;
msg += size;
}
if (saved_print_handlers)
{
clib_memcpy (am->msg_print_handlers, saved_print_handlers,
vec_len (am->msg_print_handlers) * sizeof (void *));
vec_free (saved_print_handlers);
}
munmap (hp, file_size);
}
