#include <vnet/vnet.h>
#include <vnet/ip/icmp46_packet.h>
+#include <vnet/ethernet/packet.h>
+#include <vnet/ip/format.h>
#include <vnet/ip/ip4.h>
#include <vnet/ip/ip6.h>
#include <vnet/udp/udp_packet.h>
#include <vnet/feature/feature.h>
+#include <vnet/classify/pcap_classify.h>
+#include <vnet/hash/hash.h>
+#include <vnet/interface_output.h>
+#include <vppinfra/vector/mask_compare.h>
+#include <vppinfra/vector/compress.h>
+#include <vppinfra/vector/count_equal.h>
+#include <vppinfra/vector/array_mask.h>
typedef struct
{
u32 sw_if_index;
- u8 data[128 - sizeof (u32)];
+ u32 flags;
+ u8 data[128 - 2 * sizeof (u32)];
}
interface_output_trace_t;
+#ifndef CLIB_MARCH_VARIANT
u8 *
format_vnet_interface_output_trace (u8 * s, va_list * va)
{
(vnm->interface_main.sw_interfaces, t->sw_if_index))
{
/* the interface may have been deleted by the time the trace is printed */
- s = format (s, "sw_if_index: %d\n%U%U",
- t->sw_if_index,
- format_white_space, indent,
- node->format_buffer ? node->
- format_buffer : format_hex_bytes, t->data,
- sizeof (t->data));
+ s = format (s, "sw_if_index: %d ", t->sw_if_index);
}
else
{
si = vnet_get_sw_interface (vnm, t->sw_if_index);
-
- s = format (s, "%U\n%U%U",
- format_vnet_sw_interface_name, vnm, si,
- format_white_space, indent,
- node->format_buffer ? node->
- format_buffer : format_hex_bytes, t->data,
- sizeof (t->data));
+ s = format (s, "%U flags 0x%08x", format_vnet_sw_interface_name, vnm,
+ si, t->flags);
}
+ s =
+ format (s, "\n%U%U", format_white_space, indent,
+ node->format_buffer ? node->format_buffer : format_hex_bytes,
+ t->data, sizeof (t->data));
}
return s;
}
+#endif /* CLIB_MARCH_VARIANT */
static void
vnet_interface_output_trace (vlib_main_t * vm,
{
t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_TX];
+ t0->flags = b0->flags;
clib_memcpy_fast (t0->data, vlib_buffer_get_current (b0),
sizeof (t0->data));
}
{
t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
t1->sw_if_index = vnet_buffer (b1)->sw_if_index[VLIB_TX];
+ t1->flags = b1->flags;
clib_memcpy_fast (t1->data, vlib_buffer_get_current (b1),
sizeof (t1->data));
}
{
t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_TX];
+ t0->flags = b0->flags;
clib_memcpy_fast (t0->data, vlib_buffer_get_current (b0),
sizeof (t0->data));
}
}
static_always_inline void
-calc_checksums (vlib_main_t * vm, vlib_buffer_t * b)
+vnet_interface_output_handle_offload (vlib_main_t *vm, vlib_buffer_t *b)
{
- ip4_header_t *ip4;
- ip6_header_t *ip6;
- tcp_header_t *th;
- udp_header_t *uh;
+ if (b->flags & VNET_BUFFER_F_GSO)
+ return;
+ vnet_calc_checksums_inline (vm, b, b->flags & VNET_BUFFER_F_IS_IP4,
+ b->flags & VNET_BUFFER_F_IS_IP6);
+ vnet_calc_outer_checksums_inline (vm, b);
+}
- int is_ip4 = (b->flags & VNET_BUFFER_F_IS_IP4) != 0;
- int is_ip6 = (b->flags & VNET_BUFFER_F_IS_IP6) != 0;
+static_always_inline uword
+vnet_interface_output_node_inline (vlib_main_t *vm, u32 sw_if_index,
+ vlib_combined_counter_main_t *ccm,
+ vlib_buffer_t **b, void **p,
+ u32 config_index, u8 arc, u32 n_left,
+ int processing_level)
+{
+ u32 n_bytes = 0;
+ u32 n_bytes0, n_bytes1, n_bytes2, n_bytes3;
+ u32 ti = vm->thread_index;
- ASSERT (!(is_ip4 && is_ip6));
+ while (n_left >= 8)
+ {
+ u32 or_flags;
- ip4 = (ip4_header_t *) (b->data + vnet_buffer (b)->l3_hdr_offset);
- ip6 = (ip6_header_t *) (b->data + vnet_buffer (b)->l3_hdr_offset);
- th = (tcp_header_t *) (b->data + vnet_buffer (b)->l4_hdr_offset);
- uh = (udp_header_t *) (b->data + vnet_buffer (b)->l4_hdr_offset);
+ /* Prefetch next iteration. */
+ vlib_prefetch_buffer_header (b[4], LOAD);
+ vlib_prefetch_buffer_header (b[5], LOAD);
+ vlib_prefetch_buffer_header (b[6], LOAD);
+ vlib_prefetch_buffer_header (b[7], LOAD);
+
+ if (processing_level >= 1)
+ or_flags = b[0]->flags | b[1]->flags | b[2]->flags | b[3]->flags;
+
+ /* Be grumpy about zero length buffers for benefit of
+ driver tx function. */
+ ASSERT (b[0]->current_length > 0);
+ ASSERT (b[1]->current_length > 0);
+ ASSERT (b[2]->current_length > 0);
+ ASSERT (b[3]->current_length > 0);
+
+ n_bytes += n_bytes0 = vlib_buffer_length_in_chain (vm, b[0]);
+ n_bytes += n_bytes1 = vlib_buffer_length_in_chain (vm, b[1]);
+ n_bytes += n_bytes2 = vlib_buffer_length_in_chain (vm, b[2]);
+ n_bytes += n_bytes3 = vlib_buffer_length_in_chain (vm, b[3]);
+
+ if (processing_level >= 3)
+ {
+ p[0] = vlib_buffer_get_current (b[0]);
+ p[1] = vlib_buffer_get_current (b[1]);
+ p[2] = vlib_buffer_get_current (b[2]);
+ p[3] = vlib_buffer_get_current (b[3]);
+ p += 4;
+ }
- if (is_ip4)
- {
- ip4 = (ip4_header_t *) (b->data + vnet_buffer (b)->l3_hdr_offset);
- if (b->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM)
- ip4->checksum = ip4_header_checksum (ip4);
- if (b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
+ if (processing_level >= 2)
+ {
+ u32 tx_swif0, tx_swif1, tx_swif2, tx_swif3;
+ tx_swif0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
+ tx_swif1 = vnet_buffer (b[1])->sw_if_index[VLIB_TX];
+ tx_swif2 = vnet_buffer (b[2])->sw_if_index[VLIB_TX];
+ tx_swif3 = vnet_buffer (b[3])->sw_if_index[VLIB_TX];
+
+ /* update vlan subif tx counts, if required */
+ if (PREDICT_FALSE (tx_swif0 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif0, 1, n_bytes0);
+
+ if (PREDICT_FALSE (tx_swif1 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif1, 1, n_bytes1);
+
+ if (PREDICT_FALSE (tx_swif2 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif2, 1, n_bytes2);
+
+ if (PREDICT_FALSE (tx_swif3 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif3, 1, n_bytes3);
+
+ if (PREDICT_FALSE (config_index != ~0))
+ {
+ vnet_buffer (b[0])->feature_arc_index = arc;
+ b[0]->current_config_index = config_index;
+ vnet_buffer (b[1])->feature_arc_index = arc;
+ b[1]->current_config_index = config_index;
+ vnet_buffer (b[2])->feature_arc_index = arc;
+ b[2]->current_config_index = config_index;
+ vnet_buffer (b[3])->feature_arc_index = arc;
+ b[3]->current_config_index = config_index;
+ }
+ }
+
+ if (processing_level >= 1 && (or_flags & VNET_BUFFER_F_OFFLOAD))
{
- th->checksum = 0;
- th->checksum = ip4_tcp_udp_compute_checksum (vm, b, ip4);
+ vnet_interface_output_handle_offload (vm, b[0]);
+ vnet_interface_output_handle_offload (vm, b[1]);
+ vnet_interface_output_handle_offload (vm, b[2]);
+ vnet_interface_output_handle_offload (vm, b[3]);
}
- if (b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)
- uh->checksum = ip4_tcp_udp_compute_checksum (vm, b, ip4);
+
+ n_left -= 4;
+ b += 4;
}
- if (is_ip6)
+
+ while (n_left)
{
- int bogus;
- if (b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM)
- th->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ip6, &bogus);
- if (b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM)
- uh->checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b, ip6, &bogus);
+ /* Be grumpy about zero length buffers for benefit of
+ driver tx function. */
+ ASSERT (b[0]->current_length > 0);
+
+ n_bytes += n_bytes0 = vlib_buffer_length_in_chain (vm, b[0]);
+
+ if (processing_level >= 3)
+ {
+ p[0] = vlib_buffer_get_current (b[0]);
+ p += 1;
+ }
+
+ if (processing_level >= 2)
+ {
+ u32 tx_swif0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
+
+ if (PREDICT_FALSE (config_index != ~0))
+ {
+ vnet_buffer (b[0])->feature_arc_index = arc;
+ b[0]->current_config_index = config_index;
+ }
+
+ if (PREDICT_FALSE (tx_swif0 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif0, 1, n_bytes0);
+ }
+
+ if (processing_level >= 1)
+ vnet_interface_output_handle_offload (vm, b[0]);
+
+ n_left -= 1;
+ b += 1;
}
- b->flags &= ~VNET_BUFFER_F_OFFLOAD_TCP_CKSUM;
- b->flags &= ~VNET_BUFFER_F_OFFLOAD_UDP_CKSUM;
- b->flags &= ~VNET_BUFFER_F_OFFLOAD_IP_CKSUM;
+ return n_bytes;
}
-static_always_inline uword
-vnet_interface_output_node_inline (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame, vnet_main_t * vnm,
- vnet_hw_interface_t * hi,
- int do_tx_offloads)
+static_always_inline void
+vnet_interface_pcap_tx_trace (vlib_main_t *vm, vlib_node_runtime_t *node,
+ vlib_frame_t *frame, int in_interface_ouput)
{
- vnet_interface_output_runtime_t *rt = (void *) node->runtime_data;
- vnet_sw_interface_t *si;
- u32 n_left_to_tx, *from, *from_end, *to_tx;
- u32 n_bytes, n_buffers, n_packets;
- u32 n_bytes_b0, n_bytes_b1, n_bytes_b2, n_bytes_b3;
- u32 thread_index = vm->thread_index;
- vnet_interface_main_t *im = &vnm->interface_main;
- u32 next_index = VNET_INTERFACE_OUTPUT_NEXT_TX;
- u32 current_config_index = ~0;
- u8 arc = im->output_feature_arc_index;
+ vnet_main_t *vnm = vnet_get_main ();
+ u32 n_left_from, *from;
+ u32 sw_if_index = ~0, hw_if_index = ~0;
+ vnet_pcap_t *pp = &vnm->pcap;
- n_buffers = frame->n_vectors;
+ if (PREDICT_TRUE (pp->pcap_tx_enable == 0))
+ return;
- if (node->flags & VLIB_NODE_FLAG_TRACE)
- vnet_interface_output_trace (vm, node, frame, n_buffers);
+ if (in_interface_ouput)
+ {
+ /* interface-output is called right before interface-output-template.
+ * We only want to capture packets here if there is a per-interface
+ * filter, in case it matches the sub-interface sw_if_index.
+ * If there is no per-interface filter configured, let the
+ * interface-output-template node deal with it */
+ if (pp->pcap_sw_if_index == 0)
+ return;
+ }
+ else
+ {
+ vnet_interface_output_runtime_t *rt = (void *) node->runtime_data;
+ sw_if_index = rt->sw_if_index;
+ }
+ n_left_from = frame->n_vectors;
from = vlib_frame_vector_args (frame);
- if (rt->is_deleted)
- return vlib_error_drop_buffers (vm, node, from,
- /* buffer stride */ 1,
- n_buffers,
- VNET_INTERFACE_OUTPUT_NEXT_DROP,
- node->node_index,
- VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DELETED);
-
- si = vnet_get_sw_interface (vnm, rt->sw_if_index);
- hi = vnet_get_sup_hw_interface (vnm, rt->sw_if_index);
- if (!(si->flags & (VNET_SW_INTERFACE_FLAG_ADMIN_UP |
- VNET_SW_INTERFACE_FLAG_BOND_SLAVE)) ||
- !(hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP))
+ while (n_left_from > 0)
{
- vlib_simple_counter_main_t *cm;
+ u32 bi0 = from[0];
+ vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
+ from++;
+ n_left_from--;
- cm = vec_elt_at_index (vnm->interface_main.sw_if_counters,
- VNET_INTERFACE_COUNTER_TX_ERROR);
- vlib_increment_simple_counter (cm, thread_index,
- rt->sw_if_index, n_buffers);
-
- return vlib_error_drop_buffers (vm, node, from,
- /* buffer stride */ 1,
- n_buffers,
- VNET_INTERFACE_OUTPUT_NEXT_DROP,
- node->node_index,
- VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DOWN);
+ if (in_interface_ouput)
+ {
+ const u32 sii = vnet_buffer (b0)->sw_if_index[VLIB_TX];
+ if (PREDICT_FALSE (sii != sw_if_index))
+ {
+ const vnet_hw_interface_t *hi =
+ vnet_get_sup_hw_interface (vnm, sii);
+ hw_if_index = hi->sw_if_index;
+ sw_if_index = sii;
+ }
+ if (hw_if_index == sw_if_index)
+ continue; /* defer to interface-output-template */
+ }
+
+ if (vnet_is_packet_pcaped (pp, b0, sw_if_index))
+ pcap_add_buffer (&pp->pcap_main, vm, bi0, pp->max_bytes_per_pkt);
}
+}
- from_end = from + n_buffers;
+static_always_inline void
+hash_func_with_mask (void **p, u32 *hash, u32 n_packets, u32 *lookup_table,
+ u32 mask, vnet_hash_fn_t hf)
+{
+ u32 n_left_from = n_packets;
- /* Total byte count of all buffers. */
- n_bytes = 0;
- n_packets = 0;
+ hf (p, hash, n_packets);
- /* interface-output feature arc handling */
- if (PREDICT_FALSE (vnet_have_features (arc, rt->sw_if_index)))
+ clib_array_mask_u32 (hash, mask, n_packets);
+
+ while (n_left_from >= 4)
{
- vnet_feature_config_main_t *fcm;
- fcm = vnet_feature_get_config_main (arc);
- current_config_index = vnet_get_feature_config_index (arc,
- rt->sw_if_index);
- vnet_get_config_data (&fcm->config_main, ¤t_config_index,
- &next_index, 0);
+ hash[0] = lookup_table[hash[0]];
+ hash[1] = lookup_table[hash[1]];
+ hash[2] = lookup_table[hash[2]];
+ hash[3] = lookup_table[hash[3]];
+
+ hash += 4;
+ n_left_from -= 4;
}
- while (from < from_end)
+ while (n_left_from > 0)
{
- /* Get new next frame since previous incomplete frame may have less
- than VNET_FRAME_SIZE vectors in it. */
- vlib_get_new_next_frame (vm, node, next_index, to_tx, n_left_to_tx);
+ hash[0] = lookup_table[hash[0]];
- while (from + 8 <= from_end && n_left_to_tx >= 4)
- {
- u32 bi0, bi1, bi2, bi3;
- vlib_buffer_t *b0, *b1, *b2, *b3;
- u32 tx_swif0, tx_swif1, tx_swif2, tx_swif3;
- u32 or_flags;
+ hash += 1;
+ n_left_from -= 1;
+ }
+}
- /* Prefetch next iteration. */
- vlib_prefetch_buffer_with_index (vm, from[4], LOAD);
- vlib_prefetch_buffer_with_index (vm, from[5], LOAD);
- vlib_prefetch_buffer_with_index (vm, from[6], LOAD);
- vlib_prefetch_buffer_with_index (vm, from[7], LOAD);
+static_always_inline void
+store_tx_frame_scalar_data (vnet_hw_if_tx_frame_t *copy_frame,
+ vnet_hw_if_tx_frame_t *tf)
+{
+ if (copy_frame)
+ clib_memcpy_fast (tf, copy_frame, sizeof (vnet_hw_if_tx_frame_t));
+}
- bi0 = from[0];
- bi1 = from[1];
- bi2 = from[2];
- bi3 = from[3];
- to_tx[0] = bi0;
- to_tx[1] = bi1;
- to_tx[2] = bi2;
- to_tx[3] = bi3;
- from += 4;
- to_tx += 4;
- n_left_to_tx -= 4;
+static_always_inline u32
+enqueue_one_to_tx_node (vlib_main_t *vm, vlib_node_runtime_t *node, u32 *ppqi,
+ u32 *from, vnet_hw_if_tx_frame_t *copy_frame,
+ u32 n_vectors, u32 n_left, u32 next_index)
+{
+ u32 tmp[VLIB_FRAME_SIZE];
+ vlib_frame_bitmap_t mask = {};
+ vlib_frame_t *f;
+ vnet_hw_if_tx_frame_t *tf;
+ u32 *to;
+ u32 n_copy = 0, n_free = 0;
+
+ f = vlib_get_next_frame_internal (vm, node, next_index, 0);
+ tf = vlib_frame_scalar_args (f);
+
+ if (f->n_vectors > 0 &&
+ (!copy_frame || (tf->queue_id == copy_frame->queue_id)))
+ {
+ /* append current next frame */
+ n_free = VLIB_FRAME_SIZE - f->n_vectors;
+ /*
+ * if frame contains enough space for worst case scenario,
+ * we can avoid use of tmp
+ */
+ if (n_free >= n_left)
+ to = (u32 *) vlib_frame_vector_args (f) + f->n_vectors;
+ else
+ to = tmp;
+ }
+ else
+ {
+ if (f->n_vectors > 0)
+ {
+ /* current frame doesn't fit - grab empty one */
+ f = vlib_get_next_frame_internal (vm, node, next_index, 1);
+ tf = vlib_frame_scalar_args (f);
+ }
- b0 = vlib_get_buffer (vm, bi0);
- b1 = vlib_get_buffer (vm, bi1);
- b2 = vlib_get_buffer (vm, bi2);
- b3 = vlib_get_buffer (vm, bi3);
-
- /* Be grumpy about zero length buffers for benefit of
- driver tx function. */
- ASSERT (b0->current_length > 0);
- ASSERT (b1->current_length > 0);
- ASSERT (b2->current_length > 0);
- ASSERT (b3->current_length > 0);
-
- n_bytes_b0 = vlib_buffer_length_in_chain (vm, b0);
- n_bytes_b1 = vlib_buffer_length_in_chain (vm, b1);
- n_bytes_b2 = vlib_buffer_length_in_chain (vm, b2);
- n_bytes_b3 = vlib_buffer_length_in_chain (vm, b3);
- tx_swif0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
- tx_swif1 = vnet_buffer (b1)->sw_if_index[VLIB_TX];
- tx_swif2 = vnet_buffer (b2)->sw_if_index[VLIB_TX];
- tx_swif3 = vnet_buffer (b3)->sw_if_index[VLIB_TX];
-
- n_bytes += n_bytes_b0 + n_bytes_b1;
- n_bytes += n_bytes_b2 + n_bytes_b3;
- n_packets += 4;
-
- if (PREDICT_FALSE (current_config_index != ~0))
- {
- vnet_buffer (b0)->feature_arc_index = arc;
- vnet_buffer (b1)->feature_arc_index = arc;
- vnet_buffer (b2)->feature_arc_index = arc;
- vnet_buffer (b3)->feature_arc_index = arc;
- b0->current_config_index = current_config_index;
- b1->current_config_index = current_config_index;
- b2->current_config_index = current_config_index;
- b3->current_config_index = current_config_index;
- }
+ /* empty frame - store scalar data */
+ store_tx_frame_scalar_data (copy_frame, tf);
+ to = vlib_frame_vector_args (f);
+ n_free = VLIB_FRAME_SIZE;
+ }
- /* update vlan subif tx counts, if required */
- if (PREDICT_FALSE (tx_swif0 != rt->sw_if_index))
- {
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif0, 1,
- n_bytes_b0);
- }
+ /*
+ * per packet queue id array
+ * compare with given queue_id, if match, copy respective buffer index from
+ * -> to
+ */
+ if (ppqi)
+ {
+ clib_mask_compare_u32 (copy_frame->queue_id, ppqi, mask, n_vectors);
+ n_copy = clib_compress_u32 (to, from, mask, n_vectors);
- if (PREDICT_FALSE (tx_swif1 != rt->sw_if_index))
- {
+ if (n_copy == 0)
+ return n_left;
+ }
+ else
+ {
+ /*
+ * no work required, just copy all buffer indices from -> to
+ */
+ n_copy = n_left;
+ vlib_buffer_copy_indices (to, from, n_copy);
+ }
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif1, 1,
- n_bytes_b1);
- }
+ if (to != tmp)
+ {
+ /* indices already written to frame, just close it */
+ vlib_put_next_frame (vm, node, next_index, n_free - n_copy);
+ }
+ else if (n_free >= n_copy)
+ {
+ /* enough space in the existing frame */
+ to = (u32 *) vlib_frame_vector_args (f) + f->n_vectors;
+ vlib_buffer_copy_indices (to, tmp, n_copy);
+ vlib_put_next_frame (vm, node, next_index, n_free - n_copy);
+ }
+ else
+ {
+ /* full frame */
+ to = (u32 *) vlib_frame_vector_args (f) + f->n_vectors;
+ vlib_buffer_copy_indices (to, tmp, n_free);
+ vlib_put_next_frame (vm, node, next_index, 0);
+
+ /* second frame */
+ u32 n_2nd_frame = n_copy - n_free;
+ f = vlib_get_next_frame_internal (vm, node, next_index, 1);
+ tf = vlib_frame_scalar_args (f);
+ /* empty frame - store scalar data */
+ store_tx_frame_scalar_data (copy_frame, tf);
+ to = vlib_frame_vector_args (f);
+ vlib_buffer_copy_indices (to, tmp + n_free, n_2nd_frame);
+ vlib_put_next_frame (vm, node, next_index,
+ VLIB_FRAME_SIZE - n_2nd_frame);
+ }
- if (PREDICT_FALSE (tx_swif2 != rt->sw_if_index))
- {
+ return n_left - n_copy;
+}
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif2, 1,
- n_bytes_b2);
- }
- if (PREDICT_FALSE (tx_swif3 != rt->sw_if_index))
- {
+static_always_inline void
+enqueue_to_tx_node (vlib_main_t *vm, vlib_node_runtime_t *node,
+ vnet_hw_interface_t *hi, u32 next_index,
+ vnet_hw_if_output_node_runtime_t *r, u32 *from, void **p,
+ u32 n_vectors)
+{
+ u32 n_left = n_vectors;
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif3, 1,
- n_bytes_b3);
- }
+ ASSERT (n_vectors <= VLIB_FRAME_SIZE);
- or_flags = b0->flags | b1->flags | b2->flags | b3->flags;
+ /*
+ * backward compatible for drivers not integrated with new tx infra.
+ */
+ if (r == 0)
+ {
+ n_left = enqueue_one_to_tx_node (vm, node, NULL, from, NULL, n_vectors,
+ n_left, next_index);
+ }
+ /*
+ * only 1 tx queue of given interface is available on given thread
+ */
+ else if (r->n_queues == 1)
+ {
+ n_left = enqueue_one_to_tx_node (vm, node, NULL, from, r->frame,
+ n_vectors, n_left, next_index);
+ }
+ /*
+ * multi tx-queues use case
+ */
+ else if (r->n_queues > 1)
+ {
+ u32 qids[VLIB_FRAME_SIZE];
- if (do_tx_offloads)
- {
- if (or_flags &
- (VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
- VNET_BUFFER_F_OFFLOAD_UDP_CKSUM |
- VNET_BUFFER_F_OFFLOAD_IP_CKSUM))
- {
- calc_checksums (vm, b0);
- calc_checksums (vm, b1);
- calc_checksums (vm, b2);
- calc_checksums (vm, b3);
- }
- }
- }
+ hash_func_with_mask (p, qids, n_vectors, r->lookup_table,
+ vec_len (r->lookup_table) - 1, hi->hf);
- while (from + 1 <= from_end && n_left_to_tx >= 1)
+ for (u32 i = 0; i < r->n_queues; i++)
{
- u32 bi0;
- vlib_buffer_t *b0;
- u32 tx_swif0;
+ n_left = enqueue_one_to_tx_node (vm, node, qids, from, &r->frame[i],
+ n_vectors, n_left, next_index);
+ if (n_left == 0)
+ break;
+ }
+ }
+ else
+ ASSERT (0);
+}
- bi0 = from[0];
- to_tx[0] = bi0;
- from += 1;
- to_tx += 1;
- n_left_to_tx -= 1;
+VLIB_NODE_FN (vnet_interface_output_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
+{
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_interface_main_t *im = &vnm->interface_main;
+ vlib_combined_counter_main_t *ccm;
+ vnet_hw_interface_t *hi;
+ vnet_sw_interface_t *si;
+ vnet_interface_output_runtime_t *rt = (void *) node->runtime_data;
+ vnet_hw_if_output_node_runtime_t *r = 0;
+ vlib_buffer_t *bufs[VLIB_FRAME_SIZE];
+ u32 n_bytes, n_buffers = frame->n_vectors;
+ u32 config_index = ~0;
+ u32 sw_if_index = rt->sw_if_index;
+ u32 next_index = VNET_INTERFACE_OUTPUT_NEXT_TX;
+ u32 ti = vm->thread_index;
+ u8 arc = im->output_feature_arc_index;
+ int arc_or_subif = 0;
+ int do_tx_offloads = 0;
+ void *ptr[VLIB_FRAME_SIZE], **p = ptr;
+ u8 is_parr = 0;
+ u32 *from;
- b0 = vlib_get_buffer (vm, bi0);
+ if (node->flags & VLIB_NODE_FLAG_TRACE)
+ vnet_interface_output_trace (vm, node, frame, n_buffers);
- /* Be grumpy about zero length buffers for benefit of
- driver tx function. */
- ASSERT (b0->current_length > 0);
+ from = vlib_frame_vector_args (frame);
- n_bytes_b0 = vlib_buffer_length_in_chain (vm, b0);
- tx_swif0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
- n_bytes += n_bytes_b0;
- n_packets += 1;
+ if (rt->is_deleted)
+ return vlib_error_drop_buffers (
+ vm, node, from,
+ /* buffer stride */ 1, n_buffers, VNET_INTERFACE_OUTPUT_NEXT_DROP,
+ node->node_index, VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DELETED);
- if (PREDICT_FALSE (current_config_index != ~0))
- {
- vnet_buffer (b0)->feature_arc_index = arc;
- b0->current_config_index = current_config_index;
- }
+ vnet_interface_pcap_tx_trace (vm, node, frame, 0 /* in_interface_ouput */);
- if (PREDICT_FALSE (tx_swif0 != rt->sw_if_index))
- {
+ vlib_get_buffers (vm, from, bufs, n_buffers);
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif0, 1,
- n_bytes_b0);
- }
+ si = vnet_get_sw_interface (vnm, sw_if_index);
+ hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
- if (do_tx_offloads)
- calc_checksums (vm, b0);
- }
+ if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ||
+ !(hi->flags & VNET_HW_INTERFACE_FLAG_LINK_UP))
+ {
+ vlib_simple_counter_main_t *cm;
+
+ cm = vec_elt_at_index (vnm->interface_main.sw_if_counters,
+ VNET_INTERFACE_COUNTER_TX_ERROR);
+ vlib_increment_simple_counter (cm, ti, sw_if_index, n_buffers);
- vlib_put_next_frame (vm, node, next_index, n_left_to_tx);
+ return vlib_error_drop_buffers (
+ vm, node, from,
+ /* buffer stride */ 1, n_buffers, VNET_INTERFACE_OUTPUT_NEXT_DROP,
+ node->node_index, VNET_INTERFACE_OUTPUT_ERROR_INTERFACE_DOWN);
}
- /* Update main interface stats. */
- vlib_increment_combined_counter (im->combined_sw_if_counters
- + VNET_INTERFACE_COUNTER_TX,
- thread_index,
- rt->sw_if_index, n_packets, n_bytes);
- return n_buffers;
-}
+ if (hi->output_node_thread_runtimes)
+ r = vec_elt_at_index (hi->output_node_thread_runtimes, vm->thread_index);
-uword
-vnet_interface_output_node (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * frame)
-{
- vnet_main_t *vnm = vnet_get_main ();
- vnet_hw_interface_t *hi;
- vnet_interface_output_runtime_t *rt = (void *) node->runtime_data;
- hi = vnet_get_sup_hw_interface (vnm, rt->sw_if_index);
+ if (r)
+ {
+ /*
+ * tx queue of given interface is not available on given thread
+ */
+ if (r->n_queues == 0)
+ return vlib_error_drop_buffers (
+ vm, node, from,
+ /* buffer stride */ 1, n_buffers, VNET_INTERFACE_OUTPUT_NEXT_DROP,
+ node->node_index, VNET_INTERFACE_OUTPUT_ERROR_NO_TX_QUEUE);
+ /*
+ * multiple tx queues available on given thread
+ */
+ else if (r->n_queues > 1)
+ /* construct array of pointer */
+ is_parr = 1;
+ }
+
+ /* interface-output feature arc handling */
+ if (PREDICT_FALSE (vnet_have_features (arc, sw_if_index)))
+ {
+ vnet_feature_config_main_t *fcm;
+ fcm = vnet_feature_get_config_main (arc);
+ config_index = vnet_get_feature_config_index (arc, sw_if_index);
+ vnet_get_config_data (&fcm->config_main, &config_index, &next_index, 0);
+ arc_or_subif = 1;
+ }
+ else if (hash_elts (hi->sub_interface_sw_if_index_by_id))
+ arc_or_subif = 1;
+
+ ccm = im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX;
+
+ /* if not all three flags IP4_,TCP_,UDP_CKSUM set, do compute them
+ * here before sending to the interface */
+ if ((hi->caps & VNET_HW_IF_CAP_TX_CKSUM) != VNET_HW_IF_CAP_TX_CKSUM)
+ do_tx_offloads = 1;
+
+ // basic processing
+ if (do_tx_offloads == 0 && arc_or_subif == 0 && is_parr == 0)
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, NULL, config_index, arc, n_buffers, 0);
+ // basic processing + tx offloads
+ else if (do_tx_offloads == 1 && arc_or_subif == 0 && is_parr == 0)
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, NULL, config_index, arc, n_buffers, 1);
+ // basic processing + tx offloads + vlans + arcs
+ else if (do_tx_offloads == 1 && arc_or_subif == 1 && is_parr == 0)
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, NULL, config_index, arc, n_buffers, 2);
+ // basic processing + tx offloads + vlans + arcs + multi-txqs
+ else
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, p, config_index, arc, n_buffers, 3);
- if (hi->flags & VNET_HW_INTERFACE_FLAG_SUPPORTS_TX_L4_CKSUM_OFFLOAD)
- return vnet_interface_output_node_inline (vm, node, frame, vnm, hi,
- /* do_tx_offloads */ 0);
+ from = vlib_frame_vector_args (frame);
+ if (PREDICT_TRUE (next_index == VNET_INTERFACE_OUTPUT_NEXT_TX))
+ {
+ enqueue_to_tx_node (vm, node, hi, next_index, r, from, ptr,
+ frame->n_vectors);
+ }
else
- return vnet_interface_output_node_inline (vm, node, frame, vnm, hi,
- /* do_tx_offloads */ 1);
+ {
+ vlib_buffer_enqueue_to_single_next (vm, node, from, next_index,
+ frame->n_vectors);
+ }
+
+ /* Update main interface stats. */
+ vlib_increment_combined_counter (ccm, ti, sw_if_index, n_buffers, n_bytes);
+ return n_buffers;
}
+VLIB_REGISTER_NODE (vnet_interface_output_node) = {
+ .name = "interface-output-template",
+ .vector_size = sizeof (u32),
+};
+
/* Use buffer's sw_if_index[VNET_TX] to choose output interface. */
-static uword
-vnet_per_buffer_interface_output (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+VLIB_NODE_FN (vnet_per_buffer_interface_output_node) (vlib_main_t * vm,
+ vlib_node_runtime_t *
+ node,
+ vlib_frame_t * frame)
{
vnet_main_t *vnm = vnet_get_main ();
u32 n_left_to_next, *from, *to_next;
u32 n_left_from, next_index;
+ vnet_interface_pcap_tx_trace (vm, node, frame, 1 /* in_interface_ouput */);
+
n_left_from = frame->n_vectors;
from = vlib_frame_vector_args (frame);
return frame->n_vectors;
}
-always_inline u32
-counter_index (vlib_main_t * vm, vlib_error_t e)
+typedef struct vnet_error_trace_t_
{
- vlib_node_t *n;
- u32 ci, ni;
-
- ni = vlib_error_get_node (e);
- n = vlib_get_node (vm, ni);
-
- ci = vlib_error_get_code (e);
- ASSERT (ci < n->n_errors);
-
- ci += n->error_heap_index;
-
- return ci;
-}
+ u32 sw_if_index;
+ i8 details_valid;
+ u8 is_ip6;
+ u8 pad[2];
+ u16 mactype;
+ ip46_address_t src, dst;
+} vnet_error_trace_t;
static u8 *
format_vnet_error_trace (u8 * s, va_list * va)
{
- vlib_main_t *vm = va_arg (*va, vlib_main_t *);
+ CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
- vlib_error_t *e = va_arg (*va, vlib_error_t *);
- vlib_node_t *error_node;
- vlib_error_main_t *em = &vm->error_main;
- u32 i;
-
- error_node = vlib_get_node (vm, vlib_error_get_node (e[0]));
- i = counter_index (vm, e[0]);
- s = format (s, "%v: %s", error_node->name, em->error_strings_heap[i]);
+ vnet_error_trace_t *t = va_arg (*va, vnet_error_trace_t *);
+ /* Normal, non-catchup trace */
+ if (t->details_valid == 0)
+ {
+ s = format (s, "rx:%U", format_vnet_sw_if_index_name,
+ vnet_get_main (), t->sw_if_index);
+ }
+ else if (t->details_valid == 1)
+ {
+ /* The trace capture code didn't understant the mactype */
+ s = format (s, "mactype 0x%4x (not decoded)", t->mactype);
+ }
+ else if (t->details_valid == 2)
+ {
+ /* Dump the src/dst addresses */
+ if (t->is_ip6 == 0)
+ s = format (s, "IP4: %U -> %U",
+ format_ip4_address, &t->src.ip4,
+ format_ip4_address, &t->dst.ip4);
+ else
+ s = format (s, "IP6: %U -> %U",
+ format_ip6_address, &t->src.ip6,
+ format_ip6_address, &t->dst.ip6);
+ }
return s;
}
static void
-trace_errors_with_buffers (vlib_main_t * vm,
- vlib_node_runtime_t * node, vlib_frame_t * frame)
+interface_trace_buffers (vlib_main_t * vm,
+ vlib_node_runtime_t * node, vlib_frame_t * frame)
{
u32 n_left, *buffers;
{
u32 bi0, bi1;
vlib_buffer_t *b0, *b1;
- vlib_error_t *t0, *t1;
+ vnet_error_trace_t *t0, *t1;
/* Prefetch next iteration. */
vlib_prefetch_buffer_with_index (vm, buffers[2], LOAD);
if (b0->flags & VLIB_BUFFER_IS_TRACED)
{
- t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
- t0[0] = b0->error;
+ t0 = vlib_add_trace (vm, node, b0,
+ STRUCT_OFFSET_OF (vnet_error_trace_t, pad));
+ t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ t0->details_valid = 0;
}
if (b1->flags & VLIB_BUFFER_IS_TRACED)
{
- t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
- t1[0] = b1->error;
+ t1 = vlib_add_trace (vm, node, b1,
+ STRUCT_OFFSET_OF (vnet_error_trace_t, pad));
+ t1->sw_if_index = vnet_buffer (b1)->sw_if_index[VLIB_RX];
+ t1->details_valid = 0;
}
buffers += 2;
n_left -= 2;
{
u32 bi0;
vlib_buffer_t *b0;
- vlib_error_t *t0;
+ vnet_error_trace_t *t0;
bi0 = buffers[0];
if (b0->flags & VLIB_BUFFER_IS_TRACED)
{
- t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
- t0[0] = b0->error;
+ t0 = vlib_add_trace (vm, node, b0,
+ STRUCT_OFFSET_OF (vnet_error_trace_t, pad));
+ t0->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ t0->details_valid = 0;
}
buffers += 1;
n_left -= 1;
}
}
-static u8 *
-validate_error (vlib_main_t * vm, vlib_error_t * e, u32 index)
-{
- uword node_index = vlib_error_get_node (e[0]);
- uword code = vlib_error_get_code (e[0]);
- vlib_node_t *n;
-
- if (node_index >= vec_len (vm->node_main.nodes))
- return format (0, "[%d], node index out of range 0x%x, error 0x%x",
- index, node_index, e[0]);
-
- n = vlib_get_node (vm, node_index);
- if (code >= n->n_errors)
- return format (0, "[%d], code %d out of range for node %v",
- index, code, n->name);
-
- return 0;
-}
-
-static u8 *
-validate_error_frame (vlib_main_t * vm,
- vlib_node_runtime_t * node, vlib_frame_t * f)
-{
- u32 *buffers = vlib_frame_vector_args (f);
- vlib_buffer_t *b;
- u8 *msg = 0;
- uword i;
-
- for (i = 0; i < f->n_vectors; i++)
- {
- b = vlib_get_buffer (vm, buffers[i]);
- msg = validate_error (vm, &b->error, i);
- if (msg)
- return msg;
- }
-
- return msg;
-}
-
typedef enum
{
VNET_ERROR_DISPOSITION_DROP,
VNET_ERROR_N_DISPOSITION,
} vnet_error_disposition_t;
-always_inline void
-do_packet (vlib_main_t * vm, vlib_error_t a)
+static void
+drop_catchup_trace (vlib_main_t * vm,
+ vlib_node_runtime_t * node, vlib_buffer_t * b)
{
- vlib_error_main_t *em = &vm->error_main;
- u32 i = counter_index (vm, a);
- em->counters[i] += 1;
- vlib_error_elog_count (vm, i, 1);
+ /* Can we safely rewind the buffer? If not, fagedaboudit */
+ if (b->flags & VNET_BUFFER_F_L2_HDR_OFFSET_VALID)
+ {
+ vnet_error_trace_t *t;
+ ip4_header_t *ip4;
+ ip6_header_t *ip6;
+ ethernet_header_t *eh;
+ i16 delta;
+
+ t = vlib_add_trace (vm, node, b, sizeof (*t));
+ delta = vnet_buffer (b)->l2_hdr_offset - b->current_data;
+ vlib_buffer_advance (b, delta);
+
+ eh = vlib_buffer_get_current (b);
+ /* Save mactype */
+ t->mactype = clib_net_to_host_u16 (eh->type);
+ t->details_valid = 1;
+ switch (t->mactype)
+ {
+ case ETHERNET_TYPE_IP4:
+ ip4 = (void *) (eh + 1);
+ t->details_valid = 2;
+ t->is_ip6 = 0;
+ t->src.ip4.as_u32 = ip4->src_address.as_u32;
+ t->dst.ip4.as_u32 = ip4->dst_address.as_u32;
+ break;
+
+ case ETHERNET_TYPE_IP6:
+ ip6 = (void *) (eh + 1);
+ t->details_valid = 2;
+ t->is_ip6 = 1;
+ clib_memcpy_fast (t->src.as_u8, ip6->src_address.as_u8,
+ sizeof (ip6_address_t));
+ clib_memcpy_fast (t->dst.as_u8, ip6->dst_address.as_u8,
+ sizeof (ip6_address_t));
+ break;
+
+ default:
+ /* Dunno, do nothing, leave details_valid alone */
+ break;
+ }
+ /* Restore current data (probably unnecessary) */
+ vlib_buffer_advance (b, -delta);
+ }
}
static_always_inline uword
-process_drop_punt (vlib_main_t * vm,
- vlib_node_runtime_t * node,
- vlib_frame_t * frame, vnet_error_disposition_t disposition)
+interface_drop_punt (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame,
+ vnet_error_disposition_t disposition)
{
- vnet_main_t *vnm = vnet_get_main ();
- vlib_error_main_t *em = &vm->error_main;
- u32 *buffers, *first_buffer;
- vlib_error_t current_error;
- u32 current_counter_index, n_errors_left;
- u32 current_sw_if_index, n_errors_current_sw_if_index;
- u64 current_counter;
+ u32 *from, n_left, thread_index, *sw_if_index;
+ vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
+ u32 sw_if_indices[VLIB_FRAME_SIZE];
vlib_simple_counter_main_t *cm;
- u32 thread_index = vm->thread_index;
-
- static vlib_error_t memory[VNET_ERROR_N_DISPOSITION];
- static char memory_init[VNET_ERROR_N_DISPOSITION];
+ u16 nexts[VLIB_FRAME_SIZE];
+ u32 n_trace;
+ vnet_main_t *vnm;
- buffers = vlib_frame_vector_args (frame);
- first_buffer = buffers;
+ vnm = vnet_get_main ();
+ thread_index = vm->thread_index;
+ from = vlib_frame_vector_args (frame);
+ n_left = frame->n_vectors;
+ b = bufs;
+ sw_if_index = sw_if_indices;
- {
- vlib_buffer_t *b = vlib_get_buffer (vm, first_buffer[0]);
+ vlib_get_buffers (vm, from, bufs, n_left);
- if (!memory_init[disposition])
- {
- memory_init[disposition] = 1;
- memory[disposition] = b->error;
- }
-
- current_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
- n_errors_current_sw_if_index = 0;
- }
+ /* "trace add error-drop NNN?" */
+ if (PREDICT_FALSE ((n_trace = vlib_get_trace_count (vm, node))))
+ {
+ /* If pkts aren't otherwise traced... */
+ if ((node->flags & VLIB_NODE_FLAG_TRACE) == 0)
+ {
+ /* Trace them from here */
+ node->flags |= VLIB_NODE_FLAG_TRACE;
+ while (n_trace && n_left)
+ {
+ if (PREDICT_TRUE
+ (vlib_trace_buffer (vm, node, 0 /* next_index */ , b[0],
+ 0 /* follow chain */ )))
+ {
+ /*
+ * Here we have a wireshark dissector problem.
+ * Packets may be well-formed, or not. We
+ * must not blow chunks in any case.
+ *
+ * Try to produce trace records which will help
+ * folks understand what's going on.
+ */
+ drop_catchup_trace (vm, node, b[0]);
+ n_trace--;
+ }
+ n_left--;
+ b++;
+ }
+ }
- current_error = memory[disposition];
- current_counter_index = counter_index (vm, memory[disposition]);
- current_counter = em->counters[current_counter_index];
+ vlib_set_trace_count (vm, node, n_trace);
+ b = bufs;
+ n_left = frame->n_vectors;
+ }
if (node->flags & VLIB_NODE_FLAG_TRACE)
- trace_errors_with_buffers (vm, node, frame);
+ interface_trace_buffers (vm, node, frame);
+
+ /* All going to drop regardless, this is just a counting exercise */
+ clib_memset (nexts, 0, sizeof (nexts));
- n_errors_left = frame->n_vectors;
cm = vec_elt_at_index (vnm->interface_main.sw_if_counters,
(disposition == VNET_ERROR_DISPOSITION_PUNT
? VNET_INTERFACE_COUNTER_PUNT
: VNET_INTERFACE_COUNTER_DROP));
- while (n_errors_left >= 2)
+ /* collect the array of interfaces first ... */
+ while (n_left >= 4)
{
- vlib_buffer_t *b0, *b1;
- vnet_sw_interface_t *sw_if0, *sw_if1;
- vlib_error_t e0, e1;
- u32 bi0, bi1;
- u32 sw_if_index0, sw_if_index1;
-
- bi0 = buffers[0];
- bi1 = buffers[1];
-
- buffers += 2;
- n_errors_left -= 2;
-
- b0 = vlib_get_buffer (vm, bi0);
- b1 = vlib_get_buffer (vm, bi1);
-
- e0 = b0->error;
- e1 = b1->error;
-
- sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
- sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
-
- /* Speculate that sw_if_index == sw_if_index[01]. */
- n_errors_current_sw_if_index += 2;
-
- /* Speculatively assume all 2 (node, code) pairs are equal
- to current (node, code). */
- current_counter += 2;
-
- if (PREDICT_FALSE (e0 != current_error
- || e1 != current_error
- || sw_if_index0 != current_sw_if_index
- || sw_if_index1 != current_sw_if_index))
+ if (n_left >= 12)
{
- current_counter -= 2;
- n_errors_current_sw_if_index -= 2;
-
- vlib_increment_simple_counter (cm, thread_index, sw_if_index0, 1);
- vlib_increment_simple_counter (cm, thread_index, sw_if_index1, 1);
-
- /* Increment super-interface drop/punt counters for
- sub-interfaces. */
- sw_if0 = vnet_get_sw_interface (vnm, sw_if_index0);
- vlib_increment_simple_counter
- (cm, thread_index, sw_if0->sup_sw_if_index,
- sw_if0->sup_sw_if_index != sw_if_index0);
-
- sw_if1 = vnet_get_sw_interface (vnm, sw_if_index1);
- vlib_increment_simple_counter
- (cm, thread_index, sw_if1->sup_sw_if_index,
- sw_if1->sup_sw_if_index != sw_if_index1);
-
- em->counters[current_counter_index] = current_counter;
- do_packet (vm, e0);
- do_packet (vm, e1);
-
- /* For 2 repeated errors, change current error. */
- if (e0 == e1 && e1 != current_error)
- {
- current_error = e0;
- current_counter_index = counter_index (vm, e0);
- }
- current_counter = em->counters[current_counter_index];
+ /* Prefetch 8 ahead - there's not much going on in each iteration */
+ vlib_prefetch_buffer_header (b[4], LOAD);
+ vlib_prefetch_buffer_header (b[5], LOAD);
+ vlib_prefetch_buffer_header (b[6], LOAD);
+ vlib_prefetch_buffer_header (b[7], LOAD);
}
+ sw_if_index[0] = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
+ sw_if_index[1] = vnet_buffer (b[1])->sw_if_index[VLIB_RX];
+ sw_if_index[2] = vnet_buffer (b[2])->sw_if_index[VLIB_RX];
+ sw_if_index[3] = vnet_buffer (b[3])->sw_if_index[VLIB_RX];
+
+ sw_if_index += 4;
+ n_left -= 4;
+ b += 4;
}
-
- while (n_errors_left >= 1)
+ while (n_left)
{
- vlib_buffer_t *b0;
- vnet_sw_interface_t *sw_if0;
- vlib_error_t e0;
- u32 bi0, sw_if_index0;
-
- bi0 = buffers[0];
-
- buffers += 1;
- n_errors_left -= 1;
- current_counter += 1;
-
- b0 = vlib_get_buffer (vm, bi0);
- e0 = b0->error;
-
- sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
-
- /* Increment drop/punt counters. */
- vlib_increment_simple_counter (cm, thread_index, sw_if_index0, 1);
-
- /* Increment super-interface drop/punt counters for sub-interfaces. */
- sw_if0 = vnet_get_sw_interface (vnm, sw_if_index0);
- vlib_increment_simple_counter (cm, thread_index,
- sw_if0->sup_sw_if_index,
- sw_if0->sup_sw_if_index != sw_if_index0);
-
- if (PREDICT_FALSE (e0 != current_error))
- {
- current_counter -= 1;
-
- vlib_error_elog_count (vm, current_counter_index,
- (current_counter
- - em->counters[current_counter_index]));
+ sw_if_index[0] = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
- em->counters[current_counter_index] = current_counter;
-
- do_packet (vm, e0);
- current_error = e0;
- current_counter_index = counter_index (vm, e0);
- current_counter = em->counters[current_counter_index];
- }
+ sw_if_index += 1;
+ n_left -= 1;
+ b += 1;
}
- if (n_errors_current_sw_if_index > 0)
- {
- vnet_sw_interface_t *si;
-
- vlib_increment_simple_counter (cm, thread_index, current_sw_if_index,
- n_errors_current_sw_if_index);
+ /* ... then count against them in blocks */
+ n_left = frame->n_vectors;
- si = vnet_get_sw_interface (vnm, current_sw_if_index);
- if (si->sup_sw_if_index != current_sw_if_index)
- vlib_increment_simple_counter (cm, thread_index, si->sup_sw_if_index,
- n_errors_current_sw_if_index);
- }
+ while (n_left)
+ {
+ vnet_sw_interface_t *sw_if0;
+ u16 off, count;
- vlib_error_elog_count (vm, current_counter_index,
- (current_counter
- - em->counters[current_counter_index]));
+ off = frame->n_vectors - n_left;
- /* Return cached counter. */
- em->counters[current_counter_index] = current_counter;
+ sw_if_index = sw_if_indices + off;
- /* Save memory for next iteration. */
- memory[disposition] = current_error;
+ count = clib_count_equal_u32 (sw_if_index, n_left);
+ n_left -= count;
- if (disposition == VNET_ERROR_DISPOSITION_DROP || !vm->os_punt_frame)
- {
- vlib_buffer_free (vm, first_buffer, frame->n_vectors);
+ vlib_increment_simple_counter (cm, thread_index, sw_if_index[0], count);
- /* If there is no punt function, free the frame as well. */
- if (disposition == VNET_ERROR_DISPOSITION_PUNT && !vm->os_punt_frame)
- vlib_frame_free (vm, node, frame);
+ /* Increment super-interface drop/punt counters for
+ sub-interfaces. */
+ sw_if0 = vnet_get_sw_interface (vnm, sw_if_index[0]);
+ if (sw_if0->sup_sw_if_index != sw_if_index[0])
+ vlib_increment_simple_counter
+ (cm, thread_index, sw_if0->sup_sw_if_index, count);
}
- else
- vm->os_punt_frame (vm, node, frame);
+
+ vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
return frame->n_vectors;
}
static inline void
pcap_drop_trace (vlib_main_t * vm,
- vnet_interface_main_t * im, vlib_frame_t * f)
+ vnet_interface_main_t * im,
+ vnet_pcap_t * pp, vlib_frame_t * f)
{
u32 *from;
u32 n_left = f->n_vectors;
u32 bi0;
i16 save_current_data;
u16 save_current_length;
+ vlib_error_main_t *em = &vm->error_main;
from = vlib_frame_vector_args (f);
&& hash_get (im->pcap_drop_filter_hash, b0->error))
continue;
+ if (!vnet_is_packet_pcaped (pp, b0, ~0))
+ continue; /* not matching, skip */
+
/* Trace all drops, or drops received on a specific interface */
- if (im->pcap_sw_if_index == 0 ||
- im->pcap_sw_if_index == vnet_buffer (b0)->sw_if_index[VLIB_RX])
+ save_current_data = b0->current_data;
+ save_current_length = b0->current_length;
+
+ /*
+ * Typically, we'll need to rewind the buffer
+ * if l2_hdr_offset is valid, make sure to rewind to the start of
+ * the L2 header. This may not be the buffer start in case we pop-ed
+ * vlan tags.
+ * Otherwise, rewind to buffer start and hope for the best.
+ */
+ if (b0->flags & VNET_BUFFER_F_L2_HDR_OFFSET_VALID)
+ {
+ if (b0->current_data > vnet_buffer (b0)->l2_hdr_offset)
+ vlib_buffer_advance (b0, vnet_buffer (b0)->l2_hdr_offset -
+ b0->current_data);
+ }
+ else if (b0->current_data > 0)
{
- save_current_data = b0->current_data;
- save_current_length = b0->current_length;
+ vlib_buffer_advance (b0, (word) -b0->current_data);
+ }
- /*
- * Typically, we'll need to rewind the buffer
- */
- if (b0->current_data > 0)
- vlib_buffer_advance (b0, (word) - b0->current_data);
+ {
+ vlib_buffer_t *last = b0;
+ u32 error_node_index;
+ int drop_string_len;
+ vlib_node_t *n;
+ /* Length of the error string */
+ int error_string_len =
+ clib_strnlen (em->counters_heap[b0->error].name, 128);
+
+ /* Dig up the drop node */
+ error_node_index = vm->node_main.node_by_error[b0->error];
+ n = vlib_get_node (vm, error_node_index);
+
+ /* Length of full drop string, w/ "nodename: " prepended */
+ drop_string_len = error_string_len + vec_len (n->name) + 2;
+
+ /* Find the last buffer in the chain */
+ while (last->flags & VLIB_BUFFER_NEXT_PRESENT)
+ last = vlib_get_buffer (vm, last->next_buffer);
+
+ /*
+ * Append <nodename>: <error-string> to the capture,
+ * only if we can do that without allocating a new buffer.
+ */
+ if (PREDICT_TRUE ((last->current_data + last->current_length) <
+ (VLIB_BUFFER_DEFAULT_DATA_SIZE - drop_string_len)))
+ {
+ clib_memcpy_fast (last->data + last->current_data +
+ last->current_length,
+ n->name, vec_len (n->name));
+ clib_memcpy_fast (last->data + last->current_data +
+ last->current_length + vec_len (n->name),
+ ": ", 2);
+ clib_memcpy_fast (last->data + last->current_data +
+ last->current_length + vec_len (n->name) + 2,
+ em->counters_heap[b0->error].name,
+ error_string_len);
+ last->current_length += drop_string_len;
+ b0->flags &= ~(VLIB_BUFFER_TOTAL_LENGTH_VALID);
+ pcap_add_buffer (&pp->pcap_main, vm, bi0, pp->max_bytes_per_pkt);
+ last->current_length -= drop_string_len;
+ b0->current_data = save_current_data;
+ b0->current_length = save_current_length;
+ continue;
+ }
+ }
- pcap_add_buffer (&im->pcap_main, vm, bi0, 512);
+ /*
+ * Didn't have space in the last buffer, here's the dropped
+ * packet as-is
+ */
+ pcap_add_buffer (&pp->pcap_main, vm, bi0, pp->max_bytes_per_pkt);
- b0->current_data = save_current_data;
- b0->current_length = save_current_length;
- }
+ b0->current_data = save_current_data;
+ b0->current_length = save_current_length;
}
}
+#ifndef CLIB_MARCH_VARIANT
void
vnet_pcap_drop_trace_filter_add_del (u32 error_index, int is_add)
{
else
hash_unset (im->pcap_drop_filter_hash, error_index);
}
+#endif /* CLIB_MARCH_VARIANT */
-static uword
-process_drop (vlib_main_t * vm,
- vlib_node_runtime_t * node, vlib_frame_t * frame)
+VLIB_NODE_FN (interface_drop) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
{
+ vnet_main_t *vnm = vnet_get_main ();
vnet_interface_main_t *im = &vnet_get_main ()->interface_main;
+ vnet_pcap_t *pp = &vnm->pcap;
- if (PREDICT_FALSE (im->drop_pcap_enable))
- pcap_drop_trace (vm, im, frame);
+ if (PREDICT_FALSE (pp->pcap_drop_enable))
+ pcap_drop_trace (vm, im, pp, frame);
- return process_drop_punt (vm, node, frame, VNET_ERROR_DISPOSITION_DROP);
+ return interface_drop_punt (vm, node, frame, VNET_ERROR_DISPOSITION_DROP);
}
-static uword
-process_punt (vlib_main_t * vm,
- vlib_node_runtime_t * node, vlib_frame_t * frame)
+VLIB_NODE_FN (interface_punt) (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
{
- return process_drop_punt (vm, node, frame, VNET_ERROR_DISPOSITION_PUNT);
+ return interface_drop_punt (vm, node, frame, VNET_ERROR_DISPOSITION_PUNT);
}
-/* *INDENT-OFF* */
-VLIB_REGISTER_NODE (drop_buffers,static) = {
- .function = process_drop,
+VLIB_REGISTER_NODE (interface_drop) = {
.name = "error-drop",
- .flags = VLIB_NODE_FLAG_IS_DROP,
.vector_size = sizeof (u32),
.format_trace = format_vnet_error_trace,
- .validate_frame = validate_error_frame,
+ .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
+ .n_next_nodes = 1,
+ .next_nodes = {
+ [0] = "drop",
+ },
};
-/* *INDENT-ON* */
-
-VLIB_NODE_FUNCTION_MULTIARCH (drop_buffers, process_drop);
-/* *INDENT-OFF* */
-VLIB_REGISTER_NODE (punt_buffers,static) = {
- .function = process_punt,
- .flags = (VLIB_NODE_FLAG_FRAME_NO_FREE_AFTER_DISPATCH
- | VLIB_NODE_FLAG_IS_PUNT),
+VLIB_REGISTER_NODE (interface_punt) = {
.name = "error-punt",
.vector_size = sizeof (u32),
.format_trace = format_vnet_error_trace,
- .validate_frame = validate_error_frame,
+ .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
+ .n_next_nodes = 1,
+ .next_nodes = {
+ [0] = "punt",
+ },
};
-/* *INDENT-ON* */
-VLIB_NODE_FUNCTION_MULTIARCH (punt_buffers, process_punt);
-
-/* *INDENT-OFF* */
-VLIB_REGISTER_NODE (vnet_per_buffer_interface_output_node,static) = {
- .function = vnet_per_buffer_interface_output,
+VLIB_REGISTER_NODE (vnet_per_buffer_interface_output_node) = {
.name = "interface-output",
.vector_size = sizeof (u32),
};
-/* *INDENT-ON* */
-/* Convenience node to drop a vector of buffers with a "misc error". */
-static uword
-misc_drop_buffers (vlib_main_t * vm,
- vlib_node_runtime_t * node, vlib_frame_t * frame)
+VLIB_NODE_FN (vnet_interface_output_arc_end_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
{
- return vlib_error_drop_buffers (vm, node, vlib_frame_vector_args (frame),
- /* buffer stride */ 1,
- frame->n_vectors,
- /* next */ 0,
- node->node_index,
- /* error */ 0);
-}
-
-static char *misc_drop_buffers_error_strings[] = {
- [0] = "misc. errors",
-};
-
-/* *INDENT-OFF* */
-VLIB_REGISTER_NODE (misc_drop_buffers_node,static) = {
- .function = misc_drop_buffers,
- .name = "misc-drop-buffers",
- .vector_size = sizeof (u32),
- .n_errors = 1,
- .n_next_nodes = 1,
- .next_nodes = {
- "error-drop",
- },
- .error_strings = misc_drop_buffers_error_strings,
-};
-/* *INDENT-ON* */
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_interface_main_t *im = &vnm->interface_main;
+ vnet_hw_interface_t *hi;
+ vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
+ u32 sw_if_indices[VLIB_FRAME_SIZE], *sw_if_index = sw_if_indices;
+ vlib_frame_bitmap_t used_elts = {}, mask = {};
+ u32 *tmp, *from, n_left, n_comp, n_p_comp, swif, off;
+ u16 next_index;
+ void *ptr[VLIB_FRAME_SIZE], **p = ptr;
-VLIB_NODE_FUNCTION_MULTIARCH (vnet_per_buffer_interface_output_node,
- vnet_per_buffer_interface_output);
+ from = vlib_frame_vector_args (frame);
+ n_left = frame->n_vectors;
+ vlib_get_buffers (vm, from, bufs, n_left);
-static uword
-interface_tx_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
-{
- vnet_main_t *vnm = vnet_get_main ();
- u32 last_sw_if_index = ~0;
- vlib_frame_t *to_frame = 0;
- vnet_hw_interface_t *hw = 0;
- u32 *from, *to_next = 0;
- u32 n_left_from;
-
- from = vlib_frame_vector_args (from_frame);
- n_left_from = from_frame->n_vectors;
- while (n_left_from > 0)
+ while (n_left >= 8)
{
- u32 bi0;
- vlib_buffer_t *b0;
- u32 sw_if_index0;
+ vlib_prefetch_buffer_header (b[4], LOAD);
+ vlib_prefetch_buffer_header (b[5], LOAD);
+ vlib_prefetch_buffer_header (b[6], LOAD);
+ vlib_prefetch_buffer_header (b[7], LOAD);
+
+ p[0] = vlib_buffer_get_current (b[0]);
+ p[1] = vlib_buffer_get_current (b[1]);
+ p[2] = vlib_buffer_get_current (b[2]);
+ p[3] = vlib_buffer_get_current (b[3]);
+ sw_if_index[0] = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
+ sw_if_index[1] = vnet_buffer (b[1])->sw_if_index[VLIB_TX];
+ sw_if_index[2] = vnet_buffer (b[2])->sw_if_index[VLIB_TX];
+ sw_if_index[3] = vnet_buffer (b[3])->sw_if_index[VLIB_TX];
+
+ p += 4;
+ b += 4;
+ sw_if_index += 4;
+ n_left -= 4;
+ }
- bi0 = from[0];
- from++;
- n_left_from--;
- b0 = vlib_get_buffer (vm, bi0);
- sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
+ while (n_left)
+ {
+ p[0] = vlib_buffer_get_current (b[0]);
+ sw_if_index[0] = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
+ p++;
+ b++;
+ sw_if_index++;
+ n_left--;
+ }
- if (PREDICT_FALSE ((last_sw_if_index != sw_if_index0) || to_frame == 0))
+ n_left = frame->n_vectors;
+ swif = sw_if_indices[0];
+ off = 0;
+
+ /* a bit ugly but it allows us to reuse stack space for temporary store
+ * which may also improve memory latency */
+ tmp = (u32 *) bufs;
+
+more:
+ next_index = vec_elt (im->if_out_arc_end_next_index_by_sw_if_index, swif);
+ hi = vnet_get_sup_hw_interface (vnm, swif);
+ vnet_hw_if_output_node_runtime_t *r = 0;
+ void *ptr_tmp[VLIB_FRAME_SIZE], **p_tmp = ptr_tmp;
+
+ if (hi->output_node_thread_runtimes)
+ r = vec_elt_at_index (hi->output_node_thread_runtimes, vm->thread_index);
+
+ /* compare and compress based on comparison mask */
+ clib_mask_compare_u32 (swif, sw_if_indices, mask, frame->n_vectors);
+ n_comp = clib_compress_u32 (tmp, from, mask, frame->n_vectors);
+
+ /*
+ * tx queue of given interface is not available on given thread
+ */
+ if (r)
+ {
+ if (r->n_queues == 0)
{
- if (to_frame)
- {
- hw = vnet_get_sup_hw_interface (vnm, last_sw_if_index);
- vlib_put_frame_to_node (vm, hw->tx_node_index, to_frame);
- }
- last_sw_if_index = sw_if_index0;
- hw = vnet_get_sup_hw_interface (vnm, sw_if_index0);
- to_frame = vlib_get_frame_to_node (vm, hw->tx_node_index);
- to_next = vlib_frame_vector_args (to_frame);
+ vlib_error_drop_buffers (
+ vm, node, tmp,
+ /* buffer stride */ 1, n_comp, VNET_INTERFACE_OUTPUT_NEXT_DROP,
+ node->node_index, VNET_INTERFACE_OUTPUT_ERROR_NO_TX_QUEUE);
+ goto drop;
+ }
+ else if (r->n_queues > 1)
+ {
+ n_p_comp = clib_compress_u64 ((u64 *) p_tmp, (u64 *) ptr, mask,
+ frame->n_vectors);
+ ASSERT (n_p_comp == n_comp);
}
+ }
+
+ enqueue_to_tx_node (vm, node, hi, next_index, r, tmp, ptr_tmp, n_comp);
+
+drop:
+ n_left -= n_comp;
+ if (n_left)
+ {
+ /* store comparison mask so we can find next unused element */
+ vlib_frame_bitmap_or (used_elts, mask);
+
+ /* fine first unused sw_if_index by scanning trough used_elts bitmap */
+ while (PREDICT_FALSE (used_elts[off] == ~0))
+ off++;
- to_next[0] = bi0;
- to_next++;
- to_frame->n_vectors++;
+ swif =
+ sw_if_indices[(off << 6) + count_trailing_zeros (~used_elts[off])];
+ goto more;
}
- vlib_put_frame_to_node (vm, hw->tx_node_index, to_frame);
- return from_frame->n_vectors;
+
+ return frame->n_vectors;
}
-/* *INDENT-OFF* */
-VLIB_REGISTER_NODE (interface_tx, static) = {
- .function = interface_tx_node_fn,
- .name = "interface-tx",
+VLIB_REGISTER_NODE (vnet_interface_output_arc_end_node) = {
+ .name = "interface-output-arc-end",
.vector_size = sizeof (u32),
.n_next_nodes = 1,
.next_nodes = {
},
};
-VNET_FEATURE_ARC_INIT (interface_output, static) =
-{
- .arc_name = "interface-output",
+VNET_FEATURE_ARC_INIT (interface_output, static) = {
+ .arc_name = "interface-output",
.start_nodes = VNET_FEATURES (0),
- .last_in_arc = "interface-tx",
+ .last_in_arc = "interface-output-arc-end",
.arc_index_ptr = &vnet_main.interface_main.output_feature_arc_index,
};
VNET_FEATURE_INIT (span_tx, static) = {
.arc_name = "interface-output",
.node_name = "span-output",
- .runs_before = VNET_FEATURES ("interface-tx"),
+ .runs_before = VNET_FEATURES ("interface-output-arc-end"),
};
VNET_FEATURE_INIT (ipsec_if_tx, static) = {
.arc_name = "interface-output",
.node_name = "ipsec-if-output",
- .runs_before = VNET_FEATURES ("interface-tx"),
+ .runs_before = VNET_FEATURES ("interface-output-arc-end"),
};
-VNET_FEATURE_INIT (interface_tx, static) = {
+VNET_FEATURE_INIT (interface_output_arc_end, static) = {
.arc_name = "interface-output",
- .node_name = "interface-tx",
+ .node_name = "interface-output-arc-end",
.runs_before = 0,
};
-/* *INDENT-ON* */
+#ifndef CLIB_MARCH_VARIANT
clib_error_t *
vnet_per_buffer_interface_output_hw_interface_add_del (vnet_main_t * vnm,
u32 hw_if_index,
hi->output_node_next_index = next_index;
hi->output_node_index = node_index;
}
-
-static clib_error_t *
-pcap_drop_trace_command_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;
- u8 *filename;
- u32 max;
- int matched = 0;
- clib_error_t *error = 0;
-
- while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
- {
- if (unformat (input, "on"))
- {
- if (im->drop_pcap_enable == 0)
- {
- if (im->pcap_filename == 0)
- im->pcap_filename = format (0, "/tmp/drop.pcap%c", 0);
-
- clib_memset (&im->pcap_main, 0, sizeof (im->pcap_main));
- im->pcap_main.file_name = (char *) im->pcap_filename;
- im->pcap_main.n_packets_to_capture = 100;
- if (im->pcap_pkts_to_capture)
- im->pcap_main.n_packets_to_capture = im->pcap_pkts_to_capture;
-
- im->pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet;
- im->drop_pcap_enable = 1;
- matched = 1;
- vlib_cli_output (vm, "pcap drop capture on...");
- }
- else
- {
- vlib_cli_output (vm, "pcap drop capture already on...");
- }
- matched = 1;
- }
- else if (unformat (input, "off"))
- {
- matched = 1;
-
- if (im->drop_pcap_enable)
- {
- vlib_cli_output (vm, "captured %d pkts...",
- im->pcap_main.n_packets_captured);
- if (im->pcap_main.n_packets_captured)
- {
- im->pcap_main.n_packets_to_capture =
- im->pcap_main.n_packets_captured;
- error = pcap_write (&im->pcap_main);
- if (error)
- clib_error_report (error);
- else
- vlib_cli_output (vm, "saved to %s...", im->pcap_filename);
- }
- }
- else
- {
- vlib_cli_output (vm, "pcap drop capture already off...");
- }
-
- im->drop_pcap_enable = 0;
- }
- else if (unformat (input, "max %d", &max))
- {
- im->pcap_pkts_to_capture = max;
- matched = 1;
- }
-
- else if (unformat (input, "intfc %U",
- unformat_vnet_sw_interface, vnm,
- &im->pcap_sw_if_index))
- matched = 1;
- else if (unformat (input, "intfc any"))
- {
- im->pcap_sw_if_index = 0;
- matched = 1;
- }
- else if (unformat (input, "file %s", &filename))
- {
- u8 *chroot_filename;
- /* Brain-police user path input */
- if (strstr ((char *) filename, "..")
- || index ((char *) filename, '/'))
- {
- vlib_cli_output (vm, "illegal characters in filename '%s'",
- filename);
- continue;
- }
-
- chroot_filename = format (0, "/tmp/%s%c", filename, 0);
- vec_free (filename);
-
- if (im->pcap_filename)
- vec_free (im->pcap_filename);
- im->pcap_filename = chroot_filename;
- im->pcap_main.file_name = (char *) im->pcap_filename;
- matched = 1;
- }
- else if (unformat (input, "status"))
- {
- if (im->drop_pcap_enable == 0)
- {
- vlib_cli_output (vm, "pcap drop capture is off...");
- continue;
- }
-
- vlib_cli_output (vm, "pcap drop capture: %d of %d pkts...",
- im->pcap_main.n_packets_captured,
- im->pcap_main.n_packets_to_capture);
- matched = 1;
- }
-
- else
- break;
- }
-
- if (matched == 0)
- return clib_error_return (0, "unknown input `%U'",
- format_unformat_error, input);
-
- return 0;
-}
-
-/* *INDENT-OFF* */
-VLIB_CLI_COMMAND (pcap_trace_command, static) = {
- .path = "pcap drop trace",
- .short_help =
- "pcap drop trace on off max <nn> intfc <intfc> file <name> status",
- .function = pcap_drop_trace_command_fn,
-};
-/* *INDENT-ON* */
+#endif /* CLIB_MARCH_VARIANT */
/*
* fd.io coding-style-patch-verification: ON