mbuf.h

Go to the documentation of this file.

#ifndef NDNDPDK_DPDK_MBUF_H
#define NDNDPDK_DPDK_MBUF_H

 
#include "tsc.h"
#include <rte_mbuf.h>
#include <rte_mbuf_dyn.h>
#include <rte_ring.h>
 
enum {
  Mbuf_HasMark = RTE_MBUF_F_RX_FDIR | RTE_MBUF_F_RX_FDIR_ID,
};
 
extern int Mbuf_Timestamp_DynFieldOffset_;

bool
Mbuf_RegisterDynFields();

__attribute__((nonnull)) static inline TscTime
Mbuf_GetTimestamp(struct rte_mbuf* m) {
  return *RTE_MBUF_DYNFIELD(m, Mbuf_Timestamp_DynFieldOffset_, TscTime*);
}

__attribute__((nonnull)) static inline void
Mbuf_SetTimestamp(struct rte_mbuf* m, TscTime timestamp) {
  *RTE_MBUF_DYNFIELD(m, Mbuf_Timestamp_DynFieldOffset_, TscTime*) = timestamp;
}

__attribute__((nonnull)) static inline uint32_t
Mbuf_GetMark(const struct rte_mbuf* m) {
  if ((m->ol_flags & Mbuf_HasMark) != Mbuf_HasMark) {
    return 0;
  }
  return m->hash.fdir.hi;
}

__attribute__((nonnull)) static inline void
Mbuf_SetMark(struct rte_mbuf* m, uint32_t value) {
  m->ol_flags |= Mbuf_HasMark;
  m->hash.fdir.hi = value;
}

__attribute__((nonnull)) static inline void
Mbuf_ReadTo(const struct rte_mbuf* m, uint32_t off, uint32_t len, void* dst) {
  const uint8_t* readTo = rte_pktmbuf_read(m, off, len, dst);
  if (readTo != dst) {
    rte_memcpy(dst, readTo, len);
  }
}

__attribute__((nonnull)) int
Mbuf_AsIovec(struct rte_mbuf* m, struct iovec* iov, uint32_t offset, uint32_t length);

__attribute__((nonnull)) struct rte_mbuf*
Mbuf_AllocRoom(struct rte_mempool* mp, struct iovec* iov, int* iovcnt, uint16_t firstHeadroom,
               uint16_t firstDataLen, uint16_t eachHeadroom, uint16_t eachDataLen, uint32_t pktLen);

__attribute__((nonnull)) void
Mbuf_RemainingIovec(struct spdk_iov_xfer ix, struct iovec* iov, int* iovcnt);

__attribute__((nonnull, warn_unused_result)) static inline bool
Mbuf_Chain(struct rte_mbuf* head, struct rte_mbuf* lastSeg, struct rte_mbuf* tail) {
  if (unlikely(head->nb_segs + tail->nb_segs > RTE_MBUF_MAX_NB_SEGS)) {
    struct rte_mbuf* mbufs[2] = {head, tail};
    rte_pktmbuf_free_bulk(mbufs, RTE_DIM(mbufs));
    return false;
  }
 
  lastSeg->next = tail;
  head->nb_segs += tail->nb_segs;
  head->pkt_len += tail->pkt_len;
  return true;
}

__attribute__((nonnull, warn_unused_result)) static inline struct rte_mbuf*
Mbuf_ChainVector(struct rte_mbuf* vec[], uint16_t count) {
  struct rte_mbuf* head = NULL;
  struct rte_mbuf* last = NULL;
  for (uint16_t i = 0; i < count; ++i) {
    struct rte_mbuf* m = vec[i];
    if (unlikely(m == NULL)) {
      continue;
    }
 
    if (head == NULL) {
      head = m;
      last = rte_pktmbuf_lastseg(m);
      continue;
    }
 
    struct rte_mbuf* mLast = rte_pktmbuf_lastseg(m);
    bool ok = Mbuf_Chain(head, last, m);
    if (unlikely(!ok)) {
      ++i;
      rte_pktmbuf_free_bulk(&vec[i], count - i);
      return NULL;
    }
    last = mLast;
  }
  return head;
}

__attribute__((nonnull(1, 3))) static inline uint16_t
Mbuf_FreeSegs(struct rte_mbuf** begin, struct rte_mbuf* end, uint32_t* pktLen) {
  uint16_t count = 0;
  for (struct rte_mbuf* seg = *begin; seg != end;) {
    struct rte_mbuf* next = seg->next;
    ++count;
    *pktLen -= seg->data_len;
    rte_pktmbuf_free_seg(seg);
    seg = next;
  }
  *begin = end;
  return count;
}

__attribute__((nonnull)) static __rte_always_inline uint32_t
Mbuf_EnqueueVector(struct rte_mbuf* vec[], uint32_t count, struct rte_ring* ring, bool autoFree) {
  uint32_t nEnq = rte_ring_enqueue_burst(ring, (void**)vec, count, NULL);
  uint32_t nRej = count - nEnq;
  if (autoFree && unlikely(nRej > 0)) {
    rte_pktmbuf_free_bulk(&vec[nEnq], nRej);
  }
  return nRej;
}
 
#endif // NDNDPDK_DPDK_MBUF_H