FD.io VPP  v17.01.1-3-gc6833f8
Vector Packet Processing
decap.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  * @file
17  * @brief L2 LISP-GPE decap code.
18  *
19  */
20 #include <vlib/vlib.h>
21 #include <vnet/pg/pg.h>
22 #include <vnet/lisp-gpe/lisp_gpe.h>
23 
24 typedef struct
25 {
31 
32 static u8 *
33 format_lisp_gpe_rx_trace (u8 * s, va_list * args)
34 {
35  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
36  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
37  lisp_gpe_rx_trace_t *t = va_arg (*args, lisp_gpe_rx_trace_t *);
38 
39  if (t->tunnel_index != ~0)
40  {
41  s = format (s, "LISP-GPE: tunnel %d next %d error %d", t->tunnel_index,
42  t->next_index, t->error);
43  }
44  else
45  {
46  s = format (s, "LISP-GPE: no tunnel next %d error %d\n", t->next_index,
47  t->error);
48  }
49  s = format (s, "\n %U", format_lisp_gpe_header_with_length, &t->h,
50  (u32) sizeof (t->h) /* max size */ );
51  return s;
52 }
53 
55  LISP_GPE_INPUT_NEXT_DROP,
56  LISP_GPE_INPUT_NEXT_IP4_INPUT,
57  LISP_GPE_INPUT_NEXT_IP6_INPUT,
58  LISP_GPE_INPUT_NEXT_L2_INPUT,
59  LISP_GPE_INPUT_NEXT_DROP
60 };
61 
64 {
65  /* lisp-gpe router */
66  if (PREDICT_TRUE ((lgh->flags & LISP_GPE_FLAGS_P)
69  /* legacy lisp router */
70  else if ((lgh->flags & LISP_GPE_FLAGS_P) == 0)
71  {
72  ip4_header_t *iph = (ip4_header_t *) next_header;
73  if ((iph->ip_version_and_header_length & 0xF0) == 0x40)
74  return LISP_GPE_INPUT_NEXT_IP4_INPUT;
75  else if ((iph->ip_version_and_header_length & 0xF0) == 0x60)
76  return LISP_GPE_INPUT_NEXT_IP6_INPUT;
77  else
78  return LISP_GPE_INPUT_NEXT_DROP;
79  }
80  else
81  return LISP_GPE_INPUT_NEXT_DROP;
82 }
83 
86 {
87  if (LISP_GPE_INPUT_NEXT_IP4_INPUT == next_index
88  || LISP_GPE_INPUT_NEXT_IP6_INPUT == next_index)
89  return &lgm->l3_ifaces;
90  else if (LISP_GPE_INPUT_NEXT_L2_INPUT == next_index)
91  return &lgm->l2_ifaces;
92  clib_warning ("next_index not associated to an interface!");
93  return 0;
94 }
95 
97 incr_decap_stats (vnet_main_t * vnm, u32 cpu_index, u32 length,
98  u32 sw_if_index, u32 * last_sw_if_index, u32 * n_packets,
99  u32 * n_bytes)
100 {
102 
103  if (PREDICT_TRUE (sw_if_index == *last_sw_if_index))
104  {
105  *n_packets += 1;
106  *n_bytes += length;
107  }
108  else
109  {
110  if (PREDICT_TRUE (*last_sw_if_index != ~0))
111  {
112  im = &vnm->interface_main;
113 
116  cpu_index, *last_sw_if_index,
117  *n_packets, *n_bytes);
118  }
119  *last_sw_if_index = sw_if_index;
120  *n_packets = 1;
121  *n_bytes = length;
122  }
123 }
124 
125 /**
126  * @brief LISP-GPE decap dispatcher.
127  * @node lisp_gpe_input_inline
128  *
129  * LISP-GPE decap dispatcher.
130  *
131  * Decaps IP-UDP-LISP-GPE header and based on the next protocol and in the
132  * GPE header and the vni decides the next node to forward the packet to.
133  *
134  * @param[in] vm vlib_main_t corresponding to current thread.
135  * @param[in] node vlib_node_runtime_t data for this node.
136  * @param[in] frame vlib_frame_t whose contents should be dispatched.
137  *
138  * @return number of vectors in frame.
139  */
140 static uword
142  vlib_frame_t * from_frame, u8 is_v4)
143 {
144  u32 n_left_from, next_index, *from, *to_next, cpu_index;
145  u32 n_bytes = 0, n_packets = 0, last_sw_if_index = ~0, drops = 0;
147 
148  cpu_index = os_get_cpu_number ();
149  from = vlib_frame_vector_args (from_frame);
150  n_left_from = from_frame->n_vectors;
151 
152  next_index = node->cached_next_index;
153 
154  while (n_left_from > 0)
155  {
156  u32 n_left_to_next;
157 
158  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
159 
160  while (n_left_from >= 4 && n_left_to_next >= 2)
161  {
162  u32 bi0, bi1;
163  vlib_buffer_t *b0, *b1;
164  ip4_udp_lisp_gpe_header_t *iul4_0, *iul4_1;
165  ip6_udp_lisp_gpe_header_t *iul6_0, *iul6_1;
166  lisp_gpe_header_t *lh0, *lh1;
167  u32 next0, next1, error0, error1;
168  uword *si0, *si1;
169  tunnel_lookup_t *tl0, *tl1;
170 
171  /* Prefetch next iteration. */
172  {
173  vlib_buffer_t *p2, *p3;
174 
175  p2 = vlib_get_buffer (vm, from[2]);
176  p3 = vlib_get_buffer (vm, from[3]);
177 
178  vlib_prefetch_buffer_header (p2, LOAD);
179  vlib_prefetch_buffer_header (p3, LOAD);
180 
181  CLIB_PREFETCH (p2->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
182  CLIB_PREFETCH (p3->data, 2 * CLIB_CACHE_LINE_BYTES, LOAD);
183  }
184 
185  bi0 = from[0];
186  bi1 = from[1];
187  to_next[0] = bi0;
188  to_next[1] = bi1;
189  from += 2;
190  to_next += 2;
191  n_left_to_next -= 2;
192  n_left_from -= 2;
193 
194  b0 = vlib_get_buffer (vm, bi0);
195  b1 = vlib_get_buffer (vm, bi1);
196 
197  /* udp leaves current_data pointing at the lisp header */
198  if (is_v4)
199  {
201  -(word) (sizeof (udp_header_t) +
202  sizeof (ip4_header_t)));
204  -(word) (sizeof (udp_header_t) +
205  sizeof (ip4_header_t)));
206 
207  iul4_0 = vlib_buffer_get_current (b0);
208  iul4_1 = vlib_buffer_get_current (b1);
209 
210  /* pop (ip, udp, lisp-gpe) */
211  vlib_buffer_advance (b0, sizeof (*iul4_0));
212  vlib_buffer_advance (b1, sizeof (*iul4_1));
213 
214  lh0 = &iul4_0->lisp;
215  lh1 = &iul4_1->lisp;
216  }
217  else
218  {
220  -(word) (sizeof (udp_header_t) +
221  sizeof (ip6_header_t)));
223  -(word) (sizeof (udp_header_t) +
224  sizeof (ip6_header_t)));
225 
226  iul6_0 = vlib_buffer_get_current (b0);
227  iul6_1 = vlib_buffer_get_current (b1);
228 
229  /* pop (ip, udp, lisp-gpe) */
230  vlib_buffer_advance (b0, sizeof (*iul6_0));
231  vlib_buffer_advance (b1, sizeof (*iul6_1));
232 
233  lh0 = &iul6_0->lisp;
234  lh1 = &iul6_1->lisp;
235  }
236 
237  /* determine next_index from lisp-gpe header */
238  next0 = next_protocol_to_next_index (lh0,
240  next1 = next_protocol_to_next_index (lh1,
242 
243  /* determine if tunnel is l2 or l3 */
244  tl0 = next_index_to_iface (lgm, next0);
245  tl1 = next_index_to_iface (lgm, next1);
246 
247  /* map iid/vni to lisp-gpe sw_if_index which is used by ipx_input to
248  * decide the rx vrf and the input features to be applied */
249  si0 = hash_get (tl0->sw_if_index_by_vni,
250  clib_net_to_host_u32 (lh0->iid));
251  si1 = hash_get (tl1->sw_if_index_by_vni,
252  clib_net_to_host_u32 (lh1->iid));
253 
254 
255  /* Required to make the l2 tag push / pop code work on l2 subifs */
256  vnet_update_l2_len (b0);
257  vnet_update_l2_len (b1);
258 
259  if (si0)
260  {
261  incr_decap_stats (lgm->vnet_main, cpu_index,
262  vlib_buffer_length_in_chain (vm, b0), si0[0],
263  &last_sw_if_index, &n_packets, &n_bytes);
264  vnet_buffer (b0)->sw_if_index[VLIB_RX] = si0[0];
265  error0 = 0;
266  }
267  else
268  {
269  next0 = LISP_GPE_INPUT_NEXT_DROP;
270  error0 = LISP_GPE_ERROR_NO_TUNNEL;
271  drops++;
272  }
273 
274  if (si1)
275  {
276  incr_decap_stats (lgm->vnet_main, cpu_index,
277  vlib_buffer_length_in_chain (vm, b1), si1[0],
278  &last_sw_if_index, &n_packets, &n_bytes);
279  vnet_buffer (b1)->sw_if_index[VLIB_RX] = si1[0];
280  error1 = 0;
281  }
282  else
283  {
284  next1 = LISP_GPE_INPUT_NEXT_DROP;
285  error1 = LISP_GPE_ERROR_NO_TUNNEL;
286  drops++;
287  }
288 
289  b0->error = error0 ? node->errors[error0] : 0;
290  b1->error = error1 ? node->errors[error1] : 0;
291 
293  {
294  lisp_gpe_rx_trace_t *tr = vlib_add_trace (vm, node, b0,
295  sizeof (*tr));
296  tr->next_index = next0;
297  tr->error = error0;
298  tr->h = lh0[0];
299  }
300 
302  {
303  lisp_gpe_rx_trace_t *tr = vlib_add_trace (vm, node, b1,
304  sizeof (*tr));
305  tr->next_index = next1;
306  tr->error = error1;
307  tr->h = lh1[0];
308  }
309 
310  vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
311  n_left_to_next, bi0, bi1, next0,
312  next1);
313  }
314 
315  while (n_left_from > 0 && n_left_to_next > 0)
316  {
317  u32 bi0;
318  vlib_buffer_t *b0;
319  u32 next0;
320  ip4_udp_lisp_gpe_header_t *iul4_0;
321  ip6_udp_lisp_gpe_header_t *iul6_0;
322  lisp_gpe_header_t *lh0;
323  u32 error0;
324  uword *si0;
325  tunnel_lookup_t *tl0;
326 
327  bi0 = from[0];
328  to_next[0] = bi0;
329  from += 1;
330  to_next += 1;
331  n_left_from -= 1;
332  n_left_to_next -= 1;
333 
334  b0 = vlib_get_buffer (vm, bi0);
335 
336  /* udp leaves current_data pointing at the lisp header
337  * TODO: there's no difference in processing between v4 and v6
338  * encapsulated packets so the code should be simplified if ip header
339  * info is not going to be used for dp smrs/dpsec */
340  if (is_v4)
341  {
343  -(word) (sizeof (udp_header_t) +
344  sizeof (ip4_header_t)));
345 
346  iul4_0 = vlib_buffer_get_current (b0);
347 
348  /* pop (ip, udp, lisp-gpe) */
349  vlib_buffer_advance (b0, sizeof (*iul4_0));
350 
351  lh0 = &iul4_0->lisp;
352  }
353  else
354  {
356  -(word) (sizeof (udp_header_t) +
357  sizeof (ip6_header_t)));
358 
359  iul6_0 = vlib_buffer_get_current (b0);
360 
361  /* pop (ip, udp, lisp-gpe) */
362  vlib_buffer_advance (b0, sizeof (*iul6_0));
363 
364  lh0 = &iul6_0->lisp;
365  }
366 
367  /* TODO if security is to be implemented, something similar to RPF,
368  * probably we'd like to check that the peer is allowed to send us
369  * packets. For this, we should use the tunnel table OR check that
370  * we have a mapping for the source eid and that the outer source of
371  * the packet is one of its locators */
372 
373  /* determine next_index from lisp-gpe header */
374  next0 = next_protocol_to_next_index (lh0,
376 
377  /* determine if tunnel is l2 or l3 */
378  tl0 = next_index_to_iface (lgm, next0);
379 
380  /* map iid/vni to lisp-gpe sw_if_index which is used by ipx_input to
381  * decide the rx vrf and the input features to be applied.
382  * NOTE: vni uses only the first 24 bits */
383  si0 = hash_get (tl0->sw_if_index_by_vni,
384  clib_net_to_host_u32 (lh0->iid << 8));
385 
386  /* Required to make the l2 tag push / pop code work on l2 subifs */
387  vnet_update_l2_len (b0);
388 
389  if (si0)
390  {
391  incr_decap_stats (lgm->vnet_main, cpu_index,
392  vlib_buffer_length_in_chain (vm, b0), si0[0],
393  &last_sw_if_index, &n_packets, &n_bytes);
394  vnet_buffer (b0)->sw_if_index[VLIB_RX] = si0[0];
395  error0 = 0;
396  }
397  else
398  {
399  next0 = LISP_GPE_INPUT_NEXT_DROP;
400  error0 = LISP_GPE_ERROR_NO_TUNNEL;
401  drops++;
402  }
403 
404  /* TODO error handling if security is implemented */
405  b0->error = error0 ? node->errors[error0] : 0;
406 
408  {
409  lisp_gpe_rx_trace_t *tr = vlib_add_trace (vm, node, b0,
410  sizeof (*tr));
411  tr->next_index = next0;
412  tr->error = error0;
413  tr->h = lh0[0];
414  }
415 
416  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
417  n_left_to_next, bi0, next0);
418  }
419 
420  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
421  }
422 
423  /* flush iface stats */
424  incr_decap_stats (lgm->vnet_main, cpu_index, 0, ~0, &last_sw_if_index,
425  &n_packets, &n_bytes);
427  LISP_GPE_ERROR_NO_TUNNEL, drops);
428  return from_frame->n_vectors;
429 }
430 
431 static uword
433  vlib_frame_t * from_frame)
434 {
435  return lisp_gpe_input_inline (vm, node, from_frame, 1);
436 }
437 
438 static uword
440  vlib_frame_t * from_frame)
441 {
442  return lisp_gpe_input_inline (vm, node, from_frame, 0);
443 }
444 
446 #define lisp_gpe_error(n,s) s,
448 #undef lisp_gpe_error
449 };
450 
451 /* *INDENT-OFF* */
453  .function = lisp_gpe_ip4_input,
454  .name = "lisp-gpe-ip4-input",
455  /* Takes a vector of packets. */
456  .vector_size = sizeof (u32),
457  .n_next_nodes = LISP_GPE_INPUT_N_NEXT,
458  .next_nodes = {
459 #define _(s,n) [LISP_GPE_INPUT_NEXT_##s] = n,
461 #undef _
462  },
463 
465  .error_strings = lisp_gpe_ip4_input_error_strings,
466 
467  .format_buffer = format_lisp_gpe_header_with_length,
468  .format_trace = format_lisp_gpe_rx_trace,
469  // $$$$ .unformat_buffer = unformat_lisp_gpe_header,
470 };
471 /* *INDENT-ON* */
472 
473 /* *INDENT-OFF* */
475  .function = lisp_gpe_ip6_input,
476  .name = "lisp-gpe-ip6-input",
477  /* Takes a vector of packets. */
478  .vector_size = sizeof (u32),
479  .n_next_nodes = LISP_GPE_INPUT_N_NEXT,
480  .next_nodes = {
481 #define _(s,n) [LISP_GPE_INPUT_NEXT_##s] = n,
483 #undef _
484  },
485 
487  .error_strings = lisp_gpe_ip4_input_error_strings,
488 
489  .format_buffer = format_lisp_gpe_header_with_length,
490  .format_trace = format_lisp_gpe_rx_trace,
491  // $$$$ .unformat_buffer = unformat_lisp_gpe_header,
492 };
493 /* *INDENT-ON* */
494 
495 /*
496  * fd.io coding-style-patch-verification: ON
497  *
498  * Local Variables:
499  * eval: (c-set-style "gnu")
500  * End:
501  */
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:459
#define foreach_lisp_gpe_ip_input_next
Definition: lisp_gpe.h:53
vlib_node_registration_t lisp_gpe_ip4_input_node
(constructor) VLIB_REGISTER_NODE (lisp_gpe_ip4_input_node)
Definition: decap.c:452
#define CLIB_UNUSED(x)
Definition: clib.h:79
vnet_interface_main_t interface_main
Definition: vnet.h:57
#define PREDICT_TRUE(x)
Definition: clib.h:98
static tunnel_lookup_t * next_index_to_iface(lisp_gpe_main_t *lgm, u32 next_index)
Definition: decap.c:85
static uword lisp_gpe_ip4_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: decap.c:432
LISP-GPE global state.
Definition: lisp_gpe.h:89
static_always_inline void incr_decap_stats(vnet_main_t *vnm, u32 cpu_index, u32 length, u32 sw_if_index, u32 *last_sw_if_index, u32 *n_packets, u32 *n_bytes)
Definition: decap.c:97
vlib_error_t * errors
Definition: node.h:419
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:100
static lisp_gpe_main_t * vnet_lisp_gpe_get_main()
Definition: lisp_gpe.h:135
#define static_always_inline
Definition: clib.h:85
static uword lisp_gpe_ip6_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: decap.c:439
#define always_inline
Definition: clib.h:84
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:194
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:615
#define clib_warning(format, args...)
Definition: error.h:59
u8 * format_lisp_gpe_header_with_length(u8 *s, va_list *args)
Definition: interface.c:171
static char * lisp_gpe_ip4_input_error_strings[]
Definition: decap.c:445
vlib_node_registration_t lisp_gpe_ip6_input_node
(constructor) VLIB_REGISTER_NODE (lisp_gpe_ip6_input_node)
Definition: decap.c:474
#define hash_get(h, key)
Definition: hash.h:248
uword os_get_cpu_number(void)
Definition: unix-misc.c:224
#define PREDICT_FALSE(x)
Definition: clib.h:97
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
Definition: buffer_node.h:70
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:216
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:350
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:121
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1113
uword * sw_if_index_by_vni
lookup decap tunnel termination sw_if_index by vni and vice versa
Definition: lisp_gpe.h:82
u16 n_vectors
Definition: node.h:344
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
tunnel_lookup_t l2_ifaces
Definition: lisp_gpe.h:117
vnet_main_t * vnet_main
Definition: lisp_gpe.h:124
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:207
#define ARRAY_LEN(x)
Definition: clib.h:59
LISP-GPE header.
static uword lisp_gpe_input_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u8 is_v4)
LISP-GPE decap dispatcher.
Definition: decap.c:141
u16 cached_next_index
Definition: node.h:463
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 cpu_index, u32 index, u32 packet_increment, u32 byte_increment)
Increment a combined counter.
Definition: counter.h:241
unsigned int u32
Definition: types.h:88
#define vnet_buffer(b)
Definition: buffer.h:361
lisp_gpe_header_t h
Definition: decap.c:29
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:95
u64 uword
Definition: types.h:112
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:55
static u32 next_proto_to_next_index[LISP_GPE_NEXT_PROTOS]
Definition: decap.c:54
i64 word
Definition: types.h:111
unsigned char u8
Definition: types.h:56
tunnel_lookup_t l3_ifaces
Definition: lisp_gpe.h:109
static void vnet_update_l2_len(vlib_buffer_t *b)
Definition: l2_input.h:193
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:253
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:170
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
u8 data[0]
Packet data.
Definition: buffer.h:158
static u32 next_protocol_to_next_index(lisp_gpe_header_t *lgh, u8 *next_header)
Definition: decap.c:63
u8 ip_version_and_header_length
Definition: ip4_packet.h:131
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:85
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:57
LISP-GPE definitions.
Definition: defs.h:46
static u8 * format_lisp_gpe_rx_trace(u8 *s, va_list *args)
Definition: decap.c:33