2 * gbp.h : Group Based Policy
4 * Copyright (c) 2018 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:
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include <plugins/gbp/gbp.h>
19 #include <plugins/gbp/gbp_bridge_domain.h>
20 #include <plugins/gbp/gbp_route_domain.h>
21 #include <plugins/gbp/gbp_policy_dpo.h>
22 #include <plugins/gbp/gbp_contract.h>
24 #include <vnet/dpo/load_balance.h>
25 #include <vnet/dpo/drop_dpo.h>
27 char *gbp_contract_error_strings[] = {
28 #define _(sym,string) string,
29 foreach_gbp_contract_error
34 * Single contract DB instance
36 gbp_contract_db_t gbp_contract_db;
38 gbp_contract_t *gbp_contract_pool;
40 vlib_log_class_t gc_logger;
42 fib_node_type_t gbp_next_hop_fib_type;
44 gbp_rule_t *gbp_rule_pool;
45 gbp_next_hop_t *gbp_next_hop_pool;
47 #define GBP_CONTRACT_DBG(...) \
48 vlib_log_notice (gc_logger, __VA_ARGS__);
50 /* Adjacency packet/byte counters indexed by adjacency index. */
51 vlib_combined_counter_main_t gbp_contract_permit_counters = {
52 .name = "gbp-contracts-permit",
53 .stat_segment_name = "/net/gbp/contract/permit",
56 vlib_combined_counter_main_t gbp_contract_drop_counters = {
57 .name = "gbp-contracts-drop",
58 .stat_segment_name = "/net/gbp/contract/drop",
62 gbp_rule_alloc (gbp_rule_action_t action,
63 gbp_hash_mode_t hash_mode, index_t * nhs)
67 pool_get_zero (gbp_rule_pool, gu);
69 gu->gu_hash_mode = hash_mode;
71 gu->gu_action = action;
73 return (gu - gbp_rule_pool);
77 gbp_rule_free (index_t gui)
79 pool_put_index (gbp_rule_pool, gui);
83 gbp_next_hop_alloc (const ip46_address_t * ip,
84 index_t grd, const mac_address_t * mac, index_t gbd)
86 fib_protocol_t fproto;
89 pool_get_zero (gbp_next_hop_pool, gnh);
91 fib_node_init (&gnh->gnh_node, gbp_next_hop_fib_type);
93 ip46_address_copy (&gnh->gnh_ip, ip);
94 mac_address_copy (&gnh->gnh_mac, mac);
99 FOR_EACH_FIB_IP_PROTOCOL (fproto) gnh->gnh_ai[fproto] = INDEX_INVALID;
101 return (gnh - gbp_next_hop_pool);
104 static inline gbp_next_hop_t *
105 gbp_next_hop_get (index_t gui)
107 return (pool_elt_at_index (gbp_next_hop_pool, gui));
111 gbp_contract_rules_free (index_t * rules)
115 vec_foreach (gui, rules)
117 gbp_policy_node_t pnode;
118 fib_protocol_t fproto;
122 gu = gbp_rule_get (*gui);
124 FOR_EACH_GBP_POLICY_NODE (pnode)
126 FOR_EACH_FIB_IP_PROTOCOL (fproto)
128 dpo_reset (&gu->gu_dpo[pnode][fproto]);
129 dpo_reset (&gu->gu_dpo[pnode][fproto]);
133 vec_foreach (gnhi, gu->gu_nhs)
135 fib_protocol_t fproto;
137 gnh = gbp_next_hop_get (*gnhi);
138 gbp_bridge_domain_unlock (gnh->gnh_bd);
139 gbp_route_domain_unlock (gnh->gnh_rd);
140 gbp_endpoint_child_remove (gnh->gnh_ge, gnh->gnh_sibling);
141 gbp_endpoint_unlock (GBP_ENDPOINT_SRC_RR, gnh->gnh_ge);
143 FOR_EACH_FIB_IP_PROTOCOL (fproto)
145 adj_unlock (gnh->gnh_ai[fproto]);
149 gbp_rule_free (*gui);
155 format_gbp_next_hop (u8 * s, va_list * args)
157 index_t gnhi = va_arg (*args, index_t);
160 gnh = gbp_next_hop_get (gnhi);
162 s = format (s, "%U, %U, %U EP:%d",
163 format_mac_address_t, &gnh->gnh_mac,
164 format_gbp_bridge_domain, gnh->gnh_bd,
165 format_ip46_address, &gnh->gnh_ip, IP46_TYPE_ANY, gnh->gnh_ge);
171 format_gbp_rule_action (u8 * s, va_list * args)
173 gbp_rule_action_t action = va_arg (*args, gbp_rule_action_t);
177 #define _(v,a) case GBP_RULE_##v: return (format (s, "%s", a));
178 foreach_gbp_rule_action
182 return (format (s, "unknown"));
186 format_gbp_hash_mode (u8 * s, va_list * args)
188 gbp_hash_mode_t hash_mode = va_arg (*args, gbp_hash_mode_t);
192 #define _(v,a) case GBP_HASH_MODE_##v: return (format (s, "%s", a));
193 foreach_gbp_hash_mode
197 return (format (s, "unknown"));
201 format_gbp_policy_node (u8 * s, va_list * args)
203 gbp_policy_node_t action = va_arg (*args, gbp_policy_node_t);
207 #define _(v,a) case GBP_POLICY_NODE_##v: return (format (s, "%s", a));
208 foreach_gbp_policy_node
212 return (format (s, "unknown"));
216 format_gbp_rule (u8 * s, va_list * args)
218 index_t gui = va_arg (*args, index_t);
219 gbp_policy_node_t pnode;
220 fib_protocol_t fproto;
224 gu = gbp_rule_get (gui);
225 s = format (s, "%U", format_gbp_rule_action, gu->gu_action);
227 switch (gu->gu_action)
229 case GBP_RULE_PERMIT:
232 case GBP_RULE_REDIRECT:
233 s = format (s, ", %U", format_gbp_hash_mode, gu->gu_hash_mode);
237 vec_foreach (gnhi, gu->gu_nhs)
239 s = format (s, "\n [%U]", format_gbp_next_hop, *gnhi);
242 FOR_EACH_GBP_POLICY_NODE (pnode)
244 s = format (s, "\n policy-%U", format_gbp_policy_node, pnode);
246 FOR_EACH_FIB_IP_PROTOCOL (fproto)
248 if (dpo_id_is_valid (&gu->gu_dpo[pnode][fproto]))
251 format (s, "\n %U", format_dpo_id,
252 &gu->gu_dpo[pnode][fproto], 8);
261 gbp_contract_mk_adj (gbp_next_hop_t * gnh, fib_protocol_t fproto)
263 ethernet_header_t *eth;
268 old_ai = gnh->gnh_ai[fproto];
270 vec_validate (rewrite, sizeof (*eth) - 1);
271 eth = (ethernet_header_t *) rewrite;
273 GBP_CONTRACT_DBG ("...mk-adj: %U", format_gbp_next_hop,
274 gnh - gbp_next_hop_pool);
276 ge = gbp_endpoint_get (gnh->gnh_ge);
278 eth->type = clib_host_to_net_u16 ((fproto == FIB_PROTOCOL_IP4 ?
279 ETHERNET_TYPE_IP4 : ETHERNET_TYPE_IP6));
280 mac_address_to_bytes (gbp_route_domain_get_local_mac (), eth->src_address);
281 mac_address_to_bytes (&gnh->gnh_mac, eth->dst_address);
283 gnh->gnh_ai[fproto] =
284 adj_nbr_add_or_lock_w_rewrite (fproto,
285 fib_proto_to_link (fproto),
287 gbp_itf_get_sw_if_index (ge->
294 static flow_hash_config_t
295 gbp_contract_mk_lb_hp (gbp_hash_mode_t gu_hash_mode)
297 switch (gu_hash_mode)
299 case GBP_HASH_MODE_SRC_IP:
300 return IP_FLOW_HASH_SRC_ADDR;
301 case GBP_HASH_MODE_DST_IP:
302 return IP_FLOW_HASH_DST_ADDR;
303 case GBP_HASH_MODE_SYMMETRIC:
304 return (IP_FLOW_HASH_SRC_ADDR | IP_FLOW_HASH_DST_ADDR |
305 IP_FLOW_HASH_PROTO | IP_FLOW_HASH_SYMMETRIC);
312 gbp_contract_mk_lb (index_t gui, fib_protocol_t fproto)
314 load_balance_path_t *paths = NULL;
315 gbp_policy_node_t pnode;
321 u32 policy_nodes[] = {
322 [GBP_POLICY_NODE_L2] = gbp_policy_port_node.index,
323 [GBP_POLICY_NODE_IP4] = ip4_gbp_policy_dpo_node.index,
324 [GBP_POLICY_NODE_IP6] = ip6_gbp_policy_dpo_node.index,
327 GBP_CONTRACT_DBG ("..mk-lb: %U", format_gbp_rule, gui);
329 gu = gbp_rule_get (gui);
330 dproto = fib_proto_to_dpo (fproto);
332 if (GBP_RULE_REDIRECT != gu->gu_action)
335 vec_foreach_index (ii, gu->gu_nhs)
337 gnh = gbp_next_hop_get (gu->gu_nhs[ii]);
339 gbp_contract_mk_adj (gnh, FIB_PROTOCOL_IP4);
340 gbp_contract_mk_adj (gnh, FIB_PROTOCOL_IP6);
343 FOR_EACH_GBP_POLICY_NODE (pnode)
345 vec_validate (paths, vec_len (gu->gu_nhs) - 1);
347 vec_foreach_index (ii, gu->gu_nhs)
349 gnh = gbp_next_hop_get (gu->gu_nhs[ii]);
351 paths[ii].path_index = FIB_NODE_INDEX_INVALID;
352 paths[ii].path_weight = 1;
353 dpo_set (&paths[ii].path_dpo, DPO_ADJACENCY,
354 dproto, gnh->gnh_ai[fproto]);
357 if (!dpo_id_is_valid (&gu->gu_dpo[pnode][fproto]))
359 dpo_id_t dpo = DPO_INVALID;
361 dpo_set (&dpo, DPO_LOAD_BALANCE, dproto,
362 load_balance_create (vec_len (paths),
364 gbp_contract_mk_lb_hp
365 (gu->gu_hash_mode)));
366 dpo_stack_from_node (policy_nodes[pnode], &gu->gu_dpo[pnode][fproto],
371 load_balance_multipath_update (&gu->gu_dpo[pnode][fproto],
372 paths, LOAD_BALANCE_FLAG_NONE);
378 gbp_contract_mk_one_lb (index_t gui)
380 gbp_contract_mk_lb (gui, FIB_PROTOCOL_IP4);
381 gbp_contract_mk_lb (gui, FIB_PROTOCOL_IP6);
385 gbp_contract_next_hop_resolve (index_t gui, index_t gnhi)
387 gbp_bridge_domain_t *gbd;
393 gnh = gbp_next_hop_get (gnhi);
394 gbd = gbp_bridge_domain_get (gnh->gnh_bd);
397 vec_add1 (ips, gnh->gnh_ip);
400 * source the endpoint this contract needs to forward via.
401 * give ofrwarding details via the spine proxy. if this EP is known
402 * to us, then since we source here with a low priority, the learned
403 * info will take precedenc.
405 rv = gbp_endpoint_update_and_lock (GBP_ENDPOINT_SRC_RR,
406 gbd->gb_uu_fwd_sw_if_index,
409 gnh->gnh_bd, gnh->gnh_rd, SCLASS_INVALID,
410 GBP_ENDPOINT_FLAG_NONE, NULL, NULL,
415 gnh->gnh_sibling = gbp_endpoint_child_add (gnh->gnh_ge,
416 gbp_next_hop_fib_type, gnhi);
419 GBP_CONTRACT_DBG ("..resolve: %d: %d: %U", gui, gnhi, format_gbp_next_hop,
427 gbp_contract_rule_resolve (index_t gui)
432 gu = gbp_rule_get (gui);
434 GBP_CONTRACT_DBG ("..resolve: %U", format_gbp_rule, gui);
436 vec_foreach (gnhi, gu->gu_nhs)
438 gbp_contract_next_hop_resolve (gui, *gnhi);
443 gbp_contract_resolve (index_t * guis)
447 vec_foreach (gui, guis)
449 gbp_contract_rule_resolve (*gui);
454 gbp_contract_mk_lbs (index_t * guis)
458 vec_foreach (gui, guis)
460 gbp_contract_mk_one_lb (*gui);
465 gbp_contract_update (gbp_scope_t scope,
470 u16 * allowed_ethertypes, u32 * stats_index)
472 gbp_main_t *gm = &gbp_main;
478 gbp_contract_key_t key = {
484 if (~0 == gm->gbp_acl_user_id)
486 acl_plugin_exports_init (&gm->acl_plugin);
487 gm->gbp_acl_user_id =
488 gm->acl_plugin.register_user_module ("GBP ACL", "src-epg", "dst-epg");
491 p = hash_get (gbp_contract_db.gc_hash, key.as_u64);
495 gc = gbp_contract_get (gci);
496 gbp_contract_rules_free (gc->gc_rules);
497 gbp_main.acl_plugin.put_lookup_context_index (gc->gc_lc_index);
499 vec_free (gc->gc_allowed_ethertypes);
503 pool_get_zero (gbp_contract_pool, gc);
505 gci = gc - gbp_contract_pool;
506 hash_set (gbp_contract_db.gc_hash, key.as_u64, gci);
508 vlib_validate_combined_counter (&gbp_contract_drop_counters, gci);
509 vlib_zero_combined_counter (&gbp_contract_drop_counters, gci);
510 vlib_validate_combined_counter (&gbp_contract_permit_counters, gci);
511 vlib_zero_combined_counter (&gbp_contract_permit_counters, gci);
514 GBP_CONTRACT_DBG ("update: %U", format_gbp_contract, gci);
516 gc->gc_rules = rules;
517 gc->gc_allowed_ethertypes = allowed_ethertypes;
518 gbp_contract_resolve (gc->gc_rules);
519 gbp_contract_mk_lbs (gc->gc_rules);
521 gc->gc_acl_index = acl_index;
523 gm->acl_plugin.get_lookup_context_index (gm->gbp_acl_user_id,
526 vec_add1 (acl_vec, gc->gc_acl_index);
527 gm->acl_plugin.set_acl_vec_for_context (gc->gc_lc_index, acl_vec);
536 gbp_contract_delete (gbp_scope_t scope, sclass_t sclass, sclass_t dclass)
538 gbp_contract_key_t key = {
546 p = hash_get (gbp_contract_db.gc_hash, key.as_u64);
549 gc = gbp_contract_get (p[0]);
551 gbp_contract_rules_free (gc->gc_rules);
552 gbp_main.acl_plugin.put_lookup_context_index (gc->gc_lc_index);
553 vec_free (gc->gc_allowed_ethertypes);
555 hash_unset (gbp_contract_db.gc_hash, key.as_u64);
556 pool_put (gbp_contract_pool, gc);
561 return (VNET_API_ERROR_NO_SUCH_ENTRY);
565 gbp_contract_walk (gbp_contract_cb_t cb, void *ctx)
570 pool_foreach(gc, gbp_contract_pool,
578 static clib_error_t *
579 gbp_contract_cli (vlib_main_t * vm,
580 unformat_input_t * input, vlib_cli_command_t * cmd)
582 sclass_t sclass = SCLASS_INVALID, dclass = SCLASS_INVALID;
583 u32 acl_index = ~0, stats_index, scope;
586 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
588 if (unformat (input, "add"))
590 else if (unformat (input, "del"))
592 else if (unformat (input, "scope %d", &scope))
594 else if (unformat (input, "sclass %d", &sclass))
596 else if (unformat (input, "dclass %d", &dclass))
598 else if (unformat (input, "acl-index %d", &acl_index))
604 if (SCLASS_INVALID == sclass)
605 return clib_error_return (0, "Source EPG-ID must be specified");
606 if (SCLASS_INVALID == dclass)
607 return clib_error_return (0, "Destination EPG-ID must be specified");
611 gbp_contract_update (scope, sclass, dclass, acl_index,
612 NULL, NULL, &stats_index);
616 gbp_contract_delete (scope, sclass, dclass);
623 * Configure a GBP Contract
626 * @cliexstart{set gbp contract [del] src-epg <ID> dst-epg <ID> acl-index <ACL>}
630 VLIB_CLI_COMMAND (gbp_contract_cli_node, static) =
632 .path = "gbp contract",
634 "gbp contract [del] src-epg <ID> dst-epg <ID> acl-index <ACL>",
635 .function = gbp_contract_cli,
640 format_gbp_contract_key (u8 * s, va_list * args)
642 gbp_contract_key_t *gck = va_arg (*args, gbp_contract_key_t *);
644 s = format (s, "{%d,%d,%d}", gck->gck_scope, gck->gck_src, gck->gck_dst);
650 format_gbp_contract (u8 * s, va_list * args)
652 index_t gci = va_arg (*args, index_t);
653 vlib_counter_t counts;
658 gc = gbp_contract_get (gci);
660 s = format (s, "[%d] %U: acl-index:%d",
661 gci, format_gbp_contract_key, &gc->gc_key, gc->gc_acl_index);
663 s = format (s, "\n rules:");
664 vec_foreach (gui, gc->gc_rules)
666 s = format (s, "\n %d: %U", *gui, format_gbp_rule, *gui);
669 s = format (s, "\n allowed-ethertypes:");
670 s = format (s, "\n [");
671 vec_foreach (et, gc->gc_allowed_ethertypes)
673 int host_et = clib_net_to_host_u16 (*et);
675 s = format (s, "0x%x, ", host_et);
679 s = format (s, "\n stats:");
680 vlib_get_combined_counter (&gbp_contract_drop_counters, gci, &counts);
681 s = format (s, "\n drop:[%Ld:%Ld]", counts.packets, counts.bytes);
682 vlib_get_combined_counter (&gbp_contract_permit_counters, gci, &counts);
683 s = format (s, "\n permit:[%Ld:%Ld]", counts.packets, counts.bytes);
690 static clib_error_t *
691 gbp_contract_show (vlib_main_t * vm,
692 unformat_input_t * input, vlib_cli_command_t * cmd)
698 src = dst = SCLASS_INVALID;
700 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
702 if (unformat (input, "src %d", &src))
704 else if (unformat (input, "dst %d", &dst))
710 vlib_cli_output (vm, "Contracts:");
713 pool_foreach (gc, gbp_contract_pool,
715 gci = gc - gbp_contract_pool;
717 if (SCLASS_INVALID != src && SCLASS_INVALID != dst)
719 if (gc->gc_key.gck_src == src &&
720 gc->gc_key.gck_dst == dst)
721 vlib_cli_output (vm, " %U", format_gbp_contract, gci);
723 else if (SCLASS_INVALID != src)
725 if (gc->gc_key.gck_src == src)
726 vlib_cli_output (vm, " %U", format_gbp_contract, gci);
728 else if (SCLASS_INVALID != dst)
730 if (gc->gc_key.gck_dst == dst)
731 vlib_cli_output (vm, " %U", format_gbp_contract, gci);
734 vlib_cli_output (vm, " %U", format_gbp_contract, gci);
742 * Show Group Based Policy Contracts
745 * @cliexstart{show gbp contract}
749 VLIB_CLI_COMMAND (gbp_contract_show_node, static) = {
750 .path = "show gbp contract",
751 .short_help = "show gbp contract [src <SRC>] [dst <DST>]\n",
752 .function = gbp_contract_show,
757 gbp_next_hop_get_node (fib_node_index_t index)
761 gnh = gbp_next_hop_get (index);
763 return (&gnh->gnh_node);
767 gbp_next_hop_last_lock_gone (fib_node_t * node)
772 static gbp_next_hop_t *
773 gbp_next_hop_from_fib_node (fib_node_t * node)
775 ASSERT (gbp_next_hop_fib_type == node->fn_type);
776 return ((gbp_next_hop_t *) node);
779 static fib_node_back_walk_rc_t
780 gbp_next_hop_back_walk_notify (fib_node_t * node,
781 fib_node_back_walk_ctx_t * ctx)
785 gnh = gbp_next_hop_from_fib_node (node);
787 gbp_contract_mk_one_lb (gnh->gnh_gu);
789 return (FIB_NODE_BACK_WALK_CONTINUE);
793 * The FIB path's graph node virtual function table
795 static const fib_node_vft_t gbp_next_hop_vft = {
796 .fnv_get = gbp_next_hop_get_node,
797 .fnv_last_lock = gbp_next_hop_last_lock_gone,
798 .fnv_back_walk = gbp_next_hop_back_walk_notify,
799 // .fnv_mem_show = fib_path_memory_show,
802 static clib_error_t *
803 gbp_contract_init (vlib_main_t * vm)
805 gc_logger = vlib_log_register_class ("gbp", "con");
806 gbp_next_hop_fib_type = fib_node_register_new_type (&gbp_next_hop_vft);
811 VLIB_INIT_FUNCTION (gbp_contract_init);
814 * fd.io coding-style-patch-verification: ON
817 * eval: (c-set-style "gnu")