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)")
25 #define _(f,s) SSVM_ETH_TX_ERROR_##f,
26 foreach_ssvm_eth_tx_func_error
29 } ssvm_eth_tx_func_error_t;
31 static u32 ssvm_eth_flag_change (vnet_main_t * vnm,
32 vnet_hw_interface_t * hi,
35 int ssvm_eth_create (ssvm_eth_main_t * em, u8 * name, int is_master)
37 ssvm_private_t * intfc;
40 unix_shared_memory_queue_t * q;
41 ssvm_shared_header_t * sh;
42 ssvm_eth_queue_elt_t * elts;
47 vec_add2 (em->intfcs, intfc, 1);
49 intfc->ssvm_size = em->segment_size;
50 intfc->i_am_master = 1;
52 intfc->my_pid = getpid();
55 rv = ssvm_slave_init (intfc, 20 /* timeout in seconds */);
58 goto create_vnet_interface;
61 intfc->requested_va = em->next_base_va;
62 em->next_base_va += em->segment_size;
63 rv = ssvm_master_init (intfc, intfc - em->intfcs /* master index */);
68 /* OK, segment created, set up queues and so forth. */
71 oldheap = ssvm_push_heap (sh);
73 q = unix_shared_memory_queue_init (em->queue_elts, sizeof (u32),
74 0 /* consumer pid not interesting */,
75 0 /* signal not sent */);
76 sh->opaque [TO_MASTER_Q_INDEX] = (void *)q;
77 q = unix_shared_memory_queue_init (em->queue_elts, sizeof (u32),
78 0 /* consumer pid not interesting */,
79 0 /* signal not sent */);
80 sh->opaque [TO_SLAVE_Q_INDEX] = (void *)q;
83 * Preallocate the requested number of buffer chunks
84 * There must be a better way to do this, etc.
85 * Add some slop to avoid pool reallocation, which will not go well
90 vec_validate_aligned (elts, em->nbuffers - 1, CLIB_CACHE_LINE_BYTES);
91 vec_validate_aligned (elt_indices, em->nbuffers - 1, CLIB_CACHE_LINE_BYTES);
93 for (i = 0; i < em->nbuffers; i++)
96 sh->opaque [CHUNK_POOL_INDEX] = (void *) elts;
97 sh->opaque [CHUNK_POOL_FREELIST_INDEX] = (void *) elt_indices;
98 sh->opaque [CHUNK_POOL_NFREE] = (void *)(uword) em->nbuffers;
100 ssvm_pop_heap (oldheap);
102 create_vnet_interface:
106 memset (enet_addr, 0, sizeof (enet_addr));
109 enet_addr[2] = is_master;
110 enet_addr[5] = sh->master_index;
112 e = ethernet_register_interface
113 (em->vnet_main, ssvm_eth_device_class.index,
115 /* ethernet address */ enet_addr,
116 &intfc->vlib_hw_if_index,
117 ssvm_eth_flag_change);
121 clib_error_report (e);
122 /* $$$$ unmap offending region? */
123 return VNET_API_ERROR_INVALID_INTERFACE;
126 /* Declare link up */
127 vnet_hw_interface_set_flags (em->vnet_main, intfc->vlib_hw_if_index,
128 VNET_HW_INTERFACE_FLAG_LINK_UP);
130 /* Let the games begin... */
136 static clib_error_t *
137 ssvm_config (vlib_main_t * vm, unformat_input_t * input)
142 ssvm_eth_main_t * em = &ssvm_eth_main;
144 while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT)
146 if (unformat (input, "base-va %llx", &em->next_base_va))
148 else if (unformat (input, "segment-size %lld", &em->segment_size))
149 em->segment_size = 1ULL << (max_log2 (em->segment_size));
150 else if (unformat (input, "nbuffers %lld", &em->nbuffers))
152 else if (unformat (input, "queue-elts %lld", &em->queue_elts))
154 else if (unformat (input, "slave"))
156 else if (unformat (input, "%s", &name))
157 vec_add1 (em->names, name);
162 /* No configured instances, we're done... */
163 if (vec_len (em->names) == 0)
166 for (i = 0; i < vec_len (em->names); i++)
168 rv = ssvm_eth_create (em, em->names[i], is_master);
170 return clib_error_return (0, "ssvm_eth_create '%s' failed, error %d",
174 vlib_node_set_state (vm, ssvm_eth_input_node.index, VLIB_NODE_STATE_POLLING);
179 VLIB_CONFIG_FUNCTION (ssvm_config, "ssvm_eth");
182 static clib_error_t * ssvm_eth_init (vlib_main_t * vm)
184 ssvm_eth_main_t * em = &ssvm_eth_main;
186 if (((sizeof(ssvm_eth_queue_elt_t) / CLIB_CACHE_LINE_BYTES)
187 * CLIB_CACHE_LINE_BYTES) != sizeof(ssvm_eth_queue_elt_t))
188 clib_warning ("ssvm_eth_queue_elt_t size %d not a multiple of %d",
189 sizeof(ssvm_eth_queue_elt_t), CLIB_CACHE_LINE_BYTES);
192 em->vnet_main = vnet_get_main();
193 em->elog_main = &vm->elog_main;
195 /* default config param values... */
197 em->next_base_va = 0x600000000ULL;
199 * Allocate 2 full superframes in each dir (256 x 2 x 2 x 2048 bytes),
200 * 2mb; double that so we have plenty of space... 4mb
202 em->segment_size = 8<<20;
204 em->queue_elts = 512;
208 VLIB_INIT_FUNCTION (ssvm_eth_init);
210 static char * ssvm_eth_tx_func_error_strings[] = {
212 foreach_ssvm_eth_tx_func_error
216 static u8 * format_ssvm_eth_device_name (u8 * s, va_list * args)
218 u32 i = va_arg (*args, u32);
220 s = format (s, "ssvmEthernet%d", i);
224 static u8 * format_ssvm_eth_device (u8 * s, va_list * args)
226 s = format (s, "SSVM Ethernet");
230 static u8 * format_ssvm_eth_tx_trace (u8 * s, va_list * args)
232 s = format (s, "Unimplemented...");
238 ssvm_eth_interface_tx (vlib_main_t * vm,
239 vlib_node_runtime_t * node,
242 ssvm_eth_main_t * em = &ssvm_eth_main;
243 vnet_interface_output_runtime_t * rd = (void *) node->runtime_data;
244 ssvm_private_t * intfc = vec_elt_at_index (em->intfcs, rd->dev_instance);
245 ssvm_shared_header_t * sh = intfc->sh;
246 unix_shared_memory_queue_t * q;
249 ssvm_eth_queue_elt_t * elts, * elt, * prev_elt;
250 u32 my_pid = intfc->my_pid;
253 u32 size_this_buffer;
254 u32 chunks_this_buffer;
255 u8 i_am_master = intfc->i_am_master;
257 int is_ring_full, interface_down;
259 volatile u32 *queue_lock;
260 u32 n_to_alloc = VLIB_FRAME_SIZE;
261 u32 n_allocated, n_present_in_cache, n_available;
265 q = (unix_shared_memory_queue_t *)sh->opaque [TO_SLAVE_Q_INDEX];
267 q = (unix_shared_memory_queue_t *)sh->opaque [TO_MASTER_Q_INDEX];
269 queue_lock = (u32 *) q;
271 from = vlib_frame_vector_args (f);
272 n_left = f->n_vectors;
276 n_present_in_cache = vec_len (em->chunk_cache);
278 /* admin / link up/down check */
279 if (sh->opaque [MASTER_ADMIN_STATE_INDEX] == 0 ||
280 sh->opaque [SLAVE_ADMIN_STATE_INDEX] == 0)
286 ssvm_lock (sh, my_pid, 1);
288 elts = (ssvm_eth_queue_elt_t *) (sh->opaque [CHUNK_POOL_INDEX]);
289 elt_indices = (u32 *) (sh->opaque [CHUNK_POOL_FREELIST_INDEX]);
290 n_available = (u32) pointer_to_uword(sh->opaque [CHUNK_POOL_NFREE]);
292 if (n_present_in_cache < n_left*2)
294 vec_validate (em->chunk_cache,
295 n_to_alloc + n_present_in_cache - 1);
297 n_allocated = n_to_alloc < n_available ? n_to_alloc : n_available;
299 if (PREDICT_TRUE(n_allocated > 0))
301 memcpy (&em->chunk_cache[n_present_in_cache],
302 &elt_indices[n_available - n_allocated],
303 sizeof(u32) * n_allocated);
306 n_present_in_cache += n_allocated;
307 n_available -= n_allocated;
308 sh->opaque [CHUNK_POOL_NFREE] = uword_to_pointer(n_available, void*);
309 _vec_len (em->chunk_cache) = n_present_in_cache;
317 b0 = vlib_get_buffer (vm, bi0);
319 size_this_buffer = vlib_buffer_length_in_chain (vm, b0);
320 chunks_this_buffer = (size_this_buffer + (SSVM_BUFFER_SIZE - 1))
323 /* If we're not going to be able to enqueue the buffer, tail drop. */
324 if (q->cursize >= q->maxsize)
332 for (i = 0; i < chunks_this_buffer; i++)
334 if (PREDICT_FALSE (n_present_in_cache == 0))
337 elt_index = em->chunk_cache[--n_present_in_cache];
338 elt = elts + elt_index;
340 elt->type = SSVM_PACKET_TYPE;
342 elt->total_length_not_including_first_buffer =
343 b0->total_length_not_including_first_buffer;
344 elt->length_this_buffer = b0->current_length;
345 elt->current_data_hint = b0->current_data;
346 elt->owner = !i_am_master;
349 memcpy (elt->data, b0->data + b0->current_data, b0->current_length);
351 if (PREDICT_FALSE (prev_elt != 0))
352 prev_elt->next_index = elt - elts;
354 if (PREDICT_FALSE(i < (chunks_this_buffer-1)))
356 elt->flags = SSVM_BUFFER_NEXT_PRESENT;
357 ASSERT (b0->flags & VLIB_BUFFER_NEXT_PRESENT);
358 b0 = vlib_get_buffer (vm, b0->next_buffer);
363 while (__sync_lock_test_and_set (queue_lock, 1))
366 unix_shared_memory_queue_add_raw (q, (u8 *)&elt_index);
367 CLIB_MEMORY_BARRIER();
375 if (PREDICT_FALSE(n_left))
378 vlib_error_count (vm, node->node_index, SSVM_ETH_TX_ERROR_RING_FULL,
380 else if (interface_down)
381 vlib_error_count (vm, node->node_index, SSVM_ETH_TX_ERROR_ADMIN_DOWN,
384 vlib_error_count (vm, node->node_index, SSVM_ETH_TX_ERROR_NO_BUFFERS,
387 vlib_buffer_free (vm, from, n_left);
390 vlib_buffer_free (vm, vlib_frame_vector_args (f), f->n_vectors);
392 if (PREDICT_TRUE(vec_len(em->chunk_cache)))
393 _vec_len(em->chunk_cache) = n_present_in_cache;
398 static void ssvm_eth_clear_hw_interface_counters (u32 instance)
400 /* Nothing for now */
403 static clib_error_t *
404 ssvm_eth_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
406 vnet_hw_interface_t * hif = vnet_get_hw_interface (vnm, hw_if_index);
407 uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
408 ssvm_eth_main_t * em = &ssvm_eth_main;
409 ssvm_private_t * intfc = vec_elt_at_index (em->intfcs, hif->dev_instance);
410 ssvm_shared_header_t * sh;
412 /* publish link-state in shared-memory, to discourage buffer-wasting */
414 if (intfc->i_am_master)
415 sh->opaque [MASTER_ADMIN_STATE_INDEX] = (void *) is_up;
417 sh->opaque [SLAVE_ADMIN_STATE_INDEX] = (void *) is_up;
422 static clib_error_t *
423 ssvm_eth_subif_add_del_function (vnet_main_t * vnm,
425 struct vnet_sw_interface_t * st,
428 /* Nothing for now */
433 * Dynamically redirect all pkts from a specific interface
434 * to the specified node
437 ssvm_eth_set_interface_next_node (vnet_main_t *vnm, u32 hw_if_index,
440 ssvm_eth_main_t * em = &ssvm_eth_main;
441 vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
442 ssvm_private_t * intfc = pool_elt_at_index (em->intfcs, hw->dev_instance);
444 /* Shut off redirection */
445 if (node_index == ~0)
447 intfc->per_interface_next_index = node_index;
451 intfc->per_interface_next_index =
452 vlib_node_add_next (em->vlib_main, ssvm_eth_input_node.index, node_index);
455 static u32 ssvm_eth_flag_change (vnet_main_t * vnm,
456 vnet_hw_interface_t * hi,
459 /* nothing for now */
463 VNET_DEVICE_CLASS (ssvm_eth_device_class) = {
465 .tx_function = ssvm_eth_interface_tx,
466 .tx_function_n_errors = SSVM_ETH_TX_N_ERROR,
467 .tx_function_error_strings = ssvm_eth_tx_func_error_strings,
468 .format_device_name = format_ssvm_eth_device_name,
469 .format_device = format_ssvm_eth_device,
470 .format_tx_trace = format_ssvm_eth_tx_trace,
471 .clear_counters = ssvm_eth_clear_hw_interface_counters,
472 .admin_up_down_function = ssvm_eth_interface_admin_up_down,
473 .subif_add_del_function = ssvm_eth_subif_add_del_function,
474 .rx_redirect_to_node = ssvm_eth_set_interface_next_node,
475 .no_flatten_output_chains = 1,