src/plugins/dpdk/ipsec/ipsec.h

   1 /*
   2  * Copyright (c) 2017 Intel 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 #ifndef __DPDK_IPSEC_H__
  16 #define __DPDK_IPSEC_H__
  17
  18 #include <vnet/vnet.h>
  19 #include <vppinfra/cache.h>
  20 #include <vnet/ipsec/ipsec.h>
  21
  22 #undef always_inline
  23 #include <rte_config.h>
  24 #include <rte_crypto.h>
  25 #include <rte_cryptodev.h>
  26
  27 #if CLIB_DEBUG > 0
  28 #define always_inline static inline
  29 #else
  30 #define always_inline static inline __attribute__ ((__always_inline__))
  31 #endif
  32
  33 #define DPDK_CRYPTO_N_QUEUE_DESC  2048
  34 #define DPDK_CRYPTO_NB_SESS_OBJS  20000
  35
  36 #define foreach_dpdk_crypto_input_next          \
  37   _(DROP, "error-drop")                         \
  38   _(IP4_LOOKUP, "ip4-lookup")                   \
  39   _(IP6_LOOKUP, "ip6-lookup")                   \
  40   _(INTERFACE_OUTPUT, "interface-output")       \
  41   _(DECRYPT4_POST, "dpdk-esp4-decrypt-post")     \
  42   _(DECRYPT6_POST, "dpdk-esp6-decrypt-post")
  43
  44 typedef enum
  45 {
  46 #define _(f,s) DPDK_CRYPTO_INPUT_NEXT_##f,
  47   foreach_dpdk_crypto_input_next
  48 #undef _
  49     DPDK_CRYPTO_INPUT_N_NEXT,
  50 } dpdk_crypto_input_next_t;
  51
  52 #define MAX_QP_PER_LCORE 16
  53
  54 typedef struct
  55 {
  56   u32 salt;
  57   u32 iv[2];
  58   u32 cnt;
  59 } dpdk_gcm_cnt_blk;
  60
  61 typedef struct
  62 {
  63   u32 next;
  64   u32 bi;
  65   u8 encrypt;
  66     CLIB_ALIGN_MARK (mark0, 16);
  67   dpdk_gcm_cnt_blk cb;
  68   u8 aad[16];
  69   u8 icv[32];                   /* XXX last 16B in next cache line */
  70 } dpdk_op_priv_t;
  71
  72 typedef struct
  73 {
  74   u16 *resource_idx;
  75   struct rte_crypto_op **ops;
  76   u16 cipher_resource_idx[IPSEC_CRYPTO_N_ALG];
  77   u16 auth_resource_idx[IPSEC_INTEG_N_ALG];
  78     CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
  79 } crypto_worker_main_t;
  80
  81 typedef struct
  82 {
  83   CLIB_ALIGN_MARK (pad, 8);     /* align up to 8 bytes for 32bit builds */
  84   char *name;
  85   enum rte_crypto_sym_xform_type type;
  86   u32 alg;
  87   u8 key_len;
  88   u8 iv_len;
  89   u8 trunc_size;
  90   u8 boundary;
  91   u8 disabled;
  92   u8 resources;
  93 } crypto_alg_t;
  94
  95 typedef struct
  96 {
  97   u16 *free_resources;
  98   u16 *used_resources;
  99   u8 cipher_support[IPSEC_CRYPTO_N_ALG];
 100   u8 auth_support[IPSEC_INTEG_N_ALG];
 101   u8 drv_id;
 102   u8 numa;
 103   u16 id;
 104   const char *name;
 105   u32 max_qp;
 106   u64 features;
 107 } crypto_dev_t;
 108
 109 typedef struct
 110 {
 111   const char *name;
 112   u16 *devs;
 113 } crypto_drv_t;
 114
 115 typedef struct
 116 {
 117   u16 thread_idx;
 118   u8 remove;
 119   u8 drv_id;
 120   u8 dev_id;
 121   u8 numa;
 122   u16 qp_id;
 123   u16 inflights[2];
 124   u16 n_ops;
 125   u16 __unused;
 126   struct rte_crypto_op *ops[VLIB_FRAME_SIZE];
 127   u32 bi[VLIB_FRAME_SIZE];
 128     CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 129 } crypto_resource_t;
 130
 131 typedef struct
 132 {
 133   u64 ts;
 134   struct rte_cryptodev_sym_session *session;
 135 } crypto_session_disposal_t;
 136
 137 typedef struct
 138 {
 139   struct rte_cryptodev_sym_session *session;
 140   u64 dev_mask;
 141     CLIB_ALIGN_MARK (pad, 16);  /* align up to 16 bytes for 32bit builds */
 142 } crypto_session_by_drv_t;
 143
 144 typedef struct
 145 {
 146   struct rte_mempool *crypto_op;
 147   struct rte_mempool *session_h;
 148   struct rte_mempool **session_drv;
 149   crypto_session_disposal_t *session_disposal;
 150   uword *session_by_sa_index;
 151   u64 crypto_op_get_failed;
 152   u64 session_h_failed;
 153   u64 *session_drv_failed;
 154   crypto_session_by_drv_t *session_by_drv_id_and_sa_index;
 155   clib_spinlock_t lockp;
 156   /* Required for vec_validate_aligned */
 157     CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 158 } crypto_data_t;
 159
 160 typedef struct
 161 {
 162   crypto_worker_main_t *workers_main;
 163   crypto_dev_t *dev;
 164   crypto_resource_t *resource;
 165   crypto_alg_t *cipher_algs;
 166   crypto_alg_t *auth_algs;
 167   crypto_data_t *data;
 168   crypto_drv_t *drv;
 169   u64 session_timeout;          /* nsec */
 170   u8 enabled;
 171 } dpdk_crypto_main_t;
 172
 173 extern dpdk_crypto_main_t dpdk_crypto_main;
 174
 175 static const u8 pad_data[] =
 176   { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0 };
 177
 178 void crypto_auto_placement (void);
 179
 180 clib_error_t *create_sym_session (struct rte_cryptodev_sym_session **session,
 181                                   u32 sa_idx, crypto_resource_t * res,
 182                                   crypto_worker_main_t * cwm, u8 is_outbound);
 183
 184 static_always_inline u32
 185 crypto_op_len (void)
 186 {
 187   const u32 align = 4;
 188   u32 op_size =
 189     sizeof (struct rte_crypto_op) + sizeof (struct rte_crypto_sym_op);
 190
 191   return ((op_size + align - 1) & ~(align - 1)) + sizeof (dpdk_op_priv_t);
 192 }
 193
 194 static_always_inline u32
 195 crypto_op_get_priv_offset (void)
 196 {
 197   const u32 align = 16;
 198   u32 offset;
 199
 200   offset = sizeof (struct rte_crypto_op) + sizeof (struct rte_crypto_sym_op);
 201   offset = (offset + align - 1) & ~(align - 1);
 202
 203   return offset;
 204 }
 205
 206 static_always_inline dpdk_op_priv_t *
 207 crypto_op_get_priv (struct rte_crypto_op * op)
 208 {
 209   return (dpdk_op_priv_t *) (((u8 *) op) + crypto_op_get_priv_offset ());
 210 }
 211
 212
 213 static_always_inline void
 214 add_session_by_drv_and_sa_idx (struct rte_cryptodev_sym_session *session,
 215                                crypto_data_t * data, u32 drv_id, u32 sa_idx)
 216 {
 217   crypto_session_by_drv_t *sbd;
 218   vec_validate_aligned (data->session_by_drv_id_and_sa_index, sa_idx,
 219                         CLIB_CACHE_LINE_BYTES);
 220   sbd = vec_elt_at_index (data->session_by_drv_id_and_sa_index, sa_idx);
 221   sbd->dev_mask |= 1L << drv_id;
 222   sbd->session = session;
 223 }
 224
 225 static_always_inline struct rte_cryptodev_sym_session *
 226 get_session_by_drv_and_sa_idx (crypto_data_t * data, u32 drv_id, u32 sa_idx)
 227 {
 228   crypto_session_by_drv_t *sess_by_sa;
 229   if (_vec_len (data->session_by_drv_id_and_sa_index) <= sa_idx)
 230     return NULL;
 231   sess_by_sa =
 232     vec_elt_at_index (data->session_by_drv_id_and_sa_index, sa_idx);
 233   return (sess_by_sa->dev_mask & (1L << drv_id)) ? sess_by_sa->session : NULL;
 234 }
 235
 236 static_always_inline clib_error_t *
 237 crypto_get_session (struct rte_cryptodev_sym_session ** session,
 238                     u32 sa_idx,
 239                     crypto_resource_t * res,
 240                     crypto_worker_main_t * cwm, u8 is_outbound)
 241 {
 242   dpdk_crypto_main_t *dcm = &dpdk_crypto_main;
 243   crypto_data_t *data;
 244   struct rte_cryptodev_sym_session *sess;
 245
 246   data = vec_elt_at_index (dcm->data, res->numa);
 247   sess = get_session_by_drv_and_sa_idx (data, res->drv_id, sa_idx);
 248
 249   if (PREDICT_FALSE (!sess))
 250     return create_sym_session (session, sa_idx, res, cwm, is_outbound);
 251
 252   session[0] = sess;
 253
 254   return NULL;
 255 }
 256
 257 static_always_inline u16
 258 get_resource (crypto_worker_main_t * cwm, ipsec_sa_t * sa)
 259 {
 260   u16 cipher_res = cwm->cipher_resource_idx[sa->crypto_alg];
 261   u16 auth_res = cwm->auth_resource_idx[sa->integ_alg];
 262   u8 is_aead;
 263
 264   /* Not allowed to setup SA with no-aead-cipher/NULL or NULL/NULL */
 265
 266   is_aead = ((sa->crypto_alg == IPSEC_CRYPTO_ALG_AES_GCM_128) ||
 267              (sa->crypto_alg == IPSEC_CRYPTO_ALG_AES_GCM_192) ||
 268              (sa->crypto_alg == IPSEC_CRYPTO_ALG_AES_GCM_256));
 269
 270   if (sa->crypto_alg == IPSEC_CRYPTO_ALG_NONE)
 271     return auth_res;
 272
 273   if (cipher_res == auth_res)
 274     return cipher_res;
 275
 276   if (is_aead)
 277     return cipher_res;
 278
 279   return (u16) ~ 0;
 280 }
 281
 282 static_always_inline i32
 283 crypto_alloc_ops (u8 numa, struct rte_crypto_op ** ops, u32 n)
 284 {
 285   dpdk_crypto_main_t *dcm = &dpdk_crypto_main;
 286   crypto_data_t *data = vec_elt_at_index (dcm->data, numa);
 287   i32 ret;
 288
 289   ret = rte_mempool_get_bulk (data->crypto_op, (void **) ops, n);
 290
 291   /* *INDENT-OFF* */
 292   data->crypto_op_get_failed += ! !ret;
 293   /* *INDENT-ON* */
 294
 295   return ret;
 296 }
 297
 298 static_always_inline void
 299 crypto_free_ops (u8 numa, struct rte_crypto_op **ops, u32 n)
 300 {
 301   dpdk_crypto_main_t *dcm = &dpdk_crypto_main;
 302   crypto_data_t *data = vec_elt_at_index (dcm->data, numa);
 303
 304   if (!n)
 305     return;
 306
 307   rte_mempool_put_bulk (data->crypto_op, (void **) ops, n);
 308 }
 309
 310 static_always_inline void
 311 crypto_enqueue_ops (vlib_main_t * vm, crypto_worker_main_t * cwm,
 312                     u32 node_index, u32 error, u8 numa, u8 encrypt)
 313 {
 314   dpdk_crypto_main_t *dcm = &dpdk_crypto_main;
 315   crypto_resource_t *res;
 316   u16 *res_idx;
 317
 318   /* *INDENT-OFF* */
 319   vec_foreach (res_idx, cwm->resource_idx)
 320     {
 321       u16 enq, n_ops;
 322       res = vec_elt_at_index (dcm->resource, res_idx[0]);
 323
 324       if (!res->n_ops)
 325         continue;
 326
 327       n_ops = (DPDK_CRYPTO_N_QUEUE_DESC / 2) - res->inflights[encrypt];
 328       n_ops = res->n_ops < n_ops ? res->n_ops : n_ops;
 329       enq = rte_cryptodev_enqueue_burst (res->dev_id, res->qp_id,
 330                                          res->ops, n_ops);
 331       ASSERT (n_ops == enq);
 332       res->inflights[encrypt] += enq;
 333
 334       if (PREDICT_FALSE (enq < res->n_ops))
 335         {
 336           crypto_free_ops (numa, &res->ops[enq], res->n_ops - enq);
 337           vlib_buffer_free (vm, &res->bi[enq], res->n_ops - enq);
 338
 339           vlib_node_increment_counter (vm, node_index, error,
 340                                        res->n_ops - enq);
 341         }
 342       res->n_ops = 0;
 343     }
 344   /* *INDENT-ON* */
 345 }
 346
 347 static_always_inline void
 348 crypto_set_icb (dpdk_gcm_cnt_blk * icb, u32 salt, u32 seq, u32 seq_hi)
 349 {
 350   icb->salt = salt;
 351   icb->iv[0] = seq;
 352   icb->iv[1] = seq_hi;
 353 }
 354
 355 static_always_inline void
 356 crypto_op_setup (u8 is_aead, struct rte_mbuf *mb0,
 357                  struct rte_crypto_op *op, void *session,
 358                  u32 cipher_off, u32 cipher_len,
 359                  u32 auth_off, u32 auth_len,
 360                  u8 * aad, u8 * digest, u64 digest_paddr)
 361 {
 362   struct rte_crypto_sym_op *sym_op;
 363
 364   sym_op = (struct rte_crypto_sym_op *) (op + 1);
 365
 366   sym_op->m_src = mb0;
 367   sym_op->session = session;
 368
 369   if (is_aead)
 370     {
 371       sym_op->aead.data.offset = cipher_off;
 372       sym_op->aead.data.length = cipher_len;
 373
 374       sym_op->aead.aad.data = aad;
 375       sym_op->aead.aad.phys_addr =
 376         op->phys_addr + (uintptr_t) aad - (uintptr_t) op;
 377
 378       sym_op->aead.digest.data = digest;
 379       sym_op->aead.digest.phys_addr = digest_paddr;
 380     }
 381   else
 382     {
 383       sym_op->cipher.data.offset = cipher_off;
 384       sym_op->cipher.data.length = cipher_len;
 385
 386       sym_op->auth.data.offset = auth_off;
 387       sym_op->auth.data.length = auth_len;
 388
 389       sym_op->auth.digest.data = digest;
 390       sym_op->auth.digest.phys_addr = digest_paddr;
 391     }
 392 }
 393
 394 #endif /* __DPDK_IPSEC_H__ */
 395
 396 /*
 397  * fd.io coding-style-patch-verification: ON
 398  *
 399  * Local Variables:
 400  * eval: (c-set-style "gnu")
 401  * End:
 402  */