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)
 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,
 168                                                ops, VLIB_FRAME_SIZE);
 169
 170   /* no op dequeued, do not proceed */
 171   if (n_deq == 0)
 172     return 0;
 173
 174   res->inflights -= n_ops;
 175
 176   dpdk_crypto_input_trace (vm, node, ops, n_deq);
 177
 178   while (n_ops >= 4)
 179     {
 180       struct rte_crypto_op *op0, *op1, *op2, *op3;
 181       vlib_buffer_t *b0, *b1, *b2, *b3;
 182
 183       /* Prefetch next iteration. */
 184       if (n_ops >= 8)
 185         {
 186           CLIB_PREFETCH (ops[4], CLIB_CACHE_LINE_BYTES, LOAD);
 187           CLIB_PREFETCH (ops[5], CLIB_CACHE_LINE_BYTES, LOAD);
 188           CLIB_PREFETCH (ops[6], CLIB_CACHE_LINE_BYTES, LOAD);
 189           CLIB_PREFETCH (ops[7], CLIB_CACHE_LINE_BYTES, LOAD);
 190
 191           CLIB_PREFETCH (crypto_op_get_priv (ops[4]),
 192                          CLIB_CACHE_LINE_BYTES, LOAD);
 193           CLIB_PREFETCH (crypto_op_get_priv (ops[5]),
 194                          CLIB_CACHE_LINE_BYTES, LOAD);
 195           CLIB_PREFETCH (crypto_op_get_priv (ops[6]),
 196                          CLIB_CACHE_LINE_BYTES, LOAD);
 197           CLIB_PREFETCH (crypto_op_get_priv (ops[7]),
 198                          CLIB_CACHE_LINE_BYTES, LOAD);
 199         }
 200
 201       op0 = ops[0];
 202       op1 = ops[1];
 203       op2 = ops[2];
 204       op3 = ops[3];
 205
 206       next[0] = crypto_op_get_priv (op0)->next;
 207       next[1] = crypto_op_get_priv (op1)->next;
 208       next[2] = crypto_op_get_priv (op2)->next;
 209       next[3] = crypto_op_get_priv (op3)->next;
 210
 211       dpdk_crypto_input_check_op (vm, node, op0, next + 0);
 212       dpdk_crypto_input_check_op (vm, node, op1, next + 1);
 213       dpdk_crypto_input_check_op (vm, node, op2, next + 2);
 214       dpdk_crypto_input_check_op (vm, node, op3, next + 3);
 215
 216       b0 = vlib_buffer_from_rte_mbuf (op0->sym[0].m_src);
 217       b1 = vlib_buffer_from_rte_mbuf (op1->sym[0].m_src);
 218       b2 = vlib_buffer_from_rte_mbuf (op2->sym[0].m_src);
 219       b3 = vlib_buffer_from_rte_mbuf (op3->sym[0].m_src);
 220
 221       bi[0] = vlib_get_buffer_index (vm, b0);
 222       bi[1] = vlib_get_buffer_index (vm, b1);
 223       bi[2] = vlib_get_buffer_index (vm, b2);
 224       bi[3] = vlib_get_buffer_index (vm, b3);
 225
 226       op0->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 227       op1->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 228       op2->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 229       op3->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 230
 231       /* next */
 232       next += 4;
 233       n_ops -= 4;
 234       ops += 4;
 235       bi += 4;
 236     }
 237   while (n_ops > 0)
 238     {
 239       struct rte_crypto_op *op0;
 240       vlib_buffer_t *b0;
 241
 242       op0 = ops[0];
 243
 244       next[0] = crypto_op_get_priv (op0)->next;
 245
 246       dpdk_crypto_input_check_op (vm, node, op0, next + 0);
 247
 248       /* XXX store bi0 and next0 in op0 private? */
 249       b0 = vlib_buffer_from_rte_mbuf (op0->sym[0].m_src);
 250       bi[0] = vlib_get_buffer_index (vm, b0);
 251
 252       op0->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 253
 254       /* next */
 255       next += 1;
 256       n_ops -= 1;
 257       ops += 1;
 258       bi += 1;
 259     }
 260
 261   vlib_node_increment_counter (vm, node->node_index,
 262                                DPDK_CRYPTO_INPUT_ERROR_DQ_COPS, n_deq);
 263
 264   vlib_buffer_enqueue_to_next (vm, node, bis, nexts, n_deq);
 265
 266   crypto_free_ops (numa, cwm->ops, n_deq);
 267
 268   return n_deq;
 269 }
 270
 271 static_always_inline uword
 272 dpdk_crypto_input_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
 273                           vlib_frame_t * frame)
 274 {
 275   u32 thread_index = vlib_get_thread_index ();
 276   dpdk_crypto_main_t *dcm = &dpdk_crypto_main;
 277   crypto_worker_main_t *cwm = &dcm->workers_main[thread_index];
 278   crypto_resource_t *res;
 279   u32 n_deq = 0;
 280   u16 *remove = NULL, *res_idx;
 281   word i;
 282
 283   /* *INDENT-OFF* */
 284   vec_foreach (res_idx, cwm->resource_idx)
 285     {
 286       res = vec_elt_at_index (dcm->resource, res_idx[0]);
 287
 288       if (res->inflights)
 289         n_deq += dpdk_crypto_dequeue (vm, node, res);
 290
 291       if (PREDICT_FALSE (res->remove && !(res->inflights)))
 292         vec_add1 (remove, res_idx[0]);
 293     }
 294   /* *INDENT-ON* */
 295
 296   /* TODO removal on master thread? */
 297   if (PREDICT_FALSE (remove != NULL))
 298     {
 299       /* *INDENT-OFF* */
 300       vec_foreach (res_idx, remove)
 301         {
 302           i = vec_search (cwm->resource_idx, res_idx[0]);
 303           vec_del1 (cwm->resource_idx, i);
 304
 305           res = vec_elt_at_index (dcm->resource, res_idx[0]);
 306           res->thread_idx = (u16) ~0;
 307           res->remove = 0;
 308
 309           i = vec_search (dcm->dev[res->dev_id].used_resources, res_idx[0]);
 310           ASSERT (i != (u16) ~0);
 311           vec_del1 (dcm->dev[res->dev_id].used_resources, i);
 312           vec_add1 (dcm->dev[res->dev_id].free_resources, res_idx[0]);
 313         }
 314       /* *INDENT-ON* */
 315
 316       vec_free (remove);
 317     }
 318
 319   return n_deq;
 320 }
 321
 322 VLIB_NODE_FN (dpdk_crypto_input_node) (vlib_main_t * vm,
 323                                        vlib_node_runtime_t * node,
 324                                        vlib_frame_t * from_frame)
 325 {
 326   return dpdk_crypto_input_inline (vm, node, from_frame);
 327 }
 328
 329 /* *INDENT-OFF* */
 330 VLIB_REGISTER_NODE (dpdk_crypto_input_node) =
 331 {
 332   .name = "dpdk-crypto-input",
 333   .format_trace = format_dpdk_crypto_input_trace,
 334   .type = VLIB_NODE_TYPE_INPUT,
 335   .state = VLIB_NODE_STATE_DISABLED,
 336   .n_errors = DPDK_CRYPTO_INPUT_N_ERROR,
 337   .error_strings = dpdk_crypto_input_error_strings,
 338   .n_next_nodes = DPDK_CRYPTO_INPUT_N_NEXT,
 339   .next_nodes =
 340   {
 341 #define _(s,n) [DPDK_CRYPTO_INPUT_NEXT_##s] = n,
 342     foreach_dpdk_crypto_input_next
 343 #undef _
 344   },
 345 };
 346 /* *INDENT-ON* */
 347
 348 /*
 349  * fd.io coding-style-patch-verification: ON
 350  *
 351  * Local Variables:
 352  * eval: (c-set-style "gnu")
 353  * End:
 354  */