lib/librte_ipsec/rte_ipsec_group.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #ifndef _RTE_IPSEC_GROUP_H_
   6 #define _RTE_IPSEC_GROUP_H_
   7
   8 /**
   9  * @file rte_ipsec_group.h
  10  * @b EXPERIMENTAL: this API may change without prior notice
  11  *
  12  * RTE IPsec support.
  13  * It is not recommended to include this file directly,
  14  * include <rte_ipsec.h> instead.
  15  * Contains helper functions to process completed crypto-ops
  16  * and group related packets by sessions they belong to.
  17  */
  18
  19
  20 #ifdef __cplusplus
  21 extern "C" {
  22 #endif
  23
  24 /**
  25  * Used to group mbufs by some id.
  26  * See below for particular usage.
  27  */
  28 struct rte_ipsec_group {
  29         union {
  30                 uint64_t val;
  31                 void *ptr;
  32         } id; /**< grouped by value */
  33         struct rte_mbuf **m;  /**< start of the group */
  34         uint32_t cnt;         /**< number of entries in the group */
  35         int32_t rc;           /**< status code associated with the group */
  36 };
  37
  38 /**
  39  * Take crypto-op as an input and extract pointer to related ipsec session.
  40  * @param cop
  41  *   The address of an input *rte_crypto_op* structure.
  42  * @return
  43  *   The pointer to the related *rte_ipsec_session* structure.
  44  */
  45 __rte_experimental
  46 static inline struct rte_ipsec_session *
  47 rte_ipsec_ses_from_crypto(const struct rte_crypto_op *cop)
  48 {
  49         const struct rte_security_session *ss;
  50         const struct rte_cryptodev_sym_session *cs;
  51
  52         if (cop->sess_type == RTE_CRYPTO_OP_SECURITY_SESSION) {
  53                 ss = cop->sym[0].sec_session;
  54                 return (void *)(uintptr_t)ss->opaque_data;
  55         } else if (cop->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
  56                 cs = cop->sym[0].session;
  57                 return (void *)(uintptr_t)cs->opaque_data;
  58         }
  59         return NULL;
  60 }
  61
  62 /**
  63  * Take as input completed crypto ops, extract related mbufs
  64  * and group them by rte_ipsec_session they belong to.
  65  * For mbuf which crypto-op wasn't completed successfully
  66  * PKT_RX_SEC_OFFLOAD_FAILED will be raised in ol_flags.
  67  * Note that mbufs with undetermined SA (session-less) are not freed
  68  * by the function, but are placed beyond mbufs for the last valid group.
  69  * It is a user responsibility to handle them further.
  70  * @param cop
  71  *   The address of an array of *num* pointers to the input *rte_crypto_op*
  72  *   structures.
  73  * @param mb
  74  *   The address of an array of *num* pointers to output *rte_mbuf* structures.
  75  * @param grp
  76  *   The address of an array of *num* to output *rte_ipsec_group* structures.
  77  * @param num
  78  *   The maximum number of crypto-ops to process.
  79  * @return
  80  *   Number of filled elements in *grp* array.
  81  */
  82 __rte_experimental
  83 static inline uint16_t
  84 rte_ipsec_pkt_crypto_group(const struct rte_crypto_op *cop[],
  85         struct rte_mbuf *mb[], struct rte_ipsec_group grp[], uint16_t num)
  86 {
  87         uint32_t i, j, k, n;
  88         void *ns, *ps;
  89         struct rte_mbuf *m, *dr[num];
  90
  91         j = 0;
  92         k = 0;
  93         n = 0;
  94         ps = NULL;
  95
  96         for (i = 0; i != num; i++) {
  97
  98                 m = cop[i]->sym[0].m_src;
  99                 ns = cop[i]->sym[0].session;
 100
 101                 m->ol_flags |= PKT_RX_SEC_OFFLOAD;
 102                 if (cop[i]->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
 103                         m->ol_flags |= PKT_RX_SEC_OFFLOAD_FAILED;
 104
 105                 /* no valid session found */
 106                 if (ns == NULL) {
 107                         dr[k++] = m;
 108                         continue;
 109                 }
 110
 111                 /* different SA */
 112                 if (ps != ns) {
 113
 114                         /*
 115                          * we already have an open group - finalize it,
 116                          * then open a new one.
 117                          */
 118                         if (ps != NULL) {
 119                                 grp[n].id.ptr =
 120                                         rte_ipsec_ses_from_crypto(cop[i - 1]);
 121                                 grp[n].cnt = mb + j - grp[n].m;
 122                                 n++;
 123                         }
 124
 125                         /* start new group */
 126                         grp[n].m = mb + j;
 127                         ps = ns;
 128                 }
 129
 130                 mb[j++] = m;
 131         }
 132
 133         /* finalise last group */
 134         if (ps != NULL) {
 135                 grp[n].id.ptr = rte_ipsec_ses_from_crypto(cop[i - 1]);
 136                 grp[n].cnt = mb + j - grp[n].m;
 137                 n++;
 138         }
 139
 140         /* copy mbufs with unknown session beyond recognised ones */
 141         if (k != 0 && k != num) {
 142                 for (i = 0; i != k; i++)
 143                         mb[j + i] = dr[i];
 144         }
 145
 146         return n;
 147 }
 148
 149 #ifdef __cplusplus
 150 }
 151 #endif
 152
 153 #endif /* _RTE_IPSEC_GROUP_H_ */