FD.io VPP  v16.09
Vector Packet Processing
l2_learn.c
Go to the documentation of this file.
1 /*
2  * l2_learn.c : layer 2 learning using l2fib
3  *
4  * Copyright (c) 2013 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vlib/vlib.h>
19 #include <vnet/vnet.h>
20 #include <vnet/pg/pg.h>
21 #include <vnet/ethernet/ethernet.h>
22 #include <vlib/cli.h>
23 
24 #include <vnet/l2/l2_input.h>
25 #include <vnet/l2/feat_bitmap.h>
26 #include <vnet/l2/l2_fib.h>
27 #include <vnet/l2/l2_learn.h>
28 
29 #include <vppinfra/error.h>
30 #include <vppinfra/hash.h>
31 
32 /**
33  * @file
34  * Ethernet bridge learning.
35  *
36  * Populate the mac table with entries mapping the packet's source mac + bridge
37  * domain ID to the input sw_if_index.
38  *
39  * Note that learning and forwarding are separate graph nodes. This means that
40  * for a set of packets, all learning is performed first, then all nodes are
41  * forwarded. The forwarding is done based on the end-state of the mac table,
42  * instead of the state after each packet. Thus the forwarding results could
43  * differ in certain cases (mac move tests), but this not expected to cause
44  * problems in real-world networks. It is much simpler to separate learning
45  * and forwarding into separate nodes.
46  */
47 
48 
49 typedef struct
50 {
51  u8 src[6];
52  u8 dst[6];
56 
57 
58 /* packet trace format function */
59 static u8 *
60 format_l2learn_trace (u8 * s, va_list * args)
61 {
62  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
63  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
64  l2learn_trace_t *t = va_arg (*args, l2learn_trace_t *);
65 
66  s = format (s, "l2-learn: sw_if_index %d dst %U src %U bd_index %d",
67  t->sw_if_index,
70  return s;
71 }
72 
74 
75 #define foreach_l2learn_error \
76 _(L2LEARN, "L2 learn packets") \
77 _(MISS, "L2 learn misses") \
78 _(MAC_MOVE, "L2 mac moves") \
79 _(MAC_MOVE_VIOLATE, "L2 mac move violations") \
80 _(LIMIT, "L2 not learned due to limit") \
81 _(HIT, "L2 learn hits") \
82 _(FILTER_DROP, "L2 filter mac drops")
83 
84 typedef enum
85 {
86 #define _(sym,str) L2LEARN_ERROR_##sym,
88 #undef _
91 
92 static char *l2learn_error_strings[] = {
93 #define _(sym,string) string,
95 #undef _
96 };
97 
98 typedef enum
99 {
104 
105 
106 /** Perform learning on one packet based on the mac table lookup result. */
107 
110  l2learn_main_t * msm,
111  u64 * counter_base,
112  vlib_buffer_t * b0,
113  u32 sw_if_index0,
114  l2fib_entry_key_t * key0,
115  l2fib_entry_key_t * cached_key,
116  u32 * bucket0, l2fib_entry_result_t * result0, u32 * next0)
117 {
118  u32 feature_bitmap;
119 
120  /* Set up the default next node (typically L2FWD) */
121 
122  /* Remove ourself from the feature bitmap */
123  feature_bitmap = vnet_buffer (b0)->l2.feature_bitmap & ~L2INPUT_FEAT_LEARN;
124 
125  /* Save for next feature graph nodes */
126  vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap;
127 
128  /* Determine the next node */
130  feature_bitmap);
131 
132  /* Check mac table lookup result */
133 
134  if (PREDICT_TRUE (result0->fields.sw_if_index == sw_if_index0))
135  {
136  /*
137  * The entry was in the table, and the sw_if_index matched, the normal case
138  *
139  * TODO: for dataplane learning and aging, do this:
140  * if refresh=0 and not a static mac, set refresh=1
141  */
142  counter_base[L2LEARN_ERROR_HIT] += 1;
143 
144  }
145  else if (result0->raw == ~0)
146  {
147 
148  /* The entry was not in table, so add it */
149 
150  counter_base[L2LEARN_ERROR_MISS] += 1;
151 
152  if (msm->global_learn_count == msm->global_learn_limit)
153  {
154  /*
155  * Global limit reached. Do not learn the mac but forward the packet.
156  * In the future, limits could also be per-interface or bridge-domain.
157  */
158  counter_base[L2LEARN_ERROR_LIMIT] += 1;
159  goto done;
160 
161  }
162  else
163  {
164  BVT (clib_bihash_kv) kv;
165  /* It is ok to learn */
166 
167  result0->raw = 0; /* clear all fields */
168  result0->fields.sw_if_index = sw_if_index0;
169  /* TODO: set timestamp in entry to clock for dataplane aging */
170  kv.key = key0->raw;
171  kv.value = result0->raw;
172 
173  BV (clib_bihash_add_del) (msm->mac_table, &kv, 1 /* is_add */ );
174 
175  cached_key->raw = ~0; /* invalidate the cache */
176  msm->global_learn_count++;
177  }
178 
179  }
180  else
181  {
182 
183  /* The entry was in the table, but with the wrong sw_if_index mapping (mac move) */
184  counter_base[L2LEARN_ERROR_MAC_MOVE] += 1;
185 
186  if (result0->fields.static_mac)
187  {
188  /*
189  * Don't overwrite a static mac
190  * TODO: Check violation policy. For now drop the packet
191  */
192  b0->error = node->errors[L2LEARN_ERROR_MAC_MOVE_VIOLATE];
193  *next0 = L2LEARN_NEXT_DROP;
194  }
195  else
196  {
197  /*
198  * Update the entry
199  * TODO: may want to rate limit mac moves
200  * TODO: check global/bridge domain/interface learn limits
201  */
202  BVT (clib_bihash_kv) kv;
203 
204  result0->raw = 0; /* clear all fields */
205  result0->fields.sw_if_index = sw_if_index0;
206 
207  kv.key = key0->raw;
208  kv.value = result0->raw;
209 
210  cached_key->raw = ~0; /* invalidate the cache */
211 
212  BV (clib_bihash_add_del) (msm->mac_table, &kv, 1 /* is_add */ );
213  }
214  }
215 
216  if (result0->fields.filter)
217  {
218  /* drop packet because lookup matched a filter mac entry */
219 
220  if (*next0 != L2LEARN_NEXT_DROP)
221  {
222  /* if we're not already dropping the packet, do it now */
223  b0->error = node->errors[L2LEARN_ERROR_FILTER_DROP];
224  *next0 = L2LEARN_NEXT_DROP;
225  }
226  }
227 
228 done:
229  return;
230 }
231 
232 
233 static uword
235  vlib_node_runtime_t * node, vlib_frame_t * frame)
236 {
237  u32 n_left_from, *from, *to_next;
238  l2learn_next_t next_index;
240  vlib_node_t *n = vlib_get_node (vm, l2learn_node.index);
241  u32 node_counter_base_index = n->error_heap_index;
242  vlib_error_main_t *em = &vm->error_main;
243  l2fib_entry_key_t cached_key;
244  l2fib_entry_result_t cached_result;
245 
246  from = vlib_frame_vector_args (frame);
247  n_left_from = frame->n_vectors; /* number of packets to process */
248  next_index = node->cached_next_index;
249 
250  /* Clear the one-entry cache in case mac table was updated */
251  cached_key.raw = ~0;
252  cached_result.raw = ~0; /* warning be gone */
253 
254  while (n_left_from > 0)
255  {
256  u32 n_left_to_next;
257 
258  /* get space to enqueue frame to graph node "next_index" */
259  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
260 
261  while (n_left_from >= 4 && n_left_to_next >= 2)
262  {
263  u32 bi0, bi1;
264  vlib_buffer_t *b0, *b1;
265  u32 next0, next1;
266  u32 sw_if_index0, sw_if_index1;
267  ethernet_header_t *h0, *h1;
268  l2fib_entry_key_t key0, key1;
269  l2fib_entry_result_t result0, result1;
270  u32 bucket0, bucket1;
271 
272  /* Prefetch next iteration. */
273  {
274  vlib_buffer_t *p2, *p3;
275 
276  p2 = vlib_get_buffer (vm, from[2]);
277  p3 = vlib_get_buffer (vm, from[3]);
278 
279  vlib_prefetch_buffer_header (p2, LOAD);
280  vlib_prefetch_buffer_header (p3, LOAD);
281 
284  }
285 
286  /* speculatively enqueue b0 and b1 to the current next frame */
287  /* bi is "buffer index", b is pointer to the buffer */
288  to_next[0] = bi0 = from[0];
289  to_next[1] = bi1 = from[1];
290  from += 2;
291  to_next += 2;
292  n_left_from -= 2;
293  n_left_to_next -= 2;
294 
295  b0 = vlib_get_buffer (vm, bi0);
296  b1 = vlib_get_buffer (vm, bi1);
297 
298  /* RX interface handles */
299  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
300  sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
301 
302  /* Process 2 x pkts */
303 
304  h0 = vlib_buffer_get_current (b0);
305  h1 = vlib_buffer_get_current (b1);
306 
307  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
308  {
309  if (b0->flags & VLIB_BUFFER_IS_TRACED)
310  {
311  l2learn_trace_t *t =
312  vlib_add_trace (vm, node, b0, sizeof (*t));
313  t->sw_if_index = sw_if_index0;
314  t->bd_index = vnet_buffer (b0)->l2.bd_index;
315  clib_memcpy (t->src, h0->src_address, 6);
316  clib_memcpy (t->dst, h0->dst_address, 6);
317  }
318  if (b1->flags & VLIB_BUFFER_IS_TRACED)
319  {
320  l2learn_trace_t *t =
321  vlib_add_trace (vm, node, b1, sizeof (*t));
322  t->sw_if_index = sw_if_index1;
323  t->bd_index = vnet_buffer (b1)->l2.bd_index;
324  clib_memcpy (t->src, h1->src_address, 6);
325  clib_memcpy (t->dst, h1->dst_address, 6);
326  }
327  }
328 
329  /* process 2 pkts */
330  em->counters[node_counter_base_index + L2LEARN_ERROR_L2LEARN] += 2;
331 
332  l2fib_lookup_2 (msm->mac_table, &cached_key, &cached_result,
333  h0->src_address,
334  h1->src_address,
335  vnet_buffer (b0)->l2.bd_index,
336  vnet_buffer (b1)->l2.bd_index,
337  &key0,
338  &key1, &bucket0, &bucket1, &result0, &result1);
339 
340  l2learn_process (node, msm, &em->counters[node_counter_base_index],
341  b0, sw_if_index0, &key0, &cached_key,
342  &bucket0, &result0, &next0);
343 
344  l2learn_process (node, msm, &em->counters[node_counter_base_index],
345  b1, sw_if_index1, &key1, &cached_key,
346  &bucket1, &result1, &next1);
347 
348  /* verify speculative enqueues, maybe switch current next frame */
349  /* if next0==next1==next_index then nothing special needs to be done */
350  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
351  to_next, n_left_to_next,
352  bi0, bi1, next0, next1);
353  }
354 
355  while (n_left_from > 0 && n_left_to_next > 0)
356  {
357  u32 bi0;
358  vlib_buffer_t *b0;
359  u32 next0;
360  u32 sw_if_index0;
361  ethernet_header_t *h0;
362  l2fib_entry_key_t key0;
363  l2fib_entry_result_t result0;
364  u32 bucket0;
365 
366  /* speculatively enqueue b0 to the current next frame */
367  bi0 = from[0];
368  to_next[0] = bi0;
369  from += 1;
370  to_next += 1;
371  n_left_from -= 1;
372  n_left_to_next -= 1;
373 
374  b0 = vlib_get_buffer (vm, bi0);
375 
376  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
377 
378  h0 = vlib_buffer_get_current (b0);
379 
381  && (b0->flags & VLIB_BUFFER_IS_TRACED)))
382  {
383  l2learn_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t));
384  t->sw_if_index = sw_if_index0;
385  t->bd_index = vnet_buffer (b0)->l2.bd_index;
386  clib_memcpy (t->src, h0->src_address, 6);
387  clib_memcpy (t->dst, h0->dst_address, 6);
388  }
389 
390  /* process 1 pkt */
391  em->counters[node_counter_base_index + L2LEARN_ERROR_L2LEARN] += 1;
392 
393  l2fib_lookup_1 (msm->mac_table, &cached_key, &cached_result,
394  h0->src_address, vnet_buffer (b0)->l2.bd_index,
395  &key0, &bucket0, &result0);
396 
397  l2learn_process (node, msm, &em->counters[node_counter_base_index],
398  b0, sw_if_index0, &key0, &cached_key,
399  &bucket0, &result0, &next0);
400 
401  /* verify speculative enqueue, maybe switch current next frame */
402  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
403  to_next, n_left_to_next,
404  bi0, next0);
405  }
406 
407  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
408  }
409 
410  return frame->n_vectors;
411 }
412 
413 
414 /* *INDENT-OFF* */
415 VLIB_REGISTER_NODE (l2learn_node,static) = {
416  .function = l2learn_node_fn,
417  .name = "l2-learn",
418  .vector_size = sizeof (u32),
419  .format_trace = format_l2learn_trace,
421 
422  .n_errors = ARRAY_LEN(l2learn_error_strings),
423  .error_strings = l2learn_error_strings,
424 
425  .n_next_nodes = L2LEARN_N_NEXT,
426 
427  /* edit / add dispositions here */
428  .next_nodes = {
429  [L2LEARN_NEXT_DROP] = "error-drop",
430  [L2LEARN_NEXT_L2FWD] = "l2-fwd",
431  },
432 };
433 /* *INDENT-ON* */
434 
437 {
439 
440  mp->vlib_main = vm;
441  mp->vnet_main = vnet_get_main ();
442 
443  /* Initialize the feature next-node indexes */
445  l2learn_node.index,
449 
450  /* init the hash table ptr */
451  mp->mac_table = get_mac_table ();
452 
453  /*
454  * Set the default number of dynamically learned macs to the number
455  * of buckets.
456  */
458 
459  return 0;
460 }
461 
463 
464 
465 /**
466  * Set subinterface learn enable/disable.
467  * The CLI format is:
468  * set interface l2 learn <interface> [disable]
469  */
470 static clib_error_t *
472  unformat_input_t * input, vlib_cli_command_t * cmd)
473 {
474  vnet_main_t *vnm = vnet_get_main ();
475  clib_error_t *error = 0;
476  u32 sw_if_index;
477  u32 enable;
478 
479  if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
480  {
481  error = clib_error_return (0, "unknown interface `%U'",
482  format_unformat_error, input);
483  goto done;
484  }
485 
486  enable = 1;
487  if (unformat (input, "disable"))
488  {
489  enable = 0;
490  }
491 
492  /* set the interface flag */
493  l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_LEARN, enable);
494 
495 done:
496  return error;
497 }
498 
499 /* *INDENT-OFF* */
500 VLIB_CLI_COMMAND (int_learn_cli, static) = {
501  .path = "set interface l2 learn",
502  .short_help = "set interface l2 learn <interface> [disable]",
503  .function = int_learn,
504 };
505 /* *INDENT-ON* */
506 
507 
508 static clib_error_t *
510 {
512 
514  {
515  if (unformat (input, "limit %d", &mp->global_learn_limit))
516  ;
517 
518  else
519  return clib_error_return (0, "unknown input `%U'",
520  format_unformat_error, input);
521  }
522 
523  return 0;
524 }
525 
527 
528 
529 /*
530  * fd.io coding-style-patch-verification: ON
531  *
532  * Local Variables:
533  * eval: (c-set-style "gnu")
534  * End:
535  */
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:457
u32 error_heap_index
Definition: node.h:278
u32 global_learn_count
Definition: l2_learn.h:32
#define CLIB_UNUSED(x)
Definition: clib.h:79
uword unformat(unformat_input_t *i, char *fmt,...)
Definition: unformat.c:966
bad routing header type(not 4)") sr_error (NO_MORE_SEGMENTS
#define PREDICT_TRUE(x)
Definition: clib.h:98
#define UNFORMAT_END_OF_INPUT
Definition: format.h:143
struct l2fib_entry_result_t::@159::@161 fields
u8 src_address[6]
Definition: packet.h:54
struct _vlib_node_registration vlib_node_registration_t
clib_error_t * l2learn_init(vlib_main_t *vm)
Definition: l2_learn.c:436
unformat_function_t unformat_vnet_sw_interface
Definition: l2_fib.h:54
vlib_error_t * errors
Definition: node.h:418
vnet_main_t * vnet_get_main(void)
Definition: misc.c:45
#define static_always_inline
Definition: clib.h:85
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
int clib_bihash_add_del(clib_bihash *h, clib_bihash_kv *add_v, int is_add)
Add or delete a (key,value) pair from a bi-hash table.
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:187
u8 dst_address[6]
Definition: packet.h:53
unsigned long u64
Definition: types.h:89
static_always_inline void l2learn_process(vlib_node_runtime_t *node, l2learn_main_t *msm, u64 *counter_base, vlib_buffer_t *b0, u32 sw_if_index0, l2fib_entry_key_t *key0, l2fib_entry_key_t *cached_key, u32 *bucket0, l2fib_entry_result_t *result0, u32 *next0)
Perform learning on one packet based on the mac table lookup result.
Definition: l2_learn.c:109
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:977
static char * l2learn_error_strings[]
Definition: l2_learn.c:92
vlib_error_main_t error_main
Definition: main.h:124
vnet_main_t * vnet_main
Definition: l2_learn.h:42
#define PREDICT_FALSE(x)
Definition: clib.h:97
#define VLIB_CONFIG_FUNCTION(x, n,...)
Definition: init.h:118
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
Definition: buffer_node.h:70
#define L2FIB_NUM_BUCKETS
Definition: l2_fib.h:27
static u32 feat_bitmap_get_next_node_index(u32 *next_nodes, u32 bitmap)
Return the graph node index for the feature corresponding to the first set bit in the bitmap...
Definition: feat_bitmap.h:79
static u8 * format_l2learn_trace(u8 *s, va_list *args)
Definition: l2_learn.c:60
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:130
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:348
u64 raw
Definition: l2_fib.h:70
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:118
BVT(clib_bihash)
Definition: l2_fib.c:577
u64 * counters
Definition: error.h:78
u16 n_vectors
Definition: node.h:344
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
static void feat_bitmap_init_next_nodes(vlib_main_t *vm, u32 node_index, u32 num_features, char **feat_names, u32 *next_nodes)
Initialize the feature next-node indexes of a graph node.
Definition: feat_bitmap.h:43
#define foreach_l2learn_error
Definition: l2_learn.c:75
static clib_error_t * l2learn_config(vlib_main_t *vm, unformat_input_t *input)
Definition: l2_learn.c:509
#define clib_memcpy(a, b, c)
Definition: string.h:63
l2learn_next_t
Definition: l2_learn.c:98
static clib_error_t * int_learn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Set subinterface learn enable/disable.
Definition: l2_learn.c:471
#define ARRAY_LEN(x)
Definition: clib.h:59
u32 feat_next_node_index[32]
Definition: l2_learn.h:38
char ** l2input_get_feat_names(void)
Return an array of strings containing graph node names of each feature.
Definition: l2_input.c:46
static_always_inline void l2fib_lookup_2(BVT(clib_bihash)*mac_table, l2fib_entry_key_t *cached_key, l2fib_entry_result_t *cached_result, u8 *mac0, u8 *mac1, u16 bd_index0, u16 bd_index1, l2fib_entry_key_t *key0, l2fib_entry_key_t *key1, u32 *bucket0, u32 *bucket1, l2fib_entry_result_t *result0, l2fib_entry_result_t *result1)
Lookup the entry for mac and bd_index in the mac table for 2 packets.
Definition: l2_fib.h:184
l2learn_error_t
Definition: l2_learn.c:84
u16 cached_next_index
Definition: node.h:462
unsigned int u32
Definition: types.h:88
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
#define vnet_buffer(b)
Definition: buffer.h:335
u8 * format(u8 *s, char *fmt,...)
Definition: format.c:418
Definition: l2_fib.h:33
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:259
u32 global_learn_limit
Definition: l2_learn.h:35
static uword l2learn_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: l2_learn.c:234
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:93
u64 uword
Definition: types.h:112
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:55
u32 l2input_intf_bitmap_enable(u32 sw_if_index, u32 feature_bitmap, u32 enable)
Enable (or disable) the feature in the bitmap for the given interface.
Definition: l2_input.c:501
unsigned short u16
Definition: types.h:57
VLIB_CLI_COMMAND(set_interface_ip_source_and_port_range_check_command, static)
unsigned char u8
Definition: types.h:56
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:251
vlib_main_t * vlib_main
Definition: l2_learn.h:41
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:163
#define VLIB_NODE_FUNCTION_MULTIARCH(node, fn)
Definition: node.h:158
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:169
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
l2learn_main_t l2learn_main
Definition: l2_learn.h:46
u8 data[0]
Packet data.
Definition: buffer.h:151
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:58
static_always_inline void l2fib_lookup_1(BVT(clib_bihash)*mac_table, l2fib_entry_key_t *cached_key, l2fib_entry_result_t *cached_result, u8 *mac0, u16 bd_index0, l2fib_entry_key_t *key0, u32 *bucket0, l2fib_entry_result_t *result0)
Lookup the entry for mac and bd_index in the mac table for 1 packet.
Definition: l2_fib.h:138
#define clib_error_return(e, args...)
Definition: error.h:111
struct _unformat_input_t unformat_input_t
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:85
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:69
static vlib_node_registration_t l2learn_node
(constructor) VLIB_REGISTER_NODE (l2learn_node)
Definition: l2_learn.c:73
Definition: defs.h:46
u64 raw
Definition: l2_fib.h:47