FD.io VPP  v17.01.1-3-gc6833f8
Vector Packet Processing
vxlan_gpe_api.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /*
16  *------------------------------------------------------------------
17  * vxlan_gpe_api.c - iOAM VxLAN-GPE related APIs to create
18  * and maintain profiles
19  *------------------------------------------------------------------
20  */
21 
22 #include <vnet/vnet.h>
23 #include <vnet/plugin/plugin.h>
25 
26 #include <vlibapi/api.h>
27 #include <vlibmemory/api.h>
28 #include <vlibsocket/api.h>
29 
30 /* define message IDs */
32 
33 /* define message structures */
34 #define vl_typedefs
36 #undef vl_typedefs
37 
38 /* define generated endian-swappers */
39 #define vl_endianfun
41 #undef vl_endianfun
42 
43 /* instantiate all the print functions we know about */
44 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
45 #define vl_printfun
47 #undef vl_printfun
48 
49 /* Get the API version number */
50 #define vl_api_version(n,v) static u32 api_version=(v);
52 #undef vl_api_version
53 
54 /*
55  * A handy macro to set up a message reply.
56  * Assumes that the following variables are available:
57  * mp - pointer to request message
58  * rmp - pointer to reply message type
59  * rv - return value
60  */
61 
62 #define VXLAN_GPE_REPLY_MACRO(t) \
63 do { \
64  unix_shared_memory_queue_t * q = \
65  vl_api_client_index_to_input_queue (mp->client_index); \
66  if (!q) \
67  return; \
68  \
69  rmp = vl_msg_api_alloc (sizeof (*rmp)); \
70  rmp->_vl_msg_id = ntohs((t)+sm->msg_id_base); \
71  rmp->context = mp->context; \
72  rmp->retval = ntohl(rv); \
73  \
74  vl_msg_api_send_shmem (q, (u8 *)&rmp); \
75 } while(0);
76 
77 /* *INDENT-OFF* */
78 #define VXLAN_GPE_REPLY_MACRO2(t, body) \
79 do { \
80  unix_shared_memory_queue_t * q; \
81  rv = vl_msg_api_pd_handler (mp, rv); \
82  q = vl_api_client_index_to_input_queue (mp->client_index); \
83  if (!q) \
84  return; \
85  \
86  rmp = vl_msg_api_alloc (sizeof (*rmp)); \
87  rmp->_vl_msg_id = ntohs((t)); \
88  rmp->context = mp->context; \
89  rmp->retval = ntohl(rv); \
90  do {body;} while (0); \
91  vl_msg_api_send_shmem (q, (u8 *)&rmp); \
92 } while(0);
93 /* *INDENT-ON* */
94 
95 /* List of message types that this plugin understands */
96 
97 #define foreach_vxlan_gpe_plugin_api_msg \
98 _(VXLAN_GPE_IOAM_ENABLE, vxlan_gpe_ioam_enable) \
99 _(VXLAN_GPE_IOAM_DISABLE, vxlan_gpe_ioam_disable) \
100 _(VXLAN_GPE_IOAM_VNI_ENABLE, vxlan_gpe_ioam_vni_enable) \
101 _(VXLAN_GPE_IOAM_VNI_DISABLE, vxlan_gpe_ioam_vni_disable) \
102 _(VXLAN_GPE_IOAM_TRANSIT_ENABLE, vxlan_gpe_ioam_transit_enable) \
103 _(VXLAN_GPE_IOAM_TRANSIT_DISABLE, vxlan_gpe_ioam_transit_disable) \
104 
105 
108 {
109  int rv = 0;
111  clib_error_t *error;
113 
114  /* Ignoring the profile id as currently a single profile
115  * is supported */
116  error =
118  if (error)
119  {
120  clib_error_report (error);
121  rv = clib_error_get_code (error);
122  }
123 
124  VXLAN_GPE_REPLY_MACRO (VL_API_VXLAN_GPE_IOAM_ENABLE_REPLY);
125 }
126 
129 {
130  int rv = 0;
132  clib_error_t *error;
134 
135  /* Ignoring the profile id as currently a single profile
136  * is supported */
137  error = vxlan_gpe_ioam_disable (0, 0, 0);
138  if (error)
139  {
140  clib_error_report (error);
141  rv = clib_error_get_code (error);
142  }
143 
144  VXLAN_GPE_REPLY_MACRO (VL_API_VXLAN_GPE_IOAM_DISABLE_REPLY);
145 }
146 
149 {
150  int rv = 0;
152  clib_error_t *error;
154  vxlan4_gpe_tunnel_key_t key4;
155  uword *p = NULL;
157  vxlan_gpe_tunnel_t *t = 0;
159  u32 vni;
160 
161 
162  if (!mp->is_ipv6)
163  {
164  clib_memcpy (&key4.local, &mp->local, sizeof (key4.local));
165  clib_memcpy (&key4.remote, &mp->remote, sizeof (key4.remote));
166  vni = clib_net_to_host_u32 (mp->vni);
167  key4.vni = clib_host_to_net_u32 (vni << 8);
168  key4.pad = 0;
169 
170  p = hash_get_mem (gm->vxlan4_gpe_tunnel_by_key, &key4);
171  }
172  else
173  {
174  return;
175  }
176 
177  if (!p)
178  return;
179 
180  t = pool_elt_at_index (gm->tunnels, p[0]);
181 
182  error = vxlan_gpe_ioam_set (t, hm->has_trace_option,
183  hm->has_pot_option,
184  hm->has_ppc_option, mp->is_ipv6);
185 
186 
187  if (error)
188  {
189  clib_error_report (error);
190  rv = clib_error_get_code (error);
191  }
192 
193  VXLAN_GPE_REPLY_MACRO (VL_API_VXLAN_GPE_IOAM_VNI_ENABLE_REPLY);
194 }
195 
196 
199 {
200  int rv = 0;
202  clib_error_t *error;
204  vxlan4_gpe_tunnel_key_t key4;
205  uword *p = NULL;
207  vxlan_gpe_tunnel_t *t = 0;
208  u32 vni;
209 
210 
211  if (!mp->is_ipv6)
212  {
213  clib_memcpy (&key4.local, &mp->local, sizeof (key4.local));
214  clib_memcpy (&key4.remote, &mp->remote, sizeof (key4.remote));
215  vni = clib_net_to_host_u32 (mp->vni);
216  key4.vni = clib_host_to_net_u32 (vni << 8);
217  key4.pad = 0;
218 
219  p = hash_get_mem (gm->vxlan4_gpe_tunnel_by_key, &key4);
220  }
221  else
222  {
223  return;
224  }
225 
226  if (!p)
227  return;
228 
229  t = pool_elt_at_index (gm->tunnels, p[0]);
230 
231  error = vxlan_gpe_ioam_clear (t, 0, 0, 0, 0);
232 
233 
234  if (error)
235  {
236  clib_error_report (error);
237  rv = clib_error_get_code (error);
238  }
239 
240 
241  VXLAN_GPE_REPLY_MACRO (VL_API_VXLAN_GPE_IOAM_VNI_DISABLE_REPLY);
242 }
243 
246 {
247  int rv = 0;
250  ip46_address_t dst_addr;
251 
252  memset (&dst_addr.ip4, 0, sizeof (dst_addr.ip4));
253  if (!mp->is_ipv6)
254  {
255  clib_memcpy (&dst_addr.ip4, &mp->dst_addr, sizeof (dst_addr.ip4));
256  }
258  dst_addr,
259  ntohl (mp->outer_fib_index),
260  mp->is_ipv6 ? 0 : 1,
261  1 /* is_add */ );
262 
263  VXLAN_GPE_REPLY_MACRO (VL_API_VXLAN_GPE_IOAM_TRANSIT_ENABLE_REPLY);
264 }
265 
268 {
269  int rv = 0;
272  ip46_address_t dst_addr;
273 
274  memset (&dst_addr.ip4, 0, sizeof (dst_addr.ip4));
275  if (!mp->is_ipv6)
276  {
277  clib_memcpy (&dst_addr.ip4, &mp->dst_addr, sizeof (dst_addr.ip4));
278  }
279 
281  dst_addr,
282  ntohl (mp->outer_fib_index),
283  mp->is_ipv6 ? 0 : 1);
284  VXLAN_GPE_REPLY_MACRO (VL_API_VXLAN_GPE_IOAM_TRANSIT_DISABLE_REPLY);
285 }
286 
287 /* Set up the API message handling tables */
288 static clib_error_t *
290 {
292 #define _(N,n) \
293  vl_msg_api_set_handlers((VL_API_##N + sm->msg_id_base), \
294  #n, \
295  vl_api_##n##_t_handler, \
296  vl_noop_handler, \
297  vl_api_##n##_t_endian, \
298  vl_api_##n##_t_print, \
299  sizeof(vl_api_##n##_t), 1);
301 #undef _
302 
303  return 0;
304 }
305 
306 static clib_error_t *
308 {
310  clib_error_t *error = 0;
311  u8 *name;
312  u32 encap_node_index = vxlan_gpe_encap_ioam_v4_node.index;
313  u32 decap_node_index = vxlan_gpe_decap_ioam_v4_node.index;
315  vlib_node_t *vxlan_gpe_decap_node = NULL;
316  uword next_node = 0;
317 
318  sm->vlib_main = vm;
319  sm->vnet_main = vnet_get_main ();
320  sm->unix_time_0 = (u32) time (0); /* Store starting time */
321  sm->vlib_time_0 = vlib_time_now (vm);
322 
323  name = format (0, "ioam_vxlan_gpe_%08x%c", api_version, 0);
324 
325  /* Ask for a correctly-sized block of API message decode slots */
327  ((char *) name, VL_MSG_FIRST_AVAILABLE);
328 
329  error = vxlan_gpe_plugin_api_hookup (vm);
330 
331  /* Hook the ioam-encap node to vxlan-gpe-encap */
332  vxlan_gpe_encap_node = vlib_get_node_by_name (vm, (u8 *) "vxlan-gpe-encap");
333  sm->encap_v4_next_node =
334  vlib_node_add_next (vm, vxlan_gpe_encap_node->index, encap_node_index);
335 
336  vxlan_gpe_decap_node =
337  vlib_get_node_by_name (vm, (u8 *) "vxlan4-gpe-input");
338  next_node =
339  vlib_node_add_next (vm, vxlan_gpe_decap_node->index, decap_node_index);
340  vxlan_gpe_register_decap_protocol (VXLAN_GPE_PROTOCOL_IOAM, next_node);
341 
343  sm->dst_by_ip4 = hash_create_mem (0, sizeof (fib_prefix_t), sizeof (uword));
344 
345  sm->dst_by_ip6 = hash_create_mem (0, sizeof (fib_prefix_t), sizeof (uword));
346 
348  vec_free (name);
349 
350  return error;
351 }
352 
354 
355 /*
356  * fd.io coding-style-patch-verification: ON
357  *
358  * Local Variables:
359  * eval: (c-set-style "gnu")
360  * End:
361  */
Reply to enable iOAM for VXLAN-GPE transit.
Definition: vxlan_gpe.api:148
clib_error_t * vxlan_gpe_ioam_enable(int has_trace_option, int has_pot_option, int has_ppc_option)
Disable iOAM for VXLAN-GPE transit.
Definition: vxlan_gpe.api:161
vxlan_gpe_ioam disable response
Definition: vxlan_gpe.api:62
vlib_main_t * vlib_main
State convenience vlib_main_t.
vlib_node_registration_t vxlan_gpe_decap_ioam_v4_node
(constructor) VLIB_REGISTER_NODE (vxlan_gpe_decap_ioam_v4_node)
Definition: ioam_decap.c:197
iOAM for VxLAN-GPE disable
Definition: vxlan_gpe.api:51
Reply to disable iOAM for VXLAN-GPE transit.
Definition: vxlan_gpe.api:175
#define NULL
Definition: clib.h:55
u32 index
Definition: node.h:237
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:182
int vxlan_gpe_enable_disable_ioam_for_dest(vlib_main_t *vm, ip46_address_t dst_addr, u32 outer_fib_index, u8 is_ipv4, u8 is_add)
vxlan_gpe_ioam_sw_interface_t * sw_interfaces
iOAM Over VxLAN-GPE - Set iOAM transport for VXLAN-GPE reply
Definition: vxlan_gpe.api:40
static clib_error_t * vxlan_gpe_init(vlib_main_t *vm)
clib_error_t * vxlan_gpe_ioam_clear(vxlan_gpe_tunnel_t *t, int has_trace_option, int has_pot_option, int has_ppc_option, u8 ipv6_set)
#define clib_error_report(e)
Definition: error.h:125
void vxlan_gpe_ioam_interface_init(void)
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1063
Reply to enable iOAM for a VNI (VXLAN-GPE)
Definition: vxlan_gpe.api:91
iOAM Over VxLAN-GPE - Set iOAM transport for VxLAN-GPE
Definition: vxlan_gpe.api:27
vlib_node_registration_t vxlan_gpe_encap_ioam_v4_node
(constructor) VLIB_REGISTER_NODE (vxlan_gpe_encap_ioam_v4_node)
Definition: ioam_encap.c:168
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
clib_error_t * vxlan_gpe_ioam_disable(int has_trace_option, int has_pot_option, int has_ppc_option)
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
#define vec_new(T, N)
Create new vector of given type and length (unspecified alignment, no header).
Definition: vec.h:270
int vxlan_gpe_ioam_disable_for_dest(vlib_main_t *vm, ip46_address_t dst_addr, u32 outer_fib_index, u8 ipv4_set)
vxlan_gpe_ioam_main_t vxlan_gpe_ioam_main
Aggregrate type for a prefix.
Definition: fib_types.h:145
#define VXLAN_GPE_REPLY_MACRO(t)
Definition: vxlan_gpe_api.c:62
void vxlan_gpe_register_decap_protocol(u8 protocol_id, uword next_node_index)
Definition: decap.c:645
Disable iOAM for a VNI (VXLAN-GPE)
Definition: vxlan_gpe.api:105
Enable iOAM for a VXLAN-GPE transit.
Definition: vxlan_gpe.api:134
#define hash_create_mem(elts, key_bytes, value_bytes)
Definition: hash.h:637
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:369
#define clib_error_get_code(err)
Definition: error.h:89
Struct for VXLAN GPE tunnel.
Definition: vxlan_gpe.h:90
vxlan_gpe_main_t vxlan_gpe_main
Definition: vxlan_gpe.c:24
static void vl_api_vxlan_gpe_ioam_enable_t_handler(vl_api_vxlan_gpe_ioam_enable_t *mp)
static void vl_api_vxlan_gpe_ioam_transit_disable_t_handler(vl_api_vxlan_gpe_ioam_transit_disable_t *mp)
clib_error_t * vxlan_gpe_ioam_set(vxlan_gpe_tunnel_t *t, int has_trace_option, int has_pot_option, int has_ppc_option, u8 ipv6_set)
static void vl_api_vxlan_gpe_ioam_transit_enable_t_handler(vl_api_vxlan_gpe_ioam_transit_enable_t *mp)
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:300
#define clib_memcpy(a, b, c)
Definition: string.h:69
unsigned int u32
Definition: types.h:88
Struct for VXLAN GPE node state.
Definition: vxlan_gpe.h:152
static void vl_api_vxlan_gpe_ioam_vni_enable_t_handler(vl_api_vxlan_gpe_ioam_vni_enable_t *mp)
static void vl_api_vxlan_gpe_ioam_disable_t_handler(vl_api_vxlan_gpe_ioam_disable_t *mp)
vxlan_gpe_tunnel_t * tunnels
vector of encap tunnel instances
Definition: vxlan_gpe.h:154
u64 uword
Definition: types.h:112
Enable iOAM for a VNI (VXLAN-GPE)
Definition: vxlan_gpe.api:76
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
uword * vxlan4_gpe_tunnel_by_key
lookup IPv4 VXLAN GPE tunnel by key
Definition: vxlan_gpe.h:157
unsigned char u8
Definition: types.h:56
#define hash_get_mem(h, key)
Definition: hash.h:268
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
static void vl_api_vxlan_gpe_ioam_vni_disable_t_handler(vl_api_vxlan_gpe_ioam_vni_disable_t *mp)
u16 vl_msg_api_get_msg_ids(char *name, int n)
Definition: api_shared.c:1309
vlib_node_registration_t vxlan_gpe_encap_node
(constructor) VLIB_REGISTER_NODE (vxlan_gpe_encap_node)
Definition: encap.c:370
static clib_error_t * vxlan_gpe_plugin_api_hookup(vlib_main_t *vm)
vnet_main_t * vnet_main
State convenience vnet_main_t.
#define foreach_vxlan_gpe_plugin_api_msg
Definition: vxlan_gpe_api.c:97
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:109