#include <vnet/ip/ip6.h>
#include <vnet/udp/udp_packet.h>
#include <vnet/feature/feature.h>
-#include <vnet/classify/trace_classify.h>
+#include <vnet/classify/pcap_classify.h>
#include <vnet/interface_output.h>
+#include <vppinfra/vector_funcs.h>
typedef struct
{
static_always_inline void
vnet_interface_output_handle_offload (vlib_main_t *vm, vlib_buffer_t *b)
{
- 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);
+ vnet_calc_checksums_inline (vm, b, b->flags & VNET_BUFFER_F_IS_IP4,
+ b->flags & VNET_BUFFER_F_IS_IP6);
}
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_left, int do_tx_offloads,
+ int arc_or_subif)
{
u32 n_bytes = 0;
u32 n_bytes0, n_bytes1, n_bytes2, n_bytes3;
while (n_left >= 8)
{
- u32 tx_swif0, tx_swif1, tx_swif2, tx_swif3;
u32 or_flags;
/* Prefetch next iteration. */
vlib_prefetch_buffer_header (b[6], LOAD);
vlib_prefetch_buffer_header (b[7], LOAD);
- or_flags = b[0]->flags | b[1]->flags | b[2]->flags | b[3]->flags;
+ if (do_tx_offloads)
+ 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. */
n_bytes += n_bytes2 = vlib_buffer_length_in_chain (vm, b[2]);
n_bytes += n_bytes3 = 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];
+ if (arc_or_subif)
+ {
+ 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);
+ /* 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_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_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 (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 (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 (do_tx_offloads && (or_flags & VNET_BUFFER_F_OFFLOAD))
while (n_left)
{
- u32 tx_swif0;
-
/* 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]);
- tx_swif0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
- if (PREDICT_FALSE (config_index != ~0))
+ if (arc_or_subif)
{
- vnet_buffer (b[0])->feature_arc_index = arc;
- b[0]->current_config_index = config_index;
- }
+ u32 tx_swif0 = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
- if (PREDICT_FALSE (tx_swif0 != sw_if_index))
- vlib_increment_combined_counter (ccm, ti, tx_swif0, 1, n_bytes0);
+ 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 (do_tx_offloads)
vnet_interface_output_handle_offload (vm, b[0]);
while (n_left_from > 0)
{
- int classify_filter_result;
u32 bi0 = from[0];
vlib_buffer_t *b0 = vlib_get_buffer (vm, bi0);
from++;
n_left_from--;
- if (pp->filter_classify_table_index != ~0)
- {
- classify_filter_result =
- vnet_is_packet_traced_inline
- (b0, pp->filter_classify_table_index, 0 /* full classify */ );
- if (classify_filter_result)
- pcap_add_buffer (&pp->pcap_main, vm, bi0, pp->max_bytes_per_pkt);
- continue;
- }
-
if (sw_if_index_from_buffer)
sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_TX];
- if (pp->pcap_sw_if_index == 0 || pp->pcap_sw_if_index == sw_if_index)
+ if (vnet_is_packet_pcaped (pp, b0, sw_if_index))
+ pcap_add_buffer (&pp->pcap_main, vm, bi0, pp->max_bytes_per_pkt);
+ }
+}
+
+static_always_inline void
+store_tx_frame_scalar_data (vnet_hw_if_output_node_runtime_t *r,
+ vnet_hw_if_tx_frame_t *tf)
+{
+ if (r)
+ clib_memcpy_fast (tf, &r->frame, sizeof (vnet_hw_if_tx_frame_t));
+}
+
+static_always_inline void
+enqueu_to_tx_node (vlib_main_t *vm, vlib_node_runtime_t *node,
+ vnet_hw_interface_t *hi, u32 *from, u32 n_vectors)
+{
+ u32 next_index = VNET_INTERFACE_OUTPUT_NEXT_TX;
+ vnet_hw_if_output_node_runtime_t *r = 0;
+ u32 n_free, n_copy, *to;
+ vnet_hw_if_tx_frame_t *tf;
+ vlib_frame_t *f;
+
+ ASSERT (n_vectors <= VLIB_FRAME_SIZE);
+
+ if (hi->output_node_thread_runtimes)
+ r = vec_elt_at_index (hi->output_node_thread_runtimes, vm->thread_index);
+
+ f = vlib_get_next_frame_internal (vm, node, next_index, 0);
+ tf = vlib_frame_scalar_args (f);
+
+ if (f->n_vectors > 0 && (r == 0 || tf->queue_id == r->frame.queue_id))
+ {
+ /* append current next frame */
+ n_free = VLIB_FRAME_SIZE - f->n_vectors;
+ n_copy = clib_min (n_vectors, n_free);
+ n_vectors -= n_copy;
+ to = vlib_frame_vector_args (f);
+ to += f->n_vectors;
+ }
+ else
+ {
+ if (f->n_vectors > 0)
{
- vnet_main_t *vnm = vnet_get_main ();
- vnet_hw_interface_t *hi =
- vnet_get_sup_hw_interface (vnm, sw_if_index);
- /* Capture pkt if not filtered, or if filter hits */
- if (hi->trace_classify_table_index == ~0 ||
- vnet_is_packet_traced_inline
- (b0, hi->trace_classify_table_index, 0 /* full classify */ ))
- pcap_add_buffer (&pp->pcap_main, vm, bi0, pp->max_bytes_per_pkt);
+ /* 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);
}
+
+ /* empty frame - store scalar data */
+ store_tx_frame_scalar_data (r, tf);
+ to = vlib_frame_vector_args (f);
+ n_free = VLIB_FRAME_SIZE;
+ n_copy = n_vectors;
+ n_vectors = 0;
}
+
+ vlib_buffer_copy_indices (to, from, n_copy);
+ vlib_put_next_frame (vm, node, next_index, n_free - n_copy);
+
+ if (n_vectors == 0)
+ return;
+
+ /* we have more indices to store, take empty frame */
+ from += n_copy;
+ f = vlib_get_next_frame_internal (vm, node, next_index, 1);
+ store_tx_frame_scalar_data (r, vlib_frame_scalar_args (f));
+ vlib_buffer_copy_indices (vlib_frame_vector_args (f), from, n_vectors);
+ vlib_put_next_frame (vm, node, next_index, VLIB_FRAME_SIZE - n_vectors);
}
VLIB_NODE_FN (vnet_interface_output_node)
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;
u32 *from;
if (node->flags & VLIB_NODE_FLAG_TRACE)
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 (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);
+ if ((hi->caps & VNET_HW_INTERFACE_CAP_SUPPORTS_TX_CKSUM) == 0)
+ do_tx_offloads = 1;
+
+ if (do_tx_offloads == 0 && arc_or_subif == 0)
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, config_index, arc, n_buffers, 0, 0);
+ else if (do_tx_offloads == 0 && arc_or_subif == 1)
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, config_index, arc, n_buffers, 0, 1);
+ else if (do_tx_offloads == 1 && arc_or_subif == 0)
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, config_index, arc, n_buffers, 1, 0);
else
- n_bytes = vnet_interface_output_node_inline (vm, sw_if_index, ccm, bufs,
- config_index, arc, n_buffers,
- /* do_tx_offloads */ 1);
+ n_bytes = vnet_interface_output_node_inline (
+ vm, sw_if_index, ccm, bufs, config_index, arc, n_buffers, 1, 1);
- vlib_buffer_enqueue_to_single_next (vm, node, vlib_frame_vector_args (frame),
- next_index, frame->n_vectors);
+ from = vlib_frame_vector_args (frame);
+ if (PREDICT_TRUE (next_index == VNET_INTERFACE_OUTPUT_NEXT_TX))
+ {
+ enqueu_to_tx_node (vm, node, hi, from, frame->n_vectors);
+ }
+ else
+ {
+ 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);
i16 save_current_data;
u16 save_current_length;
vlib_error_main_t *em = &vm->error_main;
- int do_trace = 0;
-
from = vlib_frame_vector_args (f);
&& hash_get (im->pcap_drop_filter_hash, b0->error))
continue;
- do_trace = (pp->pcap_sw_if_index == 0) ||
- pp->pcap_sw_if_index == vnet_buffer (b0)->sw_if_index[VLIB_RX];
+ if (!vnet_is_packet_pcaped (pp, b0, ~0))
+ continue; /* not matching, skip */
- if (PREDICT_FALSE
- (do_trace == 0 && pp->filter_classify_table_index != ~0))
+ /* Trace all drops, or drops received on a specific interface */
+ 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)
{
- do_trace = vnet_is_packet_traced_inline
- (b0, pp->filter_classify_table_index, 0 /* full classify */ );
+ if (b0->current_data > vnet_buffer (b0)->l2_hdr_offset)
+ vlib_buffer_advance (b0, vnet_buffer (b0)->l2_hdr_offset -
+ b0->current_data);
}
-
- /* Trace all drops, or drops received on a specific interface */
- if (do_trace)
+ else if (b0->current_data > 0)
{
- 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)
- vlib_buffer_advance (b0, (word) - b0->current_data);
+ 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)))
{
- 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;
- }
+ 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;
}
+ }
- /*
- * 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);
+ /*
+ * 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;
}
}
};
/* *INDENT-ON* */
-/* *INDENT-OFF* */
VLIB_REGISTER_NODE (vnet_per_buffer_interface_output_node) = {
.name = "interface-output",
.vector_size = sizeof (u32),
};
-/* *INDENT-ON* */
-static uword
-interface_tx_node_fn (vlib_main_t * vm, vlib_node_runtime_t * node,
- vlib_frame_t * from_frame)
+VLIB_NODE_FN (vnet_interface_output_arc_end_node)
+(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *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)
+ vnet_interface_main_t *im = &vnm->interface_main;
+ vnet_hw_if_output_node_runtime_t *r = 0;
+ vnet_hw_interface_t *hi;
+ vnet_hw_if_tx_frame_t *tf;
+ vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b = bufs;
+ u32 sw_if_indices[VLIB_FRAME_SIZE], *sw_if_index = sw_if_indices;
+ u64 used_elts[VLIB_FRAME_SIZE / 64] = {};
+ u64 mask[VLIB_FRAME_SIZE / 64] = {};
+ u32 *tmp, *from, n_left, n_free, n_comp, *to, swif, off;
+ u16 next_index;
+ vlib_frame_t *f;
+
+ from = vlib_frame_vector_args (frame);
+ n_left = frame->n_vectors;
+ vlib_get_buffers (vm, from, bufs, n_left);
+
+ 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);
+ 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];
- bi0 = from[0];
- from++;
- n_left_from--;
- b0 = vlib_get_buffer (vm, bi0);
- sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
+ b += 4;
+ sw_if_index += 4;
+ n_left -= 4;
+ }
+
+ while (n_left)
+ {
+ sw_if_index[0] = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
+ 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);
+ if (hi->output_node_thread_runtimes)
+ r = vec_elt_at_index (hi->output_node_thread_runtimes, vm->thread_index);
+ f = vlib_get_next_frame_internal (vm, node, next_index, 0);
+ tf = vlib_frame_scalar_args (f);
+
+ if (f->n_vectors > 0 && (r == 0 || r->frame.queue_id == tf->queue_id))
+ {
+ /* append frame */
+ n_free = VLIB_FRAME_SIZE - f->n_vectors;
+ if (n_free >= f->n_vectors)
+ to = (u32 *) vlib_frame_vector_args (f) + f->n_vectors;
+ else
+ to = tmp;
+ }
+ else
+ {
+ if (f->n_vectors > 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);
+ /* 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);
}
- to_next[0] = bi0;
- to_next++;
- to_frame->n_vectors++;
+ /* empty frame - store scalar data */
+ store_tx_frame_scalar_data (r, tf);
+ n_free = VLIB_FRAME_SIZE;
+ to = vlib_frame_vector_args (f);
+ }
+
+ /* compare and compress based on comparison mask */
+ clib_mask_compare_u32 (swif, sw_if_indices, mask, frame->n_vectors);
+ n_comp = clib_compress_u32 (to, from, mask, frame->n_vectors);
+
+ if (tmp != to)
+ {
+ /* indices already written to frame, just close it */
+ vlib_put_next_frame (vm, node, next_index, n_free - n_comp);
+ }
+ else if (n_free >= n_comp)
+ {
+ /* enough space in the existing frame */
+ to = (u32 *) vlib_frame_vector_args (f) + f->n_vectors;
+ vlib_buffer_copy_indices (to, tmp, n_comp);
+ vlib_put_next_frame (vm, node, next_index, n_free - n_comp);
+ }
+ 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_frame2 = n_comp - n_free;
+ f = vlib_get_next_frame_internal (vm, node, next_index, 1);
+ to = vlib_frame_vector_args (f);
+ vlib_buffer_copy_indices (to, tmp + n_free, n_frame2);
+ tf = vlib_frame_scalar_args (f);
+ store_tx_frame_scalar_data (r, tf);
+ vlib_put_next_frame (vm, node, next_index, VLIB_FRAME_SIZE - n_frame2);
+ }
+
+ n_left -= n_comp;
+ if (n_left)
+ {
+ /* store comparison mask so we can find next unused element */
+ for (int i = 0; i < ARRAY_LEN (used_elts); i++)
+ used_elts[i] |= mask[i];
+
+ /* fine first unused sw_if_index by scanning trough used_elts bitmap */
+ while (PREDICT_FALSE (used_elts[off] == ~0))
+ off++;
+
+ 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) = {
- .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 *
Code Review / vpp.git / blobdiff