X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fdpo%2Fload_balance.c;h=bb38233a55ec455254cbffbd3172f9082c74cf54;hb=2303cb1;hp=e70a7a306e17571fa1d4e165b7956d5175177022;hpb=c0790cfef0bd1c56f4c75dc4f959584148386258;p=vpp.git diff --git a/src/vnet/dpo/load_balance.c b/src/vnet/dpo/load_balance.c index e70a7a306e1..bb38233a55e 100644 --- a/src/vnet/dpo/load_balance.c +++ b/src/vnet/dpo/load_balance.c @@ -21,6 +21,7 @@ #include #include #include +#include /* * distribution error tolerance for load-balancing @@ -118,7 +119,8 @@ load_balance_format (index_t lbi, buckets = load_balance_get_buckets(lb); s = format(s, "%U: ", format_dpo_type, DPO_LOAD_BALANCE); - s = format(s, "[index:%d buckets:%d ", lbi, lb->lb_n_buckets); + s = format(s, "[proto:%U ", format_dpo_proto, lb->lb_proto); + s = format(s, "index:%d buckets:%d ", lbi, lb->lb_n_buckets); s = format(s, "uRPF:%d ", lb->lb_urpf); s = format(s, "to:[%Ld:%Ld]", to.packets, to.bytes); if (0 != via.packets) @@ -238,6 +240,27 @@ load_balance_is_drop (const dpo_id_t *dpo) return (0); } +u16 +load_balance_n_buckets (index_t lbi) +{ + load_balance_t *lb; + + lb = load_balance_get(lbi); + + return (lb->lb_n_buckets); +} + +void +load_balance_set_fib_entry_flags (index_t lbi, + fib_entry_flag_t flags) +{ + load_balance_t *lb; + + lb = load_balance_get(lbi); + lb->lb_fib_entry_flags = flags; +} + + void load_balance_set_urpf (index_t lbi, index_t urpf) @@ -683,7 +706,7 @@ load_balance_multipath_update (const dpo_id_t *dpo, buckets, n_buckets); - for (ii = old_n_buckets-n_buckets; ii < old_n_buckets; ii++) + for (ii = n_buckets; ii < old_n_buckets; ii++) { dpo_reset(&buckets[ii]); } @@ -799,19 +822,42 @@ const static char* const load_balance_l2_nodes[] = "l2-load-balance", NULL, }; +const static char* const load_balance_nsh_nodes[] = +{ + "nsh-load-balance", + NULL +}; +const static char* const load_balance_bier_nodes[] = +{ + "bier-load-balance", + NULL, +}; const static char* const * const load_balance_nodes[DPO_PROTO_NUM] = { [DPO_PROTO_IP4] = load_balance_ip4_nodes, [DPO_PROTO_IP6] = load_balance_ip6_nodes, [DPO_PROTO_MPLS] = load_balance_mpls_nodes, [DPO_PROTO_ETHERNET] = load_balance_l2_nodes, + [DPO_PROTO_NSH] = load_balance_nsh_nodes, + [DPO_PROTO_BIER] = load_balance_bier_nodes, }; void load_balance_module_init (void) { + index_t lbi; + dpo_register(DPO_LOAD_BALANCE, &lb_vft, load_balance_nodes); + /* + * Special LB with index zero. we need to define this since the v4 mtrie + * assumes an index of 0 implies the ply is empty. therefore all 'real' + * adjs need a non-zero index. + * This should never be used, but just in case, stack it on a drop. + */ + lbi = load_balance_create(1, DPO_PROTO_IP4, 0); + load_balance_set_bucket(lbi, 0, drop_dpo_get(DPO_PROTO_IP4)); + load_balance_map_module_init(); } @@ -906,10 +952,11 @@ typedef struct load_balance_trace_t_ index_t lb_index; } load_balance_trace_t; -static uword -l2_load_balance (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) +always_inline uword +load_balance_inline (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame, + int is_l2) { u32 n_left_from, next_index, *from, *to_next; @@ -944,7 +991,16 @@ l2_load_balance (vlib_main_t * vm, lbi0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX]; lb0 = load_balance_get(lbi0); - vnet_buffer(b0)->ip.flow_hash = l2_flow_hash(b0); + if (is_l2) + { + vnet_buffer(b0)->ip.flow_hash = l2_flow_hash(b0); + } + else + { + /* it's BIER */ + const bier_hdr_t *bh0 = vlib_buffer_get_current(b0); + vnet_buffer(b0)->ip.flow_hash = bier_hdr_get_entropy(bh0); + } dpo0 = load_balance_get_bucket_i(lb0, vnet_buffer(b0)->ip.flow_hash & @@ -969,8 +1025,16 @@ l2_load_balance (vlib_main_t * vm, return frame->n_vectors; } +static uword +l2_load_balance (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + return (load_balance_inline(vm, node, frame, 1)); +} + static u8 * -format_load_balance_trace (u8 * s, va_list * args) +format_l2_load_balance_trace (u8 * s, va_list * args) { CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); @@ -988,9 +1052,130 @@ VLIB_REGISTER_NODE (l2_load_balance_node) = { .name = "l2-load-balance", .vector_size = sizeof (u32), - .format_trace = format_load_balance_trace, + .format_trace = format_l2_load_balance_trace, .n_next_nodes = 1, .next_nodes = { [0] = "error-drop", }, }; + +static uword +nsh_load_balance (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 n_left_from, next_index, *from, *to_next; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + u32 n_left_to_next; + + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); + + while (n_left_from > 0 && n_left_to_next > 0) + { + vlib_buffer_t *b0; + u32 bi0, lbi0, next0, *nsh0; + const dpo_id_t *dpo0; + const load_balance_t *lb0; + + bi0 = from[0]; + to_next[0] = bi0; + from += 1; + to_next += 1; + n_left_from -= 1; + n_left_to_next -= 1; + + b0 = vlib_get_buffer (vm, bi0); + + lbi0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX]; + lb0 = load_balance_get(lbi0); + + /* SPI + SI are the second word of the NSH header */ + nsh0 = vlib_buffer_get_current (b0); + vnet_buffer(b0)->ip.flow_hash = nsh0[1] % lb0->lb_n_buckets; + + dpo0 = load_balance_get_bucket_i(lb0, + vnet_buffer(b0)->ip.flow_hash & + (lb0->lb_n_buckets_minus_1)); + + next0 = dpo0->dpoi_next_node; + vnet_buffer (b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index; + + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + load_balance_trace_t *tr = vlib_add_trace (vm, node, b0, + sizeof (*tr)); + tr->lb_index = lbi0; + } + vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, + n_left_to_next, bi0, next0); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + return frame->n_vectors; +} + +static u8 * +format_nsh_load_balance_trace (u8 * s, va_list * args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + load_balance_trace_t *t = va_arg (*args, load_balance_trace_t *); + + s = format (s, "NSH-load-balance: index %d", t->lb_index); + return s; +} + +/** + * @brief + */ +VLIB_REGISTER_NODE (nsh_load_balance_node) = { + .function = nsh_load_balance, + .name = "nsh-load-balance", + .vector_size = sizeof (u32), + + .format_trace = format_nsh_load_balance_trace, + .n_next_nodes = 1, + .next_nodes = { + [0] = "error-drop", + }, +}; + +static u8 * +format_bier_load_balance_trace (u8 * s, va_list * args) +{ + CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); + CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); + load_balance_trace_t *t = va_arg (*args, load_balance_trace_t *); + + s = format (s, "BIER-load-balance: index %d", t->lb_index); + return s; +} + +static uword +bier_load_balance (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + return (load_balance_inline(vm, node, frame, 0)); +} + +/** + * @brief + */ +VLIB_REGISTER_NODE (bier_load_balance_node) = { + .function = bier_load_balance, + .name = "bier-load-balance", + .vector_size = sizeof (u32), + + .format_trace = format_bier_load_balance_trace, + .sibling_of = "mpls-load-balance", +};