FD.io VPP  v17.07-30-g839fa73
Vector Packet Processing
node.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2016 Cisco and/or its affiliates.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *------------------------------------------------------------------
16  */
17 
18 #include <stdint.h>
19 #include <net/if.h>
20 #include <sys/ioctl.h>
21 
22 #include <vlib/vlib.h>
23 #include <vlib/unix/unix.h>
24 #include <vnet/ethernet/ethernet.h>
25 #include <vnet/devices/devices.h>
26 #include <vnet/feature/feature.h>
27 
30 
31 #define foreach_netmap_input_error
32 
33 typedef enum
34 {
35 #define _(f,s) NETMAP_INPUT_ERROR_##f,
37 #undef _
40 
41 static char *netmap_input_error_strings[] = {
42 #define _(n,s) s,
44 #undef _
45 };
46 
47 typedef struct
48 {
51  struct netmap_slot slot;
53 
54 static u8 *
55 format_netmap_input_trace (u8 * s, va_list * args)
56 {
57  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
58  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
59  netmap_input_trace_t *t = va_arg (*args, netmap_input_trace_t *);
60  uword indent = format_get_indent (s);
61 
62  s = format (s, "netmap: hw_if_index %d next-index %d",
63  t->hw_if_index, t->next_index);
64  s = format (s, "\n%Uslot: flags 0x%x len %u buf_idx %u",
65  format_white_space, indent + 2,
66  t->slot.flags, t->slot.len, t->slot.buf_idx);
67  return s;
68 }
69 
70 always_inline void
71 buffer_add_to_chain (vlib_main_t * vm, u32 bi, u32 first_bi, u32 prev_bi)
72 {
73  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
74  vlib_buffer_t *first_b = vlib_get_buffer (vm, first_bi);
75  vlib_buffer_t *prev_b = vlib_get_buffer (vm, prev_bi);
76 
77  /* update first buffer */
79 
80  /* update previous buffer */
81  prev_b->next_buffer = bi;
83 
84  /* update current buffer */
85  b->next_buffer = 0;
86 }
87 
90  vlib_frame_t * frame, netmap_if_t * nif)
91 {
93  uword n_trace = vlib_get_trace_count (vm, node);
95  u32 n_rx_packets = 0;
96  u32 n_rx_bytes = 0;
97  u32 *to_next = 0;
98  u32 n_free_bufs;
99  struct netmap_ring *ring;
100  int cur_ring;
101  u32 thread_index = vlib_get_thread_index ();
102  u32 n_buffer_bytes = vlib_buffer_free_list_buffer_size (vm,
104 
105  if (nif->per_interface_next_index != ~0)
106  next_index = nif->per_interface_next_index;
107 
108  n_free_bufs = vec_len (nm->rx_buffers[thread_index]);
109  if (PREDICT_FALSE (n_free_bufs < VLIB_FRAME_SIZE))
110  {
111  vec_validate (nm->rx_buffers[thread_index],
112  VLIB_FRAME_SIZE + n_free_bufs - 1);
113  n_free_bufs +=
114  vlib_buffer_alloc (vm, &nm->rx_buffers[thread_index][n_free_bufs],
116  _vec_len (nm->rx_buffers[thread_index]) = n_free_bufs;
117  }
118 
119  cur_ring = nif->first_rx_ring;
120  while (cur_ring <= nif->last_rx_ring && n_free_bufs)
121  {
122  int r = 0;
123  u32 cur_slot_index;
124  ring = NETMAP_RXRING (nif->nifp, cur_ring);
125  r = nm_ring_space (ring);
126 
127  if (!r)
128  {
129  cur_ring++;
130  continue;
131  }
132 
133  if (r > n_free_bufs)
134  r = n_free_bufs;
135 
136  cur_slot_index = ring->cur;
137  while (r)
138  {
139  u32 n_left_to_next;
140  u32 next0 = next_index;
141  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
142 
143  while (r && n_left_to_next)
144  {
145  vlib_buffer_t *first_b0 = 0;
146  u32 offset = 0;
147  u32 bi0 = 0, first_bi0 = 0, prev_bi0;
148  u32 next_slot_index = (cur_slot_index + 1) % ring->num_slots;
149  u32 next2_slot_index = (cur_slot_index + 2) % ring->num_slots;
150  struct netmap_slot *slot = &ring->slot[cur_slot_index];
151  u32 data_len = slot->len;
152 
153  /* prefetch 2 slots in advance */
154  CLIB_PREFETCH (&ring->slot[next2_slot_index],
155  CLIB_CACHE_LINE_BYTES, LOAD);
156  /* prefetch start of next packet */
157  CLIB_PREFETCH (NETMAP_BUF
158  (ring, ring->slot[next_slot_index].buf_idx),
159  CLIB_CACHE_LINE_BYTES, LOAD);
160 
161  while (data_len && n_free_bufs)
162  {
163  vlib_buffer_t *b0;
164  /* grab free buffer */
165  u32 last_empty_buffer =
166  vec_len (nm->rx_buffers[thread_index]) - 1;
167  prev_bi0 = bi0;
168  bi0 = nm->rx_buffers[thread_index][last_empty_buffer];
169  b0 = vlib_get_buffer (vm, bi0);
170  _vec_len (nm->rx_buffers[thread_index]) = last_empty_buffer;
171  n_free_bufs--;
172 
173  /* copy data */
174  u32 bytes_to_copy =
175  data_len > n_buffer_bytes ? n_buffer_bytes : data_len;
176  b0->current_data = 0;
178  (u8 *) NETMAP_BUF (ring,
179  slot->buf_idx) + offset,
180  bytes_to_copy);
181 
182  /* fill buffer header */
183  b0->current_length = bytes_to_copy;
184 
185  if (offset == 0)
186  {
189  vnet_buffer (b0)->sw_if_index[VLIB_RX] =
190  nif->sw_if_index;
191  vnet_buffer (b0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
192  first_bi0 = bi0;
193  first_b0 = vlib_get_buffer (vm, first_bi0);
194  }
195  else
196  buffer_add_to_chain (vm, bi0, first_bi0, prev_bi0);
197 
198  offset += bytes_to_copy;
199  data_len -= bytes_to_copy;
200  }
201 
202  /* trace */
204  if (PREDICT_FALSE (n_trace > 0))
205  {
206  if (PREDICT_TRUE (first_b0 != 0))
207  {
209  vlib_trace_buffer (vm, node, next0, first_b0,
210  /* follow_chain */ 0);
211  vlib_set_trace_count (vm, node, --n_trace);
212  tr = vlib_add_trace (vm, node, first_b0, sizeof (*tr));
213  tr->next_index = next0;
214  tr->hw_if_index = nif->hw_if_index;
215  memcpy (&tr->slot, slot, sizeof (struct netmap_slot));
216  }
217  }
218 
219  /* redirect if feature path enabled */
221  first_b0);
222 
223  /* enque and take next packet */
224  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
225  n_left_to_next, first_bi0,
226  next0);
227 
228  /* next packet */
229  n_rx_packets++;
230  n_rx_bytes += slot->len;
231  to_next[0] = first_bi0;
232  to_next += 1;
233  n_left_to_next--;
234  cur_slot_index = next_slot_index;
235 
236  r--;
237  }
238  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
239  }
240  ring->head = ring->cur = cur_slot_index;
241  cur_ring++;
242  }
243 
244  if (n_rx_packets)
245  ioctl (nif->fd, NIOCRXSYNC, NULL);
246 
248  (vnet_get_main ()->interface_main.combined_sw_if_counters
250  vlib_get_thread_index (), nif->hw_if_index, n_rx_packets, n_rx_bytes);
251 
252  vnet_device_increment_rx_packets (thread_index, n_rx_packets);
253 
254  return n_rx_packets;
255 }
256 
257 static uword
259  vlib_frame_t * frame)
260 {
261  int i;
262  u32 n_rx_packets = 0;
263  u32 thread_index = vlib_get_thread_index ();
264  netmap_main_t *nm = &netmap_main;
265  netmap_if_t *nmi;
266 
267  for (i = 0; i < vec_len (nm->interfaces); i++)
268  {
269  nmi = vec_elt_at_index (nm->interfaces, i);
270  if (nmi->is_admin_up &&
271  (i % nm->input_cpu_count) ==
272  (thread_index - nm->input_cpu_first_index))
273  n_rx_packets += netmap_device_input_fn (vm, node, frame, nmi);
274  }
275 
276  return n_rx_packets;
277 }
278 
279 /* *INDENT-OFF* */
281  .function = netmap_input_fn,
282  .name = "netmap-input",
283  .sibling_of = "device-input",
284  .format_trace = format_netmap_input_trace,
285  .type = VLIB_NODE_TYPE_INPUT,
286  /* default state is INTERRUPT mode, switch to POLLING if worker threads are enabled */
287  .state = VLIB_NODE_STATE_INTERRUPT,
288  .n_errors = NETMAP_INPUT_N_ERROR,
289  .error_strings = netmap_input_error_strings,
290 };
291 
293 /* *INDENT-ON* */
294 
295 
296 /*
297  * fd.io coding-style-patch-verification: ON
298  *
299  * Local Variables:
300  * eval: (c-set-style "gnu")
301  * End:
302  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:436
struct netmap_slot slot[0]
Definition: net_netmap.h:287
static void vnet_device_increment_rx_packets(u32 thread_index, u64 count)
Definition: devices.h:109
const uint32_t num_slots
Definition: net_netmap.h:266
struct netmap_slot slot
Definition: node.c:51
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
#define CLIB_UNUSED(x)
Definition: clib.h:79
static u32 vlib_get_trace_count(vlib_main_t *vm, vlib_node_runtime_t *rt)
Definition: trace_funcs.h:143
netmap_if_t * interfaces
Definition: netmap.h:80
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 char * netmap_input_error_strings[]
Definition: node.c:41
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
#define PREDICT_TRUE(x)
Definition: clib.h:98
uint16_t flags
Definition: net_netmap.h:148
#define NULL
Definition: clib.h:55
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:459
uint32_t cur
Definition: net_netmap.h:272
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
uint16_t len
Definition: net_netmap.h:147
u32 sw_if_index
Definition: netmap.h:52
static void vlib_trace_buffer(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, vlib_buffer_t *b, int follow_chain)
Definition: trace_funcs.h:104
#define VLIB_BUFFER_NEXT_PRESENT
Definition: buffer.h:87
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:67
#define always_inline
Definition: clib.h:84
static uword format_get_indent(u8 *s)
Definition: format.h:72
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:113
#define VLIB_BUFFER_TOTAL_LENGTH_VALID
Definition: buffer.h:89
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
u32 per_interface_next_index
Definition: netmap.h:55
static uword netmap_input_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: node.c:258
u32 input_cpu_count
Definition: netmap.h:98
#define foreach_netmap_input_error
Definition: node.c:31
struct netmap_if * nifp
Definition: netmap.h:62
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:71
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:188
#define VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX
Definition: buffer.h:402
static uword netmap_device_input_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, netmap_if_t *nif)
Definition: node.c:89
#define PREDICT_FALSE(x)
Definition: clib.h:97
static u32 vlib_buffer_free_list_buffer_size(vlib_main_t *vm, u32 free_list_index)
Definition: buffer_funcs.h:399
#define VLIB_FRAME_SIZE
Definition: node.h:329
uint32_t buf_idx
Definition: net_netmap.h:146
#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:216
#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:366
u16 first_rx_ring
Definition: netmap.h:65
static u8 * format_netmap_input_trace(u8 *s, va_list *args)
Definition: node.c:55
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:185
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
int fd
Definition: netmap.h:61
#define NIOCRXSYNC
Definition: net_netmap.h:597
uint32_t head
Definition: net_netmap.h:271
#define clib_memcpy(a, b, c)
Definition: string.h:69
u32 hw_if_index
Definition: netmap.h:51
netmap_main_t netmap_main
Definition: netmap.h:101
unsigned int u32
Definition: types.h:88
u32 next_buffer
Next buffer for this linked-list of buffers.
Definition: buffer.h:109
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
vlib_node_registration_t netmap_input_node
(constructor) VLIB_REGISTER_NODE (netmap_input_node)
Definition: node.c:280
u32 total_length_not_including_first_buffer
Only valid for first buffer in chain.
Definition: buffer.h:103
template key/value backing page structure
Definition: bihash_doc.h:44
Definition: defs.h:47
u32 input_cpu_first_index
Definition: netmap.h:95
u8 is_admin_up
Definition: netmap.h:56
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
#define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
Definition: buffer.h:496
static void buffer_add_to_chain(vlib_main_t *vm, u32 bi, u32 first_bi, u32 prev_bi)
Definition: node.c:71
#define vnet_buffer(b)
Definition: buffer.h:303
static_always_inline void vnet_feature_start_device_input_x1(u32 sw_if_index, u32 *next0, vlib_buffer_t *b0)
Definition: feature.h:227
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:144
u32 ** rx_buffers
Definition: netmap.h:86
static void vlib_set_trace_count(vlib_main_t *vm, vlib_node_runtime_t *rt, u32 count)
Definition: trace_funcs.h:159
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:67
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:74
static u32 vlib_buffer_alloc(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Allocate buffers into supplied array.
Definition: buffer_funcs.h:245
netmap_input_error_t
Definition: node.c:33
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
VLIB_NODE_FUNCTION_MULTIARCH(ethernet_input_not_l2_node, ethernet_input_not_l2)
Definition: node.c:1175
Definition: defs.h:46