FD.io VPP
v18.01-8-g0eacf49
Vector Packet Processing
Main Page
Related Pages
Modules
Namespaces
Data Structures
Source
Files
Symbols
FD.io VPP
Vector Packet Processing
Release Notes
Debug CLI
Startup Configuration
Todo List
Node Identifiers
Modules
Namespaces
Data Structures
Source
Files
Symbols
•
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
Modules
Pages
api_helper_macros.h
Go to the documentation of this file.
1
/*
2
*------------------------------------------------------------------
3
* api_helper_macros.h - message handler helper macros
4
*
5
* Copyright (c) 2016 Cisco and/or its affiliates.
6
* Licensed under the Apache License, Version 2.0 (the "License");
7
* you may not use this file except in compliance with the License.
8
* You may obtain a copy of the License at:
9
*
10
* http://www.apache.org/licenses/LICENSE-2.0
11
*
12
* Unless required by applicable law or agreed to in writing, software
13
* distributed under the License is distributed on an "AS IS" BASIS,
14
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15
* See the License for the specific language governing permissions and
16
* limitations under the License.
17
*------------------------------------------------------------------
18
*/
19
20
#ifndef __api_helper_macros_h__
21
#define __api_helper_macros_h__
22
23
#define f64_endian(a)
24
#define f64_print(a,b)
25
26
#ifndef REPLY_MSG_ID_BASE
27
#define REPLY_MSG_ID_BASE 0
28
#endif
29
30
#define REPLY_MACRO(t) \
31
do { \
32
vl_api_registration_t *rp; \
33
rv = vl_msg_api_pd_handler (mp, rv); \
34
rp = vl_api_client_index_to_registration (mp->client_index); \
35
if (rp == 0) \
36
return; \
37
\
38
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
39
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
40
rmp->context = mp->context; \
41
rmp->retval = ntohl(rv); \
42
\
43
vl_msg_api_send (rp, (u8 *)rmp); \
44
} while(0);
45
46
#define REPLY_MACRO2(t, body) \
47
do { \
48
vl_api_registration_t *rp; \
49
rv = vl_msg_api_pd_handler (mp, rv); \
50
rp = vl_api_client_index_to_registration (mp->client_index); \
51
if (rp == 0) \
52
return; \
53
\
54
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
55
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
56
rmp->context = mp->context; \
57
rmp->retval = ntohl(rv); \
58
do {body;} while (0); \
59
vl_msg_api_send (rp, (u8 *)rmp); \
60
} while(0);
61
62
#define REPLY_MACRO3(t, n, body) \
63
do { \
64
vl_api_registration_t *rp; \
65
rv = vl_msg_api_pd_handler (mp, rv); \
66
rp = vl_api_client_index_to_registration (mp->client_index); \
67
if (rp == 0) \
68
return; \
69
\
70
rmp = vl_msg_api_alloc (sizeof (*rmp) + n); \
71
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
72
rmp->context = mp->context; \
73
rmp->retval = ntohl(rv); \
74
do {body;} while (0); \
75
vl_msg_api_send (rp, (u8 *)rmp); \
76
} while(0);
77
78
#define REPLY_MACRO4(t, n, body) \
79
do { \
80
vl_api_registration_t *rp; \
81
u8 is_error = 0; \
82
rv = vl_msg_api_pd_handler (mp, rv); \
83
\
84
rp = vl_api_client_index_to_registration (mp->client_index); \
85
if (rp == 0) \
86
return; \
87
\
88
rmp = vl_msg_api_alloc_or_null (sizeof (*rmp) + n); \
89
if (!rmp) \
90
{ \
91
/* if there isn't enough memory, try to allocate */
\
92
/* some at least for returning an error */
\
93
rmp = vl_msg_api_alloc (sizeof (*rmp)); \
94
if (!rmp) \
95
return; \
96
\
97
memset (rmp, 0, sizeof (*rmp)); \
98
rv = VNET_API_ERROR_TABLE_TOO_BIG; \
99
is_error = 1; \
100
} \
101
rmp->_vl_msg_id = htons((t)+(REPLY_MSG_ID_BASE)); \
102
rmp->context = mp->context; \
103
rmp->retval = ntohl(rv); \
104
if (!is_error) \
105
do {body;} while (0); \
106
vl_msg_api_send (rp, (u8 *)rmp); \
107
} while(0);
108
109
/* "trust, but verify" */
110
111
static
inline
uword
112
vnet_sw_if_index_is_api_valid
(
u32
sw_if_index)
113
{
114
return
vnet_sw_interface_is_api_valid
(
vnet_get_main
(), sw_if_index);
115
}
116
117
#define VALIDATE_SW_IF_INDEX(mp) \
118
do { u32 __sw_if_index = ntohl(mp->sw_if_index); \
119
if (!vnet_sw_if_index_is_api_valid(__sw_if_index)) { \
120
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
121
goto bad_sw_if_index; \
122
} \
123
} while(0);
124
125
#define BAD_SW_IF_INDEX_LABEL \
126
do { \
127
bad_sw_if_index: \
128
; \
129
} while (0);
130
131
#define VALIDATE_RX_SW_IF_INDEX(mp) \
132
do { u32 __rx_sw_if_index = ntohl(mp->rx_sw_if_index); \
133
if (!vnet_sw_if_index_is_api_valid(__rx_sw_if_index)) { \
134
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
135
goto bad_rx_sw_if_index; \
136
} \
137
} while(0);
138
139
#define BAD_RX_SW_IF_INDEX_LABEL \
140
do { \
141
bad_rx_sw_if_index: \
142
; \
143
} while (0);
144
145
#define VALIDATE_TX_SW_IF_INDEX(mp) \
146
do { u32 __tx_sw_if_index = ntohl(mp->tx_sw_if_index); \
147
if (!vnet_sw_if_index_is_api_valid(__tx_sw_if_index)) { \
148
rv = VNET_API_ERROR_INVALID_SW_IF_INDEX; \
149
goto bad_tx_sw_if_index; \
150
} \
151
} while(0);
152
153
#define BAD_TX_SW_IF_INDEX_LABEL \
154
do { \
155
bad_tx_sw_if_index: \
156
; \
157
} while (0);
158
159
#define VALIDATE_BD_ID(mp) \
160
do { u32 __rx_bd_id = ntohl(mp->bd_id); \
161
if (__rx_bd_id > L2_BD_ID_MAX) { \
162
rv = VNET_API_ERROR_BD_ID_EXCEED_MAX; \
163
goto bad_bd_id; \
164
} \
165
} while(0);
166
167
#define BAD_BD_ID_LABEL \
168
do { \
169
bad_bd_id: \
170
; \
171
} while (0);
172
173
#define pub_sub_handler(lca,UCA) \
174
static void vl_api_want_##lca##_t_handler ( \
175
vl_api_want_##lca##_t *mp) \
176
{ \
177
vpe_api_main_t *vam = &vpe_api_main; \
178
vpe_client_registration_t *rp; \
179
vl_api_want_##lca##_reply_t *rmp; \
180
uword *p; \
181
i32 rv = 0; \
182
\
183
p = hash_get (vam->lca##_registration_hash, mp->client_index); \
184
if (p) { \
185
if (mp->enable_disable) { \
186
clib_warning ("pid %d: already enabled...", mp->pid); \
187
rv = VNET_API_ERROR_INVALID_REGISTRATION; \
188
goto reply; \
189
} else { \
190
rp = pool_elt_at_index (vam->lca##_registrations, p[0]); \
191
pool_put (vam->lca##_registrations, rp); \
192
hash_unset (vam->lca##_registration_hash, \
193
mp->client_index); \
194
goto reply; \
195
} \
196
} \
197
if (mp->enable_disable == 0) { \
198
clib_warning ("pid %d: already disabled...", mp->pid); \
199
rv = VNET_API_ERROR_INVALID_REGISTRATION; \
200
goto reply; \
201
} \
202
pool_get (vam->lca##_registrations, rp); \
203
rp->client_index = mp->client_index; \
204
rp->client_pid = mp->pid; \
205
hash_set (vam->lca##_registration_hash, rp->client_index, \
206
rp - vam->lca##_registrations); \
207
\
208
reply: \
209
REPLY_MACRO (VL_API_WANT_##UCA##_REPLY); \
210
}
211
212
#define foreach_registration_hash \
213
_(interface_events) \
214
_(to_netconf_server) \
215
_(from_netconf_server) \
216
_(to_netconf_client) \
217
_(from_netconf_client) \
218
_(oam_events) \
219
_(bfd_events) \
220
_(wc_ip6_nd_events) \
221
_(wc_ip4_arp_events)
222
223
typedef
struct
224
{
225
u32
client_index
;
/* in memclnt registration pool */
226
u32
client_pid
;
227
}
vpe_client_registration_t
;
228
229
struct
_vl_api_ip4_arp_event;
230
struct
_vl_api_ip6_nd_event;
231
232
typedef
struct
233
{
234
#define _(a) uword *a##_registration_hash; \
235
vpe_client_registration_t * a##_registrations;
236
foreach_registration_hash
237
#undef _
238
/* notifications happen really early in the game */
239
u8
link_state_process_up
;
240
241
/* ip4 arp event registration pool */
242
struct
_vl_api_ip4_arp_event *
arp_events
;
243
244
/* ip6 nd event registration pool */
245
struct
_vl_api_ip6_nd_event *
nd_events
;
246
247
/* convenience */
248
vlib_main_t
*
vlib_main
;
249
vnet_main_t
*
vnet_main
;
250
}
vpe_api_main_t
;
251
252
extern
vpe_api_main_t
vpe_api_main
;
253
254
#endif
/* __api_helper_macros_h__ */
255
256
/*
257
* fd.io coding-style-patch-verification: ON
258
*
259
* Local Variables:
260
* eval: (c-set-style "gnu")
261
* End:
262
*/
vpe_api_main_t::vnet_main
vnet_main_t * vnet_main
Definition:
api_helper_macros.h:249
vpe_api_main_t
Definition:
api_helper_macros.h:232
vnet_get_main
vnet_main_t * vnet_get_main(void)
Definition:
misc.c:47
vpe_api_main_t::vlib_main
vlib_main_t * vlib_main
Definition:
api_helper_macros.h:248
vpe_api_main_t::arp_events
struct _vl_api_ip4_arp_event * arp_events
Definition:
api_helper_macros.h:242
vpe_client_registration_t::client_pid
u32 client_pid
Definition:
api_helper_macros.h:226
vpe_api_main_t::nd_events
struct _vl_api_ip6_nd_event * nd_events
Definition:
api_helper_macros.h:245
vnet_sw_if_index_is_api_valid
static uword vnet_sw_if_index_is_api_valid(u32 sw_if_index)
Definition:
api_helper_macros.h:112
vnet_main_t
Definition:
vnet.h:51
vpe_api_main_t::link_state_process_up
foreach_registration_hash u8 link_state_process_up
Definition:
api_helper_macros.h:239
u32
unsigned int u32
Definition:
types.h:88
vpe_client_registration_t
Definition:
api_helper_macros.h:223
uword
u64 uword
Definition:
types.h:112
vnet_sw_interface_is_api_valid
static uword vnet_sw_interface_is_api_valid(vnet_main_t *vnm, u32 sw_if_index)
Definition:
interface_funcs.h:208
u8
unsigned char u8
Definition:
types.h:56
vlib_main_t
Definition:
main.h:59
vpe_client_registration_t::client_index
u32 client_index
Definition:
api_helper_macros.h:225
vpe_api_main
vpe_api_main_t vpe_api_main
Definition:
interface_api.c:49
foreach_registration_hash
#define foreach_registration_hash
Definition:
api_helper_macros.h:212
src
vlibapi
api_helper_macros.h
Generated on Wed Feb 7 2018 04:45:49 for FD.io VPP by
1.8.11