src/vnet/crypto/crypto.c

   1 /*
   2  * Copyright (c) 2018 Cisco 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 <stdbool.h>
  17 #include <vlib/vlib.h>
  18 #include <vnet/crypto/crypto.h>
  19
  20 vnet_crypto_main_t crypto_main;
  21
  22 static_always_inline u32
  23 vnet_crypto_process_ops_call_handler (vlib_main_t * vm,
  24                                       vnet_crypto_main_t * cm,
  25                                       vnet_crypto_op_type_t opt,
  26                                       vnet_crypto_op_t * ops[], u32 n_ops)
  27 {
  28   if (n_ops == 0)
  29     return 0;
  30
  31   if (cm->ops_handlers[opt] == 0)
  32     {
  33       while (n_ops--)
  34         {
  35           ops[0]->status = VNET_CRYPTO_OP_STATUS_FAIL_NO_HANDLER;
  36           ops++;
  37         }
  38       return 0;
  39     }
  40
  41   return (cm->ops_handlers[opt]) (vm, ops, n_ops);
  42 }
  43
  44
  45 u32
  46 vnet_crypto_process_ops (vlib_main_t * vm, vnet_crypto_op_t ops[], u32 n_ops)
  47 {
  48   vnet_crypto_main_t *cm = &crypto_main;
  49   const int op_q_size = VLIB_FRAME_SIZE;
  50   vnet_crypto_op_t *op_queue[op_q_size];
  51   vnet_crypto_op_type_t opt, current_op_type = ~0;
  52   u32 n_op_queue = 0;
  53   u32 rv = 0, i;
  54
  55   ASSERT (n_ops >= 1);
  56
  57   for (i = 0; i < n_ops; i++)
  58     {
  59       opt = ops[i].op;
  60
  61       if (current_op_type != opt || n_op_queue >= op_q_size)
  62         {
  63           rv += vnet_crypto_process_ops_call_handler (vm, cm, current_op_type,
  64                                                       op_queue, n_op_queue);
  65           n_op_queue = 0;
  66           current_op_type = opt;
  67         }
  68
  69       op_queue[n_op_queue++] = &ops[i];
  70     }
  71
  72   rv += vnet_crypto_process_ops_call_handler (vm, cm, current_op_type,
  73                                               op_queue, n_op_queue);
  74   return rv;
  75 }
  76
  77 u32
  78 vnet_crypto_register_engine (vlib_main_t * vm, char *name, int prio,
  79                              char *desc)
  80 {
  81   vnet_crypto_main_t *cm = &crypto_main;
  82   vnet_crypto_engine_t *p;
  83
  84   vec_add2 (cm->engines, p, 1);
  85   p->name = name;
  86   p->desc = desc;
  87   p->priority = prio;
  88
  89   hash_set_mem (cm->engine_index_by_name, p->name, p - cm->engines);
  90
  91   return p - cm->engines;
  92 }
  93
  94 int
  95 vnet_crypto_set_handler (char *ops_handler_name, char *engine)
  96 {
  97   uword *p;
  98   vnet_crypto_main_t *cm = &crypto_main;
  99   vnet_crypto_op_type_t ot;
 100   vnet_crypto_op_type_data_t *otd;
 101   vnet_crypto_engine_t *ce;
 102
 103   p = hash_get_mem (cm->ops_handler_index_by_name, ops_handler_name);
 104   if (!p)
 105     return -1;
 106
 107   ot = p[0];
 108   otd = cm->opt_data + ot;
 109
 110   p = hash_get_mem (cm->engine_index_by_name, engine);
 111   if (!p)
 112     return -1;
 113
 114   ce = cm->engines + p[0];
 115   otd->active_engine_index = p[0];
 116   cm->ops_handlers[ot] = ce->ops_handlers[ot];
 117
 118   return 0;
 119 }
 120
 121 vlib_error_t *
 122 vnet_crypto_register_ops_handler (vlib_main_t * vm, u32 engine_index,
 123                                   vnet_crypto_op_type_t opt,
 124                                   vnet_crypto_ops_handler_t * fn)
 125 {
 126   vnet_crypto_main_t *cm = &crypto_main;
 127   vnet_crypto_engine_t *ae, *e = vec_elt_at_index (cm->engines, engine_index);
 128   vnet_crypto_op_type_data_t *otd = cm->opt_data + opt;
 129   vec_validate_aligned (cm->ops_handlers, VNET_CRYPTO_N_OP_TYPES - 1,
 130                         CLIB_CACHE_LINE_BYTES);
 131   e->ops_handlers[opt] = fn;
 132
 133   if (otd->active_engine_index == ~0)
 134     {
 135       otd->active_engine_index = engine_index;
 136       cm->ops_handlers[opt] = fn;
 137       return 0;
 138     }
 139   ae = vec_elt_at_index (cm->engines, otd->active_engine_index);
 140   if (ae->priority < e->priority)
 141     {
 142       otd->active_engine_index = engine_index;
 143       cm->ops_handlers[opt] = fn;
 144     }
 145
 146   return 0;
 147 }
 148
 149 clib_error_t *
 150 vnet_crypto_init (vlib_main_t * vm)
 151 {
 152   vnet_crypto_main_t *cm = &crypto_main;
 153   vlib_thread_main_t *tm = vlib_get_thread_main ();
 154 #define CRYPTO_ENC_STR "encrypt"
 155 #define CRYPTO_DEC_STR "decrypt"
 156 #define CRYPTO_HMAC_STR "hmac"
 157
 158   cm->engine_index_by_name = hash_create_string ( /* size */ 0,
 159                                                  sizeof (uword));
 160   cm->ops_handler_index_by_name = hash_create_string (0, sizeof (uword));
 161
 162   vec_validate_aligned (cm->threads, tm->n_vlib_mains, CLIB_CACHE_LINE_BYTES);
 163   vec_validate (cm->algs, VNET_CRYPTO_N_ALGS);
 164
 165 #define _(n, s) \
 166   cm->algs[VNET_CRYPTO_ALG_##n].name = s; \
 167   cm->opt_data[VNET_CRYPTO_OP_##n##_ENC].alg = VNET_CRYPTO_ALG_##n; \
 168   cm->opt_data[VNET_CRYPTO_OP_##n##_DEC].alg = VNET_CRYPTO_ALG_##n; \
 169   cm->opt_data[VNET_CRYPTO_OP_##n##_ENC].desc = CRYPTO_ENC_STR; \
 170   cm->opt_data[VNET_CRYPTO_OP_##n##_DEC].desc = CRYPTO_DEC_STR; \
 171   cm->opt_data[VNET_CRYPTO_OP_##n##_ENC].active_engine_index = ~0; \
 172   cm->opt_data[VNET_CRYPTO_OP_##n##_DEC].active_engine_index = ~0; \
 173   hash_set_mem (cm->ops_handler_index_by_name, CRYPTO_ENC_STR "-" s, \
 174       VNET_CRYPTO_OP_##n##_ENC); \
 175   hash_set_mem (cm->ops_handler_index_by_name, CRYPTO_DEC_STR "-" s, \
 176       VNET_CRYPTO_OP_##n##_DEC);
 177   foreach_crypto_alg;
 178 #undef _
 179
 180 #define _(n, s) \
 181   cm->algs[VNET_CRYPTO_ALG_##n].name = s; \
 182   cm->opt_data[VNET_CRYPTO_OP_##n##_HMAC].alg = VNET_CRYPTO_ALG_##n; \
 183   cm->opt_data[VNET_CRYPTO_OP_##n##_HMAC].desc = CRYPTO_HMAC_STR; \
 184   cm->opt_data[VNET_CRYPTO_OP_##n##_HMAC].active_engine_index = ~0; \
 185   hash_set_mem (cm->ops_handler_index_by_name, CRYPTO_HMAC_STR "-" s, \
 186       VNET_CRYPTO_OP_##n##_HMAC);
 187   foreach_hmac_alg;
 188 #undef _
 189
 190   return 0;
 191 }
 192
 193 VLIB_INIT_FUNCTION (vnet_crypto_init);
 194
 195 /*
 196  * fd.io coding-style-patch-verification: ON
 197  *
 198  * Local Variables:
 199  * eval: (c-set-style "gnu")
 200  * End:
 201  */