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
);
138 enum dplane_op_e
dplane_ctx_get_op(const dplane_ctx_h ctx
);
139 const char *dplane_op2str(enum dplane_op_e op
);
141 const struct prefix
*dplane_ctx_get_dest(const dplane_ctx_h ctx
);
143 /* Source prefix is a little special - use convention to return NULL
144 * to mean "no src prefix"
146 const struct prefix
*dplane_ctx_get_src(const dplane_ctx_h ctx
);
148 bool dplane_ctx_is_update(const dplane_ctx_h ctx
);
149 uint32_t dplane_ctx_get_seq(const dplane_ctx_h ctx
);
150 uint32_t dplane_ctx_get_old_seq(const dplane_ctx_h ctx
);
151 vrf_id_t
dplane_ctx_get_vrf(const dplane_ctx_h ctx
);
152 int dplane_ctx_get_type(const dplane_ctx_h ctx
);
153 int dplane_ctx_get_old_type(const dplane_ctx_h ctx
);
154 afi_t
dplane_ctx_get_afi(const dplane_ctx_h ctx
);
155 safi_t
dplane_ctx_get_safi(const dplane_ctx_h ctx
);
156 uint32_t dplane_ctx_get_table(const dplane_ctx_h ctx
);
157 route_tag_t
dplane_ctx_get_tag(const dplane_ctx_h ctx
);
158 route_tag_t
dplane_ctx_get_old_tag(const dplane_ctx_h ctx
);
159 uint16_t dplane_ctx_get_instance(const dplane_ctx_h ctx
);
160 uint16_t dplane_ctx_get_old_instance(const dplane_ctx_h ctx
);
161 uint32_t dplane_ctx_get_metric(const dplane_ctx_h ctx
);
162 uint32_t dplane_ctx_get_mtu(const dplane_ctx_h ctx
);
163 uint32_t dplane_ctx_get_nh_mtu(const dplane_ctx_h ctx
);
164 uint8_t dplane_ctx_get_distance(const dplane_ctx_h ctx
);
165 uint8_t dplane_ctx_get_old_distance(const dplane_ctx_h ctx
);
167 const struct nexthop_group
*dplane_ctx_get_ng(const dplane_ctx_h ctx
);
168 const struct zebra_dplane_info
*dplane_ctx_get_ns(const dplane_ctx_h ctx
);
171 * Enqueue route change operations for the dataplane.
173 enum zebra_dplane_result
dplane_route_add(struct route_node
*rn
,
174 struct route_entry
*re
);
176 enum zebra_dplane_result
dplane_route_update(struct route_node
*rn
,
177 struct route_entry
*re
,
178 struct route_entry
*old_re
);
180 enum zebra_dplane_result
dplane_route_delete(struct route_node
*rn
,
181 struct route_entry
*re
);
183 /* Support string name for a dataplane provider */
184 #define DPLANE_PROVIDER_NAMELEN 64
186 /* Priority or ordering values for providers. The idea is that there may be
187 * some pre-processing, followed by an external or remote dataplane,
188 * followed by the kernel, followed by some post-processing step (such as
189 * the fpm output stream.)
191 enum dplane_provider_prio_e
{
192 DPLANE_PRIO_NONE
= 0,
193 DPLANE_PRIO_PREPROCESS
,
194 DPLANE_PRIO_PRE_KERNEL
,
196 DPLANE_PRIO_POSTPROCESS
,
200 /* Provider's entry-point to process a context block */
201 typedef int (*dplane_provider_process_fp
)(dplane_ctx_h ctx
);
203 /* Provider registration */
204 int dplane_provider_register(const char *name
,
205 enum dplane_provider_prio_e prio
,
206 dplane_provider_process_fp fp
);
209 * Results are returned to zebra core via a callback
211 typedef int (*dplane_results_fp
)(const dplane_ctx_h ctx
);
214 * Zebra registers a results callback with the dataplane. The callback is
215 * called in the dataplane thread context, so the expectation is that the
216 * context is queued (or that processing is very limited).
218 int dplane_results_register(dplane_results_fp fp
);
221 * Initialize the dataplane modules at zebra startup.
223 void zebra_dplane_init(void);
225 #endif /* _ZEBRA_DPLANE_H */