src/plugins/tlsopenssl/tls_async.c

   1 /*
   2  * Copyright (c) 2018 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 #include <vnet/vnet.h>
  16 #include <vnet/ip/ip.h>
  17 #include <vnet/api_errno.h>
  18 #include <vlib/node_funcs.h>
  19 #include <openssl/engine.h>
  20 #include <tlsopenssl/tls_openssl.h>
  21
  22 #define MAX_SESSION         4096
  23 #define MAX_VECTOR_ASYNC    256
  24
  25 #define SSL_ASYNC_INFLIGHT  1
  26 #define SSL_ASYNC_PENDING   2
  27 #define SSL_ASYNC_READY     3
  28
  29 #define EMPTY_STRUCT {0}
  30
  31 typedef struct openssl_tls_callback_arg_
  32 {
  33   int thread_index;
  34   int event_index;
  35 } openssl_tls_callback_arg_t;
  36
  37 typedef struct openssl_event_
  38 {
  39   int status;
  40   u32 event_index;
  41   u8 thread_index;
  42   u32 ctx_index;
  43
  44   openssl_resume_handler *handler;
  45   openssl_tls_callback_t engine_callback;
  46   openssl_tls_callback_arg_t cb_args;
  47
  48   int next;
  49 } openssl_evt_t;
  50
  51 typedef struct openssl_async_status_
  52 {
  53   int evt_run_head;
  54   int evt_run_tail;
  55   int evt_pending_head;
  56   int poll_config;
  57 } openssl_async_status_t;
  58
  59 typedef struct openssl_async_
  60 {
  61   openssl_evt_t ***evt_pool;
  62   openssl_async_status_t *status;
  63   void (*polling) (void);
  64   void (*polling_conf) (void);
  65   u8 start_polling;
  66   ENGINE *engine;
  67
  68 } openssl_async_t;
  69
  70 void qat_polling ();
  71 void qat_pre_init ();
  72 void qat_polling_config ();
  73 void dasync_polling ();
  74
  75 struct engine_polling
  76 {
  77   char *engine;
  78   void (*polling) (void);
  79   void (*pre_init) (void);
  80   void (*polling_conf) (void);
  81 };
  82
  83 struct engine_polling engine_list[] = {
  84   {"qat", qat_polling, qat_pre_init, qat_polling_config},
  85   {"dasync", dasync_polling, NULL, NULL}
  86 };
  87
  88 openssl_async_t openssl_async_main;
  89 static vlib_node_registration_t tls_async_process_node;
  90
  91 /* to avoid build warning */
  92 void session_send_rpc_evt_to_thread (u32 thread_index, void *fp,
  93                                      void *rpc_args);
  94
  95 void
  96 evt_pool_init (vlib_main_t * vm)
  97 {
  98   vlib_thread_main_t *vtm = vlib_get_thread_main ();
  99   openssl_async_t *om = &openssl_async_main;
 100   int i, num_threads;
 101
 102   num_threads = 1 /* main thread */  + vtm->n_threads;
 103
 104   TLS_DBG (2, "Totally there is %d thread\n", num_threads);
 105
 106   vec_validate (om->evt_pool, num_threads - 1);
 107   vec_validate (om->status, num_threads - 1);
 108
 109   om->start_polling = 0;
 110   om->engine = 0;
 111
 112   for (i = 0; i < num_threads; i++)
 113     {
 114       om->status[i].evt_run_head = -1;
 115       om->status[i].evt_run_tail = -1;
 116       om->status[i].evt_pending_head = -1;
 117     }
 118   om->polling = NULL;
 119
 120   openssl_async_node_enable_disable (0);
 121
 122   return;
 123 }
 124
 125 int
 126 openssl_engine_register (char *engine_name, char *algorithm)
 127 {
 128   int i, registered = -1;
 129   openssl_async_t *om = &openssl_async_main;
 130   void (*p) (void);
 131   ENGINE *engine;
 132
 133   for (i = 0; i < ARRAY_LEN (engine_list); i++)
 134     {
 135       if (!strcmp (engine_list[i].engine, engine_name))
 136         {
 137           om->polling = engine_list[i].polling;
 138           om->polling_conf = engine_list[i].polling_conf;
 139
 140           registered = i;
 141         }
 142     }
 143   if (registered < 0)
 144     {
 145       return 0;
 146     }
 147
 148   ENGINE_load_builtin_engines ();
 149   ENGINE_load_dynamic ();
 150   engine = ENGINE_by_id (engine_name);
 151
 152   if (engine == NULL)
 153     {
 154       return 0;
 155     }
 156
 157   om->engine = engine;
 158   /* call pre-init */
 159   p = engine_list[registered].pre_init;
 160   if (p)
 161     (*p) ();
 162
 163   if (algorithm)
 164     {
 165       if (!ENGINE_set_default_string (engine, algorithm))
 166         {
 167           clib_warning ("Failed to set engine %s algorithm %s\n",
 168                         engine_name, algorithm);
 169           return 0;
 170         }
 171     }
 172   else
 173     {
 174       if (!ENGINE_set_default (engine, ENGINE_METHOD_ALL))
 175         {
 176           clib_warning ("Failed to set engine %s to all algorithm",
 177                         engine_name);
 178           return 0;
 179         }
 180     }
 181
 182   om->start_polling = 1;
 183
 184   return 1;
 185
 186 }
 187
 188 static openssl_evt_t *
 189 openssl_evt_get (u32 evt_index)
 190 {
 191   openssl_evt_t **evt;
 192   evt =
 193     pool_elt_at_index (openssl_async_main.evt_pool[vlib_get_thread_index ()],
 194                        evt_index);
 195   return *evt;
 196 }
 197
 198 static openssl_evt_t *
 199 openssl_evt_get_w_thread (int evt_index, u8 thread_index)
 200 {
 201   openssl_evt_t **evt;
 202
 203   evt =
 204     pool_elt_at_index (openssl_async_main.evt_pool[thread_index], evt_index);
 205   return *evt;
 206 }
 207
 208 int
 209 openssl_evt_free (int event_idx, u8 thread_index)
 210 {
 211   openssl_evt_t *evt;
 212   openssl_async_t *om = &openssl_async_main;
 213   int *evt_run_tail = &om->status[thread_index].evt_run_tail;
 214
 215   if (event_idx < 0)
 216     return 0;
 217
 218   evt = openssl_evt_get_w_thread (event_idx, thread_index);
 219
 220   evt->status = 0;
 221
 222   /*pool operation */
 223   pool_put_index (om->evt_pool[thread_index], event_idx);
 224
 225   if (*evt_run_tail == event_idx)
 226     *evt_run_tail = -1;
 227
 228   return 1;
 229 }
 230
 231 static u32
 232 openssl_evt_alloc (void)
 233 {
 234   u8 thread_index = vlib_get_thread_index ();
 235   openssl_async_t *tm = &openssl_async_main;
 236   openssl_evt_t **evt;
 237
 238   pool_get (tm->evt_pool[thread_index], evt);
 239   if (!(*evt))
 240     *evt = clib_mem_alloc (sizeof (openssl_evt_t));
 241
 242   clib_memset (*evt, 0, sizeof (openssl_evt_t));
 243   (*evt)->event_index = evt - tm->evt_pool[thread_index];
 244   return ((*evt)->event_index);
 245 }
 246
 247 int
 248 openssl_async_run (void *evt)
 249 {
 250   openssl_evt_t *event, *event_tail;
 251   openssl_async_t *om = &openssl_async_main;
 252   openssl_tls_callback_arg_t *args = (openssl_tls_callback_arg_t *) evt;
 253   int thread_index = args->thread_index;
 254   int event_index = args->event_index;
 255   int *evt_run_tail = &om->status[thread_index].evt_run_tail;
 256   int *evt_run_head = &om->status[thread_index].evt_run_head;
 257
 258   TLS_DBG (2, "Set event %d to run\n", event_index);
 259
 260   event = openssl_evt_get_w_thread (event_index, thread_index);
 261
 262   if (event->status == SSL_ASYNC_READY)
 263     return 0;
 264
 265   event->status = SSL_ASYNC_READY;
 266   event->next = -1;
 267
 268
 269   if (*evt_run_tail >= 0)
 270     {
 271       event_tail = openssl_evt_get_w_thread (*evt_run_tail, thread_index);
 272       event_tail->next = event_index;
 273     }
 274   *evt_run_tail = event_index;
 275   if (*evt_run_head < 0)
 276     {
 277       *evt_run_head = event_index;
 278     }
 279
 280   return 1;
 281 }
 282
 283 openssl_tls_callback_t *
 284 vpp_add_async_pending_event (tls_ctx_t * ctx,
 285                              openssl_resume_handler * handler)
 286 {
 287   u32 eidx;
 288   openssl_evt_t *event;
 289   openssl_async_t *om = &openssl_async_main;
 290   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
 291   int *evt_pending_head;
 292   u32 thread_id = ctx->c_thread_index;
 293
 294   eidx = openssl_evt_alloc ();
 295   event = openssl_evt_get (eidx);
 296
 297   event->ctx_index = oc->openssl_ctx_index;
 298   event->status = SSL_ASYNC_PENDING;
 299   event->handler = handler;
 300   event->cb_args.event_index = eidx;
 301   event->cb_args.thread_index = thread_id;
 302   event->engine_callback.callback = openssl_async_run;
 303   event->engine_callback.arg = &event->cb_args;
 304
 305   /* add to pending list */
 306   evt_pending_head = &om->status[thread_id].evt_pending_head;
 307   event->next = *evt_pending_head;
 308   *evt_pending_head = eidx;
 309
 310   return &event->engine_callback;
 311 }
 312
 313 int
 314 vpp_add_async_run_event (tls_ctx_t * ctx, openssl_resume_handler * handler)
 315 {
 316   u32 eidx;
 317   openssl_evt_t *event;
 318   openssl_ctx_t *oc = (openssl_ctx_t *) ctx;
 319   u32 thread_id = ctx->c_thread_index;
 320
 321   eidx = openssl_evt_alloc ();
 322   event = openssl_evt_get (eidx);
 323
 324   event->ctx_index = oc->openssl_ctx_index;
 325   event->status = SSL_ASYNC_PENDING;
 326   event->handler = handler;
 327   event->cb_args.event_index = eidx;
 328   event->cb_args.thread_index = thread_id;
 329   event->engine_callback.callback = openssl_async_run;
 330   event->engine_callback.arg = &event->cb_args;
 331
 332   /* This is a retry event, and need to put to ring to make it run again */
 333   return openssl_async_run (&event->cb_args);
 334
 335 }
 336
 337 void
 338 event_handler (void *tls_async)
 339 {
 340
 341   openssl_resume_handler *handler;
 342   openssl_evt_t *callback;
 343   stream_session_t *tls_session;
 344   int thread_index;
 345   tls_ctx_t *ctx;
 346
 347   callback = (openssl_evt_t *) tls_async;
 348   thread_index = callback->cb_args.thread_index;
 349   ctx = openssl_ctx_get_w_thread (callback->ctx_index, thread_index);
 350   handler = callback->handler;
 351   tls_session = session_get_from_handle (ctx->tls_session_handle);
 352
 353   if (handler)
 354     {
 355       (*handler) (ctx, tls_session);
 356     }
 357
 358   /* Need to free the event */
 359   openssl_evt_free (callback->cb_args.event_index, thread_index);
 360
 361   return;
 362 }
 363
 364  /* engine specific code to polling the response ring */
 365 void
 366 dasync_polling ()
 367 {
 368   openssl_async_t *om = &openssl_async_main;
 369   openssl_evt_t *event;
 370   int *evt_pending;
 371   openssl_tls_callback_t *engine_cb;
 372   u8 thread_index = vlib_get_thread_index ();
 373
 374   /* POC code here to simulate the engine to call callback */
 375   evt_pending = &om->status[thread_index].evt_pending_head;
 376   while (*evt_pending >= 0)
 377     {
 378       TLS_DBG (2, "polling... current head = %d\n", *evt_pending);
 379       event = openssl_evt_get_w_thread (*evt_pending, thread_index);
 380       *evt_pending = event->next;
 381       if (event->status == SSL_ASYNC_PENDING)
 382         {
 383           engine_cb = &event->engine_callback;
 384           (*engine_cb->callback) (engine_cb->arg);
 385         }
 386     }
 387
 388 }
 389
 390 void
 391 qat_pre_init ()
 392 {
 393   openssl_async_t *om = &openssl_async_main;
 394
 395   ENGINE_ctrl_cmd (om->engine, "ENABLE_EXTERNAL_POLLING", 0, NULL, NULL, 0);
 396 }
 397
 398 /* Below code is spefic to QAT engine, and other vendors can refer to this code to enable a new engine */
 399 void
 400 qat_polling_config ()
 401 {
 402   openssl_async_t *om = &openssl_async_main;
 403   u8 thread_index = vlib_get_thread_index ();
 404   int *config;
 405
 406   config = &om->status[thread_index].poll_config;
 407   if (PREDICT_TRUE (*config))
 408     return;
 409
 410   ENGINE_ctrl_cmd (om->engine, "SET_INSTANCE_FOR_THREAD", thread_index,
 411                    NULL, NULL, 0);
 412   *config = 1;
 413
 414   TLS_DBG (2, "set thread %d and instance %d mapping\n", thread_index,
 415            thread_index);
 416
 417 }
 418
 419 void
 420 qat_polling ()
 421 {
 422   openssl_async_t *om = &openssl_async_main;
 423   int poll_status = 0;
 424
 425   if (om->start_polling)
 426     {
 427       ENGINE_ctrl_cmd (om->engine, "POLL", 0, &poll_status, NULL, 0);
 428     }
 429 }
 430
 431 void
 432 openssl_async_polling ()
 433 {
 434   openssl_async_t *om = &openssl_async_main;
 435   if (om->polling)
 436     {
 437       (*om->polling) ();
 438     }
 439 }
 440
 441 void
 442 openssl_async_node_enable_disable (u8 is_en)
 443 {
 444   u8 state = is_en ? VLIB_NODE_STATE_POLLING : VLIB_NODE_STATE_DISABLED;
 445   /* *INDENT-OFF* */
 446   foreach_vlib_main (({
 447     vlib_node_set_state (this_vlib_main, tls_async_process_node.index,
 448                          state);
 449   }));
 450   /* *INDENT-ON* */
 451 }
 452
 453 int
 454 tls_async_do_job (int eidx, u32 thread_index)
 455 {
 456   tls_ctx_t *ctx;
 457   openssl_evt_t *event;
 458
 459   /* do the real job */
 460   event = openssl_evt_get_w_thread (eidx, thread_index);
 461   ctx = openssl_ctx_get_w_thread (event->ctx_index, thread_index);
 462
 463   if (ctx)
 464     {
 465       ctx->resume = 1;
 466       session_send_rpc_evt_to_thread (thread_index, event_handler, event);
 467     }
 468   return 1;
 469 }
 470
 471 int
 472 tls_resume_from_crypto (int thread_index)
 473 {
 474   int i;
 475
 476   openssl_async_t *om = &openssl_async_main;
 477   openssl_evt_t *event;
 478   int *evt_run_head = &om->status[thread_index].evt_run_head;
 479
 480   if (*evt_run_head < 0)
 481     return 0;
 482
 483   for (i = 0; i < MAX_VECTOR_ASYNC; i++)
 484     {
 485       if (*evt_run_head >= 0)
 486         {
 487           event = openssl_evt_get_w_thread (*evt_run_head, thread_index);
 488           TLS_DBG (2, "event run = %d\n", *evt_run_head);
 489           tls_async_do_job (*evt_run_head, thread_index);
 490
 491           *evt_run_head = event->next;
 492
 493         }
 494       else
 495         {
 496           break;
 497         }
 498     }
 499
 500   return 0;
 501
 502 }
 503
 504 static clib_error_t *
 505 tls_async_init (vlib_main_t * vm)
 506 {
 507   evt_pool_init (vm);
 508   return 0;
 509
 510 }
 511
 512 static uword
 513 tls_async_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
 514                    vlib_frame_t * f)
 515 {
 516   u8 thread_index;
 517   openssl_async_t *om = &openssl_async_main;
 518
 519   if (om->polling_conf)
 520     (*om->polling_conf) ();
 521   thread_index = vlib_get_thread_index ();
 522   if (pool_elts (om->evt_pool[thread_index]) > 0)
 523     {
 524       openssl_async_polling ();
 525       tls_resume_from_crypto (thread_index);
 526     }
 527
 528   return 0;
 529 }
 530
 531 VLIB_INIT_FUNCTION (tls_async_init);
 532
 533 /* *INDENT-OFF* */
 534 VLIB_REGISTER_NODE (tls_async_process_node,static) = {
 535     .function = tls_async_process,
 536     .type = VLIB_NODE_TYPE_INPUT,
 537     .name = "tls-async-process",
 538 };
 539
 540
 541 /* *INDENT-ON* */
 542
 543 /*
 544  * fd.io coding-style-patch-verification: ON
 545  *
 546  * Local Variables:
 547  * eval: (c-set-style "gnu")
 548  * End:
 549  */