FD.io VPP  v20.01-48-g3e0dafb74
Vector Packet Processing
vxlan_api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * vxlan_api.c - vxlan api
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 #include <vnet/vnet.h>
21 #include <vlibmemory/api.h>
22 
23 #include <vnet/interface.h>
24 #include <vnet/api_errno.h>
25 #include <vnet/feature/feature.h>
26 #include <vnet/vxlan/vxlan.h>
27 #include <vnet/fib/fib_table.h>
28 
29 #include <vnet/vnet_msg_enum.h>
30 
31 #define vl_typedefs /* define message structures */
32 #include <vnet/vnet_all_api_h.h>
33 #undef vl_typedefs
34 
35 #define vl_endianfun /* define message structures */
36 #include <vnet/vnet_all_api_h.h>
37 #undef vl_endianfun
38 
39 /* instantiate all the print functions we know about */
40 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
41 #define vl_printfun
42 #include <vnet/vnet_all_api_h.h>
43 #undef vl_printfun
44 
46 
47 #define foreach_vpe_api_msg \
48 _(SW_INTERFACE_SET_VXLAN_BYPASS, sw_interface_set_vxlan_bypass) \
49 _(VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel) \
50 _(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump) \
51 _(VXLAN_OFFLOAD_RX, vxlan_offload_rx)
52 
53 static void
55 {
56  vl_api_vxlan_offload_rx_reply_t *rmp;
57  int rv = 0;
58  u32 hw_if_index = ntohl (mp->hw_if_index);
59  u32 sw_if_index = ntohl (mp->sw_if_index);
60 
61  if (!vnet_hw_interface_is_valid (vnet_get_main (), hw_if_index))
62  {
63  rv = VNET_API_ERROR_NO_SUCH_ENTRY;
64  goto err;
65  }
67 
68  u32 t_index = vnet_vxlan_get_tunnel_index (sw_if_index);
69  if (t_index == ~0)
70  {
71  rv = VNET_API_ERROR_INVALID_SW_IF_INDEX_2;
72  goto err;
73  }
74 
75  vxlan_main_t *vxm = &vxlan_main;
76  vxlan_tunnel_t *t = pool_elt_at_index (vxm->tunnels, t_index);
77  if (!ip46_address_is_ip4 (&t->dst))
78  {
79  rv = VNET_API_ERROR_INVALID_ADDRESS_FAMILY;
80  goto err;
81  }
82 
83  vnet_main_t *vnm = vnet_get_main ();
84  vnet_hw_interface_t *hw_if = vnet_get_hw_interface (vnm, hw_if_index);
85  ip4_main_t *im = &ip4_main;
86  u32 rx_fib_index =
88 
89  if (t->encap_fib_index != rx_fib_index)
90  {
91  rv = VNET_API_ERROR_NO_SUCH_FIB;
92  goto err;
93  }
94 
95  if (vnet_vxlan_add_del_rx_flow (hw_if_index, t_index, mp->enable))
96  {
97  rv = VNET_API_ERROR_UNSPECIFIED;
98  goto err;
99  }
101 err:
102 
103  REPLY_MACRO (VL_API_VXLAN_OFFLOAD_RX_REPLY);
104 }
105 
106 static void
109 {
110  vl_api_sw_interface_set_vxlan_bypass_reply_t *rmp;
111  int rv = 0;
112  u32 sw_if_index = ntohl (mp->sw_if_index);
113 
115 
116  vnet_int_vxlan_bypass_mode (sw_if_index, mp->is_ipv6, mp->enable);
118 
119  REPLY_MACRO (VL_API_SW_INTERFACE_SET_VXLAN_BYPASS_REPLY);
120 }
121 
124 {
126  int rv = 0;
127  u32 fib_index;
128 
129  fib_index = fib_table_find (fib_ip_proto (mp->is_ipv6),
130  ntohl (mp->encap_vrf_id));
131  if (fib_index == ~0)
132  {
133  rv = VNET_API_ERROR_NO_SUCH_FIB;
134  goto out;
135  }
136 
138  .is_add = mp->is_add,
139  .is_ip6 = mp->is_ipv6,
140  .instance = ntohl (mp->instance),
141  .mcast_sw_if_index = ntohl (mp->mcast_sw_if_index),
142  .encap_fib_index = fib_index,
143  .decap_next_index = ntohl (mp->decap_next_index),
144  .vni = ntohl (mp->vni),
145  .dst = to_ip46 (mp->is_ipv6, mp->dst_address),
146  .src = to_ip46 (mp->is_ipv6, mp->src_address),
147  };
148 
149  /* Check src & dst are different */
150  if (ip46_address_cmp (&a.dst, &a.src) == 0)
151  {
152  rv = VNET_API_ERROR_SAME_SRC_DST;
153  goto out;
154  }
155  if (ip46_address_is_multicast (&a.dst) &&
157  {
158  rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
159  goto out;
160  }
161 
162  u32 sw_if_index = ~0;
163  rv = vnet_vxlan_add_del_tunnel (&a, &sw_if_index);
164 
165 out:
166  /* *INDENT-OFF* */
167  REPLY_MACRO2(VL_API_VXLAN_ADD_DEL_TUNNEL_REPLY,
168  ({
169  rmp->sw_if_index = ntohl (sw_if_index);
170  }));
171  /* *INDENT-ON* */
172 }
173 
174 static void send_vxlan_tunnel_details
176 {
178  ip4_main_t *im4 = &ip4_main;
179  ip6_main_t *im6 = &ip6_main;
181 
182  rmp = vl_msg_api_alloc (sizeof (*rmp));
183  clib_memset (rmp, 0, sizeof (*rmp));
184  rmp->_vl_msg_id = ntohs (VL_API_VXLAN_TUNNEL_DETAILS);
185  if (is_ipv6)
186  {
187  memcpy (rmp->src_address, t->src.ip6.as_u8, 16);
188  memcpy (rmp->dst_address, t->dst.ip6.as_u8, 16);
189  rmp->encap_vrf_id = htonl (im6->fibs[t->encap_fib_index].ft_table_id);
190  }
191  else
192  {
193  memcpy (rmp->src_address, t->src.ip4.as_u8, 4);
194  memcpy (rmp->dst_address, t->dst.ip4.as_u8, 4);
195  rmp->encap_vrf_id = htonl (im4->fibs[t->encap_fib_index].ft_table_id);
196  }
197 
198  rmp->instance = htonl (t->user_instance);
199  rmp->mcast_sw_if_index = htonl (t->mcast_sw_if_index);
200  rmp->vni = htonl (t->vni);
201  rmp->decap_next_index = htonl (t->decap_next_index);
202  rmp->sw_if_index = htonl (t->sw_if_index);
203  rmp->is_ipv6 = is_ipv6;
204  rmp->context = context;
205 
206  vl_api_send_msg (reg, (u8 *) rmp);
207 }
208 
211 {
213  vxlan_main_t *vxm = &vxlan_main;
214  vxlan_tunnel_t *t;
216 
218  if (!reg)
219  return;
220 
221  sw_if_index = ntohl (mp->sw_if_index);
222 
223  if (~0 == sw_if_index)
224  {
225  /* *INDENT-OFF* */
226  pool_foreach (t, vxm->tunnels,
227  ({
228  send_vxlan_tunnel_details(t, reg, mp->context);
229  }));
230  /* *INDENT-ON* */
231  }
232  else
233  {
234  if ((sw_if_index >= vec_len (vxm->tunnel_index_by_sw_if_index)) ||
235  (~0 == vxm->tunnel_index_by_sw_if_index[sw_if_index]))
236  {
237  return;
238  }
240  send_vxlan_tunnel_details (t, reg, mp->context);
241  }
242 }
243 
244 /*
245  * vpe_api_hookup
246  * Add vpe's API message handlers to the table.
247  * vlib has already mapped shared memory and
248  * added the client registration handlers.
249  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
250  */
251 #define vl_msg_name_crc_list
252 #include <vnet/vnet_all_api_h.h>
253 #undef vl_msg_name_crc_list
254 
255 static void
257 {
258 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
259  foreach_vl_msg_name_crc_vxlan;
260 #undef _
261 }
262 
263 static clib_error_t *
265 {
266  api_main_t *am = vlibapi_get_main ();
267 
268 #define _(N,n) \
269  vl_msg_api_set_handlers(VL_API_##N, #n, \
270  vl_api_##n##_t_handler, \
271  vl_noop_handler, \
272  vl_api_##n##_t_endian, \
273  vl_api_##n##_t_print, \
274  sizeof(vl_api_##n##_t), 1);
276 #undef _
277 
278  am->api_trace_cfg[VL_API_VXLAN_ADD_DEL_TUNNEL].size += 16 * sizeof (u32);
279 
280  /*
281  * Set up the (msg_name, crc, message-id) table
282  */
284 
285  return 0;
286 }
287 
289 
290 /*
291  * fd.io coding-style-patch-verification: ON
292  *
293  * Local Variables:
294  * eval: (c-set-style "gnu")
295  * End:
296  */
u32 user_instance
Definition: vxlan.h:130
static void vl_api_sw_interface_set_vxlan_bypass_t_handler(vl_api_sw_interface_set_vxlan_bypass_t *mp)
Definition: vxlan_api.c:108
static uword ip46_address_is_multicast(const ip46_address_t *a)
Definition: ip46_address.h:154
a
Definition: bitmap.h:538
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
int size
for sanity checking
Definition: api_common.h:82
#define REPLY_MACRO2(t, body)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
Interface set vxlan-bypass request.
Definition: vxlan.api:81
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:35
ip46_address_t dst
Definition: vxlan.h:93
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
#define foreach_vpe_api_msg
Definition: vxlan_api.c:47
static void setup_message_id_table(api_main_t *am)
Definition: vxlan_api.c:256
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:121
static u8 ip46_address_is_ip4(const ip46_address_t *ip46)
Definition: ip46_address.h:55
void * vl_msg_api_alloc(int nbytes)
unsigned char u8
Definition: types.h:56
trace_cfg_t * api_trace_cfg
Current trace configuration.
Definition: api_common.h:272
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:498
vl_api_interface_index_t sw_if_index
Definition: gre.api:59
static int ip46_address_cmp(const ip46_address_t *ip46_1, const ip46_address_t *ip46_2)
Definition: ip46_address.h:80
VLIB_API_INIT_FUNCTION(vxlan_api_hookup)
static void vl_api_vxlan_add_del_tunnel_t_handler(vl_api_vxlan_add_del_tunnel_t *mp)
Definition: vxlan_api.c:123
unsigned int u32
Definition: types.h:88
u32 fib_table_find(fib_protocol_t proto, u32 table_id)
Get the index of the FIB for a Table-ID.
Definition: fib_table.c:1097
static clib_error_t * vxlan_api_hookup(vlib_main_t *vm)
Definition: vxlan_api.c:264
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:519
vxlan_main_t vxlan_main
Definition: vxlan.c:44
#define REPLY_MACRO(t)
ip6_main_t ip6_main
Definition: ip6_forward.c:2703
vlib_main_t * vm
Definition: in2out_ed.c:1810
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:225
int vnet_vxlan_add_del_rx_flow(u32 hw_if_index, u32 t_index, int is_add)
Definition: vxlan.c:1125
An API client registration, only in vpp/vlib.
Definition: api_common.h:46
#define BAD_SW_IF_INDEX_LABEL
int vnet_vxlan_add_del_tunnel(vnet_vxlan_add_del_tunnel_args_t *a, u32 *sw_if_indexp)
Definition: vxlan.c:368
Offload vxlan rx request.
Definition: vxlan.api:97
static uword vnet_sw_if_index_is_api_valid(u32 sw_if_index)
u32 ft_table_id
Table ID (hash key) for this FIB.
Definition: fib_table.h:92
u32 mcast_sw_if_index
Definition: vxlan.h:96
Create or delete a VXLAN tunnel.
Definition: vxlan.api:31
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:57
static uword vnet_hw_interface_is_valid(vnet_main_t *vnm, u32 hw_if_index)
IPv4 main type.
Definition: ip4.h:105
u32 sw_if_index
Definition: vxlan.h:105
u32 vnet_vxlan_get_tunnel_index(u32 sw_if_index)
Definition: vxlan.c:1160
#define vec_elt(v, i)
Get vector value at index i.
void vnet_int_vxlan_bypass_mode(u32 sw_if_index, u8 is_ip6, u8 is_enable)
Definition: vxlan.c:929
static ip46_address_t to_ip46(u32 is_ipv6, u8 *buf)
Definition: ip46_address.h:137
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
static fib_protocol_t fib_ip_proto(bool is_ip6)
Convert from boolean is_ip6 to FIB protocol.
Definition: fib_types.h:80
u32 encap_fib_index
Definition: vxlan.h:102
u16 decap_next_index
Definition: vxlan.h:99
u32 * tunnel_index_by_sw_if_index
Definition: vxlan.h:173
static void vl_api_vxlan_tunnel_dump_t_handler(vl_api_vxlan_tunnel_dump_t *mp)
Definition: vxlan_api.c:210
static api_main_t * vlibapi_get_main(void)
Definition: api_common.h:378
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1079
struct fib_table_t_ * fibs
Vector of FIBs.
Definition: ip4.h:110
static void send_vxlan_tunnel_details(vxlan_tunnel_t *t, vl_api_registration_t *reg, u32 context)
Definition: vxlan_api.c:175
struct fib_table_t_ * fibs
Definition: ip6.h:183
vxlan_tunnel_t * tunnels
Definition: vxlan.h:158
ip46_address_t src
Definition: vxlan.h:92
#define VALIDATE_SW_IF_INDEX(mp)
static void vl_api_vxlan_offload_rx_t_handler(vl_api_vxlan_offload_rx_t *mp)
Definition: vxlan_api.c:54
u8 is_ipv6
Definition: acl_types.api:38