2 * Copyright (c) 2015 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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 ssvm_eth_main_t ssvm_eth_main;
19 #define foreach_ssvm_eth_tx_func_error \
20 _(RING_FULL, "Tx packet drops (ring full)") \
21 _(NO_BUFFERS, "Tx packet drops (no buffers)") \
22 _(ADMIN_DOWN, "Tx packet drops (admin down)")
26 #define _(f,s) SSVM_ETH_TX_ERROR_##f,
27 foreach_ssvm_eth_tx_func_error
30 } ssvm_eth_tx_func_error_t;
32 static u32 ssvm_eth_flag_change (vnet_main_t * vnm,
33 vnet_hw_interface_t * hi, u32 flags);
36 ssvm_eth_create (ssvm_eth_main_t * em, u8 * name, int is_master)
38 ssvm_private_t *intfc;
41 unix_shared_memory_queue_t *q;
42 ssvm_shared_header_t *sh;
43 ssvm_eth_queue_elt_t *elts;
48 vec_add2 (em->intfcs, intfc, 1);
50 intfc->ssvm_size = em->segment_size;
51 intfc->i_am_master = 1;
53 intfc->my_pid = getpid ();
56 rv = ssvm_slave_init (intfc, 20 /* timeout in seconds */ );
59 goto create_vnet_interface;
62 intfc->requested_va = em->next_base_va;
63 em->next_base_va += em->segment_size;
64 rv = ssvm_master_init (intfc, intfc - em->intfcs /* master index */ );
69 /* OK, segment created, set up queues and so forth. */
72 oldheap = ssvm_push_heap (sh);
74 q = unix_shared_memory_queue_init (em->queue_elts, sizeof (u32),
75 0 /* consumer pid not interesting */ ,
76 0 /* signal not sent */ );
77 sh->opaque[TO_MASTER_Q_INDEX] = (void *) q;
78 q = unix_shared_memory_queue_init (em->queue_elts, sizeof (u32),
79 0 /* consumer pid not interesting */ ,
80 0 /* signal not sent */ );
81 sh->opaque[TO_SLAVE_Q_INDEX] = (void *) q;
84 * Preallocate the requested number of buffer chunks
85 * There must be a better way to do this, etc.
86 * Add some slop to avoid pool reallocation, which will not go well
91 vec_validate_aligned (elts, em->nbuffers - 1, CLIB_CACHE_LINE_BYTES);
92 vec_validate_aligned (elt_indices, em->nbuffers - 1, CLIB_CACHE_LINE_BYTES);
94 for (i = 0; i < em->nbuffers; i++)
97 sh->opaque[CHUNK_POOL_INDEX] = (void *) elts;
98 sh->opaque[CHUNK_POOL_FREELIST_INDEX] = (void *) elt_indices;
99 sh->opaque[CHUNK_POOL_NFREE] = (void *) (uword) em->nbuffers;
101 ssvm_pop_heap (oldheap);
103 create_vnet_interface:
107 memset (enet_addr, 0, sizeof (enet_addr));
110 enet_addr[2] = is_master;
111 enet_addr[5] = sh->master_index;
113 e = ethernet_register_interface
114 (em->vnet_main, ssvm_eth_device_class.index, intfc - em->intfcs,
115 /* ethernet address */ enet_addr,
116 &intfc->vlib_hw_if_index, ssvm_eth_flag_change);
120 clib_error_report (e);
121 /* $$$$ unmap offending region? */
122 return VNET_API_ERROR_INVALID_INTERFACE;
125 /* Declare link up */
126 vnet_hw_interface_set_flags (em->vnet_main, intfc->vlib_hw_if_index,
127 VNET_HW_INTERFACE_FLAG_LINK_UP);
129 /* Let the games begin... */
135 static clib_error_t *
136 ssvm_config (vlib_main_t * vm, unformat_input_t * input)
141 ssvm_eth_main_t *em = &ssvm_eth_main;
143 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
145 if (unformat (input, "base-va %llx", &em->next_base_va))
147 else if (unformat (input, "segment-size %lld", &em->segment_size))
148 em->segment_size = 1ULL << (max_log2 (em->segment_size));
149 else if (unformat (input, "nbuffers %lld", &em->nbuffers))
151 else if (unformat (input, "queue-elts %lld", &em->queue_elts))
153 else if (unformat (input, "slave"))
155 else if (unformat (input, "%s", &name))
156 vec_add1 (em->names, name);
161 /* No configured instances, we're done... */
162 if (vec_len (em->names) == 0)
165 for (i = 0; i < vec_len (em->names); i++)
167 rv = ssvm_eth_create (em, em->names[i], is_master);
169 return clib_error_return (0, "ssvm_eth_create '%s' failed, error %d",
173 vlib_node_set_state (vm, ssvm_eth_input_node.index,
174 VLIB_NODE_STATE_POLLING);
179 VLIB_CONFIG_FUNCTION (ssvm_config, "ssvm_eth");
182 static clib_error_t *
183 ssvm_eth_init (vlib_main_t * vm)
185 ssvm_eth_main_t *em = &ssvm_eth_main;
187 if (((sizeof (ssvm_eth_queue_elt_t) / CLIB_CACHE_LINE_BYTES)
188 * CLIB_CACHE_LINE_BYTES) != sizeof (ssvm_eth_queue_elt_t))
189 clib_warning ("ssvm_eth_queue_elt_t size %d not a multiple of %d",
190 sizeof (ssvm_eth_queue_elt_t), CLIB_CACHE_LINE_BYTES);
193 em->vnet_main = vnet_get_main ();
194 em->elog_main = &vm->elog_main;
196 /* default config param values... */
198 em->next_base_va = 0x600000000ULL;
200 * Allocate 2 full superframes in each dir (256 x 2 x 2 x 2048 bytes),
201 * 2mb; double that so we have plenty of space... 4mb
203 em->segment_size = 8 << 20;
205 em->queue_elts = 512;
209 VLIB_INIT_FUNCTION (ssvm_eth_init);
211 static char *ssvm_eth_tx_func_error_strings[] = {
213 foreach_ssvm_eth_tx_func_error
218 format_ssvm_eth_device_name (u8 * s, va_list * args)
220 u32 i = va_arg (*args, u32);
222 s = format (s, "ssvmEthernet%d", i);
227 format_ssvm_eth_device (u8 * s, va_list * args)
229 s = format (s, "SSVM Ethernet");
234 format_ssvm_eth_tx_trace (u8 * s, va_list * args)
236 s = format (s, "Unimplemented...");
242 ssvm_eth_interface_tx (vlib_main_t * vm,
243 vlib_node_runtime_t * node, vlib_frame_t * f)
245 ssvm_eth_main_t *em = &ssvm_eth_main;
246 vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
247 ssvm_private_t *intfc = vec_elt_at_index (em->intfcs, rd->dev_instance);
248 ssvm_shared_header_t *sh = intfc->sh;
249 unix_shared_memory_queue_t *q;
252 ssvm_eth_queue_elt_t *elts, *elt, *prev_elt;
253 u32 my_pid = intfc->my_pid;
256 u32 size_this_buffer;
257 u32 chunks_this_buffer;
258 u8 i_am_master = intfc->i_am_master;
260 int is_ring_full, interface_down;
262 volatile u32 *queue_lock;
263 u32 n_to_alloc = VLIB_FRAME_SIZE;
264 u32 n_allocated, n_present_in_cache, n_available;
268 q = (unix_shared_memory_queue_t *) sh->opaque[TO_SLAVE_Q_INDEX];
270 q = (unix_shared_memory_queue_t *) sh->opaque[TO_MASTER_Q_INDEX];
272 queue_lock = (u32 *) q;
274 from = vlib_frame_vector_args (f);
275 n_left = f->n_vectors;
279 n_present_in_cache = vec_len (em->chunk_cache);
281 /* admin / link up/down check */
282 if (sh->opaque[MASTER_ADMIN_STATE_INDEX] == 0 ||
283 sh->opaque[SLAVE_ADMIN_STATE_INDEX] == 0)
289 ssvm_lock (sh, my_pid, 1);
291 elts = (ssvm_eth_queue_elt_t *) (sh->opaque[CHUNK_POOL_INDEX]);
292 elt_indices = (u32 *) (sh->opaque[CHUNK_POOL_FREELIST_INDEX]);
293 n_available = (u32) pointer_to_uword (sh->opaque[CHUNK_POOL_NFREE]);
295 if (n_present_in_cache < n_left * 2)
297 vec_validate (em->chunk_cache, n_to_alloc + n_present_in_cache - 1);
299 n_allocated = n_to_alloc < n_available ? n_to_alloc : n_available;
301 if (PREDICT_TRUE (n_allocated > 0))
303 clib_memcpy (&em->chunk_cache[n_present_in_cache],
304 &elt_indices[n_available - n_allocated],
305 sizeof (u32) * n_allocated);
308 n_present_in_cache += n_allocated;
309 n_available -= n_allocated;
310 sh->opaque[CHUNK_POOL_NFREE] = uword_to_pointer (n_available, void *);
311 _vec_len (em->chunk_cache) = n_present_in_cache;
319 b0 = vlib_get_buffer (vm, bi0);
321 size_this_buffer = vlib_buffer_length_in_chain (vm, b0);
322 chunks_this_buffer = (size_this_buffer + (SSVM_BUFFER_SIZE - 1))
325 /* If we're not going to be able to enqueue the buffer, tail drop. */
326 if (q->cursize >= q->maxsize)
334 for (i = 0; i < chunks_this_buffer; i++)
336 if (PREDICT_FALSE (n_present_in_cache == 0))
339 elt_index = em->chunk_cache[--n_present_in_cache];
340 elt = elts + elt_index;
342 elt->type = SSVM_PACKET_TYPE;
344 elt->total_length_not_including_first_buffer =
345 b0->total_length_not_including_first_buffer;
346 elt->length_this_buffer = b0->current_length;
347 elt->current_data_hint = b0->current_data;
348 elt->owner = !i_am_master;
351 clib_memcpy (elt->data, b0->data + b0->current_data,
354 if (PREDICT_FALSE (prev_elt != 0))
355 prev_elt->next_index = elt - elts;
357 if (PREDICT_FALSE (i < (chunks_this_buffer - 1)))
359 elt->flags = SSVM_BUFFER_NEXT_PRESENT;
360 ASSERT (b0->flags & VLIB_BUFFER_NEXT_PRESENT);
361 b0 = vlib_get_buffer (vm, b0->next_buffer);
366 while (__sync_lock_test_and_set (queue_lock, 1))
369 unix_shared_memory_queue_add_raw (q, (u8 *) & elt_index);
370 CLIB_MEMORY_BARRIER ();
378 if (PREDICT_FALSE (n_left))
381 vlib_error_count (vm, node->node_index, SSVM_ETH_TX_ERROR_RING_FULL,
383 else if (interface_down)
384 vlib_error_count (vm, node->node_index, SSVM_ETH_TX_ERROR_ADMIN_DOWN,
387 vlib_error_count (vm, node->node_index, SSVM_ETH_TX_ERROR_NO_BUFFERS,
390 vlib_buffer_free (vm, from, n_left);
393 vlib_buffer_free (vm, vlib_frame_vector_args (f), f->n_vectors);
395 if (PREDICT_TRUE (vec_len (em->chunk_cache)))
396 _vec_len (em->chunk_cache) = n_present_in_cache;
402 ssvm_eth_clear_hw_interface_counters (u32 instance)
404 /* Nothing for now */
407 static clib_error_t *
408 ssvm_eth_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index,
411 vnet_hw_interface_t *hif = vnet_get_hw_interface (vnm, hw_if_index);
412 uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
413 ssvm_eth_main_t *em = &ssvm_eth_main;
414 ssvm_private_t *intfc = vec_elt_at_index (em->intfcs, hif->dev_instance);
415 ssvm_shared_header_t *sh;
417 /* publish link-state in shared-memory, to discourage buffer-wasting */
419 if (intfc->i_am_master)
420 sh->opaque[MASTER_ADMIN_STATE_INDEX] = (void *) is_up;
422 sh->opaque[SLAVE_ADMIN_STATE_INDEX] = (void *) is_up;
427 static clib_error_t *
428 ssvm_eth_subif_add_del_function (vnet_main_t * vnm,
430 struct vnet_sw_interface_t *st, int is_add)
432 /* Nothing for now */
437 * Dynamically redirect all pkts from a specific interface
438 * to the specified node
441 ssvm_eth_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
444 ssvm_eth_main_t *em = &ssvm_eth_main;
445 vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
446 ssvm_private_t *intfc = pool_elt_at_index (em->intfcs, hw->dev_instance);
448 /* Shut off redirection */
449 if (node_index == ~0)
451 intfc->per_interface_next_index = node_index;
455 intfc->per_interface_next_index =
456 vlib_node_add_next (em->vlib_main, ssvm_eth_input_node.index, node_index);
460 ssvm_eth_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hi, u32 flags)
462 /* nothing for now */
467 VNET_DEVICE_CLASS (ssvm_eth_device_class) = {
469 .tx_function = ssvm_eth_interface_tx,
470 .tx_function_n_errors = SSVM_ETH_TX_N_ERROR,
471 .tx_function_error_strings = ssvm_eth_tx_func_error_strings,
472 .format_device_name = format_ssvm_eth_device_name,
473 .format_device = format_ssvm_eth_device,
474 .format_tx_trace = format_ssvm_eth_tx_trace,
475 .clear_counters = ssvm_eth_clear_hw_interface_counters,
476 .admin_up_down_function = ssvm_eth_interface_admin_up_down,
477 .subif_add_del_function = ssvm_eth_subif_add_del_function,
478 .rx_redirect_to_node = ssvm_eth_set_interface_next_node,
481 VLIB_DEVICE_TX_FUNCTION_MULTIARCH (ssvm_eth_device_class,
482 ssvm_eth_interface_tx)
486 * fd.io coding-style-patch-verification: ON
489 * eval: (c-set-style "gnu")