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.
17 #include <vnet/vnet.h>
18 #include <vppinfra/xxhash.h>
19 #include <vlib/threads.h>
20 #include <vnet/handoff.h>
21 #include <vnet/feature/feature.h>
25 uword *workers_bitmap;
27 } per_inteface_handoff_data_t;
31 u32 cached_next_index;
33 u32 first_worker_index;
35 per_inteface_handoff_data_t *if_data;
37 /* Worker handoff index */
38 u32 frame_queue_index;
40 u64 (*hash_fn) (ethernet_header_t *);
43 handoff_main_t handoff_main;
48 u32 next_worker_index;
50 } worker_handoff_trace_t;
52 /* packet trace format function */
54 format_worker_handoff_trace (u8 * s, va_list * args)
56 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
57 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
58 worker_handoff_trace_t *t = va_arg (*args, worker_handoff_trace_t *);
61 format (s, "worker-handoff: sw_if_index %d, next_worker %d, buffer 0x%x",
62 t->sw_if_index, t->next_worker_index, t->buffer_index);
66 vlib_node_registration_t handoff_node;
69 worker_handoff_node_fn (vlib_main_t * vm,
70 vlib_node_runtime_t * node, vlib_frame_t * frame)
72 handoff_main_t *hm = &handoff_main;
73 vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
74 u32 n_left_from, *from;
75 u16 thread_indices[VLIB_FRAME_SIZE], *ti;
77 from = vlib_frame_vector_args (frame);
78 n_left_from = frame->n_vectors;
79 vlib_get_buffers (vm, from, bufs, n_left_from);
84 while (n_left_from > 0)
89 per_inteface_handoff_data_t *ihd0;
93 sw_if_index0 = vnet_buffer (b[0])->sw_if_index[VLIB_RX];
95 ihd0 = vec_elt_at_index (hm->if_data, sw_if_index0);
98 * Force unknown traffic onto worker 0,
99 * and into ethernet-input. $$$$ add more hashes.
102 /* Compute ingress LB hash */
103 hash_key = hm->hash_fn ((ethernet_header_t *)
104 vlib_buffer_get_current (b[0]));
105 hash = (u32) clib_xxhash (hash_key);
107 /* if input node did not specify next index, then packet
108 should go to eternet-input */
110 if (PREDICT_TRUE (is_pow2 (vec_len (ihd0->workers))))
111 index0 = hash & (vec_len (ihd0->workers) - 1);
113 index0 = hash % vec_len (ihd0->workers);
115 ti[0] = hm->first_worker_index + ihd0->workers[index0];
117 if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
118 && (b[0]->flags & VLIB_BUFFER_IS_TRACED)))
120 worker_handoff_trace_t *t =
121 vlib_add_trace (vm, node, b[0], sizeof (*t));
122 t->sw_if_index = sw_if_index0;
123 t->next_worker_index = ti[0];
124 t->buffer_index = vlib_get_buffer_index (vm, b[0]);
133 vlib_buffer_enqueue_to_thread (vm, hm->frame_queue_index, from,
134 thread_indices, frame->n_vectors);
135 return frame->n_vectors;
139 VLIB_REGISTER_NODE (worker_handoff_node) = {
140 .function = worker_handoff_node_fn,
141 .name = "worker-handoff",
142 .vector_size = sizeof (u32),
143 .format_trace = format_worker_handoff_trace,
144 .type = VLIB_NODE_TYPE_INTERNAL,
152 VLIB_NODE_FUNCTION_MULTIARCH (worker_handoff_node, worker_handoff_node_fn)
156 interface_handoff_enable_disable (vlib_main_t * vm, u32 sw_if_index,
157 uword * bitmap, int enable_disable)
159 handoff_main_t *hm = &handoff_main;
160 vnet_sw_interface_t *sw;
161 vnet_main_t *vnm = vnet_get_main ();
162 per_inteface_handoff_data_t *d;
165 if (pool_is_free_index (vnm->interface_main.sw_interfaces, sw_if_index))
166 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
168 sw = vnet_get_sw_interface (vnm, sw_if_index);
169 if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
170 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
172 if (clib_bitmap_last_set (bitmap) >= hm->num_workers)
173 return VNET_API_ERROR_INVALID_WORKER;
175 if (hm->frame_queue_index == ~0)
177 vlib_node_t *n = vlib_get_node_by_name (vm, (u8 *) "ethernet-input");
178 hm->frame_queue_index = vlib_frame_queue_main_init (n->index, 0);
181 vec_validate (hm->if_data, sw_if_index);
182 d = vec_elt_at_index (hm->if_data, sw_if_index);
184 vec_free (d->workers);
185 vec_free (d->workers_bitmap);
189 d->workers_bitmap = bitmap;
191 clib_bitmap_foreach (i, bitmap,
193 vec_add1(d->workers, i);
198 vnet_feature_enable_disable ("device-input", "worker-handoff",
199 sw_if_index, enable_disable, 0, 0);
203 static clib_error_t *
204 set_interface_handoff_command_fn (vlib_main_t * vm,
205 unformat_input_t * input,
206 vlib_cli_command_t * cmd)
208 handoff_main_t *hm = &handoff_main;
209 u32 sw_if_index = ~0;
210 int enable_disable = 1;
216 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
218 if (unformat (input, "disable"))
220 else if (unformat (input, "workers %U", unformat_bitmap_list, &bitmap))
222 else if (unformat (input, "%U", unformat_vnet_sw_interface,
223 vnet_get_main (), &sw_if_index))
225 else if (unformat (input, "symmetrical"))
227 else if (unformat (input, "asymmetrical"))
233 if (sw_if_index == ~0)
234 return clib_error_return (0, "Please specify an interface...");
237 return clib_error_return (0, "Please specify list of workers...");
240 interface_handoff_enable_disable (vm, sw_if_index, bitmap,
248 case VNET_API_ERROR_INVALID_SW_IF_INDEX:
249 return clib_error_return (0, "Invalid interface");
252 case VNET_API_ERROR_INVALID_WORKER:
253 return clib_error_return (0, "Invalid worker(s)");
256 case VNET_API_ERROR_UNIMPLEMENTED:
257 return clib_error_return (0,
258 "Device driver doesn't support redirection");
262 return clib_error_return (0, "unknown return value %d", rv);
266 hm->hash_fn = eth_get_sym_key;
268 hm->hash_fn = eth_get_key;
274 VLIB_CLI_COMMAND (set_interface_handoff_command, static) = {
275 .path = "set interface handoff",
277 "set interface handoff <interface-name> workers <workers-list> [symmetrical|asymmetrical]",
278 .function = set_interface_handoff_command_fn,
283 handoff_init (vlib_main_t * vm)
285 handoff_main_t *hm = &handoff_main;
286 vlib_thread_main_t *tm = vlib_get_thread_main ();
290 if ((error = vlib_call_init_function (vm, threads_init)))
293 vlib_thread_registration_t *tr;
294 /* Only the standard vnet worker threads are supported */
295 p = hash_get_mem (tm->thread_registrations_by_name, "workers");
298 tr = (vlib_thread_registration_t *) p[0];
301 hm->num_workers = tr->count;
302 hm->first_worker_index = tr->first_index;
306 hm->hash_fn = eth_get_key;
307 hm->frame_queue_index = ~0;
312 VLIB_INIT_FUNCTION (handoff_init);
315 * fd.io coding-style-patch-verification: ON
318 * eval: (c-set-style "gnu")