FD.io VPP  v20.01-48-g3e0dafb74
Vector Packet Processing
interface_rx_dpo.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 
17 #include <vnet/fib/fib_node.h>
18 #include <vnet/l2/l2_input.h>
19 
20 #ifndef CLIB_MARCH_VARIANT
22 
23 /*
24  * The 'DB' of interface DPOs.
25  * There is only one per-interface per-protocol, so this is a per-interface
26  * vector
27  */
29 
30 static interface_rx_dpo_t *
32 {
33  interface_rx_dpo_t *ido;
34 
35  pool_get(interface_rx_dpo_pool, ido);
36 
37  return (ido);
38 }
39 
40 static inline interface_rx_dpo_t *
42 {
44 
45  return (interface_rx_dpo_get(dpo->dpoi_index));
46 }
47 
48 static inline index_t
50 {
51  return (ido - interface_rx_dpo_pool);
52 }
53 
54 static void
56 {
57  interface_rx_dpo_t *ido;
58 
60  ido->ido_locks++;
61 }
62 
63 static void
65 {
66  interface_rx_dpo_t *ido;
67 
69  ido->ido_locks--;
70 
71  if (0 == ido->ido_locks)
72  {
75  pool_put(interface_rx_dpo_pool, ido);
76  }
77 }
78 
79 /*
80  * interface_rx_dpo_add_or_lock
81  *
82  * Add/create and lock a new or lock an existing for the interface DPO
83  * on the interface and protocol given
84  */
85 void
88  dpo_id_t *dpo)
89 {
90  interface_rx_dpo_t *ido;
91 
93  sw_if_index,
95 
96  if (INDEX_INVALID == interface_rx_dpo_db[proto][sw_if_index])
97  {
98  ido = interface_rx_dpo_alloc();
99 
101  ido->ido_proto = proto;
102 
105  }
106  else
107  {
108  ido = interface_rx_dpo_get(interface_rx_dpo_db[proto][sw_if_index]);
109  }
110 
112 }
113 #endif /* CLIB_MARCH_VARIANT */
114 
115 
116 static clib_error_t *
119  u32 flags)
120 {
121  /*
122  */
123  return (NULL);
124 }
125 
128 
129 /**
130  * @brief Registered callback for HW interface state changes
131  */
132 static clib_error_t *
134  u32 hw_if_index,
135  u32 flags)
136 {
137  return (NULL);
138 }
139 
142 
143 static clib_error_t *
146  u32 is_add)
147 {
148  return (NULL);
149 }
150 
153 
154 #ifndef CLIB_MARCH_VARIANT
155 static u8*
156 format_interface_rx_dpo (u8* s, va_list *ap)
157 {
158  index_t index = va_arg(*ap, index_t);
159  CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
160  vnet_main_t * vnm = vnet_get_main();
162 
163  return (format(s, "%U-rx-dpo: %U",
165  vnm,
167  format_dpo_proto, ido->ido_proto));
168 }
169 
170 static void
172 {
173  fib_show_memory_usage("Interface",
174  pool_elts(interface_rx_dpo_pool),
175  pool_len(interface_rx_dpo_pool),
176  sizeof(interface_rx_dpo_t));
177 }
178 
179 
180 const static dpo_vft_t interface_rx_dpo_vft = {
182  .dv_unlock = interface_rx_dpo_unlock,
183  .dv_format = format_interface_rx_dpo,
184  .dv_mem_show = interface_rx_dpo_mem_show,
185 };
186 
187 /**
188  * @brief The per-protocol VLIB graph nodes that are assigned to a glean
189  * object.
190  *
191  * this means that these graph nodes are ones from which a glean is the
192  * parent object in the DPO-graph.
193  */
194 const static char* const interface_rx_dpo_ip4_nodes[] =
195 {
196  "interface-rx-dpo-ip4",
197  NULL,
198 };
199 const static char* const interface_rx_dpo_ip6_nodes[] =
200 {
201  "interface-rx-dpo-ip6",
202  NULL,
203 };
204 const static char* const interface_rx_dpo_l2_nodes[] =
205 {
206  "interface-rx-dpo-l2",
207  NULL,
208 };
209 
210 const static char* const * const interface_rx_dpo_nodes[DPO_PROTO_NUM] =
211 {
215  [DPO_PROTO_MPLS] = NULL,
216 };
217 
218 void
220 {
222  &interface_rx_dpo_vft,
224 }
225 #endif /* CLIB_MARCH_VARIANT */
226 
227 /**
228  * @brief Interface DPO trace data
229  */
231 {
234 
236 {
240 
244  vlib_frame_t * from_frame,
245  u8 is_l2)
246 {
247  u32 n_left_from, next_index, * from, * to_next;
248  u32 thread_index = vm->thread_index;
250 
251  im = &vnet_get_main ()->interface_main;
252  from = vlib_frame_vector_args (from_frame);
253  n_left_from = from_frame->n_vectors;
254 
255  next_index = INTERFACE_RX_DPO_INPUT;
256 
257  while (n_left_from > 0)
258  {
259  u32 n_left_to_next;
260 
261  vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
262 
263  while (n_left_from >= 4 && n_left_to_next > 2)
264  {
265  const interface_rx_dpo_t *ido0, *ido1;
266  u32 bi0, idoi0, bi1, idoi1;
267  vlib_buffer_t *b0, *b1;
268 
269  bi0 = from[0];
270  to_next[0] = bi0;
271  bi1 = from[1];
272  to_next[1] = bi1;
273  from += 2;
274  to_next += 2;
275  n_left_from -= 2;
276  n_left_to_next -= 2;
277 
278  b0 = vlib_get_buffer (vm, bi0);
279  b1 = vlib_get_buffer (vm, bi1);
280 
281  idoi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
282  idoi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
283  ido0 = interface_rx_dpo_get(idoi0);
284  ido1 = interface_rx_dpo_get(idoi1);
285 
286  vnet_buffer(b0)->sw_if_index[VLIB_RX] = ido0->ido_sw_if_index;
287  vnet_buffer(b1)->sw_if_index[VLIB_RX] = ido1->ido_sw_if_index;
288 
289  if (is_l2)
290  {
291  vnet_update_l2_len (b0);
292  vnet_update_l2_len (b1);
293  }
294 
297  thread_index,
298  ido0->ido_sw_if_index,
299  1,
300  vlib_buffer_length_in_chain (vm, b0));
303  thread_index,
304  ido1->ido_sw_if_index,
305  1,
306  vlib_buffer_length_in_chain (vm, b1));
307 
308  if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
309  {
311 
312  tr0 = vlib_add_trace (vm, node, b0, sizeof (*tr0));
313  tr0->sw_if_index = ido0->ido_sw_if_index;
314  }
315  if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED))
316  {
318 
319  tr1 = vlib_add_trace (vm, node, b1, sizeof (*tr1));
320  tr1->sw_if_index = ido1->ido_sw_if_index;
321  }
322  }
323 
324  while (n_left_from > 0 && n_left_to_next > 0)
325  {
326  const interface_rx_dpo_t * ido0;
327  vlib_buffer_t * b0;
328  u32 bi0, idoi0;
329 
330  bi0 = from[0];
331  to_next[0] = bi0;
332  from += 1;
333  to_next += 1;
334  n_left_from -= 1;
335  n_left_to_next -= 1;
336 
337  b0 = vlib_get_buffer (vm, bi0);
338 
339  idoi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
340  ido0 = interface_rx_dpo_get(idoi0);
341 
342  /* Swap the RX interface of the packet to the one the
343  * interface DPR represents */
344  vnet_buffer(b0)->sw_if_index[VLIB_RX] = ido0->ido_sw_if_index;
345 
346  /* Update l2_len to make l2 tag rewrite work */
347  if (is_l2)
348  vnet_update_l2_len (b0);
349 
350  /* Bump the interface's RX coutners */
353  thread_index,
354  ido0->ido_sw_if_index,
355  1,
356  vlib_buffer_length_in_chain (vm, b0));
357 
358  if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
359  {
361 
362  tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
363  tr->sw_if_index = ido0->ido_sw_if_index;
364  }
365  }
366  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
367  }
368  return from_frame->n_vectors;
369 }
370 
371 static u8 *
372 format_interface_rx_dpo_trace (u8 * s, va_list * args)
373 {
374  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
375  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
376  interface_rx_dpo_trace_t * t = va_arg (*args, interface_rx_dpo_trace_t *);
377  u32 indent = format_get_indent (s);
378  s = format (s, "%U sw_if_index:%d",
379  format_white_space, indent,
380  t->sw_if_index);
381  return s;
382 }
383 
386  vlib_frame_t * from_frame)
387 {
388  return (interface_rx_dpo_inline(vm, node, from_frame, 0));
389 }
390 
393  vlib_frame_t * from_frame)
394 {
395  return (interface_rx_dpo_inline(vm, node, from_frame, 0));
396 }
397 
400  vlib_frame_t * from_frame)
401 {
402  return (interface_rx_dpo_inline(vm, node, from_frame, 1));
403 }
404 
406  .name = "interface-rx-dpo-ip4",
407  .vector_size = sizeof (u32),
408  .format_trace = format_interface_rx_dpo_trace,
409 
410  .n_next_nodes = 2,
411  .next_nodes = {
412  [INTERFACE_RX_DPO_DROP] = "ip4-drop",
413  [INTERFACE_RX_DPO_INPUT] = "ip4-input",
414  },
415 };
416 
417 
419  .name = "interface-rx-dpo-ip6",
420  .vector_size = sizeof (u32),
421  .format_trace = format_interface_rx_dpo_trace,
422 
423  .n_next_nodes = 2,
424  .next_nodes = {
425  [INTERFACE_RX_DPO_DROP] = "ip6-drop",
426  [INTERFACE_RX_DPO_INPUT] = "ip6-input",
427  },
428 };
429 
430 
432  .name = "interface-rx-dpo-l2",
433  .vector_size = sizeof (u32),
434  .format_trace = format_interface_rx_dpo_trace,
435 
436  .n_next_nodes = 2,
437  .next_nodes = {
438  [INTERFACE_RX_DPO_DROP] = "error-drop",
439  [INTERFACE_RX_DPO_INPUT] = "l2-input",
440  },
441 };
442 
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
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:406
static void interface_rx_dpo_mem_show(void)
u8 proto
Definition: acl_types.api:47
#define CLIB_UNUSED(x)
Definition: clib.h:82
A virtual function table regisitered for a DPO type.
Definition: dpo.h:401
Interface DPO trace data.
static void vlib_increment_combined_counter(vlib_combined_counter_main_t *cm, u32 thread_index, u32 index, u64 n_packets, u64 n_bytes)
Increment a combined counter.
Definition: counter.h:220
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
vnet_interface_main_t interface_main
Definition: vnet.h:56
static interface_rx_dpo_t * interface_rx_dpo_get(index_t index)
#define NULL
Definition: clib.h:58
u32 thread_index
Definition: main.h:218
static clib_error_t * interface_rx_dpo_interface_state_change(vnet_main_t *vnm, u32 sw_if_index, u32 flags)
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 u32 format_get_indent(u8 *s)
Definition: format.h:72
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(interface_rx_dpo_interface_state_change)
#define VLIB_NODE_FN(node)
Definition: node.h:202
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:366
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:237
interface_rx_dpo_next_t_
unsigned char u8
Definition: types.h:56
#define pool_len(p)
Number of elements in pool vector.
Definition: pool.h:140
static void interface_rx_dpo_unlock(dpo_id_t *dpo)
void dpo_register(dpo_type_t type, const dpo_vft_t *vft, const char *const *const *nodes)
For a given DPO type Register:
Definition: dpo.c:322
vl_api_interface_index_t sw_if_index
Definition: gre.api:59
vlib_node_registration_t interface_rx_dpo_ip4_node
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_ip4_node)
static u8 * format_interface_rx_dpo(u8 *s, va_list *ap)
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:863
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
static index_t interface_rx_dpo_get_index(interface_rx_dpo_t *ido)
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(interface_rx_dpo_interface_delete)
void fib_show_memory_usage(const char *name, u32 in_use_elts, u32 allocd_elts, size_t size_elt)
Show the memory usage for a type.
Definition: fib_node.c:220
unsigned int u32
Definition: types.h:88
enum dpo_proto_t_ dpo_proto_t
Data path protocol.
struct interface_rx_dpo_trace_t_ interface_rx_dpo_trace_t
Interface DPO trace data.
The identity of a DPO is a combination of its type and its instance number/index of objects of that t...
Definition: dpo.h:170
format_function_t format_vnet_sw_interface_name
static clib_error_t * interface_rx_dpo_hw_interface_state_change(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Registered callback for HW interface state changes.
u32 ido_sw_if_index
The Software interface index that the packets will be given as the ingress/rx interface.
void interface_rx_dpo_module_init(void)
interface_rx_dpo_t * interface_rx_dpo_pool
pool of all interface DPOs
dpo_type_t dpoi_type
the type
Definition: dpo.h:174
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:287
static const char *const interface_rx_dpo_ip4_nodes[]
The per-protocol VLIB graph nodes that are assigned to a glean object.
static uword interface_rx_dpo_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, u8 is_l2)
#define PREDICT_FALSE(x)
Definition: clib.h:111
#define always_inline
Definition: ipsec.h:28
vlib_node_registration_t interface_rx_dpo_ip6_node
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_ip6_node)
#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
vlib_main_t * vm
Definition: in2out_ed.c:1810
The data-path object representing a change of receive interface.
static const char *const *const interface_rx_dpo_nodes[DPO_PROTO_NUM]
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u32 flags
Definition: vhost_user.h:141
u16 n_vectors
Definition: node.h:397
static void interface_rx_dpo_lock(dpo_id_t *dpo)
void interface_rx_dpo_add_or_lock(dpo_proto_t proto, u32 sw_if_index, dpo_id_t *dpo)
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
static interface_rx_dpo_t * interface_rx_dpo_alloc(void)
void dpo_set(dpo_id_t *dpo, dpo_type_t type, dpo_proto_t proto, index_t index)
Set/create a DPO ID The DPO will be locked.
Definition: dpo.c:186
static u8 * format_interface_rx_dpo_trace(u8 *s, va_list *args)
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1810
vlib_node_registration_t interface_rx_dpo_l2_node
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_l2_node)
#define ASSERT(truth)
u16 ido_locks
number of locks.
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
static interface_rx_dpo_t * interface_rx_dpo_get_from_dpo(const dpo_id_t *dpo)
Definition: defs.h:47
#define DPO_PROTO_NUM
Definition: dpo.h:70
index_t dpoi_index
the index of objects of that type
Definition: dpo.h:186
static const char *const interface_rx_dpo_ip6_nodes[]
static void vnet_update_l2_len(vlib_buffer_t *b)
Definition: l2_input.h:236
#define INDEX_INVALID
Invalid index - used when no index is known blazoned capitals INVALID speak volumes where ~0 does not...
Definition: dpo.h:47
dpo_proto_t ido_proto
DPO protocol that the packets will have as they &#39;ingress&#39; on this interface.
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_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:178
enum interface_rx_dpo_next_t_ interface_rx_dpo_next_t
#define vnet_buffer(b)
Definition: buffer.h:408
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:487
static index_t * interface_rx_dpo_db[DPO_PROTO_NUM]
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
VNET_HW_INTERFACE_LINK_UP_DOWN_FUNCTION(interface_rx_dpo_hw_interface_state_change)
static const char *const interface_rx_dpo_l2_nodes[]
Definition: defs.h:46
static clib_error_t * interface_rx_dpo_interface_delete(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128