2 * sr_steering.c: ipv6 segment routing steering into SR policy
4 * Copyright (c) 2016 Cisco and/or its affiliates. Licensed under the Apache
5 * License, Version 2.0 (the "License"); you may not use this file except in
6 * compliance with the License. You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations
19 * @brief Packet steering into SR-MPLS Policies
21 * This file is in charge of handling the FIB appropiatly to steer packets
22 * through SR Policies as defined in 'sr_mpls_policy.c'. Notice that here
23 * we are only doing steering. SR policy application is done in
27 * - Steering of IPv6 traffic Destination Address based through BSID
28 * - Steering of IPv4 traffic Destination Address based through BSID
29 * - Steering of IPv4 and IPv6 traffic through N,C (SR CP)
32 #include <vlib/vlib.h>
33 #include <vnet/vnet.h>
34 #include <vnet/srmpls/sr_mpls.h>
35 #include <vnet/ip/ip4_packet.h>
36 #include <vnet/ip/ip6_packet.h>
37 #include <vnet/fib/mpls_fib.h>
39 #include <vppinfra/error.h>
40 #include <vppinfra/elog.h>
42 #define SRMPLS_TE_OFFSET 50
45 * @brief function to sort the colors in descending order
48 sort_color_descent (const u32 * x, u32 * y)
53 /********************* Internal (NH, C) labels *******************************/
55 * @brief find the corresponding label for (endpoint, color) and lock it
56 * endpoint might be NULL or ANY
60 find_or_create_internal_label (ip46_address_t endpoint, u32 color)
62 mpls_sr_main_t *sm = &sr_mpls_main;
63 uword *color_table, *result_label;
65 if (!sm->sr_policies_c2e2eclabel_hash.hash)
66 mhash_init (&sm->sr_policies_c2e2eclabel_hash, sizeof (mhash_t),
69 color_table = mhash_get (&sm->sr_policies_c2e2eclabel_hash, &color);
73 memset (&color_t, 0, sizeof (mhash_t));
74 mhash_init (&color_t, sizeof (u32), sizeof (ip46_address_t));
75 mhash_set_mem (&sm->sr_policies_c2e2eclabel_hash, &color,
76 (uword *) & color_t, NULL);
77 color_table = mhash_get (&sm->sr_policies_c2e2eclabel_hash, &color);
80 result_label = mhash_get ((mhash_t *) color_table, &endpoint);
83 return (u32) * result_label;
85 /* Create and set a new internal label */
86 u32 *new_internal_label = 0;
87 pool_get (sm->ec_labels, new_internal_label);
88 *new_internal_label = 0;
89 mhash_set ((mhash_t *) color_table, &endpoint,
90 (new_internal_label - sm->ec_labels) + SRMPLS_TE_OFFSET, NULL);
92 return (new_internal_label - sm->ec_labels) + SRMPLS_TE_OFFSET;
96 internal_label_lock_co (ip46_address_t endpoint, u32 color, char co_bits)
98 ip46_address_t zero, any;
99 ip46_address_reset (&zero);
100 any.as_u64[0] = any.as_u64[1] = (u64) ~ 0;
103 case SR_TE_CO_BITS_10:
104 internal_label_lock (endpoint, color);
105 internal_label_lock (zero, color);
106 internal_label_lock (any, color);
108 case SR_TE_CO_BITS_01:
109 internal_label_lock (endpoint, color);
110 internal_label_lock (zero, color);
112 case SR_TE_CO_BITS_00:
113 case SR_TE_CO_BITS_11:
114 internal_label_lock (endpoint, color);
120 * @brief lock the label for (NH, C)
121 * endpoint might be NULL or ANY
125 internal_label_lock (ip46_address_t endpoint, u32 color)
127 mpls_sr_main_t *sm = &sr_mpls_main;
128 uword *color_table, *result_label;
130 if (!sm->sr_policies_c2e2eclabel_hash.hash)
133 color_table = mhash_get (&sm->sr_policies_c2e2eclabel_hash, &color);
137 result_label = mhash_get ((mhash_t *) color_table, &endpoint);
144 pool_elt_at_index (sm->ec_labels, *result_label - SRMPLS_TE_OFFSET);
150 internal_label_unlock_co (ip46_address_t endpoint, u32 color, char co_bits)
152 ip46_address_t zero, any;
153 ip46_address_reset (&zero);
154 any.as_u64[0] = any.as_u64[1] = (u64) ~ 0;
157 case SR_TE_CO_BITS_10:
158 internal_label_unlock (endpoint, color);
159 internal_label_unlock (zero, color);
160 internal_label_unlock (any, color);
162 case SR_TE_CO_BITS_01:
163 internal_label_unlock (endpoint, color);
164 internal_label_unlock (zero, color);
166 case SR_TE_CO_BITS_00:
167 case SR_TE_CO_BITS_11:
168 internal_label_unlock (endpoint, color);
174 * @brief Release lock on label for (endpoint, color)
175 * endpoint might be NULL or ANY
179 internal_label_unlock (ip46_address_t endpoint, u32 color)
181 mpls_sr_main_t *sm = &sr_mpls_main;
182 uword *color_table, *result_label;
184 if (!sm->sr_policies_c2e2eclabel_hash.hash)
187 color_table = mhash_get (&sm->sr_policies_c2e2eclabel_hash, &color);
191 result_label = mhash_get ((mhash_t *) color_table, &endpoint);
197 pool_elt_at_index (sm->ec_labels, *result_label - SRMPLS_TE_OFFSET);
200 if (*label_lock == 0)
202 pool_put (sm->ec_labels, label_lock);
203 mhash_unset ((mhash_t *) color_table, &endpoint, NULL);
204 if (mhash_elts ((mhash_t *) color_table) == 0)
206 mhash_free ((mhash_t *) color_table);
207 mhash_unset (&sm->sr_policies_c2e2eclabel_hash, &color, NULL);
208 if (mhash_elts (&sm->sr_policies_c2e2eclabel_hash) == 0)
210 mhash_free (&sm->sr_policies_c2e2eclabel_hash);
211 sm->sr_policies_c2e2eclabel_hash.hash = NULL;
212 fib_table_unlock (sm->fib_table_EC, FIB_PROTOCOL_MPLS,
214 sm->fib_table_EC = (u32) ~ 0;
220 /********************* steering computation *********************************/
222 * @brief function to update the FIB
225 compute_sr_te_automated_steering_fib_entry (mpls_sr_steering_policy_t *
228 mpls_sr_main_t *sm = &sr_mpls_main;
229 fib_prefix_t pfx = { 0 };
231 u32 *internal_labels = 0;
232 ip46_address_t zero, any;
233 ip46_address_reset (&zero);
234 any.as_u64[0] = any.as_u64[1] = (u64) ~ 0;
237 vec_foreach (color_i, steer_pl->color)
239 switch (steer_pl->co_bits)
241 case SR_TE_CO_BITS_10:
242 vec_add1 (internal_labels,
243 find_or_create_internal_label (steer_pl->next_hop,
245 vec_add1 (internal_labels,
246 find_or_create_internal_label (zero, *color_i));
247 vec_add1 (internal_labels,
248 find_or_create_internal_label (any, *color_i));
250 case SR_TE_CO_BITS_01:
251 vec_add1 (internal_labels,
252 find_or_create_internal_label (steer_pl->next_hop,
254 vec_add1 (internal_labels,
255 find_or_create_internal_label (zero, *color_i));
257 case SR_TE_CO_BITS_00:
258 case SR_TE_CO_BITS_11:
259 vec_add1 (internal_labels,
260 find_or_create_internal_label (steer_pl->next_hop,
266 /* Does hidden FIB already exist? */
267 if (sm->fib_table_EC == (u32) ~ 0)
269 sm->fib_table_EC = fib_table_create_and_lock (FIB_PROTOCOL_MPLS,
271 "SR-MPLS Traffic Engineering (NextHop,Color)");
273 fib_table_flush (sm->fib_table_EC, FIB_PROTOCOL_MPLS,
277 /* Add the corresponding FIB entries */
278 fib_route_path_t path = {
279 .frp_proto = DPO_PROTO_MPLS,
281 .frp_sw_if_index = ~0,
282 .frp_fib_index = sm->fib_table_EC,
284 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
287 fib_route_path_t *paths = NULL;
289 if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
291 pfx.fp_proto = FIB_PROTOCOL_IP6;
292 pfx.fp_len = steer_pl->classify.mask_width;
293 pfx.fp_addr.ip6 = steer_pl->classify.prefix.ip6;
295 else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
297 pfx.fp_proto = FIB_PROTOCOL_IP4;
298 pfx.fp_len = steer_pl->classify.mask_width;
299 pfx.fp_addr.ip4 = steer_pl->classify.prefix.ip4;
302 if (steer_pl->vpn_label != (u32) ~ 0)
304 vec_add1 (path.frp_label_stack, steer_pl->vpn_label);
305 path.frp_eos = MPLS_NON_EOS;
309 vec_foreach_index (label_i, internal_labels)
311 path.frp_local_label = internal_labels[label_i];
312 path.frp_preference = label_i;
313 vec_add1 (paths, path);
316 /* Finally we must add to FIB IGP to N */
317 clib_memcpy (&path.frp_addr, &steer_pl->next_hop,
318 sizeof (steer_pl->next_hop));
319 path.frp_preference = vec_len (internal_labels);
320 path.frp_label_stack = NULL;
322 if (steer_pl->nh_type == SR_STEER_IPV6)
324 path.frp_proto = DPO_PROTO_IP6;
326 fib_table_find (FIB_PROTOCOL_IP6,
327 (steer_pl->classify.fib_table !=
328 (u32) ~ 0 ? steer_pl->classify.fib_table : 0));
330 else if (steer_pl->nh_type == SR_STEER_IPV4)
332 path.frp_proto = DPO_PROTO_IP4;
334 fib_table_find (FIB_PROTOCOL_IP4,
335 (steer_pl->classify.fib_table !=
336 (u32) ~ 0 ? steer_pl->classify.fib_table : 0));
339 vec_add1 (paths, path);
340 if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
341 fib_table_entry_update (fib_table_find
343 (steer_pl->classify.fib_table !=
344 (u32) ~ 0 ? steer_pl->classify.fib_table : 0)),
346 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT, paths);
347 else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
348 fib_table_entry_update (fib_table_find
350 (steer_pl->classify.fib_table !=
351 (u32) ~ 0 ? steer_pl->classify.fib_table : 0)),
353 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT, paths);
360 * @brief Steer traffic L3 traffic through a given SR-MPLS policy
363 * @param bsid is the bindingSID of the SR Policy (alt to sr_policy_index)
364 * @param sr_policy is the index of the SR Policy (alt to bsid)
365 * @param table_id is the VRF where to install the FIB entry for the BSID
366 * @param prefix is the IPv4/v6 address for L3 traffic type
367 * @param mask_width is the mask for L3 traffic type
368 * @param traffic_type describes the type of traffic
369 * @param next_hop SR TE Next-Hop
370 * @param nh_type is the AF of Next-Hop
371 * @param color SR TE color
372 * @param co_bits SR TE color-only bits
374 * @return 0 if correct, else error
377 sr_mpls_steering_policy_add (mpls_label_t bsid, u32 table_id,
378 ip46_address_t * prefix, u32 mask_width,
379 u8 traffic_type, ip46_address_t * next_hop,
380 u8 nh_type, u32 color, char co_bits,
381 mpls_label_t vpn_label)
383 mpls_sr_main_t *sm = &sr_mpls_main;
384 sr_mpls_steering_key_t key;
385 mpls_sr_steering_policy_t *steer_pl;
386 fib_prefix_t pfx = { 0 };
388 mpls_sr_policy_t *sr_policy = 0;
391 memset (&key, 0, sizeof (sr_mpls_steering_key_t));
393 /* Compute the steer policy key */
394 if (traffic_type == SR_STEER_IPV4 || traffic_type == SR_STEER_IPV6)
396 key.prefix.as_u64[0] = prefix->as_u64[0];
397 key.prefix.as_u64[1] = prefix->as_u64[1];
398 key.mask_width = mask_width;
399 key.fib_table = (table_id != (u32) ~ 0 ? table_id : 0);
404 key.traffic_type = traffic_type;
406 if (traffic_type != SR_STEER_IPV4 && traffic_type != SR_STEER_IPV6)
410 * Search for steering policy. If already exists we are adding a new
413 if (!sm->sr_steer_policies_hash.hash)
414 mhash_init (&sm->sr_steer_policies_hash, sizeof (uword),
415 sizeof (sr_mpls_steering_key_t));
417 p = mhash_get (&sm->sr_steer_policies_hash, &key);
420 steer_pl = pool_elt_at_index (sm->steer_policies, p[0]);
421 if (steer_pl->bsid != (u32) ~ 0)
422 return -1; //Means we are rewritting the steering. Not allowed.
424 /* Means we are adding a color. Check that NH match. */
425 if (ip46_address_cmp (&steer_pl->next_hop, next_hop))
427 if (vec_search (steer_pl->color, color) != ~0)
429 if (steer_pl->co_bits != co_bits)
430 return -4; /* CO colors should be the same */
431 if (steer_pl->vpn_label != vpn_label)
432 return -5; /* VPN label should be the same */
434 /* Remove the steering and ReDo it */
435 vec_add1 (steer_pl->color, color);
436 vec_sort_with_function (steer_pl->color, sort_color_descent);
437 compute_sr_te_automated_steering_fib_entry (steer_pl);
438 internal_label_lock_co (steer_pl->next_hop, color, steer_pl->co_bits);
442 /* Create a new steering policy */
443 pool_get (sm->steer_policies, steer_pl);
444 memset (steer_pl, 0, sizeof (*steer_pl));
445 clib_memcpy (&steer_pl->classify.prefix, prefix, sizeof (ip46_address_t));
446 clib_memcpy (&steer_pl->next_hop, next_hop, sizeof (ip46_address_t));
447 steer_pl->nh_type = nh_type;
448 steer_pl->co_bits = co_bits;
449 steer_pl->classify.mask_width = mask_width;
450 steer_pl->classify.fib_table = (table_id != (u32) ~ 0 ? table_id : 0);
451 steer_pl->classify.traffic_type = traffic_type;
452 steer_pl->color = NULL;
453 steer_pl->vpn_label = vpn_label;
455 /* Create and store key */
456 mhash_set (&sm->sr_steer_policies_hash, &key, steer_pl - sm->steer_policies,
460 if (bsid != (u32) ~ 0)
462 if (!sm->sr_policies_index_hash)
463 sm->sr_policies_index_hash = hash_create (0, sizeof (mpls_label_t));
464 steer_pl->bsid = bsid;
465 p = hash_get (sm->sr_policies_index_hash, bsid);
468 sr_policy = pool_elt_at_index (sm->sr_policies, p[0]);
470 fib_route_path_t path = {
471 .frp_proto = DPO_PROTO_MPLS,
472 .frp_local_label = sr_policy->bsid,
474 .frp_sw_if_index = ~0,
477 .frp_flags = FIB_ROUTE_PATH_FLAG_NONE,
480 fib_route_path_t *paths = NULL;
482 if (steer_pl->vpn_label != (u32) ~ 0)
483 vec_add1 (path.frp_label_stack, steer_pl->vpn_label);
485 /* FIB API calls - Recursive route through the BindingSID */
486 if (traffic_type == SR_STEER_IPV6)
488 pfx.fp_proto = FIB_PROTOCOL_IP6;
489 pfx.fp_len = steer_pl->classify.mask_width;
490 pfx.fp_addr.ip6 = steer_pl->classify.prefix.ip6;
491 path.frp_fib_index = 0;
492 path.frp_preference = 0;
493 vec_add1 (paths, path);
494 fib_table_entry_path_add2 (fib_table_find
496 (table_id != (u32) ~ 0 ? table_id : 0)),
498 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT, paths);
501 else if (traffic_type == SR_STEER_IPV4)
503 pfx.fp_proto = FIB_PROTOCOL_IP4;
504 pfx.fp_len = steer_pl->classify.mask_width;
505 pfx.fp_addr.ip4 = steer_pl->classify.prefix.ip4;
506 path.frp_fib_index = 0;
507 path.frp_preference = 0;
508 vec_add1 (paths, path);
509 fib_table_entry_path_add2 (fib_table_find
511 (table_id != (u32) ~ 0 ? table_id : 0)),
513 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT, paths);
517 /* Automated steering */
520 steer_pl->bsid = (u32) ~ 0;
521 vec_add1 (steer_pl->color, color);
522 compute_sr_te_automated_steering_fib_entry (steer_pl);
523 internal_label_lock_co (steer_pl->next_hop, color, steer_pl->co_bits);
529 * @brief Delete steering rule for an SR-MPLS policy
532 * @param bsid is the bindingSID of the SR Policy (alt to sr_policy_index)
533 * @param sr_policy is the index of the SR Policy (alt to bsid)
534 * @param table_id is the VRF where to install the FIB entry for the BSID
535 * @param prefix is the IPv4/v6 address for L3 traffic type
536 * @param mask_width is the mask for L3 traffic type
537 * @param traffic_type describes the type of traffic
538 * @param next_hop SR TE Next-HOP
539 * @param nh_type is the AF of Next-Hop
540 * @param color SR TE color
542 * @return 0 if correct, else error
545 sr_mpls_steering_policy_del (ip46_address_t * prefix, u32 mask_width,
546 u8 traffic_type, u32 table_id, u32 color)
548 mpls_sr_main_t *sm = &sr_mpls_main;
549 sr_mpls_steering_key_t key;
550 mpls_sr_steering_policy_t *steer_pl;
551 fib_prefix_t pfx = { 0 };
554 memset (&key, 0, sizeof (sr_mpls_steering_key_t));
556 /* Compute the steer policy key */
557 if (traffic_type != SR_STEER_IPV4 && traffic_type != SR_STEER_IPV6)
560 key.prefix.as_u64[0] = prefix->as_u64[0];
561 key.prefix.as_u64[1] = prefix->as_u64[1];
562 key.mask_width = mask_width;
563 key.fib_table = (table_id != (u32) ~ 0 ? table_id : 0);
564 key.traffic_type = traffic_type;
566 if (!sm->sr_steer_policies_hash.hash)
567 mhash_init (&sm->sr_steer_policies_hash, sizeof (uword),
568 sizeof (sr_mpls_steering_key_t));
570 /* Search for the item */
571 p = mhash_get (&sm->sr_steer_policies_hash, &key);
576 /* Retrieve Steer Policy function */
577 steer_pl = pool_elt_at_index (sm->steer_policies, p[0]);
579 if (steer_pl->bsid == (u32) ~ 0)
581 /* Remove the color from the color vector */
582 vec_del1 (steer_pl->color, vec_search (steer_pl->color, color));
584 if (vec_len (steer_pl->color))
587 vec_sort_with_function (steer_pl->color, sort_color_descent);
588 compute_sr_te_automated_steering_fib_entry (steer_pl);
589 /* Remove all the locks for this ones... */
590 internal_label_unlock_co (steer_pl->next_hop, color,
596 vec_free (steer_pl->color);
597 /* Remove FIB entry */
598 if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
600 pfx.fp_proto = FIB_PROTOCOL_IP6;
601 pfx.fp_len = steer_pl->classify.mask_width;
602 pfx.fp_addr.ip6 = steer_pl->classify.prefix.ip6;
603 fib_table_entry_delete (fib_table_find
605 steer_pl->classify.fib_table), &pfx,
608 else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
610 pfx.fp_proto = FIB_PROTOCOL_IP4;
611 pfx.fp_len = steer_pl->classify.mask_width;
612 pfx.fp_addr.ip4 = steer_pl->classify.prefix.ip4;
613 fib_table_entry_delete (fib_table_find
615 steer_pl->classify.fib_table), &pfx,
618 /* Remove all the locks for this ones... */
619 internal_label_unlock_co (steer_pl->next_hop, color,
623 else //Remove by BSID
625 if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
627 pfx.fp_proto = FIB_PROTOCOL_IP6;
628 pfx.fp_len = steer_pl->classify.mask_width;
629 pfx.fp_addr.ip6 = steer_pl->classify.prefix.ip6;
630 fib_table_entry_delete (fib_table_find
632 steer_pl->classify.fib_table), &pfx,
635 else if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
637 pfx.fp_proto = FIB_PROTOCOL_IP4;
638 pfx.fp_len = steer_pl->classify.mask_width;
639 pfx.fp_addr.ip4 = steer_pl->classify.prefix.ip4;
640 fib_table_entry_delete (fib_table_find
642 steer_pl->classify.fib_table), &pfx,
646 /* Delete SR steering policy entry */
647 pool_put (sm->steer_policies, steer_pl);
648 mhash_unset (&sm->sr_steer_policies_hash, &key, NULL);
649 if (mhash_elts (&sm->sr_steer_policies_hash) == 0)
651 mhash_free (&sm->sr_steer_policies_hash);
652 sm->sr_steer_policies_hash.hash = NULL;
657 static clib_error_t *
658 sr_mpls_steer_policy_command_fn (vlib_main_t * vm, unformat_input_t * input,
659 vlib_cli_command_t * cmd)
663 ip46_address_t prefix, nh;
664 u32 dst_mask_width = 0;
667 u32 fib_table = (u32) ~ 0, color = (u32) ~ 0;
670 mpls_label_t bsid, vpn_label = (u32) ~ 0;
672 u8 sr_policy_set = 0;
674 memset (&prefix, 0, sizeof (ip46_address_t));
675 memset (&nh, 0, sizeof (ip46_address_t));
678 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
680 if (unformat (input, "del"))
682 else if (!traffic_type
683 && unformat (input, "l3 %U/%d", unformat_ip6_address,
684 &prefix.ip6, &dst_mask_width))
685 traffic_type = SR_STEER_IPV6;
686 else if (!traffic_type
687 && unformat (input, "l3 %U/%d", unformat_ip4_address,
688 &prefix.ip4, &dst_mask_width))
689 traffic_type = SR_STEER_IPV4;
690 else if (!sr_policy_set
691 && unformat (input, "via sr policy bsid %U",
692 unformat_mpls_unicast_label, &bsid))
694 else if (!sr_policy_set
695 && unformat (input, "via next-hop %U color %d co %d",
696 unformat_ip4_address, &nh.ip4, &color, &co_bits))
699 nh_type = SR_STEER_IPV4;
701 else if (!sr_policy_set
702 && unformat (input, "via next-hop %U color %d co %d",
703 unformat_ip6_address, &nh.ip6, &color, &co_bits))
706 nh_type = SR_STEER_IPV6;
708 else if (fib_table == (u32) ~ 0
709 && unformat (input, "fib-table %d", &fib_table));
710 else if (unformat (input, "vpn-label %U",
711 unformat_mpls_unicast_label, &vpn_label));
717 return clib_error_return (0, "No L3 traffic specified");
719 return clib_error_return (0, "No SR policy specified");
721 /* Make sure that the prefixes are clean */
722 if (traffic_type == SR_STEER_IPV4)
725 (dst_mask_width ? (0xFFFFFFFFu >> (32 - dst_mask_width)) : 0);
726 prefix.ip4.as_u32 &= mask;
728 else if (traffic_type == SR_STEER_IPV6)
731 ip6_address_mask_from_width (&mask, dst_mask_width);
732 ip6_address_mask (&prefix.ip6, &mask);
740 sr_mpls_steering_policy_del (&prefix, dst_mask_width,
741 traffic_type, fib_table, color);
745 sr_mpls_steering_policy_add (bsid, fib_table, &prefix, dst_mask_width,
746 traffic_type, &nh, nh_type, color, co_bits,
756 return clib_error_return (0, "Incorrect API usage.");
758 return clib_error_return (0, "The Next-Hop does not match.");
760 return clib_error_return (0, "The color already exists.");
762 return clib_error_return (0, "The co-bits do not match.");
764 return clib_error_return (0, "The VPN-labels do not match.");
766 return clib_error_return (0, "BUG: sr steer policy returns %d", rv);
772 VLIB_CLI_COMMAND(sr_mpls_steer_policy_command, static)=
774 .path = "sr mpls steer",
775 .short_help = "sr mpls steer (del) l3 <ip_addr/mask> "
776 "via [sr policy bsid <mpls_label> || next-hop <ip46_addr> color <u32> co <0|1|2|3> ](fib-table <fib_table_index>)(vpn-label 500)",
778 "\tSteer L3 traffic through an existing SR policy.\n"
780 "\t\tsr steer l3 2001::/64 via sr_policy bsid 29999\n"
781 "\t\tsr steer del l3 2001::/64 via sr_policy bsid 29999\n"
782 "\t\tsr steer l3 2001::/64 via next-hop 1.1.1.1 color 1234 co 0\n"
783 "\t\tsr steer l3 2001::/64 via next-hop 2001::1 color 1234 co 2 vpn-label 500\n",
784 .function = sr_mpls_steer_policy_command_fn,
788 static clib_error_t *
789 show_sr_mpls_steering_policies_command_fn (vlib_main_t * vm,
790 unformat_input_t * input,
791 vlib_cli_command_t * cmd)
793 mpls_sr_main_t *sm = &sr_mpls_main;
794 mpls_sr_steering_policy_t **steer_policies = 0;
795 mpls_sr_steering_policy_t *steer_pl;
799 vlib_cli_output (vm, "SR MPLS steering policies:");
801 pool_foreach(steer_pl, sm->steer_policies, ({
802 vec_add1(steer_policies, steer_pl);
805 for (i = 0; i < vec_len (steer_policies); i++)
807 vlib_cli_output (vm, "==========================");
808 steer_pl = steer_policies[i];
809 if (steer_pl->classify.traffic_type == SR_STEER_IPV4)
811 vlib_cli_output (vm, "Prefix: %U/%d via:",
813 &steer_pl->classify.prefix.ip4,
814 steer_pl->classify.mask_width);
816 else if (steer_pl->classify.traffic_type == SR_STEER_IPV6)
818 vlib_cli_output (vm, "Prefix: %U/%d via:",
820 &steer_pl->classify.prefix.ip6,
821 steer_pl->classify.mask_width);
824 if (steer_pl->bsid != (u32) ~ 0)
826 vlib_cli_output (vm, "· BSID %U",
827 format_mpls_unicast_label, steer_pl->bsid);
831 if (steer_pl->nh_type == SR_STEER_IPV4)
833 vlib_cli_output (vm, "· Next-hop %U",
834 format_ip4_address, &steer_pl->next_hop.ip4);
836 else if (steer_pl->nh_type == SR_STEER_IPV6)
838 vlib_cli_output (vm, "· Next-hop %U",
839 format_ip6_address, &steer_pl->next_hop.ip6);
844 s = format (s, "[ ");
845 vec_foreach (color_i, steer_pl->color)
847 s = format (s, "%d, ", *color_i);
849 s = format (s, "\b\b ]");
850 vlib_cli_output (vm, "· Color %s", s);
852 switch (steer_pl->co_bits)
854 case SR_TE_CO_BITS_00:
855 vlib_cli_output (vm, "· CO-bits: 00");
857 case SR_TE_CO_BITS_01:
858 vlib_cli_output (vm, "· CO-bits: 01");
860 case SR_TE_CO_BITS_10:
861 vlib_cli_output (vm, "· CO-bits: 10");
863 case SR_TE_CO_BITS_11:
864 vlib_cli_output (vm, "· CO-bits: 11");
873 VLIB_CLI_COMMAND(show_sr_mpls_steering_policies_command, static)=
875 .path = "show sr mpls steering policies",
876 .short_help = "show sr mpls steering policies",
877 .function = show_sr_mpls_steering_policies_command_fn,
882 sr_mpls_steering_init (vlib_main_t * vm)
884 mpls_sr_main_t *sm = &sr_mpls_main;
886 /* Init memory for function keys */
887 sm->sr_steer_policies_hash.hash = NULL;
889 sm->fib_table_EC = (u32) ~ 0;
896 VLIB_INIT_FUNCTION(sr_mpls_steering_init);
900 * fd.io coding-style-patch-verification: ON
902 * Local Variables: eval: (c-set-style "gnu") End: