diff options
Diffstat (limited to 'vnet')
| -rw-r--r-- | vnet/Makefile.am | 3 | ||||
| -rw-r--r-- | vnet/vnet/api_errno.h | 4 | ||||
| -rw-r--r-- | vnet/vnet/devices/dpdk/device.c | 72 | ||||
| -rw-r--r-- | vnet/vnet/devices/dpdk/dpdk.h | 3 | ||||
| -rw-r--r-- | vnet/vnet/devices/virtio/vhost-user.c | 2 | ||||
| -rw-r--r-- | vnet/vnet/ip/lookup.h | 4 | ||||
| -rw-r--r-- | vnet/vnet/sr/examples/sr_multicastmap.script | 4 | ||||
| -rw-r--r-- | vnet/vnet/sr/sr.c | 633 | ||||
| -rw-r--r-- | vnet/vnet/sr/sr.h | 71 | ||||
| -rw-r--r-- | vnet/vnet/sr/sr_replicate.c | 366 |
10 files changed, 1124 insertions, 38 deletions
diff --git a/vnet/Makefile.am b/vnet/Makefile.am index d8778eb6a10..a69734d1530 100644 --- a/vnet/Makefile.am +++ b/vnet/Makefile.am @@ -527,7 +527,8 @@ nobase_include_HEADERS += \ if WITH_IPV6SR libvnet_la_SOURCES += \ - vnet/sr/sr.c + vnet/sr/sr.c \ + vnet/sr/sr_replicate.c endif nobase_include_HEADERS += \ diff --git a/vnet/vnet/api_errno.h b/vnet/vnet/api_errno.h index 04779f0bf1f..6d3dbbac7bd 100644 --- a/vnet/vnet/api_errno.h +++ b/vnet/vnet/api_errno.h @@ -72,7 +72,9 @@ _(NOT_CONNECTED, -78, "Not connected to the data plane") \ _(IF_ALREADY_EXISTS, -79, "Interface already exists") \ _(BOND_SLAVE_NOT_ALLOWED, -80, "Operation not allowed on slave of BondEthernet") \ _(VALUE_EXIST, -81, "Value already exists") \ -_(SAME_SRC_DST, -82, "Source and destination are the same") +_(SAME_SRC_DST, -82, "Source and destination are the same") \ +_(IP6_MULTICAST_ADDRESS_NOT_PRESENT, -83, "IP6 multicast address required") \ +_(SR_POLICY_NAME_NOT_PRESENT, -84, "Segement routing policy name required") typedef enum { #define _(a,b,c) VNET_API_ERROR_##a = (b), diff --git a/vnet/vnet/devices/dpdk/device.c b/vnet/vnet/devices/dpdk/device.c index 011ec75e18b..20c8b8f77cc 100644 --- a/vnet/vnet/devices/dpdk/device.c +++ b/vnet/vnet/devices/dpdk/device.c @@ -77,7 +77,7 @@ dpdk_set_mc_filter (vnet_hw_interface_t * hi, } } -static struct rte_mbuf * dpdk_replicate_packet_mb (vlib_buffer_t * b) +struct rte_mbuf * dpdk_replicate_packet_mb (vlib_buffer_t * b) { vlib_main_t * vm = vlib_get_main(); vlib_buffer_main_t * bm = vm->buffer_main; @@ -147,6 +147,74 @@ static struct rte_mbuf * dpdk_replicate_packet_mb (vlib_buffer_t * b) return first_mb; } +struct rte_mbuf * dpdk_zerocopy_replicate_packet_mb (vlib_buffer_t * b) +{ + vlib_main_t * vm = vlib_get_main(); + vlib_buffer_main_t * bm = vm->buffer_main; + struct rte_mbuf * first_mb = 0, * new_mb, * pkt_mb, ** prev_mb_next = 0; + u8 nb_segs, nb_segs_left; + unsigned socket_id = rte_socket_id(); + + ASSERT (bm->pktmbuf_pools[socket_id]); + pkt_mb = rte_mbuf_from_vlib_buffer(b); + nb_segs = pkt_mb->nb_segs; + for (nb_segs_left = nb_segs; nb_segs_left; nb_segs_left--) + { + if (PREDICT_FALSE(pkt_mb == 0)) + { + clib_warning ("Missing %d mbuf chain segment(s): " + "(nb_segs = %d, nb_segs_left = %d)!", + nb_segs - nb_segs_left, nb_segs, nb_segs_left); + if (first_mb) + rte_pktmbuf_free(first_mb); + return NULL; + } + new_mb = rte_pktmbuf_clone(pkt_mb, bm->pktmbuf_pools[socket_id]); + if (PREDICT_FALSE(new_mb == 0)) + { + if (first_mb) + rte_pktmbuf_free(first_mb); + return NULL; + } + + /* + * Copy packet info into 1st segment. + */ + if (first_mb == 0) + { + first_mb = new_mb; + rte_pktmbuf_pkt_len (first_mb) = pkt_mb->pkt_len; + first_mb->nb_segs = pkt_mb->nb_segs; + first_mb->port = pkt_mb->port; +#ifdef DAW_FIXME // TX Offload support TBD + first_mb->vlan_macip = pkt_mb->vlan_macip; + first_mb->hash = pkt_mb->hash; + first_mb->ol_flags = pkt_mb->ol_flags +#endif + } + else + { + ASSERT(prev_mb_next != 0); + *prev_mb_next = new_mb; + } + + /* + * Copy packet segment data into new mbuf segment. + */ + rte_pktmbuf_data_len (new_mb) = pkt_mb->data_len; + + prev_mb_next = &new_mb->next; + pkt_mb = pkt_mb->next; + } + + ASSERT(pkt_mb == 0); + __rte_mbuf_sanity_check(first_mb, 1); + + return first_mb; + + +} + static void dpdk_tx_trace_buffer (dpdk_main_t * dm, vlib_node_runtime_t * node, @@ -686,7 +754,7 @@ dpdk_interface_tx (vlib_main_t * vm, i++; } } - + n_left -= 2; } while (n_left > 0) diff --git a/vnet/vnet/devices/dpdk/dpdk.h b/vnet/vnet/devices/dpdk/dpdk.h index c6b0711d446..019d83f797a 100644 --- a/vnet/vnet/devices/dpdk/dpdk.h +++ b/vnet/vnet/devices/dpdk/dpdk.h @@ -468,6 +468,9 @@ u32 dpdk_get_handoff_node_index (void); void set_efd_bitmap (u8 *bitmap, u32 value, u32 op); +struct rte_mbuf * dpdk_replicate_packet_mb (vlib_buffer_t * b); +struct rte_mbuf * dpdk_zerocopy_replicate_packet_mb (vlib_buffer_t * b); + #define foreach_dpdk_error \ _(NONE, "no error") \ _(RX_PACKET_ERROR, "Rx packet errors") \ diff --git a/vnet/vnet/devices/virtio/vhost-user.c b/vnet/vnet/devices/virtio/vhost-user.c index f52de25416f..8486135dd69 100644 --- a/vnet/vnet/devices/virtio/vhost-user.c +++ b/vnet/vnet/devices/virtio/vhost-user.c @@ -1031,7 +1031,7 @@ static u32 vhost_user_if_input ( vlib_main_t * vm, error = VHOST_USER_INPUT_FUNC_ERROR_UNDERSIZED_FRAME; } - VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b); + VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b_head); vnet_buffer (b_head)->sw_if_index[VLIB_RX] = vui->sw_if_index; vnet_buffer (b_head)->sw_if_index[VLIB_TX] = (u32)~0; diff --git a/vnet/vnet/ip/lookup.h b/vnet/vnet/ip/lookup.h index e9a49124105..9c88b85c285 100644 --- a/vnet/vnet/ip/lookup.h +++ b/vnet/vnet/ip/lookup.h @@ -471,9 +471,13 @@ ip_update_adjacency (ip_lookup_main_t * lm, static inline int ip_adjacency_is_multipath(ip_lookup_main_t * lm, u32 adj_index) { + if (!vec_len(lm->multipath_adjacencies)) + return 0; + if (vec_len(lm->multipath_adjacencies) < adj_index - 1) return 0; + return (lm->multipath_adjacencies[adj_index].adj_index == adj_index && lm->multipath_adjacencies[adj_index].n_adj_in_block > 0); } diff --git a/vnet/vnet/sr/examples/sr_multicastmap.script b/vnet/vnet/sr/examples/sr_multicastmap.script new file mode 100644 index 00000000000..20bf7dc0eb7 --- /dev/null +++ b/vnet/vnet/sr/examples/sr_multicastmap.script @@ -0,0 +1,4 @@ +sr_tunnel_add_del name sr2 src ::a:1:1:0:6 dst ff15::2/128 next ::a:1:1:0:f next ::a:1:1:0:1a next ff15::1 tag ::a:1:1:0:7 clean +sr_tunnel_add_del name sr3 src ::b:1:1:0:6 dst ff16::2/128 next ::a:1:1:0:13 next ::a:1:1:0:1a next ff15::1 tag ::a:1:1:0:7 clean +sr_policy_add_del name pol1 tunnel sr2 tunnel sr3 +sr_multicast_map_add_del address ff15::1 sr-policy pol1 diff --git a/vnet/vnet/sr/sr.c b/vnet/vnet/sr/sr.c index 699df992d15..e17b474e9e7 100644 --- a/vnet/vnet/sr/sr.c +++ b/vnet/vnet/sr/sr.c @@ -23,7 +23,7 @@ ip6_sr_main_t sr_main; static vlib_node_registration_t sr_local_node; -static void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, +void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, ip6_sr_header_t * sr) { u32 key_index; @@ -204,7 +204,8 @@ u8 * format_ip6_sr_header_with_length (u8 * s, va_list * args) #define foreach_sr_rewrite_next \ _(ERROR, "error-drop") \ _(IP6_LOOKUP, "ip6-lookup") \ -_(SR_LOCAL, "sr-local") +_(SR_LOCAL, "sr-local") \ +_(SR_REPLICATE,"sr-replicate") typedef enum { #define _(s,n) SR_REWRITE_NEXT_##s, @@ -289,7 +290,8 @@ sr_rewrite (vlib_main_t * vm, vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); - while (n_left_from >= 4 && n_left_to_next >= 2) + /* Note 2x loop disabled */ + while (0 && n_left_from >= 4 && n_left_to_next >= 2) { u32 bi0, bi1; vlib_buffer_t * b0, * b1; @@ -301,7 +303,8 @@ sr_rewrite (vlib_main_t * vm, u64 * copy_src1, * copy_dst1; u32 next0 = SR_REWRITE_NEXT_IP6_LOOKUP; u32 next1 = SR_REWRITE_NEXT_IP6_LOOKUP; - u16 new_l0, new_l1; + u16 new_l0 = 0; + u16 new_l1 = 0; /* Prefetch next iteration. */ { @@ -490,13 +493,13 @@ sr_rewrite (vlib_main_t * vm, { u32 bi0; vlib_buffer_t * b0; - ip6_header_t * ip0; + ip6_header_t * ip0 = 0; ip_adjacency_t * adj0; - ip6_sr_header_t * sr0; + ip6_sr_header_t * sr0 = 0; ip6_sr_tunnel_t * t0; u64 * copy_src0, * copy_dst0; u32 next0 = SR_REWRITE_NEXT_IP6_LOOKUP; - u16 new_l0; + u16 new_l0 = 0; bi0 = from[0]; to_next[0] = bi0; @@ -516,6 +519,14 @@ sr_rewrite (vlib_main_t * vm, t0 = pool_elt_at_index (sm->tunnels, adj0->rewrite_header.sw_if_index); + /* add a replication node */ + if(PREDICT_FALSE(t0->policy_index != ~0)) + { + vnet_buffer(b0)->ip.save_protocol = t0->policy_index; + next0=SR_REWRITE_NEXT_SR_REPLICATE; + goto trace0; + } + ASSERT (VLIB_BUFFER_PRE_DATA_SIZE >= ((word) vec_len (t0->rewrite)) + b0->current_data); @@ -582,15 +593,19 @@ sr_rewrite (vlib_main_t * vm, } } + trace0: if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) { sr_rewrite_trace_t *tr = vlib_add_trace (vm, node, b0, sizeof (*tr)); tr->tunnel_index = t0 - sm->tunnels; - clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8, + if (ip0) + { + memcpy (tr->src.as_u8, ip0->src_address.as_u8, sizeof (tr->src.as_u8)); - clib_memcpy (tr->dst.as_u8, ip0->dst_address.as_u8, + memcpy (tr->dst.as_u8, ip0->dst_address.as_u8, sizeof (tr->dst.as_u8)); + } tr->length = new_l0; tr->next_index = next0; clib_memcpy (tr->sr, sr0, sizeof (tr->sr)); @@ -715,6 +730,7 @@ find_or_add_shared_secret (ip6_sr_main_t * sm, u8 * secret, u32 * indexp) return (key); } + int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a) { ip6_main_t * im = &ip6_main; @@ -733,6 +749,8 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a) ip6_add_del_route_args_t aa; u32 hmac_key_index_u32; u8 hmac_key_index = 0; + ip6_sr_policy_t * pt; + int i; /* Make sure that the rx FIB exists */ p = hash_get (im->fib_index_by_table_id, a->rx_table_id); @@ -755,7 +773,11 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a) clib_memcpy (key.src.as_u8, a->src_address->as_u8, sizeof (key.src)); clib_memcpy (key.dst.as_u8, a->dst_address->as_u8, sizeof (key.dst)); - p = hash_get_mem (sm->tunnel_index_by_key, &key); + /* If the name exists, find the tunnel by name else... */ + if (a->name) + p = hash_get_mem(sm->tunnel_index_by_name, a->name); + else if (p==0) + p = hash_get_mem (sm->tunnel_index_by_key, &key); if (p) { @@ -769,6 +791,36 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a) ip6_delete_route_no_next_hop (&t->key.dst, t->dst_mask_width, a->rx_table_id); vec_free (t->rewrite); + /* Remove tunnel from any policy if associated */ + if (t->policy_index != ~0) + { + pt=pool_elt_at_index (sm->policies, t->policy_index); + for (i=0; i< vec_len (pt->tunnel_indices); i++) + { + if (pt->tunnel_indices[i] == t - sm->tunnels) + { + vec_delete (pt->tunnel_indices, 1, i); + goto found; + } + } + clib_warning ("Tunnel index %d not found in policy_index %d", + t - sm->tunnels, pt - sm->policies); + found: + /* If this is last tunnel in the policy, clean up the policy too */ + if (vec_len (pt->tunnel_indices) == 0) + { + hash_unset_mem (sm->policy_index_by_policy_name, pt->name); + vec_free (pt->name); + pool_put (sm->policies, pt); + } + } + + /* Clean up the tunnel by name */ + if (t->name) + { + hash_unset_mem (sm->tunnel_index_by_name, t->name); + vec_free (t->name); + } pool_put (sm->tunnels, t); hp = hash_get_pair (sm->tunnel_index_by_key, &key); key_copy = (void *)(hp->key); @@ -789,6 +841,7 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a) /* create a new tunnel */ pool_get (sm->tunnels, t); memset (t, 0, sizeof (*t)); + t->policy_index = ~0; clib_memcpy (&t->key, &key, sizeof (t->key)); t->dst_mask_width = a->dst_mask_width; @@ -902,6 +955,31 @@ int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a) ip6_add_del_route (im, &aa); vec_free (add_adj); + if (a->policy_name) + { + p=hash_get_mem (sm->policy_index_by_policy_name, a->policy_name); + if (p) + { + pt = pool_elt_at_index (sm->policies, p[0]); + } + else /* no policy, lets create one */ + { + pool_get (sm->policies, pt); + memset (pt, 0, sizeof(*pt)); + pt->name = format (0, "%s%c", a->policy_name, 0); + hash_set_mem (sm->policy_index_by_policy_name, pt->name, pt - sm->policies); + p=hash_get_mem (sm->policy_index_by_policy_name, a->policy_name); + } + vec_add1 (pt->tunnel_indices, t - sm->tunnels); + t->policy_index = p[0]; /* equiv. to (pt - sm->policies) */ + } + + if (a->name) + { + t->name = format (0, "%s%c", a->name, 0); + hash_set_mem(sm->tunnel_index_by_name, t->name, t - sm->tunnels); + } + return 0; } @@ -918,6 +996,8 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm, int dst_address_set = 0; u16 flags = 0; u8 *shared_secret = 0; + u8 *name = 0; + u8 *policy_name = 0; u32 rx_table_id = 0; u32 tx_table_id = 0; ip6_address_t * segments = 0; @@ -939,6 +1019,10 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm, ; else if (unformat (input, "src %U", unformat_ip6_address, &src_address)) src_address_set = 1; + else if (unformat (input, "name %s", &name)) + ; + else if (unformat (input, "policy %s", &policy_name)) + ; else if (unformat (input, "dst %U/%d", unformat_ip6_address, &dst_address, &dst_mask_width)) @@ -1013,6 +1097,16 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm, a->tx_table_id = tx_table_id; a->shared_secret = shared_secret; + if (vec_len(name)) + a->name = name; + else + a->name = 0; + + if (vec_len(policy_name)) + a->policy_name = policy_name; + else + a->policy_name = 0; + rv = ip6_sr_add_del_tunnel (a); vec_free (segments); @@ -1051,10 +1145,46 @@ sr_add_del_tunnel_command_fn (vlib_main_t * vm, VLIB_CLI_COMMAND (sr_tunnel_command, static) = { .path = "sr tunnel", .short_help = - "sr tunnel [del] <src> <dst> [next <addr>] [cleanup] [reroute] [key %s]", + "sr tunnel [del] [name <name>] src <addr> dst <addr> [next <addr>] [cleanup] [reroute] [key %s] [policy <policy_name>", .function = sr_add_del_tunnel_command_fn, }; +void +ip6_sr_tunnel_display (vlib_main_t * vm, + ip6_sr_tunnel_t * t) +{ + ip6_main_t * im = &ip6_main; + ip6_sr_main_t * sm = &sr_main; + ip6_fib_t * rx_fib, * tx_fib; + ip6_sr_policy_t * pt; + + rx_fib = find_ip6_fib_by_table_index_or_id (im, t->rx_fib_index, + IP6_ROUTE_FLAG_FIB_INDEX); + + tx_fib = find_ip6_fib_by_table_index_or_id (im, t->tx_fib_index, + IP6_ROUTE_FLAG_FIB_INDEX); + + if (t->name) + vlib_cli_output (vm,"sr tunnel name: %s", (char *)t->name); + + vlib_cli_output (vm, "src %U dst %U first hop %U", + format_ip6_address, &t->key.src, + format_ip6_address, &t->key.dst, + format_ip6_address, &t->first_hop); + vlib_cli_output (vm, " rx-fib-id %d tx-fib-id %d", + rx_fib->table_id, tx_fib->table_id); + vlib_cli_output (vm, " sr: %U", format_ip6_sr_header, t->rewrite, + 0 /* print_hmac */); + + if (t->policy_index != ~0) + { + pt=pool_elt_at_index(sm->policies, t->policy_index); + vlib_cli_output (vm,"sr policy: %s", (char *)pt->name); + } + vlib_cli_output (vm, "-------"); + + return; +} static clib_error_t * show_sr_tunnel_fn (vlib_main_t * vm, @@ -1064,39 +1194,41 @@ show_sr_tunnel_fn (vlib_main_t * vm, static ip6_sr_tunnel_t ** tunnels; ip6_sr_tunnel_t * t; ip6_sr_main_t * sm = &sr_main; - ip6_main_t * im = &ip6_main; - ip6_fib_t * rx_fib, * tx_fib; int i; + uword * p = 0; + u8 *name = 0; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "name %s", &name)) + { + p=hash_get_mem (sm->tunnel_index_by_name, name); + if(!p) + vlib_cli_output (vm, "No SR tunnel with name: %s. Showing all.", name); + } + else + break; + } vec_reset_length (tunnels); + if(!p) /* Either name parm not passed or no tunnel with that name found, show all */ + { pool_foreach (t, sm->tunnels, ({ vec_add1 (tunnels, t); })); + } + else /* Just show the one tunnel by name */ + vec_add1 (tunnels, &sm->tunnels[p[0]]); if (vec_len (tunnels) == 0) vlib_cli_output (vm, "No SR tunnels configured"); for (i = 0; i < vec_len (tunnels); i++) { - t = tunnels [i]; - - rx_fib = find_ip6_fib_by_table_index_or_id (im, t->rx_fib_index, - IP6_ROUTE_FLAG_FIB_INDEX); - - tx_fib = find_ip6_fib_by_table_index_or_id (im, t->tx_fib_index, - IP6_ROUTE_FLAG_FIB_INDEX); - - vlib_cli_output (vm, "src %U dst %U first hop %U", - format_ip6_address, &t->key.src, - format_ip6_address, &t->key.dst, - format_ip6_address, &t->first_hop); - vlib_cli_output (vm, " rx-fib-id %d tx-fib-id %d", - rx_fib->table_id, tx_fib->table_id); - vlib_cli_output (vm, " sr: %U", format_ip6_sr_header, t->rewrite, - 0 /* print_hmac */); - vlib_cli_output (vm, "-------"); + t = tunnels[i]; + ip6_sr_tunnel_display (vm, t); } return 0; @@ -1104,10 +1236,434 @@ show_sr_tunnel_fn (vlib_main_t * vm, VLIB_CLI_COMMAND (show_sr_tunnel_command, static) = { .path = "show sr tunnel", - .short_help = "show sr tunnel", + .short_help = "show sr tunnel [name <sr-tunnel-name>]", .function = show_sr_tunnel_fn, }; +int ip6_sr_add_del_policy (ip6_sr_add_del_policy_args_t * a) +{ + ip6_sr_main_t * sm = &sr_main; + uword * p; + ip6_sr_tunnel_t * t = 0; + ip6_sr_policy_t * policy; + u32 * tunnel_indices = 0; + int i; + + + + if (a->is_del) + { + p=hash_get_mem (sm->policy_index_by_policy_name, a->name); + if (!p) + return -6; /* policy name not found */ + + policy = pool_elt_at_index(sm->policies, p[0]); + + vec_foreach_index (i, policy->tunnel_indices) + { + t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[i]); + t->policy_index = ~0; + } + hash_unset_mem (sm->policy_index_by_policy_name, a->name); + pool_put (sm->policies, policy); + return 0; + } + + + if (!vec_len(a->tunnel_names)) + return -3; /*tunnel name is required case */ + + vec_reset_length (tunnel_indices); + /* Check tunnel names, add tunnel_index to policy */ + for (i=0; i < vec_len (a->tunnel_names); i++) + { + p = hash_get_mem (sm->tunnel_index_by_name, a->tunnel_names[i]); + if (!p) + return -4; /* tunnel name not found case */ + + t = pool_elt_at_index (sm->tunnels, p[0]); + /* + No need to check t==0. -3 condition above ensures name + */ + if (t->policy_index != ~0) + return -5; /* tunnel name already associated with a policy */ + + /* Add to tunnel indicies */ + vec_add1 (tunnel_indices, p[0]); + } + + /* Add policy to ip6_sr_main_t */ + pool_get (sm->policies, policy); + policy->name = a->name; + policy->tunnel_indices = tunnel_indices; + hash_set_mem (sm->policy_index_by_policy_name, policy->name, policy - sm->policies); + + /* Yes, this could be construed as overkill but the last thing you should do is set + the policy_index on the tunnel after everything is set in ip6_sr_main_t. + If this is deemed overly cautious, could set this in the vec_len(tunnel_names) loop. + */ + for (i=0; i < vec_len(policy->tunnel_indices); i++) + { + t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[i]); + t->policy_index = policy - sm->policies; + } + + return 0; +} + + +static clib_error_t * +sr_add_del_policy_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + int is_del = 0; + u8 ** tunnel_names = 0; + u8 * tunnel_name = 0; + u8 * name = 0; + ip6_sr_add_del_policy_args_t _a, *a=&_a; + int rv; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "del")) + is_del = 1; + else if (unformat (input, "name %s", &name)) + ; + else if (unformat (input, "tunnel %s", &tunnel_name)) + { + if (tunnel_name) + { + vec_add1 (tunnel_names, tunnel_name); + tunnel_name = 0; + } + } + else + break; + } + + if (!name) + return clib_error_return (0, "name of SR policy required"); + + + memset(a, 0, sizeof(*a)); + + a->is_del = is_del; + a->name = name; + a->tunnel_names = tunnel_names; + + rv = ip6_sr_add_del_policy (a); + + vec_free(tunnel_names); + + switch (rv) + { + case 0: + break; + + case -3: + return clib_error_return (0, "tunnel name to associate to SR policy is required"); + + case -4: + return clib_error_return (0, "tunnel name not found"); + + case -5: + return clib_error_return (0, "tunnel already associated with policy"); + + case -6: + return clib_error_return (0, "policy name %s not found", name); + + case -7: + return clib_error_return (0, "TODO: deleting policy name %s", name); + + default: + return clib_error_return (0, "BUG: ip6_sr_add_del_policy returns %d", rv); + + } + return 0; +} + +VLIB_CLI_COMMAND (sr_policy_command, static) = { + .path = "sr policy", + .short_help = + "sr policy [del] name <policy-name> tunnel <sr-tunnel-name> [tunnel <sr-tunnel-name>]*", + .function = sr_add_del_policy_command_fn, +}; + +static clib_error_t * +show_sr_policy_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + static ip6_sr_policy_t ** policies; + ip6_sr_policy_t * policy; + ip6_sr_tunnel_t * t; + ip6_sr_main_t * sm = &sr_main; + int i, j; + uword * p = 0; + u8 * name = 0; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "name %s", &name)) + { + p=hash_get_mem (sm->policy_index_by_policy_name, name); + if(!p) + vlib_cli_output (vm, "policy with name %s not found. Showing all.", name); + } + else + break; + } + + vec_reset_length (policies); + + if(!p) /* Either name parm not passed or no policy with that name found, show all */ + { + pool_foreach (policy, sm->policies, + ({ + vec_add1 (policies, policy); + })); + } + else /* Just show the one policy by name and a summary of tunnel names */ + { + policy = pool_elt_at_index(sm->policies, p[0]); + vec_add1 (policies, policy); + } + + if (vec_len (policies) == 0) + vlib_cli_output (vm, "No SR policies configured"); + + for (i = 0; i < vec_len (policies); i++) + { + policy = policies [i]; + + if(policy->name) + vlib_cli_output (vm,"SR policy name: %s", (char *)policy->name); + for(j = 0; j < vec_len (policy->tunnel_indices); j++) + { + t = pool_elt_at_index (sm->tunnels, policy->tunnel_indices[j]); + ip6_sr_tunnel_display (vm, t); + } + } + + return 0; + +} + +VLIB_CLI_COMMAND (show_sr_policy_command, static) = { + .path = "show sr policy", + .short_help = "show sr policy [name <sr-policy-name>]", + .function = show_sr_policy_fn, +}; + +int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a) +{ + uword * p; + ip6_main_t * im = &ip6_main; + ip_lookup_main_t * lm = &im->lookup_main; + ip6_sr_tunnel_t * t; + ip_adjacency_t adj, * ap, * add_adj = 0; + u32 adj_index; + ip6_sr_main_t * sm = &sr_main; + ip6_add_del_route_args_t aa; + ip6_sr_policy_t * pt; + + if (a->is_del) + { + /* clean up the adjacency */ + p = hash_get_mem (sm->policy_index_by_multicast_address, a->multicast_address); + } + else + { + /* Get our policy by policy_name */ + p = hash_get_mem (sm->policy_index_by_policy_name, a->policy_name); + + } + if (!p) + return -1; + + pt=pool_elt_at_index (sm->policies, p[0]); + + /* + Get the first tunnel associated with policy populate the fib adjacency. + From there, since this tunnel will have it's policy_index != ~0 it will + be the trigger in the dual_loop to pull up the policy and make a copy-rewrite + for each tunnel in the policy + */ + + t = pool_elt_at_index (sm->tunnels, pt->tunnel_indices[0]); + + /* Construct a FIB entry for multicast using the rx/tx fib from the first tunnel */ + memset(&adj, 0, sizeof (adj)); + + /* Create an adjacency and add to v6 fib */ + adj.lookup_next_index = sm->ip6_lookup_sr_replicate_index; + adj.explicit_fib_index = ~0; + + ap = ip_add_adjacency (lm, &adj, 1 /* one adj */, + &adj_index); + + /* + * Stick the tunnel index into the rewrite header. + * + * Unfortunately, inserting an SR header according to the various + * RFC's requires parsing through the ip6 header, perhaps consing a + * buffer onto the head of the vlib_buffer_t, etc. We don't use the + * normal reverse bcopy rewrite code. + * + * We don't handle ugly RFC-related cases yet, but I'm sure PL will complain + * at some point... + */ + ap->rewrite_header.sw_if_index = t - sm->tunnels; + + vec_add1 (add_adj, ap[0]); + + memcpy (aa.dst_address.as_u8, a->multicast_address, sizeof (aa.dst_address.as_u8)); + aa.dst_address_length = 128; + + aa.flags = (a->is_del ? IP6_ROUTE_FLAG_DEL : IP6_ROUTE_FLAG_ADD); + aa.flags |= IP6_ROUTE_FLAG_FIB_INDEX; + aa.table_index_or_table_id = t->rx_fib_index; + aa.add_adj = add_adj; + aa.adj_index = adj_index; + aa.n_add_adj = 1; + ip6_add_del_route (im, &aa); + vec_free (add_adj); + + u8 * mcast_copy = 0; + mcast_copy = vec_new (ip6_address_t, 1); + memcpy (mcast_copy, a->multicast_address, sizeof (ip6_address_t)); + + if (a->is_del) + { + hash_unset_mem (sm->policy_index_by_multicast_address, mcast_copy); + vec_free (mcast_copy); + return 0; + } + /* else */ + + hash_set_mem (sm->policy_index_by_multicast_address, mcast_copy, pt - sm->policies); + + + return 0; +} + +static clib_error_t * +sr_add_del_multicast_map_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + int is_del = 0; + ip6_address_t multicast_address; + u8 * policy_name = 0; + int multicast_address_set = 0; + ip6_sr_add_del_multicastmap_args_t _a, *a=&_a; + int rv; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "del")) + is_del = 1; + else if (unformat (input, "address %U", unformat_ip6_address, &multicast_address)) + multicast_address_set = 1; + else if (unformat (input, "sr-policy %s", &policy_name)) + ; + else + break; + } + + if (!is_del && !policy_name) + return clib_error_return (0, "name of sr policy required"); + + if (!multicast_address_set) + return clib_error_return (0, "multicast address required"); + + memset(a, 0, sizeof(*a)); + + a->is_del = is_del; + a->multicast_address = &multicast_address; + a->policy_name = policy_name; + + rv = ip6_sr_add_del_multicastmap (a); + + switch (rv) + { + case 0: + break; + case -1: + return clib_error_return (0, "no policy with name: %s", policy_name); + + case -2: + return clib_error_return (0, "multicast map someting "); + + case -3: + return clib_error_return (0, "tunnel name to associate to SR policy is required"); + + case -7: + return clib_error_return (0, "TODO: deleting policy name %s", policy_name); + + default: + return clib_error_return (0, "BUG: ip6_sr_add_del_policy returns %d", rv); + + } + return 0; + +} + + +VLIB_CLI_COMMAND (sr_multicast_map_command, static) = { + .path = "sr multicast-map", + .short_help = + "sr multicast-map address <multicast-ip6-address> sr-policy <sr-policy-name> [del]", + .function = sr_add_del_multicast_map_command_fn, +}; + +static clib_error_t * +show_sr_multicast_map_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + ip6_sr_main_t * sm = &sr_main; + u8 * key = 0; + u32 value; + ip6_address_t multicast_address; + ip6_sr_policy_t * pt ; + + /* pull all entries from the hash table into vector for display */ + + hash_foreach_mem (key, value, sm->policy_index_by_multicast_address, + ({ + if (!key) + vlib_cli_output (vm, "no multicast maps configured"); + else + { + multicast_address = *((ip6_address_t *)key); + pt = pool_elt_at_index (sm->policies, value); + if (pt) + { + vlib_cli_output (vm, "address: %U policy: %s", + format_ip6_address, &multicast_address, + pt->name); + } + else + vlib_cli_output (vm, "BUG: policy not found for address: %U with policy index %d", + format_ip6_address, &multicast_address, + value); + + } + + })); + + return 0; +} + +VLIB_CLI_COMMAND (show_sr_multicast_map_command, static) = { + .path = "show sr multicast-map", + .short_help = "show sr multicast-map", + .function = show_sr_multicast_map_fn, +}; + + #define foreach_sr_fix_dst_addr_next \ _(DROP, "error-drop") @@ -1363,6 +1919,15 @@ static clib_error_t * sr_init (vlib_main_t * vm) sm->tunnel_index_by_key = hash_create_mem (0, sizeof (ip6_sr_tunnel_key_t), sizeof (uword)); + sm->tunnel_index_by_name = + hash_create_string (0, sizeof (uword)); + + sm->policy_index_by_policy_name = + hash_create_string(0, sizeof (uword)); + + sm->policy_index_by_multicast_address = + hash_create_mem (0, sizeof (ip6_address_t), sizeof (uword)); + sm->hmac_key_by_shared_secret = hash_create_string (0, sizeof(uword)); ip6_register_protocol (43, sr_local_node.index); @@ -1381,6 +1946,10 @@ static clib_error_t * sr_init (vlib_main_t * vm) sm->ip6_lookup_sr_next_index = vlib_node_add_next (vm, ip6_lookup_node->index, sr_rewrite_node.index); + /* Add a disposition to sr_replicate for the sr multicast replicate node */ + sm->ip6_lookup_sr_replicate_index = + vlib_node_add_next (vm, ip6_lookup_node->index, sr_replicate_node.index); + /* Add a disposition to ip6_rewrite for the sr dst address hack node */ sm->ip6_rewrite_sr_next_index = vlib_node_add_next (vm, ip6_rewrite_node->index, @@ -1824,7 +2393,7 @@ sr_local (vlib_main_t * vm, { u32 bi0; vlib_buffer_t * b0; - ip6_header_t * ip0; + ip6_header_t * ip0 = 0; ip6_sr_header_t * sr0; ip6_address_t * new_dst0; u32 next0 = SR_LOCAL_NEXT_IP6_LOOKUP; diff --git a/vnet/vnet/sr/sr.h b/vnet/vnet/sr/sr.h index 3c6d981d17e..023ca243d7d 100644 --- a/vnet/vnet/sr/sr.h +++ b/vnet/vnet/sr/sr.h @@ -37,6 +37,9 @@ typedef struct { /* src, dst address */ ip6_sr_tunnel_key_t key; + /* optional tunnel name */ + u8 * name; + /* mask width for FIB entry */ u32 dst_mask_width; @@ -49,6 +52,10 @@ typedef struct { /* The actual ip6 sr header */ u8 * rewrite; + + /* Indicates that this tunnel is part of a policy comprising + of multiple tunnels. */ + u32 policy_index; } ip6_sr_tunnel_t; typedef struct { @@ -63,6 +70,12 @@ typedef struct { u32 rx_table_id; u32 tx_table_id; + /* optional name argument - for referencing SR tunnel/policy by name */ + u8 * name; + + /* optional policy name */ + u8 * policy_name; + /* segment list, when inserting an ip6 SR header*/ ip6_address_t *segments; @@ -83,12 +96,57 @@ typedef struct { } ip6_sr_add_del_tunnel_args_t; typedef struct { + /* policy name */ + u8 * name; + + /* tunnel names */ + u8 ** tunnel_names; + + /* Delete the policy? */ + u8 is_del; +} ip6_sr_add_del_policy_args_t; + + +typedef struct { + /* name of policy */ + u8 * name; + + /* vector to SR tunnel index */ + u32 * tunnel_indices; + +} ip6_sr_policy_t; + +typedef struct { + /* multicast IP6 address */ + ip6_address_t *multicast_address; + + /* name of policy to map to */ + u8 * policy_name; + + /* Delete the mapping */ + u8 is_del; + +} ip6_sr_add_del_multicastmap_args_t; + +typedef struct { /* pool of tunnel instances, sr entry only */ ip6_sr_tunnel_t *tunnels; /* find an sr "tunnel" by its outer-IP src/dst */ uword * tunnel_index_by_key; - + + /* find an sr "tunnel" by its name */ + uword * tunnel_index_by_name; + + /* policy pool */ + ip6_sr_policy_t * policies; + + /* find a policy by name */ + uword * policy_index_by_policy_name; + + /* multicast address to policy mapping */ + uword * policy_index_by_multicast_address; + /* ip6-lookup next index for imposition FIB entries */ u32 ip6_lookup_sr_next_index; @@ -98,6 +156,9 @@ typedef struct { /* ip6-rewrite next index for reinstalling the original dst address */ u32 ip6_rewrite_sr_next_index; + /* ip6-replicate next index for multicast tunnel */ + u32 ip6_lookup_sr_replicate_index; + /* application API callback */ void *sr_local_cb; @@ -126,7 +187,15 @@ format_function_t format_ip6_sr_header_with_length; vlib_node_registration_t ip6_sr_input_node; +vlib_node_registration_t sr_replicate_node; + int ip6_sr_add_del_tunnel (ip6_sr_add_del_tunnel_args_t * a); +int ip6_sr_add_del_policy (ip6_sr_add_del_policy_args_t * a); +int ip6_sr_add_del_multicastmap (ip6_sr_add_del_multicastmap_args_t * a); + void vnet_register_sr_app_callback (void *cb); +void sr_fix_hmac (ip6_sr_main_t * sm, ip6_header_t * ip, + ip6_sr_header_t * sr); + #endif /* included_vnet_sr_h */ diff --git a/vnet/vnet/sr/sr_replicate.c b/vnet/vnet/sr/sr_replicate.c new file mode 100644 index 00000000000..e60b95624e1 --- /dev/null +++ b/vnet/vnet/sr/sr_replicate.c @@ -0,0 +1,366 @@ +/* + * sr_replicate.c: ipv6 segment routing replicator for multicast + * + * Copyright (c) 2016 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <vlib/vlib.h> +#include <vnet/vnet.h> +#include <vnet/pg/pg.h> +#include <vnet/sr/sr.h> +#include <vnet/devices/dpdk/dpdk.h> +#include <vnet/dpdk_replication.h> +#include <vnet/ip/ip.h> + +#include <vppinfra/hash.h> +#include <vppinfra/error.h> +#include <vppinfra/elog.h> + +typedef struct { + /* convenience */ + vlib_main_t * vlib_main; + vnet_main_t * vnet_main; +} sr_replicate_main_t; + +sr_replicate_main_t sr_replicate_main; + +vlib_node_registration_t sr_replicate_node; + + +typedef struct { + ip6_address_t src, dst; + u16 length; + u32 next_index; + u32 tunnel_index; + u8 sr[256]; +} sr_replicate_trace_t; + +/* packet trace format function */ +static u8 * format_sr_replicate_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 *); + sr_replicate_trace_t * t = va_arg (*args, sr_replicate_trace_t *); + ip6_main_t * im = &ip6_main; + ip6_sr_main_t * sm = &sr_main; + ip6_sr_tunnel_t *tun = pool_elt_at_index (sm->tunnels, t->tunnel_index); + ip6_fib_t * rx_fib, * tx_fib; + + rx_fib = find_ip6_fib_by_table_index_or_id (im, tun->rx_fib_index, + IP6_ROUTE_FLAG_FIB_INDEX); + + tx_fib = find_ip6_fib_by_table_index_or_id (im, tun->tx_fib_index, + IP6_ROUTE_FLAG_FIB_INDEX); + + s = format + (s, "SR-REPLICATE: next %s ip6 src %U dst %U len %u\n" + " rx-fib-id %d tx-fib-id %d\n%U", + "ip6-lookup", + format_ip6_address, &t->src, + format_ip6_address, &t->dst, t->length, + rx_fib->table_id, tx_fib->table_id, + format_ip6_sr_header, t->sr, 0 /* print_hmac */); + return s; + +} + +vlib_node_registration_t sr_replicate_node; + +#define foreach_sr_replicate_error \ +_(REPLICATED, "sr packets replicated") \ +_(NO_BUFFERS, "error allocating buffers for replicas") \ +_(NO_REPLICAS, "no replicas were needed") \ +_(NO_BUFFER_DROPS, "sr no buffer drops") + +typedef enum { +#define _(sym,str) SR_REPLICATE_ERROR_##sym, + foreach_sr_replicate_error +#undef _ + SR_REPLICATE_N_ERROR, +} sr_replicate_error_t; + +static char * sr_replicate_error_strings[] = { +#define _(sym,string) string, + foreach_sr_replicate_error +#undef _ +}; + +typedef enum { + SR_REPLICATE_NEXT_IP6_LOOKUP, + SR_REPLICATE_N_NEXT, +} sr_replicate_next_t; + +static uword +sr_replicate_node_fn (vlib_main_t * vm, + vlib_node_runtime_t * node, + vlib_frame_t * frame) +{ + u32 n_left_from, * from, * to_next; + sr_replicate_next_t next_index; + int pkts_replicated = 0; + ip6_sr_main_t * sm = &sr_main; + int no_buffer_drops = 0; + vlib_buffer_free_list_t * fl; + unsigned socket_id = rte_socket_id(); + vlib_buffer_main_t * bm = vm->buffer_main; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + next_index = node->cached_next_index; + + fl = vlib_buffer_get_free_list (vm, VLIB_BUFFER_DEFAULT_FREE_LIST_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) + { + u32 bi0, hdr_bi0; + vlib_buffer_t * b0, * orig_b0; + struct rte_mbuf * orig_mb0 = 0, * hdr_mb0 = 0, * clone0 = 0; + struct rte_mbuf ** hdr_vec = 0, ** rte_mbuf_vec = 0; + ip6_sr_policy_t * pol0 = 0; + ip6_sr_tunnel_t * t0 = 0; + ip6_sr_header_t * hdr_sr0 = 0; + ip6_header_t * ip0 = 0, * hdr_ip0 = 0; + int num_replicas = 0; + int i; + + bi0 = from[0]; + + b0 = vlib_get_buffer (vm, bi0); + orig_b0 = b0; + + pol0 = pool_elt_at_index (sm->policies, + vnet_buffer(b0)->ip.save_protocol); + + ip0 = vlib_buffer_get_current (b0); + /* Skip forward to the punch-in point */ + vlib_buffer_advance (b0, sizeof(*ip0)); + + orig_mb0 = rte_mbuf_from_vlib_buffer (b0); + + i16 delta0 = vlib_buffer_length_in_chain (vm, orig_b0) + - (i16) orig_mb0->pkt_len; + + u16 new_data_len0 = (u16)((i16) orig_mb0->data_len + delta0); + u16 new_pkt_len0 = (u16)((i16) orig_mb0->pkt_len + delta0); + + orig_mb0->data_len = new_data_len0; + orig_mb0->pkt_len = new_pkt_len0; + orig_mb0->data_off = (u16)(RTE_PKTMBUF_HEADROOM + b0->current_data); + + /* + Before entering loop determine if we can allocate: + - all the new HEADER RTE_MBUFs and assign them to a vector + - all the clones + + if successful, then iterate over vectors of resources + + */ + num_replicas = vec_len (pol0->tunnel_indices); + + if (PREDICT_FALSE(num_replicas == 0)) + { + b0->error = node->errors[SR_REPLICATE_ERROR_NO_REPLICAS]; + goto do_trace0; + } + + vec_reset_length (hdr_vec); + vec_reset_length (rte_mbuf_vec); + + for (i=0; i < num_replicas; i++) + { + hdr_mb0 = rte_pktmbuf_alloc(bm->pktmbuf_pools[socket_id]); + + if (i < (num_replicas - 1) ) + /* Not the last tunnel to process */ + clone0 = rte_pktmbuf_clone + (orig_mb0, bm->pktmbuf_pools[socket_id]); + else + /* Last tunnel to process, use original MB */ + clone0 = orig_mb0; + + + if (PREDICT_FALSE( !clone0 || !hdr_mb0 )) + { + b0->error = node->errors[SR_REPLICATE_ERROR_NO_BUFFERS]; + + vec_foreach_index (i, rte_mbuf_vec) + { + rte_pktmbuf_free(rte_mbuf_vec[i]); + } + vec_free (rte_mbuf_vec); + + vec_foreach_index (i, hdr_vec) + { + rte_pktmbuf_free(hdr_vec[i]); + } + vec_free (hdr_vec); + + goto do_trace0; + } + + vec_add1 (hdr_vec, hdr_mb0); + vec_add1 (rte_mbuf_vec, clone0); + + } + + for (i=0; i < num_replicas; i++) + { + vlib_buffer_t * hdr_b0; + + t0 = vec_elt_at_index (sm->tunnels, pol0->tunnel_indices[i]); + + /* Our replicas */ + hdr_mb0 = hdr_vec[i]; + clone0 = rte_mbuf_vec[i]; + + hdr_mb0->data_len = sizeof (*ip0) + vec_len (t0->rewrite); + hdr_mb0->pkt_len = hdr_mb0->data_len + + vlib_buffer_length_in_chain (vm, orig_b0); + + hdr_b0 = vlib_buffer_from_rte_mbuf (hdr_mb0); + + vlib_buffer_init_for_free_list (hdr_b0, fl); + + memcpy (hdr_b0->data, ip0, sizeof (*ip0)); + memcpy (hdr_b0->data + sizeof (*ip0), t0->rewrite, + vec_len (t0->rewrite)); + + hdr_b0->current_data = 0; + hdr_b0->current_length = sizeof (*ip0) + vec_len (t0->rewrite); + hdr_b0->flags = orig_b0->flags | VLIB_BUFFER_NEXT_PRESENT; + + + hdr_b0->total_length_not_including_first_buffer = + hdr_mb0->pkt_len - hdr_b0->current_length; + + hdr_ip0 = (ip6_header_t *) hdr_b0->data; + hdr_ip0->payload_length = clib_host_to_net_u16(hdr_mb0->data_len); + hdr_sr0 = (ip6_sr_header_t *) (hdr_ip0+1); + hdr_sr0->protocol = hdr_ip0->protocol; + hdr_ip0->protocol = 43; + + /* Rewrite the ip6 dst address */ + hdr_ip0->dst_address.as_u64[0] = t0->first_hop.as_u64[0]; + hdr_ip0->dst_address.as_u64[1] = t0->first_hop.as_u64[1]; + + sr_fix_hmac (sm, hdr_ip0, hdr_sr0); + + /* prepend new header to invariant piece */ + hdr_mb0->next = clone0; + hdr_b0->next_buffer = vlib_get_buffer_index (vm, vlib_buffer_from_rte_mbuf (clone0)); + + /* update header's fields */ + hdr_mb0->pkt_len = (uint16_t)(hdr_mb0->data_len + clone0->pkt_len); + hdr_mb0->nb_segs = (uint8_t)(clone0->nb_segs + 1); + + /* copy metadata from source packet*/ + hdr_mb0->port = clone0->port; + hdr_mb0->vlan_tci = clone0->vlan_tci; + hdr_mb0->vlan_tci_outer = clone0->vlan_tci_outer; + hdr_mb0->tx_offload = clone0->tx_offload; + hdr_mb0->hash = clone0->hash; + + hdr_mb0->ol_flags = clone0->ol_flags; + + __rte_mbuf_sanity_check(hdr_mb0, 1); + + hdr_bi0 = vlib_get_buffer_index (vm, hdr_b0); + + to_next[0] = hdr_bi0; + to_next += 1; + n_left_to_next -= 1; + + if (n_left_to_next == 0) + { + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, + to_next, n_left_to_next); + + } + pkts_replicated++; + } + + from += 1; + n_left_from -= 1; + + do_trace0: + if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) + { + sr_replicate_trace_t *tr = vlib_add_trace (vm, node, + b0, sizeof (*tr)); + tr->tunnel_index = t0 - sm->tunnels; + if (hdr_ip0) + { + memcpy (tr->src.as_u8, hdr_ip0->src_address.as_u8, + sizeof (tr->src.as_u8)); + memcpy (tr->dst.as_u8, hdr_ip0->dst_address.as_u8, + sizeof (tr->dst.as_u8)); + } + if (hdr_ip0->payload_length) + tr->length = clib_net_to_host_u16(hdr_ip0->payload_length); + else + tr->length = 0; + tr->next_index = next_index; + memcpy (tr->sr, hdr_sr0, sizeof (tr->sr)); + } + + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + vlib_node_increment_counter (vm, sr_replicate_node.index, + SR_REPLICATE_ERROR_REPLICATED, pkts_replicated); + + vlib_node_increment_counter (vm, sr_replicate_node.index, + SR_REPLICATE_ERROR_NO_BUFFER_DROPS, no_buffer_drops); + + return frame->n_vectors; +} + +VLIB_REGISTER_NODE (sr_replicate_node) = { + .function = sr_replicate_node_fn, + .name = "sr-replicate", + .vector_size = sizeof (u32), + .format_trace = format_sr_replicate_trace, + .type = VLIB_NODE_TYPE_INTERNAL, + + .n_errors = ARRAY_LEN(sr_replicate_error_strings), + .error_strings = sr_replicate_error_strings, + + .n_next_nodes = SR_REPLICATE_N_NEXT, + + .next_nodes = { + [SR_REPLICATE_NEXT_IP6_LOOKUP] = "ip6-lookup", + }, +}; + +clib_error_t *sr_replicate_init (vlib_main_t *vm) +{ + sr_replicate_main_t *msm = &sr_replicate_main; + + msm->vlib_main = vm; + msm->vnet_main = vnet_get_main(); + + return 0; +} + +VLIB_INIT_FUNCTION(sr_replicate_init); |