lib/librte_ipsec/misc.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #ifndef _MISC_H_
   6 #define _MISC_H_
   7
   8 /**
   9  * @file misc.h
  10  * Contains miscellaneous functions/structures/macros used internally
  11  * by ipsec library.
  12  */
  13
  14 /*
  15  * Move bad (unprocessed) mbufs beyond the good (processed) ones.
  16  * bad_idx[] contains the indexes of bad mbufs inside the mb[].
  17  */
  18 static inline void
  19 move_bad_mbufs(struct rte_mbuf *mb[], const uint32_t bad_idx[], uint32_t nb_mb,
  20         uint32_t nb_bad)
  21 {
  22         uint32_t i, j, k;
  23         struct rte_mbuf *drb[nb_bad];
  24
  25         j = 0;
  26         k = 0;
  27
  28         /* copy bad ones into a temp place */
  29         for (i = 0; i != nb_mb; i++) {
  30                 if (j != nb_bad && i == bad_idx[j])
  31                         drb[j++] = mb[i];
  32                 else
  33                         mb[k++] = mb[i];
  34         }
  35
  36         /* copy bad ones after the good ones */
  37         for (i = 0; i != nb_bad; i++)
  38                 mb[k + i] = drb[i];
  39 }
  40
  41 /*
  42  * Find packet's segment for the specified offset.
  43  * ofs - at input should contain required offset, at output would contain
  44  * offset value within the segment.
  45  */
  46 static inline struct rte_mbuf *
  47 mbuf_get_seg_ofs(struct rte_mbuf *mb, uint32_t *ofs)
  48 {
  49         uint32_t k, n, plen;
  50         struct rte_mbuf *ms;
  51
  52         plen = mb->pkt_len;
  53         n = *ofs;
  54
  55         if (n == plen) {
  56                 ms = rte_pktmbuf_lastseg(mb);
  57                 n = n + rte_pktmbuf_data_len(ms) - plen;
  58         } else {
  59                 ms = mb;
  60                 for (k = rte_pktmbuf_data_len(ms); n >= k;
  61                                 k = rte_pktmbuf_data_len(ms)) {
  62                         ms = ms->next;
  63                         n -= k;
  64                 }
  65         }
  66
  67         *ofs = n;
  68         return ms;
  69 }
  70
  71 /*
  72  * Trim multi-segment packet at the specified offset, and free
  73  * all unused segments.
  74  * mb - input packet
  75  * ms - segment where to cut
  76  * ofs - offset within the *ms*
  77  * len - length to cut (from given offset to the end of the packet)
  78  * Can be used in conjunction with mbuf_get_seg_ofs():
  79  * ofs = new_len;
  80  * ms = mbuf_get_seg_ofs(mb, &ofs);
  81  * mbuf_cut_seg_ofs(mb, ms, ofs, mb->pkt_len - new_len);
  82  */
  83 static inline void
  84 mbuf_cut_seg_ofs(struct rte_mbuf *mb, struct rte_mbuf *ms, uint32_t ofs,
  85         uint32_t len)
  86 {
  87         uint32_t n, slen;
  88         struct rte_mbuf *mn;
  89
  90         slen = ms->data_len;
  91         ms->data_len = ofs;
  92
  93         /* tail spawns through multiple segments */
  94         if (slen < ofs + len) {
  95                 mn = ms->next;
  96                 ms->next = NULL;
  97                 for (n = 0; mn != NULL; n++) {
  98                         ms = mn->next;
  99                         rte_pktmbuf_free_seg(mn);
 100                         mn = ms;
 101                 }
 102                 mb->nb_segs -= n;
 103         }
 104
 105         mb->pkt_len -= len;
 106 }
 107
 108 #endif /* _MISC_H_ */