lib/librte_ipsec/esp_outb.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018-2020 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 "misc.h"
  16 #include "pad.h"
  17
  18 typedef int32_t (*esp_outb_prepare_t)(struct rte_ipsec_sa *sa, rte_be64_t sqc,
  19         const uint64_t ivp[IPSEC_MAX_IV_QWORD], struct rte_mbuf *mb,
  20         union sym_op_data *icv, uint8_t sqh_len);
  21
  22 /*
  23  * helper function to fill crypto_sym op for cipher+auth algorithms.
  24  * used by outb_cop_prepare(), see below.
  25  */
  26 static inline void
  27 sop_ciph_auth_prepare(struct rte_crypto_sym_op *sop,
  28         const struct rte_ipsec_sa *sa, const union sym_op_data *icv,
  29         uint32_t pofs, uint32_t plen)
  30 {
  31         sop->cipher.data.offset = sa->ctp.cipher.offset + pofs;
  32         sop->cipher.data.length = sa->ctp.cipher.length + plen;
  33         sop->auth.data.offset = sa->ctp.auth.offset + pofs;
  34         sop->auth.data.length = sa->ctp.auth.length + plen;
  35         sop->auth.digest.data = icv->va;
  36         sop->auth.digest.phys_addr = icv->pa;
  37 }
  38
  39 /*
  40  * helper function to fill crypto_sym op for cipher+auth algorithms.
  41  * used by outb_cop_prepare(), see below.
  42  */
  43 static inline void
  44 sop_aead_prepare(struct rte_crypto_sym_op *sop,
  45         const struct rte_ipsec_sa *sa, const union sym_op_data *icv,
  46         uint32_t pofs, uint32_t plen)
  47 {
  48         sop->aead.data.offset = sa->ctp.cipher.offset + pofs;
  49         sop->aead.data.length = sa->ctp.cipher.length + plen;
  50         sop->aead.digest.data = icv->va;
  51         sop->aead.digest.phys_addr = icv->pa;
  52         sop->aead.aad.data = icv->va + sa->icv_len;
  53         sop->aead.aad.phys_addr = icv->pa + sa->icv_len;
  54 }
  55
  56 /*
  57  * setup crypto op and crypto sym op for ESP outbound packet.
  58  */
  59 static inline void
  60 outb_cop_prepare(struct rte_crypto_op *cop,
  61         const struct rte_ipsec_sa *sa, const uint64_t ivp[IPSEC_MAX_IV_QWORD],
  62         const union sym_op_data *icv, uint32_t hlen, uint32_t plen)
  63 {
  64         struct rte_crypto_sym_op *sop;
  65         struct aead_gcm_iv *gcm;
  66         struct aesctr_cnt_blk *ctr;
  67         uint32_t algo;
  68
  69         algo = sa->algo_type;
  70
  71         /* fill sym op fields */
  72         sop = cop->sym;
  73
  74         switch (algo) {
  75         case ALGO_TYPE_AES_CBC:
  76                 /* Cipher-Auth (AES-CBC *) case */
  77         case ALGO_TYPE_3DES_CBC:
  78                 /* Cipher-Auth (3DES-CBC *) case */
  79         case ALGO_TYPE_NULL:
  80                 /* NULL case */
  81                 sop_ciph_auth_prepare(sop, sa, icv, hlen, plen);
  82                 break;
  83         case ALGO_TYPE_AES_GCM:
  84                 /* AEAD (AES_GCM) case */
  85                 sop_aead_prepare(sop, sa, icv, hlen, plen);
  86
  87                 /* fill AAD IV (located inside crypto op) */
  88                 gcm = rte_crypto_op_ctod_offset(cop, struct aead_gcm_iv *,
  89                         sa->iv_ofs);
  90                 aead_gcm_iv_fill(gcm, ivp[0], sa->salt);
  91                 break;
  92         case ALGO_TYPE_AES_CTR:
  93                 /* Cipher-Auth (AES-CTR *) case */
  94                 sop_ciph_auth_prepare(sop, sa, icv, hlen, plen);
  95
  96                 /* fill CTR block (located inside crypto op) */
  97                 ctr = rte_crypto_op_ctod_offset(cop, struct aesctr_cnt_blk *,
  98                         sa->iv_ofs);
  99                 aes_ctr_cnt_blk_fill(ctr, ivp[0], sa->salt);
 100                 break;
 101         }
 102 }
 103
 104 /*
 105  * setup/update packet data and metadata for ESP outbound tunnel case.
 106  */
 107 static inline int32_t
 108 outb_tun_pkt_prepare(struct rte_ipsec_sa *sa, rte_be64_t sqc,
 109         const uint64_t ivp[IPSEC_MAX_IV_QWORD], struct rte_mbuf *mb,
 110         union sym_op_data *icv, uint8_t sqh_len)
 111 {
 112         uint32_t clen, hlen, l2len, pdlen, pdofs, plen, tlen;
 113         struct rte_mbuf *ml;
 114         struct rte_esp_hdr *esph;
 115         struct rte_esp_tail *espt;
 116         char *ph, *pt;
 117         uint64_t *iv;
 118
 119         /* calculate extra header space required */
 120         hlen = sa->hdr_len + sa->iv_len + sizeof(*esph);
 121
 122         /* size of ipsec protected data */
 123         l2len = mb->l2_len;
 124         plen = mb->pkt_len - l2len;
 125
 126         /* number of bytes to encrypt */
 127         clen = plen + sizeof(*espt);
 128         clen = RTE_ALIGN_CEIL(clen, sa->pad_align);
 129
 130         /* pad length + esp tail */
 131         pdlen = clen - plen;
 132         tlen = pdlen + sa->icv_len + sqh_len;
 133
 134         /* do append and prepend */
 135         ml = rte_pktmbuf_lastseg(mb);
 136         if (tlen + sa->aad_len > rte_pktmbuf_tailroom(ml))
 137                 return -ENOSPC;
 138
 139         /* prepend header */
 140         ph = rte_pktmbuf_prepend(mb, hlen - l2len);
 141         if (ph == NULL)
 142                 return -ENOSPC;
 143
 144         /* append tail */
 145         pdofs = ml->data_len;
 146         ml->data_len += tlen;
 147         mb->pkt_len += tlen;
 148         pt = rte_pktmbuf_mtod_offset(ml, typeof(pt), pdofs);
 149
 150         /* update pkt l2/l3 len */
 151         mb->tx_offload = (mb->tx_offload & sa->tx_offload.msk) |
 152                 sa->tx_offload.val;
 153
 154         /* copy tunnel pkt header */
 155         rte_memcpy(ph, sa->hdr, sa->hdr_len);
 156
 157         /* update original and new ip header fields */
 158         update_tun_outb_l3hdr(sa, ph + sa->hdr_l3_off, ph + hlen,
 159                         mb->pkt_len - sqh_len, sa->hdr_l3_off, sqn_low16(sqc));
 160
 161         /* update spi, seqn and iv */
 162         esph = (struct rte_esp_hdr *)(ph + sa->hdr_len);
 163         iv = (uint64_t *)(esph + 1);
 164         copy_iv(iv, ivp, sa->iv_len);
 165
 166         esph->spi = sa->spi;
 167         esph->seq = sqn_low32(sqc);
 168
 169         /* offset for ICV */
 170         pdofs += pdlen + sa->sqh_len;
 171
 172         /* pad length */
 173         pdlen -= sizeof(*espt);
 174
 175         /* copy padding data */
 176         rte_memcpy(pt, esp_pad_bytes, pdlen);
 177
 178         /* update esp trailer */
 179         espt = (struct rte_esp_tail *)(pt + pdlen);
 180         espt->pad_len = pdlen;
 181         espt->next_proto = sa->proto;
 182
 183         /* set icv va/pa value(s) */
 184         icv->va = rte_pktmbuf_mtod_offset(ml, void *, pdofs);
 185         icv->pa = rte_pktmbuf_iova_offset(ml, pdofs);
 186
 187         return clen;
 188 }
 189
 190 /*
 191  * for pure cryptodev (lookaside none) depending on SA settings,
 192  * we might have to write some extra data to the packet.
 193  */
 194 static inline void
 195 outb_pkt_xprepare(const struct rte_ipsec_sa *sa, rte_be64_t sqc,
 196         const union sym_op_data *icv)
 197 {
 198         uint32_t *psqh;
 199         struct aead_gcm_aad *aad;
 200
 201         /* insert SQN.hi between ESP trailer and ICV */
 202         if (sa->sqh_len != 0) {
 203                 psqh = (uint32_t *)(icv->va - sa->sqh_len);
 204                 psqh[0] = sqn_hi32(sqc);
 205         }
 206
 207         /*
 208          * fill IV and AAD fields, if any (aad fields are placed after icv),
 209          * right now we support only one AEAD algorithm: AES-GCM .
 210          */
 211         if (sa->aad_len != 0) {
 212                 aad = (struct aead_gcm_aad *)(icv->va + sa->icv_len);
 213                 aead_gcm_aad_fill(aad, sa->spi, sqc, IS_ESN(sa));
 214         }
 215 }
 216
 217 /*
 218  * setup/update packets and crypto ops for ESP outbound tunnel case.
 219  */
 220 uint16_t
 221 esp_outb_tun_prepare(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
 222         struct rte_crypto_op *cop[], uint16_t num)
 223 {
 224         int32_t rc;
 225         uint32_t i, k, n;
 226         uint64_t sqn;
 227         rte_be64_t sqc;
 228         struct rte_ipsec_sa *sa;
 229         struct rte_cryptodev_sym_session *cs;
 230         union sym_op_data icv;
 231         uint64_t iv[IPSEC_MAX_IV_QWORD];
 232         uint32_t dr[num];
 233
 234         sa = ss->sa;
 235         cs = ss->crypto.ses;
 236
 237         n = num;
 238         sqn = esn_outb_update_sqn(sa, &n);
 239         if (n != num)
 240                 rte_errno = EOVERFLOW;
 241
 242         k = 0;
 243         for (i = 0; i != n; i++) {
 244
 245                 sqc = rte_cpu_to_be_64(sqn + i);
 246                 gen_iv(iv, sqc);
 247
 248                 /* try to update the packet itself */
 249                 rc = outb_tun_pkt_prepare(sa, sqc, iv, mb[i], &icv,
 250                                           sa->sqh_len);
 251                 /* success, setup crypto op */
 252                 if (rc >= 0) {
 253                         outb_pkt_xprepare(sa, sqc, &icv);
 254                         lksd_none_cop_prepare(cop[k], cs, mb[i]);
 255                         outb_cop_prepare(cop[k], sa, iv, &icv, 0, rc);
 256                         k++;
 257                 /* failure, put packet into the death-row */
 258                 } else {
 259                         dr[i - k] = i;
 260                         rte_errno = -rc;
 261                 }
 262         }
 263
 264          /* copy not prepared mbufs beyond good ones */
 265         if (k != n && k != 0)
 266                 move_bad_mbufs(mb, dr, n, n - k);
 267
 268         return k;
 269 }
 270
 271 /*
 272  * setup/update packet data and metadata for ESP outbound transport case.
 273  */
 274 static inline int32_t
 275 outb_trs_pkt_prepare(struct rte_ipsec_sa *sa, rte_be64_t sqc,
 276         const uint64_t ivp[IPSEC_MAX_IV_QWORD], struct rte_mbuf *mb,
 277         union sym_op_data *icv, uint8_t sqh_len)
 278 {
 279         uint8_t np;
 280         uint32_t clen, hlen, pdlen, pdofs, plen, tlen, uhlen;
 281         struct rte_mbuf *ml;
 282         struct rte_esp_hdr *esph;
 283         struct rte_esp_tail *espt;
 284         char *ph, *pt;
 285         uint64_t *iv;
 286         uint32_t l2len, l3len;
 287
 288         l2len = mb->l2_len;
 289         l3len = mb->l3_len;
 290
 291         uhlen = l2len + l3len;
 292         plen = mb->pkt_len - uhlen;
 293
 294         /* calculate extra header space required */
 295         hlen = sa->iv_len + sizeof(*esph);
 296
 297         /* number of bytes to encrypt */
 298         clen = plen + sizeof(*espt);
 299         clen = RTE_ALIGN_CEIL(clen, sa->pad_align);
 300
 301         /* pad length + esp tail */
 302         pdlen = clen - plen;
 303         tlen = pdlen + sa->icv_len + sqh_len;
 304
 305         /* do append and insert */
 306         ml = rte_pktmbuf_lastseg(mb);
 307         if (tlen + sa->aad_len > rte_pktmbuf_tailroom(ml))
 308                 return -ENOSPC;
 309
 310         /* prepend space for ESP header */
 311         ph = rte_pktmbuf_prepend(mb, hlen);
 312         if (ph == NULL)
 313                 return -ENOSPC;
 314
 315         /* append tail */
 316         pdofs = ml->data_len;
 317         ml->data_len += tlen;
 318         mb->pkt_len += tlen;
 319         pt = rte_pktmbuf_mtod_offset(ml, typeof(pt), pdofs);
 320
 321         /* shift L2/L3 headers */
 322         insert_esph(ph, ph + hlen, uhlen);
 323
 324         /* update ip  header fields */
 325         np = update_trs_l3hdr(sa, ph + l2len, mb->pkt_len - sqh_len, l2len,
 326                         l3len, IPPROTO_ESP);
 327
 328         /* update spi, seqn and iv */
 329         esph = (struct rte_esp_hdr *)(ph + uhlen);
 330         iv = (uint64_t *)(esph + 1);
 331         copy_iv(iv, ivp, sa->iv_len);
 332
 333         esph->spi = sa->spi;
 334         esph->seq = sqn_low32(sqc);
 335
 336         /* offset for ICV */
 337         pdofs += pdlen + sa->sqh_len;
 338
 339         /* pad length */
 340         pdlen -= sizeof(*espt);
 341
 342         /* copy padding data */
 343         rte_memcpy(pt, esp_pad_bytes, pdlen);
 344
 345         /* update esp trailer */
 346         espt = (struct rte_esp_tail *)(pt + pdlen);
 347         espt->pad_len = pdlen;
 348         espt->next_proto = np;
 349
 350         /* set icv va/pa value(s) */
 351         icv->va = rte_pktmbuf_mtod_offset(ml, void *, pdofs);
 352         icv->pa = rte_pktmbuf_iova_offset(ml, pdofs);
 353
 354         return clen;
 355 }
 356
 357 /*
 358  * setup/update packets and crypto ops for ESP outbound transport case.
 359  */
 360 uint16_t
 361 esp_outb_trs_prepare(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
 362         struct rte_crypto_op *cop[], uint16_t num)
 363 {
 364         int32_t rc;
 365         uint32_t i, k, n, l2, l3;
 366         uint64_t sqn;
 367         rte_be64_t sqc;
 368         struct rte_ipsec_sa *sa;
 369         struct rte_cryptodev_sym_session *cs;
 370         union sym_op_data icv;
 371         uint64_t iv[IPSEC_MAX_IV_QWORD];
 372         uint32_t dr[num];
 373
 374         sa = ss->sa;
 375         cs = ss->crypto.ses;
 376
 377         n = num;
 378         sqn = esn_outb_update_sqn(sa, &n);
 379         if (n != num)
 380                 rte_errno = EOVERFLOW;
 381
 382         k = 0;
 383         for (i = 0; i != n; i++) {
 384
 385                 l2 = mb[i]->l2_len;
 386                 l3 = mb[i]->l3_len;
 387
 388                 sqc = rte_cpu_to_be_64(sqn + i);
 389                 gen_iv(iv, sqc);
 390
 391                 /* try to update the packet itself */
 392                 rc = outb_trs_pkt_prepare(sa, sqc, iv, mb[i], &icv,
 393                                   sa->sqh_len);
 394                 /* success, setup crypto op */
 395                 if (rc >= 0) {
 396                         outb_pkt_xprepare(sa, sqc, &icv);
 397                         lksd_none_cop_prepare(cop[k], cs, mb[i]);
 398                         outb_cop_prepare(cop[k], sa, iv, &icv, l2 + l3, rc);
 399                         k++;
 400                 /* failure, put packet into the death-row */
 401                 } else {
 402                         dr[i - k] = i;
 403                         rte_errno = -rc;
 404                 }
 405         }
 406
 407         /* copy not prepared mbufs beyond good ones */
 408         if (k != n && k != 0)
 409                 move_bad_mbufs(mb, dr, n, n - k);
 410
 411         return k;
 412 }
 413
 414
 415 static inline uint32_t
 416 outb_cpu_crypto_prepare(const struct rte_ipsec_sa *sa, uint32_t *pofs,
 417         uint32_t plen, void *iv)
 418 {
 419         uint64_t *ivp = iv;
 420         struct aead_gcm_iv *gcm;
 421         struct aesctr_cnt_blk *ctr;
 422         uint32_t clen;
 423
 424         switch (sa->algo_type) {
 425         case ALGO_TYPE_AES_GCM:
 426                 gcm = iv;
 427                 aead_gcm_iv_fill(gcm, ivp[0], sa->salt);
 428                 break;
 429         case ALGO_TYPE_AES_CTR:
 430                 ctr = iv;
 431                 aes_ctr_cnt_blk_fill(ctr, ivp[0], sa->salt);
 432                 break;
 433         }
 434
 435         *pofs += sa->ctp.auth.offset;
 436         clen = plen + sa->ctp.auth.length;
 437         return clen;
 438 }
 439
 440 static uint16_t
 441 cpu_outb_pkt_prepare(const struct rte_ipsec_session *ss,
 442                 struct rte_mbuf *mb[], uint16_t num,
 443                 esp_outb_prepare_t prepare, uint32_t cofs_mask)
 444 {
 445         int32_t rc;
 446         uint64_t sqn;
 447         rte_be64_t sqc;
 448         struct rte_ipsec_sa *sa;
 449         uint32_t i, k, n;
 450         uint32_t l2, l3;
 451         union sym_op_data icv;
 452         void *iv[num];
 453         void *aad[num];
 454         void *dgst[num];
 455         uint32_t dr[num];
 456         uint32_t l4ofs[num];
 457         uint32_t clen[num];
 458         uint64_t ivbuf[num][IPSEC_MAX_IV_QWORD];
 459
 460         sa = ss->sa;
 461
 462         n = num;
 463         sqn = esn_outb_update_sqn(sa, &n);
 464         if (n != num)
 465                 rte_errno = EOVERFLOW;
 466
 467         for (i = 0, k = 0; i != n; i++) {
 468
 469                 l2 = mb[i]->l2_len;
 470                 l3 = mb[i]->l3_len;
 471
 472                 /* calculate ESP header offset */
 473                 l4ofs[k] = (l2 + l3) & cofs_mask;
 474
 475                 sqc = rte_cpu_to_be_64(sqn + i);
 476                 gen_iv(ivbuf[k], sqc);
 477
 478                 /* try to update the packet itself */
 479                 rc = prepare(sa, sqc, ivbuf[k], mb[i], &icv, sa->sqh_len);
 480
 481                 /* success, proceed with preparations */
 482                 if (rc >= 0) {
 483
 484                         outb_pkt_xprepare(sa, sqc, &icv);
 485
 486                         /* get encrypted data offset and length */
 487                         clen[k] = outb_cpu_crypto_prepare(sa, l4ofs + k, rc,
 488                                 ivbuf[k]);
 489
 490                         /* fill iv, digest and aad */
 491                         iv[k] = ivbuf[k];
 492                         aad[k] = icv.va + sa->icv_len;
 493                         dgst[k++] = icv.va;
 494                 } else {
 495                         dr[i - k] = i;
 496                         rte_errno = -rc;
 497                 }
 498         }
 499
 500         /* copy not prepared mbufs beyond good ones */
 501         if (k != n && k != 0)
 502                 move_bad_mbufs(mb, dr, n, n - k);
 503
 504         /* convert mbufs to iovecs and do actual crypto/auth processing */
 505         if (k != 0)
 506                 cpu_crypto_bulk(ss, sa->cofs, mb, iv, aad, dgst,
 507                         l4ofs, clen, k);
 508         return k;
 509 }
 510
 511 uint16_t
 512 cpu_outb_tun_pkt_prepare(const struct rte_ipsec_session *ss,
 513                 struct rte_mbuf *mb[], uint16_t num)
 514 {
 515         return cpu_outb_pkt_prepare(ss, mb, num, outb_tun_pkt_prepare, 0);
 516 }
 517
 518 uint16_t
 519 cpu_outb_trs_pkt_prepare(const struct rte_ipsec_session *ss,
 520                 struct rte_mbuf *mb[], uint16_t num)
 521 {
 522         return cpu_outb_pkt_prepare(ss, mb, num, outb_trs_pkt_prepare,
 523                 UINT32_MAX);
 524 }
 525
 526 /*
 527  * process outbound packets for SA with ESN support,
 528  * for algorithms that require SQN.hibits to be implictly included
 529  * into digest computation.
 530  * In that case we have to move ICV bytes back to their proper place.
 531  */
 532 uint16_t
 533 esp_outb_sqh_process(const struct rte_ipsec_session *ss, struct rte_mbuf *mb[],
 534         uint16_t num)
 535 {
 536         uint32_t i, k, icv_len, *icv;
 537         struct rte_mbuf *ml;
 538         struct rte_ipsec_sa *sa;
 539         uint32_t dr[num];
 540
 541         sa = ss->sa;
 542
 543         k = 0;
 544         icv_len = sa->icv_len;
 545
 546         for (i = 0; i != num; i++) {
 547                 if ((mb[i]->ol_flags & PKT_RX_SEC_OFFLOAD_FAILED) == 0) {
 548                         ml = rte_pktmbuf_lastseg(mb[i]);
 549                         /* remove high-order 32 bits of esn from packet len */
 550                         mb[i]->pkt_len -= sa->sqh_len;
 551                         ml->data_len -= sa->sqh_len;
 552                         icv = rte_pktmbuf_mtod_offset(ml, void *,
 553                                 ml->data_len - icv_len);
 554                         remove_sqh(icv, icv_len);
 555                         k++;
 556                 } else
 557                         dr[i - k] = i;
 558         }
 559
 560         /* handle unprocessed mbufs */
 561         if (k != num) {
 562                 rte_errno = EBADMSG;
 563                 if (k != 0)
 564                         move_bad_mbufs(mb, dr, num, num - k);
 565         }
 566
 567         return k;
 568 }
 569
 570 /*
 571  * prepare packets for inline ipsec processing:
 572  * set ol_flags and attach metadata.
 573  */
 574 static inline void
 575 inline_outb_mbuf_prepare(const struct rte_ipsec_session *ss,
 576         struct rte_mbuf *mb[], uint16_t num)
 577 {
 578         uint32_t i, ol_flags;
 579
 580         ol_flags = ss->security.ol_flags & RTE_SECURITY_TX_OLOAD_NEED_MDATA;
 581         for (i = 0; i != num; i++) {
 582
 583                 mb[i]->ol_flags |= PKT_TX_SEC_OFFLOAD;
 584                 if (ol_flags != 0)
 585                         rte_security_set_pkt_metadata(ss->security.ctx,
 586                                 ss->security.ses, mb[i], NULL);
 587         }
 588 }
 589
 590 /*
 591  * process group of ESP outbound tunnel packets destined for
 592  * INLINE_CRYPTO type of device.
 593  */
 594 uint16_t
 595 inline_outb_tun_pkt_process(const struct rte_ipsec_session *ss,
 596         struct rte_mbuf *mb[], uint16_t num)
 597 {
 598         int32_t rc;
 599         uint32_t i, k, n;
 600         uint64_t sqn;
 601         rte_be64_t sqc;
 602         struct rte_ipsec_sa *sa;
 603         union sym_op_data icv;
 604         uint64_t iv[IPSEC_MAX_IV_QWORD];
 605         uint32_t dr[num];
 606
 607         sa = ss->sa;
 608
 609         n = num;
 610         sqn = esn_outb_update_sqn(sa, &n);
 611         if (n != num)
 612                 rte_errno = EOVERFLOW;
 613
 614         k = 0;
 615         for (i = 0; i != n; i++) {
 616
 617                 sqc = rte_cpu_to_be_64(sqn + i);
 618                 gen_iv(iv, sqc);
 619
 620                 /* try to update the packet itself */
 621                 rc = outb_tun_pkt_prepare(sa, sqc, iv, mb[i], &icv, 0);
 622
 623                 k += (rc >= 0);
 624
 625                 /* failure, put packet into the death-row */
 626                 if (rc < 0) {
 627                         dr[i - k] = i;
 628                         rte_errno = -rc;
 629                 }
 630         }
 631
 632         /* copy not processed mbufs beyond good ones */
 633         if (k != n && k != 0)
 634                 move_bad_mbufs(mb, dr, n, n - k);
 635
 636         inline_outb_mbuf_prepare(ss, mb, k);
 637         return k;
 638 }
 639
 640 /*
 641  * process group of ESP outbound transport packets destined for
 642  * INLINE_CRYPTO type of device.
 643  */
 644 uint16_t
 645 inline_outb_trs_pkt_process(const struct rte_ipsec_session *ss,
 646         struct rte_mbuf *mb[], uint16_t num)
 647 {
 648         int32_t rc;
 649         uint32_t i, k, n;
 650         uint64_t sqn;
 651         rte_be64_t sqc;
 652         struct rte_ipsec_sa *sa;
 653         union sym_op_data icv;
 654         uint64_t iv[IPSEC_MAX_IV_QWORD];
 655         uint32_t dr[num];
 656
 657         sa = ss->sa;
 658
 659         n = num;
 660         sqn = esn_outb_update_sqn(sa, &n);
 661         if (n != num)
 662                 rte_errno = EOVERFLOW;
 663
 664         k = 0;
 665         for (i = 0; i != n; i++) {
 666
 667                 sqc = rte_cpu_to_be_64(sqn + i);
 668                 gen_iv(iv, sqc);
 669
 670                 /* try to update the packet itself */
 671                 rc = outb_trs_pkt_prepare(sa, sqc, iv, mb[i], &icv, 0);
 672
 673                 k += (rc >= 0);
 674
 675                 /* failure, put packet into the death-row */
 676                 if (rc < 0) {
 677                         dr[i - k] = i;
 678                         rte_errno = -rc;
 679                 }
 680         }
 681
 682         /* copy not processed mbufs beyond good ones */
 683         if (k != n && k != 0)
 684                 move_bad_mbufs(mb, dr, n, n - k);
 685
 686         inline_outb_mbuf_prepare(ss, mb, k);
 687         return k;
 688 }
 689
 690 /*
 691  * outbound for RTE_SECURITY_ACTION_TYPE_INLINE_PROTOCOL:
 692  * actual processing is done by HW/PMD, just set flags and metadata.
 693  */
 694 uint16_t
 695 inline_proto_outb_pkt_process(const struct rte_ipsec_session *ss,
 696         struct rte_mbuf *mb[], uint16_t num)
 697 {
 698         inline_outb_mbuf_prepare(ss, mb, num);
 699         return num;
 700 }