FD.io VPP  v18.04-17-g3a0d853
Vector Packet Processing
geneve_api.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 SUSE LLC.
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 #include <vnet/vnet.h>
18 #include <vlibmemory/api.h>
19 
20 #include <vnet/interface.h>
21 #include <vnet/api_errno.h>
22 #include <vnet/feature/feature.h>
23 #include <vnet/geneve/geneve.h>
24 #include <vnet/fib/fib_table.h>
25 
26 #include <vnet/vnet_msg_enum.h>
27 
28 #define vl_typedefs /* define message structures */
29 #include <vnet/vnet_all_api_h.h>
30 #undef vl_typedefs
31 
32 #define vl_endianfun /* define message structures */
33 #include <vnet/vnet_all_api_h.h>
34 #undef vl_endianfun
35 
36 /* instantiate all the print functions we know about */
37 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
38 #define vl_printfun
39 #include <vnet/vnet_all_api_h.h>
40 #undef vl_printfun
41 
43 
44 #define foreach_vpe_api_msg \
45 _(SW_INTERFACE_SET_GENEVE_BYPASS, sw_interface_set_geneve_bypass) \
46 _(GENEVE_ADD_DEL_TUNNEL, geneve_add_del_tunnel) \
47 _(GENEVE_TUNNEL_DUMP, geneve_tunnel_dump)
48 
49 static void
52 {
53  vl_api_sw_interface_set_geneve_bypass_reply_t *rmp;
54  int rv = 0;
55  u32 sw_if_index = ntohl (mp->sw_if_index);
56 
58 
59  vnet_int_geneve_bypass_mode (sw_if_index, mp->is_ipv6, mp->enable);
61 
62  REPLY_MACRO (VL_API_SW_INTERFACE_SET_GENEVE_BYPASS_REPLY);
63 }
64 
67 {
69  int rv = 0;
70  ip4_main_t *im = &ip4_main;
71 
72  uword *p = hash_get (im->fib_index_by_table_id, ntohl (mp->encap_vrf_id));
73  if (!p)
74  {
75  rv = VNET_API_ERROR_NO_SUCH_FIB;
76  goto out;
77  }
78 
80  .is_add = mp->is_add,
81  .is_ip6 = mp->is_ipv6,
82  .mcast_sw_if_index = ntohl (mp->mcast_sw_if_index),
83  .encap_fib_index = p[0],
84  .decap_next_index = ntohl (mp->decap_next_index),
85  .vni = ntohl (mp->vni),
86  .remote = to_ip46 (mp->is_ipv6, mp->remote_address),
87  .local = to_ip46 (mp->is_ipv6, mp->local_address),
88  };
89 
90  /* Check src & dst are different */
91  if (ip46_address_cmp (&a.remote, &a.local) == 0)
92  {
93  rv = VNET_API_ERROR_SAME_SRC_DST;
94  goto out;
95  }
98  {
99  rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
100  goto out;
101  }
102 
103  u32 sw_if_index = ~0;
104  rv = vnet_geneve_add_del_tunnel (&a, &sw_if_index);
105 
106 out:
107  /* *INDENT-OFF* */
108  REPLY_MACRO2(VL_API_GENEVE_ADD_DEL_TUNNEL_REPLY,
109  ({
110  rmp->sw_if_index = ntohl (sw_if_index);
111  }));
112  /* *INDENT-ON* */
113 }
114 
115 static void send_geneve_tunnel_details
117 {
119  ip4_main_t *im4 = &ip4_main;
120  ip6_main_t *im6 = &ip6_main;
121  u8 is_ipv6 = !ip46_address_is_ip4 (&t->remote);
122 
123  rmp = vl_msg_api_alloc (sizeof (*rmp));
124  memset (rmp, 0, sizeof (*rmp));
125  rmp->_vl_msg_id = ntohs (VL_API_GENEVE_TUNNEL_DETAILS);
126  if (is_ipv6)
127  {
128  memcpy (rmp->src_address, t->local.ip6.as_u8, 16);
129  memcpy (rmp->dst_address, t->remote.ip6.as_u8, 16);
130  rmp->encap_vrf_id = htonl (im6->fibs[t->encap_fib_index].ft_table_id);
131  }
132  else
133  {
134  memcpy (rmp->src_address, t->local.ip4.as_u8, 4);
135  memcpy (rmp->dst_address, t->remote.ip4.as_u8, 4);
136  rmp->encap_vrf_id = htonl (im4->fibs[t->encap_fib_index].ft_table_id);
137  }
138  rmp->mcast_sw_if_index = htonl (t->mcast_sw_if_index);
139  rmp->vni = htonl (t->vni);
140  rmp->decap_next_index = htonl (t->decap_next_index);
141  rmp->sw_if_index = htonl (t->sw_if_index);
142  rmp->is_ipv6 = is_ipv6;
143  rmp->context = context;
144 
145  vl_api_send_msg (reg, (u8 *) rmp);
146 }
147 
150 {
152  geneve_main_t *vxm = &geneve_main;
153  geneve_tunnel_t *t;
154  u32 sw_if_index;
155 
157  if (!reg)
158  return;
159 
160  sw_if_index = ntohl (mp->sw_if_index);
161 
162  if (~0 == sw_if_index)
163  {
164  /* *INDENT-OFF* */
165  pool_foreach (t, vxm->tunnels,
166  ({
167  send_geneve_tunnel_details(t, reg, mp->context);
168  }));
169  /* *INDENT-ON* */
170  }
171  else
172  {
173  if ((sw_if_index >= vec_len (vxm->tunnel_index_by_sw_if_index)) ||
174  (~0 == vxm->tunnel_index_by_sw_if_index[sw_if_index]))
175  {
176  return;
177  }
178  t = &vxm->tunnels[vxm->tunnel_index_by_sw_if_index[sw_if_index]];
179  send_geneve_tunnel_details (t, reg, mp->context);
180  }
181 }
182 
183 /*
184  * vpe_api_hookup
185  * Add vpe's API message handlers to the table.
186  * vlib has alread mapped shared memory and
187  * added the client registration handlers.
188  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
189  */
190 #define vl_msg_name_crc_list
191 #include <vnet/vnet_all_api_h.h>
192 #undef vl_msg_name_crc_list
193 
194 static void
196 {
197 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
198  foreach_vl_msg_name_crc_geneve;
199 #undef _
200 }
201 
202 static clib_error_t *
204 {
205  api_main_t *am = &api_main;
206 
207 #define _(N,n) \
208  vl_msg_api_set_handlers(VL_API_##N, #n, \
209  vl_api_##n##_t_handler, \
210  vl_noop_handler, \
211  vl_api_##n##_t_endian, \
212  vl_api_##n##_t_print, \
213  sizeof(vl_api_##n##_t), 1);
215 #undef _
216 
217  am->api_trace_cfg[VL_API_GENEVE_ADD_DEL_TUNNEL].size += 16 * sizeof (u32);
218 
219  /*
220  * Set up the (msg_name, crc, message-id) table
221  */
223 
224  return 0;
225 }
226 
228 
229 /*
230  * fd.io coding-style-patch-verification: ON
231  *
232  * Local Variables:
233  * eval: (c-set-style "gnu")
234  * End:
235  */
a
Definition: bitmap.h:516
static uword ip46_address_is_multicast(ip46_address_t *a)
Definition: ip6_packet.h:152
int size
for sanity checking
Definition: api_common.h:80
#define REPLY_MACRO2(t, body)
u32 decap_next_index
Definition: geneve.h:103
static void vl_api_send_msg(vl_api_registration_t *rp, u8 *elem)
Definition: api.h:34
#define foreach_vpe_api_msg
Definition: geneve_api.c:44
u32 mcast_sw_if_index
Definition: geneve.h:100
int vnet_geneve_add_del_tunnel(vnet_geneve_add_del_tunnel_args_t *a, u32 *sw_if_indexp)
Definition: geneve.c:355
u32 * tunnel_index_by_sw_if_index
Definition: geneve.h:174
void * vl_msg_api_alloc(int nbytes)
#define ip46_address_cmp(ip46_1, ip46_2)
Definition: ip6_packet.h:80
trace_cfg_t * api_trace_cfg
Current trace configuration.
Definition: api_common.h:246
geneve_tunnel_t * tunnels
Definition: geneve.h:156
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:440
Interface set geneve-bypass request.
Definition: geneve.api:66
#define hash_get(h, key)
Definition: hash.h:248
uword * fib_index_by_table_id
Hash table mapping table id to fib index.
Definition: ip4.h:121
VLIB_API_INIT_FUNCTION(geneve_api_hookup)
u32 encap_fib_index
Definition: geneve.h:106
#define REPLY_MACRO(t)
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:199
#define ip46_address_is_ip4(ip46)
Definition: ip6_packet.h:76
An API client registration, only in vpp/vlib.
Definition: api_common.h:44
#define BAD_SW_IF_INDEX_LABEL
static uword vnet_sw_if_index_is_api_valid(u32 sw_if_index)
static clib_error_t * geneve_api_hookup(vlib_main_t *vm)
Definition: geneve_api.c:203
u32 ft_table_id
Table ID (hash key) for this FIB.
Definition: fib_table.h:89
vlib_main_t * vm
Definition: buffer.c:294
static void send_geneve_tunnel_details(geneve_tunnel_t *t, vl_api_registration_t *reg, u32 context)
Definition: geneve_api.c:116
ip46_address_t local
Definition: geneve.h:96
static void vl_api_geneve_add_del_tunnel_t_handler(vl_api_geneve_add_del_tunnel_t *mp)
Definition: geneve_api.c:66
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:56
static ip46_address_t to_ip46(u32 is_ipv6, u8 *buf)
Definition: ip6_packet.h:87
u32 sw_if_index
Definition: geneve.h:109
unsigned int u32
Definition: types.h:88
ip6_main_t ip6_main
Definition: ip6_forward.c:2750
IPv4 main type.
Definition: ip4.h:95
static void vl_api_sw_interface_set_geneve_bypass_t_handler(vl_api_sw_interface_set_geneve_bypass_t *mp)
Definition: geneve_api.c:51
u64 uword
Definition: types.h:112
ip46_address_t remote
Definition: geneve.h:97
static void setup_message_id_table(api_main_t *am)
Definition: geneve_api.c:195
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:818
geneve_main_t geneve_main
Definition: geneve.c:38
struct fib_table_t_ * fibs
Vector of FIBs.
Definition: ip4.h:100
api_main_t api_main
Definition: api_shared.c:35
struct fib_table_t_ * fibs
Definition: ip6.h:164
static void vl_api_geneve_tunnel_dump_t_handler(vl_api_geneve_tunnel_dump_t *mp)
Definition: geneve_api.c:149
#define VALIDATE_SW_IF_INDEX(mp)
void vnet_int_geneve_bypass_mode(u32 sw_if_index, u8 is_ip6, u8 is_enable)
Definition: geneve.c:920