1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Zebra dataplane layer.
4 * Copyright (c) 2018 Volta Networks, Inc.
11 #include "lib/libfrr.h"
12 #include "lib/debug.h"
13 #include "lib/frratomic.h"
14 #include "lib/frr_pthread.h"
15 #include "lib/memory.h"
16 #include "lib/zebra.h"
17 #include "zebra/netconf_netlink.h"
18 #include "zebra/zebra_router.h"
19 #include "zebra/zebra_dplane.h"
20 #include "zebra/zebra_vxlan_private.h"
21 #include "zebra/zebra_mpls.h"
23 #include "zebra/debug.h"
24 #include "zebra/zebra_pbr.h"
25 #include "zebra/zebra_neigh.h"
26 #include "zebra/zebra_tc.h"
30 DEFINE_MTYPE_STATIC(ZEBRA
, DP_CTX
, "Zebra DPlane Ctx");
31 DEFINE_MTYPE_STATIC(ZEBRA
, DP_INTF
, "Zebra DPlane Intf");
32 DEFINE_MTYPE_STATIC(ZEBRA
, DP_PROV
, "Zebra DPlane Provider");
33 DEFINE_MTYPE_STATIC(ZEBRA
, DP_NETFILTER
, "Zebra Netfilter Internal Object");
34 DEFINE_MTYPE_STATIC(ZEBRA
, DP_NS
, "DPlane NSes");
40 /* Control for collection of extra interface info with route updates; a plugin
41 * can enable the extra info via a dplane api.
43 static bool dplane_collect_extra_intf_info
;
45 /* Enable test dataplane provider */
46 /*#define DPLANE_TEST_PROVIDER 1 */
48 /* Default value for max queued incoming updates */
49 const uint32_t DPLANE_DEFAULT_MAX_QUEUED
= 200;
51 /* Default value for new work per cycle */
52 const uint32_t DPLANE_DEFAULT_NEW_WORK
= 100;
54 /* Validation check macro for context blocks */
55 /* #define DPLANE_DEBUG 1 */
59 # define DPLANE_CTX_VALID(p) \
64 # define DPLANE_CTX_VALID(p)
66 #endif /* DPLANE_DEBUG */
69 * Nexthop information captured for nexthop/nexthop group updates
71 struct dplane_nexthop_info
{
78 struct nexthop_group ng
;
79 struct nh_grp nh_grp
[MULTIPATH_NUM
];
84 * Optional extra info about interfaces used in route updates' nexthops.
86 struct dplane_intf_extra
{
92 struct dplane_intf_extra_list_item dlink
;
96 * Route information captured for route updates.
98 struct dplane_route_info
{
100 /* Dest and (optional) source prefixes */
101 struct prefix zd_dest
;
102 struct prefix zd_src
;
111 route_tag_t zd_old_tag
;
113 uint32_t zd_old_metric
;
115 uint16_t zd_instance
;
116 uint16_t zd_old_instance
;
119 uint8_t zd_old_distance
;
122 uint32_t zd_nexthop_mtu
;
126 /* Nexthop hash entry info */
127 struct dplane_nexthop_info nhe
;
131 struct nexthop_group zd_ng
;
133 /* Backup nexthops (if present) */
134 struct nexthop_group backup_ng
;
136 /* "Previous" nexthops, used only in route updates without netlink */
137 struct nexthop_group zd_old_ng
;
138 struct nexthop_group old_backup_ng
;
140 /* Optional list of extra interface info */
141 struct dplane_intf_extra_list_head intf_extra_list
;
145 * Pseudowire info for the dataplane
147 struct dplane_pw_info
{
154 mpls_label_t local_label
;
155 mpls_label_t remote_label
;
157 /* Nexthops that are valid and installed */
158 struct nexthop_group fib_nhg
;
160 /* Primary and backup nexthop sets, copied from the resolving route. */
161 struct nexthop_group primary_nhg
;
162 struct nexthop_group backup_nhg
;
164 union pw_protocol_fields fields
;
168 * Bridge port info for the dataplane
170 struct dplane_br_port_info
{
171 uint32_t sph_filter_cnt
;
172 struct in_addr sph_filters
[ES_VTEP_MAX_CNT
];
173 /* DPLANE_BR_PORT_XXX - see zebra_dplane.h*/
175 uint32_t backup_nhg_id
;
179 * Interface/prefix info for the dataplane
181 struct dplane_intf_info
{
189 #define DPLANE_INTF_CONNECTED (1 << 0) /* Connected peer, p2p */
190 #define DPLANE_INTF_SECONDARY (1 << 1)
191 #define DPLANE_INTF_BROADCAST (1 << 2)
192 #define DPLANE_INTF_HAS_DEST DPLANE_INTF_CONNECTED
193 #define DPLANE_INTF_HAS_LABEL (1 << 4)
195 /* Interface address/prefix */
196 struct prefix prefix
;
198 /* Dest address, for p2p, or broadcast prefix */
199 struct prefix dest_prefix
;
206 * EVPN MAC address info for the dataplane.
208 struct dplane_mac_info
{
210 ifindex_t br_ifindex
;
213 struct in_addr vtep_ip
;
216 uint32_t update_flags
;
220 * Neighbor info for the dataplane
222 struct dplane_neigh_info
{
223 struct ipaddr ip_addr
;
226 struct ipaddr ip_addr
;
231 uint32_t update_flags
;
237 struct dplane_neigh_table
{
240 uint32_t ucast_probes
;
241 uint32_t mcast_probes
;
245 * Policy based routing rule info for the dataplane
247 struct dplane_ctx_rule
{
250 /* The route table pointed by this rule */
253 /* Filter criteria */
257 struct prefix src_ip
;
258 struct prefix dst_ip
;
264 uint16_t action_vlan_id
;
265 uint16_t action_vlan_flags
;
267 uint32_t action_queue_id
;
269 char ifname
[INTERFACE_NAMSIZ
+ 1];
273 intptr_t dp_flow_ptr
;
276 struct dplane_rule_info
{
278 * Originating zclient sock fd, so we can know who to send
286 struct dplane_ctx_rule
new;
287 struct dplane_ctx_rule old
;
290 struct dplane_gre_ctx
{
291 uint32_t link_ifindex
;
293 struct zebra_l2info_gre info
;
298 * Network interface configuration info - aligned with netlink's NETCONF
299 * info. The flags values are public, in the dplane.h file...
301 struct dplane_netconf_info
{
302 enum dplane_netconf_status_e mpls_val
;
303 enum dplane_netconf_status_e mcast_val
;
304 enum dplane_netconf_status_e linkdown_val
;
307 struct dplane_tc_qdisc_info
{
308 enum tc_qdisc_kind kind
;
309 const char *kind_str
;
312 struct dplane_tc_class_info
{
314 enum tc_qdisc_kind kind
;
315 const char *kind_str
;
320 struct dplane_tc_filter_info
{
323 enum tc_filter_kind kind
;
324 const char *kind_str
;
328 struct prefix src_ip
;
329 struct prefix dst_ip
;
330 uint16_t src_port_min
;
331 uint16_t src_port_max
;
332 uint16_t dst_port_min
;
333 uint16_t dst_port_max
;
335 uint8_t dsfield_mask
;
340 * The context block used to exchange info about route updates across
341 * the boundary between the zebra main context (and pthread) and the
342 * dataplane layer (and pthread).
344 struct zebra_dplane_ctx
{
347 enum dplane_op_e zd_op
;
349 /* Status on return */
350 enum zebra_dplane_result zd_status
;
352 /* Dplane provider id */
353 uint32_t zd_provider
;
355 /* Flags - used by providers, e.g. */
363 /* Some updates may be generated by notifications: allow the
364 * plugin to notice and ignore results from its own notifications.
366 uint32_t zd_notif_provider
;
368 /* TODO -- internal/sub-operation status? */
369 enum zebra_dplane_result zd_remote_status
;
370 enum zebra_dplane_result zd_kernel_status
;
373 uint32_t zd_table_id
;
375 char zd_ifname
[INTERFACE_NAMSIZ
];
376 ifindex_t zd_ifindex
;
378 /* Support info for different kinds of updates */
380 struct dplane_route_info rinfo
;
381 struct zebra_lsp lsp
;
382 struct dplane_pw_info pw
;
383 struct dplane_br_port_info br_port
;
384 struct dplane_intf_info intf
;
385 struct dplane_mac_info macinfo
;
386 struct dplane_neigh_info neigh
;
387 struct dplane_rule_info rule
;
388 struct dplane_tc_qdisc_info tc_qdisc
;
389 struct dplane_tc_class_info tc_class
;
390 struct dplane_tc_filter_info tc_filter
;
391 struct zebra_pbr_iptable iptable
;
392 struct zebra_pbr_ipset ipset
;
394 struct zebra_pbr_ipset_entry entry
;
395 struct zebra_pbr_ipset_info info
;
397 struct dplane_neigh_table neightable
;
398 struct dplane_gre_ctx gre
;
399 struct dplane_netconf_info netconf
;
402 /* Namespace info, used especially for netlink kernel communication */
403 struct zebra_dplane_info zd_ns_info
;
405 /* Embedded list linkage */
406 struct dplane_ctx_list_item zd_entries
;
409 /* Flag that can be set by a pre-kernel provider as a signal that an update
410 * should bypass the kernel.
412 #define DPLANE_CTX_FLAG_NO_KERNEL 0x01
414 /* List types declared now that the structs involved are defined. */
415 DECLARE_DLIST(dplane_ctx_list
, struct zebra_dplane_ctx
, zd_entries
);
416 DECLARE_DLIST(dplane_intf_extra_list
, struct dplane_intf_extra
, dlink
);
418 /* List for dplane plugins/providers */
419 PREDECL_DLIST(dplane_prov_list
);
422 * Registration block for one dataplane provider.
424 struct zebra_dplane_provider
{
426 char dp_name
[DPLANE_PROVIDER_NAMELEN
+ 1];
428 /* Priority, for ordering among providers */
435 pthread_mutex_t dp_mutex
;
437 /* Plugin-provided extra data */
443 int (*dp_start
)(struct zebra_dplane_provider
*prov
);
445 int (*dp_fp
)(struct zebra_dplane_provider
*prov
);
447 int (*dp_fini
)(struct zebra_dplane_provider
*prov
, bool early_p
);
449 _Atomic
uint32_t dp_in_counter
;
450 _Atomic
uint32_t dp_in_queued
;
451 _Atomic
uint32_t dp_in_max
;
452 _Atomic
uint32_t dp_out_counter
;
453 _Atomic
uint32_t dp_out_queued
;
454 _Atomic
uint32_t dp_out_max
;
455 _Atomic
uint32_t dp_error_counter
;
457 /* Queue of contexts inbound to the provider */
458 struct dplane_ctx_list_head dp_ctx_in_list
;
460 /* Queue of completed contexts outbound from the provider back
461 * towards the dataplane module.
463 struct dplane_ctx_list_head dp_ctx_out_list
;
465 /* Embedded list linkage for provider objects */
466 struct dplane_prov_list_item dp_link
;
469 /* Declare list of providers/plugins */
470 DECLARE_DLIST(dplane_prov_list
, struct zebra_dplane_provider
, dp_link
);
472 /* Declare types for list of zns info objects */
473 PREDECL_DLIST(zns_info_list
);
475 struct dplane_zns_info
{
476 struct zebra_dplane_info info
;
478 /* Request data from the OS */
479 struct event
*t_request
;
482 struct event
*t_read
;
485 struct zns_info_list_item link
;
491 static struct zebra_dplane_globals
{
492 /* Mutex to control access to dataplane components */
493 pthread_mutex_t dg_mutex
;
495 /* Results callback registered by zebra 'core' */
496 int (*dg_results_cb
)(struct dplane_ctx_list_head
*ctxlist
);
498 /* Sentinel for beginning of shutdown */
499 volatile bool dg_is_shutdown
;
501 /* Sentinel for end of shutdown */
502 volatile bool dg_run
;
504 /* Update context queue inbound to the dataplane */
505 struct dplane_ctx_list_head dg_update_list
;
507 /* Ordered list of providers */
508 struct dplane_prov_list_head dg_providers
;
510 /* List of info about each zns */
511 struct zns_info_list_head dg_zns_list
;
513 /* Counter used to assign internal ids to providers */
514 uint32_t dg_provider_id
;
516 /* Limit number of pending, unprocessed updates */
517 _Atomic
uint32_t dg_max_queued_updates
;
519 /* Control whether system route notifications should be produced. */
520 bool dg_sys_route_notifs
;
522 /* Limit number of new updates dequeued at once, to pace an
525 uint32_t dg_updates_per_cycle
;
527 _Atomic
uint32_t dg_routes_in
;
528 _Atomic
uint32_t dg_routes_queued
;
529 _Atomic
uint32_t dg_routes_queued_max
;
530 _Atomic
uint32_t dg_route_errors
;
531 _Atomic
uint32_t dg_other_errors
;
533 _Atomic
uint32_t dg_nexthops_in
;
534 _Atomic
uint32_t dg_nexthop_errors
;
536 _Atomic
uint32_t dg_lsps_in
;
537 _Atomic
uint32_t dg_lsp_errors
;
539 _Atomic
uint32_t dg_pws_in
;
540 _Atomic
uint32_t dg_pw_errors
;
542 _Atomic
uint32_t dg_br_port_in
;
543 _Atomic
uint32_t dg_br_port_errors
;
545 _Atomic
uint32_t dg_intf_addrs_in
;
546 _Atomic
uint32_t dg_intf_addr_errors
;
547 _Atomic
uint32_t dg_intf_changes
;
548 _Atomic
uint32_t dg_intf_changes_errors
;
550 _Atomic
uint32_t dg_macs_in
;
551 _Atomic
uint32_t dg_mac_errors
;
553 _Atomic
uint32_t dg_neighs_in
;
554 _Atomic
uint32_t dg_neigh_errors
;
556 _Atomic
uint32_t dg_rules_in
;
557 _Atomic
uint32_t dg_rule_errors
;
559 _Atomic
uint32_t dg_update_yields
;
561 _Atomic
uint32_t dg_iptable_in
;
562 _Atomic
uint32_t dg_iptable_errors
;
564 _Atomic
uint32_t dg_ipset_in
;
565 _Atomic
uint32_t dg_ipset_errors
;
566 _Atomic
uint32_t dg_ipset_entry_in
;
567 _Atomic
uint32_t dg_ipset_entry_errors
;
569 _Atomic
uint32_t dg_neightable_in
;
570 _Atomic
uint32_t dg_neightable_errors
;
572 _Atomic
uint32_t dg_gre_set_in
;
573 _Atomic
uint32_t dg_gre_set_errors
;
575 _Atomic
uint32_t dg_intfs_in
;
576 _Atomic
uint32_t dg_intf_errors
;
578 _Atomic
uint32_t dg_tcs_in
;
579 _Atomic
uint32_t dg_tcs_errors
;
581 /* Dataplane pthread */
582 struct frr_pthread
*dg_pthread
;
584 /* Event-delivery context 'master' for the dplane */
585 struct event_loop
*dg_master
;
587 /* Event/'thread' pointer for queued updates */
588 struct event
*dg_t_update
;
590 /* Event pointer for pending shutdown check loop */
591 struct event
*dg_t_shutdown_check
;
595 /* Instantiate zns list type */
596 DECLARE_DLIST(zns_info_list
, struct dplane_zns_info
, link
);
599 * Lock and unlock for interactions with the zebra 'core' pthread
601 #define DPLANE_LOCK() pthread_mutex_lock(&zdplane_info.dg_mutex)
602 #define DPLANE_UNLOCK() pthread_mutex_unlock(&zdplane_info.dg_mutex)
606 * Lock and unlock for individual providers
608 #define DPLANE_PROV_LOCK(p) pthread_mutex_lock(&((p)->dp_mutex))
609 #define DPLANE_PROV_UNLOCK(p) pthread_mutex_unlock(&((p)->dp_mutex))
612 static void dplane_thread_loop(struct event
*event
);
613 static enum zebra_dplane_result
lsp_update_internal(struct zebra_lsp
*lsp
,
614 enum dplane_op_e op
);
615 static enum zebra_dplane_result
pw_update_internal(struct zebra_pw
*pw
,
616 enum dplane_op_e op
);
617 static enum zebra_dplane_result
intf_addr_update_internal(
618 const struct interface
*ifp
, const struct connected
*ifc
,
619 enum dplane_op_e op
);
620 static enum zebra_dplane_result
621 mac_update_common(enum dplane_op_e op
, const struct interface
*ifp
,
622 const struct interface
*br_ifp
, vlanid_t vid
,
623 const struct ethaddr
*mac
, vni_t vni
, struct in_addr vtep_ip
,
624 bool sticky
, uint32_t nhg_id
, uint32_t update_flags
);
625 static enum zebra_dplane_result
626 neigh_update_internal(enum dplane_op_e op
, const struct interface
*ifp
,
627 const void *link
, int link_family
,
628 const struct ipaddr
*ip
, vni_t vni
, uint32_t flags
,
629 uint16_t state
, uint32_t update_flags
, int protocol
);
635 /* Obtain thread_master for dataplane thread */
636 struct event_loop
*dplane_get_thread_master(void)
638 return zdplane_info
.dg_master
;
642 * Allocate a dataplane update context
644 struct zebra_dplane_ctx
*dplane_ctx_alloc(void)
646 struct zebra_dplane_ctx
*p
;
648 /* TODO -- just alloc'ing memory, but would like to maintain
651 p
= XCALLOC(MTYPE_DP_CTX
, sizeof(struct zebra_dplane_ctx
));
656 /* Enable system route notifications */
657 void dplane_enable_sys_route_notifs(void)
659 zdplane_info
.dg_sys_route_notifs
= true;
663 * Clean up dependent/internal allocations inside a context object
665 static void dplane_ctx_free_internal(struct zebra_dplane_ctx
*ctx
)
667 struct dplane_intf_extra
*if_extra
;
670 * Some internal allocations may need to be freed, depending on
671 * the type of info captured in the ctx.
673 switch (ctx
->zd_op
) {
674 case DPLANE_OP_ROUTE_INSTALL
:
675 case DPLANE_OP_ROUTE_UPDATE
:
676 case DPLANE_OP_ROUTE_DELETE
:
677 case DPLANE_OP_SYS_ROUTE_ADD
:
678 case DPLANE_OP_SYS_ROUTE_DELETE
:
679 case DPLANE_OP_ROUTE_NOTIFY
:
681 /* Free allocated nexthops */
682 if (ctx
->u
.rinfo
.zd_ng
.nexthop
) {
683 /* This deals with recursive nexthops too */
684 nexthops_free(ctx
->u
.rinfo
.zd_ng
.nexthop
);
686 ctx
->u
.rinfo
.zd_ng
.nexthop
= NULL
;
689 /* Free backup info also (if present) */
690 if (ctx
->u
.rinfo
.backup_ng
.nexthop
) {
691 /* This deals with recursive nexthops too */
692 nexthops_free(ctx
->u
.rinfo
.backup_ng
.nexthop
);
694 ctx
->u
.rinfo
.backup_ng
.nexthop
= NULL
;
697 if (ctx
->u
.rinfo
.zd_old_ng
.nexthop
) {
698 /* This deals with recursive nexthops too */
699 nexthops_free(ctx
->u
.rinfo
.zd_old_ng
.nexthop
);
701 ctx
->u
.rinfo
.zd_old_ng
.nexthop
= NULL
;
704 if (ctx
->u
.rinfo
.old_backup_ng
.nexthop
) {
705 /* This deals with recursive nexthops too */
706 nexthops_free(ctx
->u
.rinfo
.old_backup_ng
.nexthop
);
708 ctx
->u
.rinfo
.old_backup_ng
.nexthop
= NULL
;
711 /* Optional extra interface info */
712 while ((if_extra
= dplane_intf_extra_list_pop(
713 &ctx
->u
.rinfo
.intf_extra_list
)))
714 XFREE(MTYPE_DP_INTF
, if_extra
);
718 case DPLANE_OP_NH_INSTALL
:
719 case DPLANE_OP_NH_UPDATE
:
720 case DPLANE_OP_NH_DELETE
: {
721 if (ctx
->u
.rinfo
.nhe
.ng
.nexthop
) {
722 /* This deals with recursive nexthops too */
723 nexthops_free(ctx
->u
.rinfo
.nhe
.ng
.nexthop
);
725 ctx
->u
.rinfo
.nhe
.ng
.nexthop
= NULL
;
730 case DPLANE_OP_LSP_INSTALL
:
731 case DPLANE_OP_LSP_UPDATE
:
732 case DPLANE_OP_LSP_DELETE
:
733 case DPLANE_OP_LSP_NOTIFY
:
735 struct zebra_nhlfe
*nhlfe
;
737 /* Unlink and free allocated NHLFEs */
738 frr_each_safe(nhlfe_list
, &ctx
->u
.lsp
.nhlfe_list
, nhlfe
) {
739 nhlfe_list_del(&ctx
->u
.lsp
.nhlfe_list
, nhlfe
);
740 zebra_mpls_nhlfe_free(nhlfe
);
743 /* Unlink and free allocated backup NHLFEs, if present */
744 frr_each_safe(nhlfe_list
,
745 &(ctx
->u
.lsp
.backup_nhlfe_list
), nhlfe
) {
746 nhlfe_list_del(&ctx
->u
.lsp
.backup_nhlfe_list
,
748 zebra_mpls_nhlfe_free(nhlfe
);
751 /* Clear pointers in lsp struct, in case we're caching
752 * free context structs.
754 nhlfe_list_init(&ctx
->u
.lsp
.nhlfe_list
);
755 ctx
->u
.lsp
.best_nhlfe
= NULL
;
756 nhlfe_list_init(&ctx
->u
.lsp
.backup_nhlfe_list
);
761 case DPLANE_OP_PW_INSTALL
:
762 case DPLANE_OP_PW_UNINSTALL
:
763 /* Free allocated nexthops */
764 if (ctx
->u
.pw
.fib_nhg
.nexthop
) {
765 /* This deals with recursive nexthops too */
766 nexthops_free(ctx
->u
.pw
.fib_nhg
.nexthop
);
768 ctx
->u
.pw
.fib_nhg
.nexthop
= NULL
;
770 if (ctx
->u
.pw
.primary_nhg
.nexthop
) {
771 nexthops_free(ctx
->u
.pw
.primary_nhg
.nexthop
);
773 ctx
->u
.pw
.primary_nhg
.nexthop
= NULL
;
775 if (ctx
->u
.pw
.backup_nhg
.nexthop
) {
776 nexthops_free(ctx
->u
.pw
.backup_nhg
.nexthop
);
778 ctx
->u
.pw
.backup_nhg
.nexthop
= NULL
;
782 case DPLANE_OP_ADDR_INSTALL
:
783 case DPLANE_OP_ADDR_UNINSTALL
:
784 case DPLANE_OP_INTF_ADDR_ADD
:
785 case DPLANE_OP_INTF_ADDR_DEL
:
786 /* Maybe free label string, if allocated */
787 if (ctx
->u
.intf
.label
!= NULL
&&
788 ctx
->u
.intf
.label
!= ctx
->u
.intf
.label_buf
) {
789 XFREE(MTYPE_DP_CTX
, ctx
->u
.intf
.label
);
790 ctx
->u
.intf
.label
= NULL
;
794 case DPLANE_OP_MAC_INSTALL
:
795 case DPLANE_OP_MAC_DELETE
:
796 case DPLANE_OP_NEIGH_INSTALL
:
797 case DPLANE_OP_NEIGH_UPDATE
:
798 case DPLANE_OP_NEIGH_DELETE
:
799 case DPLANE_OP_VTEP_ADD
:
800 case DPLANE_OP_VTEP_DELETE
:
801 case DPLANE_OP_RULE_ADD
:
802 case DPLANE_OP_RULE_DELETE
:
803 case DPLANE_OP_RULE_UPDATE
:
804 case DPLANE_OP_NEIGH_DISCOVER
:
805 case DPLANE_OP_BR_PORT_UPDATE
:
806 case DPLANE_OP_NEIGH_IP_INSTALL
:
807 case DPLANE_OP_NEIGH_IP_DELETE
:
809 case DPLANE_OP_IPSET_ADD
:
810 case DPLANE_OP_IPSET_DELETE
:
811 case DPLANE_OP_INTF_INSTALL
:
812 case DPLANE_OP_INTF_UPDATE
:
813 case DPLANE_OP_INTF_DELETE
:
814 case DPLANE_OP_TC_QDISC_INSTALL
:
815 case DPLANE_OP_TC_QDISC_UNINSTALL
:
816 case DPLANE_OP_TC_CLASS_ADD
:
817 case DPLANE_OP_TC_CLASS_DELETE
:
818 case DPLANE_OP_TC_CLASS_UPDATE
:
819 case DPLANE_OP_TC_FILTER_ADD
:
820 case DPLANE_OP_TC_FILTER_DELETE
:
821 case DPLANE_OP_TC_FILTER_UPDATE
:
824 case DPLANE_OP_IPSET_ENTRY_ADD
:
825 case DPLANE_OP_IPSET_ENTRY_DELETE
:
827 case DPLANE_OP_NEIGH_TABLE_UPDATE
:
829 case DPLANE_OP_IPTABLE_ADD
:
830 case DPLANE_OP_IPTABLE_DELETE
:
831 if (ctx
->u
.iptable
.interface_name_list
)
832 list_delete(&ctx
->u
.iptable
.interface_name_list
);
834 case DPLANE_OP_GRE_SET
:
835 case DPLANE_OP_INTF_NETCONFIG
:
841 * Free a dataplane results context.
843 static void dplane_ctx_free(struct zebra_dplane_ctx
**pctx
)
848 DPLANE_CTX_VALID(*pctx
);
850 /* TODO -- just freeing memory, but would like to maintain
854 /* Some internal allocations may need to be freed, depending on
855 * the type of info captured in the ctx.
857 dplane_ctx_free_internal(*pctx
);
859 XFREE(MTYPE_DP_CTX
, *pctx
);
863 * Reset an allocated context object for re-use. All internal allocations are
864 * freed and the context is memset.
866 void dplane_ctx_reset(struct zebra_dplane_ctx
*ctx
)
868 dplane_ctx_free_internal(ctx
);
869 memset(ctx
, 0, sizeof(*ctx
));
873 * Return a context block to the dplane module after processing
875 void dplane_ctx_fini(struct zebra_dplane_ctx
**pctx
)
877 /* TODO -- maintain pool; for now, just free */
878 dplane_ctx_free(pctx
);
881 /* Init a list of contexts */
882 void dplane_ctx_q_init(struct dplane_ctx_list_head
*q
)
884 dplane_ctx_list_init(q
);
887 /* Enqueue a context block */
888 void dplane_ctx_enqueue_tail(struct dplane_ctx_list_head
*list
,
889 const struct zebra_dplane_ctx
*ctx
)
891 dplane_ctx_list_add_tail(list
, (struct zebra_dplane_ctx
*)ctx
);
894 /* Append a list of context blocks to another list */
895 void dplane_ctx_list_append(struct dplane_ctx_list_head
*to_list
,
896 struct dplane_ctx_list_head
*from_list
)
898 struct zebra_dplane_ctx
*ctx
;
900 while ((ctx
= dplane_ctx_list_pop(from_list
)) != NULL
)
901 dplane_ctx_list_add_tail(to_list
, ctx
);
904 struct zebra_dplane_ctx
*dplane_ctx_get_head(struct dplane_ctx_list_head
*q
)
906 struct zebra_dplane_ctx
*ctx
= dplane_ctx_list_first(q
);
911 /* Dequeue a context block from the head of a list */
912 struct zebra_dplane_ctx
*dplane_ctx_dequeue(struct dplane_ctx_list_head
*q
)
914 struct zebra_dplane_ctx
*ctx
= dplane_ctx_list_pop(q
);
920 * Accessors for information from the context object
922 enum zebra_dplane_result
dplane_ctx_get_status(
923 const struct zebra_dplane_ctx
*ctx
)
925 DPLANE_CTX_VALID(ctx
);
927 return ctx
->zd_status
;
930 void dplane_ctx_set_status(struct zebra_dplane_ctx
*ctx
,
931 enum zebra_dplane_result status
)
933 DPLANE_CTX_VALID(ctx
);
935 ctx
->zd_status
= status
;
938 /* Retrieve last/current provider id */
939 uint32_t dplane_ctx_get_provider(const struct zebra_dplane_ctx
*ctx
)
941 DPLANE_CTX_VALID(ctx
);
942 return ctx
->zd_provider
;
945 /* Providers run before the kernel can control whether a kernel
946 * update should be done.
948 void dplane_ctx_set_skip_kernel(struct zebra_dplane_ctx
*ctx
)
950 DPLANE_CTX_VALID(ctx
);
952 SET_FLAG(ctx
->zd_flags
, DPLANE_CTX_FLAG_NO_KERNEL
);
955 bool dplane_ctx_is_skip_kernel(const struct zebra_dplane_ctx
*ctx
)
957 DPLANE_CTX_VALID(ctx
);
959 return CHECK_FLAG(ctx
->zd_flags
, DPLANE_CTX_FLAG_NO_KERNEL
);
962 void dplane_ctx_set_op(struct zebra_dplane_ctx
*ctx
, enum dplane_op_e op
)
964 DPLANE_CTX_VALID(ctx
);
968 enum dplane_op_e
dplane_ctx_get_op(const struct zebra_dplane_ctx
*ctx
)
970 DPLANE_CTX_VALID(ctx
);
975 const char *dplane_op2str(enum dplane_op_e op
)
977 const char *ret
= "UNKNOWN";
985 case DPLANE_OP_ROUTE_INSTALL
:
986 ret
= "ROUTE_INSTALL";
988 case DPLANE_OP_ROUTE_UPDATE
:
989 ret
= "ROUTE_UPDATE";
991 case DPLANE_OP_ROUTE_DELETE
:
992 ret
= "ROUTE_DELETE";
994 case DPLANE_OP_ROUTE_NOTIFY
:
995 ret
= "ROUTE_NOTIFY";
999 case DPLANE_OP_NH_INSTALL
:
1002 case DPLANE_OP_NH_UPDATE
:
1005 case DPLANE_OP_NH_DELETE
:
1009 case DPLANE_OP_LSP_INSTALL
:
1010 ret
= "LSP_INSTALL";
1012 case DPLANE_OP_LSP_UPDATE
:
1015 case DPLANE_OP_LSP_DELETE
:
1018 case DPLANE_OP_LSP_NOTIFY
:
1022 case DPLANE_OP_PW_INSTALL
:
1025 case DPLANE_OP_PW_UNINSTALL
:
1026 ret
= "PW_UNINSTALL";
1029 case DPLANE_OP_SYS_ROUTE_ADD
:
1030 ret
= "SYS_ROUTE_ADD";
1032 case DPLANE_OP_SYS_ROUTE_DELETE
:
1033 ret
= "SYS_ROUTE_DEL";
1036 case DPLANE_OP_BR_PORT_UPDATE
:
1037 ret
= "BR_PORT_UPDATE";
1040 case DPLANE_OP_ADDR_INSTALL
:
1041 ret
= "ADDR_INSTALL";
1043 case DPLANE_OP_ADDR_UNINSTALL
:
1044 ret
= "ADDR_UNINSTALL";
1047 case DPLANE_OP_MAC_INSTALL
:
1048 ret
= "MAC_INSTALL";
1050 case DPLANE_OP_MAC_DELETE
:
1054 case DPLANE_OP_NEIGH_INSTALL
:
1055 ret
= "NEIGH_INSTALL";
1057 case DPLANE_OP_NEIGH_UPDATE
:
1058 ret
= "NEIGH_UPDATE";
1060 case DPLANE_OP_NEIGH_DELETE
:
1061 ret
= "NEIGH_DELETE";
1063 case DPLANE_OP_VTEP_ADD
:
1066 case DPLANE_OP_VTEP_DELETE
:
1067 ret
= "VTEP_DELETE";
1070 case DPLANE_OP_RULE_ADD
:
1073 case DPLANE_OP_RULE_DELETE
:
1074 ret
= "RULE_DELETE";
1076 case DPLANE_OP_RULE_UPDATE
:
1077 ret
= "RULE_UPDATE";
1080 case DPLANE_OP_NEIGH_DISCOVER
:
1081 ret
= "NEIGH_DISCOVER";
1084 case DPLANE_OP_IPTABLE_ADD
:
1085 ret
= "IPTABLE_ADD";
1087 case DPLANE_OP_IPTABLE_DELETE
:
1088 ret
= "IPTABLE_DELETE";
1090 case DPLANE_OP_IPSET_ADD
:
1093 case DPLANE_OP_IPSET_DELETE
:
1094 ret
= "IPSET_DELETE";
1096 case DPLANE_OP_IPSET_ENTRY_ADD
:
1097 ret
= "IPSET_ENTRY_ADD";
1099 case DPLANE_OP_IPSET_ENTRY_DELETE
:
1100 ret
= "IPSET_ENTRY_DELETE";
1102 case DPLANE_OP_NEIGH_IP_INSTALL
:
1103 ret
= "NEIGH_IP_INSTALL";
1105 case DPLANE_OP_NEIGH_IP_DELETE
:
1106 ret
= "NEIGH_IP_DELETE";
1108 case DPLANE_OP_NEIGH_TABLE_UPDATE
:
1109 ret
= "NEIGH_TABLE_UPDATE";
1112 case DPLANE_OP_GRE_SET
:
1116 case DPLANE_OP_INTF_ADDR_ADD
:
1117 return "INTF_ADDR_ADD";
1119 case DPLANE_OP_INTF_ADDR_DEL
:
1120 return "INTF_ADDR_DEL";
1122 case DPLANE_OP_INTF_NETCONFIG
:
1123 return "INTF_NETCONFIG";
1125 case DPLANE_OP_INTF_INSTALL
:
1126 ret
= "INTF_INSTALL";
1128 case DPLANE_OP_INTF_UPDATE
:
1129 ret
= "INTF_UPDATE";
1131 case DPLANE_OP_INTF_DELETE
:
1132 ret
= "INTF_DELETE";
1135 case DPLANE_OP_TC_QDISC_INSTALL
:
1136 ret
= "TC_QDISC_INSTALL";
1138 case DPLANE_OP_TC_QDISC_UNINSTALL
:
1139 ret
= "TC_QDISC_UNINSTALL";
1141 case DPLANE_OP_TC_CLASS_ADD
:
1142 ret
= "TC_CLASS_ADD";
1144 case DPLANE_OP_TC_CLASS_DELETE
:
1145 ret
= "TC_CLASS_DELETE";
1147 case DPLANE_OP_TC_CLASS_UPDATE
:
1148 ret
= "TC_CLASS_UPDATE";
1150 case DPLANE_OP_TC_FILTER_ADD
:
1151 ret
= "TC_FILTER_ADD";
1153 case DPLANE_OP_TC_FILTER_DELETE
:
1154 ret
= "TC_FILTER_DELETE";
1156 case DPLANE_OP_TC_FILTER_UPDATE
:
1157 ret
= "TC__FILTER_UPDATE";
1164 const char *dplane_res2str(enum zebra_dplane_result res
)
1166 const char *ret
= "<Unknown>";
1169 case ZEBRA_DPLANE_REQUEST_FAILURE
:
1172 case ZEBRA_DPLANE_REQUEST_QUEUED
:
1175 case ZEBRA_DPLANE_REQUEST_SUCCESS
:
1183 void dplane_ctx_set_dest(struct zebra_dplane_ctx
*ctx
,
1184 const struct prefix
*dest
)
1186 DPLANE_CTX_VALID(ctx
);
1188 prefix_copy(&(ctx
->u
.rinfo
.zd_dest
), dest
);
1191 const struct prefix
*dplane_ctx_get_dest(const struct zebra_dplane_ctx
*ctx
)
1193 DPLANE_CTX_VALID(ctx
);
1195 return &(ctx
->u
.rinfo
.zd_dest
);
1198 void dplane_ctx_set_src(struct zebra_dplane_ctx
*ctx
, const struct prefix
*src
)
1200 DPLANE_CTX_VALID(ctx
);
1203 prefix_copy(&(ctx
->u
.rinfo
.zd_src
), src
);
1205 memset(&(ctx
->u
.rinfo
.zd_src
), 0, sizeof(struct prefix
));
1208 /* Source prefix is a little special - return NULL for "no src prefix" */
1209 const struct prefix
*dplane_ctx_get_src(const struct zebra_dplane_ctx
*ctx
)
1211 DPLANE_CTX_VALID(ctx
);
1213 if (ctx
->u
.rinfo
.zd_src
.prefixlen
== 0 &&
1214 IN6_IS_ADDR_UNSPECIFIED(&(ctx
->u
.rinfo
.zd_src
.u
.prefix6
))) {
1217 return &(ctx
->u
.rinfo
.zd_src
);
1221 bool dplane_ctx_is_update(const struct zebra_dplane_ctx
*ctx
)
1223 DPLANE_CTX_VALID(ctx
);
1225 return ctx
->zd_is_update
;
1228 uint32_t dplane_ctx_get_seq(const struct zebra_dplane_ctx
*ctx
)
1230 DPLANE_CTX_VALID(ctx
);
1235 uint32_t dplane_ctx_get_old_seq(const struct zebra_dplane_ctx
*ctx
)
1237 DPLANE_CTX_VALID(ctx
);
1239 return ctx
->zd_old_seq
;
1242 void dplane_ctx_set_vrf(struct zebra_dplane_ctx
*ctx
, vrf_id_t vrf
)
1244 DPLANE_CTX_VALID(ctx
);
1246 ctx
->zd_vrf_id
= vrf
;
1249 vrf_id_t
dplane_ctx_get_vrf(const struct zebra_dplane_ctx
*ctx
)
1251 DPLANE_CTX_VALID(ctx
);
1253 return ctx
->zd_vrf_id
;
1256 /* In some paths we have only a namespace id */
1257 void dplane_ctx_set_ns_id(struct zebra_dplane_ctx
*ctx
, ns_id_t nsid
)
1259 DPLANE_CTX_VALID(ctx
);
1261 ctx
->zd_ns_info
.ns_id
= nsid
;
1264 ns_id_t
dplane_ctx_get_ns_id(const struct zebra_dplane_ctx
*ctx
)
1266 DPLANE_CTX_VALID(ctx
);
1268 return ctx
->zd_ns_info
.ns_id
;
1271 bool dplane_ctx_is_from_notif(const struct zebra_dplane_ctx
*ctx
)
1273 DPLANE_CTX_VALID(ctx
);
1275 return (ctx
->zd_notif_provider
!= 0);
1278 uint32_t dplane_ctx_get_notif_provider(const struct zebra_dplane_ctx
*ctx
)
1280 DPLANE_CTX_VALID(ctx
);
1282 return ctx
->zd_notif_provider
;
1285 void dplane_ctx_set_notif_provider(struct zebra_dplane_ctx
*ctx
,
1288 DPLANE_CTX_VALID(ctx
);
1290 ctx
->zd_notif_provider
= id
;
1293 const char *dplane_ctx_get_ifname(const struct zebra_dplane_ctx
*ctx
)
1295 DPLANE_CTX_VALID(ctx
);
1297 return ctx
->zd_ifname
;
1300 void dplane_ctx_set_ifname(struct zebra_dplane_ctx
*ctx
, const char *ifname
)
1302 DPLANE_CTX_VALID(ctx
);
1307 strlcpy(ctx
->zd_ifname
, ifname
, sizeof(ctx
->zd_ifname
));
1310 ifindex_t
dplane_ctx_get_ifindex(const struct zebra_dplane_ctx
*ctx
)
1312 DPLANE_CTX_VALID(ctx
);
1314 return ctx
->zd_ifindex
;
1317 void dplane_ctx_set_ifindex(struct zebra_dplane_ctx
*ctx
, ifindex_t ifindex
)
1319 DPLANE_CTX_VALID(ctx
);
1321 ctx
->zd_ifindex
= ifindex
;
1324 void dplane_ctx_set_type(struct zebra_dplane_ctx
*ctx
, int type
)
1326 DPLANE_CTX_VALID(ctx
);
1328 ctx
->u
.rinfo
.zd_type
= type
;
1331 int dplane_ctx_get_type(const struct zebra_dplane_ctx
*ctx
)
1333 DPLANE_CTX_VALID(ctx
);
1335 return ctx
->u
.rinfo
.zd_type
;
1338 int dplane_ctx_get_old_type(const struct zebra_dplane_ctx
*ctx
)
1340 DPLANE_CTX_VALID(ctx
);
1342 return ctx
->u
.rinfo
.zd_old_type
;
1345 void dplane_ctx_set_afi(struct zebra_dplane_ctx
*ctx
, afi_t afi
)
1347 DPLANE_CTX_VALID(ctx
);
1349 ctx
->u
.rinfo
.zd_afi
= afi
;
1352 afi_t
dplane_ctx_get_afi(const struct zebra_dplane_ctx
*ctx
)
1354 DPLANE_CTX_VALID(ctx
);
1356 return ctx
->u
.rinfo
.zd_afi
;
1359 void dplane_ctx_set_safi(struct zebra_dplane_ctx
*ctx
, safi_t safi
)
1361 DPLANE_CTX_VALID(ctx
);
1363 ctx
->u
.rinfo
.zd_safi
= safi
;
1366 safi_t
dplane_ctx_get_safi(const struct zebra_dplane_ctx
*ctx
)
1368 DPLANE_CTX_VALID(ctx
);
1370 return ctx
->u
.rinfo
.zd_safi
;
1373 void dplane_ctx_set_table(struct zebra_dplane_ctx
*ctx
, uint32_t table
)
1375 DPLANE_CTX_VALID(ctx
);
1377 ctx
->zd_table_id
= table
;
1380 uint32_t dplane_ctx_get_table(const struct zebra_dplane_ctx
*ctx
)
1382 DPLANE_CTX_VALID(ctx
);
1384 return ctx
->zd_table_id
;
1387 route_tag_t
dplane_ctx_get_tag(const struct zebra_dplane_ctx
*ctx
)
1389 DPLANE_CTX_VALID(ctx
);
1391 return ctx
->u
.rinfo
.zd_tag
;
1394 void dplane_ctx_set_tag(struct zebra_dplane_ctx
*ctx
, route_tag_t tag
)
1396 DPLANE_CTX_VALID(ctx
);
1398 ctx
->u
.rinfo
.zd_tag
= tag
;
1401 route_tag_t
dplane_ctx_get_old_tag(const struct zebra_dplane_ctx
*ctx
)
1403 DPLANE_CTX_VALID(ctx
);
1405 return ctx
->u
.rinfo
.zd_old_tag
;
1408 uint16_t dplane_ctx_get_instance(const struct zebra_dplane_ctx
*ctx
)
1410 DPLANE_CTX_VALID(ctx
);
1412 return ctx
->u
.rinfo
.zd_instance
;
1415 void dplane_ctx_set_instance(struct zebra_dplane_ctx
*ctx
, uint16_t instance
)
1417 DPLANE_CTX_VALID(ctx
);
1419 ctx
->u
.rinfo
.zd_instance
= instance
;
1422 uint16_t dplane_ctx_get_old_instance(const struct zebra_dplane_ctx
*ctx
)
1424 DPLANE_CTX_VALID(ctx
);
1426 return ctx
->u
.rinfo
.zd_old_instance
;
1429 uint32_t dplane_ctx_get_flags(const struct zebra_dplane_ctx
*ctx
)
1431 DPLANE_CTX_VALID(ctx
);
1433 return ctx
->u
.rinfo
.zd_flags
;
1436 void dplane_ctx_set_flags(struct zebra_dplane_ctx
*ctx
, uint32_t flags
)
1438 DPLANE_CTX_VALID(ctx
);
1440 ctx
->u
.rinfo
.zd_flags
= flags
;
1443 uint32_t dplane_ctx_get_metric(const struct zebra_dplane_ctx
*ctx
)
1445 DPLANE_CTX_VALID(ctx
);
1447 return ctx
->u
.rinfo
.zd_metric
;
1450 uint32_t dplane_ctx_get_old_metric(const struct zebra_dplane_ctx
*ctx
)
1452 DPLANE_CTX_VALID(ctx
);
1454 return ctx
->u
.rinfo
.zd_old_metric
;
1457 uint32_t dplane_ctx_get_mtu(const struct zebra_dplane_ctx
*ctx
)
1459 DPLANE_CTX_VALID(ctx
);
1461 return ctx
->u
.rinfo
.zd_mtu
;
1464 uint32_t dplane_ctx_get_nh_mtu(const struct zebra_dplane_ctx
*ctx
)
1466 DPLANE_CTX_VALID(ctx
);
1468 return ctx
->u
.rinfo
.zd_nexthop_mtu
;
1471 uint8_t dplane_ctx_get_distance(const struct zebra_dplane_ctx
*ctx
)
1473 DPLANE_CTX_VALID(ctx
);
1475 return ctx
->u
.rinfo
.zd_distance
;
1478 void dplane_ctx_set_distance(struct zebra_dplane_ctx
*ctx
, uint8_t distance
)
1480 DPLANE_CTX_VALID(ctx
);
1482 ctx
->u
.rinfo
.zd_distance
= distance
;
1485 uint8_t dplane_ctx_get_old_distance(const struct zebra_dplane_ctx
*ctx
)
1487 DPLANE_CTX_VALID(ctx
);
1489 return ctx
->u
.rinfo
.zd_old_distance
;
1492 int dplane_ctx_tc_qdisc_get_kind(const struct zebra_dplane_ctx
*ctx
)
1494 DPLANE_CTX_VALID(ctx
);
1496 return ctx
->u
.tc_qdisc
.kind
;
1499 const char *dplane_ctx_tc_qdisc_get_kind_str(const struct zebra_dplane_ctx
*ctx
)
1501 DPLANE_CTX_VALID(ctx
);
1503 return ctx
->u
.tc_qdisc
.kind_str
;
1506 uint32_t dplane_ctx_tc_class_get_handle(const struct zebra_dplane_ctx
*ctx
)
1508 DPLANE_CTX_VALID(ctx
);
1510 return ctx
->u
.tc_class
.handle
;
1513 int dplane_ctx_tc_class_get_kind(const struct zebra_dplane_ctx
*ctx
)
1515 DPLANE_CTX_VALID(ctx
);
1517 return ctx
->u
.tc_class
.kind
;
1520 const char *dplane_ctx_tc_class_get_kind_str(const struct zebra_dplane_ctx
*ctx
)
1522 DPLANE_CTX_VALID(ctx
);
1524 return ctx
->u
.tc_class
.kind_str
;
1527 uint64_t dplane_ctx_tc_class_get_rate(const struct zebra_dplane_ctx
*ctx
)
1529 DPLANE_CTX_VALID(ctx
);
1531 return ctx
->u
.tc_class
.rate
;
1534 uint64_t dplane_ctx_tc_class_get_ceil(const struct zebra_dplane_ctx
*ctx
)
1536 DPLANE_CTX_VALID(ctx
);
1538 return ctx
->u
.tc_class
.ceil
;
1541 int dplane_ctx_tc_filter_get_kind(const struct zebra_dplane_ctx
*ctx
)
1543 DPLANE_CTX_VALID(ctx
);
1545 return ctx
->u
.tc_filter
.kind
;
1549 dplane_ctx_tc_filter_get_kind_str(const struct zebra_dplane_ctx
*ctx
)
1551 DPLANE_CTX_VALID(ctx
);
1553 return ctx
->u
.tc_filter
.kind_str
;
1556 uint32_t dplane_ctx_tc_filter_get_priority(const struct zebra_dplane_ctx
*ctx
)
1558 DPLANE_CTX_VALID(ctx
);
1560 return ctx
->u
.tc_filter
.priority
;
1563 uint32_t dplane_ctx_tc_filter_get_handle(const struct zebra_dplane_ctx
*ctx
)
1565 DPLANE_CTX_VALID(ctx
);
1567 return ctx
->u
.tc_filter
.handle
;
1570 uint16_t dplane_ctx_tc_filter_get_eth_proto(const struct zebra_dplane_ctx
*ctx
)
1572 DPLANE_CTX_VALID(ctx
);
1574 return ctx
->u
.tc_filter
.eth_proto
;
1577 uint32_t dplane_ctx_tc_filter_get_filter_bm(const struct zebra_dplane_ctx
*ctx
)
1579 DPLANE_CTX_VALID(ctx
);
1581 return ctx
->u
.tc_filter
.filter_bm
;
1584 const struct prefix
*
1585 dplane_ctx_tc_filter_get_src_ip(const struct zebra_dplane_ctx
*ctx
)
1587 DPLANE_CTX_VALID(ctx
);
1589 return &ctx
->u
.tc_filter
.src_ip
;
1593 dplane_ctx_tc_filter_get_src_port_min(const struct zebra_dplane_ctx
*ctx
)
1595 DPLANE_CTX_VALID(ctx
);
1597 return ctx
->u
.tc_filter
.src_port_min
;
1602 dplane_ctx_tc_filter_get_src_port_max(const struct zebra_dplane_ctx
*ctx
)
1604 DPLANE_CTX_VALID(ctx
);
1606 return ctx
->u
.tc_filter
.src_port_max
;
1609 const struct prefix
*
1610 dplane_ctx_tc_filter_get_dst_ip(const struct zebra_dplane_ctx
*ctx
)
1612 DPLANE_CTX_VALID(ctx
);
1614 return &ctx
->u
.tc_filter
.dst_ip
;
1618 dplane_ctx_tc_filter_get_dst_port_min(const struct zebra_dplane_ctx
*ctx
)
1620 DPLANE_CTX_VALID(ctx
);
1622 return ctx
->u
.tc_filter
.dst_port_min
;
1627 dplane_ctx_tc_filter_get_dst_port_max(const struct zebra_dplane_ctx
*ctx
)
1629 DPLANE_CTX_VALID(ctx
);
1631 return ctx
->u
.tc_filter
.dst_port_max
;
1634 uint8_t dplane_ctx_tc_filter_get_ip_proto(const struct zebra_dplane_ctx
*ctx
)
1636 DPLANE_CTX_VALID(ctx
);
1638 return ctx
->u
.tc_filter
.ip_proto
;
1641 uint8_t dplane_ctx_tc_filter_get_dsfield(const struct zebra_dplane_ctx
*ctx
)
1643 DPLANE_CTX_VALID(ctx
);
1645 return ctx
->u
.tc_filter
.dsfield
;
1649 dplane_ctx_tc_filter_get_dsfield_mask(const struct zebra_dplane_ctx
*ctx
)
1651 DPLANE_CTX_VALID(ctx
);
1653 return ctx
->u
.tc_filter
.dsfield_mask
;
1656 uint32_t dplane_ctx_tc_filter_get_classid(const struct zebra_dplane_ctx
*ctx
)
1658 DPLANE_CTX_VALID(ctx
);
1660 return ctx
->u
.tc_filter
.classid
;
1664 * Set the nexthops associated with a context: note that processing code
1665 * may well expect that nexthops are in canonical (sorted) order, so we
1666 * will enforce that here.
1668 void dplane_ctx_set_nexthops(struct zebra_dplane_ctx
*ctx
, struct nexthop
*nh
)
1670 DPLANE_CTX_VALID(ctx
);
1672 if (ctx
->u
.rinfo
.zd_ng
.nexthop
) {
1673 nexthops_free(ctx
->u
.rinfo
.zd_ng
.nexthop
);
1674 ctx
->u
.rinfo
.zd_ng
.nexthop
= NULL
;
1676 nexthop_group_copy_nh_sorted(&(ctx
->u
.rinfo
.zd_ng
), nh
);
1680 * Set the list of backup nexthops; their ordering is preserved (they're not
1683 void dplane_ctx_set_backup_nhg(struct zebra_dplane_ctx
*ctx
,
1684 const struct nexthop_group
*nhg
)
1686 struct nexthop
*nh
, *last_nh
, *nexthop
;
1688 DPLANE_CTX_VALID(ctx
);
1690 if (ctx
->u
.rinfo
.backup_ng
.nexthop
) {
1691 nexthops_free(ctx
->u
.rinfo
.backup_ng
.nexthop
);
1692 ctx
->u
.rinfo
.backup_ng
.nexthop
= NULL
;
1697 /* Be careful to preserve the order of the backup list */
1698 for (nh
= nhg
->nexthop
; nh
; nh
= nh
->next
) {
1699 nexthop
= nexthop_dup(nh
, NULL
);
1702 NEXTHOP_APPEND(last_nh
, nexthop
);
1704 ctx
->u
.rinfo
.backup_ng
.nexthop
= nexthop
;
1710 uint32_t dplane_ctx_get_nhg_id(const struct zebra_dplane_ctx
*ctx
)
1712 DPLANE_CTX_VALID(ctx
);
1713 return ctx
->u
.rinfo
.zd_nhg_id
;
1716 const struct nexthop_group
*dplane_ctx_get_ng(
1717 const struct zebra_dplane_ctx
*ctx
)
1719 DPLANE_CTX_VALID(ctx
);
1721 return &(ctx
->u
.rinfo
.zd_ng
);
1724 const struct nexthop_group
*
1725 dplane_ctx_get_backup_ng(const struct zebra_dplane_ctx
*ctx
)
1727 DPLANE_CTX_VALID(ctx
);
1729 return &(ctx
->u
.rinfo
.backup_ng
);
1732 const struct nexthop_group
*
1733 dplane_ctx_get_old_ng(const struct zebra_dplane_ctx
*ctx
)
1735 DPLANE_CTX_VALID(ctx
);
1737 return &(ctx
->u
.rinfo
.zd_old_ng
);
1740 const struct nexthop_group
*
1741 dplane_ctx_get_old_backup_ng(const struct zebra_dplane_ctx
*ctx
)
1743 DPLANE_CTX_VALID(ctx
);
1745 return &(ctx
->u
.rinfo
.old_backup_ng
);
1748 const struct zebra_dplane_info
*dplane_ctx_get_ns(
1749 const struct zebra_dplane_ctx
*ctx
)
1751 DPLANE_CTX_VALID(ctx
);
1753 return &(ctx
->zd_ns_info
);
1756 int dplane_ctx_get_ns_sock(const struct zebra_dplane_ctx
*ctx
)
1758 DPLANE_CTX_VALID(ctx
);
1761 return ctx
->zd_ns_info
.sock
;
1767 /* Accessors for nexthop information */
1768 uint32_t dplane_ctx_get_nhe_id(const struct zebra_dplane_ctx
*ctx
)
1770 DPLANE_CTX_VALID(ctx
);
1771 return ctx
->u
.rinfo
.nhe
.id
;
1774 uint32_t dplane_ctx_get_old_nhe_id(const struct zebra_dplane_ctx
*ctx
)
1776 DPLANE_CTX_VALID(ctx
);
1777 return ctx
->u
.rinfo
.nhe
.old_id
;
1780 afi_t
dplane_ctx_get_nhe_afi(const struct zebra_dplane_ctx
*ctx
)
1782 DPLANE_CTX_VALID(ctx
);
1783 return ctx
->u
.rinfo
.nhe
.afi
;
1786 vrf_id_t
dplane_ctx_get_nhe_vrf_id(const struct zebra_dplane_ctx
*ctx
)
1788 DPLANE_CTX_VALID(ctx
);
1789 return ctx
->u
.rinfo
.nhe
.vrf_id
;
1792 int dplane_ctx_get_nhe_type(const struct zebra_dplane_ctx
*ctx
)
1794 DPLANE_CTX_VALID(ctx
);
1795 return ctx
->u
.rinfo
.nhe
.type
;
1798 const struct nexthop_group
*
1799 dplane_ctx_get_nhe_ng(const struct zebra_dplane_ctx
*ctx
)
1801 DPLANE_CTX_VALID(ctx
);
1802 return &(ctx
->u
.rinfo
.nhe
.ng
);
1805 const struct nh_grp
*
1806 dplane_ctx_get_nhe_nh_grp(const struct zebra_dplane_ctx
*ctx
)
1808 DPLANE_CTX_VALID(ctx
);
1809 return ctx
->u
.rinfo
.nhe
.nh_grp
;
1812 uint8_t dplane_ctx_get_nhe_nh_grp_count(const struct zebra_dplane_ctx
*ctx
)
1814 DPLANE_CTX_VALID(ctx
);
1815 return ctx
->u
.rinfo
.nhe
.nh_grp_count
;
1818 /* Accessors for LSP information */
1820 mpls_label_t
dplane_ctx_get_in_label(const struct zebra_dplane_ctx
*ctx
)
1822 DPLANE_CTX_VALID(ctx
);
1824 return ctx
->u
.lsp
.ile
.in_label
;
1827 void dplane_ctx_set_in_label(struct zebra_dplane_ctx
*ctx
, mpls_label_t label
)
1829 DPLANE_CTX_VALID(ctx
);
1831 ctx
->u
.lsp
.ile
.in_label
= label
;
1834 uint8_t dplane_ctx_get_addr_family(const struct zebra_dplane_ctx
*ctx
)
1836 DPLANE_CTX_VALID(ctx
);
1838 return ctx
->u
.lsp
.addr_family
;
1841 void dplane_ctx_set_addr_family(struct zebra_dplane_ctx
*ctx
,
1844 DPLANE_CTX_VALID(ctx
);
1846 ctx
->u
.lsp
.addr_family
= family
;
1849 uint32_t dplane_ctx_get_lsp_flags(const struct zebra_dplane_ctx
*ctx
)
1851 DPLANE_CTX_VALID(ctx
);
1853 return ctx
->u
.lsp
.flags
;
1856 void dplane_ctx_set_lsp_flags(struct zebra_dplane_ctx
*ctx
,
1859 DPLANE_CTX_VALID(ctx
);
1861 ctx
->u
.lsp
.flags
= flags
;
1864 const struct nhlfe_list_head
*dplane_ctx_get_nhlfe_list(
1865 const struct zebra_dplane_ctx
*ctx
)
1867 DPLANE_CTX_VALID(ctx
);
1868 return &(ctx
->u
.lsp
.nhlfe_list
);
1871 const struct nhlfe_list_head
*dplane_ctx_get_backup_nhlfe_list(
1872 const struct zebra_dplane_ctx
*ctx
)
1874 DPLANE_CTX_VALID(ctx
);
1875 return &(ctx
->u
.lsp
.backup_nhlfe_list
);
1878 struct zebra_nhlfe
*dplane_ctx_add_nhlfe(struct zebra_dplane_ctx
*ctx
,
1879 enum lsp_types_t lsp_type
,
1880 enum nexthop_types_t nh_type
,
1881 const union g_addr
*gate
,
1882 ifindex_t ifindex
, uint8_t num_labels
,
1883 mpls_label_t
*out_labels
)
1885 struct zebra_nhlfe
*nhlfe
;
1887 DPLANE_CTX_VALID(ctx
);
1889 nhlfe
= zebra_mpls_lsp_add_nhlfe(&(ctx
->u
.lsp
),
1890 lsp_type
, nh_type
, gate
,
1891 ifindex
, num_labels
, out_labels
);
1896 struct zebra_nhlfe
*dplane_ctx_add_backup_nhlfe(
1897 struct zebra_dplane_ctx
*ctx
, enum lsp_types_t lsp_type
,
1898 enum nexthop_types_t nh_type
, const union g_addr
*gate
,
1899 ifindex_t ifindex
, uint8_t num_labels
, mpls_label_t
*out_labels
)
1901 struct zebra_nhlfe
*nhlfe
;
1903 DPLANE_CTX_VALID(ctx
);
1905 nhlfe
= zebra_mpls_lsp_add_backup_nhlfe(&(ctx
->u
.lsp
),
1906 lsp_type
, nh_type
, gate
,
1907 ifindex
, num_labels
,
1913 const struct zebra_nhlfe
*
1914 dplane_ctx_get_best_nhlfe(const struct zebra_dplane_ctx
*ctx
)
1916 DPLANE_CTX_VALID(ctx
);
1918 return ctx
->u
.lsp
.best_nhlfe
;
1921 const struct zebra_nhlfe
*
1922 dplane_ctx_set_best_nhlfe(struct zebra_dplane_ctx
*ctx
,
1923 struct zebra_nhlfe
*nhlfe
)
1925 DPLANE_CTX_VALID(ctx
);
1927 ctx
->u
.lsp
.best_nhlfe
= nhlfe
;
1928 return ctx
->u
.lsp
.best_nhlfe
;
1931 uint32_t dplane_ctx_get_lsp_num_ecmp(const struct zebra_dplane_ctx
*ctx
)
1933 DPLANE_CTX_VALID(ctx
);
1935 return ctx
->u
.lsp
.num_ecmp
;
1938 mpls_label_t
dplane_ctx_get_pw_local_label(const struct zebra_dplane_ctx
*ctx
)
1940 DPLANE_CTX_VALID(ctx
);
1942 return ctx
->u
.pw
.local_label
;
1945 mpls_label_t
dplane_ctx_get_pw_remote_label(const struct zebra_dplane_ctx
*ctx
)
1947 DPLANE_CTX_VALID(ctx
);
1949 return ctx
->u
.pw
.remote_label
;
1952 int dplane_ctx_get_pw_type(const struct zebra_dplane_ctx
*ctx
)
1954 DPLANE_CTX_VALID(ctx
);
1956 return ctx
->u
.pw
.type
;
1959 int dplane_ctx_get_pw_af(const struct zebra_dplane_ctx
*ctx
)
1961 DPLANE_CTX_VALID(ctx
);
1963 return ctx
->u
.pw
.af
;
1966 uint32_t dplane_ctx_get_pw_flags(const struct zebra_dplane_ctx
*ctx
)
1968 DPLANE_CTX_VALID(ctx
);
1970 return ctx
->u
.pw
.flags
;
1973 int dplane_ctx_get_pw_status(const struct zebra_dplane_ctx
*ctx
)
1975 DPLANE_CTX_VALID(ctx
);
1977 return ctx
->u
.pw
.status
;
1980 void dplane_ctx_set_pw_status(struct zebra_dplane_ctx
*ctx
, int status
)
1982 DPLANE_CTX_VALID(ctx
);
1984 ctx
->u
.pw
.status
= status
;
1987 const union g_addr
*dplane_ctx_get_pw_dest(
1988 const struct zebra_dplane_ctx
*ctx
)
1990 DPLANE_CTX_VALID(ctx
);
1992 return &(ctx
->u
.pw
.dest
);
1995 const union pw_protocol_fields
*dplane_ctx_get_pw_proto(
1996 const struct zebra_dplane_ctx
*ctx
)
1998 DPLANE_CTX_VALID(ctx
);
2000 return &(ctx
->u
.pw
.fields
);
2003 const struct nexthop_group
*
2004 dplane_ctx_get_pw_nhg(const struct zebra_dplane_ctx
*ctx
)
2006 DPLANE_CTX_VALID(ctx
);
2008 return &(ctx
->u
.pw
.fib_nhg
);
2011 const struct nexthop_group
*
2012 dplane_ctx_get_pw_primary_nhg(const struct zebra_dplane_ctx
*ctx
)
2014 DPLANE_CTX_VALID(ctx
);
2016 return &(ctx
->u
.pw
.primary_nhg
);
2019 const struct nexthop_group
*
2020 dplane_ctx_get_pw_backup_nhg(const struct zebra_dplane_ctx
*ctx
)
2022 DPLANE_CTX_VALID(ctx
);
2024 return &(ctx
->u
.pw
.backup_nhg
);
2027 /* Accessors for interface information */
2028 uint32_t dplane_ctx_get_intf_metric(const struct zebra_dplane_ctx
*ctx
)
2030 DPLANE_CTX_VALID(ctx
);
2032 return ctx
->u
.intf
.metric
;
2035 void dplane_ctx_set_intf_metric(struct zebra_dplane_ctx
*ctx
, uint32_t metric
)
2037 DPLANE_CTX_VALID(ctx
);
2039 ctx
->u
.intf
.metric
= metric
;
2042 uint32_t dplane_ctx_get_intf_pd_reason_val(const struct zebra_dplane_ctx
*ctx
)
2044 DPLANE_CTX_VALID(ctx
);
2046 return ctx
->u
.intf
.pd_reason_val
;
2049 void dplane_ctx_set_intf_pd_reason_val(struct zebra_dplane_ctx
*ctx
, bool val
)
2051 DPLANE_CTX_VALID(ctx
);
2053 ctx
->u
.intf
.pd_reason_val
= val
;
2056 bool dplane_ctx_intf_is_protodown(const struct zebra_dplane_ctx
*ctx
)
2058 DPLANE_CTX_VALID(ctx
);
2060 return ctx
->u
.intf
.protodown
;
2063 /* Is interface addr p2p? */
2064 bool dplane_ctx_intf_is_connected(const struct zebra_dplane_ctx
*ctx
)
2066 DPLANE_CTX_VALID(ctx
);
2068 return (ctx
->u
.intf
.flags
& DPLANE_INTF_CONNECTED
);
2071 bool dplane_ctx_intf_is_secondary(const struct zebra_dplane_ctx
*ctx
)
2073 DPLANE_CTX_VALID(ctx
);
2075 return (ctx
->u
.intf
.flags
& DPLANE_INTF_SECONDARY
);
2078 bool dplane_ctx_intf_is_broadcast(const struct zebra_dplane_ctx
*ctx
)
2080 DPLANE_CTX_VALID(ctx
);
2082 return (ctx
->u
.intf
.flags
& DPLANE_INTF_BROADCAST
);
2085 void dplane_ctx_intf_set_connected(struct zebra_dplane_ctx
*ctx
)
2087 DPLANE_CTX_VALID(ctx
);
2089 ctx
->u
.intf
.flags
|= DPLANE_INTF_CONNECTED
;
2092 void dplane_ctx_intf_set_secondary(struct zebra_dplane_ctx
*ctx
)
2094 DPLANE_CTX_VALID(ctx
);
2096 ctx
->u
.intf
.flags
|= DPLANE_INTF_SECONDARY
;
2099 void dplane_ctx_intf_set_broadcast(struct zebra_dplane_ctx
*ctx
)
2101 DPLANE_CTX_VALID(ctx
);
2103 ctx
->u
.intf
.flags
|= DPLANE_INTF_BROADCAST
;
2106 const struct prefix
*dplane_ctx_get_intf_addr(
2107 const struct zebra_dplane_ctx
*ctx
)
2109 DPLANE_CTX_VALID(ctx
);
2111 return &(ctx
->u
.intf
.prefix
);
2114 void dplane_ctx_set_intf_addr(struct zebra_dplane_ctx
*ctx
,
2115 const struct prefix
*p
)
2117 DPLANE_CTX_VALID(ctx
);
2119 prefix_copy(&(ctx
->u
.intf
.prefix
), p
);
2122 bool dplane_ctx_intf_has_dest(const struct zebra_dplane_ctx
*ctx
)
2124 DPLANE_CTX_VALID(ctx
);
2126 return (ctx
->u
.intf
.flags
& DPLANE_INTF_HAS_DEST
);
2129 const struct prefix
*dplane_ctx_get_intf_dest(
2130 const struct zebra_dplane_ctx
*ctx
)
2132 DPLANE_CTX_VALID(ctx
);
2134 return &(ctx
->u
.intf
.dest_prefix
);
2137 void dplane_ctx_set_intf_dest(struct zebra_dplane_ctx
*ctx
,
2138 const struct prefix
*p
)
2140 DPLANE_CTX_VALID(ctx
);
2142 prefix_copy(&(ctx
->u
.intf
.dest_prefix
), p
);
2145 bool dplane_ctx_intf_has_label(const struct zebra_dplane_ctx
*ctx
)
2147 DPLANE_CTX_VALID(ctx
);
2149 return (ctx
->u
.intf
.flags
& DPLANE_INTF_HAS_LABEL
);
2152 const char *dplane_ctx_get_intf_label(const struct zebra_dplane_ctx
*ctx
)
2154 DPLANE_CTX_VALID(ctx
);
2156 return ctx
->u
.intf
.label
;
2159 void dplane_ctx_set_intf_label(struct zebra_dplane_ctx
*ctx
, const char *label
)
2163 DPLANE_CTX_VALID(ctx
);
2165 if (ctx
->u
.intf
.label
&& ctx
->u
.intf
.label
!= ctx
->u
.intf
.label_buf
)
2166 XFREE(MTYPE_DP_CTX
, ctx
->u
.intf
.label
);
2168 ctx
->u
.intf
.label
= NULL
;
2171 ctx
->u
.intf
.flags
|= DPLANE_INTF_HAS_LABEL
;
2173 /* Use embedded buffer if it's adequate; else allocate. */
2174 len
= strlen(label
);
2176 if (len
< sizeof(ctx
->u
.intf
.label_buf
)) {
2177 strlcpy(ctx
->u
.intf
.label_buf
, label
,
2178 sizeof(ctx
->u
.intf
.label_buf
));
2179 ctx
->u
.intf
.label
= ctx
->u
.intf
.label_buf
;
2181 ctx
->u
.intf
.label
= XSTRDUP(MTYPE_DP_CTX
, label
);
2184 ctx
->u
.intf
.flags
&= ~DPLANE_INTF_HAS_LABEL
;
2188 /* Accessors for MAC information */
2189 vlanid_t
dplane_ctx_mac_get_vlan(const struct zebra_dplane_ctx
*ctx
)
2191 DPLANE_CTX_VALID(ctx
);
2192 return ctx
->u
.macinfo
.vid
;
2195 bool dplane_ctx_mac_is_sticky(const struct zebra_dplane_ctx
*ctx
)
2197 DPLANE_CTX_VALID(ctx
);
2198 return ctx
->u
.macinfo
.is_sticky
;
2201 uint32_t dplane_ctx_mac_get_nhg_id(const struct zebra_dplane_ctx
*ctx
)
2203 DPLANE_CTX_VALID(ctx
);
2204 return ctx
->u
.macinfo
.nhg_id
;
2207 uint32_t dplane_ctx_mac_get_update_flags(const struct zebra_dplane_ctx
*ctx
)
2209 DPLANE_CTX_VALID(ctx
);
2210 return ctx
->u
.macinfo
.update_flags
;
2213 const struct ethaddr
*dplane_ctx_mac_get_addr(
2214 const struct zebra_dplane_ctx
*ctx
)
2216 DPLANE_CTX_VALID(ctx
);
2217 return &(ctx
->u
.macinfo
.mac
);
2220 vni_t
dplane_ctx_mac_get_vni(const struct zebra_dplane_ctx
*ctx
)
2222 DPLANE_CTX_VALID(ctx
);
2223 return ctx
->u
.macinfo
.vni
;
2226 const struct in_addr
*dplane_ctx_mac_get_vtep_ip(
2227 const struct zebra_dplane_ctx
*ctx
)
2229 DPLANE_CTX_VALID(ctx
);
2230 return &(ctx
->u
.macinfo
.vtep_ip
);
2233 ifindex_t
dplane_ctx_mac_get_br_ifindex(const struct zebra_dplane_ctx
*ctx
)
2235 DPLANE_CTX_VALID(ctx
);
2236 return ctx
->u
.macinfo
.br_ifindex
;
2239 /* Accessors for neighbor information */
2240 const struct ipaddr
*dplane_ctx_neigh_get_ipaddr(
2241 const struct zebra_dplane_ctx
*ctx
)
2243 DPLANE_CTX_VALID(ctx
);
2244 return &(ctx
->u
.neigh
.ip_addr
);
2247 const struct ipaddr
*
2248 dplane_ctx_neigh_get_link_ip(const struct zebra_dplane_ctx
*ctx
)
2250 DPLANE_CTX_VALID(ctx
);
2251 return &(ctx
->u
.neigh
.link
.ip_addr
);
2254 const struct ethaddr
*dplane_ctx_neigh_get_mac(
2255 const struct zebra_dplane_ctx
*ctx
)
2257 DPLANE_CTX_VALID(ctx
);
2258 return &(ctx
->u
.neigh
.link
.mac
);
2261 vni_t
dplane_ctx_neigh_get_vni(const struct zebra_dplane_ctx
*ctx
)
2263 DPLANE_CTX_VALID(ctx
);
2264 return ctx
->u
.neigh
.vni
;
2267 uint32_t dplane_ctx_neigh_get_flags(const struct zebra_dplane_ctx
*ctx
)
2269 DPLANE_CTX_VALID(ctx
);
2270 return ctx
->u
.neigh
.flags
;
2273 uint16_t dplane_ctx_neigh_get_state(const struct zebra_dplane_ctx
*ctx
)
2275 DPLANE_CTX_VALID(ctx
);
2276 return ctx
->u
.neigh
.state
;
2279 uint32_t dplane_ctx_neigh_get_update_flags(const struct zebra_dplane_ctx
*ctx
)
2281 DPLANE_CTX_VALID(ctx
);
2282 return ctx
->u
.neigh
.update_flags
;
2285 /* Accessor for GRE set */
2287 dplane_ctx_gre_get_link_ifindex(const struct zebra_dplane_ctx
*ctx
)
2289 DPLANE_CTX_VALID(ctx
);
2291 return ctx
->u
.gre
.link_ifindex
;
2295 dplane_ctx_gre_get_mtu(const struct zebra_dplane_ctx
*ctx
)
2297 DPLANE_CTX_VALID(ctx
);
2299 return ctx
->u
.gre
.mtu
;
2302 const struct zebra_l2info_gre
*
2303 dplane_ctx_gre_get_info(const struct zebra_dplane_ctx
*ctx
)
2305 DPLANE_CTX_VALID(ctx
);
2307 return &ctx
->u
.gre
.info
;
2310 /* Accessors for PBR rule information */
2311 int dplane_ctx_rule_get_sock(const struct zebra_dplane_ctx
*ctx
)
2313 DPLANE_CTX_VALID(ctx
);
2315 return ctx
->u
.rule
.sock
;
2318 const char *dplane_ctx_rule_get_ifname(const struct zebra_dplane_ctx
*ctx
)
2320 DPLANE_CTX_VALID(ctx
);
2322 return ctx
->u
.rule
.new.ifname
;
2325 int dplane_ctx_rule_get_unique(const struct zebra_dplane_ctx
*ctx
)
2327 DPLANE_CTX_VALID(ctx
);
2329 return ctx
->u
.rule
.unique
;
2332 int dplane_ctx_rule_get_seq(const struct zebra_dplane_ctx
*ctx
)
2334 DPLANE_CTX_VALID(ctx
);
2336 return ctx
->u
.rule
.seq
;
2339 uint32_t dplane_ctx_rule_get_priority(const struct zebra_dplane_ctx
*ctx
)
2341 DPLANE_CTX_VALID(ctx
);
2343 return ctx
->u
.rule
.new.priority
;
2346 uint32_t dplane_ctx_rule_get_old_priority(const struct zebra_dplane_ctx
*ctx
)
2348 DPLANE_CTX_VALID(ctx
);
2350 return ctx
->u
.rule
.old
.priority
;
2353 uint32_t dplane_ctx_rule_get_table(const struct zebra_dplane_ctx
*ctx
)
2355 DPLANE_CTX_VALID(ctx
);
2357 return ctx
->u
.rule
.new.table
;
2360 uint32_t dplane_ctx_rule_get_old_table(const struct zebra_dplane_ctx
*ctx
)
2362 DPLANE_CTX_VALID(ctx
);
2364 return ctx
->u
.rule
.old
.table
;
2367 uint32_t dplane_ctx_rule_get_filter_bm(const struct zebra_dplane_ctx
*ctx
)
2369 DPLANE_CTX_VALID(ctx
);
2371 return ctx
->u
.rule
.new.filter_bm
;
2374 uint32_t dplane_ctx_rule_get_old_filter_bm(const struct zebra_dplane_ctx
*ctx
)
2376 DPLANE_CTX_VALID(ctx
);
2378 return ctx
->u
.rule
.old
.filter_bm
;
2381 uint32_t dplane_ctx_rule_get_fwmark(const struct zebra_dplane_ctx
*ctx
)
2383 DPLANE_CTX_VALID(ctx
);
2385 return ctx
->u
.rule
.new.fwmark
;
2388 uint32_t dplane_ctx_rule_get_old_fwmark(const struct zebra_dplane_ctx
*ctx
)
2390 DPLANE_CTX_VALID(ctx
);
2392 return ctx
->u
.rule
.old
.fwmark
;
2395 uint8_t dplane_ctx_rule_get_ipproto(const struct zebra_dplane_ctx
*ctx
)
2397 DPLANE_CTX_VALID(ctx
);
2399 return ctx
->u
.rule
.new.ip_proto
;
2402 uint8_t dplane_ctx_rule_get_old_ipproto(const struct zebra_dplane_ctx
*ctx
)
2404 DPLANE_CTX_VALID(ctx
);
2406 return ctx
->u
.rule
.old
.ip_proto
;
2409 uint16_t dplane_ctx_rule_get_src_port(const struct zebra_dplane_ctx
*ctx
)
2411 DPLANE_CTX_VALID(ctx
);
2413 return ctx
->u
.rule
.new.src_port
;
2416 uint16_t dplane_ctx_rule_get_old_src_port(const struct zebra_dplane_ctx
*ctx
)
2418 DPLANE_CTX_VALID(ctx
);
2420 return ctx
->u
.rule
.old
.src_port
;
2423 uint16_t dplane_ctx_rule_get_dst_port(const struct zebra_dplane_ctx
*ctx
)
2425 DPLANE_CTX_VALID(ctx
);
2427 return ctx
->u
.rule
.new.dst_port
;
2430 uint16_t dplane_ctx_rule_get_old_dst_port(const struct zebra_dplane_ctx
*ctx
)
2432 DPLANE_CTX_VALID(ctx
);
2434 return ctx
->u
.rule
.old
.dst_port
;
2437 uint8_t dplane_ctx_rule_get_dsfield(const struct zebra_dplane_ctx
*ctx
)
2439 DPLANE_CTX_VALID(ctx
);
2441 return ctx
->u
.rule
.new.dsfield
;
2444 uint8_t dplane_ctx_rule_get_old_dsfield(const struct zebra_dplane_ctx
*ctx
)
2446 DPLANE_CTX_VALID(ctx
);
2448 return ctx
->u
.rule
.old
.dsfield
;
2451 const struct prefix
*
2452 dplane_ctx_rule_get_src_ip(const struct zebra_dplane_ctx
*ctx
)
2454 DPLANE_CTX_VALID(ctx
);
2456 return &(ctx
->u
.rule
.new.src_ip
);
2459 const struct prefix
*
2460 dplane_ctx_rule_get_old_src_ip(const struct zebra_dplane_ctx
*ctx
)
2462 DPLANE_CTX_VALID(ctx
);
2464 return &(ctx
->u
.rule
.old
.src_ip
);
2467 const struct prefix
*
2468 dplane_ctx_rule_get_dst_ip(const struct zebra_dplane_ctx
*ctx
)
2470 DPLANE_CTX_VALID(ctx
);
2472 return &(ctx
->u
.rule
.new.dst_ip
);
2475 const struct prefix
*
2476 dplane_ctx_rule_get_old_dst_ip(const struct zebra_dplane_ctx
*ctx
)
2478 DPLANE_CTX_VALID(ctx
);
2480 return &(ctx
->u
.rule
.old
.dst_ip
);
2483 uint32_t dplane_ctx_get_br_port_flags(const struct zebra_dplane_ctx
*ctx
)
2485 DPLANE_CTX_VALID(ctx
);
2487 return ctx
->u
.br_port
.flags
;
2491 dplane_ctx_get_br_port_sph_filter_cnt(const struct zebra_dplane_ctx
*ctx
)
2493 DPLANE_CTX_VALID(ctx
);
2495 return ctx
->u
.br_port
.sph_filter_cnt
;
2498 const struct in_addr
*
2499 dplane_ctx_get_br_port_sph_filters(const struct zebra_dplane_ctx
*ctx
)
2501 DPLANE_CTX_VALID(ctx
);
2503 return ctx
->u
.br_port
.sph_filters
;
2507 dplane_ctx_get_br_port_backup_nhg_id(const struct zebra_dplane_ctx
*ctx
)
2509 DPLANE_CTX_VALID(ctx
);
2511 return ctx
->u
.br_port
.backup_nhg_id
;
2514 /* Accessors for PBR iptable information */
2515 void dplane_ctx_get_pbr_iptable(const struct zebra_dplane_ctx
*ctx
,
2516 struct zebra_pbr_iptable
*table
)
2518 DPLANE_CTX_VALID(ctx
);
2520 memcpy(table
, &ctx
->u
.iptable
, sizeof(struct zebra_pbr_iptable
));
2523 void dplane_ctx_get_pbr_ipset(const struct zebra_dplane_ctx
*ctx
,
2524 struct zebra_pbr_ipset
*ipset
)
2526 DPLANE_CTX_VALID(ctx
);
2530 if (ctx
->zd_op
== DPLANE_OP_IPSET_ENTRY_ADD
||
2531 ctx
->zd_op
== DPLANE_OP_IPSET_ENTRY_DELETE
) {
2532 memset(ipset
, 0, sizeof(struct zebra_pbr_ipset
));
2533 ipset
->type
= ctx
->u
.ipset_entry
.info
.type
;
2534 ipset
->family
= ctx
->u
.ipset_entry
.info
.family
;
2535 memcpy(&ipset
->ipset_name
, &ctx
->u
.ipset_entry
.info
.ipset_name
,
2536 ZEBRA_IPSET_NAME_SIZE
);
2538 memcpy(ipset
, &ctx
->u
.ipset
, sizeof(struct zebra_pbr_ipset
));
2541 void dplane_ctx_get_pbr_ipset_entry(const struct zebra_dplane_ctx
*ctx
,
2542 struct zebra_pbr_ipset_entry
*entry
)
2544 DPLANE_CTX_VALID(ctx
);
2548 memcpy(entry
, &ctx
->u
.ipset_entry
.entry
, sizeof(struct zebra_pbr_ipset_entry
));
2551 const struct ethaddr
*
2552 dplane_ctx_rule_get_smac(const struct zebra_dplane_ctx
*ctx
)
2554 DPLANE_CTX_VALID(ctx
);
2556 return &(ctx
->u
.rule
.new.smac
);
2559 const struct ethaddr
*
2560 dplane_ctx_rule_get_dmac(const struct zebra_dplane_ctx
*ctx
)
2562 DPLANE_CTX_VALID(ctx
);
2564 return &(ctx
->u
.rule
.new.dmac
);
2567 int dplane_ctx_rule_get_out_ifindex(const struct zebra_dplane_ctx
*ctx
)
2569 DPLANE_CTX_VALID(ctx
);
2571 return ctx
->u
.rule
.new.out_ifindex
;
2574 intptr_t dplane_ctx_rule_get_old_dp_flow_ptr(const struct zebra_dplane_ctx
*ctx
)
2576 DPLANE_CTX_VALID(ctx
);
2578 return ctx
->u
.rule
.old
.dp_flow_ptr
;
2581 intptr_t dplane_ctx_rule_get_dp_flow_ptr(const struct zebra_dplane_ctx
*ctx
)
2583 DPLANE_CTX_VALID(ctx
);
2585 return ctx
->u
.rule
.new.dp_flow_ptr
;
2588 void dplane_ctx_rule_set_dp_flow_ptr(struct zebra_dplane_ctx
*ctx
,
2589 intptr_t dp_flow_ptr
)
2591 DPLANE_CTX_VALID(ctx
);
2593 ctx
->u
.rule
.new.dp_flow_ptr
= dp_flow_ptr
;
2597 * End of dplane context accessors
2600 /* Optional extra info about interfaces in nexthops - a plugin must enable
2603 const struct dplane_intf_extra
*
2604 dplane_ctx_get_intf_extra(const struct zebra_dplane_ctx
*ctx
)
2606 return dplane_intf_extra_list_const_first(
2607 &ctx
->u
.rinfo
.intf_extra_list
);
2610 const struct dplane_intf_extra
*
2611 dplane_ctx_intf_extra_next(const struct zebra_dplane_ctx
*ctx
,
2612 const struct dplane_intf_extra
*ptr
)
2614 return dplane_intf_extra_list_const_next(&ctx
->u
.rinfo
.intf_extra_list
,
2618 vrf_id_t
dplane_intf_extra_get_vrfid(const struct dplane_intf_extra
*ptr
)
2623 uint32_t dplane_intf_extra_get_ifindex(const struct dplane_intf_extra
*ptr
)
2625 return ptr
->ifindex
;
2628 uint32_t dplane_intf_extra_get_flags(const struct dplane_intf_extra
*ptr
)
2633 uint32_t dplane_intf_extra_get_status(const struct dplane_intf_extra
*ptr
)
2639 * End of interface extra info accessors
2642 uint8_t dplane_ctx_neightable_get_family(const struct zebra_dplane_ctx
*ctx
)
2644 DPLANE_CTX_VALID(ctx
);
2646 return ctx
->u
.neightable
.family
;
2650 dplane_ctx_neightable_get_app_probes(const struct zebra_dplane_ctx
*ctx
)
2652 DPLANE_CTX_VALID(ctx
);
2654 return ctx
->u
.neightable
.app_probes
;
2658 dplane_ctx_neightable_get_ucast_probes(const struct zebra_dplane_ctx
*ctx
)
2660 DPLANE_CTX_VALID(ctx
);
2662 return ctx
->u
.neightable
.ucast_probes
;
2666 dplane_ctx_neightable_get_mcast_probes(const struct zebra_dplane_ctx
*ctx
)
2668 DPLANE_CTX_VALID(ctx
);
2670 return ctx
->u
.neightable
.mcast_probes
;
2673 enum dplane_netconf_status_e
2674 dplane_ctx_get_netconf_mpls(const struct zebra_dplane_ctx
*ctx
)
2676 DPLANE_CTX_VALID(ctx
);
2678 return ctx
->u
.netconf
.mpls_val
;
2681 enum dplane_netconf_status_e
2682 dplane_ctx_get_netconf_mcast(const struct zebra_dplane_ctx
*ctx
)
2684 DPLANE_CTX_VALID(ctx
);
2686 return ctx
->u
.netconf
.mcast_val
;
2689 enum dplane_netconf_status_e
2690 dplane_ctx_get_netconf_linkdown(const struct zebra_dplane_ctx
*ctx
)
2692 DPLANE_CTX_VALID(ctx
);
2694 return ctx
->u
.netconf
.linkdown_val
;
2697 void dplane_ctx_set_netconf_mpls(struct zebra_dplane_ctx
*ctx
,
2698 enum dplane_netconf_status_e val
)
2700 DPLANE_CTX_VALID(ctx
);
2702 ctx
->u
.netconf
.mpls_val
= val
;
2705 void dplane_ctx_set_netconf_mcast(struct zebra_dplane_ctx
*ctx
,
2706 enum dplane_netconf_status_e val
)
2708 DPLANE_CTX_VALID(ctx
);
2710 ctx
->u
.netconf
.mcast_val
= val
;
2713 void dplane_ctx_set_netconf_linkdown(struct zebra_dplane_ctx
*ctx
,
2714 enum dplane_netconf_status_e val
)
2716 DPLANE_CTX_VALID(ctx
);
2718 ctx
->u
.netconf
.linkdown_val
= val
;
2723 * Retrieve the limit on the number of pending, unprocessed updates.
2725 uint32_t dplane_get_in_queue_limit(void)
2727 return atomic_load_explicit(&zdplane_info
.dg_max_queued_updates
,
2728 memory_order_relaxed
);
2732 * Configure limit on the number of pending, queued updates.
2734 void dplane_set_in_queue_limit(uint32_t limit
, bool set
)
2736 /* Reset to default on 'unset' */
2738 limit
= DPLANE_DEFAULT_MAX_QUEUED
;
2740 atomic_store_explicit(&zdplane_info
.dg_max_queued_updates
, limit
,
2741 memory_order_relaxed
);
2745 * Retrieve the current queue depth of incoming, unprocessed updates
2747 uint32_t dplane_get_in_queue_len(void)
2749 return atomic_load_explicit(&zdplane_info
.dg_routes_queued
,
2750 memory_order_seq_cst
);
2754 * Internal helper that copies information from a zebra ns object; this is
2755 * called in the zebra main pthread context as part of dplane ctx init.
2757 static void ctx_info_from_zns(struct zebra_dplane_info
*ns_info
,
2758 struct zebra_ns
*zns
)
2760 ns_info
->ns_id
= zns
->ns_id
;
2762 #if defined(HAVE_NETLINK)
2763 ns_info
->is_cmd
= true;
2764 ns_info
->sock
= zns
->netlink_dplane_out
.sock
;
2765 ns_info
->seq
= zns
->netlink_dplane_out
.seq
;
2766 #endif /* NETLINK */
2770 * Common dataplane context init with zebra namespace info.
2772 static int dplane_ctx_ns_init(struct zebra_dplane_ctx
*ctx
,
2773 struct zebra_ns
*zns
,
2776 ctx_info_from_zns(&(ctx
->zd_ns_info
), zns
); /* */
2778 ctx
->zd_is_update
= is_update
;
2780 #if defined(HAVE_NETLINK)
2781 /* Increment message counter after copying to context struct - may need
2782 * two messages in some 'update' cases.
2785 zns
->netlink_dplane_out
.seq
+= 2;
2787 zns
->netlink_dplane_out
.seq
++;
2788 #endif /* HAVE_NETLINK */
2793 int dplane_ctx_route_init_basic(struct zebra_dplane_ctx
*ctx
,
2794 enum dplane_op_e op
, struct route_entry
*re
,
2795 const struct prefix
*p
,
2796 const struct prefix_ipv6
*src_p
, afi_t afi
,
2804 dplane_intf_extra_list_init(&ctx
->u
.rinfo
.intf_extra_list
);
2807 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
2809 ctx
->u
.rinfo
.zd_type
= re
->type
;
2810 ctx
->u
.rinfo
.zd_old_type
= re
->type
;
2812 prefix_copy(&(ctx
->u
.rinfo
.zd_dest
), p
);
2815 prefix_copy(&(ctx
->u
.rinfo
.zd_src
), src_p
);
2817 memset(&(ctx
->u
.rinfo
.zd_src
), 0, sizeof(ctx
->u
.rinfo
.zd_src
));
2819 ctx
->zd_table_id
= re
->table
;
2821 ctx
->u
.rinfo
.zd_flags
= re
->flags
;
2822 ctx
->u
.rinfo
.zd_metric
= re
->metric
;
2823 ctx
->u
.rinfo
.zd_old_metric
= re
->metric
;
2824 ctx
->zd_vrf_id
= re
->vrf_id
;
2825 ctx
->u
.rinfo
.zd_mtu
= re
->mtu
;
2826 ctx
->u
.rinfo
.zd_nexthop_mtu
= re
->nexthop_mtu
;
2827 ctx
->u
.rinfo
.zd_instance
= re
->instance
;
2828 ctx
->u
.rinfo
.zd_tag
= re
->tag
;
2829 ctx
->u
.rinfo
.zd_old_tag
= re
->tag
;
2830 ctx
->u
.rinfo
.zd_distance
= re
->distance
;
2832 ctx
->u
.rinfo
.zd_afi
= afi
;
2833 ctx
->u
.rinfo
.zd_safi
= safi
;
2839 * Initialize a context block for a route update from zebra data structs.
2841 int dplane_ctx_route_init(struct zebra_dplane_ctx
*ctx
, enum dplane_op_e op
,
2842 struct route_node
*rn
, struct route_entry
*re
)
2845 const struct route_table
*table
= NULL
;
2846 const struct rib_table_info
*info
;
2847 const struct prefix
*p
;
2848 const struct prefix_ipv6
*src_p
;
2849 struct zebra_ns
*zns
;
2850 struct zebra_vrf
*zvrf
;
2851 struct nexthop
*nexthop
;
2852 struct zebra_l3vni
*zl3vni
;
2853 const struct interface
*ifp
;
2854 struct dplane_intf_extra
*if_extra
;
2856 if (!ctx
|| !rn
|| !re
)
2860 * Let's grab the data from the route_node
2861 * so that we can call a helper function
2864 /* Prefixes: dest, and optional source */
2865 srcdest_rnode_prefixes(rn
, &p
, (const struct prefix
**)&src_p
);
2866 table
= srcdest_rnode_table(rn
);
2869 if (dplane_ctx_route_init_basic(ctx
, op
, re
, p
, src_p
, info
->afi
,
2873 /* Copy nexthops; recursive info is included too */
2874 copy_nexthops(&(ctx
->u
.rinfo
.zd_ng
.nexthop
),
2875 re
->nhe
->nhg
.nexthop
, NULL
);
2876 ctx
->u
.rinfo
.zd_nhg_id
= re
->nhe
->id
;
2878 /* Copy backup nexthop info, if present */
2879 if (re
->nhe
->backup_info
&& re
->nhe
->backup_info
->nhe
) {
2880 copy_nexthops(&(ctx
->u
.rinfo
.backup_ng
.nexthop
),
2881 re
->nhe
->backup_info
->nhe
->nhg
.nexthop
, NULL
);
2885 * Ensure that the dplane nexthops' flags are clear and copy
2886 * encapsulation information.
2888 for (ALL_NEXTHOPS(ctx
->u
.rinfo
.zd_ng
, nexthop
)) {
2889 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
2891 /* Optionally capture extra interface info while we're in the
2892 * main zebra pthread - a plugin has to ask for this info.
2894 if (dplane_collect_extra_intf_info
) {
2895 ifp
= if_lookup_by_index(nexthop
->ifindex
,
2901 sizeof(struct dplane_intf_extra
));
2902 if_extra
->vrf_id
= nexthop
->vrf_id
;
2903 if_extra
->ifindex
= nexthop
->ifindex
;
2904 if_extra
->flags
= ifp
->flags
;
2905 if_extra
->status
= ifp
->status
;
2907 dplane_intf_extra_list_add_tail(
2908 &ctx
->u
.rinfo
.intf_extra_list
,
2913 /* Check for available evpn encapsulations. */
2914 if (!CHECK_FLAG(nexthop
->flags
, NEXTHOP_FLAG_EVPN
))
2917 zl3vni
= zl3vni_from_vrf(nexthop
->vrf_id
);
2918 if (zl3vni
&& is_l3vni_oper_up(zl3vni
)) {
2919 nexthop
->nh_encap_type
= NET_VXLAN
;
2920 nexthop
->nh_encap
.vni
= zl3vni
->vni
;
2924 /* Don't need some info when capturing a system notification */
2925 if (op
== DPLANE_OP_SYS_ROUTE_ADD
||
2926 op
== DPLANE_OP_SYS_ROUTE_DELETE
) {
2930 /* Extract ns info - can't use pointers to 'core' structs */
2931 zvrf
= vrf_info_lookup(re
->vrf_id
);
2933 dplane_ctx_ns_init(ctx
, zns
, (op
== DPLANE_OP_ROUTE_UPDATE
));
2937 struct nhg_hash_entry
*nhe
= zebra_nhg_resolve(re
->nhe
);
2939 ctx
->u
.rinfo
.nhe
.id
= nhe
->id
;
2940 ctx
->u
.rinfo
.nhe
.old_id
= 0;
2942 * Check if the nhe is installed/queued before doing anything
2945 * If its a delete we only use the prefix anyway, so this only
2946 * matters for INSTALL/UPDATE.
2948 if (zebra_nhg_kernel_nexthops_enabled() &&
2949 (((op
== DPLANE_OP_ROUTE_INSTALL
) ||
2950 (op
== DPLANE_OP_ROUTE_UPDATE
)) &&
2951 !CHECK_FLAG(nhe
->flags
, NEXTHOP_GROUP_INSTALLED
) &&
2952 !CHECK_FLAG(nhe
->flags
, NEXTHOP_GROUP_QUEUED
)))
2955 re
->nhe_installed_id
= nhe
->id
;
2957 #endif /* HAVE_NETLINK */
2959 /* Trying out the sequence number idea, so we can try to detect
2960 * when a result is stale.
2962 re
->dplane_sequence
= zebra_router_get_next_sequence();
2963 ctx
->zd_seq
= re
->dplane_sequence
;
2968 static int dplane_ctx_tc_qdisc_init(struct zebra_dplane_ctx
*ctx
,
2969 enum dplane_op_e op
,
2970 const struct zebra_tc_qdisc
*qdisc
)
2974 struct zebra_ns
*zns
= NULL
;
2977 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
2978 ctx
->zd_ifindex
= qdisc
->qdisc
.ifindex
;
2979 ctx
->u
.tc_qdisc
.kind
= qdisc
->qdisc
.kind
;
2980 ctx
->u
.tc_qdisc
.kind_str
= tc_qdisc_kind2str(qdisc
->qdisc
.kind
);
2982 /* TODO: init traffic control qdisc */
2983 zns
= zebra_ns_lookup(NS_DEFAULT
);
2985 dplane_ctx_ns_init(ctx
, zns
, true);
2992 static int dplane_ctx_tc_class_init(struct zebra_dplane_ctx
*ctx
,
2993 enum dplane_op_e op
,
2994 struct zebra_tc_class
*class)
2998 struct zebra_ns
*zns
= NULL
;
3001 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3002 ctx
->zd_ifindex
= class->class.ifindex
;
3004 ctx
->u
.tc_class
.handle
= class->class.handle
;
3005 ctx
->u
.tc_class
.kind
= class->class.kind
;
3006 ctx
->u
.tc_class
.kind_str
= tc_qdisc_kind2str(class->class.kind
);
3007 ctx
->u
.tc_class
.rate
= class->class.u
.htb
.rate
;
3008 ctx
->u
.tc_class
.ceil
= class->class.u
.htb
.ceil
;
3010 zns
= zebra_ns_lookup(NS_DEFAULT
);
3012 dplane_ctx_ns_init(ctx
, zns
, true);
3019 static int dplane_ctx_tc_filter_init(struct zebra_dplane_ctx
*ctx
,
3020 enum dplane_op_e op
,
3021 struct zebra_tc_filter
*filter
)
3025 struct zebra_ns
*zns
= NULL
;
3028 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3029 ctx
->zd_ifindex
= filter
->filter
.ifindex
;
3031 ctx
->u
.tc_filter
.eth_proto
= filter
->filter
.protocol
;
3032 ctx
->u
.tc_filter
.ip_proto
= filter
->filter
.u
.flower
.ip_proto
;
3034 ctx
->u
.tc_filter
.kind
= filter
->filter
.kind
;
3035 ctx
->u
.tc_filter
.kind_str
= tc_filter_kind2str(filter
->filter
.kind
);
3037 ctx
->u
.tc_filter
.filter_bm
= filter
->filter
.u
.flower
.filter_bm
;
3038 prefix_copy(&ctx
->u
.tc_filter
.src_ip
, &filter
->filter
.u
.flower
.src_ip
);
3039 ctx
->u
.tc_filter
.src_port_min
= filter
->filter
.u
.flower
.src_port_min
;
3040 ctx
->u
.tc_filter
.src_port_max
= filter
->filter
.u
.flower
.src_port_max
;
3041 prefix_copy(&ctx
->u
.tc_filter
.dst_ip
, &filter
->filter
.u
.flower
.dst_ip
);
3042 ctx
->u
.tc_filter
.dst_port_min
= filter
->filter
.u
.flower
.dst_port_min
;
3043 ctx
->u
.tc_filter
.dst_port_max
= filter
->filter
.u
.flower
.dst_port_max
;
3044 ctx
->u
.tc_filter
.dsfield
= filter
->filter
.u
.flower
.dsfield
;
3045 ctx
->u
.tc_filter
.dsfield_mask
= filter
->filter
.u
.flower
.dsfield_mask
;
3046 ctx
->u
.tc_filter
.classid
= filter
->filter
.u
.flower
.classid
;
3048 ctx
->u
.tc_filter
.priority
= filter
->filter
.priority
;
3049 ctx
->u
.tc_filter
.handle
= filter
->filter
.handle
;
3051 zns
= zebra_ns_lookup(NS_DEFAULT
);
3053 dplane_ctx_ns_init(ctx
, zns
, true);
3061 * dplane_ctx_nexthop_init() - Initialize a context block for a nexthop update
3063 * @ctx: Dataplane context to init
3064 * @op: Operation being performed
3065 * @nhe: Nexthop group hash entry
3067 * Return: Result status
3069 int dplane_ctx_nexthop_init(struct zebra_dplane_ctx
*ctx
, enum dplane_op_e op
,
3070 struct nhg_hash_entry
*nhe
)
3072 struct zebra_vrf
*zvrf
= NULL
;
3073 struct zebra_ns
*zns
= NULL
;
3080 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3082 /* Copy over nhe info */
3083 ctx
->u
.rinfo
.nhe
.id
= nhe
->id
;
3084 ctx
->u
.rinfo
.nhe
.afi
= nhe
->afi
;
3085 ctx
->u
.rinfo
.nhe
.vrf_id
= nhe
->vrf_id
;
3086 ctx
->u
.rinfo
.nhe
.type
= nhe
->type
;
3088 nexthop_group_copy(&(ctx
->u
.rinfo
.nhe
.ng
), &(nhe
->nhg
));
3090 /* If this is a group, convert it to a grp array of ids */
3091 if (!zebra_nhg_depends_is_empty(nhe
)
3092 && !CHECK_FLAG(nhe
->flags
, NEXTHOP_GROUP_RECURSIVE
))
3093 ctx
->u
.rinfo
.nhe
.nh_grp_count
= zebra_nhg_nhe2grp(
3094 ctx
->u
.rinfo
.nhe
.nh_grp
, nhe
, MULTIPATH_NUM
);
3096 zvrf
= vrf_info_lookup(nhe
->vrf_id
);
3099 * Fallback to default namespace if the vrf got ripped out from under
3102 zns
= zvrf
? zvrf
->zns
: zebra_ns_lookup(NS_DEFAULT
);
3105 * TODO: Might not need to mark this as an update, since
3106 * it probably won't require two messages
3108 dplane_ctx_ns_init(ctx
, zns
, (op
== DPLANE_OP_NH_UPDATE
));
3116 * dplane_ctx_intf_init() - Initialize a context block for a interface update
3118 * @ctx: Dataplane context to init
3119 * @op: Operation being performed
3122 * Return: Result status
3124 int dplane_ctx_intf_init(struct zebra_dplane_ctx
*ctx
, enum dplane_op_e op
,
3125 const struct interface
*ifp
)
3127 struct zebra_ns
*zns
;
3128 struct zebra_if
*zif
;
3130 bool set_pdown
, unset_pdown
;
3136 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3137 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
3139 strlcpy(ctx
->zd_ifname
, ifp
->name
, sizeof(ctx
->zd_ifname
));
3140 ctx
->zd_ifindex
= ifp
->ifindex
;
3142 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
3143 dplane_ctx_ns_init(ctx
, zns
, false);
3146 /* Copy over ifp info */
3147 ctx
->u
.intf
.metric
= ifp
->metric
;
3148 ctx
->u
.intf
.flags
= ifp
->flags
;
3150 /* Copy over extra zebra info, if available */
3151 zif
= (struct zebra_if
*)ifp
->info
;
3154 set_pdown
= !!(zif
->flags
& ZIF_FLAG_SET_PROTODOWN
);
3155 unset_pdown
= !!(zif
->flags
& ZIF_FLAG_UNSET_PROTODOWN
);
3157 if (zif
->protodown_rc
&&
3158 ZEBRA_IF_IS_PROTODOWN_ONLY_EXTERNAL(zif
) == false)
3159 ctx
->u
.intf
.pd_reason_val
= true;
3162 * See if we have new protodown state to set, otherwise keep
3166 ctx
->u
.intf
.protodown
= true;
3167 else if (unset_pdown
)
3168 ctx
->u
.intf
.protodown
= false;
3170 ctx
->u
.intf
.protodown
= !!ZEBRA_IF_IS_PROTODOWN(zif
);
3173 dplane_ctx_ns_init(ctx
, zns
, (op
== DPLANE_OP_INTF_UPDATE
));
3174 ctx
->zd_is_update
= (op
== DPLANE_OP_INTF_UPDATE
);
3182 * Capture information for an LSP update in a dplane context.
3184 int dplane_ctx_lsp_init(struct zebra_dplane_ctx
*ctx
, enum dplane_op_e op
,
3185 struct zebra_lsp
*lsp
)
3188 struct zebra_nhlfe
*nhlfe
, *new_nhlfe
;
3191 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3193 /* Capture namespace info */
3194 dplane_ctx_ns_init(ctx
, zebra_ns_lookup(NS_DEFAULT
),
3195 (op
== DPLANE_OP_LSP_UPDATE
));
3197 memset(&ctx
->u
.lsp
, 0, sizeof(ctx
->u
.lsp
));
3199 nhlfe_list_init(&(ctx
->u
.lsp
.nhlfe_list
));
3200 nhlfe_list_init(&(ctx
->u
.lsp
.backup_nhlfe_list
));
3202 /* This may be called to create/init a dplane context, not necessarily
3203 * to copy an lsp object.
3208 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
3209 zlog_debug("init dplane ctx %s: in-label %u ecmp# %d",
3210 dplane_op2str(op
), lsp
->ile
.in_label
,
3213 ctx
->u
.lsp
.ile
= lsp
->ile
;
3214 ctx
->u
.lsp
.addr_family
= lsp
->addr_family
;
3215 ctx
->u
.lsp
.num_ecmp
= lsp
->num_ecmp
;
3216 ctx
->u
.lsp
.flags
= lsp
->flags
;
3218 /* Copy source LSP's nhlfes, and capture 'best' nhlfe */
3219 frr_each(nhlfe_list
, &lsp
->nhlfe_list
, nhlfe
) {
3220 /* Not sure if this is meaningful... */
3221 if (nhlfe
->nexthop
== NULL
)
3224 new_nhlfe
= zebra_mpls_lsp_add_nh(&(ctx
->u
.lsp
), nhlfe
->type
,
3226 if (new_nhlfe
== NULL
|| new_nhlfe
->nexthop
== NULL
) {
3231 /* Need to copy flags and backup info too */
3232 new_nhlfe
->flags
= nhlfe
->flags
;
3233 new_nhlfe
->nexthop
->flags
= nhlfe
->nexthop
->flags
;
3235 if (CHECK_FLAG(new_nhlfe
->nexthop
->flags
,
3236 NEXTHOP_FLAG_HAS_BACKUP
)) {
3237 new_nhlfe
->nexthop
->backup_num
=
3238 nhlfe
->nexthop
->backup_num
;
3239 memcpy(new_nhlfe
->nexthop
->backup_idx
,
3240 nhlfe
->nexthop
->backup_idx
,
3241 new_nhlfe
->nexthop
->backup_num
);
3244 if (nhlfe
== lsp
->best_nhlfe
)
3245 ctx
->u
.lsp
.best_nhlfe
= new_nhlfe
;
3251 /* Capture backup nhlfes/nexthops */
3252 frr_each(nhlfe_list
, &lsp
->backup_nhlfe_list
, nhlfe
) {
3253 /* Not sure if this is meaningful... */
3254 if (nhlfe
->nexthop
== NULL
)
3257 new_nhlfe
= zebra_mpls_lsp_add_backup_nh(&(ctx
->u
.lsp
),
3260 if (new_nhlfe
== NULL
|| new_nhlfe
->nexthop
== NULL
) {
3265 /* Need to copy flags too */
3266 new_nhlfe
->flags
= nhlfe
->flags
;
3267 new_nhlfe
->nexthop
->flags
= nhlfe
->nexthop
->flags
;
3274 * Capture information for an LSP update in a dplane context.
3276 static int dplane_ctx_pw_init(struct zebra_dplane_ctx
*ctx
,
3277 enum dplane_op_e op
,
3278 struct zebra_pw
*pw
)
3283 struct route_table
*table
;
3284 struct route_node
*rn
;
3285 struct route_entry
*re
;
3286 const struct nexthop_group
*nhg
;
3287 struct nexthop
*nh
, *newnh
, *last_nh
;
3289 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
3290 zlog_debug("init dplane ctx %s: pw '%s', loc %u, rem %u",
3291 dplane_op2str(op
), pw
->ifname
, pw
->local_label
,
3295 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3297 /* Capture namespace info: no netlink support as of 12/18,
3298 * but just in case...
3300 dplane_ctx_ns_init(ctx
, zebra_ns_lookup(NS_DEFAULT
), false);
3302 memset(&ctx
->u
.pw
, 0, sizeof(ctx
->u
.pw
));
3304 /* This name appears to be c-string, so we use string copy. */
3305 strlcpy(ctx
->zd_ifname
, pw
->ifname
, sizeof(ctx
->zd_ifname
));
3307 ctx
->zd_vrf_id
= pw
->vrf_id
;
3308 ctx
->zd_ifindex
= pw
->ifindex
;
3309 ctx
->u
.pw
.type
= pw
->type
;
3310 ctx
->u
.pw
.af
= pw
->af
;
3311 ctx
->u
.pw
.local_label
= pw
->local_label
;
3312 ctx
->u
.pw
.remote_label
= pw
->remote_label
;
3313 ctx
->u
.pw
.flags
= pw
->flags
;
3315 ctx
->u
.pw
.dest
= pw
->nexthop
;
3317 ctx
->u
.pw
.fields
= pw
->data
;
3319 /* Capture nexthop info for the pw destination. We need to look
3320 * up and use zebra datastructs, but we're running in the zebra
3321 * pthread here so that should be ok.
3323 memcpy(&p
.u
, &pw
->nexthop
, sizeof(pw
->nexthop
));
3325 p
.prefixlen
= ((pw
->af
== AF_INET
) ? IPV4_MAX_BITLEN
: IPV6_MAX_BITLEN
);
3327 afi
= (pw
->af
== AF_INET
) ? AFI_IP
: AFI_IP6
;
3328 table
= zebra_vrf_table(afi
, SAFI_UNICAST
, pw
->vrf_id
);
3332 rn
= route_node_match(table
, &p
);
3337 RNODE_FOREACH_RE(rn
, re
) {
3338 if (CHECK_FLAG(re
->flags
, ZEBRA_FLAG_SELECTED
))
3343 /* We'll capture a 'fib' list of nexthops that meet our
3344 * criteria: installed, and labelled.
3346 nhg
= rib_get_fib_nhg(re
);
3349 if (nhg
&& nhg
->nexthop
) {
3350 for (ALL_NEXTHOPS_PTR(nhg
, nh
)) {
3351 if (!CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_ACTIVE
)
3352 || CHECK_FLAG(nh
->flags
,
3353 NEXTHOP_FLAG_RECURSIVE
)
3354 || nh
->nh_label
== NULL
)
3357 newnh
= nexthop_dup(nh
, NULL
);
3360 NEXTHOP_APPEND(last_nh
, newnh
);
3362 ctx
->u
.pw
.fib_nhg
.nexthop
= newnh
;
3367 /* Include any installed backup nexthops also. */
3368 nhg
= rib_get_fib_backup_nhg(re
);
3369 if (nhg
&& nhg
->nexthop
) {
3370 for (ALL_NEXTHOPS_PTR(nhg
, nh
)) {
3371 if (!CHECK_FLAG(nh
->flags
, NEXTHOP_FLAG_ACTIVE
)
3372 || CHECK_FLAG(nh
->flags
,
3373 NEXTHOP_FLAG_RECURSIVE
)
3374 || nh
->nh_label
== NULL
)
3377 newnh
= nexthop_dup(nh
, NULL
);
3380 NEXTHOP_APPEND(last_nh
, newnh
);
3382 ctx
->u
.pw
.fib_nhg
.nexthop
= newnh
;
3387 /* Copy primary nexthops; recursive info is included too */
3388 assert(re
->nhe
!= NULL
); /* SA warning */
3389 copy_nexthops(&(ctx
->u
.pw
.primary_nhg
.nexthop
),
3390 re
->nhe
->nhg
.nexthop
, NULL
);
3391 ctx
->u
.pw
.nhg_id
= re
->nhe
->id
;
3393 /* Copy backup nexthop info, if present */
3394 if (re
->nhe
->backup_info
&& re
->nhe
->backup_info
->nhe
) {
3395 copy_nexthops(&(ctx
->u
.pw
.backup_nhg
.nexthop
),
3396 re
->nhe
->backup_info
->nhe
->nhg
.nexthop
,
3400 route_unlock_node(rn
);
3406 * dplane_ctx_rule_init_single() - Initialize a dataplane representation of a
3409 * @dplane_rule: Dataplane internal representation of a rule
3412 static void dplane_ctx_rule_init_single(struct dplane_ctx_rule
*dplane_rule
,
3413 struct zebra_pbr_rule
*rule
)
3415 struct zebra_neigh_ent
*n
;
3417 dplane_rule
->priority
= rule
->rule
.priority
;
3418 dplane_rule
->table
= rule
->rule
.action
.table
;
3420 dplane_rule
->filter_bm
= rule
->rule
.filter
.filter_bm
;
3421 dplane_rule
->fwmark
= rule
->rule
.filter
.fwmark
;
3422 dplane_rule
->dsfield
= rule
->rule
.filter
.dsfield
;
3423 dplane_rule
->ip_proto
= rule
->rule
.filter
.ip_proto
;
3424 dplane_rule
->src_port
= rule
->rule
.filter
.src_port
;
3425 dplane_rule
->dst_port
= rule
->rule
.filter
.dst_port
;
3426 prefix_copy(&(dplane_rule
->dst_ip
), &rule
->rule
.filter
.dst_ip
);
3427 prefix_copy(&(dplane_rule
->src_ip
), &rule
->rule
.filter
.src_ip
);
3429 dplane_rule
->action_pcp
= rule
->rule
.action
.pcp
;
3430 dplane_rule
->action_vlan_flags
= rule
->rule
.action
.vlan_flags
;
3431 dplane_rule
->action_vlan_id
= rule
->rule
.action
.vlan_id
;
3432 dplane_rule
->action_queue_id
= rule
->rule
.action
.queue_id
;
3434 strlcpy(dplane_rule
->ifname
, rule
->ifname
, INTERFACE_NAMSIZ
);
3435 dplane_rule
->dp_flow_ptr
= rule
->action
.dp_flow_ptr
;
3436 n
= rule
->action
.neigh
;
3437 if (n
&& (n
->flags
& ZEBRA_NEIGH_ENT_ACTIVE
)) {
3438 struct interface
*ifp
= if_lookup_by_index_per_ns(
3439 zebra_ns_lookup(NS_DEFAULT
), n
->ifindex
);
3441 dplane_rule
->out_ifindex
= n
->ifindex
;
3442 memcpy(&dplane_rule
->dmac
, &n
->mac
, ETH_ALEN
);
3443 memcpy(&dplane_rule
->smac
, ifp
->hw_addr
, ETH_ALEN
);
3445 dplane_rule
->out_ifindex
= 0;
3451 * dplane_ctx_rule_init() - Initialize a context block for a PBR rule update.
3453 * @ctx: Dataplane context to init
3454 * @op: Operation being performed
3455 * @new_rule: PBR rule
3457 * Return: Result status
3459 static int dplane_ctx_rule_init(struct zebra_dplane_ctx
*ctx
,
3460 enum dplane_op_e op
,
3461 struct zebra_pbr_rule
*new_rule
,
3462 struct zebra_pbr_rule
*old_rule
)
3464 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
3466 "init dplane ctx %s: IF %s Prio %u Fwmark %u Src %pFX Dst %pFX Table %u",
3467 dplane_op2str(op
), new_rule
->ifname
,
3468 new_rule
->rule
.priority
, new_rule
->rule
.filter
.fwmark
,
3469 &new_rule
->rule
.filter
.src_ip
,
3470 &new_rule
->rule
.filter
.dst_ip
,
3471 new_rule
->rule
.action
.table
);
3474 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3476 dplane_ctx_ns_init(ctx
, zebra_ns_lookup(NS_DEFAULT
),
3477 op
== DPLANE_OP_RULE_UPDATE
);
3479 ctx
->zd_vrf_id
= new_rule
->vrf_id
;
3480 strlcpy(ctx
->zd_ifname
, new_rule
->ifname
, sizeof(ctx
->zd_ifname
));
3482 ctx
->u
.rule
.sock
= new_rule
->sock
;
3483 ctx
->u
.rule
.unique
= new_rule
->rule
.unique
;
3484 ctx
->u
.rule
.seq
= new_rule
->rule
.seq
;
3486 dplane_ctx_rule_init_single(&ctx
->u
.rule
.new, new_rule
);
3487 if (op
== DPLANE_OP_RULE_UPDATE
) {
3488 dplane_ctx_rule_init_single(&ctx
->u
.rule
.old
, old_rule
);
3489 /* clear the dp_flow_ptr in the old_rule - it is about to be
3492 old_rule
->action
.dp_flow_ptr
= (intptr_t)NULL
;
3498 static void zebra_dplane_interface_name_list_deletion(void *data
)
3500 XFREE(MTYPE_DP_NETFILTER
, data
);
3504 * dplane_ctx_iptable_init() - Initialize a context block for a PBR iptable
3507 * @ctx: Dataplane context to init
3508 * @op: Operation being performed
3509 * @new_rule: PBR iptable
3511 * Return: Result status
3513 static int dplane_ctx_iptable_init(struct zebra_dplane_ctx
*ctx
,
3514 enum dplane_op_e op
,
3515 struct zebra_pbr_iptable
*iptable
)
3518 struct listnode
*node
;
3520 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
) {
3522 "init dplane ctx %s: Unique %u Fwmark %u Family %s Action %s",
3523 dplane_op2str(op
), iptable
->unique
, iptable
->fwmark
,
3524 family2str(iptable
->family
),
3525 iptable
->action
== ZEBRA_IPTABLES_DROP
? "Drop"
3530 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3532 dplane_ctx_ns_init(ctx
, zebra_ns_lookup(NS_DEFAULT
), false);
3534 ctx
->zd_vrf_id
= iptable
->vrf_id
;
3535 memcpy(&ctx
->u
.iptable
, iptable
, sizeof(struct zebra_pbr_iptable
));
3536 if (iptable
->nb_interface
> 0) {
3537 ctx
->u
.iptable
.interface_name_list
= list_new();
3538 ctx
->u
.iptable
.interface_name_list
->del
=
3539 zebra_dplane_interface_name_list_deletion
;
3540 for (ALL_LIST_ELEMENTS_RO(iptable
->interface_name_list
, node
,
3542 listnode_add(ctx
->u
.iptable
.interface_name_list
,
3543 XSTRDUP(MTYPE_DP_NETFILTER
, ifname
));
3550 * dplane_ctx_ipset_init() - Initialize a context block for a PBR ipset update.
3552 * @ctx: Dataplane context to init
3553 * @op: Operation being performed
3554 * @new_rule: PBR ipset
3556 * Return: Result status
3558 static int dplane_ctx_ipset_init(struct zebra_dplane_ctx
*ctx
,
3559 enum dplane_op_e op
,
3560 struct zebra_pbr_ipset
*ipset
)
3562 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
) {
3563 zlog_debug("init dplane ctx %s: %s Unique %u Family %s Type %s",
3564 dplane_op2str(op
), ipset
->ipset_name
, ipset
->unique
,
3565 family2str(ipset
->family
),
3566 zebra_pbr_ipset_type2str(ipset
->type
));
3570 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3572 dplane_ctx_ns_init(ctx
, zebra_ns_lookup(NS_DEFAULT
), false);
3574 ctx
->zd_vrf_id
= ipset
->vrf_id
;
3576 memcpy(&ctx
->u
.ipset
, ipset
, sizeof(struct zebra_pbr_ipset
));
3581 * dplane_ctx_ipset_entry_init() - Initialize a context block for a PBR ipset
3584 * @ctx: Dataplane context to init
3585 * @op: Operation being performed
3586 * @new_rule: PBR ipset
3588 * Return: Result status
3591 dplane_ctx_ipset_entry_init(struct zebra_dplane_ctx
*ctx
, enum dplane_op_e op
,
3592 struct zebra_pbr_ipset_entry
*ipset_entry
)
3594 struct zebra_pbr_ipset
*ipset
;
3596 ipset
= ipset_entry
->backpointer
;
3597 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
) {
3598 zlog_debug("init dplane ctx %s: %s Unique %u filter %u",
3599 dplane_op2str(op
), ipset
->ipset_name
,
3600 ipset_entry
->unique
, ipset_entry
->filter_bm
);
3604 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
3606 dplane_ctx_ns_init(ctx
, zebra_ns_lookup(NS_DEFAULT
), false);
3608 ctx
->zd_vrf_id
= ipset
->vrf_id
;
3610 memcpy(&ctx
->u
.ipset_entry
.entry
, ipset_entry
,
3611 sizeof(struct zebra_pbr_ipset_entry
));
3612 ctx
->u
.ipset_entry
.entry
.backpointer
= NULL
;
3613 ctx
->u
.ipset_entry
.info
.type
= ipset
->type
;
3614 ctx
->u
.ipset_entry
.info
.family
= ipset
->family
;
3615 memcpy(&ctx
->u
.ipset_entry
.info
.ipset_name
, &ipset
->ipset_name
,
3616 ZEBRA_IPSET_NAME_SIZE
);
3623 * Enqueue a new update,
3624 * and ensure an event is active for the dataplane pthread.
3626 static int dplane_update_enqueue(struct zebra_dplane_ctx
*ctx
)
3629 uint32_t high
, curr
;
3631 /* Enqueue for processing by the dataplane pthread */
3634 dplane_ctx_list_add_tail(&zdplane_info
.dg_update_list
, ctx
);
3638 curr
= atomic_fetch_add_explicit(
3639 &(zdplane_info
.dg_routes_queued
),
3640 1, memory_order_seq_cst
);
3642 curr
++; /* We got the pre-incremented value */
3644 /* Maybe update high-water counter also */
3645 high
= atomic_load_explicit(&zdplane_info
.dg_routes_queued_max
,
3646 memory_order_seq_cst
);
3647 while (high
< curr
) {
3648 if (atomic_compare_exchange_weak_explicit(
3649 &zdplane_info
.dg_routes_queued_max
,
3651 memory_order_seq_cst
,
3652 memory_order_seq_cst
))
3656 /* Ensure that an event for the dataplane thread is active */
3657 ret
= dplane_provider_work_ready();
3663 * Utility that prepares a route update and enqueues it for processing
3665 static enum zebra_dplane_result
3666 dplane_route_update_internal(struct route_node
*rn
,
3667 struct route_entry
*re
,
3668 struct route_entry
*old_re
,
3669 enum dplane_op_e op
)
3671 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3673 struct zebra_dplane_ctx
*ctx
= NULL
;
3675 /* Obtain context block */
3676 ctx
= dplane_ctx_alloc();
3678 /* Init context with info from zebra data structs */
3679 ret
= dplane_ctx_route_init(ctx
, op
, rn
, re
);
3681 /* Capture some extra info for update case
3682 * where there's a different 'old' route.
3684 if ((op
== DPLANE_OP_ROUTE_UPDATE
) &&
3685 old_re
&& (old_re
!= re
)) {
3687 old_re
->dplane_sequence
=
3688 zebra_router_get_next_sequence();
3689 ctx
->zd_old_seq
= old_re
->dplane_sequence
;
3691 ctx
->u
.rinfo
.zd_old_tag
= old_re
->tag
;
3692 ctx
->u
.rinfo
.zd_old_type
= old_re
->type
;
3693 ctx
->u
.rinfo
.zd_old_instance
= old_re
->instance
;
3694 ctx
->u
.rinfo
.zd_old_distance
= old_re
->distance
;
3695 ctx
->u
.rinfo
.zd_old_metric
= old_re
->metric
;
3696 ctx
->u
.rinfo
.nhe
.old_id
= old_re
->nhe
->id
;
3698 #ifndef HAVE_NETLINK
3699 /* For bsd, capture previous re's nexthops too, sigh.
3700 * We'll need these to do per-nexthop deletes.
3702 copy_nexthops(&(ctx
->u
.rinfo
.zd_old_ng
.nexthop
),
3703 old_re
->nhe
->nhg
.nexthop
, NULL
);
3705 if (zebra_nhg_get_backup_nhg(old_re
->nhe
) != NULL
) {
3706 struct nexthop_group
*nhg
;
3707 struct nexthop
**nh
;
3709 nhg
= zebra_nhg_get_backup_nhg(old_re
->nhe
);
3710 nh
= &(ctx
->u
.rinfo
.old_backup_ng
.nexthop
);
3713 copy_nexthops(nh
, nhg
->nexthop
, NULL
);
3715 #endif /* !HAVE_NETLINK */
3719 * If the old and new context type, and nexthop group id
3720 * are the same there is no need to send down a route replace
3721 * as that we know we have sent a nexthop group replace
3722 * or an upper level protocol has sent us the exact
3725 if ((dplane_ctx_get_type(ctx
) == dplane_ctx_get_old_type(ctx
))
3726 && (dplane_ctx_get_nhe_id(ctx
)
3727 == dplane_ctx_get_old_nhe_id(ctx
))
3728 && (dplane_ctx_get_nhe_id(ctx
) >= ZEBRA_NHG_PROTO_LOWER
)) {
3729 struct nexthop
*nexthop
;
3731 if (IS_ZEBRA_DEBUG_DPLANE
)
3733 "%s: Ignoring Route exactly the same",
3736 for (ALL_NEXTHOPS_PTR(dplane_ctx_get_ng(ctx
),
3738 if (CHECK_FLAG(nexthop
->flags
,
3739 NEXTHOP_FLAG_RECURSIVE
))
3742 if (CHECK_FLAG(nexthop
->flags
,
3743 NEXTHOP_FLAG_ACTIVE
))
3744 SET_FLAG(nexthop
->flags
,
3748 if ((op
== DPLANE_OP_ROUTE_UPDATE
) && old_re
&& re
&&
3750 !CHECK_FLAG(re
->status
, ROUTE_ENTRY_INSTALLED
))
3751 SET_FLAG(re
->status
, ROUTE_ENTRY_INSTALLED
);
3753 dplane_ctx_free(&ctx
);
3754 return ZEBRA_DPLANE_REQUEST_SUCCESS
;
3757 /* Enqueue context for processing */
3758 ret
= dplane_update_enqueue(ctx
);
3761 /* Update counter */
3762 atomic_fetch_add_explicit(&zdplane_info
.dg_routes_in
, 1,
3763 memory_order_relaxed
);
3766 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
3768 atomic_fetch_add_explicit(&zdplane_info
.dg_route_errors
, 1,
3769 memory_order_relaxed
);
3771 dplane_ctx_free(&ctx
);
3777 static enum zebra_dplane_result
3778 tc_qdisc_update_internal(enum dplane_op_e op
,
3779 const struct zebra_tc_qdisc
*qdisc
)
3781 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3783 struct zebra_dplane_ctx
*ctx
= NULL
;
3785 /* Obtain context block */
3786 ctx
= dplane_ctx_alloc();
3788 /* Init context with info from zebra data structs */
3789 ret
= dplane_ctx_tc_qdisc_init(ctx
, op
, qdisc
);
3792 ret
= dplane_update_enqueue(ctx
);
3794 /* Update counter */
3795 atomic_fetch_add_explicit(&zdplane_info
.dg_tcs_in
, 1,
3796 memory_order_relaxed
);
3798 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
3800 atomic_fetch_add_explicit(&zdplane_info
.dg_tcs_errors
, 1,
3801 memory_order_relaxed
);
3803 dplane_ctx_free(&ctx
);
3809 static enum zebra_dplane_result
3810 tc_class_update_internal(enum dplane_op_e op
, struct zebra_tc_class
*class)
3812 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3814 struct zebra_dplane_ctx
*ctx
= NULL
;
3816 /* Obtain context block */
3817 ctx
= dplane_ctx_alloc();
3819 /* Init context with info from zebra data structs */
3820 ret
= dplane_ctx_tc_class_init(ctx
, op
, class);
3823 ret
= dplane_update_enqueue(ctx
);
3825 /* Update counter */
3826 atomic_fetch_add_explicit(&zdplane_info
.dg_tcs_in
, 1,
3827 memory_order_relaxed
);
3829 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
3831 atomic_fetch_add_explicit(&zdplane_info
.dg_tcs_errors
, 1,
3832 memory_order_relaxed
);
3834 dplane_ctx_free(&ctx
);
3840 static enum zebra_dplane_result
3841 tc_filter_update_internal(enum dplane_op_e op
, struct zebra_tc_filter
*filter
)
3843 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3845 struct zebra_dplane_ctx
*ctx
= NULL
;
3847 /* Obtain context block */
3848 ctx
= dplane_ctx_alloc();
3850 /* Init context with info from zebra data structs */
3851 ret
= dplane_ctx_tc_filter_init(ctx
, op
, filter
);
3854 ret
= dplane_update_enqueue(ctx
);
3856 /* Update counter */
3857 atomic_fetch_add_explicit(&zdplane_info
.dg_tcs_in
, 1,
3858 memory_order_relaxed
);
3860 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
3862 atomic_fetch_add_explicit(&zdplane_info
.dg_tcs_errors
, 1,
3863 memory_order_relaxed
);
3865 dplane_ctx_free(&ctx
);
3871 enum zebra_dplane_result
dplane_tc_qdisc_install(struct zebra_tc_qdisc
*qdisc
)
3873 return tc_qdisc_update_internal(DPLANE_OP_TC_QDISC_INSTALL
, qdisc
);
3876 enum zebra_dplane_result
dplane_tc_qdisc_uninstall(struct zebra_tc_qdisc
*qdisc
)
3878 return tc_qdisc_update_internal(DPLANE_OP_TC_QDISC_UNINSTALL
, qdisc
);
3881 enum zebra_dplane_result
dplane_tc_class_add(struct zebra_tc_class
*class)
3883 return tc_class_update_internal(DPLANE_OP_TC_CLASS_ADD
, class);
3886 enum zebra_dplane_result
dplane_tc_class_delete(struct zebra_tc_class
*class)
3888 return tc_class_update_internal(DPLANE_OP_TC_CLASS_DELETE
, class);
3891 enum zebra_dplane_result
dplane_tc_class_update(struct zebra_tc_class
*class)
3893 return tc_class_update_internal(DPLANE_OP_TC_CLASS_UPDATE
, class);
3896 enum zebra_dplane_result
dplane_tc_filter_add(struct zebra_tc_filter
*filter
)
3898 return tc_filter_update_internal(DPLANE_OP_TC_FILTER_ADD
, filter
);
3901 enum zebra_dplane_result
dplane_tc_filter_delete(struct zebra_tc_filter
*filter
)
3903 return tc_filter_update_internal(DPLANE_OP_TC_FILTER_DELETE
, filter
);
3906 enum zebra_dplane_result
dplane_tc_filter_update(struct zebra_tc_filter
*filter
)
3908 return tc_filter_update_internal(DPLANE_OP_TC_FILTER_UPDATE
, filter
);
3912 * dplane_nexthop_update_internal() - Helper for enqueuing nexthop changes
3914 * @nhe: Nexthop group hash entry where the change occured
3915 * @op: The operation to be enqued
3917 * Return: Result of the change
3919 static enum zebra_dplane_result
3920 dplane_nexthop_update_internal(struct nhg_hash_entry
*nhe
, enum dplane_op_e op
)
3922 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3924 struct zebra_dplane_ctx
*ctx
= NULL
;
3926 /* Obtain context block */
3927 ctx
= dplane_ctx_alloc();
3929 ret
= dplane_ctx_nexthop_init(ctx
, op
, nhe
);
3931 ret
= dplane_update_enqueue(ctx
);
3933 /* Update counter */
3934 atomic_fetch_add_explicit(&zdplane_info
.dg_nexthops_in
, 1,
3935 memory_order_relaxed
);
3938 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
3940 atomic_fetch_add_explicit(&zdplane_info
.dg_nexthop_errors
, 1,
3941 memory_order_relaxed
);
3943 dplane_ctx_free(&ctx
);
3950 * Enqueue a route 'add' for the dataplane.
3952 enum zebra_dplane_result
dplane_route_add(struct route_node
*rn
,
3953 struct route_entry
*re
)
3955 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3957 if (rn
== NULL
|| re
== NULL
)
3960 ret
= dplane_route_update_internal(rn
, re
, NULL
,
3961 DPLANE_OP_ROUTE_INSTALL
);
3967 * Enqueue a route update for the dataplane.
3969 enum zebra_dplane_result
dplane_route_update(struct route_node
*rn
,
3970 struct route_entry
*re
,
3971 struct route_entry
*old_re
)
3973 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3975 if (rn
== NULL
|| re
== NULL
)
3978 ret
= dplane_route_update_internal(rn
, re
, old_re
,
3979 DPLANE_OP_ROUTE_UPDATE
);
3985 * Enqueue a route removal for the dataplane.
3987 enum zebra_dplane_result
dplane_route_delete(struct route_node
*rn
,
3988 struct route_entry
*re
)
3990 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
3992 if (rn
== NULL
|| re
== NULL
)
3995 ret
= dplane_route_update_internal(rn
, re
, NULL
,
3996 DPLANE_OP_ROUTE_DELETE
);
4002 * Notify the dplane when system/connected routes change.
4004 enum zebra_dplane_result
dplane_sys_route_add(struct route_node
*rn
,
4005 struct route_entry
*re
)
4007 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4009 /* Ignore this event unless a provider plugin has requested it. */
4010 if (!zdplane_info
.dg_sys_route_notifs
)
4011 return ZEBRA_DPLANE_REQUEST_SUCCESS
;
4014 if (rn
== NULL
|| re
== NULL
)
4017 ret
= dplane_route_update_internal(rn
, re
, NULL
,
4018 DPLANE_OP_SYS_ROUTE_ADD
);
4024 * Notify the dplane when system/connected routes are deleted.
4026 enum zebra_dplane_result
dplane_sys_route_del(struct route_node
*rn
,
4027 struct route_entry
*re
)
4029 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4031 /* Ignore this event unless a provider plugin has requested it. */
4032 if (!zdplane_info
.dg_sys_route_notifs
)
4033 return ZEBRA_DPLANE_REQUEST_SUCCESS
;
4035 if (rn
== NULL
|| re
== NULL
)
4038 ret
= dplane_route_update_internal(rn
, re
, NULL
,
4039 DPLANE_OP_SYS_ROUTE_DELETE
);
4045 * Update from an async notification, to bring other fibs up-to-date.
4047 enum zebra_dplane_result
4048 dplane_route_notif_update(struct route_node
*rn
,
4049 struct route_entry
*re
,
4050 enum dplane_op_e op
,
4051 struct zebra_dplane_ctx
*ctx
)
4053 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4055 struct zebra_dplane_ctx
*new_ctx
= NULL
;
4056 struct nexthop
*nexthop
;
4057 struct nexthop_group
*nhg
;
4059 if (rn
== NULL
|| re
== NULL
)
4062 new_ctx
= dplane_ctx_alloc();
4064 /* Init context with info from zebra data structs */
4065 dplane_ctx_route_init(new_ctx
, op
, rn
, re
);
4067 /* For add/update, need to adjust the nexthops so that we match
4068 * the notification state, which may not be the route-entry/RIB
4071 if (op
== DPLANE_OP_ROUTE_UPDATE
||
4072 op
== DPLANE_OP_ROUTE_INSTALL
) {
4074 nexthops_free(new_ctx
->u
.rinfo
.zd_ng
.nexthop
);
4075 new_ctx
->u
.rinfo
.zd_ng
.nexthop
= NULL
;
4077 nhg
= rib_get_fib_nhg(re
);
4078 if (nhg
&& nhg
->nexthop
)
4079 copy_nexthops(&(new_ctx
->u
.rinfo
.zd_ng
.nexthop
),
4080 nhg
->nexthop
, NULL
);
4082 /* Check for installed backup nexthops also */
4083 nhg
= rib_get_fib_backup_nhg(re
);
4084 if (nhg
&& nhg
->nexthop
) {
4085 copy_nexthops(&(new_ctx
->u
.rinfo
.zd_ng
.nexthop
),
4086 nhg
->nexthop
, NULL
);
4089 for (ALL_NEXTHOPS(new_ctx
->u
.rinfo
.zd_ng
, nexthop
))
4090 UNSET_FLAG(nexthop
->flags
, NEXTHOP_FLAG_FIB
);
4094 /* Capture info about the source of the notification, in 'ctx' */
4095 dplane_ctx_set_notif_provider(new_ctx
,
4096 dplane_ctx_get_notif_provider(ctx
));
4098 ret
= dplane_update_enqueue(new_ctx
);
4102 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4104 dplane_ctx_free(&new_ctx
);
4110 * Enqueue a nexthop add for the dataplane.
4112 enum zebra_dplane_result
dplane_nexthop_add(struct nhg_hash_entry
*nhe
)
4114 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4117 ret
= dplane_nexthop_update_internal(nhe
, DPLANE_OP_NH_INSTALL
);
4122 * Enqueue a nexthop update for the dataplane.
4124 * Might not need this func since zebra's nexthop objects should be immutable?
4126 enum zebra_dplane_result
dplane_nexthop_update(struct nhg_hash_entry
*nhe
)
4128 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4131 ret
= dplane_nexthop_update_internal(nhe
, DPLANE_OP_NH_UPDATE
);
4136 * Enqueue a nexthop removal for the dataplane.
4138 enum zebra_dplane_result
dplane_nexthop_delete(struct nhg_hash_entry
*nhe
)
4140 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4143 ret
= dplane_nexthop_update_internal(nhe
, DPLANE_OP_NH_DELETE
);
4149 * Enqueue LSP add for the dataplane.
4151 enum zebra_dplane_result
dplane_lsp_add(struct zebra_lsp
*lsp
)
4153 enum zebra_dplane_result ret
=
4154 lsp_update_internal(lsp
, DPLANE_OP_LSP_INSTALL
);
4160 * Enqueue LSP update for the dataplane.
4162 enum zebra_dplane_result
dplane_lsp_update(struct zebra_lsp
*lsp
)
4164 enum zebra_dplane_result ret
=
4165 lsp_update_internal(lsp
, DPLANE_OP_LSP_UPDATE
);
4171 * Enqueue LSP delete for the dataplane.
4173 enum zebra_dplane_result
dplane_lsp_delete(struct zebra_lsp
*lsp
)
4175 enum zebra_dplane_result ret
=
4176 lsp_update_internal(lsp
, DPLANE_OP_LSP_DELETE
);
4181 /* Update or un-install resulting from an async notification */
4182 enum zebra_dplane_result
4183 dplane_lsp_notif_update(struct zebra_lsp
*lsp
, enum dplane_op_e op
,
4184 struct zebra_dplane_ctx
*notif_ctx
)
4186 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4188 struct zebra_dplane_ctx
*ctx
= NULL
;
4189 struct nhlfe_list_head
*head
;
4190 struct zebra_nhlfe
*nhlfe
, *new_nhlfe
;
4192 /* Obtain context block */
4193 ctx
= dplane_ctx_alloc();
4195 /* Copy info from zebra LSP */
4196 ret
= dplane_ctx_lsp_init(ctx
, op
, lsp
);
4200 /* Add any installed backup nhlfes */
4201 head
= &(ctx
->u
.lsp
.backup_nhlfe_list
);
4202 frr_each(nhlfe_list
, head
, nhlfe
) {
4204 if (CHECK_FLAG(nhlfe
->flags
, NHLFE_FLAG_INSTALLED
) &&
4205 CHECK_FLAG(nhlfe
->nexthop
->flags
, NEXTHOP_FLAG_FIB
)) {
4206 new_nhlfe
= zebra_mpls_lsp_add_nh(&(ctx
->u
.lsp
),
4210 /* Need to copy flags too */
4211 new_nhlfe
->flags
= nhlfe
->flags
;
4212 new_nhlfe
->nexthop
->flags
= nhlfe
->nexthop
->flags
;
4216 /* Capture info about the source of the notification */
4217 dplane_ctx_set_notif_provider(
4219 dplane_ctx_get_notif_provider(notif_ctx
));
4221 ret
= dplane_update_enqueue(ctx
);
4224 /* Update counter */
4225 atomic_fetch_add_explicit(&zdplane_info
.dg_lsps_in
, 1,
4226 memory_order_relaxed
);
4229 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4231 atomic_fetch_add_explicit(&zdplane_info
.dg_lsp_errors
, 1,
4232 memory_order_relaxed
);
4234 dplane_ctx_free(&ctx
);
4240 * Enqueue pseudowire install for the dataplane.
4242 enum zebra_dplane_result
dplane_pw_install(struct zebra_pw
*pw
)
4244 return pw_update_internal(pw
, DPLANE_OP_PW_INSTALL
);
4248 * Enqueue pseudowire un-install for the dataplane.
4250 enum zebra_dplane_result
dplane_pw_uninstall(struct zebra_pw
*pw
)
4252 return pw_update_internal(pw
, DPLANE_OP_PW_UNINSTALL
);
4256 * Common internal LSP update utility
4258 static enum zebra_dplane_result
lsp_update_internal(struct zebra_lsp
*lsp
,
4259 enum dplane_op_e op
)
4261 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4263 struct zebra_dplane_ctx
*ctx
= NULL
;
4265 /* Obtain context block */
4266 ctx
= dplane_ctx_alloc();
4268 ret
= dplane_ctx_lsp_init(ctx
, op
, lsp
);
4272 ret
= dplane_update_enqueue(ctx
);
4275 /* Update counter */
4276 atomic_fetch_add_explicit(&zdplane_info
.dg_lsps_in
, 1,
4277 memory_order_relaxed
);
4280 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4282 atomic_fetch_add_explicit(&zdplane_info
.dg_lsp_errors
, 1,
4283 memory_order_relaxed
);
4284 dplane_ctx_free(&ctx
);
4291 * Internal, common handler for pseudowire updates.
4293 static enum zebra_dplane_result
pw_update_internal(struct zebra_pw
*pw
,
4294 enum dplane_op_e op
)
4296 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4298 struct zebra_dplane_ctx
*ctx
= NULL
;
4300 ctx
= dplane_ctx_alloc();
4302 ret
= dplane_ctx_pw_init(ctx
, op
, pw
);
4306 ret
= dplane_update_enqueue(ctx
);
4309 /* Update counter */
4310 atomic_fetch_add_explicit(&zdplane_info
.dg_pws_in
, 1,
4311 memory_order_relaxed
);
4314 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4316 atomic_fetch_add_explicit(&zdplane_info
.dg_pw_errors
, 1,
4317 memory_order_relaxed
);
4318 dplane_ctx_free(&ctx
);
4325 * Enqueue access br_port update.
4327 enum zebra_dplane_result
4328 dplane_br_port_update(const struct interface
*ifp
, bool non_df
,
4329 uint32_t sph_filter_cnt
,
4330 const struct in_addr
*sph_filters
, uint32_t backup_nhg_id
)
4332 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4335 struct zebra_dplane_ctx
*ctx
= NULL
;
4336 struct zebra_ns
*zns
;
4337 enum dplane_op_e op
= DPLANE_OP_BR_PORT_UPDATE
;
4340 flags
|= DPLANE_BR_PORT_NON_DF
;
4342 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
|| IS_ZEBRA_DEBUG_EVPN_MH_ES
) {
4344 char vtep_str
[ES_VTEP_LIST_STR_SZ
];
4347 for (i
= 0; i
< sph_filter_cnt
; ++i
) {
4348 snprintfrr(vtep_str
+ strlen(vtep_str
),
4349 sizeof(vtep_str
) - strlen(vtep_str
), "%pI4 ",
4353 "init br_port ctx %s: ifp %s, flags 0x%x backup_nhg 0x%x sph %s",
4354 dplane_op2str(op
), ifp
->name
, flags
, backup_nhg_id
,
4358 ctx
= dplane_ctx_alloc();
4361 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
4362 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
4364 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
4365 dplane_ctx_ns_init(ctx
, zns
, false);
4367 ctx
->zd_ifindex
= ifp
->ifindex
;
4368 strlcpy(ctx
->zd_ifname
, ifp
->name
, sizeof(ctx
->zd_ifname
));
4370 /* Init the br-port-specific data area */
4371 memset(&ctx
->u
.br_port
, 0, sizeof(ctx
->u
.br_port
));
4373 ctx
->u
.br_port
.flags
= flags
;
4374 ctx
->u
.br_port
.backup_nhg_id
= backup_nhg_id
;
4375 ctx
->u
.br_port
.sph_filter_cnt
= sph_filter_cnt
;
4376 memcpy(ctx
->u
.br_port
.sph_filters
, sph_filters
,
4377 sizeof(ctx
->u
.br_port
.sph_filters
[0]) * sph_filter_cnt
);
4379 /* Enqueue for processing on the dplane pthread */
4380 ret
= dplane_update_enqueue(ctx
);
4382 /* Increment counter */
4383 atomic_fetch_add_explicit(&zdplane_info
.dg_br_port_in
, 1,
4384 memory_order_relaxed
);
4387 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4390 atomic_fetch_add_explicit(&zdplane_info
.dg_br_port_errors
, 1,
4391 memory_order_relaxed
);
4392 dplane_ctx_free(&ctx
);
4398 enum zebra_dplane_result
4399 dplane_intf_mpls_modify_state(const struct interface
*ifp
, bool set
)
4401 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4402 struct zebra_dplane_ctx
*ctx
;
4403 struct zebra_ns
*zns
;
4406 ctx
= dplane_ctx_alloc();
4407 ctx
->zd_op
= DPLANE_OP_INTF_NETCONFIG
;
4408 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
4409 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
4410 strlcpy(ctx
->zd_ifname
, ifp
->name
, sizeof(ctx
->zd_ifname
));
4412 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
4413 dplane_ctx_ns_init(ctx
, zns
, false);
4415 ctx
->zd_ifindex
= ifp
->ifindex
;
4417 dplane_ctx_set_netconf_mpls(ctx
, DPLANE_NETCONF_STATUS_ENABLED
);
4419 dplane_ctx_set_netconf_mpls(ctx
,
4420 DPLANE_NETCONF_STATUS_DISABLED
);
4421 /* Increment counter */
4422 atomic_fetch_add_explicit(&zdplane_info
.dg_intf_changes
, 1,
4423 memory_order_relaxed
);
4425 ret
= dplane_update_enqueue(ctx
);
4428 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4431 atomic_fetch_add_explicit(&zdplane_info
.dg_intf_changes_errors
,
4432 1, memory_order_relaxed
);
4433 dplane_ctx_free(&ctx
);
4440 * Enqueue interface address add for the dataplane.
4442 enum zebra_dplane_result
dplane_intf_addr_set(const struct interface
*ifp
,
4443 const struct connected
*ifc
)
4445 #if !defined(HAVE_NETLINK) && defined(HAVE_STRUCT_IFALIASREQ)
4446 /* Extra checks for this OS path. */
4448 /* Don't configure PtP addresses on broadcast ifs or reverse */
4449 if (!(ifp
->flags
& IFF_POINTOPOINT
) != !CONNECTED_PEER(ifc
)) {
4450 if (IS_ZEBRA_DEBUG_KERNEL
|| IS_ZEBRA_DEBUG_DPLANE
)
4451 zlog_debug("Failed to set intf addr: mismatch p2p and connected");
4453 return ZEBRA_DPLANE_REQUEST_FAILURE
;
4457 return intf_addr_update_internal(ifp
, ifc
, DPLANE_OP_ADDR_INSTALL
);
4461 * Enqueue interface address remove/uninstall for the dataplane.
4463 enum zebra_dplane_result
dplane_intf_addr_unset(const struct interface
*ifp
,
4464 const struct connected
*ifc
)
4466 return intf_addr_update_internal(ifp
, ifc
, DPLANE_OP_ADDR_UNINSTALL
);
4469 static enum zebra_dplane_result
intf_addr_update_internal(
4470 const struct interface
*ifp
, const struct connected
*ifc
,
4471 enum dplane_op_e op
)
4473 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4475 struct zebra_dplane_ctx
*ctx
= NULL
;
4476 struct zebra_ns
*zns
;
4478 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
4479 zlog_debug("init intf ctx %s: idx %d, addr %u:%pFX",
4480 dplane_op2str(op
), ifp
->ifindex
, ifp
->vrf
->vrf_id
,
4483 ctx
= dplane_ctx_alloc();
4486 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
4487 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
4489 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
4490 dplane_ctx_ns_init(ctx
, zns
, false);
4492 /* Init the interface-addr-specific area */
4493 memset(&ctx
->u
.intf
, 0, sizeof(ctx
->u
.intf
));
4495 strlcpy(ctx
->zd_ifname
, ifp
->name
, sizeof(ctx
->zd_ifname
));
4496 ctx
->zd_ifindex
= ifp
->ifindex
;
4497 ctx
->u
.intf
.prefix
= *(ifc
->address
);
4499 if (if_is_broadcast(ifp
))
4500 ctx
->u
.intf
.flags
|= DPLANE_INTF_BROADCAST
;
4502 if (CONNECTED_PEER(ifc
)) {
4503 ctx
->u
.intf
.dest_prefix
= *(ifc
->destination
);
4504 ctx
->u
.intf
.flags
|=
4505 (DPLANE_INTF_CONNECTED
| DPLANE_INTF_HAS_DEST
);
4508 if (CHECK_FLAG(ifc
->flags
, ZEBRA_IFA_SECONDARY
))
4509 ctx
->u
.intf
.flags
|= DPLANE_INTF_SECONDARY
;
4514 ctx
->u
.intf
.flags
|= DPLANE_INTF_HAS_LABEL
;
4516 /* Use embedded buffer if it's adequate; else allocate. */
4517 len
= strlen(ifc
->label
);
4519 if (len
< sizeof(ctx
->u
.intf
.label_buf
)) {
4520 strlcpy(ctx
->u
.intf
.label_buf
, ifc
->label
,
4521 sizeof(ctx
->u
.intf
.label_buf
));
4522 ctx
->u
.intf
.label
= ctx
->u
.intf
.label_buf
;
4524 ctx
->u
.intf
.label
= XSTRDUP(MTYPE_DP_CTX
, ifc
->label
);
4528 ret
= dplane_update_enqueue(ctx
);
4530 /* Increment counter */
4531 atomic_fetch_add_explicit(&zdplane_info
.dg_intf_addrs_in
, 1,
4532 memory_order_relaxed
);
4535 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4538 atomic_fetch_add_explicit(&zdplane_info
.dg_intf_addr_errors
,
4539 1, memory_order_relaxed
);
4540 dplane_ctx_free(&ctx
);
4547 * dplane_intf_update_internal() - Helper for enqueuing interface changes
4549 * @ifp: Interface where the change occured
4550 * @op: The operation to be enqued
4552 * Return: Result of the change
4554 static enum zebra_dplane_result
4555 dplane_intf_update_internal(const struct interface
*ifp
, enum dplane_op_e op
)
4557 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4559 struct zebra_dplane_ctx
*ctx
= NULL
;
4561 /* Obtain context block */
4562 ctx
= dplane_ctx_alloc();
4564 ret
= dplane_ctx_intf_init(ctx
, op
, ifp
);
4566 ret
= dplane_update_enqueue(ctx
);
4568 /* Update counter */
4569 atomic_fetch_add_explicit(&zdplane_info
.dg_intfs_in
, 1,
4570 memory_order_relaxed
);
4573 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4575 atomic_fetch_add_explicit(&zdplane_info
.dg_intf_errors
, 1,
4576 memory_order_relaxed
);
4578 dplane_ctx_free(&ctx
);
4585 * Enqueue a interface add for the dataplane.
4587 enum zebra_dplane_result
dplane_intf_add(const struct interface
*ifp
)
4589 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4592 ret
= dplane_intf_update_internal(ifp
, DPLANE_OP_INTF_INSTALL
);
4597 * Enqueue a interface update for the dataplane.
4599 enum zebra_dplane_result
dplane_intf_update(const struct interface
*ifp
)
4601 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4604 ret
= dplane_intf_update_internal(ifp
, DPLANE_OP_INTF_UPDATE
);
4609 * Enqueue a interface delete for the dataplane.
4611 enum zebra_dplane_result
dplane_intf_delete(const struct interface
*ifp
)
4613 enum zebra_dplane_result ret
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4616 ret
= dplane_intf_update_internal(ifp
, DPLANE_OP_INTF_DELETE
);
4621 * Enqueue vxlan/evpn mac add (or update).
4623 enum zebra_dplane_result
4624 dplane_rem_mac_add(const struct interface
*ifp
,
4625 const struct interface
*bridge_ifp
, vlanid_t vid
,
4626 const struct ethaddr
*mac
, vni_t vni
, struct in_addr vtep_ip
,
4627 bool sticky
, uint32_t nhg_id
, bool was_static
)
4629 enum zebra_dplane_result result
;
4630 uint32_t update_flags
= 0;
4632 update_flags
|= DPLANE_MAC_REMOTE
;
4634 update_flags
|= DPLANE_MAC_WAS_STATIC
;
4636 /* Use common helper api */
4637 result
= mac_update_common(DPLANE_OP_MAC_INSTALL
, ifp
, bridge_ifp
, vid
,
4638 mac
, vni
, vtep_ip
, sticky
, nhg_id
,
4644 * Enqueue vxlan/evpn mac delete.
4646 enum zebra_dplane_result
dplane_rem_mac_del(const struct interface
*ifp
,
4647 const struct interface
*bridge_ifp
,
4649 const struct ethaddr
*mac
,
4650 vni_t vni
, struct in_addr vtep_ip
)
4652 enum zebra_dplane_result result
;
4653 uint32_t update_flags
= 0;
4655 update_flags
|= DPLANE_MAC_REMOTE
;
4657 /* Use common helper api */
4658 result
= mac_update_common(DPLANE_OP_MAC_DELETE
, ifp
, bridge_ifp
, vid
,
4659 mac
, vni
, vtep_ip
, false, 0, update_flags
);
4664 * API to configure link local with either MAC address or IP information
4666 enum zebra_dplane_result
dplane_neigh_ip_update(enum dplane_op_e op
,
4667 const struct interface
*ifp
,
4668 struct ipaddr
*link_ip
,
4670 uint32_t ndm_state
, int protocol
)
4672 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4674 uint32_t update_flags
;
4676 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
4677 zlog_debug("%s: init link ctx %s: ifp %s, link_ip %pIA ip %pIA",
4678 __func__
, dplane_op2str(op
), ifp
->name
, link_ip
, ip
);
4680 if (ndm_state
== ZEBRA_NEIGH_STATE_REACHABLE
)
4681 state
= DPLANE_NUD_REACHABLE
;
4682 else if (ndm_state
== ZEBRA_NEIGH_STATE_FAILED
)
4683 state
= DPLANE_NUD_FAILED
;
4685 update_flags
= DPLANE_NEIGH_NO_EXTENSION
;
4687 result
= neigh_update_internal(op
, ifp
, (const void *)link_ip
,
4688 ipaddr_family(link_ip
), ip
, 0, 0, state
,
4689 update_flags
, protocol
);
4695 * Enqueue local mac add (or update).
4697 enum zebra_dplane_result
dplane_local_mac_add(const struct interface
*ifp
,
4698 const struct interface
*bridge_ifp
,
4700 const struct ethaddr
*mac
,
4702 uint32_t set_static
,
4703 uint32_t set_inactive
)
4705 enum zebra_dplane_result result
;
4706 uint32_t update_flags
= 0;
4707 struct in_addr vtep_ip
;
4710 update_flags
|= DPLANE_MAC_SET_STATIC
;
4713 update_flags
|= DPLANE_MAC_SET_INACTIVE
;
4717 /* Use common helper api */
4718 result
= mac_update_common(DPLANE_OP_MAC_INSTALL
, ifp
, bridge_ifp
, vid
,
4719 mac
, 0, vtep_ip
, sticky
, 0, update_flags
);
4724 * Enqueue local mac del
4726 enum zebra_dplane_result
4727 dplane_local_mac_del(const struct interface
*ifp
,
4728 const struct interface
*bridge_ifp
, vlanid_t vid
,
4729 const struct ethaddr
*mac
)
4731 enum zebra_dplane_result result
;
4732 struct in_addr vtep_ip
;
4736 /* Use common helper api */
4737 result
= mac_update_common(DPLANE_OP_MAC_DELETE
, ifp
, bridge_ifp
, vid
,
4738 mac
, 0, vtep_ip
, false, 0, 0);
4742 * Public api to init an empty context - either newly-allocated or
4743 * reset/cleared - for a MAC update.
4745 void dplane_mac_init(struct zebra_dplane_ctx
*ctx
, const struct interface
*ifp
,
4746 const struct interface
*br_ifp
, vlanid_t vid
,
4747 const struct ethaddr
*mac
, vni_t vni
,
4748 struct in_addr vtep_ip
, bool sticky
, uint32_t nhg_id
,
4749 uint32_t update_flags
)
4751 struct zebra_ns
*zns
;
4753 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
4754 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
4756 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
4757 dplane_ctx_ns_init(ctx
, zns
, false);
4759 strlcpy(ctx
->zd_ifname
, ifp
->name
, sizeof(ctx
->zd_ifname
));
4760 ctx
->zd_ifindex
= ifp
->ifindex
;
4762 /* Init the mac-specific data area */
4763 memset(&ctx
->u
.macinfo
, 0, sizeof(ctx
->u
.macinfo
));
4765 ctx
->u
.macinfo
.br_ifindex
= br_ifp
->ifindex
;
4766 ctx
->u
.macinfo
.vtep_ip
= vtep_ip
;
4767 ctx
->u
.macinfo
.mac
= *mac
;
4768 ctx
->u
.macinfo
.vni
= vni
;
4769 ctx
->u
.macinfo
.vid
= vid
;
4770 ctx
->u
.macinfo
.is_sticky
= sticky
;
4771 ctx
->u
.macinfo
.nhg_id
= nhg_id
;
4772 ctx
->u
.macinfo
.update_flags
= update_flags
;
4776 * Common helper api for MAC address/vxlan updates
4778 static enum zebra_dplane_result
4779 mac_update_common(enum dplane_op_e op
, const struct interface
*ifp
,
4780 const struct interface
*br_ifp
, vlanid_t vid
,
4781 const struct ethaddr
*mac
, vni_t vni
, struct in_addr vtep_ip
,
4782 bool sticky
, uint32_t nhg_id
, uint32_t update_flags
)
4784 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4786 struct zebra_dplane_ctx
*ctx
= NULL
;
4788 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
4789 zlog_debug("init mac ctx %s: mac %pEA, ifp %s, vtep %pI4",
4790 dplane_op2str(op
), mac
, ifp
->name
, &vtep_ip
);
4792 ctx
= dplane_ctx_alloc();
4795 /* Common init for the ctx */
4796 dplane_mac_init(ctx
, ifp
, br_ifp
, vid
, mac
, vni
, vtep_ip
, sticky
,
4797 nhg_id
, update_flags
);
4799 /* Enqueue for processing on the dplane pthread */
4800 ret
= dplane_update_enqueue(ctx
);
4802 /* Increment counter */
4803 atomic_fetch_add_explicit(&zdplane_info
.dg_macs_in
, 1,
4804 memory_order_relaxed
);
4807 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
4810 atomic_fetch_add_explicit(&zdplane_info
.dg_mac_errors
, 1,
4811 memory_order_relaxed
);
4812 dplane_ctx_free(&ctx
);
4819 * Enqueue evpn neighbor add for the dataplane.
4821 enum zebra_dplane_result
dplane_rem_neigh_add(const struct interface
*ifp
,
4822 const struct ipaddr
*ip
,
4823 const struct ethaddr
*mac
,
4824 uint32_t flags
, bool was_static
)
4826 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4827 uint32_t update_flags
= 0;
4829 update_flags
|= DPLANE_NEIGH_REMOTE
;
4832 update_flags
|= DPLANE_NEIGH_WAS_STATIC
;
4834 result
= neigh_update_internal(
4835 DPLANE_OP_NEIGH_INSTALL
, ifp
, (const void *)mac
, AF_ETHERNET
,
4836 ip
, 0, flags
, DPLANE_NUD_NOARP
, update_flags
, 0);
4842 * Enqueue local neighbor add for the dataplane.
4844 enum zebra_dplane_result
dplane_local_neigh_add(const struct interface
*ifp
,
4845 const struct ipaddr
*ip
,
4846 const struct ethaddr
*mac
,
4847 bool set_router
, bool set_static
,
4850 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4851 uint32_t update_flags
= 0;
4856 update_flags
|= DPLANE_NEIGH_SET_STATIC
;
4859 update_flags
|= DPLANE_NEIGH_SET_INACTIVE
;
4860 state
= DPLANE_NUD_STALE
;
4862 state
= DPLANE_NUD_REACHABLE
;
4866 ntf
|= DPLANE_NTF_ROUTER
;
4868 result
= neigh_update_internal(DPLANE_OP_NEIGH_INSTALL
, ifp
,
4869 (const void *)mac
, AF_ETHERNET
, ip
, 0,
4870 ntf
, state
, update_flags
, 0);
4876 * Enqueue evpn neighbor delete for the dataplane.
4878 enum zebra_dplane_result
dplane_rem_neigh_delete(const struct interface
*ifp
,
4879 const struct ipaddr
*ip
)
4881 enum zebra_dplane_result result
;
4882 uint32_t update_flags
= 0;
4884 update_flags
|= DPLANE_NEIGH_REMOTE
;
4886 result
= neigh_update_internal(DPLANE_OP_NEIGH_DELETE
, ifp
, NULL
,
4887 AF_ETHERNET
, ip
, 0, 0, 0, update_flags
,
4894 * Enqueue evpn VTEP add for the dataplane.
4896 enum zebra_dplane_result
dplane_vtep_add(const struct interface
*ifp
,
4897 const struct in_addr
*ip
,
4900 enum zebra_dplane_result result
;
4901 struct ethaddr mac
= { {0, 0, 0, 0, 0, 0} };
4904 if (IS_ZEBRA_DEBUG_VXLAN
)
4905 zlog_debug("Install %pI4 into flood list for VNI %u intf %s(%u)",
4906 ip
, vni
, ifp
->name
, ifp
->ifindex
);
4908 SET_IPADDR_V4(&addr
);
4909 addr
.ipaddr_v4
= *ip
;
4911 result
= neigh_update_internal(DPLANE_OP_VTEP_ADD
, ifp
, &mac
,
4912 AF_ETHERNET
, &addr
, vni
, 0, 0, 0, 0);
4918 * Enqueue evpn VTEP add for the dataplane.
4920 enum zebra_dplane_result
dplane_vtep_delete(const struct interface
*ifp
,
4921 const struct in_addr
*ip
,
4924 enum zebra_dplane_result result
;
4925 struct ethaddr mac
= { {0, 0, 0, 0, 0, 0} };
4928 if (IS_ZEBRA_DEBUG_VXLAN
)
4930 "Uninstall %pI4 from flood list for VNI %u intf %s(%u)",
4931 ip
, vni
, ifp
->name
, ifp
->ifindex
);
4933 SET_IPADDR_V4(&addr
);
4934 addr
.ipaddr_v4
= *ip
;
4936 result
= neigh_update_internal(DPLANE_OP_VTEP_DELETE
, ifp
,
4937 (const void *)&mac
, AF_ETHERNET
, &addr
,
4943 enum zebra_dplane_result
dplane_neigh_discover(const struct interface
*ifp
,
4944 const struct ipaddr
*ip
)
4946 enum zebra_dplane_result result
;
4948 result
= neigh_update_internal(DPLANE_OP_NEIGH_DISCOVER
, ifp
, NULL
,
4949 AF_ETHERNET
, ip
, 0, DPLANE_NTF_USE
,
4950 DPLANE_NUD_INCOMPLETE
, 0, 0);
4955 enum zebra_dplane_result
dplane_neigh_table_update(const struct interface
*ifp
,
4956 const uint8_t family
,
4957 const uint32_t app_probes
,
4958 const uint32_t ucast_probes
,
4959 const uint32_t mcast_probes
)
4961 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
4963 struct zebra_dplane_ctx
*ctx
= NULL
;
4964 struct zebra_ns
*zns
;
4965 enum dplane_op_e op
= DPLANE_OP_NEIGH_TABLE_UPDATE
;
4967 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
) {
4968 zlog_debug("set neigh ctx %s: ifp %s, family %s",
4969 dplane_op2str(op
), ifp
->name
, family2str(family
));
4972 ctx
= dplane_ctx_alloc();
4975 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
4976 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
4978 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
4979 dplane_ctx_ns_init(ctx
, zns
, false);
4981 strlcpy(ctx
->zd_ifname
, ifp
->name
, sizeof(ctx
->zd_ifname
));
4982 ctx
->zd_ifindex
= ifp
->ifindex
;
4984 /* Init the neighbor-specific data area */
4985 memset(&ctx
->u
.neightable
, 0, sizeof(ctx
->u
.neightable
));
4987 ctx
->u
.neightable
.family
= family
;
4988 ctx
->u
.neightable
.app_probes
= app_probes
;
4989 ctx
->u
.neightable
.ucast_probes
= ucast_probes
;
4990 ctx
->u
.neightable
.mcast_probes
= mcast_probes
;
4992 /* Enqueue for processing on the dplane pthread */
4993 ret
= dplane_update_enqueue(ctx
);
4995 /* Increment counter */
4996 atomic_fetch_add_explicit(&zdplane_info
.dg_neightable_in
, 1,
4997 memory_order_relaxed
);
5000 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
5003 atomic_fetch_add_explicit(&zdplane_info
.dg_neightable_errors
, 1,
5004 memory_order_relaxed
);
5005 dplane_ctx_free(&ctx
);
5012 * Common helper api for neighbor updates
5014 static enum zebra_dplane_result
5015 neigh_update_internal(enum dplane_op_e op
, const struct interface
*ifp
,
5016 const void *link
, const int link_family
,
5017 const struct ipaddr
*ip
, vni_t vni
, uint32_t flags
,
5018 uint16_t state
, uint32_t update_flags
, int protocol
)
5020 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
5022 struct zebra_dplane_ctx
*ctx
= NULL
;
5023 struct zebra_ns
*zns
;
5024 const struct ethaddr
*mac
= NULL
;
5025 const struct ipaddr
*link_ip
= NULL
;
5027 if (link_family
== AF_ETHERNET
)
5028 mac
= (const struct ethaddr
*)link
;
5030 link_ip
= (const struct ipaddr
*)link
;
5032 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
) {
5033 char buf1
[PREFIX_STRLEN
];
5036 if (link_family
== AF_ETHERNET
)
5037 prefix_mac2str(mac
, buf1
, sizeof(buf1
));
5039 ipaddr2str(link_ip
, buf1
, sizeof(buf1
));
5040 zlog_debug("init neigh ctx %s: ifp %s, %s %s, ip %pIA",
5041 dplane_op2str(op
), ifp
->name
,
5042 link_family
== AF_ETHERNET
? "mac" : "link", buf1
,
5046 ctx
= dplane_ctx_alloc();
5049 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
5050 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
5051 dplane_ctx_set_type(ctx
, protocol
);
5053 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
5054 dplane_ctx_ns_init(ctx
, zns
, false);
5056 strlcpy(ctx
->zd_ifname
, ifp
->name
, sizeof(ctx
->zd_ifname
));
5057 ctx
->zd_ifindex
= ifp
->ifindex
;
5059 /* Init the neighbor-specific data area */
5060 memset(&ctx
->u
.neigh
, 0, sizeof(ctx
->u
.neigh
));
5062 ctx
->u
.neigh
.ip_addr
= *ip
;
5064 ctx
->u
.neigh
.link
.mac
= *mac
;
5066 ctx
->u
.neigh
.link
.ip_addr
= *link_ip
;
5068 ctx
->u
.neigh
.flags
= flags
;
5069 ctx
->u
.neigh
.vni
= vni
;
5070 ctx
->u
.neigh
.state
= state
;
5071 ctx
->u
.neigh
.update_flags
= update_flags
;
5073 /* Enqueue for processing on the dplane pthread */
5074 ret
= dplane_update_enqueue(ctx
);
5076 /* Increment counter */
5077 atomic_fetch_add_explicit(&zdplane_info
.dg_neighs_in
, 1,
5078 memory_order_relaxed
);
5081 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
5084 atomic_fetch_add_explicit(&zdplane_info
.dg_neigh_errors
, 1,
5085 memory_order_relaxed
);
5086 dplane_ctx_free(&ctx
);
5093 * Common helper api for PBR rule updates
5095 static enum zebra_dplane_result
5096 rule_update_internal(enum dplane_op_e op
, struct zebra_pbr_rule
*new_rule
,
5097 struct zebra_pbr_rule
*old_rule
)
5099 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
5100 struct zebra_dplane_ctx
*ctx
;
5103 ctx
= dplane_ctx_alloc();
5105 ret
= dplane_ctx_rule_init(ctx
, op
, new_rule
, old_rule
);
5109 ret
= dplane_update_enqueue(ctx
);
5112 atomic_fetch_add_explicit(&zdplane_info
.dg_rules_in
, 1,
5113 memory_order_relaxed
);
5116 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
5118 atomic_fetch_add_explicit(&zdplane_info
.dg_rule_errors
, 1,
5119 memory_order_relaxed
);
5120 dplane_ctx_free(&ctx
);
5126 enum zebra_dplane_result
dplane_pbr_rule_add(struct zebra_pbr_rule
*rule
)
5128 return rule_update_internal(DPLANE_OP_RULE_ADD
, rule
, NULL
);
5131 enum zebra_dplane_result
dplane_pbr_rule_delete(struct zebra_pbr_rule
*rule
)
5133 return rule_update_internal(DPLANE_OP_RULE_DELETE
, rule
, NULL
);
5136 enum zebra_dplane_result
dplane_pbr_rule_update(struct zebra_pbr_rule
*old_rule
,
5137 struct zebra_pbr_rule
*new_rule
)
5139 return rule_update_internal(DPLANE_OP_RULE_UPDATE
, new_rule
, old_rule
);
5142 * Common helper api for iptable updates
5144 static enum zebra_dplane_result
5145 iptable_update_internal(enum dplane_op_e op
, struct zebra_pbr_iptable
*iptable
)
5147 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
5148 struct zebra_dplane_ctx
*ctx
;
5151 if ((op
== DPLANE_OP_IPTABLE_ADD
&&
5152 CHECK_FLAG(iptable
->internal_flags
, IPTABLE_INSTALL_QUEUED
)) ||
5153 (op
== DPLANE_OP_IPTABLE_DELETE
&&
5154 CHECK_FLAG(iptable
->internal_flags
, IPTABLE_UNINSTALL_QUEUED
))) {
5155 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
5157 "update dplane ctx %s: iptable %s already in progress",
5158 dplane_op2str(op
), iptable
->ipset_name
);
5162 ctx
= dplane_ctx_alloc();
5164 ret
= dplane_ctx_iptable_init(ctx
, op
, iptable
);
5168 ret
= dplane_update_enqueue(ctx
);
5171 atomic_fetch_add_explicit(&zdplane_info
.dg_iptable_in
, 1,
5172 memory_order_relaxed
);
5175 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
5176 if (op
== DPLANE_OP_IPTABLE_ADD
)
5177 SET_FLAG(iptable
->internal_flags
,
5178 IPTABLE_INSTALL_QUEUED
);
5180 SET_FLAG(iptable
->internal_flags
,
5181 IPTABLE_UNINSTALL_QUEUED
);
5183 atomic_fetch_add_explicit(&zdplane_info
.dg_iptable_errors
, 1,
5184 memory_order_relaxed
);
5185 dplane_ctx_free(&ctx
);
5190 enum zebra_dplane_result
5191 dplane_pbr_iptable_add(struct zebra_pbr_iptable
*iptable
)
5193 return iptable_update_internal(DPLANE_OP_IPTABLE_ADD
, iptable
);
5196 enum zebra_dplane_result
5197 dplane_pbr_iptable_delete(struct zebra_pbr_iptable
*iptable
)
5199 return iptable_update_internal(DPLANE_OP_IPTABLE_DELETE
, iptable
);
5203 * Common helper api for ipset updates
5205 static enum zebra_dplane_result
5206 ipset_update_internal(enum dplane_op_e op
, struct zebra_pbr_ipset
*ipset
)
5208 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
5209 struct zebra_dplane_ctx
*ctx
;
5212 ctx
= dplane_ctx_alloc();
5214 ret
= dplane_ctx_ipset_init(ctx
, op
, ipset
);
5218 ret
= dplane_update_enqueue(ctx
);
5221 atomic_fetch_add_explicit(&zdplane_info
.dg_ipset_in
, 1,
5222 memory_order_relaxed
);
5225 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
5227 atomic_fetch_add_explicit(&zdplane_info
.dg_ipset_errors
, 1,
5228 memory_order_relaxed
);
5229 dplane_ctx_free(&ctx
);
5235 enum zebra_dplane_result
dplane_pbr_ipset_add(struct zebra_pbr_ipset
*ipset
)
5237 return ipset_update_internal(DPLANE_OP_IPSET_ADD
, ipset
);
5240 enum zebra_dplane_result
dplane_pbr_ipset_delete(struct zebra_pbr_ipset
*ipset
)
5242 return ipset_update_internal(DPLANE_OP_IPSET_DELETE
, ipset
);
5246 * Common helper api for ipset updates
5248 static enum zebra_dplane_result
5249 ipset_entry_update_internal(enum dplane_op_e op
,
5250 struct zebra_pbr_ipset_entry
*ipset_entry
)
5252 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
5253 struct zebra_dplane_ctx
*ctx
;
5256 ctx
= dplane_ctx_alloc();
5258 ret
= dplane_ctx_ipset_entry_init(ctx
, op
, ipset_entry
);
5262 ret
= dplane_update_enqueue(ctx
);
5265 atomic_fetch_add_explicit(&zdplane_info
.dg_ipset_entry_in
, 1,
5266 memory_order_relaxed
);
5269 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
5271 atomic_fetch_add_explicit(&zdplane_info
.dg_ipset_entry_errors
,
5272 1, memory_order_relaxed
);
5273 dplane_ctx_free(&ctx
);
5279 enum zebra_dplane_result
5280 dplane_pbr_ipset_entry_add(struct zebra_pbr_ipset_entry
*ipset
)
5282 return ipset_entry_update_internal(DPLANE_OP_IPSET_ENTRY_ADD
, ipset
);
5285 enum zebra_dplane_result
5286 dplane_pbr_ipset_entry_delete(struct zebra_pbr_ipset_entry
*ipset
)
5288 return ipset_entry_update_internal(DPLANE_OP_IPSET_ENTRY_DELETE
, ipset
);
5292 * Common helper api for GRE set
5294 enum zebra_dplane_result
5295 dplane_gre_set(struct interface
*ifp
, struct interface
*ifp_link
,
5296 unsigned int mtu
, const struct zebra_l2info_gre
*gre_info
)
5298 enum zebra_dplane_result result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
5299 struct zebra_dplane_ctx
*ctx
;
5300 enum dplane_op_e op
= DPLANE_OP_GRE_SET
;
5302 struct zebra_ns
*zns
;
5304 ctx
= dplane_ctx_alloc();
5311 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
) {
5312 zlog_debug("init dplane ctx %s: if %s link %s%s",
5313 dplane_op2str(op
), ifp
->name
,
5314 ifp_link
? "set" : "unset", ifp_link
?
5315 ifp_link
->name
: "");
5319 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
5320 zns
= zebra_ns_lookup(ifp
->vrf
->vrf_id
);
5326 dplane_ctx_ns_init(ctx
, zns
, false);
5328 dplane_ctx_set_ifname(ctx
, ifp
->name
);
5329 ctx
->zd_vrf_id
= ifp
->vrf
->vrf_id
;
5330 ctx
->zd_ifindex
= ifp
->ifindex
;
5332 ctx
->u
.gre
.link_ifindex
= ifp_link
->ifindex
;
5334 ctx
->u
.gre
.link_ifindex
= 0;
5336 memcpy(&ctx
->u
.gre
.info
, gre_info
, sizeof(ctx
->u
.gre
.info
));
5337 ctx
->u
.gre
.mtu
= mtu
;
5339 ctx
->zd_status
= ZEBRA_DPLANE_REQUEST_SUCCESS
;
5341 /* Enqueue context for processing */
5342 ret
= dplane_update_enqueue(ctx
);
5345 /* Update counter */
5346 atomic_fetch_add_explicit(&zdplane_info
.dg_gre_set_in
, 1,
5347 memory_order_relaxed
);
5350 result
= ZEBRA_DPLANE_REQUEST_QUEUED
;
5352 atomic_fetch_add_explicit(
5353 &zdplane_info
.dg_gre_set_errors
, 1,
5354 memory_order_relaxed
);
5355 dplane_ctx_free(&ctx
);
5356 result
= ZEBRA_DPLANE_REQUEST_FAILURE
;
5362 * Handler for 'show dplane'
5364 int dplane_show_helper(struct vty
*vty
, bool detailed
)
5366 uint64_t queued
, queue_max
, limit
, errs
, incoming
, yields
,
5369 /* Using atomics because counters are being changed in different
5372 incoming
= atomic_load_explicit(&zdplane_info
.dg_routes_in
,
5373 memory_order_relaxed
);
5374 limit
= atomic_load_explicit(&zdplane_info
.dg_max_queued_updates
,
5375 memory_order_relaxed
);
5376 queued
= atomic_load_explicit(&zdplane_info
.dg_routes_queued
,
5377 memory_order_relaxed
);
5378 queue_max
= atomic_load_explicit(&zdplane_info
.dg_routes_queued_max
,
5379 memory_order_relaxed
);
5380 errs
= atomic_load_explicit(&zdplane_info
.dg_route_errors
,
5381 memory_order_relaxed
);
5382 yields
= atomic_load_explicit(&zdplane_info
.dg_update_yields
,
5383 memory_order_relaxed
);
5384 other_errs
= atomic_load_explicit(&zdplane_info
.dg_other_errors
,
5385 memory_order_relaxed
);
5387 vty_out(vty
, "Zebra dataplane:\nRoute updates: %"PRIu64
"\n",
5389 vty_out(vty
, "Route update errors: %"PRIu64
"\n", errs
);
5390 vty_out(vty
, "Other errors : %"PRIu64
"\n", other_errs
);
5391 vty_out(vty
, "Route update queue limit: %"PRIu64
"\n", limit
);
5392 vty_out(vty
, "Route update queue depth: %"PRIu64
"\n", queued
);
5393 vty_out(vty
, "Route update queue max: %"PRIu64
"\n", queue_max
);
5394 vty_out(vty
, "Dplane update yields: %"PRIu64
"\n", yields
);
5396 incoming
= atomic_load_explicit(&zdplane_info
.dg_lsps_in
,
5397 memory_order_relaxed
);
5398 errs
= atomic_load_explicit(&zdplane_info
.dg_lsp_errors
,
5399 memory_order_relaxed
);
5400 vty_out(vty
, "LSP updates: %"PRIu64
"\n", incoming
);
5401 vty_out(vty
, "LSP update errors: %"PRIu64
"\n", errs
);
5403 incoming
= atomic_load_explicit(&zdplane_info
.dg_pws_in
,
5404 memory_order_relaxed
);
5405 errs
= atomic_load_explicit(&zdplane_info
.dg_pw_errors
,
5406 memory_order_relaxed
);
5407 vty_out(vty
, "PW updates: %"PRIu64
"\n", incoming
);
5408 vty_out(vty
, "PW update errors: %"PRIu64
"\n", errs
);
5410 incoming
= atomic_load_explicit(&zdplane_info
.dg_intf_addrs_in
,
5411 memory_order_relaxed
);
5412 errs
= atomic_load_explicit(&zdplane_info
.dg_intf_addr_errors
,
5413 memory_order_relaxed
);
5414 vty_out(vty
, "Intf addr updates: %"PRIu64
"\n", incoming
);
5415 vty_out(vty
, "Intf addr errors: %"PRIu64
"\n", errs
);
5417 incoming
= atomic_load_explicit(&zdplane_info
.dg_intf_changes
,
5418 memory_order_relaxed
);
5419 errs
= atomic_load_explicit(&zdplane_info
.dg_intf_changes_errors
,
5420 memory_order_relaxed
);
5421 vty_out(vty
, "Intf change updates: %" PRIu64
"\n", incoming
);
5422 vty_out(vty
, "Intf change errors: %" PRIu64
"\n", errs
);
5424 incoming
= atomic_load_explicit(&zdplane_info
.dg_macs_in
,
5425 memory_order_relaxed
);
5426 errs
= atomic_load_explicit(&zdplane_info
.dg_mac_errors
,
5427 memory_order_relaxed
);
5428 vty_out(vty
, "EVPN MAC updates: %"PRIu64
"\n", incoming
);
5429 vty_out(vty
, "EVPN MAC errors: %"PRIu64
"\n", errs
);
5431 incoming
= atomic_load_explicit(&zdplane_info
.dg_neighs_in
,
5432 memory_order_relaxed
);
5433 errs
= atomic_load_explicit(&zdplane_info
.dg_neigh_errors
,
5434 memory_order_relaxed
);
5435 vty_out(vty
, "EVPN neigh updates: %"PRIu64
"\n", incoming
);
5436 vty_out(vty
, "EVPN neigh errors: %"PRIu64
"\n", errs
);
5438 incoming
= atomic_load_explicit(&zdplane_info
.dg_rules_in
,
5439 memory_order_relaxed
);
5440 errs
= atomic_load_explicit(&zdplane_info
.dg_rule_errors
,
5441 memory_order_relaxed
);
5442 vty_out(vty
, "Rule updates: %" PRIu64
"\n", incoming
);
5443 vty_out(vty
, "Rule errors: %" PRIu64
"\n", errs
);
5445 incoming
= atomic_load_explicit(&zdplane_info
.dg_br_port_in
,
5446 memory_order_relaxed
);
5447 errs
= atomic_load_explicit(&zdplane_info
.dg_br_port_errors
,
5448 memory_order_relaxed
);
5449 vty_out(vty
, "Bridge port updates: %" PRIu64
"\n", incoming
);
5450 vty_out(vty
, "Bridge port errors: %" PRIu64
"\n", errs
);
5452 incoming
= atomic_load_explicit(&zdplane_info
.dg_iptable_in
,
5453 memory_order_relaxed
);
5454 errs
= atomic_load_explicit(&zdplane_info
.dg_iptable_errors
,
5455 memory_order_relaxed
);
5456 vty_out(vty
, "IPtable updates: %" PRIu64
"\n", incoming
);
5457 vty_out(vty
, "IPtable errors: %" PRIu64
"\n", errs
);
5458 incoming
= atomic_load_explicit(&zdplane_info
.dg_ipset_in
,
5459 memory_order_relaxed
);
5460 errs
= atomic_load_explicit(&zdplane_info
.dg_ipset_errors
,
5461 memory_order_relaxed
);
5462 vty_out(vty
, "IPset updates: %" PRIu64
"\n", incoming
);
5463 vty_out(vty
, "IPset errors: %" PRIu64
"\n", errs
);
5464 incoming
= atomic_load_explicit(&zdplane_info
.dg_ipset_entry_in
,
5465 memory_order_relaxed
);
5466 errs
= atomic_load_explicit(&zdplane_info
.dg_ipset_entry_errors
,
5467 memory_order_relaxed
);
5468 vty_out(vty
, "IPset entry updates: %" PRIu64
"\n", incoming
);
5469 vty_out(vty
, "IPset entry errors: %" PRIu64
"\n", errs
);
5471 incoming
= atomic_load_explicit(&zdplane_info
.dg_neightable_in
,
5472 memory_order_relaxed
);
5473 errs
= atomic_load_explicit(&zdplane_info
.dg_neightable_errors
,
5474 memory_order_relaxed
);
5475 vty_out(vty
, "Neighbor Table updates: %"PRIu64
"\n", incoming
);
5476 vty_out(vty
, "Neighbor Table errors: %"PRIu64
"\n", errs
);
5478 incoming
= atomic_load_explicit(&zdplane_info
.dg_gre_set_in
,
5479 memory_order_relaxed
);
5480 errs
= atomic_load_explicit(&zdplane_info
.dg_gre_set_errors
,
5481 memory_order_relaxed
);
5482 vty_out(vty
, "GRE set updates: %"PRIu64
"\n", incoming
);
5483 vty_out(vty
, "GRE set errors: %"PRIu64
"\n", errs
);
5488 * Handler for 'show dplane providers'
5490 int dplane_show_provs_helper(struct vty
*vty
, bool detailed
)
5492 struct zebra_dplane_provider
*prov
;
5493 uint64_t in
, in_q
, in_max
, out
, out_q
, out_max
;
5495 vty_out(vty
, "Zebra dataplane providers:\n");
5498 prov
= dplane_prov_list_first(&zdplane_info
.dg_providers
);
5501 /* Show counters, useful info from each registered provider */
5504 in
= atomic_load_explicit(&prov
->dp_in_counter
,
5505 memory_order_relaxed
);
5506 in_q
= atomic_load_explicit(&prov
->dp_in_queued
,
5507 memory_order_relaxed
);
5508 in_max
= atomic_load_explicit(&prov
->dp_in_max
,
5509 memory_order_relaxed
);
5510 out
= atomic_load_explicit(&prov
->dp_out_counter
,
5511 memory_order_relaxed
);
5512 out_q
= atomic_load_explicit(&prov
->dp_out_queued
,
5513 memory_order_relaxed
);
5514 out_max
= atomic_load_explicit(&prov
->dp_out_max
,
5515 memory_order_relaxed
);
5517 vty_out(vty
, "%s (%u): in: %"PRIu64
", q: %"PRIu64
", q_max: %"PRIu64
", out: %"PRIu64
", q: %"PRIu64
", q_max: %"PRIu64
"\n",
5518 prov
->dp_name
, prov
->dp_id
, in
, in_q
, in_max
,
5519 out
, out_q
, out_max
);
5521 prov
= dplane_prov_list_next(&zdplane_info
.dg_providers
, prov
);
5528 * Helper for 'show run' etc.
5530 int dplane_config_write_helper(struct vty
*vty
)
5532 if (zdplane_info
.dg_max_queued_updates
!= DPLANE_DEFAULT_MAX_QUEUED
)
5533 vty_out(vty
, "zebra dplane limit %u\n",
5534 zdplane_info
.dg_max_queued_updates
);
5540 * Provider registration
5542 int dplane_provider_register(const char *name
,
5543 enum dplane_provider_prio prio
,
5545 int (*start_fp
)(struct zebra_dplane_provider
*),
5546 int (*fp
)(struct zebra_dplane_provider
*),
5547 int (*fini_fp
)(struct zebra_dplane_provider
*,
5550 struct zebra_dplane_provider
**prov_p
)
5553 struct zebra_dplane_provider
*p
= NULL
, *last
;
5561 if (prio
<= DPLANE_PRIO_NONE
||
5562 prio
> DPLANE_PRIO_LAST
) {
5567 /* Allocate and init new provider struct */
5568 p
= XCALLOC(MTYPE_DP_PROV
, sizeof(struct zebra_dplane_provider
));
5570 pthread_mutex_init(&(p
->dp_mutex
), NULL
);
5571 dplane_ctx_list_init(&p
->dp_ctx_in_list
);
5572 dplane_ctx_list_init(&p
->dp_ctx_out_list
);
5574 p
->dp_flags
= flags
;
5575 p
->dp_priority
= prio
;
5577 p
->dp_start
= start_fp
;
5578 p
->dp_fini
= fini_fp
;
5581 /* Lock - the dplane pthread may be running */
5584 p
->dp_id
= ++zdplane_info
.dg_provider_id
;
5587 strlcpy(p
->dp_name
, name
, DPLANE_PROVIDER_NAMELEN
);
5589 snprintf(p
->dp_name
, DPLANE_PROVIDER_NAMELEN
,
5590 "provider-%u", p
->dp_id
);
5592 /* Insert into list ordered by priority */
5593 frr_each (dplane_prov_list
, &zdplane_info
.dg_providers
, last
) {
5594 if (last
->dp_priority
> p
->dp_priority
)
5599 dplane_prov_list_add_after(&zdplane_info
.dg_providers
, last
, p
);
5601 dplane_prov_list_add_tail(&zdplane_info
.dg_providers
, p
);
5606 if (IS_ZEBRA_DEBUG_DPLANE
)
5607 zlog_debug("dplane: registered new provider '%s' (%u), prio %d",
5608 p
->dp_name
, p
->dp_id
, p
->dp_priority
);
5617 /* Accessors for provider attributes */
5618 const char *dplane_provider_get_name(const struct zebra_dplane_provider
*prov
)
5620 return prov
->dp_name
;
5623 uint32_t dplane_provider_get_id(const struct zebra_dplane_provider
*prov
)
5628 void *dplane_provider_get_data(const struct zebra_dplane_provider
*prov
)
5630 return prov
->dp_data
;
5633 int dplane_provider_get_work_limit(const struct zebra_dplane_provider
*prov
)
5635 return zdplane_info
.dg_updates_per_cycle
;
5638 /* Lock/unlock a provider's mutex - iff the provider was registered with
5639 * the THREADED flag.
5641 void dplane_provider_lock(struct zebra_dplane_provider
*prov
)
5643 if (dplane_provider_is_threaded(prov
))
5644 DPLANE_PROV_LOCK(prov
);
5647 void dplane_provider_unlock(struct zebra_dplane_provider
*prov
)
5649 if (dplane_provider_is_threaded(prov
))
5650 DPLANE_PROV_UNLOCK(prov
);
5654 * Dequeue and maintain associated counter
5656 struct zebra_dplane_ctx
*dplane_provider_dequeue_in_ctx(
5657 struct zebra_dplane_provider
*prov
)
5659 struct zebra_dplane_ctx
*ctx
= NULL
;
5661 dplane_provider_lock(prov
);
5663 ctx
= dplane_ctx_list_pop(&(prov
->dp_ctx_in_list
));
5665 atomic_fetch_sub_explicit(&prov
->dp_in_queued
, 1,
5666 memory_order_relaxed
);
5669 dplane_provider_unlock(prov
);
5675 * Dequeue work to a list, return count
5677 int dplane_provider_dequeue_in_list(struct zebra_dplane_provider
*prov
,
5678 struct dplane_ctx_list_head
*listp
)
5681 struct zebra_dplane_ctx
*ctx
;
5683 limit
= zdplane_info
.dg_updates_per_cycle
;
5685 dplane_provider_lock(prov
);
5687 for (ret
= 0; ret
< limit
; ret
++) {
5688 ctx
= dplane_ctx_list_pop(&(prov
->dp_ctx_in_list
));
5690 dplane_ctx_list_add_tail(listp
, ctx
);
5696 atomic_fetch_sub_explicit(&prov
->dp_in_queued
, ret
,
5697 memory_order_relaxed
);
5699 dplane_provider_unlock(prov
);
5704 uint32_t dplane_provider_out_ctx_queue_len(struct zebra_dplane_provider
*prov
)
5706 return atomic_load_explicit(&(prov
->dp_out_counter
),
5707 memory_order_relaxed
);
5711 * Enqueue and maintain associated counter
5713 void dplane_provider_enqueue_out_ctx(struct zebra_dplane_provider
*prov
,
5714 struct zebra_dplane_ctx
*ctx
)
5716 uint64_t curr
, high
;
5718 dplane_provider_lock(prov
);
5720 dplane_ctx_list_add_tail(&(prov
->dp_ctx_out_list
), ctx
);
5722 /* Maintain out-queue counters */
5723 atomic_fetch_add_explicit(&(prov
->dp_out_queued
), 1,
5724 memory_order_relaxed
);
5725 curr
= atomic_load_explicit(&prov
->dp_out_queued
,
5726 memory_order_relaxed
);
5727 high
= atomic_load_explicit(&prov
->dp_out_max
,
5728 memory_order_relaxed
);
5730 atomic_store_explicit(&prov
->dp_out_max
, curr
,
5731 memory_order_relaxed
);
5733 dplane_provider_unlock(prov
);
5735 atomic_fetch_add_explicit(&(prov
->dp_out_counter
), 1,
5736 memory_order_relaxed
);
5739 static struct zebra_dplane_ctx
*
5740 dplane_provider_dequeue_out_ctx(struct zebra_dplane_provider
*prov
)
5742 struct zebra_dplane_ctx
*ctx
;
5744 ctx
= dplane_ctx_list_pop(&(prov
->dp_ctx_out_list
));
5748 atomic_fetch_sub_explicit(&(prov
->dp_out_queued
), 1,
5749 memory_order_relaxed
);
5755 * Accessor for provider object
5757 bool dplane_provider_is_threaded(const struct zebra_dplane_provider
*prov
)
5759 return (prov
->dp_flags
& DPLANE_PROV_FLAG_THREADED
);
5764 * Callback when an OS (netlink) incoming event read is ready. This runs
5765 * in the dplane pthread.
5767 static void dplane_incoming_read(struct event
*event
)
5769 struct dplane_zns_info
*zi
= EVENT_ARG(event
);
5771 kernel_dplane_read(&zi
->info
);
5773 /* Re-start read task */
5774 event_add_read(zdplane_info
.dg_master
, dplane_incoming_read
, zi
,
5775 zi
->info
.sock
, &zi
->t_read
);
5779 * Callback in the dataplane pthread that requests info from the OS and
5780 * initiates netlink reads.
5782 static void dplane_incoming_request(struct event
*event
)
5784 struct dplane_zns_info
*zi
= EVENT_ARG(event
);
5786 /* Start read task */
5787 event_add_read(zdplane_info
.dg_master
, dplane_incoming_read
, zi
,
5788 zi
->info
.sock
, &zi
->t_read
);
5791 netlink_request_netconf(zi
->info
.sock
);
5795 * Initiate requests for existing info from the OS. This is called by the
5796 * main pthread, but we want all activity on the dplane netlink socket to
5797 * take place on the dplane pthread, so we schedule an event to accomplish
5800 static void dplane_kernel_info_request(struct dplane_zns_info
*zi
)
5802 /* If we happen to encounter an enabled zns before the dplane
5803 * pthread is running, we'll initiate this later on.
5805 if (zdplane_info
.dg_master
)
5806 event_add_event(zdplane_info
.dg_master
, dplane_incoming_request
,
5807 zi
, 0, &zi
->t_request
);
5810 #endif /* HAVE_NETLINK */
5813 * Notify dplane when namespaces are enabled and disabled. The dplane
5814 * needs to start and stop reading incoming events from the zns. In the
5815 * common case where vrfs are _not_ namespaces, there will only be one
5818 * This is called in the main pthread.
5820 void zebra_dplane_ns_enable(struct zebra_ns
*zns
, bool enabled
)
5822 struct dplane_zns_info
*zi
;
5824 if (IS_ZEBRA_DEBUG_DPLANE
)
5825 zlog_debug("%s: %s for nsid %u", __func__
,
5826 (enabled
? "ENABLED" : "DISABLED"), zns
->ns_id
);
5828 /* Search for an existing zns info entry */
5829 frr_each (zns_info_list
, &zdplane_info
.dg_zns_list
, zi
) {
5830 if (zi
->info
.ns_id
== zns
->ns_id
)
5835 /* Create a new entry if necessary; start reading. */
5837 zi
= XCALLOC(MTYPE_DP_NS
, sizeof(*zi
));
5839 zi
->info
.ns_id
= zns
->ns_id
;
5841 zns_info_list_add_tail(&zdplane_info
.dg_zns_list
, zi
);
5843 if (IS_ZEBRA_DEBUG_DPLANE
)
5844 zlog_debug("%s: nsid %u, new zi %p", __func__
,
5848 /* Make sure we're up-to-date with the zns object */
5849 #if defined(HAVE_NETLINK)
5850 zi
->info
.is_cmd
= false;
5851 zi
->info
.sock
= zns
->netlink_dplane_in
.sock
;
5853 /* Initiate requests for existing info from the OS, and
5854 * begin reading from the netlink socket.
5856 dplane_kernel_info_request(zi
);
5859 if (IS_ZEBRA_DEBUG_DPLANE
)
5860 zlog_debug("%s: nsid %u, deleting zi %p", __func__
,
5863 /* Stop reading, free memory */
5864 zns_info_list_del(&zdplane_info
.dg_zns_list
, zi
);
5866 /* Stop any outstanding tasks */
5867 if (zdplane_info
.dg_master
) {
5868 event_cancel_async(zdplane_info
.dg_master
,
5869 &zi
->t_request
, NULL
);
5871 event_cancel_async(zdplane_info
.dg_master
, &zi
->t_read
,
5875 XFREE(MTYPE_DP_NS
, zi
);
5880 * Provider api to signal that work/events are available
5881 * for the dataplane pthread.
5883 int dplane_provider_work_ready(void)
5885 /* Note that during zebra startup, we may be offered work before
5886 * the dataplane pthread (and thread-master) are ready. We want to
5887 * enqueue the work, but the event-scheduling machinery may not be
5890 if (zdplane_info
.dg_run
) {
5891 event_add_event(zdplane_info
.dg_master
, dplane_thread_loop
,
5892 NULL
, 0, &zdplane_info
.dg_t_update
);
5899 * Enqueue a context directly to zebra main.
5901 void dplane_provider_enqueue_to_zebra(struct zebra_dplane_ctx
*ctx
)
5903 struct dplane_ctx_list_head temp_list
;
5905 /* Zebra's api takes a list, so we need to use a temporary list */
5906 dplane_ctx_list_init(&temp_list
);
5908 dplane_ctx_list_add_tail(&temp_list
, ctx
);
5909 (zdplane_info
.dg_results_cb
)(&temp_list
);
5913 * Kernel dataplane provider
5916 static void kernel_dplane_log_detail(struct zebra_dplane_ctx
*ctx
)
5918 char buf
[PREFIX_STRLEN
];
5920 switch (dplane_ctx_get_op(ctx
)) {
5922 case DPLANE_OP_ROUTE_INSTALL
:
5923 case DPLANE_OP_ROUTE_UPDATE
:
5924 case DPLANE_OP_ROUTE_DELETE
:
5925 zlog_debug("%u:%pFX Dplane route update ctx %p op %s",
5926 dplane_ctx_get_vrf(ctx
), dplane_ctx_get_dest(ctx
),
5927 ctx
, dplane_op2str(dplane_ctx_get_op(ctx
)));
5930 case DPLANE_OP_NH_INSTALL
:
5931 case DPLANE_OP_NH_UPDATE
:
5932 case DPLANE_OP_NH_DELETE
:
5933 zlog_debug("ID (%u) Dplane nexthop update ctx %p op %s",
5934 dplane_ctx_get_nhe_id(ctx
), ctx
,
5935 dplane_op2str(dplane_ctx_get_op(ctx
)));
5938 case DPLANE_OP_LSP_INSTALL
:
5939 case DPLANE_OP_LSP_UPDATE
:
5940 case DPLANE_OP_LSP_DELETE
:
5943 case DPLANE_OP_PW_INSTALL
:
5944 case DPLANE_OP_PW_UNINSTALL
:
5945 zlog_debug("Dplane pw %s: op %s af %d loc: %u rem: %u",
5946 dplane_ctx_get_ifname(ctx
),
5947 dplane_op2str(ctx
->zd_op
), dplane_ctx_get_pw_af(ctx
),
5948 dplane_ctx_get_pw_local_label(ctx
),
5949 dplane_ctx_get_pw_remote_label(ctx
));
5952 case DPLANE_OP_ADDR_INSTALL
:
5953 case DPLANE_OP_ADDR_UNINSTALL
:
5954 zlog_debug("Dplane intf %s, idx %u, addr %pFX",
5955 dplane_op2str(dplane_ctx_get_op(ctx
)),
5956 dplane_ctx_get_ifindex(ctx
),
5957 dplane_ctx_get_intf_addr(ctx
));
5960 case DPLANE_OP_MAC_INSTALL
:
5961 case DPLANE_OP_MAC_DELETE
:
5962 prefix_mac2str(dplane_ctx_mac_get_addr(ctx
), buf
,
5965 zlog_debug("Dplane %s, mac %s, ifindex %u",
5966 dplane_op2str(dplane_ctx_get_op(ctx
)),
5967 buf
, dplane_ctx_get_ifindex(ctx
));
5970 case DPLANE_OP_NEIGH_INSTALL
:
5971 case DPLANE_OP_NEIGH_UPDATE
:
5972 case DPLANE_OP_NEIGH_DELETE
:
5973 case DPLANE_OP_VTEP_ADD
:
5974 case DPLANE_OP_VTEP_DELETE
:
5975 case DPLANE_OP_NEIGH_DISCOVER
:
5976 case DPLANE_OP_NEIGH_IP_INSTALL
:
5977 case DPLANE_OP_NEIGH_IP_DELETE
:
5978 ipaddr2str(dplane_ctx_neigh_get_ipaddr(ctx
), buf
,
5981 zlog_debug("Dplane %s, ip %s, ifindex %u",
5982 dplane_op2str(dplane_ctx_get_op(ctx
)),
5983 buf
, dplane_ctx_get_ifindex(ctx
));
5986 case DPLANE_OP_RULE_ADD
:
5987 case DPLANE_OP_RULE_DELETE
:
5988 case DPLANE_OP_RULE_UPDATE
:
5989 zlog_debug("Dplane rule update op %s, if %s(%u), ctx %p",
5990 dplane_op2str(dplane_ctx_get_op(ctx
)),
5991 dplane_ctx_get_ifname(ctx
),
5992 dplane_ctx_get_ifindex(ctx
), ctx
);
5995 case DPLANE_OP_SYS_ROUTE_ADD
:
5996 case DPLANE_OP_SYS_ROUTE_DELETE
:
5997 case DPLANE_OP_ROUTE_NOTIFY
:
5998 case DPLANE_OP_LSP_NOTIFY
:
5999 case DPLANE_OP_BR_PORT_UPDATE
:
6001 case DPLANE_OP_NONE
:
6004 case DPLANE_OP_IPTABLE_ADD
:
6005 case DPLANE_OP_IPTABLE_DELETE
: {
6006 struct zebra_pbr_iptable ipt
;
6008 dplane_ctx_get_pbr_iptable(ctx
, &ipt
);
6009 zlog_debug("Dplane iptable update op %s, unique(%u), ctx %p",
6010 dplane_op2str(dplane_ctx_get_op(ctx
)), ipt
.unique
,
6013 case DPLANE_OP_IPSET_ADD
:
6014 case DPLANE_OP_IPSET_DELETE
: {
6015 struct zebra_pbr_ipset ipset
;
6017 dplane_ctx_get_pbr_ipset(ctx
, &ipset
);
6018 zlog_debug("Dplane ipset update op %s, unique(%u), ctx %p",
6019 dplane_op2str(dplane_ctx_get_op(ctx
)), ipset
.unique
,
6022 case DPLANE_OP_IPSET_ENTRY_ADD
:
6023 case DPLANE_OP_IPSET_ENTRY_DELETE
: {
6024 struct zebra_pbr_ipset_entry ipent
;
6026 dplane_ctx_get_pbr_ipset_entry(ctx
, &ipent
);
6028 "Dplane ipset entry update op %s, unique(%u), ctx %p",
6029 dplane_op2str(dplane_ctx_get_op(ctx
)), ipent
.unique
,
6032 case DPLANE_OP_NEIGH_TABLE_UPDATE
:
6033 zlog_debug("Dplane neigh table op %s, ifp %s, family %s",
6034 dplane_op2str(dplane_ctx_get_op(ctx
)),
6035 dplane_ctx_get_ifname(ctx
),
6036 family2str(dplane_ctx_neightable_get_family(ctx
)));
6038 case DPLANE_OP_GRE_SET
:
6039 zlog_debug("Dplane gre set op %s, ifp %s, link %u",
6040 dplane_op2str(dplane_ctx_get_op(ctx
)),
6041 dplane_ctx_get_ifname(ctx
),
6042 ctx
->u
.gre
.link_ifindex
);
6045 case DPLANE_OP_INTF_ADDR_ADD
:
6046 case DPLANE_OP_INTF_ADDR_DEL
:
6047 zlog_debug("Dplane incoming op %s, intf %s, addr %pFX",
6048 dplane_op2str(dplane_ctx_get_op(ctx
)),
6049 dplane_ctx_get_ifname(ctx
),
6050 dplane_ctx_get_intf_addr(ctx
));
6053 case DPLANE_OP_INTF_NETCONFIG
:
6054 zlog_debug("%s: ifindex %d, mpls %d, mcast %d",
6055 dplane_op2str(dplane_ctx_get_op(ctx
)),
6056 dplane_ctx_get_ifindex(ctx
),
6057 dplane_ctx_get_netconf_mpls(ctx
),
6058 dplane_ctx_get_netconf_mcast(ctx
));
6061 case DPLANE_OP_INTF_INSTALL
:
6062 case DPLANE_OP_INTF_UPDATE
:
6063 case DPLANE_OP_INTF_DELETE
:
6064 zlog_debug("Dplane intf %s, idx %u, protodown %d",
6065 dplane_op2str(dplane_ctx_get_op(ctx
)),
6066 dplane_ctx_get_ifindex(ctx
),
6067 dplane_ctx_intf_is_protodown(ctx
));
6070 /* TODO: more detailed log */
6071 case DPLANE_OP_TC_QDISC_INSTALL
:
6072 case DPLANE_OP_TC_QDISC_UNINSTALL
:
6073 zlog_debug("Dplane tc qdisc ifidx %u",
6074 dplane_ctx_get_ifindex(ctx
));
6076 case DPLANE_OP_TC_CLASS_ADD
:
6077 case DPLANE_OP_TC_CLASS_DELETE
:
6078 case DPLANE_OP_TC_CLASS_UPDATE
:
6080 case DPLANE_OP_TC_FILTER_ADD
:
6081 case DPLANE_OP_TC_FILTER_DELETE
:
6082 case DPLANE_OP_TC_FILTER_UPDATE
:
6087 static void kernel_dplane_handle_result(struct zebra_dplane_ctx
*ctx
)
6089 enum zebra_dplane_result res
= dplane_ctx_get_status(ctx
);
6091 switch (dplane_ctx_get_op(ctx
)) {
6093 case DPLANE_OP_ROUTE_INSTALL
:
6094 case DPLANE_OP_ROUTE_UPDATE
:
6095 case DPLANE_OP_ROUTE_DELETE
:
6096 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6097 atomic_fetch_add_explicit(&zdplane_info
.dg_route_errors
,
6098 1, memory_order_relaxed
);
6100 if ((dplane_ctx_get_op(ctx
) != DPLANE_OP_ROUTE_DELETE
)
6101 && (res
== ZEBRA_DPLANE_REQUEST_SUCCESS
)) {
6102 struct nexthop
*nexthop
;
6104 /* Update installed nexthops to signal which have been
6107 for (ALL_NEXTHOPS_PTR(dplane_ctx_get_ng(ctx
),
6109 if (CHECK_FLAG(nexthop
->flags
,
6110 NEXTHOP_FLAG_RECURSIVE
))
6113 if (CHECK_FLAG(nexthop
->flags
,
6114 NEXTHOP_FLAG_ACTIVE
)) {
6115 SET_FLAG(nexthop
->flags
,
6122 case DPLANE_OP_NH_INSTALL
:
6123 case DPLANE_OP_NH_UPDATE
:
6124 case DPLANE_OP_NH_DELETE
:
6125 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6126 atomic_fetch_add_explicit(
6127 &zdplane_info
.dg_nexthop_errors
, 1,
6128 memory_order_relaxed
);
6131 case DPLANE_OP_LSP_INSTALL
:
6132 case DPLANE_OP_LSP_UPDATE
:
6133 case DPLANE_OP_LSP_DELETE
:
6134 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6135 atomic_fetch_add_explicit(&zdplane_info
.dg_lsp_errors
,
6136 1, memory_order_relaxed
);
6139 case DPLANE_OP_PW_INSTALL
:
6140 case DPLANE_OP_PW_UNINSTALL
:
6141 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6142 atomic_fetch_add_explicit(&zdplane_info
.dg_pw_errors
, 1,
6143 memory_order_relaxed
);
6146 case DPLANE_OP_ADDR_INSTALL
:
6147 case DPLANE_OP_ADDR_UNINSTALL
:
6148 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6149 atomic_fetch_add_explicit(
6150 &zdplane_info
.dg_intf_addr_errors
, 1,
6151 memory_order_relaxed
);
6154 case DPLANE_OP_MAC_INSTALL
:
6155 case DPLANE_OP_MAC_DELETE
:
6156 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6157 atomic_fetch_add_explicit(&zdplane_info
.dg_mac_errors
,
6158 1, memory_order_relaxed
);
6161 case DPLANE_OP_NEIGH_INSTALL
:
6162 case DPLANE_OP_NEIGH_UPDATE
:
6163 case DPLANE_OP_NEIGH_DELETE
:
6164 case DPLANE_OP_VTEP_ADD
:
6165 case DPLANE_OP_VTEP_DELETE
:
6166 case DPLANE_OP_NEIGH_DISCOVER
:
6167 case DPLANE_OP_NEIGH_IP_INSTALL
:
6168 case DPLANE_OP_NEIGH_IP_DELETE
:
6169 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6170 atomic_fetch_add_explicit(&zdplane_info
.dg_neigh_errors
,
6171 1, memory_order_relaxed
);
6174 case DPLANE_OP_RULE_ADD
:
6175 case DPLANE_OP_RULE_DELETE
:
6176 case DPLANE_OP_RULE_UPDATE
:
6177 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6178 atomic_fetch_add_explicit(&zdplane_info
.dg_rule_errors
,
6179 1, memory_order_relaxed
);
6182 case DPLANE_OP_IPTABLE_ADD
:
6183 case DPLANE_OP_IPTABLE_DELETE
:
6184 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6185 atomic_fetch_add_explicit(
6186 &zdplane_info
.dg_iptable_errors
, 1,
6187 memory_order_relaxed
);
6190 case DPLANE_OP_IPSET_ADD
:
6191 case DPLANE_OP_IPSET_DELETE
:
6192 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6193 atomic_fetch_add_explicit(&zdplane_info
.dg_ipset_errors
,
6194 1, memory_order_relaxed
);
6197 case DPLANE_OP_IPSET_ENTRY_ADD
:
6198 case DPLANE_OP_IPSET_ENTRY_DELETE
:
6199 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6200 atomic_fetch_add_explicit(
6201 &zdplane_info
.dg_ipset_entry_errors
, 1,
6202 memory_order_relaxed
);
6205 case DPLANE_OP_NEIGH_TABLE_UPDATE
:
6206 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6207 atomic_fetch_add_explicit(
6208 &zdplane_info
.dg_neightable_errors
, 1,
6209 memory_order_relaxed
);
6212 case DPLANE_OP_GRE_SET
:
6213 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6214 atomic_fetch_add_explicit(
6215 &zdplane_info
.dg_gre_set_errors
, 1,
6216 memory_order_relaxed
);
6219 case DPLANE_OP_INTF_INSTALL
:
6220 case DPLANE_OP_INTF_UPDATE
:
6221 case DPLANE_OP_INTF_DELETE
:
6222 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6223 atomic_fetch_add_explicit(&zdplane_info
.dg_intf_errors
,
6224 1, memory_order_relaxed
);
6227 case DPLANE_OP_TC_QDISC_INSTALL
:
6228 case DPLANE_OP_TC_QDISC_UNINSTALL
:
6229 case DPLANE_OP_TC_CLASS_ADD
:
6230 case DPLANE_OP_TC_CLASS_DELETE
:
6231 case DPLANE_OP_TC_CLASS_UPDATE
:
6232 case DPLANE_OP_TC_FILTER_ADD
:
6233 case DPLANE_OP_TC_FILTER_DELETE
:
6234 case DPLANE_OP_TC_FILTER_UPDATE
:
6235 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6236 atomic_fetch_add_explicit(&zdplane_info
.dg_tcs_errors
,
6237 1, memory_order_relaxed
);
6240 /* Ignore 'notifications' - no-op */
6241 case DPLANE_OP_SYS_ROUTE_ADD
:
6242 case DPLANE_OP_SYS_ROUTE_DELETE
:
6243 case DPLANE_OP_ROUTE_NOTIFY
:
6244 case DPLANE_OP_LSP_NOTIFY
:
6245 case DPLANE_OP_BR_PORT_UPDATE
:
6248 /* TODO -- error counters for incoming events? */
6249 case DPLANE_OP_INTF_ADDR_ADD
:
6250 case DPLANE_OP_INTF_ADDR_DEL
:
6251 case DPLANE_OP_INTF_NETCONFIG
:
6254 case DPLANE_OP_NONE
:
6255 if (res
!= ZEBRA_DPLANE_REQUEST_SUCCESS
)
6256 atomic_fetch_add_explicit(&zdplane_info
.dg_other_errors
,
6257 1, memory_order_relaxed
);
6262 static void kernel_dplane_process_iptable(struct zebra_dplane_provider
*prov
,
6263 struct zebra_dplane_ctx
*ctx
)
6265 zebra_pbr_process_iptable(ctx
);
6266 dplane_provider_enqueue_out_ctx(prov
, ctx
);
6269 static void kernel_dplane_process_ipset(struct zebra_dplane_provider
*prov
,
6270 struct zebra_dplane_ctx
*ctx
)
6272 zebra_pbr_process_ipset(ctx
);
6273 dplane_provider_enqueue_out_ctx(prov
, ctx
);
6277 kernel_dplane_process_ipset_entry(struct zebra_dplane_provider
*prov
,
6278 struct zebra_dplane_ctx
*ctx
)
6280 zebra_pbr_process_ipset_entry(ctx
);
6281 dplane_provider_enqueue_out_ctx(prov
, ctx
);
6284 void dplane_rib_add_multipath(afi_t afi
, safi_t safi
, struct prefix
*p
,
6285 struct prefix_ipv6
*src_p
, struct route_entry
*re
,
6286 struct nexthop_group
*ng
, int startup
,
6287 struct zebra_dplane_ctx
*ctx
)
6290 rib_add_multipath(afi
, safi
, p
, src_p
, re
, ng
, startup
);
6292 dplane_ctx_route_init_basic(ctx
, dplane_ctx_get_op(ctx
), re
, p
,
6294 dplane_provider_enqueue_to_zebra(ctx
);
6299 * Kernel provider callback
6301 static int kernel_dplane_process_func(struct zebra_dplane_provider
*prov
)
6303 struct zebra_dplane_ctx
*ctx
;
6304 struct dplane_ctx_list_head work_list
;
6307 dplane_ctx_list_init(&work_list
);
6309 limit
= dplane_provider_get_work_limit(prov
);
6311 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6312 zlog_debug("dplane provider '%s': processing",
6313 dplane_provider_get_name(prov
));
6315 for (counter
= 0; counter
< limit
; counter
++) {
6316 ctx
= dplane_provider_dequeue_in_ctx(prov
);
6319 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6320 kernel_dplane_log_detail(ctx
);
6322 if ((dplane_ctx_get_op(ctx
) == DPLANE_OP_IPTABLE_ADD
6323 || dplane_ctx_get_op(ctx
) == DPLANE_OP_IPTABLE_DELETE
))
6324 kernel_dplane_process_iptable(prov
, ctx
);
6325 else if ((dplane_ctx_get_op(ctx
) == DPLANE_OP_IPSET_ADD
6326 || dplane_ctx_get_op(ctx
) == DPLANE_OP_IPSET_DELETE
))
6327 kernel_dplane_process_ipset(prov
, ctx
);
6328 else if ((dplane_ctx_get_op(ctx
) == DPLANE_OP_IPSET_ENTRY_ADD
6329 || dplane_ctx_get_op(ctx
)
6330 == DPLANE_OP_IPSET_ENTRY_DELETE
))
6331 kernel_dplane_process_ipset_entry(prov
, ctx
);
6333 dplane_ctx_list_add_tail(&work_list
, ctx
);
6336 kernel_update_multi(&work_list
);
6338 while ((ctx
= dplane_ctx_list_pop(&work_list
)) != NULL
) {
6339 kernel_dplane_handle_result(ctx
);
6341 dplane_provider_enqueue_out_ctx(prov
, ctx
);
6344 /* Ensure that we'll run the work loop again if there's still
6347 if (counter
>= limit
) {
6348 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6349 zlog_debug("dplane provider '%s' reached max updates %d",
6350 dplane_provider_get_name(prov
), counter
);
6352 atomic_fetch_add_explicit(&zdplane_info
.dg_update_yields
,
6353 1, memory_order_relaxed
);
6355 dplane_provider_work_ready();
6361 #ifdef DPLANE_TEST_PROVIDER
6364 * Test dataplane provider plugin
6368 * Test provider process callback
6370 static int test_dplane_process_func(struct zebra_dplane_provider
*prov
)
6372 struct zebra_dplane_ctx
*ctx
;
6375 /* Just moving from 'in' queue to 'out' queue */
6377 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6378 zlog_debug("dplane provider '%s': processing",
6379 dplane_provider_get_name(prov
));
6381 limit
= dplane_provider_get_work_limit(prov
);
6383 for (counter
= 0; counter
< limit
; counter
++) {
6384 ctx
= dplane_provider_dequeue_in_ctx(prov
);
6388 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6389 zlog_debug("dplane provider '%s': op %s",
6390 dplane_provider_get_name(prov
),
6391 dplane_op2str(dplane_ctx_get_op(ctx
)));
6393 dplane_ctx_set_status(ctx
, ZEBRA_DPLANE_REQUEST_SUCCESS
);
6395 dplane_provider_enqueue_out_ctx(prov
, ctx
);
6398 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6399 zlog_debug("dplane provider '%s': processed %d",
6400 dplane_provider_get_name(prov
), counter
);
6402 /* Ensure that we'll run the work loop again if there's still
6405 if (counter
>= limit
)
6406 dplane_provider_work_ready();
6412 * Test provider shutdown/fini callback
6414 static int test_dplane_shutdown_func(struct zebra_dplane_provider
*prov
,
6417 if (IS_ZEBRA_DEBUG_DPLANE
)
6418 zlog_debug("dplane provider '%s': %sshutdown",
6419 dplane_provider_get_name(prov
),
6420 early
? "early " : "");
6424 #endif /* DPLANE_TEST_PROVIDER */
6427 * Register default kernel provider
6429 static void dplane_provider_init(void)
6433 ret
= dplane_provider_register("Kernel",
6435 DPLANE_PROV_FLAGS_DEFAULT
, NULL
,
6436 kernel_dplane_process_func
,
6441 zlog_err("Unable to register kernel dplane provider: %d",
6444 #ifdef DPLANE_TEST_PROVIDER
6445 /* Optional test provider ... */
6446 ret
= dplane_provider_register("Test",
6447 DPLANE_PRIO_PRE_KERNEL
,
6448 DPLANE_PROV_FLAGS_DEFAULT
, NULL
,
6449 test_dplane_process_func
,
6450 test_dplane_shutdown_func
,
6451 NULL
/* data */, NULL
);
6454 zlog_err("Unable to register test dplane provider: %d",
6456 #endif /* DPLANE_TEST_PROVIDER */
6460 * Allow zebra code to walk the queue of pending contexts, evaluate each one
6461 * using a callback function. If the function returns 'true', the context
6462 * will be dequeued and freed without being processed.
6464 int dplane_clean_ctx_queue(bool (*context_cb
)(struct zebra_dplane_ctx
*ctx
,
6465 void *arg
), void *val
)
6467 struct zebra_dplane_ctx
*ctx
;
6468 struct dplane_ctx_list_head work_list
;
6470 dplane_ctx_list_init(&work_list
);
6472 if (context_cb
== NULL
)
6475 /* Walk the pending context queue under the dplane lock. */
6478 frr_each_safe (dplane_ctx_list
, &zdplane_info
.dg_update_list
, ctx
) {
6479 if (context_cb(ctx
, val
)) {
6480 dplane_ctx_list_del(&zdplane_info
.dg_update_list
, ctx
);
6481 dplane_ctx_list_add_tail(&work_list
, ctx
);
6487 /* Now free any contexts selected by the caller, without holding
6490 while ((ctx
= dplane_ctx_list_pop(&work_list
)) != NULL
)
6491 dplane_ctx_fini(&ctx
);
6496 /* Indicates zebra shutdown/exit is in progress. Some operations may be
6497 * simplified or skipped during shutdown processing.
6499 bool dplane_is_in_shutdown(void)
6501 return zdplane_info
.dg_is_shutdown
;
6505 * Enable collection of extra info about interfaces in route updates.
6507 void dplane_enable_intf_extra_info(void)
6509 dplane_collect_extra_intf_info
= true;
6513 * Early or pre-shutdown, de-init notification api. This runs pretty
6514 * early during zebra shutdown, as a signal to stop new work and prepare
6515 * for updates generated by shutdown/cleanup activity, as zebra tries to
6516 * remove everything it's responsible for.
6517 * NB: This runs in the main zebra pthread context.
6519 void zebra_dplane_pre_finish(void)
6521 struct zebra_dplane_provider
*prov
;
6523 if (IS_ZEBRA_DEBUG_DPLANE
)
6524 zlog_debug("Zebra dataplane pre-finish called");
6526 zdplane_info
.dg_is_shutdown
= true;
6528 /* Notify provider(s) of pending shutdown. */
6529 frr_each (dplane_prov_list
, &zdplane_info
.dg_providers
, prov
) {
6530 if (prov
->dp_fini
== NULL
)
6533 prov
->dp_fini(prov
, true /* early */);
6538 * Utility to determine whether work remains enqueued within the dplane;
6539 * used during system shutdown processing.
6541 static bool dplane_work_pending(void)
6544 struct zebra_dplane_ctx
*ctx
;
6545 struct zebra_dplane_provider
*prov
;
6547 /* TODO -- just checking incoming/pending work for now, must check
6552 ctx
= dplane_ctx_list_first(&zdplane_info
.dg_update_list
);
6553 prov
= dplane_prov_list_first(&zdplane_info
.dg_providers
);
6562 dplane_provider_lock(prov
);
6564 ctx
= dplane_ctx_list_first(&(prov
->dp_ctx_in_list
));
6566 ctx
= dplane_ctx_list_first(&(prov
->dp_ctx_out_list
));
6568 dplane_provider_unlock(prov
);
6573 prov
= dplane_prov_list_next(&zdplane_info
.dg_providers
, prov
);
6583 * Shutdown-time intermediate callback, used to determine when all pending
6584 * in-flight updates are done. If there's still work to do, reschedules itself.
6585 * If all work is done, schedules an event to the main zebra thread for
6586 * final zebra shutdown.
6587 * This runs in the dplane pthread context.
6589 static void dplane_check_shutdown_status(struct event
*event
)
6591 struct dplane_zns_info
*zi
;
6593 if (IS_ZEBRA_DEBUG_DPLANE
)
6594 zlog_debug("Zebra dataplane shutdown status check called");
6596 /* Remove any zns info entries as we stop the dplane pthread. */
6597 frr_each_safe (zns_info_list
, &zdplane_info
.dg_zns_list
, zi
) {
6598 zns_info_list_del(&zdplane_info
.dg_zns_list
, zi
);
6600 if (zdplane_info
.dg_master
) {
6601 EVENT_OFF(zi
->t_read
);
6602 EVENT_OFF(zi
->t_request
);
6605 XFREE(MTYPE_DP_NS
, zi
);
6608 if (dplane_work_pending()) {
6609 /* Reschedule dplane check on a short timer */
6610 event_add_timer_msec(zdplane_info
.dg_master
,
6611 dplane_check_shutdown_status
, NULL
, 100,
6612 &zdplane_info
.dg_t_shutdown_check
);
6614 /* TODO - give up and stop waiting after a short time? */
6617 /* We appear to be done - schedule a final callback event
6618 * for the zebra main pthread.
6620 event_add_event(zrouter
.master
, zebra_finalize
, NULL
, 0, NULL
);
6625 * Shutdown, de-init api. This runs pretty late during shutdown,
6626 * after zebra has tried to free/remove/uninstall all routes during shutdown.
6627 * At this point, dplane work may still remain to be done, so we can't just
6628 * blindly terminate. If there's still work to do, we'll periodically check
6629 * and when done, we'll enqueue a task to the zebra main thread for final
6630 * termination processing.
6632 * NB: This runs in the main zebra thread context.
6634 void zebra_dplane_finish(void)
6636 if (IS_ZEBRA_DEBUG_DPLANE
)
6637 zlog_debug("Zebra dataplane fini called");
6639 event_add_event(zdplane_info
.dg_master
, dplane_check_shutdown_status
,
6640 NULL
, 0, &zdplane_info
.dg_t_shutdown_check
);
6644 * Main dataplane pthread event loop. The thread takes new incoming work
6645 * and offers it to the first provider. It then iterates through the
6646 * providers, taking complete work from each one and offering it
6647 * to the next in order. At each step, a limited number of updates are
6648 * processed during a cycle in order to provide some fairness.
6650 * This loop through the providers is only run once, so that the dataplane
6651 * pthread can look for other pending work - such as i/o work on behalf of
6654 static void dplane_thread_loop(struct event
*event
)
6656 struct dplane_ctx_list_head work_list
;
6657 struct dplane_ctx_list_head error_list
;
6658 struct zebra_dplane_provider
*prov
;
6659 struct zebra_dplane_ctx
*ctx
;
6660 int limit
, counter
, error_counter
;
6661 uint64_t curr
, high
;
6662 bool reschedule
= false;
6664 /* Capture work limit per cycle */
6665 limit
= zdplane_info
.dg_updates_per_cycle
;
6667 /* Init temporary lists used to move contexts among providers */
6668 dplane_ctx_list_init(&work_list
);
6669 dplane_ctx_list_init(&error_list
);
6673 /* Check for zebra shutdown */
6674 if (!zdplane_info
.dg_run
)
6677 /* Dequeue some incoming work from zebra (if any) onto the temporary
6682 /* Locate initial registered provider */
6683 prov
= dplane_prov_list_first(&zdplane_info
.dg_providers
);
6685 /* Move new work from incoming list to temp list */
6686 for (counter
= 0; counter
< limit
; counter
++) {
6687 ctx
= dplane_ctx_list_pop(&zdplane_info
.dg_update_list
);
6689 ctx
->zd_provider
= prov
->dp_id
;
6691 dplane_ctx_list_add_tail(&work_list
, ctx
);
6699 atomic_fetch_sub_explicit(&zdplane_info
.dg_routes_queued
, counter
,
6700 memory_order_relaxed
);
6702 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6703 zlog_debug("dplane: incoming new work counter: %d", counter
);
6705 /* Iterate through the registered providers, offering new incoming
6706 * work. If the provider has outgoing work in its queue, take that
6707 * work for the next provider
6711 /* At each iteration, the temporary work list has 'counter'
6714 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6715 zlog_debug("dplane enqueues %d new work to provider '%s'",
6716 counter
, dplane_provider_get_name(prov
));
6718 /* Capture current provider id in each context; check for
6721 frr_each_safe (dplane_ctx_list
, &work_list
, ctx
) {
6722 if (dplane_ctx_get_status(ctx
) ==
6723 ZEBRA_DPLANE_REQUEST_SUCCESS
) {
6724 ctx
->zd_provider
= prov
->dp_id
;
6727 * TODO -- improve error-handling: recirc
6728 * errors backwards so that providers can
6729 * 'undo' their work (if they want to)
6732 /* Move to error list; will be returned
6735 dplane_ctx_list_del(&work_list
, ctx
);
6736 dplane_ctx_list_add_tail(&error_list
, ctx
);
6741 /* Enqueue new work to the provider */
6742 dplane_provider_lock(prov
);
6744 while ((ctx
= dplane_ctx_list_pop(&work_list
)) != NULL
)
6745 dplane_ctx_list_add_tail(&(prov
->dp_ctx_in_list
), ctx
);
6747 atomic_fetch_add_explicit(&prov
->dp_in_counter
, counter
,
6748 memory_order_relaxed
);
6749 atomic_fetch_add_explicit(&prov
->dp_in_queued
, counter
,
6750 memory_order_relaxed
);
6751 curr
= atomic_load_explicit(&prov
->dp_in_queued
,
6752 memory_order_relaxed
);
6753 high
= atomic_load_explicit(&prov
->dp_in_max
,
6754 memory_order_relaxed
);
6756 atomic_store_explicit(&prov
->dp_in_max
, curr
,
6757 memory_order_relaxed
);
6759 dplane_provider_unlock(prov
);
6761 /* Reset the temp list (though the 'concat' may have done this
6762 * already), and the counter
6764 dplane_ctx_list_init(&work_list
);
6767 /* Call into the provider code. Note that this is
6768 * unconditional: we offer to do work even if we don't enqueue
6771 (*prov
->dp_fp
)(prov
);
6773 /* Check for zebra shutdown */
6774 if (!zdplane_info
.dg_run
)
6777 /* Dequeue completed work from the provider */
6778 dplane_provider_lock(prov
);
6780 while (counter
< limit
) {
6781 ctx
= dplane_provider_dequeue_out_ctx(prov
);
6783 dplane_ctx_list_add_tail(&work_list
, ctx
);
6789 dplane_provider_unlock(prov
);
6791 if (counter
>= limit
)
6794 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6795 zlog_debug("dplane dequeues %d completed work from provider %s",
6796 counter
, dplane_provider_get_name(prov
));
6798 /* Locate next provider */
6799 prov
= dplane_prov_list_next(&zdplane_info
.dg_providers
, prov
);
6803 * We hit the work limit while processing at least one provider's
6804 * output queue - ensure we come back and finish it.
6807 dplane_provider_work_ready();
6809 /* After all providers have been serviced, enqueue any completed
6810 * work and any errors back to zebra so it can process the results.
6812 if (IS_ZEBRA_DEBUG_DPLANE_DETAIL
)
6813 zlog_debug("dplane has %d completed, %d errors, for zebra main",
6814 counter
, error_counter
);
6817 * Hand lists through the api to zebra main,
6818 * to reduce the number of lock/unlock cycles
6821 /* Call through to zebra main */
6822 (zdplane_info
.dg_results_cb
)(&error_list
);
6824 dplane_ctx_list_init(&error_list
);
6826 /* Call through to zebra main */
6827 (zdplane_info
.dg_results_cb
)(&work_list
);
6829 dplane_ctx_list_init(&work_list
);
6833 * Final phase of shutdown, after all work enqueued to dplane has been
6834 * processed. This is called from the zebra main pthread context.
6836 void zebra_dplane_shutdown(void)
6838 struct zebra_dplane_provider
*dp
;
6840 if (IS_ZEBRA_DEBUG_DPLANE
)
6841 zlog_debug("Zebra dataplane shutdown called");
6843 /* Stop dplane thread, if it's running */
6845 zdplane_info
.dg_run
= false;
6847 frr_pthread_stop(zdplane_info
.dg_pthread
, NULL
);
6849 /* Destroy pthread */
6850 frr_pthread_destroy(zdplane_info
.dg_pthread
);
6851 zdplane_info
.dg_pthread
= NULL
;
6852 zdplane_info
.dg_master
= NULL
;
6854 /* Notify provider(s) of final shutdown.
6855 * Note that this call is in the main pthread, so providers must
6856 * be prepared for that.
6858 frr_each (dplane_prov_list
, &zdplane_info
.dg_providers
, dp
) {
6859 if (dp
->dp_fini
== NULL
)
6862 dp
->dp_fini(dp
, false);
6865 /* TODO -- Clean-up provider objects */
6867 /* TODO -- Clean queue(s), free memory */
6871 * Initialize the dataplane module during startup, internal/private version
6873 static void zebra_dplane_init_internal(void)
6875 memset(&zdplane_info
, 0, sizeof(zdplane_info
));
6877 pthread_mutex_init(&zdplane_info
.dg_mutex
, NULL
);
6879 dplane_prov_list_init(&zdplane_info
.dg_providers
);
6881 dplane_ctx_list_init(&zdplane_info
.dg_update_list
);
6882 zns_info_list_init(&zdplane_info
.dg_zns_list
);
6884 zdplane_info
.dg_updates_per_cycle
= DPLANE_DEFAULT_NEW_WORK
;
6886 zdplane_info
.dg_max_queued_updates
= DPLANE_DEFAULT_MAX_QUEUED
;
6888 /* Register default kernel 'provider' during init */
6889 dplane_provider_init();
6893 * Start the dataplane pthread. This step needs to be run later than the
6894 * 'init' step, in case zebra has fork-ed.
6896 void zebra_dplane_start(void)
6898 struct dplane_zns_info
*zi
;
6899 struct zebra_dplane_provider
*prov
;
6900 struct frr_pthread_attr pattr
= {
6901 .start
= frr_pthread_attr_default
.start
,
6902 .stop
= frr_pthread_attr_default
.stop
6905 /* Start dataplane pthread */
6907 zdplane_info
.dg_pthread
= frr_pthread_new(&pattr
, "Zebra dplane thread",
6910 zdplane_info
.dg_master
= zdplane_info
.dg_pthread
->master
;
6912 zdplane_info
.dg_run
= true;
6914 /* Enqueue an initial event for the dataplane pthread */
6915 event_add_event(zdplane_info
.dg_master
, dplane_thread_loop
, NULL
, 0,
6916 &zdplane_info
.dg_t_update
);
6918 /* Enqueue requests and reads if necessary */
6919 frr_each (zns_info_list
, &zdplane_info
.dg_zns_list
, zi
) {
6920 #if defined(HAVE_NETLINK)
6921 event_add_read(zdplane_info
.dg_master
, dplane_incoming_read
, zi
,
6922 zi
->info
.sock
, &zi
->t_read
);
6923 dplane_kernel_info_request(zi
);
6927 /* Call start callbacks for registered providers */
6930 prov
= dplane_prov_list_first(&zdplane_info
.dg_providers
);
6936 (prov
->dp_start
)(prov
);
6938 /* Locate next provider */
6939 prov
= dplane_prov_list_next(&zdplane_info
.dg_providers
, prov
);
6942 frr_pthread_run(zdplane_info
.dg_pthread
, NULL
);
6946 * Initialize the dataplane module at startup; called by zebra rib_init()
6948 void zebra_dplane_init(int (*results_fp
)(struct dplane_ctx_list_head
*))
6950 zebra_dplane_init_internal();
6951 zdplane_info
.dg_results_cb
= results_fp
;