Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 1 | /* |
| 2 | * mpls_tunnel.c: MPLS tunnel interfaces (i.e. for RSVP-TE) |
| 3 | * |
| 4 | * Copyright (c) 2012 Cisco and/or its affiliates. |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at: |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | #include <vnet/vnet.h> |
| 19 | #include <vnet/pg/pg.h> |
| 20 | #include <vnet/mpls/mpls_tunnel.h> |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 21 | #include <vnet/mpls/mpls_types.h> |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 22 | #include <vnet/ip/ip.h> |
| 23 | #include <vnet/fib/fib_path_list.h> |
| 24 | #include <vnet/adj/adj_midchain.h> |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 25 | #include <vnet/adj/adj_mcast.h> |
| 26 | #include <vnet/dpo/replicate_dpo.h> |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 27 | |
| 28 | /** |
| 29 | * @brief pool of tunnel instances |
| 30 | */ |
| 31 | static mpls_tunnel_t *mpls_tunnel_pool; |
| 32 | |
| 33 | /** |
| 34 | * @brief Pool of free tunnel SW indices - i.e. recycled indices |
| 35 | */ |
| 36 | static u32 * mpls_tunnel_free_hw_if_indices; |
| 37 | |
| 38 | /** |
| 39 | * @brief DB of SW index to tunnel index |
| 40 | */ |
| 41 | static u32 *mpls_tunnel_db; |
| 42 | |
| 43 | /** |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 44 | * @brief MPLS tunnel flags strings |
| 45 | */ |
| 46 | static const char *mpls_tunnel_attribute_names[] = MPLS_TUNNEL_ATTRIBUTES; |
| 47 | |
| 48 | /** |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 49 | * @brief Get a tunnel object from a SW interface index |
| 50 | */ |
| 51 | static mpls_tunnel_t* |
| 52 | mpls_tunnel_get_from_sw_if_index (u32 sw_if_index) |
| 53 | { |
| 54 | if ((vec_len(mpls_tunnel_db) < sw_if_index) || |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 55 | (~0 == mpls_tunnel_db[sw_if_index])) |
| 56 | return (NULL); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 57 | |
| 58 | return (pool_elt_at_index(mpls_tunnel_pool, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 59 | mpls_tunnel_db[sw_if_index])); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | /** |
| 63 | * @brief Build a rewrite string for the MPLS tunnel. |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 64 | */ |
| 65 | static u8* |
| 66 | mpls_tunnel_build_rewrite_i (void) |
| 67 | { |
| 68 | /* |
| 69 | * passing the adj code a NULL rewirte means 'i don't have one cos |
| 70 | * t'other end is unresolved'. That's not the case here. For the mpls |
| 71 | * tunnel there are just no bytes of encap to apply in the adj. We'll impose |
| 72 | * the label stack once we choose a path. So return a zero length rewrite. |
| 73 | */ |
| 74 | u8 *rewrite = NULL; |
| 75 | |
| 76 | vec_validate(rewrite, 0); |
| 77 | vec_reset_length(rewrite); |
| 78 | |
| 79 | return (rewrite); |
| 80 | } |
| 81 | |
| 82 | /** |
| 83 | * @brief Build a rewrite string for the MPLS tunnel. |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 84 | */ |
| 85 | static u8* |
| 86 | mpls_tunnel_build_rewrite (vnet_main_t * vnm, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 87 | u32 sw_if_index, |
| 88 | vnet_link_t link_type, |
| 89 | const void *dst_address) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 90 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 91 | return (mpls_tunnel_build_rewrite_i()); |
| 92 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 93 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 94 | typedef struct mpls_tunnel_collect_forwarding_ctx_t_ |
| 95 | { |
| 96 | load_balance_path_t * next_hops; |
| 97 | const mpls_tunnel_t *mt; |
| 98 | fib_forward_chain_type_t fct; |
| 99 | } mpls_tunnel_collect_forwarding_ctx_t; |
| 100 | |
| 101 | static int |
| 102 | mpls_tunnel_collect_forwarding (fib_node_index_t pl_index, |
| 103 | fib_node_index_t path_index, |
| 104 | void *arg) |
| 105 | { |
| 106 | mpls_tunnel_collect_forwarding_ctx_t *ctx; |
| 107 | fib_path_ext_t *path_ext; |
| 108 | int have_path_ext; |
| 109 | |
| 110 | ctx = arg; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 111 | |
Neale Ranns | 3b222a3 | 2016-12-02 15:41:03 +0000 | [diff] [blame] | 112 | /* |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 113 | * if the path is not resolved, don't include it. |
Neale Ranns | 3b222a3 | 2016-12-02 15:41:03 +0000 | [diff] [blame] | 114 | */ |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 115 | if (!fib_path_is_resolved(path_index)) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 116 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 117 | return (!0); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 118 | } |
| 119 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 120 | /* |
| 121 | * get the matching path-extension for the path being visited. |
| 122 | */ |
| 123 | have_path_ext = 0; |
| 124 | vec_foreach(path_ext, ctx->mt->mt_path_exts) |
Neale Ranns | 3b222a3 | 2016-12-02 15:41:03 +0000 | [diff] [blame] | 125 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 126 | if (path_ext->fpe_path_index == path_index) |
| 127 | { |
| 128 | have_path_ext = 1; |
| 129 | break; |
| 130 | } |
| 131 | } |
| 132 | |
| 133 | if (have_path_ext) |
| 134 | { |
| 135 | /* |
| 136 | * found a matching extension. stack it to obtain the forwarding |
| 137 | * info for this path. |
| 138 | */ |
| 139 | ctx->next_hops = fib_path_ext_stack(path_ext, |
| 140 | ctx->fct, |
| 141 | ctx->fct, |
| 142 | ctx->next_hops); |
| 143 | } |
| 144 | else |
| 145 | ASSERT(0); |
| 146 | /* |
| 147 | * else |
| 148 | * There should be a path-extenios associated with each path |
| 149 | */ |
| 150 | |
| 151 | return (!0); |
| 152 | } |
| 153 | |
| 154 | static void |
| 155 | mpls_tunnel_mk_lb (mpls_tunnel_t *mt, |
| 156 | vnet_link_t linkt, |
| 157 | fib_forward_chain_type_t fct, |
| 158 | dpo_id_t *dpo_lb) |
| 159 | { |
| 160 | dpo_proto_t lb_proto; |
| 161 | |
| 162 | /* |
| 163 | * If the entry has path extensions then we construct a load-balance |
| 164 | * by stacking the extensions on the forwarding chains of the paths. |
| 165 | * Otherwise we use the load-balance of the path-list |
| 166 | */ |
| 167 | mpls_tunnel_collect_forwarding_ctx_t ctx = { |
| 168 | .mt = mt, |
| 169 | .next_hops = NULL, |
| 170 | .fct = fct, |
| 171 | }; |
| 172 | |
| 173 | /* |
| 174 | * As an optimisation we allocate the vector of next-hops to be sized |
| 175 | * equal to the maximum nuber of paths we will need, which is also the |
| 176 | * most likely number we will need, since in most cases the paths are 'up'. |
| 177 | */ |
| 178 | vec_validate(ctx.next_hops, fib_path_list_get_n_paths(mt->mt_path_list)); |
| 179 | vec_reset_length(ctx.next_hops); |
| 180 | |
| 181 | lb_proto = vnet_link_to_dpo_proto(linkt); |
| 182 | |
| 183 | fib_path_list_walk(mt->mt_path_list, |
| 184 | mpls_tunnel_collect_forwarding, |
| 185 | &ctx); |
| 186 | |
| 187 | if (!dpo_id_is_valid(dpo_lb)) |
| 188 | { |
| 189 | /* |
| 190 | * first time create |
| 191 | */ |
| 192 | if (mt->mt_flags & MPLS_TUNNEL_FLAG_MCAST) |
| 193 | { |
| 194 | dpo_set(dpo_lb, |
| 195 | DPO_REPLICATE, |
| 196 | lb_proto, |
| 197 | replicate_create(0, lb_proto)); |
| 198 | } |
| 199 | else |
| 200 | { |
| 201 | flow_hash_config_t fhc; |
| 202 | |
| 203 | fhc = 0; // FIXME |
| 204 | /* fhc = fib_table_get_flow_hash_config(fib_entry->fe_fib_index, */ |
| 205 | /* dpo_proto_to_fib(lb_proto)); */ |
| 206 | dpo_set(dpo_lb, |
| 207 | DPO_LOAD_BALANCE, |
| 208 | lb_proto, |
| 209 | load_balance_create(0, lb_proto, fhc)); |
| 210 | } |
| 211 | } |
| 212 | |
| 213 | if (mt->mt_flags & MPLS_TUNNEL_FLAG_MCAST) |
| 214 | { |
| 215 | /* |
| 216 | * MPLS multicast |
| 217 | */ |
| 218 | replicate_multipath_update(dpo_lb, ctx.next_hops); |
Neale Ranns | 3b222a3 | 2016-12-02 15:41:03 +0000 | [diff] [blame] | 219 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 220 | else |
Neale Ranns | 3b222a3 | 2016-12-02 15:41:03 +0000 | [diff] [blame] | 221 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 222 | load_balance_multipath_update(dpo_lb, |
| 223 | ctx.next_hops, |
| 224 | LOAD_BALANCE_FLAG_NONE); |
| 225 | vec_free(ctx.next_hops); |
Neale Ranns | 3b222a3 | 2016-12-02 15:41:03 +0000 | [diff] [blame] | 226 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 227 | } |
| 228 | |
| 229 | /** |
| 230 | * mpls_tunnel_stack |
| 231 | * |
| 232 | * 'stack' (resolve the recursion for) the tunnel's midchain adjacency |
| 233 | */ |
| 234 | static void |
| 235 | mpls_tunnel_stack (adj_index_t ai) |
| 236 | { |
| 237 | ip_adjacency_t *adj; |
| 238 | mpls_tunnel_t *mt; |
| 239 | u32 sw_if_index; |
| 240 | |
| 241 | adj = adj_get(ai); |
| 242 | sw_if_index = adj->rewrite_header.sw_if_index; |
| 243 | |
| 244 | mt = mpls_tunnel_get_from_sw_if_index(sw_if_index); |
| 245 | |
| 246 | if (NULL == mt) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 247 | return; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 248 | |
| 249 | /* |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 250 | * while we're stacking the adj, remove the tunnel from the child list |
| 251 | * of the path list. this breaks a circular dependency of walk updates |
| 252 | * where the create of adjacencies in the children can lead to walks |
| 253 | * that get back here. |
| 254 | */ |
| 255 | fib_path_list_lock(mt->mt_path_list); |
| 256 | |
| 257 | fib_path_list_child_remove(mt->mt_path_list, |
| 258 | mt->mt_sibling_index); |
| 259 | |
| 260 | /* |
| 261 | * Construct the DPO (load-balance or replicate) that we can stack |
| 262 | * the tunnel's midchain on |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 263 | */ |
| 264 | if (vnet_hw_interface_get_flags(vnet_get_main(), |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 265 | mt->mt_hw_if_index) & |
| 266 | VNET_HW_INTERFACE_FLAG_LINK_UP) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 267 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 268 | dpo_id_t dpo = DPO_INVALID; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 269 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 270 | mpls_tunnel_mk_lb(mt, |
| 271 | adj->ia_link, |
| 272 | FIB_FORW_CHAIN_TYPE_MPLS_EOS, |
| 273 | &dpo); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 274 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 275 | adj_nbr_midchain_stack(ai, &dpo); |
| 276 | dpo_reset(&dpo); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 277 | } |
| 278 | else |
| 279 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 280 | adj_nbr_midchain_unstack(ai); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 281 | } |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 282 | |
| 283 | mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list, |
| 284 | FIB_NODE_TYPE_MPLS_TUNNEL, |
| 285 | mt - mpls_tunnel_pool); |
| 286 | |
| 287 | fib_path_list_lock(mt->mt_path_list); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | /** |
| 291 | * @brief Call back when restacking all adjacencies on a MPLS interface |
| 292 | */ |
| 293 | static adj_walk_rc_t |
| 294 | mpls_adj_walk_cb (adj_index_t ai, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 295 | void *ctx) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 296 | { |
| 297 | mpls_tunnel_stack(ai); |
| 298 | |
| 299 | return (ADJ_WALK_RC_CONTINUE); |
| 300 | } |
| 301 | |
| 302 | static void |
| 303 | mpls_tunnel_restack (mpls_tunnel_t *mt) |
| 304 | { |
| 305 | fib_protocol_t proto; |
| 306 | |
| 307 | /* |
| 308 | * walk all the adjacencies on the MPLS interface and restack them |
| 309 | */ |
| 310 | FOR_EACH_FIB_PROTOCOL(proto) |
| 311 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 312 | adj_nbr_walk(mt->mt_sw_if_index, |
| 313 | proto, |
| 314 | mpls_adj_walk_cb, |
| 315 | NULL); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 316 | } |
| 317 | } |
| 318 | |
| 319 | static clib_error_t * |
| 320 | mpls_tunnel_admin_up_down (vnet_main_t * vnm, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 321 | u32 hw_if_index, |
| 322 | u32 flags) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 323 | { |
| 324 | vnet_hw_interface_t * hi; |
| 325 | mpls_tunnel_t *mt; |
| 326 | |
| 327 | hi = vnet_get_hw_interface (vnm, hw_if_index); |
| 328 | |
| 329 | mt = mpls_tunnel_get_from_sw_if_index(hi->sw_if_index); |
| 330 | |
| 331 | if (NULL == mt) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 332 | return (NULL); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 333 | |
| 334 | if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 335 | vnet_hw_interface_set_flags (vnm, hw_if_index, |
| 336 | VNET_HW_INTERFACE_FLAG_LINK_UP); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 337 | else |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 338 | vnet_hw_interface_set_flags (vnm, hw_if_index, 0 /* down */); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 339 | |
| 340 | mpls_tunnel_restack(mt); |
| 341 | |
| 342 | return (NULL); |
| 343 | } |
| 344 | |
| 345 | /** |
| 346 | * @brief Fixup the adj rewrite post encap. This is a no-op since the |
| 347 | * rewrite is a stack of labels. |
| 348 | */ |
| 349 | static void |
| 350 | mpls_tunnel_fixup (vlib_main_t *vm, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 351 | ip_adjacency_t *adj, |
| 352 | vlib_buffer_t *b0) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 353 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 354 | /* |
| 355 | * A no-op w.r.t. the header. but reset the 'have we pushed any |
| 356 | * MPLS labels onto the packet' flag. That way when we enter the |
| 357 | * tunnel we'll get a TTL set to 255 |
| 358 | */ |
| 359 | vnet_buffer(b0)->mpls.first = 0; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 360 | } |
| 361 | |
| 362 | static void |
| 363 | mpls_tunnel_update_adj (vnet_main_t * vnm, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 364 | u32 sw_if_index, |
| 365 | adj_index_t ai) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 366 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 367 | ip_adjacency_t *adj; |
| 368 | |
| 369 | ASSERT(ADJ_INDEX_INVALID != ai); |
| 370 | |
| 371 | adj = adj_get(ai); |
| 372 | |
| 373 | switch (adj->lookup_next_index) |
| 374 | { |
| 375 | case IP_LOOKUP_NEXT_ARP: |
| 376 | case IP_LOOKUP_NEXT_GLEAN: |
| 377 | adj_nbr_midchain_update_rewrite(ai, mpls_tunnel_fixup, |
| 378 | ADJ_FLAG_NONE, |
| 379 | mpls_tunnel_build_rewrite_i()); |
| 380 | break; |
| 381 | case IP_LOOKUP_NEXT_MCAST: |
| 382 | /* |
| 383 | * Construct a partial rewrite from the known ethernet mcast dest MAC |
| 384 | * There's no MAC fixup, so the last 2 parameters are 0 |
| 385 | */ |
| 386 | adj_mcast_midchain_update_rewrite(ai, mpls_tunnel_fixup, |
| 387 | ADJ_FLAG_NONE, |
| 388 | mpls_tunnel_build_rewrite_i(), |
| 389 | 0, 0); |
| 390 | break; |
| 391 | |
| 392 | case IP_LOOKUP_NEXT_DROP: |
| 393 | case IP_LOOKUP_NEXT_PUNT: |
| 394 | case IP_LOOKUP_NEXT_LOCAL: |
| 395 | case IP_LOOKUP_NEXT_REWRITE: |
| 396 | case IP_LOOKUP_NEXT_MIDCHAIN: |
| 397 | case IP_LOOKUP_NEXT_MCAST_MIDCHAIN: |
| 398 | case IP_LOOKUP_NEXT_ICMP_ERROR: |
| 399 | case IP_LOOKUP_N_NEXT: |
| 400 | ASSERT (0); |
| 401 | break; |
| 402 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 403 | |
| 404 | mpls_tunnel_stack(ai); |
| 405 | } |
| 406 | |
| 407 | static u8 * |
| 408 | format_mpls_tunnel_name (u8 * s, va_list * args) |
| 409 | { |
| 410 | u32 dev_instance = va_arg (*args, u32); |
| 411 | return format (s, "mpls-tunnel%d", dev_instance); |
| 412 | } |
| 413 | |
| 414 | static u8 * |
| 415 | format_mpls_tunnel_device (u8 * s, va_list * args) |
| 416 | { |
| 417 | u32 dev_instance = va_arg (*args, u32); |
| 418 | CLIB_UNUSED (int verbose) = va_arg (*args, int); |
| 419 | |
| 420 | return (format (s, "MPLS-tunnel: id %d\n", dev_instance)); |
| 421 | } |
| 422 | |
| 423 | /** |
| 424 | * @brief Packet trace structure |
| 425 | */ |
| 426 | typedef struct mpls_tunnel_trace_t_ |
| 427 | { |
| 428 | /** |
| 429 | * Tunnel-id / index in tunnel vector |
| 430 | */ |
| 431 | u32 tunnel_id; |
| 432 | } mpls_tunnel_trace_t; |
| 433 | |
| 434 | static u8 * |
| 435 | format_mpls_tunnel_tx_trace (u8 * s, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 436 | va_list * args) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 437 | { |
| 438 | CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *); |
| 439 | CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *); |
| 440 | mpls_tunnel_trace_t * t = va_arg (*args, mpls_tunnel_trace_t *); |
| 441 | |
| 442 | s = format (s, "MPLS: tunnel %d", t->tunnel_id); |
| 443 | return s; |
| 444 | } |
| 445 | |
| 446 | /** |
| 447 | * @brief TX function. Only called L2. L3 traffic uses the adj-midchains |
| 448 | */ |
| 449 | static uword |
| 450 | mpls_tunnel_tx (vlib_main_t * vm, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 451 | vlib_node_runtime_t * node, |
| 452 | vlib_frame_t * frame) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 453 | { |
| 454 | u32 next_index; |
| 455 | u32 * from, * to_next, n_left_from, n_left_to_next; |
| 456 | vnet_interface_output_runtime_t * rd = (void *) node->runtime_data; |
| 457 | const mpls_tunnel_t *mt; |
| 458 | |
| 459 | mt = pool_elt_at_index(mpls_tunnel_pool, rd->dev_instance); |
| 460 | |
| 461 | /* Vector of buffer / pkt indices we're supposed to process */ |
| 462 | from = vlib_frame_vector_args (frame); |
| 463 | |
| 464 | /* Number of buffers / pkts */ |
| 465 | n_left_from = frame->n_vectors; |
| 466 | |
| 467 | /* Speculatively send the first buffer to the last disposition we used */ |
| 468 | next_index = node->cached_next_index; |
| 469 | |
| 470 | while (n_left_from > 0) |
| 471 | { |
| 472 | /* set up to enqueue to our disposition with index = next_index */ |
| 473 | vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); |
| 474 | |
| 475 | /* |
| 476 | * FIXME DUAL LOOP |
| 477 | */ |
| 478 | while (n_left_from > 0 && n_left_to_next > 0) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 479 | { |
| 480 | vlib_buffer_t * b0; |
| 481 | u32 bi0; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 482 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 483 | bi0 = from[0]; |
| 484 | to_next[0] = bi0; |
| 485 | from += 1; |
| 486 | to_next += 1; |
| 487 | n_left_from -= 1; |
| 488 | n_left_to_next -= 1; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 489 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 490 | b0 = vlib_get_buffer(vm, bi0); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 491 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 492 | vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mt->mt_l2_adj; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 493 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 494 | if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) |
| 495 | { |
| 496 | mpls_tunnel_trace_t *tr = vlib_add_trace (vm, node, |
| 497 | b0, sizeof (*tr)); |
| 498 | tr->tunnel_id = rd->dev_instance; |
| 499 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 500 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 501 | vlib_validate_buffer_enqueue_x1 (vm, node, next_index, |
| 502 | to_next, n_left_to_next, |
| 503 | bi0, mt->mt_l2_tx_arc); |
| 504 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 505 | |
| 506 | vlib_put_next_frame (vm, node, next_index, n_left_to_next); |
| 507 | } |
| 508 | |
| 509 | return frame->n_vectors; |
| 510 | } |
| 511 | |
| 512 | VNET_DEVICE_CLASS (mpls_tunnel_class) = { |
| 513 | .name = "MPLS tunnel device", |
| 514 | .format_device_name = format_mpls_tunnel_name, |
| 515 | .format_device = format_mpls_tunnel_device, |
| 516 | .format_tx_trace = format_mpls_tunnel_tx_trace, |
| 517 | .tx_function = mpls_tunnel_tx, |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 518 | .admin_up_down_function = mpls_tunnel_admin_up_down, |
| 519 | }; |
| 520 | |
| 521 | VNET_HW_INTERFACE_CLASS (mpls_tunnel_hw_interface_class) = { |
| 522 | .name = "MPLS-Tunnel", |
| 523 | // .format_header = format_mpls_eth_header_with_length, |
| 524 | // .unformat_header = unformat_mpls_eth_header, |
| 525 | .update_adjacency = mpls_tunnel_update_adj, |
| 526 | .build_rewrite = mpls_tunnel_build_rewrite, |
| 527 | .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P, |
| 528 | }; |
| 529 | |
| 530 | const mpls_tunnel_t * |
| 531 | mpls_tunnel_get (u32 mti) |
| 532 | { |
| 533 | return (pool_elt_at_index(mpls_tunnel_pool, mti)); |
| 534 | } |
| 535 | |
| 536 | /** |
| 537 | * @brief Walk all the MPLS tunnels |
| 538 | */ |
| 539 | void |
| 540 | mpls_tunnel_walk (mpls_tunnel_walk_cb_t cb, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 541 | void *ctx) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 542 | { |
| 543 | u32 mti; |
| 544 | |
| 545 | pool_foreach_index(mti, mpls_tunnel_pool, |
| 546 | ({ |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 547 | cb(mti, ctx); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 548 | })); |
| 549 | } |
| 550 | |
| 551 | void |
| 552 | vnet_mpls_tunnel_del (u32 sw_if_index) |
| 553 | { |
| 554 | mpls_tunnel_t *mt; |
| 555 | |
| 556 | mt = mpls_tunnel_get_from_sw_if_index(sw_if_index); |
| 557 | |
| 558 | if (NULL == mt) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 559 | return; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 560 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 561 | if (FIB_NODE_INDEX_INVALID != mt->mt_path_list) |
| 562 | fib_path_list_child_remove(mt->mt_path_list, |
| 563 | mt->mt_sibling_index); |
| 564 | if (ADJ_INDEX_INVALID != mt->mt_l2_adj) |
| 565 | adj_unlock(mt->mt_l2_adj); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 566 | |
| 567 | vec_add1 (mpls_tunnel_free_hw_if_indices, mt->mt_hw_if_index); |
| 568 | pool_put(mpls_tunnel_pool, mt); |
| 569 | mpls_tunnel_db[sw_if_index] = ~0; |
| 570 | } |
| 571 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 572 | u32 |
| 573 | vnet_mpls_tunnel_create (u8 l2_only, |
| 574 | u8 is_multicast) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 575 | { |
| 576 | vnet_hw_interface_t * hi; |
| 577 | mpls_tunnel_t *mt; |
| 578 | vnet_main_t * vnm; |
| 579 | u32 mti; |
| 580 | |
| 581 | vnm = vnet_get_main(); |
| 582 | pool_get(mpls_tunnel_pool, mt); |
| 583 | memset (mt, 0, sizeof (*mt)); |
| 584 | mti = mt - mpls_tunnel_pool; |
| 585 | fib_node_init(&mt->mt_node, FIB_NODE_TYPE_MPLS_TUNNEL); |
| 586 | mt->mt_l2_adj = ADJ_INDEX_INVALID; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 587 | mt->mt_path_list = FIB_NODE_INDEX_INVALID; |
| 588 | mt->mt_sibling_index = FIB_NODE_INDEX_INVALID; |
| 589 | |
| 590 | if (is_multicast) |
| 591 | mt->mt_flags |= MPLS_TUNNEL_FLAG_MCAST; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 592 | |
| 593 | /* |
| 594 | * Create a new, or re=use and old, tunnel HW interface |
| 595 | */ |
| 596 | if (vec_len (mpls_tunnel_free_hw_if_indices) > 0) |
| 597 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 598 | mt->mt_hw_if_index = |
| 599 | mpls_tunnel_free_hw_if_indices[vec_len(mpls_tunnel_free_hw_if_indices)-1]; |
| 600 | _vec_len (mpls_tunnel_free_hw_if_indices) -= 1; |
| 601 | hi = vnet_get_hw_interface (vnm, mt->mt_hw_if_index); |
| 602 | hi->hw_instance = mti; |
| 603 | hi->dev_instance = mti; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 604 | } |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 605 | else |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 606 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 607 | mt->mt_hw_if_index = vnet_register_interface( |
| 608 | vnm, |
| 609 | mpls_tunnel_class.index, |
| 610 | mti, |
| 611 | mpls_tunnel_hw_interface_class.index, |
| 612 | mti); |
| 613 | hi = vnet_get_hw_interface(vnm, mt->mt_hw_if_index); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 614 | } |
| 615 | |
| 616 | /* |
| 617 | * Add the new tunnel to the tunnel DB - key:SW if index |
| 618 | */ |
| 619 | mt->mt_sw_if_index = hi->sw_if_index; |
| 620 | vec_validate_init_empty(mpls_tunnel_db, mt->mt_sw_if_index, ~0); |
| 621 | mpls_tunnel_db[mt->mt_sw_if_index] = mti; |
| 622 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 623 | if (l2_only) |
| 624 | { |
| 625 | mt->mt_l2_adj = |
| 626 | adj_nbr_add_or_lock(fib_path_list_get_proto(mt->mt_path_list), |
| 627 | VNET_LINK_ETHERNET, |
| 628 | &zero_addr, |
| 629 | mt->mt_sw_if_index); |
| 630 | |
| 631 | mt->mt_l2_tx_arc = vlib_node_add_named_next(vlib_get_main(), |
| 632 | hi->tx_node_index, |
| 633 | "adj-l2-midchain"); |
| 634 | } |
| 635 | |
| 636 | return (mt->mt_sw_if_index); |
| 637 | } |
| 638 | |
| 639 | /* |
| 640 | * mpls_tunnel_path_ext_add |
| 641 | * |
| 642 | * append a path extension to the entry's list |
| 643 | */ |
| 644 | static void |
| 645 | mpls_tunnel_path_ext_append (mpls_tunnel_t *mt, |
| 646 | const fib_route_path_t *rpath) |
| 647 | { |
| 648 | if (NULL != rpath->frp_label_stack) |
| 649 | { |
| 650 | fib_path_ext_t *path_ext; |
| 651 | |
| 652 | vec_add2(mt->mt_path_exts, path_ext, 1); |
| 653 | |
| 654 | fib_path_ext_init(path_ext, mt->mt_path_list, rpath); |
| 655 | } |
| 656 | } |
| 657 | |
| 658 | /* |
| 659 | * mpls_tunnel_path_ext_insert |
| 660 | * |
| 661 | * insert, sorted, a path extension to the entry's list. |
| 662 | * It's not strictly necessary in sort the path extensions, since each |
| 663 | * extension has the path index to which it resolves. However, by being |
| 664 | * sorted the load-balance produced has a deterministic order, not an order |
| 665 | * based on the sequence of extension additions. this is a considerable benefit. |
| 666 | */ |
| 667 | static void |
| 668 | mpls_tunnel_path_ext_insert (mpls_tunnel_t *mt, |
| 669 | const fib_route_path_t *rpath) |
| 670 | { |
| 671 | if (0 == vec_len(mt->mt_path_exts)) |
| 672 | return (mpls_tunnel_path_ext_append(mt, rpath)); |
| 673 | |
| 674 | if (NULL != rpath->frp_label_stack) |
| 675 | { |
| 676 | fib_path_ext_t path_ext; |
| 677 | int i = 0; |
| 678 | |
| 679 | fib_path_ext_init(&path_ext, mt->mt_path_list, rpath); |
| 680 | |
| 681 | while (i < vec_len(mt->mt_path_exts) && |
| 682 | (fib_path_ext_cmp(&mt->mt_path_exts[i], rpath) < 0)) |
| 683 | { |
| 684 | i++; |
| 685 | } |
| 686 | |
| 687 | vec_insert_elts(mt->mt_path_exts, &path_ext, 1, i); |
| 688 | } |
| 689 | } |
| 690 | |
| 691 | void |
| 692 | vnet_mpls_tunnel_path_add (u32 sw_if_index, |
| 693 | fib_route_path_t *rpaths) |
| 694 | { |
| 695 | mpls_tunnel_t *mt; |
| 696 | u32 mti; |
| 697 | |
| 698 | mt = mpls_tunnel_get_from_sw_if_index(sw_if_index); |
| 699 | |
| 700 | if (NULL == mt) |
| 701 | return; |
| 702 | |
| 703 | mti = mt - mpls_tunnel_pool; |
| 704 | |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 705 | /* |
| 706 | * construct a path-list from the path provided |
| 707 | */ |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 708 | if (FIB_NODE_INDEX_INVALID == mt->mt_path_list) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 709 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 710 | mt->mt_path_list = fib_path_list_create(FIB_PATH_LIST_FLAG_SHARED, rpaths); |
| 711 | mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list, |
| 712 | FIB_NODE_TYPE_MPLS_TUNNEL, |
| 713 | mti); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 714 | } |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 715 | else |
| 716 | { |
| 717 | fib_node_index_t old_pl_index; |
| 718 | fib_path_ext_t *path_ext; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 719 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 720 | old_pl_index = mt->mt_path_list; |
| 721 | |
| 722 | mt->mt_path_list = |
| 723 | fib_path_list_copy_and_path_add(old_pl_index, |
| 724 | FIB_PATH_LIST_FLAG_SHARED, |
| 725 | rpaths); |
| 726 | |
| 727 | fib_path_list_child_remove(old_pl_index, |
| 728 | mt->mt_sibling_index); |
| 729 | mt->mt_sibling_index = fib_path_list_child_add(mt->mt_path_list, |
| 730 | FIB_NODE_TYPE_MPLS_TUNNEL, |
| 731 | mti); |
| 732 | /* |
| 733 | * re-resolve all the path-extensions with the new path-list |
| 734 | */ |
| 735 | vec_foreach(path_ext, mt->mt_path_exts) |
| 736 | { |
| 737 | fib_path_ext_resolve(path_ext, mt->mt_path_list); |
| 738 | } |
| 739 | } |
| 740 | mpls_tunnel_path_ext_insert(mt, rpaths); |
| 741 | mpls_tunnel_restack(mt); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 742 | } |
| 743 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 744 | int |
| 745 | vnet_mpls_tunnel_path_remove (u32 sw_if_index, |
| 746 | fib_route_path_t *rpaths) |
| 747 | { |
| 748 | mpls_tunnel_t *mt; |
| 749 | u32 mti; |
| 750 | |
| 751 | mt = mpls_tunnel_get_from_sw_if_index(sw_if_index); |
| 752 | |
| 753 | if (NULL == mt) |
| 754 | return (0); |
| 755 | |
| 756 | mti = mt - mpls_tunnel_pool; |
| 757 | |
| 758 | /* |
| 759 | * construct a path-list from the path provided |
| 760 | */ |
| 761 | if (FIB_NODE_INDEX_INVALID == mt->mt_path_list) |
| 762 | { |
| 763 | /* can't remove a path if we have onoe */ |
| 764 | return (0); |
| 765 | } |
| 766 | else |
| 767 | { |
| 768 | fib_node_index_t old_pl_index; |
| 769 | fib_path_ext_t *path_ext; |
| 770 | |
| 771 | old_pl_index = mt->mt_path_list; |
| 772 | |
| 773 | mt->mt_path_list = |
| 774 | fib_path_list_copy_and_path_remove(old_pl_index, |
| 775 | FIB_PATH_LIST_FLAG_SHARED, |
| 776 | rpaths); |
| 777 | |
| 778 | fib_path_list_child_remove(old_pl_index, |
| 779 | mt->mt_sibling_index); |
| 780 | |
| 781 | if (FIB_NODE_INDEX_INVALID == mt->mt_path_list) |
| 782 | { |
| 783 | /* no paths left */ |
| 784 | return (0); |
| 785 | } |
| 786 | else |
| 787 | { |
| 788 | mt->mt_sibling_index = |
| 789 | fib_path_list_child_add(mt->mt_path_list, |
| 790 | FIB_NODE_TYPE_MPLS_TUNNEL, |
| 791 | mti); |
| 792 | } |
| 793 | /* |
| 794 | * find the matching path extension and remove it |
| 795 | */ |
| 796 | vec_foreach(path_ext, mt->mt_path_exts) |
| 797 | { |
| 798 | if (!fib_path_ext_cmp(path_ext, rpaths)) |
| 799 | { |
| 800 | /* |
| 801 | * delete the element moving the remaining elements down 1 position. |
| 802 | * this preserves the sorted order. |
| 803 | */ |
| 804 | vec_free(path_ext->fpe_label_stack); |
| 805 | vec_delete(mt->mt_path_exts, 1, |
| 806 | (path_ext - mt->mt_path_exts)); |
| 807 | break; |
| 808 | } |
| 809 | } |
| 810 | /* |
| 811 | * re-resolve all the path-extensions with the new path-list |
| 812 | */ |
| 813 | vec_foreach(path_ext, mt->mt_path_exts) |
| 814 | { |
| 815 | fib_path_ext_resolve(path_ext, mt->mt_path_list); |
| 816 | } |
| 817 | |
| 818 | mpls_tunnel_restack(mt); |
| 819 | } |
| 820 | |
| 821 | return (fib_path_list_get_n_paths(mt->mt_path_list)); |
| 822 | } |
| 823 | |
| 824 | |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 825 | static clib_error_t * |
| 826 | vnet_create_mpls_tunnel_command_fn (vlib_main_t * vm, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 827 | unformat_input_t * input, |
| 828 | vlib_cli_command_t * cmd) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 829 | { |
| 830 | unformat_input_t _line_input, * line_input = &_line_input; |
| 831 | vnet_main_t * vnm = vnet_get_main(); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 832 | u8 is_del = 0, l2_only = 0, is_multicast =0; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 833 | fib_route_path_t rpath, *rpaths = NULL; |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 834 | mpls_label_t out_label = MPLS_LABEL_INVALID; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 835 | u32 sw_if_index; |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 836 | clib_error_t *error = NULL; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 837 | |
| 838 | memset(&rpath, 0, sizeof(rpath)); |
| 839 | |
| 840 | /* Get a line of input. */ |
| 841 | if (! unformat_user (input, unformat_line_input, line_input)) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 842 | return 0; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 843 | |
| 844 | while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) |
| 845 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 846 | if (unformat (line_input, "del %U", |
| 847 | unformat_vnet_sw_interface, vnm, |
| 848 | &sw_if_index)) |
| 849 | is_del = 1; |
| 850 | else if (unformat (line_input, "add")) |
| 851 | is_del = 0; |
| 852 | else if (unformat (line_input, "out-label %U", |
| 853 | unformat_mpls_unicast_label, &out_label)) |
| 854 | { |
| 855 | vec_add1(rpath.frp_label_stack, out_label); |
| 856 | } |
| 857 | else if (unformat (line_input, "via %U %U", |
| 858 | unformat_ip4_address, |
| 859 | &rpath.frp_addr.ip4, |
| 860 | unformat_vnet_sw_interface, vnm, |
| 861 | &rpath.frp_sw_if_index)) |
| 862 | { |
| 863 | rpath.frp_weight = 1; |
| 864 | rpath.frp_proto = FIB_PROTOCOL_IP4; |
| 865 | } |
| 866 | |
| 867 | else if (unformat (line_input, "via %U %U", |
| 868 | unformat_ip6_address, |
| 869 | &rpath.frp_addr.ip6, |
| 870 | unformat_vnet_sw_interface, vnm, |
| 871 | &rpath.frp_sw_if_index)) |
| 872 | { |
| 873 | rpath.frp_weight = 1; |
| 874 | rpath.frp_proto = FIB_PROTOCOL_IP6; |
| 875 | } |
| 876 | else if (unformat (line_input, "via %U", |
| 877 | unformat_ip6_address, |
| 878 | &rpath.frp_addr.ip6)) |
| 879 | { |
| 880 | rpath.frp_fib_index = 0; |
| 881 | rpath.frp_weight = 1; |
| 882 | rpath.frp_sw_if_index = ~0; |
| 883 | rpath.frp_proto = FIB_PROTOCOL_IP6; |
| 884 | } |
| 885 | else if (unformat (line_input, "via %U", |
| 886 | unformat_ip4_address, |
| 887 | &rpath.frp_addr.ip4)) |
| 888 | { |
| 889 | rpath.frp_fib_index = 0; |
| 890 | rpath.frp_weight = 1; |
| 891 | rpath.frp_sw_if_index = ~0; |
| 892 | rpath.frp_proto = FIB_PROTOCOL_IP4; |
| 893 | } |
| 894 | else if (unformat (line_input, "l2-only")) |
| 895 | l2_only = 1; |
| 896 | else if (unformat (line_input, "multicast")) |
| 897 | is_multicast = 1; |
| 898 | else |
| 899 | { |
| 900 | error = clib_error_return (0, "unknown input '%U'", |
| 901 | format_unformat_error, line_input); |
| 902 | goto done; |
| 903 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 904 | } |
| 905 | |
| 906 | if (is_del) |
| 907 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 908 | vnet_mpls_tunnel_del(sw_if_index); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 909 | } |
| 910 | else |
| 911 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 912 | if (0 == vec_len(rpath.frp_label_stack)) |
| 913 | { |
| 914 | error = clib_error_return (0, "No Output Labels '%U'", |
| 915 | format_unformat_error, line_input); |
| 916 | goto done; |
| 917 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 918 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 919 | vec_add1(rpaths, rpath); |
| 920 | sw_if_index = vnet_mpls_tunnel_create(l2_only, is_multicast); |
| 921 | vnet_mpls_tunnel_path_add(sw_if_index, rpaths); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 922 | } |
| 923 | |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 924 | done: |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 925 | vec_free(rpaths); |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 926 | unformat_free (line_input); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 927 | |
Billy McFall | a9a20e7 | 2017-02-15 11:39:12 -0500 | [diff] [blame] | 928 | return error; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 929 | } |
| 930 | |
| 931 | /*? |
| 932 | * This command create a uni-directional MPLS tunnel |
| 933 | * |
| 934 | * @cliexpar |
| 935 | * @cliexstart{create mpls tunnel} |
| 936 | * create mpls tunnel via 10.0.0.1 GigEthernet0/8/0 out-label 33 out-label 34 |
| 937 | * @cliexend |
| 938 | ?*/ |
| 939 | VLIB_CLI_COMMAND (create_mpls_tunnel_command, static) = { |
| 940 | .path = "mpls tunnel", |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 941 | .short_help = |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 942 | "mpls tunnel via [addr] [interface] [out-labels]", |
| 943 | .function = vnet_create_mpls_tunnel_command_fn, |
| 944 | }; |
| 945 | |
| 946 | static u8 * |
| 947 | format_mpls_tunnel (u8 * s, va_list * args) |
| 948 | { |
| 949 | mpls_tunnel_t *mt = va_arg (*args, mpls_tunnel_t *); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 950 | mpls_tunnel_attribute_t attr; |
| 951 | fib_path_ext_t *path_ext; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 952 | |
| 953 | s = format(s, "mpls_tunnel%d: sw_if_index:%d hw_if_index:%d", |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 954 | mt - mpls_tunnel_pool, |
| 955 | mt->mt_sw_if_index, |
| 956 | mt->mt_hw_if_index); |
| 957 | if (MPLS_TUNNEL_FLAG_NONE != mt->mt_flags) { |
| 958 | s = format(s, " \n flags:"); |
| 959 | FOR_EACH_MPLS_TUNNEL_ATTRIBUTE(attr) { |
| 960 | if ((1<<attr) & mt->mt_flags) { |
| 961 | s = format (s, "%s,", mpls_tunnel_attribute_names[attr]); |
| 962 | } |
| 963 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 964 | } |
| 965 | s = format(s, "\n via:\n"); |
| 966 | s = fib_path_list_format(mt->mt_path_list, s); |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 967 | s = format(s, " Extensions:"); |
| 968 | vec_foreach(path_ext, mt->mt_path_exts) |
| 969 | { |
| 970 | s = format(s, "\n %U", format_fib_path_ext, path_ext); |
| 971 | } |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 972 | s = format(s, "\n"); |
| 973 | |
| 974 | return (s); |
| 975 | } |
| 976 | |
| 977 | static clib_error_t * |
| 978 | show_mpls_tunnel_command_fn (vlib_main_t * vm, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 979 | unformat_input_t * input, |
| 980 | vlib_cli_command_t * cmd) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 981 | { |
| 982 | mpls_tunnel_t * mt; |
| 983 | u32 mti = ~0; |
| 984 | |
| 985 | if (pool_elts (mpls_tunnel_pool) == 0) |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 986 | vlib_cli_output (vm, "No MPLS tunnels configured..."); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 987 | |
| 988 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 989 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 990 | if (unformat (input, "%d", &mti)) |
| 991 | ; |
| 992 | else |
| 993 | break; |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 994 | } |
| 995 | |
| 996 | if (~0 == mti) |
| 997 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 998 | pool_foreach (mt, mpls_tunnel_pool, |
| 999 | ({ |
| 1000 | vlib_cli_output (vm, "[@%d] %U", |
| 1001 | mt - mpls_tunnel_pool, |
| 1002 | format_mpls_tunnel, mt); |
| 1003 | })); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 1004 | } |
| 1005 | else |
| 1006 | { |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 1007 | if (pool_is_free_index(mpls_tunnel_pool, mti)) |
| 1008 | return clib_error_return (0, "Not atunnel index %d", mti); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 1009 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 1010 | mt = pool_elt_at_index(mpls_tunnel_pool, mti); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 1011 | |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 1012 | vlib_cli_output (vm, "[@%d] %U", |
| 1013 | mt - mpls_tunnel_pool, |
| 1014 | format_mpls_tunnel, mt); |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 1015 | } |
| 1016 | |
| 1017 | return 0; |
| 1018 | } |
| 1019 | |
| 1020 | /*? |
| 1021 | * This command to show MPLS tunnels |
| 1022 | * |
| 1023 | * @cliexpar |
| 1024 | * @cliexstart{sh mpls tunnel 2} |
| 1025 | * [@2] mpls_tunnel2: sw_if_index:5 hw_if_index:5 |
| 1026 | * label-stack: |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 1027 | * 3, |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 1028 | * via: |
| 1029 | * index:26 locks:1 proto:ipv4 uPRF-list:26 len:1 itfs:[2, ] |
| 1030 | * index:26 pl-index:26 ipv4 weight=1 attached-nexthop: oper-flags:resolved, |
| 1031 | * 10.0.0.2 loop0 |
| 1032 | * [@0]: ipv4 via 10.0.0.2 loop0: IP4: de:ad:00:00:00:00 -> 00:00:11:aa:bb:cc |
| 1033 | * @cliexend |
| 1034 | ?*/ |
| 1035 | VLIB_CLI_COMMAND (show_mpls_tunnel_command, static) = { |
| 1036 | .path = "show mpls tunnel", |
| 1037 | .function = show_mpls_tunnel_command_fn, |
| 1038 | }; |
| 1039 | |
| 1040 | static mpls_tunnel_t * |
| 1041 | mpls_tunnel_from_fib_node (fib_node_t *node) |
| 1042 | { |
| 1043 | #if (CLIB_DEBUG > 0) |
| 1044 | ASSERT(FIB_NODE_TYPE_MPLS_TUNNEL == node->fn_type); |
| 1045 | #endif |
| 1046 | return ((mpls_tunnel_t*) (((char*)node) - |
| 1047 | STRUCT_OFFSET_OF(mpls_tunnel_t, mt_node))); |
| 1048 | } |
| 1049 | |
| 1050 | /** |
| 1051 | * Function definition to backwalk a FIB node |
| 1052 | */ |
| 1053 | static fib_node_back_walk_rc_t |
| 1054 | mpls_tunnel_back_walk (fib_node_t *node, |
Neale Ranns | 0f26c5a | 2017-03-01 15:12:11 -0800 | [diff] [blame] | 1055 | fib_node_back_walk_ctx_t *ctx) |
Neale Ranns | ad422ed | 2016-11-02 14:20:04 +0000 | [diff] [blame] | 1056 | { |
| 1057 | mpls_tunnel_restack(mpls_tunnel_from_fib_node(node)); |
| 1058 | |
| 1059 | return (FIB_NODE_BACK_WALK_CONTINUE); |
| 1060 | } |
| 1061 | |
| 1062 | /** |
| 1063 | * Function definition to get a FIB node from its index |
| 1064 | */ |
| 1065 | static fib_node_t* |
| 1066 | mpls_tunnel_fib_node_get (fib_node_index_t index) |
| 1067 | { |
| 1068 | mpls_tunnel_t * mt; |
| 1069 | |
| 1070 | mt = pool_elt_at_index(mpls_tunnel_pool, index); |
| 1071 | |
| 1072 | return (&mt->mt_node); |
| 1073 | } |
| 1074 | |
| 1075 | /** |
| 1076 | * Function definition to inform the FIB node that its last lock has gone. |
| 1077 | */ |
| 1078 | static void |
| 1079 | mpls_tunnel_last_lock_gone (fib_node_t *node) |
| 1080 | { |
| 1081 | /* |
| 1082 | * The MPLS MPLS tunnel is a root of the graph. As such |
| 1083 | * it never has children and thus is never locked. |
| 1084 | */ |
| 1085 | ASSERT(0); |
| 1086 | } |
| 1087 | |
| 1088 | /* |
| 1089 | * Virtual function table registered by MPLS MPLS tunnels |
| 1090 | * for participation in the FIB object graph. |
| 1091 | */ |
| 1092 | const static fib_node_vft_t mpls_vft = { |
| 1093 | .fnv_get = mpls_tunnel_fib_node_get, |
| 1094 | .fnv_last_lock = mpls_tunnel_last_lock_gone, |
| 1095 | .fnv_back_walk = mpls_tunnel_back_walk, |
| 1096 | }; |
| 1097 | |
| 1098 | static clib_error_t * |
| 1099 | mpls_tunnel_init (vlib_main_t *vm) |
| 1100 | { |
| 1101 | fib_node_register_type(FIB_NODE_TYPE_MPLS_TUNNEL, &mpls_vft); |
| 1102 | |
| 1103 | return 0; |
| 1104 | } |
| 1105 | VLIB_INIT_FUNCTION(mpls_tunnel_init); |