FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
ip4_fib.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 #include <vnet/fib/fib_table.h>
17 #include <vnet/fib/fib_entry.h>
18 #include <vnet/fib/ip4_fib.h>
19 
20 /*
21  * A table of prefixes to be added to tables and the sources for them
22  */
28 
30  {
31  /* 0.0.0.0/0*/
32  .ift_prefix = {
33  .fp_addr = {
34  .ip4.data_u32 = 0,
35  },
36  .fp_len = 0,
37  .fp_proto = FIB_PROTOCOL_IP4,
38  },
39  .ift_source = FIB_SOURCE_DEFAULT_ROUTE,
40  .ift_flag = FIB_ENTRY_FLAG_DROP,
41  },
42  {
43  /* 0.0.0.0/32*/
44  .ift_prefix = {
45  .fp_addr = {
46  .ip4.data_u32 = 0,
47  },
48  .fp_len = 32,
49  .fp_proto = FIB_PROTOCOL_IP4,
50  },
51  .ift_source = FIB_SOURCE_DEFAULT_ROUTE,
52  .ift_flag = FIB_ENTRY_FLAG_DROP,
53  },
54  {
55  /*
56  * 240.0.0.0/4
57  * drop class E
58  */
59  .ift_prefix = {
60  .fp_addr = {
61  .ip4.data_u32 = 0xf0000000,
62  },
63  .fp_len = 4,
64  .fp_proto = FIB_PROTOCOL_IP4,
65  },
66  .ift_source = FIB_SOURCE_SPECIAL,
67  .ift_flag = FIB_ENTRY_FLAG_DROP,
68 
69  },
70  {
71  /*
72  * 224.0.0.0/4
73  * drop all mcast
74  */
75  .ift_prefix = {
76  .fp_addr = {
77  .ip4.data_u32 = 0xe0000000,
78  },
79  .fp_len = 4,
80  .fp_proto = FIB_PROTOCOL_IP4,
81  },
82  .ift_source = FIB_SOURCE_SPECIAL,
83  .ift_flag = FIB_ENTRY_FLAG_DROP,
84  },
85  {
86  /*
87  * 255.255.255.255/32
88  * drop, but we'll allow it to be usurped by the likes of DHCP
89  */
90  .ift_prefix = {
91  .fp_addr = {
92  .ip4.data_u32 = 0xffffffff,
93  },
94  .fp_len = 32,
95  .fp_proto = FIB_PROTOCOL_IP4,
96  },
97  .ift_source = FIB_SOURCE_DEFAULT_ROUTE,
98  .ift_flag = FIB_ENTRY_FLAG_DROP,
99  }
100 };
101 
102 
103 static u32
106 {
107  fib_table_t *fib_table;
108  ip4_fib_t *v4_fib;
109 
110  pool_get(ip4_main.fibs, fib_table);
111  clib_memset(fib_table, 0, sizeof(*fib_table));
112 
114 
115  ASSERT((fib_table - ip4_main.fibs) ==
116  (v4_fib - ip4_main.v4_fibs));
117 
118  fib_table->ft_proto = FIB_PROTOCOL_IP4;
119  fib_table->ft_index =
120  v4_fib->index =
121  (fib_table - ip4_main.fibs);
122 
124 
125  fib_table->ft_table_id =
126  v4_fib->table_id =
127  table_id;
129 
131 
132  ip4_mtrie_init(&v4_fib->mtrie);
133 
134  /*
135  * add the special entries into the new FIB
136  */
137  int ii;
138 
139  for (ii = 0; ii < ARRAY_LEN(ip4_specials); ii++)
140  {
142 
143  prefix.fp_addr.ip4.data_u32 =
144  clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
145 
147  &prefix,
149  ip4_specials[ii].ift_flag);
150  }
151 
152  return (fib_table->ft_index);
153 }
154 
155 void
157 {
158  fib_table_t *fib_table = pool_elt_at_index(ip4_main.fibs, fib_index);
159  ip4_fib_t *v4_fib = pool_elt_at_index(ip4_main.v4_fibs, fib_index);
160  u32 *n_locks;
161  int ii;
162 
163  /*
164  * remove all the specials we added when the table was created.
165  * In reverse order so the default route is last.
166  */
167  for (ii = ARRAY_LEN(ip4_specials) - 1; ii >= 0; ii--)
168  {
170 
171  prefix.fp_addr.ip4.data_u32 =
172  clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
173 
175  &prefix,
177  }
178 
179  /*
180  * validate no more routes.
181  */
182 #if CLIB_DEBUG > 0
183  if (0 != fib_table->ft_total_route_counts)
184  fib_table_assert_empty(fib_table);
185 #endif
186 
187  vec_foreach(n_locks, fib_table->ft_src_route_counts)
188  {
189  ASSERT(0 == *n_locks);
190  }
191 
192  if (~0 != fib_table->ft_table_id)
193  {
195  }
196 
197  vec_free(fib_table->ft_src_route_counts);
198  ip4_mtrie_free(&v4_fib->mtrie);
199 
200  pool_put(ip4_main.v4_fibs, v4_fib);
201  pool_put(ip4_main.fibs, fib_table);
202 }
203 
204 
205 u32
208 {
209  u32 index;
210 
212  if (~0 == index)
214 
216 
217  return (index);
218 }
219 
220 u32
222 {
223  return (ip4_create_fib_with_table_id(~0, src));
224 }
225 
226 u32
228 {
230  {
231  /*
232  * This is the case for interfaces that are not yet mapped to
233  * a IP table
234  */
235  return (~0);
236  }
238 }
239 
240 /*
241  * ip4_fib_table_lookup_exact_match
242  *
243  * Exact match prefix lookup
244  */
247  const ip4_address_t *addr,
248  u32 len)
249 {
250  uword * hash, * result;
251  u32 key;
252 
253  hash = fib->fib_entry_by_dst_address[len];
254  key = (addr->data_u32 & ip4_main.fib_masks[len]);
255 
256  result = hash_get(hash, key);
257 
258  if (NULL != result) {
259  return (result[0]);
260  }
261  return (FIB_NODE_INDEX_INVALID);
262 }
263 
264 /*
265  * ip4_fib_table_lookup_adj
266  *
267  * Longest prefix match
268  */
269 index_t
271  const ip4_address_t *addr)
272 {
273  fib_node_index_t fei;
274 
275  fei = ip4_fib_table_lookup(fib, addr, 32);
276 
277  if (FIB_NODE_INDEX_INVALID != fei)
278  {
279  const dpo_id_t *dpo;
280 
282 
283  return (dpo->dpoi_index);
284  }
285  return (INDEX_INVALID);
286 }
287 
288 /*
289  * ip4_fib_table_lookup
290  *
291  * Longest prefix match
292  */
295  const ip4_address_t *addr,
296  u32 len)
297 {
298  uword * hash, * result;
299  i32 mask_len;
300  u32 key;
301 
302  for (mask_len = len; mask_len >= 0; mask_len--)
303  {
304  hash = fib->fib_entry_by_dst_address[mask_len];
305  key = (addr->data_u32 & ip4_main.fib_masks[mask_len]);
306 
307  result = hash_get (hash, key);
308 
309  if (NULL != result) {
310  return (result[0]);
311  }
312  }
313  return (FIB_NODE_INDEX_INVALID);
314 }
315 
316 void
318  const ip4_address_t *addr,
319  u32 len,
320  fib_node_index_t fib_entry_index)
321 {
322  uword * hash, * result;
323  u32 key;
324 
325  key = (addr->data_u32 & ip4_main.fib_masks[len]);
326  hash = fib->fib_entry_by_dst_address[len];
327  result = hash_get (hash, key);
328 
329  if (NULL == result) {
330  /*
331  * adding a new entry
332  */
333 
334  if (NULL == hash) {
335  hash = hash_create (32 /* elts */, sizeof (uword));
337 
338  }
339  hash = hash_set(hash, key, fib_entry_index);
340  fib->fib_entry_by_dst_address[len] = hash;
341  }
342  else
343  {
344  ASSERT(0);
345  }
346 }
347 
348 void
350  const ip4_address_t *addr,
351  u32 len)
352 {
353  uword * hash, * result;
354  u32 key;
355 
356  key = (addr->data_u32 & ip4_main.fib_masks[len]);
357  hash = fib->fib_entry_by_dst_address[len];
358  result = hash_get (hash, key);
359 
360  if (NULL == result)
361  {
362  /*
363  * removing a non-existent entry. i'll allow it.
364  */
365  }
366  else
367  {
368  hash_unset(hash, key);
369  }
370 
371  fib->fib_entry_by_dst_address[len] = hash;
372 }
373 
374 void
376  const ip4_address_t *addr,
377  u32 len,
378  const dpo_id_t *dpo)
379 {
381 }
382 
383 void
385  const ip4_address_t *addr,
386  u32 len,
387  const dpo_id_t *dpo,
388  u32 cover_index)
389 {
390  const fib_prefix_t *cover_prefix;
391  const dpo_id_t *cover_dpo;
392 
393  /*
394  * We need to pass the MTRIE the LB index and address length of the
395  * covering prefix, so it can fill the plys with the correct replacement
396  * for the entry being removed
397  */
398  cover_prefix = fib_entry_get_prefix(cover_index);
399  cover_dpo = fib_entry_contribute_ip_forwarding(cover_index);
400 
402  addr, len, dpo->dpoi_index,
403  cover_prefix->fp_len,
404  cover_dpo->dpoi_index);
405 }
406 
407 void
410  void *ctx)
411 {
412  fib_prefix_t root = {
414  // address and length default to all 0
415  };
416 
417  /*
418  * A full tree walk is the dengenerate case of a sub-tree from
419  * the very root
420  */
421  return (ip4_fib_table_sub_tree_walk(fib, &root, fn, ctx));
422 }
423 
424 void
426  const fib_prefix_t *root,
428  void *ctx)
429 {
430  fib_prefix_t *sub_trees = NULL;
431  int i;
432 
433  /*
434  * There is no efficient way to walk this array of hash tables.
435  * so we walk each table with a mask length greater than and equal to
436  * the required root and check it is covered by the root.
437  */
438  for (i = root->fp_len;
440  i++)
441  {
442  uword * hash = fib->fib_entry_by_dst_address[i];
443 
444  if (NULL != hash)
445  {
447  hash_pair_t * p;
448 
449  hash_foreach_pair (p, hash,
450  ({
451  key.as_u32 = p->key;
453  &key,
454  &root->fp_addr.ip4,
455  root->fp_len))
456  {
457  const fib_prefix_t *sub_tree;
458  int skip = 0;
459 
460  /*
461  * exclude sub-trees the walk does not want to explore
462  */
463  vec_foreach(sub_tree, sub_trees)
464  {
465  if (ip4_destination_matches_route(&ip4_main,
466  &key,
467  &sub_tree->fp_addr.ip4,
468  sub_tree->fp_len))
469  {
470  skip = 1;
471  break;
472  }
473  }
474 
475  if (!skip)
476  {
477  switch (fn(p->value[0], ctx))
478  {
479  case FIB_TABLE_WALK_CONTINUE:
480  break;
481  case FIB_TABLE_WALK_SUB_TREE_STOP: {
482  fib_prefix_t pfx = {
483  .fp_proto = FIB_PROTOCOL_IP4,
484  .fp_len = i,
485  .fp_addr.ip4 = key,
486  };
487  vec_add1(sub_trees, pfx);
488  break;
489  }
490  case FIB_TABLE_WALK_STOP:
491  goto done;
492  }
493  }
494  }
495  }));
496  }
497  }
498 done:
499  vec_free(sub_trees);
500  return;
501 }
502 
503 /**
504  * Walk show context
505  */
507 {
510 
511 static fib_table_walk_rc_t
513  void *arg)
514 {
516 
517  vec_add1(ctx->ifsw_indicies, fib_entry_index);
518 
519  return (FIB_TABLE_WALK_CONTINUE);
520 }
521 
522 static void
524  vlib_main_t * vm)
525 {
527  .ifsw_indicies = NULL,
528  };
529  fib_node_index_t *fib_entry_index;
530 
532  vec_sort_with_function(ctx.ifsw_indicies,
534 
535  vec_foreach(fib_entry_index, ctx.ifsw_indicies)
536  {
537  vlib_cli_output(vm, "%U",
539  *fib_entry_index,
541  }
542 
543  vec_free(ctx.ifsw_indicies);
544 }
545 
546 static void
548  vlib_main_t * vm,
550  u32 mask_len,
551  int detail)
552 {
553  vlib_cli_output(vm, "%U",
555  ip4_fib_table_lookup(fib, address, mask_len),
556  (detail ?
559 }
560 
561 u8 *
562 format_ip4_fib_table_memory (u8 * s, va_list * args)
563 {
564  s = format(s, "%=30s %=6d\n",
565  "IPv4 unicast",
567  return (s);
568 }
569 
570 static clib_error_t *
572  unformat_input_t * input,
573  vlib_cli_command_t * cmd)
574 {
575  ip4_main_t * im4 = &ip4_main;
576  fib_table_t * fib_table;
577  u64 total_mtrie_memory, total_hash_memory;
578  int verbose, matching, mtrie, memory;
579  ip4_address_t matching_address;
580  u32 matching_mask = 32;
581  int i, table_id = -1, fib_index = ~0;
582  int detail = 0;
583 
584  verbose = 1;
585  matching = mtrie = memory = 0;
586  total_hash_memory = total_mtrie_memory = 0;
587 
589  {
590  if (unformat (input, "brief") || unformat (input, "summary")
591  || unformat (input, "sum"))
592  verbose = 0;
593 
594  else if (unformat (input, "detail") || unformat (input, "det"))
595  detail = 1;
596 
597  else if (unformat (input, "mtrie"))
598  mtrie = 1;
599 
600  else if (unformat (input, "mem") ||
601  unformat (input, "memory"))
602  memory = 1;
603 
604  else if (unformat (input, "%U/%d",
605  unformat_ip4_address, &matching_address, &matching_mask))
606  matching = 1;
607 
608  else if (unformat (input, "%U", unformat_ip4_address, &matching_address))
609  matching = 1;
610 
611  else if (unformat (input, "table %d", &table_id))
612  ;
613  else if (unformat (input, "index %d", &fib_index))
614  ;
615  else
616  break;
617  }
618 
619  pool_foreach (fib_table, im4->fibs)
620  {
621  ip4_fib_t *fib = pool_elt_at_index(im4->v4_fibs, fib_table->ft_index);
622  fib_source_t source;
623  u8 *s = NULL;
624 
625  if (table_id >= 0 && table_id != (int)fib->table_id)
626  continue;
627  if (fib_index != ~0 && fib_index != (int)fib->index)
628  continue;
629 
630  if (memory)
631  {
632  uword mtrie_size, hash_size;
633 
634 
635  mtrie_size = ip4_fib_mtrie_memory_usage(&fib->mtrie);
636  hash_size = 0;
637 
638  for (i = 0; i < ARRAY_LEN (fib->fib_entry_by_dst_address); i++)
639  {
640  uword * hash = fib->fib_entry_by_dst_address[i];
641  if (NULL != hash)
642  {
643  hash_size += hash_bytes(hash);
644  }
645  }
646 
647  if (verbose)
648  vlib_cli_output (vm, "%U mtrie:%d hash:%d",
651  mtrie_size,
652  hash_size);
653  total_mtrie_memory += mtrie_size;
654  total_hash_memory += hash_size;
655  continue;
656  }
657 
658  s = format(s, "%U, fib_index:%d, flow hash:[%U] epoch:%d flags:%U locks:[",
661  fib->index,
663  fib_table->ft_flow_hash_config,
664  fib_table->ft_epoch,
665  format_fib_table_flags, fib_table->ft_flags);
666  vec_foreach_index(source, fib_table->ft_locks)
667  {
668  if (0 != fib_table->ft_locks[source])
669  {
670  s = format(s, "%U:%d, ",
671  format_fib_source, source,
672  fib_table->ft_locks[source]);
673  }
674  }
675  s = format (s, "]");
676  vlib_cli_output (vm, "%v", s);
677  vec_free(s);
678 
679  /* Show summary? */
680  if (mtrie)
681  {
682  vlib_cli_output (vm, "%U", format_ip4_fib_mtrie, &fib->mtrie, verbose);
683  continue;
684  }
685  if (! verbose)
686  {
687  vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count");
688  for (i = 0; i < ARRAY_LEN (fib->fib_entry_by_dst_address); i++)
689  {
690  uword * hash = fib->fib_entry_by_dst_address[i];
691  uword n_elts = hash_elts (hash);
692  if (n_elts > 0)
693  vlib_cli_output (vm, "%20d%16d", i, n_elts);
694  }
695  continue;
696  }
697 
698  if (!matching)
699  {
701  }
702  else
703  {
704  ip4_fib_table_show_one(fib, vm, &matching_address,
705  matching_mask, detail);
706  }
707  }
708 
709  if (memory)
710  {
711  vlib_cli_output (vm, "totals: mtrie:%ld hash:%ld all:%ld",
712  total_mtrie_memory,
713  total_hash_memory,
714  total_mtrie_memory + total_hash_memory);
715  }
716  return 0;
717 }
718 
719 /*?
720  * This command displays the IPv4 FIB Tables (VRF Tables) and the route
721  * entries for each table.
722  *
723  * @note This command will run for a long time when the FIB tables are
724  * comprised of millions of entries. For those senarios, consider displaying
725  * a single table or summary mode.
726  *
727  * @cliexpar
728  * Example of how to display all the IPv4 FIB tables:
729  * @cliexstart{show ip fib}
730  * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
731  * 0.0.0.0/0
732  * unicast-ip4-chain
733  * [@0]: dpo-load-balance: [index:0 buckets:1 uRPF:0 to:[0:0]]
734  * [0] [@0]: dpo-drop ip6
735  * 0.0.0.0/32
736  * unicast-ip4-chain
737  * [@0]: dpo-load-balance: [index:1 buckets:1 uRPF:1 to:[0:0]]
738  * [0] [@0]: dpo-drop ip6
739  * 6.0.1.2/32
740  * unicast-ip4-chain
741  * [@0]: dpo-load-balance: [index:30 buckets:1 uRPF:29 to:[0:0]]
742  * [0] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
743  * 7.0.0.1/32
744  * unicast-ip4-chain
745  * [@0]: dpo-load-balance: [index:31 buckets:4 uRPF:30 to:[0:0]]
746  * [0] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
747  * [1] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
748  * [2] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
749  * [3] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
750  * 224.0.0.0/8
751  * unicast-ip4-chain
752  * [@0]: dpo-load-balance: [index:3 buckets:1 uRPF:3 to:[0:0]]
753  * [0] [@0]: dpo-drop ip6
754  * 240.0.0.0/8
755  * unicast-ip4-chain
756  * [@0]: dpo-load-balance: [index:2 buckets:1 uRPF:2 to:[0:0]]
757  * [0] [@0]: dpo-drop ip6
758  * 255.255.255.255/32
759  * unicast-ip4-chain
760  * [@0]: dpo-load-balance: [index:4 buckets:1 uRPF:4 to:[0:0]]
761  * [0] [@0]: dpo-drop ip6
762  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
763  * 0.0.0.0/0
764  * unicast-ip4-chain
765  * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
766  * [0] [@0]: dpo-drop ip6
767  * 0.0.0.0/32
768  * unicast-ip4-chain
769  * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
770  * [0] [@0]: dpo-drop ip6
771  * 172.16.1.0/24
772  * unicast-ip4-chain
773  * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
774  * [0] [@4]: ipv4-glean: af_packet0
775  * 172.16.1.1/32
776  * unicast-ip4-chain
777  * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
778  * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
779  * 172.16.1.2/32
780  * unicast-ip4-chain
781  * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
782  * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
783  * 172.16.2.0/24
784  * unicast-ip4-chain
785  * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
786  * [0] [@4]: ipv4-glean: af_packet1
787  * 172.16.2.1/32
788  * unicast-ip4-chain
789  * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
790  * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
791  * 224.0.0.0/8
792  * unicast-ip4-chain
793  * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
794  * [0] [@0]: dpo-drop ip6
795  * 240.0.0.0/8
796  * unicast-ip4-chain
797  * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
798  * [0] [@0]: dpo-drop ip6
799  * 255.255.255.255/32
800  * unicast-ip4-chain
801  * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
802  * [0] [@0]: dpo-drop ip6
803  * @cliexend
804  * Example of how to display a single IPv4 FIB table:
805  * @cliexstart{show ip fib table 7}
806  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
807  * 0.0.0.0/0
808  * unicast-ip4-chain
809  * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
810  * [0] [@0]: dpo-drop ip6
811  * 0.0.0.0/32
812  * unicast-ip4-chain
813  * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
814  * [0] [@0]: dpo-drop ip6
815  * 172.16.1.0/24
816  * unicast-ip4-chain
817  * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
818  * [0] [@4]: ipv4-glean: af_packet0
819  * 172.16.1.1/32
820  * unicast-ip4-chain
821  * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
822  * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
823  * 172.16.1.2/32
824  * unicast-ip4-chain
825  * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
826  * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
827  * 172.16.2.0/24
828  * unicast-ip4-chain
829  * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
830  * [0] [@4]: ipv4-glean: af_packet1
831  * 172.16.2.1/32
832  * unicast-ip4-chain
833  * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
834  * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
835  * 224.0.0.0/8
836  * unicast-ip4-chain
837  * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
838  * [0] [@0]: dpo-drop ip6
839  * 240.0.0.0/8
840  * unicast-ip4-chain
841  * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
842  * [0] [@0]: dpo-drop ip6
843  * 255.255.255.255/32
844  * unicast-ip4-chain
845  * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
846  * [0] [@0]: dpo-drop ip6
847  * @cliexend
848  * Example of how to display a summary of all IPv4 FIB tables:
849  * @cliexstart{show ip fib summary}
850  * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
851  * Prefix length Count
852  * 0 1
853  * 8 2
854  * 32 4
855  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
856  * Prefix length Count
857  * 0 1
858  * 8 2
859  * 24 2
860  * 32 4
861  * @cliexend
862  ?*/
863 /* *INDENT-OFF* */
865  .path = "show ip fib",
866  .short_help = "show ip fib [summary] [table <table-id>] [index <fib-id>] [<ip4-addr>[/<mask>]] [mtrie] [detail]",
867  .function = ip4_show_fib,
868 };
869 /* *INDENT-ON* */
fib_entry.h
ip4_fib_table_find_or_create_and_lock
u32 ip4_fib_table_find_or_create_and_lock(u32 table_id, fib_source_t src)
Get or create an IPv4 fib.
Definition: ip4_fib.c:206
dpo_id_t_::dpoi_index
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:190
ip4_main_t::v4_fibs
struct ip4_fib_t_ * v4_fibs
Vector of MTries.
Definition: ip4.h:115
fib_entry_get_prefix
const fib_prefix_t * fib_entry_get_prefix(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1728
ip4_show_fib
static clib_error_t * ip4_show_fib(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ip4_fib.c:571
ip4_fib_table_entry_insert
void ip4_fib_table_entry_insert(ip4_fib_t *fib, const ip4_address_t *addr, u32 len, fib_node_index_t fib_entry_index)
Definition: ip4_fib.c:317
ip4_fib_table_lookup_exact_match
fib_node_index_t ip4_fib_table_lookup_exact_match(const ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:246
ip4_main
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1105
hash_set_flags
static void hash_set_flags(void *v, uword flags)
Definition: hash.h:153
pool_elt_at_index
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:553
fib_entry_cmp_for_sort
int fib_entry_cmp_for_sort(void *i1, void *i2)
Definition: fib_entry.c:1660
FIB_ENTRY_FORMAT_DETAIL
#define FIB_ENTRY_FORMAT_DETAIL
Definition: fib_entry.h:360
fib_table_t_::ft_epoch
u32 ft_epoch
Epoch - number of resyncs performed.
Definition: fib_table.h:117
FIB_ENTRY_FORMAT_DETAIL2
#define FIB_ENTRY_FORMAT_DETAIL2
Definition: fib_entry.h:361
format_ip4_fib_mtrie
format_function_t format_ip4_fib_mtrie
Format/display the contents of the mtrie.
Definition: ip4_mtrie.h:172
pool_get_aligned
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P with alignment A.
Definition: pool.h:249
fib_table_assert_empty
void fib_table_assert_empty(const fib_table_t *fib_table)
Debug function.
Definition: fib_entry.c:1755
format_ip_flow_hash_config
u8 * format_ip_flow_hash_config(u8 *s, va_list *args)
Definition: lookup.c:118
format_fib_table_name
u8 * format_fib_table_name(u8 *s, va_list *ap)
Format the description/name of the table.
Definition: fib_table.c:1379
ip4_fib_table_entry_remove
void ip4_fib_table_entry_remove(ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:349
ip4_fib_table_walk
void ip4_fib_table_walk(ip4_fib_t *fib, fib_table_walk_fn_t fn, void *ctx)
Walk all entries in a FIB table N.B: This is NOT safe to deletes.
Definition: ip4_fib.c:408
vlib_cli_command_t::path
char * path
Definition: cli.h:96
FIB_NODE_INDEX_INVALID
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:30
fib_table.h
fib_prefix_t_::fp_len
u16 fp_len
The mask length.
Definition: fib_types.h:206
ip4_main_t::fib_index_by_table_id
uword * fib_index_by_table_id
Hash table mapping table id to fib index.
Definition: ip4.h:133
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_fib_table_create_and_lock
u32 ip4_fib_table_create_and_lock(fib_source_t src)
Definition: ip4_fib.c:221
HASH_FLAG_NO_AUTO_SHRINK
#define HASH_FLAG_NO_AUTO_SHRINK
Definition: hash.h:64
ip4_main_t::fib_masks
u32 fib_masks[33]
Definition: ip4.h:120
unformat_input_t
struct _unformat_input_t unformat_input_t
addr
vhost_vring_addr_t addr
Definition: vhost_user.h:130
hash_create
#define hash_create(elts, value_bytes)
Definition: hash.h:695
ip4_show_fib_command
static vlib_cli_command_t ip4_show_fib_command
(constructor) VLIB_CLI_COMMAND (ip4_show_fib_command)
Definition: ip4_fib.c:864
ip4_fib_t_
The IPv4 FIB.
Definition: ip4_fib.h:39
key
typedef key
Definition: ipsec_types.api:88
i32
signed int i32
Definition: types.h:77
hash_foreach_pair
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:373
unformat
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
hash_set
#define hash_set(h, key, value)
Definition: hash.h:255
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_fib_table_show_all
static void ip4_fib_table_show_all(ip4_fib_t *fib, vlib_main_t *vm)
Definition: ip4_fib.c:523
fib_table_t_
A protocol Independent FIB table.
Definition: fib_table.h:71
fib_table_entry_special_remove
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a 'special' entry from the FIB.
Definition: fib_table.c:424
ip4_fib_mtrie_memory_usage
uword ip4_fib_mtrie_memory_usage(ip4_fib_mtrie_t *m)
return the memory used by the table
Definition: ip4_mtrie.c:674
pool_foreach
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:534
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
fib_entry_flag_t
enum fib_entry_flag_t_ fib_entry_flag_t
len
u8 len
Definition: ip_types.api:103
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:606
fib_table_t_::ft_index
fib_node_index_t ft_index
Index into FIB vector.
Definition: fib_table.h:97
hash_pair_t::value
uword value[0]
Definition: hash.h:165
fib_entry_contribute_ip_forwarding
const dpo_id_t * fib_entry_contribute_ip_forwarding(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:506
ip4_fib_table_special_prefix_t
struct ip4_fib_table_special_prefix_t_ ip4_fib_table_special_prefix_t
memory
vhost_user_memory_t memory
Definition: vhost_user.h:131
fib_table_t_::ft_table_id
u32 ft_table_id
Table ID (hash key) for this FIB.
Definition: fib_table.h:92
fib_table_t_::ft_total_route_counts
u32 ft_total_route_counts
Total route counters.
Definition: fib_table.h:112
ARRAY_LEN
#define ARRAY_LEN(x)
Definition: clib.h:70
unformat_check_input
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
ip4_fib_show_walk_ctx_t_::ifsw_indicies
fib_node_index_t * ifsw_indicies
Definition: ip4_fib.c:508
fib_table_t_::ft_locks
u32 * ft_locks
per-source number of locks on the table
Definition: fib_table.h:86
index_t
u32 index_t
A Data-Path Object is an object that represents actions that are applied to packets are they are swit...
Definition: dpo.h:43
format_fib_source
u8 * format_fib_source(u8 *s, va_list *args)
Definition: fib_source.c:66
IP_FLOW_HASH_DEFAULT
#define IP_FLOW_HASH_DEFAULT
Default: 5-tuple + flowlabel without the "reverse" bit.
Definition: ip_flow_hash.h:22
fib_node_index_t
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:29
vec_foreach_index
#define vec_foreach_index(var, v)
Iterate over vector indices.
Definition: vec_bootstrap.h:220
ip4_fib_table_lookup_lb
index_t ip4_fib_table_lookup_lb(ip4_fib_t *fib, const ip4_address_t *addr)
Definition: ip4_fib.c:270
uword
u64 uword
Definition: types.h:112
if
if(node->flags &VLIB_NODE_FLAG_TRACE) vnet_interface_output_trace(vm
hash_get
#define hash_get(h, key)
Definition: hash.h:249
ip4_fib_table_lookup
fib_node_index_t ip4_fib_table_lookup(const ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:294
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
pool_get
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:255
fib_table_t_::ft_flags
fib_table_flags_t ft_flags
Table flags.
Definition: fib_table.h:81
address
manual_print typedef address
Definition: ip_types.api:96
VLIB_CLI_COMMAND
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
src
vl_api_address_t src
Definition: gre.api:54
ip4_specials
static const ip4_fib_table_special_prefix_t ip4_specials[]
Definition: ip4_fib.c:29
ip4_fib_show_walk_ctx_t_
Walk show context.
Definition: ip4_fib.c:506
ip4_fib_table_special_prefix_t_::ift_source
fib_source_t ift_source
Definition: ip4_fib.c:25
ip4_address_t
Definition: ip4_packet.h:50
FIB_ENTRY_FLAG_DROP
@ FIB_ENTRY_FLAG_DROP
Definition: fib_entry.h:115
FIB_PROTOCOL_IP4
@ FIB_PROTOCOL_IP4
Definition: fib_types.h:36
CLIB_CACHE_LINE_BYTES
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
vlib_cli_output
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
fib_prefix_t_::fp_addr
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:225
ip4_fib_table_destroy
void ip4_fib_table_destroy(u32 fib_index)
Definition: ip4_fib.c:156
fib_table_walk_fn_t
fib_table_walk_rc_t(* fib_table_walk_fn_t)(fib_node_index_t fei, void *ctx)
Call back function when walking entries in a FIB table.
Definition: fib_table.h:930
ip4_fib_table_special_prefix_t_::ift_flag
fib_entry_flag_t ift_flag
Definition: ip4_fib.c:26
ip4_destination_matches_route
static uword ip4_destination_matches_route(const ip4_main_t *im, const ip4_address_t *key, const ip4_address_t *dest, uword dest_length)
Definition: ip4.h:188
hash_elts
static uword hash_elts(void *v)
Definition: hash.h:118
vec_free
#define vec_free(V)
Free vector's memory (no header).
Definition: vec.h:395
index
u32 index
Definition: flow_types.api:221
format_ip4_fib_table_memory
u8 * format_ip4_fib_table_memory(u8 *s, va_list *args)
Definition: ip4_fib.c:562
ip4_fib_mtrie_route_add
void ip4_fib_mtrie_route_add(ip4_fib_mtrie_t *m, const ip4_address_t *dst_address, u32 dst_address_length, u32 adj_index)
Add a route/entry to the mtrie.
Definition: ip4_mtrie.c:617
ip4_fib_table_fwding_dpo_remove
void ip4_fib_table_fwding_dpo_remove(ip4_fib_t *fib, const ip4_address_t *addr, u32 len, const dpo_id_t *dpo, u32 cover_index)
Definition: ip4_fib.c:384
fib_table_t_::ft_flow_hash_config
u32 ft_flow_hash_config
flow hash configuration
Definition: fib_table.h:102
u64
unsigned long u64
Definition: types.h:89
format
description fragment has unexpected format
Definition: map.api:433
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
FIB_SOURCE_DEFAULT_ROUTE
@ FIB_SOURCE_DEFAULT_ROUTE
The default route source.
Definition: fib_source.h:134
FIB_TABLE_WALK_STOP
@ FIB_TABLE_WALK_STOP
Stop the walk completely.
Definition: fib_table.h:924
ip4_fib_mtrie_route_del
void ip4_fib_mtrie_route_del(ip4_fib_mtrie_t *m, const ip4_address_t *dst_address, u32 dst_address_length, u32 adj_index, u32 cover_address_length, u32 cover_adj_index)
remove a route/entry to the mtrie
Definition: ip4_mtrie.c:634
fib_table_lock
void fib_table_lock(u32 fib_index, fib_protocol_t proto, fib_source_t source)
Release a reference counting lock on the table.
Definition: fib_table.c:1355
u32
unsigned int u32
Definition: types.h:88
ip4_fib_table_get_index_for_sw_if_index
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
Definition: ip4_fib.c:227
ip4_fib_table_sub_tree_walk
void ip4_fib_table_sub_tree_walk(ip4_fib_t *fib, const fib_prefix_t *root, fib_table_walk_fn_t fn, void *ctx)
Walk all entries in a sub-tree of the FIB table N.B: This is NOT safe to deletes.
Definition: ip4_fib.c:425
ip4_mtrie_free
void ip4_mtrie_free(ip4_fib_mtrie_t *m)
Free an mtrie, It must be emty when free'd.
Definition: ip4_mtrie.c:192
fib_table_walk_rc_t
enum fib_table_walk_rc_t_ fib_table_walk_rc_t
return code controlling how a table walk proceeds
ip4_main_t::fibs
struct fib_table_t_ * fibs
Vector of FIBs.
Definition: ip4.h:112
table_id
u32 table_id
Definition: wireguard.api:102
ip4_fib_table_fwding_dpo_update
void ip4_fib_table_fwding_dpo_update(ip4_fib_t *fib, const ip4_address_t *addr, u32 len, const dpo_id_t *dpo)
Definition: ip4_fib.c:375
ctx
long ctx[MAX_CONNS]
Definition: main.c:144
vec_foreach
#define vec_foreach(var, vec)
Vector iterator.
Definition: vec_bootstrap.h:213
hash_pair_t::key
uword key
Definition: hash.h:162
ip4_fib_show_walk_cb
static fib_table_walk_rc_t ip4_fib_show_walk_cb(fib_node_index_t fib_entry_index, void *arg)
Definition: ip4_fib.c:512
pool_elts
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:127
FIB_ENTRY_FORMAT_BRIEF
#define FIB_ENTRY_FORMAT_BRIEF
Definition: fib_entry.h:359
fib_prefix_t_::fp_proto
fib_protocol_t fp_proto
protocol type
Definition: fib_types.h:211
FIB_SOURCE_SPECIAL
@ FIB_SOURCE_SPECIAL
Special sources.
Definition: fib_source.h:45
ip4_fib.h
hash_unset
#define hash_unset(h, key)
Definition: hash.h:261
vec_sort_with_function
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:1097
ip4_fib_index_from_table_id
static u32 ip4_fib_index_from_table_id(u32 table_id)
Definition: ip4_fib.h:145
FIB_TABLE_WALK_CONTINUE
@ FIB_TABLE_WALK_CONTINUE
Continue on to the next entry.
Definition: fib_table.h:916
clib_memset
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
vlib_main_t
Definition: main.h:102
format_fib_table_flags
u8 * format_fib_table_flags(u8 *s, va_list *args)
Definition: fib_table.c:1393
u8
unsigned char u8
Definition: types.h:56
clib_error_t
Definition: clib_error.h:21
hash_bytes
__clib_export uword hash_bytes(void *v)
Definition: hash.c:994
dpo_id_t_
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:172
fib_source_t
enum fib_source_t_ fib_source_t
The different sources that can create a route.
unformat_ip4_address
unformat_function_t unformat_ip4_address
Definition: format.h:68
ip4_fib_table_special_prefix_t_::ift_prefix
fib_prefix_t ift_prefix
Definition: ip4_fib.c:24
ip4_fib_t_::mtrie
ip4_fib_mtrie_t mtrie
Mtrie for fast lookups.
Definition: ip4_fib.h:48
ip4_fib_t_::index
u32 index
Definition: ip4_fib.h:57
ip4_fib_table_show_one
static void ip4_fib_table_show_one(ip4_fib_t *fib, vlib_main_t *vm, ip4_address_t *address, u32 mask_len, int detail)
Definition: ip4_fib.c:547
fib_table_t_::ft_proto
fib_protocol_t ft_proto
Which protocol this table serves.
Definition: fib_table.h:76
ip4_mtrie_init
void ip4_mtrie_init(ip4_fib_mtrie_t *m)
Initialise an mtrie.
Definition: ip4_mtrie.c:208
fib_table_entry_special_add
fib_node_index_t fib_table_entry_special_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags)
Add a 'special' entry to the FIB.
Definition: fib_table.c:405
vlib_cli_command_t
Definition: cli.h:92
INDEX_INVALID
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:49
ip4_main_t
IPv4 main type.
Definition: ip4.h:107
ip4_fib_table_special_prefix_t_
Definition: ip4_fib.c:23
fib_table_t_::ft_src_route_counts
u32 * ft_src_route_counts
Per-source route counters.
Definition: fib_table.h:107
sw_if_index
vl_api_interface_index_t sw_if_index
Definition: wireguard.api:34
ip4_fib_t_::table_id
u32 table_id
Definition: ip4_fib.h:54
fib_prefix_t_
Aggregate type for a prefix.
Definition: fib_types.h:202
ip4_fib_show_walk_ctx_t
struct ip4_fib_show_walk_ctx_t_ ip4_fib_show_walk_ctx_t
Walk show context.
UNFORMAT_END_OF_INPUT
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
hash_pair_t
Definition: hash.h:159
prefix
vl_api_prefix_t prefix
Definition: ip.api:146
ip4_fib_t_::fib_entry_by_dst_address
uword * fib_entry_by_dst_address[33]
Definition: ip4_fib.h:51
ip4_create_fib_with_table_id
static u32 ip4_create_fib_with_table_id(u32 table_id, fib_source_t src)
Definition: ip4_fib.c:104
format_fib_entry
u8 * format_fib_entry(u8 *s, va_list *args)
Definition: fib_entry.c:130