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