FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
sr_steering.c
Go to the documentation of this file.
1 /*
2  * sr_steering.c: ipv6 segment routing steering into SR policy
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 Packet steering into SR Policies
21  *
22  * This file is in charge of handling the FIB appropiatly to steer packets
23  * through SR Policies as defined in 'sr_policy_rewrite.c'. Notice that here
24  * we are only doing steering. SR policy application is done in
25  * sr_policy_rewrite.c
26  *
27  * Supports:
28  * - Steering of IPv6 traffic Destination Address based
29  * - Steering of IPv4 traffic Destination Address based
30  * - Steering of L2 frames, interface based (sw interface)
31  */
32 
33 #include <vlib/vlib.h>
34 #include <vnet/vnet.h>
35 #include <vnet/srv6/sr.h>
36 #include <vnet/ip/ip.h>
37 #include <vnet/srv6/sr_packet.h>
38 #include <vnet/ip/ip6_packet.h>
39 #include <vnet/fib/ip6_fib.h>
40 #include <vnet/dpo/dpo.h>
41 
42 #include <vppinfra/error.h>
43 #include <vppinfra/elog.h>
44 
45 /**
46  * @brief Steer traffic L2 and L3 traffic through a given SR policy
47  *
48  * @param is_del
49  * @param bsid is the bindingSID of the SR Policy (alt to sr_policy_index)
50  * @param sr_policy is the index of the SR Policy (alt to bsid)
51  * @param table_id is the VRF where to install the FIB entry for the BSID
52  * @param prefix is the IPv4/v6 address for L3 traffic type
53  * @param mask_width is the mask for L3 traffic type
54  * @param sw_if_index is the incoming interface for L2 traffic
55  * @param traffic_type describes the type of traffic
56  *
57  * @return 0 if correct, else error
58  */
59 int
60 sr_steering_policy (int is_del, ip6_address_t * bsid, u32 sr_policy_index,
61  u32 table_id, ip46_address_t * prefix, u32 mask_width,
62  u32 sw_if_index, u8 traffic_type)
63 {
64  ip6_sr_main_t *sm = &sr_main;
66  ip6_sr_steering_policy_t *steer_pl;
67  fib_prefix_t pfx = { 0 };
68 
69  ip6_sr_policy_t *sr_policy = 0;
70  uword *p = 0;
71 
72  clib_memset (&key, 0, sizeof (sr_steering_key_t));
73 
74  /* Compute the steer policy key */
75  if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
76  {
77  key.l3.prefix.as_u64[0] = prefix->as_u64[0];
78  key.l3.prefix.as_u64[1] = prefix->as_u64[1];
79  key.l3.mask_width = mask_width;
80  key.l3.fib_table = (table_id != (u32) ~ 0 ? table_id : 0);
81  }
82  else if (traffic_type == SR_STEER_L2)
83  {
84  key.l2.sw_if_index = sw_if_index;
85 
86  /* Sanitise the SW_IF_INDEX */
88  sw_if_index))
89  return -3;
90 
92  vnet_get_sw_interface (sm->vnet_main, sw_if_index);
94  return -3;
95  }
96  else
97  return -1;
98 
99  key.traffic_type = traffic_type;
100 
101  /* Search for the item */
102  p = mhash_get (&sm->sr_steer_policies_hash, &key);
103 
104  if (p)
105  {
106  /* Retrieve Steer Policy function */
107  steer_pl = pool_elt_at_index (sm->steer_policies, p[0]);
108 
109  if (is_del)
110  {
111  if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
112  {
113  /* Remove FIB entry */
115  pfx.fp_len = steer_pl->classify.l3.mask_width;
116  pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
117 
120  steer_pl->classify.l3.fib_table),
121  &pfx, FIB_SOURCE_SR);
122  }
123  else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
124  {
125  /* Remove FIB entry */
127  pfx.fp_len = steer_pl->classify.l3.mask_width;
128  pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
129 
132  steer_pl->classify.l3.fib_table), &pfx,
133  FIB_SOURCE_SR);
134  }
135  else if (steer_pl->classify.traffic_type == SR_STEER_L2)
136  {
137  /* Remove HW redirection */
138  int ret = vnet_feature_enable_disable ("device-input",
139  "sr-pl-rewrite-encaps-l2",
140  sw_if_index, 0, 0, 0);
141 
142  if (ret != 0)
143  return -1;
144 
146 
147  /* Remove promiscous mode from interface */
148  vnet_main_t *vnm = vnet_get_main ();
150  vnet_get_sup_hw_interface (vnm, sw_if_index);
151  /* Make sure it is main interface */
152  if (hi->sw_if_index == sw_if_index)
153  ethernet_set_flags (vnm, hi->hw_if_index, 0);
154  }
155 
156  /* Delete SR steering policy entry */
157  pool_put (sm->steer_policies, steer_pl);
158  mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
159 
160  /* If no more SR policies or steering policies */
161  if (!pool_elts (sm->sr_policies) && !pool_elts (sm->steer_policies))
162  {
167  sm->fib_table_ip6 = (u32) ~ 0;
168  sm->fib_table_ip4 = (u32) ~ 0;
169  }
170 
171  return 0;
172  }
173  else /* It means user requested to update an existing SR steering policy */
174  {
175  /* Retrieve SR steering policy */
176  if (bsid)
177  {
178  p = mhash_get (&sm->sr_policies_index_hash, bsid);
179  if (p)
180  sr_policy = pool_elt_at_index (sm->sr_policies, p[0]);
181  else
182  return -2;
183  }
184  else
185  sr_policy = pool_elt_at_index (sm->sr_policies, sr_policy_index);
186 
187  if (!sr_policy)
188  return -2;
189 
190  steer_pl->sr_policy = sr_policy - sm->sr_policies;
191 
192  /* Remove old FIB/hw redirection and create a new one */
193  if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
194  {
195  /* Remove FIB entry */
197  pfx.fp_len = steer_pl->classify.l3.mask_width;
198  pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
199 
202  steer_pl->classify.l3.fib_table),
203  &pfx, FIB_SOURCE_SR);
204 
205  /* Create a new one */
206  goto update_fib;
207  }
208  else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
209  {
210  /* Remove FIB entry */
212  pfx.fp_len = steer_pl->classify.l3.mask_width;
213  pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
214 
217  steer_pl->classify.l3.fib_table),
218  &pfx, FIB_SOURCE_SR);
219 
220  /* Create a new one */
221  goto update_fib;
222  }
223  else if (steer_pl->classify.traffic_type == SR_STEER_L2)
224  {
225  /* Update L2-HW redirection */
226  goto update_fib;
227  }
228  }
229  }
230  else
231  /* delete; steering policy does not exist; complain */
232  if (is_del)
233  return -4;
234 
235  /* Retrieve SR policy */
236  if (bsid)
237  {
238  p = mhash_get (&sm->sr_policies_index_hash, bsid);
239  if (p)
240  sr_policy = pool_elt_at_index (sm->sr_policies, p[0]);
241  else
242  return -2;
243  }
244  else
245  sr_policy = pool_elt_at_index (sm->sr_policies, sr_policy_index);
246 
247  /* Create a new steering policy */
248  pool_get (sm->steer_policies, steer_pl);
249  clib_memset (steer_pl, 0, sizeof (*steer_pl));
250 
251  if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
252  {
253  clib_memcpy_fast (&steer_pl->classify.l3.prefix, prefix,
254  sizeof (ip46_address_t));
255  steer_pl->classify.l3.mask_width = mask_width;
256  steer_pl->classify.l3.fib_table =
257  (table_id != (u32) ~ 0 ? table_id : 0);
258  steer_pl->classify.traffic_type = traffic_type;
259  }
260  else if (traffic_type == SR_STEER_L2)
261  {
262  steer_pl->classify.l2.sw_if_index = sw_if_index;
263  steer_pl->classify.traffic_type = traffic_type;
264  }
265  else
266  {
267  /* Incorrect API usage. Should never get here */
268  pool_put (sm->steer_policies, steer_pl);
269  mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
270  return -1;
271  }
272  steer_pl->sr_policy = sr_policy - sm->sr_policies;
273 
274  /* Create and store key */
275  mhash_set (&sm->sr_steer_policies_hash, &key, steer_pl - sm->steer_policies,
276  NULL);
277 
278  if (traffic_type == SR_STEER_L2)
279  {
280  if (!sr_policy->is_encap)
281  goto cleanup_error_encap;
282 
284  ("device-input", "sr-pl-rewrite-encaps-l2", sw_if_index, 1, 0, 0))
285  goto cleanup_error_redirection;
286 
287  /* Set promiscous mode on interface */
288  vnet_main_t *vnm = vnet_get_main ();
289  vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
290  /* Make sure it is main interface */
291  if (hi->sw_if_index == sw_if_index)
294  }
295  else if (traffic_type == SR_STEER_IPV4)
296  if (!sr_policy->is_encap)
297  goto cleanup_error_encap;
298 
299 update_fib:
300  /* FIB API calls - Recursive route through the BindingSID */
301  if (traffic_type == SR_STEER_IPV6)
302  {
304  pfx.fp_len = steer_pl->classify.l3.mask_width;
305  pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
306 
308  (table_id !=
309  (u32) ~ 0 ?
310  table_id : 0)),
311  &pfx, FIB_SOURCE_SR,
314  (ip46_address_t *) & sr_policy->bsid, ~0,
315  sm->fib_table_ip6, 1, NULL,
317  }
318  else if (traffic_type == SR_STEER_IPV4)
319  {
321  pfx.fp_len = steer_pl->classify.l3.mask_width;
322  pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
323 
325  (table_id !=
326  (u32) ~ 0 ?
327  table_id : 0)),
328  &pfx, FIB_SOURCE_SR,
331  (ip46_address_t *) & sr_policy->bsid, ~0,
332  sm->fib_table_ip4, 1, NULL,
334  }
335  else if (traffic_type == SR_STEER_L2)
336  {
337  if (sw_if_index < vec_len (sm->sw_iface_sr_policies))
338  sm->sw_iface_sr_policies[sw_if_index] = steer_pl->sr_policy;
339  else
340  {
343  - vec_len (sm->sw_iface_sr_policies)));
344  sm->sw_iface_sr_policies[sw_if_index] = steer_pl->sr_policy;
345  }
346  }
347 
348  return 0;
349 
350 cleanup_error_encap:
351  pool_put (sm->steer_policies, steer_pl);
352  mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
353  return -5;
354 
355 cleanup_error_redirection:
356  pool_put (sm->steer_policies, steer_pl);
357  mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
358  return -3;
359 }
360 
361 static clib_error_t *
363  vlib_cli_command_t * cmd)
364 {
365  vnet_main_t *vnm = vnet_get_main ();
366 
367  int is_del = 0;
368 
369  ip46_address_t prefix;
370  u32 dst_mask_width = 0;
371  u32 sw_if_index = (u32) ~ 0;
372  u8 traffic_type = 0;
373  u32 fib_table = (u32) ~ 0;
374 
375  ip6_address_t bsid;
376  u32 sr_policy_index = (u32) ~ 0;
377 
378  u8 sr_policy_set = 0;
379 
380  clib_memset (&prefix, 0, sizeof (ip46_address_t));
381 
382  int rv;
384  {
385  if (unformat (input, "del"))
386  is_del = 1;
387  else if (!traffic_type
388  && unformat (input, "l3 %U/%d", unformat_ip6_address,
389  &prefix.ip6, &dst_mask_width))
390  traffic_type = SR_STEER_IPV6;
391  else if (!traffic_type
392  && unformat (input, "l3 %U/%d", unformat_ip4_address,
393  &prefix.ip4, &dst_mask_width))
394  traffic_type = SR_STEER_IPV4;
395  else if (!traffic_type
396  && unformat (input, "l2 %U", unformat_vnet_sw_interface, vnm,
397  &sw_if_index))
398  traffic_type = SR_STEER_L2;
399  else if (!sr_policy_set
400  && unformat (input, "via index %d", &sr_policy_index))
401  sr_policy_set = 1;
402  else if (!sr_policy_set
403  && unformat (input, "via bsid %U",
404  unformat_ip6_address, &bsid))
405  sr_policy_set = 1;
406  else if (fib_table == (u32) ~ 0
407  && unformat (input, "fib-table %d", &fib_table));
408  else
409  break;
410  }
411 
412  if (!traffic_type)
413  return clib_error_return (0, "No L2/L3 traffic specified");
414  if (!sr_policy_set)
415  return clib_error_return (0, "No SR policy specified");
416 
417  /* Make sure that the prefixes are clean */
418  if (traffic_type == SR_STEER_IPV4)
419  {
420  u32 mask =
421  (dst_mask_width ? (0xFFFFFFFFu >> (32 - dst_mask_width)) : 0);
422  prefix.ip4.as_u32 &= mask;
423  }
424  else if (traffic_type == SR_STEER_IPV6)
425  {
426  ip6_address_t mask;
427  ip6_address_mask_from_width (&mask, dst_mask_width);
428  ip6_address_mask (&prefix.ip6, &mask);
429  }
430 
431  rv =
432  sr_steering_policy (is_del, (sr_policy_index == ~(u32) 0 ? &bsid : NULL),
433  sr_policy_index, fib_table, &prefix, dst_mask_width,
434  sw_if_index, traffic_type);
435 
436  switch (rv)
437  {
438  case 0:
439  break;
440  case 1:
441  return 0;
442  case -1:
443  return clib_error_return (0, "Incorrect API usage.");
444  case -2:
445  return clib_error_return (0,
446  "The requested SR policy could not be located. Review the BSID/index.");
447  case -3:
448  return clib_error_return (0,
449  "Unable to do SW redirect. Incorrect interface.");
450  case -4:
451  return clib_error_return (0,
452  "The requested SR steering policy could not be deleted.");
453  case -5:
454  return clib_error_return (0,
455  "The SR policy is not an encapsulation one.");
456  default:
457  return clib_error_return (0, "BUG: sr steer policy returns %d", rv);
458  }
459  return 0;
460 }
461 
462 /* *INDENT-OFF* */
463 VLIB_CLI_COMMAND (sr_steer_policy_command, static) = {
464  .path = "sr steer",
465  .short_help = "sr steer (del) [l3 <ip_addr/mask>|l2 <sf_if>] "
466  "via [index <sr_policy_index>|bsid <bsid_ip6_addr>] "
467  "(fib-table <fib_table_index>)",
468  .long_help =
469  "\tSteer a L2 or L3 traffic through an existing SR policy.\n"
470  "\tExamples:\n"
471  "\t\tsr steer l3 2001::/64 via sr_policy index 5\n"
472  "\t\tsr steer l3 2001::/64 via sr_policy bsid 2010::9999:1\n"
473  "\t\tsr steer l2 GigabitEthernet0/5/0 via sr_policy index 5\n"
474  "\t\tsr steer del l3 2001::/64 via sr_policy index 5\n",
475  .function = sr_steer_policy_command_fn,
476 };
477 /* *INDENT-ON* */
478 
479 static clib_error_t *
481  unformat_input_t * input,
482  vlib_cli_command_t * cmd)
483 {
484  ip6_sr_main_t *sm = &sr_main;
485  ip6_sr_steering_policy_t **steer_policies = 0;
486  ip6_sr_steering_policy_t *steer_pl;
487 
488  vnet_main_t *vnm = vnet_get_main ();
489 
490  ip6_sr_policy_t *pl = 0;
491  int i;
492 
493  vlib_cli_output (vm, "SR steering policies:");
494  /* *INDENT-OFF* */
495  pool_foreach (steer_pl, sm->steer_policies, ({vec_add1(steer_policies, steer_pl);}));
496  /* *INDENT-ON* */
497  vlib_cli_output (vm, "Traffic\t\tSR policy BSID");
498  for (i = 0; i < vec_len (steer_policies); i++)
499  {
500  steer_pl = steer_policies[i];
501  pl = pool_elt_at_index (sm->sr_policies, steer_pl->sr_policy);
502  if (steer_pl->classify.traffic_type == SR_STEER_L2)
503  {
504  vlib_cli_output (vm, "L2 %U\t%U",
506  steer_pl->classify.l2.sw_if_index,
507  format_ip6_address, &pl->bsid);
508  }
509  else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
510  {
511  vlib_cli_output (vm, "L3 %U/%d\t%U",
513  &steer_pl->classify.l3.prefix.ip4,
514  steer_pl->classify.l3.mask_width,
515  format_ip6_address, &pl->bsid);
516  }
517  else if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
518  {
519  vlib_cli_output (vm, "L3 %U/%d\t%U",
521  &steer_pl->classify.l3.prefix.ip6,
522  steer_pl->classify.l3.mask_width,
523  format_ip6_address, &pl->bsid);
524  }
525  }
526  return 0;
527 }
528 
529 /* *INDENT-OFF* */
530 VLIB_CLI_COMMAND (show_sr_steering_policies_command, static) = {
531  .path = "show sr steering-policies",
532  .short_help = "show sr steering-policies",
534 };
535 /* *INDENT-ON* */
536 
537 clib_error_t *
539 {
540  ip6_sr_main_t *sm = &sr_main;
541 
542  /* Init memory for function keys */
543  mhash_init (&sm->sr_steer_policies_hash, sizeof (uword),
544  sizeof (sr_steering_key_t));
545 
546  sm->sw_iface_sr_policies = 0;
547 
548  sm->vnet_main = vnet_get_main ();
549 
550  return 0;
551 }
552 
553 /* *INDENT-OFF* */
555 /* *INDENT-ON* */
556 
557 /* *INDENT-OFF* */
558 VNET_FEATURE_INIT (sr_pl_rewrite_encaps_l2, static) =
559 {
560  .arc_name = "device-input",
561  .node_name = "sr-pl-rewrite-encaps-l2",
562  .runs_before = VNET_FEATURES ("ethernet-input"),
563 };
564 /* *INDENT-ON* */
565 
566 /*
567 * fd.io coding-style-patch-verification: ON
568 *
569 * Local Variables:
570 * eval: (c-set-style "gnu")
571 * End:
572 */
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:212
ip6_sr_main_t sr_main
Definition: sr.c:31
fib_node_index_t fib_table_entry_path_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, dpo_proto_t next_hop_proto, const ip46_address_t *next_hop, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, fib_mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags)
Add one path to an entry (aka route) in the FIB.
Definition: fib_table.c:549
#define SR_STEER_IPV6
Definition: sr_mpls.h:42
#define SR_STEER_IPV4
Definition: sr_mpls.h:41
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
vnet_interface_main_t interface_main
Definition: vnet.h:59
static clib_error_t * sr_steer_policy_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: sr_steering.c:362
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
uword mhash_unset(mhash_t *h, void *key, uword *old_value)
Definition: mhash.c:346
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
vlib_main_t * vm
Definition: in2out_ed.c:1582
unformat_function_t unformat_vnet_sw_interface
vl_api_prefix_t prefix
Definition: ip.api:144
u16 mask
Definition: flow_types.api:52
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:252
static void ip6_address_mask(ip6_address_t *a, const ip6_address_t *mask)
Definition: ip6_packet.h:195
ip6_sr_steering_policy_t * steer_policies
Definition: sr.h:276
format_function_t format_vnet_sw_if_index_name
unsigned char u8
Definition: types.h:56
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:140
static clib_error_t * show_sr_steering_policies_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: sr_steering.c:480
VNET_FEATURE_INIT(sr_pl_rewrite_encaps_l2, static)
u32 * sw_iface_sr_policies
Definition: sr.h:282
Definition: fib_entry.h:120
format_function_t format_ip4_address
Definition: format.h:73
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:513
unformat_function_t unformat_ip4_address
Definition: format.h:68
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
Aggregate type for a prefix.
Definition: fib_types.h:203
#define clib_error_return(e, args...)
Definition: error.h:99
struct sr_steering_key_t::@544::@546 l3
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:281
unsigned int u32
Definition: types.h:88
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:1097
u16 fp_len
The mask length.
Definition: fib_types.h:207
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:534
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:226
struct _unformat_input_t unformat_input_t
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:302
sr_steering_key_t classify
Traffic classification.
Definition: sr.h:241
static uword mhash_set(mhash_t *h, void *key, uword new_value, uword *old_value)
Definition: mhash.h:117
void fib_table_unlock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Take a reference counting lock on the table.
Definition: fib_table.c:1291
u8 is_encap
Mode (0 is SRH insert, 1 Encaps)
Definition: sr.h:109
struct sr_steering_key_t::@544::@547 l2
u32 sr_policy
SR Policy index.
Definition: sr.h:242
unformat_function_t unformat_ip6_address
Definition: format.h:89
vnet_main_t * vnet_main
Definition: sr.h:309
The fine-grained event logger allows lightweight, thread-safe event logging at minimum cost...
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
void mhash_init(mhash_t *h, uword n_value_bytes, uword n_key_bytes)
Definition: mhash.c:168
SRv6 and SR-MPLS.
Definition: fib_source.h:60
format_function_t format_ip6_address
Definition: format.h:91
u8 mask_width
Definition: dhcp.api:204
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
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:886
#define ETHERNET_INTERFACE_FLAG_ACCEPT_ALL
Definition: ethernet.h:152
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:299
Steering db key.
Definition: sr.h:220
int sr_steering_policy(int is_del, ip6_address_t *bsid, u32 sr_policy_index, u32 table_id, ip46_address_t *prefix, u32 mask_width, u32 sw_if_index, u8 traffic_type)
Steer traffic L2 and L3 traffic through a given SR policy.
Definition: sr_steering.c:60
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:158
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:696
static uword * mhash_get(mhash_t *h, const void *key)
Definition: mhash.h:110
#define VNET_FEATURES(...)
Definition: feature.h:470
vl_api_ip4_address_t hi
Definition: arp.api:37
mhash_t sr_policies_index_hash
Definition: sr.h:267
typedef key
Definition: ipsec_types.api:85
clib_error_t * sr_steering_init(vlib_main_t *vm)
Definition: sr_steering.c:538
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
ip6_sr_policy_t * sr_policies
Definition: sr.h:264
mhash_t sr_steer_policies_hash
Definition: sr.h:279
SR Policy.
Definition: sr.h:93
u64 uword
Definition: types.h:112
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:872
u32 table_id
Definition: wireguard.api:100
static void ip6_address_mask_from_width(ip6_address_t *a, u32 width)
Definition: ip6_packet.h:211
Segment Routing data structures definitions.
Segment Routing main datastructure.
Definition: sr.h:255
vnet_sw_interface_type_t type
Definition: interface.h:736
u8 traffic_type
Traffic type (IPv4, IPv6, L2)
Definition: sr.h:235
u32 fib_table_ip4
Definition: sr.h:305
#define SR_STEER_L2
Definition: sr.h:50
u32 fib_table_ip6
Definition: sr.h:304
ip6_address_t bsid
BindingSID (key)
Definition: sr.h:97
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:33
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: feature.c:303
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
u32 ethernet_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:426
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128