FD.io VPP  v18.01.2-1-g9b554f3
Vector Packet Processing
udp.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 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 #ifndef __included_udp_h__
16 #define __included_udp_h__
17 
18 #include <vnet/vnet.h>
19 #include <vnet/udp/udp_packet.h>
20 #include <vnet/ip/ip.h>
21 #include <vnet/ip/ip4.h>
22 #include <vnet/ip/ip4_packet.h>
23 #include <vnet/pg/pg.h>
24 #include <vnet/ip/format.h>
25 
26 #include <vnet/ip/ip.h>
27 #include <vnet/session/transport.h>
28 
29 typedef enum
30 {
31 #define udp_error(n,s) UDP_ERROR_##n,
32 #include <vnet/udp/udp_error.def>
33 #undef udp_error
35 } udp_error_t;
36 
37 typedef struct
38 {
39  transport_connection_t connection; /** must be first */
40  /** ersatz MTU to limit fifo pushes to test data size */
43 
44 #define foreach_udp4_dst_port \
45 _ (53, dns) \
46 _ (67, dhcp_to_server) \
47 _ (68, dhcp_to_client) \
48 _ (500, ikev2) \
49 _ (2152, GTPU) \
50 _ (3784, bfd4) \
51 _ (3785, bfd_echo4) \
52 _ (4341, lisp_gpe) \
53 _ (4342, lisp_cp) \
54 _ (4739, ipfix) \
55 _ (4789, vxlan) \
56 _ (4789, vxlan6) \
57 _ (4790, VXLAN_GPE) \
58 _ (6633, vpath_3) \
59 _ (6081, geneve) \
60 _ (53053, dns_reply)
61 
62 
63 #define foreach_udp6_dst_port \
64 _ (53, dns6) \
65 _ (547, dhcpv6_to_server) \
66 _ (546, dhcpv6_to_client) \
67 _ (2152, GTPU6) \
68 _ (3784, bfd6) \
69 _ (3785, bfd_echo6) \
70 _ (4341, lisp_gpe6) \
71 _ (4342, lisp_cp6) \
72 _ (4790, VXLAN6_GPE) \
73 _ (6633, vpath6_3) \
74 _ (6081, geneve6) \
75 _ (8138, BIER) \
76 _ (53053, dns_reply6)
77 
78 typedef enum
79 {
80 #define _(n,f) UDP_DST_PORT_##f = n,
82 #undef _
84 
85 typedef enum
86 {
87 #define _(n,f) UDP6_DST_PORT_##f = n,
89 #undef _
91 
92 typedef struct
93 {
94  /* Name (a c string). */
95  char *name;
96 
97  /* GRE protocol type in host byte order. */
99 
100  /* Node which handles this type. */
102 
103  /* Next index for this type. */
106 
107 typedef enum
108 {
109  UDP_IP6 = 0,
110  UDP_IP4, /* the code is full of is_ip4... */
112 } udp_af_t;
113 
114 typedef struct
115 {
116  udp_dst_port_info_t *dst_port_infos[N_UDP_AF];
117 
118  /* Hash tables mapping name/protocol to protocol info index. */
119  uword *dst_port_info_by_name[N_UDP_AF];
120  uword *dst_port_info_by_dst_port[N_UDP_AF];
121 
122  /* Sparse vector mapping udp dst_port in network byte order
123  to next index. */
128 
129  /*
130  * Per-worker thread udp connection pools used with session layer
131  */
137 
138 } udp_main_t;
139 
140 extern udp_main_t udp_main;
143 
145 udp_connection_get (u32 conn_index, u32 thread_index)
146 {
147  if (pool_is_free_index (udp_main.connections[thread_index], conn_index))
148  return 0;
149  return pool_elt_at_index (udp_main.connections[thread_index], conn_index);
150 }
151 
153 udp_listener_get (u32 conn_index)
154 {
155  return pool_elt_at_index (udp_main.listener_pool, conn_index);
156 }
157 
160 {
161  return &udp_main;
162 }
163 
166 {
167  return ((udp_connection_t *) tc);
168 }
169 
172 {
173  return (uc - udp_main.connections[uc->c_thread_index]);
174 }
175 
177 
178 /**
179  * Acquires a lock that blocks a connection pool from expanding.
180  */
181 always_inline void
182 udp_pool_add_peeker (u32 thread_index)
183 {
184  if (thread_index != vlib_get_thread_index ())
185  return;
186  clib_spinlock_lock_if_init (&udp_main.peekers_readers_locks[thread_index]);
187  udp_main.connection_peekers[thread_index] += 1;
188  if (udp_main.connection_peekers[thread_index] == 1)
189  clib_spinlock_lock_if_init (&udp_main.peekers_write_locks[thread_index]);
191  [thread_index]);
192 }
193 
194 always_inline void
196 {
197  if (thread_index != vlib_get_thread_index ())
198  return;
199  ASSERT (udp_main.connection_peekers[thread_index] > 0);
200  clib_spinlock_lock_if_init (&udp_main.peekers_readers_locks[thread_index]);
201  udp_main.connection_peekers[thread_index] -= 1;
202  if (udp_main.connection_peekers[thread_index] == 0)
204  [thread_index]);
206  [thread_index]);
207 }
208 
210 udp_conenction_clone_safe (u32 connection_index, u32 thread_index)
211 {
212  udp_connection_t *old_c, *new_c;
213  u32 current_thread_index = vlib_get_thread_index ();
214  new_c = udp_connection_alloc (current_thread_index);
215 
216  /* If during the memcpy pool is reallocated AND the memory allocator
217  * decides to give the old chunk of memory to somebody in a hurry to
218  * scribble something on it, we have a problem. So add this thread as
219  * a session pool peeker.
220  */
221  udp_pool_add_peeker (thread_index);
222  old_c = udp_main.connections[thread_index] + connection_index;
223  clib_memcpy (new_c, old_c, sizeof (*new_c));
224  udp_pool_remove_peeker (thread_index);
225  new_c->c_thread_index = current_thread_index;
226  new_c->c_c_index = udp_connection_index (new_c);
227  return new_c;
228 }
229 
230 
233 {
234  uword *p = hash_get (um->dst_port_info_by_dst_port[is_ip4], dst_port);
235  return p ? vec_elt_at_index (um->dst_port_infos[is_ip4], p[0]) : 0;
236 }
237 
241 
243  udp_dst_port_t dst_port,
244  u32 node_index, u8 is_ip4);
246  udp_dst_port_t dst_port, u8 is_ip4);
247 
248 void udp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add);
249 
250 always_inline void *
251 vlib_buffer_push_udp (vlib_buffer_t * b, u16 sp, u16 dp, u8 offload_csum)
252 {
253  udp_header_t *uh;
254 
255  uh = vlib_buffer_push_uninit (b, sizeof (udp_header_t));
256  uh->src_port = sp;
257  uh->dst_port = dp;
258  uh->checksum = 0;
259  uh->length = clib_host_to_net_u16 (b->current_length);
260  if (offload_csum)
261  {
262  b->flags |= VNET_BUFFER_F_OFFLOAD_UDP_CKSUM;
263  vnet_buffer (b)->l4_hdr_offset = (u8 *) uh - b->data;
264  }
265  return uh;
266 }
267 
268 always_inline void
270 {
271  u16 new_l0;
272  udp_header_t *udp0;
273 
274  if (is_ip4)
275  {
276  ip4_header_t *ip0;
277  ip_csum_t sum0;
278  u16 old_l0 = 0;
279 
280  ip0 = vlib_buffer_get_current (b0);
281 
282  /* fix the <bleep>ing outer-IP checksum */
283  sum0 = ip0->checksum;
284  /* old_l0 always 0, see the rewrite setup */
285  new_l0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0));
286 
287  sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t,
288  length /* changed member */ );
289  ip0->checksum = ip_csum_fold (sum0);
290  ip0->length = new_l0;
291 
292  /* Fix UDP length */
293  udp0 = (udp_header_t *) (ip0 + 1);
294  new_l0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0)
295  - sizeof (*ip0));
296  udp0->length = new_l0;
297  }
298  else
299  {
300  ip6_header_t *ip0;
301  int bogus0;
302 
303  ip0 = vlib_buffer_get_current (b0);
304 
305  new_l0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0)
306  - sizeof (*ip0));
307  ip0->payload_length = new_l0;
308 
309  /* Fix UDP length */
310  udp0 = (udp_header_t *) (ip0 + 1);
311  udp0->length = new_l0;
312 
313  udp0->checksum =
314  ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip0, &bogus0);
315  ASSERT (bogus0 == 0);
316 
317  if (udp0->checksum == 0)
318  udp0->checksum = 0xffff;
319  }
320 }
321 
322 always_inline void
324  u8 is_ip4)
325 {
326  vlib_buffer_advance (b0, -ec_len);
327 
328  if (is_ip4)
329  {
330  ip4_header_t *ip0;
331 
332  ip0 = vlib_buffer_get_current (b0);
333 
334  /* Apply the encap string. */
335  clib_memcpy (ip0, ec0, ec_len);
336  ip_udp_fixup_one (vm, b0, 1);
337  }
338  else
339  {
340  ip6_header_t *ip0;
341 
342  ip0 = vlib_buffer_get_current (b0);
343 
344  /* Apply the encap string. */
345  clib_memcpy (ip0, ec0, ec_len);
346  ip_udp_fixup_one (vm, b0, 0);
347  }
348 }
349 
350 always_inline void
352  u8 * ec0, u8 * ec1, word ec_len, u8 is_v4)
353 {
354  u16 new_l0, new_l1;
355  udp_header_t *udp0, *udp1;
356 
357  ASSERT (_vec_len (ec0) == _vec_len (ec1));
358 
359  vlib_buffer_advance (b0, -ec_len);
360  vlib_buffer_advance (b1, -ec_len);
361 
362  if (is_v4)
363  {
364  ip4_header_t *ip0, *ip1;
365  ip_csum_t sum0, sum1;
366  u16 old_l0 = 0, old_l1 = 0;
367 
368  ip0 = vlib_buffer_get_current (b0);
369  ip1 = vlib_buffer_get_current (b1);
370 
371  /* Apply the encap string */
372  clib_memcpy (ip0, ec0, ec_len);
373  clib_memcpy (ip1, ec1, ec_len);
374 
375  /* fix the <bleep>ing outer-IP checksum */
376  sum0 = ip0->checksum;
377  sum1 = ip1->checksum;
378 
379  /* old_l0 always 0, see the rewrite setup */
380  new_l0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0));
381  new_l1 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b1));
382 
383  sum0 = ip_csum_update (sum0, old_l0, new_l0, ip4_header_t,
384  length /* changed member */ );
385  sum1 = ip_csum_update (sum1, old_l1, new_l1, ip4_header_t,
386  length /* changed member */ );
387 
388  ip0->checksum = ip_csum_fold (sum0);
389  ip1->checksum = ip_csum_fold (sum1);
390 
391  ip0->length = new_l0;
392  ip1->length = new_l1;
393 
394  /* Fix UDP length */
395  udp0 = (udp_header_t *) (ip0 + 1);
396  udp1 = (udp_header_t *) (ip1 + 1);
397 
398  new_l0 =
399  clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0) -
400  sizeof (*ip0));
401  new_l1 =
402  clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b1) -
403  sizeof (*ip1));
404  udp0->length = new_l0;
405  udp1->length = new_l1;
406  }
407  else
408  {
409  ip6_header_t *ip0, *ip1;
410  int bogus0, bogus1;
411 
412  ip0 = vlib_buffer_get_current (b0);
413  ip1 = vlib_buffer_get_current (b1);
414 
415  /* Apply the encap string. */
416  clib_memcpy (ip0, ec0, ec_len);
417  clib_memcpy (ip1, ec1, ec_len);
418 
419  new_l0 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b0)
420  - sizeof (*ip0));
421  new_l1 = clib_host_to_net_u16 (vlib_buffer_length_in_chain (vm, b1)
422  - sizeof (*ip1));
423  ip0->payload_length = new_l0;
424  ip1->payload_length = new_l1;
425 
426  /* Fix UDP length */
427  udp0 = (udp_header_t *) (ip0 + 1);
428  udp1 = (udp_header_t *) (ip1 + 1);
429 
430  udp0->length = new_l0;
431  udp1->length = new_l1;
432 
433  udp0->checksum =
434  ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip0, &bogus0);
435  udp1->checksum =
436  ip6_tcp_udp_icmp_compute_checksum (vm, b1, ip1, &bogus1);
437  ASSERT (bogus0 == 0);
438  ASSERT (bogus1 == 0);
439 
440  if (udp0->checksum == 0)
441  udp0->checksum = 0xffff;
442  if (udp1->checksum == 0)
443  udp1->checksum = 0xffff;
444  }
445 }
446 
447 /*
448  * fd.io coding-style-patch-verification: ON
449  *
450  * Local Variables:
451  * eval: (c-set-style "gnu")
452  * End:
453  */
454 
455 #endif /* __included_udp_h__ */
uword( unformat_function_t)(unformat_input_t *input, va_list *args)
Definition: format.h:231
static udp_connection_t * udp_listener_get(u32 conn_index)
Definition: udp.h:153
u16 * next_by_dst_port6
Definition: udp.h:125
unformat_function_t unformat_udp_header
Definition: udp.h:240
struct _transport_connection transport_connection_t
u32 * connection_peekers
Definition: udp.h:133
uword * dst_port_info_by_dst_port[N_UDP_AF]
Definition: udp.h:120
static udp_connection_t * udp_get_connection_from_transport(transport_connection_t *tc)
Definition: udp.h:165
static_always_inline void clib_spinlock_unlock_if_init(clib_spinlock_t *p)
Definition: lock.h:85
struct _vlib_node_registration vlib_node_registration_t
static udp_dst_port_info_t * udp_get_dst_port_info(udp_main_t *um, udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp.h:232
uword ip_csum_t
Definition: ip_packet.h:90
u8 *( format_function_t)(u8 *s, va_list *args)
Definition: format.h:48
u8 punt_unknown6
Definition: udp.h:127
static void * vlib_buffer_push_udp(vlib_buffer_t *b, u16 sp, u16 dp, u8 offload_csum)
Definition: udp.h:251
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:107
static udp_main_t * vnet_get_udp_main()
Definition: udp.h:159
#define always_inline
Definition: clib.h:92
udp_connection_t * udp_connection_alloc(u32 thread_index)
Definition: udp.c:26
u8 punt_unknown4
Definition: udp.h:126
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define foreach_udp6_dst_port
Definition: udp.h:63
static void udp_pool_remove_peeker(u32 thread_index)
Definition: udp.h:195
vlib_node_registration_t udp4_input_node
(constructor) VLIB_REGISTER_NODE (udp4_input_node)
Definition: udp_input.c:257
#define hash_get(h, key)
Definition: hash.h:248
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:459
u16 * next_by_dst_port4
Definition: udp.h:124
udp_main_t udp_main
Definition: udp_local.c:24
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:72
static u32 udp_connection_index(udp_connection_t *uc)
Definition: udp.h:171
udp_dst_port_info_t * dst_port_infos[N_UDP_AF]
Definition: udp.h:116
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:195
clib_spinlock_t * peekers_readers_locks
Definition: udp.h:134
vlib_node_registration_t udp6_input_node
(constructor) VLIB_REGISTER_NODE (udp6_input_node)
Definition: udp_input.c:283
udp_connection_t * listener_pool
Definition: udp.h:136
static void ip_udp_encap_one(vlib_main_t *vm, vlib_buffer_t *b0, u8 *ec0, word ec_len, u8 is_ip4)
Definition: udp.h:323
Definition: udp.h:109
static void udp_pool_add_peeker(u32 thread_index)
Acquires a lock that blocks a connection pool from expanding.
Definition: udp.h:182
void udp_punt_unknown(vlib_main_t *vm, u8 is_ip4, u8 is_add)
Definition: udp_local.c:553
static void ip_udp_fixup_one(vlib_main_t *vm, vlib_buffer_t *b0, u8 is_ip4)
Definition: udp.h:269
format_function_t format_udp_rx_trace
Definition: udp.h:239
static void ip_udp_encap_two(vlib_main_t *vm, vlib_buffer_t *b0, vlib_buffer_t *b1, u8 *ec0, u8 *ec1, word ec_len, u8 is_v4)
Definition: udp.h:351
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:221
vlib_main_t * vm
Definition: buffer.c:283
void udp_unregister_dst_port(vlib_main_t *vm, udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp_local.c:530
#define clib_memcpy(a, b, c)
Definition: string.h:75
static udp_connection_t * udp_connection_get(u32 conn_index, u32 thread_index)
Definition: udp.h:145
udp_error_t
Definition: udp.h:29
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:268
udp_dst_port_t
Definition: udp.h:78
u16 ip6_tcp_udp_icmp_compute_checksum(vlib_main_t *vm, vlib_buffer_t *p0, ip6_header_t *ip0, int *bogus_lengthp)
Definition: ip6_forward.c:1133
#define foreach_udp4_dst_port
Definition: udp.h:44
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
udp_af_t
Definition: udp.h:107
udp_dst_port_t dst_port
Definition: udp.h:98
char * name
Definition: udp.h:95
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:208
static udp_connection_t * udp_conenction_clone_safe(u32 connection_index, u32 thread_index)
Definition: udp.h:210
clib_spinlock_t * peekers_write_locks
Definition: udp.h:135
u64 uword
Definition: types.h:112
static void * vlib_buffer_push_uninit(vlib_buffer_t *b, u8 size)
Prepend uninitialized data to buffer.
Definition: buffer.h:292
unsigned short u16
Definition: types.h:57
u16 payload_length
Definition: ip6_packet.h:332
i64 word
Definition: types.h:111
transport_connection_t connection
Definition: udp.h:39
unsigned char u8
Definition: types.h:56
#define ip_csum_update(sum, old, new, type, field)
Definition: ip_packet.h:139
#define vnet_buffer(b)
Definition: buffer.h:326
u8 data[0]
Packet data.
Definition: buffer.h:159
void udp_register_dst_port(vlib_main_t *vm, udp_dst_port_t dst_port, u32 node_index, u8 is_ip4)
Definition: udp_local.c:492
u32 mtu
must be first
Definition: udp.h:41
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:75
udp_connection_t ** connections
Definition: udp.h:132
static_always_inline void clib_spinlock_lock_if_init(clib_spinlock_t *p)
Definition: lock.h:65
udp6_dst_port_t
Definition: udp.h:85
Definition: udp.h:110
static u16 ip_csum_fold(ip_csum_t c)
Definition: ip_packet.h:145
Definition: udp.h:111
format_function_t format_udp_header
Definition: udp.h:238