src/vnet/mpls/mpls_tunnel.c

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