lib/librte_ipsec/sa.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <rte_ipsec.h>
   6 #include <rte_esp.h>
   7 #include <rte_ip.h>
   8 #include <rte_errno.h>
   9 #include <rte_cryptodev.h>
  10
  11 #include "sa.h"
  12 #include "ipsec_sqn.h"
  13 #include "crypto.h"
  14 #include "iph.h"
  15 #include "pad.h"
  16
  17 #define MBUF_MAX_L2_LEN         RTE_LEN2MASK(RTE_MBUF_L2_LEN_BITS, uint64_t)
  18 #define MBUF_MAX_L3_LEN         RTE_LEN2MASK(RTE_MBUF_L3_LEN_BITS, uint64_t)
  19
  20 /* some helper structures */
  21 struct crypto_xform {
  22         struct rte_crypto_auth_xform *auth;
  23         struct rte_crypto_cipher_xform *cipher;
  24         struct rte_crypto_aead_xform *aead;
  25 };
  26
  27 /*
  28  * helper routine, fills internal crypto_xform structure.
  29  */
  30 static int
  31 fill_crypto_xform(struct crypto_xform *xform, uint64_t type,
  32         const struct rte_ipsec_sa_prm *prm)
  33 {
  34         struct rte_crypto_sym_xform *xf, *xfn;
  35
  36         memset(xform, 0, sizeof(*xform));
  37
  38         xf = prm->crypto_xform;
  39         if (xf == NULL)
  40                 return -EINVAL;
  41
  42         xfn = xf->next;
  43
  44         /* for AEAD just one xform required */
  45         if (xf->type == RTE_CRYPTO_SYM_XFORM_AEAD) {
  46                 if (xfn != NULL)
  47                         return -EINVAL;
  48                 xform->aead = &xf->aead;
  49         /*
  50          * CIPHER+AUTH xforms are expected in strict order,
  51          * depending on SA direction:
  52          * inbound: AUTH+CIPHER
  53          * outbound: CIPHER+AUTH
  54          */
  55         } else if ((type & RTE_IPSEC_SATP_DIR_MASK) == RTE_IPSEC_SATP_DIR_IB) {
  56
  57                 /* wrong order or no cipher */
  58                 if (xfn == NULL || xf->type != RTE_CRYPTO_SYM_XFORM_AUTH ||
  59                                 xfn->type != RTE_CRYPTO_SYM_XFORM_CIPHER)
  60                         return -EINVAL;
  61
  62                 xform->auth = &xf->auth;
  63                 xform->cipher = &xfn->cipher;
  64
  65         } else {
  66
  67                 /* wrong order or no auth */
  68                 if (xfn == NULL || xf->type != RTE_CRYPTO_SYM_XFORM_CIPHER ||
  69                                 xfn->type != RTE_CRYPTO_SYM_XFORM_AUTH)
  70                         return -EINVAL;
  71
  72                 xform->cipher = &xf->cipher;
  73                 xform->auth = &xfn->auth;
  74         }
  75
  76         return 0;
  77 }
  78
  79 uint64_t __rte_experimental
  80 rte_ipsec_sa_type(const struct rte_ipsec_sa *sa)
  81 {
  82         return sa->type;
  83 }
  84
  85 static int32_t
  86 ipsec_sa_size(uint64_t type, uint32_t *wnd_sz, uint32_t *nb_bucket)
  87 {
  88         uint32_t n, sz, wsz;
  89
  90         wsz = *wnd_sz;
  91         n = 0;
  92
  93         if ((type & RTE_IPSEC_SATP_DIR_MASK) == RTE_IPSEC_SATP_DIR_IB) {
  94
  95                 /*
  96                  * RFC 4303 recommends 64 as minimum window size.
  97                  * there is no point to use ESN mode without SQN window,
  98                  * so make sure we have at least 64 window when ESN is enalbed.
  99                  */
 100                 wsz = ((type & RTE_IPSEC_SATP_ESN_MASK) ==
 101                         RTE_IPSEC_SATP_ESN_DISABLE) ?
 102                         wsz : RTE_MAX(wsz, (uint32_t)WINDOW_BUCKET_SIZE);
 103                 if (wsz != 0)
 104                         n = replay_num_bucket(wsz);
 105         }
 106
 107         if (n > WINDOW_BUCKET_MAX)
 108                 return -EINVAL;
 109
 110         *wnd_sz = wsz;
 111         *nb_bucket = n;
 112
 113         sz = rsn_size(n);
 114         if ((type & RTE_IPSEC_SATP_SQN_MASK) == RTE_IPSEC_SATP_SQN_ATOM)
 115                 sz *= REPLAY_SQN_NUM;
 116
 117         sz += sizeof(struct rte_ipsec_sa);
 118         return sz;
 119 }
 120
 121 void __rte_experimental
 122 rte_ipsec_sa_fini(struct rte_ipsec_sa *sa)
 123 {
 124         memset(sa, 0, sa->size);
 125 }
 126
 127 /*
 128  * Determine expected SA type based on input parameters.
 129  */
 130 static int
 131 fill_sa_type(const struct rte_ipsec_sa_prm *prm, uint64_t *type)
 132 {
 133         uint64_t tp;
 134
 135         tp = 0;
 136
 137         if (prm->ipsec_xform.proto == RTE_SECURITY_IPSEC_SA_PROTO_AH)
 138                 tp |= RTE_IPSEC_SATP_PROTO_AH;
 139         else if (prm->ipsec_xform.proto == RTE_SECURITY_IPSEC_SA_PROTO_ESP)
 140                 tp |= RTE_IPSEC_SATP_PROTO_ESP;
 141         else
 142                 return -EINVAL;
 143
 144         if (prm->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
 145                 tp |= RTE_IPSEC_SATP_DIR_OB;
 146         else if (prm->ipsec_xform.direction ==
 147                         RTE_SECURITY_IPSEC_SA_DIR_INGRESS)
 148                 tp |= RTE_IPSEC_SATP_DIR_IB;
 149         else
 150                 return -EINVAL;
 151
 152         if (prm->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
 153                 if (prm->ipsec_xform.tunnel.type ==
 154                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4)
 155                         tp |= RTE_IPSEC_SATP_MODE_TUNLV4;
 156                 else if (prm->ipsec_xform.tunnel.type ==
 157                                 RTE_SECURITY_IPSEC_TUNNEL_IPV6)
 158                         tp |= RTE_IPSEC_SATP_MODE_TUNLV6;
 159                 else
 160                         return -EINVAL;
 161
 162                 if (prm->tun.next_proto == IPPROTO_IPIP)
 163                         tp |= RTE_IPSEC_SATP_IPV4;
 164                 else if (prm->tun.next_proto == IPPROTO_IPV6)
 165                         tp |= RTE_IPSEC_SATP_IPV6;
 166                 else
 167                         return -EINVAL;
 168         } else if (prm->ipsec_xform.mode ==
 169                         RTE_SECURITY_IPSEC_SA_MODE_TRANSPORT) {
 170                 tp |= RTE_IPSEC_SATP_MODE_TRANS;
 171                 if (prm->trs.proto == IPPROTO_IPIP)
 172                         tp |= RTE_IPSEC_SATP_IPV4;
 173                 else if (prm->trs.proto == IPPROTO_IPV6)
 174                         tp |= RTE_IPSEC_SATP_IPV6;
 175                 else
 176                         return -EINVAL;
 177         } else
 178                 return -EINVAL;
 179
 180         /* check for ESN flag */
 181         if (prm->ipsec_xform.options.esn == 0)
 182                 tp |= RTE_IPSEC_SATP_ESN_DISABLE;
 183         else
 184                 tp |= RTE_IPSEC_SATP_ESN_ENABLE;
 185
 186         /* interpret flags */
 187         if (prm->flags & RTE_IPSEC_SAFLAG_SQN_ATOM)
 188                 tp |= RTE_IPSEC_SATP_SQN_ATOM;
 189         else
 190                 tp |= RTE_IPSEC_SATP_SQN_RAW;
 191
 192         *type = tp;
 193         return 0;
 194 }
 195
 196 /*
 197  * Init ESP inbound specific things.
 198  */
 199 static void
 200 esp_inb_init(struct rte_ipsec_sa *sa)
 201 {
 202         /* these params may differ with new algorithms support */
 203         sa->ctp.auth.offset = 0;
 204         sa->ctp.auth.length = sa->icv_len - sa->sqh_len;
 205         sa->ctp.cipher.offset = sizeof(struct esp_hdr) + sa->iv_len;
 206         sa->ctp.cipher.length = sa->icv_len + sa->ctp.cipher.offset;
 207 }
 208
 209 /*
 210  * Init ESP inbound tunnel specific things.
 211  */
 212 static void
 213 esp_inb_tun_init(struct rte_ipsec_sa *sa, const struct rte_ipsec_sa_prm *prm)
 214 {
 215         sa->proto = prm->tun.next_proto;
 216         esp_inb_init(sa);
 217 }
 218
 219 /*
 220  * Init ESP outbound specific things.
 221  */
 222 static void
 223 esp_outb_init(struct rte_ipsec_sa *sa, uint32_t hlen)
 224 {
 225         uint8_t algo_type;
 226
 227         sa->sqn.outb.raw = 1;
 228
 229         /* these params may differ with new algorithms support */
 230         sa->ctp.auth.offset = hlen;
 231         sa->ctp.auth.length = sizeof(struct esp_hdr) + sa->iv_len + sa->sqh_len;
 232
 233         algo_type = sa->algo_type;
 234
 235         switch (algo_type) {
 236         case ALGO_TYPE_AES_GCM:
 237         case ALGO_TYPE_AES_CTR:
 238         case ALGO_TYPE_NULL:
 239                 sa->ctp.cipher.offset = hlen + sizeof(struct esp_hdr) +
 240                         sa->iv_len;
 241                 sa->ctp.cipher.length = 0;
 242                 break;
 243         case ALGO_TYPE_AES_CBC:
 244         case ALGO_TYPE_3DES_CBC:
 245                 sa->ctp.cipher.offset = sa->hdr_len + sizeof(struct esp_hdr);
 246                 sa->ctp.cipher.length = sa->iv_len;
 247                 break;
 248         }
 249 }
 250
 251 /*
 252  * Init ESP outbound tunnel specific things.
 253  */
 254 static void
 255 esp_outb_tun_init(struct rte_ipsec_sa *sa, const struct rte_ipsec_sa_prm *prm)
 256 {
 257         sa->proto = prm->tun.next_proto;
 258         sa->hdr_len = prm->tun.hdr_len;
 259         sa->hdr_l3_off = prm->tun.hdr_l3_off;
 260
 261         /* update l2_len and l3_len fields for outbound mbuf */
 262         sa->tx_offload.val = rte_mbuf_tx_offload(sa->hdr_l3_off,
 263                 sa->hdr_len - sa->hdr_l3_off, 0, 0, 0, 0, 0);
 264
 265         memcpy(sa->hdr, prm->tun.hdr, sa->hdr_len);
 266
 267         esp_outb_init(sa, sa->hdr_len);
 268 }
 269
 270 /*
 271  * helper function, init SA structure.
 272  */
 273 static int
 274 esp_sa_init(struct rte_ipsec_sa *sa, const struct rte_ipsec_sa_prm *prm,
 275         const struct crypto_xform *cxf)
 276 {
 277         static const uint64_t msk = RTE_IPSEC_SATP_DIR_MASK |
 278                                 RTE_IPSEC_SATP_MODE_MASK;
 279
 280         if (cxf->aead != NULL) {
 281                 switch (cxf->aead->algo) {
 282                 case RTE_CRYPTO_AEAD_AES_GCM:
 283                         /* RFC 4106 */
 284                         sa->aad_len = sizeof(struct aead_gcm_aad);
 285                         sa->icv_len = cxf->aead->digest_length;
 286                         sa->iv_ofs = cxf->aead->iv.offset;
 287                         sa->iv_len = sizeof(uint64_t);
 288                         sa->pad_align = IPSEC_PAD_AES_GCM;
 289                         sa->algo_type = ALGO_TYPE_AES_GCM;
 290                         break;
 291                 default:
 292                         return -EINVAL;
 293                 }
 294         } else {
 295                 sa->icv_len = cxf->auth->digest_length;
 296                 sa->iv_ofs = cxf->cipher->iv.offset;
 297                 sa->sqh_len = IS_ESN(sa) ? sizeof(uint32_t) : 0;
 298
 299                 switch (cxf->cipher->algo) {
 300                 case RTE_CRYPTO_CIPHER_NULL:
 301                         sa->pad_align = IPSEC_PAD_NULL;
 302                         sa->iv_len = 0;
 303                         sa->algo_type = ALGO_TYPE_NULL;
 304                         break;
 305
 306                 case RTE_CRYPTO_CIPHER_AES_CBC:
 307                         sa->pad_align = IPSEC_PAD_AES_CBC;
 308                         sa->iv_len = IPSEC_MAX_IV_SIZE;
 309                         sa->algo_type = ALGO_TYPE_AES_CBC;
 310                         break;
 311
 312                 case RTE_CRYPTO_CIPHER_AES_CTR:
 313                         /* RFC 3686 */
 314                         sa->pad_align = IPSEC_PAD_AES_CTR;
 315                         sa->iv_len = IPSEC_AES_CTR_IV_SIZE;
 316                         sa->algo_type = ALGO_TYPE_AES_CTR;
 317                         break;
 318
 319                 case RTE_CRYPTO_CIPHER_3DES_CBC:
 320                         /* RFC 1851 */
 321                         sa->pad_align = IPSEC_PAD_3DES_CBC;
 322                         sa->iv_len = IPSEC_3DES_IV_SIZE;
 323                         sa->algo_type = ALGO_TYPE_3DES_CBC;
 324                         break;
 325
 326                 default:
 327                         return -EINVAL;
 328                 }
 329         }
 330
 331         sa->udata = prm->userdata;
 332         sa->spi = rte_cpu_to_be_32(prm->ipsec_xform.spi);
 333         sa->salt = prm->ipsec_xform.salt;
 334
 335         /* preserve all values except l2_len and l3_len */
 336         sa->tx_offload.msk =
 337                 ~rte_mbuf_tx_offload(MBUF_MAX_L2_LEN, MBUF_MAX_L3_LEN,
 338                                 0, 0, 0, 0, 0);
 339
 340         switch (sa->type & msk) {
 341         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TUNLV4):
 342         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TUNLV6):
 343                 esp_inb_tun_init(sa, prm);
 344                 break;
 345         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TRANS):
 346                 esp_inb_init(sa);
 347                 break;
 348         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TUNLV4):
 349         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TUNLV6):
 350                 esp_outb_tun_init(sa, prm);
 351                 break;
 352         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TRANS):
 353                 esp_outb_init(sa, 0);
 354                 break;
 355         }
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * helper function, init SA replay structure.
 362  */
 363 static void
 364 fill_sa_replay(struct rte_ipsec_sa *sa, uint32_t wnd_sz, uint32_t nb_bucket)
 365 {
 366         sa->replay.win_sz = wnd_sz;
 367         sa->replay.nb_bucket = nb_bucket;
 368         sa->replay.bucket_index_mask = nb_bucket - 1;
 369         sa->sqn.inb.rsn[0] = (struct replay_sqn *)(sa + 1);
 370         if ((sa->type & RTE_IPSEC_SATP_SQN_MASK) == RTE_IPSEC_SATP_SQN_ATOM)
 371                 sa->sqn.inb.rsn[1] = (struct replay_sqn *)
 372                         ((uintptr_t)sa->sqn.inb.rsn[0] + rsn_size(nb_bucket));
 373 }
 374
 375 int __rte_experimental
 376 rte_ipsec_sa_size(const struct rte_ipsec_sa_prm *prm)
 377 {
 378         uint64_t type;
 379         uint32_t nb, wsz;
 380         int32_t rc;
 381
 382         if (prm == NULL)
 383                 return -EINVAL;
 384
 385         /* determine SA type */
 386         rc = fill_sa_type(prm, &type);
 387         if (rc != 0)
 388                 return rc;
 389
 390         /* determine required size */
 391         wsz = prm->replay_win_sz;
 392         return ipsec_sa_size(type, &wsz, &nb);
 393 }
 394
 395 int __rte_experimental
 396 rte_ipsec_sa_init(struct rte_ipsec_sa *sa, const struct rte_ipsec_sa_prm *prm,
 397         uint32_t size)
 398 {
 399         int32_t rc, sz;
 400         uint32_t nb, wsz;
 401         uint64_t type;
 402         struct crypto_xform cxf;
 403
 404         if (sa == NULL || prm == NULL)
 405                 return -EINVAL;
 406
 407         /* determine SA type */
 408         rc = fill_sa_type(prm, &type);
 409         if (rc != 0)
 410                 return rc;
 411
 412         /* determine required size */
 413         wsz = prm->replay_win_sz;
 414         sz = ipsec_sa_size(type, &wsz, &nb);
 415         if (sz < 0)
 416                 return sz;
 417         else if (size < (uint32_t)sz)
 418                 return -ENOSPC;
 419
 420         /* only esp is supported right now */
 421         if (prm->ipsec_xform.proto != RTE_SECURITY_IPSEC_SA_PROTO_ESP)
 422                 return -EINVAL;
 423
 424         if (prm->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL &&
 425                         prm->tun.hdr_len > sizeof(sa->hdr))
 426                 return -EINVAL;
 427
 428         rc = fill_crypto_xform(&cxf, type, prm);
 429         if (rc != 0)
 430                 return rc;
 431
 432         /* initialize SA */
 433
 434         memset(sa, 0, sz);
 435         sa->type = type;
 436         sa->size = sz;
 437
 438         /* check for ESN flag */
 439         sa->sqn_mask = (prm->ipsec_xform.options.esn == 0) ?
 440                 UINT32_MAX : UINT64_MAX;
 441
 442         rc = esp_sa_init(sa, prm, &cxf);
 443         if (rc != 0)
 444                 rte_ipsec_sa_fini(sa);
 445
 446         /* fill replay window related fields */
 447         if (nb != 0)
 448                 fill_sa_replay(sa, wsz, nb);
 449
 450         return sz;
 451 }
 452
 453 static inline void
 454 mbuf_bulk_copy(struct rte_mbuf *dst[], struct rte_mbuf * const src[],
 455         uint32_t num)
 456 {
 457         uint32_t i;
 458
 459         for (i = 0; i != num; i++)
 460                 dst[i] = src[i];
 461 }
 462
 463 /*
 464  * setup crypto ops for LOOKASIDE_NONE (pure crypto) type of devices.
 465  */
 466 static inline void
 467 lksd_none_cop_prepare(struct rte_crypto_op *cop,
 468         struct rte_cryptodev_sym_session *cs, struct rte_mbuf *mb)
 469 {
 470         struct rte_crypto_sym_op *sop;
 471
 472         sop = cop->sym;
 473         cop->type = RTE_CRYPTO_OP_TYPE_SYMMETRIC;
 474         cop->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
 475         cop->sess_type = RTE_CRYPTO_OP_WITH_SESSION;
 476         sop->m_src = mb;
 477         __rte_crypto_sym_op_attach_sym_session(sop, cs);
 478 }
 479
 480 /*
 481  * setup crypto op and crypto sym op for ESP outbound packet.
 482  */
 483 static inline void
 484 esp_outb_cop_prepare(struct rte_crypto_op *cop,
 485         const struct rte_ipsec_sa *sa, const uint64_t ivp[IPSEC_MAX_IV_QWORD],
 486         const union sym_op_data *icv, uint32_t hlen, uint32_t plen)
 487 {
 488         struct rte_crypto_sym_op *sop;
 489         struct aead_gcm_iv *gcm;
 490         struct aesctr_cnt_blk *ctr;
 491         uint8_t algo_type = sa->algo_type;
 492
 493         /* fill sym op fields */
 494         sop = cop->sym;
 495
 496         switch (algo_type) {
 497         case ALGO_TYPE_AES_CBC:
 498                 /* Cipher-Auth (AES-CBC *) case */
 499         case ALGO_TYPE_3DES_CBC:
 500                 /* Cipher-Auth (3DES-CBC *) case */
 501         case ALGO_TYPE_NULL:
 502                 /* NULL case */
 503                 sop->cipher.data.offset = sa->ctp.cipher.offset + hlen;
 504                 sop->cipher.data.length = sa->ctp.cipher.length + plen;
 505                 sop->auth.data.offset = sa->ctp.auth.offset + hlen;
 506                 sop->auth.data.length = sa->ctp.auth.length + plen;
 507                 sop->auth.digest.data = icv->va;
 508                 sop->auth.digest.phys_addr = icv->pa;
 509                 break;
 510         case ALGO_TYPE_AES_GCM:
 511                 /* AEAD (AES_GCM) case */
 512                 sop->aead.data.offset = sa->ctp.cipher.offset + hlen;
 513                 sop->aead.data.length = sa->ctp.cipher.length + plen;
 514                 sop->aead.digest.data = icv->va;
 515                 sop->aead.digest.phys_addr = icv->pa;
 516                 sop->aead.aad.data = icv->va + sa->icv_len;
 517                 sop->aead.aad.phys_addr = icv->pa + sa->icv_len;
 518
 519                 /* fill AAD IV (located inside crypto op) */
 520                 gcm = rte_crypto_op_ctod_offset(cop, struct aead_gcm_iv *,
 521                         sa->iv_ofs);
 522                 aead_gcm_iv_fill(gcm, ivp[0], sa->salt);
 523                 break;
 524         case ALGO_TYPE_AES_CTR:
 525                 /* Cipher-Auth (AES-CTR *) case */
 526                 sop->cipher.data.offset = sa->ctp.cipher.offset + hlen;
 527                 sop->cipher.data.length = sa->ctp.cipher.length + plen;
 528                 sop->auth.data.offset = sa->ctp.auth.offset + hlen;
 529                 sop->auth.data.length = sa->ctp.auth.length + plen;
 530                 sop->auth.digest.data = icv->va;
 531                 sop->auth.digest.phys_addr = icv->pa;
 532
 533                 ctr = rte_crypto_op_ctod_offset(cop, struct aesctr_cnt_blk *,
 534                         sa->iv_ofs);
 535                 aes_ctr_cnt_blk_fill(ctr, ivp[0], sa->salt);
 536                 break;
 537         default:
 538                 break;
 539         }
 540 }
 541
 542 /*
 543  * setup/update packet data and metadata for ESP outbound tunnel case.
 544  */
 545 static inline int32_t
 546 esp_outb_tun_pkt_prepare(struct rte_ipsec_sa *sa, rte_be64_t sqc,
 547         const uint64_t ivp[IPSEC_MAX_IV_QWORD], struct rte_mbuf *mb,
 548         union sym_op_data *icv)
 549 {
 550         uint32_t clen, hlen, l2len, pdlen, pdofs, plen, tlen;
 551         struct rte_mbuf *ml;
 552         struct esp_hdr *esph;
 553         struct esp_tail *espt;
 554         char *ph, *pt;
 555         uint64_t *iv;
 556
 557         /* calculate extra header space required */
 558         hlen = sa->hdr_len + sa->iv_len + sizeof(*esph);
 559
 560         /* size of ipsec protected data */
 561         l2len = mb->l2_len;
 562         plen = mb->pkt_len - l2len;
 563
 564         /* number of bytes to encrypt */
 565         clen = plen + sizeof(*espt);
 566         clen = RTE_ALIGN_CEIL(clen, sa->pad_align);
 567
 568         /* pad length + esp tail */
 569         pdlen = clen - plen;
 570         tlen = pdlen + sa->icv_len;
 571
 572         /* do append and prepend */
 573         ml = rte_pktmbuf_lastseg(mb);
 574         if (tlen + sa->sqh_len + sa->aad_len > rte_pktmbuf_tailroom(ml))
 575                 return -ENOSPC;
 576
 577         /* prepend header */
 578         ph = rte_pktmbuf_prepend(mb, hlen - l2len);
 579         if (ph == NULL)
 580                 return -ENOSPC;
 581
 582         /* append tail */
 583         pdofs = ml->data_len;
 584         ml->data_len += tlen;
 585         mb->pkt_len += tlen;
 586         pt = rte_pktmbuf_mtod_offset(ml, typeof(pt), pdofs);
 587
 588         /* update pkt l2/l3 len */
 589         mb->tx_offload = (mb->tx_offload & sa->tx_offload.msk) |
 590                 sa->tx_offload.val;
 591
 592         /* copy tunnel pkt header */
 593         rte_memcpy(ph, sa->hdr, sa->hdr_len);
 594
 595         /* update original and new ip header fields */
 596         update_tun_l3hdr(sa, ph + sa->hdr_l3_off, mb->pkt_len, sa->hdr_l3_off,
 597                         sqn_low16(sqc));
 598
 599         /* update spi, seqn and iv */
 600         esph = (struct esp_hdr *)(ph + sa->hdr_len);
 601         iv = (uint64_t *)(esph + 1);
 602         copy_iv(iv, ivp, sa->iv_len);
 603
 604         esph->spi = sa->spi;
 605         esph->seq = sqn_low32(sqc);
 606
 607         /* offset for ICV */
 608         pdofs += pdlen + sa->sqh_len;
 609
 610         /* pad length */
 611         pdlen -= sizeof(*espt);
 612
 613         /* copy padding data */
 614         rte_memcpy(pt, esp_pad_bytes, pdlen);
 615
 616         /* update esp trailer */
 617         espt = (struct esp_tail *)(pt + pdlen);
 618         espt->pad_len = pdlen;
 619         espt->next_proto = sa->proto;
 620
 621         icv->va = rte_pktmbuf_mtod_offset(ml, void *, pdofs);
 622         icv->pa = rte_pktmbuf_iova_offset(ml, pdofs);
 623
 624         return clen;
 625 }
 626
 627 /*
 628  * for pure cryptodev (lookaside none) depending on SA settings,
 629  * we might have to write some extra data to the packet.
 630  */
 631 static inline void
 632 outb_pkt_xprepare(const struct rte_ipsec_sa *sa, rte_be64_t sqc,
 633         const union sym_op_data *icv)
 634 {
 635         uint32_t *psqh;
 636         struct aead_gcm_aad *aad;
 637         uint8_t algo_type = sa->algo_type;
 638
 639         /* insert SQN.hi between ESP trailer and ICV */
 640         if (sa->sqh_len != 0) {
 641                 psqh = (uint32_t *)(icv->va - sa->sqh_len);
 642                 psqh[0] = sqn_hi32(sqc);
 643         }
 644
 645         /*
 646          * fill IV and AAD fields, if any (aad fields are placed after icv),
 647          * right now we support only one AEAD algorithm: AES-GCM .
 648          */
 649         if (algo_type == ALGO_TYPE_AES_GCM) {
 650                 aad = (struct aead_gcm_aad *)(icv->va + sa->icv_len);
 651                 aead_gcm_aad_fill(aad, sa->spi, sqc, IS_ESN(sa));
 652         }
 653 }
 654
 655 /*
 656  * setup/update packets and crypto ops for ESP outbound tunnel case.
 657  */
 658 static uint16_t
 659 outb_tun_prepare(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
 660         struct rte_crypto_op *cop[], uint16_t num)
 661 {
 662         int32_t rc;
 663         uint32_t i, k, n;
 664         uint64_t sqn;
 665         rte_be64_t sqc;
 666         struct rte_ipsec_sa *sa;
 667         struct rte_cryptodev_sym_session *cs;
 668         union sym_op_data icv;
 669         uint64_t iv[IPSEC_MAX_IV_QWORD];
 670         struct rte_mbuf *dr[num];
 671
 672         sa = ss->sa;
 673         cs = ss->crypto.ses;
 674
 675         n = num;
 676         sqn = esn_outb_update_sqn(sa, &n);
 677         if (n != num)
 678                 rte_errno = EOVERFLOW;
 679
 680         k = 0;
 681         for (i = 0; i != n; i++) {
 682
 683                 sqc = rte_cpu_to_be_64(sqn + i);
 684                 gen_iv(iv, sqc);
 685
 686                 /* try to update the packet itself */
 687                 rc = esp_outb_tun_pkt_prepare(sa, sqc, iv, mb[i], &icv);
 688
 689                 /* success, setup crypto op */
 690                 if (rc >= 0) {
 691                         outb_pkt_xprepare(sa, sqc, &icv);
 692                         lksd_none_cop_prepare(cop[k], cs, mb[i]);
 693                         esp_outb_cop_prepare(cop[k], sa, iv, &icv, 0, rc);
 694                         mb[k++] = mb[i];
 695                 /* failure, put packet into the death-row */
 696                 } else {
 697                         dr[i - k] = mb[i];
 698                         rte_errno = -rc;
 699                 }
 700         }
 701
 702          /* copy not prepared mbufs beyond good ones */
 703         if (k != n && k != 0)
 704                 mbuf_bulk_copy(mb + k, dr, n - k);
 705
 706         return k;
 707 }
 708
 709 /*
 710  * setup/update packet data and metadata for ESP outbound transport case.
 711  */
 712 static inline int32_t
 713 esp_outb_trs_pkt_prepare(struct rte_ipsec_sa *sa, rte_be64_t sqc,
 714         const uint64_t ivp[IPSEC_MAX_IV_QWORD], struct rte_mbuf *mb,
 715         uint32_t l2len, uint32_t l3len, union sym_op_data *icv)
 716 {
 717         uint8_t np;
 718         uint32_t clen, hlen, pdlen, pdofs, plen, tlen, uhlen;
 719         struct rte_mbuf *ml;
 720         struct esp_hdr *esph;
 721         struct esp_tail *espt;
 722         char *ph, *pt;
 723         uint64_t *iv;
 724
 725         uhlen = l2len + l3len;
 726         plen = mb->pkt_len - uhlen;
 727
 728         /* calculate extra header space required */
 729         hlen = sa->iv_len + sizeof(*esph);
 730
 731         /* number of bytes to encrypt */
 732         clen = plen + sizeof(*espt);
 733         clen = RTE_ALIGN_CEIL(clen, sa->pad_align);
 734
 735         /* pad length + esp tail */
 736         pdlen = clen - plen;
 737         tlen = pdlen + sa->icv_len;
 738
 739         /* do append and insert */
 740         ml = rte_pktmbuf_lastseg(mb);
 741         if (tlen + sa->sqh_len + sa->aad_len > rte_pktmbuf_tailroom(ml))
 742                 return -ENOSPC;
 743
 744         /* prepend space for ESP header */
 745         ph = rte_pktmbuf_prepend(mb, hlen);
 746         if (ph == NULL)
 747                 return -ENOSPC;
 748
 749         /* append tail */
 750         pdofs = ml->data_len;
 751         ml->data_len += tlen;
 752         mb->pkt_len += tlen;
 753         pt = rte_pktmbuf_mtod_offset(ml, typeof(pt), pdofs);
 754
 755         /* shift L2/L3 headers */
 756         insert_esph(ph, ph + hlen, uhlen);
 757
 758         /* update ip  header fields */
 759         np = update_trs_l3hdr(sa, ph + l2len, mb->pkt_len, l2len, l3len,
 760                         IPPROTO_ESP);
 761
 762         /* update spi, seqn and iv */
 763         esph = (struct esp_hdr *)(ph + uhlen);
 764         iv = (uint64_t *)(esph + 1);
 765         copy_iv(iv, ivp, sa->iv_len);
 766
 767         esph->spi = sa->spi;
 768         esph->seq = sqn_low32(sqc);
 769
 770         /* offset for ICV */
 771         pdofs += pdlen + sa->sqh_len;
 772
 773         /* pad length */
 774         pdlen -= sizeof(*espt);
 775
 776         /* copy padding data */
 777         rte_memcpy(pt, esp_pad_bytes, pdlen);
 778
 779         /* update esp trailer */
 780         espt = (struct esp_tail *)(pt + pdlen);
 781         espt->pad_len = pdlen;
 782         espt->next_proto = np;
 783
 784         icv->va = rte_pktmbuf_mtod_offset(ml, void *, pdofs);
 785         icv->pa = rte_pktmbuf_iova_offset(ml, pdofs);
 786
 787         return clen;
 788 }
 789
 790 /*
 791  * setup/update packets and crypto ops for ESP outbound transport case.
 792  */
 793 static uint16_t
 794 outb_trs_prepare(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
 795         struct rte_crypto_op *cop[], uint16_t num)
 796 {
 797         int32_t rc;
 798         uint32_t i, k, n, l2, l3;
 799         uint64_t sqn;
 800         rte_be64_t sqc;
 801         struct rte_ipsec_sa *sa;
 802         struct rte_cryptodev_sym_session *cs;
 803         union sym_op_data icv;
 804         uint64_t iv[IPSEC_MAX_IV_QWORD];
 805         struct rte_mbuf *dr[num];
 806
 807         sa = ss->sa;
 808         cs = ss->crypto.ses;
 809
 810         n = num;
 811         sqn = esn_outb_update_sqn(sa, &n);
 812         if (n != num)
 813                 rte_errno = EOVERFLOW;
 814
 815         k = 0;
 816         for (i = 0; i != n; i++) {
 817
 818                 l2 = mb[i]->l2_len;
 819                 l3 = mb[i]->l3_len;
 820
 821                 sqc = rte_cpu_to_be_64(sqn + i);
 822                 gen_iv(iv, sqc);
 823
 824                 /* try to update the packet itself */
 825                 rc = esp_outb_trs_pkt_prepare(sa, sqc, iv, mb[i],
 826                                 l2, l3, &icv);
 827
 828                 /* success, setup crypto op */
 829                 if (rc >= 0) {
 830                         outb_pkt_xprepare(sa, sqc, &icv);
 831                         lksd_none_cop_prepare(cop[k], cs, mb[i]);
 832                         esp_outb_cop_prepare(cop[k], sa, iv, &icv, l2 + l3, rc);
 833                         mb[k++] = mb[i];
 834                 /* failure, put packet into the death-row */
 835                 } else {
 836                         dr[i - k] = mb[i];
 837                         rte_errno = -rc;
 838                 }
 839         }
 840
 841         /* copy not prepared mbufs beyond good ones */
 842         if (k != n && k != 0)
 843                 mbuf_bulk_copy(mb + k, dr, n - k);
 844
 845         return k;
 846 }
 847
 848 /*
 849  * setup crypto op and crypto sym op for ESP inbound tunnel packet.
 850  */
 851 static inline int32_t
 852 esp_inb_tun_cop_prepare(struct rte_crypto_op *cop,
 853         const struct rte_ipsec_sa *sa, struct rte_mbuf *mb,
 854         const union sym_op_data *icv, uint32_t pofs, uint32_t plen)
 855 {
 856         struct rte_crypto_sym_op *sop;
 857         struct aead_gcm_iv *gcm;
 858         struct aesctr_cnt_blk *ctr;
 859         uint64_t *ivc, *ivp;
 860         uint32_t clen;
 861         uint8_t algo_type = sa->algo_type;
 862
 863         clen = plen - sa->ctp.cipher.length;
 864         if ((int32_t)clen < 0 || (clen & (sa->pad_align - 1)) != 0)
 865                 return -EINVAL;
 866
 867         /* fill sym op fields */
 868         sop = cop->sym;
 869
 870         switch (algo_type) {
 871         case ALGO_TYPE_AES_GCM:
 872                 sop->aead.data.offset = pofs + sa->ctp.cipher.offset;
 873                 sop->aead.data.length = clen;
 874                 sop->aead.digest.data = icv->va;
 875                 sop->aead.digest.phys_addr = icv->pa;
 876                 sop->aead.aad.data = icv->va + sa->icv_len;
 877                 sop->aead.aad.phys_addr = icv->pa + sa->icv_len;
 878
 879                 /* fill AAD IV (located inside crypto op) */
 880                 gcm = rte_crypto_op_ctod_offset(cop, struct aead_gcm_iv *,
 881                         sa->iv_ofs);
 882                 ivp = rte_pktmbuf_mtod_offset(mb, uint64_t *,
 883                         pofs + sizeof(struct esp_hdr));
 884                 aead_gcm_iv_fill(gcm, ivp[0], sa->salt);
 885                 break;
 886         case ALGO_TYPE_AES_CBC:
 887         case ALGO_TYPE_3DES_CBC:
 888                 sop->cipher.data.offset = pofs + sa->ctp.cipher.offset;
 889                 sop->cipher.data.length = clen;
 890                 sop->auth.data.offset = pofs + sa->ctp.auth.offset;
 891                 sop->auth.data.length = plen - sa->ctp.auth.length;
 892                 sop->auth.digest.data = icv->va;
 893                 sop->auth.digest.phys_addr = icv->pa;
 894
 895                 /* copy iv from the input packet to the cop */
 896                 ivc = rte_crypto_op_ctod_offset(cop, uint64_t *, sa->iv_ofs);
 897                 ivp = rte_pktmbuf_mtod_offset(mb, uint64_t *,
 898                         pofs + sizeof(struct esp_hdr));
 899                 copy_iv(ivc, ivp, sa->iv_len);
 900                 break;
 901         case ALGO_TYPE_AES_CTR:
 902                 sop->cipher.data.offset = pofs + sa->ctp.cipher.offset;
 903                 sop->cipher.data.length = clen;
 904                 sop->auth.data.offset = pofs + sa->ctp.auth.offset;
 905                 sop->auth.data.length = plen - sa->ctp.auth.length;
 906                 sop->auth.digest.data = icv->va;
 907                 sop->auth.digest.phys_addr = icv->pa;
 908
 909                 /* copy iv from the input packet to the cop */
 910                 ctr = rte_crypto_op_ctod_offset(cop, struct aesctr_cnt_blk *,
 911                         sa->iv_ofs);
 912                 ivp = rte_pktmbuf_mtod_offset(mb, uint64_t *,
 913                         pofs + sizeof(struct esp_hdr));
 914                 aes_ctr_cnt_blk_fill(ctr, ivp[0], sa->salt);
 915                 break;
 916         case ALGO_TYPE_NULL:
 917                 sop->cipher.data.offset = pofs + sa->ctp.cipher.offset;
 918                 sop->cipher.data.length = clen;
 919                 sop->auth.data.offset = pofs + sa->ctp.auth.offset;
 920                 sop->auth.data.length = plen - sa->ctp.auth.length;
 921                 sop->auth.digest.data = icv->va;
 922                 sop->auth.digest.phys_addr = icv->pa;
 923                 break;
 924
 925         default:
 926                 return -EINVAL;
 927         }
 928
 929         return 0;
 930 }
 931
 932 /*
 933  * for pure cryptodev (lookaside none) depending on SA settings,
 934  * we might have to write some extra data to the packet.
 935  */
 936 static inline void
 937 inb_pkt_xprepare(const struct rte_ipsec_sa *sa, rte_be64_t sqc,
 938         const union sym_op_data *icv)
 939 {
 940         struct aead_gcm_aad *aad;
 941
 942         /* insert SQN.hi between ESP trailer and ICV */
 943         if (sa->sqh_len != 0)
 944                 insert_sqh(sqn_hi32(sqc), icv->va, sa->icv_len);
 945
 946         /*
 947          * fill AAD fields, if any (aad fields are placed after icv),
 948          * right now we support only one AEAD algorithm: AES-GCM.
 949          */
 950         if (sa->aad_len != 0) {
 951                 aad = (struct aead_gcm_aad *)(icv->va + sa->icv_len);
 952                 aead_gcm_aad_fill(aad, sa->spi, sqc, IS_ESN(sa));
 953         }
 954 }
 955
 956 /*
 957  * setup/update packet data and metadata for ESP inbound tunnel case.
 958  */
 959 static inline int32_t
 960 esp_inb_tun_pkt_prepare(const struct rte_ipsec_sa *sa,
 961         const struct replay_sqn *rsn, struct rte_mbuf *mb,
 962         uint32_t hlen, union sym_op_data *icv)
 963 {
 964         int32_t rc;
 965         uint64_t sqn;
 966         uint32_t icv_ofs, plen;
 967         struct rte_mbuf *ml;
 968         struct esp_hdr *esph;
 969
 970         esph = rte_pktmbuf_mtod_offset(mb, struct esp_hdr *, hlen);
 971
 972         /*
 973          * retrieve and reconstruct SQN, then check it, then
 974          * convert it back into network byte order.
 975          */
 976         sqn = rte_be_to_cpu_32(esph->seq);
 977         if (IS_ESN(sa))
 978                 sqn = reconstruct_esn(rsn->sqn, sqn, sa->replay.win_sz);
 979
 980         rc = esn_inb_check_sqn(rsn, sa, sqn);
 981         if (rc != 0)
 982                 return rc;
 983
 984         sqn = rte_cpu_to_be_64(sqn);
 985
 986         /* start packet manipulation */
 987         plen = mb->pkt_len;
 988         plen = plen - hlen;
 989
 990         ml = rte_pktmbuf_lastseg(mb);
 991         icv_ofs = ml->data_len - sa->icv_len + sa->sqh_len;
 992
 993         /* we have to allocate space for AAD somewhere,
 994          * right now - just use free trailing space at the last segment.
 995          * Would probably be more convenient to reserve space for AAD
 996          * inside rte_crypto_op itself
 997          * (again for IV space is already reserved inside cop).
 998          */
 999         if (sa->aad_len + sa->sqh_len > rte_pktmbuf_tailroom(ml))
1000                 return -ENOSPC;
1001
1002         icv->va = rte_pktmbuf_mtod_offset(ml, void *, icv_ofs);
1003         icv->pa = rte_pktmbuf_iova_offset(ml, icv_ofs);
1004
1005         inb_pkt_xprepare(sa, sqn, icv);
1006         return plen;
1007 }
1008
1009 /*
1010  * setup/update packets and crypto ops for ESP inbound case.
1011  */
1012 static uint16_t
1013 inb_pkt_prepare(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
1014         struct rte_crypto_op *cop[], uint16_t num)
1015 {
1016         int32_t rc;
1017         uint32_t i, k, hl;
1018         struct rte_ipsec_sa *sa;
1019         struct rte_cryptodev_sym_session *cs;
1020         struct replay_sqn *rsn;
1021         union sym_op_data icv;
1022         struct rte_mbuf *dr[num];
1023
1024         sa = ss->sa;
1025         cs = ss->crypto.ses;
1026         rsn = rsn_acquire(sa);
1027
1028         k = 0;
1029         for (i = 0; i != num; i++) {
1030
1031                 hl = mb[i]->l2_len + mb[i]->l3_len;
1032                 rc = esp_inb_tun_pkt_prepare(sa, rsn, mb[i], hl, &icv);
1033                 if (rc >= 0) {
1034                         lksd_none_cop_prepare(cop[k], cs, mb[i]);
1035                         rc = esp_inb_tun_cop_prepare(cop[k], sa, mb[i], &icv,
1036                                 hl, rc);
1037                 }
1038
1039                 if (rc == 0)
1040                         mb[k++] = mb[i];
1041                 else {
1042                         dr[i - k] = mb[i];
1043                         rte_errno = -rc;
1044                 }
1045         }
1046
1047         rsn_release(sa, rsn);
1048
1049         /* copy not prepared mbufs beyond good ones */
1050         if (k != num && k != 0)
1051                 mbuf_bulk_copy(mb + k, dr, num - k);
1052
1053         return k;
1054 }
1055
1056 /*
1057  *  setup crypto ops for LOOKASIDE_PROTO type of devices.
1058  */
1059 static inline void
1060 lksd_proto_cop_prepare(const struct rte_ipsec_session *ss,
1061         struct rte_mbuf *mb[], struct rte_crypto_op *cop[], uint16_t num)
1062 {
1063         uint32_t i;
1064         struct rte_crypto_sym_op *sop;
1065
1066         for (i = 0; i != num; i++) {
1067                 sop = cop[i]->sym;
1068                 cop[i]->type = RTE_CRYPTO_OP_TYPE_SYMMETRIC;
1069                 cop[i]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
1070                 cop[i]->sess_type = RTE_CRYPTO_OP_SECURITY_SESSION;
1071                 sop->m_src = mb[i];
1072                 __rte_security_attach_session(sop, ss->security.ses);
1073         }
1074 }
1075
1076 /*
1077  *  setup packets and crypto ops for LOOKASIDE_PROTO type of devices.
1078  *  Note that for LOOKASIDE_PROTO all packet modifications will be
1079  *  performed by PMD/HW.
1080  *  SW has only to prepare crypto op.
1081  */
1082 static uint16_t
1083 lksd_proto_prepare(const struct rte_ipsec_session *ss,
1084         struct rte_mbuf *mb[], struct rte_crypto_op *cop[], uint16_t num)
1085 {
1086         lksd_proto_cop_prepare(ss, mb, cop, num);
1087         return num;
1088 }
1089
1090 /*
1091  * process ESP inbound tunnel packet.
1092  */
1093 static inline int
1094 esp_inb_tun_single_pkt_process(struct rte_ipsec_sa *sa, struct rte_mbuf *mb,
1095         uint32_t *sqn)
1096 {
1097         uint32_t hlen, icv_len, tlen;
1098         struct esp_hdr *esph;
1099         struct esp_tail *espt;
1100         struct rte_mbuf *ml;
1101         char *pd;
1102
1103         if (mb->ol_flags & PKT_RX_SEC_OFFLOAD_FAILED)
1104                 return -EBADMSG;
1105
1106         icv_len = sa->icv_len;
1107
1108         ml = rte_pktmbuf_lastseg(mb);
1109         espt = rte_pktmbuf_mtod_offset(ml, struct esp_tail *,
1110                 ml->data_len - icv_len - sizeof(*espt));
1111
1112         /*
1113          * check padding and next proto.
1114          * return an error if something is wrong.
1115          */
1116         pd = (char *)espt - espt->pad_len;
1117         if (espt->next_proto != sa->proto ||
1118                         memcmp(pd, esp_pad_bytes, espt->pad_len))
1119                 return -EINVAL;
1120
1121         /* cut of ICV, ESP tail and padding bytes */
1122         tlen = icv_len + sizeof(*espt) + espt->pad_len;
1123         ml->data_len -= tlen;
1124         mb->pkt_len -= tlen;
1125
1126         /* cut of L2/L3 headers, ESP header and IV */
1127         hlen = mb->l2_len + mb->l3_len;
1128         esph = rte_pktmbuf_mtod_offset(mb, struct esp_hdr *, hlen);
1129         rte_pktmbuf_adj(mb, hlen + sa->ctp.cipher.offset);
1130
1131         /* retrieve SQN for later check */
1132         *sqn = rte_be_to_cpu_32(esph->seq);
1133
1134         /* reset mbuf metatdata: L2/L3 len, packet type */
1135         mb->packet_type = RTE_PTYPE_UNKNOWN;
1136         mb->tx_offload = (mb->tx_offload & sa->tx_offload.msk) |
1137                 sa->tx_offload.val;
1138
1139         /* clear the PKT_RX_SEC_OFFLOAD flag if set */
1140         mb->ol_flags &= ~(mb->ol_flags & PKT_RX_SEC_OFFLOAD);
1141         return 0;
1142 }
1143
1144 /*
1145  * process ESP inbound transport packet.
1146  */
1147 static inline int
1148 esp_inb_trs_single_pkt_process(struct rte_ipsec_sa *sa, struct rte_mbuf *mb,
1149         uint32_t *sqn)
1150 {
1151         uint32_t hlen, icv_len, l2len, l3len, tlen;
1152         struct esp_hdr *esph;
1153         struct esp_tail *espt;
1154         struct rte_mbuf *ml;
1155         char *np, *op, *pd;
1156
1157         if (mb->ol_flags & PKT_RX_SEC_OFFLOAD_FAILED)
1158                 return -EBADMSG;
1159
1160         icv_len = sa->icv_len;
1161
1162         ml = rte_pktmbuf_lastseg(mb);
1163         espt = rte_pktmbuf_mtod_offset(ml, struct esp_tail *,
1164                 ml->data_len - icv_len - sizeof(*espt));
1165
1166         /* check padding, return an error if something is wrong. */
1167         pd = (char *)espt - espt->pad_len;
1168         if (memcmp(pd, esp_pad_bytes, espt->pad_len))
1169                 return -EINVAL;
1170
1171         /* cut of ICV, ESP tail and padding bytes */
1172         tlen = icv_len + sizeof(*espt) + espt->pad_len;
1173         ml->data_len -= tlen;
1174         mb->pkt_len -= tlen;
1175
1176         /* retrieve SQN for later check */
1177         l2len = mb->l2_len;
1178         l3len = mb->l3_len;
1179         hlen = l2len + l3len;
1180         op = rte_pktmbuf_mtod(mb, char *);
1181         esph = (struct esp_hdr *)(op + hlen);
1182         *sqn = rte_be_to_cpu_32(esph->seq);
1183
1184         /* cut off ESP header and IV, update L3 header */
1185         np = rte_pktmbuf_adj(mb, sa->ctp.cipher.offset);
1186         remove_esph(np, op, hlen);
1187         update_trs_l3hdr(sa, np + l2len, mb->pkt_len, l2len, l3len,
1188                         espt->next_proto);
1189
1190         /* reset mbuf packet type */
1191         mb->packet_type &= (RTE_PTYPE_L2_MASK | RTE_PTYPE_L3_MASK);
1192
1193         /* clear the PKT_RX_SEC_OFFLOAD flag if set */
1194         mb->ol_flags &= ~(mb->ol_flags & PKT_RX_SEC_OFFLOAD);
1195         return 0;
1196 }
1197
1198 /*
1199  * for group of ESP inbound packets perform SQN check and update.
1200  */
1201 static inline uint16_t
1202 esp_inb_rsn_update(struct rte_ipsec_sa *sa, const uint32_t sqn[],
1203         struct rte_mbuf *mb[], struct rte_mbuf *dr[], uint16_t num)
1204 {
1205         uint32_t i, k;
1206         struct replay_sqn *rsn;
1207
1208         rsn = rsn_update_start(sa);
1209
1210         k = 0;
1211         for (i = 0; i != num; i++) {
1212                 if (esn_inb_update_sqn(rsn, sa, sqn[i]) == 0)
1213                         mb[k++] = mb[i];
1214                 else
1215                         dr[i - k] = mb[i];
1216         }
1217
1218         rsn_update_finish(sa, rsn);
1219         return k;
1220 }
1221
1222 /*
1223  * process group of ESP inbound tunnel packets.
1224  */
1225 static uint16_t
1226 inb_tun_pkt_process(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
1227         uint16_t num)
1228 {
1229         uint32_t i, k;
1230         struct rte_ipsec_sa *sa;
1231         uint32_t sqn[num];
1232         struct rte_mbuf *dr[num];
1233
1234         sa = ss->sa;
1235
1236         /* process packets, extract seq numbers */
1237
1238         k = 0;
1239         for (i = 0; i != num; i++) {
1240                 /* good packet */
1241                 if (esp_inb_tun_single_pkt_process(sa, mb[i], sqn + k) == 0)
1242                         mb[k++] = mb[i];
1243                 /* bad packet, will drop from furhter processing */
1244                 else
1245                         dr[i - k] = mb[i];
1246         }
1247
1248         /* update seq # and replay winow */
1249         k = esp_inb_rsn_update(sa, sqn, mb, dr + i - k, k);
1250
1251         /* handle unprocessed mbufs */
1252         if (k != num) {
1253                 rte_errno = EBADMSG;
1254                 if (k != 0)
1255                         mbuf_bulk_copy(mb + k, dr, num - k);
1256         }
1257
1258         return k;
1259 }
1260
1261 /*
1262  * process group of ESP inbound transport packets.
1263  */
1264 static uint16_t
1265 inb_trs_pkt_process(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
1266         uint16_t num)
1267 {
1268         uint32_t i, k;
1269         uint32_t sqn[num];
1270         struct rte_ipsec_sa *sa;
1271         struct rte_mbuf *dr[num];
1272
1273         sa = ss->sa;
1274
1275         /* process packets, extract seq numbers */
1276
1277         k = 0;
1278         for (i = 0; i != num; i++) {
1279                 /* good packet */
1280                 if (esp_inb_trs_single_pkt_process(sa, mb[i], sqn + k) == 0)
1281                         mb[k++] = mb[i];
1282                 /* bad packet, will drop from furhter processing */
1283                 else
1284                         dr[i - k] = mb[i];
1285         }
1286
1287         /* update seq # and replay winow */
1288         k = esp_inb_rsn_update(sa, sqn, mb, dr + i - k, k);
1289
1290         /* handle unprocessed mbufs */
1291         if (k != num) {
1292                 rte_errno = EBADMSG;
1293                 if (k != 0)
1294                         mbuf_bulk_copy(mb + k, dr, num - k);
1295         }
1296
1297         return k;
1298 }
1299
1300 /*
1301  * process outbound packets for SA with ESN support,
1302  * for algorithms that require SQN.hibits to be implictly included
1303  * into digest computation.
1304  * In that case we have to move ICV bytes back to their proper place.
1305  */
1306 static uint16_t
1307 outb_sqh_process(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
1308         uint16_t num)
1309 {
1310         uint32_t i, k, icv_len, *icv;
1311         struct rte_mbuf *ml;
1312         struct rte_ipsec_sa *sa;
1313         struct rte_mbuf *dr[num];
1314
1315         sa = ss->sa;
1316
1317         k = 0;
1318         icv_len = sa->icv_len;
1319
1320         for (i = 0; i != num; i++) {
1321                 if ((mb[i]->ol_flags & PKT_RX_SEC_OFFLOAD_FAILED) == 0) {
1322                         ml = rte_pktmbuf_lastseg(mb[i]);
1323                         icv = rte_pktmbuf_mtod_offset(ml, void *,
1324                                 ml->data_len - icv_len);
1325                         remove_sqh(icv, icv_len);
1326                         mb[k++] = mb[i];
1327                 } else
1328                         dr[i - k] = mb[i];
1329         }
1330
1331         /* handle unprocessed mbufs */
1332         if (k != num) {
1333                 rte_errno = EBADMSG;
1334                 if (k != 0)
1335                         mbuf_bulk_copy(mb + k, dr, num - k);
1336         }
1337
1338         return k;
1339 }
1340
1341 /*
1342  * simplest pkt process routine:
1343  * all actual processing is already done by HW/PMD,
1344  * just check mbuf ol_flags.
1345  * used for:
1346  * - inbound for RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL
1347  * - inbound/outbound for RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL
1348  * - outbound for RTE_SECURITY_ACTION_TYPE_NONE when ESN is disabled
1349  */
1350 static uint16_t
1351 pkt_flag_process(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
1352         uint16_t num)
1353 {
1354         uint32_t i, k;
1355         struct rte_mbuf *dr[num];
1356
1357         RTE_SET_USED(ss);
1358
1359         k = 0;
1360         for (i = 0; i != num; i++) {
1361                 if ((mb[i]->ol_flags & PKT_RX_SEC_OFFLOAD_FAILED) == 0)
1362                         mb[k++] = mb[i];
1363                 else
1364                         dr[i - k] = mb[i];
1365         }
1366
1367         /* handle unprocessed mbufs */
1368         if (k != num) {
1369                 rte_errno = EBADMSG;
1370                 if (k != 0)
1371                         mbuf_bulk_copy(mb + k, dr, num - k);
1372         }
1373
1374         return k;
1375 }
1376
1377 /*
1378  * prepare packets for inline ipsec processing:
1379  * set ol_flags and attach metadata.
1380  */
1381 static inline void
1382 inline_outb_mbuf_prepare(const struct rte_ipsec_session *ss,
1383         struct rte_mbuf *mb[], uint16_t num)
1384 {
1385         uint32_t i, ol_flags;
1386
1387         ol_flags = ss->security.ol_flags & RTE_SECURITY_TX_OLOAD_NEED_MDATA;
1388         for (i = 0; i != num; i++) {
1389
1390                 mb[i]->ol_flags |= PKT_TX_SEC_OFFLOAD;
1391                 if (ol_flags != 0)
1392                         rte_security_set_pkt_metadata(ss->security.ctx,
1393                                 ss->security.ses, mb[i], NULL);
1394         }
1395 }
1396
1397 /*
1398  * process group of ESP outbound tunnel packets destined for
1399  * INLINE_CRYPTO type of device.
1400  */
1401 static uint16_t
1402 inline_outb_tun_pkt_process(const struct rte_ipsec_session *ss,
1403         struct rte_mbuf *mb[], uint16_t num)
1404 {
1405         int32_t rc;
1406         uint32_t i, k, n;
1407         uint64_t sqn;
1408         rte_be64_t sqc;
1409         struct rte_ipsec_sa *sa;
1410         union sym_op_data icv;
1411         uint64_t iv[IPSEC_MAX_IV_QWORD];
1412         struct rte_mbuf *dr[num];
1413
1414         sa = ss->sa;
1415
1416         n = num;
1417         sqn = esn_outb_update_sqn(sa, &n);
1418         if (n != num)
1419                 rte_errno = EOVERFLOW;
1420
1421         k = 0;
1422         for (i = 0; i != n; i++) {
1423
1424                 sqc = rte_cpu_to_be_64(sqn + i);
1425                 gen_iv(iv, sqc);
1426
1427                 /* try to update the packet itself */
1428                 rc = esp_outb_tun_pkt_prepare(sa, sqc, iv, mb[i], &icv);
1429
1430                 /* success, update mbuf fields */
1431                 if (rc >= 0)
1432                         mb[k++] = mb[i];
1433                 /* failure, put packet into the death-row */
1434                 else {
1435                         dr[i - k] = mb[i];
1436                         rte_errno = -rc;
1437                 }
1438         }
1439
1440         inline_outb_mbuf_prepare(ss, mb, k);
1441
1442         /* copy not processed mbufs beyond good ones */
1443         if (k != n && k != 0)
1444                 mbuf_bulk_copy(mb + k, dr, n - k);
1445
1446         return k;
1447 }
1448
1449 /*
1450  * process group of ESP outbound transport packets destined for
1451  * INLINE_CRYPTO type of device.
1452  */
1453 static uint16_t
1454 inline_outb_trs_pkt_process(const struct rte_ipsec_session *ss,
1455         struct rte_mbuf *mb[], uint16_t num)
1456 {
1457         int32_t rc;
1458         uint32_t i, k, n, l2, l3;
1459         uint64_t sqn;
1460         rte_be64_t sqc;
1461         struct rte_ipsec_sa *sa;
1462         union sym_op_data icv;
1463         uint64_t iv[IPSEC_MAX_IV_QWORD];
1464         struct rte_mbuf *dr[num];
1465
1466         sa = ss->sa;
1467
1468         n = num;
1469         sqn = esn_outb_update_sqn(sa, &n);
1470         if (n != num)
1471                 rte_errno = EOVERFLOW;
1472
1473         k = 0;
1474         for (i = 0; i != n; i++) {
1475
1476                 l2 = mb[i]->l2_len;
1477                 l3 = mb[i]->l3_len;
1478
1479                 sqc = rte_cpu_to_be_64(sqn + i);
1480                 gen_iv(iv, sqc);
1481
1482                 /* try to update the packet itself */
1483                 rc = esp_outb_trs_pkt_prepare(sa, sqc, iv, mb[i],
1484                                 l2, l3, &icv);
1485
1486                 /* success, update mbuf fields */
1487                 if (rc >= 0)
1488                         mb[k++] = mb[i];
1489                 /* failure, put packet into the death-row */
1490                 else {
1491                         dr[i - k] = mb[i];
1492                         rte_errno = -rc;
1493                 }
1494         }
1495
1496         inline_outb_mbuf_prepare(ss, mb, k);
1497
1498         /* copy not processed mbufs beyond good ones */
1499         if (k != n && k != 0)
1500                 mbuf_bulk_copy(mb + k, dr, n - k);
1501
1502         return k;
1503 }
1504
1505 /*
1506  * outbound for RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL:
1507  * actual processing is done by HW/PMD, just set flags and metadata.
1508  */
1509 static uint16_t
1510 outb_inline_proto_process(const struct rte_ipsec_session *ss,
1511                 struct rte_mbuf *mb[], uint16_t num)
1512 {
1513         inline_outb_mbuf_prepare(ss, mb, num);
1514         return num;
1515 }
1516
1517 /*
1518  * Select packet processing function for session on LOOKASIDE_NONE
1519  * type of device.
1520  */
1521 static int
1522 lksd_none_pkt_func_select(const struct rte_ipsec_sa *sa,
1523                 struct rte_ipsec_sa_pkt_func *pf)
1524 {
1525         int32_t rc;
1526
1527         static const uint64_t msk = RTE_IPSEC_SATP_DIR_MASK |
1528                         RTE_IPSEC_SATP_MODE_MASK;
1529
1530         rc = 0;
1531         switch (sa->type & msk) {
1532         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TUNLV4):
1533         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TUNLV6):
1534                 pf->prepare = inb_pkt_prepare;
1535                 pf->process = inb_tun_pkt_process;
1536                 break;
1537         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TRANS):
1538                 pf->prepare = inb_pkt_prepare;
1539                 pf->process = inb_trs_pkt_process;
1540                 break;
1541         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TUNLV4):
1542         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TUNLV6):
1543                 pf->prepare = outb_tun_prepare;
1544                 pf->process = (sa->sqh_len != 0) ?
1545                         outb_sqh_process : pkt_flag_process;
1546                 break;
1547         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TRANS):
1548                 pf->prepare = outb_trs_prepare;
1549                 pf->process = (sa->sqh_len != 0) ?
1550                         outb_sqh_process : pkt_flag_process;
1551                 break;
1552         default:
1553                 rc = -ENOTSUP;
1554         }
1555
1556         return rc;
1557 }
1558
1559 /*
1560  * Select packet processing function for session on INLINE_CRYPTO
1561  * type of device.
1562  */
1563 static int
1564 inline_crypto_pkt_func_select(const struct rte_ipsec_sa *sa,
1565                 struct rte_ipsec_sa_pkt_func *pf)
1566 {
1567         int32_t rc;
1568
1569         static const uint64_t msk = RTE_IPSEC_SATP_DIR_MASK |
1570                         RTE_IPSEC_SATP_MODE_MASK;
1571
1572         rc = 0;
1573         switch (sa->type & msk) {
1574         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TUNLV4):
1575         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TUNLV6):
1576                 pf->process = inb_tun_pkt_process;
1577                 break;
1578         case (RTE_IPSEC_SATP_DIR_IB | RTE_IPSEC_SATP_MODE_TRANS):
1579                 pf->process = inb_trs_pkt_process;
1580                 break;
1581         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TUNLV4):
1582         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TUNLV6):
1583                 pf->process = inline_outb_tun_pkt_process;
1584                 break;
1585         case (RTE_IPSEC_SATP_DIR_OB | RTE_IPSEC_SATP_MODE_TRANS):
1586                 pf->process = inline_outb_trs_pkt_process;
1587                 break;
1588         default:
1589                 rc = -ENOTSUP;
1590         }
1591
1592         return rc;
1593 }
1594
1595 /*
1596  * Select packet processing function for given session based on SA parameters
1597  * and type of associated with the session device.
1598  */
1599 int
1600 ipsec_sa_pkt_func_select(const struct rte_ipsec_session *ss,
1601         const struct rte_ipsec_sa *sa, struct rte_ipsec_sa_pkt_func *pf)
1602 {
1603         int32_t rc;
1604
1605         rc = 0;
1606         pf[0] = (struct rte_ipsec_sa_pkt_func) { 0 };
1607
1608         switch (ss->type) {
1609         case RTE_SECURITY_ACTION_TYPE_NONE:
1610                 rc = lksd_none_pkt_func_select(sa, pf);
1611                 break;
1612         case RTE_SECURITY_ACTION_TYPE_INLINE_CRYPTO:
1613                 rc = inline_crypto_pkt_func_select(sa, pf);
1614                 break;
1615         case RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL:
1616                 if ((sa->type & RTE_IPSEC_SATP_DIR_MASK) ==
1617                                 RTE_IPSEC_SATP_DIR_IB)
1618                         pf->process = pkt_flag_process;
1619                 else
1620                         pf->process = outb_inline_proto_process;
1621                 break;
1622         case RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL:
1623                 pf->prepare = lksd_proto_prepare;
1624                 pf->process = pkt_flag_process;
1625                 break;
1626         default:
1627                 rc = -ENOTSUP;
1628         }
1629
1630         return rc;
1631 }