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