FD.io VPP  v18.01.2-1-g9b554f3
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 {
592  u8 sr[256];
596 
597 #define foreach_sr_localsid_error \
598 _(NO_INNER_HEADER, "(SR-Error) No inner IP header") \
599 _(NO_MORE_SEGMENTS, "(SR-Error) No more segments") \
600 _(NO_SRH, "(SR-Error) No SR header") \
601 _(NO_PSP, "(SR-Error) PSP Not available (segments left > 0)") \
602 _(NOT_LS, "(SR-Error) Decaps not available (segments left > 0)") \
603 _(L2, "(SR-Error) SRv6 decapsulated a L2 frame without dest")
604 
605 typedef enum
606 {
607 #define _(sym,str) SR_LOCALSID_ERROR_##sym,
609 #undef _
612 
613 static char *sr_localsid_error_strings[] = {
614 #define _(sym,string) string,
616 #undef _
617 };
618 
619 #define foreach_sr_localsid_next \
620 _(ERROR, "error-drop") \
621 _(IP6_LOOKUP, "ip6-lookup") \
622 _(IP4_LOOKUP, "ip4-lookup") \
623 _(IP6_REWRITE, "ip6-rewrite") \
624 _(IP4_REWRITE, "ip4-rewrite") \
625 _(INTERFACE_OUTPUT, "interface-output")
626 
627 typedef enum
628 {
629 #define _(s,n) SR_LOCALSID_NEXT_##s,
631 #undef _
634 
635 /**
636  * @brief SR LocalSID graph node trace function
637  *
638  * @see sr_localsid
639  */
640 u8 *
641 format_sr_localsid_trace (u8 * s, va_list * args)
642 {
643  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
644  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
645  sr_localsid_trace_t *t = va_arg (*args, sr_localsid_trace_t *);
646 
647  s =
648  format (s, "SR-LOCALSID:\n\tLocalsid: %U\n", format_ip6_address,
649  &t->localsid);
650  switch (t->behavior)
651  {
652  case SR_BEHAVIOR_END:
653  s = format (s, "\tBehavior: End\n");
654  break;
655  case SR_BEHAVIOR_DX6:
656  s = format (s, "\tBehavior: Decapsulation with IPv6 L3 xconnect\n");
657  break;
658  case SR_BEHAVIOR_DX4:
659  s = format (s, "\tBehavior: Decapsulation with IPv4 L3 xconnect\n");
660  break;
661  case SR_BEHAVIOR_X:
662  s = format (s, "\tBehavior: IPv6 L3 xconnect\n");
663  break;
664  case SR_BEHAVIOR_T:
665  s = format (s, "\tBehavior: IPv6 specific table lookup\n");
666  break;
667  case SR_BEHAVIOR_DT6:
668  s = format (s, "\tBehavior: Decapsulation with IPv6 Table lookup\n");
669  break;
670  case SR_BEHAVIOR_DT4:
671  s = format (s, "\tBehavior: Decapsulation with IPv4 Table lookup\n");
672  break;
673  case SR_BEHAVIOR_DX2:
674  s = format (s, "\tBehavior: Decapsulation with L2 xconnect\n");
675  break;
676  default:
677  s = format (s, "\tBehavior: defined in plugin\n"); //TODO
678  break;
679  }
680  if (t->num_segments != 0xFF)
681  {
682  if (t->num_segments > 0)
683  {
684  s = format (s, "\tSegments left: %d\n", t->segments_left);
685  s = format (s, "\tSID list: [in ietf order]");
686  int i = 0;
687  for (i = 0; i < t->num_segments; i++)
688  {
689  s = format (s, "\n\t-> %U", format_ip6_address,
690  (ip6_address_t *) & t->sr[i *
691  sizeof (ip6_address_t)]);
692  }
693  }
694  }
695  return s;
696 }
697 
698 /**
699  * @brief Function doing End processing.
700  */
703  vlib_buffer_t * b0,
704  ip6_header_t * ip0,
705  ip6_sr_header_t * sr0,
706  ip6_sr_localsid_t * ls0,
707  u32 * next0, u8 psp, ip6_ext_header_t * prev0)
708 {
709  ip6_address_t *new_dst0;
710 
712  {
713  if (sr0->segments_left == 1 && psp)
714  {
715  u32 new_l0, sr_len;
716  u64 *copy_dst0, *copy_src0;
717  u32 copy_len_u64s0 = 0;
718 
719  ip0->dst_address.as_u64[0] = sr0->segments->as_u64[0];
720  ip0->dst_address.as_u64[1] = sr0->segments->as_u64[1];
721 
722  /* Remove the SRH taking care of the rest of IPv6 ext header */
723  if (prev0)
724  prev0->next_hdr = sr0->protocol;
725  else
726  ip0->protocol = sr0->protocol;
727 
728  sr_len = ip6_ext_header_len (sr0);
729  vlib_buffer_advance (b0, sr_len);
730  new_l0 = clib_net_to_host_u16 (ip0->payload_length) - sr_len;
731  ip0->payload_length = clib_host_to_net_u16 (new_l0);
732  copy_src0 = (u64 *) ip0;
733  copy_dst0 = copy_src0 + (sr0->length + 1);
734  /* number of 8 octet units to copy
735  * By default in absence of extension headers it is equal to length of ip6 header
736  * With extension headers it number of 8 octet units of ext headers preceding
737  * SR header
738  */
739  copy_len_u64s0 =
740  (((u8 *) sr0 - (u8 *) ip0) - sizeof (ip6_header_t)) >> 3;
741  copy_dst0[4 + copy_len_u64s0] = copy_src0[4 + copy_len_u64s0];
742  copy_dst0[3 + copy_len_u64s0] = copy_src0[3 + copy_len_u64s0];
743  copy_dst0[2 + copy_len_u64s0] = copy_src0[2 + copy_len_u64s0];
744  copy_dst0[1 + copy_len_u64s0] = copy_src0[1 + copy_len_u64s0];
745  copy_dst0[0 + copy_len_u64s0] = copy_src0[0 + copy_len_u64s0];
746 
747  int i;
748  for (i = copy_len_u64s0 - 1; i >= 0; i--)
749  {
750  copy_dst0[i] = copy_src0[i];
751  }
752 
753  if (ls0->behavior == SR_BEHAVIOR_X)
754  {
755  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
756  *next0 = SR_LOCALSID_NEXT_IP6_REWRITE;
757  }
758  else if (ls0->behavior == SR_BEHAVIOR_T)
759  {
760  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
761  }
762  }
763  else if (PREDICT_TRUE (sr0->segments_left > 0))
764  {
765  sr0->segments_left -= 1;
766  new_dst0 = (ip6_address_t *) (sr0->segments);
767  new_dst0 += sr0->segments_left;
768  ip0->dst_address.as_u64[0] = new_dst0->as_u64[0];
769  ip0->dst_address.as_u64[1] = new_dst0->as_u64[1];
770 
771  if (ls0->behavior == SR_BEHAVIOR_X)
772  {
773  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
774  *next0 = SR_LOCALSID_NEXT_IP6_REWRITE;
775  }
776  else if (ls0->behavior == SR_BEHAVIOR_T)
777  {
778  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
779  }
780  }
781  else
782  {
783  *next0 = SR_LOCALSID_NEXT_ERROR;
784  b0->error = node->errors[SR_LOCALSID_ERROR_NO_MORE_SEGMENTS];
785  }
786  }
787  else
788  {
789  /* Error. Routing header of type != SR */
790  *next0 = SR_LOCALSID_NEXT_ERROR;
791  b0->error = node->errors[SR_LOCALSID_ERROR_NO_SRH];
792  }
793 }
794 
795 /*
796  * @brief Function doing SRH processing for D* variants
797  */
800  vlib_buffer_t * b0,
801  ip6_header_t * ip0,
802  ip6_sr_header_t * sr0,
803  ip6_sr_localsid_t * ls0, u32 * next0)
804 {
805  /* Compute the size of the IPv6 header with all Ext. headers */
806  u8 next_proto;
807  ip6_ext_header_t *next_ext_header;
808  u16 total_size = 0;
809 
810  next_proto = ip0->protocol;
811  next_ext_header = (void *) (ip0 + 1);
812  total_size = sizeof (ip6_header_t);
813  while (ip6_ext_hdr (next_proto))
814  {
815  total_size += ip6_ext_header_len (next_ext_header);
816  next_proto = next_ext_header->next_hdr;
817  next_ext_header = ip6_ext_next_header (next_ext_header);
818  }
819 
820  /* Ensure this is the last segment. Otherwise drop. */
821  if (sr0 && sr0->segments_left != 0)
822  {
823  *next0 = SR_LOCALSID_NEXT_ERROR;
824  b0->error = node->errors[SR_LOCALSID_ERROR_NOT_LS];
825  return;
826  }
827 
828  switch (next_proto)
829  {
830  case IP_PROTOCOL_IPV6:
831  /* Encap-End IPv6. Pop outer IPv6 header. */
832  if (ls0->behavior == SR_BEHAVIOR_DX6)
833  {
834  vlib_buffer_advance (b0, total_size);
835  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
836  *next0 = SR_LOCALSID_NEXT_IP6_REWRITE;
837  return;
838  }
839  else if (ls0->behavior == SR_BEHAVIOR_DT6)
840  {
841  vlib_buffer_advance (b0, total_size);
842  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
843  return;
844  }
845  break;
846  case IP_PROTOCOL_IP_IN_IP:
847  /* Encap-End IPv4. Pop outer IPv6 header */
848  if (ls0->behavior == SR_BEHAVIOR_DX4)
849  {
850  vlib_buffer_advance (b0, total_size);
851  vnet_buffer (b0)->ip.adj_index[VLIB_TX] = ls0->nh_adj;
852  *next0 = SR_LOCALSID_NEXT_IP4_REWRITE;
853  return;
854  }
855  else if (ls0->behavior == SR_BEHAVIOR_DT4)
856  {
857  vlib_buffer_advance (b0, total_size);
858  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->vrf_index;
859  *next0 = SR_LOCALSID_NEXT_IP4_LOOKUP;
860  return;
861  }
862  break;
863  case IP_PROTOCOL_IP6_NONXT:
864  /* L2 encaps */
865  if (ls0->behavior == SR_BEHAVIOR_DX2)
866  {
867  vlib_buffer_advance (b0, total_size);
868  vnet_buffer (b0)->sw_if_index[VLIB_TX] = ls0->sw_if_index;
869  *next0 = SR_LOCALSID_NEXT_INTERFACE_OUTPUT;
870  return;
871  }
872  break;
873  }
874  *next0 = SR_LOCALSID_NEXT_ERROR;
875  b0->error = node->errors[SR_LOCALSID_ERROR_NO_INNER_HEADER];
876  return;
877 }
878 
879 /**
880  * @brief SR LocalSID graph node. Supports all default SR Endpoint variants with decaps
881  */
882 static uword
884  vlib_frame_t * from_frame)
885 {
886  u32 n_left_from, next_index, *from, *to_next;
887  ip6_sr_main_t *sm = &sr_main;
888  from = vlib_frame_vector_args (from_frame);
889  n_left_from = from_frame->n_vectors;
890  next_index = node->cached_next_index;
891  u32 thread_index = vlib_get_thread_index ();
892 
893  while (n_left_from > 0)
894  {
895  u32 n_left_to_next;
896  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
897 
898  /* Quad - Loop */
899  while (n_left_from >= 8 && n_left_to_next >= 4)
900  {
901  u32 bi0, bi1, bi2, bi3;
902  vlib_buffer_t *b0, *b1, *b2, *b3;
903  ip6_header_t *ip0, *ip1, *ip2, *ip3;
904  ip6_ext_header_t *prev0, *prev1, *prev2, *prev3;
905  ip6_sr_header_t *sr0, *sr1, *sr2, *sr3;
906  u32 next0, next1, next2, next3;
907  next0 = next1 = next2 = next3 = SR_LOCALSID_NEXT_IP6_LOOKUP;
908  ip6_sr_localsid_t *ls0, *ls1, *ls2, *ls3;
909 
910  /* Prefetch next iteration. */
911  {
912  vlib_buffer_t *p4, *p5, *p6, *p7;
913 
914  p4 = vlib_get_buffer (vm, from[4]);
915  p5 = vlib_get_buffer (vm, from[5]);
916  p6 = vlib_get_buffer (vm, from[6]);
917  p7 = vlib_get_buffer (vm, from[7]);
918 
919  /* Prefetch the buffer header and packet for the N+4 loop iteration */
920  vlib_prefetch_buffer_header (p4, LOAD);
921  vlib_prefetch_buffer_header (p5, LOAD);
922  vlib_prefetch_buffer_header (p6, LOAD);
923  vlib_prefetch_buffer_header (p7, LOAD);
924 
929  }
930 
931  to_next[0] = bi0 = from[0];
932  to_next[1] = bi1 = from[1];
933  to_next[2] = bi2 = from[2];
934  to_next[3] = bi3 = from[3];
935  from += 4;
936  to_next += 4;
937  n_left_from -= 4;
938  n_left_to_next -= 4;
939 
940  b0 = vlib_get_buffer (vm, bi0);
941  b1 = vlib_get_buffer (vm, bi1);
942  b2 = vlib_get_buffer (vm, bi2);
943  b3 = vlib_get_buffer (vm, bi3);
944 
945  ls0 =
947  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
948  ls1 =
950  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
951  ls2 =
953  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
954  ls3 =
956  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
957 
958  ip0 = vlib_buffer_get_current (b0);
959  ip1 = vlib_buffer_get_current (b1);
960  ip2 = vlib_buffer_get_current (b2);
961  ip3 = vlib_buffer_get_current (b3);
962 
963  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
964  ip6_ext_header_find_t (ip1, prev1, sr1, IP_PROTOCOL_IPV6_ROUTE);
965  ip6_ext_header_find_t (ip2, prev2, sr2, IP_PROTOCOL_IPV6_ROUTE);
966  ip6_ext_header_find_t (ip3, prev3, sr3, IP_PROTOCOL_IPV6_ROUTE);
967 
968  end_decaps_srh_processing (node, b0, ip0, sr0, ls0, &next0);
969  end_decaps_srh_processing (node, b1, ip1, sr1, ls1, &next1);
970  end_decaps_srh_processing (node, b2, ip2, sr2, ls2, &next2);
971  end_decaps_srh_processing (node, b3, ip3, sr3, ls3, &next3);
972 
974  {
975  sr_localsid_trace_t *tr =
976  vlib_add_trace (vm, node, b0, sizeof (*tr));
977  tr->num_segments = 0;
979  sizeof (tr->localsid.as_u8));
980  tr->behavior = ls0->behavior;
981  if (ip0 == vlib_buffer_get_current (b0))
982  {
983  if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE
984  && sr0->type == ROUTING_HEADER_TYPE_SR)
985  {
986  clib_memcpy (tr->sr, sr0->segments, sr0->length * 8);
987  tr->num_segments =
988  sr0->length * 8 / sizeof (ip6_address_t);
989  tr->segments_left = sr0->segments_left;
990  }
991  }
992  else
993  tr->num_segments = 0xFF;
994  }
995 
997  {
998  sr_localsid_trace_t *tr =
999  vlib_add_trace (vm, node, b1, sizeof (*tr));
1000  tr->num_segments = 0;
1002  sizeof (tr->localsid.as_u8));
1003  tr->behavior = ls1->behavior;
1004  if (ip1 == vlib_buffer_get_current (b1))
1005  {
1006  if (ip1->protocol == IP_PROTOCOL_IPV6_ROUTE
1007  && sr1->type == ROUTING_HEADER_TYPE_SR)
1008  {
1009  clib_memcpy (tr->sr, sr1->segments, sr1->length * 8);
1010  tr->num_segments =
1011  sr1->length * 8 / sizeof (ip6_address_t);
1012  tr->segments_left = sr1->segments_left;
1013  }
1014  }
1015  else
1016  tr->num_segments = 0xFF;
1017  }
1018 
1020  {
1021  sr_localsid_trace_t *tr =
1022  vlib_add_trace (vm, node, b2, sizeof (*tr));
1023  tr->num_segments = 0;
1025  sizeof (tr->localsid.as_u8));
1026  tr->behavior = ls2->behavior;
1027  if (ip2 == vlib_buffer_get_current (b2))
1028  {
1029  if (ip2->protocol == IP_PROTOCOL_IPV6_ROUTE
1030  && sr2->type == ROUTING_HEADER_TYPE_SR)
1031  {
1032  clib_memcpy (tr->sr, sr2->segments, sr2->length * 8);
1033  tr->num_segments =
1034  sr2->length * 8 / sizeof (ip6_address_t);
1035  tr->segments_left = sr2->segments_left;
1036  }
1037  }
1038  else
1039  tr->num_segments = 0xFF;
1040  }
1041 
1043  {
1044  sr_localsid_trace_t *tr =
1045  vlib_add_trace (vm, node, b3, sizeof (*tr));
1046  tr->num_segments = 0;
1048  sizeof (tr->localsid.as_u8));
1049  tr->behavior = ls3->behavior;
1050  if (ip3 == vlib_buffer_get_current (b3))
1051  {
1052  if (ip3->protocol == IP_PROTOCOL_IPV6_ROUTE
1053  && sr3->type == ROUTING_HEADER_TYPE_SR)
1054  {
1055  clib_memcpy (tr->sr, sr3->segments, sr3->length * 8);
1056  tr->num_segments =
1057  sr3->length * 8 / sizeof (ip6_address_t);
1058  tr->segments_left = sr3->segments_left;
1059  }
1060  }
1061  else
1062  tr->num_segments = 0xFF;
1063  }
1064 
1066  (((next0 ==
1067  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1068  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
1069  1, vlib_buffer_length_in_chain (vm, b0));
1070 
1072  (((next1 ==
1073  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1074  &(sm->sr_ls_valid_counters)), thread_index, ls1 - sm->localsids,
1075  1, vlib_buffer_length_in_chain (vm, b1));
1076 
1078  (((next2 ==
1079  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1080  &(sm->sr_ls_valid_counters)), thread_index, ls2 - sm->localsids,
1081  1, vlib_buffer_length_in_chain (vm, b2));
1082 
1084  (((next3 ==
1085  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1086  &(sm->sr_ls_valid_counters)), thread_index, ls3 - sm->localsids,
1087  1, vlib_buffer_length_in_chain (vm, b3));
1088 
1089  vlib_validate_buffer_enqueue_x4 (vm, node, next_index, to_next,
1090  n_left_to_next, bi0, bi1, bi2, bi3,
1091  next0, next1, next2, next3);
1092  }
1093 
1094  /* Single loop for potentially the last three packets */
1095  while (n_left_from > 0 && n_left_to_next > 0)
1096  {
1097  u32 bi0;
1098  vlib_buffer_t *b0;
1099  ip6_header_t *ip0;
1100  ip6_ext_header_t *prev0;
1101  ip6_sr_header_t *sr0;
1102  u32 next0 = SR_LOCALSID_NEXT_IP6_LOOKUP;
1103  ip6_sr_localsid_t *ls0;
1104 
1105  bi0 = from[0];
1106  to_next[0] = bi0;
1107  from += 1;
1108  to_next += 1;
1109  n_left_from -= 1;
1110  n_left_to_next -= 1;
1111 
1112  b0 = vlib_get_buffer (vm, bi0);
1113  ip0 = vlib_buffer_get_current (b0);
1114 
1115  /* Lookup the SR End behavior based on IP DA (adj) */
1116  ls0 =
1118  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1119 
1120  /* Find SRH as well as previous header */
1121  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
1122 
1123  /* SRH processing and End variants */
1124  end_decaps_srh_processing (node, b0, ip0, sr0, ls0, &next0);
1125 
1127  {
1128  sr_localsid_trace_t *tr =
1129  vlib_add_trace (vm, node, b0, sizeof (*tr));
1130  tr->num_segments = 0;
1132  sizeof (tr->localsid.as_u8));
1133  tr->behavior = ls0->behavior;
1134  if (ip0 == vlib_buffer_get_current (b0))
1135  {
1136  if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE
1137  && sr0->type == ROUTING_HEADER_TYPE_SR)
1138  {
1139  clib_memcpy (tr->sr, sr0->segments, sr0->length * 8);
1140  tr->num_segments =
1141  sr0->length * 8 / sizeof (ip6_address_t);
1142  tr->segments_left = sr0->segments_left;
1143  }
1144  }
1145  else
1146  tr->num_segments = 0xFF;
1147  }
1148 
1149  /* Increase the counters */
1151  (((next0 ==
1152  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1153  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
1154  1, vlib_buffer_length_in_chain (vm, b0));
1155 
1156  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1157  n_left_to_next, bi0, next0);
1158  }
1159  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1160  }
1161  return from_frame->n_vectors;
1162 }
1163 
1164 /* *INDENT-OFF* */
1166  .function = sr_localsid_d_fn,
1167  .name = "sr-localsid-d",
1168  .vector_size = sizeof (u32),
1169  .format_trace = format_sr_localsid_trace,
1170  .type = VLIB_NODE_TYPE_INTERNAL,
1171  .n_errors = SR_LOCALSID_N_ERROR,
1172  .error_strings = sr_localsid_error_strings,
1173  .n_next_nodes = SR_LOCALSID_N_NEXT,
1174  .next_nodes = {
1175 #define _(s,n) [SR_LOCALSID_NEXT_##s] = n,
1177 #undef _
1178  },
1179 };
1180 /* *INDENT-ON* */
1181 
1182 /**
1183  * @brief SR LocalSID graph node. Supports all default SR Endpoint without decaps
1184  */
1185 static uword
1187  vlib_frame_t * from_frame)
1188 {
1189  u32 n_left_from, next_index, *from, *to_next;
1190  ip6_sr_main_t *sm = &sr_main;
1191  from = vlib_frame_vector_args (from_frame);
1192  n_left_from = from_frame->n_vectors;
1193  next_index = node->cached_next_index;
1194  u32 thread_index = vlib_get_thread_index ();
1195 
1196  while (n_left_from > 0)
1197  {
1198  u32 n_left_to_next;
1199  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1200 
1201  /* Quad - Loop */
1202  while (n_left_from >= 8 && n_left_to_next >= 4)
1203  {
1204  u32 bi0, bi1, bi2, bi3;
1205  vlib_buffer_t *b0, *b1, *b2, *b3;
1206  ip6_header_t *ip0, *ip1, *ip2, *ip3;
1207  ip6_sr_header_t *sr0, *sr1, *sr2, *sr3;
1208  ip6_ext_header_t *prev0, *prev1, *prev2, *prev3;
1209  u32 next0, next1, next2, next3;
1210  next0 = next1 = next2 = next3 = SR_LOCALSID_NEXT_IP6_LOOKUP;
1211  ip6_sr_localsid_t *ls0, *ls1, *ls2, *ls3;
1212 
1213  /* Prefetch next iteration. */
1214  {
1215  vlib_buffer_t *p4, *p5, *p6, *p7;
1216 
1217  p4 = vlib_get_buffer (vm, from[4]);
1218  p5 = vlib_get_buffer (vm, from[5]);
1219  p6 = vlib_get_buffer (vm, from[6]);
1220  p7 = vlib_get_buffer (vm, from[7]);
1221 
1222  /* Prefetch the buffer header and packet for the N+2 loop iteration */
1223  vlib_prefetch_buffer_header (p4, LOAD);
1224  vlib_prefetch_buffer_header (p5, LOAD);
1225  vlib_prefetch_buffer_header (p6, LOAD);
1226  vlib_prefetch_buffer_header (p7, LOAD);
1227 
1232  }
1233 
1234  to_next[0] = bi0 = from[0];
1235  to_next[1] = bi1 = from[1];
1236  to_next[2] = bi2 = from[2];
1237  to_next[3] = bi3 = from[3];
1238  from += 4;
1239  to_next += 4;
1240  n_left_from -= 4;
1241  n_left_to_next -= 4;
1242 
1243  b0 = vlib_get_buffer (vm, bi0);
1244  b1 = vlib_get_buffer (vm, bi1);
1245  b2 = vlib_get_buffer (vm, bi2);
1246  b3 = vlib_get_buffer (vm, bi3);
1247 
1248  ip0 = vlib_buffer_get_current (b0);
1249  ip1 = vlib_buffer_get_current (b1);
1250  ip2 = vlib_buffer_get_current (b2);
1251  ip3 = vlib_buffer_get_current (b3);
1252 
1253  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
1254  ip6_ext_header_find_t (ip1, prev1, sr1, IP_PROTOCOL_IPV6_ROUTE);
1255  ip6_ext_header_find_t (ip2, prev2, sr2, IP_PROTOCOL_IPV6_ROUTE);
1256  ip6_ext_header_find_t (ip3, prev3, sr3, IP_PROTOCOL_IPV6_ROUTE);
1257 
1258  ls0 =
1260  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1261  ls1 =
1263  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1264  ls2 =
1266  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1267  ls3 =
1269  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1270 
1271  end_srh_processing (node, b0, ip0, sr0, ls0, &next0, ls0->end_psp,
1272  prev0);
1273  end_srh_processing (node, b1, ip1, sr1, ls1, &next1, ls1->end_psp,
1274  prev1);
1275  end_srh_processing (node, b2, ip2, sr2, ls2, &next2, ls2->end_psp,
1276  prev2);
1277  end_srh_processing (node, b3, ip3, sr3, ls3, &next3, ls3->end_psp,
1278  prev3);
1279 
1281  {
1282  sr_localsid_trace_t *tr =
1283  vlib_add_trace (vm, node, b0, sizeof (*tr));
1284  tr->num_segments = 0;
1286  sizeof (tr->localsid.as_u8));
1287  tr->behavior = ls0->behavior;
1288  if (ip0 == vlib_buffer_get_current (b0))
1289  {
1290  if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE
1291  && sr0->type == ROUTING_HEADER_TYPE_SR)
1292  {
1293  clib_memcpy (tr->sr, sr0->segments, sr0->length * 8);
1294  tr->num_segments =
1295  sr0->length * 8 / sizeof (ip6_address_t);
1296  tr->segments_left = sr0->segments_left;
1297  }
1298  }
1299  else
1300  tr->num_segments = 0xFF;
1301  }
1302 
1304  {
1305  sr_localsid_trace_t *tr =
1306  vlib_add_trace (vm, node, b1, sizeof (*tr));
1307  tr->num_segments = 0;
1309  sizeof (tr->localsid.as_u8));
1310  tr->behavior = ls1->behavior;
1311  if (ip1 == vlib_buffer_get_current (b1))
1312  {
1313  if (ip1->protocol == IP_PROTOCOL_IPV6_ROUTE
1314  && sr1->type == ROUTING_HEADER_TYPE_SR)
1315  {
1316  clib_memcpy (tr->sr, sr1->segments, sr1->length * 8);
1317  tr->num_segments =
1318  sr1->length * 8 / sizeof (ip6_address_t);
1319  tr->segments_left = sr1->segments_left;
1320  }
1321  }
1322  else
1323  tr->num_segments = 0xFF;
1324  }
1325 
1327  {
1328  sr_localsid_trace_t *tr =
1329  vlib_add_trace (vm, node, b2, sizeof (*tr));
1330  tr->num_segments = 0;
1332  sizeof (tr->localsid.as_u8));
1333  tr->behavior = ls2->behavior;
1334  if (ip2 == vlib_buffer_get_current (b2))
1335  {
1336  if (ip2->protocol == IP_PROTOCOL_IPV6_ROUTE
1337  && sr2->type == ROUTING_HEADER_TYPE_SR)
1338  {
1339  clib_memcpy (tr->sr, sr2->segments, sr2->length * 8);
1340  tr->num_segments =
1341  sr2->length * 8 / sizeof (ip6_address_t);
1342  tr->segments_left = sr2->segments_left;
1343  }
1344  }
1345  else
1346  tr->num_segments = 0xFF;
1347  }
1348 
1350  {
1351  sr_localsid_trace_t *tr =
1352  vlib_add_trace (vm, node, b3, sizeof (*tr));
1353  tr->num_segments = 0;
1355  sizeof (tr->localsid.as_u8));
1356  tr->behavior = ls3->behavior;
1357  if (ip3 == vlib_buffer_get_current (b3))
1358  {
1359  if (ip3->protocol == IP_PROTOCOL_IPV6_ROUTE
1360  && sr3->type == ROUTING_HEADER_TYPE_SR)
1361  {
1362  clib_memcpy (tr->sr, sr3->segments, sr3->length * 8);
1363  tr->num_segments =
1364  sr3->length * 8 / sizeof (ip6_address_t);
1365  tr->segments_left = sr3->segments_left;
1366  }
1367  }
1368  else
1369  tr->num_segments = 0xFF;
1370  }
1371 
1373  (((next0 ==
1374  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1375  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
1376  1, vlib_buffer_length_in_chain (vm, b0));
1377 
1379  (((next1 ==
1380  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1381  &(sm->sr_ls_valid_counters)), thread_index, ls1 - sm->localsids,
1382  1, vlib_buffer_length_in_chain (vm, b1));
1383 
1385  (((next2 ==
1386  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1387  &(sm->sr_ls_valid_counters)), thread_index, ls2 - sm->localsids,
1388  1, vlib_buffer_length_in_chain (vm, b2));
1389 
1391  (((next3 ==
1392  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1393  &(sm->sr_ls_valid_counters)), thread_index, ls3 - sm->localsids,
1394  1, vlib_buffer_length_in_chain (vm, b3));
1395 
1396  vlib_validate_buffer_enqueue_x4 (vm, node, next_index, to_next,
1397  n_left_to_next, bi0, bi1, bi2, bi3,
1398  next0, next1, next2, next3);
1399  }
1400 
1401  /* Single loop for potentially the last three packets */
1402  while (n_left_from > 0 && n_left_to_next > 0)
1403  {
1404  u32 bi0;
1405  vlib_buffer_t *b0;
1406  ip6_header_t *ip0 = 0;
1407  ip6_ext_header_t *prev0;
1408  ip6_sr_header_t *sr0;
1409  u32 next0 = SR_LOCALSID_NEXT_IP6_LOOKUP;
1410  ip6_sr_localsid_t *ls0;
1411 
1412  bi0 = from[0];
1413  to_next[0] = bi0;
1414  from += 1;
1415  to_next += 1;
1416  n_left_from -= 1;
1417  n_left_to_next -= 1;
1418 
1419  b0 = vlib_get_buffer (vm, bi0);
1420  ip0 = vlib_buffer_get_current (b0);
1421  ip6_ext_header_find_t (ip0, prev0, sr0, IP_PROTOCOL_IPV6_ROUTE);
1422 
1423  /* Lookup the SR End behavior based on IP DA (adj) */
1424  ls0 =
1426  vnet_buffer (b0)->ip.adj_index[VLIB_TX]);
1427 
1428  /* SRH processing */
1429  end_srh_processing (node, b0, ip0, sr0, ls0, &next0, ls0->end_psp,
1430  prev0);
1431 
1433  {
1434  sr_localsid_trace_t *tr =
1435  vlib_add_trace (vm, node, b0, sizeof (*tr));
1436  tr->num_segments = 0;
1438  sizeof (tr->localsid.as_u8));
1439  tr->behavior = ls0->behavior;
1440  if (ip0 == vlib_buffer_get_current (b0))
1441  {
1442  if (ip0->protocol == IP_PROTOCOL_IPV6_ROUTE
1443  && sr0->type == ROUTING_HEADER_TYPE_SR)
1444  {
1445  clib_memcpy (tr->sr, sr0->segments, sr0->length * 8);
1446  tr->num_segments =
1447  sr0->length * 8 / sizeof (ip6_address_t);
1448  tr->segments_left = sr0->segments_left;
1449  }
1450  }
1451  else
1452  tr->num_segments = 0xFF;
1453  }
1454 
1456  (((next0 ==
1457  SR_LOCALSID_NEXT_ERROR) ? &(sm->sr_ls_invalid_counters) :
1458  &(sm->sr_ls_valid_counters)), thread_index, ls0 - sm->localsids,
1459  1, vlib_buffer_length_in_chain (vm, b0));
1460 
1461  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1462  n_left_to_next, bi0, next0);
1463  }
1464  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1465  }
1466  return from_frame->n_vectors;
1467 }
1468 
1469 /* *INDENT-OFF* */
1471  .function = sr_localsid_fn,
1472  .name = "sr-localsid",
1473  .vector_size = sizeof (u32),
1474  .format_trace = format_sr_localsid_trace,
1475  .type = VLIB_NODE_TYPE_INTERNAL,
1476  .n_errors = SR_LOCALSID_N_ERROR,
1477  .error_strings = sr_localsid_error_strings,
1478  .n_next_nodes = SR_LOCALSID_N_NEXT,
1479  .next_nodes = {
1480 #define _(s,n) [SR_LOCALSID_NEXT_##s] = n,
1482 #undef _
1483  },
1484 };
1485 /* *INDENT-ON* */
1486 
1487 static u8 *
1488 format_sr_dpo (u8 * s, va_list * args)
1489 {
1490  index_t index = va_arg (*args, index_t);
1491  CLIB_UNUSED (u32 indent) = va_arg (*args, u32);
1492 
1493  return (format (s, "SR: localsid_index:[%d]", index));
1494 }
1495 
1496 const static dpo_vft_t sr_loc_vft = {
1497  .dv_lock = sr_dpo_lock,
1498  .dv_unlock = sr_dpo_unlock,
1499  .dv_format = format_sr_dpo,
1500 };
1501 
1502 const static char *const sr_loc_ip6_nodes[] = {
1503  "sr-localsid",
1504  NULL,
1505 };
1506 
1507 const static char *const *const sr_loc_nodes[DPO_PROTO_NUM] = {
1509 };
1510 
1511 const static char *const sr_loc_d_ip6_nodes[] = {
1512  "sr-localsid-d",
1513  NULL,
1514 };
1515 
1516 const static char *const *const sr_loc_d_nodes[DPO_PROTO_NUM] = {
1518 };
1519 
1520 
1521 /*************************** SR LocalSID plugins ******************************/
1522 /**
1523  * @brief SR LocalSID plugin registry
1524  */
1525 int
1527  u8 * keyword_str, u8 * def_str,
1528  u8 * params_str, dpo_type_t * dpo,
1529  format_function_t * ls_format,
1530  unformat_function_t * ls_unformat,
1531  sr_plugin_callback_t * creation_fn,
1532  sr_plugin_callback_t * removal_fn)
1533 {
1534  ip6_sr_main_t *sm = &sr_main;
1535  uword *p;
1536 
1538 
1539  /* Did this function exist? If so update it */
1540  p = hash_get_mem (sm->plugin_functions_by_key, fn_name);
1541  if (p)
1542  {
1543  plugin = pool_elt_at_index (sm->plugin_functions, p[0]);
1544  }
1545  /* Else create a new one and set hash key */
1546  else
1547  {
1548  pool_get (sm->plugin_functions, plugin);
1549  hash_set_mem (sm->plugin_functions_by_key, fn_name,
1550  plugin - sm->plugin_functions);
1551  }
1552 
1553  memset (plugin, 0, sizeof (*plugin));
1554 
1555  plugin->sr_localsid_function_number = (plugin - sm->plugin_functions);
1557  plugin->ls_format = ls_format;
1558  plugin->ls_unformat = ls_unformat;
1559  plugin->creation = creation_fn;
1560  plugin->removal = removal_fn;
1561  clib_memcpy (&plugin->dpo, dpo, sizeof (dpo_type_t));
1562  plugin->function_name = format (0, "%s%c", fn_name, 0);
1563  plugin->keyword_str = format (0, "%s%c", keyword_str, 0);
1564  plugin->def_str = format (0, "%s%c", def_str, 0);
1565  plugin->params_str = format (0, "%s%c", params_str, 0);
1566 
1567  return plugin->sr_localsid_function_number;
1568 }
1569 
1570 /**
1571  * @brief CLI function to 'show' all available SR LocalSID behaviors
1572  */
1573 static clib_error_t *
1575  unformat_input_t * input,
1576  vlib_cli_command_t * cmd)
1577 {
1578  ip6_sr_main_t *sm = &sr_main;
1580  sr_localsid_fn_registration_t **plugins_vec = 0;
1581  int i;
1582 
1583  vlib_cli_output (vm,
1584  "SR LocalSIDs behaviors:\n-----------------------\n\n");
1585 
1586  /* *INDENT-OFF* */
1587  pool_foreach (plugin, sm->plugin_functions,
1588  ({ vec_add1 (plugins_vec, plugin); }));
1589  /* *INDENT-ON* */
1590 
1591  /* Print static behaviors */
1592  vlib_cli_output (vm, "Default behaviors:\n"
1593  "\tEnd\t-> Endpoint.\n"
1594  "\tEnd.X\t-> Endpoint with Layer-3 cross-connect.\n"
1595  "\t\tParameters: '<iface> <ip6_next_hop>'\n"
1596  "\tEnd.T\t-> Endpoint with specific IPv6 table lookup.\n"
1597  "\t\tParameters: '<fib_table>'\n"
1598  "\tEnd.DX2\t-> Endpoint with decapsulation and Layer-2 cross-connect.\n"
1599  "\t\tParameters: '<iface>'\n"
1600  "\tEnd.DX6\t-> Endpoint with decapsulation and IPv6 cross-connect.\n"
1601  "\t\tParameters: '<iface> <ip6_next_hop>'\n"
1602  "\tEnd.DX4\t-> Endpoint with decapsulation and IPv4 cross-connect.\n"
1603  "\t\tParameters: '<iface> <ip4_next_hop>'\n"
1604  "\tEnd.DT6\t-> Endpoint with decapsulation and specific IPv6 table lookup.\n"
1605  "\t\tParameters: '<ip6_fib_table>'\n"
1606  "\tEnd.DT4\t-> Endpoint with decapsulation and specific IPv4 table lookup.\n"
1607  "\t\tParameters: '<ip4_fib_table>'\n");
1608  vlib_cli_output (vm, "Plugin behaviors:\n");
1609  for (i = 0; i < vec_len (plugins_vec); i++)
1610  {
1611  plugin = plugins_vec[i];
1612  vlib_cli_output (vm, "\t%s\t-> %s.\n", plugin->keyword_str,
1613  plugin->def_str);
1614  vlib_cli_output (vm, "\t\tParameters: '%s'\n", plugin->params_str);
1615  }
1616  return 0;
1617 }
1618 
1619 /* *INDENT-OFF* */
1620 VLIB_CLI_COMMAND (show_sr_localsid_behaviors_command, static) = {
1621  .path = "show sr localsids behaviors",
1622  .short_help = "show sr localsids behaviors",
1624 };
1625 /* *INDENT-ON* */
1626 
1627 /**
1628  * @brief SR LocalSID initialization
1629  */
1630 clib_error_t *
1632 {
1633  /* Init memory for function keys */
1634  ip6_sr_main_t *sm = &sr_main;
1635  mhash_init (&sm->sr_localsids_index_hash, sizeof (uword),
1636  sizeof (ip6_address_t));
1637  /* Init SR behaviors DPO type */
1639  /* Init SR behaviors DPO type */
1641  dpo_register_new_type (&sr_loc_vft, sr_loc_d_nodes);
1642  /* Init memory for localsid plugins */
1643  sm->plugin_functions_by_key = hash_create_string (0, sizeof (uword));
1644  return 0;
1645 }
1646 
1648 /*
1649 * fd.io coding-style-patch-verification: ON
1650 *
1651 * Local Variables:
1652 * eval: (c-set-style "gnu")
1653 * End:
1654 */
u8 * function_name
Function name.
Definition: sr.h:136
#define SR_BEHAVIOR_D_FIRST
Definition: sr.h:40
sr_localsid_error_t
Definition: sr_localsid.c:605
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:181
ip6_sr_main_t sr_main
Definition: sr.c:31
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:382
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:377
static const char *const sr_loc_ip6_nodes[]
Definition: sr_localsid.c:1502
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_X
Definition: sr.h:38
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:47
#define PREDICT_TRUE(x)
Definition: clib.h:106
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
ip6_address_t localsid
Definition: sr_localsid.c:590
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
#define SR_BEHAVIOR_DT6
Definition: sr.h:44
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:799
#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]
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:415
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:107
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:225
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
static char * sr_localsid_error_strings[]
Definition: sr_localsid.c:613
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:1574
format_function_t format_vnet_sw_if_index_name
#define SR_BEHAVIOR_DT4
Definition: sr.h:45
static const char *const sr_loc_d_ip6_nodes[]
Definition: sr_localsid.c:1511
static const char *const *const sr_loc_nodes[DPO_PROTO_NUM]
Definition: sr_localsid.c:1507
format_function_t format_ip4_address
Definition: format.h:79
#define static_always_inline
Definition: clib.h:93
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:438
unformat_function_t unformat_ip4_address
Definition: format.h:76
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
#define SR_BEHAVIOR_LAST
Definition: sr.h:46
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:171
Aggregrate type for a prefix.
Definition: fib_types.h:172
#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:239
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:1028
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:322
#define hash_create_string(elts, value_bytes)
Definition: hash.h:675
int( sr_plugin_callback_t)(ip6_sr_localsid_t *localsid)
Definition: sr.h:127
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:166
Definition: fib_entry.h:242
#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:459
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:1165
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:195
#define SR_BEHAVIOR_END
Definition: sr.h:37
u8 * format_sr_localsid_trace(u8 *s, va_list *args)
SR LocalSID graph node trace function.
Definition: sr_localsid.c:641
struct _unformat_input_t unformat_input_t
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:195
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:271
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:105
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:1488
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:702
#define SR_BEHAVIOR_DX4
Definition: sr.h:43
#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 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:364
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:883
#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:344
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:221
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
vlib_main_t * vm
Definition: buffer.c:283
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:836
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:93
#define clib_memcpy(a, b, c)
Definition: string.h:75
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:29
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:1526
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:454
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:182
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:456
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:1516
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:208
u32 fib_table
FIB table where localsid is registered.
Definition: sr.h:116
#define SR_BEHAVIOR_DX2
Definition: sr.h:41
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:70
SRv6 and SR-MPLS.
Definition: fib_entry.h:58
u16 payload_length
Definition: ip6_packet.h:332
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:30
#define SR_BEHAVIOR_T
Definition: sr.h:39
#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:267
#define DPO_INVALID
An initialiser for DPOs declared on the stack.
Definition: dpo.h:193
clib_error_t * sr_localsids_init(vlib_main_t *vm)
SR LocalSID initialization.
Definition: sr_localsid.c:1631
#define hash_get_mem(h, key)
Definition: hash.h:268
#define vnet_buffer(b)
Definition: buffer.h:326
vlib_node_registration_t sr_localsid_node
(constructor) VLIB_REGISTER_NODE (sr_localsid_node)
Definition: sr_localsid.c:1470
Segment Routing data structures definitions.
Segment Routing main datastructure.
Definition: sr.h:189
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
u8 data[0]
Packet data.
Definition: buffer.h:159
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:228
#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:1186
#define ip6_ext_header_find_t(i, p, m, t)
Definition: ip6_packet.h:480
#define foreach_sr_localsid_next
Definition: sr_localsid.c:619
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:597
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_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:75
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:627
#define SR_BEHAVIOR_DX6
Definition: sr.h:42
ip6_address_t dst_address
Definition: ip6_packet.h:341
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
uword * plugin_functions_by_key
Definition: sr.h:225