src/vnet/dpo/mpls_label_dpo.c

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vnet/ip/ip.h>
  17 #include <vnet/dpo/mpls_label_dpo.h>
  18 #include <vnet/mpls/mpls.h>
  19 #include <vnet/dpo/drop_dpo.h>
  20
  21 /*
  22  * pool of all MPLS Label DPOs
  23  */
  24 mpls_label_dpo_t *mpls_label_dpo_pool;
  25
  26 /**
  27  * Strings for the flags
  28  */
  29 const char* mpls_label_dpo_attr_names[] = MPLS_LABEL_DPO_ATTR_NAMES;
  30
  31 /**
  32  * registered DPO types for each of the label sub-types. And there's a
  33  * subtype for each of the flag combinations.
  34  */
  35 static dpo_type_t mpls_label_dpo_types[1 << MPLS_LABEL_DPO_ATTR_MAX];
  36
  37 static mpls_label_dpo_t *
  38 mpls_label_dpo_alloc (void)
  39 {
  40     mpls_label_dpo_t *mld;
  41
  42     pool_get_aligned(mpls_label_dpo_pool, mld, CLIB_CACHE_LINE_BYTES);
  43     memset(mld, 0, sizeof(*mld));
  44
  45     dpo_reset(&mld->mld_dpo);
  46
  47     return (mld);
  48 }
  49
  50 static index_t
  51 mpls_label_dpo_get_index (mpls_label_dpo_t *mld)
  52 {
  53     return (mld - mpls_label_dpo_pool);
  54 }
  55
  56 void
  57 mpls_label_dpo_create (fib_mpls_label_t *label_stack,
  58                        mpls_eos_bit_t eos,
  59                        dpo_proto_t payload_proto,
  60                        mpls_label_dpo_flags_t flags,
  61                        const dpo_id_t *parent,
  62                        dpo_id_t *dpo)
  63 {
  64     mpls_label_dpo_t *mld;
  65     dpo_type_t dtype;
  66     u32 ii;
  67
  68     if ((DPO_PROTO_IP4 != payload_proto) &&
  69         (DPO_PROTO_IP6 != payload_proto))
  70     {
  71         /*
  72          * remove unsupported configuration
  73          */
  74         flags &= ~MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR;
  75     }
  76
  77     mld = mpls_label_dpo_alloc();
  78     mld->mld_flags = flags;
  79     dtype = mpls_label_dpo_types[flags];
  80
  81     if (MPLS_LABEL_DPO_MAX_N_LABELS < vec_len(label_stack))
  82     {
  83         clib_warning("Label stack size exceeded");
  84         dpo_stack(dtype,
  85                   mld->mld_payload_proto,
  86                   &mld->mld_dpo,
  87                   drop_dpo_get(DPO_PROTO_MPLS));
  88     }
  89     else
  90     {
  91         mld->mld_n_labels = vec_len(label_stack);
  92         mld->mld_n_hdr_bytes = mld->mld_n_labels * sizeof(mld->mld_hdr[0]);
  93         mld->mld_payload_proto = payload_proto;
  94
  95         /*
  96          * construct label rewrite headers for each value passed.
  97          * get the header in network byte order since we will paint it
  98          * on a packet in the data-plane
  99          */
 100         for (ii = 0; ii < mld->mld_n_labels-1; ii++)
 101         {
 102             vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl,
 103                                    label_stack[ii].fml_value);
 104             vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl,
 105                                  label_stack[ii].fml_exp);
 106             vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl,
 107                                MPLS_NON_EOS);
 108             if (0 != label_stack[ii].fml_ttl)
 109             {
 110                 vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
 111                                      label_stack[ii].fml_ttl);
 112             }
 113             else
 114             {
 115                 vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
 116                                      MPLS_LABEL_DEFAULT_TTL);
 117             }
 118             mld->mld_hdr[ii].label_exp_s_ttl =
 119                 clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
 120         }
 121
 122         /*
 123          * the inner most label
 124          */
 125         ii = mld->mld_n_labels-1;
 126
 127         vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl,
 128                                label_stack[ii].fml_value);
 129         vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl,
 130                              label_stack[ii].fml_exp);
 131         vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl, eos);
 132         if (0 != label_stack[ii].fml_ttl)
 133         {
 134             vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
 135                                  label_stack[ii].fml_ttl);
 136         }
 137         else
 138         {
 139             vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
 140                                  MPLS_LABEL_DEFAULT_TTL);
 141         }
 142         mld->mld_hdr[ii].label_exp_s_ttl =
 143             clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
 144
 145         /*
 146          * pipe/uniform mode is only supported for the bottom of stack label
 147          */
 148         if (FIB_MPLS_LSP_MODE_UNIFORM == label_stack[ii].fml_mode)
 149         {
 150             mld->mld_flags |= MPLS_LABEL_DPO_FLAG_UNIFORM_MODE;
 151         }
 152         else
 153         {
 154             mld->mld_flags &= ~MPLS_LABEL_DPO_FLAG_UNIFORM_MODE;
 155         }
 156         dtype = mpls_label_dpo_types[mld->mld_flags];
 157
 158         /*
 159          * stack this label object on its parent.
 160          */
 161         dpo_stack(dtype,
 162                   mld->mld_payload_proto,
 163                   &mld->mld_dpo,
 164                   parent);
 165     }
 166
 167     dpo_set(dpo,
 168             dtype,
 169             mld->mld_payload_proto,
 170             mpls_label_dpo_get_index(mld));
 171 }
 172
 173 u8*
 174 format_mpls_label_dpo_flags (u8 *s, va_list *args)
 175 {
 176     mpls_label_dpo_flags_t flags = va_arg (*args, int);
 177     mpls_label_dpo_attr_t attr;
 178
 179     FOR_EACH_MPLS_LABEL_DPO_ATTR(attr)
 180     {
 181         if ((1 << attr) & flags)
 182         {
 183             s = format(s, "%s,", mpls_label_dpo_attr_names[attr]);
 184         }
 185     }
 186
 187     return (s);
 188 }
 189
 190 u8*
 191 format_mpls_label_dpo (u8 *s, va_list *args)
 192 {
 193     index_t index = va_arg (*args, index_t);
 194     u32 indent = va_arg (*args, u32);
 195     mpls_unicast_header_t hdr;
 196     mpls_label_dpo_t *mld;
 197     u32 ii;
 198
 199     if (pool_is_free_index(mpls_label_dpo_pool, index))
 200     {
 201         /*
 202          * the packet trace can be printed after the DPO has been deleted
 203          */
 204         return (format(s, "mpls-label[???,%d]:", index));
 205     }
 206
 207     mld = mpls_label_dpo_get(index);
 208     s = format(s, "mpls-label[%U%d]:",
 209                format_mpls_label_dpo_flags,
 210                (int) mld->mld_flags, index);
 211
 212     for (ii = 0; ii < mld->mld_n_labels; ii++)
 213     {
 214         hdr.label_exp_s_ttl =
 215             clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl);
 216         s = format(s, "%U", format_mpls_header, hdr);
 217     }
 218
 219     s = format(s, "\n%U", format_white_space, indent);
 220     s = format(s, "%U", format_dpo_id, &mld->mld_dpo, indent+2);
 221
 222     return (s);
 223 }
 224
 225 static void
 226 mpls_label_dpo_lock (dpo_id_t *dpo)
 227 {
 228     mpls_label_dpo_t *mld;
 229
 230     mld = mpls_label_dpo_get(dpo->dpoi_index);
 231
 232     mld->mld_locks++;
 233 }
 234
 235 static void
 236 mpls_label_dpo_unlock (dpo_id_t *dpo)
 237 {
 238     mpls_label_dpo_t *mld;
 239
 240     mld = mpls_label_dpo_get(dpo->dpoi_index);
 241
 242     mld->mld_locks--;
 243
 244     if (0 == mld->mld_locks)
 245     {
 246         dpo_reset(&mld->mld_dpo);
 247         pool_put(mpls_label_dpo_pool, mld);
 248     }
 249 }
 250
 251 /**
 252  * @brief A struct to hold tracing information for the MPLS label imposition
 253  * node.
 254  */
 255 typedef struct mpls_label_imposition_trace_t_
 256 {
 257     /**
 258      * The MPLS header imposed
 259      */
 260     mpls_unicast_header_t hdr;
 261
 262     /**
 263      * TTL imposed - only valid for uniform LSPs
 264      */
 265     u8 ttl;
 266
 267     /**
 268      * TTL imposed - only valid for uniform LSPs
 269      */
 270     u8 exp;
 271 } mpls_label_imposition_trace_t;
 272
 273 always_inline mpls_unicast_header_t *
 274 mpls_label_paint (vlib_buffer_t * b0,
 275                   mpls_label_dpo_t *mld0)
 276 {
 277     mpls_unicast_header_t *hdr0;
 278
 279     vlib_buffer_advance(b0, -(mld0->mld_n_hdr_bytes));
 280
 281     hdr0 = vlib_buffer_get_current(b0);
 282
 283     if (1 == mld0->mld_n_labels)
 284     {
 285         /* optimise for the common case of one label */
 286         *hdr0 = mld0->mld_hdr[0];
 287     }
 288     else
 289     {
 290         clib_memcpy(hdr0, mld0->mld_hdr, mld0->mld_n_hdr_bytes);
 291         hdr0 = hdr0 + (mld0->mld_n_labels - 1);
 292     }
 293
 294     return (hdr0);
 295 }
 296
 297 /**
 298  * Paint on an MPLS label and fixup the TTL
 299  */
 300 always_inline mpls_unicast_header_t *
 301 mpls_label_paint_w_ttl (vlib_buffer_t * b0,
 302                         mpls_label_dpo_t *mld0,
 303                         u8 ttl0)
 304 {
 305     mpls_unicast_header_t *hdr0;
 306
 307     hdr0 = mpls_label_paint(b0, mld0);
 308
 309     /* fixup the TTL for the inner most label */
 310     ((char*)hdr0)[3] = ttl0;
 311
 312     return (hdr0);
 313 }
 314
 315 /**
 316  * Paint on an MPLS label and fixup the TTL and EXP bits.
 317  */
 318 always_inline mpls_unicast_header_t *
 319 mpls_label_paint_w_ttl_exp (vlib_buffer_t * b0,
 320                             mpls_label_dpo_t *mld0,
 321                             u8 ttl0,
 322                             u8 exp0)
 323 {
 324     mpls_unicast_header_t *hdr0;
 325
 326     hdr0 = mpls_label_paint_w_ttl(b0, mld0, ttl0);
 327
 328     /* fixup the EXP for the inner most label */
 329     ((char*)hdr0)[2] |= (exp0 << 1);
 330
 331     return (hdr0);
 332 }
 333
 334 /**
 335  * Paint on an MPLS label and fixup the TTL and EXP bits
 336  * When the EXP bits are *already* bit shift to the correct place in
 337  * in the 2nd byte (i.e. they were read from another label)
 338  */
 339 always_inline mpls_unicast_header_t *
 340 mpls_label_paint_w_ttl_mpls_exp (vlib_buffer_t * b0,
 341                                  mpls_label_dpo_t *mld0,
 342                                  u8 ttl0,
 343                                  u8 exp0)
 344 {
 345     mpls_unicast_header_t *hdr0;
 346
 347     hdr0 = mpls_label_paint_w_ttl(b0, mld0, ttl0);
 348
 349     /* fixup the EXP for the inner most label */
 350     ((char*)hdr0)[2] |= exp0;
 351
 352     return (hdr0);
 353 }
 354
 355 always_inline uword
 356 mpls_label_imposition_inline (vlib_main_t * vm,
 357                               vlib_node_runtime_t * node,
 358                               vlib_frame_t * from_frame,
 359                               const dpo_proto_t dproto,
 360                               const mpls_label_dpo_flags_t flags)
 361 {
 362     u32 n_left_from, next_index, * from, * to_next;
 363
 364     from = vlib_frame_vector_args (from_frame);
 365     n_left_from = from_frame->n_vectors;
 366
 367     next_index = node->cached_next_index;
 368
 369     while (n_left_from > 0)
 370     {
 371         u32 n_left_to_next;
 372
 373         vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
 374
 375         while (n_left_from >= 8 && n_left_to_next >= 4)
 376         {
 377             u32 bi0, mldi0, bi1, mldi1, bi2, mldi2, bi3, mldi3;
 378             mpls_unicast_header_t *hdr0, *hdr1, *hdr2, *hdr3;
 379             mpls_label_dpo_t *mld0, *mld1, *mld2, *mld3;
 380             vlib_buffer_t * b0, *b1, * b2, *b3;
 381             u32 next0, next1, next2, next3;
 382             u8 ttl0, ttl1, ttl2, ttl3;
 383             u8 exp0, exp1, exp2, exp3;
 384
 385             bi0 = to_next[0] = from[0];
 386             bi1 = to_next[1] = from[1];
 387             bi2 = to_next[2] = from[2];
 388             bi3 = to_next[3] = from[3];
 389
 390             /* Prefetch next iteration. */
 391             {
 392                 vlib_buffer_t * p2, * p3, *p4, *p5;
 393
 394                 p2 = vlib_get_buffer (vm, from[2]);
 395                 p3 = vlib_get_buffer (vm, from[3]);
 396                 p4 = vlib_get_buffer (vm, from[4]);
 397                 p5 = vlib_get_buffer (vm, from[5]);
 398
 399                 vlib_prefetch_buffer_header (p2, STORE);
 400                 vlib_prefetch_buffer_header (p3, STORE);
 401                 vlib_prefetch_buffer_header (p4, STORE);
 402                 vlib_prefetch_buffer_header (p5, STORE);
 403
 404                 CLIB_PREFETCH (p2->data, sizeof (hdr0[0]), STORE);
 405                 CLIB_PREFETCH (p3->data, sizeof (hdr0[0]), STORE);
 406                 CLIB_PREFETCH (p4->data, sizeof (hdr0[0]), STORE);
 407                 CLIB_PREFETCH (p5->data, sizeof (hdr0[0]), STORE);
 408             }
 409
 410             from += 4;
 411             to_next += 4;
 412             n_left_from -= 4;
 413             n_left_to_next -= 4;
 414
 415             b0 = vlib_get_buffer (vm, bi0);
 416             b1 = vlib_get_buffer (vm, bi1);
 417             b2 = vlib_get_buffer (vm, bi2);
 418             b3 = vlib_get_buffer (vm, bi3);
 419
 420             /* dst lookup was done by ip4 lookup */
 421             mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
 422             mldi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
 423             mldi2 = vnet_buffer(b2)->ip.adj_index[VLIB_TX];
 424             mldi3 = vnet_buffer(b3)->ip.adj_index[VLIB_TX];
 425             mld0 = mpls_label_dpo_get(mldi0);
 426             mld1 = mpls_label_dpo_get(mldi1);
 427             mld2 = mpls_label_dpo_get(mldi2);
 428             mld3 = mpls_label_dpo_get(mldi3);
 429
 430             if (DPO_PROTO_MPLS != dproto)
 431             {
 432                 /*
 433                  * These are the non-MPLS payload imposition cases
 434                  */
 435                 if (DPO_PROTO_IP4 == dproto)
 436                 {
 437                     ip4_header_t * ip0 = vlib_buffer_get_current(b0);
 438                     ip4_header_t * ip1 = vlib_buffer_get_current(b1);
 439                     ip4_header_t * ip2 = vlib_buffer_get_current(b2);
 440                     ip4_header_t * ip3 = vlib_buffer_get_current(b3);
 441
 442                     if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
 443                     {
 444                         /*
 445                          * decrement the TTL on ingress to the LSP
 446                          */
 447                         u32 checksum0;
 448                         u32 checksum1;
 449                         u32 checksum2;
 450                         u32 checksum3;
 451
 452                         checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
 453                         checksum1 = ip1->checksum + clib_host_to_net_u16 (0x0100);
 454                         checksum2 = ip2->checksum + clib_host_to_net_u16 (0x0100);
 455                         checksum3 = ip3->checksum + clib_host_to_net_u16 (0x0100);
 456
 457                         checksum0 += checksum0 >= 0xffff;
 458                         checksum1 += checksum1 >= 0xffff;
 459                         checksum2 += checksum2 >= 0xffff;
 460                         checksum3 += checksum3 >= 0xffff;
 461
 462                         ip0->checksum = checksum0;
 463                         ip1->checksum = checksum1;
 464                         ip2->checksum = checksum2;
 465                         ip3->checksum = checksum3;
 466
 467                         ip0->ttl -= 1;
 468                         ip1->ttl -= 1;
 469                         ip2->ttl -= 1;
 470                         ip3->ttl -= 1;
 471                     }
 472
 473                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 474                     {
 475                         ttl1 = ip1->ttl;
 476                         ttl0 = ip0->ttl;
 477                         ttl3 = ip3->ttl;
 478                         ttl2 = ip2->ttl;
 479                         /* by default copy the 3 most significant bits */
 480                         exp0 = ip_dscp_to_mpls_exp(ip0->tos);
 481                         exp1 = ip_dscp_to_mpls_exp(ip1->tos);
 482                         exp2 = ip_dscp_to_mpls_exp(ip2->tos);
 483                         exp3 = ip_dscp_to_mpls_exp(ip3->tos);
 484                     }
 485                 }
 486                 else if (DPO_PROTO_IP6 == dproto)
 487                 {
 488                     /*
 489                      * decrement the TTL on ingress to the LSP
 490                      */
 491                     ip6_header_t * ip0 = vlib_buffer_get_current(b0);
 492                     ip6_header_t * ip1 = vlib_buffer_get_current(b1);
 493                     ip6_header_t * ip2 = vlib_buffer_get_current(b2);
 494                     ip6_header_t * ip3 = vlib_buffer_get_current(b3);
 495
 496                     if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
 497                     {
 498                         ip0->hop_limit -= 1;
 499                         ip1->hop_limit -= 1;
 500                         ip2->hop_limit -= 1;
 501                         ip3->hop_limit -= 1;
 502                     }
 503                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 504                     {
 505                         ttl0 = ip0->hop_limit;
 506                         ttl1 = ip1->hop_limit;
 507                         ttl2 = ip2->hop_limit;
 508                         ttl3 = ip3->hop_limit;
 509                         /* by default copy the 3 most significant bits */
 510                         exp0 = ip_dscp_to_mpls_exp(
 511                             ip6_traffic_class_network_order(ip0));
 512                         exp1 = ip_dscp_to_mpls_exp(
 513                             ip6_traffic_class_network_order(ip1));
 514                         exp2 = ip_dscp_to_mpls_exp(
 515                             ip6_traffic_class_network_order(ip2));
 516                         exp3 = ip_dscp_to_mpls_exp(
 517                             ip6_traffic_class_network_order(ip3));
 518                     }
 519                 }
 520                 else
 521                 {
 522                     /*
 523                      * nothing to change in the ethernet header
 524                      */
 525                     ttl0 = ttl1 = ttl2 = ttl3 = MPLS_LABEL_DEFAULT_TTL;
 526                     exp0 = exp1 = exp2 = exp3 = MPLS_LABEL_DEFAULT_EXP;
 527                 }
 528                 /*
 529                  * These are the non-MPLS payload imposition cases.
 530                  * Based on the LSP mode either, for uniform, copy down the TTL
 531                  * and EXP from the payload or, for pipe mode, slap on the value
 532                  * requested from config
 533                  */
 534                 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 535                 {
 536                     hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
 537                     hdr1 = mpls_label_paint_w_ttl_exp(b1, mld1, ttl1, exp1);
 538                     hdr2 = mpls_label_paint_w_ttl_exp(b2, mld2, ttl2, exp2);
 539                     hdr3 = mpls_label_paint_w_ttl_exp(b3, mld3, ttl3, exp3);
 540                 }
 541                 else
 542                 {
 543                     hdr0 = mpls_label_paint(b0, mld0);
 544                     hdr1 = mpls_label_paint(b1, mld1);
 545                     hdr2 = mpls_label_paint(b2, mld2);
 546                     hdr3 = mpls_label_paint(b3, mld3);
 547                 }
 548             }
 549             else
 550             {
 551                 /*
 552                  * else, the packet to be encapped is an MPLS packet
 553                  * there are two cases to consider:
 554                  *  1 - this is an MPLS label swap at an LSP midpoint.
 555                  *      recognisable because mpls.first = 1. In this case the
 556                  *      TTL must be set to the current value -1.
 557                  *  2 - The MPLS packet is recursing (or being injected into)
 558                  *      this LSP, in which case the pipe/uniform rules apply
 559                  *
 560                  */
 561                 if (PREDICT_TRUE(vnet_buffer(b0)->mpls.first))
 562                 {
 563                     /*
 564                      * The first label to be imposed on the packet. this is a
 565                      * label swap.in which case we stashed the TTL and EXP bits
 566                      * in the packet in the lookup node
 567                      */
 568                     ASSERT(0 != vnet_buffer (b0)->mpls.ttl);
 569
 570                     ttl0 = vnet_buffer(b0)->mpls.ttl - 1;
 571                     exp0 = vnet_buffer(b0)->mpls.exp;
 572                     hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
 573                 }
 574                 else
 575                 {
 576                     /*
 577                      * not the first label. implying we are recusring down a
 578                      * chain of output labels. Each layer is considered a new
 579                      * LSP - hence the TTL/EXP are pipe/uniform handled
 580                      */
 581                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 582                     {
 583                         hdr0 = vlib_buffer_get_current(b0);
 584                         ttl0 = ((u8*)hdr0)[3];
 585                         exp0 = ((u8*)hdr0)[2] & 0xe;
 586                         hdr0 = mpls_label_paint_w_ttl_mpls_exp(b0, mld0, ttl0, exp0);
 587                     }
 588                     else
 589                     {
 590                         hdr0 = mpls_label_paint(b0, mld0);
 591                     }
 592                 }
 593                 if (PREDICT_TRUE(vnet_buffer(b1)->mpls.first))
 594                 {
 595                     ASSERT(0 != vnet_buffer (b1)->mpls.ttl);
 596
 597                     ttl1 = vnet_buffer(b1)->mpls.ttl - 1;
 598                     exp1 = vnet_buffer(b1)->mpls.exp;
 599                     hdr1 = mpls_label_paint_w_ttl_exp(b1, mld1, ttl1, exp1);
 600                 }
 601                 else
 602                 {
 603                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 604                     {
 605                         hdr1 = vlib_buffer_get_current(b1);
 606                         ttl1 = ((u8*)hdr1)[3];
 607                         exp1 = ((u8*)hdr1)[2] & 0xe;
 608                         hdr1 = mpls_label_paint_w_ttl_mpls_exp(b1, mld1, ttl1, exp1);
 609                     }
 610                     else
 611                     {
 612                         hdr1 = mpls_label_paint(b1, mld1);
 613                     }
 614                 }
 615                 if (PREDICT_TRUE(vnet_buffer(b2)->mpls.first))
 616                 {
 617                     ASSERT(0 != vnet_buffer (b2)->mpls.ttl);
 618
 619                     ttl2 = vnet_buffer(b2)->mpls.ttl - 1;
 620                     exp2 = vnet_buffer(b2)->mpls.exp;
 621                     hdr2 = mpls_label_paint_w_ttl_exp(b2, mld2, ttl2, exp2);
 622                 }
 623                 else
 624                 {
 625                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 626                     {
 627                         hdr2 = vlib_buffer_get_current(b2);
 628                         ttl2 = ((u8*)hdr2)[3];
 629                         exp2 = ((u8*)hdr2)[2] & 0xe;
 630                         hdr2 = mpls_label_paint_w_ttl_mpls_exp(b2, mld2, ttl2, exp2);
 631                     }
 632                     else
 633                     {
 634                         hdr2 = mpls_label_paint(b2, mld2);
 635                     }
 636                 }
 637                 if (PREDICT_TRUE(vnet_buffer(b3)->mpls.first))
 638                 {
 639                     ASSERT(0 != vnet_buffer (b3)->mpls.ttl);
 640
 641                     ttl3 = vnet_buffer(b3)->mpls.ttl - 1;
 642                     exp3 = vnet_buffer(b3)->mpls.exp;
 643                     hdr3 = mpls_label_paint_w_ttl_exp(b3, mld3, ttl3, exp3);
 644                 }
 645                 else
 646                 {
 647                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 648                     {
 649                         hdr3 = vlib_buffer_get_current(b3);
 650                         ttl3 = ((u8*)hdr3)[3];
 651                         exp3 = ((u8*)hdr3)[2] & 0xe;
 652                         hdr3 = mpls_label_paint_w_ttl_mpls_exp(b3, mld3, ttl3, exp3);
 653                     }
 654                     else
 655                     {
 656                         hdr3 = mpls_label_paint(b3, mld3);
 657                     }
 658                 }
 659
 660                 vnet_buffer(b0)->mpls.first = 0;
 661                 vnet_buffer(b1)->mpls.first = 0;
 662                 vnet_buffer(b2)->mpls.first = 0;
 663                 vnet_buffer(b3)->mpls.first = 0;
 664             }
 665
 666             next0 = mld0->mld_dpo.dpoi_next_node;
 667             next1 = mld1->mld_dpo.dpoi_next_node;
 668             next2 = mld2->mld_dpo.dpoi_next_node;
 669             next3 = mld3->mld_dpo.dpoi_next_node;
 670
 671             vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index;
 672             vnet_buffer(b1)->ip.adj_index[VLIB_TX] = mld1->mld_dpo.dpoi_index;
 673             vnet_buffer(b2)->ip.adj_index[VLIB_TX] = mld2->mld_dpo.dpoi_index;
 674             vnet_buffer(b3)->ip.adj_index[VLIB_TX] = mld3->mld_dpo.dpoi_index;
 675
 676             if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 677             {
 678                 mpls_label_imposition_trace_t *tr =
 679                     vlib_add_trace (vm, node, b0, sizeof (*tr));
 680                 tr->hdr = *hdr0;
 681                 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 682                 {
 683                     tr->ttl = ttl0;
 684                     tr->exp = exp0;
 685                 }
 686                 else
 687                 {
 688                     tr->ttl = tr->exp = 0;
 689                 }
 690             }
 691             if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
 692             {
 693                 mpls_label_imposition_trace_t *tr =
 694                     vlib_add_trace (vm, node, b1, sizeof (*tr));
 695                 tr->hdr = *hdr1;
 696                 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 697                 {
 698                     tr->ttl = ttl1;
 699                     tr->exp = exp1;
 700                 }
 701                 else
 702                 {
 703                     tr->ttl = tr->exp = 0;
 704                 }
 705             }
 706             if (PREDICT_FALSE(b2->flags & VLIB_BUFFER_IS_TRACED))
 707             {
 708                 mpls_label_imposition_trace_t *tr =
 709                     vlib_add_trace (vm, node, b2, sizeof (*tr));
 710                 tr->hdr = *hdr2;
 711                 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 712                 {
 713                     tr->ttl = ttl2;
 714                     tr->exp = exp2;
 715                 }
 716                 else
 717                 {
 718                     tr->ttl = tr->exp = 0;
 719                 }
 720             }
 721             if (PREDICT_FALSE(b3->flags & VLIB_BUFFER_IS_TRACED))
 722             {
 723                 mpls_label_imposition_trace_t *tr =
 724                     vlib_add_trace (vm, node, b3, sizeof (*tr));
 725                 tr->hdr = *hdr3;
 726                 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 727                 {
 728                     tr->ttl = ttl3;
 729                     tr->exp = exp3;
 730                 }
 731                 else
 732                 {
 733                     tr->ttl = tr->exp = 0;
 734                 }
 735             }
 736
 737             vlib_validate_buffer_enqueue_x4(vm, node, next_index, to_next,
 738                                             n_left_to_next,
 739                                             bi0, bi1, bi2, bi3,
 740                                             next0, next1, next2, next3);
 741         }
 742
 743         while (n_left_from > 0 && n_left_to_next > 0)
 744         {
 745             mpls_unicast_header_t *hdr0;
 746             mpls_label_dpo_t *mld0;
 747             vlib_buffer_t * b0;
 748             u32 bi0, mldi0;
 749             u8 ttl0, exp0;
 750             u32 next0;
 751
 752             bi0 = from[0];
 753             to_next[0] = bi0;
 754             from += 1;
 755             to_next += 1;
 756             n_left_from -= 1;
 757             n_left_to_next -= 1;
 758
 759             b0 = vlib_get_buffer (vm, bi0);
 760
 761             /* dst lookup was done by ip4 lookup */
 762             mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
 763             mld0 = mpls_label_dpo_get(mldi0);
 764
 765             if (DPO_PROTO_MPLS != dproto)
 766             {
 767                 if (DPO_PROTO_IP4 == dproto)
 768                 {
 769                     /*
 770                      * decrement the TTL on ingress to the LSP
 771                      */
 772                     ip4_header_t * ip0 = vlib_buffer_get_current(b0);
 773                     if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
 774                     {
 775                         u32 checksum0;
 776
 777                         checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
 778                         checksum0 += checksum0 >= 0xffff;
 779
 780                         ip0->checksum = checksum0;
 781                         ip0->ttl -= 1;
 782                     }
 783                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 784                     {
 785                         ttl0 = ip0->ttl;
 786                         exp0 = ip_dscp_to_mpls_exp(ip0->tos);
 787                     }
 788                 }
 789                 else if (DPO_PROTO_IP6 == dproto)
 790                 {
 791                     /*
 792                      * decrement the TTL on ingress to the LSP
 793                      */
 794                     ip6_header_t * ip0 = vlib_buffer_get_current(b0);
 795
 796                     if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
 797                     {
 798                         ip0->hop_limit -= 1;
 799                     }
 800                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 801                     {
 802                         ttl0 = ip0->hop_limit;
 803                         exp0 = ip_dscp_to_mpls_exp(
 804                             ip6_traffic_class_network_order(ip0));
 805                     }
 806                 }
 807                 else
 808                 {
 809                     /*
 810                      * nothing to change in the ethernet header
 811                      */
 812                     ttl0 = MPLS_LABEL_DEFAULT_TTL;
 813                     exp0 = MPLS_LABEL_DEFAULT_EXP;
 814                 }
 815
 816                 /*
 817                  * These are the non-MPLS payload imposition cases.
 818                  * Based on the LSP mode either, for uniform, copy down the TTL
 819                  * from the payload or, for pipe mode, slap on the value
 820                  * requested from config
 821                  */
 822                 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 823                 {
 824                     hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
 825                 }
 826                 else
 827                 {
 828                     hdr0 = mpls_label_paint(b0, mld0);
 829                 }
 830             }
 831             else
 832             {
 833                 if (PREDICT_TRUE(vnet_buffer(b0)->mpls.first))
 834                 {
 835                     ASSERT(0 != vnet_buffer (b0)->mpls.ttl);
 836
 837                     ttl0 = vnet_buffer(b0)->mpls.ttl - 1;
 838                     exp0 = vnet_buffer(b0)->mpls.exp;
 839                     hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
 840                 }
 841                 else
 842                 {
 843                     if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 844                     {
 845                         hdr0 = vlib_buffer_get_current(b0);
 846                         ttl0 = ((u8*)hdr0)[3];
 847                         exp0 = ((u8*)hdr0)[2] & 0xe;
 848                         hdr0 = mpls_label_paint_w_ttl_mpls_exp(b0, mld0, ttl0, exp0);
 849                     }
 850                     else
 851                     {
 852                         hdr0 = mpls_label_paint(b0, mld0);
 853                     }
 854                 }
 855
 856                 vnet_buffer(b0)->mpls.first = 0;
 857             }
 858
 859             next0 = mld0->mld_dpo.dpoi_next_node;
 860             vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index;
 861
 862             if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
 863             {
 864                 mpls_label_imposition_trace_t *tr =
 865                     vlib_add_trace (vm, node, b0, sizeof (*tr));
 866                 tr->hdr = *hdr0;
 867                 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
 868                 {
 869                     tr->ttl = ttl0;
 870                     tr->exp = exp0;
 871                 }
 872                 else
 873                 {
 874                     tr->ttl = tr->exp = 0;
 875                 }
 876            }
 877
 878             vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
 879                                             n_left_to_next, bi0, next0);
 880         }
 881         vlib_put_next_frame (vm, node, next_index, n_left_to_next);
 882     }
 883     return from_frame->n_vectors;
 884 }
 885
 886 static u8 *
 887 format_mpls_label_imposition_trace (u8 * s, va_list * args)
 888 {
 889     CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
 890     CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
 891     mpls_label_imposition_trace_t * t;
 892     mpls_unicast_header_t hdr;
 893     u32 indent;
 894
 895     t = va_arg (*args, mpls_label_imposition_trace_t *);
 896     indent = format_get_indent (s);
 897     hdr.label_exp_s_ttl = clib_net_to_host_u32(t->hdr.label_exp_s_ttl);
 898
 899     s = format (s, "%Umpls-header:%U",
 900                 format_white_space, indent,
 901                 format_mpls_header, hdr);
 902     return (s);
 903 }
 904
 905 static uword
 906 mpls_mpls_label_imposition_pipe (vlib_main_t * vm,
 907                                  vlib_node_runtime_t * node,
 908                                  vlib_frame_t * frame)
 909 {
 910     return (mpls_label_imposition_inline(vm, node, frame,
 911                                          DPO_PROTO_MPLS,
 912                                          MPLS_LABEL_DPO_FLAG_NONE));
 913 }
 914
 915 VLIB_REGISTER_NODE (mpls_mpls_label_imposition_pipe_node) = {
 916     .function = mpls_mpls_label_imposition_pipe,
 917     .name = "mpls-label-imposition-pipe",
 918     .vector_size = sizeof (u32),
 919
 920     .format_trace = format_mpls_label_imposition_trace,
 921     .n_next_nodes = 1,
 922     .next_nodes = {
 923         [0] = "mpls-drop",
 924     }
 925 };
 926 VLIB_NODE_FUNCTION_MULTIARCH (mpls_mpls_label_imposition_pipe_node,
 927                               mpls_mpls_label_imposition_pipe)
 928
 929 static uword
 930 ip4_mpls_label_imposition_pipe (vlib_main_t * vm,
 931                                 vlib_node_runtime_t * node,
 932                                 vlib_frame_t * frame)
 933 {
 934     return (mpls_label_imposition_inline(vm, node, frame,
 935                                          DPO_PROTO_IP4,
 936                                          MPLS_LABEL_DPO_FLAG_NONE));
 937 }
 938
 939 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_pipe_node) = {
 940     .function = ip4_mpls_label_imposition_pipe,
 941     .name = "ip4-mpls-label-imposition-pipe",
 942     .vector_size = sizeof (u32),
 943
 944     .format_trace = format_mpls_label_imposition_trace,
 945     .n_next_nodes = 1,
 946     .next_nodes = {
 947         [0] = "ip4-drop",
 948     }
 949 };
 950 VLIB_NODE_FUNCTION_MULTIARCH (ip4_mpls_label_imposition_pipe_node,
 951                               ip4_mpls_label_imposition_pipe)
 952
 953 static uword
 954 ip6_mpls_label_imposition_pipe (vlib_main_t * vm,
 955                                 vlib_node_runtime_t * node,
 956                                 vlib_frame_t * frame)
 957 {
 958     return (mpls_label_imposition_inline(vm, node, frame,
 959                                          DPO_PROTO_IP6,
 960                                          MPLS_LABEL_DPO_FLAG_NONE));
 961 }
 962
 963 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_pipe_node) = {
 964     .function = ip6_mpls_label_imposition_pipe,
 965     .name = "ip6-mpls-label-imposition-pipe",
 966     .vector_size = sizeof (u32),
 967
 968     .format_trace = format_mpls_label_imposition_trace,
 969     .n_next_nodes = 1,
 970     .next_nodes = {
 971         [0] = "ip6-drop",
 972     }
 973 };
 974 VLIB_NODE_FUNCTION_MULTIARCH (ip6_mpls_label_imposition_pipe_node,
 975                               ip6_mpls_label_imposition_pipe)
 976
 977 static uword
 978 ethernet_mpls_label_imposition_pipe (vlib_main_t * vm,
 979                                      vlib_node_runtime_t * node,
 980                                      vlib_frame_t * frame)
 981 {
 982     return (mpls_label_imposition_inline(vm, node, frame,
 983                                          DPO_PROTO_ETHERNET,
 984                                          MPLS_LABEL_DPO_FLAG_NONE));
 985 }
 986
 987 VLIB_REGISTER_NODE (ethernet_mpls_label_imposition_pipe_node) = {
 988     .function = ethernet_mpls_label_imposition_pipe,
 989     .name = "ethernet-mpls-label-imposition-pipe",
 990     .vector_size = sizeof (u32),
 991
 992     .format_trace = format_mpls_label_imposition_trace,
 993     .n_next_nodes = 1,
 994     .next_nodes = {
 995         [0] = "error-drop",
 996     }
 997 };
 998
 999 VLIB_NODE_FUNCTION_MULTIARCH (ethernet_mpls_label_imposition_pipe_node,
1000                               ethernet_mpls_label_imposition_pipe)
1001
1002 static uword
1003 mpls_mpls_label_imposition_uniform (vlib_main_t * vm,
1004                                     vlib_node_runtime_t * node,
1005                                     vlib_frame_t * frame)
1006 {
1007     return (mpls_label_imposition_inline(vm, node, frame,
1008                                          DPO_PROTO_MPLS,
1009                                          MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1010 }
1011
1012 VLIB_REGISTER_NODE (mpls_mpls_label_imposition_uniform_node) = {
1013     .function = mpls_mpls_label_imposition_uniform,
1014     .name = "mpls-label-imposition-uniform",
1015     .vector_size = sizeof (u32),
1016
1017     .format_trace = format_mpls_label_imposition_trace,
1018     .n_next_nodes = 1,
1019     .next_nodes = {
1020         [0] = "mpls-drop",
1021     }
1022 };
1023 VLIB_NODE_FUNCTION_MULTIARCH (mpls_mpls_label_imposition_uniform_node,
1024                               mpls_mpls_label_imposition_uniform)
1025
1026 static uword
1027 ip4_mpls_label_imposition_uniform (vlib_main_t * vm,
1028                                    vlib_node_runtime_t * node,
1029                                    vlib_frame_t * frame)
1030 {
1031     return (mpls_label_imposition_inline(vm, node, frame,
1032                                          DPO_PROTO_IP4,
1033                                          MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1034 }
1035
1036 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_uniform_node) = {
1037     .function = ip4_mpls_label_imposition_uniform,
1038     .name = "ip4-mpls-label-imposition-uniform",
1039     .vector_size = sizeof (u32),
1040
1041     .format_trace = format_mpls_label_imposition_trace,
1042     .n_next_nodes = 1,
1043     .next_nodes = {
1044         [0] = "ip4-drop",
1045     }
1046 };
1047 VLIB_NODE_FUNCTION_MULTIARCH (ip4_mpls_label_imposition_uniform_node,
1048                               ip4_mpls_label_imposition_uniform)
1049
1050 static uword
1051 ip6_mpls_label_imposition_uniform (vlib_main_t * vm,
1052                                    vlib_node_runtime_t * node,
1053                                    vlib_frame_t * frame)
1054 {
1055     return (mpls_label_imposition_inline(vm, node, frame,
1056                                          DPO_PROTO_IP6,
1057                                          MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1058 }
1059
1060 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_uniform_node) = {
1061     .function = ip6_mpls_label_imposition_uniform,
1062     .name = "ip6-mpls-label-imposition-uniform",
1063     .vector_size = sizeof (u32),
1064
1065     .format_trace = format_mpls_label_imposition_trace,
1066     .n_next_nodes = 1,
1067     .next_nodes = {
1068         [0] = "ip6-drop",
1069     }
1070 };
1071 VLIB_NODE_FUNCTION_MULTIARCH (ip6_mpls_label_imposition_uniform_node,
1072                               ip6_mpls_label_imposition_uniform)
1073
1074 static uword
1075 ethernet_mpls_label_imposition_uniform (vlib_main_t * vm,
1076                                         vlib_node_runtime_t * node,
1077                                         vlib_frame_t * frame)
1078 {
1079     return (mpls_label_imposition_inline(vm, node, frame,
1080                                          DPO_PROTO_ETHERNET,
1081                                          MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1082 }
1083
1084 VLIB_REGISTER_NODE (ethernet_mpls_label_imposition_uniform_node) = {
1085     .function = ethernet_mpls_label_imposition_uniform,
1086     .name = "ethernet-mpls-label-imposition-uniform",
1087     .vector_size = sizeof (u32),
1088
1089     .format_trace = format_mpls_label_imposition_trace,
1090     .n_next_nodes = 1,
1091     .next_nodes = {
1092         [0] = "error-drop",
1093     }
1094 };
1095
1096 VLIB_NODE_FUNCTION_MULTIARCH (ethernet_mpls_label_imposition_uniform_node,
1097                               ethernet_mpls_label_imposition_uniform)
1098
1099 static uword
1100 ip4_mpls_label_imposition_pipe_no_ip_ttl_decr (vlib_main_t * vm,
1101                                                vlib_node_runtime_t * node,
1102                                                vlib_frame_t * frame)
1103 {
1104     return (mpls_label_imposition_inline(vm, node, frame,
1105                                          DPO_PROTO_IP4,
1106                                          MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR));
1107 }
1108
1109 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_pipe_no_ip_ttl_decr_node) = {
1110     .function = ip4_mpls_label_imposition_pipe_no_ip_ttl_decr,
1111     .name = "ip4-mpls-label-imposition-pipe-no-ip-ttl-decr",
1112     .vector_size = sizeof (u32),
1113
1114     .format_trace = format_mpls_label_imposition_trace,
1115     .n_next_nodes = 1,
1116     .next_nodes = {
1117         [0] = "ip4-drop",
1118     }
1119 };
1120 VLIB_NODE_FUNCTION_MULTIARCH (ip4_mpls_label_imposition_pipe_no_ip_ttl_decr_node,
1121                               ip4_mpls_label_imposition_pipe_no_ip_ttl_decr)
1122
1123 static uword
1124 ip6_mpls_label_imposition_pipe_no_ip_ttl_decr (vlib_main_t * vm,
1125                                                vlib_node_runtime_t * node,
1126                                                vlib_frame_t * frame)
1127 {
1128     return (mpls_label_imposition_inline(vm, node, frame,
1129                                          DPO_PROTO_IP6,
1130                                          MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR));
1131 }
1132
1133 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_pipe_no_ip_ttl_decr_node) = {
1134     .function = ip6_mpls_label_imposition_pipe_no_ip_ttl_decr,
1135     .name = "ip6-mpls-label-imposition-pipe-no-ip-ttl-decr",
1136     .vector_size = sizeof (u32),
1137
1138     .format_trace = format_mpls_label_imposition_trace,
1139     .n_next_nodes = 1,
1140     .next_nodes = {
1141         [0] = "ip6-drop",
1142     }
1143 };
1144 VLIB_NODE_FUNCTION_MULTIARCH (ip6_mpls_label_imposition_pipe_no_ip_ttl_decr_node,
1145                               ip6_mpls_label_imposition_pipe_no_ip_ttl_decr)
1146
1147 static uword
1148 ip4_mpls_label_imposition_uniform_no_ip_ttl_decr (vlib_main_t * vm,
1149                                                   vlib_node_runtime_t * node,
1150                                                   vlib_frame_t * frame)
1151 {
1152     return (mpls_label_imposition_inline(vm, node, frame,
1153                                          DPO_PROTO_IP4,
1154                                          (MPLS_LABEL_DPO_FLAG_UNIFORM_MODE |
1155                                           MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR)));
1156 }
1157
1158 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_uniform_no_ip_ttl_decr_node) = {
1159     .function = ip4_mpls_label_imposition_uniform_no_ip_ttl_decr,
1160     .name = "ip4-mpls-label-imposition-uniform-no-ip-ttl-decr",
1161     .vector_size = sizeof (u32),
1162
1163     .format_trace = format_mpls_label_imposition_trace,
1164     .n_next_nodes = 1,
1165     .next_nodes = {
1166         [0] = "ip4-drop",
1167     }
1168 };
1169 VLIB_NODE_FUNCTION_MULTIARCH (ip4_mpls_label_imposition_uniform_no_ip_ttl_decr_node,
1170                               ip4_mpls_label_imposition_uniform_no_ip_ttl_decr)
1171
1172 static uword
1173 ip6_mpls_label_imposition_uniform_no_ip_ttl_decr (vlib_main_t * vm,
1174                                                   vlib_node_runtime_t * node,
1175                                                   vlib_frame_t * frame)
1176 {
1177     return (mpls_label_imposition_inline(vm, node, frame,
1178                                          DPO_PROTO_IP6,
1179                                          (MPLS_LABEL_DPO_FLAG_UNIFORM_MODE |
1180                                           MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR)));
1181 }
1182
1183 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_uniform_no_ip_ttl_decr_node) = {
1184     .function = ip6_mpls_label_imposition_uniform_no_ip_ttl_decr,
1185     .name = "ip6-mpls-label-imposition-uniform-no-ip-ttl-decr",
1186     .vector_size = sizeof (u32),
1187
1188     .format_trace = format_mpls_label_imposition_trace,
1189     .n_next_nodes = 1,
1190     .next_nodes = {
1191         [0] = "ip6-drop",
1192     }
1193 };
1194 VLIB_NODE_FUNCTION_MULTIARCH (ip6_mpls_label_imposition_uniform_no_ip_ttl_decr_node,
1195                               ip6_mpls_label_imposition_uniform_no_ip_ttl_decr)
1196
1197
1198 static void
1199 mpls_label_dpo_mem_show (void)
1200 {
1201     fib_show_memory_usage("MPLS label",
1202                           pool_elts(mpls_label_dpo_pool),
1203                           pool_len(mpls_label_dpo_pool),
1204                           sizeof(mpls_label_dpo_t));
1205 }
1206
1207 /**
1208  * Interpose a label DPO. used in the FIB unit tests
1209  */
1210 static void
1211 mpls_label_interpose (const dpo_id_t *original,
1212                       const dpo_id_t *parent,
1213                       dpo_id_t *clone)
1214 {
1215     mpls_label_dpo_t *mld, *mld_clone;
1216
1217     mld_clone = mpls_label_dpo_alloc();
1218     mld = mpls_label_dpo_get(original->dpoi_index);
1219
1220     mld_clone->mld_locks = 0;
1221     clib_memcpy(&mld_clone->mld_hdr,
1222                 &mld->mld_hdr,
1223                 sizeof(mld_clone->mld_hdr));
1224     mld_clone->mld_payload_proto = mld->mld_payload_proto;
1225     mld_clone->mld_n_labels = mld->mld_n_labels;
1226     mld_clone->mld_n_hdr_bytes = mld->mld_n_hdr_bytes;
1227
1228     dpo_stack(mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NONE],
1229               mld_clone->mld_payload_proto,
1230               &mld_clone->mld_dpo,
1231               parent);
1232
1233     dpo_set(clone,
1234             mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NONE],
1235             mld_clone->mld_payload_proto,
1236             mpls_label_dpo_get_index(mld_clone));
1237 }
1238
1239 const static dpo_vft_t mld_vft = {
1240     .dv_lock = mpls_label_dpo_lock,
1241     .dv_unlock = mpls_label_dpo_unlock,
1242     .dv_format = format_mpls_label_dpo,
1243     .dv_mem_show = mpls_label_dpo_mem_show,
1244     .dv_mk_interpose = mpls_label_interpose,
1245 };
1246
1247 const static char* const mpls_label_imp_pipe_ip4_nodes[] =
1248 {
1249     "ip4-mpls-label-imposition-pipe",
1250     NULL,
1251 };
1252 const static char* const mpls_label_imp_pipe_ip6_nodes[] =
1253 {
1254     "ip6-mpls-label-imposition-pipe",
1255     NULL,
1256 };
1257 const static char* const mpls_label_imp_pipe_mpls_nodes[] =
1258 {
1259     "mpls-label-imposition-pipe",
1260     NULL,
1261 };
1262 const static char* const mpls_label_imp_pipe_ethernet_nodes[] =
1263 {
1264     "ethernet-mpls-label-imposition-pipe",
1265     NULL,
1266 };
1267
1268 const static char* const * const mpls_label_imp_pipe_nodes[DPO_PROTO_NUM] =
1269 {
1270     [DPO_PROTO_IP4]  = mpls_label_imp_pipe_ip4_nodes,
1271     [DPO_PROTO_IP6]  = mpls_label_imp_pipe_ip6_nodes,
1272     [DPO_PROTO_MPLS] = mpls_label_imp_pipe_mpls_nodes,
1273     [DPO_PROTO_ETHERNET] = mpls_label_imp_pipe_ethernet_nodes,
1274 };
1275
1276 const static char* const mpls_label_imp_uniform_ip4_nodes[] =
1277 {
1278     "ip4-mpls-label-imposition-uniform",
1279     NULL,
1280 };
1281 const static char* const mpls_label_imp_uniform_ip6_nodes[] =
1282 {
1283     "ip6-mpls-label-imposition-uniform",
1284     NULL,
1285 };
1286 const static char* const mpls_label_imp_uniform_mpls_nodes[] =
1287 {
1288     "mpls-label-imposition-uniform",
1289     NULL,
1290 };
1291 const static char* const mpls_label_imp_uniform_ethernet_nodes[] =
1292 {
1293     "ethernet-mpls-label-imposition-uniform",
1294     NULL,
1295 };
1296
1297 const static char* const * const mpls_label_imp_uniform_nodes[DPO_PROTO_NUM] =
1298 {
1299     [DPO_PROTO_IP4]  = mpls_label_imp_uniform_ip4_nodes,
1300     [DPO_PROTO_IP6]  = mpls_label_imp_uniform_ip6_nodes,
1301     [DPO_PROTO_MPLS] = mpls_label_imp_uniform_mpls_nodes,
1302     [DPO_PROTO_ETHERNET] = mpls_label_imp_uniform_ethernet_nodes,
1303 };
1304
1305 const static char* const mpls_label_imp_pipe_no_ip_tll_decr_ip4_nodes[] =
1306 {
1307     "ip4-mpls-label-imposition-pipe-no-ip-ttl-decr",
1308     NULL,
1309 };
1310 const static char* const mpls_label_imp_pipe_no_ip_tll_decr_ip6_nodes[] =
1311 {
1312     "ip6-mpls-label-imposition-pipe-no-ip-ttl-decr",
1313     NULL,
1314 };
1315
1316 const static char* const * const mpls_label_imp_pipe_no_ip_tll_decr_nodes[DPO_PROTO_NUM] =
1317 {
1318     [DPO_PROTO_IP4]  = mpls_label_imp_pipe_no_ip_tll_decr_ip4_nodes,
1319     [DPO_PROTO_IP6]  = mpls_label_imp_pipe_no_ip_tll_decr_ip6_nodes,
1320 };
1321
1322 const static char* const mpls_label_imp_uniform_no_ip_tll_decr_ip4_nodes[] =
1323 {
1324     "ip4-mpls-label-imposition-uniform-no-ip-ttl-decr",
1325     NULL,
1326 };
1327 const static char* const mpls_label_imp_uniform_no_ip_tll_decr_ip6_nodes[] =
1328 {
1329     "ip6-mpls-label-imposition-uniform-no-ip-ttl-decr",
1330     NULL,
1331 };
1332
1333 const static char* const * const mpls_label_imp_uniform_no_ip_tll_decr_nodes[DPO_PROTO_NUM] =
1334 {
1335     [DPO_PROTO_IP4]  = mpls_label_imp_uniform_no_ip_tll_decr_ip4_nodes,
1336     [DPO_PROTO_IP6]  = mpls_label_imp_uniform_no_ip_tll_decr_ip6_nodes,
1337 };
1338
1339 void
1340 mpls_label_dpo_module_init (void)
1341 {
1342     mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NONE] =
1343         dpo_register_new_type(&mld_vft,
1344                               mpls_label_imp_pipe_nodes);
1345     mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR] =
1346         dpo_register_new_type(&mld_vft,
1347                               mpls_label_imp_pipe_no_ip_tll_decr_nodes);
1348     mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_UNIFORM_MODE] =
1349         dpo_register_new_type(&mld_vft,
1350                               mpls_label_imp_uniform_nodes);
1351     mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_UNIFORM_MODE |
1352                          MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR] =
1353         dpo_register_new_type(&mld_vft,
1354                               mpls_label_imp_uniform_no_ip_tll_decr_nodes);
1355 }
1356
1357 dpo_type_t
1358 mpls_label_dpo_get_type (mpls_label_dpo_flags_t flags)
1359 {
1360     return (mpls_label_dpo_types[flags]);
1361 }