FD.io VPP  v20.01-rc1
Vector Packet Processing
ila.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 <ila/ila.h>
17 #include <vnet/plugin/plugin.h>
18 #include <vnet/ip/lookup.h>
19 #include <vnet/dpo/dpo.h>
20 #include <vnet/fib/fib_table.h>
21 #include <vpp/app/version.h>
22 
24 
25 #define ILA_TABLE_DEFAULT_HASH_NUM_BUCKETS (64 * 1024)
26 #define ILA_TABLE_DEFAULT_HASH_MEMORY_SIZE (32<<20)
27 
28 #define foreach_ila_error \
29  _(NONE, "valid ILA packets")
30 
31 typedef enum {
32 #define _(sym,str) ILA_ERROR_##sym,
34 #undef _
36 } ila_error_t;
37 
38 static char *ila_error_strings[] = {
39 #define _(sym,string) string,
41 #undef _
42 };
43 
44 typedef enum {
48 
49 typedef struct {
54 
55 static ila_entry_t ila_sir2ila_default_entry = {
56  .csum_mode = ILA_CSUM_MODE_NO_ACTION,
57  .type = ILA_TYPE_IID,
58  .dir = ILA_DIR_ILA2SIR, //Will pass the packet with no
59 };
60 
61 /**
62  * @brief Dynamically registered DPO Type for ILA
63  */
65 
66 /**
67  * @brief Dynamically registered FIB node type for ILA
68  */
70 
71 /**
72  * FIB source for adding entries
73  */
75 
76 u8 *
77 format_half_ip6_address (u8 * s, va_list * va)
78 {
79  u64 v = clib_net_to_host_u64 (va_arg (*va, u64));
80 
81  return format (s, "%04x:%04x:%04x:%04x",
82  v >> 48, (v >> 32) & 0xffff, (v >> 16) & 0xffff, v & 0xffff);
83 
84 }
85 
86 u8 *
87 format_ila_direction (u8 * s, va_list * args)
88 {
89  ila_direction_t t = va_arg (*args, ila_direction_t);
90 #define _(i,n,st) \
91  if (t == ILA_DIR_##i) \
92  return format(s, st);
94 #undef _
95  return format (s, "invalid_ila_direction");
96 }
97 
98 static u8 *
99 format_csum_mode (u8 * s, va_list * va)
100 {
101  ila_csum_mode_t csum_mode = va_arg (*va, ila_csum_mode_t);
102  char *txt;
103 
104  switch (csum_mode)
105  {
106 #define _(i,n,st) \
107  case ILA_CSUM_MODE_##i: \
108  txt = st; \
109  break;
111 #undef _
112  default:
113  txt = "invalid_ila_csum_mode";
114  break;
115  }
116  return format (s, txt);
117 }
118 
119 u8 *
120 format_ila_type (u8 * s, va_list * args)
121 {
122  ila_type_t t = va_arg (*args, ila_type_t);
123 #define _(i,n,st) \
124  if (t == ILA_TYPE_##i) \
125  return format(s, st);
127 #undef _
128  return format (s, "invalid_ila_type");
129 }
130 
131 static u8 *
132 format_ila_entry (u8 * s, va_list * va)
133 {
134  vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
135  ila_entry_t *e = va_arg (*va, ila_entry_t *);
136 
137  if (!e)
138  {
139  return format (s, "%-15s%=40s%=40s%+16s%+18s%+11s", "Type", "SIR Address",
140  "ILA Address", "Checksum Mode", "Direction", "Next DPO");
141  }
142  else if (vnm)
143  {
144  if (ip6_address_is_zero(&e->next_hop))
145  {
146  return format (s, "%-15U%=40U%=40U%18U%11U%s",
147  format_ila_type, e->type,
152  "n/a");
153  }
154  else
155  {
156  return format (s, "%-15U%=40U%=40U%18U%11U%U",
157  format_ila_type, e->type,
162  format_dpo_id, &e->ila_dpo, 0);
163  }
164  }
165 
166  return NULL;
167 }
168 
169 u8 *
170 format_ila_ila2sir_trace (u8 * s, va_list * args)
171 {
172  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
173  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
174  ila_ila2sir_trace_t *t = va_arg (*args, ila_ila2sir_trace_t *);
175  return format (s,
176  "ILA -> SIR adj index: %d entry index: %d initial_dst: %U",
178  &t->initial_dst);
179 }
180 
181 static uword
182 unformat_ila_direction (unformat_input_t * input, va_list * args)
183 {
184  ila_direction_t *result = va_arg (*args, ila_direction_t *);
185 #define _(i,n,s) \
186  if (unformat(input, s)) \
187  { \
188  *result = ILA_DIR_##i; \
189  return 1;\
190  }
191 
193 #undef _
194  return 0;
195 }
196 
197 static uword
198 unformat_ila_type (unformat_input_t * input, va_list * args)
199 {
200  ila_type_t *result = va_arg (*args, ila_type_t *);
201 #define _(i,n,s) \
202  if (unformat(input, s)) \
203  { \
204  *result = ILA_TYPE_##i; \
205  return 1;\
206  }
207 
209 #undef _
210  return 0;
211 }
212 
213 static uword
214 unformat_ila_csum_mode (unformat_input_t * input, va_list * args)
215 {
216  ila_csum_mode_t *result = va_arg (*args, ila_csum_mode_t *);
217  if (unformat (input, "none") || unformat (input, "no-action"))
218  {
219  *result = ILA_CSUM_MODE_NO_ACTION;
220  return 1;
221  }
222  if (unformat (input, "neutral-map"))
223  {
224  *result = ILA_CSUM_MODE_NEUTRAL_MAP;
225  return 1;
226  }
227  if (unformat (input, "adjust-transport"))
228  {
229  *result = ILA_CSUM_MODE_ADJUST_TRANSPORT;
230  return 1;
231  }
232  return 0;
233 }
234 
235 static uword
237 {
238  u64 *result = va_arg (*args, u64 *);
239  u32 a[4];
240 
241  if (!unformat (input, "%x:%x:%x:%x", &a[0], &a[1], &a[2], &a[3]))
242  return 0;
243 
244  if (a[0] > 0xFFFF || a[1] > 0xFFFF || a[2] > 0xFFFF || a[3] > 0xFFFF)
245  return 0;
246 
247  *result = clib_host_to_net_u64 ((((u64) a[0]) << 48) |
248  (((u64) a[1]) << 32) |
249  (((u64) a[2]) << 16) | (((u64) a[3])));
250 
251  return 1;
252 }
253 
255 
256 static uword
259 {
260  u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
261  ila_main_t *ilm = &ila_main;
262 
263  from = vlib_frame_vector_args (frame);
264  n_left_from = frame->n_vectors;
265  next_index = node->cached_next_index;
266 
267  while (n_left_from > 0)
268  {
269  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
270 
271  while (n_left_from >= 4 && n_left_to_next >= 2)
272  {
273  u32 pi0, pi1;
274  vlib_buffer_t *p0, *p1;
275  ila_entry_t *ie0, *ie1;
276  ip6_header_t *ip60, *ip61;
277  ip6_address_t *sir_address0, *sir_address1;
278 
279  {
280  vlib_buffer_t *p2, *p3;
281 
282  p2 = vlib_get_buffer (vm, from[2]);
283  p3 = vlib_get_buffer (vm, from[3]);
284 
285  vlib_prefetch_buffer_header (p2, LOAD);
286  vlib_prefetch_buffer_header (p3, LOAD);
287  CLIB_PREFETCH (p2->data, sizeof (ip6_header_t), LOAD);
288  CLIB_PREFETCH (p3->data, sizeof (ip6_header_t), LOAD);
289  }
290 
291  pi0 = to_next[0] = from[0];
292  pi1 = to_next[1] = from[1];
293  from += 2;
294  n_left_from -= 2;
295  to_next += 2;
296  n_left_to_next -= 2;
297 
298  p0 = vlib_get_buffer (vm, pi0);
299  p1 = vlib_get_buffer (vm, pi1);
300  ip60 = vlib_buffer_get_current (p0);
301  ip61 = vlib_buffer_get_current (p1);
302  sir_address0 = &ip60->dst_address;
303  sir_address1 = &ip61->dst_address;
304  ie0 = pool_elt_at_index (ilm->entries,
305  vnet_buffer (p0)->ip.adj_index[VLIB_TX]);
306  ie1 = pool_elt_at_index (ilm->entries,
307  vnet_buffer (p1)->ip.adj_index[VLIB_TX]);
308 
309  if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
310  {
311  ila_ila2sir_trace_t *tr =
312  vlib_add_trace (vm, node, p0, sizeof (*tr));
313  tr->ila_index = ie0 - ilm->entries;
314  tr->initial_dst = ip60->dst_address;
315  tr->adj_index = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
316  }
317 
318  if (PREDICT_FALSE (p1->flags & VLIB_BUFFER_IS_TRACED))
319  {
320  ila_ila2sir_trace_t *tr =
321  vlib_add_trace (vm, node, p1, sizeof (*tr));
322  tr->ila_index = ie1 - ilm->entries;
323  tr->initial_dst = ip61->dst_address;
324  tr->adj_index = vnet_buffer (p1)->ip.adj_index[VLIB_TX];
325  }
326 
327  sir_address0 = (ie0->dir != ILA_DIR_SIR2ILA) ? &ie0->sir_address : sir_address0;
328  sir_address1 = (ie1->dir != ILA_DIR_SIR2ILA) ? &ie1->sir_address : sir_address1;
329  ip60->dst_address.as_u64[0] = sir_address0->as_u64[0];
330  ip60->dst_address.as_u64[1] = sir_address0->as_u64[1];
331  ip61->dst_address.as_u64[0] = sir_address1->as_u64[0];
332  ip61->dst_address.as_u64[1] = sir_address1->as_u64[1];
333 
334  vnet_buffer (p0)->ip.adj_index[VLIB_TX] = ie0->ila_dpo.dpoi_index;
335  vnet_buffer (p1)->ip.adj_index[VLIB_TX] = ie1->ila_dpo.dpoi_index;
336 
337  vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
338  n_left_to_next, pi0, pi1,
339  ie0->ila_dpo.dpoi_next_node,
340  ie1->ila_dpo.dpoi_next_node);
341  }
342 
343  /* Single loop */
344  while (n_left_from > 0 && n_left_to_next > 0)
345  {
346  u32 pi0;
347  vlib_buffer_t *p0;
348  ila_entry_t *ie0;
349  ip6_header_t *ip60;
350  ip6_address_t *sir_address0;
351 
352  pi0 = to_next[0] = from[0];
353  from += 1;
354  n_left_from -= 1;
355  to_next += 1;
356  n_left_to_next -= 1;
357 
358  p0 = vlib_get_buffer (vm, pi0);
359  ip60 = vlib_buffer_get_current (p0);
360  sir_address0 = &ip60->dst_address;
361  ie0 = pool_elt_at_index (ilm->entries,
362  vnet_buffer (p0)->ip.adj_index[VLIB_TX]);
363 
364  if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
365  {
366  ila_ila2sir_trace_t *tr =
367  vlib_add_trace (vm, node, p0, sizeof (*tr));
368  tr->ila_index = ie0 ? (ie0 - ilm->entries) : ~0;
369  tr->initial_dst = ip60->dst_address;
370  tr->adj_index = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
371  }
372 
373  sir_address0 = (ie0->dir != ILA_DIR_SIR2ILA) ? &ie0->sir_address : sir_address0;
374  ip60->dst_address.as_u64[0] = sir_address0->as_u64[0];
375  ip60->dst_address.as_u64[1] = sir_address0->as_u64[1];
376  vnet_buffer (p0)->ip.adj_index[VLIB_TX] = ie0->ila_dpo.dpoi_index;
377 
378  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
379  n_left_to_next, pi0,
380  ie0->ila_dpo.dpoi_next_node);
381  }
382  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
383  }
384 
385  return frame->n_vectors;
386 }
387 
388 /** *INDENT-OFF* */
390 {
391  .function = ila_ila2sir,
392  .name = "ila-to-sir",
393  .vector_size = sizeof (u32),
394  .format_trace = format_ila_ila2sir_trace,
395  .n_errors = ILA_N_ERROR,
396  .error_strings = ila_error_strings,
397  .n_next_nodes = ILA_ILA2SIR_N_NEXT,
398  .next_nodes =
399  {
400  [ILA_ILA2SIR_NEXT_DROP] = "error-drop"
401  },
402 };
403 /** *INDENT-ON* */
404 
405 typedef enum
406 {
410 
411 typedef struct
412 {
416 
417 u8 *
418 format_ila_sir2ila_trace (u8 * s, va_list * args)
419 {
420  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
421  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
422  ila_sir2ila_trace_t *t = va_arg (*args, ila_sir2ila_trace_t *);
423 
424  return format (s, "SIR -> ILA entry index: %d initial_dst: %U",
426 }
427 
429 
430 static uword
433 {
434  u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
435  ila_main_t *ilm = &ila_main;
436 
437  from = vlib_frame_vector_args (frame);
438  n_left_from = frame->n_vectors;
439  next_index = node->cached_next_index;
440 
441  while (n_left_from > 0)
442  {
443  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
444 
445  while (n_left_from >= 4 && n_left_to_next >= 2)
446  {
447  u32 pi0, pi1;
448  vlib_buffer_t *p0, *p1;
449  ip6_header_t *ip60, *ip61;
450  u32 next0 = ILA_SIR2ILA_NEXT_DROP;
451  u32 next1 = ILA_SIR2ILA_NEXT_DROP;
452  BVT (clib_bihash_kv) kv0, value0;
453  BVT (clib_bihash_kv) kv1, value1;
456  ip6_address_t *ila_address0, *ila_address1;
457 
458  {
459  vlib_buffer_t *p2, *p3;
460 
461  p2 = vlib_get_buffer (vm, from[2]);
462  p3 = vlib_get_buffer (vm, from[3]);
463 
464  vlib_prefetch_buffer_header (p2, LOAD);
465  vlib_prefetch_buffer_header (p3, LOAD);
466  CLIB_PREFETCH (p2->data, sizeof (ip6_header_t), LOAD);
467  CLIB_PREFETCH (p3->data, sizeof (ip6_header_t), LOAD);
468  }
469 
470  pi0 = to_next[0] = from[0];
471  pi1 = to_next[1] = from[1];
472  from += 2;
473  n_left_from -= 2;
474  to_next += 2;
475  n_left_to_next -= 2;
476 
477  p0 = vlib_get_buffer (vm, pi0);
478  p1 = vlib_get_buffer (vm, pi1);
479  ip60 = vlib_buffer_get_current (p0);
480  ip61 = vlib_buffer_get_current (p1);
481  ila_address0 = &ip60->dst_address;
482  ila_address1 = &ip61->dst_address;
483  kv0.key[0] = ip60->dst_address.as_u64[0];
484  kv0.key[1] = ip60->dst_address.as_u64[1];
485  kv0.key[2] = 0;
486  kv1.key[0] = ip61->dst_address.as_u64[0];
487  kv1.key[1] = ip61->dst_address.as_u64[1];
488  kv1.key[2] = 0;
489 
490  if (PREDICT_TRUE((BV (clib_bihash_search)
491  (&ilm->id_to_entry_table, &kv0, &value0)) == 0)) {
492  ie0 = &ilm->entries[value0.value];
493  ila_address0 = (ie0->dir != ILA_DIR_ILA2SIR) ? &ie0->ila_address : ila_address0;
494  }
495 
496  if ((BV (clib_bihash_search)
497  (&ilm->id_to_entry_table, &kv1, &value1)) == 0) {
498  ie1 = &ilm->entries[value1.value];
499  ila_address1 = (ie1->dir != ILA_DIR_ILA2SIR) ? &ie1->ila_address : ila_address1;
500  }
501 
502  if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
503  {
504  ila_sir2ila_trace_t *tr =
505  vlib_add_trace (vm, node, p0, sizeof (*tr));
506  tr->ila_index =
507  (ie0 != &ila_sir2ila_default_entry) ? (ie0 - ilm->entries) : ~0;
508  tr->initial_dst = ip60->dst_address;
509  }
510 
511  if (PREDICT_FALSE (p1->flags & VLIB_BUFFER_IS_TRACED))
512  {
513  ila_sir2ila_trace_t *tr =
514  vlib_add_trace (vm, node, p1, sizeof (*tr));
515  tr->ila_index =
516  (ie1 != &ila_sir2ila_default_entry) ? (ie1 - ilm->entries) : ~0;
517  tr->initial_dst = ip61->dst_address;
518  }
519 
520  ip60->dst_address.as_u64[0] = ila_address0->as_u64[0];
521  ip60->dst_address.as_u64[1] = ila_address0->as_u64[1];
522  ip61->dst_address.as_u64[0] = ila_address1->as_u64[0];
523  ip61->dst_address.as_u64[1] = ila_address1->as_u64[1];
524 
525  vnet_feature_next (&next0, p0);
526  vnet_feature_next (&next1, p1);
527 
528  vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
529  n_left_to_next, pi0, pi1, next0,
530  next1);
531  }
532 
533  /* Single loop */
534  while (n_left_from > 0 && n_left_to_next > 0)
535  {
536  u32 pi0;
537  vlib_buffer_t *p0;
538  ip6_header_t *ip60;
539  u32 next0 = ILA_SIR2ILA_NEXT_DROP;
540  BVT (clib_bihash_kv) kv0, value0;
542  ip6_address_t *ila_address0;
543 
544  pi0 = to_next[0] = from[0];
545  from += 1;
546  n_left_from -= 1;
547  to_next += 1;
548  n_left_to_next -= 1;
549 
550  p0 = vlib_get_buffer (vm, pi0);
551  ip60 = vlib_buffer_get_current (p0);
552  ila_address0 = &ip60->dst_address;
553 
554  kv0.key[0] = ip60->dst_address.as_u64[0];
555  kv0.key[1] = ip60->dst_address.as_u64[1];
556  kv0.key[2] = 0;
557 
558  if (PREDICT_TRUE((BV (clib_bihash_search)
559  (&ilm->id_to_entry_table, &kv0, &value0)) == 0)) {
560  ie0 = &ilm->entries[value0.value];
561  ila_address0 = (ie0->dir != ILA_DIR_ILA2SIR) ? &ie0->ila_address : ila_address0;
562  }
563 
564  if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
565  {
566  ila_sir2ila_trace_t *tr =
567  vlib_add_trace (vm, node, p0, sizeof (*tr));
568  tr->ila_index =
569  (ie0 != &ila_sir2ila_default_entry) ? (ie0 - ilm->entries) : ~0;
570  tr->initial_dst = ip60->dst_address;
571  }
572 
573  //This operation should do everything for any type (except vnid4 obviously)
574  ip60->dst_address.as_u64[0] = ila_address0->as_u64[0];
575  ip60->dst_address.as_u64[1] = ila_address0->as_u64[1];
576 
577  vnet_feature_next (&next0, p0);
578 
579  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
580  n_left_to_next, pi0, next0);
581  }
582  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
583  }
584 
585  return frame->n_vectors;
586 }
587 
588 /** *INDENT-OFF* */
590 {
591  .function = ila_sir2ila,.name = "sir-to-ila",
592  .vector_size = sizeof (u32),
593  .format_trace = format_ila_sir2ila_trace,
594  .n_errors = ILA_N_ERROR,
595  .error_strings = ila_error_strings,
596  .n_next_nodes = ILA_SIR2ILA_N_NEXT,
597  .next_nodes =
598  {
599  [ILA_SIR2ILA_NEXT_DROP] = "error-drop"
600  },
601 };
602 /** *INDENT-ON* */
603 
604 /** *INDENT-OFF* */
605 VNET_FEATURE_INIT (ila_sir2ila, static) =
606 {
607  .arc_name = "ip6-unicast",
608  .node_name = "sir-to-ila",
609  .runs_before = VNET_FEATURES ("ip6-lookup"),
610 };
611 /** *INDENT-ON* */
612 
613 static void
615 {
616  /*
617  * restack on the next-hop's FIB entry
618  */
621  &ie->ila_dpo,
624 }
625 
626 int
628 {
629  ila_main_t *ilm = &ila_main;
630  BVT (clib_bihash_kv) kv, value;
631 
632  //Sanity check
633  if (args->type == ILA_TYPE_IID || args->type == ILA_TYPE_LUID)
634  {
635  if ((args->sir_address.as_u8[8] >> 5) != args->type)
636  {
637  clib_warning ("Incorrect SIR address (ILA type mismatch %d %d)",
638  args->sir_address.as_u8[8] >> 1, args->type);
639  return -1;
640  }
641  if (args->sir_address.as_u8[8] & 0x10)
642  {
643  clib_warning ("Checksum bit should not be set in SIR address");
644  return -1;
645  }
646  }
647  else if (args->type == ILA_TYPE_VNIDM)
648  {
649  if (args->sir_address.as_u8[0] != 0xff ||
650  (args->sir_address.as_u8[1] & 0xf0) != 0xf0)
651  {
652  clib_warning ("SIR multicast address must start with fff");
653  return -1;
654  }
655  if (args->sir_address.as_u16[1] || args->sir_address.as_u16[2] ||
656  args->sir_address.as_u16[3] || args->sir_address.as_u16[4] ||
657  args->sir_address.as_u16[5] || (args->sir_address.as_u8[12] & 0xf0))
658  {
659  clib_warning ("SIR multicast address must start with fff");
660  return -1;
661  }
662  }
663 
664  if (!args->is_del)
665  {
666  ila_entry_t *e;
667  pool_get (ilm->entries, e);
668  e->type = args->type;
669  e->sir_address = args->sir_address;
670  e->next_hop = args->next_hop_address;
671  e->csum_mode = args->csum_mode;
672  e->dir = args->dir;
673 
674  //Construct ILA address
675  switch (e->type)
676  {
677  case ILA_TYPE_IID:
678  e->ila_address = e->sir_address;
679  break;
680  case ILA_TYPE_LUID:
681  e->ila_address.as_u64[0] = args->locator;
682  e->ila_address.as_u64[1] = args->sir_address.as_u64[1];
683  break;
684  case ILA_TYPE_VNID6:
685  e->ila_address.as_u64[0] = args->locator;
686  e->ila_address.as_u8[8] = (ILA_TYPE_VNID6 << 1);
687  e->ila_address.as_u32[2] |= args->vnid;
688  e->ila_address.as_u32[3] = args->sir_address.as_u32[3];
689  break;
690  case ILA_TYPE_VNIDM:
691  e->ila_address.as_u64[0] = args->locator;
692  e->ila_address.as_u8[8] = (ILA_TYPE_VNIDM << 1);
693  e->ila_address.as_u32[2] |= args->vnid;
694  e->ila_address.as_u32[3] = args->sir_address.as_u32[3];
695  e->ila_address.as_u8[12] |= args->sir_address.as_u8[2] << 4;
696  break;
697  case ILA_TYPE_VNID4:
698  clib_warning ("ILA type '%U' is not supported", format_ila_type,
699  e->type);
700  return -1;
701  }
702 
703  //Modify ILA checksum if necessary
704  if (e->csum_mode == ILA_CSUM_MODE_NEUTRAL_MAP)
705  {
706  ip_csum_t csum = e->ila_address.as_u16[7];
707  int i;
708  for (i = 0; i < 4; i++)
709  {
710  csum = ip_csum_sub_even (csum, e->sir_address.as_u32[i]);
711  csum = ip_csum_add_even (csum, e->ila_address.as_u32[i]);
712  }
713  csum = ip_csum_add_even (csum, clib_host_to_net_u16 (0x1000));
714  e->ila_address.as_u16[7] = ip_csum_fold (csum);
715  e->ila_address.as_u8[8] |= 0x10;
716  }
717 
718  //Create entry with the sir address
719  kv.key[0] = e->sir_address.as_u64[0];
720  kv.key[1] = e->sir_address.as_u64[1];
721  kv.key[2] = 0;
722  kv.value = e - ilm->entries;
723  BV (clib_bihash_add_del) (&ilm->id_to_entry_table, &kv,
724  1 /* is_add */ );
725 
726  if (!ip6_address_is_zero(&e->next_hop))
727  {
728  /*
729  * become a child of the FIB netry for the next-hop
730  * so we are informed when its forwarding changes
731  */
732  fib_prefix_t next_hop = {
733  .fp_addr = {
734  .ip6 = e->next_hop,
735  },
736  .fp_len = 128,
737  .fp_proto = FIB_PROTOCOL_IP6,
738  };
739 
742  &next_hop,
748  e - ilm->entries);
749 
750  /*
751  * Create a route that results in the ILA entry
752  */
753  dpo_id_t dpo = DPO_INVALID;
754  fib_prefix_t pfx = {
755  .fp_addr = {
756  .ip6 = e->ila_address,
757  },
758  .fp_len = 128,
759  .fp_proto = FIB_PROTOCOL_IP6,
760  };
761 
762  dpo_set(&dpo, ila_dpo_type, DPO_PROTO_IP6, e - ilm->entries);
763 
765  &pfx,
766  ila_fib_src,
768  &dpo);
769  dpo_reset(&dpo);
770 
771  /*
772  * finally stack the ILA entry so it will forward to the next-hop
773  */
774  ila_entry_stack (e);
775  }
776  }
777  else
778  {
779  ila_entry_t *e;
780  kv.key[0] = args->sir_address.as_u64[0];
781  kv.key[1] = args->sir_address.as_u64[1];
782  kv.key[2] = 0;
783 
784  if ((BV (clib_bihash_search) (&ilm->id_to_entry_table, &kv, &value) <
785  0))
786  {
787  return -1;
788  }
789 
790  e = &ilm->entries[value.value];
791 
792  if (!ip6_address_is_zero(&e->next_hop))
793  {
794  fib_prefix_t pfx = {
795  .fp_addr = {
796  .ip6 = e->ila_address,
797  },
798  .fp_len = 128,
799  .fp_proto = FIB_PROTOCOL_IP6,
800  };
801 
803  /*
804  * remove this ILA entry as child of the FIB netry for the next-hop
805  */
809  FIB_SOURCE_RR);
811  }
812  dpo_reset (&e->ila_dpo);
813 
814  BV (clib_bihash_add_del) (&ilm->id_to_entry_table, &kv,
815  0 /* is_add */ );
816  pool_put (ilm->entries, e);
817  }
818  return 0;
819 }
820 
821 int
823 {
824  vnet_feature_enable_disable ("ip4-unicast", "sir-to-ila", sw_if_index,
825  !disable, 0, 0);
826  return 0;
827 }
828 
829 /* *INDENT-OFF* */
831  .version = VPP_BUILD_VER,
832  .description = "Identifier Locator Addressing (ILA) for IPv6",
833 };
834 /* *INDENT-ON* */
835 
836 u8 *format_ila_dpo (u8 * s, va_list * va)
837 {
838  index_t index = va_arg (*va, index_t);
839  CLIB_UNUSED(u32 indent) = va_arg (*va, u32);
840  ila_main_t *ilm = &ila_main;
841  ila_entry_t *ie = pool_elt_at_index (ilm->entries, index);
842  return format(s, "ILA: idx:%d sir:%U",
843  index,
845 }
846 
847 /**
848  * @brief no-op lock function.
849  * The lifetime of the ILA entry is managed by the control plane
850  */
851 static void
853 {
854 }
855 
856 /**
857  * @brief no-op unlock function.
858  * The lifetime of the ILA entry is managed by the control plane
859  */
860 static void
862 {
863 }
864 
865 const static dpo_vft_t ila_vft = {
867  .dv_unlock = ila_dpo_unlock,
868  .dv_format = format_ila_dpo,
869 };
870 const static char* const ila_ip6_nodes[] =
871 {
872  "ila-to-sir",
873  NULL,
874 };
875 const static char* const * const ila_nodes[DPO_PROTO_NUM] =
876 {
878 };
879 
880 static fib_node_t *
882 {
883  ila_main_t *ilm = &ila_main;
884  ila_entry_t *ie = pool_elt_at_index (ilm->entries, index);
885 
886  return (&ie->ila_fib_node);
887 }
888 
889 /**
890  * @brief no-op unlock function.
891  * The lifetime of the ILA entry is managed by the control plane
892  */
893 static void
895 {
896 }
897 
898 static ila_entry_t *
900 {
901  return ((ila_entry_t*)(((char*)node) -
902  STRUCT_OFFSET_OF(ila_entry_t, ila_fib_node)));
903 }
904 
905 /**
906  * @brief
907  * Callback function invoked when the forwarding changes for the ILA next-hop
908  */
912 {
914 
916 }
917 
918 /*
919  * ILA's FIB graph node virtual function table
920  */
921 static const fib_node_vft_t ila_fib_node_vft = {
923  .fnv_last_lock = ila_fib_node_last_lock_gone,
924  .fnv_back_walk = ila_fib_node_back_walk_notify,
925 };
926 
927 clib_error_t *
929 {
930  ila_main_t *ilm = &ila_main;
931  ilm->entries = NULL;
932 
936 
938  "ila id to entry index table",
940 
942  ila_fib_node_type = fib_node_register_new_type(&ila_fib_node_vft);
946  return NULL;
947 }
948 
950 
951 static clib_error_t *
953  unformat_input_t * input, vlib_cli_command_t * cmd)
954 {
955  unformat_input_t _line_input, *line_input = &_line_input;
956  ila_add_del_entry_args_t args = { 0 };
957  u8 next_hop_set = 0;
958  int ret;
959  clib_error_t *error = 0;
960 
961  args.type = ILA_TYPE_IID;
962  args.csum_mode = ILA_CSUM_MODE_NO_ACTION;
963  args.local_adj_index = ~0;
964  args.dir = ILA_DIR_BIDIR;
965 
966  if (!unformat_user (input, unformat_line_input, line_input))
967  return 0;
968 
969  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
970  {
971  if (unformat (line_input, "type %U", unformat_ila_type, &args.type))
972  ;
973  else if (unformat
974  (line_input, "sir-address %U", unformat_ip6_address,
975  &args.sir_address))
976  ;
977  else if (unformat
978  (line_input, "locator %U", unformat_half_ip6_address,
979  &args.locator))
980  ;
981  else if (unformat
982  (line_input, "csum-mode %U", unformat_ila_csum_mode,
983  &args.csum_mode))
984  ;
985  else if (unformat (line_input, "vnid %x", &args.vnid))
986  ;
987  else if (unformat
988  (line_input, "next-hop %U", unformat_ip6_address,
989  &args.next_hop_address))
990  ;
991  else if (unformat
992  (line_input, "direction %U", unformat_ila_direction, &args.dir))
993  next_hop_set = 1;
994  else if (unformat (line_input, "del"))
995  args.is_del = 1;
996  else
997  {
998  error = clib_error_return (0, "parse error: '%U'",
999  format_unformat_error, line_input);
1000  goto done;
1001  }
1002  }
1003 
1004  if (!next_hop_set)
1005  {
1006  error = clib_error_return (0, "Specified a next hop");
1007  goto done;
1008  }
1009 
1010  if ((ret = ila_add_del_entry (&args)))
1011  {
1012  error = clib_error_return (0, "ila_add_del_entry returned error %d", ret);
1013  goto done;
1014  }
1015 
1016 done:
1017  unformat_free (line_input);
1018 
1019  return error;
1020 }
1021 
1022 VLIB_CLI_COMMAND (ila_entry_command, static) =
1023 {
1024  .path = "ila entry",
1025  .short_help = "ila entry [type <type>] [sir-address <address>] [locator <locator>] [vnid <hex-vnid>]"
1026  " [adj-index <adj-index>] [next-hop <next-hop>] [direction (bidir|sir2ila|ila2sir)]"
1027  " [csum-mode (no-action|neutral-map|transport-adjust)] [del]",
1028  .function = ila_entry_command_fn,
1029 };
1030 
1031 static clib_error_t *
1033  unformat_input_t * input, vlib_cli_command_t * cmd)
1034 {
1035  vnet_main_t *vnm = vnet_get_main ();
1036  u32 sw_if_index = ~0;
1037  u8 disable = 0;
1038 
1039  if (!unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index))
1040  {
1041  return clib_error_return (0, "Invalid interface name");
1042  }
1043 
1044  if (unformat (input, "disable"))
1045  {
1046  disable = 1;
1047  }
1048 
1049  int ret;
1050  if ((ret = ila_interface (sw_if_index, disable)))
1051  return clib_error_return (0, "ila_interface returned error %d", ret);
1052 
1053  return NULL;
1054 }
1055 
1056 VLIB_CLI_COMMAND (ila_interface_command, static) =
1057 {
1058  .path = "ila interface",
1059  .short_help = "ila interface <interface-name> [disable]",
1060  .function = ila_interface_command_fn,
1061 };
1062 
1063 static clib_error_t *
1065  unformat_input_t * input,
1066  vlib_cli_command_t * cmd)
1067 {
1068  vnet_main_t *vnm = vnet_get_main ();
1069  ila_main_t *ilm = &ila_main;
1070  ila_entry_t *e;
1071 
1072  vlib_cli_output (vm, " %U\n", format_ila_entry, vnm, NULL);
1073  pool_foreach (e, ilm->entries,
1074  ({
1075  vlib_cli_output (vm, " %U\n", format_ila_entry, vnm, e);
1076  }));
1077 
1078  return NULL;
1079 }
1080 
1081 VLIB_CLI_COMMAND (ila_show_entries_command, static) =
1082 {
1083  .path = "show ila entries",
1084  .short_help = "show ila entries",
1085  .function = ila_show_entries_command_fn,
1086 };
static u8 * format_ila_entry(u8 *s, va_list *va)
Definition: ila.c:132
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:124
ila_direction_t dir
Definition: ila.h:72
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:406
ip6_address_t initial_dst
Definition: ila.c:51
enum fib_source_t_ fib_source_t
The different sources that can create a route.
clib_bihash_24_8_t id_to_entry_table
Definition: ila.h:95
ila_direction_t dir
Definition: ila.h:109
#define CLIB_UNUSED(x)
Definition: clib.h:82
A virtual function table regisitered for a DPO type.
Definition: dpo.h:401
ila_sir2ila_next_t
INDENT-ON
Definition: ila.c:405
ip6_address_t initial_dst
Definition: ila.c:414
a
Definition: bitmap.h:538
ip6_address_t next_hop
Definition: ila.h:70
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static fib_node_type_t ila_fib_node_type
Dynamically registered FIB node type for ILA.
Definition: ila.c:69
u8 * format_half_ip6_address(u8 *s, va_list *va)
Definition: ila.c:77
u32 fib_entry_child_add(fib_node_index_t fib_entry_index, fib_node_type_t child_type, fib_node_index_t child_index)
Definition: fib_entry.c:555
#define PREDICT_TRUE(x)
Definition: clib.h:112
u8 as_u8[16]
Definition: ip6_packet.h:48
u64 as_u64[2]
Definition: ip6_packet.h:51
unsigned long u64
Definition: types.h:89
Definitions for all things IP (v4|v6) unicast and multicast lookup related.
u8 * format_ila_sir2ila_trace(u8 *s, va_list *args)
Definition: ila.c:418
#define NULL
Definition: clib.h:58
enum fib_node_back_walk_rc_t_ fib_node_back_walk_rc_t
Return code from a back walk function.
const dpo_id_t * fib_entry_contribute_ip_forwarding(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:506
Definition: ila.h:101
static uword unformat_ila_type(unformat_input_t *input, va_list *args)
Definition: ila.c:198
add paths without path extensions
Definition: fib_source.h:205
dpo_id_t ila_dpo
The next DPO in the graph to follow.
Definition: ila.h:87
void fib_entry_child_remove(fib_node_index_t fib_entry_index, u32 sibling_index)
Definition: fib_entry.c:566
u8 data[0]
Packet data.
Definition: buffer.h:181
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
ip6_address_t ila_address
Definition: ila.h:69
int i
VNET_FEATURE_INIT(ila_sir2ila, static)
INDENT-ON
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
static void ila_entry_stack(ila_entry_t *ie)
INDENT-ON
Definition: ila.c:614
#define STRUCT_OFFSET_OF(t, f)
Definition: clib.h:65
uword ip_csum_t
Definition: ip_packet.h:244
static ila_main_t ila_main
Definition: ila.c:23
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
unformat_function_t unformat_vnet_sw_interface
ila_csum_mode_t
Definition: ila.h:44
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:237
clib_error_t * ila_init(vlib_main_t *vm)
Definition: ila.c:928
ip6_address_t sir_address
Definition: ila.h:68
VLIB_PLUGIN_REGISTER()
int ila_add_del_entry(ila_add_del_entry_args_t *args)
Definition: ila.c:627
static fib_node_t * ila_fib_node_get_node(fib_node_index_t index)
Definition: ila.c:881
unsigned char u8
Definition: types.h:56
fib_node_type_t fib_node_register_new_type(const fib_node_vft_t *vft)
Create a new FIB node type and Register the function table for it.
Definition: fib_node.c:80
fib_node_index_t next_hop_fib_entry_index
The FIB entry index for the next-hop.
Definition: ila.h:77
static clib_error_t * ila_entry_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ila.c:952
ila_ila2sir_next_t
Definition: ila.c:44
ip6_address_t next_hop_address
Definition: ila.h:104
enum dpo_type_t_ dpo_type_t
Common types of data-path objects New types can be dynamically added using dpo_register_new_type() ...
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:498
ila_type_t type
Definition: ila.h:67
vl_api_interface_index_t sw_if_index
Definition: gre.api:59
int clib_bihash_add_del(clib_bihash *h, clib_bihash_kv *add_v, int is_add)
Add or delete a (key,value) pair from a bi-hash table.
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a &#39;special&#39; entry from the FIB.
Definition: fib_table.c:424
#define ILA_TABLE_DEFAULT_HASH_NUM_BUCKETS
Definition: ila.c:25
static BVT(clib_bihash)
Definition: adj_nbr.c:28
u8 is_del
Definition: ila.h:110
Recursive resolution source.
Definition: fib_source.h:119
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:203
Aggregate type for a prefix.
Definition: fib_types.h:203
static uword unformat_ila_direction(unformat_input_t *input, va_list *args)
Definition: ila.c:182
#define clib_error_return(e, args...)
Definition: error.h:99
static fib_source_t ila_fib_src
FIB source for adding entries.
Definition: ila.c:74
static ila_entry_t ila_sir2ila_default_entry
Definition: ila.c:55
u32 local_adj_index
Definition: ila.h:107
unsigned int u32
Definition: types.h:88
ila_direction_t
Definition: ila.h:56
static char * ila_error_strings[]
Definition: ila.c:38
u64 lookup_table_nbuckets
Definition: ila.h:93
static uword unformat_half_ip6_address(unformat_input_t *input, va_list *args)
Definition: ila.c:236
dpo_type_t dpo_register_new_type(const dpo_vft_t *vft, const char *const *const *nodes)
Create and register a new DPO type.
Definition: dpo.c:342
fib_source_t fib_source_allocate(const char *name, fib_source_priority_t prio, fib_source_behaviour_t bh)
Definition: fib_source.c:118
Definition: fib_entry.h:112
unformat_function_t unformat_line_input
Definition: format.h:283
static vlib_node_registration_t ila_ila2sir_node
INDENT-OFF
Definition: ila.c:254
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:170
#define ila_csum_foreach_type
Definition: ila.h:39
Definition: ila.h:62
Definition: fib_entry.h:116
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:519
u32 vnid
Definition: ila.h:106
#define FIB_SOURCE_PRIORITY_HI
Some priority values that plugins might use when they are not to concerned where in the list they&#39;ll ...
Definition: fib_source.h:273
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:226
long ctx[MAX_CONNS]
Definition: main.c:144
struct _unformat_input_t unformat_input_t
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:287
#define PREDICT_FALSE(x)
Definition: clib.h:111
ila_csum_mode_t csum_mode
Definition: ila.h:108
static clib_error_t * ila_show_entries_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ila.c:1064
#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:218
static fib_node_back_walk_rc_t ila_fib_node_back_walk_notify(fib_node_t *node, fib_node_back_walk_ctx_t *ctx)
Callback function invoked when the forwarding changes for the ILA next-hop.
Definition: ila.c:910
An node in the FIB graph.
Definition: fib_node.h:295
#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:338
void clib_bihash_init(clib_bihash *h, char *name, u32 nbuckets, uword memory_size)
initialize a bounded index extensible hash table
vlib_main_t * vm
Definition: in2out_ed.c:1810
static void ila_dpo_unlock(dpo_id_t *dpo)
no-op unlock function.
Definition: ila.c:861
u8 * format_ila_direction(u8 *s, va_list *args)
Definition: ila.c:87
static vlib_node_registration_t ila_sir2ila_node
INDENT-OFF
Definition: ila.c:428
unformat_function_t unformat_ip6_address
Definition: format.h:89
u32 as_u32[4]
Definition: ip6_packet.h:50
fib_node_index_t fib_table_entry_special_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags)
Add a &#39;special&#39; entry to the FIB.
Definition: fib_table.c:405
static const char *const ila_ip6_nodes[]
Definition: ila.c:870
ila_entry_t * entries
Definition: ila.h:91
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
u16 n_vectors
Definition: node.h:397
format_function_t format_ip6_address
Definition: format.h:91
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
void fib_table_entry_delete_index(fib_node_index_t fib_entry_index, fib_source_t source)
Delete a FIB entry.
Definition: fib_table.c:905
static uword ip6_address_is_zero(const ip6_address_t *a)
Definition: ip6_packet.h:223
static_always_inline void vnet_feature_next(u32 *next0, vlib_buffer_t *b0)
Definition: feature.h:302
u8 * format_ila_ila2sir_trace(u8 *s, va_list *args)
Definition: ila.c:170
static ila_entry_t * ila_entry_from_fib_node(fib_node_t *node)
Definition: ila.c:899
#define clib_warning(format, args...)
Definition: error.h:59
fib_node_get_t fnv_get
Definition: fib_node.h:283
static uword ila_ila2sir(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: ila.c:257
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
fib_node_t ila_fib_node
Fib Node base class.
Definition: ila.h:66
static clib_error_t * ila_interface_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ila.c:1032
static void ila_fib_node_last_lock_gone(fib_node_t *node)
no-op unlock function.
Definition: ila.c:894
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:456
void dpo_set(dpo_id_t *dpo, dpo_type_t type, dpo_proto_t proto, index_t index)
Set/create a DPO ID The DPO will be locked.
Definition: dpo.c:186
ila_type_t type
Definition: ila.h:102
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1810
Context passed between object during a back walk.
Definition: fib_node.h:208
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:152
fib_node_index_t fib_table_entry_special_dpo_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo)
Add a &#39;special&#39; entry to the FIB that links to the DPO passed A special entry is an entry that the FI...
Definition: fib_table.c:324
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:515
u8 value
Definition: qos.api:54
u64 lookup_table_size
Definition: ila.h:94
static ip_csum_t ip_csum_sub_even(ip_csum_t c, ip_csum_t x)
Definition: ip_packet.h:272
ip6_address_t sir_address
Definition: ila.h:103
Definition: ila.h:90
u8 * format_dpo_id(u8 *s, va_list *args)
Format a DPO_id_t oject
Definition: dpo.c:148
#define VNET_FEATURES(...)
Definition: feature.h:442
static u8 * format_csum_mode(u8 *s, va_list *va)
Definition: ila.c:99
static dpo_type_t ila_dpo_type
Dynamically registered DPO Type for ILA.
Definition: ila.c:64
u8 * format_ila_dpo(u8 *s, va_list *va)
Definition: ila.c:836
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
struct _vlib_node_registration vlib_node_registration_t
Definition: defs.h:47
#define DPO_PROTO_NUM
Definition: dpo.h:70
u32 next_hop_child_index
The child index on the FIB entry.
Definition: ila.h:82
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:186
vl_api_address_t ip
Definition: l2.api:490
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
static uword max_log2(uword x)
Definition: clib.h:191
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
static void unformat_free(unformat_input_t *i)
Definition: format.h:163
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:197
u64 locator
Definition: ila.h:105
static void ila_dpo_lock(dpo_id_t *dpo)
no-op lock function.
Definition: ila.c:852
ila_error_t
Definition: ila.c:31
A FIB graph nodes virtual function table.
Definition: fib_node.h:282
#define vnet_buffer(b)
Definition: buffer.h:408
ila_csum_mode_t csum_mode
Definition: ila.h:71
enum fib_node_type_t_ fib_node_type_t
The types of nodes in a FIB graph.
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
ila_type_t
Definition: ila.h:33
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:232
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
Definition: in2out_ed.c:1811
u16 as_u16[8]
Definition: ip6_packet.h:49
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:182
#define foreach_ila_error
Definition: ila.c:28
static uword unformat_ila_csum_mode(unformat_input_t *input, va_list *args)
Definition: ila.c:214
static const char *const *const ila_nodes[DPO_PROTO_NUM]
Definition: ila.c:875
static uword ila_sir2ila(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: ila.c:431
u8 * format_ila_type(u8 *s, va_list *args)
Definition: ila.c:120
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:689
int ila_interface(u32 sw_if_index, u8 disable)
Definition: ila.c:822
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
#define ILA_TABLE_DEFAULT_HASH_MEMORY_SIZE
Definition: ila.c:26
static u16 ip_csum_fold(ip_csum_t c)
Definition: ip_packet.h:300
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
static ip_csum_t ip_csum_add_even(ip_csum_t c, ip_csum_t x)
Definition: ip_packet.h:255
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: feature.c:304
ip6_address_t dst_address
Definition: ip6_packet.h:307
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
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:516