FD.io VPP  v17.01-9-ge7dcee4
Vector Packet Processing
mpls_label_dpo.c
Go to the documentation of this file.
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>
18 #include <vnet/mpls/mpls.h>
19 
20 /*
21  * pool of all MPLS Label DPOs
22  */
24 
25 static mpls_label_dpo_t *
27 {
28  mpls_label_dpo_t *mld;
29 
30  pool_get_aligned(mpls_label_dpo_pool, mld, CLIB_CACHE_LINE_BYTES);
31  memset(mld, 0, sizeof(*mld));
32 
33  dpo_reset(&mld->mld_dpo);
34 
35  return (mld);
36 }
37 
38 static index_t
40 {
41  return (mld - mpls_label_dpo_pool);
42 }
43 
44 index_t
46  mpls_eos_bit_t eos,
47  u8 ttl,
48  u8 exp,
49  dpo_proto_t payload_proto,
50  const dpo_id_t *dpo)
51 {
52  mpls_label_dpo_t *mld;
53  u32 ii;
54 
55  mld = mpls_label_dpo_alloc();
56  mld->mld_n_labels = vec_len(label_stack);
57  mld->mld_n_hdr_bytes = mld->mld_n_labels * sizeof(mld->mld_hdr[0]);
58  mld->mld_payload_proto = payload_proto;
59 
60  /*
61  * construct label rewrite headers for each value value passed.
62  * get the header in network byte order since we will paint it
63  * on a packet in the data-plane
64  */
65 
66  for (ii = 0; ii < mld->mld_n_labels-1; ii++)
67  {
68  vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl, label_stack[ii]);
72  mld->mld_hdr[ii].label_exp_s_ttl =
73  clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
74  }
75 
76  /*
77  * the inner most label
78  */
79  ii = mld->mld_n_labels-1;
80 
81  vnet_mpls_uc_set_label(&mld->mld_hdr[ii].label_exp_s_ttl, label_stack[ii]);
85  mld->mld_hdr[ii].label_exp_s_ttl =
86  clib_host_to_net_u32(mld->mld_hdr[ii].label_exp_s_ttl);
87 
88  /*
89  * stack this label objct on its parent.
90  */
92  mld->mld_payload_proto,
93  &mld->mld_dpo,
94  dpo);
95 
96  return (mpls_label_dpo_get_index(mld));
97 }
98 
99 u8*
100 format_mpls_label_dpo (u8 *s, va_list *args)
101 {
102  index_t index = va_arg (*args, index_t);
103  u32 indent = va_arg (*args, u32);
105  mpls_label_dpo_t *mld;
106  u32 ii;
107 
108  mld = mpls_label_dpo_get(index);
109 
110  s = format(s, "mpls-label:[%d]:", index);
111 
112  for (ii = 0; ii < mld->mld_n_labels; ii++)
113  {
114  hdr.label_exp_s_ttl =
115  clib_net_to_host_u32(mld->mld_hdr[ii].label_exp_s_ttl);
116  s = format(s, "%U", format_mpls_header, hdr);
117  }
118 
119  s = format(s, "\n%U", format_white_space, indent);
120  s = format(s, "%U", format_dpo_id, &mld->mld_dpo, indent+2);
121 
122  return (s);
123 }
124 
125 static void
127 {
128  mpls_label_dpo_t *mld;
129 
130  mld = mpls_label_dpo_get(dpo->dpoi_index);
131 
132  mld->mld_locks++;
133 }
134 
135 static void
137 {
138  mpls_label_dpo_t *mld;
139 
140  mld = mpls_label_dpo_get(dpo->dpoi_index);
141 
142  mld->mld_locks--;
143 
144  if (0 == mld->mld_locks)
145  {
146  dpo_reset(&mld->mld_dpo);
147  pool_put(mpls_label_dpo_pool, mld);
148  }
149 }
150 
151 /**
152  * @brief A struct to hold tracing information for the MPLS label imposition
153  * node.
154  */
156 {
157  /**
158  * The MPLS header imposed
159  */
162 
165  vlib_node_runtime_t * node,
166  vlib_frame_t * from_frame,
167  u8 payload_is_ip4,
168  u8 payload_is_ip6)
169 {
170  u32 n_left_from, next_index, * from, * to_next;
171 
172  from = vlib_frame_vector_args (from_frame);
173  n_left_from = from_frame->n_vectors;
174 
175  next_index = node->cached_next_index;
176 
177  while (n_left_from > 0)
178  {
179  u32 n_left_to_next;
180 
181  vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
182 
183  while (n_left_from >= 4 && n_left_to_next >= 2)
184  {
185  mpls_unicast_header_t *hdr0, *hdr1;
186  mpls_label_dpo_t *mld0, *mld1;
187  u32 bi0, mldi0, bi1, mldi1;
188  vlib_buffer_t * b0, *b1;
189  u32 next0, next1;
190  u8 ttl0, ttl1;
191 
192  bi0 = to_next[0] = from[0];
193  bi1 = to_next[1] = from[1];
194 
195  /* Prefetch next iteration. */
196  {
197  vlib_buffer_t * p2, * p3;
198 
199  p2 = vlib_get_buffer (vm, from[2]);
200  p3 = vlib_get_buffer (vm, from[3]);
201 
202  vlib_prefetch_buffer_header (p2, STORE);
203  vlib_prefetch_buffer_header (p3, STORE);
204 
205  CLIB_PREFETCH (p2->data, sizeof (hdr0[0]), STORE);
206  CLIB_PREFETCH (p3->data, sizeof (hdr0[0]), STORE);
207  }
208 
209  from += 2;
210  to_next += 2;
211  n_left_from -= 2;
212  n_left_to_next -= 2;
213 
214  b0 = vlib_get_buffer (vm, bi0);
215  b1 = vlib_get_buffer (vm, bi1);
216 
217  /* dst lookup was done by ip4 lookup */
218  mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
219  mldi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
220  mld0 = mpls_label_dpo_get(mldi0);
221  mld1 = mpls_label_dpo_get(mldi1);
222 
223  if (payload_is_ip4)
224  {
225  /*
226  * decrement the TTL on ingress to the LSP
227  */
230  u32 checksum0;
231  u32 checksum1;
232 
233  checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
234  checksum1 = ip1->checksum + clib_host_to_net_u16 (0x0100);
235 
236  checksum0 += checksum0 >= 0xffff;
237  checksum1 += checksum1 >= 0xffff;
238 
239  ip0->checksum = checksum0;
240  ip1->checksum = checksum1;
241 
242  ip0->ttl -= 1;
243  ip1->ttl -= 1;
244 
245  ttl1 = ip1->ttl;
246  ttl0 = ip0->ttl;
247  }
248  else if (payload_is_ip6)
249  {
250  /*
251  * decrement the TTL on ingress to the LSP
252  */
255 
256 
257  ip0->hop_limit -= 1;
258  ip1->hop_limit -= 1;
259 
260  ttl0 = ip0->hop_limit;
261  ttl1 = ip1->hop_limit;
262  }
263  else
264  {
265  /*
266  * else, the packet to be encapped is an MPLS packet
267  */
268  if (PREDICT_TRUE(vnet_buffer(b0)->mpls.first))
269  {
270  /*
271  * The first label to be imposed on the packet. this is a label swap.
272  * in which case we stashed the TTL and EXP bits in the
273  * packet in the lookup node
274  */
275  ASSERT(0 != vnet_buffer (b0)->mpls.ttl);
276 
277  ttl0 = vnet_buffer(b0)->mpls.ttl - 1;
278  }
279  else
280  {
281  /*
282  * not the first label. implying we are recusring down a chain of
283  * output labels.
284  * Each layer is considered a new LSP - hence the TTL is reset.
285  */
286  ttl0 = 255;
287  }
288  if (PREDICT_TRUE(vnet_buffer(b1)->mpls.first))
289  {
290  ASSERT(1 != vnet_buffer (b1)->mpls.ttl);
291  ttl1 = vnet_buffer(b1)->mpls.ttl - 1;
292  }
293  else
294  {
295  ttl1 = 255;
296  }
297  }
298  vnet_buffer(b0)->mpls.first = 0;
299  vnet_buffer(b1)->mpls.first = 0;
300 
301  /* Paint the MPLS header */
302  vlib_buffer_advance(b0, -(mld0->mld_n_hdr_bytes));
303  vlib_buffer_advance(b1, -(mld1->mld_n_hdr_bytes));
304 
305  hdr0 = vlib_buffer_get_current(b0);
306  hdr1 = vlib_buffer_get_current(b1);
307 
308  clib_memcpy(hdr0, mld0->mld_hdr, mld0->mld_n_hdr_bytes);
309  clib_memcpy(hdr1, mld1->mld_hdr, mld1->mld_n_hdr_bytes);
310 
311  /* fixup the TTL for the inner most label */
312  hdr0 = hdr0 + (mld0->mld_n_labels - 1);
313  hdr1 = hdr1 + (mld1->mld_n_labels - 1);
314  ((char*)hdr0)[3] = ttl0;
315  ((char*)hdr1)[3] = ttl1;
316 
317  next0 = mld0->mld_dpo.dpoi_next_node;
318  next1 = mld1->mld_dpo.dpoi_next_node;
319  vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index;
320  vnet_buffer(b1)->ip.adj_index[VLIB_TX] = mld1->mld_dpo.dpoi_index;
321 
323  {
325  vlib_add_trace (vm, node, b0, sizeof (*tr));
326  tr->hdr = *hdr0;
327  }
329  {
331  vlib_add_trace (vm, node, b1, sizeof (*tr));
332  tr->hdr = *hdr1;
333  }
334 
335  vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
336  n_left_to_next,
337  bi0, bi1, next0, next1);
338  }
339 
340  while (n_left_from > 0 && n_left_to_next > 0)
341  {
342  mpls_unicast_header_t *hdr0;
343  mpls_label_dpo_t *mld0;
344  vlib_buffer_t * b0;
345  u32 bi0, mldi0;
346  u32 next0;
347  u8 ttl;
348 
349  bi0 = from[0];
350  to_next[0] = bi0;
351  from += 1;
352  to_next += 1;
353  n_left_from -= 1;
354  n_left_to_next -= 1;
355 
356  b0 = vlib_get_buffer (vm, bi0);
357 
358  /* dst lookup was done by ip4 lookup */
359  mldi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
360  mld0 = mpls_label_dpo_get(mldi0);
361 
362  if (payload_is_ip4)
363  {
364  /*
365  * decrement the TTL on ingress to the LSP
366  */
368  u32 checksum0;
369 
370  checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
371  checksum0 += checksum0 >= 0xffff;
372 
373  ip0->checksum = checksum0;
374  ip0->ttl -= 1;
375  ttl = ip0->ttl;
376  }
377  else if (payload_is_ip6)
378  {
379  /*
380  * decrement the TTL on ingress to the LSP
381  */
383 
384  ip0->hop_limit -= 1;
385  ttl = ip0->hop_limit;
386  }
387  else
388  {
389  /*
390  * else, the packet to be encapped is an MPLS packet
391  */
392  if (vnet_buffer(b0)->mpls.first)
393  {
394  /*
395  * The first label to be imposed on the packet. this is a label swap.
396  * in which case we stashed the TTL and EXP bits in the
397  * packet in the lookup node
398  */
399  ASSERT(0 != vnet_buffer (b0)->mpls.ttl);
400 
401  ttl = vnet_buffer(b0)->mpls.ttl - 1;
402  }
403  else
404  {
405  /*
406  * not the first label. implying we are recusring down a chain of
407  * output labels.
408  * Each layer is considered a new LSP - hence the TTL is reset.
409  */
410  ttl = 255;
411  }
412  }
413  vnet_buffer(b0)->mpls.first = 0;
414 
415  /* Paint the MPLS header */
416  vlib_buffer_advance(b0, -(mld0->mld_n_hdr_bytes));
417  hdr0 = vlib_buffer_get_current(b0);
418  clib_memcpy(hdr0, mld0->mld_hdr, mld0->mld_n_hdr_bytes);
419 
420  /* fixup the TTL for the inner most label */
421  hdr0 = hdr0 + (mld0->mld_n_labels - 1);
422  ((char*)hdr0)[3] = ttl;
423 
424  next0 = mld0->mld_dpo.dpoi_next_node;
425  vnet_buffer(b0)->ip.adj_index[VLIB_TX] = mld0->mld_dpo.dpoi_index;
426 
428  {
430  vlib_add_trace (vm, node, b0, sizeof (*tr));
431  tr->hdr = *hdr0;
432  }
433 
434  vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
435  n_left_to_next, bi0, next0);
436  }
437  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
438  }
439  return from_frame->n_vectors;
440 }
441 
442 static u8 *
444 {
445  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
446  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
449  uword indent;
450 
451  t = va_arg (*args, mpls_label_imposition_trace_t *);
452  indent = format_get_indent (s);
453  hdr.label_exp_s_ttl = clib_net_to_host_u32(t->hdr.label_exp_s_ttl);
454 
455  s = format (s, "%Umpls-header:%U",
456  format_white_space, indent,
457  format_mpls_header, hdr);
458  return (s);
459 }
460 
461 static uword
463  vlib_node_runtime_t * node,
464  vlib_frame_t * frame)
465 {
466  return (mpls_label_imposition_inline(vm, node, frame, 0, 0));
467 }
468 
470  .function = mpls_label_imposition,
471  .name = "mpls-label-imposition",
472  .vector_size = sizeof (u32),
473 
474  .format_trace = format_mpls_label_imposition_trace,
475  .n_next_nodes = 1,
476  .next_nodes = {
477  [0] = "error-drop",
478  }
479 };
482 
483 static uword
484 ip4_mpls_label_imposition (vlib_main_t * vm,
485  vlib_node_runtime_t * node,
486  vlib_frame_t * frame)
487 {
488  return (mpls_label_imposition_inline(vm, node, frame, 1, 0));
489 }
490 
492  .function = ip4_mpls_label_imposition,
493  .name = "ip4-mpls-label-imposition",
494  .vector_size = sizeof (u32),
495 
496  .format_trace = format_mpls_label_imposition_trace,
497  .n_next_nodes = 1,
498  .next_nodes = {
499  [0] = "error-drop",
500  }
501 };
503  ip4_mpls_label_imposition)
504 
505 static uword
506 ip6_mpls_label_imposition (vlib_main_t * vm,
507  vlib_node_runtime_t * node,
508  vlib_frame_t * frame)
509 {
510  return (mpls_label_imposition_inline(vm, node, frame, 0, 1));
511 }
512 
514  .function = ip6_mpls_label_imposition,
515  .name = "ip6-mpls-label-imposition",
516  .vector_size = sizeof (u32),
517 
518  .format_trace = format_mpls_label_imposition_trace,
519  .n_next_nodes = 1,
520  .next_nodes = {
521  [0] = "error-drop",
522  }
523 };
525  ip6_mpls_label_imposition)
526 
527 static void
528 mpls_label_dpo_mem_show (void)
529 {
530  fib_show_memory_usage("MPLS label",
531  pool_elts(mpls_label_dpo_pool),
532  pool_len(mpls_label_dpo_pool),
533  sizeof(mpls_label_dpo_t));
534 }
535 
536 const static dpo_vft_t mld_vft = {
538  .dv_unlock = mpls_label_dpo_unlock,
539  .dv_format = format_mpls_label_dpo,
540  .dv_mem_show = mpls_label_dpo_mem_show,
541 };
542 
543 const static char* const mpls_label_imp_ip4_nodes[] =
544 {
545  "ip4-mpls-label-imposition",
546  NULL,
547 };
548 const static char* const mpls_label_imp_ip6_nodes[] =
549 {
550  "ip6-mpls-label-imposition",
551  NULL,
552 };
553 const static char* const mpls_label_imp_mpls_nodes[] =
554 {
555  "mpls-label-imposition",
556  NULL,
557 };
558 const static char* const * const mpls_label_imp_nodes[DPO_PROTO_NUM] =
559 {
563 };
564 
565 
566 void
568 {
570 }
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:459
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:327
static const char *const mpls_label_imp_ip6_nodes[]
VLIB_NODE_FUNCTION_MULTIARCH(mpls_label_imposition_node, mpls_label_imposition)
#define CLIB_UNUSED(x)
Definition: clib.h:79
A virtual function table regisitered for a DPO type.
Definition: dpo.h:322
static const char *const mpls_label_imp_mpls_nodes[]
format_function_t format_mpls_header
Definition: mpls.h:95
mpls_unicast_header_t hdr
The MPLS header imposed.
#define PREDICT_TRUE(x)
Definition: clib.h:98
#define NULL
Definition: clib.h:55
u32 mpls_label_t
A label value only, i.e.
Definition: packet.h:24
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:41
u8 * format_mpls_label_dpo(u8 *s, va_list *args)
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:121
static uword mpls_label_imposition_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u8 payload_is_ip4, u8 payload_is_ip6)
index_t mpls_label_dpo_create(mpls_label_t *label_stack, mpls_eos_bit_t eos, u8 ttl, u8 exp, dpo_proto_t payload_proto, const dpo_id_t *dpo)
Create an MPLS label object.
static index_t mpls_label_dpo_get_index(mpls_label_dpo_t *mld)
void dpo_register(dpo_type_t type, const dpo_vft_t *vft, const char *const *const *nodes)
For a given DPO type Register:
Definition: dpo.c:246
#define always_inline
Definition: clib.h:84
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:194
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
void fib_show_memory_usage(const char *name, u32 in_use_elts, u32 allocd_elts, size_t size_elt)
Show the memory usage for a type.
Definition: fib_node.c:221
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
static void vnet_mpls_uc_set_label(mpls_label_t *label_exp_s_ttl, u32 value)
Definition: packet.h:97
dpo_proto_t mld_payload_proto
The protocol of the payload/packets that are being encapped.
static void vnet_mpls_uc_set_exp(mpls_label_t *label_exp_s_ttl, u32 exp)
Definition: packet.h:104
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:138
static uword format_get_indent(u8 *s)
Definition: format.h:72
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:214
#define PREDICT_FALSE(x)
Definition: clib.h:97
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
Definition: buffer_node.h:70
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:216
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:350
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
Definition: pool.h:169
u16 n_vectors
Definition: node.h:344
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
u16 mld_n_hdr_bytes
Cached amount of header bytes to paint.
u16 mld_n_labels
Size of the label stack.
static mpls_label_dpo_t * mpls_label_dpo_get(index_t index)
#define clib_memcpy(a, b, c)
Definition: string.h:69
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:207
vlib_node_registration_t mpls_label_imposition_node
(constructor) VLIB_REGISTER_NODE (mpls_label_imposition_node)
void mpls_label_dpo_module_init(void)
u16 cached_next_index
Definition: node.h:463
static void mpls_label_dpo_lock(dpo_id_t *dpo)
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
#define vnet_buffer(b)
Definition: buffer.h:361
dpo_id_t mld_dpo
Next DPO in the graph.
struct mpls_label_imposition_trace_t_ mpls_label_imposition_trace_t
A struct to hold tracing information for the MPLS label imposition node.
vlib_node_registration_t ip6_mpls_label_imposition_node
(constructor) VLIB_REGISTER_NODE (ip6_mpls_label_imposition_node)
mpls_label_t label_exp_s_ttl
Definition: packet.h:31
static void vnet_mpls_uc_set_s(mpls_label_t *label_exp_s_ttl, u32 eos)
Definition: packet.h:111
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:118
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:95
u64 uword
Definition: types.h:112
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:55
vlib_node_registration_t ip4_mpls_label_imposition_node
(constructor) VLIB_REGISTER_NODE (ip4_mpls_label_imposition_node)
Definition: defs.h:47
#define DPO_PROTO_NUM
Definition: dpo.h:72
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:154
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:253
static void vnet_mpls_uc_set_ttl(mpls_label_t *label_exp_s_ttl, u32 ttl)
Definition: packet.h:118
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:170
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
static const char *const *const mpls_label_imp_nodes[DPO_PROTO_NUM]
static u8 * format_mpls_label_imposition_trace(u8 *s, va_list *args)
u8 data[0]
Packet data.
Definition: buffer.h:158
mpls_label_dpo_t * mpls_label_dpo_pool
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:191
u16 mld_locks
Number of locks/users of the label.
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:150
mpls_unicast_header_t mld_hdr[8]
The MPLS label header to impose.
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:85
static mpls_label_dpo_t * mpls_label_dpo_alloc(void)
A struct to hold tracing information for the MPLS label imposition node.
static void mpls_label_dpo_unlock(dpo_id_t *dpo)
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:57
A representation of an MPLS label for imposition in the data-path.
static const char *const mpls_label_imp_ip4_nodes[]
void dpo_stack(dpo_type_t child_type, dpo_proto_t child_proto, dpo_id_t *dpo, const dpo_id_t *parent)
Stack one DPO object on another, and thus establish a child-parent relationship.
Definition: dpo.c:398
enum mpls_eos_bit_t_ mpls_eos_bit_t
static uword mpls_label_imposition(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:109