fib_index = table_index_or_id;
if (! (flags & IP4_ROUTE_FLAG_FIB_INDEX))
{
+ if (table_index_or_id == ~0) {
+ table_index_or_id = 0;
+ while ((p = hash_get (im->fib_index_by_table_id, table_index_or_id))) {
+ table_index_or_id++;
+ }
+ return create_fib_with_table_id (im, table_index_or_id);
+ }
+
p = hash_get (im->fib_index_by_table_id, table_index_or_id);
if (! p)
return create_fib_with_table_id (im, table_index_or_id);
vec_validate_init_empty (fib->old_hash_values, max_index, ~0);
}
-static void serialize_ip4_address (serialize_main_t * m, va_list * va)
-{
- ip4_address_t * a = va_arg (*va, ip4_address_t *);
- u8 * p = serialize_get (m, sizeof (a->as_u8));
- memcpy (p, a->as_u8, sizeof (a->as_u8));
-}
-
-static void unserialize_ip4_address (serialize_main_t * m, va_list * va)
-{
- ip4_address_t * a = va_arg (*va, ip4_address_t *);
- u8 * p = unserialize_get (m, sizeof (a->as_u8));
- memcpy (a->as_u8, p, sizeof (a->as_u8));
-}
-
-static void serialize_ip4_address_and_length (serialize_main_t * m, va_list * va)
-{
- ip4_address_t * a = va_arg (*va, ip4_address_t *);
- u32 l = va_arg (*va, u32);
- u32 n_bytes = (l / 8) + ((l % 8) != 0);
- u8 * p = serialize_get (m, 1 + n_bytes);
- ASSERT (l <= 32);
- p[0] = l;
- memcpy (p + 1, a->as_u8, n_bytes);
-}
-
-static void unserialize_ip4_address_and_length (serialize_main_t * m, va_list * va)
-{
- ip4_address_t * a = va_arg (*va, ip4_address_t *);
- u32 * al = va_arg (*va, u32 *);
- u8 * p = unserialize_get (m, 1);
- u32 l, n_bytes;
-
- al[0] = l = p[0];
- ASSERT (l <= 32);
- n_bytes = (l / 8) + ((l % 8) != 0);
-
- if (n_bytes)
- {
- p = unserialize_get (m, n_bytes);
- memcpy (a->as_u8, p, n_bytes);
- }
-}
-
-static void serialize_ip4_add_del_route_msg (serialize_main_t * m, va_list * va)
-{
- ip4_add_del_route_args_t * a = va_arg (*va, ip4_add_del_route_args_t *);
-
- serialize_likely_small_unsigned_integer (m, a->table_index_or_table_id);
- serialize_likely_small_unsigned_integer (m, a->flags);
- serialize (m, serialize_ip4_address_and_length, &a->dst_address, a->dst_address_length);
- serialize_likely_small_unsigned_integer (m, a->adj_index);
- serialize_likely_small_unsigned_integer (m, a->n_add_adj);
- if (a->n_add_adj > 0)
- serialize (m, serialize_vec_ip_adjacency, a->add_adj, a->n_add_adj);
-}
-
-/* Serialized adjacencies for arp/rewrite do not send graph next_index
- since graph hookup is not guaranteed to be the same for both sides
- of serialize/unserialize. */
-static void
-unserialize_fixup_ip4_rewrite_adjacencies (vlib_main_t * vm,
- ip_adjacency_t * adj,
- u32 n_adj)
-{
- vnet_main_t * vnm = vnet_get_main();
- u32 i, ni, sw_if_index, is_arp;
- vnet_hw_interface_t * hw;
-
- for (i = 0; i < n_adj; i++)
- {
- switch (adj[i].lookup_next_index)
- {
- case IP_LOOKUP_NEXT_REWRITE:
- case IP_LOOKUP_NEXT_ARP:
- is_arp = adj[i].lookup_next_index == IP_LOOKUP_NEXT_ARP;
- sw_if_index = adj[i].rewrite_header.sw_if_index;
- hw = vnet_get_sup_hw_interface (vnm, sw_if_index);
- ni = is_arp ? ip4_arp_node.index : ip4_rewrite_node.index;
- adj[i].rewrite_header.node_index = ni;
- adj[i].rewrite_header.next_index = vlib_node_add_next (vm, ni, hw->output_node_index);
- if (is_arp)
- vnet_rewrite_for_sw_interface
- (vnm,
- VNET_L3_PACKET_TYPE_ARP,
- sw_if_index,
- ni,
- VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST,
- &adj[i].rewrite_header,
- sizeof (adj->rewrite_data));
- break;
-
- default:
- break;
- }
- }
-}
-
-static void unserialize_ip4_add_del_route_msg (serialize_main_t * m, va_list * va)
-{
- ip4_main_t * i4m = &ip4_main;
- ip4_add_del_route_args_t a;
-
- a.table_index_or_table_id = unserialize_likely_small_unsigned_integer (m);
- a.flags = unserialize_likely_small_unsigned_integer (m);
- unserialize (m, unserialize_ip4_address_and_length, &a.dst_address, &a.dst_address_length);
- a.adj_index = unserialize_likely_small_unsigned_integer (m);
- a.n_add_adj = unserialize_likely_small_unsigned_integer (m);
- a.add_adj = 0;
- if (a.n_add_adj > 0)
- {
- vec_resize (a.add_adj, a.n_add_adj);
- unserialize (m, unserialize_vec_ip_adjacency, a.add_adj, a.n_add_adj);
- unserialize_fixup_ip4_rewrite_adjacencies (vlib_get_main(),
- a.add_adj, a.n_add_adj);
- }
-
- /* Prevent re-re-distribution. */
- a.flags |= IP4_ROUTE_FLAG_NO_REDISTRIBUTE;
-
- ip4_add_del_route (i4m, &a);
-
- vec_free (a.add_adj);
-}
-
-MC_SERIALIZE_MSG (ip4_add_del_route_msg, static) = {
- .name = "vnet_ip4_add_del_route",
- .serialize = serialize_ip4_add_del_route_msg,
- .unserialize = unserialize_ip4_add_del_route_msg,
-};
-
static void
ip4_fib_set_adj_index (ip4_main_t * im,
ip4_fib_t * fib,
fib->new_hash_values);
p = hash_get (hash, dst_address_u32);
- memcpy (p, fib->new_hash_values, vec_bytes (fib->new_hash_values));
+ clib_memcpy (p, fib->new_hash_values, vec_bytes (fib->new_hash_values));
}
}
void ip4_add_del_route (ip4_main_t * im, ip4_add_del_route_args_t * a)
{
- vlib_main_t * vm = vlib_get_main();
ip_lookup_main_t * lm = &im->lookup_main;
ip4_fib_t * fib;
u32 dst_address, dst_address_length, adj_index, old_adj_index;
uword * hash, is_del;
ip4_add_del_route_callback_t * cb;
- if (vm->mc_main && ! (a->flags & IP4_ROUTE_FLAG_NO_REDISTRIBUTE))
- {
- u32 multiple_messages_per_vlib_buffer = (a->flags & IP4_ROUTE_FLAG_NOT_LAST_IN_GROUP);
- mc_serialize2 (vm->mc_main, multiple_messages_per_vlib_buffer,
- &ip4_add_del_route_msg, a);
- return;
- }
-
/* Either create new adjacency or use given one depending on arguments. */
if (a->n_add_adj > 0)
{
old_adj_index = fib->old_hash_values[0];
+ /* Avoid spurious reference count increments */
+ if (old_adj_index == adj_index
+ && adj_index != ~0
+ && !(a->flags & IP4_ROUTE_FLAG_KEEP_OLD_ADJACENCY))
+ {
+ ip_adjacency_t * adj = ip_get_adjacency (lm, adj_index);
+ if (adj->share_count > 0)
+ adj->share_count --;
+ }
+
ip4_fib_mtrie_add_del_route (fib, a->dst_address, dst_address_length,
is_del ? old_adj_index : adj_index,
is_del);
ip_del_adjacency (lm, old_adj_index);
}
-static void serialize_ip4_add_del_route_next_hop_msg (serialize_main_t * m, va_list * va)
-{
- u32 flags = va_arg (*va, u32);
- ip4_address_t * dst_address = va_arg (*va, ip4_address_t *);
- u32 dst_address_length = va_arg (*va, u32);
- ip4_address_t * next_hop_address = va_arg (*va, ip4_address_t *);
- u32 next_hop_sw_if_index = va_arg (*va, u32);
- u32 next_hop_weight = va_arg (*va, u32);
-
- serialize_likely_small_unsigned_integer (m, flags);
- serialize (m, serialize_ip4_address_and_length, dst_address, dst_address_length);
- serialize (m, serialize_ip4_address, next_hop_address);
- serialize_likely_small_unsigned_integer (m, next_hop_sw_if_index);
- serialize_likely_small_unsigned_integer (m, next_hop_weight);
-}
-
-static void unserialize_ip4_add_del_route_next_hop_msg (serialize_main_t * m, va_list * va)
-{
- ip4_main_t * im = &ip4_main;
- u32 flags, dst_address_length, next_hop_sw_if_index, next_hop_weight;
- ip4_address_t dst_address, next_hop_address;
-
- flags = unserialize_likely_small_unsigned_integer (m);
- unserialize (m, unserialize_ip4_address_and_length, &dst_address, &dst_address_length);
- unserialize (m, unserialize_ip4_address, &next_hop_address);
- next_hop_sw_if_index = unserialize_likely_small_unsigned_integer (m);
- next_hop_weight = unserialize_likely_small_unsigned_integer (m);
-
- ip4_add_del_route_next_hop
- (im,
- flags | IP4_ROUTE_FLAG_NO_REDISTRIBUTE,
- &dst_address,
- dst_address_length,
- &next_hop_address,
- next_hop_sw_if_index,
- next_hop_weight, (u32)~0,
- (u32)~0 /* explicit FIB index */);
-}
-
-MC_SERIALIZE_MSG (ip4_add_del_route_next_hop_msg, static) = {
- .name = "vnet_ip4_add_del_route_next_hop",
- .serialize = serialize_ip4_add_del_route_next_hop_msg,
- .unserialize = unserialize_ip4_add_del_route_next_hop_msg,
-};
-
void
ip4_add_del_route_next_hop (ip4_main_t * im,
u32 flags,
u32 explicit_fib_index)
{
vnet_main_t * vnm = vnet_get_main();
- vlib_main_t * vm = vlib_get_main();
ip_lookup_main_t * lm = &im->lookup_main;
u32 fib_index;
ip4_fib_t * fib;
int is_interface_next_hop;
clib_error_t * error = 0;
- if (vm->mc_main && ! (flags & IP4_ROUTE_FLAG_NO_REDISTRIBUTE))
- {
- u32 multiple_messages_per_vlib_buffer = (flags & IP4_ROUTE_FLAG_NOT_LAST_IN_GROUP);
- mc_serialize2 (vm->mc_main,
- multiple_messages_per_vlib_buffer,
- &ip4_add_del_route_next_hop_msg,
- flags,
- dst_address, dst_address_length,
- next_hop, next_hop_sw_if_index, next_hop_weight);
- return;
- }
-
if (explicit_fib_index == (u32)~0)
fib_index = vec_elt (im->fib_index_by_sw_if_index, next_hop_sw_if_index);
else
/* Next hop must be known. */
if (! nh_result)
{
- vnm->api_errno = VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB;
- error = clib_error_return (0, "next-hop %U/32 not in FIB",
- format_ip4_address, next_hop);
- goto done;
- }
- nh_adj_index = *nh_result;
- }
+ ip_adjacency_t * adj;
+
+ nh_adj_index = ip4_fib_lookup_with_table (im, fib_index,
+ next_hop, 0);
+ adj = ip_get_adjacency (lm, nh_adj_index);
+ /* if ARP interface adjacencty is present, we need to
+ install ARP adjaceny for specific next hop */
+ if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP &&
+ adj->arp.next_hop.ip4.as_u32 == 0)
+ {
+ nh_adj_index = vnet_arp_glean_add(fib_index, next_hop);
+ }
+ else
+ {
+ /* Next hop is not known, so create indirect adj */
+ ip_adjacency_t add_adj;
+ add_adj.lookup_next_index = IP_LOOKUP_NEXT_INDIRECT;
+ add_adj.indirect.next_hop.ip4.as_u32 = next_hop->as_u32;
+ add_adj.explicit_fib_index = explicit_fib_index;
+ ip_add_adjacency (lm, &add_adj, 1, &nh_adj_index);
+ }
+ }
+ else
+ nh_adj_index = *nh_result;
+ }
}
else
{
goto done;
}
+ /* Destination is not known and default weight is set so add route
+ to existing non-multipath adjacency */
+ if (dst_adj_index == ~0 && next_hop_weight == 1 && next_hop_sw_if_index == ~0)
+ {
+ /* create new adjacency */
+ ip4_add_del_route_args_t a;
+ a.table_index_or_table_id = fib_index;
+ a.flags = ((is_del ? IP4_ROUTE_FLAG_DEL : IP4_ROUTE_FLAG_ADD)
+ | IP4_ROUTE_FLAG_FIB_INDEX
+ | IP4_ROUTE_FLAG_KEEP_OLD_ADJACENCY
+ | (flags & (IP4_ROUTE_FLAG_NO_REDISTRIBUTE
+ | IP4_ROUTE_FLAG_NOT_LAST_IN_GROUP)));
+ a.dst_address = dst_address[0];
+ a.dst_address_length = dst_address_length;
+ a.adj_index = nh_adj_index;
+ a.add_adj = 0;
+ a.n_add_adj = 0;
+
+ ip4_add_del_route (im, &a);
+
+ goto done;
+ }
+
old_mp_adj_index = dst_adj ? dst_adj->heap_handle : ~0;
if (! ip_multipath_adjacency_add_del_next_hop
else
{
/* Remap to new adjacency. */
- memcpy (fib->old_hash_values, p->value, vec_bytes (fib->old_hash_values));
+ clib_memcpy (fib->old_hash_values, p->value, vec_bytes (fib->old_hash_values));
/* Set new adjacency value. */
fib->new_hash_values[0] = p->value[0] = m - 1;
ip4_lookup_inline (vlib_main_t * vm,
vlib_node_runtime_t * node,
vlib_frame_t * frame,
- int lookup_for_responses_to_locally_received_packets)
+ int lookup_for_responses_to_locally_received_packets,
+ int is_indirect)
{
ip4_main_t * im = &ip4_main;
ip_lookup_main_t * lm = &im->lookup_main;
ip_adjacency_t * adj0, * adj1;
ip4_fib_mtrie_t * mtrie0, * mtrie1;
ip4_fib_mtrie_leaf_t leaf0, leaf1;
+ ip4_address_t * dst_addr0, *dst_addr1;
__attribute__((unused)) u32 pi0, fib_index0, adj_index0, is_tcp_udp0;
__attribute__((unused)) u32 pi1, fib_index1, adj_index1, is_tcp_udp1;
u32 flow_hash_config0, flow_hash_config1;
ip0 = vlib_buffer_get_current (p0);
ip1 = vlib_buffer_get_current (p1);
+ if (is_indirect)
+ {
+ ip_adjacency_t * iadj0, * iadj1;
+ iadj0 = ip_get_adjacency (lm, vnet_buffer(p0)->ip.adj_index[VLIB_TX]);
+ iadj1 = ip_get_adjacency (lm, vnet_buffer(p1)->ip.adj_index[VLIB_TX]);
+ dst_addr0 = &iadj0->indirect.next_hop.ip4;
+ dst_addr1 = &iadj1->indirect.next_hop.ip4;
+ }
+ else
+ {
+ dst_addr0 = &ip0->dst_address;
+ dst_addr1 = &ip1->dst_address;
+ }
+
fib_index0 = vec_elt (im->fib_index_by_sw_if_index, vnet_buffer (p0)->sw_if_index[VLIB_RX]);
fib_index1 = vec_elt (im->fib_index_by_sw_if_index, vnet_buffer (p1)->sw_if_index[VLIB_RX]);
fib_index0 = (vnet_buffer(p0)->sw_if_index[VLIB_TX] == (u32)~0) ?
leaf0 = leaf1 = IP4_FIB_MTRIE_LEAF_ROOT;
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 0);
- leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->dst_address, 0);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 0);
+ leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 0);
}
tcp0 = (void *) (ip0 + 1);
if (! lookup_for_responses_to_locally_received_packets)
{
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 1);
- leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->dst_address, 1);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 1);
+ leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 1);
}
if (! lookup_for_responses_to_locally_received_packets)
{
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 2);
- leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->dst_address, 2);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 2);
+ leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 2);
}
if (! lookup_for_responses_to_locally_received_packets)
{
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 3);
- leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->dst_address, 3);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 3);
+ leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 3);
}
if (lookup_for_responses_to_locally_received_packets)
}
ASSERT (adj_index0 == ip4_fib_lookup_with_table (im, fib_index0,
- &ip0->dst_address,
+ dst_addr0,
/* no_default_route */ 0));
ASSERT (adj_index1 == ip4_fib_lookup_with_table (im, fib_index1,
- &ip1->dst_address,
+ dst_addr1,
/* no_default_route */ 0));
adj0 = ip_get_adjacency (lm, adj_index0);
adj1 = ip_get_adjacency (lm, adj_index1);
ip_adjacency_t * adj0;
ip4_fib_mtrie_t * mtrie0;
ip4_fib_mtrie_leaf_t leaf0;
+ ip4_address_t * dst_addr0;
__attribute__((unused)) u32 pi0, fib_index0, adj_index0, is_tcp_udp0;
u32 flow_hash_config0, hash_c0;
ip0 = vlib_buffer_get_current (p0);
+ if (is_indirect)
+ {
+ ip_adjacency_t * iadj0;
+ iadj0 = ip_get_adjacency (lm, vnet_buffer(p0)->ip.adj_index[VLIB_TX]);
+ dst_addr0 = &iadj0->indirect.next_hop.ip4;
+ }
+ else
+ {
+ dst_addr0 = &ip0->dst_address;
+ }
+
fib_index0 = vec_elt (im->fib_index_by_sw_if_index, vnet_buffer (p0)->sw_if_index[VLIB_RX]);
fib_index0 = (vnet_buffer(p0)->sw_if_index[VLIB_TX] == (u32)~0) ?
fib_index0 : vnet_buffer(p0)->sw_if_index[VLIB_TX];
leaf0 = IP4_FIB_MTRIE_LEAF_ROOT;
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 0);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 0);
}
tcp0 = (void *) (ip0 + 1);
|| ip0->protocol == IP_PROTOCOL_UDP);
if (! lookup_for_responses_to_locally_received_packets)
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 1);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 1);
if (! lookup_for_responses_to_locally_received_packets)
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 2);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 2);
if (! lookup_for_responses_to_locally_received_packets)
- leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->dst_address, 3);
+ leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 3);
if (lookup_for_responses_to_locally_received_packets)
adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_RX];
}
ASSERT (adj_index0 == ip4_fib_lookup_with_table (im, fib_index0,
- &ip0->dst_address,
+ dst_addr0,
/* no_default_route */ 0));
adj0 = ip_get_adjacency (lm, adj_index0);
vlib_node_runtime_t * node,
vlib_frame_t * frame)
{
- return ip4_lookup_inline (vm, node, frame, /* lookup_for_responses_to_locally_received_packets */ 0);
+ return ip4_lookup_inline (vm, node, frame,
+ /* lookup_for_responses_to_locally_received_packets */ 0,
+ /* is_indirect */ 0);
}
n = IP_LOOKUP_NEXT_ARP;
node_index = ip4_arp_node.index;
adj->if_address_index = if_address_index;
+ adj->arp.next_hop.ip4.as_u32 = 0;
+ ip46_address_reset(&adj->arp.next_hop);
packet_type = VNET_L3_PACKET_TYPE_ARP;
}
else
if (classify_table_index != (u32) ~0)
{
adj->lookup_next_index = IP_LOOKUP_NEXT_CLASSIFY;
- adj->classify_table_index = classify_table_index;
+ adj->classify.table_index = classify_table_index;
}
else
adj->lookup_next_index = IP_LOOKUP_NEXT_LOCAL;
u32 length;
} ip4_interface_address_t;
-static void serialize_vec_ip4_set_interface_address (serialize_main_t * m, va_list * va)
-{
- ip4_interface_address_t * a = va_arg (*va, ip4_interface_address_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- for (i = 0; i < n; i++) {
- serialize_integer (m, a[i].sw_if_index, sizeof (a[i].sw_if_index));
- serialize (m, serialize_ip4_address, &a[i].address);
- serialize_integer (m, a[i].length, sizeof (a[i].length));
- }
-}
-
-static void unserialize_vec_ip4_set_interface_address (serialize_main_t * m, va_list * va)
-{
- ip4_interface_address_t * a = va_arg (*va, ip4_interface_address_t *);
- u32 n = va_arg (*va, u32);
- u32 i;
- for (i = 0; i < n; i++) {
- unserialize_integer (m, &a[i].sw_if_index, sizeof (a[i].sw_if_index));
- unserialize (m, unserialize_ip4_address, &a[i].address);
- unserialize_integer (m, &a[i].length, sizeof (a[i].length));
- }
-}
-
-static void serialize_ip4_set_interface_address_msg (serialize_main_t * m, va_list * va)
-{
- ip4_interface_address_t * a = va_arg (*va, ip4_interface_address_t *);
- int is_del = va_arg (*va, int);
- serialize (m, serialize_vec_ip4_set_interface_address, a, 1);
- serialize_integer (m, is_del, sizeof (is_del));
-}
-
static clib_error_t *
ip4_add_del_interface_address_internal (vlib_main_t * vm,
u32 sw_if_index,
u32 insert_routes,
u32 is_del);
-static void unserialize_ip4_set_interface_address_msg (serialize_main_t * m, va_list * va)
-{
- mc_main_t * mcm = va_arg (*va, mc_main_t *);
- vlib_main_t * vm = mcm->vlib_main;
- ip4_interface_address_t a;
- clib_error_t * error;
- int is_del;
-
- unserialize (m, unserialize_vec_ip4_set_interface_address, &a, 1);
- unserialize_integer (m, &is_del, sizeof (is_del));
- error = ip4_add_del_interface_address_internal
- (vm, a.sw_if_index, &a.address, a.length,
- /* redistribute */ 0,
- /* insert_routes */ 1,
- is_del);
- if (error)
- clib_error_report (error);
-}
-
-MC_SERIALIZE_MSG (ip4_set_interface_address_msg, static) = {
- .name = "vnet_ip4_set_interface_address",
- .serialize = serialize_ip4_set_interface_address_msg,
- .unserialize = unserialize_ip4_set_interface_address_msg,
-};
-
static clib_error_t *
ip4_add_del_interface_address_internal (vlib_main_t * vm,
u32 sw_if_index,
}));
}
- if (vm->mc_main && redistribute)
- {
- ip4_interface_address_t a;
- a.sw_if_index = sw_if_index;
- a.address = address[0];
- a.length = address_length;
- mc_serialize (vm->mc_main, &ip4_set_interface_address_msg,
- &a, (int)is_del);
- goto done;
- }
-
elts_before = pool_elts (lm->if_address_pool);
error = ip_interface_address_add_del
is_del);
}
-static void serialize_ip4_fib (serialize_main_t * m, va_list * va)
-{
- ip4_fib_t * f = va_arg (*va, ip4_fib_t *);
- u32 l, dst, adj_index;
-
- serialize_integer (m, f->table_id, sizeof (f->table_id));
- for (l = 0; l < ARRAY_LEN (f->adj_index_by_dst_address); l++)
- {
- u32 n_elts = hash_elts (f->adj_index_by_dst_address[l]);
-
- serialize_integer (m, n_elts, sizeof (n_elts));
- hash_foreach (dst, adj_index, f->adj_index_by_dst_address[l], ({
- ip4_address_t tmp;
- tmp.as_u32 = dst;
- serialize (m, serialize_ip4_address, &tmp);
- serialize_integer (m, adj_index, sizeof (adj_index));
- }));
- }
-}
-
-static void unserialize_ip4_fib (serialize_main_t * m, va_list * va)
-{
- ip4_add_del_route_args_t a;
- u32 i;
-
- a.flags = (IP4_ROUTE_FLAG_ADD
- | IP4_ROUTE_FLAG_NO_REDISTRIBUTE
- | IP4_ROUTE_FLAG_TABLE_ID);
- a.n_add_adj = 0;
- a.add_adj = 0;
-
- unserialize_integer (m, &a.table_index_or_table_id,
- sizeof (a.table_index_or_table_id));
-
- for (i = 0; i < STRUCT_ARRAY_LEN (ip4_fib_t, adj_index_by_dst_address); i++)
- {
- u32 n_elts;
- unserialize_integer (m, &n_elts, sizeof (u32));
- a.dst_address_length = i;
- while (n_elts > 0)
- {
- unserialize (m, unserialize_ip4_address, &a.dst_address);
- unserialize_integer (m, &a.adj_index, sizeof (a.adj_index));
- ip4_add_del_route (&ip4_main, &a);
- n_elts--;
- }
- }
-}
-
-void serialize_vnet_ip4_main (serialize_main_t * m, va_list * va)
-{
- vnet_main_t * vnm = va_arg (*va, vnet_main_t *);
- vnet_interface_main_t * vim = &vnm->interface_main;
- vnet_sw_interface_t * si;
- ip4_main_t * i4m = &ip4_main;
- ip4_interface_address_t * as = 0, * a;
-
- /* Download adjacency tables & multipath stuff. */
- serialize (m, serialize_ip_lookup_main, &i4m->lookup_main);
-
- /* FIBs. */
- {
- ip4_fib_t * f;
- u32 n_fibs = vec_len (i4m->fibs);
- serialize_integer (m, n_fibs, sizeof (n_fibs));
- vec_foreach (f, i4m->fibs)
- serialize (m, serialize_ip4_fib, f);
- }
-
- /* FIB interface config. */
- vec_serialize (m, i4m->fib_index_by_sw_if_index, serialize_vec_32);
-
- /* Interface ip4 addresses. */
- pool_foreach (si, vim->sw_interfaces, ({
- u32 sw_if_index = si->sw_if_index;
- ip_interface_address_t * ia;
- foreach_ip_interface_address (&i4m->lookup_main, ia, sw_if_index,
- 0 /* honor unnumbered */,
- ({
- ip4_address_t * x = ip_interface_address_get_address (&i4m->lookup_main, ia);
- vec_add2 (as, a, 1);
- a->address = x[0];
- a->length = ia->address_length;
- a->sw_if_index = sw_if_index;
- }));
- }));
- vec_serialize (m, as, serialize_vec_ip4_set_interface_address);
- vec_free (as);
-}
-
-void unserialize_vnet_ip4_main (serialize_main_t * m, va_list * va)
-{
- vlib_main_t * vm = va_arg (*va, vlib_main_t *);
- ip4_main_t * i4m = &ip4_main;
- ip4_interface_address_t * as = 0, * a;
-
- unserialize (m, unserialize_ip_lookup_main, &i4m->lookup_main);
-
- {
- ip_adjacency_t * adj, * adj_heap;
- u32 n_adj;
- adj_heap = i4m->lookup_main.adjacency_heap;
- heap_foreach (adj, n_adj, adj_heap, ({
- unserialize_fixup_ip4_rewrite_adjacencies (vm, adj, n_adj);
- ip_call_add_del_adjacency_callbacks (&i4m->lookup_main, adj - adj_heap, /* is_del */ 0);
- }));
- }
-
- /* FIBs */
- {
- u32 i, n_fibs;
- unserialize_integer (m, &n_fibs, sizeof (n_fibs));
- for (i = 0; i < n_fibs; i++)
- unserialize (m, unserialize_ip4_fib);
- }
-
- vec_unserialize (m, &i4m->fib_index_by_sw_if_index, unserialize_vec_32);
-
- vec_unserialize (m, &as, unserialize_vec_ip4_set_interface_address);
- vec_foreach (a, as) {
- ip4_add_del_interface_address_internal
- (vm, a->sw_if_index, &a->address, a->length,
- /* redistribute */ 0,
- /* insert_routes */ 0,
- /* is_del */ 0);
- }
- vec_free (as);
-}
-
static clib_error_t *
ip4_sw_interface_admin_up_down (vnet_main_t * vnm,
u32 sw_if_index,
VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip4_sw_interface_add_del);
+
VLIB_REGISTER_NODE (ip4_lookup_node) = {
.function = ip4_lookup,
.name = "ip4-lookup",
.vector_size = sizeof (u32),
.n_next_nodes = IP_LOOKUP_N_NEXT,
- .next_nodes = {
- [IP_LOOKUP_NEXT_MISS] = "ip4-miss",
- [IP_LOOKUP_NEXT_DROP] = "ip4-drop",
- [IP_LOOKUP_NEXT_PUNT] = "ip4-punt",
- [IP_LOOKUP_NEXT_LOCAL] = "ip4-local",
- [IP_LOOKUP_NEXT_ARP] = "ip4-arp",
- [IP_LOOKUP_NEXT_REWRITE] = "ip4-rewrite-transit",
- [IP_LOOKUP_NEXT_CLASSIFY] = "ip4-classify",
- [IP_LOOKUP_NEXT_MAP] = "ip4-map",
- [IP_LOOKUP_NEXT_MAP_T] = "ip4-map-t",
- [IP_LOOKUP_NEXT_SIXRD] = "ip4-sixrd",
- [IP_LOOKUP_NEXT_HOP_BY_HOP] = "ip4-hop-by-hop",
- [IP_LOOKUP_NEXT_ADD_HOP_BY_HOP] = "ip4-add-hop-by-hop",
- [IP_LOOKUP_NEXT_POP_HOP_BY_HOP] = "ip4-pop-hop-by-hop",
- },
+ .next_nodes = IP4_LOOKUP_NEXT_NODES,
};
+static uword
+ip4_indirect (vlib_main_t * vm,
+ vlib_node_runtime_t * node,
+ vlib_frame_t * frame)
+{
+ return ip4_lookup_inline (vm, node, frame,
+ /* lookup_for_responses_to_locally_received_packets */ 0,
+ /* is_indirect */ 1);
+}
+
+VLIB_REGISTER_NODE (ip4_indirect_node) = {
+ .function = ip4_indirect,
+ .name = "ip4-indirect",
+ .vector_size = sizeof (u32),
+
+ .n_next_nodes = IP_LOOKUP_N_NEXT,
+ .next_nodes = IP4_LOOKUP_NEXT_NODES,
+};
+
+
/* Global IP4 main. */
ip4_main_t ip4_main;
uword indent = format_get_indent (s);
adj = ip_get_adjacency (&im->lookup_main, t->adj_index);
- s = format (s, "fib: %d adjacency: %U flow hash: 0x%08x",
- t->fib_index, format_ip_adjacency,
+ s = format (s, "fib %d adj-idx %d : %U flow hash: 0x%08x",
+ t->fib_index, t->adj_index, format_ip_adjacency,
vnm, &im->lookup_main, t->adj_index, t->flow_hash);
switch (adj->lookup_next_index)
{
t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
t0->fib_index = vec_elt (im->fib_index_by_sw_if_index,
vnet_buffer(b0)->sw_if_index[VLIB_RX]);
- memcpy (t0->packet_data,
+ clib_memcpy (t0->packet_data,
vlib_buffer_get_current (b0),
sizeof (t0->packet_data));
}
t1->flow_hash = vnet_buffer (b1)->ip.flow_hash;
t1->fib_index = vec_elt (im->fib_index_by_sw_if_index,
vnet_buffer(b1)->sw_if_index[VLIB_RX]);
- memcpy (t1->packet_data,
+ clib_memcpy (t1->packet_data,
vlib_buffer_get_current (b1),
sizeof (t1->packet_data));
}
t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
t0->fib_index = vec_elt (im->fib_index_by_sw_if_index,
vnet_buffer(b0)->sw_if_index[VLIB_RX]);
- memcpy (t0->packet_data,
+ clib_memcpy (t0->packet_data,
vlib_buffer_get_current (b0),
sizeof (t0->packet_data));
}
.next_nodes = {
[IP_LOCAL_NEXT_DROP] = "error-drop",
[IP_LOCAL_NEXT_PUNT] = "error-punt",
- // [IP_LOCAL_NEXT_TCP_LOOKUP] = "ip4-tcp-lookup",
[IP_LOCAL_NEXT_UDP_LOOKUP] = "ip4-udp-lookup",
[IP_LOCAL_NEXT_ICMP] = "ip4-icmp-input",
},
adj0 = ip_get_adjacency (lm, adj_index0);
ip0 = vlib_buffer_get_current (p0);
+ /* If packet destination is not local, send ARP to next hop */
+ if (adj0->arp.next_hop.ip4.as_u32)
+ ip0->dst_address.data_u32 = adj0->arp.next_hop.ip4.as_u32;
+
/*
* if ip4_rewrite_local applied the IP_LOOKUP_NEXT_ARP
* rewrite to this packet, we need to skip it here.
hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
/* Src ethernet address in ARP header. */
- memcpy (h0->ip4_over_ethernet[0].ethernet, hw_if0->hw_address,
+ clib_memcpy (h0->ip4_over_ethernet[0].ethernet, hw_if0->hw_address,
sizeof (h0->ip4_over_ethernet[0].ethernet));
ip4_src_address_for_packet (im, p0, &h0->ip4_over_ethernet[0].ip4, sw_if_index0);
hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
- memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address, sizeof (h->ip4_over_ethernet[0].ethernet));
+ clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address, sizeof (h->ip4_over_ethernet[0].ethernet));
h->ip4_over_ethernet[0].ip4 = src[0];
h->ip4_over_ethernet[1].ip4 = dst[0];
.vector_size = sizeof (u32),
.n_next_nodes = IP_LOOKUP_N_NEXT,
- .next_nodes = {
- [IP_LOOKUP_NEXT_MISS] = "ip4-miss",
- [IP_LOOKUP_NEXT_DROP] = "ip4-drop",
- [IP_LOOKUP_NEXT_PUNT] = "ip4-punt",
- [IP_LOOKUP_NEXT_LOCAL] = "ip4-local",
- [IP_LOOKUP_NEXT_ARP] = "ip4-arp",
- [IP_LOOKUP_NEXT_REWRITE] = "ip4-rewrite-transit",
- [IP_LOOKUP_NEXT_CLASSIFY] = "ip4-classify",
- [IP_LOOKUP_NEXT_MAP] = "ip4-map",
- [IP_LOOKUP_NEXT_MAP_T] = "ip4-map-t",
- [IP_LOOKUP_NEXT_SIXRD] = "ip4-sixrd",
- [IP_LOOKUP_NEXT_HOP_BY_HOP] = "ip4-hop-by-hop",
- [IP_LOOKUP_NEXT_ADD_HOP_BY_HOP] = "ip4-add-hop-by-hop",
- [IP_LOOKUP_NEXT_POP_HOP_BY_HOP] = "ip4-pop-hop-by-hop",
- },
+ .next_nodes = IP4_LOOKUP_NEXT_NODES,
};
VLIB_REGISTER_NODE (ip4_multicast_node,static) = {
Code Review / vpp.git / blobdiff