X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Finterface_cli.c;h=4f6f2cf05a505eae7b59045f44d9176b22112981;hb=2c77ae484;hp=9271f5b78c5076eb4fd762cefb7be2cd12507f88;hpb=54f7c51fd5a1ea927a4df3a989f62afdf9d6c0c5;p=vpp.git diff --git a/src/vnet/interface_cli.c b/src/vnet/interface_cli.c index 9271f5b78c5..4f6f2cf05a5 100644 --- a/src/vnet/interface_cli.c +++ b/src/vnet/interface_cli.c @@ -36,7 +36,6 @@ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ - /** * @file * @brief Interface CLI. @@ -44,7 +43,6 @@ * Source code for several CLI interface commands. * */ - #include #include #include @@ -52,7 +50,9 @@ #include #include #include - +#include +#include +#include static int compare_interface_names (void *a1, void *a2) { @@ -65,16 +65,15 @@ compare_interface_names (void *a1, void *a2) static clib_error_t * show_or_clear_hw_interfaces (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) + vlib_cli_command_t * cmd, int is_show) { clib_error_t *error = 0; vnet_main_t *vnm = vnet_get_main (); vnet_interface_main_t *im = &vnm->interface_main; vnet_hw_interface_t *hi; u32 hw_if_index, *hw_if_indices = 0; - int i, verbose = -1, is_show, show_bond = 0; + int i, verbose = -1, show_bond = 0; - is_show = strstr (cmd->path, "show") != 0; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { /* See if user wants to show a specific interface. */ @@ -112,8 +111,8 @@ show_or_clear_hw_interfaces (vlib_main_t * vm, /* Gather interfaces. */ if (vec_len (hw_if_indices) == 0) - pool_foreach (hi, im->hw_interfaces, - vec_add1 (hw_if_indices, hi - im->hw_interfaces)); + pool_foreach (hi, im->hw_interfaces) + vec_add1 (hw_if_indices, hi - im->hw_interfaces); if (verbose < 0) verbose = 1; /* default to verbose (except bond) */ @@ -139,12 +138,12 @@ show_or_clear_hw_interfaces (vlib_main_t * vm, hi, verbose); /* *INDENT-OFF* */ - clib_bitmap_foreach (hw_idx, hi->bond_info, - ({ + clib_bitmap_foreach (hw_idx, hi->bond_info) + { shi = vnet_get_hw_interface(vnm, hw_idx); vlib_cli_output (vm, "%U\n", format_vnet_hw_interface, vnm, shi, verbose); - })); + } /* *INDENT-ON* */ } } @@ -168,6 +167,21 @@ done: return error; } +static clib_error_t * +show_hw_interfaces (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + return show_or_clear_hw_interfaces (vm, input, cmd, 1 /* is_show */ ); +} + +static clib_error_t * +clear_hw_interfaces (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + return show_or_clear_hw_interfaces (vm, input, cmd, 0 /* is_show */ ); +} + + /*? * Display more detailed information about all or a list of given interfaces. * The verboseness of the output can be controlled by the following optional @@ -229,7 +243,7 @@ VLIB_CLI_COMMAND (show_hw_interfaces_command, static) = { .path = "show hardware-interfaces", .short_help = "show hardware-interfaces [brief|verbose|detail] [bond] " "[ [ [..]]] [ [ [..]]]", - .function = show_or_clear_hw_interfaces, + .function = show_hw_interfaces, }; /* *INDENT-ON* */ @@ -250,7 +264,7 @@ VLIB_CLI_COMMAND (clear_hw_interface_counters_command, static) = { .path = "clear hardware-interfaces", .short_help = "clear hardware-interfaces " "[ [ [..]]] [ [ [..]]]", - .function = show_or_clear_hw_interfaces, + .function = clear_hw_interfaces, }; /* *INDENT-ON* */ @@ -277,6 +291,7 @@ show_sw_interfaces (vlib_main_t * vm, u8 show_addresses = 0; u8 show_features = 0; u8 show_tag = 0; + u8 show_vtr = 0; int verbose = 0; /* @@ -300,10 +315,28 @@ show_sw_interfaces (vlib_main_t * vm, show_features = 1; else if (unformat (linput, "tag")) show_tag = 1; + else if (unformat (linput, "vtr")) + show_vtr = 1; else if (unformat (linput, "verbose")) verbose = 1; + else if (unformat (linput, "%d", &sw_if_index)) + { + if (!pool_is_free_index (im->sw_interfaces, sw_if_index)) + { + si = pool_elt_at_index (im->sw_interfaces, sw_if_index); + vec_add1 (sorted_sis, si[0]); + } + else + { + vec_free (sorted_sis); + error = clib_error_return (0, "unknown interface index `%d'", + sw_if_index); + goto done; + } + } else { + vec_free (sorted_sis); error = clib_error_return (0, "unknown input `%U'", format_unformat_error, linput); goto done; @@ -311,29 +344,27 @@ show_sw_interfaces (vlib_main_t * vm, } unformat_free (linput); } - if (show_features || show_tag) + if (show_features || show_tag || show_vtr) { if (sw_if_index == ~(u32) 0) - return clib_error_return (0, "Interface not specified..."); + { + vec_free (sorted_sis); + return clib_error_return (0, "Interface not specified..."); + } } if (show_features) { vnet_interface_features_show (vm, sw_if_index, verbose); - - l2_input_config_t *l2_input = l2input_intf_config (sw_if_index); - u32 fb = l2_input->feature_bitmap; - /* intf input features are masked by bridge domain */ - if (l2_input->bridge) - fb &= l2input_bd_config (l2_input->bd_index)->feature_bitmap; - vlib_cli_output (vm, "\nl2-input:\n%U", format_l2_input_features, fb); + vlib_cli_output (vm, "%U", format_l2_input_features, sw_if_index, 1); l2_output_config_t *l2_output = l2output_intf_config (sw_if_index); vlib_cli_output (vm, "\nl2-output:"); if (l2_output->out_vtr_flag) vlib_cli_output (vm, "%10s (%s)", "VTR", "--internal--"); vlib_cli_output (vm, "%U", format_l2_output_features, - l2_output->feature_bitmap); + l2_output->feature_bitmap, 1); + vec_free (sorted_sis); return 0; } if (show_tag) @@ -343,6 +374,28 @@ show_sw_interfaces (vlib_main_t * vm, vlib_cli_output (vm, "%U: %s", format_vnet_sw_if_index_name, vnm, sw_if_index, tag ? (char *) tag : "(none)"); + vec_free (sorted_sis); + return 0; + } + + /* + * Show vlan tag rewrite data for one interface. + */ + if (show_vtr) + { + u32 vtr_op = L2_VTR_DISABLED; + u32 push_dot1q = 0, tag1 = 0, tag2 = 0; + + if (l2vtr_get (vm, vnm, sw_if_index, + &vtr_op, &push_dot1q, &tag1, &tag2) != 0) + { + vlib_cli_output (vm, "%U: Problem getting vlan tag-rewrite data", + format_vnet_sw_if_index_name, vnm, sw_if_index); + return 0; + } + vlib_cli_output (vm, "%U: VTR %0U", + format_vnet_sw_if_index_name, vnm, sw_if_index, + format_vtr, vtr_op, push_dot1q, tag1, tag2); return 0; } @@ -356,12 +409,12 @@ show_sw_interfaces (vlib_main_t * vm, vec_new (vnet_sw_interface_t, pool_elts (im->sw_interfaces)); _vec_len (sorted_sis) = 0; /* *INDENT-OFF* */ - pool_foreach (si, im->sw_interfaces, - ({ + pool_foreach (si, im->sw_interfaces) + { int visible = vnet_swif_is_api_visible (si); if (visible) - vec_add1 (sorted_sis, si[0]);} - )); + vec_add1 (sorted_sis, si[0]); + } /* *INDENT-ON* */ /* Sort by name. */ vec_sort_with_function (sorted_sis, sw_interface_name_compare); @@ -402,19 +455,7 @@ show_sw_interfaces (vlib_main_t * vm, (si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? "up" : "dn"); /* Display any L2 info */ - l2_input_config_t *l2_input = l2input_intf_config (si->sw_if_index); - if (l2_input->bridge) - { - bd_main_t *bdm = &bd_main; - u32 bd_id = l2input_main.bd_configs[l2_input->bd_index].bd_id; - vlib_cli_output (vm, " L2 bridge bd-id %d idx %d shg %d %s", - bd_id, bd_find_index (bdm, bd_id), l2_input->shg, - l2_input->bvi ? "bvi" : " "); - } - else if (l2_input->xconnect) - vlib_cli_output (vm, " L2 xconnect %U", - format_vnet_sw_if_index_name, vnm, - l2_input->output_sw_if_index); + vlib_cli_output (vm, "%U", format_l2_input, si->sw_if_index); /* *INDENT-OFF* */ /* Display any IP4 addressing info */ @@ -422,11 +463,11 @@ show_sw_interfaces (vlib_main_t * vm, 1 /* honor unnumbered */, ({ ip4_address_t *r4 = ip_interface_address_get_address (lm4, ia); - if (fib4->table_id) - vlib_cli_output (vm, " L3 %U/%d ip4 table-id %d fib-idx %d", - format_ip4_address, r4, ia->address_length, - fib4->table_id, - ip4_fib_index_from_table_id (fib4->table_id)); + if (fib4->hash.table_id) + vlib_cli_output ( + vm, " L3 %U/%d ip4 table-id %d fib-idx %d", format_ip4_address, + r4, ia->address_length, fib4->hash.table_id, + ip4_fib_index_from_table_id (fib4->hash.table_id)); else vlib_cli_output (vm, " L3 %U/%d", format_ip4_address, r4, ia->address_length); @@ -467,8 +508,9 @@ done: /* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_sw_interfaces_command, static) = { .path = "show interface", - .short_help = "show interface [address|addr|features|feat] [ [ [..]]] [verbose]", + .short_help = "show interface [address|addr|features|feat|vtr] [ [ [..]]] [verbose]", .function = show_sw_interfaces, + .is_mp_safe = 1, }; /* *INDENT-ON* */ @@ -495,42 +537,24 @@ clear_interface_counters (vlib_main_t * vm, vnet_interface_main_t *im = &vnm->interface_main; vlib_simple_counter_main_t *sm; vlib_combined_counter_main_t *cm; - static vnet_main_t **my_vnet_mains; - int i, j, n_counters; - - vec_reset_length (my_vnet_mains); - - for (i = 0; i < vec_len (vnet_mains); i++) - { - if (vnet_mains[i]) - vec_add1 (my_vnet_mains, vnet_mains[i]); - } - - if (vec_len (vnet_mains) == 0) - vec_add1 (my_vnet_mains, vnm); + int j, n_counters; n_counters = vec_len (im->combined_sw_if_counters); for (j = 0; j < n_counters; j++) { - for (i = 0; i < vec_len (my_vnet_mains); i++) - { - im = &my_vnet_mains[i]->interface_main; - cm = im->combined_sw_if_counters + j; - vlib_clear_combined_counters (cm); - } + im = &vnm->interface_main; + cm = im->combined_sw_if_counters + j; + vlib_clear_combined_counters (cm); } n_counters = vec_len (im->sw_if_counters); for (j = 0; j < n_counters; j++) { - for (i = 0; i < vec_len (my_vnet_mains); i++) - { - im = &my_vnet_mains[i]->interface_main; - sm = im->sw_if_counters + j; - vlib_clear_simple_counters (sm); - } + im = &vnm->interface_main; + sm = im->sw_if_counters + j; + vlib_clear_simple_counters (sm); } return 0; @@ -687,7 +711,7 @@ create_sub_interfaces (vlib_main_t * vm, goto done; } - memset (&template, 0, sizeof (template)); + clib_memset (&template, 0, sizeof (template)); template.sub.eth.raw_flags = 0; if (unformat (input, "%d default", &id_min)) @@ -767,9 +791,6 @@ create_sub_interfaces (vlib_main_t * vm, continue; } - kp = clib_mem_alloc (sizeof (*kp)); - *kp = sup_and_sub_key; - template.type = VNET_SW_INTERFACE_TYPE_SUB; template.flood_class = VNET_FLOOD_CLASS_NORMAL; template.sup_sw_if_index = hi->sw_if_index; @@ -781,6 +802,9 @@ create_sub_interfaces (vlib_main_t * vm, if (error) goto done; + kp = clib_mem_alloc (sizeof (*kp)); + *kp = sup_and_sub_key; + hash_set (hi->sub_interface_sw_if_index_by_id, id, sw_if_index); hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index); vlib_cli_output (vm, "%U\n", format_vnet_sw_if_index_name, @@ -814,14 +838,14 @@ done: * subinterfaces to handle a range of VLAN IDs. * * - create sub-interfaces dot1q|dot1ad |any [exact-match] - - * Use this command to specify the outer VLAN ID, to either be explicited or to make the + * Use this command to specify the outer VLAN ID, to either be explicit or to make the * VLAN ID different from the 'subId'. * * - create sub-interfaces dot1q|dot1ad |any inner-dot1q * |any [exact-match] - Use this command to specify the outer VLAN ID and - * the innner VLAN ID. + * the inner VLAN ID. * - * When 'dot1q' or 'dot1ad' is explictly entered, subinterfaces + * When 'dot1q' or 'dot1ad' is explicitly entered, subinterfaces * can be configured as either exact-match or non-exact match. Non-exact match is the CLI * default. If 'exact-match' is specified, packets must have the same number of * VLAN tags as the configuration. For non-exact-match, packets must at least that number @@ -917,7 +941,6 @@ done: return error; } - /*? * This command is used to change the admin state (up/down) of an interface. * @@ -927,9 +950,11 @@ done: * 'punt' flag (interface is still down). * * @cliexpar - * Example of how to configure the admin state of an interface to 'upup': * @cliexcmd{set interface state GigabitEthernet2/0/0 up} - * Example of how to configure the admin state of an interface to 'downdown': * @cliexcmd{set interface state GigabitEthernet2/0/0 down} ?*/ /* *INDENT-OFF* */ @@ -964,11 +989,26 @@ set_unnumbered (vlib_main_t * vm, if (~0 == unnumbered_sw_if_index) return clib_error_return (0, "Specify the unnumbered interface"); if (enable && ~0 == inherit_from_sw_if_index) - return clib_error_return (0, "When enabling unnumberered specify the" + return clib_error_return (0, "When enabling unnumbered specify the" " IP enabled interface that it uses"); - vnet_sw_interface_update_unnumbered (unnumbered_sw_if_index, - inherit_from_sw_if_index, enable); + int rv = vnet_sw_interface_update_unnumbered ( + unnumbered_sw_if_index, inherit_from_sw_if_index, enable); + + switch (rv) + { + case 0: + break; + + case VNET_API_ERROR_UNEXPECTED_INTF_STATE: + return clib_error_return ( + 0, + "When enabling unnumbered both interfaces must be in the same tables"); + + default: + return clib_error_return ( + 0, "vnet_sw_interface_update_unnumbered returned %d", rv); + } return (NULL); } @@ -1174,6 +1214,158 @@ VLIB_CLI_COMMAND (set_interface_mtu_cmd, static) = { }; /* *INDENT-ON* */ +static clib_error_t * +show_interface_sec_mac_addr_fn (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_interface_main_t *im = &vnm->interface_main; + ethernet_main_t *em = ðernet_main; + u32 sw_if_index = ~0; + vnet_sw_interface_t *si, *sorted_sis = 0; + + if (unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index)) + { + si = pool_elt_at_index (im->sw_interfaces, sw_if_index); + vec_add1 (sorted_sis, si[0]); + } + + /* if an interface name was not passed, get all interfaces */ + if (vec_len (sorted_sis) == 0) + { + sorted_sis = + vec_new (vnet_sw_interface_t, pool_elts (im->sw_interfaces)); + _vec_len (sorted_sis) = 0; + /* *INDENT-OFF* */ + pool_foreach (si, im->sw_interfaces) + { + int visible = vnet_swif_is_api_visible (si); + if (visible) + vec_add1 (sorted_sis, si[0]); + } + /* *INDENT-ON* */ + /* Sort by name. */ + vec_sort_with_function (sorted_sis, sw_interface_name_compare); + } + + vec_foreach (si, sorted_sis) + { + vnet_sw_interface_t *sup_si; + ethernet_interface_t *ei; + + sup_si = vnet_get_sup_sw_interface (vnm, si->sw_if_index); + ei = ethernet_get_interface (em, sup_si->hw_if_index); + + vlib_cli_output (vm, "%U (%s):", + format_vnet_sw_if_index_name, vnm, si->sw_if_index, + (si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ? + "up" : "dn"); + + if (ei && ei->secondary_addrs) + { + ethernet_interface_address_t *sec_addr; + + vec_foreach (sec_addr, ei->secondary_addrs) + { + vlib_cli_output (vm, " %U", format_mac_address_t, &sec_addr->mac); + } + } + } + + vec_free (sorted_sis); + return 0; +} + +/*? + * This command is used to display interface secondary mac addresses. + * + * @cliexpar + * Example of how to display interface secondary mac addresses: + * @cliexstart{show interface secondary-mac-address} + * @cliexend +?*/ +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (show_interface_sec_mac_addr, static) = { + .path = "show interface secondary-mac-address", + .short_help = "show interface secondary-mac-address []", + .function = show_interface_sec_mac_addr_fn, +}; +/* *INDENT-ON* */ + +static clib_error_t * +interface_add_del_mac_address (vlib_main_t * vm, unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_sw_interface_t *si = NULL; + clib_error_t *error = 0; + u32 sw_if_index = ~0; + u8 mac[6] = { 0 }; + u8 is_add, is_del; + + is_add = is_del = 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_user (input, unformat_ethernet_address, mac)) + { + error = clib_error_return (0, "expected mac address `%U'", + format_unformat_error, input); + goto done; + } + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "add")) + is_add = 1; + else if (unformat (input, "del")) + is_del = 1; + else + break; + } + + if (is_add == is_del) + { + error = clib_error_return (0, "must choose one of add or del"); + goto done; + } + + si = vnet_get_sw_interface (vnm, sw_if_index); + error = + vnet_hw_interface_add_del_mac_address (vnm, si->hw_if_index, mac, is_add); + +done: + return error; +} + +/*? + * The 'set interface secondary-mac-address ' command allows adding + * or deleting extra MAC addresses on a given interface without changing the + * default MAC address. This could allow packets sent to these MAC addresses + * to be received without setting the interface to promiscuous mode. + * Not all interfaces support this operation. The ones that do are mostly + * hardware NICs, though virtio does also. + * + * @cliexpar + * @parblock + * Example of how to add a secondary MAC Address on an interface: + * @cliexcmd{set interface secondary-mac-address GigabitEthernet0/8/0 aa:bb:cc:dd:ee:01 add} + * Example of how to delete a secondary MAC address from an interface: + * @cliexcmd{set interface secondary-mac-address GigabitEthernet0/8/0 aa:bb:cc:dd:ee:01 del} + * @endparblock +?*/ +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (interface_add_del_mac_address_cmd, static) = { + .path = "set interface secondary-mac-address", + .short_help = "set interface secondary-mac-address [(add|del)]", + .function = interface_add_del_mac_address, +}; +/* *INDENT-ON* */ + static clib_error_t * set_interface_mac_address (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) @@ -1313,86 +1505,42 @@ VLIB_CLI_COMMAND (set_ip_directed_broadcast_command, static) = { }; /* *INDENT-ON* */ -static clib_error_t * -set_hw_interface_rx_mode (vnet_main_t * vnm, u32 hw_if_index, - u32 queue_id, vnet_hw_interface_rx_mode mode) -{ - vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index); - vnet_device_class_t *dev_class = - vnet_get_device_class (vnm, hw->dev_class_index); - clib_error_t *error; - vnet_hw_interface_rx_mode old_mode; - int rv; - - if (mode == VNET_HW_INTERFACE_RX_MODE_DEFAULT) - mode = hw->default_rx_mode; - - rv = vnet_hw_interface_get_rx_mode (vnm, hw_if_index, queue_id, &old_mode); - switch (rv) - { - case 0: - if (old_mode == mode) - return 0; /* same rx-mode, no change */ - break; - case VNET_API_ERROR_INVALID_INTERFACE: - return clib_error_return (0, "invalid interface"); - case VNET_API_ERROR_INVALID_QUEUE: - return clib_error_return (0, "invalid queue"); - default: - return clib_error_return (0, "unknown error"); - } - - if (dev_class->rx_mode_change_function) - { - error = dev_class->rx_mode_change_function (vnm, hw_if_index, queue_id, - mode); - if (error) - return (error); - } - - rv = vnet_hw_interface_set_rx_mode (vnm, hw_if_index, queue_id, mode); - switch (rv) - { - case 0: - break; - case VNET_API_ERROR_UNSUPPORTED: - return clib_error_return (0, "unsupported"); - case VNET_API_ERROR_INVALID_INTERFACE: - return clib_error_return (0, "invalid interface"); - case VNET_API_ERROR_INVALID_QUEUE: - return clib_error_return (0, "invalid queue"); - default: - return clib_error_return (0, "unknown error"); - } - - return 0; -} - clib_error_t * set_hw_interface_change_rx_mode (vnet_main_t * vnm, u32 hw_if_index, u8 queue_id_valid, u32 queue_id, - vnet_hw_interface_rx_mode mode) + vnet_hw_if_rx_mode mode) { clib_error_t *error = 0; vnet_hw_interface_t *hw; - int i; + u32 *queue_indices = 0; hw = vnet_get_hw_interface (vnm, hw_if_index); - if (queue_id_valid == 0) + if (queue_id_valid) { - for (i = 0; i < vec_len (hw->dq_runtime_index_by_queue); i++) - { - error = set_hw_interface_rx_mode (vnm, hw_if_index, i, mode); - if (error) - break; - } - hw->default_rx_mode = mode; + u32 queue_index; + queue_index = + vnet_hw_if_get_rx_queue_index_by_id (vnm, hw_if_index, queue_id); + if (queue_index == ~0) + return clib_error_return (0, "unknown queue %u on interface %s", + queue_id, hw->name); + vec_add1 (queue_indices, queue_index); } else - error = set_hw_interface_rx_mode (vnm, hw_if_index, queue_id, mode); + queue_indices = hw->rx_queue_indices; - return (error); + for (int i = 0; i < vec_len (queue_indices); i++) + { + int rv = vnet_hw_if_set_rx_queue_mode (vnm, queue_indices[i], mode); + if (rv) + goto done; + } + +done: + if (queue_indices != hw->rx_queue_indices) + vec_free (queue_indices); + vnet_hw_if_update_runtime_data (vnm, hw_if_index); + return error; } static clib_error_t * @@ -1404,7 +1552,7 @@ set_interface_rx_mode (vlib_main_t * vm, unformat_input_t * input, vnet_main_t *vnm = vnet_get_main (); u32 hw_if_index = (u32) ~ 0; u32 queue_id = (u32) ~ 0; - vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN; + vnet_hw_if_rx_mode mode = VNET_HW_IF_RX_MODE_UNKNOWN; u8 queue_id_valid = 0; if (!unformat_user (input, unformat_line_input, line_input)) @@ -1418,11 +1566,11 @@ set_interface_rx_mode (vlib_main_t * vm, unformat_input_t * input, else if (unformat (line_input, "queue %d", &queue_id)) queue_id_valid = 1; else if (unformat (line_input, "polling")) - mode = VNET_HW_INTERFACE_RX_MODE_POLLING; + mode = VNET_HW_IF_RX_MODE_POLLING; else if (unformat (line_input, "interrupt")) - mode = VNET_HW_INTERFACE_RX_MODE_INTERRUPT; + mode = VNET_HW_IF_RX_MODE_INTERRUPT; else if (unformat (line_input, "adaptive")) - mode = VNET_HW_INTERFACE_RX_MODE_ADAPTIVE; + mode = VNET_HW_IF_RX_MODE_ADAPTIVE; else { error = clib_error_return (0, "parse error: '%U'", @@ -1437,7 +1585,7 @@ set_interface_rx_mode (vlib_main_t * vm, unformat_input_t * input, if (hw_if_index == (u32) ~ 0) return clib_error_return (0, "please specify valid interface name"); - if (mode == VNET_HW_INTERFACE_RX_MODE_UNKNOWN) + if (mode == VNET_HW_IF_RX_MODE_UNKNOWN) return clib_error_return (0, "please specify valid rx-mode"); error = set_hw_interface_change_rx_mode (vnm, hw_if_index, queue_id_valid, @@ -1493,42 +1641,36 @@ show_interface_rx_placement_fn (vlib_main_t * vm, unformat_input_t * input, { u8 *s = 0; vnet_main_t *vnm = vnet_get_main (); - vnet_device_input_runtime_t *rt; - vnet_device_and_queue_t *dq; - vlib_node_t *pn = vlib_get_node_by_name (vm, (u8 *) "device-input"); - uword si; - int index = 0; - - /* *INDENT-OFF* */ - foreach_vlib_main (({ - clib_bitmap_foreach (si, pn->sibling_bitmap, - ({ - rt = vlib_node_get_runtime_data (this_vlib_main, si); - - if (vec_len (rt->devices_and_queues)) - s = format (s, " node %U:\n", format_vlib_node_name, vm, si); - - vec_foreach (dq, rt->devices_and_queues) - { - vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, - dq->hw_if_index); - s = format (s, " %U queue %u (%U)\n", - format_vnet_sw_if_index_name, vnm, hi->sw_if_index, - dq->queue_id, - format_vnet_hw_interface_rx_mode, dq->mode); - } - })); - if (vec_len (s) > 0) - { - vlib_cli_output(vm, "Thread %u (%v):\n%v", index, - vlib_worker_threads[index].name, s); - vec_reset_length (s); - } - index++; - })); - /* *INDENT-ON* */ - + vnet_hw_if_rx_queue_t **all_queues = 0; + vnet_hw_if_rx_queue_t **qptr; + vnet_hw_if_rx_queue_t *q; + pool_foreach (q, vnm->interface_main.hw_if_rx_queues) + vec_add1 (all_queues, q); + vec_sort_with_function (all_queues, vnet_hw_if_rxq_cmp_cli_api); + u32 prev_node = ~0; + + vec_foreach (qptr, all_queues) + { + u32 current_thread = qptr[0]->thread_index; + u32 hw_if_index = qptr[0]->hw_if_index; + vnet_hw_interface_t *hw_if = vnet_get_hw_interface (vnm, hw_if_index); + u32 current_node = hw_if->input_node_index; + if (current_node != prev_node) + s = format (s, " node %U:\n", format_vlib_node_name, vm, current_node); + s = format (s, " %U queue %u (%U)\n", format_vnet_sw_if_index_name, + vnm, hw_if->sw_if_index, qptr[0]->queue_id, + format_vnet_hw_if_rx_mode, qptr[0]->mode); + if (qptr == all_queues + vec_len (all_queues) - 1 || + current_thread != qptr[1]->thread_index) + { + vlib_cli_output (vm, "Thread %u (%s):\n%v", current_thread, + vlib_worker_threads[current_thread].name, s); + vec_reset_length (s); + } + prev_node = current_node; + } vec_free (s); + vec_free (all_queues); return 0; } @@ -1564,16 +1706,14 @@ VLIB_CLI_COMMAND (show_interface_rx_placement, static) = { .function = show_interface_rx_placement_fn, }; /* *INDENT-ON* */ - clib_error_t * set_hw_interface_rx_placement (u32 hw_if_index, u32 queue_id, u32 thread_index, u8 is_main) { vnet_main_t *vnm = vnet_get_main (); vnet_device_main_t *vdm = &vnet_device_main; - clib_error_t *error = 0; - vnet_hw_interface_rx_mode mode = VNET_HW_INTERFACE_RX_MODE_UNKNOWN; - int rv; + vnet_hw_interface_t *hw; + u32 queue_index; if (is_main) thread_index = 0; @@ -1584,26 +1724,21 @@ set_hw_interface_rx_placement (u32 hw_if_index, u32 queue_id, return clib_error_return (0, "please specify valid worker thread or main"); - rv = vnet_hw_interface_get_rx_mode (vnm, hw_if_index, queue_id, &mode); - - if (rv) - return clib_error_return (0, "not found"); - - rv = vnet_hw_interface_unassign_rx_thread (vnm, hw_if_index, queue_id); - - if (rv) - return clib_error_return (0, "not found"); - - vnet_hw_interface_assign_rx_thread (vnm, hw_if_index, queue_id, - thread_index); - vnet_hw_interface_set_rx_mode (vnm, hw_if_index, queue_id, mode); + hw = vnet_get_hw_interface (vnm, hw_if_index); - return (error); + queue_index = + vnet_hw_if_get_rx_queue_index_by_id (vnm, hw_if_index, queue_id); + if (queue_index == ~0) + return clib_error_return (0, "unknown queue %u on interface %s", queue_id, + hw->name); + vnet_hw_if_set_rx_queue_thread_index (vnm, queue_index, thread_index); + vnet_hw_if_update_runtime_data (vnm, hw_if_index); + return 0; } static clib_error_t * -set_interface_rx_placement (vlib_main_t * vm, unformat_input_t * input, - vlib_cli_command_t * cmd) +set_interface_rx_placement (vlib_main_t *vm, unformat_input_t *input, + vlib_cli_command_t *cmd) { clib_error_t *error = 0; unformat_input_t _line_input, *line_input = &_line_input; @@ -1704,6 +1839,634 @@ VLIB_CLI_COMMAND (cmd_set_if_rx_placement,static) = { .is_mp_safe = 1, }; /* *INDENT-ON* */ + +clib_error_t * +set_hw_interface_tx_queue (u32 hw_if_index, u32 queue_id, uword *bitmap) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_device_main_t *vdm = &vnet_device_main; + vnet_hw_interface_t *hw; + vnet_hw_if_tx_queue_t *txq; + u32 queue_index; + u32 thread_index; + + hw = vnet_get_hw_interface (vnm, hw_if_index); + + /* highest set bit in bitmap should not exceed last worker thread index */ + thread_index = clib_bitmap_last_set (bitmap); + if ((thread_index != ~0) && (thread_index > vdm->last_worker_thread_index)) + return clib_error_return (0, "please specify valid thread(s)"); + + queue_index = + vnet_hw_if_get_tx_queue_index_by_id (vnm, hw_if_index, queue_id); + if (queue_index == ~0) + return clib_error_return (0, "unknown queue %u on interface %s", queue_id, + hw->name); + + txq = vnet_hw_if_get_tx_queue (vnm, queue_index); + + // free the existing bitmap + if (clib_bitmap_count_set_bits (txq->threads)) + { + txq->shared_queue = 0; + clib_bitmap_free (txq->threads); + } + + clib_bitmap_foreach (thread_index, bitmap) + vnet_hw_if_tx_queue_assign_thread (vnm, queue_index, thread_index); + + vnet_hw_if_update_runtime_data (vnm, hw_if_index); + return 0; +} + +static clib_error_t * +set_interface_tx_queue (vlib_main_t *vm, unformat_input_t *input, + vlib_cli_command_t *cmd) +{ + clib_error_t *error = 0; + unformat_input_t _line_input, *line_input = &_line_input; + vnet_main_t *vnm = vnet_get_main (); + u32 hw_if_index = (u32) ~0; + u32 queue_id = (u32) 0; + uword *bitmap = 0; + + 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, "%U", unformat_vnet_hw_interface, vnm, + &hw_if_index)) + ; + else if (unformat (line_input, "queue %d", &queue_id)) + ; + else if (unformat (line_input, "threads %U", unformat_bitmap_list, + &bitmap)) + ; + else + { + error = clib_error_return (0, "parse error: '%U'", + format_unformat_error, line_input); + unformat_free (line_input); + return error; + } + } + + unformat_free (line_input); + + if (hw_if_index == (u32) ~0) + { + error = clib_error_return (0, "please specify valid interface name"); + goto error; + } + + error = set_hw_interface_tx_queue (hw_if_index, queue_id, bitmap); + +error: + clib_bitmap_free (bitmap); + return (error); +} + +VLIB_CLI_COMMAND (cmd_set_if_tx_queue, static) = { + .path = "set interface tx-queue", + .short_help = "set interface tx-queue queue " + "[threads ]", + .function = set_interface_tx_queue, + .is_mp_safe = 1, +}; + +clib_error_t * +set_interface_rss_queues (vlib_main_t * vm, u32 hw_if_index, + clib_bitmap_t * bitmap) +{ + vnet_main_t *vnm = vnet_get_main (); + vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); + + return vnet_hw_interface_set_rss_queues (vnm, hi, bitmap); +} + +static clib_error_t * +set_interface_rss_queues_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + clib_error_t *error = 0; + unformat_input_t _line_input, *line_input = &_line_input; + vnet_main_t *vnm = vnet_get_main (); + u32 hw_if_index = (u32) ~ 0; + clib_bitmap_t *bitmap = NULL; + + 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, "%U", unformat_vnet_hw_interface, vnm, &hw_if_index)) + ; + else + if (unformat (line_input, "list %U", unformat_bitmap_list, &bitmap)) + ; + else + { + error = clib_error_return (0, "parse error: '%U'", + format_unformat_error, line_input); + unformat_free (line_input); + goto done; + } + } + + unformat_free (line_input); + + if (hw_if_index == (u32) ~ 0) + { + error = clib_error_return (0, "please specify valid interface name"); + goto done; + } + + if (bitmap == NULL) + { + error = clib_error_return (0, "please specify the valid rss queues"); + goto done; + } + + error = set_interface_rss_queues (vm, hw_if_index, bitmap); + +done: + if (bitmap) + clib_bitmap_free (bitmap); + + return (error); +} + +/*? + * This command is used to set the rss queues of a given interface + * Not all the interfaces support this operation. + * To display the current rss queues, use the command + * 'show hardware-interfaces'. + * + * @cliexpar + * Example of how to set the rss queues to 0,2-5,7 of an interface: + * @cliexstart{set interface rss queues VirtualFunctionEthernet18/1/0 list 0,2-5,7} + * @cliexend +?*/ +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (cmd_set_interface_rss_queues,static) = { + .path = "set interface rss queues", + .short_help = "set interface rss queues >", + .function = set_interface_rss_queues_fn, +}; +/* *INDENT-ON* */ + +static u8 * +format_vnet_pcap (u8 * s, va_list * args) +{ + vnet_pcap_t *pp = va_arg (*args, vnet_pcap_t *); + int type = va_arg (*args, int); + int printed = 0; + + if (type == 0) + { + if (pp->pcap_rx_enable) + { + s = format (s, "rx"); + printed = 1; + } + if (pp->pcap_tx_enable) + { + if (printed) + s = format (s, " and "); + s = format (s, "tx"); + printed = 1; + } + if (pp->pcap_drop_enable) + { + if (printed) + s = format (s, " and "); + s = format (s, "drop"); + printed = 1; + } + return s; + } + s = format (s, "unknown type %d!", type); + return s; +} + + +int +vnet_pcap_dispatch_trace_configure (vnet_pcap_dispatch_trace_args_t * a) +{ + vlib_main_t *vm = vlib_get_main (); + vnet_main_t *vnm = vnet_get_main (); + vnet_pcap_t *pp = &vnm->pcap; + pcap_main_t *pm = &pp->pcap_main; + vnet_classify_main_t *cm = &vnet_classify_main; + + if (a->status) + { + if (pp->pcap_rx_enable || pp->pcap_tx_enable || pp->pcap_drop_enable) + { + vlib_cli_output + (vm, "pcap %U dispatch capture enabled: %d of %d pkts...", + format_vnet_pcap, pp, 0 /* print type */ , + pm->n_packets_captured, pm->n_packets_to_capture); + vlib_cli_output (vm, "capture to file %s", pm->file_name); + } + else + vlib_cli_output (vm, "pcap dispatch capture disabled"); + + return 0; + } + + /* Consistency checks */ + + /* Enable w/ capture already enabled not allowed */ + if ((pp->pcap_rx_enable + pp->pcap_tx_enable + pp->pcap_drop_enable) + && (a->rx_enable + a->tx_enable + a->drop_enable)) + return VNET_API_ERROR_INVALID_VALUE; + + /* Disable capture with capture already disabled, not interesting */ + if (((pp->pcap_rx_enable + pp->pcap_tx_enable + pp->pcap_drop_enable) == + 0) && + ((a->rx_enable + a->tx_enable + a->drop_enable == 0))) + return VNET_API_ERROR_VALUE_EXIST; + + /* Change number of packets to capture while capturing */ + if ((pp->pcap_rx_enable + pp->pcap_tx_enable + pp->pcap_drop_enable) + && (a->rx_enable + a->tx_enable + a->drop_enable) + && (pm->n_packets_to_capture != a->packets_to_capture)) + return VNET_API_ERROR_INVALID_VALUE_2; + + /* Classify filter specified, but no classify filter configured */ + if ((a->rx_enable + a->tx_enable + a->drop_enable) && a->filter && + (!cm->classify_table_index_by_sw_if_index || + cm->classify_table_index_by_sw_if_index[0] == ~0)) + return VNET_API_ERROR_NO_SUCH_LABEL; + + if (a->rx_enable + a->tx_enable + a->drop_enable) + { + void *save_pcap_data; + + /* Sanity check max bytes per pkt */ + if (a->max_bytes_per_pkt < 32 || a->max_bytes_per_pkt > 9000) + return VNET_API_ERROR_INVALID_MEMORY_SIZE; + + /* Clean up from previous run, if any */ + vec_reset_length (pm->pcap_data); + + /* Throw away the data buffer? */ + if (a->free_data) + vec_free (pm->pcap_data); + + save_pcap_data = pm->pcap_data; + + memset (pm, 0, sizeof (*pm)); + + pm->pcap_data = save_pcap_data; + + vec_validate_aligned (vnet_trace_placeholder, 2048, + CLIB_CACHE_LINE_BYTES); + if (pm->lock == 0) + clib_spinlock_init (&(pm->lock)); + + if (a->filename == 0) + { + u8 *stem = 0; + + if (a->rx_enable) + stem = format (stem, "rx"); + if (a->tx_enable) + stem = format (stem, "tx"); + if (a->drop_enable) + stem = format (stem, "drop"); + a->filename = format (0, "/tmp/%v.pcap%c", stem, 0); + vec_free (stem); + } + + pm->file_name = (char *) a->filename; + pm->n_packets_captured = 0; + pm->packet_type = PCAP_PACKET_TYPE_ethernet; + /* Preallocate the data vector? */ + if (a->preallocate_data) + { + vec_validate + (pm->pcap_data, a->packets_to_capture + * ((sizeof (pcap_packet_header_t) + a->max_bytes_per_pkt))); + vec_reset_length (pm->pcap_data); + } + pm->n_packets_to_capture = a->packets_to_capture; + pp->pcap_sw_if_index = a->sw_if_index; + if (a->filter) + pp->filter_classify_table_index = + cm->classify_table_index_by_sw_if_index[0]; + else + pp->filter_classify_table_index = ~0; + pp->pcap_error_index = a->drop_err; + pp->pcap_rx_enable = a->rx_enable; + pp->pcap_tx_enable = a->tx_enable; + pp->pcap_drop_enable = a->drop_enable; + pp->max_bytes_per_pkt = a->max_bytes_per_pkt; + } + else + { + pp->pcap_rx_enable = 0; + pp->pcap_tx_enable = 0; + pp->pcap_drop_enable = 0; + pp->filter_classify_table_index = ~0; + pp->pcap_error_index = ~0; + if (pm->n_packets_captured) + { + clib_error_t *error; + pm->n_packets_to_capture = pm->n_packets_captured; + vlib_cli_output (vm, "Write %d packets to %s, and stop capture...", + pm->n_packets_captured, pm->file_name); + error = pcap_write (pm); + if (pm->flags & PCAP_MAIN_INIT_DONE) + pcap_close (pm); + /* Report I/O errors... */ + if (error) + { + clib_error_report (error); + return VNET_API_ERROR_SYSCALL_ERROR_1; + } + vec_free (pm->file_name); + if (a->free_data) + vec_free (pm->pcap_data); + return 0; + } + else + return VNET_API_ERROR_NO_SUCH_ENTRY; + } + + return 0; +} + +static clib_error_t * +pcap_trace_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_pcap_dispatch_trace_args_t _a, *a = &_a; + vnet_main_t *vnm = vnet_get_main (); + u8 *filename = 0; + u32 max = 1000; + u32 max_bytes_per_pkt = 512; + int rv; + int rx_enable = 0; + int tx_enable = 0; + int preallocate_data = 0; + int drop_enable = 0; + int status = 0; + int filter = 0; + int free_data = 0; + u32 sw_if_index = 0; /* default: any interface */ + vlib_error_t drop_err = ~0; /* default: any error */ + + /* 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, "rx")) + rx_enable = 1; + else if (unformat (line_input, "tx")) + tx_enable = 1; + else if (unformat (line_input, "drop")) + drop_enable = 1; + else if (unformat (line_input, "off")) + rx_enable = tx_enable = drop_enable = 0; + else if (unformat (line_input, "max-bytes-per-pkt %u", + &max_bytes_per_pkt)) + ; + else if (unformat (line_input, "max %d", &max)) + ; + else if (unformat (line_input, "packets-to-capture %d", &max)) + ; + else if (unformat (line_input, "file %U", unformat_vlib_tmpfile, + &filename)) + ; + else if (unformat (line_input, "status %=", &status, 1)) + ; + else if (unformat (line_input, "intfc %U", + unformat_vnet_sw_interface, vnm, &sw_if_index)) + ; + else if (unformat (line_input, "interface %U", + unformat_vnet_sw_interface, vnm, &sw_if_index)) + ; + else if (unformat (line_input, "error %U", unformat_vlib_error, vm, + &drop_err)) + ; + else if (unformat (line_input, "preallocate-data %=", + &preallocate_data, 1)) + ; + else if (unformat (line_input, "free-data %=", &free_data, 1)) + ; + else if (unformat (line_input, "intfc any") + || unformat (line_input, "interface any")) + sw_if_index = 0; + else if (unformat (line_input, "filter")) + filter = 1; + else + { + return clib_error_return (0, "unknown input `%U'", + format_unformat_error, line_input); + } + } + + unformat_free (line_input); + + /* no need for memset (a, 0, sizeof (*a)), set all fields here. */ + a->filename = filename; + a->rx_enable = rx_enable; + a->tx_enable = tx_enable; + a->preallocate_data = preallocate_data; + a->free_data = free_data; + a->drop_enable = drop_enable; + a->status = status; + a->packets_to_capture = max; + a->sw_if_index = sw_if_index; + a->filter = filter; + a->max_bytes_per_pkt = max_bytes_per_pkt; + a->drop_err = drop_err; + + rv = vnet_pcap_dispatch_trace_configure (a); + + switch (rv) + { + case 0: + break; + + case VNET_API_ERROR_INVALID_VALUE: + return clib_error_return (0, "dispatch trace already enabled..."); + + case VNET_API_ERROR_VALUE_EXIST: + return clib_error_return (0, "dispatch trace already disabled..."); + + case VNET_API_ERROR_INVALID_VALUE_2: + return clib_error_return + (0, "can't change number of records to capture while tracing..."); + + case VNET_API_ERROR_SYSCALL_ERROR_1: + return clib_error_return (0, "I/O writing trace capture..."); + + case VNET_API_ERROR_NO_SUCH_ENTRY: + return clib_error_return (0, "No packets captured..."); + + case VNET_API_ERROR_INVALID_MEMORY_SIZE: + return clib_error_return (0, + "Max bytes per pkt must be > 32, < 9000..."); + + case VNET_API_ERROR_NO_SUCH_LABEL: + return clib_error_return + (0, "No classify filter configured, see 'classify filter...'"); + + default: + vlib_cli_output (vm, "WARNING: trace configure returned %d", rv); + break; + } + return 0; +} + +/*? + * This command is used to start or stop a packet capture, or show + * the status of packet capture. + * + * This command has the following optional parameters: + * + * + * - rx - Capture received packets + * + * - tx - Capture transmitted packets + * + * - drop - Capture dropped packets + * + * - off - Stop capturing packets, write results to the specified file + * + * - max - Depth of local buffer. Once 'nn' number + * of packets have been received, buffer is flushed to file. Once another + * 'nn' number of packets have been received, buffer is flushed + * to file, overwriting previous write. If not entered, value defaults + * to 100. Can only be updated if packet capture is off. + * + * - max-bytes-per-pkt - Maximum number of bytes to capture + * for each packet. Must be >= 32, <= 9000. + * + * - preallocate-data - Preallocate the data buffer, to avoid + * vector expansion delays during pcap capture + * + * - free-data - Free the data buffer. Ordinarily it's a feature + * to retain the data buffer so this option is seldom used. + * + * - intfc |any - Used to specify a given interface, + * or use 'any' to run packet capture on all interfaces. + * 'any' is the default if not provided. Settings from a previous + * packet capture are preserved, so 'any' can be used to reset + * the interface setting. + * + * - filter - Use the pcap rx / tx / drop trace filter, which + * must be configured. Use classify filter pcap... to configure the + * filter. The filter will only be executed if the per-interface or + * any-interface tests fail. + * + * - error . - filter packets based on a specific error. + * For example: error {ip4-udp-lookup}.{No listener for dst port} + * + * - file - Used to specify the output filename. The file will + * be placed in the '/tmp' directory, so only the filename is + * supported. Directory should not be entered. If file already exists, file + * will be overwritten. If no filename is provided, the file will be + * named "/tmp/rx.pcap", "/tmp/tx.pcap", "/tmp/rxandtx.pcap", etc. + * Can only be updated if packet capture is off. + * + * - status - Displays the current status and configured attributes + * associated with a packet capture. If packet capture is in progress, + * 'status' also will return the number of packets currently in + * the local buffer. All additional attributes entered on command line + * with 'status' will be ignored and not applied. + * + * @cliexpar + * Example of how to display the status of a tx packet capture when off: + * @cliexstart{pcap trace status} + * max is 100, for any interface to file /tmp/vpe.pcap + * pcap tx capture is off... + * @cliexend + * Example of how to start a tx packet capture: + * @cliexstart{pcap trace tx max 35 intfc GigabitEthernet0/8/0 file + * vppTest.pcap} + * @cliexend + * Example of how to display the status of a tx packet capture in progress: + * @cliexstart{pcap trace status} + * max is 35, for interface GigabitEthernet0/8/0 to file /tmp/vppTest.pcap + * pcap tx capture is on: 20 of 35 pkts... + * @cliexend + * Example of how to stop a tx packet capture: + * @cliexstart{pcap trace off} + * captured 21 pkts... + * saved to /tmp/vppTest.pcap... + * @cliexend +?*/ +/* *INDENT-OFF* */ + +VLIB_CLI_COMMAND (pcap_tx_trace_command, static) = { + .path = "pcap trace", + .short_help = + "pcap trace [rx] [tx] [drop] [off] [max ] [intfc |any]\n" + " [file ] [status] [max-bytes-per-pkt ][filter]\n" + " [preallocate-data][free-data]", + .function = pcap_trace_command_fn, +}; +/* *INDENT-ON* */ + +static clib_error_t * +set_interface_name (vlib_main_t *vm, unformat_input_t *input, + vlib_cli_command_t *cmd) +{ + clib_error_t *error = 0; + unformat_input_t _line_input, *line_input = &_line_input; + vnet_main_t *vnm = vnet_get_main (); + u32 hw_if_index = ~0; + char *name = 0; + + 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, "%U %s", unformat_vnet_hw_interface, vnm, + &hw_if_index, &name)) + ; + else + { + error = clib_error_return (0, "parse error: '%U'", + format_unformat_error, line_input); + unformat_free (line_input); + vec_free (name); + return error; + } + } + + unformat_free (line_input); + + if (hw_if_index == (u32) ~0 || name == 0) + { + vec_free (name); + error = clib_error_return (0, "please specify valid interface name"); + return error; + } + + error = vnet_rename_interface (vnm, hw_if_index, name); + vec_free (name); + + return (error); +} + +VLIB_CLI_COMMAND (cmd_set_if_name, static) = { + .path = "set interface name", + .short_help = "set interface name ", + .function = set_interface_name, + .is_mp_safe = 1, +}; /* * fd.io coding-style-patch-verification: ON *