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