FD.io VPP  v18.01-8-g0eacf49
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 pefixes to be added to tables and the sources for them
22  */
28 
29 static const ip4_fib_table_special_prefix_t ip4_specials[] = {
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
105  fib_source_t src)
106 {
107  fib_table_t *fib_table;
108  ip4_fib_t *v4_fib;
109  void *old_heap;
110 
112  memset(fib_table, 0, sizeof(*fib_table));
113 
116  clib_mem_set_heap (old_heap);
117 
118  ASSERT((fib_table - ip4_main.fibs) ==
119  (v4_fib - ip4_main.v4_fibs));
120 
121  fib_table->ft_proto = FIB_PROTOCOL_IP4;
122  fib_table->ft_index =
123  v4_fib->index =
124  (fib_table - ip4_main.fibs);
125 
126  hash_set (ip4_main.fib_index_by_table_id, table_id, fib_table->ft_index);
127 
128  fib_table->ft_table_id =
129  v4_fib->table_id =
130  table_id;
132  v4_fib->fwd_classify_table_index = ~0;
133  v4_fib->rev_classify_table_index = ~0;
134 
135  fib_table_lock(fib_table->ft_index, FIB_PROTOCOL_IP4, src);
136 
137  ip4_mtrie_init(&v4_fib->mtrie);
138 
139  /*
140  * add the special entries into the new FIB
141  */
142  int ii;
143 
144  for (ii = 0; ii < ARRAY_LEN(ip4_specials); ii++)
145  {
146  fib_prefix_t prefix = ip4_specials[ii].ift_prefix;
147 
148  prefix.fp_addr.ip4.data_u32 =
149  clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
150 
152  &prefix,
153  ip4_specials[ii].ift_source,
154  ip4_specials[ii].ift_flag);
155  }
156 
157  return (fib_table->ft_index);
158 }
159 
160 void
162 {
163  fib_table_t *fib_table = pool_elt_at_index(ip4_main.fibs, fib_index);
164  ip4_fib_t *v4_fib = pool_elt_at_index(ip4_main.v4_fibs, fib_index);
165  int ii;
166 
167  /*
168  * remove all the specials we added when the table was created.
169  * In reverse order so the default route is last.
170  */
171  for (ii = ARRAY_LEN(ip4_specials) - 1; ii >= 0; ii--)
172  {
173  fib_prefix_t prefix = ip4_specials[ii].ift_prefix;
174 
175  prefix.fp_addr.ip4.data_u32 =
176  clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
177 
179  &prefix,
180  ip4_specials[ii].ift_source);
181  }
182 
183  /*
184  * validate no more routes.
185  */
186  ASSERT(0 == fib_table->ft_total_route_counts);
188  {
189  ASSERT(0 == fib_table->ft_src_route_counts[ii]);
190  }
191 
192  if (~0 != fib_table->ft_table_id)
193  {
195  }
196 
197  ip4_mtrie_free(&v4_fib->mtrie);
198 
199  pool_put(ip4_main.v4_fibs, v4_fib);
200  pool_put(ip4_main.fibs, fib_table);
201 }
202 
203 
204 u32
206  fib_source_t src)
207 {
208  u32 index;
209 
210  index = ip4_fib_index_from_table_id(table_id);
211  if (~0 == index)
212  return ip4_create_fib_with_table_id(table_id, src);
213 
214  fib_table_lock(index, FIB_PROTOCOL_IP4, src);
215 
216  return (index);
217 }
218 
219 u32
221 {
222  return (ip4_create_fib_with_table_id(~0, src));
223 }
224 
225 u32
227 {
228  if (sw_if_index >= vec_len(ip4_main.fib_index_by_sw_if_index))
229  {
230  /*
231  * This is the case for interfaces that are not yet mapped to
232  * a IP table
233  */
234  return (~0);
235  }
236  return (ip4_main.fib_index_by_sw_if_index[sw_if_index]);
237 }
238 
239 /*
240  * ip4_fib_table_lookup_exact_match
241  *
242  * Exact match prefix lookup
243  */
246  const ip4_address_t *addr,
247  u32 len)
248 {
249  uword * hash, * result;
250  u32 key;
251 
252  hash = fib->fib_entry_by_dst_address[len];
253  key = (addr->data_u32 & ip4_main.fib_masks[len]);
254 
255  result = hash_get(hash, key);
256 
257  if (NULL != result) {
258  return (result[0]);
259  }
260  return (FIB_NODE_INDEX_INVALID);
261 }
262 
263 /*
264  * ip4_fib_table_lookup_adj
265  *
266  * Longest prefix match
267  */
268 index_t
270  const ip4_address_t *addr)
271 {
272  fib_node_index_t fei;
273 
274  fei = ip4_fib_table_lookup(fib, addr, 32);
275 
276  if (FIB_NODE_INDEX_INVALID != fei)
277  {
278  const dpo_id_t *dpo;
279 
281 
282  return (dpo->dpoi_index);
283  }
284  return (INDEX_INVALID);
285 }
286 
287 /*
288  * ip4_fib_table_lookup
289  *
290  * Longest prefix match
291  */
294  const ip4_address_t *addr,
295  u32 len)
296 {
297  uword * hash, * result;
298  i32 mask_len;
299  u32 key;
300 
301  for (mask_len = len; mask_len >= 0; mask_len--)
302  {
303  hash = fib->fib_entry_by_dst_address[mask_len];
304  key = (addr->data_u32 & ip4_main.fib_masks[mask_len]);
305 
306  result = hash_get (hash, key);
307 
308  if (NULL != result) {
309  return (result[0]);
310  }
311  }
312  return (FIB_NODE_INDEX_INVALID);
313 }
314 
315 void
317  const ip4_address_t *addr,
318  u32 len,
319  fib_node_index_t fib_entry_index)
320 {
321  uword * hash, * result;
322  u32 key;
323 
324  key = (addr->data_u32 & ip4_main.fib_masks[len]);
325  hash = fib->fib_entry_by_dst_address[len];
326  result = hash_get (hash, key);
327 
328  if (NULL == result) {
329  /*
330  * adding a new entry
331  */
332  uword *old_heap;
334 
335  if (NULL == hash) {
336  hash = hash_create (32 /* elts */, sizeof (uword));
338 
339  }
340  hash = hash_set(hash, key, fib_entry_index);
341  fib->fib_entry_by_dst_address[len] = hash;
342  clib_mem_set_heap (old_heap);
343  }
344  else
345  {
346  ASSERT(0);
347  }
348 }
349 
350 void
352  const ip4_address_t *addr,
353  u32 len)
354 {
355  uword * hash, * result;
356  u32 key;
357 
358  key = (addr->data_u32 & ip4_main.fib_masks[len]);
359  hash = fib->fib_entry_by_dst_address[len];
360  result = hash_get (hash, key);
361 
362  if (NULL == result)
363  {
364  /*
365  * removing a non-existant entry. i'll allow it.
366  */
367  }
368  else
369  {
370  uword *old_heap;
371 
373  hash_unset(hash, key);
374  clib_mem_set_heap (old_heap);
375  }
376 
377  fib->fib_entry_by_dst_address[len] = hash;
378 }
379 
380 void
382  const ip4_address_t *addr,
383  u32 len,
384  const dpo_id_t *dpo)
385 {
386  ip4_fib_mtrie_route_add(&fib->mtrie, addr, len, dpo->dpoi_index);
387 }
388 
389 void
391  const ip4_address_t *addr,
392  u32 len,
393  const dpo_id_t *dpo,
394  u32 cover_index)
395 {
396  fib_prefix_t cover_prefix = {
397  .fp_len = 0,
398  };
399  const dpo_id_t *cover_dpo;
400 
401  /*
402  * We need to pass the MTRIE the LB index and address length of the
403  * covering prefix, so it can fill the plys with the correct replacement
404  * for the entry being removed
405  */
406  fib_entry_get_prefix(cover_index, &cover_prefix);
407  cover_dpo = fib_entry_contribute_ip_forwarding(cover_index);
408 
410  addr, len, dpo->dpoi_index,
411  cover_prefix.fp_len,
412  cover_dpo->dpoi_index);
413 }
414 
415 void
418  void *ctx)
419 {
420  int i;
421 
422  for (i = 0; i < ARRAY_LEN (fib->fib_entry_by_dst_address); i++)
423  {
424  uword * hash = fib->fib_entry_by_dst_address[i];
425 
426  if (NULL != hash)
427  {
428  hash_pair_t * p;
429 
430  hash_foreach_pair (p, hash,
431  ({
432  fn(p->value[0], ctx);
433  }));
434  }
435  }
436 }
437 
438 /**
439  * Walk show context
440  */
442 {
445 
446 static int
448  void *arg)
449 {
451 
452  vec_add1(ctx->ifsw_indicies, fib_entry_index);
453 
454  return (1);
455 }
456 
457 static void
459  vlib_main_t * vm)
460 {
462  .ifsw_indicies = NULL,
463  };
464  fib_node_index_t *fib_entry_index;
465 
469 
470  vec_foreach(fib_entry_index, ctx.ifsw_indicies)
471  {
472  vlib_cli_output(vm, "%U",
474  *fib_entry_index,
476  }
477 
478  vec_free(ctx.ifsw_indicies);
479 }
480 
481 static void
483  vlib_main_t * vm,
484  ip4_address_t *address,
485  u32 mask_len,
486  int detail)
487 {
488  vlib_cli_output(vm, "%U",
490  ip4_fib_table_lookup(fib, address, mask_len),
491  (detail ?
494 }
495 
496 u8 *
497 format_ip4_fib_table_memory (u8 * s, va_list * args)
498 {
499  s = format(s, "%=30s %=6d %=8ld\n",
500  "IPv4 unicast",
503 
504  return (s);
505 }
506 
507 static clib_error_t *
509  unformat_input_t * input,
510  vlib_cli_command_t * cmd)
511 {
512  ip4_main_t * im4 = &ip4_main;
513  fib_table_t * fib_table;
514  u64 total_mtrie_memory, total_hash_memory;
515  int verbose, matching, mtrie, memory;
516  ip4_address_t matching_address;
517  u32 matching_mask = 32;
518  int i, table_id = -1, fib_index = ~0;
519  int detail = 0;
520 
521  verbose = 1;
522  matching = mtrie = memory = 0;
523  total_hash_memory = total_mtrie_memory = 0;
524 
526  {
527  if (unformat (input, "brief") || unformat (input, "summary")
528  || unformat (input, "sum"))
529  verbose = 0;
530 
531  else if (unformat (input, "detail") || unformat (input, "det"))
532  detail = 1;
533 
534  else if (unformat (input, "mtrie"))
535  mtrie = 1;
536 
537  else if (unformat (input, "mem") ||
538  unformat (input, "memory"))
539  memory = 1;
540 
541  else if (unformat (input, "%U/%d",
542  unformat_ip4_address, &matching_address, &matching_mask))
543  matching = 1;
544 
545  else if (unformat (input, "%U", unformat_ip4_address, &matching_address))
546  matching = 1;
547 
548  else if (unformat (input, "table %d", &table_id))
549  ;
550  else if (unformat (input, "index %d", &fib_index))
551  ;
552  else
553  break;
554  }
555 
556  pool_foreach (fib_table, im4->fibs,
557  ({
558  ip4_fib_t *fib = pool_elt_at_index(im4->v4_fibs, fib_table->ft_index);
559  fib_source_t source;
560  u8 *s = NULL;
561 
562  if (table_id >= 0 && table_id != (int)fib->table_id)
563  continue;
564  if (fib_index != ~0 && fib_index != (int)fib->index)
565  continue;
566 
567  if (memory)
568  {
569  uword mtrie_size, hash_size;
570 
571  mtrie_size = ip4_fib_mtrie_memory_usage(&fib->mtrie);
572  hash_size = 0;
573 
574  for (i = 0; i < ARRAY_LEN (fib->fib_entry_by_dst_address); i++)
575  {
576  uword * hash = fib->fib_entry_by_dst_address[i];
577  if (NULL != hash)
578  {
579  hash_size += hash_bytes(hash);
580  }
581  }
582  if (verbose)
583  vlib_cli_output (vm, "%U mtrie:%d hash:%d",
584  format_fib_table_name, fib->index,
585  FIB_PROTOCOL_IP4,
586  mtrie_size,
587  hash_size);
588  total_mtrie_memory += mtrie_size;
589  total_hash_memory += hash_size;
590  continue;
591  }
592 
593  s = format(s, "%U, fib_index:%d, flow hash:[%U] locks:[",
594  format_fib_table_name, fib->index,
596  fib->index,
598  fib_table->ft_flow_hash_config);
599  FOR_EACH_FIB_SOURCE(source)
600  {
601  if (0 != fib_table->ft_locks[source])
602  {
603  s = format(s, "%U:%d, ",
604  format_fib_source, source,
605  fib_table->ft_locks[source]);
606  }
607  }
608  s = format (s, "]");
609  vlib_cli_output (vm, "%v", s);
610  vec_free(s);
611 
612  /* Show summary? */
613  if (mtrie)
614  {
615  vlib_cli_output (vm, "%U", format_ip4_fib_mtrie, &fib->mtrie, verbose);
616  continue;
617  }
618  if (! verbose)
619  {
620  vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count");
621  for (i = 0; i < ARRAY_LEN (fib->fib_entry_by_dst_address); i++)
622  {
623  uword * hash = fib->fib_entry_by_dst_address[i];
624  uword n_elts = hash_elts (hash);
625  if (n_elts > 0)
626  vlib_cli_output (vm, "%20d%16d", i, n_elts);
627  }
628  continue;
629  }
630 
631  if (!matching)
632  {
633  ip4_fib_table_show_all(fib, vm);
634  }
635  else
636  {
637  ip4_fib_table_show_one(fib, vm, &matching_address,
638  matching_mask, detail);
639  }
640  }));
641 
642  if (memory)
643  vlib_cli_output (vm, "totals: mtrie:%ld hash:%ld all:%ld",
644  total_mtrie_memory,
645  total_hash_memory,
646  total_mtrie_memory + total_hash_memory);
647 
648  return 0;
649 }
650 
651 /*?
652  * This command displays the IPv4 FIB Tables (VRF Tables) and the route
653  * entries for each table.
654  *
655  * @note This command will run for a long time when the FIB tables are
656  * comprised of millions of entries. For those senarios, consider displaying
657  * a single table or summary mode.
658  *
659  * @cliexpar
660  * Example of how to display all the IPv4 FIB tables:
661  * @cliexstart{show ip fib}
662  * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
663  * 0.0.0.0/0
664  * unicast-ip4-chain
665  * [@0]: dpo-load-balance: [index:0 buckets:1 uRPF:0 to:[0:0]]
666  * [0] [@0]: dpo-drop ip6
667  * 0.0.0.0/32
668  * unicast-ip4-chain
669  * [@0]: dpo-load-balance: [index:1 buckets:1 uRPF:1 to:[0:0]]
670  * [0] [@0]: dpo-drop ip6
671  * 6.0.1.2/32
672  * unicast-ip4-chain
673  * [@0]: dpo-load-balance: [index:30 buckets:1 uRPF:29 to:[0:0]]
674  * [0] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
675  * 7.0.0.1/32
676  * unicast-ip4-chain
677  * [@0]: dpo-load-balance: [index:31 buckets:4 uRPF:30 to:[0:0]]
678  * [0] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
679  * [1] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
680  * [2] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
681  * [3] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
682  * 224.0.0.0/8
683  * unicast-ip4-chain
684  * [@0]: dpo-load-balance: [index:3 buckets:1 uRPF:3 to:[0:0]]
685  * [0] [@0]: dpo-drop ip6
686  * 240.0.0.0/8
687  * unicast-ip4-chain
688  * [@0]: dpo-load-balance: [index:2 buckets:1 uRPF:2 to:[0:0]]
689  * [0] [@0]: dpo-drop ip6
690  * 255.255.255.255/32
691  * unicast-ip4-chain
692  * [@0]: dpo-load-balance: [index:4 buckets:1 uRPF:4 to:[0:0]]
693  * [0] [@0]: dpo-drop ip6
694  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
695  * 0.0.0.0/0
696  * unicast-ip4-chain
697  * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
698  * [0] [@0]: dpo-drop ip6
699  * 0.0.0.0/32
700  * unicast-ip4-chain
701  * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
702  * [0] [@0]: dpo-drop ip6
703  * 172.16.1.0/24
704  * unicast-ip4-chain
705  * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
706  * [0] [@4]: ipv4-glean: af_packet0
707  * 172.16.1.1/32
708  * unicast-ip4-chain
709  * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
710  * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
711  * 172.16.1.2/32
712  * unicast-ip4-chain
713  * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
714  * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
715  * 172.16.2.0/24
716  * unicast-ip4-chain
717  * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
718  * [0] [@4]: ipv4-glean: af_packet1
719  * 172.16.2.1/32
720  * unicast-ip4-chain
721  * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
722  * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
723  * 224.0.0.0/8
724  * unicast-ip4-chain
725  * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
726  * [0] [@0]: dpo-drop ip6
727  * 240.0.0.0/8
728  * unicast-ip4-chain
729  * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
730  * [0] [@0]: dpo-drop ip6
731  * 255.255.255.255/32
732  * unicast-ip4-chain
733  * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
734  * [0] [@0]: dpo-drop ip6
735  * @cliexend
736  * Example of how to display a single IPv4 FIB table:
737  * @cliexstart{show ip fib table 7}
738  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
739  * 0.0.0.0/0
740  * unicast-ip4-chain
741  * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
742  * [0] [@0]: dpo-drop ip6
743  * 0.0.0.0/32
744  * unicast-ip4-chain
745  * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
746  * [0] [@0]: dpo-drop ip6
747  * 172.16.1.0/24
748  * unicast-ip4-chain
749  * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
750  * [0] [@4]: ipv4-glean: af_packet0
751  * 172.16.1.1/32
752  * unicast-ip4-chain
753  * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
754  * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
755  * 172.16.1.2/32
756  * unicast-ip4-chain
757  * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
758  * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
759  * 172.16.2.0/24
760  * unicast-ip4-chain
761  * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
762  * [0] [@4]: ipv4-glean: af_packet1
763  * 172.16.2.1/32
764  * unicast-ip4-chain
765  * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
766  * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
767  * 224.0.0.0/8
768  * unicast-ip4-chain
769  * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
770  * [0] [@0]: dpo-drop ip6
771  * 240.0.0.0/8
772  * unicast-ip4-chain
773  * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
774  * [0] [@0]: dpo-drop ip6
775  * 255.255.255.255/32
776  * unicast-ip4-chain
777  * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
778  * [0] [@0]: dpo-drop ip6
779  * @cliexend
780  * Example of how to display a summary of all IPv4 FIB tables:
781  * @cliexstart{show ip fib summary}
782  * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
783  * Prefix length Count
784  * 0 1
785  * 8 2
786  * 32 4
787  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
788  * Prefix length Count
789  * 0 1
790  * 8 2
791  * 24 2
792  * 32 4
793  * @cliexend
794  ?*/
795 /* *INDENT-OFF* */
796 VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
797  .path = "show ip fib",
798  .short_help = "show ip fib [summary] [table <table-id>] [index <fib-id>] [<ip4-addr>[/<mask>]] [mtrie] [detail]",
799  .function = ip4_show_fib,
800 };
801 /* *INDENT-ON* */
u8 * format_fib_entry(u8 *s, va_list *args)
Definition: fib_entry.c:103
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:482
#define hash_set(h, key, value)
Definition: hash.h:254
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
fib_protocol_t ft_proto
Which protocol this table serves.
Definition: fib_table.h:40
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:390
#define hash_unset(h, key)
Definition: hash.h:260
#define FIB_ENTRY_FORMAT_DETAIL
Definition: fib_entry.h:440
void fib_entry_get_prefix(fib_node_index_t fib_entry_index, fib_prefix_t *pfx)
Definition: fib_entry.c:1546
#define NULL
Definition: clib.h:55
int(* 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:798
const dpo_id_t * fib_entry_contribute_ip_forwarding(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:459
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:41
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
void ip4_fib_table_destroy(u32 fib_index)
Definition: ip4_fib.c:161
static clib_error_t * ip4_show_fib(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ip4_fib.c:508
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:111
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
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:205
static void ip4_fib_table_show_all(ip4_fib_t *fib, vlib_main_t *vm)
Definition: ip4_fib.c:458
uword value[0]
Definition: hash.h:164
vhost_user_memory_t memory
Definition: vhost-user.h:84
u32 ip4_fib_table_create_and_lock(fib_source_t src)
Definition: ip4_fib.c:220
fib_entry_flag_t ift_flag
Definition: ip4_fib.c:26
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
Definition: ip4_fib.c:226
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:438
unformat_function_t unformat_ip4_address
Definition: format.h:76
u32 table_id
Definition: ip4_fib.h:51
void fib_table_entry_special_remove(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source)
Remove a &#39;special&#39; entry from the FIB.
Definition: fib_table.c:390
u32 index
Definition: ip4_fib.h:54
int i32
Definition: types.h:81
void ip4_mtrie_free(ip4_fib_mtrie_t *m)
Free an mtrie, It must be emty when free&#39;d.
Definition: ip4_mtrie.c:199
Aggregrate type for a prefix.
Definition: fib_types.h:172
unsigned long u64
Definition: types.h:89
static void hash_set_flags(void *v, uword flags)
Definition: hash.h:152
static int ip4_fib_show_walk_cb(fib_node_index_t fib_entry_index, void *arg)
Definition: ip4_fib.c:447
u16 fp_len
The mask length.
Definition: fib_types.h:176
void ip4_fib_table_entry_remove(ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:351
int fib_entry_cmp_for_sort(void *i1, void *i2)
Definition: fib_entry.c:1498
void ip4_mtrie_init(ip4_fib_mtrie_t *m)
Initialise an mtrie.
Definition: ip4_mtrie.c:215
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:166
#define hash_get(h, key)
Definition: hash.h:248
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:459
uword * fib_index_by_table_id
Hash table mapping table id to fib index.
Definition: ip4.h:121
enum fib_source_t_ fib_source_t
The different sources that can create a route.
ip46_address_t fp_addr
The address type is not deriveable from the fp_addr member.
Definition: fib_types.h:195
u16 ft_locks[FIB_TABLE_N_LOCKS]
per-source number of locks on the table
Definition: fib_table.h:45
struct _unformat_input_t unformat_input_t
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:271
u32 ft_total_route_counts
Total route counters.
Definition: fib_table.h:70
void * mtrie_mheap
The memory heap for the mtries.
Definition: ip4.h:156
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:381
ip4_fib_mtrie_t mtrie
Mtrie for fast lookups.
Definition: ip4_fib.h:45
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P (general version).
Definition: pool.h:188
fib_node_index_t ip4_fib_table_lookup(const ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:293
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 &#39;special&#39; entry to the FIB.
Definition: fib_table.c:371
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:316
The IPv4 FIB.
Definition: ip4_fib.h:39
fib_node_index_t ft_index
Index into FIB vector.
Definition: fib_table.h:55
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
u32 ft_table_id
Table ID (hash key) for this FIB.
Definition: fib_table.h:50
vlib_main_t * vm
Definition: buffer.c:283
u32 ft_flow_hash_config
flow hash configuration
Definition: fib_table.h:60
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
#define FOR_EACH_FIB_SOURCE(_item)
Definition: fib_entry.h:166
fib_node_index_t * ifsw_indicies
Definition: ip4_fib.c:443
static void * clib_mem_set_heap(void *heap)
Definition: mem.h:226
Definition: fib_entry.h:241
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:29
static u32 ip4_fib_index_from_table_id(u32 table_id)
Definition: ip4_fib.h:137
#define ARRAY_LEN(x)
Definition: clib.h:59
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:416
enum fib_entry_flag_t_ fib_entry_flag_t
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:1209
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
#define hash_create(elts, value_bytes)
Definition: hash.h:681
static uword hash_elts(void *v)
Definition: hash.h:117
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
long ctx[MAX_CONNS]
Definition: main.c:122
The default route source.
Definition: fib_entry.h:129
IPv4 main type.
Definition: ip4.h:95
Walk show context.
Definition: ip4_fib.c:441
u32 ft_src_route_counts[FIB_SOURCE_MAX]
Per-source route counters.
Definition: fib_table.h:65
#define IP_FLOW_HASH_DEFAULT
Default: 5-tuple without the "reverse" bit.
Definition: lookup.h:69
u8 * format_ip4_fib_table_memory(u8 *s, va_list *args)
Definition: ip4_fib.c:497
u64 uword
Definition: types.h:112
uword mheap_bytes(void *v)
Definition: mheap.c:1030
#define FIB_ENTRY_FORMAT_BRIEF
Definition: fib_entry.h:439
format_function_t format_ip4_fib_mtrie
Format/display the contents of the mtrie.
Definition: ip4_mtrie.h:172
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:182
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:30
struct ip4_fib_t_ * v4_fibs
Vector of MTries.
Definition: ip4.h:103
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:372
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
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/rntry to the mtrie.
Definition: ip4_mtrie.c:633
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:956
u32 rev_classify_table_index
Definition: ip4_fib.h:58
Special sources.
Definition: fib_entry.h:40
u32 fwd_classify_table_index
Definition: ip4_fib.h:57
uword * fib_entry_by_dst_address[33]
Definition: ip4_fib.h:48
struct ip4_fib_table_special_prefix_t_ ip4_fib_table_special_prefix_t
u8 * format_fib_table_name(u8 *s, va_list *ap)
Format the description/name of the table.
Definition: fib_table.c:1233
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1181
struct fib_table_t_ * fibs
Vector of FIBs.
Definition: ip4.h:100
#define FIB_ENTRY_FORMAT_DETAIL2
Definition: fib_entry.h:441
#define vec_foreach(var, vec)
Vector iterator.
index_t ip4_fib_table_lookup_lb(ip4_fib_t *fib, const ip4_address_t *addr)
Definition: ip4_fib.c:269
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/rntry to the mtrie
Definition: ip4_mtrie.c:650
vhost_vring_addr_t addr
Definition: vhost-user.h:83
u8 * format_ip_flow_hash_config(u8 *s, va_list *args)
Definition: lookup.c:244
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
#define HASH_FLAG_NO_AUTO_SHRINK
Definition: hash.h:64
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:245
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:680
struct ip4_fib_show_walk_ctx_t_ ip4_fib_show_walk_ctx_t
Walk show context.
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
A protocol Independent FIB table.
Definition: fib_table.h:35
u32 fib_masks[33]
Definition: ip4.h:108
static u32 ip4_create_fib_with_table_id(u32 table_id, fib_source_t src)
Definition: ip4_fib.c:104
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128