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 *
mtu_cmd (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd)
{
vnet_main_t * vnm = vnet_get_main();
u32 hw_if_index, mtu;
u32 flags = ETHERNET_INTERFACE_FLAG_MTU;
if (unformat (input, "%d %U", &mtu,
unformat_ethernet_interface, vnm, &hw_if_index))
{
vnet_hw_interface_t * hi = vnet_get_hw_interface (vnm, hw_if_index);
if (mtu < ETHERNET_MIN_PACKET_BYTES)
return clib_error_return (0, "Invalid mtu (%d): "
"must be >= min pkt bytes (%d)", mtu,
hi->min_packet_bytes);
if (mtu > ETHERNET_MAX_PACKET_BYTES)
return clib_error_return (0, "Invalid mtu (%d): must be <= 9216", mtu);
if (hi->max_packet_bytes != mtu)
{
hi->max_packet_bytes = mtu;
ethernet_set_flags (vnm, hw_if_index, flags);
}
}
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
return 0;
}
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 *
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 *
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 *
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 *
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 *
promiscuous_cmd (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
vnet_main_t * vnm = vnet_get_main();
u32 hw_if_index;
u32 flags = ETHERNET_INTERFACE_FLAG_ACCEPT_ALL;
if (unformat (input, "on %U",
unformat_ethernet_interface, vnm, &hw_if_index))
{
ethernet_set_flags (vnm, hw_if_index, flags);
}
else if (unformat (input, "off %U",
unformat_ethernet_interface, vnm, &hw_if_index))
{
flags = 0;
ethernet_set_flags (vnm, hw_if_index, flags);
}
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
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);
}
static clib_error_t *catchup_socket_error_ready (unix_file_t *uf)
{
unix_main_t *um = &unix_main;
mc_socket_main_t *msm = (mc_socket_main_t *)uf->private_data;
mc_socket_catchup_t *c = find_catchup_from_file_descriptor (msm, uf->file_descriptor);
catchup_cleanup (msm, c, um, uf);
return clib_error_return (0, "error");
}
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 *
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 *
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 *
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;
}
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 *
mpls_interface_enable_disable (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
vnet_main_t * vnm = vnet_get_main();
clib_error_t * error = 0;
u32 sw_if_index, enable;
int rv;
sw_if_index = ~0;
if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
{
error = clib_error_return (0, "unknown interface `%U'",
format_unformat_error, input);
goto done;
}
if (unformat (input, "enable"))
enable = 1;
else if (unformat (input, "disable"))
enable = 0;
else
{
error = clib_error_return (0, "expected 'enable' or 'disable'",
format_unformat_error, input);
goto done;
}
rv = mpls_sw_interface_enable_disable(&mpls_main, sw_if_index, enable, 0);
if (VNET_API_ERROR_NO_SUCH_FIB == rv)
error = clib_error_return (0, "default MPLS table must be created first");
done:
return error;
}
clib_error_t *
dpdk_set_mc_filter (vnet_hw_interface_t * hi,
struct ether_addr mc_addr_vec[], int naddr)
{
int error;
dpdk_main_t * dm = &dpdk_main;
dpdk_device_t * xd = vec_elt_at_index (dm->devices, hi->dev_instance);
error=rte_eth_dev_set_mc_addr_list(xd->device_index, mc_addr_vec, naddr);
if (error) {
return clib_error_return (0, "mc addr list failed: %d", error);
} else {
return NULL;
}
}
clib_error_t *
dpdk_set_mac_address (vnet_hw_interface_t * hi, char * address)
{
int error;
dpdk_main_t * dm = &dpdk_main;
dpdk_device_t * xd = vec_elt_at_index (dm->devices, hi->dev_instance);
error=rte_eth_dev_default_mac_addr_set(xd->device_index,
(struct ether_addr *) address);
if (error) {
return clib_error_return (0, "mac address set failed: %d", error);
} else {
return NULL;
}
}
clib_error_t *
clib_file_read_contents (char *file, u8 * result, uword n_bytes)
{
int fd = -1;
uword n_done, n_left;
clib_error_t *error = 0;
u8 *v = result;
if ((fd = open (file, 0)) < 0)
return clib_error_return_unix (0, "open `%s'", file);
n_left = n_bytes;
n_done = 0;
while (n_left > 0)
{
int n_read;
if ((n_read = read (fd, v + n_done, n_left)) < 0)
{
error = clib_error_return_unix (0, "open `%s'", file);
goto done;
}
/* End of file. */
if (n_read == 0)
break;
n_left -= n_read;
n_done += n_read;
}
if (n_left > 0)
{
error =
clib_error_return (0,
" `%s' expected to read %wd bytes; read only %wd",
file, n_bytes, n_bytes - n_left);
goto done;
}
done:
close (fd);
return error;
}
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;
}
clib_error_t *
vlib_sysfs_read (char *file_name, char *fmt, ...)
{
unformat_input_t input;
u8 *s = 0;
int fd;
ssize_t sz;
uword result;
fd = open (file_name, O_RDONLY);
if (fd < 0)
return clib_error_return_unix (0, "open `%s'", file_name);
vec_validate (s, 4095);
sz = read (fd, s, vec_len (s));
if (sz < 0)
{
close (fd);
vec_free (s);
return clib_error_return_unix (0, "read `%s'", file_name);
}
_vec_len (s) = sz;
unformat_init_vector (&input, s);
va_list va;
va_start (va, fmt);
result = va_unformat (&input, fmt, &va);
va_end (va);
vec_free (s);
close (fd);
if (result == 0)
return clib_error_return (0, "unformat error");
return 0;
}
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;
}
/*
* 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;
}
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;
}
clib_error_t * pcap_read (pcap_main_t * pm)
{
clib_error_t * error = 0;
int fd, need_swap, n;
pcap_file_header_t fh;
pcap_packet_header_t ph;
fd = open (pm->file_name, O_RDONLY);
if (fd < 0)
{
error = clib_error_return_unix (0, "open `%s'", pm->file_name);
goto done;
}
if (read (fd, &fh, sizeof (fh)) != sizeof (fh))
{
error = clib_error_return_unix (0, "read file header `%s'", pm->file_name);
goto done;
}
need_swap = 0;
if (fh.magic == 0xd4c3b2a1)
{
need_swap = 1;
#define _(t,f) fh.f = clib_byte_swap_##t (fh.f);
foreach_pcap_file_header;
#undef _
}
if (fh.magic != 0xa1b2c3d4)
{
error = clib_error_return (0, "bad magic `%s'", pm->file_name);
goto done;
}
pm->min_packet_bytes = 0;
pm->max_packet_bytes = 0;
while ((n = read (fd, &ph, sizeof (ph))) != 0)
{
u8 * data;
if (need_swap)
{
#define _(t,f) ph.f = clib_byte_swap_##t (ph.f);
foreach_pcap_packet_header;
#undef _
}
data = vec_new (u8, ph.n_bytes_in_packet);
if (read (fd, data, ph.n_packet_bytes_stored_in_file) != ph.n_packet_bytes_stored_in_file)
{
error = clib_error_return (0, "short read `%s'", pm->file_name);
goto done;
}
if (vec_len (pm->packets_read) == 0)
pm->min_packet_bytes = pm->max_packet_bytes = ph.n_bytes_in_packet;
else
{
pm->min_packet_bytes = clib_min (pm->min_packet_bytes, ph.n_bytes_in_packet);
pm->max_packet_bytes = clib_max (pm->max_packet_bytes, ph.n_bytes_in_packet);
}
vec_add1 (pm->packets_read, data);
}
done:
if (fd >= 0)
close (fd);
return error;
}
clib_error_t *
pcap_write (pcap_main_t * pm)
{
clib_error_t * error = 0;
if (! (pm->flags & PCAP_MAIN_INIT_DONE))
{
pcap_file_header_t fh;
int n;
if (! pm->file_name)
pm->file_name = "/tmp/vnet.pcap";
pm->file_descriptor = open (pm->file_name, O_CREAT | O_TRUNC | O_WRONLY, 0664);
if (pm->file_descriptor < 0)
{
error = clib_error_return_unix (0, "failed to open `%s'", pm->file_name);
goto done;
}
pm->flags |= PCAP_MAIN_INIT_DONE;
pm->n_packets_captured = 0;
pm->n_pcap_data_written = 0;
/* Write file header. */
memset (&fh, 0, sizeof (fh));
fh.magic = 0xa1b2c3d4;
fh.major_version = 2;
fh.minor_version = 4;
fh.time_zone = 0;
fh.max_packet_size_in_bytes = 1 << 16;
fh.packet_type = pm->packet_type;
n = write (pm->file_descriptor, &fh, sizeof (fh));
if (n != sizeof (fh))
{
if (n < 0)
error = clib_error_return_unix (0, "write file header `%s'", pm->file_name);
else
error = clib_error_return (0, "short write of file header `%s'", pm->file_name);
goto done;
}
}
do {
int n = vec_len (pm->pcap_data) - pm->n_pcap_data_written;
if (n > 0)
{
n = write (pm->file_descriptor,
vec_elt_at_index (pm->pcap_data, pm->n_pcap_data_written),
n);
if (n < 0 && unix_error_is_fatal (errno))
{
error = clib_error_return_unix (0, "write `%s'", pm->file_name);
goto done;
}
}
pm->n_pcap_data_written += n;
if (pm->n_pcap_data_written >= vec_len (pm->pcap_data))
{
vec_reset_length (pm->pcap_data);
break;
}
} while (pm->n_packets_captured >= pm->n_packets_to_capture);
if (pm->n_packets_captured >= pm->n_packets_to_capture)
{
close (pm->file_descriptor);
pm->flags &= ~PCAP_MAIN_INIT_DONE;
pm->file_descriptor = -1;
}
done:
if (error)
{
if (pm->file_descriptor >= 0)
close (pm->file_descriptor);
}
return error;
}
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;
}
clib_error_t *
policer_add_del (vlib_main_t *vm,
u8 * name,
sse2_qos_pol_cfg_params_st * cfg,
u32 * policer_index,
u8 is_add)
{
vnet_policer_main_t *pm = &vnet_policer_main;
policer_read_response_type_st test_policer;
policer_read_response_type_st * policer;
uword * p;
u32 pi;
int rv;
p = hash_get_mem (pm->policer_config_by_name, name);
if (is_add == 0)
{
if (p == 0)
{
vec_free(name);
return clib_error_return (0, "No such policer configuration");
}
hash_unset_mem (pm->policer_config_by_name, name);
hash_unset_mem (pm->policer_index_by_name, name);
vec_free(name);
return 0;
}
if (p != 0)
{
vec_free(name);
return clib_error_return (0, "Policer already exists");
}
/* Vet the configuration before adding it to the table */
rv = sse2_pol_logical_2_physical (cfg, &test_policer);
if (rv == 0)
{
policer_read_response_type_st *pp;
sse2_qos_pol_cfg_params_st *cp;
pool_get (pm->configs, cp);
pool_get (pm->policer_templates, pp);
ASSERT (cp - pm->configs == pp - pm->policer_templates);
clib_memcpy (cp, cfg, sizeof (*cp));
clib_memcpy (pp, &test_policer, sizeof (*pp));
hash_set_mem (pm->policer_config_by_name, name, cp - pm->configs);
pool_get_aligned (pm->policers, policer, CLIB_CACHE_LINE_BYTES);
policer[0] = pp[0];
pi = policer - pm->policers;
hash_set_mem (pm->policer_index_by_name, name, pi);
*policer_index = pi;
}
else
{
vec_free (name);
return clib_error_return (0, "Config failed sanity check");
}
return 0;
}
