FD.io VPP  v18.01-8-g0eacf49
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 
19 /*
20  * The 'DB' of interface DPOs.
21  * There is only one per-interface per-protocol, so this is a per-interface
22  * vector
23  */
25 
26 static interface_rx_dpo_t *
28 {
29  interface_rx_dpo_t *ido;
30 
32 
33  return (ido);
34 }
35 
36 static inline interface_rx_dpo_t *
38 {
40 
41  return (interface_rx_dpo_get(dpo->dpoi_index));
42 }
43 
44 static inline index_t
46 {
47  return (ido - interface_rx_dpo_pool);
48 }
49 
50 static void
52 {
53  interface_rx_dpo_t *ido;
54 
56  ido->ido_locks++;
57 }
58 
59 static void
61 {
62  interface_rx_dpo_t *ido;
63 
65  ido->ido_locks--;
66 
67  if (0 == ido->ido_locks)
68  {
72  }
73 }
74 
75 /*
76  * interface_rx_dpo_add_or_lock
77  *
78  * Add/create and lock a new or lock an existing for the interface DPO
79  * on the interface and protocol given
80  */
81 void
83  u32 sw_if_index,
84  dpo_id_t *dpo)
85 {
86  interface_rx_dpo_t *ido;
87 
89  sw_if_index,
91 
92  if (INDEX_INVALID == interface_rx_dpo_db[proto][sw_if_index])
93  {
94  ido = interface_rx_dpo_alloc();
95 
96  ido->ido_sw_if_index = sw_if_index;
97  ido->ido_proto = proto;
98 
99  interface_rx_dpo_db[proto][sw_if_index] =
101  }
102  else
103  {
104  ido = interface_rx_dpo_get(interface_rx_dpo_db[proto][sw_if_index]);
105  }
106 
108 }
109 
110 
111 static clib_error_t *
113  u32 sw_if_index,
114  u32 flags)
115 {
116  /*
117  */
118  return (NULL);
119 }
120 
123 
124 /**
125  * @brief Registered callback for HW interface state changes
126  */
127 static clib_error_t *
129  u32 hw_if_index,
130  u32 flags)
131 {
132  return (NULL);
133 }
134 
137 
138 static clib_error_t *
140  u32 sw_if_index,
141  u32 is_add)
142 {
143  return (NULL);
144 }
145 
148 
149 u8*
150 format_interface_rx_dpo (u8* s, va_list *ap)
151 {
152  index_t index = va_arg(*ap, index_t);
153  CLIB_UNUSED(u32 indent) = va_arg(*ap, u32);
154  vnet_main_t * vnm = vnet_get_main();
156 
157  return (format(s, "%U-rx-dpo: %U",
159  vnm,
161  format_dpo_proto, ido->ido_proto));
162 }
163 
164 static void
166 {
167  fib_show_memory_usage("Interface",
170  sizeof(interface_rx_dpo_t));
171 }
172 
173 
174 const static dpo_vft_t interface_rx_dpo_vft = {
176  .dv_unlock = interface_rx_dpo_unlock,
177  .dv_format = format_interface_rx_dpo,
178  .dv_mem_show = interface_rx_dpo_mem_show,
179 };
180 
181 /**
182  * @brief The per-protocol VLIB graph nodes that are assigned to a glean
183  * object.
184  *
185  * this means that these graph nodes are ones from which a glean is the
186  * parent object in the DPO-graph.
187  */
188 const static char* const interface_rx_dpo_ip4_nodes[] =
189 {
190  "interface-rx-dpo-ip4",
191  NULL,
192 };
193 const static char* const interface_rx_dpo_ip6_nodes[] =
194 {
195  "interface-rx-dpo-ip6",
196  NULL,
197 };
198 const static char* const interface_rx_dpo_l2_nodes[] =
199 {
200  "interface-rx-dpo-l2",
201  NULL,
202 };
203 
204 const static char* const * const interface_rx_dpo_nodes[DPO_PROTO_NUM] =
205 {
209  [DPO_PROTO_MPLS] = NULL,
210 };
211 
212 void
214 {
216  &interface_rx_dpo_vft,
218 }
219 
220 /**
221  * @brief Interface DPO trace data
222  */
224 {
227 
229 {
233 
236  vlib_node_runtime_t * node,
237  vlib_frame_t * from_frame)
238 {
239  u32 n_left_from, next_index, * from, * to_next;
240  u32 thread_index = vlib_get_thread_index ();
242 
243  im = &vnet_get_main ()->interface_main;
244  from = vlib_frame_vector_args (from_frame);
245  n_left_from = from_frame->n_vectors;
246 
247  next_index = node->cached_next_index;
248 
249  while (n_left_from > 0)
250  {
251  u32 n_left_to_next;
252 
253  vlib_get_next_frame(vm, node, next_index, to_next, n_left_to_next);
254 
255  while (n_left_from >= 4 && n_left_to_next > 2)
256  {
257  const interface_rx_dpo_t *ido0, *ido1;
258  u32 bi0, idoi0, bi1, idoi1;
259  vlib_buffer_t *b0, *b1;
260 
261  bi0 = from[0];
262  to_next[0] = bi0;
263  bi1 = from[1];
264  to_next[1] = bi1;
265  from += 2;
266  to_next += 2;
267  n_left_from -= 2;
268  n_left_to_next -= 2;
269 
270  b0 = vlib_get_buffer (vm, bi0);
271  b1 = vlib_get_buffer (vm, bi1);
272 
273  idoi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
274  idoi1 = vnet_buffer(b1)->ip.adj_index[VLIB_TX];
275  ido0 = interface_rx_dpo_get(idoi0);
276  ido1 = interface_rx_dpo_get(idoi1);
277 
278  vnet_buffer(b0)->sw_if_index[VLIB_RX] = ido0->ido_sw_if_index;
279  vnet_buffer(b1)->sw_if_index[VLIB_RX] = ido1->ido_sw_if_index;
280 
283  thread_index,
284  ido0->ido_sw_if_index,
285  1,
286  vlib_buffer_length_in_chain (vm, b0));
289  thread_index,
290  ido1->ido_sw_if_index,
291  1,
292  vlib_buffer_length_in_chain (vm, b1));
293 
295  {
297 
298  tr0 = vlib_add_trace (vm, node, b0, sizeof (*tr0));
299  tr0->sw_if_index = ido0->ido_sw_if_index;
300  }
302  {
304 
305  tr1 = vlib_add_trace (vm, node, b1, sizeof (*tr1));
306  tr1->sw_if_index = ido1->ido_sw_if_index;
307  }
308 
309  vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next,
310  n_left_to_next, bi0, bi1,
313  }
314 
315  while (n_left_from > 0 && n_left_to_next > 0)
316  {
317  const interface_rx_dpo_t * ido0;
318  vlib_buffer_t * b0;
319  u32 bi0, idoi0;
320 
321  bi0 = from[0];
322  to_next[0] = bi0;
323  from += 1;
324  to_next += 1;
325  n_left_from -= 1;
326  n_left_to_next -= 1;
327 
328  b0 = vlib_get_buffer (vm, bi0);
329 
330  idoi0 = vnet_buffer(b0)->ip.adj_index[VLIB_TX];
331  ido0 = interface_rx_dpo_get(idoi0);
332 
333  /* Swap the RX interface of the packet to the one the
334  * interface DPR represents */
335  vnet_buffer(b0)->sw_if_index[VLIB_RX] = ido0->ido_sw_if_index;
336 
337  /* Bump the interface's RX coutners */
340  thread_index,
341  ido0->ido_sw_if_index,
342  1,
343  vlib_buffer_length_in_chain (vm, b0));
344 
346  {
348 
349  tr = vlib_add_trace (vm, node, b0, sizeof (*tr));
350  tr->sw_if_index = ido0->ido_sw_if_index;
351  }
352 
353  vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next,
354  n_left_to_next, bi0,
356  }
357  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
358  }
359  return from_frame->n_vectors;
360 }
361 
362 static u8 *
363 format_interface_rx_dpo_trace (u8 * s, va_list * args)
364 {
365  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
366  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
367  interface_rx_dpo_trace_t * t = va_arg (*args, interface_rx_dpo_trace_t *);
368  u32 indent = format_get_indent (s);
369  s = format (s, "%U sw_if_index:%d",
370  format_white_space, indent,
371  t->sw_if_index);
372  return s;
373 }
374 
375 static uword
377  vlib_node_runtime_t * node,
378  vlib_frame_t * from_frame)
379 {
380  return (interface_rx_dpo_inline(vm, node, from_frame));
381 }
382 
383 static uword
385  vlib_node_runtime_t * node,
386  vlib_frame_t * from_frame)
387 {
388  return (interface_rx_dpo_inline(vm, node, from_frame));
389 }
390 
391 static uword
393  vlib_node_runtime_t * node,
394  vlib_frame_t * from_frame)
395 {
396  return (interface_rx_dpo_inline(vm, node, from_frame));
397 }
398 
400  .function = interface_rx_dpo_ip4,
401  .name = "interface-rx-dpo-ip4",
402  .vector_size = sizeof (u32),
403  .format_trace = format_interface_rx_dpo_trace,
404 
405  .n_next_nodes = 2,
406  .next_nodes = {
407  [INTERFACE_RX_DPO_DROP] = "ip4-drop",
408  [INTERFACE_RX_DPO_INPUT] = "ip4-input",
409  },
410 };
411 
414 
415 VLIB_REGISTER_NODE (interface_rx_dpo_ip6_node) = {
416  .function = interface_rx_dpo_ip6,
417  .name = "interface-rx-dpo-ip6",
418  .vector_size = sizeof (u32),
419  .format_trace = format_interface_rx_dpo_trace,
420 
421  .n_next_nodes = 2,
422  .next_nodes = {
423  [INTERFACE_RX_DPO_DROP] = "ip6-drop",
424  [INTERFACE_RX_DPO_INPUT] = "ip6-input",
425  },
426 };
427 
428 VLIB_NODE_FUNCTION_MULTIARCH (interface_rx_dpo_ip6_node,
430 
431 VLIB_REGISTER_NODE (interface_rx_dpo_l2_node) = {
432  .function = interface_rx_dpo_l2,
433  .name = "interface-rx-dpo-l2",
434  .vector_size = sizeof (u32),
435  .format_trace = format_interface_rx_dpo_trace,
436 
437  .n_next_nodes = 2,
438  .next_nodes = {
439  [INTERFACE_RX_DPO_DROP] = "error-drop",
440  [INTERFACE_RX_DPO_INPUT] = "l2-input",
441  },
442 };
443 
444 VLIB_NODE_FUNCTION_MULTIARCH (interface_rx_dpo_l2_node,
dpo_lock_fn_t dv_lock
A reference counting lock function.
Definition: dpo.h:382
static void interface_rx_dpo_mem_show(void)
VLIB_NODE_FUNCTION_MULTIARCH(interface_rx_dpo_ip4_node, interface_rx_dpo_ip4)
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_ip6_node)
#define CLIB_UNUSED(x)
Definition: clib.h:79
A virtual function table regisitered for a DPO type.
Definition: dpo.h:377
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:211
static uword interface_rx_dpo_ip6(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
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:55
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:419
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(interface_rx_dpo_interface_state_change)
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:107
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:225
interface_rx_dpo_next_t_
#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:306
#define always_inline
Definition: clib.h:92
vlib_node_registration_t interface_rx_dpo_ip4_node
(constructor) VLIB_REGISTER_NODE (interface_rx_dpo_ip4_node)
vlib_combined_counter_main_t * combined_sw_if_counters
Definition: interface.h:672
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
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
u8 * format_interface_rx_dpo(u8 *s, va_list *ap)
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:166
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)
dpo_type_t dpoi_type
the type
Definition: dpo.h:170
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:271
static const char *const interface_rx_dpo_ip4_nodes[]
The per-protocol VLIB graph nodes that are assigned to a glean object.
#define PREDICT_FALSE(x)
Definition: clib.h:105
interface_rx_dpo_t * interface_rx_dpo_pool
pool of all interface DPOs
#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 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:364
static uword interface_rx_dpo_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
The data-path object representing a change of receive interface.
static const char *const *const interface_rx_dpo_nodes[DPO_PROTO_NUM]
u16 n_vectors
Definition: node.h:344
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:221
vlib_main_t * vm
Definition: buffer.c:283
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:93
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:454
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:182
static u8 * format_interface_rx_dpo_trace(u8 *s, va_list *args)
static uword interface_rx_dpo_ip4(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:456
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
u16 ido_locks
number of locks.
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
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:182
static const char *const interface_rx_dpo_ip6_nodes[]
unsigned char u8
Definition: types.h:56
#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.
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:267
u8 * format_dpo_proto(u8 *s, va_list *args)
format a DPO protocol
Definition: dpo.c:174
enum interface_rx_dpo_next_t_ interface_rx_dpo_next_t
#define vnet_buffer(b)
Definition: buffer.h:326
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
static uword interface_rx_dpo_l2(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
u32 flags
Definition: vhost-user.h:77
#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:481
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:75
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:57
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