FD.io VPP  v17.07.01-10-g3be13f0
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 {
106  fib_table_t *fib_table;
107  ip4_fib_t *v4_fib;
108 
110  memset(fib_table, 0, sizeof(*fib_table));
111 
113 
114  ASSERT((fib_table - ip4_main.fibs) ==
115  (v4_fib - ip4_main.v4_fibs));
116 
117  fib_table->ft_proto = FIB_PROTOCOL_IP4;
118  fib_table->ft_index =
119  v4_fib->index =
120  (fib_table - ip4_main.fibs);
121 
122  hash_set (ip4_main.fib_index_by_table_id, table_id, fib_table->ft_index);
123 
124  fib_table->ft_table_id =
125  v4_fib->table_id =
126  table_id;
128  v4_fib->fwd_classify_table_index = ~0;
129  v4_fib->rev_classify_table_index = ~0;
130 
132 
133  ip4_mtrie_init(&v4_fib->mtrie);
134 
135  /*
136  * add the special entries into the new FIB
137  */
138  int ii;
139 
140  for (ii = 0; ii < ARRAY_LEN(ip4_specials); ii++)
141  {
142  fib_prefix_t prefix = ip4_specials[ii].ift_prefix;
143 
144  prefix.fp_addr.ip4.data_u32 =
145  clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
146 
148  &prefix,
149  ip4_specials[ii].ift_source,
150  ip4_specials[ii].ift_flag);
151  }
152 
153  return (fib_table->ft_index);
154 }
155 
156 void
158 {
159  fib_table_t *fib_table = pool_elt_at_index(ip4_main.fibs, fib_index);
160  ip4_fib_t *v4_fib = pool_elt_at_index(ip4_main.v4_fibs, fib_index);
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  {
169  fib_prefix_t prefix = ip4_specials[ii].ift_prefix;
170 
171  prefix.fp_addr.ip4.data_u32 =
172  clib_host_to_net_u32(prefix.fp_addr.ip4.data_u32);
173 
175  &prefix,
176  ip4_specials[ii].ift_source);
177  }
178 
179  /*
180  * validate no more routes.
181  */
182  ASSERT(0 == fib_table->ft_total_route_counts);
184  {
185  ASSERT(0 == fib_table->ft_src_route_counts[ii]);
186  }
187 
188  if (~0 != fib_table->ft_table_id)
189  {
191  }
192 
193  ip4_mtrie_free(&v4_fib->mtrie);
194 
195  pool_put(ip4_main.v4_fibs, v4_fib);
196  pool_put(ip4_main.fibs, fib_table);
197 }
198 
199 
200 u32
202 {
203  u32 index;
204 
205  index = ip4_fib_index_from_table_id(table_id);
206  if (~0 == index)
207  return ip4_create_fib_with_table_id(table_id);
208 
210 
211  return (index);
212 }
213 
214 u32
216 {
217  return (ip4_create_fib_with_table_id(~0));
218 }
219 
220 u32
222 {
223  if (sw_if_index >= vec_len(ip4_main.fib_index_by_sw_if_index))
224  {
225  /*
226  * This is the case for interfaces that are not yet mapped to
227  * a IP table
228  */
229  return (~0);
230  }
231  return (ip4_main.fib_index_by_sw_if_index[sw_if_index]);
232 }
233 
234 /*
235  * ip4_fib_table_lookup_exact_match
236  *
237  * Exact match prefix lookup
238  */
241  const ip4_address_t *addr,
242  u32 len)
243 {
244  uword * hash, * result;
245  u32 key;
246 
247  hash = fib->fib_entry_by_dst_address[len];
248  key = (addr->data_u32 & ip4_main.fib_masks[len]);
249 
250  result = hash_get(hash, key);
251 
252  if (NULL != result) {
253  return (result[0]);
254  }
255  return (FIB_NODE_INDEX_INVALID);
256 }
257 
258 /*
259  * ip4_fib_table_lookup_adj
260  *
261  * Longest prefix match
262  */
263 index_t
265  const ip4_address_t *addr)
266 {
267  fib_node_index_t fei;
268 
269  fei = ip4_fib_table_lookup(fib, addr, 32);
270 
271  if (FIB_NODE_INDEX_INVALID != fei)
272  {
273  const dpo_id_t *dpo;
274 
276 
277  return (dpo->dpoi_index);
278  }
279  return (INDEX_INVALID);
280 }
281 
282 /*
283  * ip4_fib_table_lookup
284  *
285  * Longest prefix match
286  */
289  const ip4_address_t *addr,
290  u32 len)
291 {
292  uword * hash, * result;
293  i32 mask_len;
294  u32 key;
295 
296  for (mask_len = len; mask_len >= 0; mask_len--)
297  {
298  hash = fib->fib_entry_by_dst_address[mask_len];
299  key = (addr->data_u32 & ip4_main.fib_masks[mask_len]);
300 
301  result = hash_get (hash, key);
302 
303  if (NULL != result) {
304  return (result[0]);
305  }
306  }
307  return (FIB_NODE_INDEX_INVALID);
308 }
309 
310 void
312  const ip4_address_t *addr,
313  u32 len,
314  fib_node_index_t fib_entry_index)
315 {
316  uword * hash, * result;
317  u32 key;
318 
319  key = (addr->data_u32 & ip4_main.fib_masks[len]);
320  hash = fib->fib_entry_by_dst_address[len];
321  result = hash_get (hash, key);
322 
323  if (NULL == result) {
324  /*
325  * adding a new entry
326  */
327  if (NULL == hash) {
328  hash = hash_create (32 /* elts */, sizeof (uword));
330  }
331  hash = hash_set(hash, key, fib_entry_index);
332  fib->fib_entry_by_dst_address[len] = hash;
333  }
334  else
335  {
336  ASSERT(0);
337  }
338 }
339 
340 void
342  const ip4_address_t *addr,
343  u32 len)
344 {
345  uword * hash, * result;
346  u32 key;
347 
348  key = (addr->data_u32 & ip4_main.fib_masks[len]);
349  hash = fib->fib_entry_by_dst_address[len];
350  result = hash_get (hash, key);
351 
352  if (NULL == result)
353  {
354  /*
355  * removing a non-existant entry. i'll allow it.
356  */
357  }
358  else
359  {
360  hash_unset(hash, key);
361  }
362 
363  fib->fib_entry_by_dst_address[len] = hash;
364 }
365 
366 void
368  const ip4_address_t *addr,
369  u32 len,
370  const dpo_id_t *dpo)
371 {
372  ip4_fib_mtrie_route_add(&fib->mtrie, addr, len, dpo->dpoi_index);
373 }
374 
375 void
377  const ip4_address_t *addr,
378  u32 len,
379  const dpo_id_t *dpo,
380  u32 cover_index)
381 {
382  fib_prefix_t cover_prefix = {
383  .fp_len = 0,
384  };
385  const dpo_id_t *cover_dpo;
386 
387  /*
388  * We need to pass the MTRIE the LB index and address length of the
389  * covering prefix, so it can fill the plys with the correct replacement
390  * for the entry being removed
391  */
392  fib_entry_get_prefix(cover_index, &cover_prefix);
393  cover_dpo = fib_entry_contribute_ip_forwarding(cover_index);
394 
396  addr, len, dpo->dpoi_index,
397  cover_prefix.fp_len,
398  cover_dpo->dpoi_index);
399 }
400 
401 void
404  void *ctx)
405 {
406  int i;
407 
408  for (i = 0; i < ARRAY_LEN (fib->fib_entry_by_dst_address); i++)
409  {
410  uword * hash = fib->fib_entry_by_dst_address[i];
411 
412  if (NULL != hash)
413  {
414  hash_pair_t * p;
415 
416  hash_foreach_pair (p, hash,
417  ({
418  fn(p->value[0], ctx);
419  }));
420  }
421  }
422 }
423 
424 /**
425  * Walk show context
426  */
428 {
431 
432 static int
434  void *arg)
435 {
436  ip4_fib_show_walk_ctx_t *ctx = arg;
437 
438  vec_add1(ctx->ifsw_indicies, fib_entry_index);
439 
440  return (1);
441 }
442 
443 static void
445  vlib_main_t * vm)
446 {
448  .ifsw_indicies = NULL,
449  };
450  fib_node_index_t *fib_entry_index;
451 
455 
456  vec_foreach(fib_entry_index, ctx.ifsw_indicies)
457  {
458  vlib_cli_output(vm, "%U",
460  *fib_entry_index,
462  }
463 
464  vec_free(ctx.ifsw_indicies);
465 }
466 
467 static void
469  vlib_main_t * vm,
470  ip4_address_t *address,
471  u32 mask_len,
472  int detail)
473 {
474  vlib_cli_output(vm, "%U",
476  ip4_fib_table_lookup(fib, address, mask_len),
477  (detail ?
480 }
481 
482 static clib_error_t *
484  unformat_input_t * input,
485  vlib_cli_command_t * cmd)
486 {
487  ip4_main_t * im4 = &ip4_main;
488  fib_table_t * fib_table;
489  int verbose, matching, mtrie;
490  ip4_address_t matching_address;
491  u32 matching_mask = 32;
492  int i, table_id = -1, fib_index = ~0;
493  int detail = 0;
494 
495  verbose = 1;
496  matching = 0;
497  mtrie = 0;
499  {
500  if (unformat (input, "brief") || unformat (input, "summary")
501  || unformat (input, "sum"))
502  verbose = 0;
503 
504  else if (unformat (input, "detail") || unformat (input, "det"))
505  detail = 1;
506 
507  else if (unformat (input, "mtrie"))
508  mtrie = 1;
509 
510  else if (unformat (input, "%U/%d",
511  unformat_ip4_address, &matching_address, &matching_mask))
512  matching = 1;
513 
514  else if (unformat (input, "%U", unformat_ip4_address, &matching_address))
515  matching = 1;
516 
517  else if (unformat (input, "table %d", &table_id))
518  ;
519  else if (unformat (input, "index %d", &fib_index))
520  ;
521  else
522  break;
523  }
524 
525  pool_foreach (fib_table, im4->fibs,
526  ({
527  ip4_fib_t *fib = pool_elt_at_index(im4->v4_fibs, fib_table->ft_index);
528 
529  if (table_id >= 0 && table_id != (int)fib->table_id)
530  continue;
531  if (fib_index != ~0 && fib_index != (int)fib->index)
532  continue;
533 
534  vlib_cli_output (vm, "%U, fib_index:%d, flow hash:[%U] locks:%d",
535  format_fib_table_name, fib->index, FIB_PROTOCOL_IP4,
536  fib->index,
537  format_ip_flow_hash_config, fib_table->ft_flow_hash_config,
538  fib_table->ft_locks);
539 
540  /* Show summary? */
541  if (! verbose)
542  {
543  vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count");
544  for (i = 0; i < ARRAY_LEN (fib->fib_entry_by_dst_address); i++)
545  {
546  uword * hash = fib->fib_entry_by_dst_address[i];
547  uword n_elts = hash_elts (hash);
548  if (n_elts > 0)
549  vlib_cli_output (vm, "%20d%16d", i, n_elts);
550  }
551  continue;
552  }
553  if (mtrie)
554  {
555  vlib_cli_output (vm, "%U", format_ip4_fib_mtrie, &fib->mtrie);
556  continue;
557  }
558 
559  if (!matching)
560  {
561  ip4_fib_table_show_all(fib, vm);
562  }
563  else
564  {
565  ip4_fib_table_show_one(fib, vm, &matching_address,
566  matching_mask, detail);
567  }
568  }));
569 
570  return 0;
571 }
572 
573 /*?
574  * This command displays the IPv4 FIB Tables (VRF Tables) and the route
575  * entries for each table.
576  *
577  * @note This command will run for a long time when the FIB tables are
578  * comprised of millions of entries. For those senarios, consider displaying
579  * a single table or summary mode.
580  *
581  * @cliexpar
582  * Example of how to display all the IPv4 FIB tables:
583  * @cliexstart{show ip fib}
584  * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
585  * 0.0.0.0/0
586  * unicast-ip4-chain
587  * [@0]: dpo-load-balance: [index:0 buckets:1 uRPF:0 to:[0:0]]
588  * [0] [@0]: dpo-drop ip6
589  * 0.0.0.0/32
590  * unicast-ip4-chain
591  * [@0]: dpo-load-balance: [index:1 buckets:1 uRPF:1 to:[0:0]]
592  * [0] [@0]: dpo-drop ip6
593  * 6.0.1.2/32
594  * unicast-ip4-chain
595  * [@0]: dpo-load-balance: [index:30 buckets:1 uRPF:29 to:[0:0]]
596  * [0] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
597  * 7.0.0.1/32
598  * unicast-ip4-chain
599  * [@0]: dpo-load-balance: [index:31 buckets:4 uRPF:30 to:[0:0]]
600  * [0] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
601  * [1] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
602  * [2] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
603  * [3] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
604  * 224.0.0.0/8
605  * unicast-ip4-chain
606  * [@0]: dpo-load-balance: [index:3 buckets:1 uRPF:3 to:[0:0]]
607  * [0] [@0]: dpo-drop ip6
608  * 240.0.0.0/8
609  * unicast-ip4-chain
610  * [@0]: dpo-load-balance: [index:2 buckets:1 uRPF:2 to:[0:0]]
611  * [0] [@0]: dpo-drop ip6
612  * 255.255.255.255/32
613  * unicast-ip4-chain
614  * [@0]: dpo-load-balance: [index:4 buckets:1 uRPF:4 to:[0:0]]
615  * [0] [@0]: dpo-drop ip6
616  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
617  * 0.0.0.0/0
618  * unicast-ip4-chain
619  * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
620  * [0] [@0]: dpo-drop ip6
621  * 0.0.0.0/32
622  * unicast-ip4-chain
623  * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
624  * [0] [@0]: dpo-drop ip6
625  * 172.16.1.0/24
626  * unicast-ip4-chain
627  * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
628  * [0] [@4]: ipv4-glean: af_packet0
629  * 172.16.1.1/32
630  * unicast-ip4-chain
631  * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
632  * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
633  * 172.16.1.2/32
634  * unicast-ip4-chain
635  * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
636  * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
637  * 172.16.2.0/24
638  * unicast-ip4-chain
639  * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
640  * [0] [@4]: ipv4-glean: af_packet1
641  * 172.16.2.1/32
642  * unicast-ip4-chain
643  * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
644  * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
645  * 224.0.0.0/8
646  * unicast-ip4-chain
647  * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
648  * [0] [@0]: dpo-drop ip6
649  * 240.0.0.0/8
650  * unicast-ip4-chain
651  * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
652  * [0] [@0]: dpo-drop ip6
653  * 255.255.255.255/32
654  * unicast-ip4-chain
655  * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
656  * [0] [@0]: dpo-drop ip6
657  * @cliexend
658  * Example of how to display a single IPv4 FIB table:
659  * @cliexstart{show ip fib table 7}
660  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
661  * 0.0.0.0/0
662  * unicast-ip4-chain
663  * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
664  * [0] [@0]: dpo-drop ip6
665  * 0.0.0.0/32
666  * unicast-ip4-chain
667  * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
668  * [0] [@0]: dpo-drop ip6
669  * 172.16.1.0/24
670  * unicast-ip4-chain
671  * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
672  * [0] [@4]: ipv4-glean: af_packet0
673  * 172.16.1.1/32
674  * unicast-ip4-chain
675  * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
676  * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
677  * 172.16.1.2/32
678  * unicast-ip4-chain
679  * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
680  * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
681  * 172.16.2.0/24
682  * unicast-ip4-chain
683  * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
684  * [0] [@4]: ipv4-glean: af_packet1
685  * 172.16.2.1/32
686  * unicast-ip4-chain
687  * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
688  * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
689  * 224.0.0.0/8
690  * unicast-ip4-chain
691  * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
692  * [0] [@0]: dpo-drop ip6
693  * 240.0.0.0/8
694  * unicast-ip4-chain
695  * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
696  * [0] [@0]: dpo-drop ip6
697  * 255.255.255.255/32
698  * unicast-ip4-chain
699  * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
700  * [0] [@0]: dpo-drop ip6
701  * @cliexend
702  * Example of how to display a summary of all IPv4 FIB tables:
703  * @cliexstart{show ip fib summary}
704  * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
705  * Prefix length Count
706  * 0 1
707  * 8 2
708  * 32 4
709  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
710  * Prefix length Count
711  * 0 1
712  * 8 2
713  * 24 2
714  * 32 4
715  * @cliexend
716  ?*/
717 /* *INDENT-OFF* */
718 VLIB_CLI_COMMAND (ip4_show_fib_command, static) = {
719  .path = "show ip fib",
720  .short_help = "show ip fib [summary] [table <table-id>] [index <fib-id>] [<ip4-addr>[/<mask>]] [mtrie] [detail]",
721  .function = ip4_show_fib,
722 };
723 /* *INDENT-ON* */
u8 * format_fib_entry(u8 *s, va_list *args)
Definition: fib_entry.c:87
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:468
#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:34
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:376
#define hash_unset(h, key)
Definition: hash.h:260
void fib_table_lock(u32 fib_index, fib_protocol_t proto)
Release a reference counting lock on the table.
Definition: fib_table.c:1159
#define FIB_ENTRY_FORMAT_DETAIL
Definition: fib_entry.h:435
void fib_entry_get_prefix(fib_node_index_t fib_entry_index, fib_prefix_t *pfx)
Definition: fib_entry.c:1532
#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:751
const dpo_id_t * fib_entry_contribute_ip_forwarding(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:445
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:522
void ip4_fib_table_destroy(u32 fib_index)
Definition: ip4_fib.c:157
static clib_error_t * ip4_show_fib(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ip4_fib.c:483
u32 * fib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:99
static void ip4_fib_table_show_all(ip4_fib_t *fib, vlib_main_t *vm)
Definition: ip4_fib.c:444
static u32 ip4_create_fib_with_table_id(u32 table_id)
Definition: ip4_fib.c:104
uword value[0]
Definition: hash.h:164
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:221
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:376
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:196
Aggregrate type for a prefix.
Definition: fib_types.h:160
static void hash_set_flags(void *v, uword flags)
Definition: hash.h:152
u32 ip4_fib_table_find_or_create_and_lock(u32 table_id)
Get or create an IPv4 fib.
Definition: ip4_fib.c:201
static int ip4_fib_show_walk_cb(fib_node_index_t fib_entry_index, void *arg)
Definition: ip4_fib.c:433
u16 fp_len
The mask length.
Definition: fib_types.h:164
void ip4_fib_table_entry_remove(ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:341
int fib_entry_cmp_for_sort(void *i1, void *i2)
Definition: fib_entry.c:1484
void ip4_mtrie_init(ip4_fib_mtrie_t *m)
Initialise an mtrie.
Definition: ip4_mtrie.c:212
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:152
#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:397
uword * fib_index_by_table_id
Hash table mapping table id to fib index.
Definition: ip4.h:109
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:183
struct _unformat_input_t unformat_input_t
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:241
u32 ft_total_route_counts
Total route counters.
Definition: fib_table.h:64
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:367
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:169
fib_node_index_t ip4_fib_table_lookup(const ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:288
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:311
The IPv4 FIB.
Definition: ip4_fib.h:39
fib_node_index_t ft_index
Index into FIB vector.
Definition: fib_table.h:49
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
u32 ft_table_id
Table ID (hash key) for this FIB.
Definition: fib_table.h:44
u32 ft_flow_hash_config
flow hash configuration
Definition: fib_table.h:54
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:340
#define FOR_EACH_FIB_SOURCE(_item)
Definition: fib_entry.h:156
fib_node_index_t * ifsw_indicies
Definition: ip4_fib.c:429
Definition: fib_entry.h:236
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
static u32 ip4_fib_index_from_table_id(u32 table_id)
Definition: ip4_fib.h:135
#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:402
enum fib_entry_flag_t_ fib_entry_flag_t
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
#define hash_create(elts, value_bytes)
Definition: hash.h:658
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
The default route source.
Definition: fib_entry.h:121
IPv4 main type.
Definition: ip4.h:83
Walk show context.
Definition: ip4_fib.c:427
u32 ft_src_route_counts[FIB_SOURCE_MAX]
Per-source route counters.
Definition: fib_table.h:59
#define IP_FLOW_HASH_DEFAULT
Default: 5-tuple without the "reverse" bit.
Definition: lookup.h:69
u64 uword
Definition: types.h:112
#define FIB_ENTRY_FORMAT_BRIEF
Definition: fib_entry.h:434
format_function_t format_ip4_fib_mtrie
Format/display the contents of the mtrie.
Definition: ip4_mtrie.h:167
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:168
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:29
struct ip4_fib_t_ * v4_fibs
Vector of MTries.
Definition: ip4.h:91
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:349
#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:630
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:960
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
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1168
struct fib_table_t_ * fibs
Vector of FIBs.
Definition: ip4.h:88
#define FIB_ENTRY_FORMAT_DETAIL2
Definition: fib_entry.h:436
#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:264
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:647
vhost_vring_addr_t addr
Definition: vhost-user.h:82
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 ip4_fib_table_create_and_lock(void)
Definition: ip4_fib.c:215
#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:240
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:29
u32 fib_masks[33]
Definition: ip4.h:96