ipsec: add support for chained buffers

[vpp.git] / src / vnet / crypto / crypto.h

diff --git a/src/vnet/crypto/crypto.h b/src/vnet/crypto/crypto.h
index 626e71d..f89ecf9 100644 (file)
--- a/src/vnet/crypto/crypto.h
+++ b/src/vnet/crypto/crypto.h
@@ -116,38 +116,82 @@ typedef enum
 } vnet_crypto_op_id_t;
 /* *INDENT-ON* */
 
+typedef enum
+{
+  CRYPTO_OP_SIMPLE,
+  CRYPTO_OP_CHAINED,
+  CRYPTO_OP_BOTH,
+} crypto_op_class_type_t;
+
 typedef struct
 {
   char *name;
   vnet_crypto_op_id_t op_by_type[VNET_CRYPTO_OP_N_TYPES];
 } vnet_crypto_alg_data_t;
 
+typedef struct
+{
+  u8 *src;
+  u8 *dst;
+  u32 len;
+} vnet_crypto_op_chunk_t;
+
 typedef struct
 {
   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
+  uword user_data;
   vnet_crypto_op_id_t op:16;
   vnet_crypto_op_status_t status:8;
   u8 flags;
 #define VNET_CRYPTO_OP_FLAG_INIT_IV (1 << 0)
 #define VNET_CRYPTO_OP_FLAG_HMAC_CHECK (1 << 1)
-  u32 key_index;
-  u32 len;
+#define VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS (1 << 2)
+
+  union
+  {
+    u8 digest_len;
+    u8 tag_len;
+  };
   u16 aad_len;
-  u8 digest_len, tag_len;
+
+  union
+  {
+    struct
+    {
+      u8 *src;
+      u8 *dst;
+    };
+
+    /* valid if VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS is set */
+    u16 n_chunks;
+  };
+
+  union
+  {
+    u32 len;
+    /* valid if VNET_CRYPTO_OP_FLAG_CHAINED_BUFFERS is set */
+    u32 chunk_index;
+  };
+
+  u32 key_index;
   u8 *iv;
-  u8 *src;
-  u8 *dst;
   u8 *aad;
-  u8 *tag;
-  u8 *digest;
-  uword user_data;
+
+  union
+  {
+    u8 *tag;
+    u8 *digest;
+  };
 } vnet_crypto_op_t;
 
+STATIC_ASSERT_SIZEOF (vnet_crypto_op_t, CLIB_CACHE_LINE_BYTES);
+
 typedef struct
 {
   vnet_crypto_op_type_t type;
   vnet_crypto_alg_t alg;
-  u32 active_engine_index;
+  u32 active_engine_index_simple;
+  u32 active_engine_index_chained;
 } vnet_crypto_op_data_t;
 
 typedef struct
@@ -158,6 +202,11 @@ typedef struct
 
 typedef u32 vnet_crypto_key_index_t;
 
+typedef u32 (vnet_crypto_chained_ops_handler_t) (vlib_main_t * vm,
+                                                vnet_crypto_op_t * ops[],
+                                                vnet_crypto_op_chunk_t *
+                                                chunks, u32 n_ops);
+
 typedef u32 (vnet_crypto_ops_handler_t) (vlib_main_t * vm,
                                         vnet_crypto_op_t * ops[], u32 n_ops);
 
@@ -171,6 +220,18 @@ u32 vnet_crypto_register_engine (vlib_main_t * vm, char *name, int prio,
 void vnet_crypto_register_ops_handler (vlib_main_t * vm, u32 engine_index,
                                       vnet_crypto_op_id_t opt,
                                       vnet_crypto_ops_handler_t * oph);
+
+void vnet_crypto_register_chained_ops_handler (vlib_main_t * vm,
+                                              u32 engine_index,
+                                              vnet_crypto_op_id_t opt,
+                                              vnet_crypto_chained_ops_handler_t
+                                              * oph);
+void vnet_crypto_register_ops_handlers (vlib_main_t * vm, u32 engine_index,
+                                       vnet_crypto_op_id_t opt,
+                                       vnet_crypto_ops_handler_t * fn,
+                                       vnet_crypto_chained_ops_handler_t *
+                                       cfn);
+
 void vnet_crypto_register_key_handler (vlib_main_t * vm, u32 engine_index,
                                       vnet_crypto_key_handler_t * keyh);
 
@@ -181,6 +242,8 @@ typedef struct
   int priority;
   vnet_crypto_key_handler_t *key_op_handler;
   vnet_crypto_ops_handler_t *ops_handlers[VNET_CRYPTO_N_OP_IDS];
+    vnet_crypto_chained_ops_handler_t
+    * chained_ops_handlers[VNET_CRYPTO_N_OP_IDS];
 } vnet_crypto_engine_t;
 
 typedef struct
@@ -188,6 +251,7 @@ typedef struct
   vnet_crypto_alg_data_t *algs;
   vnet_crypto_thread_t *threads;
   vnet_crypto_ops_handler_t **ops_handlers;
+  vnet_crypto_chained_ops_handler_t **chained_ops_handlers;
   vnet_crypto_op_data_t opt_data[VNET_CRYPTO_N_OP_IDS];
   vnet_crypto_engine_t *engines;
   vnet_crypto_key_t *keys;
@@ -200,10 +264,14 @@ extern vnet_crypto_main_t crypto_main;
 u32 vnet_crypto_submit_ops (vlib_main_t * vm, vnet_crypto_op_t ** jobs,
                            u32 n_jobs);
 
+u32 vnet_crypto_process_chained_ops (vlib_main_t * vm, vnet_crypto_op_t ops[],
+                                    vnet_crypto_op_chunk_t * chunks,
+                                    u32 n_ops);
 u32 vnet_crypto_process_ops (vlib_main_t * vm, vnet_crypto_op_t ops[],
                             u32 n_ops);
 
-int vnet_crypto_set_handler (char *ops_handler_name, char *engine);
+int vnet_crypto_set_handler2 (char *ops_handler_name, char *engine,
+                             crypto_op_class_type_t oct);
 int vnet_crypto_is_set_handler (vnet_crypto_alg_t alg);
 
 u32 vnet_crypto_key_add (vlib_main_t * vm, vnet_crypto_alg_t alg,
@@ -225,6 +293,7 @@ vnet_crypto_op_init (vnet_crypto_op_t * op, vnet_crypto_op_id_t type)
   op->op = type;
   op->flags = 0;
   op->key_index = ~0;
+  op->n_chunks = 0;
 }
 
 static_always_inline vnet_crypto_op_type_t
@@ -243,6 +312,12 @@ vnet_crypto_get_key (vnet_crypto_key_index_t index)
   return vec_elt_at_index (cm->keys, index);
 }
 
+static_always_inline int
+vnet_crypto_set_handler (char *alg_name, char *engine)
+{
+  return vnet_crypto_set_handler2 (alg_name, engine, CRYPTO_OP_BOTH);
+}
+
 #endif /* included_vnet_crypto_crypto_h */
 
 /*