X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Finterface_cli.c;h=8db26391573824733e74dae166c9710a7a8516bc;hb=9af7e2e87e6a11fb69309fc9ce4bf8432acbc4e3;hp=b803a31c05f7b1affb57edc93b788f497ee4f72c;hpb=525c9d0f8645ef9901316f042c195adc970b4546;p=vpp.git diff --git a/src/vnet/interface_cli.c b/src/vnet/interface_cli.c index b803a31c05f..8db26391573 100644 --- a/src/vnet/interface_cli.c +++ b/src/vnet/interface_cli.c @@ -304,6 +304,7 @@ show_sw_interfaces (vlib_main_t * vm, verbose = 1; else { + vec_free (sorted_sis); error = clib_error_return (0, "unknown input `%U'", format_unformat_error, linput); goto done; @@ -314,7 +315,10 @@ show_sw_interfaces (vlib_main_t * vm, if (show_features || show_tag) { 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) @@ -326,14 +330,16 @@ show_sw_interfaces (vlib_main_t * vm, /* 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, "\nl2-input:\n%U", format_l2_input_features, fb, + 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 +349,7 @@ 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; } @@ -362,7 +369,7 @@ show_sw_interfaces (vlib_main_t * vm, if (visible) vec_add1 (sorted_sis, si[0]);} )); - /* *INDENT-OFF* */ + /* *INDENT-ON* */ /* Sort by name. */ vec_sort_with_function (sorted_sis, sw_interface_name_compare); } @@ -449,20 +456,19 @@ show_sw_interfaces (vlib_main_t * vm, format_ip6_address, r6, ia->address_length); })); /* *INDENT-ON* */ + } + } + else + { + vec_foreach (si, sorted_sis) + { + vlib_cli_output (vm, "%U\n", format_vnet_sw_interface, vnm, si); + } } -} - -else -{ - vec_foreach (si, sorted_sis) - { - vlib_cli_output (vm, "%U\n", format_vnet_sw_interface, vnm, si); - } -} done: -vec_free (sorted_sis); -return error; + vec_free (sorted_sis); + return error; } /* *INDENT-OFF* */ @@ -470,6 +476,7 @@ VLIB_CLI_COMMAND (show_sw_interfaces_command, static) = { .path = "show interface", .short_help = "show interface [address|addr|features|feat] [ [ [..]]] [verbose]", .function = show_sw_interfaces, + .is_mp_safe = 1, }; /* *INDENT-ON* */ @@ -496,42 +503,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; @@ -688,7 +677,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)) @@ -815,14 +804,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 @@ -965,7 +954,7 @@ 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, @@ -1115,12 +1104,17 @@ 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 hw_if_index, sw_if_index, mtu; ethernet_main_t *em = ðernet_main; + u32 mtus[VNET_N_MTU] = { 0, 0, 0, 0 }; if (unformat (input, "%d %U", &mtu, unformat_vnet_hw_interface, vnm, &hw_if_index)) { + /* + * Change physical MTU on interface. Only supported for Ethernet + * interfaces + */ vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index); ethernet_interface_t *eif = ethernet_get_interface (em, hw_if_index); @@ -1137,17 +1131,35 @@ mtu_cmd (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) hi->max_supported_packet_bytes); vnet_hw_interface_set_mtu (vnm, hw_if_index, mtu); + goto done; } + else if (unformat (input, "packet %d %U", &mtu, + unformat_vnet_sw_interface, vnm, &sw_if_index)) + /* Set default packet MTU (including L3 header */ + mtus[VNET_MTU_L3] = mtu; + else if (unformat (input, "ip4 %d %U", &mtu, + unformat_vnet_sw_interface, vnm, &sw_if_index)) + mtus[VNET_MTU_IP4] = mtu; + else if (unformat (input, "ip6 %d %U", &mtu, + unformat_vnet_sw_interface, vnm, &sw_if_index)) + mtus[VNET_MTU_IP6] = mtu; + else if (unformat (input, "mpls %d %U", &mtu, + unformat_vnet_sw_interface, vnm, &sw_if_index)) + mtus[VNET_MTU_MPLS] = mtu; else return clib_error_return (0, "unknown input `%U'", format_unformat_error, input); + + vnet_sw_interface_set_protocol_mtu (vnm, sw_if_index, mtus); + +done: return 0; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (set_interface_mtu_cmd, static) = { .path = "set interface mtu", - .short_help = "set interface mtu ", + .short_help = "set interface mtu [packet|ip4|ip6|mpls] ", .function = mtu_cmd, }; /* *INDENT-ON* */ @@ -1251,6 +1263,46 @@ VLIB_CLI_COMMAND (clear_tag_command, static) = { }; /* *INDENT-ON* */ +static clib_error_t * +set_ip_directed_broadcast (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + vnet_main_t *vnm = vnet_get_main (); + u32 sw_if_index = ~0; + u8 enable = 0; + + if (!unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index)); + else if (unformat (input, "enable")) + enable = 1; + else if (unformat (input, "disable")) + enable = 0; + else + return clib_error_return (0, "unknown input: `%U'", + format_unformat_error, input); + + if (~0 == sw_if_index) + return clib_error_return (0, "specify an interface: `%U'", + format_unformat_error, input); + + vnet_sw_interface_ip_directed_broadcast (vnm, sw_if_index, enable); + + return 0; +} + +/*? + * This command is used to enable/disable IP directed broadcast + * If directed broadcast is enabled a packet sent to the interface's + * subnet broadcast address will be sent L2 broadcast on the interface, + * otherwise it is dropped. + ?*/ +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (set_ip_directed_broadcast_command, static) = { + .path = "set interface ip directed-broadcast", + .short_help = "set interface enable ", + .function = set_ip_directed_broadcast, +}; +/* *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) @@ -1458,7 +1510,7 @@ show_interface_rx_placement_fn (vlib_main_t * vm, unformat_input_t * input, })); if (vec_len (s) > 0) { - vlib_cli_output(vm, "Thread %u (%v):\n%v", index, + vlib_cli_output(vm, "Thread %u (%s):\n%v", index, vlib_worker_threads[index].name, s); vec_reset_length (s); } @@ -1503,6 +1555,42 @@ VLIB_CLI_COMMAND (show_interface_rx_placement, static) = { }; /* *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; + + if (is_main) + thread_index = 0; + else + thread_index += vdm->first_worker_thread_index; + + if (thread_index > vdm->last_worker_thread_index) + 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); + + return (error); +} + static clib_error_t * set_interface_rx_placement (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) @@ -1510,12 +1598,10 @@ set_interface_rx_placement (vlib_main_t * vm, unformat_input_t * input, clib_error_t *error = 0; unformat_input_t _line_input, *line_input = &_line_input; vnet_main_t *vnm = vnet_get_main (); - vnet_device_main_t *vdm = &vnet_device_main; - vnet_hw_interface_rx_mode mode; u32 hw_if_index = (u32) ~ 0; u32 queue_id = (u32) 0; u32 thread_index = (u32) ~ 0; - int rv; + u8 is_main = 0; if (!unformat_user (input, unformat_line_input, line_input)) return 0; @@ -1528,9 +1614,9 @@ set_interface_rx_placement (vlib_main_t * vm, unformat_input_t * input, else if (unformat (line_input, "queue %d", &queue_id)) ; else if (unformat (line_input, "main", &thread_index)) - thread_index = 0; + is_main = 1; else if (unformat (line_input, "worker %d", &thread_index)) - thread_index += vdm->first_worker_thread_index; + ; else { error = clib_error_return (0, "parse error: '%U'", @@ -1545,25 +1631,10 @@ set_interface_rx_placement (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 (thread_index > vdm->last_worker_thread_index) - 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"); + error = set_hw_interface_rx_placement (hw_if_index, queue_id, thread_index, + is_main); - 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); - - return 0; + return (error); } /*? @@ -1623,6 +1694,291 @@ VLIB_CLI_COMMAND (cmd_set_if_rx_placement,static) = { .is_mp_safe = 1, }; /* *INDENT-ON* */ + +static inline clib_error_t * +pcap_trace_command_internal (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd, int rx_tx) +{ + unformat_input_t _line_input, *line_input = &_line_input; + u8 *filename; + u8 *chroot_filename = 0; + u32 max = 0; + int enabled = 0; + int errorFlag = 0; + clib_error_t *error = 0; + 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, "on")) + { + if (vm->pcap[rx_tx].pcap_enable == 0) + { + enabled = 1; + vm->pcap[rx_tx].pcap_main.n_packets_to_capture = + PCAP_DEF_PKT_TO_CAPTURE; + } + else + { + vlib_cli_output (vm, "pcap %s capture already on...", + (rx_tx == VLIB_RX) ? "rx" : "tx"); + errorFlag = 1; + break; + } + } + else if (unformat (line_input, "off")) + { + if (vm->pcap[rx_tx].pcap_enable) + { + vlib_cli_output + (vm, "captured %d pkts...", + vm->pcap[rx_tx].pcap_main.n_packets_captured); + if (vm->pcap[rx_tx].pcap_main.n_packets_captured) + { + vm->pcap[rx_tx].pcap_main.n_packets_to_capture = + vm->pcap[rx_tx].pcap_main.n_packets_captured; + error = pcap_write (&vm->pcap[rx_tx].pcap_main); + if (vm->pcap[rx_tx].pcap_main.file_descriptor >= 0) + pcap_close (&vm->pcap[rx_tx].pcap_main); + if (error) + clib_error_report (error); + else + vlib_cli_output (vm, "saved to %s...", + vm->pcap[rx_tx].pcap_main.file_name); + } + + vm->pcap[rx_tx].pcap_enable = 0; + } + else + { + vlib_cli_output (vm, "pcap %s capture already off...", + (rx_tx == VLIB_RX) ? "rx" : "tx"); + errorFlag = 1; + break; + } + } + else if (unformat (line_input, "max %d", &max)) + { + if (vm->pcap[rx_tx].pcap_enable) + { + vlib_cli_output + (vm, + "can't change max value while pcap tx capture active..."); + errorFlag = 1; + break; + } + vm->pcap[rx_tx].pcap_main.n_packets_to_capture = max; + } + else if (unformat (line_input, "intfc %U", + unformat_vnet_sw_interface, vnm, + &vm->pcap[rx_tx].pcap_sw_if_index)) + ; + + else if (unformat (line_input, "intfc any")) + { + vm->pcap[rx_tx].pcap_sw_if_index = 0; + } + else if (unformat (line_input, "file %s", &filename)) + { + if (vm->pcap[rx_tx].pcap_enable) + { + vlib_cli_output + (vm, "can't change file while pcap tx capture active..."); + errorFlag = 1; + break; + } + + /* Brain-police user path input */ + if (strstr ((char *) filename, "..") + || index ((char *) filename, '/')) + { + vlib_cli_output (vm, "illegal characters in filename '%s'", + filename); + vlib_cli_output (vm, "Hint: .. and / are not allowed."); + vec_free (filename); + errorFlag = 1; + break; + } + + chroot_filename = format (0, "/tmp/%s%c", filename, 0); + vec_free (filename); + } + else if (unformat (line_input, "status")) + { + if (vm->pcap[rx_tx].pcap_sw_if_index == 0) + { + vlib_cli_output + (vm, "max is %d for any interface to file %s", + vm->pcap[rx_tx].pcap_main.n_packets_to_capture, + vm->pcap[rx_tx].pcap_main.file_name ? + (u8 *) vm->pcap[rx_tx].pcap_main.file_name : + (u8 *) "/tmp/vpe.pcap"); + } + else + { + vlib_cli_output (vm, "max is %d for interface %U to file %s", + vm->pcap[rx_tx].pcap_main.n_packets_to_capture, + format_vnet_sw_if_index_name, vnm, + vm->pcap[rx_tx].pcap_sw_if_index, + vm->pcap[rx_tx]. + pcap_main.file_name ? (u8 *) vm->pcap[rx_tx]. + pcap_main.file_name : (u8 *) "/tmp/vpe.pcap"); + } + + if (vm->pcap[rx_tx].pcap_enable == 0) + { + vlib_cli_output (vm, "pcap %s capture is off...", + (rx_tx == VLIB_RX) ? "rx" : "tx"); + } + else + { + vlib_cli_output (vm, "pcap %s capture is on: %d of %d pkts...", + (rx_tx == VLIB_RX) ? "rx" : "tx", + vm->pcap[rx_tx].pcap_main.n_packets_captured, + vm->pcap[rx_tx]. + pcap_main.n_packets_to_capture); + } + break; + } + + else + { + error = clib_error_return (0, "unknown input `%U'", + format_unformat_error, line_input); + errorFlag = 1; + break; + } + } + unformat_free (line_input); + + + if (errorFlag == 0) + { + /* Since no error, save configured values. */ + if (chroot_filename) + { + if (vm->pcap[rx_tx].pcap_main.file_name) + vec_free (vm->pcap[rx_tx].pcap_main.file_name); + vec_add1 (chroot_filename, 0); + vm->pcap[rx_tx].pcap_main.file_name = (char *) chroot_filename; + } + + if (max) + vm->pcap[rx_tx].pcap_main.n_packets_to_capture = max; + + if (enabled) + { + if (vm->pcap[rx_tx].pcap_main.file_name == 0) + vm->pcap[rx_tx].pcap_main.file_name + = (char *) format (0, "/tmp/vpe.pcap%c", 0); + + vm->pcap[rx_tx].pcap_main.n_packets_captured = 0; + vm->pcap[rx_tx].pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet; + if (vm->pcap[rx_tx].pcap_main.lock == 0) + clib_spinlock_init (&(vm->pcap[rx_tx].pcap_main.lock)); + vm->pcap[rx_tx].pcap_enable = 1; + vlib_cli_output (vm, "pcap %s capture on...", + rx_tx == VLIB_RX ? "rx" : "tx"); + } + } + else if (chroot_filename) + vec_free (chroot_filename); + + return error; +} + +static clib_error_t * +pcap_rx_trace_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + return pcap_trace_command_internal (vm, input, cmd, VLIB_RX); +} + +static clib_error_t * +pcap_tx_trace_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) +{ + return pcap_trace_command_internal (vm, input, cmd, VLIB_TX); +} + + +/*? + * This command is used to start or stop a packet capture, or show + * the status of packet capture. Note that both "pcap rx trace" and + * "pcap tx trace" are implemented. The command syntax is identical, + * simply substitute rx for tx as needed. + * + * This command has the following optional parameters: + * + * - on|off - Used to start or stop a packet capture. + * + * - 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. + * + * - 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. + * + * - 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, '/tmp/vpe.pcap' + * will be used. 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 tx 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 tx trace on max 35 intfc GigabitEthernet0/8/0 file vppTest.pcap} + * pcap tx capture on... + * @cliexend + * Example of how to display the status of a tx packet capture in progress: + * @cliexstart{pcap tx 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{vppctl pcap tx trace off} + * captured 21 pkts... + * saved to /tmp/vppTest.pcap... + * @cliexend +?*/ +/* *INDENT-OFF* */ + +VLIB_CLI_COMMAND (pcap_tx_trace_command, static) = { + .path = "pcap tx trace", + .short_help = + "pcap tx trace [on|off] [max ] [intfc |any] [file ] [status]", + .function = pcap_tx_trace_command_fn, +}; +VLIB_CLI_COMMAND (pcap_rx_trace_command, static) = { + .path = "pcap rx trace", + .short_help = + "pcap rx trace [on|off] [max ] [intfc |any] [file ] [status]", + .function = pcap_rx_trace_command_fn, +}; +/* *INDENT-ON* */ + + /* * fd.io coding-style-patch-verification: ON *