src/plugins/dpdk/ipsec/crypto_node.c

   1 /*
   2  *------------------------------------------------------------------
   3  * crypto_node.c - DPDK Cryptodev input node
   4  *
   5  * Copyright (c) 2017 Intel and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a opy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <vlib/vlib.h>
  21 #include <vnet/ip/ip.h>
  22 #include <vnet/ethernet/ethernet.h>
  23 #include <vnet/ipsec/ipsec.h>
  24
  25 #include <dpdk/buffer.h>
  26 #include <dpdk/device/dpdk.h>
  27 #include <dpdk/device/dpdk_priv.h>
  28 #include <dpdk/ipsec/ipsec.h>
  29
  30 #define foreach_dpdk_crypto_input_error         \
  31   _(DQ_COPS, "Crypto ops dequeued")             \
  32   _(AUTH_FAILED, "Crypto verification failed")        \
  33   _(STATUS, "Crypto operation failed")
  34
  35 typedef enum
  36 {
  37 #define _(f,s) DPDK_CRYPTO_INPUT_ERROR_##f,
  38   foreach_dpdk_crypto_input_error
  39 #undef _
  40     DPDK_CRYPTO_INPUT_N_ERROR,
  41 } dpdk_crypto_input_error_t;
  42
  43 static char *dpdk_crypto_input_error_strings[] = {
  44 #define _(n, s) s,
  45   foreach_dpdk_crypto_input_error
  46 #undef _
  47 };
  48
  49 extern vlib_node_registration_t dpdk_crypto_input_node;
  50
  51 typedef struct
  52 {
  53   u32 status;
  54 } dpdk_crypto_input_trace_t;
  55
  56 #define foreach_cryptodev_status \
  57     _(SUCCESS, "success") \
  58     _(NOT_PROCESSED, "not processed") \
  59     _(AUTH_FAILED, "auth failed") \
  60     _(INVALID_SESSION, "invalid session") \
  61     _(INVALID_ARGS, "invalid arguments") \
  62     _(ERROR, "error")
  63
  64 static u8 *
  65 format_cryptodev_status (u8 * s, va_list * args)
  66 {
  67   u32 status = va_arg (*args, u32);
  68   char *str = 0;
  69
  70   switch (status)
  71     {
  72 #define _(x, z) case RTE_CRYPTO_OP_STATUS_##x: str = z; break;
  73       foreach_cryptodev_status
  74 #undef _
  75     }
  76   s = format (s, "%s", str);
  77
  78   return s;
  79 }
  80
  81 static u8 *
  82 format_dpdk_crypto_input_trace (u8 * s, va_list * args)
  83 {
  84   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
  85   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
  86   dpdk_crypto_input_trace_t *t = va_arg (*args, dpdk_crypto_input_trace_t *);
  87
  88   s = format (s, "status: %U", format_cryptodev_status, t->status);
  89
  90   return s;
  91 }
  92
  93 static_always_inline void
  94 dpdk_crypto_input_check_op (vlib_main_t * vm, vlib_node_runtime_t * node,
  95                             struct rte_crypto_op *op0, u16 * next)
  96 {
  97   if (PREDICT_FALSE (op0->status != RTE_CRYPTO_OP_STATUS_SUCCESS))
  98     {
  99       next[0] = DPDK_CRYPTO_INPUT_NEXT_DROP;
 100       vlib_node_increment_counter (vm,
 101                                    node->node_index,
 102                                    DPDK_CRYPTO_INPUT_ERROR_STATUS, 1);
 103       /* if auth failed */
 104       if (op0->status == RTE_CRYPTO_OP_STATUS_AUTH_FAILED)
 105         vlib_node_increment_counter (vm,
 106                                      node->node_index,
 107                                      DPDK_CRYPTO_INPUT_ERROR_AUTH_FAILED, 1);
 108     }
 109 }
 110
 111 always_inline void
 112 dpdk_crypto_input_trace (vlib_main_t * vm, vlib_node_runtime_t * node,
 113                          struct rte_crypto_op **ops, u32 n_deq)
 114 {
 115   u32 n_left, n_trace;
 116   if (PREDICT_FALSE ((n_trace = vlib_get_trace_count (vm, node))))
 117     {
 118       n_left = n_deq;
 119
 120       while (n_trace && n_left)
 121         {
 122           vlib_buffer_t *b0;
 123           struct rte_crypto_op *op0;
 124           u16 next;
 125
 126           op0 = ops[0];
 127
 128           next = crypto_op_get_priv (op0)->next;
 129
 130           b0 = vlib_buffer_from_rte_mbuf (op0->sym[0].m_src);
 131
 132           vlib_trace_buffer (vm, node, next, b0, /* follow_chain */ 0);
 133
 134           dpdk_crypto_input_trace_t *tr =
 135             vlib_add_trace (vm, node, b0, sizeof (*tr));
 136           tr->status = op0->status;
 137
 138           n_trace--;
 139           n_left--;
 140           ops++;
 141         }
 142       vlib_set_trace_count (vm, node, n_trace);
 143     }
 144 }
 145
 146 static_always_inline u32
 147 dpdk_crypto_dequeue (vlib_main_t * vm, vlib_node_runtime_t * node,
 148                      crypto_resource_t * res, u8 outbound)
 149 {
 150   u32 thread_idx = vlib_get_thread_index ();
 151   u8 numa = rte_socket_id ();
 152
 153   dpdk_crypto_main_t *dcm = &dpdk_crypto_main;
 154   crypto_worker_main_t *cwm =
 155     vec_elt_at_index (dcm->workers_main, thread_idx);
 156
 157   u32 n_ops, n_deq;
 158   u32 bis[VLIB_FRAME_SIZE], *bi;
 159   u16 nexts[VLIB_FRAME_SIZE], *next;
 160   struct rte_crypto_op **ops;
 161
 162   bi = bis;
 163   next = nexts;
 164   ops = cwm->ops;
 165
 166   n_ops = n_deq = rte_cryptodev_dequeue_burst (res->dev_id,
 167                                                res->qp_id + outbound,
 168                                                ops, VLIB_FRAME_SIZE);
 169
 170   res->inflights[outbound] -= n_ops;
 171
 172   dpdk_crypto_input_trace (vm, node, ops, n_deq);
 173
 174   while (n_ops >= 4)
 175     {
 176       struct rte_crypto_op *op0, *op1, *op2, *op3;
 177       vlib_buffer_t *b0, *b1, *b2, *b3;
 178
 179       /* Prefetch next iteration. */
 180       if (n_ops >= 8)
 181         {
 182           CLIB_PREFETCH (ops[4], CLIB_CACHE_LINE_BYTES, LOAD);
 183           CLIB_PREFETCH (ops[5], CLIB_CACHE_LINE_BYTES, LOAD);
 184           CLIB_PREFETCH (ops[6], CLIB_CACHE_LINE_BYTES, LOAD);
 185           CLIB_PREFETCH (ops[7], CLIB_CACHE_LINE_BYTES, LOAD);
 186
 187           CLIB_PREFETCH (crypto_op_get_priv (ops[4]), CLIB_CACHE_LINE_BYTES,
 188                          LOAD);
 189           CLIB_PREFETCH (crypto_op_get_priv (ops[5]), CLIB_CACHE_LINE_BYTES,
 190                          LOAD);
 191           CLIB_PREFETCH (crypto_op_get_priv (ops[6]), CLIB_CACHE_LINE_BYTES,
 192                          LOAD);
 193           CLIB_PREFETCH (crypto_op_get_priv (ops[7]), CLIB_CACHE_LINE_BYTES,
 194                          LOAD);
 195         }
 196
 197       op0 = ops[0];
 198       op1 = ops[1];
 199       op2 = ops[2];
 200       op3 = ops[3];
 201
 202       next[0] = crypto_op_get_priv (op0)->next;
 203       next[1] = crypto_op_get_priv (op1)->next;
 204       next[2] = crypto_op_get_priv (op2)->next;
 205       next[3] = crypto_op_get_priv (op3)->next;
 206
 207       dpdk_crypto_input_check_op (vm, node, op0, next + 0);
 208       dpdk_crypto_input_check_op (vm, node, op1, next + 1);
 209       dpdk_crypto_input_check_op (vm, node, op2, next + 2);
 210       dpdk_crypto_input_check_op (vm, node, op3, next + 3);
 211
 212       b0 = vlib_buffer_from_rte_mbuf (op0->sym[0].m_src);
 213       b1 = vlib_buffer_from_rte_mbuf (op1->sym[0].m_src);
 214       b2 = vlib_buffer_from_rte_mbuf (op2->sym[0].m_src);
 215       b3 = vlib_buffer_from_rte_mbuf (op3->sym[0].m_src);
 216
 217       bi[0] = vlib_get_buffer_index (vm, b0);
 218       bi[1] = vlib_get_buffer_index (vm, b1);
 219       bi[2] = vlib_get_buffer_index (vm, b2);
 220       bi[3] = vlib_get_buffer_index (vm, b3);
 221
 222       op0->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 223       op1->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 224       op2->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 225       op3->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 226
 227       /* next */
 228       next += 4;
 229       n_ops -= 4;
 230       ops += 4;
 231       bi += 4;
 232     }
 233   while (n_ops > 0)
 234     {
 235       struct rte_crypto_op *op0;
 236       vlib_buffer_t *b0;
 237
 238       op0 = ops[0];
 239
 240       next[0] = crypto_op_get_priv (op0)->next;
 241
 242       dpdk_crypto_input_check_op (vm, node, op0, next + 0);
 243
 244       /* XXX store bi0 and next0 in op0 private? */
 245       b0 = vlib_buffer_from_rte_mbuf (op0->sym[0].m_src);
 246       bi[0] = vlib_get_buffer_index (vm, b0);
 247
 248       op0->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 249
 250       /* next */
 251       next += 1;
 252       n_ops -= 1;
 253       ops += 1;
 254       bi += 1;
 255     }
 256
 257   vlib_node_increment_counter (vm, node->node_index,
 258                                DPDK_CRYPTO_INPUT_ERROR_DQ_COPS, n_deq);
 259
 260   vlib_buffer_enqueue_to_next (vm, node, bis, nexts, n_deq);
 261
 262   crypto_free_ops (numa, cwm->ops, n_deq);
 263
 264   return n_deq;
 265 }
 266
 267 static_always_inline uword
 268 dpdk_crypto_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 269                           vlib_frame_t * frame)
 270 {
 271   u32 thread_index = vlib_get_thread_index ();
 272   dpdk_crypto_main_t *dcm = &dpdk_crypto_main;
 273   crypto_worker_main_t *cwm = &dcm->workers_main[thread_index];
 274   crypto_resource_t *res;
 275   u32 n_deq = 0;
 276   u16 *remove = NULL, *res_idx;
 277   word i;
 278
 279   /* *INDENT-OFF* */
 280   vec_foreach (res_idx, cwm->resource_idx)
 281     {
 282       res = vec_elt_at_index (dcm->resource, res_idx[0]);
 283
 284       if (res->inflights[0])
 285         n_deq += dpdk_crypto_dequeue (vm, node, res, 0);
 286
 287       if (res->inflights[1])
 288         n_deq += dpdk_crypto_dequeue (vm, node, res, 1);
 289
 290       if (PREDICT_FALSE (res->remove && !(res->inflights[0] || res->inflights[1])))
 291         vec_add1 (remove, res_idx[0]);
 292     }
 293   /* *INDENT-ON* */
 294
 295   /* TODO removal on master thread? */
 296   if (PREDICT_FALSE (remove != NULL))
 297     {
 298       /* *INDENT-OFF* */
 299       vec_foreach (res_idx, remove)
 300         {
 301           i = vec_search (cwm->resource_idx, res_idx[0]);
 302           vec_del1 (cwm->resource_idx, i);
 303
 304           res = vec_elt_at_index (dcm->resource, res_idx[0]);
 305           res->thread_idx = (u16) ~0;
 306           res->remove = 0;
 307
 308           i = vec_search (dcm->dev[res->dev_id].used_resources, res_idx[0]);
 309           ASSERT (i != (u16) ~0);
 310           vec_del1 (dcm->dev[res->dev_id].used_resources, i);
 311           vec_add1 (dcm->dev[res->dev_id].free_resources, res_idx[0]);
 312         }
 313       /* *INDENT-ON* */
 314
 315       vec_free (remove);
 316     }
 317
 318   return n_deq;
 319 }
 320
 321 VLIB_NODE_FN (dpdk_crypto_input_node) (vlib_main_t * vm,
 322                                        vlib_node_runtime_t * node,
 323                                        vlib_frame_t * from_frame)
 324 {
 325   return dpdk_crypto_input_inline (vm, node, from_frame);
 326 }
 327
 328 /* *INDENT-OFF* */
 329 VLIB_REGISTER_NODE (dpdk_crypto_input_node) =
 330 {
 331   .name = "dpdk-crypto-input",
 332   .format_trace = format_dpdk_crypto_input_trace,
 333   .type = VLIB_NODE_TYPE_INPUT,
 334   .state = VLIB_NODE_STATE_DISABLED,
 335   .n_errors = DPDK_CRYPTO_INPUT_N_ERROR,
 336   .error_strings = dpdk_crypto_input_error_strings,
 337   .n_next_nodes = DPDK_CRYPTO_INPUT_N_NEXT,
 338   .next_nodes =
 339   {
 340 #define _(s,n) [DPDK_CRYPTO_INPUT_NEXT_##s] = n,
 341     foreach_dpdk_crypto_input_next
 342 #undef _
 343   },
 344 };
 345 /* *INDENT-ON* */
 346
 347 /*
 348  * fd.io coding-style-patch-verification: ON
 349  *
 350  * Local Variables:
 351  * eval: (c-set-style "gnu")
 352  * End:
 353  */