2 * Zebra dataplane layer api interfaces.
3 * Copyright (c) 2018 Volta Networks, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; see the file COPYING; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #ifndef _ZEBRA_DPLANE_H
21 #define _ZEBRA_DPLANE_H 1
23 #include "lib/zebra.h"
24 #include "lib/prefix.h"
25 #include "lib/nexthop.h"
26 #include "lib/nexthop_group.h"
27 #include "lib/openbsd-queue.h"
28 #include "zebra/zebra_ns.h"
29 #include "zebra/rib.h"
30 #include "zebra/zserv.h"
33 /* Key netlink info from zebra ns */
34 struct zebra_dplane_info
{
37 #if defined(HAVE_NETLINK)
43 /* Utility to fill in zns info from main zns struct */
45 zebra_dplane_info_from_zns(struct zebra_dplane_info
*zns_info
,
46 const struct zebra_ns
*zns
, bool is_cmd
)
48 zns_info
->ns_id
= zns
->ns_id
;
50 #if defined(HAVE_NETLINK)
51 zns_info
->is_cmd
= is_cmd
;
53 zns_info
->nls
= zns
->netlink_cmd
;
55 zns_info
->nls
= zns
->netlink
;
61 * Result codes used when returning status back to the main zebra context.
67 * Flags being SET/UNSET do not belong in the South Bound
68 * Interface. This Setting belongs at the calling level
69 * because we can and will have multiple different interfaces
70 * and we will have potentially multiple different
71 * modules/filters to call. As such Setting/Unsetting
72 * success failure should be handled by the caller.
74 enum zebra_dplane_status
{
75 ZEBRA_DPLANE_STATUS_NONE
= 0,
76 ZEBRA_DPLANE_INSTALL_SUCCESS
,
77 ZEBRA_DPLANE_INSTALL_FAILURE
,
78 ZEBRA_DPLANE_DELETE_SUCCESS
,
79 ZEBRA_DPLANE_DELETE_FAILURE
,
83 enum zebra_dplane_result
{
84 ZEBRA_DPLANE_REQUEST_QUEUED
,
85 ZEBRA_DPLANE_REQUEST_SUCCESS
,
86 ZEBRA_DPLANE_REQUEST_FAILURE
,
90 * API between the zebra dataplane system and the main zebra processing
95 * Enqueue a route install or update for the dataplane.
101 DPLANE_OP_ROUTE_INSTALL
,
102 DPLANE_OP_ROUTE_UPDATE
,
103 DPLANE_OP_ROUTE_DELETE
,
108 * The dataplane context struct is used to exchange info between the main zebra
109 * context and the dataplane module(s). If these are two independent pthreads,
110 * they cannot share existing global data structures safely.
113 /* Define a tailq list type for context blocks. The list is exposed/public,
114 * but the internal linkage in the context struct is private, so there
115 * are accessor apis that support enqueue and dequeue.
117 TAILQ_HEAD(dplane_ctx_q
, zebra_dplane_ctx
);
119 /* Return a dataplane results context block after use; the caller's pointer will
122 void dplane_ctx_fini(struct zebra_dplane_ctx
**pctx
);
124 /* Enqueue a context block to caller's tailq. This just exists so that the
125 * context struct can remain opaque.
127 void dplane_ctx_enqueue_tail(struct dplane_ctx_q
*q
,
128 const struct zebra_dplane_ctx
*ctx
);
130 /* Dequeue a context block from the head of caller's tailq */
131 void dplane_ctx_dequeue(struct dplane_ctx_q
*q
, struct zebra_dplane_ctx
**ctxp
);
134 * Accessors for information from the context object
136 enum zebra_dplane_result
dplane_ctx_get_status(
137 const struct zebra_dplane_ctx
*ctx
);
138 const char *dplane_res2str(enum zebra_dplane_result res
);
140 enum dplane_op_e
dplane_ctx_get_op(const struct zebra_dplane_ctx
*ctx
);
141 const char *dplane_op2str(enum dplane_op_e op
);
143 const struct prefix
*dplane_ctx_get_dest(const struct zebra_dplane_ctx
*ctx
);
145 /* Source prefix is a little special - use convention to return NULL
146 * to mean "no src prefix"
148 const struct prefix
*dplane_ctx_get_src(const struct zebra_dplane_ctx
*ctx
);
150 bool dplane_ctx_is_update(const struct zebra_dplane_ctx
*ctx
);
151 uint32_t dplane_ctx_get_seq(const struct zebra_dplane_ctx
*ctx
);
152 uint32_t dplane_ctx_get_old_seq(const struct zebra_dplane_ctx
*ctx
);
153 vrf_id_t
dplane_ctx_get_vrf(const struct zebra_dplane_ctx
*ctx
);
154 int dplane_ctx_get_type(const struct zebra_dplane_ctx
*ctx
);
155 int dplane_ctx_get_old_type(const struct zebra_dplane_ctx
*ctx
);
156 afi_t
dplane_ctx_get_afi(const struct zebra_dplane_ctx
*ctx
);
157 safi_t
dplane_ctx_get_safi(const struct zebra_dplane_ctx
*ctx
);
158 uint32_t dplane_ctx_get_table(const struct zebra_dplane_ctx
*ctx
);
159 route_tag_t
dplane_ctx_get_tag(const struct zebra_dplane_ctx
*ctx
);
160 route_tag_t
dplane_ctx_get_old_tag(const struct zebra_dplane_ctx
*ctx
);
161 uint16_t dplane_ctx_get_instance(const struct zebra_dplane_ctx
*ctx
);
162 uint16_t dplane_ctx_get_old_instance(const struct zebra_dplane_ctx
*ctx
);
163 uint32_t dplane_ctx_get_metric(const struct zebra_dplane_ctx
*ctx
);
164 uint32_t dplane_ctx_get_old_metric(const struct zebra_dplane_ctx
*ctx
);
165 uint32_t dplane_ctx_get_mtu(const struct zebra_dplane_ctx
*ctx
);
166 uint32_t dplane_ctx_get_nh_mtu(const struct zebra_dplane_ctx
*ctx
);
167 uint8_t dplane_ctx_get_distance(const struct zebra_dplane_ctx
*ctx
);
168 uint8_t dplane_ctx_get_old_distance(const struct zebra_dplane_ctx
*ctx
);
170 const struct nexthop_group
*dplane_ctx_get_ng(
171 const struct zebra_dplane_ctx
*ctx
);
172 const struct nexthop_group
*dplane_ctx_get_old_ng(
173 const struct zebra_dplane_ctx
*ctx
);
175 const struct zebra_dplane_info
*dplane_ctx_get_ns(
176 const struct zebra_dplane_ctx
*ctx
);
178 /* Indicates zebra shutdown/exit is in progress. Some operations may be
179 * simplified or skipped during shutdown processing.
181 bool dplane_is_in_shutdown(void);
184 * Enqueue route change operations for the dataplane.
186 enum zebra_dplane_result
dplane_route_add(struct route_node
*rn
,
187 struct route_entry
*re
);
189 enum zebra_dplane_result
dplane_route_update(struct route_node
*rn
,
190 struct route_entry
*re
,
191 struct route_entry
*old_re
);
193 enum zebra_dplane_result
dplane_route_delete(struct route_node
*rn
,
194 struct route_entry
*re
);
196 /* Retrieve the limit on the number of pending, unprocessed updates. */
197 uint32_t dplane_get_in_queue_limit(void);
199 /* Configure limit on the number of pending, queued updates. If 'unset', reset
202 void dplane_set_in_queue_limit(uint32_t limit
, bool set
);
204 /* Retrieve the current queue depth of incoming, unprocessed updates */
205 uint32_t dplane_get_in_queue_len(void);
210 int dplane_show_helper(struct vty
*vty
, bool detailed
);
211 int dplane_show_provs_helper(struct vty
*vty
, bool detailed
);
215 * Dataplane providers: modules that consume dataplane events.
218 /* Support string name for a dataplane provider */
219 #define DPLANE_PROVIDER_NAMELEN 64
221 /* Priority or ordering values for providers. The idea is that there may be
222 * some pre-processing, followed by an external or remote dataplane,
223 * followed by the kernel, followed by some post-processing step (such as
224 * the fpm output stream.)
226 enum dplane_provider_prio_e
{
227 DPLANE_PRIO_NONE
= 0,
228 DPLANE_PRIO_PREPROCESS
,
229 DPLANE_PRIO_PRE_KERNEL
,
231 DPLANE_PRIO_POSTPROCESS
,
235 /* Provider's entry-point to process a context block */
236 typedef int (*dplane_provider_process_fp
)(struct zebra_dplane_ctx
*ctx
);
238 /* Provider's entry-point for shutdown and cleanup */
239 typedef int (*dplane_provider_fini_fp
)(void);
241 /* Provider registration */
242 int dplane_provider_register(const char *name
,
243 enum dplane_provider_prio_e prio
,
244 dplane_provider_process_fp fp
,
245 dplane_provider_fini_fp fini_fp
);
248 * Results are returned to zebra core via a callback
250 typedef int (*dplane_results_fp
)(const struct zebra_dplane_ctx
*ctx
);
253 * Zebra registers a results callback with the dataplane. The callback is
254 * called in the dataplane thread context, so the expectation is that the
255 * context is queued (or that processing is very limited).
257 int dplane_results_register(dplane_results_fp fp
);
260 * Initialize the dataplane modules at zebra startup. This is currently called
263 void zebra_dplane_init(void);
265 /* Finalize/cleanup apis, one called early as shutdown is starting,
266 * one called late at the end of zebra shutdown, and then one called
267 * from the zebra main thread to stop the dplane thread free all resources.
269 * Zebra expects to try to clean up all vrfs and all routes during
270 * shutdown, so the dplane must be available until very late.
272 void zebra_dplane_pre_finish(void);
273 void zebra_dplane_finish(void);
274 void zebra_dplane_shutdown(void);
276 #endif /* _ZEBRA_DPLANE_H */