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 * Opaque context block 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.
112 typedef struct zebra_dplane_ctx_s
*dplane_ctx_h
;
114 /* Define a tailq list type for context blocks. The list is exposed/public,
115 * but the internal linkage in the context struct is private, so there
116 * are accessor apis that support enqueue and dequeue.
118 TAILQ_HEAD(dplane_ctx_q_s
, zebra_dplane_ctx_s
);
120 /* Return a dataplane results context block after use; the caller's pointer will
123 void dplane_ctx_fini(dplane_ctx_h
*pctx
);
125 /* Enqueue a context block to caller's tailq. This just exists so that the
126 * context struct can remain opaque.
128 void dplane_ctx_enqueue_tail(struct dplane_ctx_q_s
*q
, dplane_ctx_h ctx
);
130 /* Dequeue a context block from the head of caller's tailq */
131 void dplane_ctx_dequeue(struct dplane_ctx_q_s
*q
, dplane_ctx_h
*ctxp
);
134 * Accessors for information from the context object
136 enum zebra_dplane_result
dplane_ctx_get_status(const dplane_ctx_h ctx
);
137 const char *dplane_res2str(enum zebra_dplane_result res
);
139 enum dplane_op_e
dplane_ctx_get_op(const dplane_ctx_h ctx
);
140 const char *dplane_op2str(enum dplane_op_e op
);
142 const struct prefix
*dplane_ctx_get_dest(const dplane_ctx_h ctx
);
144 /* Source prefix is a little special - use convention to return NULL
145 * to mean "no src prefix"
147 const struct prefix
*dplane_ctx_get_src(const dplane_ctx_h ctx
);
149 bool dplane_ctx_is_update(const dplane_ctx_h ctx
);
150 uint32_t dplane_ctx_get_seq(const dplane_ctx_h ctx
);
151 uint32_t dplane_ctx_get_old_seq(const dplane_ctx_h ctx
);
152 vrf_id_t
dplane_ctx_get_vrf(const dplane_ctx_h ctx
);
153 int dplane_ctx_get_type(const dplane_ctx_h ctx
);
154 int dplane_ctx_get_old_type(const dplane_ctx_h ctx
);
155 afi_t
dplane_ctx_get_afi(const dplane_ctx_h ctx
);
156 safi_t
dplane_ctx_get_safi(const dplane_ctx_h ctx
);
157 uint32_t dplane_ctx_get_table(const dplane_ctx_h ctx
);
158 route_tag_t
dplane_ctx_get_tag(const dplane_ctx_h ctx
);
159 route_tag_t
dplane_ctx_get_old_tag(const dplane_ctx_h ctx
);
160 uint16_t dplane_ctx_get_instance(const dplane_ctx_h ctx
);
161 uint16_t dplane_ctx_get_old_instance(const dplane_ctx_h ctx
);
162 uint32_t dplane_ctx_get_metric(const dplane_ctx_h ctx
);
163 uint32_t dplane_ctx_get_old_metric(const dplane_ctx_h ctx
);
164 uint32_t dplane_ctx_get_mtu(const dplane_ctx_h ctx
);
165 uint32_t dplane_ctx_get_nh_mtu(const dplane_ctx_h ctx
);
166 uint8_t dplane_ctx_get_distance(const dplane_ctx_h ctx
);
167 uint8_t dplane_ctx_get_old_distance(const dplane_ctx_h ctx
);
169 const struct nexthop_group
*dplane_ctx_get_ng(const dplane_ctx_h ctx
);
170 const struct zebra_dplane_info
*dplane_ctx_get_ns(const dplane_ctx_h ctx
);
171 const struct nexthop_group
*dplane_ctx_get_old_ng(const dplane_ctx_h ctx
);
174 * Enqueue route change operations for the dataplane.
176 enum zebra_dplane_result
dplane_route_add(struct route_node
*rn
,
177 struct route_entry
*re
);
179 enum zebra_dplane_result
dplane_route_update(struct route_node
*rn
,
180 struct route_entry
*re
,
181 struct route_entry
*old_re
);
183 enum zebra_dplane_result
dplane_route_delete(struct route_node
*rn
,
184 struct route_entry
*re
);
189 int dplane_show_helper(struct vty
*vty
, bool detailed
);
190 int dplane_show_provs_helper(struct vty
*vty
, bool detailed
);
194 * Dataplane providers: modules that consume dataplane events.
197 /* Support string name for a dataplane provider */
198 #define DPLANE_PROVIDER_NAMELEN 64
200 /* Priority or ordering values for providers. The idea is that there may be
201 * some pre-processing, followed by an external or remote dataplane,
202 * followed by the kernel, followed by some post-processing step (such as
203 * the fpm output stream.)
205 enum dplane_provider_prio_e
{
206 DPLANE_PRIO_NONE
= 0,
207 DPLANE_PRIO_PREPROCESS
,
208 DPLANE_PRIO_PRE_KERNEL
,
210 DPLANE_PRIO_POSTPROCESS
,
214 /* Provider's entry-point to process a context block */
215 typedef int (*dplane_provider_process_fp
)(dplane_ctx_h ctx
);
217 /* Provider's entry-point for shutdown and cleanup */
218 typedef int (*dplane_provider_fini_fp
)(void);
220 /* Provider registration */
221 int dplane_provider_register(const char *name
,
222 enum dplane_provider_prio_e prio
,
223 dplane_provider_process_fp fp
,
224 dplane_provider_fini_fp fini_fp
);
227 * Results are returned to zebra core via a callback
229 typedef int (*dplane_results_fp
)(const dplane_ctx_h ctx
);
232 * Zebra registers a results callback with the dataplane. The callback is
233 * called in the dataplane thread context, so the expectation is that the
234 * context is queued (or that processing is very limited).
236 int dplane_results_register(dplane_results_fp fp
);
239 * Initialize the dataplane modules at zebra startup. This is currently called
242 void zebra_dplane_init(void);
244 /* Finalize/cleanup api, called quite late during zebra shutdown.
245 * Zebra expects to try to clean up all vrfs and all routes during
246 * shutdown, so the dplane must be available until very late.
248 void zebra_dplane_finish(void);
250 #endif /* _ZEBRA_DPLANE_H */