X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vnet%2Fvnet%2Fip%2Flookup.c;h=8531f645629a658edc890b39ea021649da0602f3;hb=3cff0e70766c2aa243edad3174df54885bb5c07b;hp=629c900a6b62882a5a354fc94755c500988569b4;hpb=f1bd8bec8776755dfb98f1a93be0f9ee884aa7da;p=vpp.git diff --git a/vnet/vnet/ip/lookup.c b/vnet/vnet/ip/lookup.c index 629c900a6b6..8531f645629 100644 --- a/vnet/vnet/ip/lookup.c +++ b/vnet/vnet/ip/lookup.c @@ -59,6 +59,109 @@ ip_poison_adjacencies (ip_adjacency_t * adj, uword n_adj) } } +static void +ip_share_adjacency(ip_lookup_main_t * lm, u32 adj_index) +{ + ip_adjacency_t * adj = ip_get_adjacency(lm, adj_index); + uword * p; + u32 old_ai; + uword signature = vnet_ip_adjacency_signature (adj); + + p = hash_get (lm->adj_index_by_signature, signature); + /* Hash collision? */ + if (p) + { + /* Save the adj index, p[0] will be toast after the unset! */ + old_ai = p[0]; + hash_unset (lm->adj_index_by_signature, signature); + hash_set (lm->adj_index_by_signature, signature, adj_index); + adj->next_adj_with_signature = old_ai; + } + else + { + adj->next_adj_with_signature = 0; + hash_set (lm->adj_index_by_signature, signature, adj_index); + } +} + +static void +ip_unshare_adjacency(ip_lookup_main_t * lm, u32 adj_index) +{ + ip_adjacency_t * adj = ip_get_adjacency(lm, adj_index); + uword signature; + uword * p; + u32 this_ai; + ip_adjacency_t * this_adj, * prev_adj = 0; + + signature = vnet_ip_adjacency_signature (adj); + p = hash_get (lm->adj_index_by_signature, signature); + if (p == 0) + return; + + this_ai = p[0]; + /* At the top of the signature chain (likely)? */ + if (this_ai == adj_index) + { + if (adj->next_adj_with_signature == 0) + { + hash_unset (lm->adj_index_by_signature, signature); + return; + } + else + { + this_adj = ip_get_adjacency (lm, adj->next_adj_with_signature); + hash_unset (lm->adj_index_by_signature, signature); + hash_set (lm->adj_index_by_signature, signature, + this_adj->heap_handle); + } + } + else /* walk signature chain */ + { + this_adj = ip_get_adjacency (lm, this_ai); + while (this_adj != adj) + { + prev_adj = this_adj; + this_adj = ip_get_adjacency + (lm, this_adj->next_adj_with_signature); + /* + * This can happen when creating the first multipath adj of a set + * We end up looking at the miss adjacency (handle==0). + */ + if (this_adj->heap_handle == 0) + return; + } + prev_adj->next_adj_with_signature = this_adj->next_adj_with_signature; + } +} + +int ip_register_adjacency(vlib_main_t *vm, + u8 is_ip4, + ip_adj_register_t *reg) +{ + ip_lookup_main_t *lm = (is_ip4)?&ip4_main.lookup_main:&ip6_main.lookup_main; + vlib_node_t *node = vlib_get_node_by_name (vm, (u8 *) ((is_ip4)?"ip4-lookup":"ip6-lookup")); + vlib_node_t *next_node = vlib_get_node_by_name(vm, (u8 *) reg->node_name); + *reg->next_index = vlib_node_add_next (vm, node->index, next_node->index); + vec_validate(lm->registered_adjacencies, *reg->next_index); + lm->registered_adjacencies[*reg->next_index] = *reg; + return 0; +} + +int ip_init_registered_adjacencies(u8 is_ip4) +{ + vlib_main_t *vm = vlib_get_main(); + ip_lookup_main_t *lm = (is_ip4)?&ip4_main.lookup_main:&ip6_main.lookup_main; + ip_adj_register_t *reg = lm->registered_adjacencies; + lm->registered_adjacencies = 0; //Init vector + int rv; + while (reg) { + if((rv = ip_register_adjacency(vm, is_ip4, reg))) + return rv; + reg = reg->next; + } + return 0; +} + /* Create new block of given number of contiguous adjacencies. */ ip_adjacency_t * ip_add_adjacency (ip_lookup_main_t * lm, @@ -134,9 +237,10 @@ ip_add_adjacency (ip_lookup_main_t * lm, adj[i].mcast_group_index = ~0; adj[i].classify.table_index = ~0; adj[i].saved_lookup_next_index = 0; + adj[i].special_adjacency_format_function_index = 0; if (copy_adj) - adj[i] = copy_adj[i]; + adj[i] = copy_adj[i]; adj[i].heap_handle = handle; adj[i].n_adj = n_adj; @@ -149,32 +253,33 @@ ip_add_adjacency (ip_lookup_main_t * lm, /* Set up to share the adj later */ if (copy_adj && n_adj == 1) - { - uword * p; - u32 old_ai; - uword signature = vnet_ip_adjacency_signature (adj); - - p = hash_get (lm->adj_index_by_signature, signature); - /* Hash collision? */ - if (p) - { - /* Save the adj index, p[0] will be toast after the unset! */ - old_ai = p[0]; - hash_unset (lm->adj_index_by_signature, signature); - hash_set (lm->adj_index_by_signature, signature, ai); - adj->next_adj_with_signature = old_ai; - } - else - { - adj->next_adj_with_signature = 0; - hash_set (lm->adj_index_by_signature, signature, ai); - } - } + ip_share_adjacency(lm, ai); *adj_index_return = ai; return adj; } +void +ip_update_adjacency (ip_lookup_main_t * lm, + u32 adj_index, + ip_adjacency_t * copy_adj) +{ + ip_adjacency_t * adj = ip_get_adjacency(lm, adj_index); + + ip_call_add_del_adjacency_callbacks (lm, adj_index, /* is_del */ 1); + ip_unshare_adjacency(lm, adj_index); + + /* temporary redirect to drop while updating rewrite data */ + adj->lookup_next_index = IP_LOOKUP_NEXT_ARP; + CLIB_MEMORY_BARRIER(); + + clib_memcpy (&adj->rewrite_header, ©_adj->rewrite_header, + VLIB_BUFFER_PRE_DATA_SIZE); + adj->lookup_next_index = copy_adj->lookup_next_index; + ip_share_adjacency(lm, adj_index); + ip_call_add_del_adjacency_callbacks (lm, adj_index, /* is_del */ 0); +} + static void ip_del_adjacency2 (ip_lookup_main_t * lm, u32 adj_index, u32 delete_multipath_adjacency) { ip_adjacency_t * adj; @@ -189,58 +294,15 @@ static void ip_del_adjacency2 (ip_lookup_main_t * lm, u32 adj_index, u32 delete_ if (adj->n_adj == 1) { - uword signature; - uword * p; - u32 this_ai; - ip_adjacency_t * this_adj, * prev_adj = 0; if (adj->share_count > 0) { adj->share_count --; return; } - signature = vnet_ip_adjacency_signature (adj); - p = hash_get (lm->adj_index_by_signature, signature); - if (p == 0) - goto bag_it; - - this_ai = p[0]; - /* At the top of the signature chain (likely)? */ - if (this_ai == adj_index) - { - if (adj->next_adj_with_signature == 0) - { - hash_unset (lm->adj_index_by_signature, signature); - goto bag_it; - } - else - { - this_adj = ip_get_adjacency (lm, adj->next_adj_with_signature); - hash_unset (lm->adj_index_by_signature, signature); - hash_set (lm->adj_index_by_signature, signature, - this_adj->heap_handle); - } - } - else /* walk signature chain */ - { - this_adj = ip_get_adjacency (lm, this_ai); - while (this_adj != adj) - { - prev_adj = this_adj; - this_adj = ip_get_adjacency - (lm, this_adj->next_adj_with_signature); - /* - * This can happen when creating the first multipath adj of a set - * We end up looking at the miss adjacency (handle==0). - */ - if (this_adj->heap_handle == 0) - goto bag_it; - } - prev_adj->next_adj_with_signature = this_adj->next_adj_with_signature; - } + ip_unshare_adjacency(lm, adj_index); } - bag_it: if (delete_multipath_adjacency) ip_multipath_del_adjacency (lm, adj_index); @@ -310,7 +372,7 @@ static u32 ip_multipath_normalize_next_hops (ip_lookup_main_t * lm, } else { - memcpy (nhs, raw_next_hops, n_nhs * sizeof (raw_next_hops[0])); + clib_memcpy (nhs, raw_next_hops, n_nhs * sizeof (raw_next_hops[0])); qsort (nhs, n_nhs, sizeof (nhs[0]), (void *) next_hop_sort_by_weight); } @@ -438,7 +500,7 @@ ip_multipath_adjacency_get (ip_lookup_main_t * lm, madj->normalized_next_hops.heap_offset = heap_alloc (lm->next_hop_heap, vec_len (nhs), madj->normalized_next_hops.heap_handle); - memcpy (lm->next_hop_heap + madj->normalized_next_hops.heap_offset, + clib_memcpy (lm->next_hop_heap + madj->normalized_next_hops.heap_offset, nhs, vec_bytes (nhs)); hash_set (lm->multipath_adjacency_by_next_hops, @@ -449,7 +511,7 @@ ip_multipath_adjacency_get (ip_lookup_main_t * lm, madj->unnormalized_next_hops.heap_offset = heap_alloc (lm->next_hop_heap, vec_len (raw_next_hops), madj->unnormalized_next_hops.heap_handle); - memcpy (lm->next_hop_heap + madj->unnormalized_next_hops.heap_offset, + clib_memcpy (lm->next_hop_heap + madj->unnormalized_next_hops.heap_offset, raw_next_hops, vec_bytes (raw_next_hops)); ip_call_add_del_adjacency_callbacks (lm, adj_index, /* is_del */ 0); @@ -475,6 +537,17 @@ ip_multipath_adjacency_add_del_next_hop (ip_lookup_main_t * lm, i_nh = 0; nhs = 0; + /* If old adj is not multipath, we need to "convert" it by calling this + * function recursively */ + if (old_mp_adj_index != ~0 && !ip_adjacency_is_multipath(lm, old_mp_adj_index)) + { + ip_multipath_adjacency_add_del_next_hop(lm, /* is_del */ 0, + /* old_mp_adj_index */ ~0, + /* nh_adj_index */ old_mp_adj_index, + /* weight * */ 1, + &old_mp_adj_index); + } + /* If old multipath adjacency is valid, find requested next hop. */ if (old_mp_adj_index < vec_len (lm->multipath_adjacencies) && lm->multipath_adjacencies[old_mp_adj_index].normalized_next_hops.count > 0) @@ -871,12 +944,14 @@ void ip_lookup_init (ip_lookup_main_t * lm, u32 is_ip6) lm->builtin_protocol_by_ip_protocol[IP_PROTOCOL_UDP] = IP_BUILTIN_PROTOCOL_UDP; lm->builtin_protocol_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 : IP_PROTOCOL_ICMP] = IP_BUILTIN_PROTOCOL_ICMP; } + + ip_init_registered_adjacencies(!is_ip6); } u8 * format_ip_flow_hash_config (u8 * s, va_list * args) { u32 flow_hash_config = va_arg (*args, u32); - + #define _(n,v) if (flow_hash_config & v) s = format (s, "%s ", #n); foreach_flow_hash_bit; #undef _ @@ -886,13 +961,20 @@ u8 * format_ip_flow_hash_config (u8 * s, va_list * args) u8 * format_ip_lookup_next (u8 * s, va_list * args) { - ip_lookup_next_t n = va_arg (*args, ip_lookup_next_t); + ip_lookup_main_t * lm = va_arg (*args, ip_lookup_main_t *); + ip_lookup_next_t n = va_arg (*args, u32); + ip_adj_register_t *reg; + char * t = 0; switch (n) { default: - s = format (s, "unknown %d", n); + vec_validate(lm->registered_adjacencies, n); + reg = vec_elt_at_index(lm->registered_adjacencies, n); + if (reg->node_name) { + s = format (s, "%s:", reg->node_name); + } return s; case IP_LOOKUP_NEXT_MISS: t = "miss"; break; @@ -903,7 +985,7 @@ u8 * format_ip_lookup_next (u8 * s, va_list * args) case IP_LOOKUP_NEXT_CLASSIFY: t = "classify"; break; case IP_LOOKUP_NEXT_MAP: t = "map"; break; case IP_LOOKUP_NEXT_MAP_T: t = "map-t"; break; - case IP_LOOKUP_NEXT_SIXRD: t = "sixrd"; break; + case IP_LOOKUP_NEXT_INDIRECT: t="indirect"; break; case IP_LOOKUP_NEXT_REWRITE: break; } @@ -927,44 +1009,89 @@ static u8 * format_ip_interface_address (u8 * s, va_list * args) return format (s, "%U", format_ip4_address_and_length, a, ia->address_length); } +u32 vnet_register_special_adjacency_format_function +(ip_lookup_main_t * lm, format_function_t * fp) +{ + u32 rv; + /* + * Initialize the format function registration vector + * Index 0 must be invalid, to avoid finding and fixing trivial bugs + * all over the place + */ + if (vec_len (lm->special_adjacency_format_functions) == 0) + { + vec_add1 (lm->special_adjacency_format_functions, + (format_function_t *) 0); + } + + rv = vec_len (lm->special_adjacency_format_functions); + vec_add1 (lm->special_adjacency_format_functions, fp); + return rv; +} + +/** @brief Pretty print helper function for formatting specific adjacencies. + @param s - input string to format + @param args - other args passed to format function such as: + - vnet_main_t + - ip_lookup_main_t + - adj_index +*/ u8 * format_ip_adjacency (u8 * s, va_list * args) { vnet_main_t * vnm = va_arg (*args, vnet_main_t *); ip_lookup_main_t * lm = va_arg (*args, ip_lookup_main_t *); u32 adj_index = va_arg (*args, u32); ip_adjacency_t * adj = ip_get_adjacency (lm, adj_index); + ip_adj_register_t *reg; + if (adj->lookup_next_index < vec_len (lm->registered_adjacencies)) + { + reg = vec_elt_at_index(lm->registered_adjacencies, + adj->lookup_next_index); + if (reg->fn) + { + s = format(s, " %U", reg->fn, lm, adj); + goto format_done; + } + } + switch (adj->lookup_next_index) { case IP_LOOKUP_NEXT_REWRITE: s = format (s, "%U", format_vnet_rewrite, - vnm->vlib_main, &adj->rewrite_header, sizeof (adj->rewrite_data)); + vnm->vlib_main, &adj->rewrite_header, + sizeof (adj->rewrite_data)); break; - + + case IP_LOOKUP_NEXT_ARP: + if (adj->if_address_index != ~0) + s = format (s, " %U", format_ip_interface_address, lm, + adj->if_address_index); + if (adj->arp.next_hop.ip6.as_u64[0] || adj->arp.next_hop.ip6.as_u64[1]) + s = format (s, " via %U", format_ip46_address, + &adj->arp.next_hop, IP46_TYPE_ANY); + break; + case IP_LOOKUP_NEXT_LOCAL: + if (adj->if_address_index != ~0) + s = format (s, " %U", format_ip_interface_address, lm, + adj->if_address_index); + break; + + case IP_LOOKUP_NEXT_CLASSIFY: + s = format (s, " table %d", adj->classify.table_index); + break; + case IP_LOOKUP_NEXT_INDIRECT: + s = format (s, " via %U", format_ip46_address, + &adj->indirect.next_hop, IP46_TYPE_ANY); + break; + default: - s = format (s, "%U", format_ip_lookup_next, adj->lookup_next_index); - if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP) - s = format (s, " %U", - format_vnet_sw_interface_name, - vnm, - vnet_get_sw_interface (vnm, adj->rewrite_header.sw_if_index)); - switch (adj->lookup_next_index) - { - case IP_LOOKUP_NEXT_ARP: - case IP_LOOKUP_NEXT_LOCAL: - if (adj->if_address_index != ~0) - s = format (s, " %U", format_ip_interface_address, lm, adj->if_address_index); - break; - - case IP_LOOKUP_NEXT_CLASSIFY: - s = format (s, " table %d", adj->classify.table_index); - - default: - break; - } + s = format (s, " unknown %d", adj->lookup_next_index); break; } + + format_done: if (adj->explicit_fib_index != ~0 && adj->explicit_fib_index != 0) s = format (s, " lookup fib index %d", adj->explicit_fib_index); if (adj->share_count > 0) @@ -1042,7 +1169,7 @@ static uword unformat_ip_adjacency (unformat_input_t * input, va_list * args) if (unformat (input, "arp %U %U", unformat_vnet_sw_interface, vnm, &sw_if_index, - unformat_ip46_address, &a46, is_ip6)) + unformat_ip46_address, &a46, is_ip6?IP46_TYPE_IP6:IP46_TYPE_IP4)) { ip_lookup_main_t * lm = is_ip6 ? &ip6_main.lookup_main : &ip4_main.lookup_main; ip_adjacency_t * a_adj; @@ -1275,73 +1402,6 @@ vnet_ip_route_cmd (vlib_main_t * vm, unformat_input_t * main_input, vlib_cli_com goto done; } - if (vec_len(ip4_via_next_hops)) - { - if (sw_if_indices[0] == (u32)~0) - { - u32 ai; - uword * p; - u32 fib_index; - ip_adjacency_t *nh_adj; - - p = hash_get (ip4_main.fib_index_by_table_id, table_ids[0]); - if (p == 0) - { - error = clib_error_return (0, "Nonexistent FIB id %d", - table_ids[0]); - goto done; - } - - fib_index = p[0]; - - ai = ip4_fib_lookup_with_table (&ip4_main, - fib_index, - ip4_via_next_hops, - 1 /* disable default route */); - if (ai == 0) - { - error = clib_error_return (0, "next hop %U not in FIB", - format_ip4_address, - ip4_via_next_hops); - goto done; - } - nh_adj = ip_get_adjacency (&ip4_main.lookup_main, ai); - vec_add1 (add_adj, nh_adj[0]); - } - } - if (vec_len(ip6_via_next_hops)) - { - if (sw_if_indices[0] == (u32)~0) - { - u32 ai; - uword * p; - u32 fib_index; - ip_adjacency_t *nh_adj; - - p = hash_get (ip6_main.fib_index_by_table_id, table_ids[0]); - if (p == 0) - { - error = clib_error_return (0, "Nonexistent FIB id %d", - table_ids[0]); - goto done; - } - - fib_index = p[0]; - ai = ip6_fib_lookup_with_table (&ip6_main, - fib_index, - ip6_via_next_hops); - if (ai == 0) - { - error = clib_error_return (0, "next hop %U not in FIB", - format_ip6_address, - ip6_via_next_hops); - goto done; - } - nh_adj = ip_get_adjacency (&ip6_main.lookup_main, ai); - vec_add1 (add_adj, nh_adj[0]); - } - } - { int i; ip4_main_t * im4 = &ip4_main; @@ -2017,8 +2077,13 @@ ip4_show_fib (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * c msg = format (msg, "%16Ld%16Ld ", sum.packets, sum.bytes); indent = vec_len (msg); - msg = format (msg, "weight %d, index %d\n%U%U", - nhs[j].weight, adj_index + i, + msg = format (msg, "weight %d, index %d", + nhs[j].weight, adj_index + i); + + if (ip_adjacency_is_multipath(lm, adj_index)) + msg = format (msg, ", multipath"); + + msg = format (msg, "\n%U%U", format_white_space, indent, format_ip_adjacency, vnm, lm, adj_index + i); @@ -2240,8 +2305,13 @@ ip6_show_fib (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * c msg = format (msg, "%16Ld%16Ld ", sum.packets, sum.bytes); indent = vec_len (msg); - msg = format (msg, "weight %d, index %d\n%U%U", - nhs[j].weight, adj_index + i, + msg = format (msg, "weight %d, index %d", + nhs[j].weight, adj_index + i); + + if (ip_adjacency_is_multipath(lm, adj_index + i)) + msg = format (msg, ", multipath"); + + msg = format (msg, "\n%U%U", format_white_space, indent, format_ip_adjacency, vnm, lm, adj_index + i);