2 * Copyright (c) 2020 Cisco and/or its affiliates.
3 * Copyright (c) 2020 Doc.ai 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 <wireguard/wireguard.h>
18 #include <wireguard/wireguard_peer.h>
20 #define foreach_wg_handoff_error \
21 _(CONGESTION_DROP, "congestion drop")
25 #define _(sym,str) WG_HANDOFF_ERROR_##sym,
26 foreach_wg_handoff_error
29 } ipsec_handoff_error_t;
31 static char *wg_handoff_error_strings[] = {
32 #define _(sym,string) string,
33 foreach_wg_handoff_error
44 typedef struct wg_handoff_trace_t_
46 u32 next_worker_index;
51 format_wg_handoff_trace (u8 * s, va_list * args)
53 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
54 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
55 wg_handoff_trace_t *t = va_arg (*args, wg_handoff_trace_t *);
57 s = format (s, "next-worker %d peer %d", t->next_worker_index, t->peer);
62 static_always_inline uword
63 wg_handoff (vlib_main_t * vm,
64 vlib_node_runtime_t * node,
65 vlib_frame_t * frame, u32 fq_index, wg_handoff_mode_t mode)
67 vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
68 u16 thread_indices[VLIB_FRAME_SIZE], *ti;
69 u32 n_enq, n_left_from, *from;
73 from = vlib_frame_vector_args (frame);
74 n_left_from = frame->n_vectors;
75 vlib_get_buffers (vm, from, bufs, n_left_from);
80 while (n_left_from > 0)
82 const wg_peer_t *peer;
83 index_t peeri = INDEX_INVALID;
85 if (PREDICT_FALSE (mode == WG_HANDOFF_HANDSHAKE))
89 else if (mode == WG_HANDOFF_INP_DATA)
91 message_data_t *data = vlib_buffer_get_current (b[0]);
93 wg_index_table_lookup (&wmp->index_table, data->receiver_index);
95 peer = wg_peer_get (peeri);
97 ti[0] = peer->input_thread_index;
102 wg_peer_get_by_adj_index (vnet_buffer (b[0])->
103 ip.adj_index[VLIB_TX]);
104 peer = wg_peer_get (peeri);
105 ti[0] = peer->output_thread_index;
108 if (PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED))
110 wg_handoff_trace_t *t =
111 vlib_add_trace (vm, node, b[0], sizeof (*t));
112 t->next_worker_index = ti[0];
121 n_enq = vlib_buffer_enqueue_to_thread (vm, node, fq_index, from,
122 thread_indices, frame->n_vectors, 1);
124 if (n_enq < frame->n_vectors)
125 vlib_node_increment_counter (vm, node->node_index,
126 WG_HANDOFF_ERROR_CONGESTION_DROP,
127 frame->n_vectors - n_enq);
132 VLIB_NODE_FN (wg4_handshake_handoff)
133 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
135 wg_main_t *wmp = &wg_main;
137 return wg_handoff (vm, node, from_frame, wmp->in4_fq_index,
138 WG_HANDOFF_HANDSHAKE);
141 VLIB_NODE_FN (wg6_handshake_handoff)
142 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
144 wg_main_t *wmp = &wg_main;
146 return wg_handoff (vm, node, from_frame, wmp->in6_fq_index,
147 WG_HANDOFF_HANDSHAKE);
150 VLIB_NODE_FN (wg4_input_data_handoff)
151 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
153 wg_main_t *wmp = &wg_main;
155 return wg_handoff (vm, node, from_frame, wmp->in4_fq_index,
156 WG_HANDOFF_INP_DATA);
159 VLIB_NODE_FN (wg6_input_data_handoff)
160 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
162 wg_main_t *wmp = &wg_main;
164 return wg_handoff (vm, node, from_frame, wmp->in6_fq_index,
165 WG_HANDOFF_INP_DATA);
168 VLIB_NODE_FN (wg4_output_tun_handoff)
169 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
171 wg_main_t *wmp = &wg_main;
173 return wg_handoff (vm, node, from_frame, wmp->out4_fq_index,
177 VLIB_NODE_FN (wg6_output_tun_handoff)
178 (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
180 wg_main_t *wmp = &wg_main;
182 return wg_handoff (vm, node, from_frame, wmp->out6_fq_index,
187 VLIB_REGISTER_NODE (wg4_handshake_handoff) =
189 .name = "wg4-handshake-handoff",
190 .vector_size = sizeof (u32),
191 .format_trace = format_wg_handoff_trace,
192 .type = VLIB_NODE_TYPE_INTERNAL,
193 .n_errors = ARRAY_LEN (wg_handoff_error_strings),
194 .error_strings = wg_handoff_error_strings,
201 VLIB_REGISTER_NODE (wg6_handshake_handoff) =
203 .name = "wg6-handshake-handoff",
204 .vector_size = sizeof (u32),
205 .format_trace = format_wg_handoff_trace,
206 .type = VLIB_NODE_TYPE_INTERNAL,
207 .n_errors = ARRAY_LEN (wg_handoff_error_strings),
208 .error_strings = wg_handoff_error_strings,
215 VLIB_REGISTER_NODE (wg4_input_data_handoff) =
217 .name = "wg4-input-data-handoff",
218 .vector_size = sizeof (u32),
219 .format_trace = format_wg_handoff_trace,
220 .type = VLIB_NODE_TYPE_INTERNAL,
221 .n_errors = ARRAY_LEN (wg_handoff_error_strings),
222 .error_strings = wg_handoff_error_strings,
229 VLIB_REGISTER_NODE (wg6_input_data_handoff) =
231 .name = "wg6-input-data-handoff",
232 .vector_size = sizeof (u32),
233 .format_trace = format_wg_handoff_trace,
234 .type = VLIB_NODE_TYPE_INTERNAL,
235 .n_errors = ARRAY_LEN (wg_handoff_error_strings),
236 .error_strings = wg_handoff_error_strings,
243 VLIB_REGISTER_NODE (wg4_output_tun_handoff) =
245 .name = "wg4-output-tun-handoff",
246 .vector_size = sizeof (u32),
247 .format_trace = format_wg_handoff_trace,
248 .type = VLIB_NODE_TYPE_INTERNAL,
249 .n_errors = ARRAY_LEN (wg_handoff_error_strings),
250 .error_strings = wg_handoff_error_strings,
257 VLIB_REGISTER_NODE (wg6_output_tun_handoff) =
259 .name = "wg6-output-tun-handoff",
260 .vector_size = sizeof (u32),
261 .format_trace = format_wg_handoff_trace,
262 .type = VLIB_NODE_TYPE_INTERNAL,
263 .n_errors = ARRAY_LEN (wg_handoff_error_strings),
264 .error_strings = wg_handoff_error_strings,
273 * fd.io coding-style-patch-verification: ON
276 * eval: (c-set-style "gnu")