FD.io VPP  v20.01-48-g3e0dafb74
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  ethernet_interface_t *eif =
151  ethernet_get_interface (em, sw_if_index);
152 
153  if (!eif)
154  goto cleanup_error_redirection;
155 
156  ethernet_set_flags (vnm, sw_if_index, 0);
157  }
158 
159  /* Delete SR steering policy entry */
160  pool_put (sm->steer_policies, steer_pl);
162 
163  /* If no more SR policies or steering policies */
164  if (!pool_elts (sm->sr_policies) && !pool_elts (sm->steer_policies))
165  {
170  sm->fib_table_ip6 = (u32) ~ 0;
171  sm->fib_table_ip4 = (u32) ~ 0;
172  }
173 
174  return 0;
175  }
176  else /* It means user requested to update an existing SR steering policy */
177  {
178  /* Retrieve SR steering policy */
179  if (bsid)
180  {
181  p = mhash_get (&sm->sr_policies_index_hash, bsid);
182  if (p)
183  sr_policy = pool_elt_at_index (sm->sr_policies, p[0]);
184  else
185  return -2;
186  }
187  else
188  sr_policy = pool_elt_at_index (sm->sr_policies, sr_policy_index);
189 
190  if (!sr_policy)
191  return -2;
192 
193  steer_pl->sr_policy = sr_policy - sm->sr_policies;
194 
195  /* Remove old FIB/hw redirection and create a new one */
196  if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
197  {
198  /* Remove FIB entry */
200  pfx.fp_len = steer_pl->classify.l3.mask_width;
201  pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
202 
205  steer_pl->classify.l3.fib_table),
206  &pfx, FIB_SOURCE_SR);
207 
208  /* Create a new one */
209  goto update_fib;
210  }
211  else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
212  {
213  /* Remove FIB entry */
215  pfx.fp_len = steer_pl->classify.l3.mask_width;
216  pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
217 
220  steer_pl->classify.l3.fib_table),
221  &pfx, FIB_SOURCE_SR);
222 
223  /* Create a new one */
224  goto update_fib;
225  }
226  else if (steer_pl->classify.traffic_type == SR_STEER_L2)
227  {
228  /* Update L2-HW redirection */
229  goto update_fib;
230  }
231  }
232  }
233  else
234  /* delete; steering policy does not exist; complain */
235  if (is_del)
236  return -4;
237 
238  /* Retrieve SR policy */
239  if (bsid)
240  {
241  p = mhash_get (&sm->sr_policies_index_hash, bsid);
242  if (p)
243  sr_policy = pool_elt_at_index (sm->sr_policies, p[0]);
244  else
245  return -2;
246  }
247  else
248  sr_policy = pool_elt_at_index (sm->sr_policies, sr_policy_index);
249 
250  /* Create a new steering policy */
251  pool_get (sm->steer_policies, steer_pl);
252  clib_memset (steer_pl, 0, sizeof (*steer_pl));
253 
254  if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
255  {
256  clib_memcpy_fast (&steer_pl->classify.l3.prefix, prefix,
257  sizeof (ip46_address_t));
258  steer_pl->classify.l3.mask_width = mask_width;
259  steer_pl->classify.l3.fib_table =
260  (table_id != (u32) ~ 0 ? table_id : 0);
261  steer_pl->classify.traffic_type = traffic_type;
262  }
263  else if (traffic_type == SR_STEER_L2)
264  {
265  steer_pl->classify.l2.sw_if_index = sw_if_index;
266  steer_pl->classify.traffic_type = traffic_type;
267  }
268  else
269  {
270  /* Incorrect API usage. Should never get here */
271  pool_put (sm->steer_policies, steer_pl);
273  return -1;
274  }
275  steer_pl->sr_policy = sr_policy - sm->sr_policies;
276 
277  /* Create and store key */
278  mhash_set (&sm->sr_steer_policies_hash, &key, steer_pl - sm->steer_policies,
279  NULL);
280 
281  if (traffic_type == SR_STEER_L2)
282  {
283  if (!sr_policy->is_encap)
284  goto cleanup_error_encap;
285 
287  ("device-input", "sr-pl-rewrite-encaps-l2", sw_if_index, 1, 0, 0))
288  goto cleanup_error_redirection;
289 
290  /* Set promiscous mode on interface */
291  vnet_main_t *vnm = vnet_get_main ();
293  ethernet_interface_t *eif = ethernet_get_interface (em, sw_if_index);
294 
295  if (!eif)
296  goto cleanup_error_redirection;
297 
298  ethernet_set_flags (vnm, sw_if_index,
300  }
301  else if (traffic_type == SR_STEER_IPV4)
302  if (!sr_policy->is_encap)
303  goto cleanup_error_encap;
304 
305 update_fib:
306  /* FIB API calls - Recursive route through the BindingSID */
307  if (traffic_type == SR_STEER_IPV6)
308  {
310  pfx.fp_len = steer_pl->classify.l3.mask_width;
311  pfx.fp_addr.ip6 = steer_pl->classify.l3.prefix.ip6;
312 
314  (table_id !=
315  (u32) ~ 0 ?
316  table_id : 0)),
317  &pfx, FIB_SOURCE_SR,
320  (ip46_address_t *) & sr_policy->bsid, ~0,
321  sm->fib_table_ip6, 1, NULL,
323  }
324  else if (traffic_type == SR_STEER_IPV4)
325  {
327  pfx.fp_len = steer_pl->classify.l3.mask_width;
328  pfx.fp_addr.ip4 = steer_pl->classify.l3.prefix.ip4;
329 
331  (table_id !=
332  (u32) ~ 0 ?
333  table_id : 0)),
334  &pfx, FIB_SOURCE_SR,
337  (ip46_address_t *) & sr_policy->bsid, ~0,
338  sm->fib_table_ip4, 1, NULL,
340  }
341  else if (traffic_type == SR_STEER_L2)
342  {
343  if (sw_if_index < vec_len (sm->sw_iface_sr_policies))
344  sm->sw_iface_sr_policies[sw_if_index] = steer_pl->sr_policy;
345  else
346  {
349  - vec_len (sm->sw_iface_sr_policies)));
350  sm->sw_iface_sr_policies[sw_if_index] = steer_pl->sr_policy;
351  }
352  }
353 
354  return 0;
355 
356 cleanup_error_encap:
357  pool_put (sm->steer_policies, steer_pl);
359  return -5;
360 
361 cleanup_error_redirection:
362  pool_put (sm->steer_policies, steer_pl);
364  return -3;
365 }
366 
367 static clib_error_t *
369  vlib_cli_command_t * cmd)
370 {
371  vnet_main_t *vnm = vnet_get_main ();
372 
373  int is_del = 0;
374 
375  ip46_address_t prefix;
376  u32 dst_mask_width = 0;
377  u32 sw_if_index = (u32) ~ 0;
378  u8 traffic_type = 0;
379  u32 fib_table = (u32) ~ 0;
380 
381  ip6_address_t bsid;
382  u32 sr_policy_index = (u32) ~ 0;
383 
384  u8 sr_policy_set = 0;
385 
386  clib_memset (&prefix, 0, sizeof (ip46_address_t));
387 
388  int rv;
390  {
391  if (unformat (input, "del"))
392  is_del = 1;
393  else if (!traffic_type
394  && unformat (input, "l3 %U/%d", unformat_ip6_address,
395  &prefix.ip6, &dst_mask_width))
396  traffic_type = SR_STEER_IPV6;
397  else if (!traffic_type
398  && unformat (input, "l3 %U/%d", unformat_ip4_address,
399  &prefix.ip4, &dst_mask_width))
400  traffic_type = SR_STEER_IPV4;
401  else if (!traffic_type
402  && unformat (input, "l2 %U", unformat_vnet_sw_interface, vnm,
403  &sw_if_index))
404  traffic_type = SR_STEER_L2;
405  else if (!sr_policy_set
406  && unformat (input, "via index %d", &sr_policy_index))
407  sr_policy_set = 1;
408  else if (!sr_policy_set
409  && unformat (input, "via bsid %U",
410  unformat_ip6_address, &bsid))
411  sr_policy_set = 1;
412  else if (fib_table == (u32) ~ 0
413  && unformat (input, "fib-table %d", &fib_table));
414  else
415  break;
416  }
417 
418  if (!traffic_type)
419  return clib_error_return (0, "No L2/L3 traffic specified");
420  if (!sr_policy_set)
421  return clib_error_return (0, "No SR policy specified");
422 
423  /* Make sure that the prefixes are clean */
424  if (traffic_type == SR_STEER_IPV4)
425  {
426  u32 mask =
427  (dst_mask_width ? (0xFFFFFFFFu >> (32 - dst_mask_width)) : 0);
428  prefix.ip4.as_u32 &= mask;
429  }
430  else if (traffic_type == SR_STEER_IPV6)
431  {
432  ip6_address_t mask;
433  ip6_address_mask_from_width (&mask, dst_mask_width);
434  ip6_address_mask (&prefix.ip6, &mask);
435  }
436 
437  rv =
438  sr_steering_policy (is_del, (sr_policy_index == ~(u32) 0 ? &bsid : NULL),
439  sr_policy_index, fib_table, &prefix, dst_mask_width,
440  sw_if_index, traffic_type);
441 
442  switch (rv)
443  {
444  case 0:
445  break;
446  case 1:
447  return 0;
448  case -1:
449  return clib_error_return (0, "Incorrect API usage.");
450  case -2:
451  return clib_error_return (0,
452  "The requested SR policy could not be located. Review the BSID/index.");
453  case -3:
454  return clib_error_return (0,
455  "Unable to do SW redirect. Incorrect interface.");
456  case -4:
457  return clib_error_return (0,
458  "The requested SR steering policy could not be deleted.");
459  case -5:
460  return clib_error_return (0,
461  "The SR policy is not an encapsulation one.");
462  default:
463  return clib_error_return (0, "BUG: sr steer policy returns %d", rv);
464  }
465  return 0;
466 }
467 
468 /* *INDENT-OFF* */
469 VLIB_CLI_COMMAND (sr_steer_policy_command, static) = {
470  .path = "sr steer",
471  .short_help = "sr steer (del) [l3 <ip_addr/mask>|l2 <sf_if>] "
472  "via [index <sr_policy_index>|bsid <bsid_ip6_addr>] "
473  "(fib-table <fib_table_index>)",
474  .long_help =
475  "\tSteer a L2 or L3 traffic through an existing SR policy.\n"
476  "\tExamples:\n"
477  "\t\tsr steer l3 2001::/64 via sr_policy index 5\n"
478  "\t\tsr steer l3 2001::/64 via sr_policy bsid 2010::9999:1\n"
479  "\t\tsr steer l2 GigabitEthernet0/5/0 via sr_policy index 5\n"
480  "\t\tsr steer del l3 2001::/64 via sr_policy index 5\n",
481  .function = sr_steer_policy_command_fn,
482 };
483 /* *INDENT-ON* */
484 
485 static clib_error_t *
487  unformat_input_t * input,
488  vlib_cli_command_t * cmd)
489 {
490  ip6_sr_main_t *sm = &sr_main;
491  ip6_sr_steering_policy_t **steer_policies = 0;
492  ip6_sr_steering_policy_t *steer_pl;
493 
494  vnet_main_t *vnm = vnet_get_main ();
495 
496  ip6_sr_policy_t *pl = 0;
497  int i;
498 
499  vlib_cli_output (vm, "SR steering policies:");
500  /* *INDENT-OFF* */
501  pool_foreach (steer_pl, sm->steer_policies, ({vec_add1(steer_policies, steer_pl);}));
502  /* *INDENT-ON* */
503  vlib_cli_output (vm, "Traffic\t\tSR policy BSID");
504  for (i = 0; i < vec_len (steer_policies); i++)
505  {
506  steer_pl = steer_policies[i];
507  pl = pool_elt_at_index (sm->sr_policies, steer_pl->sr_policy);
508  if (steer_pl->classify.traffic_type == SR_STEER_L2)
509  {
510  vlib_cli_output (vm, "L2 %U\t%U",
512  steer_pl->classify.l2.sw_if_index,
513  format_ip6_address, &pl->bsid);
514  }
515  else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
516  {
517  vlib_cli_output (vm, "L3 %U/%d\t%U",
519  &steer_pl->classify.l3.prefix.ip4,
520  steer_pl->classify.l3.mask_width,
521  format_ip6_address, &pl->bsid);
522  }
523  else if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
524  {
525  vlib_cli_output (vm, "L3 %U/%d\t%U",
527  &steer_pl->classify.l3.prefix.ip6,
528  steer_pl->classify.l3.mask_width,
529  format_ip6_address, &pl->bsid);
530  }
531  }
532  return 0;
533 }
534 
535 /* *INDENT-OFF* */
536 VLIB_CLI_COMMAND (show_sr_steering_policies_command, static) = {
537  .path = "show sr steering-policies",
538  .short_help = "show sr steering-policies",
540 };
541 /* *INDENT-ON* */
542 
543 clib_error_t *
545 {
546  ip6_sr_main_t *sm = &sr_main;
547 
548  /* Init memory for function keys */
549  mhash_init (&sm->sr_steer_policies_hash, sizeof (uword),
550  sizeof (sr_steering_key_t));
551 
552  sm->sw_iface_sr_policies = 0;
553 
554  sm->vnet_main = vnet_get_main ();
555 
556  return 0;
557 }
558 
559 /* *INDENT-OFF* */
561 /* *INDENT-ON* */
562 
563 /* *INDENT-OFF* */
564 VNET_FEATURE_INIT (sr_pl_rewrite_encaps_l2, static) =
565 {
566  .arc_name = "device-input",
567  .node_name = "sr-pl-rewrite-encaps-l2",
568  .runs_before = VNET_FEATURES ("ethernet-input"),
569 };
570 /* *INDENT-ON* */
571 
572 /*
573 * fd.io coding-style-patch-verification: ON
574 *
575 * Local Variables:
576 * eval: (c-set-style "gnu")
577 * End:
578 */
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
vnet_interface_main_t interface_main
Definition: vnet.h:56
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:368
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
#define NULL
Definition: clib.h:58
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)
int i
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
unformat_function_t unformat_vnet_sw_interface
vl_api_prefix_t prefix
Definition: ip.api:144
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:237
static void ip6_address_mask(ip6_address_t *a, const ip6_address_t *mask)
Definition: ip6_packet.h:192
ip6_sr_steering_policy_t * steer_policies
Definition: sr.h:258
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:486
VNET_FEATURE_INIT(sr_pl_rewrite_encaps_l2, static)
struct sr_steering_key_t::@454::@457 l2
u32 * sw_iface_sr_policies
Definition: sr.h:264
Definition: fib_entry.h:120
ethernet_main_t ethernet_main
Definition: init.c:45
format_function_t format_ip4_address
Definition: format.h:73
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:498
unformat_function_t unformat_ip4_address
Definition: format.h:68
vl_api_interface_index_t sw_if_index
Definition: gre.api:59
#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
#define vec_resize(V, N)
Resize a vector (no header, unspecified alignment) Add N elements to end of given vector V...
Definition: vec.h:243
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
struct sr_steering_key_t::@454::@456 l3
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:519
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:287
sr_steering_key_t classify
Traffic classification.
Definition: sr.h:230
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:107
vlib_main_t * vm
Definition: in2out_ed.c:1810
u32 sr_policy
SR Policy index.
Definition: sr.h:231
unformat_function_t unformat_ip6_address
Definition: format.h:89
vnet_main_t * vnet_main
Definition: sr.h:291
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
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:141
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:284
Steering db key.
Definition: sr.h:209
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:152
static uword * mhash_get(mhash_t *h, const void *key)
Definition: mhash.h:110
#define VNET_FEATURES(...)
Definition: feature.h:442
mhash_t sr_policies_index_hash
Definition: sr.h:249
typedef key
Definition: ipsec_types.api:83
clib_error_t * sr_steering_init(vlib_main_t *vm)
Definition: sr_steering.c:544
ethernet_interface_t * ethernet_get_interface(ethernet_main_t *em, u32 hw_if_index)
Definition: interface.c:940
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
ip6_sr_policy_t * sr_policies
Definition: sr.h:246
mhash_t sr_steer_policies_hash
Definition: sr.h:261
SR Policy.
Definition: sr.h:91
u64 uword
Definition: types.h:112
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:854
static void ip6_address_mask_from_width(ip6_address_t *a, u32 width)
Definition: ip6_packet.h:208
Segment Routing data structures definitions.
Segment Routing main datastructure.
Definition: sr.h:237
vnet_sw_interface_type_t type
Definition: interface.h:718
u8 traffic_type
Traffic type (IPv4, IPv6, L2)
Definition: sr.h:224
u32 fib_table_ip4
Definition: sr.h:287
#define SR_STEER_L2
Definition: sr.h:48
u32 table_id
Definition: fib_types.api:118
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:689
u32 fib_table_ip6
Definition: sr.h:286
ip6_address_t bsid
BindingSID (key)
Definition: sr.h:95
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:304
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