FD.io VPP  v19.01.1-17-ge106252
Vector Packet Processing
ip4_mfib.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/mfib/ip4_mfib.h>
17 
18 #include <vnet/mfib/mfib_table.h>
19 #include <vnet/mfib/mfib_entry.h>
20 
21 static const mfib_prefix_t ip4_specials[] = {
22  {
23  /* (*,*)/0 */
24  .fp_src_addr = {
25  .ip4.data_u32 = 0,
26  },
27  .fp_grp_addr = {
28  .ip4.data_u32 = 0,
29  },
30  .fp_len = 0,
31  .fp_proto = FIB_PROTOCOL_IP4,
32  },
33 };
34 
35 static u32
38 {
39  mfib_table_t *mfib_table;
40 
42  clib_memset(mfib_table, 0, sizeof(*mfib_table));
43 
44  mfib_table->mft_proto = FIB_PROTOCOL_IP4;
45  mfib_table->mft_index =
46  mfib_table->v4.index =
47  (mfib_table - ip4_main.mfibs);
48 
50  table_id,
51  mfib_table->mft_index);
52 
53  mfib_table->mft_table_id =
54  mfib_table->v4.table_id =
55  table_id;
56 
57  mfib_table_lock(mfib_table->mft_index, FIB_PROTOCOL_IP4, src);
58 
59  /*
60  * add the special entries into the new FIB
61  */
62  int ii;
63 
64  for (ii = 0; ii < ARRAY_LEN(ip4_specials); ii++)
65  {
66  mfib_prefix_t prefix = ip4_specials[ii];
67 
68  prefix.fp_src_addr.ip4.data_u32 =
69  clib_host_to_net_u32(prefix.fp_src_addr.ip4.data_u32);
70  prefix.fp_grp_addr.ip4.data_u32 =
71  clib_host_to_net_u32(prefix.fp_grp_addr.ip4.data_u32);
72 
74  &prefix,
78  }
79 
80  return (mfib_table->mft_index);
81 }
82 
83 void
85 {
86  mfib_table_t *mfib_table = (mfib_table_t*)mfib;
87  int ii;
88 
89  /*
90  * remove all the specials we added when the table was created.
91  */
92  for (ii = 0; ii < ARRAY_LEN(ip4_specials); ii++)
93  {
94  fib_node_index_t mfei;
95  mfib_prefix_t prefix = ip4_specials[ii];
96 
97  prefix.fp_src_addr.ip4.data_u32 =
98  clib_host_to_net_u32(prefix.fp_src_addr.ip4.data_u32);
99  prefix.fp_grp_addr.ip4.data_u32 =
100  clib_host_to_net_u32(prefix.fp_grp_addr.ip4.data_u32);
101 
102  mfei = mfib_table_lookup(mfib_table->mft_index, &prefix);
104  }
105 
106  /*
107  * validate no more routes.
108  */
109  ASSERT(0 == mfib_table->mft_total_route_counts);
110  ASSERT(~0 != mfib_table->mft_table_id);
111 
113  pool_put(ip4_main.mfibs, mfib_table);
114 }
115 
116 u32
119 {
120  u32 index;
121 
122  index = ip4_mfib_index_from_table_id(table_id);
123  if (~0 == index)
124  return ip4_create_mfib_with_table_id(table_id, src);
125  mfib_table_lock(index, FIB_PROTOCOL_IP4, src);
126 
127  return (index);
128 }
129 
130 u32
132 {
133  if (sw_if_index >= vec_len(ip4_main.mfib_index_by_sw_if_index))
134  {
135  /*
136  * This is the case for interfaces that are not yet mapped to
137  * a IP table
138  */
139  return (~0);
140  }
141  return (ip4_main.mfib_index_by_sw_if_index[sw_if_index]);
142 }
143 
144 #define IPV4_MFIB_GRP_LEN(_len)\
145  (_len > 32 ? 32 : _len)
146 
147 #define IP4_MFIB_MK_KEY(_grp, _src, _len, _key) \
148 { \
149  _key = ((u64)(_grp->data_u32 & \
150  ip4_main.fib_masks[IPV4_MFIB_GRP_LEN(_len)])) << 32; \
151  _key |= _src->data_u32; \
152 }
153 #define IP4_MFIB_MK_GRP_KEY(_grp, _len, _key) \
154 { \
155  _key = ((u64)(_grp->data_u32 & \
156  ip4_main.fib_masks[IPV4_MFIB_GRP_LEN(_len)])) << 32; \
157 }
158 
159 /*
160  * ip4_fib_table_lookup_exact_match
161  *
162  * Exact match prefix lookup
163  */
166  const ip4_address_t *grp,
167  const ip4_address_t *src,
168  u32 len)
169 {
170  uword * hash, * result;
171  u64 key;
172 
173  hash = mfib->fib_entry_by_dst_address[len];
174  IP4_MFIB_MK_KEY(grp, src, len, key);
175 
176  result = hash_get(hash, key);
177 
178  if (NULL != result) {
179  return (result[0]);
180  }
181  return (FIB_NODE_INDEX_INVALID);
182 }
183 
184 /*
185  * ip4_fib_table_lookup
186  *
187  * Longest prefix match
188  */
191  const ip4_address_t *src,
192  const ip4_address_t *grp,
193  u32 len)
194 {
195  uword * hash, * result;
196  i32 mask_len;
197  u64 key;
198 
199  mask_len = len;
200 
201  if (PREDICT_TRUE(64 == mask_len))
202  {
203  hash = mfib->fib_entry_by_dst_address[mask_len];
204  IP4_MFIB_MK_KEY(grp, src, mask_len, key);
205 
206  result = hash_get (hash, key);
207 
208  if (NULL != result) {
209  return (result[0]);
210  }
211  }
212 
213  for (mask_len = (len == 64 ? 32 : len); mask_len >= 0; mask_len--)
214  {
215  hash = mfib->fib_entry_by_dst_address[mask_len];
216  IP4_MFIB_MK_GRP_KEY(grp, mask_len, key);
217 
218  result = hash_get (hash, key);
219 
220  if (NULL != result) {
221  return (result[0]);
222  }
223  }
224  return (FIB_NODE_INDEX_INVALID);
225 }
226 
229  const ip4_address_t *src,
230  const ip4_address_t *grp,
231  u32 len)
232 {
233  u32 mask_len;
234 
235  /*
236  * in the absence of a tree structure for the table that allows for an O(1)
237  * parent get, a cheeky way to find the cover is to LPM for the prefix with
238  * mask-1.
239  * there should always be a cover, though it may be the default route. the
240  * default route's cover is the default route.
241  */
242  if (len == 64)
243  {
244  /* go from (S,G) to (*,G*) */
245  mask_len = 32;
246  }
247  else if (len != 0)
248  {
249  mask_len = len - 1;
250  }
251  else
252  {
253  mask_len = len;
254  }
255 
256  return (ip4_mfib_table_lookup(mfib, src, grp, mask_len));
257 }
258 
259 void
261  const ip4_address_t *grp,
262  const ip4_address_t *src,
263  u32 len,
264  fib_node_index_t fib_entry_index)
265 {
266  uword * hash, * result;
267  u64 key;
268 
269  IP4_MFIB_MK_KEY(grp, src, len, key);
270  hash = mfib->fib_entry_by_dst_address[len];
271  result = hash_get (hash, key);
272 
273  if (NULL == result) {
274  /*
275  * adding a new entry
276  */
277  if (NULL == hash) {
278  hash = hash_create (32 /* elts */, sizeof (uword));
280  }
281  hash = hash_set(hash, key, fib_entry_index);
282  mfib->fib_entry_by_dst_address[len] = hash;
283  }
284  else
285  {
286  ASSERT(0);
287  }
288 }
289 
290 void
292  const ip4_address_t *grp,
293  const ip4_address_t *src,
294  u32 len)
295 {
296  uword * hash, * result;
297  u64 key;
298 
299  IP4_MFIB_MK_KEY(grp, src, len, key);
300  hash = mfib->fib_entry_by_dst_address[len];
301  result = hash_get (hash, key);
302 
303  if (NULL == result)
304  {
305  /*
306  * removing a non-existant entry. i'll allow it.
307  */
308  }
309  else
310  {
311  hash_unset(hash, key);
312  }
313 
314  mfib->fib_entry_by_dst_address[len] = hash;
315 }
316 
317 void
320  void *ctx)
321 {
322  int i;
323 
324  for (i = 0; i < ARRAY_LEN (mfib->fib_entry_by_dst_address); i++)
325  {
326  uword * hash = mfib->fib_entry_by_dst_address[i];
327 
328  if (NULL != hash)
329  {
330  hash_pair_t * p;
331 
332  hash_foreach_pair (p, hash,
333  ({
334  fn(p->value[0], ctx);
335  }));
336  }
337  }
338 }
339 
340 u8 *
341 format_ip4_mfib_table_memory (u8 * s, va_list * args)
342 {
343  mfib_table_t *mfib_table;
344  u64 total_memory;
345 
346  total_memory = 0;
347 
348  pool_foreach (mfib_table, ip4_main.mfibs,
349  ({
350  ip4_mfib_t *mfib = &mfib_table->v4;
351  uword mfib_size;
352  int i;
353 
354  mfib_size = 0;
355 
356  for (i = 0; i < ARRAY_LEN (mfib->fib_entry_by_dst_address); i++)
357  {
358  uword * hash = mfib->fib_entry_by_dst_address[i];
359 
360  if (NULL != hash)
361  {
362  mfib_size += hash_bytes(hash);
363  }
364  }
365 
366  total_memory += mfib_size;
367  }));
368 
369  s = format(s, "%=30s %=6d %=8ld\n",
370  "IPv4 multicast",
371  pool_elts(ip4_main.mfibs), total_memory);
372 
373  return (s);
374 }
375 
376 static void
378  vlib_main_t * vm)
379 {
380  fib_node_index_t *mfib_entry_indicies;
381  fib_node_index_t *mfib_entry_index;
382  int i;
383 
384  mfib_entry_indicies = NULL;
385 
386  for (i = 0; i < ARRAY_LEN (mfib->fib_entry_by_dst_address); i++)
387  {
388  uword * hash = mfib->fib_entry_by_dst_address[i];
389 
390  if (NULL != hash)
391  {
392  hash_pair_t * p;
393 
394  hash_foreach_pair (p, hash,
395  ({
396  vec_add1(mfib_entry_indicies, p->value[0]);
397  }));
398  }
399  }
400 
401  vec_sort_with_function(mfib_entry_indicies, mfib_entry_cmp_for_sort);
402 
403  vec_foreach(mfib_entry_index, mfib_entry_indicies)
404  {
405  vlib_cli_output(vm, "%U",
407  *mfib_entry_index,
409  }
410 
411  vec_free(mfib_entry_indicies);
412 }
413 
414 static void
416  vlib_main_t * vm,
418  ip4_address_t *grp,
419  u32 mask_len)
420 {
421  vlib_cli_output(vm, "%U",
423  ip4_mfib_table_lookup(mfib, src, grp, mask_len),
425 }
426 
427 static clib_error_t *
429  unformat_input_t * input,
430  vlib_cli_command_t * cmd)
431 {
432  ip4_main_t * im4 = &ip4_main;
433  mfib_table_t *mfib_table;
434  int verbose, matching, memory;
435  ip4_address_t grp, src = {{0}};
436  u32 mask = 32;
437  u64 total_hash_memory;
438  int i, table_id = -1, fib_index = ~0;
439 
440  verbose = 1;
441  memory = matching = 0;
442  total_hash_memory = 0;
443 
445  {
446  if (unformat (input, "brief") || unformat (input, "summary")
447  || unformat (input, "sum"))
448  verbose = 0;
449  else if (unformat (input, "mem") || unformat (input, "memory"))
450  memory = 1;
451  else if (unformat (input, "%U %U",
452  unformat_ip4_address, &src,
453  unformat_ip4_address, &grp))
454  {
455  matching = 1;
456  mask = 64;
457  }
458  else if (unformat (input, "%U/%d", unformat_ip4_address, &grp, &mask))
459  {
460  clib_memset(&src, 0, sizeof(src));
461  matching = 1;
462  }
463  else if (unformat (input, "%U", unformat_ip4_address, &grp))
464  {
465  clib_memset(&src, 0, sizeof(src));
466  matching = 1;
467  mask = 32;
468  }
469  else if (unformat (input, "table %d", &table_id))
470  ;
471  else if (unformat (input, "index %d", &fib_index))
472  ;
473  else
474  break;
475  }
476 
477  pool_foreach (mfib_table, im4->mfibs,
478  ({
479  ip4_mfib_t *mfib = &mfib_table->v4;
480 
481  if (table_id >= 0 && table_id != (int)mfib->table_id)
482  continue;
483  if (fib_index != ~0 && fib_index != (int)mfib->index)
484  continue;
485 
486  if (memory)
487  {
488  uword hash_size;
489 
490  hash_size = 0;
491 
492  for (i = 0; i < ARRAY_LEN (mfib->fib_entry_by_dst_address); i++)
493  {
494  uword * hash = mfib->fib_entry_by_dst_address[i];
495  if (NULL != hash)
496  {
497  hash_size += hash_bytes(hash);
498  }
499  }
500  if (verbose)
501  vlib_cli_output (vm, "%U hash:%d",
502  format_mfib_table_name, mfib->index,
503  FIB_PROTOCOL_IP4,
504  hash_size);
505  total_hash_memory += hash_size;
506  continue;
507  }
508 
509  vlib_cli_output (vm, "%U, fib_index %d",
511  mfib->index);
512 
513  /* Show summary? */
514  if (! verbose)
515  {
516  vlib_cli_output (vm, "%=20s%=16s", "Prefix length", "Count");
517  for (i = 0; i < ARRAY_LEN (mfib->fib_entry_by_dst_address); i++)
518  {
519  uword * hash = mfib->fib_entry_by_dst_address[i];
520  uword n_elts = hash_elts (hash);
521  if (n_elts > 0)
522  vlib_cli_output (vm, "%20d%16d", i, n_elts);
523  }
524  continue;
525  }
526 
527  if (!matching)
528  {
529  ip4_mfib_table_show_all(mfib, vm);
530  }
531  else
532  {
533  ip4_mfib_table_show_one(mfib, vm, &src, &grp, mask);
534  }
535  }));
536  if (memory)
537  vlib_cli_output (vm, "totals: hash:%ld", total_hash_memory);
538 
539  return 0;
540 }
541 
542 /*?
543  * This command displays the IPv4 MulticasrFIB Tables (VRF Tables) and
544  * the route entries for each table.
545  *
546  * @note This command will run for a long time when the FIB tables are
547  * comprised of millions of entries. For those senarios, consider displaying
548  * a single table or summary mode.
549  *
550  * @cliexpar
551  * Example of how to display all the IPv4 Multicast FIB tables:
552  * @cliexstart{show ip fib}
553  * ipv4-VRF:0, fib_index 0
554  * (*, 0.0.0.0/0): flags:D,
555  * Interfaces:
556  * multicast-ip4-chain
557  * [@1]: dpo-drop ip4
558  * (*, 232.1.1.1/32):
559  * Interfaces:
560  * test-eth1: Forward,
561  * test-eth2: Forward,
562  * test-eth0: Accept,
563  * multicast-ip4-chain
564  * [@2]: dpo-replicate: [index:1 buckets:2 to:[0:0]]
565  * [0] [@1]: ipv4-mcast: test-eth1: IP4: d0:d1:d2:d3:d4:01 -> 01:00:05:00:00:00
566  * [1] [@1]: ipv4-mcast: test-eth2: IP4: d0:d1:d2:d3:d4:02 -> 01:00:05:00:00:00
567  *
568  * @cliexend
569  * Example of how to display a summary of all IPv4 FIB tables:
570  * @cliexstart{show ip fib summary}
571  * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
572  * Prefix length Count
573  * 0 1
574  * 8 2
575  * 32 4
576  * ipv4-VRF:7, fib_index 1, flow hash: src dst sport dport proto
577  * Prefix length Count
578  * 0 1
579  * 8 2
580  * 24 2
581  * 32 4
582  * @cliexend
583  ?*/
584 /* *INDENT-OFF* */
585 VLIB_CLI_COMMAND (ip4_show_mfib_command, static) = {
586  .path = "show ip mfib",
587  .short_help = "show ip mfib [summary] [table <table-id>] [index <fib-id>] [<grp-addr>[/<mask>]] [<grp-addr>] [<src-addr> <grp-addr>]",
588  .function = ip4_show_mfib,
589 };
590 /* *INDENT-ON* */
#define MFIB_ENTRY_FORMAT_DETAIL
Definition: mfib_entry.h:111
static clib_error_t * ip4_show_mfib(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ip4_mfib.c:428
ip46_address_t fp_src_addr
Definition: mfib_types.h:47
#define hash_set(h, key, value)
Definition: hash.h:255
fib_node_index_t mfib_table_lookup(u32 fib_index, const mfib_prefix_t *prefix)
Perfom a longest prefix match in the non-forwarding table.
Definition: mfib_table.c:67
vl_api_address_t src
Definition: vxlan_gbp.api:32
vhost_user_memory_t memory
Definition: vhost_user.h:122
#define hash_unset(h, key)
Definition: hash.h:261
u32 index
Definition: ip4.h:59
#define PREDICT_TRUE(x)
Definition: clib.h:112
unsigned long u64
Definition: types.h:89
u32 ip4_mfib_table_get_index_for_sw_if_index(u32 sw_if_index)
Definition: ip4_mfib.c:131
#define NULL
Definition: clib.h:58
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:525
static void ip4_mfib_table_show_one(ip4_mfib_t *mfib, vlib_main_t *vm, ip4_address_t *src, ip4_address_t *grp, u32 mask_len)
Definition: ip4_mfib.c:415
int i
clib_memset(h->entries, 0, sizeof(h->entries[0])*entries)
u32 mft_total_route_counts
Total route counters.
Definition: mfib_table.h:76
fib_node_index_t mfib_table_entry_update(u32 fib_index, const mfib_prefix_t *prefix, mfib_source_t source, fib_rpf_id_t rpf_id, mfib_entry_flags_t entry_flags)
Add a new (with no replication) or lock an existing entry.
Definition: mfib_table.c:235
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
fib_node_index_t ip4_mfib_table_get_less_specific(const ip4_mfib_t *mfib, const ip4_address_t *src, const ip4_address_t *grp, u32 len)
Definition: ip4_mfib.c:228
#define MFIB_ENTRY_FORMAT_BRIEF
Definition: mfib_entry.h:110
unsigned char u8
Definition: types.h:56
uword value[0]
Definition: hash.h:165
enum mfib_source_t_ mfib_source_t
Possible [control plane] sources of MFIB entries.
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:115
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:490
unformat_function_t unformat_ip4_address
Definition: format.h:70
#define MFIB_RPF_ID_NONE
Definition: fib_types.h:393
u32 sw_if_index
Definition: vxlan_gbp.api:37
fib_node_index_t mft_index
Index into FIB vector.
Definition: mfib_table.h:71
void mfib_table_entry_delete_index(fib_node_index_t mfib_entry_index, mfib_source_t source)
Delete a FIB entry.
Definition: mfib_table.c:464
#define IP4_MFIB_MK_GRP_KEY(_grp, _len, _key)
Definition: ip4_mfib.c:153
unsigned int u32
Definition: types.h:88
static void hash_set_flags(void *v, uword flags)
Definition: hash.h:153
struct mfib_table_t_ * mfibs
Vector of MFIBs.
Definition: ip4.h:107
void ip4_mfib_table_walk(ip4_mfib_t *mfib, mfib_table_walk_fn_t fn, void *ctx)
Walk the IP4 mfib table.
Definition: ip4_mfib.c:318
#define hash_get(h, key)
Definition: hash.h:249
void ip4_mfib_table_entry_remove(ip4_mfib_t *mfib, const ip4_address_t *grp, const ip4_address_t *src, u32 len)
Definition: ip4_mfib.c:291
long ctx[MAX_CONNS]
Definition: main.c:144
struct _unformat_input_t unformat_input_t
#define IP4_MFIB_MK_KEY(_grp, _src, _len, _key)
Definition: ip4_mfib.c:147
static u32 ip4_create_mfib_with_table_id(u32 table_id, mfib_source_t src)
Definition: ip4_mfib.c:36
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
Definition: ip4.h:50
int mfib_entry_cmp_for_sort(void *i1, void *i2)
Definition: mfib_entry.c:1185
void mfib_table_lock(u32 fib_index, fib_protocol_t proto, mfib_source_t source)
Release a reference counting lock on the table.
Definition: mfib_table.c:682
u8 len
Definition: ip_types.api:49
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P with alignment A.
Definition: pool.h:230
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
vlib_main_t * vm
Definition: buffer.c:301
fib_node_index_t ip4_mfib_table_lookup_exact_match(const ip4_mfib_t *mfib, const ip4_address_t *grp, const ip4_address_t *src, u32 len)
Definition: ip4_mfib.c:165
u8 * format_mfib_entry(u8 *s, va_list *args)
Definition: mfib_entry.c:105
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
#define ARRAY_LEN(x)
Definition: clib.h:62
Aggregrate type for a prefix.
Definition: mfib_types.h:24
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
uword * fib_entry_by_dst_address[65]
Definition: ip4.h:53
signed int i32
Definition: types.h:77
#define hash_create(elts, value_bytes)
Definition: hash.h:696
static uword hash_elts(void *v)
Definition: hash.h:118
#define ASSERT(truth)
IPv4 main type.
Definition: ip4.h:96
fib_node_index_t ip4_mfib_table_lookup(const ip4_mfib_t *mfib, const ip4_address_t *src, const ip4_address_t *grp, u32 len)
The IPv4 Multicast-FIB.
Definition: ip4_mfib.c:190
void ip4_mfib_table_entry_insert(ip4_mfib_t *mfib, const ip4_address_t *grp, const ip4_address_t *src, u32 len, fib_node_index_t fib_entry_index)
Definition: ip4_mfib.c:260
fib_protocol_t mft_proto
Which protocol this table serves.
Definition: mfib_table.h:56
u32 mft_table_id
Table ID (hash key) for this FIB.
Definition: mfib_table.h:66
static void ip4_mfib_table_show_all(ip4_mfib_t *mfib, vlib_main_t *vm)
Definition: ip4_mfib.c:377
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u32 ip4_mfib_table_find_or_create_and_lock(u32 table_id, mfib_source_t src)
Get or create an IPv4 fib.
Definition: ip4_mfib.c:117
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:373
u64 uword
Definition: types.h:112
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:984
typedef prefix
Definition: ip_types.api:35
int(* mfib_table_walk_fn_t)(fib_node_index_t fei, void *ctx)
Call back function when walking entries in a FIB table.
Definition: mfib_table.h:447
ip4_mfib_t v4
Definition: mfib_table.h:49
A protocol Independent IP multicast FIB table.
Definition: mfib_table.h:35
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:903
#define vec_foreach(var, vec)
Vector iterator.
u32 table_id
Definition: ip4.h:56
uword * mfib_index_by_table_id
Hash table mapping table id to multicast fib index.
Definition: ip4.h:126
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
static u32 ip4_mfib_index_from_table_id(u32 table_id)
Definition: ip4_mfib.h:84
#define HASH_FLAG_NO_AUTO_SHRINK
Definition: hash.h:64
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:725
u8 * format_mfib_table_name(u8 *s, va_list *ap)
Format the description/name of the table.
Definition: mfib_table.c:724
void ip4_mfib_table_destroy(ip4_mfib_t *mfib)
Definition: ip4_mfib.c:84
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
ip46_address_t fp_grp_addr
The address type is not deriveable from the fp_addr member.
Definition: mfib_types.h:46
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
u8 * format_ip4_mfib_table_memory(u8 *s, va_list *args)
format (display) the memory usage for IP4 mfibs
Definition: ip4_mfib.c:341
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128