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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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 *------------------------------------------------------------------
21 #include <sys/ioctl.h>
24 #include <vlib/vlib.h>
25 #include <vlib/unix/unix.h>
26 #include <vnet/ethernet/ethernet.h>
28 #include <memif/memif.h>
29 #include <memif/private.h>
31 #define foreach_memif_tx_func_error \
32 _(NO_FREE_SLOTS, "no free tx slots") \
33 _(TRUNC_PACKET, "packet > buffer size -- truncated in tx ring") \
34 _(PENDING_MSGS, "pending msgs in tx ring")
38 #define _(f,s) MEMIF_TX_ERROR_##f,
39 foreach_memif_tx_func_error
42 } memif_tx_func_error_t;
44 static __clib_unused char *memif_tx_func_error_strings[] = {
46 foreach_memif_tx_func_error
50 #ifndef CLIB_MULTIARCH_VARIANT
52 format_memif_device_name (u8 * s, va_list * args)
54 u32 dev_instance = va_arg (*args, u32);
55 memif_main_t *mm = &memif_main;
56 memif_if_t *mif = pool_elt_at_index (mm->interfaces, dev_instance);
57 memif_socket_file_t *msf;
59 msf = pool_elt_at_index (mm->socket_files, mif->socket_file_index);
60 s = format (s, "memif%lu/%lu", msf->socket_id, mif->id);
65 static __clib_unused u8 *
66 format_memif_device (u8 * s, va_list * args)
68 u32 dev_instance = va_arg (*args, u32);
69 int verbose = va_arg (*args, int);
70 u32 indent = format_get_indent (s);
72 s = format (s, "MEMIF interface");
75 s = format (s, "\n%U instance %u", format_white_space, indent + 2,
81 static __clib_unused u8 *
82 format_memif_tx_trace (u8 * s, va_list * args)
84 s = format (s, "Unimplemented...");
88 static_always_inline void
89 memif_prefetch_buffer_and_data (vlib_main_t * vm, u32 bi)
91 vlib_buffer_t *b = vlib_get_buffer (vm, bi);
92 vlib_prefetch_buffer_header (b, LOAD);
93 CLIB_PREFETCH (b->data, CLIB_CACHE_LINE_BYTES, LOAD);
97 * @brief Copy buffer to tx ring
101 * @param * mif (in) pointer to memif interface
102 * @param bi (in) vlib buffer index
103 * @param * ring (in) pointer to memif ring
104 * @param * head (in/out) ring head
105 * @param mask (in) ring size - 1
107 static_always_inline void
108 memif_copy_buffer_to_tx_ring (vlib_main_t * vm, vlib_node_runtime_t * node,
109 memif_if_t * mif, u32 bi, memif_ring_t * ring,
110 u16 * head, u16 mask)
115 u16 slot = (*head) & mask;
117 mb0 = memif_get_buffer (mif, ring, slot);
118 ring->desc[slot].flags = 0;
121 b0 = vlib_get_buffer (vm, bi);
122 len = b0->current_length;
123 if (PREDICT_FALSE (ring->desc[slot].buffer_length < (total + len)))
125 if (PREDICT_TRUE (total))
127 ring->desc[slot].length = total;
129 ring->desc[slot].flags |= MEMIF_DESC_FLAG_NEXT;
131 slot = (*head) & mask;
132 mb0 = memif_get_buffer (mif, ring, slot);
133 ring->desc[slot].flags = 0;
136 if (PREDICT_TRUE (ring->desc[slot].buffer_length >= (total + len)))
138 clib_memcpy (mb0 + total, vlib_buffer_get_current (b0),
139 CLIB_CACHE_LINE_BYTES);
140 if (len > CLIB_CACHE_LINE_BYTES)
141 clib_memcpy (mb0 + CLIB_CACHE_LINE_BYTES + total,
142 vlib_buffer_get_current (b0) + CLIB_CACHE_LINE_BYTES,
143 len - CLIB_CACHE_LINE_BYTES);
148 vlib_error_count (vm, node->node_index, MEMIF_TX_ERROR_TRUNC_PACKET,
153 while ((bi = (b0->flags & VLIB_BUFFER_NEXT_PRESENT) ? b0->next_buffer : 0));
155 if (PREDICT_TRUE (total))
157 ring->desc[slot].length = total;
162 static_always_inline uword
163 memif_interface_tx_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
164 vlib_frame_t * frame, memif_if_t * mif,
165 memif_ring_type_t type)
169 u32 *buffers = vlib_frame_args (frame);
170 u32 n_left = frame->n_vectors;
174 u32 thread_index = vlib_get_thread_index ();
175 u8 tx_queues = vec_len (mif->tx_queues);
179 if (tx_queues < vec_len (vlib_mains))
181 ASSERT (tx_queues > 0);
182 qid = thread_index % tx_queues;
183 clib_spinlock_lock_if_init (&mif->lockp);
188 mq = vec_elt_at_index (mif->tx_queues, qid);
190 ring_size = 1 << mq->log2_ring_size;
191 mask = ring_size - 1;
194 /* free consumed buffers */
199 free_slots = ring_size - head + tail;
201 while (n_left > 5 && free_slots > 1)
203 CLIB_PREFETCH (memif_get_buffer (mif, ring, (head + 2) & mask),
204 CLIB_CACHE_LINE_BYTES, STORE);
205 CLIB_PREFETCH (memif_get_buffer (mif, ring, (head + 3) & mask),
206 CLIB_CACHE_LINE_BYTES, STORE);
207 CLIB_PREFETCH (&ring->desc[(head + 4) & mask], CLIB_CACHE_LINE_BYTES,
209 CLIB_PREFETCH (&ring->desc[(head + 5) & mask], CLIB_CACHE_LINE_BYTES,
211 memif_prefetch_buffer_and_data (vm, buffers[2]);
212 memif_prefetch_buffer_and_data (vm, buffers[3]);
214 memif_copy_buffer_to_tx_ring (vm, node, mif, buffers[0], ring, &head,
216 memif_copy_buffer_to_tx_ring (vm, node, mif, buffers[1], ring, &head,
224 while (n_left && free_slots)
226 memif_copy_buffer_to_tx_ring (vm, node, mif, buffers[0], ring, &head,
233 CLIB_MEMORY_STORE_BARRIER ();
236 if (n_left && n_retries--)
239 clib_spinlock_unlock_if_init (&mif->lockp);
243 vlib_error_count (vm, node->node_index, MEMIF_TX_ERROR_NO_FREE_SLOTS,
247 if ((ring->flags & MEMIF_RING_FLAG_MASK_INT) == 0 && mq->int_fd > -1)
250 CLIB_UNUSED (int r) = write (mq->int_fd, &b, sizeof (b));
254 vlib_buffer_free (vm, vlib_frame_args (frame), frame->n_vectors);
256 return frame->n_vectors;
260 CLIB_MULTIARCH_FN (memif_interface_tx) (vlib_main_t * vm,
261 vlib_node_runtime_t * node,
262 vlib_frame_t * frame)
264 memif_main_t *nm = &memif_main;
265 vnet_interface_output_runtime_t *rund = (void *) node->runtime_data;
266 memif_if_t *mif = pool_elt_at_index (nm->interfaces, rund->dev_instance);
268 if (mif->flags & MEMIF_IF_FLAG_IS_SLAVE)
269 return memif_interface_tx_inline (vm, node, frame, mif, MEMIF_RING_S2M);
271 return memif_interface_tx_inline (vm, node, frame, mif, MEMIF_RING_M2S);
274 static __clib_unused void
275 memif_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
278 memif_main_t *apm = &memif_main;
279 vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
280 memif_if_t *mif = pool_elt_at_index (apm->interfaces, hw->dev_instance);
282 /* Shut off redirection */
283 if (node_index == ~0)
285 mif->per_interface_next_index = node_index;
289 mif->per_interface_next_index =
290 vlib_node_add_next (vlib_get_main (), memif_input_node.index, node_index);
293 static __clib_unused void
294 memif_clear_hw_interface_counters (u32 instance)
296 /* Nothing for now */
299 static __clib_unused clib_error_t *
300 memif_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index, u32 qid,
301 vnet_hw_interface_rx_mode mode)
303 memif_main_t *mm = &memif_main;
304 vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
305 memif_if_t *mif = pool_elt_at_index (mm->interfaces, hw->dev_instance);
306 memif_queue_t *mq = vec_elt_at_index (mif->rx_queues, qid);
308 if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
309 mq->ring->flags |= MEMIF_RING_FLAG_MASK_INT;
311 mq->ring->flags &= ~MEMIF_RING_FLAG_MASK_INT;
316 static __clib_unused clib_error_t *
317 memif_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
319 memif_main_t *mm = &memif_main;
320 vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
321 memif_if_t *mif = pool_elt_at_index (mm->interfaces, hw->dev_instance);
322 static clib_error_t *error = 0;
324 if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
325 mif->flags |= MEMIF_IF_FLAG_ADMIN_UP;
327 mif->flags &= ~MEMIF_IF_FLAG_ADMIN_UP;
332 static __clib_unused clib_error_t *
333 memif_subif_add_del_function (vnet_main_t * vnm,
335 struct vnet_sw_interface_t *st, int is_add)
337 /* Nothing for now */
341 #ifndef CLIB_MULTIARCH_VARIANT
343 VNET_DEVICE_CLASS (memif_device_class) = {
345 .tx_function = memif_interface_tx,
346 .format_device_name = format_memif_device_name,
347 .format_device = format_memif_device,
348 .format_tx_trace = format_memif_tx_trace,
349 .tx_function_n_errors = MEMIF_TX_N_ERROR,
350 .tx_function_error_strings = memif_tx_func_error_strings,
351 .rx_redirect_to_node = memif_set_interface_next_node,
352 .clear_counters = memif_clear_hw_interface_counters,
353 .admin_up_down_function = memif_interface_admin_up_down,
354 .subif_add_del_function = memif_subif_add_del_function,
355 .rx_mode_change_function = memif_interface_rx_mode_change,
359 vlib_node_function_t __clib_weak memif_interface_tx_avx512;
360 vlib_node_function_t __clib_weak memif_interface_tx_avx2;
361 static void __clib_constructor
362 dpdk_interface_tx_multiarch_select (void)
364 if (memif_interface_tx_avx512 && clib_cpu_supports_avx512f ())
365 memif_device_class.tx_function = memif_interface_tx_avx512;
366 else if (memif_interface_tx_avx2 && clib_cpu_supports_avx2 ())
367 memif_device_class.tx_function = memif_interface_tx_avx2;
375 * fd.io coding-style-patch-verification: ON
378 * eval: (c-set-style "gnu")