src/plugins/wireguard/wireguard_handoff.c

   1 /*
   2  * Copyright (c) 2020 Doc.ai 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:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   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.
  14  */
  15
  16 #include <wireguard/wireguard.h>
  17 #include <wireguard/wireguard_peer.h>
  18
  19 #define foreach_wg_handoff_error  \
  20 _(CONGESTION_DROP, "congestion drop")
  21
  22 typedef enum
  23 {
  24 #define _(sym,str) WG_HANDOFF_ERROR_##sym,
  25   foreach_wg_handoff_error
  26 #undef _
  27     HANDOFF_N_ERROR,
  28 } ipsec_handoff_error_t;
  29
  30 static char *wg_handoff_error_strings[] = {
  31 #define _(sym,string) string,
  32   foreach_wg_handoff_error
  33 #undef _
  34 };
  35
  36 typedef enum
  37 {
  38   WG_HANDOFF_HANDSHAKE,
  39   WG_HANDOFF_INP_DATA,
  40   WG_HANDOFF_OUT_TUN,
  41 } wg_handoff_mode_t;
  42
  43 typedef struct wg_handoff_trace_t_
  44 {
  45   u32 next_worker_index;
  46   index_t peer;
  47 } wg_handoff_trace_t;
  48
  49 static u8 *
  50 format_wg_handoff_trace (u8 * s, va_list * args)
  51 {
  52   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  53   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  54   wg_handoff_trace_t *t = va_arg (*args, wg_handoff_trace_t *);
  55
  56   s = format (s, "next-worker %d peer %d", t->next_worker_index, t->peer);
  57
  58   return s;
  59 }
  60
  61 static_always_inline uword
  62 wg_handoff (vlib_main_t * vm,
  63             vlib_node_runtime_t * node,
  64             vlib_frame_t * frame, u32 fq_index, wg_handoff_mode_t mode)
  65 {
  66   vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
  67   u16 thread_indices[VLIB_FRAME_SIZE], *ti;
  68   u32 n_enq, n_left_from, *from;
  69   wg_main_t *wmp;
  70
  71   wmp = &wg_main;
  72   from = vlib_frame_vector_args (frame);
  73   n_left_from = frame->n_vectors;
  74   vlib_get_buffers (vm, from, bufs, n_left_from);
  75
  76   b = bufs;
  77   ti = thread_indices;
  78
  79   while (n_left_from > 0)
  80     {
  81       const wg_peer_t *peer;
  82       index_t peeri;
  83
  84       if (PREDICT_FALSE (mode == WG_HANDOFF_HANDSHAKE))
  85         {
  86           ti[0] = 0;
  87         }
  88       else if (mode == WG_HANDOFF_INP_DATA)
  89         {
  90           message_data_t *data = vlib_buffer_get_current (b[0]);
  91           u32 *entry =
  92             wg_index_table_lookup (&wmp->index_table, data->receiver_index);
  93           peeri = *entry;
  94           peer = wg_peer_get (peeri);
  95
  96           ti[0] = peer->input_thread_index;
  97         }
  98       else
  99         {
 100           peeri =
 101             wg_peer_get_by_adj_index (vnet_buffer (b[0])->
 102                                       ip.adj_index[VLIB_TX]);
 103           peer = wg_peer_get (peeri);
 104           ti[0] = peer->output_thread_index;
 105         }
 106
 107       if (PREDICT_FALSE (b[0]->flags & VLIB_BUFFER_IS_TRACED))
 108         {
 109           wg_handoff_trace_t *t =
 110             vlib_add_trace (vm, node, b[0], sizeof (*t));
 111           t->next_worker_index = ti[0];
 112           t->peer = peeri;
 113         }
 114
 115       n_left_from -= 1;
 116       ti += 1;
 117       b += 1;
 118     }
 119
 120   n_enq = vlib_buffer_enqueue_to_thread (vm, fq_index, from,
 121                                          thread_indices, frame->n_vectors, 1);
 122
 123   if (n_enq < frame->n_vectors)
 124     vlib_node_increment_counter (vm, node->node_index,
 125                                  WG_HANDOFF_ERROR_CONGESTION_DROP,
 126                                  frame->n_vectors - n_enq);
 127
 128   return n_enq;
 129 }
 130
 131 VLIB_NODE_FN (wg_handshake_handoff) (vlib_main_t * vm,
 132                                      vlib_node_runtime_t * node,
 133                                      vlib_frame_t * from_frame)
 134 {
 135   wg_main_t *wmp = &wg_main;
 136
 137   return wg_handoff (vm, node, from_frame, wmp->in_fq_index,
 138                      WG_HANDOFF_HANDSHAKE);
 139 }
 140
 141 VLIB_NODE_FN (wg_input_data_handoff) (vlib_main_t * vm,
 142                                       vlib_node_runtime_t * node,
 143                                       vlib_frame_t * from_frame)
 144 {
 145   wg_main_t *wmp = &wg_main;
 146
 147   return wg_handoff (vm, node, from_frame, wmp->in_fq_index,
 148                      WG_HANDOFF_INP_DATA);
 149 }
 150
 151 VLIB_NODE_FN (wg_output_tun_handoff) (vlib_main_t * vm,
 152                                       vlib_node_runtime_t * node,
 153                                       vlib_frame_t * from_frame)
 154 {
 155   wg_main_t *wmp = &wg_main;
 156
 157   return wg_handoff (vm, node, from_frame, wmp->out_fq_index,
 158                      WG_HANDOFF_OUT_TUN);
 159 }
 160
 161 VLIB_REGISTER_NODE (wg_handshake_handoff) =
 162 {
 163   .name = "wg-handshake-handoff",.vector_size = sizeof (u32),.format_trace =
 164     format_wg_handoff_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
 165     ARRAY_LEN (wg_handoff_error_strings),.error_strings =
 166     wg_handoff_error_strings,.n_next_nodes = 1,.next_nodes =
 167   {
 168   [0] = "error-drop",}
 169 ,};
 170
 171 VLIB_REGISTER_NODE (wg_input_data_handoff) =
 172 {
 173   .name = "wg-input-data-handoff",.vector_size = sizeof (u32),.format_trace =
 174     format_wg_handoff_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
 175     ARRAY_LEN (wg_handoff_error_strings),.error_strings =
 176     wg_handoff_error_strings,.n_next_nodes = 1,.next_nodes =
 177   {
 178   [0] = "error-drop",}
 179 ,};
 180
 181 VLIB_REGISTER_NODE (wg_output_tun_handoff) =
 182 {
 183   .name = "wg-output-tun-handoff",.vector_size = sizeof (u32),.format_trace =
 184     format_wg_handoff_trace,.type = VLIB_NODE_TYPE_INTERNAL,.n_errors =
 185     ARRAY_LEN (wg_handoff_error_strings),.error_strings =
 186     wg_handoff_error_strings,.n_next_nodes = 1,.next_nodes =
 187   {
 188   [0] = "error-drop",}
 189 ,};
 190
 191 /*
 192  * fd.io coding-style-patch-verification: ON
 193  *
 194  * Local Variables:
 195  * eval: (c-set-style "gnu")
 196  * End:
 197  */