#include <vppinfra/math.h> /* for fabs */
#include <vnet/ip/ip.h>
+#include <vnet/ip/adj_alloc.h>
static void
ip_multipath_del_adjacency (ip_lookup_main_t * lm, u32 del_adj_index);
ip_poison_adjacencies (ip_adjacency_t * adj, uword n_adj)
{
if (CLIB_DEBUG > 0)
- memset (adj, 0xfe, n_adj * sizeof (adj[0]));
+ {
+ u32 save_handle = adj->heap_handle;;
+ u32 save_n_adj = adj->n_adj;
+
+ memset (adj, 0xfe, n_adj * sizeof (adj[0]));
+
+ adj->heap_handle = save_handle;
+ adj->n_adj = save_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;
+ }
}
/* Create new block of given number of contiguous adjacencies. */
ip_adjacency_t * adj;
u32 ai, i, handle;
- ai = heap_alloc (lm->adjacency_heap, n_adj, handle);
- adj = heap_elt_at_index (lm->adjacency_heap, ai);
+ /* See if we know enough to attempt to share an existing adjacency */
+ if (copy_adj && n_adj == 1)
+ {
+ uword signature;
+ uword * p;
+
+ switch (copy_adj->lookup_next_index)
+ {
+ case IP_LOOKUP_NEXT_DROP:
+ if (lm->drop_adj_index)
+ {
+ adj = ip_get_adjacency (lm, lm->drop_adj_index);
+ *adj_index_return = lm->drop_adj_index;
+ return (adj);
+ }
+ break;
+
+ case IP_LOOKUP_NEXT_LOCAL:
+ if (lm->local_adj_index)
+ {
+ adj = ip_get_adjacency (lm, lm->local_adj_index);
+ *adj_index_return = lm->local_adj_index;
+ return (adj);
+ }
+ default:
+ break;
+ }
+
+ signature = vnet_ip_adjacency_signature (copy_adj);
+ p = hash_get (lm->adj_index_by_signature, signature);
+ if (p)
+ {
+ adj = vec_elt_at_index (lm->adjacency_heap, p[0]);
+ while (1)
+ {
+ if (vnet_ip_adjacency_share_compare (adj, copy_adj))
+ {
+ adj->share_count++;
+ *adj_index_return = p[0];
+ return adj;
+ }
+ if (adj->next_adj_with_signature == 0)
+ break;
+ adj = vec_elt_at_index (lm->adjacency_heap,
+ adj->next_adj_with_signature);
+ }
+ }
+ }
+
+ lm->adjacency_heap = aa_alloc (lm->adjacency_heap, &adj, n_adj);
+ handle = ai = adj->heap_handle;
ip_poison_adjacencies (adj, n_adj);
adj[i].rewrite_header.sw_if_index = ~0;
adj[i].explicit_fib_index = ~0;
adj[i].mcast_group_index = ~0;
- adj[i].classify_table_index = ~0;
+ adj[i].classify.table_index = ~0;
adj[i].saved_lookup_next_index = 0;
if (copy_adj)
adj[i].heap_handle = handle;
adj[i].n_adj = n_adj;
+ adj[i].share_count = 0;
+ adj[i].next_adj_with_signature = 0;
/* Zero possibly stale counters for re-used adjacencies. */
vlib_zero_combined_counter (&lm->adjacency_counters, ai + i);
}
+ /* Set up to share the adj later */
+ if (copy_adj && n_adj == 1)
+ 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;
- uword handle;
ip_call_add_del_adjacency_callbacks (lm, adj_index, /* is_del */ 1);
adj = ip_get_adjacency (lm, adj_index);
- handle = adj->heap_handle;
+
+ /* Special-case miss, local, drop adjs */
+ if (adj_index < 3)
+ return;
+
+ if (adj->n_adj == 1)
+ {
+ if (adj->share_count > 0)
+ {
+ adj->share_count --;
+ return;
+ }
+
+ ip_unshare_adjacency(lm, adj_index);
+ }
if (delete_multipath_adjacency)
ip_multipath_del_adjacency (lm, adj_index);
ip_poison_adjacencies (adj, adj->n_adj);
- heap_dealloc (lm->adjacency_heap, handle);
+ aa_free (lm->adjacency_heap, adj);
}
void ip_del_adjacency (ip_lookup_main_t * lm, u32 adj_index)
}
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);
}
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,
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);
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)
return /* no error */ 0;
}
-void serialize_vec_ip_adjacency (serialize_main_t * m, va_list * va)
-{
- ip_adjacency_t * a = va_arg (*va, ip_adjacency_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- for (i = 0; i < n; i++)
- {
- serialize_integer (m, a[i].heap_handle, sizeof (a[i].heap_handle));
- serialize_integer (m, a[i].n_adj, sizeof (a[i].n_adj));
- serialize_integer (m, a[i].lookup_next_index, sizeof (a[i].lookup_next_index_as_int));
- switch (a[i].lookup_next_index)
- {
- case IP_LOOKUP_NEXT_LOCAL:
- serialize_integer (m, a[i].if_address_index, sizeof (a[i].if_address_index));
- break;
-
- case IP_LOOKUP_NEXT_ARP:
- serialize_integer (m, a[i].if_address_index, sizeof (a[i].if_address_index));
- serialize_integer (m, a[i].rewrite_header.sw_if_index, sizeof (a[i].rewrite_header.sw_if_index));
- break;
-
- case IP_LOOKUP_NEXT_REWRITE:
- serialize (m, serialize_vnet_rewrite, &a[i].rewrite_header, sizeof (a[i].rewrite_data));
- break;
-
- default:
- /* nothing else to serialize. */
- break;
- }
- }
-}
-
-void unserialize_vec_ip_adjacency (serialize_main_t * m, va_list * va)
-{
- ip_adjacency_t * a = va_arg (*va, ip_adjacency_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- ip_poison_adjacencies (a, n);
- for (i = 0; i < n; i++)
- {
- unserialize_integer (m, &a[i].heap_handle, sizeof (a[i].heap_handle));
- unserialize_integer (m, &a[i].n_adj, sizeof (a[i].n_adj));
- unserialize_integer (m, &a[i].lookup_next_index_as_int, sizeof (a[i].lookup_next_index_as_int));
- switch (a[i].lookup_next_index)
- {
- case IP_LOOKUP_NEXT_LOCAL:
- unserialize_integer (m, &a[i].if_address_index, sizeof (a[i].if_address_index));
- break;
-
- case IP_LOOKUP_NEXT_ARP:
- unserialize_integer (m, &a[i].if_address_index, sizeof (a[i].if_address_index));
- unserialize_integer (m, &a[i].rewrite_header.sw_if_index, sizeof (a[i].rewrite_header.sw_if_index));
- break;
-
- case IP_LOOKUP_NEXT_REWRITE:
- unserialize (m, unserialize_vnet_rewrite, &a[i].rewrite_header, sizeof (a[i].rewrite_data));
- break;
-
- default:
- /* nothing else to unserialize. */
- break;
- }
- }
-}
-
-static void serialize_vec_ip_multipath_next_hop (serialize_main_t * m, va_list * va)
-{
- ip_multipath_next_hop_t * nh = va_arg (*va, ip_multipath_next_hop_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- for (i = 0; i < n; i++)
- {
- serialize_integer (m, nh[i].next_hop_adj_index, sizeof (nh[i].next_hop_adj_index));
- serialize_integer (m, nh[i].weight, sizeof (nh[i].weight));
- }
-}
-
-static void unserialize_vec_ip_multipath_next_hop (serialize_main_t * m, va_list * va)
-{
- ip_multipath_next_hop_t * nh = va_arg (*va, ip_multipath_next_hop_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- for (i = 0; i < n; i++)
- {
- unserialize_integer (m, &nh[i].next_hop_adj_index, sizeof (nh[i].next_hop_adj_index));
- unserialize_integer (m, &nh[i].weight, sizeof (nh[i].weight));
- }
-}
-
-static void serialize_vec_ip_multipath_adjacency (serialize_main_t * m, va_list * va)
-{
- ip_multipath_adjacency_t * a = va_arg (*va, ip_multipath_adjacency_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- for (i = 0; i < n; i++)
- {
-#define foreach_ip_multipath_adjacency_field \
- _ (adj_index) _ (n_adj_in_block) _ (reference_count) \
- _ (normalized_next_hops.count) \
- _ (normalized_next_hops.heap_offset) \
- _ (normalized_next_hops.heap_handle) \
- _ (unnormalized_next_hops.count) \
- _ (unnormalized_next_hops.heap_offset) \
- _ (unnormalized_next_hops.heap_handle)
-
-#define _(f) serialize_integer (m, a[i].f, sizeof (a[i].f));
- foreach_ip_multipath_adjacency_field;
-#undef _
- }
-}
-
-static void unserialize_vec_ip_multipath_adjacency (serialize_main_t * m, va_list * va)
-{
- ip_multipath_adjacency_t * a = va_arg (*va, ip_multipath_adjacency_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- for (i = 0; i < n; i++)
- {
-#define _(f) unserialize_integer (m, &a[i].f, sizeof (a[i].f));
- foreach_ip_multipath_adjacency_field;
-#undef _
- }
-}
-
-void serialize_ip_lookup_main (serialize_main_t * m, va_list * va)
-{
- ip_lookup_main_t * lm = va_arg (*va, ip_lookup_main_t *);
-
- /* If this isn't true you need to call e.g. ip4_maybe_remap_adjacencies
- to make it true. */
- ASSERT (lm->n_adjacency_remaps == 0);
-
- serialize (m, serialize_heap, lm->adjacency_heap, serialize_vec_ip_adjacency);
-
- serialize (m, serialize_heap, lm->next_hop_heap, serialize_vec_ip_multipath_next_hop);
- vec_serialize (m, lm->multipath_adjacencies, serialize_vec_ip_multipath_adjacency);
-
- /* Adjacency counters (FIXME disabled for now). */
- if (0)
- serialize (m, serialize_vlib_combined_counter_main, &lm->adjacency_counters, /* incremental */ 0);
-}
-
-void unserialize_ip_lookup_main (serialize_main_t * m, va_list * va)
+void ip_lookup_init (ip_lookup_main_t * lm, u32 is_ip6)
{
- ip_lookup_main_t * lm = va_arg (*va, ip_lookup_main_t *);
-
- unserialize (m, unserialize_heap, &lm->adjacency_heap, unserialize_vec_ip_adjacency);
- unserialize (m, unserialize_heap, &lm->next_hop_heap, unserialize_vec_ip_multipath_next_hop);
- vec_unserialize (m, &lm->multipath_adjacencies, unserialize_vec_ip_multipath_adjacency);
-
- /* Build hash table from unserialized data. */
- {
- ip_multipath_adjacency_t * a;
+ ip_adjacency_t * adj;
+ ip_adjacency_t template_adj;
- vec_foreach (a, lm->multipath_adjacencies)
- {
- if (a->n_adj_in_block > 0 && a->reference_count > 0)
- hash_set (lm->multipath_adjacency_by_next_hops,
- ip_next_hop_hash_key_from_handle (a->normalized_next_hops.heap_handle),
- a - lm->multipath_adjacencies);
- }
- }
+ /* ensure that adjacency is cacheline aligned and sized */
+ ASSERT(STRUCT_OFFSET_OF(ip_adjacency_t, cacheline0) == 0);
+ ASSERT(STRUCT_OFFSET_OF(ip_adjacency_t, cacheline1) == CLIB_CACHE_LINE_BYTES);
- /* Validate adjacency counters. */
- vlib_validate_combined_counter (&lm->adjacency_counters,
- vec_len (lm->adjacency_heap) - 1);
+ lm->adj_index_by_signature = hash_create (0, sizeof (uword));
+ memset (&template_adj, 0, sizeof (template_adj));
- /* Adjacency counters (FIXME disabled for now). */
- if (0)
- unserialize (m, unserialize_vlib_combined_counter_main, &lm->adjacency_counters, /* incremental */ 0);
-}
-
-void ip_lookup_init (ip_lookup_main_t * lm, u32 is_ip6)
-{
- ip_adjacency_t * adj;
+ /* Preallocate three "special" adjacencies */
+ lm->adjacency_heap = aa_bootstrap (0, 3 /* n=1 free items */);
/* Hand-craft special miss adjacency to use when nothing matches in the
routing table. Same for drop adjacency. */
- adj = ip_add_adjacency (lm, /* template */ 0, /* n-adj */ 1, &lm->miss_adj_index);
+ adj = ip_add_adjacency (lm, /* template */ 0, /* n-adj */ 1,
+ &lm->miss_adj_index);
adj->lookup_next_index = IP_LOOKUP_NEXT_MISS;
ASSERT (lm->miss_adj_index == IP_LOOKUP_MISS_ADJ_INDEX);
- adj = ip_add_adjacency (lm, /* template */ 0, /* n-adj */ 1, &lm->drop_adj_index);
- adj->lookup_next_index = IP_LOOKUP_NEXT_DROP;
+ /* Make the "drop" adj sharable */
+ template_adj.lookup_next_index = IP_LOOKUP_NEXT_DROP;
+ adj = ip_add_adjacency (lm, &template_adj, /* n-adj */ 1,
+ &lm->drop_adj_index);
- adj = ip_add_adjacency (lm, /* template */ 0, /* n-adj */ 1, &lm->local_adj_index);
- adj->lookup_next_index = IP_LOOKUP_NEXT_LOCAL;
- adj->if_address_index = ~0;
+ /* Make the "local" adj sharable */
+ template_adj.lookup_next_index = IP_LOOKUP_NEXT_LOCAL;
+ template_adj.if_address_index = ~0;
+ adj = ip_add_adjacency (lm, &template_adj, /* n-adj */ 1,
+ &lm->local_adj_index);
if (! lm->fib_result_n_bytes)
lm->fib_result_n_bytes = sizeof (uword);
lm->local_next_by_ip_protocol[i] = IP_LOCAL_NEXT_PUNT;
lm->builtin_protocol_by_ip_protocol[i] = IP_BUILTIN_PROTOCOL_UNKNOWN;
}
-#if 0
- /* Eliot's TCP doesn't actually work */
- lm->local_next_by_ip_protocol[IP_PROTOCOL_TCP] = IP_LOCAL_NEXT_TCP_LOOKUP;
- lm->builtin_protocol_by_ip_protocol[IP_PROTOCOL_TCP] =
- IP_BUILTIN_PROTOCOL_TCP;
-#endif
lm->local_next_by_ip_protocol[IP_PROTOCOL_UDP] = IP_LOCAL_NEXT_UDP_LOOKUP;
lm->local_next_by_ip_protocol[is_ip6 ? IP_PROTOCOL_ICMP6 : IP_PROTOCOL_ICMP] = IP_LOCAL_NEXT_ICMP;
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;
}
switch (adj->lookup_next_index)
{
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);
+ s = format (s, " table %d", adj->classify.table_index);
+ case IP_LOOKUP_NEXT_INDIRECT:
+ s = format (s, " via %U", format_ip46_address,
+ &adj->indirect.next_hop, IP46_TYPE_ANY);
default:
break;
}
}
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)
+ s = format (s, " shared %d", adj->share_count + 1);
+ if (adj->next_adj_with_signature)
+ s = format (s, " next_adj_with_signature %d", adj->next_adj_with_signature);
return s;
}
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;
if (next == IP_LOOKUP_NEXT_LOCAL)
(void) unformat (input, "%d", &adj->if_address_index);
else if (next == IP_LOOKUP_NEXT_CLASSIFY)
- if (!unformat (input, "%d", &adj->classify_table_index))
- {
- clib_warning ("classify adj must specify table index");
- return 0;
- }
+ {
+ if (!unformat (input, "%d", &adj->classify.table_index))
+ {
+ clib_warning ("classify adj must specify table index");
+ return 0;
+ }
+ }
+ else if (next == IP_LOOKUP_NEXT_DROP)
+ {
+ adj->rewrite_header.node_index = 0;
+ }
}
else if (unformat_user (input,
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;
.path = "ip route",
.short_help = "Add/delete IP routes",
.function = vnet_ip_route_cmd,
+ .is_mp_safe = 1,
};
/*
default:
clib_warning ("unknown event_type %d", event_type);
}
+ vec_reset_length (event_data);
}
done:
- vec_reset_length (event_data);
if (!resolved)
return clib_error_return (0, "Resolution failed for %U",
default:
clib_warning ("unknown event_type %d", event_type);
}
+ vec_reset_length (event_data);
}
done:
.path = "ip probe-neighbor",
.function = probe_neighbor_address,
.short_help = "ip probe-neighbor <intfc> <ip4-addr> | <ip6-addr> [retry nn]",
+ .is_mp_safe = 1,
};
typedef CLIB_PACKED (struct {
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);
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);
Code Review / vpp.git / blobdiff