FD.io VPP  v19.08.3-2-gbabecb413
Vector Packet Processing
mfib_forward.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/mfib_itf.h>
17 #include <vnet/mfib/mfib_entry.h>
18 #include <vnet/dpo/replicate_dpo.h>
19 #include <vnet/mfib/ip4_mfib.h>
20 #include <vnet/mfib/ip6_mfib.h>
21 #include <vnet/mfib/mfib_signal.h>
22 #include <vnet/fib/ip4_fib.h>
23 #include <vnet/fib/ip6_fib.h>
24 
25 #include <vnet/ip/ip4.h>
26 #include <vnet/vnet.h>
27 
32 
33 static u8 *
34 format_mfib_forward_lookup_trace (u8 * s, va_list * args)
35 {
36  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
37  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
39 
40  s = format (s, "fib %d entry %d", t->fib_index, t->entry_index);
41  return s;
42 }
43 
44 /* Common trace function for all ip4-forward next nodes. */
45 static void
47  vlib_node_runtime_t * node,
48  vlib_frame_t * frame)
49 {
50  u32 * from, n_left;
51  ip4_main_t * im = &ip4_main;
52 
53  n_left = frame->n_vectors;
54  from = vlib_frame_vector_args (frame);
55 
56  while (n_left >= 4)
57  {
58  mfib_forward_lookup_trace_t * t0, * t1;
59  vlib_buffer_t * b0, * b1;
60  u32 bi0, bi1;
61 
62  /* Prefetch next iteration. */
63  vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
64  vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
65 
66  bi0 = from[0];
67  bi1 = from[1];
68 
69  b0 = vlib_get_buffer (vm, bi0);
70  b1 = vlib_get_buffer (vm, bi1);
71 
72  if (b0->flags & VLIB_BUFFER_IS_TRACED)
73  {
74  t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
75  t0->entry_index = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
78  }
79  if (b1->flags & VLIB_BUFFER_IS_TRACED)
80  {
81  t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
82  t1->entry_index = vnet_buffer (b1)->ip.adj_index[VLIB_TX];
85  }
86  from += 2;
87  n_left -= 2;
88  }
89 
90  while (n_left >= 1)
91  {
93  vlib_buffer_t * b0;
94  u32 bi0;
95 
96  bi0 = from[0];
97 
98  b0 = vlib_get_buffer (vm, bi0);
99 
100  if (b0->flags & VLIB_BUFFER_IS_TRACED)
101  {
102  t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
103  t0->entry_index = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
106  }
107  from += 1;
108  n_left -= 1;
109  }
110 }
111 
116 
117 static uword
119  vlib_node_runtime_t * node,
120  vlib_frame_t * frame,
121  int is_v4)
122 {
123  u32 n_left_from, n_left_to_next, * from, * to_next;
124 
125  from = vlib_frame_vector_args (frame);
126  n_left_from = frame->n_vectors;
127 
128  while (n_left_from > 0)
129  {
131  to_next, n_left_to_next);
132 
133  while (n_left_from > 0 && n_left_to_next > 0)
134  {
135  fib_node_index_t mfei0;
136  vlib_buffer_t * p0;
137  u32 fib_index0;
138  u32 pi0;
139 
140  pi0 = from[0];
141  to_next[0] = pi0;
142  from += 1;
143  to_next += 1;
144  n_left_to_next -= 1;
145  n_left_from -= 1;
146 
147  p0 = vlib_get_buffer (vm, pi0);
148 
149  if (is_v4)
150  {
151  ip4_header_t * ip0;
152 
155  ip0 = vlib_buffer_get_current (p0);
156  mfei0 = ip4_mfib_table_lookup(ip4_mfib_get(fib_index0),
157  &ip0->src_address,
158  &ip0->dst_address,
159  64);
160  }
161  else
162  {
163  ip6_header_t * ip0;
164 
167  ip0 = vlib_buffer_get_current (p0);
168  mfei0 = ip6_mfib_table_fwd_lookup(ip6_mfib_get(fib_index0),
169  &ip0->src_address,
170  &ip0->dst_address);
171  }
172 
173  vnet_buffer (p0)->ip.adj_index[VLIB_TX] = mfei0;
174  }
175 
176  vlib_put_next_frame(vm, node,
178  n_left_to_next);
179  }
180 
181  if (node->flags & VLIB_NODE_FLAG_TRACE)
182  mfib_forward_lookup_trace(vm, node, frame);
183 
184  return frame->n_vectors;
185 }
186 
188  vlib_node_runtime_t * node,
189  vlib_frame_t * frame)
190 {
191  return (mfib_forward_lookup (vm, node, frame, 1));
192 }
193 
195  .name = "ip4-mfib-forward-lookup",
196  .vector_size = sizeof (u32),
197 
198  .format_trace = format_mfib_forward_lookup_trace,
199 
200  .n_next_nodes = MFIB_FORWARD_LOOKUP_N_NEXT,
201  .next_nodes = {
202  [MFIB_FORWARD_LOOKUP_NEXT_RPF] = "ip4-mfib-forward-rpf",
203  },
204 };
205 
207  vlib_node_runtime_t * node,
208  vlib_frame_t * frame)
209 {
210  return (mfib_forward_lookup (vm, node, frame, 0));
211 }
212 
214  .name = "ip6-mfib-forward-lookup",
215  .vector_size = sizeof (u32),
216 
217  .format_trace = format_mfib_forward_lookup_trace,
218 
219  .n_next_nodes = MFIB_FORWARD_LOOKUP_N_NEXT,
220  .next_nodes = {
221  [MFIB_FORWARD_LOOKUP_NEXT_RPF] = "ip6-mfib-forward-rpf",
222  },
223 };
224 
225 
231 
236 
237 static u8 *
238 format_mfib_forward_rpf_trace (u8 * s, va_list * args)
239 {
240  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
241  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
242  mfib_forward_rpf_trace_t * t = va_arg (*args, mfib_forward_rpf_trace_t *);
243 
244  s = format (s, "entry %d", t->entry_index);
245  s = format (s, " itf %d", t->sw_if_index);
246  s = format (s, " flags %U", format_mfib_itf_flags, t->itf_flags);
247 
248  return s;
249 }
250 
251 static int
254  int is_v4)
255 {
256  /*
257  * Lookup the source of the IP packet in the
258  * FIB. return true if the entry is attached.
259  */
260  index_t lbi0;
261 
262  if (is_v4)
263  {
264  load_balance_t *lb0;
265  ip4_header_t *ip0;
266 
267  ip0 = vlib_buffer_get_current(b0);
268 
271  sw_if_index),
272  &ip0->src_address);
273  lb0 = load_balance_get(lbi0);
274 
275  return (FIB_ENTRY_FLAG_ATTACHED &
276  lb0->lb_fib_entry_flags);
277  }
278  else
279  {
280  ASSERT(0);
281  }
282  return (0);
283 }
284 
285 static void
287  const mfib_entry_t *mfe,
288  mfib_itf_t *mfi,
289  vlib_buffer_t *b0)
290 {
291  mfib_itf_flags_t old_flags;
292 
293  old_flags = clib_atomic_fetch_or(&mfi->mfi_flags,
295 
296  if (!(old_flags & MFIB_ITF_FLAG_SIGNAL_PRESENT))
297  {
298  /*
299  * we were the lucky ones to set the signal present flag
300  */
301  if (!(old_flags & MFIB_ITF_FLAG_DONT_PRESERVE))
302  {
303  /*
304  * preserve a copy of the packet for the control
305  * plane to examine.
306  * Only allow one preserved packet at at time, since
307  * when the signal present flag is cleared so is the
308  * preserved packet.
309  */
310  mfib_signal_push(mfe, mfi, b0);
311  }
312  else
313  {
314  /*
315  * The control plane just wants the signal, not the packet as well
316  */
317  mfib_signal_push(mfe, mfi, NULL);
318  }
319  }
320  /*
321  * else
322  * there is already a signal present on this interface that the
323  * control plane has not yet acknowledged
324  */
325 }
326 
329  vlib_node_runtime_t * node,
330  vlib_frame_t * frame,
331  int is_v4)
332 {
333  u32 n_left_from, n_left_to_next, * from, * to_next;
335  vlib_node_runtime_t *error_node;
336 
337  if (is_v4)
338  error_node = vlib_node_get_runtime (vm, ip4_input_node.index);
339  else
340  error_node = vlib_node_get_runtime (vm, ip6_input_node.index);
341  from = vlib_frame_vector_args (frame);
342  n_left_from = frame->n_vectors;
344 
345  while (n_left_from > 0)
346  {
347  vlib_get_next_frame (vm, node, next,
348  to_next, n_left_to_next);
349 
350  while (n_left_from > 0 && n_left_to_next > 0)
351  {
352  fib_node_index_t mfei0;
353  const mfib_entry_t *mfe0;
354  mfib_itf_t *mfi0;
355  vlib_buffer_t * b0;
356  u32 pi0, next0;
357  mfib_itf_flags_t iflags0;
358  mfib_entry_flags_t eflags0;
359  u8 error0;
360 
361  pi0 = from[0];
362  to_next[0] = pi0;
363  from += 1;
364  to_next += 1;
365  n_left_to_next -= 1;
366  n_left_from -= 1;
367 
368  error0 = IP4_ERROR_NONE;
369  b0 = vlib_get_buffer (vm, pi0);
370  mfei0 = vnet_buffer (b0)->ip.adj_index[VLIB_TX];
371  mfe0 = mfib_entry_get(mfei0);
372  mfi0 = mfib_entry_get_itf(mfe0,
374 
375  /*
376  * throughout this function we are 'PREDICT' optimising
377  * for the case of throughput traffic that is not replicated
378  * to the host stack nor sets local flags
379  */
380 
381  /*
382  * If the mfib entry has a configured RPF-ID check that
383  * in preference to an interface based RPF
384  */
385  if (MFIB_RPF_ID_NONE != mfe0->mfe_rpf_id)
386  {
387  iflags0 = (mfe0->mfe_rpf_id == vnet_buffer(b0)->ip.rpf_id ?
390  }
391  else
392  {
393  if (PREDICT_TRUE(NULL != mfi0))
394  {
395  iflags0 = mfi0->mfi_flags;
396  }
397  else
398  {
399  iflags0 = MFIB_ITF_FLAG_NONE;
400  }
401  }
402  eflags0 = mfe0->mfe_flags;
403 
405  {
406  /*
407  * lookup the source in the unicast FIB - check it
408  * matches a connected.
409  */
411  b0,
412  vnet_buffer(b0)->sw_if_index[VLIB_RX],
413  is_v4))
414  {
415  mfib_forward_itf_signal(vm, mfe0, mfi0, b0);
416  }
417  }
418  if (PREDICT_FALSE((eflags0 & MFIB_ENTRY_FLAG_SIGNAL) ^
419  (iflags0 & MFIB_ITF_FLAG_NEGATE_SIGNAL)))
420  {
421  /*
422  * Entry signal XOR interface negate-signal
423  */
424  if (NULL != mfi0)
425  {
426  mfib_forward_itf_signal(vm, mfe0, mfi0, b0);
427  }
428  }
429 
430  if (PREDICT_TRUE((iflags0 & MFIB_ITF_FLAG_ACCEPT) ||
431  (eflags0 & MFIB_ENTRY_FLAG_ACCEPT_ALL_ITF)))
432  {
433  /*
434  * This interface is accepting packets for the matching entry
435  */
436  next0 = mfe0->mfe_rep.dpoi_next_node;
437 
438  vnet_buffer(b0)->ip.adj_index[VLIB_TX] =
439  mfe0->mfe_rep.dpoi_index;
440  }
441  else
442  {
444  error0 = IP4_ERROR_RPF_FAILURE;
445  }
446 
447  b0->error = error0 ? error_node->errors[error0] : 0;
448 
449  if (b0->flags & VLIB_BUFFER_IS_TRACED)
450  {
452 
453  t0 = vlib_add_trace (vm, node, b0, sizeof (*t0));
454  t0->entry_index = mfei0;
455  t0->itf_flags = iflags0;
456  if (NULL == mfi0)
457  {
458  t0->sw_if_index = ~0;
459  }
460  else
461  {
462  t0->sw_if_index = mfi0->mfi_sw_if_index;
463  }
464  }
465  vlib_validate_buffer_enqueue_x1 (vm, node, next,
466  to_next, n_left_to_next,
467  pi0, next0);
468  }
469 
470  vlib_put_next_frame(vm, node, next, n_left_to_next);
471  }
472 
473  return frame->n_vectors;
474 }
475 
477  vlib_node_runtime_t * node,
478  vlib_frame_t * frame)
479 {
480  return (mfib_forward_rpf(vm, node, frame, 1));
481 }
482 
483 
485  .name = "ip4-mfib-forward-rpf",
486  .vector_size = sizeof (u32),
487 
488  .format_trace = format_mfib_forward_rpf_trace,
489 
490  .n_next_nodes = MFIB_FORWARD_RPF_N_NEXT,
491  .next_nodes = {
492  [MFIB_FORWARD_RPF_NEXT_DROP] = "ip4-drop",
493  },
494 };
495 
497  vlib_node_runtime_t * node,
498  vlib_frame_t * frame)
499 {
500  return (mfib_forward_rpf(vm, node, frame, 0));
501 }
502 
503 
505  .name = "ip6-mfib-forward-rpf",
506  .vector_size = sizeof (u32),
507 
508  .format_trace = format_mfib_forward_rpf_trace,
509 
510  .n_next_nodes = MFIB_FORWARD_RPF_N_NEXT,
511  .next_nodes = {
512  [MFIB_FORWARD_RPF_NEXT_DROP] = "ip6-drop",
513  },
514 };
515 
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:124
fib_entry_flag_t lb_fib_entry_flags
Flags from the load-balance&#39;s associated fib_entry_t.
Definition: load_balance.h:138
#define CLIB_UNUSED(x)
Definition: clib.h:83
enum mfib_entry_flags_t_ mfib_entry_flags_t
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip6.h:197
ip4_address_t src_address
Definition: ip4_packet.h:170
#define PREDICT_TRUE(x)
Definition: clib.h:113
static u8 * format_mfib_forward_rpf_trace(u8 *s, va_list *args)
Definition: mfib_forward.c:238
An entry in a FIB table.
Definition: mfib_entry.h:32
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
static uword mfib_forward_lookup(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int is_v4)
Definition: mfib_forward.c:118
static void mfib_forward_itf_signal(vlib_main_t *vm, const mfib_entry_t *mfe, mfib_itf_t *mfi, vlib_buffer_t *b0)
Definition: mfib_forward.c:286
fib_node_index_t ip6_mfib_table_fwd_lookup(const ip6_mfib_t *mfib, const ip6_address_t *src, const ip6_address_t *grp)
Definition: ip6_mfib.c:350
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define VLIB_NODE_FN(node)
Definition: node.h:202
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:470
Definition: fib_entry.h:283
ip6_address_t src_address
Definition: ip6_packet.h:383
unsigned char u8
Definition: types.h:56
static ip4_mfib_t * ip4_mfib_get(u32 index)
Get the FIB at the given index.
Definition: ip4_mfib.h:62
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
Definition: ip4_fib.c:224
u32 * mfib_index_by_sw_if_index
Table index indexed by software interface.
Definition: ip4.h:124
#define vlib_prefetch_buffer_with_index(vm, bi, type)
Prefetch buffer metadata by buffer index The first 64 bytes of buffer contains most header informatio...
Definition: buffer_funcs.h:440
vl_api_interface_index_t sw_if_index
Definition: gre.api:50
#define MFIB_RPF_ID_NONE
Definition: fib_types.h:408
#define always_inline
Definition: clib.h:99
ip4_address_t dst_address
Definition: ip4_packet.h:170
#define clib_atomic_fetch_or(a, b)
Definition: atomics.h:27
enum mfib_forward_lookup_next_t_ mfib_forward_lookup_next_t
vlib_node_registration_t ip6_mfib_forward_rpf_node
(constructor) VLIB_REGISTER_NODE (ip6_mfib_forward_rpf_node)
Definition: mfib_forward.c:504
unsigned int u32
Definition: types.h:88
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:136
vlib_node_registration_t ip6_mfib_forward_lookup_node
(constructor) VLIB_REGISTER_NODE (ip6_mfib_forward_lookup_node)
Definition: mfib_forward.c:213
struct mfib_forward_rpf_trace_t_ mfib_forward_rpf_trace_t
dpo_id_t mfe_rep
The DPO used for forwarding; replicate, drop, etc.
Definition: mfib_entry.h:72
vlib_node_registration_t ip4_input_node
Global ip4 input node.
Definition: ip4_input.c:317
vlib_node_registration_t ip6_input_node
(constructor) VLIB_REGISTER_NODE (ip6_input_node)
Definition: ip6_input.c:230
static u8 * format_mfib_forward_lookup_trace(u8 *s, va_list *args)
Definition: mfib_forward.c:34
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
static void mfib_forward_lookup_trace(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: mfib_forward.c:46
The FIB DPO provieds;.
Definition: load_balance.h:106
#define PREDICT_FALSE(x)
Definition: clib.h:112
#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:218
#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:338
static mfib_entry_t * mfib_entry_get(fib_node_index_t index)
Definition: mfib_entry.h:198
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
mfib_itf_flags_t itf_flags
Definition: mfib_forward.c:229
u16 n_vectors
Definition: node.h:397
vlib_main_t * vm
Definition: buffer.c:323
mfib_forward_lookup_next_t_
Definition: mfib_forward.c:112
mfib_itf_flags_t mfi_flags
Forwarding Flags on the entry - checked in the data-path.
Definition: mfib_itf.h:35
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
Definition: node_funcs.h:89
static int mfib_forward_connected_check(vlib_buffer_t *b0, u32 sw_if_index, int is_v4)
Definition: mfib_forward.c:252
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
mfib_entry_flags_t mfe_flags
Route flags.
Definition: mfib_entry.h:77
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:456
#define ASSERT(truth)
ip6_main_t ip6_main
Definition: ip6_forward.c:2805
static load_balance_t * load_balance_get(index_t lbi)
Definition: load_balance.h:220
IPv4 main type.
Definition: ip4.h:105
An interface associated with a particular MFIB entry.
Definition: mfib_itf.h:25
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
static index_t ip4_fib_forwarding_lookup(u32 fib_index, const ip4_address_t *addr)
Definition: ip4_fib.h:160
fib_rpf_id_t mfe_rpf_id
RPF-ID used when the packets ingress not from an interface.
Definition: mfib_entry.h:82
vlib_node_registration_t ip4_mfib_forward_rpf_node
(constructor) VLIB_REGISTER_NODE (ip4_mfib_forward_rpf_node)
Definition: mfib_forward.c:484
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
#define vec_elt(v, i)
Get vector value at index i.
Definition: defs.h:47
static mfib_itf_t * mfib_entry_get_itf(const mfib_entry_t *mfe, u32 sw_if_index)
Definition: mfib_entry.h:226
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:186
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
u8 * format_mfib_itf_flags(u8 *s, va_list *args)
Definition: mfib_types.c:181
void mfib_signal_push(const mfib_entry_t *mfe, mfib_itf_t *mfi, vlib_buffer_t *b0)
Definition: mfib_signal.c:141
vlib_node_registration_t ip4_mfib_forward_lookup_node
(constructor) VLIB_REGISTER_NODE (ip4_mfib_forward_lookup_node)
Definition: mfib_forward.c:194
enum mfib_itf_flags_t_ mfib_itf_flags_t
static uword mfib_forward_rpf(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, int is_v4)
Definition: mfib_forward.c:328
enum mfib_forward_rpf_next_t_ mfib_forward_rpf_next_t
static ip6_mfib_t * ip6_mfib_get(u32 index)
Get the FIB at the given index.
Definition: ip6_mfib.h:72
#define vnet_buffer(b)
Definition: buffer.h:365
u32 mfi_sw_if_index
The SW IF index that this MFIB interface represents.
Definition: mfib_itf.h:40
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1076
u16 flags
Copy of main node flags.
Definition: node.h:509
u16 dpoi_next_node
The next VLIB node to follow.
Definition: dpo.h:182
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:302
mfib_forward_rpf_next_t_
Definition: mfib_forward.c:232
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
Definition: defs.h:46
ip6_address_t dst_address
Definition: ip6_packet.h:383
struct mfib_forward_lookup_trace_t_ mfib_forward_lookup_trace_t