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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
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>
21 #ifndef CLIB_MARCH_VARIANT
23 * pool of all MPLS Label DPOs
25 mpls_label_dpo_t *mpls_label_dpo_pool;
28 * Strings for the flags
30 const char* mpls_label_dpo_attr_names[] = MPLS_LABEL_DPO_ATTR_NAMES;
33 * registered DPO types for each of the label sub-types. And there's a
34 * subtype for each of the flag combinations.
36 static dpo_type_t mpls_label_dpo_types[1 << MPLS_LABEL_DPO_ATTR_MAX];
38 static mpls_label_dpo_t *
39 mpls_label_dpo_alloc (void)
41 mpls_label_dpo_t *mld;
43 pool_get_aligned(mpls_label_dpo_pool, mld, CLIB_CACHE_LINE_BYTES);
44 clib_memset(mld, 0, sizeof(*mld));
46 dpo_reset(&mld->mld_dpo);
52 mpls_label_dpo_get_index (mpls_label_dpo_t *mld)
54 return (mld - mpls_label_dpo_pool);
58 mpls_label_dpo_create (fib_mpls_label_t *label_stack,
60 dpo_proto_t payload_proto,
61 mpls_label_dpo_flags_t flags,
62 const dpo_id_t *parent,
65 mpls_label_dpo_t *mld;
69 if ((DPO_PROTO_IP4 != payload_proto) &&
70 (DPO_PROTO_IP6 != payload_proto))
73 * remove unsupported configuration
75 flags &= ~MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR;
78 mld = mpls_label_dpo_alloc();
79 mld->mld_flags = flags;
80 dtype = mpls_label_dpo_types[flags];
82 if (MPLS_LABEL_DPO_MAX_N_LABELS < vec_len(label_stack))
84 clib_warning("Label stack size exceeded");
86 mld->mld_payload_proto,
88 drop_dpo_get(DPO_PROTO_MPLS));
92 mld->mld_n_labels = vec_len(label_stack);
93 mld->mld_n_hdr_bytes = mld->mld_n_labels * sizeof(mld->mld_hdr[0]);
94 mld->mld_payload_proto = payload_proto;
97 * construct label rewrite headers for each value passed.
98 * get the header in network byte order since we will paint it
99 * on a packet in the data-plane
101 for (ii = 0; ii < mld->mld_n_labels-1; ii++)
103 vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl,
104 label_stack[ii].fml_value);
105 vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl,
106 label_stack[ii].fml_exp);
107 vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl,
109 if (0 != label_stack[ii].fml_ttl)
111 vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
112 label_stack[ii].fml_ttl);
116 vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
117 MPLS_LABEL_DEFAULT_TTL);
119 mld->mld_hdr[ii].label_exp_s_ttl =
120 clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
124 * the inner most label
126 ii = mld->mld_n_labels-1;
128 vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl,
129 label_stack[ii].fml_value);
130 vnet_mpls_uc_set_exp(&mld->mld_hdr[ii].label_exp_s_ttl,
131 label_stack[ii].fml_exp);
132 vnet_mpls_uc_set_s(&mld->mld_hdr[ii].label_exp_s_ttl, eos);
133 if (0 != label_stack[ii].fml_ttl)
135 vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
136 label_stack[ii].fml_ttl);
140 vnet_mpls_uc_set_ttl(&mld->mld_hdr[ii].label_exp_s_ttl,
141 MPLS_LABEL_DEFAULT_TTL);
143 mld->mld_hdr[ii].label_exp_s_ttl =
144 clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
147 * pipe/uniform mode is only supported for the bottom of stack label
149 if (FIB_MPLS_LSP_MODE_UNIFORM == label_stack[ii].fml_mode)
151 mld->mld_flags |= MPLS_LABEL_DPO_FLAG_UNIFORM_MODE;
155 mld->mld_flags &= ~MPLS_LABEL_DPO_FLAG_UNIFORM_MODE;
157 dtype = mpls_label_dpo_types[mld->mld_flags];
160 * stack this label object on its parent.
163 mld->mld_payload_proto,
170 mld->mld_payload_proto,
171 mpls_label_dpo_get_index(mld));
175 format_mpls_label_dpo_flags (u8 *s, va_list *args)
177 mpls_label_dpo_flags_t flags = va_arg (*args, int);
178 mpls_label_dpo_attr_t attr;
180 FOR_EACH_MPLS_LABEL_DPO_ATTR(attr)
182 if ((1 << attr) & flags)
184 s = format(s, "%s,", mpls_label_dpo_attr_names[attr]);
192 format_mpls_label_dpo (u8 *s, va_list *args)
194 index_t index = va_arg (*args, index_t);
195 u32 indent = va_arg (*args, u32);
196 mpls_unicast_header_t hdr;
197 mpls_label_dpo_t *mld;
200 if (pool_is_free_index(mpls_label_dpo_pool, index))
203 * the packet trace can be printed after the DPO has been deleted
205 return (format(s, "mpls-label[???,%d]:", index));
208 mld = mpls_label_dpo_get(index);
209 s = format(s, "mpls-label[%U@%d]:",
210 format_mpls_label_dpo_flags,
211 (int) mld->mld_flags, index);
213 for (ii = 0; ii < mld->mld_n_labels; ii++)
215 hdr.label_exp_s_ttl =
216 clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl);
217 s = format(s, "%U", format_mpls_header, hdr);
220 s = format(s, "\n%U", format_white_space, indent);
221 s = format(s, "%U", format_dpo_id, &mld->mld_dpo, indent+2);
227 mpls_label_dpo_lock (dpo_id_t *dpo)
229 mpls_label_dpo_t *mld;
231 mld = mpls_label_dpo_get(dpo->dpoi_index);
237 mpls_label_dpo_unlock (dpo_id_t *dpo)
239 mpls_label_dpo_t *mld;
241 mld = mpls_label_dpo_get(dpo->dpoi_index);
245 if (0 == mld->mld_locks)
247 dpo_reset(&mld->mld_dpo);
248 pool_put(mpls_label_dpo_pool, mld);
251 #endif /* CLIB_MARCH_VARIANT */
254 * @brief A struct to hold tracing information for the MPLS label imposition
257 typedef struct mpls_label_imposition_trace_t_
260 * The MPLS header imposed
262 mpls_unicast_header_t hdr;
265 * TTL imposed - only valid for uniform LSPs
270 * TTL imposed - only valid for uniform LSPs
273 } mpls_label_imposition_trace_t;
275 always_inline mpls_unicast_header_t *
276 mpls_label_paint (vlib_buffer_t * b0,
277 mpls_label_dpo_t *mld0)
279 mpls_unicast_header_t *hdr0;
281 vlib_buffer_advance(b0, -(mld0->mld_n_hdr_bytes));
283 hdr0 = vlib_buffer_get_current(b0);
285 if (1 == mld0->mld_n_labels)
287 /* optimise for the common case of one label */
288 *hdr0 = mld0->mld_hdr[0];
292 clib_memcpy_fast(hdr0, mld0->mld_hdr, mld0->mld_n_hdr_bytes);
293 hdr0 = hdr0 + (mld0->mld_n_labels - 1);
300 * Paint on an MPLS label and fixup the TTL
302 always_inline mpls_unicast_header_t *
303 mpls_label_paint_w_ttl (vlib_buffer_t * b0,
304 mpls_label_dpo_t *mld0,
307 mpls_unicast_header_t *hdr0;
309 hdr0 = mpls_label_paint(b0, mld0);
311 /* fixup the TTL for the inner most label */
312 ((char*)hdr0)[3] = ttl0;
318 * Paint on an MPLS label and fixup the TTL and EXP bits.
320 always_inline mpls_unicast_header_t *
321 mpls_label_paint_w_ttl_exp (vlib_buffer_t * b0,
322 mpls_label_dpo_t *mld0,
326 mpls_unicast_header_t *hdr0;
328 hdr0 = mpls_label_paint_w_ttl(b0, mld0, ttl0);
330 /* fixup the EXP for the inner most label */
331 ((char*)hdr0)[2] |= (exp0 << 1);
337 * Paint on an MPLS label and fixup the TTL and EXP bits
338 * When the EXP bits are *already* bit shift to the correct place in
339 * in the 2nd byte (i.e. they were read from another label)
341 always_inline mpls_unicast_header_t *
342 mpls_label_paint_w_ttl_mpls_exp (vlib_buffer_t * b0,
343 mpls_label_dpo_t *mld0,
347 mpls_unicast_header_t *hdr0;
349 hdr0 = mpls_label_paint_w_ttl(b0, mld0, ttl0);
351 /* fixup the EXP for the inner most label */
352 ((char*)hdr0)[2] |= exp0;
358 mpls_label_imposition_inline (vlib_main_t * vm,
359 vlib_node_runtime_t * node,
360 vlib_frame_t * from_frame,
361 const dpo_proto_t dproto,
362 const mpls_label_dpo_flags_t flags)
364 u32 n_left_from, next_index, * from, * to_next;
366 from = vlib_frame_vector_args (from_frame);
367 n_left_from = from_frame->n_vectors;
369 next_index = node->cached_next_index;
371 while (n_left_from > 0)
375 vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
377 while (n_left_from >= 8 && n_left_to_next >= 4)
379 u32 bi0, mldi0, bi1, mldi1, bi2, mldi2, bi3, mldi3;
380 mpls_unicast_header_t *hdr0, *hdr1, *hdr2, *hdr3;
381 mpls_label_dpo_t *mld0, *mld1, *mld2, *mld3;
382 vlib_buffer_t * b0, *b1, * b2, *b3;
383 u32 next0, next1, next2, next3;
384 u8 ttl0, ttl1, ttl2, ttl3;
385 u8 exp0, exp1, exp2, exp3;
387 bi0 = to_next[0] = from[0];
388 bi1 = to_next[1] = from[1];
389 bi2 = to_next[2] = from[2];
390 bi3 = to_next[3] = from[3];
392 /* Prefetch next iteration. */
394 vlib_buffer_t * p2, * p3, *p4, *p5;
396 p2 = vlib_get_buffer (vm, from[2]);
397 p3 = vlib_get_buffer (vm, from[3]);
398 p4 = vlib_get_buffer (vm, from[4]);
399 p5 = vlib_get_buffer (vm, from[5]);
401 vlib_prefetch_buffer_header (p2, STORE);
402 vlib_prefetch_buffer_header (p3, STORE);
403 vlib_prefetch_buffer_header (p4, STORE);
404 vlib_prefetch_buffer_header (p5, STORE);
406 CLIB_PREFETCH (p2->data, sizeof (hdr0[0]), STORE);
407 CLIB_PREFETCH (p3->data, sizeof (hdr0[0]), STORE);
408 CLIB_PREFETCH (p4->data, sizeof (hdr0[0]), STORE);
409 CLIB_PREFETCH (p5->data, sizeof (hdr0[0]), STORE);
417 b0 = vlib_get_buffer (vm, bi0);
418 b1 = vlib_get_buffer (vm, bi1);
419 b2 = vlib_get_buffer (vm, bi2);
420 b3 = vlib_get_buffer (vm, bi3);
422 /* dst lookup was done by ip4 lookup */
423 mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
424 mldi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
425 mldi2 = vnet_buffer(b2)->ip.adj_index[VLIB_TX];
426 mldi3 = vnet_buffer(b3)->ip.adj_index[VLIB_TX];
427 mld0 = mpls_label_dpo_get(mldi0);
428 mld1 = mpls_label_dpo_get(mldi1);
429 mld2 = mpls_label_dpo_get(mldi2);
430 mld3 = mpls_label_dpo_get(mldi3);
432 if (DPO_PROTO_MPLS != dproto)
435 * These are the non-MPLS payload imposition cases
437 if (DPO_PROTO_IP4 == dproto)
439 ip4_header_t * ip0 = vlib_buffer_get_current(b0);
440 ip4_header_t * ip1 = vlib_buffer_get_current(b1);
441 ip4_header_t * ip2 = vlib_buffer_get_current(b2);
442 ip4_header_t * ip3 = vlib_buffer_get_current(b3);
444 if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
447 * decrement the TTL on ingress to the LSP
454 checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
455 checksum1 = ip1->checksum + clib_host_to_net_u16 (0x0100);
456 checksum2 = ip2->checksum + clib_host_to_net_u16 (0x0100);
457 checksum3 = ip3->checksum + clib_host_to_net_u16 (0x0100);
459 checksum0 += checksum0 >= 0xffff;
460 checksum1 += checksum1 >= 0xffff;
461 checksum2 += checksum2 >= 0xffff;
462 checksum3 += checksum3 >= 0xffff;
464 ip0->checksum = checksum0;
465 ip1->checksum = checksum1;
466 ip2->checksum = checksum2;
467 ip3->checksum = checksum3;
475 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
481 /* by default copy the 3 most significant bits */
482 exp0 = ip_dscp_to_mpls_exp(ip0->tos);
483 exp1 = ip_dscp_to_mpls_exp(ip1->tos);
484 exp2 = ip_dscp_to_mpls_exp(ip2->tos);
485 exp3 = ip_dscp_to_mpls_exp(ip3->tos);
488 /* save the payload proto information in mpls opaque */
489 vnet_buffer(b0)->mpls.pyld_proto = DPO_PROTO_IP4;
490 vnet_buffer(b1)->mpls.pyld_proto = DPO_PROTO_IP4;
491 vnet_buffer(b2)->mpls.pyld_proto = DPO_PROTO_IP4;
492 vnet_buffer(b3)->mpls.pyld_proto = DPO_PROTO_IP4;
494 else if (DPO_PROTO_IP6 == dproto)
497 * decrement the TTL on ingress to the LSP
499 ip6_header_t * ip0 = vlib_buffer_get_current(b0);
500 ip6_header_t * ip1 = vlib_buffer_get_current(b1);
501 ip6_header_t * ip2 = vlib_buffer_get_current(b2);
502 ip6_header_t * ip3 = vlib_buffer_get_current(b3);
504 if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
511 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
513 ttl0 = ip0->hop_limit;
514 ttl1 = ip1->hop_limit;
515 ttl2 = ip2->hop_limit;
516 ttl3 = ip3->hop_limit;
517 /* by default copy the 3 most significant bits */
518 exp0 = ip_dscp_to_mpls_exp(
519 ip6_traffic_class_network_order(ip0));
520 exp1 = ip_dscp_to_mpls_exp(
521 ip6_traffic_class_network_order(ip1));
522 exp2 = ip_dscp_to_mpls_exp(
523 ip6_traffic_class_network_order(ip2));
524 exp3 = ip_dscp_to_mpls_exp(
525 ip6_traffic_class_network_order(ip3));
528 /* save the payload proto information in mpls opaque */
529 vnet_buffer(b0)->mpls.pyld_proto = DPO_PROTO_IP6;
530 vnet_buffer(b1)->mpls.pyld_proto = DPO_PROTO_IP6;
531 vnet_buffer(b2)->mpls.pyld_proto = DPO_PROTO_IP6;
532 vnet_buffer(b3)->mpls.pyld_proto = DPO_PROTO_IP6;
537 * nothing to change in the ethernet header
539 ttl0 = ttl1 = ttl2 = ttl3 = MPLS_LABEL_DEFAULT_TTL;
540 exp0 = exp1 = exp2 = exp3 = MPLS_LABEL_DEFAULT_EXP;
543 * These are the non-MPLS payload imposition cases.
544 * Based on the LSP mode either, for uniform, copy down the TTL
545 * and EXP from the payload or, for pipe mode, slap on the value
546 * requested from config
548 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
550 hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
551 hdr1 = mpls_label_paint_w_ttl_exp(b1, mld1, ttl1, exp1);
552 hdr2 = mpls_label_paint_w_ttl_exp(b2, mld2, ttl2, exp2);
553 hdr3 = mpls_label_paint_w_ttl_exp(b3, mld3, ttl3, exp3);
557 hdr0 = mpls_label_paint(b0, mld0);
558 hdr1 = mpls_label_paint(b1, mld1);
559 hdr2 = mpls_label_paint(b2, mld2);
560 hdr3 = mpls_label_paint(b3, mld3);
566 * else, the packet to be encapped is an MPLS packet
567 * there are two cases to consider:
568 * 1 - this is an MPLS label swap at an LSP midpoint.
569 * recognisable because mpls.first = 1. In this case the
570 * TTL must be set to the current value -1.
571 * 2 - The MPLS packet is recursing (or being injected into)
572 * this LSP, in which case the pipe/uniform rules apply
575 if (PREDICT_TRUE(vnet_buffer(b0)->mpls.first))
578 * The first label to be imposed on the packet. this is a
579 * label swap.in which case we stashed the TTL and EXP bits
580 * in the packet in the lookup node
582 ASSERT(0 != vnet_buffer (b0)->mpls.ttl);
584 ttl0 = vnet_buffer(b0)->mpls.ttl - 1;
585 exp0 = vnet_buffer(b0)->mpls.exp;
586 hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
591 * not the first label. implying we are recusring down a
592 * chain of output labels. Each layer is considered a new
593 * LSP - hence the TTL/EXP are pipe/uniform handled
595 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
597 hdr0 = vlib_buffer_get_current(b0);
598 ttl0 = ((u8*)hdr0)[3];
599 exp0 = ((u8*)hdr0)[2] & 0xe;
600 hdr0 = mpls_label_paint_w_ttl_mpls_exp(b0, mld0, ttl0, exp0);
604 hdr0 = mpls_label_paint(b0, mld0);
607 if (PREDICT_TRUE(vnet_buffer(b1)->mpls.first))
609 ASSERT(0 != vnet_buffer (b1)->mpls.ttl);
611 ttl1 = vnet_buffer(b1)->mpls.ttl - 1;
612 exp1 = vnet_buffer(b1)->mpls.exp;
613 hdr1 = mpls_label_paint_w_ttl_exp(b1, mld1, ttl1, exp1);
617 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
619 hdr1 = vlib_buffer_get_current(b1);
620 ttl1 = ((u8*)hdr1)[3];
621 exp1 = ((u8*)hdr1)[2] & 0xe;
622 hdr1 = mpls_label_paint_w_ttl_mpls_exp(b1, mld1, ttl1, exp1);
626 hdr1 = mpls_label_paint(b1, mld1);
629 if (PREDICT_TRUE(vnet_buffer(b2)->mpls.first))
631 ASSERT(0 != vnet_buffer (b2)->mpls.ttl);
633 ttl2 = vnet_buffer(b2)->mpls.ttl - 1;
634 exp2 = vnet_buffer(b2)->mpls.exp;
635 hdr2 = mpls_label_paint_w_ttl_exp(b2, mld2, ttl2, exp2);
639 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
641 hdr2 = vlib_buffer_get_current(b2);
642 ttl2 = ((u8*)hdr2)[3];
643 exp2 = ((u8*)hdr2)[2] & 0xe;
644 hdr2 = mpls_label_paint_w_ttl_mpls_exp(b2, mld2, ttl2, exp2);
648 hdr2 = mpls_label_paint(b2, mld2);
651 if (PREDICT_TRUE(vnet_buffer(b3)->mpls.first))
653 ASSERT(0 != vnet_buffer (b3)->mpls.ttl);
655 ttl3 = vnet_buffer(b3)->mpls.ttl - 1;
656 exp3 = vnet_buffer(b3)->mpls.exp;
657 hdr3 = mpls_label_paint_w_ttl_exp(b3, mld3, ttl3, exp3);
661 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
663 hdr3 = vlib_buffer_get_current(b3);
664 ttl3 = ((u8*)hdr3)[3];
665 exp3 = ((u8*)hdr3)[2] & 0xe;
666 hdr3 = mpls_label_paint_w_ttl_mpls_exp(b3, mld3, ttl3, exp3);
670 hdr3 = mpls_label_paint(b3, mld3);
674 vnet_buffer(b0)->mpls.first = 0;
675 vnet_buffer(b1)->mpls.first = 0;
676 vnet_buffer(b2)->mpls.first = 0;
677 vnet_buffer(b3)->mpls.first = 0;
680 next0 = mld0->mld_dpo.dpoi_next_node;
681 next1 = mld1->mld_dpo.dpoi_next_node;
682 next2 = mld2->mld_dpo.dpoi_next_node;
683 next3 = mld3->mld_dpo.dpoi_next_node;
685 vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index;
686 vnet_buffer(b1)->ip.adj_index[VLIB_TX] = mld1->mld_dpo.dpoi_index;
687 vnet_buffer(b2)->ip.adj_index[VLIB_TX] = mld2->mld_dpo.dpoi_index;
688 vnet_buffer(b3)->ip.adj_index[VLIB_TX] = mld3->mld_dpo.dpoi_index;
690 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
692 mpls_label_imposition_trace_t *tr =
693 vlib_add_trace (vm, node, b0, sizeof (*tr));
695 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
702 tr->ttl = tr->exp = 0;
705 if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
707 mpls_label_imposition_trace_t *tr =
708 vlib_add_trace (vm, node, b1, sizeof (*tr));
710 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
717 tr->ttl = tr->exp = 0;
720 if (PREDICT_FALSE(b2->flags & VLIB_BUFFER_IS_TRACED))
722 mpls_label_imposition_trace_t *tr =
723 vlib_add_trace (vm, node, b2, sizeof (*tr));
725 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
732 tr->ttl = tr->exp = 0;
735 if (PREDICT_FALSE(b3->flags & VLIB_BUFFER_IS_TRACED))
737 mpls_label_imposition_trace_t *tr =
738 vlib_add_trace (vm, node, b3, sizeof (*tr));
740 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
747 tr->ttl = tr->exp = 0;
751 vlib_validate_buffer_enqueue_x4(vm, node, next_index, to_next,
754 next0, next1, next2, next3);
757 while (n_left_from > 0 && n_left_to_next > 0)
759 mpls_unicast_header_t *hdr0;
760 mpls_label_dpo_t *mld0;
773 b0 = vlib_get_buffer (vm, bi0);
775 /* dst lookup was done by ip4 lookup */
776 mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
777 mld0 = mpls_label_dpo_get(mldi0);
779 if (DPO_PROTO_MPLS != dproto)
781 if (DPO_PROTO_IP4 == dproto)
784 * decrement the TTL on ingress to the LSP
786 ip4_header_t * ip0 = vlib_buffer_get_current(b0);
787 if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
791 checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
792 checksum0 += checksum0 >= 0xffff;
794 ip0->checksum = checksum0;
797 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
800 exp0 = ip_dscp_to_mpls_exp(ip0->tos);
803 /* save the payload proto information in mpls opaque */
804 vnet_buffer(b0)->mpls.pyld_proto = DPO_PROTO_IP4;
806 else if (DPO_PROTO_IP6 == dproto)
809 * decrement the TTL on ingress to the LSP
811 ip6_header_t * ip0 = vlib_buffer_get_current(b0);
813 if (!(MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR & flags))
817 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
819 ttl0 = ip0->hop_limit;
820 exp0 = ip_dscp_to_mpls_exp(
821 ip6_traffic_class_network_order(ip0));
824 /* save the payload proto information in mpls opaque */
825 vnet_buffer(b0)->mpls.pyld_proto = DPO_PROTO_IP6;
830 * nothing to change in the ethernet header
832 ttl0 = MPLS_LABEL_DEFAULT_TTL;
833 exp0 = MPLS_LABEL_DEFAULT_EXP;
837 * These are the non-MPLS payload imposition cases.
838 * Based on the LSP mode either, for uniform, copy down the TTL
839 * from the payload or, for pipe mode, slap on the value
840 * requested from config
842 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
844 hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
848 hdr0 = mpls_label_paint(b0, mld0);
853 if (PREDICT_TRUE(vnet_buffer(b0)->mpls.first))
855 ASSERT(0 != vnet_buffer (b0)->mpls.ttl);
857 ttl0 = vnet_buffer(b0)->mpls.ttl - 1;
858 exp0 = vnet_buffer(b0)->mpls.exp;
859 hdr0 = mpls_label_paint_w_ttl_exp(b0, mld0, ttl0, exp0);
863 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
865 hdr0 = vlib_buffer_get_current(b0);
866 ttl0 = ((u8*)hdr0)[3];
867 exp0 = ((u8*)hdr0)[2] & 0xe;
868 hdr0 = mpls_label_paint_w_ttl_mpls_exp(b0, mld0, ttl0, exp0);
872 hdr0 = mpls_label_paint(b0, mld0);
876 vnet_buffer(b0)->mpls.first = 0;
879 next0 = mld0->mld_dpo.dpoi_next_node;
880 vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index;
882 if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
884 mpls_label_imposition_trace_t *tr =
885 vlib_add_trace (vm, node, b0, sizeof (*tr));
887 if (flags & MPLS_LABEL_DPO_FLAG_UNIFORM_MODE)
894 tr->ttl = tr->exp = 0;
898 vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
899 n_left_to_next, bi0, next0);
901 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
903 return from_frame->n_vectors;
907 format_mpls_label_imposition_trace (u8 * s, va_list * args)
909 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
910 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
911 mpls_label_imposition_trace_t * t;
912 mpls_unicast_header_t hdr;
915 t = va_arg (*args, mpls_label_imposition_trace_t *);
916 indent = format_get_indent (s);
917 hdr.label_exp_s_ttl = clib_net_to_host_u32(t->hdr.label_exp_s_ttl);
919 s = format (s, "%Umpls-header:%U",
920 format_white_space, indent,
921 format_mpls_header, hdr);
925 VLIB_NODE_FN (mpls_mpls_label_imposition_pipe_node) (vlib_main_t * vm,
926 vlib_node_runtime_t * node,
927 vlib_frame_t * frame)
929 return (mpls_label_imposition_inline(vm, node, frame,
931 MPLS_LABEL_DPO_FLAG_NONE));
934 VLIB_REGISTER_NODE (mpls_mpls_label_imposition_pipe_node) = {
935 .name = "mpls-label-imposition-pipe",
936 .vector_size = sizeof (u32),
938 .format_trace = format_mpls_label_imposition_trace,
945 VLIB_NODE_FN (ip4_mpls_label_imposition_pipe_node) (vlib_main_t * vm,
946 vlib_node_runtime_t * node,
947 vlib_frame_t * frame)
949 return (mpls_label_imposition_inline(vm, node, frame,
951 MPLS_LABEL_DPO_FLAG_NONE));
954 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_pipe_node) = {
955 .name = "ip4-mpls-label-imposition-pipe",
956 .vector_size = sizeof (u32),
958 .format_trace = format_mpls_label_imposition_trace,
965 VLIB_NODE_FN (ip6_mpls_label_imposition_pipe_node) (vlib_main_t * vm,
966 vlib_node_runtime_t * node,
967 vlib_frame_t * frame)
969 return (mpls_label_imposition_inline(vm, node, frame,
971 MPLS_LABEL_DPO_FLAG_NONE));
974 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_pipe_node) = {
975 .name = "ip6-mpls-label-imposition-pipe",
976 .vector_size = sizeof (u32),
978 .format_trace = format_mpls_label_imposition_trace,
985 VLIB_NODE_FN (ethernet_mpls_label_imposition_pipe_node) (vlib_main_t * vm,
986 vlib_node_runtime_t * node,
987 vlib_frame_t * frame)
989 return (mpls_label_imposition_inline(vm, node, frame,
991 MPLS_LABEL_DPO_FLAG_NONE));
994 VLIB_REGISTER_NODE (ethernet_mpls_label_imposition_pipe_node) = {
995 .name = "ethernet-mpls-label-imposition-pipe",
996 .vector_size = sizeof (u32),
998 .format_trace = format_mpls_label_imposition_trace,
1005 VLIB_NODE_FN (mpls_mpls_label_imposition_uniform_node) (vlib_main_t * vm,
1006 vlib_node_runtime_t * node,
1007 vlib_frame_t * frame)
1009 return (mpls_label_imposition_inline(vm, node, frame,
1011 MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1014 VLIB_REGISTER_NODE (mpls_mpls_label_imposition_uniform_node) = {
1015 .name = "mpls-label-imposition-uniform",
1016 .vector_size = sizeof (u32),
1018 .format_trace = format_mpls_label_imposition_trace,
1025 VLIB_NODE_FN (ip4_mpls_label_imposition_uniform_node) (vlib_main_t * vm,
1026 vlib_node_runtime_t * node,
1027 vlib_frame_t * frame)
1029 return (mpls_label_imposition_inline(vm, node, frame,
1031 MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1034 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_uniform_node) = {
1035 .name = "ip4-mpls-label-imposition-uniform",
1036 .vector_size = sizeof (u32),
1038 .format_trace = format_mpls_label_imposition_trace,
1045 VLIB_NODE_FN (ip6_mpls_label_imposition_uniform_node) (vlib_main_t * vm,
1046 vlib_node_runtime_t * node,
1047 vlib_frame_t * frame)
1049 return (mpls_label_imposition_inline(vm, node, frame,
1051 MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1054 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_uniform_node) = {
1055 .name = "ip6-mpls-label-imposition-uniform",
1056 .vector_size = sizeof (u32),
1058 .format_trace = format_mpls_label_imposition_trace,
1065 VLIB_NODE_FN (ethernet_mpls_label_imposition_uniform_node) (vlib_main_t * vm,
1066 vlib_node_runtime_t * node,
1067 vlib_frame_t * frame)
1069 return (mpls_label_imposition_inline(vm, node, frame,
1071 MPLS_LABEL_DPO_FLAG_UNIFORM_MODE));
1074 VLIB_REGISTER_NODE (ethernet_mpls_label_imposition_uniform_node) = {
1075 .name = "ethernet-mpls-label-imposition-uniform",
1076 .vector_size = sizeof (u32),
1078 .format_trace = format_mpls_label_imposition_trace,
1086 VLIB_NODE_FN (ip4_mpls_label_imposition_pipe_no_ip_ttl_decr_node) (vlib_main_t * vm,
1087 vlib_node_runtime_t * node,
1088 vlib_frame_t * frame)
1090 return (mpls_label_imposition_inline(vm, node, frame,
1092 MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR));
1095 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_pipe_no_ip_ttl_decr_node) = {
1096 .name = "ip4-mpls-label-imposition-pipe-no-ip-ttl-decr",
1097 .vector_size = sizeof (u32),
1099 .format_trace = format_mpls_label_imposition_trace,
1106 VLIB_NODE_FN (ip6_mpls_label_imposition_pipe_no_ip_ttl_decr_node) (vlib_main_t * vm,
1107 vlib_node_runtime_t * node,
1108 vlib_frame_t * frame)
1110 return (mpls_label_imposition_inline(vm, node, frame,
1112 MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR));
1115 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_pipe_no_ip_ttl_decr_node) = {
1116 .name = "ip6-mpls-label-imposition-pipe-no-ip-ttl-decr",
1117 .vector_size = sizeof (u32),
1119 .format_trace = format_mpls_label_imposition_trace,
1126 VLIB_NODE_FN (ip4_mpls_label_imposition_uniform_no_ip_ttl_decr_node) (vlib_main_t * vm,
1127 vlib_node_runtime_t * node,
1128 vlib_frame_t * frame)
1130 return (mpls_label_imposition_inline(vm, node, frame,
1132 (MPLS_LABEL_DPO_FLAG_UNIFORM_MODE |
1133 MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR)));
1136 VLIB_REGISTER_NODE (ip4_mpls_label_imposition_uniform_no_ip_ttl_decr_node) = {
1137 .name = "ip4-mpls-label-imposition-uniform-no-ip-ttl-decr",
1138 .vector_size = sizeof (u32),
1140 .format_trace = format_mpls_label_imposition_trace,
1147 VLIB_NODE_FN (ip6_mpls_label_imposition_uniform_no_ip_ttl_decr_node) (vlib_main_t * vm,
1148 vlib_node_runtime_t * node,
1149 vlib_frame_t * frame)
1151 return (mpls_label_imposition_inline(vm, node, frame,
1153 (MPLS_LABEL_DPO_FLAG_UNIFORM_MODE |
1154 MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR)));
1157 VLIB_REGISTER_NODE (ip6_mpls_label_imposition_uniform_no_ip_ttl_decr_node) = {
1158 .name = "ip6-mpls-label-imposition-uniform-no-ip-ttl-decr",
1159 .vector_size = sizeof (u32),
1161 .format_trace = format_mpls_label_imposition_trace,
1169 #ifndef CLIB_MARCH_VARIANT
1171 mpls_label_dpo_mem_show (void)
1173 fib_show_memory_usage("MPLS label",
1174 pool_elts(mpls_label_dpo_pool),
1175 pool_len(mpls_label_dpo_pool),
1176 sizeof(mpls_label_dpo_t));
1180 * Interpose a label DPO. used in the FIB unit tests
1183 mpls_label_interpose (const dpo_id_t *original,
1184 const dpo_id_t *parent,
1187 mpls_label_dpo_t *mld, *mld_clone;
1189 mld_clone = mpls_label_dpo_alloc();
1190 mld = mpls_label_dpo_get(original->dpoi_index);
1192 mld_clone->mld_locks = 0;
1193 clib_memcpy_fast(&mld_clone->mld_hdr,
1195 sizeof(mld_clone->mld_hdr));
1196 mld_clone->mld_payload_proto = mld->mld_payload_proto;
1197 mld_clone->mld_n_labels = mld->mld_n_labels;
1198 mld_clone->mld_n_hdr_bytes = mld->mld_n_hdr_bytes;
1200 dpo_stack(mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NONE],
1201 mld_clone->mld_payload_proto,
1202 &mld_clone->mld_dpo,
1206 mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NONE],
1207 mld_clone->mld_payload_proto,
1208 mpls_label_dpo_get_index(mld_clone));
1211 const static dpo_vft_t mld_vft = {
1212 .dv_lock = mpls_label_dpo_lock,
1213 .dv_unlock = mpls_label_dpo_unlock,
1214 .dv_format = format_mpls_label_dpo,
1215 .dv_mem_show = mpls_label_dpo_mem_show,
1216 .dv_mk_interpose = mpls_label_interpose,
1219 const static char* const mpls_label_imp_pipe_ip4_nodes[] =
1221 "ip4-mpls-label-imposition-pipe",
1224 const static char* const mpls_label_imp_pipe_ip6_nodes[] =
1226 "ip6-mpls-label-imposition-pipe",
1229 const static char* const mpls_label_imp_pipe_mpls_nodes[] =
1231 "mpls-label-imposition-pipe",
1234 const static char* const mpls_label_imp_pipe_ethernet_nodes[] =
1236 "ethernet-mpls-label-imposition-pipe",
1240 const static char* const * const mpls_label_imp_pipe_nodes[DPO_PROTO_NUM] =
1242 [DPO_PROTO_IP4] = mpls_label_imp_pipe_ip4_nodes,
1243 [DPO_PROTO_IP6] = mpls_label_imp_pipe_ip6_nodes,
1244 [DPO_PROTO_MPLS] = mpls_label_imp_pipe_mpls_nodes,
1245 [DPO_PROTO_ETHERNET] = mpls_label_imp_pipe_ethernet_nodes,
1248 const static char* const mpls_label_imp_uniform_ip4_nodes[] =
1250 "ip4-mpls-label-imposition-uniform",
1253 const static char* const mpls_label_imp_uniform_ip6_nodes[] =
1255 "ip6-mpls-label-imposition-uniform",
1258 const static char* const mpls_label_imp_uniform_mpls_nodes[] =
1260 "mpls-label-imposition-uniform",
1263 const static char* const mpls_label_imp_uniform_ethernet_nodes[] =
1265 "ethernet-mpls-label-imposition-uniform",
1269 const static char* const * const mpls_label_imp_uniform_nodes[DPO_PROTO_NUM] =
1271 [DPO_PROTO_IP4] = mpls_label_imp_uniform_ip4_nodes,
1272 [DPO_PROTO_IP6] = mpls_label_imp_uniform_ip6_nodes,
1273 [DPO_PROTO_MPLS] = mpls_label_imp_uniform_mpls_nodes,
1274 [DPO_PROTO_ETHERNET] = mpls_label_imp_uniform_ethernet_nodes,
1277 const static char* const mpls_label_imp_pipe_no_ip_tll_decr_ip4_nodes[] =
1279 "ip4-mpls-label-imposition-pipe-no-ip-ttl-decr",
1282 const static char* const mpls_label_imp_pipe_no_ip_tll_decr_ip6_nodes[] =
1284 "ip6-mpls-label-imposition-pipe-no-ip-ttl-decr",
1288 const static char* const * const mpls_label_imp_pipe_no_ip_tll_decr_nodes[DPO_PROTO_NUM] =
1290 [DPO_PROTO_IP4] = mpls_label_imp_pipe_no_ip_tll_decr_ip4_nodes,
1291 [DPO_PROTO_IP6] = mpls_label_imp_pipe_no_ip_tll_decr_ip6_nodes,
1294 const static char* const mpls_label_imp_uniform_no_ip_tll_decr_ip4_nodes[] =
1296 "ip4-mpls-label-imposition-uniform-no-ip-ttl-decr",
1299 const static char* const mpls_label_imp_uniform_no_ip_tll_decr_ip6_nodes[] =
1301 "ip6-mpls-label-imposition-uniform-no-ip-ttl-decr",
1305 const static char* const * const mpls_label_imp_uniform_no_ip_tll_decr_nodes[DPO_PROTO_NUM] =
1307 [DPO_PROTO_IP4] = mpls_label_imp_uniform_no_ip_tll_decr_ip4_nodes,
1308 [DPO_PROTO_IP6] = mpls_label_imp_uniform_no_ip_tll_decr_ip6_nodes,
1312 mpls_label_dpo_module_init (void)
1314 mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NONE] =
1315 dpo_register_new_type(&mld_vft,
1316 mpls_label_imp_pipe_nodes);
1317 mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR] =
1318 dpo_register_new_type(&mld_vft,
1319 mpls_label_imp_pipe_no_ip_tll_decr_nodes);
1320 mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_UNIFORM_MODE] =
1321 dpo_register_new_type(&mld_vft,
1322 mpls_label_imp_uniform_nodes);
1323 mpls_label_dpo_types[MPLS_LABEL_DPO_FLAG_UNIFORM_MODE |
1324 MPLS_LABEL_DPO_FLAG_NO_IP_TTL_DECR] =
1325 dpo_register_new_type(&mld_vft,
1326 mpls_label_imp_uniform_no_ip_tll_decr_nodes);
1330 mpls_label_dpo_get_type (mpls_label_dpo_flags_t flags)
1332 return (mpls_label_dpo_types[flags]);
1334 #endif /* CLIB_MARCH_VARIANT */