FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
ip4_full_reass.c
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 
16 /**
17  * @file
18  * @brief IPv4 Full Reassembly.
19  *
20  * This file contains the source code for IPv4 full reassembly.
21  */
22 
23 #include <vppinfra/vec.h>
24 #include <vnet/vnet.h>
25 #include <vnet/ip/ip.h>
26 #include <vppinfra/fifo.h>
27 #include <vppinfra/bihash_16_8.h>
29 #include <stddef.h>
30 
31 #define MSEC_PER_SEC 1000
32 #define IP4_REASS_TIMEOUT_DEFAULT_MS 100
33 #define IP4_REASS_EXPIRE_WALK_INTERVAL_DEFAULT_MS 10000 // 10 seconds default
34 #define IP4_REASS_MAX_REASSEMBLIES_DEFAULT 1024
35 #define IP4_REASS_MAX_REASSEMBLY_LENGTH_DEFAULT 3
36 #define IP4_REASS_HT_LOAD_FACTOR (0.75)
37 
38 #define IP4_REASS_DEBUG_BUFFERS 0
39 #if IP4_REASS_DEBUG_BUFFERS
40 #define IP4_REASS_DEBUG_BUFFER(bi, what) \
41  do \
42  { \
43  u32 _bi = bi; \
44  printf (#what "buffer %u", _bi); \
45  vlib_buffer_t *_b = vlib_get_buffer (vm, _bi); \
46  while (_b->flags & VLIB_BUFFER_NEXT_PRESENT) \
47  { \
48  _bi = _b->next_buffer; \
49  printf ("[%u]", _bi); \
50  _b = vlib_get_buffer (vm, _bi); \
51  } \
52  printf ("\n"); \
53  fflush (stdout); \
54  } \
55  while (0)
56 #else
57 #define IP4_REASS_DEBUG_BUFFER(...)
58 #endif
59 
60 typedef enum
61 {
68 
69 typedef struct
70 {
71  union
72  {
73  struct
74  {
81  };
82  u64 as_u64[2];
83  };
85 
86 typedef union
87 {
88  struct
89  {
92  };
95 
96 typedef union
97 {
98  struct
99  {
102  };
105 
108 {
110  return vnb->ip.reass.range_first - vnb->ip.reass.fragment_first;
111 }
112 
115 {
117  return clib_min (vnb->ip.reass.range_last, vnb->ip.reass.fragment_last) -
118  (vnb->ip.reass.fragment_first +
120 }
121 
122 typedef struct
123 {
124  // hash table key
126  // time when last packet was received
128  // internal id of this reassembly
130  // buffer index of first buffer in this reassembly context
132  // last octet of packet, ~0 until fragment without more_fragments arrives
134  // length of data collected so far
136  // trace operation counter
138  // next index - used by non-feature node
140  // error next index - used by custom apps (~0 if not used)
142  // minimum fragment length for this reassembly - used to estimate MTU
144  // number of fragments in this reassembly
146  // thread owning memory for this context (whose pool contains this ctx)
148  // thread which received fragment with offset 0 and which sends out the
149  // completed reassembly
152 
153 typedef struct
154 {
160 
161 typedef struct
162 {
163  // IPv4 config
167  // maximum number of fragments in one reassembly
169  // maximum number of reassemblies
171 
172  // IPv4 runtime
173  clib_bihash_16_8_t hash;
174  // per-thread data
176 
177  // convenience
179 
180  // node index of ip4-drop node
183 
184  /** Worker handoff */
188 
189  // reference count for enabling/disabling feature - per interface
192 
194 
195 #ifndef CLIB_MARCH_VARIANT
197 #endif /* CLIB_MARCH_VARIANT */
198 
199 typedef enum
200 {
206 
207 typedef enum
208 {
213 
214 typedef enum
215 {
223 
224 typedef struct
225 {
233 
234 typedef struct
235 {
249 
253 
254 static void
257 {
260  trace->range_first = vnb->ip.reass.range_first;
261  trace->range_last = vnb->ip.reass.range_last;
264  trace->range_bi = bi;
265 }
266 
267 static u8 *
269 {
271  va_arg (*args, ip4_full_reass_range_trace_t *);
272  s =
273  format (s, "range: [%u, %u], off %d, len %u, bi %u", trace->range_first,
274  trace->range_last, trace->data_offset, trace->data_len,
275  trace->range_bi);
276  return s;
277 }
278 
279 static u8 *
280 format_ip4_full_reass_trace (u8 * s, va_list * args)
281 {
282  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
283  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
284  ip4_full_reass_trace_t *t = va_arg (*args, ip4_full_reass_trace_t *);
285  u32 indent = 0;
286  if (~0 != t->reass_id)
287  {
288  if (t->is_after_handoff)
289  {
290  s =
291  format (s, "%U\n", format_ip4_header, &t->ip4_header,
292  sizeof (t->ip4_header));
293  indent = 2;
294  }
295  s =
296  format (s, "%Ureass id: %u, op id: %u, ", format_white_space, indent,
297  t->reass_id, t->op_id);
298  indent = format_get_indent (s);
299  s =
300  format (s,
301  "first bi: %u, data len: %u, ip/fragment[%u, %u]",
303  t->fragment_last);
304  }
305  switch (t->action)
306  {
307  case RANGE_SHRINK:
308  s = format (s, "\n%Ushrink %U by %u", format_white_space, indent,
310  t->size_diff);
311  break;
312  case RANGE_DISCARD:
313  s = format (s, "\n%Udiscard %U", format_white_space, indent,
315  break;
316  case RANGE_NEW:
317  s = format (s, "\n%Unew %U", format_white_space, indent,
319  break;
320  case RANGE_OVERLAP:
321  s = format (s, "\n%Uoverlapping/ignored %U", format_white_space, indent,
323  break;
324  case FINALIZE:
325  s = format (s, "\n%Ufinalize reassembly", format_white_space, indent);
326  break;
327  case HANDOFF:
328  s =
329  format (s, "handoff from thread #%u to thread #%u", t->thread_id,
330  t->thread_id_to);
331  break;
332  }
333  return s;
334 }
335 
336 static void
339  ip4_full_reass_t * reass, u32 bi,
341  u32 size_diff, u32 thread_id_to)
342 {
347  {
348  // this buffer's trace is gone
349  b->flags &= ~VLIB_BUFFER_IS_TRACED;
350  return;
351  }
352  bool is_after_handoff = false;
354  {
355  is_after_handoff = true;
356  }
357  ip4_full_reass_trace_t *t = vlib_add_trace (vm, node, b, sizeof (t[0]));
358  t->is_after_handoff = is_after_handoff;
359  if (t->is_after_handoff)
360  {
362  clib_min (sizeof (t->ip4_header), b->current_length));
363  }
364  if (reass)
365  {
366  t->reass_id = reass->id;
367  t->op_id = reass->trace_op_counter;
368  t->trace_range.first_bi = reass->first_bi;
369  t->total_data_len = reass->data_len;
370  ++reass->trace_op_counter;
371  }
372  else
373  {
374  t->reass_id = ~0;
375  t->op_id = 0;
376  t->trace_range.first_bi = 0;
377  t->total_data_len = 0;
378  }
379  t->action = action;
381  t->size_diff = size_diff;
382  t->thread_id = vm->thread_index;
383  t->thread_id_to = thread_id_to;
384  t->fragment_first = vnb->ip.reass.fragment_first;
385  t->fragment_last = vnb->ip.reass.fragment_last;
386 #if 0
387  static u8 *s = NULL;
388  s = format (s, "%U", format_ip4_full_reass_trace, NULL, NULL, t);
389  printf ("%.*s\n", vec_len (s), s);
390  fflush (stdout);
391  vec_reset_length (s);
392 #endif
393 }
394 
395 always_inline void
397  ip4_full_reass_t * reass)
398 {
399  pool_put (rt->pool, reass);
400  --rt->reass_n;
401 }
402 
403 always_inline void
406  ip4_full_reass_t * reass)
407 {
409  kv.key[0] = reass->key.as_u64[0];
410  kv.key[1] = reass->key.as_u64[1];
411  clib_bihash_add_del_16_8 (&rm->hash, &kv, 0);
412  return ip4_full_reass_free_ctx (rt, reass);
413 }
414 
415 always_inline void
418 {
419  u32 range_bi = reass->first_bi;
420  vlib_buffer_t *range_b;
421  vnet_buffer_opaque_t *range_vnb;
422  u32 *to_free = NULL;
423  while (~0 != range_bi)
424  {
425  range_b = vlib_get_buffer (vm, range_bi);
426  range_vnb = vnet_buffer (range_b);
427  u32 bi = range_bi;
428  while (~0 != bi)
429  {
430  vec_add1 (to_free, bi);
432  if (b->flags & VLIB_BUFFER_NEXT_PRESENT)
433  {
434  bi = b->next_buffer;
435  b->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
436  }
437  else
438  {
439  bi = ~0;
440  }
441  }
442  range_bi = range_vnb->ip.reass.next_range_bi;
443  }
444  /* send to next_error_index */
445  if (~0 != reass->error_next_index)
446  {
447  u32 n_left_to_next, *to_next, next_index;
448 
449  next_index = reass->error_next_index;
450  u32 bi = ~0;
451 
452  while (vec_len (to_free) > 0)
453  {
454  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
455 
456  while (vec_len (to_free) > 0 && n_left_to_next > 0)
457  {
458  bi = vec_pop (to_free);
459 
460  if (~0 != bi)
461  {
462  to_next[0] = bi;
463  to_next += 1;
464  n_left_to_next -= 1;
465  }
466  }
467  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
468  }
469  }
470  else
471  {
472  vlib_buffer_free (vm, to_free, vec_len (to_free));
473  }
474  vec_free (to_free);
475 }
476 
477 always_inline void
479 {
480  reass->first_bi = ~0;
481  reass->last_packet_octet = ~0;
482  reass->data_len = 0;
483  reass->next_index = ~0;
484  reass->error_next_index = ~0;
485 }
486 
491  ip4_full_reass_kv_t * kv, u8 * do_handoff)
492 {
493  ip4_full_reass_t *reass;
494  f64 now;
495 
496 again:
497 
498  reass = NULL;
499  now = vlib_time_now (vm);
500  if (!clib_bihash_search_16_8 (&rm->hash, &kv->kv, &kv->kv))
501  {
503  {
504  *do_handoff = 1;
505  return NULL;
506  }
507  reass =
510  kv->v.reass_index);
511 
512  if (now > reass->last_heard + rm->timeout)
513  {
514  ip4_full_reass_drop_all (vm, node, rm, reass);
515  ip4_full_reass_free (rm, rt, reass);
516  reass = NULL;
517  }
518  }
519 
520  if (reass)
521  {
522  reass->last_heard = now;
523  return reass;
524  }
525 
526  if (rt->reass_n >= rm->max_reass_n)
527  {
528  reass = NULL;
529  return reass;
530  }
531  else
532  {
533  pool_get (rt->pool, reass);
534  clib_memset (reass, 0, sizeof (*reass));
535  reass->id = ((u64) vm->thread_index * 1000000000) + rt->id_counter;
537  ++rt->id_counter;
538  ip4_full_reass_init (reass);
539  ++rt->reass_n;
540  }
541 
542  reass->key.as_u64[0] = kv->kv.key[0];
543  reass->key.as_u64[1] = kv->kv.key[1];
544  kv->v.reass_index = (reass - rt->pool);
546  reass->last_heard = now;
547 
548  int rv = clib_bihash_add_del_16_8 (&rm->hash, &kv->kv, 2);
549  if (rv)
550  {
551  ip4_full_reass_free_ctx (rt, reass);
552  reass = NULL;
553  // if other worker created a context already work with the other copy
554  if (-2 == rv)
555  goto again;
556  }
557 
558  return reass;
559 }
560 
565  ip4_full_reass_t * reass, u32 * bi0,
566  u32 * next0, u32 * error0, bool is_custom)
567 {
568  vlib_buffer_t *first_b = vlib_get_buffer (vm, reass->first_bi);
569  vlib_buffer_t *last_b = NULL;
570  u32 sub_chain_bi = reass->first_bi;
571  u32 total_length = 0;
572  u32 buf_cnt = 0;
573  do
574  {
575  u32 tmp_bi = sub_chain_bi;
576  vlib_buffer_t *tmp = vlib_get_buffer (vm, tmp_bi);
579  if (!(vnb->ip.reass.range_first >= vnb->ip.reass.fragment_first) &&
580  !(vnb->ip.reass.range_last > vnb->ip.reass.fragment_first))
581  {
583  }
584 
586  u32 trim_front =
588  u32 trim_end =
589  vlib_buffer_length_in_chain (vm, tmp) - trim_front - data_len;
590  if (tmp_bi == reass->first_bi)
591  {
592  /* first buffer - keep ip4 header */
594  {
596  }
597  trim_front = 0;
598  trim_end = vlib_buffer_length_in_chain (vm, tmp) - data_len -
600  if (!(vlib_buffer_length_in_chain (vm, tmp) - trim_end > 0))
601  {
603  }
604  }
605  u32 keep_data =
606  vlib_buffer_length_in_chain (vm, tmp) - trim_front - trim_end;
607  while (1)
608  {
609  ++buf_cnt;
610  if (trim_front)
611  {
612  if (trim_front > tmp->current_length)
613  {
614  /* drop whole buffer */
615  u32 to_be_freed_bi = tmp_bi;
616  trim_front -= tmp->current_length;
617  if (!(tmp->flags & VLIB_BUFFER_NEXT_PRESENT))
618  {
620  }
621  tmp->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
622  tmp_bi = tmp->next_buffer;
623  tmp->next_buffer = 0;
624  tmp = vlib_get_buffer (vm, tmp_bi);
625  vlib_buffer_free_one (vm, to_be_freed_bi);
626  continue;
627  }
628  else
629  {
630  vlib_buffer_advance (tmp, trim_front);
631  trim_front = 0;
632  }
633  }
634  if (keep_data)
635  {
636  if (last_b)
637  {
638  last_b->flags |= VLIB_BUFFER_NEXT_PRESENT;
639  last_b->next_buffer = tmp_bi;
640  }
641  last_b = tmp;
642  if (keep_data <= tmp->current_length)
643  {
644  tmp->current_length = keep_data;
645  keep_data = 0;
646  }
647  else
648  {
649  keep_data -= tmp->current_length;
650  if (!(tmp->flags & VLIB_BUFFER_NEXT_PRESENT))
651  {
653  }
654  }
655  total_length += tmp->current_length;
656  if (tmp->flags & VLIB_BUFFER_NEXT_PRESENT)
657  {
658  tmp_bi = tmp->next_buffer;
659  tmp = vlib_get_buffer (vm, tmp->next_buffer);
660  }
661  else
662  {
663  break;
664  }
665  }
666  else
667  {
668  u32 to_be_freed_bi = tmp_bi;
669  if (reass->first_bi == tmp_bi)
670  {
672  }
673  if (tmp->flags & VLIB_BUFFER_NEXT_PRESENT)
674  {
675  tmp->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
676  tmp_bi = tmp->next_buffer;
677  tmp->next_buffer = 0;
678  tmp = vlib_get_buffer (vm, tmp_bi);
679  vlib_buffer_free_one (vm, to_be_freed_bi);
680  }
681  else
682  {
683  tmp->next_buffer = 0;
684  vlib_buffer_free_one (vm, to_be_freed_bi);
685  break;
686  }
687  }
688  }
689  sub_chain_bi =
690  vnet_buffer (vlib_get_buffer (vm, sub_chain_bi))->ip.
691  reass.next_range_bi;
692  }
693  while (~0 != sub_chain_bi);
694 
695  if (!last_b)
696  {
698  }
699  last_b->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
700 
701  if (total_length < first_b->current_length)
702  {
704  }
705  total_length -= first_b->current_length;
706  first_b->flags |= VLIB_BUFFER_TOTAL_LENGTH_VALID;
707  first_b->total_length_not_including_first_buffer = total_length;
709  ip->flags_and_fragment_offset = 0;
710  ip->length = clib_host_to_net_u16 (first_b->current_length + total_length);
711  ip->checksum = ip4_header_checksum (ip);
712  if (!vlib_buffer_chain_linearize (vm, first_b))
713  {
714  return IP4_REASS_RC_NO_BUF;
715  }
716  // reset to reconstruct the mbuf linking
717  first_b->flags &= ~VLIB_BUFFER_EXT_HDR_VALID;
718  if (PREDICT_FALSE (first_b->flags & VLIB_BUFFER_IS_TRACED))
719  {
720  ip4_full_reass_add_trace (vm, node, rm, reass, reass->first_bi,
721  FINALIZE, 0, ~0);
722 #if 0
723  // following code does a hexdump of packet fragments to stdout ...
724  do
725  {
726  u32 bi = reass->first_bi;
727  u8 *s = NULL;
728  while (~0 != bi)
729  {
731  s = format (s, "%u: %U\n", bi, format_hexdump,
733  if (b->flags & VLIB_BUFFER_NEXT_PRESENT)
734  {
735  bi = b->next_buffer;
736  }
737  else
738  {
739  break;
740  }
741  }
742  printf ("%.*s\n", vec_len (s), s);
743  fflush (stdout);
744  vec_free (s);
745  }
746  while (0);
747 #endif
748  }
749  *bi0 = reass->first_bi;
750  if (!is_custom)
751  {
752  *next0 = IP4_FULL_REASS_NEXT_INPUT;
753  }
754  else
755  {
756  *next0 = reass->next_index;
757  }
758  vnet_buffer (first_b)->ip.reass.estimated_mtu = reass->min_fragment_length;
759  *error0 = IP4_ERROR_NONE;
760  ip4_full_reass_free (rm, rt, reass);
761  reass = NULL;
762  return IP4_REASS_RC_OK;
763 }
764 
769  ip4_full_reass_t * reass,
770  u32 prev_range_bi, u32 new_next_bi)
771 {
772  vlib_buffer_t *new_next_b = vlib_get_buffer (vm, new_next_bi);
773  vnet_buffer_opaque_t *new_next_vnb = vnet_buffer (new_next_b);
774  if (~0 != prev_range_bi)
775  {
776  vlib_buffer_t *prev_b = vlib_get_buffer (vm, prev_range_bi);
777  vnet_buffer_opaque_t *prev_vnb = vnet_buffer (prev_b);
778  new_next_vnb->ip.reass.next_range_bi = prev_vnb->ip.reass.next_range_bi;
779  prev_vnb->ip.reass.next_range_bi = new_next_bi;
780  }
781  else
782  {
783  if (~0 != reass->first_bi)
784  {
785  new_next_vnb->ip.reass.next_range_bi = reass->first_bi;
786  }
787  reass->first_bi = new_next_bi;
788  }
789  vnet_buffer_opaque_t *vnb = vnet_buffer (new_next_b);
790  if (!(vnb->ip.reass.range_first >= vnb->ip.reass.fragment_first) &&
791  !(vnb->ip.reass.range_last > vnb->ip.reass.fragment_first))
792  {
794  }
795  reass->data_len += ip4_full_reass_buffer_get_data_len (new_next_b);
796  return IP4_REASS_RC_OK;
797 }
798 
803  ip4_full_reass_t * reass,
804  u32 prev_range_bi, u32 discard_bi)
805 {
806  vlib_buffer_t *discard_b = vlib_get_buffer (vm, discard_bi);
807  vnet_buffer_opaque_t *discard_vnb = vnet_buffer (discard_b);
808  if (~0 != prev_range_bi)
809  {
810  vlib_buffer_t *prev_b = vlib_get_buffer (vm, prev_range_bi);
811  vnet_buffer_opaque_t *prev_vnb = vnet_buffer (prev_b);
812  if (!(prev_vnb->ip.reass.next_range_bi == discard_bi))
813  {
815  }
816  prev_vnb->ip.reass.next_range_bi = discard_vnb->ip.reass.next_range_bi;
817  }
818  else
819  {
820  reass->first_bi = discard_vnb->ip.reass.next_range_bi;
821  }
822  vnet_buffer_opaque_t *vnb = vnet_buffer (discard_b);
823  if (!(vnb->ip.reass.range_first >= vnb->ip.reass.fragment_first) &&
824  !(vnb->ip.reass.range_last > vnb->ip.reass.fragment_first))
825  {
827  }
828  reass->data_len -= ip4_full_reass_buffer_get_data_len (discard_b);
829  while (1)
830  {
831  u32 to_be_freed_bi = discard_bi;
832  if (PREDICT_FALSE (discard_b->flags & VLIB_BUFFER_IS_TRACED))
833  {
834  ip4_full_reass_add_trace (vm, node, rm, reass, discard_bi,
835  RANGE_DISCARD, 0, ~0);
836  }
837  if (discard_b->flags & VLIB_BUFFER_NEXT_PRESENT)
838  {
839  discard_b->flags &= ~VLIB_BUFFER_NEXT_PRESENT;
840  discard_bi = discard_b->next_buffer;
841  discard_b->next_buffer = 0;
842  discard_b = vlib_get_buffer (vm, discard_bi);
843  vlib_buffer_free_one (vm, to_be_freed_bi);
844  }
845  else
846  {
847  discard_b->next_buffer = 0;
848  vlib_buffer_free_one (vm, to_be_freed_bi);
849  break;
850  }
851  }
852  return IP4_REASS_RC_OK;
853 }
854 
859  ip4_full_reass_t * reass, u32 * bi0, u32 * next0,
860  u32 * error0, bool is_custom, u32 * handoff_thread_idx)
861 {
862  vlib_buffer_t *fb = vlib_get_buffer (vm, *bi0);
863  vnet_buffer_opaque_t *fvnb = vnet_buffer (fb);
864  if (is_custom)
865  {
866  // store (error_)next_index before it's overwritten
867  reass->next_index = fvnb->ip.reass.next_index;
868  reass->error_next_index = fvnb->ip.reass.error_next_index;
869  }
871  int consumed = 0;
873  const u32 fragment_first = ip4_get_fragment_offset_bytes (fip);
874  const u32 fragment_length =
875  clib_net_to_host_u16 (fip->length) - ip4_header_bytes (fip);
876  const u32 fragment_last = fragment_first + fragment_length - 1;
877  fvnb->ip.reass.fragment_first = fragment_first;
878  fvnb->ip.reass.fragment_last = fragment_last;
879  int more_fragments = ip4_get_fragment_more (fip);
880  u32 candidate_range_bi = reass->first_bi;
881  u32 prev_range_bi = ~0;
882  fvnb->ip.reass.range_first = fragment_first;
883  fvnb->ip.reass.range_last = fragment_last;
884  fvnb->ip.reass.next_range_bi = ~0;
885  if (!more_fragments)
886  {
887  reass->last_packet_octet = fragment_last;
888  }
889  if (~0 == reass->first_bi)
890  {
891  // starting a new reassembly
892  rc =
894  prev_range_bi, *bi0);
895  if (IP4_REASS_RC_OK != rc)
896  {
897  return rc;
898  }
899  if (PREDICT_FALSE (fb->flags & VLIB_BUFFER_IS_TRACED))
900  {
901  ip4_full_reass_add_trace (vm, node, rm, reass, *bi0, RANGE_NEW, 0,
902  ~0);
903  }
904  *bi0 = ~0;
905  reass->min_fragment_length = clib_net_to_host_u16 (fip->length);
906  reass->fragments_n = 1;
907  return IP4_REASS_RC_OK;
908  }
909  reass->min_fragment_length =
910  clib_min (clib_net_to_host_u16 (fip->length),
911  fvnb->ip.reass.estimated_mtu);
912  while (~0 != candidate_range_bi)
913  {
914  vlib_buffer_t *candidate_b = vlib_get_buffer (vm, candidate_range_bi);
915  vnet_buffer_opaque_t *candidate_vnb = vnet_buffer (candidate_b);
916  if (fragment_first > candidate_vnb->ip.reass.range_last)
917  {
918  // this fragments starts after candidate range
919  prev_range_bi = candidate_range_bi;
920  candidate_range_bi = candidate_vnb->ip.reass.next_range_bi;
921  if (candidate_vnb->ip.reass.range_last < fragment_last &&
922  ~0 == candidate_range_bi)
923  {
924  // special case - this fragment falls beyond all known ranges
925  rc =
927  prev_range_bi, *bi0);
928  if (IP4_REASS_RC_OK != rc)
929  {
930  return rc;
931  }
932  consumed = 1;
933  break;
934  }
935  continue;
936  }
937  if (fragment_last < candidate_vnb->ip.reass.range_first)
938  {
939  // this fragment ends before candidate range without any overlap
940  rc =
942  prev_range_bi, *bi0);
943  if (IP4_REASS_RC_OK != rc)
944  {
945  return rc;
946  }
947  consumed = 1;
948  }
949  else
950  {
951  if (fragment_first >= candidate_vnb->ip.reass.range_first &&
952  fragment_last <= candidate_vnb->ip.reass.range_last)
953  {
954  // this fragment is a (sub)part of existing range, ignore it
955  if (PREDICT_FALSE (fb->flags & VLIB_BUFFER_IS_TRACED))
956  {
957  ip4_full_reass_add_trace (vm, node, rm, reass, *bi0,
958  RANGE_OVERLAP, 0, ~0);
959  }
960  break;
961  }
962  int discard_candidate = 0;
963  if (fragment_first < candidate_vnb->ip.reass.range_first)
964  {
965  u32 overlap =
966  fragment_last - candidate_vnb->ip.reass.range_first + 1;
967  if (overlap < ip4_full_reass_buffer_get_data_len (candidate_b))
968  {
969  candidate_vnb->ip.reass.range_first += overlap;
970  if (reass->data_len < overlap)
971  {
973  }
974  reass->data_len -= overlap;
975  if (PREDICT_FALSE (fb->flags & VLIB_BUFFER_IS_TRACED))
976  {
977  ip4_full_reass_add_trace (vm, node, rm, reass,
978  candidate_range_bi,
979  RANGE_SHRINK, 0, ~0);
980  }
981  rc =
983  prev_range_bi,
984  *bi0);
985  if (IP4_REASS_RC_OK != rc)
986  {
987  return rc;
988  }
989  consumed = 1;
990  }
991  else
992  {
993  discard_candidate = 1;
994  }
995  }
996  else if (fragment_last > candidate_vnb->ip.reass.range_last)
997  {
998  u32 overlap =
999  candidate_vnb->ip.reass.range_last - fragment_first + 1;
1000  if (overlap < ip4_full_reass_buffer_get_data_len (candidate_b))
1001  {
1002  fvnb->ip.reass.range_first += overlap;
1003  if (~0 != candidate_vnb->ip.reass.next_range_bi)
1004  {
1005  prev_range_bi = candidate_range_bi;
1006  candidate_range_bi =
1007  candidate_vnb->ip.reass.next_range_bi;
1008  continue;
1009  }
1010  else
1011  {
1012  // special case - last range discarded
1013  rc =
1015  reass,
1016  candidate_range_bi,
1017  *bi0);
1018  if (IP4_REASS_RC_OK != rc)
1019  {
1020  return rc;
1021  }
1022  consumed = 1;
1023  }
1024  }
1025  else
1026  {
1027  discard_candidate = 1;
1028  }
1029  }
1030  else
1031  {
1032  discard_candidate = 1;
1033  }
1034  if (discard_candidate)
1035  {
1036  u32 next_range_bi = candidate_vnb->ip.reass.next_range_bi;
1037  // discard candidate range, probe next range
1038  rc =
1040  prev_range_bi,
1041  candidate_range_bi);
1042  if (IP4_REASS_RC_OK != rc)
1043  {
1044  return rc;
1045  }
1046  if (~0 != next_range_bi)
1047  {
1048  candidate_range_bi = next_range_bi;
1049  continue;
1050  }
1051  else
1052  {
1053  // special case - last range discarded
1054  rc =
1056  prev_range_bi,
1057  *bi0);
1058  if (IP4_REASS_RC_OK != rc)
1059  {
1060  return rc;
1061  }
1062  consumed = 1;
1063  }
1064  }
1065  }
1066  break;
1067  }
1068  ++reass->fragments_n;
1069  if (consumed)
1070  {
1071  if (PREDICT_FALSE (fb->flags & VLIB_BUFFER_IS_TRACED))
1072  {
1073  ip4_full_reass_add_trace (vm, node, rm, reass, *bi0, RANGE_NEW, 0,
1074  ~0);
1075  }
1076  }
1077  if (~0 != reass->last_packet_octet &&
1078  reass->data_len == reass->last_packet_octet + 1)
1079  {
1080  *handoff_thread_idx = reass->sendout_thread_index;
1081  int handoff =
1083  rc =
1084  ip4_full_reass_finalize (vm, node, rm, rt, reass, bi0, next0, error0,
1085  is_custom);
1086  if (IP4_REASS_RC_OK == rc && handoff)
1087  {
1088  rc = IP4_REASS_RC_HANDOFF;
1089  }
1090  }
1091  else
1092  {
1093  if (consumed)
1094  {
1095  *bi0 = ~0;
1096  if (reass->fragments_n > rm->max_reass_len)
1097  {
1099  }
1100  }
1101  else
1102  {
1103  *next0 = IP4_FULL_REASS_NEXT_DROP;
1104  *error0 = IP4_ERROR_REASS_DUPLICATE_FRAGMENT;
1105  }
1106  }
1107  return rc;
1108 }
1109 
1113 {
1115  u32 n_left_from, n_left_to_next, *to_next, next_index;
1118  clib_spinlock_lock (&rt->lock);
1119 
1120  n_left_from = frame->n_vectors;
1121  next_index = node->cached_next_index;
1122  while (n_left_from > 0)
1123  {
1124  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1125 
1126  while (n_left_from > 0 && n_left_to_next > 0)
1127  {
1128  u32 bi0;
1129  vlib_buffer_t *b0;
1130  u32 next0;
1131  u32 error0 = IP4_ERROR_NONE;
1132 
1133  bi0 = from[0];
1134  b0 = vlib_get_buffer (vm, bi0);
1135 
1137  if (!ip4_get_fragment_more (ip0) && !ip4_get_fragment_offset (ip0))
1138  {
1139  // this is a whole packet - no fragmentation
1140  if (CUSTOM != type)
1141  {
1142  next0 = IP4_FULL_REASS_NEXT_INPUT;
1143  }
1144  else
1145  {
1146  next0 = vnet_buffer (b0)->ip.reass.next_index;
1147  }
1148  goto packet_enqueue;
1149  }
1150  const u32 fragment_first = ip4_get_fragment_offset_bytes (ip0);
1151  const u32 fragment_length =
1152  clib_net_to_host_u16 (ip0->length) - ip4_header_bytes (ip0);
1153  const u32 fragment_last = fragment_first + fragment_length - 1;
1154  if (fragment_first > fragment_last || fragment_first + fragment_length > UINT16_MAX - 20 || (fragment_length < 8 && ip4_get_fragment_more (ip0))) // 8 is minimum frag length per RFC 791
1155  {
1156  next0 = IP4_FULL_REASS_NEXT_DROP;
1157  error0 = IP4_ERROR_REASS_MALFORMED_PACKET;
1158  goto packet_enqueue;
1159  }
1161  u8 do_handoff = 0;
1162 
1163  kv.k.as_u64[0] =
1165  vnet_buffer (b0)->sw_if_index[VLIB_RX]) |
1166  (u64) ip0->src_address.as_u32 << 32;
1167  kv.k.as_u64[1] =
1168  (u64) ip0->dst_address.
1169  as_u32 | (u64) ip0->fragment_id << 32 | (u64) ip0->protocol << 48;
1170 
1171  ip4_full_reass_t *reass =
1173  &do_handoff);
1174 
1175  if (reass)
1176  {
1177  const u32 fragment_first = ip4_get_fragment_offset_bytes (ip0);
1178  if (0 == fragment_first)
1179  {
1180  reass->sendout_thread_index = vm->thread_index;
1181  }
1182  }
1183 
1184  if (PREDICT_FALSE (do_handoff))
1185  {
1187  vnet_buffer (b0)->ip.reass.owner_thread_index =
1189  }
1190  else if (reass)
1191  {
1192  u32 handoff_thread_idx;
1193  switch (ip4_full_reass_update
1194  (vm, node, rm, rt, reass, &bi0, &next0,
1195  &error0, CUSTOM == type, &handoff_thread_idx))
1196  {
1197  case IP4_REASS_RC_OK:
1198  /* nothing to do here */
1199  break;
1200  case IP4_REASS_RC_HANDOFF:
1202  b0 = vlib_get_buffer (vm, bi0);
1203  vnet_buffer (b0)->ip.reass.owner_thread_index =
1204  handoff_thread_idx;
1205  break;
1207  vlib_node_increment_counter (vm, node->node_index,
1208  IP4_ERROR_REASS_FRAGMENT_CHAIN_TOO_LONG,
1209  1);
1210  ip4_full_reass_drop_all (vm, node, rm, reass);
1211  ip4_full_reass_free (rm, rt, reass);
1212  goto next_packet;
1213  break;
1214  case IP4_REASS_RC_NO_BUF:
1215  vlib_node_increment_counter (vm, node->node_index,
1216  IP4_ERROR_REASS_NO_BUF, 1);
1217  ip4_full_reass_drop_all (vm, node, rm, reass);
1218  ip4_full_reass_free (rm, rt, reass);
1219  goto next_packet;
1220  break;
1222  /* drop everything and start with a clean slate */
1223  vlib_node_increment_counter (vm, node->node_index,
1224  IP4_ERROR_REASS_INTERNAL_ERROR,
1225  1);
1226  ip4_full_reass_drop_all (vm, node, rm, reass);
1227  ip4_full_reass_free (rm, rt, reass);
1228  goto next_packet;
1229  break;
1230  }
1231  }
1232  else
1233  {
1234  next0 = IP4_FULL_REASS_NEXT_DROP;
1235  error0 = IP4_ERROR_REASS_LIMIT_REACHED;
1236  }
1237 
1238 
1239  packet_enqueue:
1240 
1241  if (bi0 != ~0)
1242  {
1243  to_next[0] = bi0;
1244  to_next += 1;
1245  n_left_to_next -= 1;
1246 
1247  /* bi0 might have been updated by reass_finalize, reload */
1248  b0 = vlib_get_buffer (vm, bi0);
1249  if (IP4_ERROR_NONE != error0)
1250  {
1251  b0->error = node->errors[error0];
1252  }
1253 
1254  if (next0 == IP4_FULL_REASS_NEXT_HANDOFF)
1255  {
1256  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
1257  {
1258  ip4_full_reass_add_trace (vm, node, rm, NULL, bi0,
1259  HANDOFF, 0,
1260  vnet_buffer (b0)->ip.
1261  reass.owner_thread_index);
1262  }
1263  }
1264  else if (FEATURE == type && IP4_ERROR_NONE == error0)
1265  {
1266  vnet_feature_next (&next0, b0);
1267  }
1269  to_next, n_left_to_next,
1270  bi0, next0);
1271  IP4_REASS_DEBUG_BUFFER (bi0, enqueue_next);
1272  }
1273 
1274  next_packet:
1275  from += 1;
1276  n_left_from -= 1;
1277  }
1278 
1279  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1280  }
1281 
1282  clib_spinlock_unlock (&rt->lock);
1283  return frame->n_vectors;
1284 }
1285 
1287 #define _(sym, string) string,
1289 #undef _
1290 };
1291 
1294  vlib_frame_t * frame)
1295 {
1297 }
1298 
1299 /* *INDENT-OFF* */
1301  .name = "ip4-full-reassembly",
1302  .vector_size = sizeof (u32),
1303  .format_trace = format_ip4_full_reass_trace,
1305  .error_strings = ip4_full_reass_error_strings,
1306  .n_next_nodes = IP4_FULL_REASS_N_NEXT,
1307  .next_nodes =
1308  {
1309  [IP4_FULL_REASS_NEXT_INPUT] = "ip4-input",
1310  [IP4_FULL_REASS_NEXT_DROP] = "ip4-drop",
1311  [IP4_FULL_REASS_NEXT_HANDOFF] = "ip4-full-reassembly-handoff",
1312 
1313  },
1314 };
1315 /* *INDENT-ON* */
1316 
1319  vlib_frame_t * frame)
1320 {
1322 }
1323 
1324 /* *INDENT-OFF* */
1326  .name = "ip4-full-reassembly-feature",
1327  .vector_size = sizeof (u32),
1328  .format_trace = format_ip4_full_reass_trace,
1330  .error_strings = ip4_full_reass_error_strings,
1331  .n_next_nodes = IP4_FULL_REASS_N_NEXT,
1332  .next_nodes =
1333  {
1334  [IP4_FULL_REASS_NEXT_INPUT] = "ip4-input",
1335  [IP4_FULL_REASS_NEXT_DROP] = "ip4-drop",
1336  [IP4_FULL_REASS_NEXT_HANDOFF] = "ip4-full-reass-feature-hoff",
1337  },
1338 };
1339 /* *INDENT-ON* */
1340 
1341 /* *INDENT-OFF* */
1342 VNET_FEATURE_INIT (ip4_full_reass_feature, static) = {
1343  .arc_name = "ip4-unicast",
1344  .node_name = "ip4-full-reassembly-feature",
1345  .runs_before = VNET_FEATURES ("ip4-lookup",
1346  "ipsec4-input-feature"),
1347  .runs_after = 0,
1348 };
1349 /* *INDENT-ON* */
1350 
1353  vlib_frame_t * frame)
1354 {
1356 }
1357 
1358 /* *INDENT-OFF* */
1360  .name = "ip4-full-reassembly-custom",
1361  .vector_size = sizeof (u32),
1362  .format_trace = format_ip4_full_reass_trace,
1364  .error_strings = ip4_full_reass_error_strings,
1365  .n_next_nodes = IP4_FULL_REASS_N_NEXT,
1366  .next_nodes =
1367  {
1368  [IP4_FULL_REASS_NEXT_INPUT] = "ip4-input",
1369  [IP4_FULL_REASS_NEXT_DROP] = "ip4-drop",
1370  [IP4_FULL_REASS_NEXT_HANDOFF] = "ip4-full-reass-custom-hoff",
1371  },
1372 };
1373 /* *INDENT-ON* */
1374 
1375 /* *INDENT-OFF* */
1376 VNET_FEATURE_INIT (ip4_full_reass_custom, static) = {
1377  .arc_name = "ip4-unicast",
1378  .node_name = "ip4-full-reassembly-feature",
1379  .runs_before = VNET_FEATURES ("ip4-lookup",
1380  "ipsec4-input-feature"),
1381  .runs_after = 0,
1382 };
1383 
1384 /* *INDENT-ON* */
1385 
1386 #ifndef CLIB_MARCH_VARIANT
1387 uword
1389 {
1390  return vlib_node_add_next (vlib_get_main (),
1392 }
1393 
1396 {
1398  u32 nbuckets;
1399  u8 i;
1400 
1401  nbuckets = (u32) (rm->max_reass_n / IP4_REASS_HT_LOAD_FACTOR);
1402 
1403  for (i = 0; i < 31; i++)
1404  if ((1 << i) >= nbuckets)
1405  break;
1406  nbuckets = 1 << i;
1407 
1408  return nbuckets;
1409 }
1410 #endif /* CLIB_MARCH_VARIANT */
1411 
1412 typedef enum
1413 {
1416 
1417 typedef struct
1418 {
1419  int failure;
1420  clib_bihash_16_8_t *new_hash;
1422 
1423 #ifndef CLIB_MARCH_VARIANT
1424 static int
1426 {
1427  ip4_rehash_cb_ctx *ctx = _ctx;
1428  if (clib_bihash_add_del_16_8 (ctx->new_hash, kv, 1))
1429  {
1430  ctx->failure = 1;
1431  }
1432  return (BIHASH_WALK_CONTINUE);
1433 }
1434 
1435 static void
1436 ip4_full_reass_set_params (u32 timeout_ms, u32 max_reassemblies,
1437  u32 max_reassembly_length,
1438  u32 expire_walk_interval_ms)
1439 {
1440  ip4_full_reass_main.timeout_ms = timeout_ms;
1441  ip4_full_reass_main.timeout = (f64) timeout_ms / (f64) MSEC_PER_SEC;
1442  ip4_full_reass_main.max_reass_n = max_reassemblies;
1443  ip4_full_reass_main.max_reass_len = max_reassembly_length;
1444  ip4_full_reass_main.expire_walk_interval_ms = expire_walk_interval_ms;
1445 }
1446 
1448 ip4_full_reass_set (u32 timeout_ms, u32 max_reassemblies,
1449  u32 max_reassembly_length, u32 expire_walk_interval_ms)
1450 {
1451  u32 old_nbuckets = ip4_full_reass_get_nbuckets ();
1452  ip4_full_reass_set_params (timeout_ms, max_reassemblies,
1453  max_reassembly_length, expire_walk_interval_ms);
1457  u32 new_nbuckets = ip4_full_reass_get_nbuckets ();
1458  if (ip4_full_reass_main.max_reass_n > 0 && new_nbuckets > old_nbuckets)
1459  {
1460  clib_bihash_16_8_t new_hash;
1461  clib_memset (&new_hash, 0, sizeof (new_hash));
1463  ctx.failure = 0;
1464  ctx.new_hash = &new_hash;
1465  clib_bihash_init_16_8 (&new_hash, "ip4-dr", new_nbuckets,
1466  new_nbuckets * 1024);
1467  clib_bihash_foreach_key_value_pair_16_8 (&ip4_full_reass_main.hash,
1468  ip4_rehash_cb, &ctx);
1469  if (ctx.failure)
1470  {
1471  clib_bihash_free_16_8 (&new_hash);
1472  return -1;
1473  }
1474  else
1475  {
1476  clib_bihash_free_16_8 (&ip4_full_reass_main.hash);
1478  sizeof (ip4_full_reass_main.hash));
1480  }
1481  }
1482  return 0;
1483 }
1484 
1486 ip4_full_reass_get (u32 * timeout_ms, u32 * max_reassemblies,
1487  u32 * max_reassembly_length,
1488  u32 * expire_walk_interval_ms)
1489 {
1490  *timeout_ms = ip4_full_reass_main.timeout_ms;
1491  *max_reassemblies = ip4_full_reass_main.max_reass_n;
1492  *max_reassembly_length = ip4_full_reass_main.max_reass_len;
1493  *expire_walk_interval_ms = ip4_full_reass_main.expire_walk_interval_ms;
1494  return 0;
1495 }
1496 
1497 static clib_error_t *
1499 {
1501  clib_error_t *error = 0;
1502  u32 nbuckets;
1503  vlib_node_t *node;
1504 
1505  rm->vlib_main = vm;
1506 
1510  {
1511  clib_spinlock_init (&rt->lock);
1512  pool_alloc (rt->pool, rm->max_reass_n);
1513  }
1514 
1515  node = vlib_get_node_by_name (vm, (u8 *) "ip4-full-reassembly-expire-walk");
1516  ASSERT (node);
1517  rm->ip4_full_reass_expire_node_idx = node->index;
1518 
1523 
1524  nbuckets = ip4_full_reass_get_nbuckets ();
1525  clib_bihash_init_16_8 (&rm->hash, "ip4-dr", nbuckets, nbuckets * 1024);
1526 
1527  node = vlib_get_node_by_name (vm, (u8 *) "ip4-drop");
1528  ASSERT (node);
1529  rm->ip4_drop_idx = node->index;
1530 
1532  rm->fq_feature_index =
1534  rm->fq_custom_index =
1536 
1537  rm->feature_use_refcount_per_intf = NULL;
1538  return error;
1539 }
1540 
1542 #endif /* CLIB_MARCH_VARIANT */
1543 
1544 static uword
1547 {
1549  uword event_type, *event_data = 0;
1550 
1551  while (true)
1552  {
1554  (f64)
1556  (f64) MSEC_PER_SEC);
1557  event_type = vlib_process_get_events (vm, &event_data);
1558 
1559  switch (event_type)
1560  {
1561  case ~0: /* no events => timeout */
1562  /* nothing to do here */
1563  break;
1565  break;
1566  default:
1567  clib_warning ("BUG: event type 0x%wx", event_type);
1568  break;
1569  }
1570  f64 now = vlib_time_now (vm);
1571 
1572  ip4_full_reass_t *reass;
1573  int *pool_indexes_to_free = NULL;
1574 
1575  uword thread_index = 0;
1576  int index;
1577  const uword nthreads = vlib_num_workers () + 1;
1578  for (thread_index = 0; thread_index < nthreads; ++thread_index)
1579  {
1582  clib_spinlock_lock (&rt->lock);
1583 
1584  vec_reset_length (pool_indexes_to_free);
1585  /* *INDENT-OFF* */
1586  pool_foreach_index (index, rt->pool) {
1587  reass = pool_elt_at_index (rt->pool, index);
1588  if (now > reass->last_heard + rm->timeout)
1589  {
1590  vec_add1 (pool_indexes_to_free, index);
1591  }
1592  }
1593  /* *INDENT-ON* */
1594  int *i;
1595  /* *INDENT-OFF* */
1596  vec_foreach (i, pool_indexes_to_free)
1597  {
1598  ip4_full_reass_t *reass = pool_elt_at_index (rt->pool, i[0]);
1599  ip4_full_reass_drop_all (vm, node, rm, reass);
1600  ip4_full_reass_free (rm, rt, reass);
1601  }
1602  /* *INDENT-ON* */
1603 
1604  clib_spinlock_unlock (&rt->lock);
1605  }
1606 
1607  vec_free (pool_indexes_to_free);
1608  if (event_data)
1609  {
1610  _vec_len (event_data) = 0;
1611  }
1612  }
1613 
1614  return 0;
1615 }
1616 
1617 /* *INDENT-OFF* */
1619  .function = ip4_full_reass_walk_expired,
1620  .type = VLIB_NODE_TYPE_PROCESS,
1621  .name = "ip4-full-reassembly-expire-walk",
1622  .format_trace = format_ip4_full_reass_trace,
1624  .error_strings = ip4_full_reass_error_strings,
1625 
1626 };
1627 /* *INDENT-ON* */
1628 
1629 static u8 *
1630 format_ip4_full_reass_key (u8 * s, va_list * args)
1631 {
1632  ip4_full_reass_key_t *key = va_arg (*args, ip4_full_reass_key_t *);
1633  s =
1634  format (s,
1635  "xx_id: %u, src: %U, dst: %U, frag_id: %u, proto: %u",
1636  key->xx_id, format_ip4_address, &key->src, format_ip4_address,
1637  &key->dst, clib_net_to_host_u16 (key->frag_id), key->proto);
1638  return s;
1639 }
1640 
1641 static u8 *
1642 format_ip4_reass (u8 * s, va_list * args)
1643 {
1644  vlib_main_t *vm = va_arg (*args, vlib_main_t *);
1645  ip4_full_reass_t *reass = va_arg (*args, ip4_full_reass_t *);
1646 
1647  s = format (s, "ID: %lu, key: %U\n first_bi: %u, data_len: %u, "
1648  "last_packet_octet: %u, trace_op_counter: %u\n",
1649  reass->id, format_ip4_full_reass_key, &reass->key,
1650  reass->first_bi, reass->data_len,
1651  reass->last_packet_octet, reass->trace_op_counter);
1652 
1653  u32 bi = reass->first_bi;
1654  u32 counter = 0;
1655  while (~0 != bi)
1656  {
1657  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
1659  s =
1660  format (s,
1661  " #%03u: range: [%u, %u], bi: %u, off: %d, len: %u, "
1662  "fragment[%u, %u]\n", counter, vnb->ip.reass.range_first,
1663  vnb->ip.reass.range_last, bi,
1666  vnb->ip.reass.fragment_first, vnb->ip.reass.fragment_last);
1667  if (b->flags & VLIB_BUFFER_NEXT_PRESENT)
1668  {
1669  bi = b->next_buffer;
1670  }
1671  else
1672  {
1673  bi = ~0;
1674  }
1675  }
1676  return s;
1677 }
1678 
1679 static clib_error_t *
1681  unformat_input_t * input,
1683 {
1685 
1686  vlib_cli_output (vm, "---------------------");
1687  vlib_cli_output (vm, "IP4 reassembly status");
1688  vlib_cli_output (vm, "---------------------");
1689  bool details = false;
1690  if (unformat (input, "details"))
1691  {
1692  details = true;
1693  }
1694 
1695  u32 sum_reass_n = 0;
1696  ip4_full_reass_t *reass;
1698  const uword nthreads = vlib_num_workers () + 1;
1699  for (thread_index = 0; thread_index < nthreads; ++thread_index)
1700  {
1702  clib_spinlock_lock (&rt->lock);
1703  if (details)
1704  {
1705  /* *INDENT-OFF* */
1706  pool_foreach (reass, rt->pool) {
1707  vlib_cli_output (vm, "%U", format_ip4_reass, vm, reass);
1708  }
1709  /* *INDENT-ON* */
1710  }
1711  sum_reass_n += rt->reass_n;
1712  clib_spinlock_unlock (&rt->lock);
1713  }
1714  vlib_cli_output (vm, "---------------------");
1715  vlib_cli_output (vm, "Current full IP4 reassemblies count: %lu\n",
1716  (long unsigned) sum_reass_n);
1718  "Maximum configured concurrent full IP4 reassemblies per worker-thread: %lu\n",
1719  (long unsigned) rm->max_reass_n);
1721  "Maximum configured amount of fragments "
1722  "per full IP4 reassembly: %lu\n",
1723  (long unsigned) rm->max_reass_len);
1725  "Maximum configured full IP4 reassembly timeout: %lums\n",
1726  (long unsigned) rm->timeout_ms);
1728  "Maximum configured full IP4 reassembly expire walk interval: %lums\n",
1729  (long unsigned) rm->expire_walk_interval_ms);
1730  return 0;
1731 }
1732 
1733 /* *INDENT-OFF* */
1735  .path = "show ip4-full-reassembly",
1736  .short_help = "show ip4-full-reassembly [details]",
1737  .function = show_ip4_reass,
1738 };
1739 /* *INDENT-ON* */
1740 
1741 #ifndef CLIB_MARCH_VARIANT
1744 {
1745  return vnet_feature_enable_disable ("ip4-unicast",
1746  "ip4-full-reassembly-feature",
1747  sw_if_index, enable_disable, 0, 0);
1748 }
1749 #endif /* CLIB_MARCH_VARIANT */
1750 
1751 
1752 #define foreach_ip4_full_reass_handoff_error \
1753 _(CONGESTION_DROP, "congestion drop")
1754 
1755 
1756 typedef enum
1757 {
1758 #define _(sym,str) IP4_FULL_REASS_HANDOFF_ERROR_##sym,
1760 #undef _
1763 
1765 #define _(sym,string) string,
1767 #undef _
1768 };
1769 
1770 typedef struct
1771 {
1774 
1775 static u8 *
1777 {
1778  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1779  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1781  va_arg (*args, ip4_full_reass_handoff_trace_t *);
1782 
1783  s =
1784  format (s, "ip4-full-reassembly-handoff: next-worker %d",
1785  t->next_worker_index);
1786 
1787  return s;
1788 }
1789 
1793  vlib_frame_t * frame,
1795 {
1797 
1799  u32 n_enq, n_left_from, *from;
1800  u16 thread_indices[VLIB_FRAME_SIZE], *ti;
1801  u32 fq_index;
1802 
1804  n_left_from = frame->n_vectors;
1806 
1807  b = bufs;
1808  ti = thread_indices;
1809 
1810  switch (type)
1811  {
1812  case NORMAL:
1813  fq_index = rm->fq_index;
1814  break;
1815  case FEATURE:
1816  fq_index = rm->fq_feature_index;
1817  break;
1818  case CUSTOM:
1819  fq_index = rm->fq_custom_index;
1820  break;
1821  default:
1822  clib_warning ("Unexpected `type' (%d)!", type);
1823  ASSERT (0);
1824  }
1825 
1826  while (n_left_from > 0)
1827  {
1828  ti[0] = vnet_buffer (b[0])->ip.reass.owner_thread_index;
1829 
1830  if (PREDICT_FALSE
1831  ((node->flags & VLIB_NODE_FLAG_TRACE)
1832  && (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
1833  {
1835  vlib_add_trace (vm, node, b[0], sizeof (*t));
1836  t->next_worker_index = ti[0];
1837  }
1838 
1839  n_left_from -= 1;
1840  ti += 1;
1841  b += 1;
1842  }
1843  n_enq = vlib_buffer_enqueue_to_thread (vm, node, fq_index, from,
1844  thread_indices, frame->n_vectors, 1);
1845 
1846  if (n_enq < frame->n_vectors)
1847  vlib_node_increment_counter (vm, node->node_index,
1848  IP4_FULL_REASS_HANDOFF_ERROR_CONGESTION_DROP,
1849  frame->n_vectors - n_enq);
1850  return frame->n_vectors;
1851 }
1852 
1855  vlib_frame_t * frame)
1856 {
1858 }
1859 
1860 
1861 /* *INDENT-OFF* */
1863  .name = "ip4-full-reassembly-handoff",
1864  .vector_size = sizeof (u32),
1866  .error_strings = ip4_full_reass_handoff_error_strings,
1867  .format_trace = format_ip4_full_reass_handoff_trace,
1868 
1869  .n_next_nodes = 1,
1870 
1871  .next_nodes = {
1872  [0] = "error-drop",
1873  },
1874 };
1875 /* *INDENT-ON* */
1876 
1877 
1878 /* *INDENT-OFF* */
1881  node,
1882  vlib_frame_t * frame)
1883 {
1885 }
1886 /* *INDENT-ON* */
1887 
1888 
1889 /* *INDENT-OFF* */
1891  .name = "ip4-full-reass-feature-hoff",
1892  .vector_size = sizeof (u32),
1894  .error_strings = ip4_full_reass_handoff_error_strings,
1895  .format_trace = format_ip4_full_reass_handoff_trace,
1896 
1897  .n_next_nodes = 1,
1898 
1899  .next_nodes = {
1900  [0] = "error-drop",
1901  },
1902 };
1903 /* *INDENT-ON* */
1904 
1905 /* *INDENT-OFF* */
1908  node,
1909  vlib_frame_t * frame)
1910 {
1912 }
1913 /* *INDENT-ON* */
1914 
1915 
1916 /* *INDENT-OFF* */
1918  .name = "ip4-full-reass-custom-hoff",
1919  .vector_size = sizeof (u32),
1921  .error_strings = ip4_full_reass_handoff_error_strings,
1922  .format_trace = format_ip4_full_reass_handoff_trace,
1923 
1924  .n_next_nodes = 1,
1925 
1926  .next_nodes = {
1927  [0] = "error-drop",
1928  },
1929 };
1930 /* *INDENT-ON* */
1931 
1932 #ifndef CLIB_MARCH_VARIANT
1933 int
1935 {
1938  if (is_enable)
1939  {
1941  {
1943  return vnet_feature_enable_disable ("ip4-unicast",
1944  "ip4-full-reassembly-feature",
1945  sw_if_index, 1, 0, 0);
1946  }
1948  }
1949  else
1950  {
1953  return vnet_feature_enable_disable ("ip4-unicast",
1954  "ip4-full-reassembly-feature",
1955  sw_if_index, 0, 0, 0);
1956  }
1957  return -1;
1958 }
1959 #endif
1960 
1961 /*
1962  * fd.io coding-style-patch-verification: ON
1963  *
1964  * Local Variables:
1965  * eval: (c-set-style "gnu")
1966  * End:
1967  */
vec_reset_length
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
Definition: vec_bootstrap.h:194
clib_spinlock_init
static void clib_spinlock_init(clib_spinlock_t *p)
Definition: lock.h:65
ip4_full_reass_key_t::dst
ip4_address_t dst
Definition: ip4_full_reass.c:77
tmp
u32 * tmp
Definition: interface_output.c:1078
vlib_buffer_t::next_buffer
u32 next_buffer
Next buffer for this linked-list of buffers.
Definition: buffer.h:149
ip4_full_reass_key_t::xx_id
u32 xx_id
Definition: ip4_full_reass.c:75
ip4_full_reass_get_nbuckets
static u32 ip4_full_reass_get_nbuckets()
Definition: ip4_full_reass.c:1395
vlib_buffer_free
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
Definition: buffer_funcs.h:982
ip4_full_reass_node_type_t
ip4_full_reass_node_type_t
Definition: ip4_full_reass.c:207
ip4_full_reass_trace_t::fragment_first
u32 fragment_first
Definition: ip4_full_reass.c:243
ip4_full_reass_node
vlib_node_registration_t ip4_full_reass_node
(constructor) VLIB_REGISTER_NODE (ip4_full_reass_node)
Definition: ip4_full_reass.c:1300
vlib_num_workers
static u32 vlib_num_workers()
Definition: threads.h:354
ip4_full_reass_custom_register_next_node
uword ip4_full_reass_custom_register_next_node(uword node_index)
Definition: ip4_full_reass.c:1388
trace
static vlib_cli_command_t trace
(constructor) VLIB_CLI_COMMAND (trace)
Definition: vlib_api_cli.c:899
ip4_full_reass_per_thread_t::pool
ip4_full_reass_t * pool
Definition: ip4_full_reass.c:155
ip4_full_reass_kv_t
Definition: ip4_full_reass.c:96
HANDOFF
@ HANDOFF
Definition: ip4_full_reass.c:221
thread_index
u32 thread_index
Definition: nat44_ei_hairpinning.c:492
ip4_full_reass_main_t::per_thread_data
ip4_full_reass_per_thread_t * per_thread_data
Definition: ip4_full_reass.c:175
bufs
vlib_buffer_t * bufs[VLIB_FRAME_SIZE]
Definition: nat44_ei_out2in.c:717
ip4_full_reass_t::error_next_index
u32 error_next_index
Definition: ip4_full_reass.c:141
ip4_rehash_cb_ctx::failure
int failure
Definition: ip4_full_reass.c:1419
vlib_buffer_enqueue_to_thread
static_always_inline u32 vlib_buffer_enqueue_to_thread(vlib_main_t *vm, vlib_node_runtime_t *node, u32 frame_queue_index, u32 *buffer_indices, u16 *thread_indices, u32 n_packets, int drop_on_congestion)
Definition: buffer_node.h:358
frame
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
Definition: nat44_ei.c:3048
ip4_full_reass_range_trace_t::range_last
u16 range_last
Definition: ip4_full_reass.c:227
ip4_full_reass_trace_t::action
ip4_full_reass_trace_operation_e action
Definition: ip4_full_reass.c:236
ip4_full_reass_val_t::reass_index
u32 reass_index
Definition: ip4_full_reass.c:90
vlib_node_add_next
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1177
format_ip4_address
format_function_t format_ip4_address
Definition: format.h:73
clib_memcpy
#define clib_memcpy(d, s, n)
Definition: string.h:197
next_index
nat44_ei_hairpin_src_next_t next_index
Definition: nat44_ei_hairpinning.c:412
ip4_full_reass_main_t::max_reass_n
u32 max_reass_n
Definition: ip4_full_reass.c:170
ip4_full_reass_node_feature
vlib_node_registration_t ip4_full_reass_node_feature
(constructor) VLIB_REGISTER_NODE (ip4_full_reass_node_feature)
Definition: ip4_full_reass.c:1325
ip4_main
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1105
ip4_full_reass_enable_disable_with_refcnt
int ip4_full_reass_enable_disable_with_refcnt(u32 sw_if_index, int is_enable)
Definition: ip4_full_reass.c:1934
vlib_get_buffer
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:111
ip4_full_reass_update
static ip4_full_reass_rc_t ip4_full_reass_update(vlib_main_t *vm, vlib_node_runtime_t *node, ip4_full_reass_main_t *rm, ip4_full_reass_per_thread_t *rt, ip4_full_reass_t *reass, u32 *bi0, u32 *next0, u32 *error0, bool is_custom, u32 *handoff_thread_idx)
Definition: ip4_full_reass.c:856
f
vlib_frame_t * f
Definition: interface_output.c:1080
ip4_full_reass_expire_node
vlib_node_registration_t ip4_full_reass_expire_node
(constructor) VLIB_REGISTER_NODE (ip4_full_reass_expire_node)
Definition: ip4_full_reass.c:1618
pool_elt_at_index
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:553
ip4_full_reass_main_t::timeout
f64 timeout
Definition: ip4_full_reass.c:165
show_ip4_full_reass_cmd
static vlib_cli_command_t show_ip4_full_reass_cmd
(constructor) VLIB_CLI_COMMAND (show_ip4_full_reass_cmd)
Definition: ip4_full_reass.c:1734
ip4_full_reass_per_thread_t::lock
clib_spinlock_t lock
Definition: ip4_full_reass.c:158
vlib_get_buffers
vlib_get_buffers(vm, from, b, n_left_from)
format_ip4_full_reass_trace
static u8 * format_ip4_full_reass_trace(u8 *s, va_list *args)
Definition: ip4_full_reass.c:280
ip4_full_reass_key_t::proto
u8 proto
Definition: ip4_full_reass.c:79
VLIB_FRAME_SIZE
#define VLIB_FRAME_SIZE
Definition: node.h:368
ip4_full_reass_drop_all
static void ip4_full_reass_drop_all(vlib_main_t *vm, vlib_node_runtime_t *node, ip4_full_reass_main_t *rm, ip4_full_reass_t *reass)
Definition: ip4_full_reass.c:416
node
vlib_main_t vlib_node_runtime_t * node
Definition: nat44_ei.c:3047
IP4_REASS_RC_HANDOFF
@ IP4_REASS_RC_HANDOFF
Definition: ip4_full_reass.c:66
vlib_cli_command_t::path
char * path
Definition: cli.h:96
ip4_address_t::as_u32
u32 as_u32
Definition: ip4_packet.h:57
ip4_full_reass_main_t::fq_feature_index
u32 fq_feature_index
Definition: ip4_full_reass.c:186
VNET_FEATURE_INIT
VNET_FEATURE_INIT(ip4_full_reass_feature, static)
ip4_rehash_cb
static int ip4_rehash_cb(clib_bihash_kv_16_8_t *kv, void *_ctx)
Definition: ip4_full_reass.c:1425
IP4_REASS_MAX_REASSEMBLIES_DEFAULT
#define IP4_REASS_MAX_REASSEMBLIES_DEFAULT
Definition: ip4_full_reass.c:34
ip4_get_fragment_offset_bytes
static int ip4_get_fragment_offset_bytes(const ip4_header_t *i)
Definition: ip4_packet.h:184
ip4_rehash_cb_ctx::new_hash
clib_bihash_16_8_t * new_hash
Definition: ip4_full_reass.c:1420
ip4_full_reass_handoff_trace_t
Definition: ip4_full_reass.c:1770
ip4_full_reass_t::min_fragment_length
u16 min_fragment_length
Definition: ip4_full_reass.c:143
u16
unsigned short u16
Definition: types.h:57
IP4_FULL_REASS_NEXT_HANDOFF
@ IP4_FULL_REASS_NEXT_HANDOFF
Definition: ip4_full_reass.c:203
ip4_rehash_cb_ctx
Definition: ip4_full_reass.c:1417
pool_put
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:305
vm
vlib_main_t * vm
X-connect all packets from the HOST to the PHY.
Definition: nat44_ei.c:3047
ip4_full_reass_t::data_len
u32 data_len
Definition: ip4_full_reass.c:135
fifo.h
VLIB_RX
@ VLIB_RX
Definition: defs.h:46
node_index
node node_index
Definition: interface_output.c:420
ip4_full_reass_kv_t::v
ip4_full_reass_val_t v
Definition: ip4_full_reass.c:101
format_hexdump
u8 * format_hexdump(u8 *s, va_list *va)
Definition: std-formats.c:352
ip4_full_reass_trace_details
static void ip4_full_reass_trace_details(vlib_main_t *vm, u32 bi, ip4_full_reass_range_trace_t *trace)
Definition: ip4_full_reass.c:255
ip4_full_reass_main_t
Definition: ip4_full_reass.c:161
ip4_full_reass.h
IPv4 Reassembly.
vlib_buffer_get_trace_thread
static u32 vlib_buffer_get_trace_thread(vlib_buffer_t *b)
Extract the thread id from a trace handle.
Definition: buffer.h:404
ip4_full_reass_main_t::expire_walk_interval_ms
u32 expire_walk_interval_ms
Definition: ip4_full_reass.c:166
unformat_input_t
struct _unformat_input_t unformat_input_t
ip4_full_reass_get
vnet_api_error_t ip4_full_reass_get(u32 *timeout_ms, u32 *max_reassemblies, u32 *max_reassembly_length, u32 *expire_walk_interval_ms)
get ip4 reassembly configuration
Definition: ip4_full_reass.c:1486
vlib_frame_t
Definition: node.h:372
ip4_full_reass_per_thread_t::reass_n
u32 reass_n
Definition: ip4_full_reass.c:156
vlib_process_signal_event
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:1019
RANGE_OVERLAP
@ RANGE_OVERLAP
Definition: ip4_full_reass.c:219
vlib_buffer_length_in_chain
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:433
clib_memcpy_fast
static_always_inline void * clib_memcpy_fast(void *restrict dst, const void *restrict src, size_t n)
Definition: string.h:92
IP4_FULL_REASS_NEXT_INPUT
@ IP4_FULL_REASS_NEXT_INPUT
Definition: ip4_full_reass.c:201
ip4_header_t
Definition: ip4_packet.h:87
ip4_full_reass_feature_handoff_node
vlib_node_registration_t ip4_full_reass_feature_handoff_node
(constructor) VLIB_REGISTER_NODE (ip4_full_reass_feature_handoff_node)
Definition: ip4_full_reass.c:1890
error
Definition: cJSON.c:88
ip4_header_t::length
u16 length
Definition: ip4_packet.h:99
key
typedef key
Definition: ipsec_types.api:88
i32
signed int i32
Definition: types.h:77
RANGE_DISCARD
@ RANGE_DISCARD
Definition: ip4_full_reass.c:218
ip4_full_reass_handoff_trace_t::next_worker_index
u32 next_worker_index
Definition: ip4_full_reass.c:1772
MSEC_PER_SEC
#define MSEC_PER_SEC
Definition: ip4_full_reass.c:31
vlib_frame_queue_main_init
u32 vlib_frame_queue_main_init(u32 node_index, u32 frame_queue_nelts)
Definition: threads.c:1572
ip4_full_reass_handoff_error_t
ip4_full_reass_handoff_error_t
Definition: ip4_full_reass.c:1756
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
vnet_buffer_opaque_t::ip
struct vnet_buffer_opaque_t::@157::@159 ip
pool_is_free_index
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:302
NORMAL
@ NORMAL
Definition: ip4_full_reass.c:209
vec_elt
#define vec_elt(v, i)
Get vector value at index i.
Definition: vec_bootstrap.h:210
ip4_full_reass_range_trace_t::range_bi
u32 range_bi
Definition: ip4_full_reass.c:228
ip4_full_reass_trace_t::reass_id
u32 reass_id
Definition: ip4_full_reass.c:237
ip4_main_t::fib_index_by_sw_if_index
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:123
ip4_full_reass_range_trace_t::range_first
u16 range_first
Definition: ip4_full_reass.c:226
vlib_process_get_events
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type,...
Definition: node_funcs.h:583
ip4_full_reass_trace_t::op_id
u32 op_id
Definition: ip4_full_reass.c:240
ti
u32 ti
Definition: interface_output.c:405
ip4_full_reass_range_trace_t::data_offset
i32 data_offset
Definition: ip4_full_reass.c:229
pool_foreach
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:534
vlib_buffer_advance
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:276
IP4_REASS_TIMEOUT_DEFAULT_MS
#define IP4_REASS_TIMEOUT_DEFAULT_MS
Definition: ip4_full_reass.c:32
foreach_ip4_full_reass_handoff_error
#define foreach_ip4_full_reass_handoff_error
Definition: ip4_full_reass.c:1752
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
vlib_buffer_t::error
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:145
VLIB_NODE_FN
#define VLIB_NODE_FN(node)
Definition: node.h:202
ip4_full_reass_key_t::src
ip4_address_t src
Definition: ip4_full_reass.c:76
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
ip4_full_reass_range_trace_t::first_bi
u32 first_bi
Definition: ip4_full_reass.c:231
ip4_full_reass_trace_t::thread_id_to
u32 thread_id_to
Definition: ip4_full_reass.c:242
IP4_REASS_RC_TOO_MANY_FRAGMENTS
@ IP4_REASS_RC_TOO_MANY_FRAGMENTS
Definition: ip4_full_reass.c:63
format_ip4_full_reass_range_trace
static u8 * format_ip4_full_reass_range_trace(u8 *s, va_list *args)
Definition: ip4_full_reass.c:268
ip4_full_reass_main_t::timeout_ms
u32 timeout_ms
Definition: ip4_full_reass.c:164
CLIB_UNUSED
#define CLIB_UNUSED(x)
Definition: clib.h:90
vnet_buffer
#define vnet_buffer(b)
Definition: buffer.h:437
VLIB_NODE_FLAG_TRACE
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:291
PREDICT_FALSE
#define PREDICT_FALSE(x)
Definition: clib.h:124
ip4_full_reass_handoff_node
vlib_node_registration_t ip4_full_reass_handoff_node
(constructor) VLIB_REGISTER_NODE (ip4_full_reass_handoff_node)
Definition: ip4_full_reass.c:1862
format_ip4_full_reass_key
static u8 * format_ip4_full_reass_key(u8 *s, va_list *args)
Definition: ip4_full_reass.c:1630
ip4_full_reass_key_t::as_u64
u64 as_u64[2]
Definition: ip4_full_reass.c:82
vnet_feature_next
static_always_inline void vnet_feature_next(u32 *next0, vlib_buffer_t *b0)
Definition: feature.h:322
ip4_full_reass_free_ctx
static void ip4_full_reass_free_ctx(ip4_full_reass_per_thread_t *rt, ip4_full_reass_t *reass)
Definition: ip4_full_reass.c:396
ARRAY_LEN
#define ARRAY_LEN(x)
Definition: clib.h:70
FEATURE
@ FEATURE
Definition: ip4_full_reass.c:210
vlib_frame_vector_args
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:301
ip4_full_reass_trace_operation_e
ip4_full_reass_trace_operation_e
Definition: ip4_full_reass.c:214
ip4_get_fragment_offset
static u16 ip4_get_fragment_offset(const ip4_header_t *i)
Definition: ip4_packet.h:155
show_ip4_reass
static clib_error_t * show_ip4_reass(vlib_main_t *vm, unformat_input_t *input, CLIB_UNUSED(vlib_cli_command_t *lmd))
Definition: ip4_full_reass.c:1680
clib_spinlock_lock
static_always_inline void clib_spinlock_lock(clib_spinlock_t *p)
Definition: lock.h:82
clib_bihash_copied
__clib_export void clib_bihash_copied(void *dst, void *src)
Definition: bihash_all_vector.c:36
clib_spinlock_s
Definition: lock.h:51
IP4_FULL_REASS_NEXT_DROP
@ IP4_FULL_REASS_NEXT_DROP
Definition: ip4_full_reass.c:202
uword
u64 uword
Definition: types.h:112
ip4_full_reass_main_t::feature_use_refcount_per_intf
u32 * feature_use_refcount_per_intf
Definition: ip4_full_reass.c:190
ip4_full_reass_error_strings
static char * ip4_full_reass_error_strings[]
Definition: ip4_full_reass.c:1286
vlib_main_t::thread_index
u32 thread_index
Definition: main.h:213
vlib_node_increment_counter
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
Definition: node_funcs.h:1244
ip4_full_reass_val_t::memory_owner_thread_index
u32 memory_owner_thread_index
Definition: ip4_full_reass.c:91
ip4_full_reass_buffer_get_data_offset
static u32 ip4_full_reass_buffer_get_data_offset(vlib_buffer_t *b)
Definition: ip4_full_reass.c:107
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
ip4_full_reass_trace_t::is_after_handoff
bool is_after_handoff
Definition: ip4_full_reass.c:246
ip4_full_reass_next_t
ip4_full_reass_next_t
Definition: ip4_full_reass.c:199
f64
double f64
Definition: types.h:142
RANGE_NEW
@ RANGE_NEW
Definition: ip4_full_reass.c:216
pool_get
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:255
ip4_full_reass_trace_t::total_data_len
u32 total_data_len
Definition: ip4_full_reass.c:245
vec_validate
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment)
Definition: vec.h:523
format_ip4_reass
static u8 * format_ip4_reass(u8 *s, va_list *args)
Definition: ip4_full_reass.c:1642
VLIB_CLI_COMMAND
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
IP4_REASS_RC_INTERNAL_ERROR
@ IP4_REASS_RC_INTERNAL_ERROR
Definition: ip4_full_reass.c:64
ip4_full_reass_trace_t::size_diff
u32 size_diff
Definition: ip4_full_reass.c:239
FINALIZE
@ FINALIZE
Definition: ip4_full_reass.c:220
ip4_full_reass_enable_disable
vnet_api_error_t ip4_full_reass_enable_disable(u32 sw_if_index, u8 enable_disable)
Definition: ip4_full_reass.c:1743
ip4_full_reass_per_thread_t::id_counter
u32 id_counter
Definition: ip4_full_reass.c:157
ip4_address_t
Definition: ip4_packet.h:50
ip4_full_reass_t::first_bi
u32 first_bi
Definition: ip4_full_reass.c:131
ip4_full_reass_inline
static uword ip4_full_reass_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, ip4_full_reass_node_type_t type)
Definition: ip4_full_reass.c:1111
clib_min
#define clib_min(x, y)
Definition: clib.h:342
vlib_buffer_chain_linearize
static u32 vlib_buffer_chain_linearize(vlib_main_t *vm, vlib_buffer_t *b)
Definition: buffer_funcs.h:1472
ip4_full_reass_t::memory_owner_thread_index
u32 memory_owner_thread_index
Definition: ip4_full_reass.c:147
vec_pop
#define vec_pop(V)
Returns last element of a vector and decrements its length.
Definition: vec.h:705
ip4_full_reass_main_t::hash
clib_bihash_16_8_t hash
Definition: ip4_full_reass.c:173
ip4_full_reass_walk_expired
static uword ip4_full_reass_walk_expired(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *f)
Definition: ip4_full_reass.c:1545
ip4_full_reass_kv_t::kv
clib_bihash_kv_16_8_t kv
Definition: ip4_full_reass.c:103
vlib_node_registration_t
struct _vlib_node_registration vlib_node_registration_t
vlib_cli_output
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
ip4_full_reass_trace_t::fragment_last
u32 fragment_last
Definition: ip4_full_reass.c:244
ip4_header_t::dst_address
ip4_address_t dst_address
Definition: ip4_packet.h:125
vlib_buffer_t::current_length
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:122
ip4_full_reass_t::last_heard
f64 last_heard
Definition: ip4_full_reass.c:127
ip4_full_reass_buffer_get_data_len
static u16 ip4_full_reass_buffer_get_data_len(vlib_buffer_t *b)
Definition: ip4_full_reass.c:114
ip4_header_t::fragment_id
u16 fragment_id
Definition: ip4_packet.h:102
ip4_get_fragment_more
static u16 ip4_get_fragment_more(const ip4_header_t *i)
Definition: ip4_packet.h:161
ip4_full_reass_key_t::frag_id
u16 frag_id
Definition: ip4_full_reass.c:78
IP4_REASS_DEBUG_BUFFER
#define IP4_REASS_DEBUG_BUFFER(...)
Definition: ip4_full_reass.c:57
IP4_EVENT_CONFIG_CHANGED
@ IP4_EVENT_CONFIG_CHANGED
Definition: ip4_full_reass.c:1414
format_ip4_full_reass_handoff_trace
static u8 * format_ip4_full_reass_handoff_trace(u8 *s, va_list *args)
Definition: ip4_full_reass.c:1776
ip4_full_reass_range_trace_t::data_len
u32 data_len
Definition: ip4_full_reass.c:230
IP4_REASS_EXPIRE_WALK_INTERVAL_DEFAULT_MS
#define IP4_REASS_EXPIRE_WALK_INTERVAL_DEFAULT_MS
Definition: ip4_full_reass.c:33
ip4_full_reass_handoff_error_strings
static char * ip4_full_reass_handoff_error_strings[]
Definition: ip4_full_reass.c:1764
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
ip4_full_reass_kv_t::k
ip4_full_reass_key_t k
Definition: ip4_full_reass.c:100
vlib_validate_buffer_enqueue_x1
#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:224
index
u32 index
Definition: flow_types.api:221
ip4_full_reass_init
static void ip4_full_reass_init(ip4_full_reass_t *reass)
Definition: ip4_full_reass.c:478
ip4_full_reass_range_trace_t
Definition: ip4_full_reass.c:224
always_inline
#define always_inline
Definition: rdma_mlx5dv.h:23
ip4_full_reass_t
Definition: ip4_full_reass.c:122
vlib_get_node_by_name
vlib_node_t * vlib_get_node_by_name(vlib_main_t *vm, u8 *name)
Definition: node.c:45
vnet_buffer_opaque_t
Definition: buffer.h:149
ip4_full_reass_custom_handoff_node
vlib_node_registration_t ip4_full_reass_custom_handoff_node
(constructor) VLIB_REGISTER_NODE (ip4_full_reass_custom_handoff_node)
Definition: ip4_full_reass.c:1917
ip4_header_t::src_address
ip4_address_t src_address
Definition: ip4_packet.h:125
ip4_full_reass_trace_t::thread_id
u32 thread_id
Definition: ip4_full_reass.c:241
ip4_full_reass_main_t::vlib_main
vlib_main_t * vlib_main
Definition: ip4_full_reass.c:178
pool_foreach_index
#define pool_foreach_index(i, v)
Definition: pool.h:576
clib_bihash_kv_16_8_t
Definition: bihash_16_8.h:40
ip4_full_reass_set_params
static void ip4_full_reass_set_params(u32 timeout_ms, u32 max_reassemblies, u32 max_reassembly_length, u32 expire_walk_interval_ms)
Definition: ip4_full_reass.c:1436
u64
unsigned long u64
Definition: types.h:89
vlib_trace_main_t::trace_buffer_pool
vlib_trace_header_t ** trace_buffer_pool
Definition: trace.h:86
vlib_process_wait_for_event_or_clock
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:755
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
ip4_full_reass_handoff_node_inline
static uword ip4_full_reass_handoff_node_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, ip4_full_reass_node_type_t type)
Definition: ip4_full_reass.c:1791
format_get_indent
static u32 format_get_indent(u8 *s)
Definition: format.h:72
data_len
u8 data_len
Definition: ikev2_types.api:24
IP4_REASS_MAX_REASSEMBLY_LENGTH_DEFAULT
#define IP4_REASS_MAX_REASSEMBLY_LENGTH_DEFAULT
Definition: ip4_full_reass.c:35
vlib_put_next_frame
vlib_put_next_frame(vm, node, next_index, 0)
clib_bihash_kv_16_8_t::key
u64 key[2]
Definition: bihash_16_8.h:42
ip.h
u32
unsigned int u32
Definition: types.h:88
ip4_full_reass_event_t
ip4_full_reass_event_t
Definition: ip4_full_reass.c:1412
VLIB_INIT_FUNCTION
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:172
ip4_full_reass_insert_range_in_chain
static ip4_full_reass_rc_t ip4_full_reass_insert_range_in_chain(vlib_main_t *vm, ip4_full_reass_main_t *rm, ip4_full_reass_per_thread_t *rt, ip4_full_reass_t *reass, u32 prev_range_bi, u32 new_next_bi)
Definition: ip4_full_reass.c:766
ip4_full_reass_main
ip4_full_reass_main_t ip4_full_reass_main
Definition: ip4_full_reass.c:196
ip4_full_reass_main_t::fq_index
u32 fq_index
Worker handoff.
Definition: ip4_full_reass.c:185
ip4_full_reass_t::fragments_n
u32 fragments_n
Definition: ip4_full_reass.c:145
ctx
long ctx[MAX_CONNS]
Definition: main.c:144
ip4_full_reass_main_t::ip4_full_reass_expire_node_idx
u32 ip4_full_reass_expire_node_idx
Definition: ip4_full_reass.c:182
vec_foreach
#define vec_foreach(var, vec)
Vector iterator.
Definition: vec_bootstrap.h:213
ip4_full_reass_val_t
Definition: ip4_full_reass.c:86
VLIB_NODE_TYPE_PROCESS
@ VLIB_NODE_TYPE_PROCESS
Definition: node.h:84
as_u64
u64 as_u64
Definition: bihash_doc.h:63
n_vectors
return frame n_vectors
Definition: nat44_ei_hairpinning.c:485
IP4_REASS_RC_OK
@ IP4_REASS_RC_OK
Definition: ip4_full_reass.c:62
ip4_full_reass_val_t::as_u64
u64 as_u64
Definition: ip4_full_reass.c:93
clib_spinlock_unlock
static_always_inline void clib_spinlock_unlock(clib_spinlock_t *p)
Definition: lock.h:121
bihash_16_8.h
IP4_FULL_REASS_N_NEXT
@ IP4_FULL_REASS_N_NEXT
Definition: ip4_full_reass.c:204
ip4_full_reass_key_t::unused
u8 unused
Definition: ip4_full_reass.c:80
vnet_feature_enable_disable
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: pnat_test_stubs.h:50
format_ip4_header
format_function_t format_ip4_header
Definition: format.h:81
ip4_full_reass_add_trace
static void ip4_full_reass_add_trace(vlib_main_t *vm, vlib_node_runtime_t *node, ip4_full_reass_main_t *rm, ip4_full_reass_t *reass, u32 bi, ip4_full_reass_trace_operation_e action, u32 size_diff, u32 thread_id_to)
Definition: ip4_full_reass.c:337
ip4_full_reass_main_t::max_reass_len
u32 max_reass_len
Definition: ip4_full_reass.c:168
vec.h
now
f64 now
Definition: nat44_ei_out2in.c:710
foreach_ip4_error
#define foreach_ip4_error
Definition: ip4_error.h:43
ip4_full_reass_trace_t
Definition: ip4_full_reass.c:234
ip4_full_reass_main_t::fq_custom_index
u32 fq_custom_index
Definition: ip4_full_reass.c:187
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
ip4_full_reass_finalize
static ip4_full_reass_rc_t ip4_full_reass_finalize(vlib_main_t *vm, vlib_node_runtime_t *node, ip4_full_reass_main_t *rm, ip4_full_reass_per_thread_t *rt, ip4_full_reass_t *reass, u32 *bi0, u32 *next0, u32 *error0, bool is_custom)
Definition: ip4_full_reass.c:562
vlib_node_t
Definition: node.h:247
vlib_add_trace
void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace.c:628
ip4_full_reass_rc_t
ip4_full_reass_rc_t
Definition: ip4_full_reass.c:60
vlib_get_main
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:38
b
vlib_buffer_t ** b
Definition: nat44_ei_out2in.c:717
VNET_FEATURES
#define VNET_FEATURES(...)
Definition: feature.h:470
u8
unsigned char u8
Definition: types.h:56
ip4_full_reass_find_or_create
static ip4_full_reass_t * ip4_full_reass_find_or_create(vlib_main_t *vm, vlib_node_runtime_t *node, ip4_full_reass_main_t *rm, ip4_full_reass_per_thread_t *rt, ip4_full_reass_kv_t *kv, u8 *do_handoff)
Definition: ip4_full_reass.c:488
clib_error_t
Definition: clib_error.h:21
ip4_full_reass_t::trace_op_counter
u32 trace_op_counter
Definition: ip4_full_reass.c:137
vlib_buffer_get_current
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:257
rt
vnet_interface_output_runtime_t * rt
Definition: interface_output.c:399
ip4_full_reass_t::key
ip4_full_reass_key_t key
Definition: ip4_full_reass.c:125
ip
vl_api_address_t ip
Definition: l2.api:558
ip4_header_checksum
static u16 ip4_header_checksum(ip4_header_t *i)
Definition: ip4_packet.h:314
ip4_full_reass_t::sendout_thread_index
u32 sendout_thread_index
Definition: ip4_full_reass.c:150
vlib_init_function_t
clib_error_t *() vlib_init_function_t(struct vlib_main_t *vm)
Definition: init.h:51
ip4_full_reass_remove_range_from_chain
static ip4_full_reass_rc_t ip4_full_reass_remove_range_from_chain(vlib_main_t *vm, vlib_node_runtime_t *node, ip4_full_reass_main_t *rm, ip4_full_reass_t *reass, u32 prev_range_bi, u32 discard_bi)
Definition: ip4_full_reass.c:800
ip4_full_reass_main_t::ip4_drop_idx
u32 ip4_drop_idx
Definition: ip4_full_reass.c:181
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
pool_alloc
#define pool_alloc(P, N)
Allocate N more free elements to pool (unspecified alignment).
Definition: pool.h:367
ip4_full_reass_init_function
static clib_error_t * ip4_full_reass_init_function(vlib_main_t *vm)
Definition: ip4_full_reass.c:1498
ip4_full_reass_trace_t::ip4_header
ip4_header_t ip4_header
Definition: ip4_full_reass.c:247
ip4_header_bytes
static int ip4_header_bytes(const ip4_header_t *i)
Definition: ip4_packet.h:190
rv
int __clib_unused rv
Definition: application.c:491
IP4_FULL_REASS_HANDOFF_N_ERROR
@ IP4_FULL_REASS_HANDOFF_N_ERROR
Definition: ip4_full_reass.c:1761
vlib_buffer_free_one
static void vlib_buffer_free_one(vlib_main_t *vm, u32 buffer_index)
Free one buffer Shorthand to free a single buffer chain.
Definition: buffer_funcs.h:1015
ip4_full_reass_per_thread_t
Definition: ip4_full_reass.c:153
vlib_time_now
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:325
ip4_full_reass_set
vnet_api_error_t ip4_full_reass_set(u32 timeout_ms, u32 max_reassemblies, u32 max_reassembly_length, u32 expire_walk_interval_ms)
set ip4 reassembly configuration
Definition: ip4_full_reass.c:1448
ip4_full_reass_trace_t::trace_range
ip4_full_reass_range_trace_t trace_range
Definition: ip4_full_reass.c:238
vnet.h
CUSTOM
@ CUSTOM
Definition: ip4_full_reass.c:211
vlib_main_t::trace_main
vlib_trace_main_t trace_main
Definition: main.h:174
vlib_node_runtime_t
Definition: node.h:454
vlib_buffer_get_trace_index
static u32 vlib_buffer_get_trace_index(vlib_buffer_t *b)
Extract the trace (pool) index from a trace handle.
Definition: buffer.h:416
vlib_cli_command_t
Definition: cli.h:92
from
from
Definition: nat44_ei_hairpinning.c:415
IP4_REASS_HT_LOAD_FACTOR
#define IP4_REASS_HT_LOAD_FACTOR
Definition: ip4_full_reass.c:36
ip4_full_reass_t::last_packet_octet
u32 last_packet_octet
Definition: ip4_full_reass.c:133
ip4_full_reass_key_t
Definition: ip4_full_reass.c:69
action
vl_api_mac_event_action_t action
Definition: l2.api:211
vlib_buffer_t::total_length_not_including_first_buffer
u32 total_length_not_including_first_buffer
Only valid for first buffer in chain.
Definition: buffer.h:176
sw_if_index
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
vlib_get_next_frame
#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:395
RANGE_SHRINK
@ RANGE_SHRINK
Definition: ip4_full_reass.c:217
n_left_from
n_left_from
Definition: nat44_ei_hairpinning.c:416
ip4_full_reass_node_custom
vlib_node_registration_t ip4_full_reass_node_custom
(constructor) VLIB_REGISTER_NODE (ip4_full_reass_node_custom)
Definition: ip4_full_reass.c:1359
type
vl_api_fib_path_type_t type
Definition: fib_types.api:123
IP4_REASS_RC_NO_BUF
@ IP4_REASS_RC_NO_BUF
Definition: ip4_full_reass.c:65
ip4_header_t::protocol
u8 protocol
Definition: ip4_packet.h:115
ip4_full_reass_t::id
u64 id
Definition: ip4_full_reass.c:129
ip4_full_reass_free
static void ip4_full_reass_free(ip4_full_reass_main_t *rm, ip4_full_reass_per_thread_t *rt, ip4_full_reass_t *reass)
Definition: ip4_full_reass.c:404
format_white_space
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
vnet_api_error_t
vnet_api_error_t
Definition: api_errno.h:162
vlib_buffer_t::flags
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index,...
Definition: buffer.h:133
ip4_full_reass_t::next_index
u32 next_index
Definition: ip4_full_reass.c:139
vlib_buffer_t
VLIB buffer representation.
Definition: buffer.h:111
VLIB_REGISTER_NODE
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169