FD.io VPP  v17.07.01-10-g3be13f0
Vector Packet Processing
sr_localsid.c
Go to the documentation of this file.
1 /*
2  * sr_localsid.c: ipv6 segment routing Endpoint behaviors
3  *
4  * Copyright (c) 2016 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 /**
19  * @file
20  * @brief Processing of packets with a SRH
21  *
22  * CLI to define new Segment Routing End processing functions.
23  * Graph node to support such functions.
24  *
25  * Each function associates an SRv6 segment (IPv6 address) with an specific
26  * Segment Routing function.
27  *
28  */
29 
30 #include <vlib/vlib.h>
31 #include <vnet/vnet.h>
32 #include <vnet/srv6/sr.h>
33 #include <vnet/ip/ip.h>
34 #include <vnet/srv6/sr_packet.h>
35 #include <vnet/ip/ip6_packet.h>
36 #include <vnet/fib/ip6_fib.h>
37 #include <vnet/dpo/dpo.h>
38 #include <vnet/adj/adj.h>
39 
40 #include <vppinfra/error.h>
41 #include <vppinfra/elog.h>
42 
43 /**
44  * @brief Dynamically added SR localsid DPO type
45  */
48 
49 /**
50  * @brief SR localsid add/del
51  *
52  * Function to add or delete SR LocalSIDs.
53  *
54  * @param is_del Boolean of whether its a delete instruction
55  * @param localsid_addr IPv6 address of the localsid
56  * @param is_decap Boolean of whether decapsulation is allowed in this function
57  * @param behavior Type of behavior (function) for this localsid
58  * @param sw_if_index Only for L2/L3 xconnect. OIF. In VRF variant the fib_table.
59  * @param vlan_index Only for L2 xconnect. Outgoing VLAN tag.
60  * @param fib_table FIB table in which we should install the localsid entry
61  * @param nh_addr Next Hop IPv4/IPv6 address. Only for L2/L3 xconnect.
62  *
63  * @return 0 on success, error otherwise.
64  */
65 int
66 sr_cli_localsid (char is_del, ip6_address_t * localsid_addr,
67  char end_psp, u8 behavior, u32 sw_if_index, u32 vlan_index,
68  u32 fib_table, ip46_address_t * nh_addr, void *ls_plugin_mem)
69 {
70  ip6_sr_main_t *sm = &sr_main;
71  uword *p;
72  int rv;
73 
74  ip6_sr_localsid_t *ls = 0;
75 
76  dpo_id_t dpo = DPO_INVALID;
77 
78  /* Search for the item */
79  p = mhash_get (&sm->sr_localsids_index_hash, localsid_addr);
80 
81  if (p)
82  {
83  if (is_del)
84  {
85  /* Retrieve localsid */
86  ls = pool_elt_at_index (sm->localsids, p[0]);
87  /* Delete FIB entry */
88  fib_prefix_t pfx = {
90  .fp_len = 128,
91  .fp_addr = {
92  .ip6 = *localsid_addr,
93  }
94  };
95 
97  fib_table),
98  &pfx, FIB_SOURCE_SR);
99 
100  /* In case it is a Xconnect iface remove the (OIF, NHOP) adj */
101  if (ls->behavior == SR_BEHAVIOR_X || ls->behavior == SR_BEHAVIOR_DX6
102  || ls->behavior == SR_BEHAVIOR_DX4)
103  adj_unlock (ls->nh_adj);
104 
105  if (ls->behavior >= SR_BEHAVIOR_LAST)
106  {
107  sr_localsid_fn_registration_t *plugin = 0;
108  plugin = pool_elt_at_index (sm->plugin_functions,
109  ls->behavior - SR_BEHAVIOR_LAST);
110 
111  /* Callback plugin removal function */
112  rv = plugin->removal (ls);
113  }
114 
115  /* Delete localsid registry */
116  pool_put (sm->localsids, ls);
117  mhash_unset (&sm->sr_localsids_index_hash, localsid_addr, NULL);
118  return 0;
119  }
120  else /* create with function already existing; complain */
121  return -1;
122  }
123  else
124  /* delete; localsid does not exist; complain */
125  if (is_del)
126  return -2;
127 
128  /* Check whether there exists a FIB entry with such address */
129  fib_prefix_t pfx = {
131  .fp_len = 128,
132  };
133 
134  pfx.fp_addr.as_u64[0] = localsid_addr->as_u64[0];
135  pfx.fp_addr.as_u64[1] = localsid_addr->as_u64[1];
136 
137  /* Lookup the FIB index associated to the table id provided */
138  u32 fib_index = fib_table_find (FIB_PROTOCOL_IP6, fib_table);
139  if (fib_index == ~0)
140  return -3;
141 
142  /* Lookup the localsid in such FIB table */
143  fib_node_index_t fei = fib_table_lookup_exact_match (fib_index, &pfx);
144  if (FIB_NODE_INDEX_INVALID != fei)
145  return -4; //There is an entry for such address (the localsid addr)
146 
147  /* Create a new localsid registry */
148  pool_get (sm->localsids, ls);
149  memset (ls, 0, sizeof (*ls));
150 
151  clib_memcpy (&ls->localsid, localsid_addr, sizeof (ip6_address_t));
152  ls->end_psp = end_psp;
153  ls->behavior = behavior;
154  ls->nh_adj = (u32) ~ 0;
155  ls->fib_table = fib_table;
156  switch (behavior)
157  {
158  case SR_BEHAVIOR_END:
159  break;
160  case SR_BEHAVIOR_X:
161  ls->sw_if_index = sw_if_index;
162  clib_memcpy (&ls->next_hop.ip6, &nh_addr->ip6, sizeof (ip6_address_t));
163  break;
164  case SR_BEHAVIOR_T:
165  ls->vrf_index = sw_if_index;
166  break;
167  case SR_BEHAVIOR_DX4:
168  ls->sw_if_index = sw_if_index;
169  clib_memcpy (&ls->next_hop.ip4, &nh_addr->ip4, sizeof (ip4_address_t));
170  break;
171  case SR_BEHAVIOR_DX6:
172  ls->sw_if_index = sw_if_index;
173  clib_memcpy (&ls->next_hop.ip6, &nh_addr->ip6, sizeof (ip6_address_t));
174  break;
175  case SR_BEHAVIOR_DT6:
176  ls->vrf_index = sw_if_index;
177  break;
178  case SR_BEHAVIOR_DT4:
179  ls->vrf_index = sw_if_index;
180  break;
181  case SR_BEHAVIOR_DX2:
182  ls->sw_if_index = sw_if_index;
183  ls->vlan_index = vlan_index;
184  break;
185  }
186 
187  /* Figure out the adjacency magic for Xconnect variants */
188  if (ls->behavior == SR_BEHAVIOR_X || ls->behavior == SR_BEHAVIOR_DX4
189  || ls->behavior == SR_BEHAVIOR_DX6)
190  {
191  adj_index_t nh_adj_index = ADJ_INDEX_INVALID;
192 
193  /* Retrieve the adjacency corresponding to the (OIF, next_hop) */
194  if (ls->behavior == SR_BEHAVIOR_DX6 || ls->behavior == SR_BEHAVIOR_X)
196  nh_addr, sw_if_index);
197 
198  else if (ls->behavior == SR_BEHAVIOR_DX4)
200  nh_addr, sw_if_index);
201 
202  /* Check for ADJ creation error. If so panic */
203  if (nh_adj_index == ADJ_INDEX_INVALID)
204  {
205  pool_put (sm->localsids, ls);
206  return -5;
207  }
208 
209  ls->nh_adj = nh_adj_index;
210  }
211 
212  /* Set DPO */
213  if (ls->behavior == SR_BEHAVIOR_END || ls->behavior == SR_BEHAVIOR_X)
215  else if (ls->behavior > SR_BEHAVIOR_D_FIRST
216  && ls->behavior < SR_BEHAVIOR_LAST)
218  else if (ls->behavior >= SR_BEHAVIOR_LAST)
219  {
220  sr_localsid_fn_registration_t *plugin = 0;
221  plugin = pool_elt_at_index (sm->plugin_functions,
222  ls->behavior - SR_BEHAVIOR_LAST);
223  /* Copy the unformat memory result */
224  ls->plugin_mem = ls_plugin_mem;
225  /* Callback plugin creation function */
226  rv = plugin->creation (ls);
227  if (rv)
228  {
229  pool_put (sm->localsids, ls);
230  return -6;
231  }
232  dpo_set (&dpo, plugin->dpo, DPO_PROTO_IP6, ls - sm->localsids);
233  }
234 
235  /* Set hash key for searching localsid by address */
236  mhash_set (&sm->sr_localsids_index_hash, localsid_addr, ls - sm->localsids,
237  NULL);
238 
241  dpo_reset (&dpo);
242 
243  /* Set counter to zero */
245  ls - sm->localsids);
247  ls - sm->localsids);
248 
250  ls - sm->localsids);
252  ls - sm->localsids);
253 
254  return 0;
255 }
256 
257 /**
258  * @brief SR LocalSID CLI function.
259  *
260  * @see sr_cli_localsid
261  */
262 static clib_error_t *
264  vlib_cli_command_t * cmd)
265 {
266  vnet_main_t *vnm = vnet_get_main ();
267  ip6_sr_main_t *sm = &sr_main;
268  u32 sw_if_index = (u32) ~ 0, vlan_index = (u32) ~ 0, fib_index = 0;
269  int is_del = 0;
270  int end_psp = 0;
271  ip6_address_t resulting_address;
272  ip46_address_t next_hop;
273  char address_set = 0;
274  char behavior = 0;
275  void *ls_plugin_mem = 0;
276 
277  int rv;
278 
279  memset (&resulting_address, 0, sizeof (ip6_address_t));
280  ip46_address_reset (&next_hop);
281 
283  {
284  if (unformat (input, "del"))
285  is_del = 1;
286  else if (!address_set
287  && unformat (input, "address %U", unformat_ip6_address,
288  &resulting_address))
289  address_set = 1;
290  else if (!address_set
291  && unformat (input, "addr %U", unformat_ip6_address,
292  &resulting_address))
293  address_set = 1;
294  else if (unformat (input, "fib-table %u", &fib_index));
295  else if (vlan_index == (u32) ~ 0
296  && unformat (input, "vlan %u", &vlan_index));
297  else if (!behavior && unformat (input, "behavior"))
298  {
299  if (unformat (input, "end.x %U %U",
300  unformat_vnet_sw_interface, vnm, &sw_if_index,
301  unformat_ip6_address, &next_hop.ip6))
302  behavior = SR_BEHAVIOR_X;
303  else if (unformat (input, "end.t %u", &sw_if_index))
304  behavior = SR_BEHAVIOR_T;
305  else if (unformat (input, "end.dx6 %U %U",
306  unformat_vnet_sw_interface, vnm, &sw_if_index,
307  unformat_ip6_address, &next_hop.ip6))
308  behavior = SR_BEHAVIOR_DX6;
309  else if (unformat (input, "end.dx4 %U %U",
310  unformat_vnet_sw_interface, vnm, &sw_if_index,
311  unformat_ip4_address, &next_hop.ip4))
312  behavior = SR_BEHAVIOR_DX4;
313  else if (unformat (input, "end.dx2 %U",
314  unformat_vnet_sw_interface, vnm, &sw_if_index))
315  behavior = SR_BEHAVIOR_DX2;
316  else if (unformat (input, "end.dt6 %u", &sw_if_index))
317  behavior = SR_BEHAVIOR_DT6;
318  else if (unformat (input, "end.dt4 %u", &sw_if_index))
319  behavior = SR_BEHAVIOR_DT4;
320  else
321  {
322  /* Loop over all the plugin behavior format functions */
323  sr_localsid_fn_registration_t *plugin = 0, **vec_plugins = 0;
324  sr_localsid_fn_registration_t **plugin_it = 0;
325 
326  /* Create a vector out of the plugin pool as recommended */
327  /* *INDENT-OFF* */
328  pool_foreach (plugin, sm->plugin_functions,
329  {
330  vec_add1 (vec_plugins, plugin);
331  });
332  /* *INDENT-ON* */
333 
334  vec_foreach (plugin_it, vec_plugins)
335  {
336  if (unformat
337  (input, "%U", (*plugin_it)->ls_unformat, &ls_plugin_mem))
338  {
339  behavior = (*plugin_it)->sr_localsid_function_number;
340  break;
341  }
342  }
343  }
344 
345  if (!behavior)
346  {
347  if (unformat (input, "end"))
348  behavior = SR_BEHAVIOR_END;
349  else
350  break;
351  }
352  }
353  else if (!end_psp && unformat (input, "psp"))
354  end_psp = 1;
355  else
356  break;
357  }
358 
359  if (!behavior && end_psp)
360  behavior = SR_BEHAVIOR_END;
361 
362  if (!address_set)
363  return clib_error_return (0,
364  "Error: SRv6 LocalSID address is mandatory.");
365  if (!is_del && !behavior)
366  return clib_error_return (0,
367  "Error: SRv6 LocalSID behavior is mandatory.");
368  if (vlan_index != (u32) ~ 0)
369  return clib_error_return (0,
370  "Error: SRv6 End.DX2 with rewrite VLAN tag not supported by now.");
371  if (end_psp && !(behavior == SR_BEHAVIOR_END || behavior == SR_BEHAVIOR_X))
372  return clib_error_return (0,
373  "Error: SRv6 PSP only compatible with End and End.X");
374 
375  rv = sr_cli_localsid (is_del, &resulting_address, end_psp, behavior,
376  sw_if_index, vlan_index, fib_index, &next_hop,
377  ls_plugin_mem);
378 
379  switch (rv)
380  {
381  case 0:
382  break;
383  case 1:
384  return 0;
385  case -1:
386  return clib_error_return (0,
387  "Identical localsid already exists. Requested localsid not created.");
388  case -2:
389  return clib_error_return (0,
390  "The requested localsid could not be deleted. SR localsid not found");
391  case -3:
392  return clib_error_return (0, "FIB table %u does not exist", fib_index);
393  case -4:
394  return clib_error_return (0, "There is already one FIB entry for the"
395  "requested localsid non segment routing related");
396  case -5:
397  return clib_error_return (0,
398  "Could not create ARP/ND entry for such next_hop. Internal error.");
399  case -6:
400  return clib_error_return (0,
401  "Error on the plugin based localsid creation.");
402  default:
403  return clib_error_return (0, "BUG: sr localsid returns %d", rv);
404  }
405  return 0;
406 }
407 
408 /* *INDENT-OFF* */
409 VLIB_CLI_COMMAND (sr_localsid_command, static) = {
410  .path = "sr localsid",
411  .short_help = "sr localsid (del) address XX:XX::YY:YY"
412  "(fib-table 8) behavior STRING",
413  .long_help =
414  "Create SR LocalSID and binds it to a particular behavior\n"
415  "Arguments:\n"
416  "\tlocalSID IPv6_addr(128b) LocalSID IPv6 address\n"
417  "\t(fib-table X) Optional. VRF where to install SRv6 localsid\n"
418  "\tbehavior STRING Specifies the behavior\n"
419  "\n\tBehaviors:\n"
420  "\tEnd\t-> Endpoint.\n"
421  "\tEnd.X\t-> Endpoint with decapsulation and Layer-3 cross-connect.\n"
422  "\t\tParameters: '<iface> <ip6_next_hop>'\n"
423  "\tEnd.DX2\t-> Endpoint with decapsulation and Layer-2 cross-connect.\n"
424  "\t\tParameters: '<iface>'\n"
425  "\tEnd.DX6\t-> Endpoint with decapsulation and IPv6 cross-connect.\n"
426  "\t\tParameters: '<iface> <ip6_next_hop>'\n"
427  "\tEnd.DX4\t-> Endpoint with decapsulation and IPv4 cross-connect.\n"
428  "\t\tParameters: '<iface> <ip4_next_hop>'\n"
429  "\tEnd.DT6\t-> Endpoint with decapsulation and specific IPv6 table lookup.\n"
430  "\t\tParameters: '<ip6_fib_table>'\n"
431  "\tEnd.DT4\t-> Endpoint with decapsulation and specific IPv4 table lookup.\n"
432  "\t\tParameters: '<ip4_fib_table>'\n",
433  .function = sr_cli_localsid_command_fn,
434 };
435 /* *INDENT-ON* */
436 
437 /**
438  * @brief CLI function to 'show' all SR LocalSIDs on console.
439  */
440 static clib_error_t *
442  vlib_cli_command_t * cmd)
443 {
444  vnet_main_t *vnm = vnet_get_main ();
445  ip6_sr_main_t *sm = &sr_main;
446  ip6_sr_localsid_t **localsid_list = 0;
447  ip6_sr_localsid_t *ls;
448  int i;
449 
450  vlib_cli_output (vm, "SRv6 - My LocalSID Table:");
451  vlib_cli_output (vm, "=========================");
452  /* *INDENT-OFF* */
453  pool_foreach (ls, sm->localsids, ({ vec_add1 (localsid_list, ls); }));
454  /* *INDENT-ON* */
455  for (i = 0; i < vec_len (localsid_list); i++)
456  {
457  ls = localsid_list[i];
458  switch (ls->behavior)
459  {
460  case SR_BEHAVIOR_END:
461  vlib_cli_output (vm, "\tAddress: \t%U\n\tBehavior: \tEnd",
463  break;
464  case SR_BEHAVIOR_X:
465  vlib_cli_output (vm,
466  "\tAddress: \t%U\n\tBehavior: \tX (Endpoint with Layer-3 cross-connect)"
467  "\n\tIface: \t%U\n\tNext hop: \t%U",
470  format_ip6_address, &ls->next_hop.ip6);
471  break;
472  case SR_BEHAVIOR_T:
473  vlib_cli_output (vm,
474  "\tAddress: \t%U\n\tBehavior: \tT (Endpoint with specific IPv6 table lookup)"
475  "\n\tTable: \t%u",
478  break;
479  case SR_BEHAVIOR_DX4:
480  vlib_cli_output (vm,
481  "\tAddress: \t%U\n\tBehavior: \tDX4 (Endpoint with decapsulation and IPv4 cross-connect)"
482  "\n\tIface: \t%U\n\tNext hop: \t%U",
485  format_ip4_address, &ls->next_hop.ip4);
486  break;
487  case SR_BEHAVIOR_DX6:
488  vlib_cli_output (vm,
489  "\tAddress: \t%U\n\tBehavior: \tDX6 (Endpoint with decapsulation and IPv6 cross-connect)"
490  "\n\tIface: \t%U\n\tNext hop: \t%U",
493  format_ip6_address, &ls->next_hop.ip6);
494  break;
495  case SR_BEHAVIOR_DX2:
496  if (ls->vlan_index == (u32) ~ 0)
497  vlib_cli_output (vm,
498  "\tAddress: \t%U\n\tBehavior: \tDX2 (Endpoint with decapulation and Layer-2 cross-connect)"
499  "\n\tIface: \t%U", format_ip6_address,
501  ls->sw_if_index);
502  else
503  vlib_cli_output (vm,
504  "Unsupported yet. (DX2 with egress VLAN rewrite)");
505  break;
506  case SR_BEHAVIOR_DT6:
507  vlib_cli_output (vm,
508  "\tAddress: \t%U\n\tBehavior: \tDT6 (Endpoint with decapsulation and specific IPv6 table lookup)"
509  "\n\tTable: %u", format_ip6_address, &ls->localsid,
510  ls->vrf_index);
511  break;
512  case SR_BEHAVIOR_DT4:
513  vlib_cli_output (vm,
514  "\tAddress: \t%U\n\tBehavior: \tDT4 (Endpoint with decapsulation and specific IPv4 table lookup)"
515  "\n\tTable: \t%u", format_ip6_address,
516  &ls->localsid, ls->vrf_index);
517  break;
518  default:
519  if (ls->behavior >= SR_BEHAVIOR_LAST)
520  {
523  ls->behavior - SR_BEHAVIOR_LAST);
524 
525  vlib_cli_output (vm, "\tAddress: \t%U\n"
526  "\tBehavior: \t%s (%s)\n\t%U",
528  plugin->keyword_str, plugin->def_str,
529  plugin->ls_format, ls->plugin_mem);
530  }
531  else
532  //Should never get here...
533  vlib_cli_output (vm, "Internal error");
534  break;
535  }
536  if (ls->end_psp)
537  vlib_cli_output (vm, "\tPSP: \tTrue\n");
538 
539  /* Print counters */
540  vlib_counter_t valid, invalid;
543  vlib_cli_output (vm, "\tGood traffic: \t[%Ld packets : %Ld bytes]\n",
544  valid.packets, valid.bytes);
545  vlib_cli_output (vm, "\tBad traffic: \t[%Ld packets : %Ld bytes]\n",
546  invalid.packets, invalid.bytes);
547  vlib_cli_output (vm, "--------------------");
548  }
549  return 0;
550 }
551 
552 /* *INDENT-OFF* */
553 VLIB_CLI_COMMAND (show_sr_localsid_command, static) = {
554  .path = "show sr localsids",
555  .short_help = "show sr localsids",
556  .function = show_sr_localsid_command_fn,
557 };
558 /* *INDENT-ON* */
559 
560 /**
561  * @brief Function to 'clear' ALL SR localsid counters
562  */
563 static clib_error_t *
565  unformat_input_t * input,
566  vlib_cli_command_t * cmd)
567 {
568  ip6_sr_main_t *sm = &sr_main;
569 
572 
573  return 0;
574 }
575 
576 /* *INDENT-OFF* */
577 VLIB_CLI_COMMAND (clear_sr_localsid_counters_command, static) = {
578  .path = "clear sr localsid counters",
579  .short_help = "clear sr localsid counters",
581 };
582 /* *INDENT-ON* */
583 
584 /************************ SR LocalSID graphs node ****************************/
585 /**
586  * @brief SR localsid node trace
587  */
588 typedef struct
589 {
591  ip6_address_t src, out_dst;
592  u8 sr[256];
595  //With SRv6 header update include flags here.
597 
598 #define foreach_sr_localsid_error \
599 _(NO_INNER_HEADER, "(SR-Error) No inner IP header") \
600 _(NO_MORE_SEGMENTS, "(SR-Error) No more segments") \
601 _(NO_SRH, "(SR-Error) No SR header") \
602 _(NO_PSP, "(SR-Error) PSP Not available (segments left > 0)") \
603 _(NOT_LS, "(SR-Error) Decaps not available (segments left > 0)") \
604 _(L2, "(SR-Error) SRv6 decapsulated a L2 frame without dest")
605 
606 typedef enum
607 {
608 #define _(sym,str) SR_LOCALSID_ERROR_##sym,
610 #undef _
613 
614 static char *sr_localsid_error_strings[] = {
615 #define _(sym,string) string,
617 #undef _
618 };
619 
620 #define foreach_sr_localsid_next \
621 _(ERROR, "error-drop") \
622 _(IP6_LOOKUP, "ip6-lookup") \
623 _(IP4_LOOKUP, "ip4-lookup") \
624 _(IP6_REWRITE, "ip6-rewrite") \
625 _(IP4_REWRITE, "ip4-rewrite") \
626 _(INTERFACE_OUTPUT, "interface-output")
627 
628 typedef enum
629 {
630 #define _(s,n) SR_LOCALSID_NEXT_##s,
632 #undef _
635 
636 /**
637  * @brief SR LocalSID graph node trace function
638  *
639  * @see sr_localsid
640  */
641 u8 *
642 format_sr_localsid_trace (u8 * s, va_list * args)
643 {
644  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
645  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
646  ip6_sr_main_t *sm = &sr_main;
647  sr_localsid_trace_t *t = va_arg (*args, sr_localsid_trace_t *);
648 
649  ip6_sr_localsid_t *ls =
651 
652  s =
653  format (s, "SR-LOCALSID:\n\tLocalsid: %U\n", format_ip6_address,
654  &ls->localsid);
655  switch (ls->behavior)
656  {
657  case SR_BEHAVIOR_END:
658  s = format (s, "\tBehavior: End\n");
659  break;
660  case SR_BEHAVIOR_DX6:
661  s = format (s, "\tBehavior: Decapsulation with IPv6 L3 xconnect\n");
662  break;
663  case SR_BEHAVIOR_DX4:
664  s = format (s, "\tBehavior: Decapsulation with IPv4 L3 xconnect\n");
665  break;
666  case SR_BEHAVIOR_X:
667  s = format (s, "\tBehavior: IPv6 L3 xconnect\n");
668  break;
669  case SR_BEHAVIOR_T:
670  s = format (s, "\tBehavior: IPv6 specific table lookup\n");
671  break;
672  case SR_BEHAVIOR_DT6:
673  s = format (s, "\tBehavior: Decapsulation with IPv6 Table lookup\n");
674  break;
675  case SR_BEHAVIOR_DT4:
676  s = format (s, "\tBehavior: Decapsulation with IPv4 Table lookup\n");
677  break;
678  case SR_BEHAVIOR_DX2:
679  s = format (s, "\tBehavior: Decapsulation with L2 xconnect\n");
680  break;
681  default:
682  s = format (s, "\tBehavior: defined in plugin\n"); //TODO
683  break;
684  }
685  if (t->num_segments != 0xFF)
686  {
687  if (t->num_segments > 0)
688  {
689  s = format (s, "\tSegments left: %d\n", t->num_segments);
690  s = format (s, "\tSID list: [in ietf order]");
691  int i = 0;
692  for (i = 0; i < t->num_segments; i++)
693  {
694  s = format (s, "\n\t-> %U", format_ip6_address,
695  (ip6_address_t *) & t->sr[i *
696  sizeof (ip6_address_t)]);
697  }
698  }
699  }
700  return s;
701 }
702 
703 /**
704  * @brief Function doing End processing.
705  */
708  vlib_buffer_t * b0,
709  ip6_header_t * ip0,
710  ip6_sr_header_t * sr0,
711  ip6_sr_localsid_t * ls0,
712  u32 * next0, u8 psp, ip6_ext_header_t * prev0)
713 {
714  ip6_address_t *new_dst0;
715 
717  {
718  if (sr0->segments_left == 1 && psp)
719  {
720  u32 new_l0, sr_len;
721  u64 *copy_dst0, *copy_src0;
722  u32 copy_len_u64s0 = 0;
723 
724  ip0->dst_address.as_u64[0] = sr0->segments->as_u64[0];
725  ip0->dst_address.as_u64[1] = sr0->segments->as_u64[1];
726 
727  /* Remove the SRH taking care of the rest of IPv6 ext header */
728  if (prev0)
729  prev0->next_hdr = sr0->protocol;
730  else
731  ip0->protocol = sr0->protocol;
732 
733  sr_len = ip6_ext_header_len (sr0);
734  vlib_buffer_advance (b0, sr_len);
735  new_l0 = clib_net_to_host_u16 (ip0->payload_length) - sr_len;
736  ip0->payload_length = clib_host_to_net_u16 (new_l0);
737  copy_src0 = (u64 *) ip0;
738  copy_dst0 = copy_src0 + (sr0->length + 1);
739  /* number of 8 octet units to copy
740  * By default in absence of extension headers it is equal to length of ip6 header
741  * With extension headers it number of 8 octet units of ext headers preceding
742  * SR header
743  */
744  copy_len_u64s0 =
745  (((u8 *) sr0 - (u8 *) ip0) - sizeof (ip6_header_t)) >> 3;
746  copy_dst0[4 + copy_len_u64s0] = copy_src0[4 + copy_len_u64s0];
747  copy_dst0[3 + copy_len_u64s0] = copy_src0[3 + copy_len_u64s0];
748  copy_dst0[2 + copy_len_u64s0] = copy_src0[2 + copy_len_u64s0];
749  copy_dst0[1 + copy_len_u64s0] = copy_src0[1 + copy_len_u64s0];
750  copy_dst0[0 + copy_len_u64s0] = copy_src0[0 + copy_len_u64s0];
751 
752  int i;
753  for (i = copy_len_u64s0 - 1; i >= 0; i--)
754  {
755  copy_dst0[i] = copy_src0[i];
756  }
757 
758  if (ls0->behavior == SR_BEHAVIOR_X)
759  {
760  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
761  *next0 = SR_LOCALSID_NEXT_IP6_REWRITE;
762  }
763  else if (ls0->behavior == SR_BEHAVIOR_T)
764  {
765  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
766  }
767  }
768  else if (PREDICT_TRUE (sr0->segments_left > 0))
769  {
770  sr0->segments_left -= 1;
771  new_dst0 = (ip6_address_t *) (sr0->segments);
772  new_dst0 += sr0->segments_left;
773  ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
774  ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
775 
776  if (ls0->behavior == SR_BEHAVIOR_X)
777  {
778  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
779  *next0 = SR_LOCALSID_NEXT_IP6_REWRITE;
780  }
781  else if (ls0->behavior == SR_BEHAVIOR_T)
782  {
783  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
784  }
785  }
786  else
787  {
788  *next0 = SR_LOCALSID_NEXT_ERROR;
789  b0->error = node->errors[SR_LOCALSID_ERROR_NO_MORE_SEGMENTS];
790  }
791  }
792  else
793  {
794  /* Error. Routing header of type != SR */
795  *next0 = SR_LOCALSID_NEXT_ERROR;
796  b0->error = node->errors[SR_LOCALSID_ERROR_NO_SRH];
797  }
798 }
799 
800 /*
801  * @brief Function doing SRH processing for D* variants
802  */
805  vlib_buffer_t * b0,
806  ip6_header_t * ip0,
807  ip6_sr_header_t * sr0,
808  ip6_sr_localsid_t * ls0, u32 * next0)
809 {
810  /* Compute the size of the IPv6 header with all Ext. headers */
811  u8 next_proto;
812  ip6_ext_header_t *next_ext_header;
813  u16 total_size = 0;
814 
815  next_proto = ip0->protocol;
816  next_ext_header = (void *) (ip0 + 1);
817  total_size = sizeof (ip6_header_t);
818  while (ip6_ext_hdr (next_proto))
819  {
820  total_size += ip6_ext_header_len (next_ext_header);
821  next_proto = next_ext_header->next_hdr;
822  next_ext_header = ip6_ext_next_header (next_ext_header);
823  }
824 
825  /* Ensure this is the last segment. Otherwise drop. */
826  if (sr0 && sr0->segments_left != 0)
827  {
828  *next0 = SR_LOCALSID_NEXT_ERROR;
829  b0->error = node->errors[SR_LOCALSID_ERROR_NOT_LS];
830  return;
831  }
832 
833  switch (next_proto)
834  {
835  case IP_PROTOCOL_IPV6:
836  /* Encap-End IPv6. Pop outer IPv6 header. */
837  if (ls0->behavior == SR_BEHAVIOR_DX6)
838  {
839  vlib_buffer_advance (b0, total_size);
840  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
841  *next0 = SR_LOCALSID_NEXT_IP6_REWRITE;
842  return;
843  }
844  else if (ls0->behavior == SR_BEHAVIOR_DT6)
845  {
846  vlib_buffer_advance (b0, total_size);
847  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
848  return;
849  }
850  break;
851  case IP_PROTOCOL_IP_IN_IP:
852  /* Encap-End IPv4. Pop outer IPv6 header */
853  if (ls0->behavior == SR_BEHAVIOR_DX4)
854  {
855  vlib_buffer_advance (b0, total_size);
856  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
857  *next0 = SR_LOCALSID_NEXT_IP4_REWRITE;
858  return;
859  }
860  else if (ls0->behavior == SR_BEHAVIOR_DT4)
861  {
862  vlib_buffer_advance (b0, total_size);
863  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
864  *next0 = SR_LOCALSID_NEXT_IP4_LOOKUP;
865  return;
866  }
867  break;
868  case IP_PROTOCOL_IP6_NONXT:
869  /* L2 encaps */
870  if (ls0->behavior == SR_BEHAVIOR_DX2)
871  {
872  vlib_buffer_advance (b0, total_size);
873  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->sw_if_index;
874  *next0 = SR_LOCALSID_NEXT_INTERFACE_OUTPUT;
875  return;
876  }
877  break;
878  }
879  *next0 = SR_LOCALSID_NEXT_ERROR;
880  b0->error = node->errors[SR_LOCALSID_ERROR_NO_INNER_HEADER];
881  return;
882 }
883 
884 /**
885  * @brief SR LocalSID graph node. Supports all default SR Endpoint variants
886  */
887 static uword
889  vlib_frame_t * from_frame)
890 {
891  u32 n_left_from, next_index, *from, *to_next;
892  ip6_sr_main_t *sm = &sr_main;
893  from = vlib_frame_vector_args (from_frame);
894  n_left_from = from_frame->n_vectors;
895  next_index = node->cached_next_index;
896  u32 thread_index = vlib_get_thread_index ();
897 
898  while (n_left_from > 0)
899  {
900  u32 n_left_to_next;
901  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
902 
903  /* Quad - Loop */
904  while (n_left_from >= 8 && n_left_to_next >= 4)
905  {
906  u32 bi0, bi1, bi2, bi3;
907  vlib_buffer_t *b0, *b1, *b2, *b3;
908  ip6_header_t *ip0, *ip1, *ip2, *ip3;
909  ip6_ext_header_t *prev0, *prev1, *prev2, *prev3;
910  ip6_sr_header_t *sr0, *sr1, *sr2, *sr3;
911  u32 next0, next1, next2, next3;
912  next0 = next1 = next2 = next3 = SR_LOCALSID_NEXT_IP6_LOOKUP;
913  ip6_sr_localsid_t *ls0, *ls1, *ls2, *ls3;
914 
915  /* Prefetch next iteration. */
916  {
917  vlib_buffer_t *p4, *p5, *p6, *p7;
918 
919  p4 = vlib_get_buffer (vm, from[4]);
920  p5 = vlib_get_buffer (vm, from[5]);
921  p6 = vlib_get_buffer (vm, from[6]);
922  p7 = vlib_get_buffer (vm, from[7]);
923 
924  /* Prefetch the buffer header and packet for the N+4 loop iteration */
925  vlib_prefetch_buffer_header (p4, LOAD);
926  vlib_prefetch_buffer_header (p5, LOAD);
927  vlib_prefetch_buffer_header (p6, LOAD);
928  vlib_prefetch_buffer_header (p7, LOAD);
929 
934  }
935 
936  to_next[0] = bi0 = from[0];
937  to_next[1] = bi1 = from[1];
938  to_next[2] = bi2 = from[2];
939  to_next[3] = bi3 = from[3];
940  from += 4;
941  to_next += 4;
942  n_left_from -= 4;
943  n_left_to_next -= 4;
944 
945  b0 = vlib_get_buffer (vm, bi0);
946  b1 = vlib_get_buffer (vm, bi1);
947  b2 = vlib_get_buffer (vm, bi2);
948  b3 = vlib_get_buffer (vm, bi3);
949 
950  ls0 =
952  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
953  ls1 =
955  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
956  ls2 =
958  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
959  ls3 =
961  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
962 
963  ip0 = vlib_buffer_get_current (b0);
964  ip1 = vlib_buffer_get_current (b1);
965  ip2 = vlib_buffer_get_current (b2);
966  ip3 = vlib_buffer_get_current (b3);
967 
968  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
969  ip6_ext_header_find_t (ip1, prev1, sr1, IP_PROTOCOL_IPV6_ROUTE);
970  ip6_ext_header_find_t (ip2, prev2, sr2, IP_PROTOCOL_IPV6_ROUTE);
971  ip6_ext_header_find_t (ip3, prev3, sr3, IP_PROTOCOL_IPV6_ROUTE);
972 
973  end_decaps_srh_processing (node, b0, ip0, sr0, ls0, &next0);
974  end_decaps_srh_processing (node, b1, ip1, sr1, ls1, &next1);
975  end_decaps_srh_processing (node, b2, ip2, sr2, ls2, &next2);
976  end_decaps_srh_processing (node, b3, ip3, sr3, ls3, &next3);
977 
978  //TODO: trace.
979 
981  (((next0 ==
982  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
983  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
984  1, vlib_buffer_length_in_chain (vm, b0));
985 
987  (((next1 ==
988  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
989  &(sm->sr_ls_valid_counters)), thread_index, ls1 - sm->localsids,
990  1, vlib_buffer_length_in_chain (vm, b1));
991 
993  (((next2 ==
994  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
995  &(sm->sr_ls_valid_counters)), thread_index, ls2 - sm->localsids,
996  1, vlib_buffer_length_in_chain (vm, b2));
997 
999  (((next3 ==
1000  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1001  &(sm->sr_ls_valid_counters)), thread_index, ls3 - sm->localsids,
1002  1, vlib_buffer_length_in_chain (vm, b3));
1003 
1004  vlib_validate_buffer_enqueue_x4 (vm, node, next_index, to_next,
1005  n_left_to_next, bi0, bi1, bi2, bi3,
1006  next0, next1, next2, next3);
1007  }
1008 
1009  /* Single loop for potentially the last three packets */
1010  while (n_left_from > 0 && n_left_to_next > 0)
1011  {
1012  u32 bi0;
1013  vlib_buffer_t *b0;
1014  ip6_header_t *ip0;
1015  ip6_ext_header_t *prev0;
1016  ip6_sr_header_t *sr0;
1017  u32 next0 = SR_LOCALSID_NEXT_IP6_LOOKUP;
1018  ip6_sr_localsid_t *ls0;
1019 
1020  bi0 = from[0];
1021  to_next[0] = bi0;
1022  from += 1;
1023  to_next += 1;
1024  n_left_from -= 1;
1025  n_left_to_next -= 1;
1026 
1027  b0 = vlib_get_buffer (vm, bi0);
1028  ip0 = vlib_buffer_get_current (b0);
1029 
1030  /* Lookup the SR End behavior based on IP DA (adj) */
1031  ls0 =
1033  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1034 
1035  /* Find SRH as well as previous header */
1036  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
1037 
1038  /* SRH processing and End variants */
1039  end_decaps_srh_processing (node, b0, ip0, sr0, ls0, &next0);
1040 
1042  {
1043  sr_localsid_trace_t *tr =
1044  vlib_add_trace (vm, node, b0, sizeof (*tr));
1045  tr->num_segments = 0;
1046  tr->localsid_index = ls0 - sm->localsids;
1047 
1048  if (ip0 == vlib_buffer_get_current (b0))
1049  {
1050  clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
1051  sizeof (tr->src.as_u8));
1053  sizeof (tr->out_dst.as_u8));
1054  if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE
1055  && sr0->type == ROUTING_HEADER_TYPE_SR)
1056  {
1057  clib_memcpy (tr->sr, sr0->segments, sr0->length * 8);
1058  tr->num_segments =
1059  sr0->length * 8 / sizeof (ip6_address_t);
1060  tr->segments_left = sr0->segments_left;
1061  }
1062  }
1063  else
1064  tr->num_segments = 0xFF;
1065  }
1066 
1067  /* Increase the counters */
1069  (((next0 ==
1070  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1071  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
1072  1, vlib_buffer_length_in_chain (vm, b0));
1073 
1074  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1075  n_left_to_next, bi0, next0);
1076  }
1077  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1078  }
1079  return from_frame->n_vectors;
1080 }
1081 
1082 /* *INDENT-OFF* */
1084  .function = sr_localsid_d_fn,
1085  .name = "sr-localsid-d",
1086  .vector_size = sizeof (u32),
1087  .format_trace = format_sr_localsid_trace,
1088  .type = VLIB_NODE_TYPE_INTERNAL,
1089  .n_errors = SR_LOCALSID_N_ERROR,
1090  .error_strings = sr_localsid_error_strings,
1091  .n_next_nodes = SR_LOCALSID_N_NEXT,
1092  .next_nodes = {
1093 #define _(s,n) [SR_LOCALSID_NEXT_##s] = n,
1095 #undef _
1096  },
1097 };
1098 /* *INDENT-ON* */
1099 
1100 /**
1101  * @brief SR LocalSID graph node. Supports all default SR Endpoint variants
1102  */
1103 static uword
1105  vlib_frame_t * from_frame)
1106 {
1107  u32 n_left_from, next_index, *from, *to_next;
1108  ip6_sr_main_t *sm = &sr_main;
1109  from = vlib_frame_vector_args (from_frame);
1110  n_left_from = from_frame->n_vectors;
1111  next_index = node->cached_next_index;
1112  u32 thread_index = vlib_get_thread_index ();
1113 
1114  while (n_left_from > 0)
1115  {
1116  u32 n_left_to_next;
1117  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1118 
1119  /* Quad - Loop */
1120  while (n_left_from >= 8 && n_left_to_next >= 4)
1121  {
1122  u32 bi0, bi1, bi2, bi3;
1123  vlib_buffer_t *b0, *b1, *b2, *b3;
1124  ip6_header_t *ip0, *ip1, *ip2, *ip3;
1125  ip6_sr_header_t *sr0, *sr1, *sr2, *sr3;
1126  ip6_ext_header_t *prev0, *prev1, *prev2, *prev3;
1127  u32 next0, next1, next2, next3;
1128  next0 = next1 = next2 = next3 = SR_LOCALSID_NEXT_IP6_LOOKUP;
1129  ip6_sr_localsid_t *ls0, *ls1, *ls2, *ls3;
1130 
1131  /* Prefetch next iteration. */
1132  {
1133  vlib_buffer_t *p4, *p5, *p6, *p7;
1134 
1135  p4 = vlib_get_buffer (vm, from[4]);
1136  p5 = vlib_get_buffer (vm, from[5]);
1137  p6 = vlib_get_buffer (vm, from[6]);
1138  p7 = vlib_get_buffer (vm, from[7]);
1139 
1140  /* Prefetch the buffer header and packet for the N+2 loop iteration */
1141  vlib_prefetch_buffer_header (p4, LOAD);
1142  vlib_prefetch_buffer_header (p5, LOAD);
1143  vlib_prefetch_buffer_header (p6, LOAD);
1144  vlib_prefetch_buffer_header (p7, LOAD);
1145 
1150  }
1151 
1152  to_next[0] = bi0 = from[0];
1153  to_next[1] = bi1 = from[1];
1154  to_next[2] = bi2 = from[2];
1155  to_next[3] = bi3 = from[3];
1156  from += 4;
1157  to_next += 4;
1158  n_left_from -= 4;
1159  n_left_to_next -= 4;
1160 
1161  b0 = vlib_get_buffer (vm, bi0);
1162  b1 = vlib_get_buffer (vm, bi1);
1163  b2 = vlib_get_buffer (vm, bi2);
1164  b3 = vlib_get_buffer (vm, bi3);
1165 
1166  ip0 = vlib_buffer_get_current (b0);
1167  ip1 = vlib_buffer_get_current (b1);
1168  ip2 = vlib_buffer_get_current (b2);
1169  ip3 = vlib_buffer_get_current (b3);
1170 
1171  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
1172  ip6_ext_header_find_t (ip1, prev1, sr1, IP_PROTOCOL_IPV6_ROUTE);
1173  ip6_ext_header_find_t (ip2, prev2, sr2, IP_PROTOCOL_IPV6_ROUTE);
1174  ip6_ext_header_find_t (ip3, prev3, sr3, IP_PROTOCOL_IPV6_ROUTE);
1175 
1176  ls0 =
1178  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1179  ls1 =
1181  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1182  ls2 =
1184  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1185  ls3 =
1187  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1188 
1189  end_srh_processing (node, b0, ip0, sr0, ls0, &next0, ls0->end_psp,
1190  prev0);
1191  end_srh_processing (node, b1, ip1, sr1, ls1, &next1, ls1->end_psp,
1192  prev1);
1193  end_srh_processing (node, b2, ip2, sr2, ls2, &next2, ls2->end_psp,
1194  prev2);
1195  end_srh_processing (node, b3, ip3, sr3, ls3, &next3, ls3->end_psp,
1196  prev3);
1197 
1198  //TODO: proper trace.
1199 
1201  (((next0 ==
1202  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1203  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
1204  1, vlib_buffer_length_in_chain (vm, b0));
1205 
1207  (((next1 ==
1208  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1209  &(sm->sr_ls_valid_counters)), thread_index, ls1 - sm->localsids,
1210  1, vlib_buffer_length_in_chain (vm, b1));
1211 
1213  (((next2 ==
1214  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1215  &(sm->sr_ls_valid_counters)), thread_index, ls2 - sm->localsids,
1216  1, vlib_buffer_length_in_chain (vm, b2));
1217 
1219  (((next3 ==
1220  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1221  &(sm->sr_ls_valid_counters)), thread_index, ls3 - sm->localsids,
1222  1, vlib_buffer_length_in_chain (vm, b3));
1223 
1224  vlib_validate_buffer_enqueue_x4 (vm, node, next_index, to_next,
1225  n_left_to_next, bi0, bi1, bi2, bi3,
1226  next0, next1, next2, next3);
1227  }
1228 
1229  /* Single loop for potentially the last three packets */
1230  while (n_left_from > 0 && n_left_to_next > 0)
1231  {
1232  u32 bi0;
1233  vlib_buffer_t *b0;
1234  ip6_header_t *ip0 = 0;
1235  ip6_ext_header_t *prev0;
1236  ip6_sr_header_t *sr0;
1237  u32 next0 = SR_LOCALSID_NEXT_IP6_LOOKUP;
1238  ip6_sr_localsid_t *ls0;
1239 
1240  bi0 = from[0];
1241  to_next[0] = bi0;
1242  from += 1;
1243  to_next += 1;
1244  n_left_from -= 1;
1245  n_left_to_next -= 1;
1246 
1247  b0 = vlib_get_buffer (vm, bi0);
1248  ip0 = vlib_buffer_get_current (b0);
1249  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
1250 
1251  /* Lookup the SR End behavior based on IP DA (adj) */
1252  ls0 =
1254  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1255 
1256  /* SRH processing */
1257  end_srh_processing (node, b0, ip0, sr0, ls0, &next0, ls0->end_psp,
1258  prev0);
1259 
1261  {
1262  sr_localsid_trace_t *tr =
1263  vlib_add_trace (vm, node, b0, sizeof (*tr));
1264  tr->num_segments = 0;
1265  tr->localsid_index = ls0 - sm->localsids;
1266 
1267  if (ip0 == vlib_buffer_get_current (b0))
1268  {
1269  clib_memcpy (tr->src.as_u8, ip0->src_address.as_u8,
1270  sizeof (tr->src.as_u8));
1272  sizeof (tr->out_dst.as_u8));
1273  if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE
1274  && sr0->type == ROUTING_HEADER_TYPE_SR)
1275  {
1276  clib_memcpy (tr->sr, sr0->segments, sr0->length * 8);
1277  tr->num_segments =
1278  sr0->length * 8 / sizeof (ip6_address_t);
1279  tr->segments_left = sr0->segments_left;
1280  }
1281  }
1282  else
1283  {
1284  tr->num_segments = 0xFF;
1285  }
1286  }
1287 
1289  (((next0 ==
1290  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1291  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
1292  1, vlib_buffer_length_in_chain (vm, b0));
1293 
1294  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1295  n_left_to_next, bi0, next0);
1296  }
1297  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1298  }
1299  return from_frame->n_vectors;
1300 }
1301 
1302 /* *INDENT-OFF* */
1304  .function = sr_localsid_fn,
1305  .name = "sr-localsid",
1306  .vector_size = sizeof (u32),
1307  .format_trace = format_sr_localsid_trace,
1308  .type = VLIB_NODE_TYPE_INTERNAL,
1309  .n_errors = SR_LOCALSID_N_ERROR,
1310  .error_strings = sr_localsid_error_strings,
1311  .n_next_nodes = SR_LOCALSID_N_NEXT,
1312  .next_nodes = {
1313 #define _(s,n) [SR_LOCALSID_NEXT_##s] = n,
1315 #undef _
1316  },
1317 };
1318 /* *INDENT-ON* */
1319 
1320 static u8 *
1321 format_sr_dpo (u8 * s, va_list * args)
1322 {
1323  index_t index = va_arg (*args, index_t);
1324  CLIB_UNUSED (u32 indent) = va_arg (*args, u32);
1325 
1326  return (format (s, "SR: localsid_index:[%d]", index));
1327 }
1328 
1329 const static dpo_vft_t sr_loc_vft = {
1330  .dv_lock = sr_dpo_lock,
1331  .dv_unlock = sr_dpo_unlock,
1332  .dv_format = format_sr_dpo,
1333 };
1334 
1335 const static char *const sr_loc_ip6_nodes[] = {
1336  "sr-localsid",
1337  NULL,
1338 };
1339 
1340 const static char *const *const sr_loc_nodes[DPO_PROTO_NUM] = {
1342 };
1343 
1344 const static char *const sr_loc_d_ip6_nodes[] = {
1345  "sr-localsid-d",
1346  NULL,
1347 };
1348 
1349 const static char *const *const sr_loc_d_nodes[DPO_PROTO_NUM] = {
1351 };
1352 
1353 
1354 /*************************** SR LocalSID plugins ******************************/
1355 /**
1356  * @brief SR LocalSID plugin registry
1357  */
1358 int
1360  u8 * keyword_str, u8 * def_str,
1361  u8 * params_str, dpo_type_t * dpo,
1362  format_function_t * ls_format,
1363  unformat_function_t * ls_unformat,
1364  sr_plugin_callback_t * creation_fn,
1365  sr_plugin_callback_t * removal_fn)
1366 {
1367  ip6_sr_main_t *sm = &sr_main;
1368  uword *p;
1369 
1371 
1372  /* Did this function exist? If so update it */
1373  p = hash_get_mem (sm->plugin_functions_by_key, fn_name);
1374  if (p)
1375  {
1376  plugin = pool_elt_at_index (sm->plugin_functions, p[0]);
1377  }
1378  /* Else create a new one and set hash key */
1379  else
1380  {
1381  pool_get (sm->plugin_functions, plugin);
1382  hash_set_mem (sm->plugin_functions_by_key, fn_name,
1383  plugin - sm->plugin_functions);
1384  }
1385 
1386  memset (plugin, 0, sizeof (*plugin));
1387 
1388  plugin->sr_localsid_function_number = (plugin - sm->plugin_functions);
1390  plugin->ls_format = ls_format;
1391  plugin->ls_unformat = ls_unformat;
1392  plugin->creation = creation_fn;
1393  plugin->removal = removal_fn;
1394  clib_memcpy (&plugin->dpo, dpo, sizeof (dpo_type_t));
1395  plugin->function_name = format (0, "%s%c", fn_name, 0);
1396  plugin->keyword_str = format (0, "%s%c", keyword_str, 0);
1397  plugin->def_str = format (0, "%s%c", def_str, 0);
1398  plugin->params_str = format (0, "%s%c", params_str, 0);
1399 
1400  return plugin->sr_localsid_function_number;
1401 }
1402 
1403 /**
1404  * @brief CLI function to 'show' all available SR LocalSID behaviors
1405  */
1406 static clib_error_t *
1408  unformat_input_t * input,
1409  vlib_cli_command_t * cmd)
1410 {
1411  ip6_sr_main_t *sm = &sr_main;
1413  sr_localsid_fn_registration_t **plugins_vec = 0;
1414  int i;
1415 
1416  vlib_cli_output (vm,
1417  "SR LocalSIDs behaviors:\n-----------------------\n\n");
1418 
1419  /* *INDENT-OFF* */
1420  pool_foreach (plugin, sm->plugin_functions,
1421  ({ vec_add1 (plugins_vec, plugin); }));
1422  /* *INDENT-ON* */
1423 
1424  /* Print static behaviors */
1425  vlib_cli_output (vm, "Default behaviors:\n"
1426  "\tEnd\t-> Endpoint.\n"
1427  "\tEnd.X\t-> Endpoint with Layer-3 cross-connect.\n"
1428  "\t\tParameters: '<iface> <ip6_next_hop>'\n"
1429  "\tEnd.T\t-> Endpoint with specific IPv6 table lookup.\n"
1430  "\t\tParameters: '<fib_table>'\n"
1431  "\tEnd.DX2\t-> Endpoint with decapsulation and Layer-2 cross-connect.\n"
1432  "\t\tParameters: '<iface>'\n"
1433  "\tEnd.DX6\t-> Endpoint with decapsulation and IPv6 cross-connect.\n"
1434  "\t\tParameters: '<iface> <ip6_next_hop>'\n"
1435  "\tEnd.DX4\t-> Endpoint with decapsulation and IPv4 cross-connect.\n"
1436  "\t\tParameters: '<iface> <ip4_next_hop>'\n"
1437  "\tEnd.DT6\t-> Endpoint with decapsulation and specific IPv6 table lookup.\n"
1438  "\t\tParameters: '<ip6_fib_table>'\n"
1439  "\tEnd.DT4\t-> Endpoint with decapsulation and specific IPv4 table lookup.\n"
1440  "\t\tParameters: '<ip4_fib_table>'\n");
1441  vlib_cli_output (vm, "Plugin behaviors:\n");
1442  for (i = 0; i < vec_len (plugins_vec); i++)
1443  {
1444  plugin = plugins_vec[i];
1445  vlib_cli_output (vm, "\t%s\t-> %s.\n", plugin->keyword_str,
1446  plugin->def_str);
1447  vlib_cli_output (vm, "\t\tParameters: '%s'\n", plugin->params_str);
1448  }
1449  return 0;
1450 }
1451 
1452 /* *INDENT-OFF* */
1453 VLIB_CLI_COMMAND (show_sr_localsid_behaviors_command, static) = {
1454  .path = "show sr localsids behaviors",
1455  .short_help = "show sr localsids behaviors",
1457 };
1458 /* *INDENT-ON* */
1459 
1460 /**
1461  * @brief SR LocalSID initialization
1462  */
1463 clib_error_t *
1465 {
1466  /* Init memory for function keys */
1467  ip6_sr_main_t *sm = &sr_main;
1468  mhash_init (&sm->sr_localsids_index_hash, sizeof (uword),
1469  sizeof (ip6_address_t));
1470  /* Init SR behaviors DPO type */
1472  /* Init SR behaviors DPO type */
1474  dpo_register_new_type (&sr_loc_vft, sr_loc_d_nodes);
1475  /* Init memory for localsid plugins */
1476  sm->plugin_functions_by_key = hash_create_string (0, sizeof (uword));
1477  return 0;
1478 }
1479 
1481 /*
1482 * fd.io coding-style-patch-verification: ON
1483 *
1484 * Local Variables:
1485 * eval: (c-set-style "gnu")
1486 * End:
1487 */
u8 * function_name
Function name.
Definition: sr.h:136
sr_localsid_error_t
Definition: sr_localsid.c:606
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:169
ip6_sr_main_t sr_main
Definition: sr.c:31
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:341
u32 vlan_index
VLAN tag (not an index)
Definition: sr.h:118
uword( unformat_function_t)(unformat_input_t *input, va_list *args)
Definition: format.h:231
u32 nh_adj
Next_adj for xconnect usage only.
Definition: sr.h:122
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define CLIB_UNUSED(x)
Definition: clib.h:79
A virtual function table regisitered for a DPO type.
Definition: dpo.h:336
static const char *const sr_loc_ip6_nodes[]
Definition: sr_localsid.c:1335
void vlib_validate_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
validate a combined counter
Definition: counter.c:89
fib_node_index_t fib_table_lookup_exact_match(u32 fib_index, const fib_prefix_t *prefix)
Perfom an exact match in the non-forwarding table.
Definition: fib_table.c:95
#define SR_BEHAVIOR_END
Definition: sr.h:37
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:211
SR LocalSID.
Definition: sr.h:102
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
#define PREDICT_TRUE(x)
Definition: clib.h:98
void sr_dpo_unlock(dpo_id_t *dpo)
no-op unlock function.
Definition: sr.c:47
int sr_cli_localsid(char is_del, ip6_address_t *localsid_addr, char end_psp, u8 behavior, u32 sw_if_index, u32 vlan_index, u32 fib_table, ip46_address_t *nh_addr, void *ls_plugin_mem)
SR localsid add/del.
Definition: sr_localsid.c:66
u8 as_u8[16]
Definition: ip6_packet.h:48
u64 as_u64[2]
Definition: ip6_packet.h:51
unsigned char params_str[32]
#define NULL
Definition: clib.h:55
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:353
format_function_t * ls_format
LocalSID format function.
Definition: sr.h:146
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
ip6_address_t out_dst
Definition: sr_localsid.c:591
int( sr_plugin_callback_t)(ip6_sr_localsid_t *localsid)
Definition: sr.h:127
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
static_always_inline void end_decaps_srh_processing(vlib_node_runtime_t *node, vlib_buffer_t *b0, ip6_header_t *ip0, ip6_sr_header_t *sr0, ip6_sr_localsid_t *ls0, u32 *next0)
Definition: sr_localsid.c:804
#define vlib_validate_buffer_enqueue_x4(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, bi2, bi3, next0, next1, next2, next3)
Finish enqueueing four buffers forward in the graph.
Definition: buffer_node.h:138
Combined counter to hold both packets and byte differences.
Definition: counter.h:139
static void * ip6_ext_next_header(ip6_ext_header_t *ext_hdr)
Definition: ip6_packet.h:471
#define hash_set_mem(h, key, value)
Definition: hash.h:274
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
u16 behavior
Behavior associated to this localsid.
Definition: sr.h:108
unformat_function_t unformat_vnet_sw_interface
#define ROUTING_HEADER_TYPE_SR
Definition: sr_packet.h:116
u8 *( format_function_t)(u8 *s, va_list *args)
Definition: format.h:48
unsigned char keyword_str[32]
#define SR_BEHAVIOR_D_FIRST
Definition: sr.h:40
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:419
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:100
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:200
vlib_combined_counter_main_t sr_ls_invalid_counters
Definition: sr.h:229
vlib_combined_counter_main_t sr_ls_valid_counters
Definition: sr.h:228
ip6_address_t src_address
Definition: ip6_packet.h:341
static char * sr_localsid_error_strings[]
Definition: sr_localsid.c:614
static clib_error_t * show_sr_localsid_behaviors_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
CLI function to &#39;show&#39; all available SR LocalSID behaviors.
Definition: sr_localsid.c:1407
format_function_t format_vnet_sw_if_index_name
#define SR_BEHAVIOR_DX4
Definition: sr.h:43
#define SR_BEHAVIOR_DT4
Definition: sr.h:45
static const char *const sr_loc_d_ip6_nodes[]
Definition: sr_localsid.c:1344
static const char *const *const sr_loc_nodes[DPO_PROTO_NUM]
Definition: sr_localsid.c:1340
format_function_t format_ip4_address
Definition: format.h:79
#define static_always_inline
Definition: clib.h:85
static clib_error_t * sr_cli_localsid_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
SR LocalSID CLI function.
Definition: sr_localsid.c:263
void vlib_clear_combined_counters(vlib_combined_counter_main_t *cm)
Clear a collection of combined counters.
Definition: counter.c:60
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:376
unformat_function_t unformat_ip4_address
Definition: format.h:76
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:164
Aggregrate type for a prefix.
Definition: fib_types.h:160
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned long u64
Definition: types.h:89
void adj_unlock(adj_index_t adj_index)
Release a reference counting lock on the adjacency.
Definition: adj.c:229
u32 fib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1025
#define SR_BEHAVIOR_T
Definition: sr.h:39
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:272
ip6_address_t src
Definition: sr_localsid.c:591
#define hash_create_string(elts, value_bytes)
Definition: hash.h:652
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:152
Definition: fib_entry.h:237
#define ADJ_INDEX_INVALID
Invalid ADJ index - used when no adj is known likewise blazoned capitals INVALID speak volumes where ...
Definition: adj_types.h:36
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:397
static void vlib_zero_combined_counter(vlib_combined_counter_main_t *cm, u32 index)
Clear a combined counter Clears the set of per-thread counters.
Definition: counter.h:276
counter_t packets
packet counter
Definition: counter.h:141
vlib_node_registration_t sr_localsid_d_node
(constructor) VLIB_REGISTER_NODE (sr_localsid_d_node)
Definition: sr_localsid.c:1083
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:183
#define SR_BEHAVIOR_LAST
Definition: sr.h:46
u8 * format_sr_localsid_trace(u8 *s, va_list *args)
SR LocalSID graph node trace function.
Definition: sr_localsid.c:642
struct _unformat_input_t unformat_input_t
#define SR_BEHAVIOR_DX2
Definition: sr.h:41
SR LocalSID behavior registration.
Definition: sr.h:132
unsigned char def_str[64]
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:188
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:241
char end_psp
Combined with End.PSP?
Definition: sr.h:106
static dpo_type_t sr_localsid_d_dpo_type
Definition: sr_localsid.c:47
#define PREDICT_FALSE(x)
Definition: clib.h:97
void sr_dpo_lock(dpo_id_t *dpo)
no-op lock function.
Definition: sr.c:38
static u8 * format_sr_dpo(u8 *s, va_list *args)
Definition: sr_localsid.c:1321
static_always_inline void end_srh_processing(vlib_node_runtime_t *node, vlib_buffer_t *b0, ip6_header_t *ip0, ip6_sr_header_t *sr0, ip6_sr_localsid_t *ls0, u32 *next0, u8 psp, ip6_ext_header_t *prev0)
Function doing End processing.
Definition: sr_localsid.c:707
#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
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
Definition: mhash.h:117
#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:366
#define SR_BEHAVIOR_DT6
Definition: sr.h:44
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:113
static uword sr_localsid_d_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
SR LocalSID graph node.
Definition: sr_localsid.c:888
#define ip6_ext_header_len(p)
Definition: ip6_packet.h:467
unformat_function_t unformat_ip6_address
Definition: format.h:94
ip6_sr_localsid_t * localsids
Definition: sr.h:204
The fine-grained event logger allows lightweight, thread-safe event logging at minimum cost...
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
void mhash_init(mhash_t *h, uword n_value_bytes, uword n_key_bytes)
Definition: mhash.c:168
static clib_error_t * show_sr_localsid_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
CLI function to &#39;show&#39; all SR LocalSIDs on console.
Definition: sr_localsid.c:441
u16 n_vectors
Definition: node.h:345
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:185
format_function_t format_ip6_address
Definition: format.h:95
static void vlib_get_combined_counter(const vlib_combined_counter_main_t *cm, u32 index, vlib_counter_t *result)
Get the value of a combined counter, never called in the speed path Scrapes the entire set of per-thr...
Definition: counter.h:250
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
#define SR_BEHAVIOR_X
Definition: sr.h:38
static clib_error_t * clear_sr_localsid_counters_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Function to &#39;clear&#39; ALL SR localsid counters.
Definition: sr_localsid.c:564
void fib_table_entry_delete(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Delete a FIB entry.
Definition: fib_table.c:835
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:85
#define clib_memcpy(a, b, c)
Definition: string.h:69
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
unformat_function_t * ls_unformat
LocalSID unformat function.
Definition: sr.h:148
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
int sr_localsid_register_function(vlib_main_t *vm, u8 *fn_name, u8 *keyword_str, u8 *def_str, u8 *params_str, dpo_type_t *dpo, format_function_t *ls_format, unformat_function_t *ls_unformat, sr_plugin_callback_t *creation_fn, sr_plugin_callback_t *removal_fn)
SR LocalSID plugin registry.
Definition: sr_localsid.c:1359
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:159
static u8 ip6_ext_hdr(u8 nexthdr)
Definition: ip6_packet.h:455
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
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:290
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:460
unsigned int u32
Definition: types.h:88
dpo_type_t dpo
DPO type registration.
Definition: sr.h:144
u8 * def_str
Behavior definition (i.e.
Definition: sr.h:140
static uword * mhash_get(mhash_t *h, const void *key)
Definition: mhash.h:110
void * plugin_mem
Memory to be used by the plugin callback functions.
Definition: sr.h:124
static const char *const *const sr_loc_d_nodes[DPO_PROTO_NUM]
Definition: sr_localsid.c:1349
u32 vrf_index
vrf only
Definition: sr.h:113
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:201
u32 fib_table
FIB table where localsid is registered.
Definition: sr.h:116
SR localsid node trace.
Definition: sr_localsid.c:588
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
u16 sr_localsid_function_number
SR LocalSID plugin function (>SR_BEHAVIOR_LAST)
Definition: sr.h:134
#define ip46_address_reset(ip46)
Definition: ip6_packet.h:79
counter_t bytes
byte counter
Definition: counter.h:142
Definition: defs.h:47
unsigned short u16
Definition: types.h:57
#define DPO_PROTO_NUM
Definition: dpo.h:73
SRv6 and SR-MPLS.
Definition: fib_entry.h:54
u16 payload_length
Definition: ip6_packet.h:332
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:29
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
ip6_address_t segments[0]
Definition: sr_packet.h:148
sr_plugin_callback_t * creation
Function within plugin that will be called after localsid creation.
Definition: sr.h:150
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:269
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:179
clib_error_t * sr_localsids_init(vlib_main_t *vm)
SR LocalSID initialization.
Definition: sr_localsid.c:1464
#define hash_get_mem(h, key)
Definition: hash.h:268
#define vnet_buffer(b)
Definition: buffer.h:304
vlib_node_registration_t sr_localsid_node
(constructor) VLIB_REGISTER_NODE (sr_localsid_node)
Definition: sr_localsid.c:1303
Segment Routing main datastructure.
Definition: sr.h:189
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:144
u8 data[0]
Packet data.
Definition: buffer.h:152
#define SR_BEHAVIOR_DX6
Definition: sr.h:42
adj_index_t adj_nbr_add_or_lock(fib_protocol_t nh_proto, vnet_link_t link_type, const ip46_address_t *nh_addr, u32 sw_if_index)
Neighbour Adjacency sub-type.
Definition: adj_nbr.c:214
void dpo_reset(dpo_id_t *dpo)
reset a DPO ID The DPO will be unlocked.
Definition: dpo.c:205
#define vec_foreach(var, vec)
Vector iterator.
static uword sr_localsid_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
SR LocalSID graph node.
Definition: sr_localsid.c:1104
#define ip6_ext_header_find_t(i, p, m, t)
Definition: ip6_packet.h:480
#define foreach_sr_localsid_next
Definition: sr_localsid.c:620
ip46_address_t next_hop
Next_hop for xconnect usage only.
Definition: sr.h:120
mhash_t sr_localsids_index_hash
Definition: sr.h:207
u8 * params_str
Behavior parameters (i.e.
Definition: sr.h:142
#define foreach_sr_localsid_error
Definition: sr_localsid.c:598
u32 sw_if_index
xconnect only
Definition: sr.h:112
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
sr_plugin_callback_t * removal
Function within plugin that will be called before localsid removal.
Definition: sr.h:152
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:74
ip6_address_t localsid
LocalSID IPv6 address.
Definition: sr.h:104
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
static dpo_type_t sr_localsid_dpo_type
Dynamically added SR localsid DPO type.
Definition: sr_localsid.c:46
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
u8 * keyword_str
Behavior keyword (i.e.
Definition: sr.h:138
sr_localsid_fn_registration_t * plugin_functions
Definition: sr.h:222
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
sr_localsid_next_t
Definition: sr_localsid.c:628
ip6_address_t dst_address
Definition: ip6_packet.h:341
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
Segment Routing data structures definitions.
uword * plugin_functions_by_key
Definition: sr.h:225