#include <vlib/vlib.h>
#include <vnet/pg/pg.h>
-#include <vnet/mpls/mpls.h>
+#include <vnet/mpls/mpls_lookup.h>
#include <vnet/fib/mpls_fib.h>
#include <vnet/dpo/load_balance_map.h>
#include <vnet/dpo/replicate_dpo.h>
-/**
- * Static MPLS VLIB forwarding node
- */
-static vlib_node_registration_t mpls_lookup_node;
-
/**
* The arc/edge from the MPLS lookup node to the MPLS replicate node
*/
-static u32 mpls_lookup_to_replicate_edge;
+#ifndef CLIB_MARCH_VARIANT
+u32 mpls_lookup_to_replicate_edge;
+#endif /* CLIB_MARCH_VARIANT */
typedef struct {
u32 next_index;
CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
mpls_lookup_trace_t * t = va_arg (*args, mpls_lookup_trace_t *);
- s = format (s, "MPLS: next [%d], lookup fib index %d, LB index %d hash %#x "
+ s = format (s, "MPLS: next [%d], lookup fib index %d, LB index %d hash %x "
"label %d eos %d",
t->next_index, t->lfib_index, t->lb_index, t->hash,
vnet_mpls_uc_get_label(
clib_net_to_host_u32(t->label_net_byte_order)),
- vnet_mpls_uc_get_s(t->label_net_byte_order));
+ vnet_mpls_uc_get_s(
+ clib_net_to_host_u32(t->label_net_byte_order)));
return s;
}
-/*
- * Compute flow hash.
- * We'll use it to select which adjacency to use for this flow. And other things.
- */
-always_inline u32
-mpls_compute_flow_hash (const mpls_unicast_header_t * hdr,
- flow_hash_config_t flow_hash_config)
-{
- /*
- * improve this to include:
- * - all labels in the stack.
- * - recognise entropy labels.
- *
- * We need to byte swap so we use the numerical value. i.e. an odd label
- * leads to an odd bucket. ass opposed to a label above and below value X.
- */
- return (vnet_mpls_uc_get_label(clib_net_to_host_u32(hdr->label_exp_s_ttl)));
-}
-
-static inline uword
-mpls_lookup (vlib_main_t * vm,
+VLIB_NODE_FN (mpls_lookup_node) (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * from_frame)
{
/* Prefetch next iteration. */
{
- vlib_buffer_t * p2, * p3, *p4, *p5;
+ vlib_buffer_t *p4, *p5, *p6, *p7;
- p2 = vlib_get_buffer (vm, from[2]);
- p3 = vlib_get_buffer (vm, from[3]);
p4 = vlib_get_buffer (vm, from[4]);
p5 = vlib_get_buffer (vm, from[5]);
+ p6 = vlib_get_buffer (vm, from[6]);
+ p7 = vlib_get_buffer (vm, from[7]);
- vlib_prefetch_buffer_header (p2, STORE);
- vlib_prefetch_buffer_header (p3, STORE);
vlib_prefetch_buffer_header (p4, STORE);
vlib_prefetch_buffer_header (p5, STORE);
+ vlib_prefetch_buffer_header (p6, STORE);
+ vlib_prefetch_buffer_header (p7, STORE);
- CLIB_PREFETCH (p2->data, sizeof (h0[0]), STORE);
- CLIB_PREFETCH (p3->data, sizeof (h0[0]), STORE);
- CLIB_PREFETCH (p4->data, sizeof (h0[0]), STORE);
- CLIB_PREFETCH (p5->data, sizeof (h0[0]), STORE);
+ CLIB_PREFETCH (p4->data, sizeof (h0[0]), LOAD);
+ CLIB_PREFETCH (p5->data, sizeof (h0[0]), LOAD);
+ CLIB_PREFETCH (p6->data, sizeof (h0[0]), LOAD);
+ CLIB_PREFETCH (p7->data, sizeof (h0[0]), LOAD);
}
bi0 = to_next[0] = from[0];
vlib_put_next_frame (vm, node, next_index, n_left_to_next);
}
- vlib_node_increment_counter (vm, mpls_lookup_node.index,
+ vlib_node_increment_counter (vm, mm->mpls_lookup_node_index,
MPLS_ERROR_PKTS_DECAP, from_frame->n_vectors);
return from_frame->n_vectors;
}
#undef mpls_error
};
-VLIB_REGISTER_NODE (mpls_lookup_node, static) = {
- .function = mpls_lookup,
+VLIB_REGISTER_NODE (mpls_lookup_node) = {
.name = "mpls-lookup",
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
.unformat_buffer = unformat_mpls_header,
};
-VLIB_NODE_FUNCTION_MULTIARCH (mpls_lookup_node, mpls_lookup)
-
typedef struct {
u32 next_index;
u32 lb_index;
return s;
}
-always_inline uword
-mpls_load_balance (vlib_main_t * vm,
+VLIB_NODE_FN (mpls_load_balance_node) (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
vlib_prefetch_buffer_header (p2, STORE);
vlib_prefetch_buffer_header (p3, STORE);
- CLIB_PREFETCH (p2->data, sizeof (mpls0[0]), STORE);
- CLIB_PREFETCH (p3->data, sizeof (mpls0[0]), STORE);
+ CLIB_PREFETCH (p2->data, sizeof (mpls0[0]), LOAD);
+ CLIB_PREFETCH (p3->data, sizeof (mpls0[0]), LOAD);
}
pi0 = to_next[0] = from[0];
}
VLIB_REGISTER_NODE (mpls_load_balance_node) = {
- .function = mpls_load_balance,
.name = "mpls-load-balance",
.vector_size = sizeof (u32),
.format_trace = format_mpls_load_balance_trace,
.n_next_nodes = 1,
.next_nodes =
{
- [0] = "mpls-drop",
+ [MPLS_LOOKUP_NEXT_DROP] = "mpls-drop",
},
};
-VLIB_NODE_FUNCTION_MULTIARCH (mpls_load_balance_node, mpls_load_balance)
-
+#ifndef CLIB_MARCH_VARIANT
static clib_error_t *
mpls_lookup_init (vlib_main_t * vm)
{
+ mpls_main_t *mm = &mpls_main;
clib_error_t * error;
+ vlib_node_t *node = vlib_get_node_by_name (vm, (u8*)"mpls-lookup" );
+
+ mm->mpls_lookup_node_index = node->index;
if ((error = vlib_call_init_function (vm, mpls_init)))
return error;
mpls_lookup_to_replicate_edge =
vlib_node_add_named_next(vm,
- mpls_lookup_node.index,
+ mm->mpls_lookup_node_index,
"mpls-replicate");
return (NULL);
}
VLIB_INIT_FUNCTION (mpls_lookup_init);
+#endif /* CLIB_MARCH_VARIANT */