#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>
}
return s;
}
+#endif /* CLIB_MARCH_VARIANT */
static void
vnet_interface_output_trace (vlib_main_t * vm,
}
}
-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_output_handle_offload (vlib_main_t *vm, vlib_buffer_t *b)
{
- 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;
- vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
-
- n_buffers = frame->n_vectors;
-
- if (node->flags & VLIB_NODE_FLAG_TRACE)
- vnet_interface_output_trace (vm, node, frame, n_buffers);
-
- from = vlib_frame_vector_args (frame);
- vlib_get_buffers (vm, from, b, n_buffers);
-
- 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) ||
- !(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, 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);
- }
-
- from_end = from + n_buffers;
-
- /* Total byte count of all buffers. */
- n_bytes = 0;
- n_packets = 0;
+ if (b->flags & VNET_BUFFER_F_OFFLOAD)
+ vnet_calc_checksums_inline (vm, b, b->flags & VNET_BUFFER_F_IS_IP4,
+ b->flags & VNET_BUFFER_F_IS_IP6);
+}
- /* interface-output feature arc handling */
- if (PREDICT_FALSE (vnet_have_features (arc, rt->sw_if_index)))
- {
- 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);
- }
+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, u32 config_index, u8 arc,
+ u32 n_left, int do_tx_offloads)
+{
+ u32 n_bytes = 0;
+ u32 n_bytes0, n_bytes1, n_bytes2, n_bytes3;
+ u32 ti = vm->thread_index;
- while (from < from_end)
+ while (n_left >= 8)
{
- /* 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);
-
- while (from + 8 <= from_end && n_left_to_tx >= 4)
- {
- u32 bi0, bi1, bi2, bi3;
- u32 tx_swif0, tx_swif1, tx_swif2, tx_swif3;
- u32 or_flags;
+ u32 tx_swif0, tx_swif1, tx_swif2, tx_swif3;
+ u32 or_flags;
- /* 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);
+ /* 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);
- 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;
-
- or_flags = b[0]->flags | b[1]->flags | b[2]->flags | b[3]->flags;
-
- from += 4;
- to_tx += 4;
- n_left_to_tx -= 4;
-
- /* 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_b0 = vlib_buffer_length_in_chain (vm, b[0]);
- n_bytes_b1 = vlib_buffer_length_in_chain (vm, b[1]);
- n_bytes_b2 = vlib_buffer_length_in_chain (vm, b[2]);
- n_bytes_b3 = vlib_buffer_length_in_chain (vm, b[3]);
- 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];
-
- 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 (b[0])->feature_arc_index = arc;
- vnet_buffer (b[1])->feature_arc_index = arc;
- vnet_buffer (b[2])->feature_arc_index = arc;
- vnet_buffer (b[3])->feature_arc_index = arc;
- b[0]->current_config_index = current_config_index;
- b[1]->current_config_index = current_config_index;
- b[2]->current_config_index = current_config_index;
- b[3]->current_config_index = current_config_index;
- }
+ or_flags = b[0]->flags | b[1]->flags | b[2]->flags | b[3]->flags;
- /* 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);
- }
+ /* 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);
- if (PREDICT_FALSE (tx_swif1 != rt->sw_if_index))
- {
+ 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]);
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif1, 1,
- n_bytes_b1);
- }
+ 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];
- if (PREDICT_FALSE (tx_swif2 != rt->sw_if_index))
- {
+ /* 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);
- 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))
- {
+ if (PREDICT_FALSE (tx_swif1 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif1, 1, n_bytes1);
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif3, 1,
- n_bytes_b3);
- }
+ if (PREDICT_FALSE (tx_swif2 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif2, 1, n_bytes2);
- if (do_tx_offloads)
- {
- u32 vnet_buffer_offload_flags =
- (VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
- VNET_BUFFER_F_OFFLOAD_UDP_CKSUM |
- VNET_BUFFER_F_OFFLOAD_IP_CKSUM);
- if (or_flags & vnet_buffer_offload_flags)
- {
- if (b[0]->flags & vnet_buffer_offload_flags)
- vnet_calc_checksums_inline
- (vm, b[0],
- b[0]->flags & VNET_BUFFER_F_IS_IP4,
- b[0]->flags & VNET_BUFFER_F_IS_IP6);
- if (b[1]->flags & vnet_buffer_offload_flags)
- vnet_calc_checksums_inline
- (vm, b[1],
- b[1]->flags & VNET_BUFFER_F_IS_IP4,
- b[1]->flags & VNET_BUFFER_F_IS_IP6);
- if (b[2]->flags & vnet_buffer_offload_flags)
- vnet_calc_checksums_inline
- (vm, b[2],
- b[2]->flags & VNET_BUFFER_F_IS_IP4,
- b[2]->flags & VNET_BUFFER_F_IS_IP6);
- if (b[3]->flags & vnet_buffer_offload_flags)
- vnet_calc_checksums_inline
- (vm, b[3],
- b[3]->flags & VNET_BUFFER_F_IS_IP4,
- b[3]->flags & VNET_BUFFER_F_IS_IP6);
- }
- }
- b += 4;
+ 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;
}
- while (from + 1 <= from_end && n_left_to_tx >= 1)
+ if (do_tx_offloads && (or_flags & VNET_BUFFER_F_OFFLOAD))
{
- u32 bi0;
- u32 tx_swif0;
+ 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]);
+ }
- bi0 = from[0];
- to_tx[0] = bi0;
- from += 1;
- to_tx += 1;
- n_left_to_tx -= 1;
+ n_left -= 4;
+ b += 4;
+ }
- /* Be grumpy about zero length buffers for benefit of
- driver tx function. */
- ASSERT (b[0]->current_length > 0);
+ while (n_left)
+ {
+ u32 tx_swif0;
- n_bytes_b0 = vlib_buffer_length_in_chain (vm, b[0]);
- tx_swif0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
- n_bytes += n_bytes_b0;
- n_packets += 1;
+ /* Be grumpy about zero length buffers for benefit of
+ driver tx function. */
+ ASSERT (b[0]->current_length > 0);
- if (PREDICT_FALSE (current_config_index != ~0))
- {
- vnet_buffer (b[0])->feature_arc_index = arc;
- b[0]->current_config_index = current_config_index;
- }
+ n_bytes += n_bytes0 = vlib_buffer_length_in_chain (vm, b[0]);
+ tx_swif0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
- if (PREDICT_FALSE (tx_swif0 != rt->sw_if_index))
- {
+ if (PREDICT_FALSE (config_index != ~0))
+ {
+ vnet_buffer (b[0])->feature_arc_index = arc;
+ b[0]->current_config_index = config_index;
+ }
- vlib_increment_combined_counter (im->combined_sw_if_counters +
- VNET_INTERFACE_COUNTER_TX,
- thread_index, tx_swif0, 1,
- n_bytes_b0);
- }
+ if (PREDICT_FALSE (tx_swif0 != sw_if_index))
+ vlib_increment_combined_counter (ccm, ti, tx_swif0, 1, n_bytes0);
- if (do_tx_offloads)
- {
- if (b[0]->flags &
- (VNET_BUFFER_F_OFFLOAD_TCP_CKSUM |
- VNET_BUFFER_F_OFFLOAD_UDP_CKSUM |
- VNET_BUFFER_F_OFFLOAD_IP_CKSUM))
- vnet_calc_checksums_inline
- (vm, b[0],
- b[0]->flags & VNET_BUFFER_F_IS_IP4,
- b[0]->flags & VNET_BUFFER_F_IS_IP6);
- }
- b += 1;
- }
+ if (do_tx_offloads)
+ vnet_interface_output_handle_offload (vm, b[0]);
- vlib_put_next_frame (vm, node, next_index, n_left_to_tx);
+ n_left -= 1;
+ b += 1;
}
- /* 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;
+ return n_bytes;
}
-#endif /* CLIB_MARCH_VARIANT */
static_always_inline void vnet_interface_pcap_tx_trace
(vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame,
int sw_if_index_from_buffer)
{
+ vnet_main_t *vnm = vnet_get_main ();
u32 n_left_from, *from;
u32 sw_if_index;
- vnet_pcap_t *pp = &vlib_global_main.pcap;
+ vnet_pcap_t *pp = &vnm->pcap;
if (PREDICT_TRUE (pp->pcap_tx_enable == 0))
return;
}
}
-#ifndef CLIB_MARCH_VARIANT
-
-uword
-vnet_interface_output_node (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * frame)
+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;
- hi = vnet_get_sup_hw_interface (vnm, rt->sw_if_index);
+ 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;
+ u32 *from;
+
+ if (node->flags & VLIB_NODE_FLAG_TRACE)
+ vnet_interface_output_trace (vm, node, frame, n_buffers);
+
+ 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);
vnet_interface_pcap_tx_trace (vm, node, frame,
0 /* sw_if_index_from_buffer */ );
- 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);
+ vlib_get_buffers (vm, from, bufs, n_buffers);
+
+ si = vnet_get_sw_interface (vnm, sw_if_index);
+ hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
+
+ 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);
+
+ 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);
+ }
+
+ /* 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);
+ }
+
+ ccm = im->combined_sw_if_counters + VNET_INTERFACE_COUNTER_TX;
+
+ if (hi->caps & VNET_HW_INTERFACE_CAP_SUPPORTS_TX_CKSUM)
+ n_bytes = vnet_interface_output_node_inline (vm, sw_if_index, ccm, bufs,
+ config_index, arc, n_buffers,
+ /* do_tx_offloads */ 0);
else
- return vnet_interface_output_node_inline (vm, node, frame, vnm, hi,
- /* do_tx_offloads */ 1);
+ n_bytes = vnet_interface_output_node_inline (vm, sw_if_index, ccm, bufs,
+ config_index, arc, n_buffers,
+ /* do_tx_offloads */ 1);
+
+ vlib_buffer_enqueue_to_single_next (vm, node, vlib_frame_vector_args (frame),
+ 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;
}
-#endif /* CLIB_MARCH_VARIANT */
+
+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. */
VLIB_NODE_FN (vnet_per_buffer_interface_output_node) (vlib_main_t * vm,
typedef struct vnet_error_trace_t_
{
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)
{
CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
vnet_error_trace_t *t = va_arg (*va, vnet_error_trace_t *);
- s = format (s, "rx:%U", format_vnet_sw_if_index_name,
- vnet_get_main (), t->sw_if_index);
-
+ /* 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;
}
if (b0->flags & VLIB_BUFFER_IS_TRACED)
{
- t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
+ 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 = 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;
if (b0->flags & VLIB_BUFFER_IS_TRACED)
{
- t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
+ 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;
VNET_ERROR_N_DISPOSITION,
} vnet_error_disposition_t;
+static void
+drop_catchup_trace (vlib_main_t * vm,
+ vlib_node_runtime_t * node, vlib_buffer_t * b)
+{
+ /* 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
interface_drop_punt (vlib_main_t * vm,
vlib_node_runtime_t * node,
u32 sw_if_indices[VLIB_FRAME_SIZE];
vlib_simple_counter_main_t *cm;
u16 nexts[VLIB_FRAME_SIZE];
+ u32 n_trace;
vnet_main_t *vnm;
vnm = vnet_get_main ();
vlib_get_buffers (vm, from, bufs, n_left);
+ /* "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++;
+ }
+ }
+
+ vlib_set_trace_count (vm, node, n_trace);
+ b = bufs;
+ n_left = frame->n_vectors;
+ }
+
if (node->flags & VLIB_NODE_FLAG_TRACE)
interface_trace_buffers (vm, node, frame);
vlib_node_t *n;
/* Length of the error string */
int error_string_len =
- clib_strnlen (em->error_strings_heap[b0->error], 128);
+ 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];
": ", 2);
clib_memcpy_fast (last->data + last->current_data +
last->current_length + vec_len (n->name) +
- 2, em->error_strings_heap[b0->error],
+ 2, em->counters_heap[b0->error].name,
error_string_len);
last->current_length += drop_string_len;
b0->flags &= ~(VLIB_BUFFER_TOTAL_LENGTH_VALID);
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 = &vlib_global_main.pcap;
+ vnet_pcap_t *pp = &vnm->pcap;
if (PREDICT_FALSE (pp->pcap_drop_enable))
pcap_drop_trace (vm, im, pp, frame);
.name = "error-drop",
.vector_size = sizeof (u32),
.format_trace = format_vnet_error_trace,
+ .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
.n_next_nodes = 1,
.next_nodes = {
[0] = "drop",
.name = "error-punt",
.vector_size = sizeof (u32),
.format_trace = format_vnet_error_trace,
+ .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
.n_next_nodes = 1,
.next_nodes = {
[0] = "punt",
Code Review / vpp.git / blobdiff