/* vmxnet3 delete API */
static int
api_vmxnet3_delete (vat_main_t * vam)
{
unformat_input_t *i = vam->input;
vl_api_vmxnet3_delete_t *mp;
u32 sw_if_index = 0;
u8 index_defined = 0;
int ret;
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
if (unformat (i, "sw_if_index %u", &sw_if_index))
index_defined = 1;
else
{
clib_warning ("unknown input '%U'", format_unformat_error, i);
return -99;
}
}
if (!index_defined)
{
errmsg ("missing sw_if_index\n");
return -99;
}
M (VMXNET3_DELETE, mp);
mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
S (mp);
W (ret);
return ret;
}
static clib_error_t *
cdp_command_fn (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
cdp_main_t *cm = &cdp_main;
int enable_disable = 1;
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "disable"))
enable_disable = 0;
else if (unformat (input, "enable"))
enable_disable = 1;
else
break;
}
rv = cdp_enable_disable (cm, enable_disable);
switch (rv)
{
case 0:
break;
default:
return clib_error_return (0, "cdp_enable_disable returned %d", rv);
}
return 0;
}
static clib_error_t *
netmap_delete_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;
/* 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
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");
netmap_delete_if(vm, host_if_name);
return 0;
}
static clib_error_t *
mrvl_pp2_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;
mrvl_pp2_create_if_args_t args = { 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", &args.name))
;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
unformat_free (line_input);
mrvl_pp2_create_if (&args);
vec_free (args.name);
return args.error;
}
static clib_error_t *
virtio_pci_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;
virtio_pci_create_if_args_t args;
u64 feature_mask = (u64) ~ (0ULL);
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
memset (&args, 0, sizeof (args));
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "%U", unformat_vlib_pci_addr, &args.addr))
;
else if (unformat (line_input, "feature-mask 0x%llx", &feature_mask))
args.features = feature_mask;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
unformat_free (line_input);
virtio_pci_create_if (vm, &args);
return args.error;
}
static clib_error_t *
cj_config (vlib_main_t * vm, unformat_input_t * input)
{
cj_main_t * cjm = &cj_main;
int matched = 0;
int enable = 0;
while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "records %d", &cjm->num_records))
matched = 1;
else if (unformat (input, "on"))
enable = 1;
else
return clib_error_return (0, "cj_config: unknown input '%U'",
format_unformat_error, input);
}
if (matched == 0)
return 0;
cjm->num_records = max_pow2 (cjm->num_records);
vec_validate (cjm->records, cjm->num_records-1);
memset (cjm->records, 0xff, cjm->num_records * sizeof (cj_record_t));
cjm->tail = ~0;
cjm->enable = enable;
return 0;
}
static clib_error_t *
cj_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
int is_enable = -1;
int is_dump = -1;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
if (unformat (input, "enable") || unformat (input, "on"))
is_enable = 1;
else if (unformat (input, "disable") || unformat (input, "off"))
is_enable = 0;
else if (unformat (input, "dump"))
is_dump = 1;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
if (is_enable >= 0)
cj_enable_disable (is_enable);
if (is_dump > 0)
cj_dump ();
return 0;
}
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);
}
/* vmxnet3 create API */
static int
api_vmxnet3_create (vat_main_t * vam)
{
unformat_input_t *i = vam->input;
vl_api_vmxnet3_create_t *mp;
vmxnet3_create_if_args_t args;
int ret;
u32 x[4];
clib_memset (&args, 0, sizeof (vmxnet3_create_if_args_t));
while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
{
if (unformat (i, "%x:%x:%x.%x", &x[0], &x[1], &x[2], &x[3]))
{
args.addr.domain = x[0];
args.addr.bus = x[1];
args.addr.slot = x[2];
args.addr.function = x[3];
}
else if (unformat (i, "elog"))
args.enable_elog = 1;
else if (unformat (i, "bind"))
args.bind = 1;
else if (unformat (i, "rx-queue-size %u", &args.rxq_size))
;
else if (unformat (i, "tx-queue-size %u", &args.txq_size))
;
else if (unformat (i, "num-tx-queues %u", &args.txq_num))
;
else if (unformat (i, "num-rx-queues %u", &args.rxq_num))
;
else
{
clib_warning ("unknown input '%U'", format_unformat_error, i);
return -99;
}
}
M (VMXNET3_CREATE, mp);
mp->pci_addr = clib_host_to_net_u32 (args.addr.as_u32);
mp->enable_elog = clib_host_to_net_u16 (args.enable_elog);
mp->rxq_size = clib_host_to_net_u16 (args.rxq_size);
mp->txq_size = clib_host_to_net_u16 (args.txq_size);
mp->txq_num = clib_host_to_net_u16 (args.txq_num);
mp->rxq_num = clib_host_to_net_u16 (args.rxq_num);
mp->bind = args.bind;
S (mp);
W (ret);
return ret;
}
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 *
macswap_enable_disable_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
sample_main_t * sm = &sample_main;
u32 sw_if_index = ~0;
int enable_disable = 1;
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
if (unformat (input, "disable"))
enable_disable = 0;
else if (unformat (input, "%U", unformat_vnet_sw_interface,
sm->vnet_main, &sw_if_index))
;
else
break;
}
if (sw_if_index == ~0)
return clib_error_return (0, "Please specify an interface...");
rv = sample_macswap_enable_disable (sm, sw_if_index, enable_disable);
switch(rv) {
case 0:
break;
case VNET_API_ERROR_INVALID_SW_IF_INDEX:
return clib_error_return
(0, "Invalid interface, only works on physical ports");
break;
case VNET_API_ERROR_UNIMPLEMENTED:
return clib_error_return (0, "Device driver doesn't support redirection");
break;
default:
return clib_error_return (0, "sample_macswap_enable_disable returned %d",
rv);
}
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 clib_error_t *
qos_mark_cli (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
qos_egress_map_id_t map_id;
u32 sw_if_index, qs;
vnet_main_t *vnm;
int rv, enable;
vnm = vnet_get_main ();
map_id = ~0;
qs = 0xff;
enable = 1;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "id %d", &map_id))
;
else if (unformat (input, "disable"))
enable = 0;
else if (unformat (input, "%U", unformat_qos_source, &qs))
;
else if (unformat (input, "%U",
unformat_vnet_sw_interface, vnm, &sw_if_index))
;
else
break;
}
if (~0 == sw_if_index)
return clib_error_return (0, "interface must be specified");
if (0xff == qs)
return clib_error_return (0, "output location must be specified");
if (enable)
rv = qos_mark_enable (sw_if_index, qs, map_id);
else
rv = qos_mark_disable (sw_if_index, qs);
if (0 == rv)
return (NULL);
return clib_error_return (0, "Failed to map interface");
}
static clib_error_t *
show_virtio_pci_fn (vlib_main_t * vm, unformat_input_t * input,
vlib_cli_command_t * cmd)
{
virtio_main_t *vim = &virtio_main;
vnet_main_t *vnm = &vnet_main;
virtio_if_t *vif;
clib_error_t *error = 0;
u32 hw_if_index, *hw_if_indices = 0;
vnet_hw_interface_t *hi;
u8 show_descr = 0, show_device_config = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat
(input, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index))
{
hi = vnet_get_hw_interface (vnm, hw_if_index);
if (virtio_device_class.index != hi->dev_class_index)
{
error = clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
goto done;
}
vec_add1 (hw_if_indices, hw_if_index);
}
else if (unformat (input, "descriptors") || unformat (input, "desc"))
show_descr = 1;
else if (unformat (input, "debug-device"))
show_device_config = 1;
else
{
error = clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
goto done;
}
}
if (vec_len (hw_if_indices) == 0)
{
pool_foreach (vif, vim->interfaces,
vec_add1 (hw_if_indices, vif->hw_if_index);
);
static clib_error_t *
virtio_pci_delete_command_fn (vlib_main_t * vm, unformat_input_t * input,
vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, *line_input = &_line_input;
u32 sw_if_index = ~0;
vnet_hw_interface_t *hw;
virtio_main_t *vim = &virtio_main;
virtio_if_t *vif;
vnet_main_t *vnm = vnet_get_main ();
/* 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, "sw_if_index %d", &sw_if_index))
;
else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
vnm, &sw_if_index))
;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
unformat_free (line_input);
if (sw_if_index == ~0)
return clib_error_return (0,
"please specify interface name or sw_if_index");
hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
if (hw == NULL || virtio_device_class.index != hw->dev_class_index)
return clib_error_return (0, "not a virtio interface");
vif = pool_elt_at_index (vim->interfaces, hw->dev_instance);
if (virtio_pci_delete_if (vm, vif) < 0)
return clib_error_return (0, "not a virtio pci interface");
return 0;
}
clib_error_t *
ssvm_config (vlib_main_t * vm, unformat_input_t * input)
{
u8 * name;
int is_master = 1;
int i, rv;
ssvm_eth_main_t * em = &ssvm_eth_main;
while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "base-va %llx", &em->next_base_va))
;
else if (unformat (input, "segment-size %lld", &em->segment_size))
em->segment_size = 1ULL << (max_log2 (em->segment_size));
else if (unformat (input, "nbuffers %lld", &em->nbuffers))
;
else if (unformat (input, "queue-elts %lld", &em->queue_elts))
;
else if (unformat (input, "slave"))
is_master = 0;
else if (unformat (input, "%s", &name)) {
vec_add1 (em->names, name);
printf("AYXX: adding %s\n", name);
}
else
break;
}
/* No configured instances, we're done... */
if (vec_len (em->names) == 0)
return 0;
for (i = 0; i < vec_len (em->names); i++)
{
rv = ssvm_eth_create (em, em->names[i], is_master);
if (rv < 0)
return clib_error_return (0, "ssvm_eth_create '%s' failed, error %d",
em->names[i], rv);
}
return 0;
}
static int
api_trace_profile_add (vat_main_t * vam)
{
unformat_input_t *input = vam->input;
vl_api_trace_profile_add_t *mp;
u8 trace_type = 0;
u8 num_elts = 0;
u32 node_id = 0;
u32 app_data = 0;
u8 trace_tsp = 0;
int ret;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "trace-type 0x%x", &trace_type))
;
else if (unformat (input, "trace-elts %d", &num_elts))
;
else if (unformat (input, "trace-tsp %d", &trace_tsp))
;
else if (unformat (input, "node-id 0x%x", &node_id))
;
else if (unformat (input, "app-data 0x%x", &app_data))
;
else
break;
}
M (TRACE_PROFILE_ADD, mp);
mp->trace_type = trace_type;
mp->trace_tsp = trace_tsp;
mp->node_id = htonl (node_id);
mp->app_data = htonl (app_data);
mp->num_elts = num_elts;
S (mp);
W (ret);
return ret;
}
static clib_error_t *
cj_command_fn (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
int is_enable = -1;
int is_dump = -1;
unformat_input_t _line_input, *line_input = &_line_input;
clib_error_t *error = NULL;
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
return clib_error_return (0, "expected enable | disable | dump");
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "enable") || unformat (line_input, "on"))
is_enable = 1;
else if (unformat (line_input, "disable")
|| unformat (line_input, "off"))
is_enable = 0;
else if (unformat (line_input, "dump"))
is_dump = 1;
else
{
error = clib_error_return (0, "unknown input `%U'",
format_unformat_error, line_input);
goto done;
}
}
if (is_enable >= 0)
cj_enable_disable (is_enable);
if (is_dump > 0)
cj_dump ();
done:
unformat_free (line_input);
return error;
}
static clib_error_t *
rdma_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;
rdma_create_if_args_t args;
/* Get a line of input. */
if (!unformat_user (input, unformat_line_input, line_input))
return 0;
clib_memset (&args, 0, sizeof (rdma_create_if_args_t));
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "host-if %s", &args.ifname))
;
else if (unformat (line_input, "name %s", &args.name))
;
else if (unformat (line_input, "rx-queue-size %u", &args.rxq_size))
;
else if (unformat (line_input, "tx-queue-size %u", &args.txq_size))
;
else if (unformat (line_input, "num-rx-queues %u", &args.rxq_num))
;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
unformat_free (line_input);
rdma_create_if (vm, &args);
vec_free (args.ifname);
vec_free (args.name);
return args.error;
}
static clib_error_t *
virtual_ip_cmd_fn_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
unformat_input_t _line_input, * line_input = &_line_input;
vnet_main_t * vnm = vnet_get_main();
ip4_main_t * im = &ip4_main;
ip_lookup_main_t * lm = &im->lookup_main;
ip4_address_t ip_addr, next_hop;
u8 mac_addr[6];
mac_addr_t *mac_addrs = 0;
u32 sw_if_index;
u32 i, f;
/* Get a line of input. */
if (! unformat_user (input, unformat_line_input, line_input))
return 0;
if (!unformat(line_input, "%U %U",
unformat_ip4_address, &ip_addr,
unformat_vnet_sw_interface, vnm, &sw_if_index))
goto barf;
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) {
if (unformat (line_input, "mac %U",
unformat_ethernet_address,
&mac_addr))
{
mac_addr_t *ma;
vec_add2 (mac_addrs, ma, 1);
clib_memcpy(ma, mac_addr, sizeof (mac_addr));
} else {
barf:
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
}
if (vec_len (mac_addrs) == 0)
goto barf;
/* Create / delete special interface route /32's */
next_hop.as_u32 = 0;
for (i = 0; i < vec_len(mac_addrs); i++) {
ip_adjacency_t adj;
u32 adj_index;
adj.lookup_next_index = IP_LOOKUP_NEXT_REWRITE;
vnet_rewrite_for_sw_interface
(vnm,
VNET_L3_PACKET_TYPE_IP4,
sw_if_index,
ip4_rewrite_node.index,
&mac_addrs[i], /* destination address */
&adj.rewrite_header,
sizeof (adj.rewrite_data));
ip_add_adjacency (lm, &adj, 1 /* one adj */,
&adj_index);
f = (i + 1 < vec_len(mac_addrs)) ? IP4_ROUTE_FLAG_NOT_LAST_IN_GROUP : 0;
ip4_add_del_route_next_hop (im,
IP4_ROUTE_FLAG_ADD | f,
&ip_addr,
32 /* insert /32's */,
&next_hop,
sw_if_index,
1 /* weight */,
adj_index,
(u32)~0 /* explicit fib index */);
}
vec_free (mac_addrs);
return 0;
}
int test_standalone_string_main (unformat_input_t * input)
{
uword iter = 0;
uword help = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (0 == unformat (input, "iter %d", &iter)
&& 0 == unformat (input, "bytes %d", &g_bytes)
&& 0 == unformat (input, "seed %d", &g_seed)
&& 0 == unformat (input, "align %d", &g_align)
&& 0 == unformat (input, "overlap %d", &g_overlap)
&& 0 == unformat (input, "verbose %d", &g_verbose)
&& 0 == unformat (input, "swap %=", &g_swap, 1)
&& 0 == unformat (input, "help %=", &help, 1))
{
clib_error ("unknown input `%U'", format_unformat_error, input);
goto usage;
}
}
if (help)
goto usage;
fformat (stdout, "iter %d, bytes %d, seed %u, align %d, overlap %d, "
"verbose %d, %s\n",
iter, g_bytes, g_seed, g_align, g_overlap, g_verbose,
(g_swap) ? "swap" : "");
#if 1
assert_memset (iter);
assert_memcpy (iter);
assert_memmove (iter);
assert_memcmp (iter);
assert_strlen (iter);
#endif
if (g_bytes < 64)
{
fformat (stdout, "To ensure fairness in timing, the number of bytes "
"to process needs to be at least 64\n");
return -1;
}
#if 1
time_memset (iter);
time_memcpy (iter);
time_memmove (iter);
time_memcmp (iter);
time_strcpy (iter);
#endif
memory_snap ();
return 0;
usage:
fformat (stdout,
"Usage: test_standalone_string iter <N> bytes <N> seed <N>\n"
" align <N> overlap <N> verbose <N>\n"
" swap help\n");
if (help)
return 0;
return -1;
}
clib_error_t *
vlib_call_all_config_functions (vlib_main_t * vm,
unformat_input_t * input, int is_early)
{
clib_error_t *error = 0;
vlib_config_function_runtime_t *c, **all;
uword *hash = 0, *p;
uword i;
hash = hash_create_string (0, sizeof (uword));
all = 0;
c = vm->config_function_registrations;
while (c)
{
hash_set_mem (hash, c->name, vec_len (all));
vec_add1 (all, c);
unformat_init (&c->input, 0, 0);
c = c->next_registration;
}
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
u8 *s, *v;
if (!unformat (input, "%s %v", &s, &v) || !(p = hash_get_mem (hash, s)))
{
error = clib_error_create ("unknown input `%s %v'", s, v);
goto done;
}
c = all[p[0]];
if (vec_len (c->input.buffer) > 0)
vec_add1 (c->input.buffer, ' ');
vec_add (c->input.buffer, v, vec_len (v));
vec_free (v);
vec_free (s);
}
for (i = 0; i < vec_len (all); i++)
{
c = all[i];
/* Is this an early config? Are we doing early configs? */
if (is_early ^ c->is_early)
continue;
/* Already called? */
if (hash_get (vm->init_functions_called, c->function))
continue;
hash_set1 (vm->init_functions_called, c->function);
error = c->function (vm, &c->input);
if (error)
goto done;
}
done:
for (i = 0; i < vec_len (all); i++)
{
c = all[i];
unformat_free (&c->input);
}
vec_free (all);
hash_free (hash);
return error;
}
int test_socket_main (unformat_input_t * input)
{
clib_socket_t _s = {0}, * s = &_s;
char * config;
clib_error_t * error;
s->config = "localhost:22";
s->flags = SOCKET_IS_CLIENT;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "server %s %=", &config,
&s->flags, SOCKET_IS_SERVER))
;
else if (unformat (input, "client %s %=", &config,
&s->flags, SOCKET_IS_CLIENT))
;
else
{
error = clib_error_create ("unknown input `%U'\n",
format_unformat_error, input);
goto done;
}
}
error = clib_socket_init (s);
if (error)
goto done;
if (0)
{
struct { int a, b; } * msg;
msg = clib_socket_tx_add (s, sizeof (msg[0]));
msg->a = 99;
msg->b = 100;
}
else
clib_socket_tx_add_formatted (s, "hello there mr server %d\n", 99);
error = clib_socket_tx (s);
if (error)
goto done;
while (1)
{
error = clib_socket_rx (s, 100);
if (error)
break;
if (clib_socket_rx_end_of_file (s))
break;
if_verbose ("%v", s->rx_buffer);
_vec_len (s->rx_buffer) = 0;
}
error = clib_socket_close (s);
done:
if (error)
clib_error_report (error);
return 0;
}
static clib_error_t *
lisp_gpe_add_del_fwd_entry_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 is_add = 1;
ip_address_t lloc, rloc, *llocs = 0, *rlocs = 0;
clib_error_t * error = 0;
gid_address_t _reid, * reid = &_reid, _leid, * leid = &_leid;
u8 reid_set = 0, leid_set = 0, is_negative = 0, vrf_set = 0, vni_set = 0;
u32 vni, vrf, action = ~0;
int rv;
/* 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, "del"))
is_add = 0;
else if (unformat (line_input, "add"))
is_add = 1;
else if (unformat (line_input, "leid %U",
unformat_gid_address, leid))
{
leid_set = 1;
}
else if (unformat (line_input, "reid %U",
unformat_gid_address, reid))
{
reid_set = 1;
}
else if (unformat (line_input, "vni %u", &vni))
{
gid_address_vni (leid) = vni;
gid_address_vni (reid) = vni;
vni_set = 1;
}
else if (unformat (line_input, "vrf %u", &vrf))
{
vrf_set = 1;
}
else if (unformat (line_input, "negative action %U",
unformat_negative_mapping_action, &action))
{
is_negative = 1;
}
else if (unformat (line_input, "lloc %U rloc %U",
unformat_ip_address, &lloc,
unformat_ip_address, &rloc))
{
/* TODO: support p and w */
vec_add1 (llocs, lloc);
vec_add1 (rlocs, rloc);
}
else
{
error = unformat_parse_error (line_input);
goto done;
}
}
unformat_free (line_input);
if (!vni_set || !vrf_set)
{
error = clib_error_return(0, "vni and vrf must be set!");
goto done;
}
if (!reid_set)
{
error = clib_error_return(0, "remote eid must be set!");
goto done;
}
if (is_negative)
{
if (~0 == action)
{
error = clib_error_return(0, "no action set for negative tunnel!");
goto done;
}
}
else
{
if (vec_len (llocs) == 0)
{
error = clib_error_return (0, "expected ip4/ip6 locators.");
goto done;
}
if (vec_len (llocs) != 1)
{
error = clib_error_return (0, "multihoming not supported for now!");
goto done;
}
}
if (!leid_set)
{
/* if leid not set, make sure it's the same AFI like reid */
gid_address_type(leid) = gid_address_type(reid);
if (GID_ADDR_IP_PREFIX == gid_address_type (reid))
gid_address_ip_version(leid) = gid_address_ip_version(reid);
}
/* add fwd entry */
vnet_lisp_gpe_add_del_fwd_entry_args_t _a, * a = &_a;
memset (a, 0, sizeof(a[0]));
a->is_add = is_add;
a->vni = vni;
a->table_id = vrf;
gid_address_copy(&a->seid, leid);
gid_address_copy(&a->deid, reid);
if (!is_negative)
{
a->slocator = llocs[0];
a->dlocator = rlocs[0];
}
rv = vnet_lisp_gpe_add_del_fwd_entry (a, 0);
if (0 != rv)
{
error = clib_error_return(0, "failed to %s gpe tunnel!",
is_add ? "add" : "delete");
}
done:
vec_free(llocs);
vec_free(rlocs);
return error;
}
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);
}
/*
* enable or disable the output_feature
*/
static clib_error_t *
nsim_output_feature_enable_disable_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
nsim_main_t *nsm = &nsim_main;
unformat_input_t _line_input, *line_input = &_line_input;
u32 sw_if_index = ~0;
int enable_disable = 1;
int rv;
/* 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, "disable"))
enable_disable = 0;
else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
nsm->vnet_main, &sw_if_index))
;
else
{
clib_error_t *error = clib_error_return (0, "unknown input `%U'",
format_unformat_error,
line_input);
unformat_free (line_input);
return error;
}
}
unformat_free (line_input);
if (sw_if_index == ~0)
return clib_error_return (0, "Please specify one interface...");
rv = nsim_output_feature_enable_disable (nsm, sw_if_index, enable_disable);
switch (rv)
{
case 0:
break;
case VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE:
return clib_error_return (0, "Not configured, please 'set nsim' first");
case VNET_API_ERROR_INVALID_SW_IF_INDEX:
return clib_error_return
(0, "Invalid interface, only works on physical ports");
break;
case VNET_API_ERROR_UNIMPLEMENTED:
return clib_error_return (0,
"Device driver doesn't support redirection");
break;
default:
return clib_error_return
(0, "nsim_output_feature_enable_disable returned %d", rv);
}
return 0;
}
int test_random_main (unformat_input_t * input)
{
uword n_iterations;
uword i, repeat_count;
uword * bitmap = 0;
uword print;
u32 seed;
u32 *seedp = &seed;
/* first, check known sequence from Numerical Recipes in C, 2nd ed.
page 284 */
seed = known_random_sequence[0];
for (i = 0; i < ARRAY_LEN(known_random_sequence)-1; i++)
{
u32 rv;
rv = random_u32 (seedp);
if (rv != known_random_sequence[i+1])
{
fformat(stderr, "known sequence check FAILS at index %d", i+1);
break;
}
}
clib_warning ("known sequence check passes");
n_iterations = 1000;
seed = 0;
print = 1 << 24;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (0 == unformat (input, "iter %d", &n_iterations)
&& 0 == unformat (input, "print %d", &print)
&& 0 == unformat (input, "seed %d", &seed))
clib_error ("unknown input `%U'", format_unformat_error, input);
}
if (! seed)
seed = random_default_seed ();
if (n_iterations == 0)
n_iterations = random_u32_max ();
clib_warning ("%d iterations, seed %d\n", n_iterations, seed);
repeat_count = 0;
for (i = 0; i < n_iterations; i++)
{
uword r = random_u32 (&seed);
uword b, ri, rj;
ri = r / BITS (bitmap[0]);
rj = (uword) 1 << (r % BITS (bitmap[0]));
vec_validate (bitmap, ri);
b = bitmap[ri];
if (b & rj)
goto repeat;
b |= rj;
bitmap[ri] = b;
if (0 == (i & (print - 1)))
fformat (stderr, "0x%08x iterations %d repeats\n", i, repeat_count);
continue;
repeat:
fformat (stderr, "repeat found at iteration %d/%d\n", i, n_iterations);
repeat_count++;
continue;
}
return 0;
}
static clib_error_t *
unix_config (vlib_main_t * vm, unformat_input_t * input)
{
unix_main_t *um = &unix_main;
clib_error_t *error = 0;
gid_t gid;
int pidfd = -1;
/* Defaults */
um->cli_pager_buffer_limit = UNIX_CLI_DEFAULT_PAGER_LIMIT;
um->cli_history_limit = UNIX_CLI_DEFAULT_HISTORY;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
char *cli_prompt;
if (unformat (input, "interactive"))
um->flags |= UNIX_FLAG_INTERACTIVE;
else if (unformat (input, "nodaemon"))
um->flags |= UNIX_FLAG_NODAEMON;
else if (unformat (input, "cli-prompt %s", &cli_prompt))
vlib_unix_cli_set_prompt (cli_prompt);
else
if (unformat (input, "cli-listen %s", &um->cli_listen_socket.config))
;
else if (unformat (input, "runtime-dir %s", &um->runtime_dir))
;
else if (unformat (input, "cli-line-mode"))
um->cli_line_mode = 1;
else if (unformat (input, "cli-no-banner"))
um->cli_no_banner = 1;
else if (unformat (input, "cli-no-pager"))
um->cli_no_pager = 1;
else if (unformat (input, "poll-sleep-usec %d", &um->poll_sleep_usec))
;
else if (unformat (input, "cli-pager-buffer-limit %d",
&um->cli_pager_buffer_limit))
;
else
if (unformat (input, "cli-history-limit %d", &um->cli_history_limit))
;
else if (unformat (input, "coredump-size"))
{
uword coredump_size = 0;
if (unformat (input, "unlimited"))
{
coredump_size = RLIM_INFINITY;
}
else
if (!unformat (input, "%U", unformat_memory_size, &coredump_size))
{
return clib_error_return (0,
"invalid coredump-size parameter `%U'",
format_unformat_error, input);
}
const struct rlimit new_limit = { coredump_size, coredump_size };
if (0 != setrlimit (RLIMIT_CORE, &new_limit))
{
clib_unix_warning ("prlimit() failed");
}
}
else if (unformat (input, "full-coredump"))
{
int fd;
fd = open ("/proc/self/coredump_filter", O_WRONLY);
if (fd >= 0)
{
if (write (fd, "0x6f\n", 5) != 5)
clib_unix_warning ("coredump filter write failed!");
close (fd);
}
else
clib_unix_warning ("couldn't open /proc/self/coredump_filter");
}
else if (unformat (input, "startup-config %s",
&um->startup_config_filename))
;
else if (unformat (input, "exec %s", &um->startup_config_filename))
;
else if (unformat (input, "log %s", &um->log_filename))
{
um->log_fd = open ((char *) um->log_filename,
O_CREAT | O_WRONLY | O_APPEND, 0644);
if (um->log_fd < 0)
{
clib_warning ("couldn't open log '%s'\n", um->log_filename);
um->log_fd = 0;
}
else
{
u8 *lv = 0;
lv = format (0, "%U: ***** Start: PID %d *****\n",
format_timeval, 0 /* current bat-time */ ,
0 /* current bat-format */ ,
getpid ());
{
int rv __attribute__ ((unused)) =
write (um->log_fd, lv, vec_len (lv));
}
vec_free (lv);
}
}
else if (unformat (input, "gid %U", unformat_unix_gid, &gid))
{
if (setegid (gid) == -1)
return clib_error_return_unix (0, "setegid");
}
else if (unformat (input, "pidfile %s", &um->pidfile))
;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
}
if (um->runtime_dir == 0)
{
uid_t uid = geteuid ();
if (uid == 00)
um->runtime_dir = format (0, "/run/%s%c",
vlib_default_runtime_dir, 0);
else
um->runtime_dir = format (0, "/run/user/%u/%s%c", uid,
vlib_default_runtime_dir, 0);
}
error = setup_signal_handlers (um);
if (error)
return error;
if (um->pidfile)
{
if ((error = vlib_unix_validate_runtime_file (um,
(char *) um->pidfile,
&um->pidfile)))
return error;
if (((pidfd = open ((char *) um->pidfile,
O_CREAT | O_WRONLY | O_TRUNC, 0644)) < 0))
{
return clib_error_return_unix (0, "open");
}
}
if (!(um->flags & UNIX_FLAG_INTERACTIVE))
{
openlog (vm->name, LOG_CONS | LOG_PERROR | LOG_PID, LOG_DAEMON);
clib_error_register_handler (unix_error_handler, um);
if (!(um->flags & UNIX_FLAG_NODAEMON) && daemon ( /* chdir to / */ 0,
/* stdin/stdout/stderr -> /dev/null */
0) < 0)
clib_error_return (0, "daemon () fails");
}
if (pidfd >= 0)
{
u8 *lv = format (0, "%d", getpid ());
if (write (pidfd, (char *) lv, vec_len (lv)) != vec_len (lv))
{
vec_free (lv);
close (pidfd);
return clib_error_return_unix (0, "write");
}
vec_free (lv);
close (pidfd);
}
um->unix_config_complete = 1;
return 0;
}
int
test_mheap_main (unformat_input_t * input)
{
int i, j, k, n_iterations;
void *h, *h_mem;
uword *objects = 0;
u32 objects_used, really_verbose, n_objects, max_object_size;
u32 check_mask, seed, trace, use_vm;
u32 print_every = 0;
u32 *data;
mheap_t *mh;
/* Validation flags. */
check_mask = 0;
#define CHECK_VALIDITY 1
#define CHECK_DATA 2
#define CHECK_ALIGN 4
#define TEST1 8
n_iterations = 10;
seed = 0;
max_object_size = 100;
n_objects = 1000;
trace = 0;
really_verbose = 0;
use_vm = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (0 == unformat (input, "iter %d", &n_iterations)
&& 0 == unformat (input, "count %d", &n_objects)
&& 0 == unformat (input, "size %d", &max_object_size)
&& 0 == unformat (input, "seed %d", &seed)
&& 0 == unformat (input, "print %d", &print_every)
&& 0 == unformat (input, "validdata %|",
&check_mask, CHECK_DATA | CHECK_VALIDITY)
&& 0 == unformat (input, "valid %|",
&check_mask, CHECK_VALIDITY)
&& 0 == unformat (input, "verbose %=", &really_verbose, 1)
&& 0 == unformat (input, "trace %=", &trace, 1)
&& 0 == unformat (input, "vm %=", &use_vm, 1)
&& 0 == unformat (input, "align %|", &check_mask, CHECK_ALIGN)
&& 0 == unformat (input, "test1 %|", &check_mask, TEST1))
{
clib_warning ("unknown input `%U'", format_unformat_error, input);
return 1;
}
}
/* Zero seed means use default. */
if (!seed)
seed = random_default_seed ();
if (check_mask & TEST1)
{
return test1 ();
}
if_verbose
("testing %d iterations, %d %saligned objects, max. size %d, seed %d",
n_iterations, n_objects, (check_mask & CHECK_ALIGN) ? "randomly " : "un",
max_object_size, seed);
vec_resize (objects, n_objects);
if (vec_bytes (objects) > 0) /* stupid warning be gone */
clib_memset (objects, ~0, vec_bytes (objects));
objects_used = 0;
/* Allocate initial heap. */
{
uword size =
max_pow2 (2 * n_objects * max_object_size * sizeof (data[0]));
h_mem = clib_mem_alloc (size);
if (!h_mem)
return 0;
h = mheap_alloc (h_mem, size);
}
if (trace)
mheap_trace (h, trace);
mh = mheap_header (h);
if (use_vm)
mh->flags &= ~MHEAP_FLAG_DISABLE_VM;
else
mh->flags |= MHEAP_FLAG_DISABLE_VM;
if (check_mask & CHECK_VALIDITY)
mh->flags |= MHEAP_FLAG_VALIDATE;
for (i = 0; i < n_iterations; i++)
{
while (1)
{
j = random_u32 (&seed) % vec_len (objects);
if (objects[j] != ~0 || i + objects_used < n_iterations)
break;
}
if (objects[j] != ~0)
{
mheap_put (h, objects[j]);
objects_used--;
objects[j] = ~0;
}
else
{
uword size, align, align_offset;
size = (random_u32 (&seed) % max_object_size) * sizeof (data[0]);
align = align_offset = 0;
if (check_mask & CHECK_ALIGN)
{
align = 1 << (random_u32 (&seed) % 10);
align_offset = round_pow2 (random_u32 (&seed) & (align - 1),
sizeof (u32));
}
h = mheap_get_aligned (h, size, align, align_offset, &objects[j]);
if (align > 0)
ASSERT (0 == ((objects[j] + align_offset) & (align - 1)));
ASSERT (objects[j] != ~0);
objects_used++;
/* Set newly allocated object with test data. */
if (check_mask & CHECK_DATA)
{
uword len;
data = (void *) h + objects[j];
len = mheap_len (h, data);
ASSERT (size <= mheap_data_bytes (h, objects[j]));
data[0] = len;
for (k = 1; k < len; k++)
data[k] = objects[j] + k;
}
}
/* Verify that all used objects have correct test data. */
if (check_mask & 2)
{
for (j = 0; j < vec_len (objects); j++)
if (objects[j] != ~0)
{
u32 *data = h + objects[j];
uword len = data[0];
for (k = 1; k < len; k++)
ASSERT (data[k] == objects[j] + k);
}
}
if (print_every != 0 && i > 0 && (i % print_every) == 0)
fformat (stderr, "iteration %d: %U\n", i, format_mheap, h,
really_verbose);
}
if (verbose)
fformat (stderr, "%U\n", format_mheap, h, really_verbose);
mheap_free (h);
clib_mem_free (h_mem);
vec_free (objects);
return 0;
}
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;
}
