ndni: LpHeader_Parse accepts segmented mbuf

Author: yoursunny

csrc/dpdk/mbuf.h

@@ -113,6 +113,33 @@ Mbuf_ChainVector(struct rte_mbuf* vec[], uint16_t count) {
   return head;
 }
 
+/**
+ * @brief Free a sequence of segments.
+ * @param begin pointer to first segment pointer.
+ * @param end exclusive last segment, will not be freed.
+ * @param pktLen pointer to packet length, will be decremented.
+ * @return number of freed segments.
+ * @post @c *begin is freed, but @c end is not freed.
+ * @post *begin == end
+ * @code
+ * // free second through last segments of an mbuf
+ * pkt->nb_segs -= Mbuf_FreeSegs(&pkt->next, NULL, &pkt->pkt_len);
+ * @endcode
+ */
+__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;
+}
+
 /**
  * @brief Enqueue a burst of packets to a ring buffer.
  * @param autoFree if true, rejected packets are freed.

csrc/iface/face-rx.c

@@ -11,7 +11,7 @@ FaceRx_Input(Face* face, int rxThread, struct rte_mbuf* pkt) {
   rxt->nFrames[0] += pkt->pkt_len; // nOctets counter
 
   Packet* npkt = Packet_FromMbuf(pkt);
-  if (unlikely(!rte_pktmbuf_is_contiguous(pkt) || !Packet_Parse(npkt, face->impl->rxParseFor))) {
+  if (unlikely(!Packet_Parse(npkt, face->impl->rxParseFor))) {
     ++rxt->nDecodeErr;
     N_LOGD("l2-decode-error face=%" PRI_FaceID " thread=%d", face->id, rxThread);
     rte_pktmbuf_free(pkt);

csrc/iface/reassembler.c

@@ -91,10 +91,13 @@ Reassembler_Reassemble_(Reassembler* reass, LpL2* pm, hash_sig_t hash) {
 Packet*
 Reassembler_Accept(Reassembler* reass, Packet* fragment) {
   struct rte_mbuf* pkt = Packet_ToMbuf(fragment);
+  if (unlikely(!rte_pktmbuf_is_contiguous(pkt))) {
+    goto DROP_PKT;
+  }
   LpL2* l2 = &Packet_GetLpHdr(fragment)->l2;
   NDNDPDK_ASSERT(l2->fragCount > 1 && // single fragment packets should bypass reassembler
                  l2->fragCount <= LpMaxFragments && RTE_MBUF_DIRECT(pkt) &&
-                 rte_pktmbuf_is_contiguous(pkt) && rte_mbuf_refcnt_read(pkt) == 1);
+                 rte_mbuf_refcnt_read(pkt) == 1);
 
   hash_sig_t hash = rte_hash_hash(reass->table, &l2->seqNumBase);
   LpL2* pm = NULL;

csrc/iface/reassembler.h

@@ -36,6 +36,7 @@ Reassembler_Close(Reassembler* reass);
 /**
  * @brief Accept an incoming fragment.
  * @param fragment an NDNLPv2 fragment. It must have type PktFragment and FragCount greater than 1.
+ *                 Non-contiguous packet is unsupported and will be rejected.
  * @return a reassembled network layer packet, unparsed.
  * @retval NULL no network layer packet is ready.
  */

csrc/ndni/lp.c

@@ -46,32 +46,40 @@ LpHeader_ParseNack(LpHeader* lph, TlvDecoder* d) {
 
 bool
 LpHeader_Parse(LpHeader* lph, struct rte_mbuf* pkt) {
-  NDNDPDK_ASSERT(RTE_MBUF_DIRECT(pkt) && rte_pktmbuf_is_contiguous(pkt) &&
-                 rte_mbuf_refcnt_read(pkt) == 1);
+  NDNDPDK_ASSERT(RTE_MBUF_DIRECT(pkt) && rte_mbuf_refcnt_read(pkt) == 1);
   *lph = (const LpHeader){0};
   lph->l2.fragCount = 1;
+  uint64_t seqNum = 0;
 
   TlvDecoder d = TlvDecoder_Init(pkt);
   uint32_t length0, type0 = TlvDecoder_ReadTL(&d, &length0);
-  pkt->pkt_len = pkt->data_len = d.offset + length0; // strip Ethernet trailer, if any
-  d.length = length0;
   switch (type0) {
     case TtInterest:
-    case TtData:
-      return true;
+    case TtData: {
+      uint32_t trailerL = d.length - length0;
+      if (likely(trailerL == 0)) {
+        // no Ethernet trailer, no truncation needed
+        return true;
+      }
+      d = TlvDecoder_Init(pkt);
+      d.length -= trailerL;
+      goto ACCEPT;
+    }
     case TtLpPacket:
+      d.length = length0;
       break;
     default:
       return false;
   }
 
-  uint64_t seqNum = 0;
   TlvDecoder_EachTL (&d, type, length) {
     switch (type) {
       case TtLpPayload: {
-        pkt->data_off += d.offset;
-        pkt->pkt_len = pkt->data_len = length;
-        goto FOUND_PAYLOAD;
+        if (unlikely(length == 0)) {
+          return false;
+        }
+        d.length = length;
+        goto ACCEPT;
       }
       case TtLpSeqNum: {
         if (unlikely(length != 8 || !TlvDecoder_ReadNniTo(&d, length, &seqNum))) {
@@ -121,10 +129,18 @@ LpHeader_Parse(LpHeader* lph, struct rte_mbuf* pkt) {
     }
   }
 
-  pkt->pkt_len = pkt->data_len = 0; // no payload
-FOUND_PAYLOAD:;
+  // no payload i.e. IDLE packet, no feature depends on it
+  return false;
+
+ACCEPT:;
   lph->l2.seqNumBase = seqNum - lph->l2.fragIndex;
-  return lph->l2.fragIndex < lph->l2.fragCount;
+  if (unlikely(lph->l2.fragIndex >= lph->l2.fragCount)) {
+    return false;
+  }
+
+  // truncate pkt to d.length that covers fragment
+  TlvDecoder_Truncate(&d);
+  return true;
 }
 
 void

csrc/ndni/lp.h

@@ -67,7 +67,7 @@ typedef struct LpHeader {
 
 /**
  * @brief Parse NDNLPv2 header and strip from mbuf.
- * @param pkt a uniquely owned, unsegmented, direct mbuf.
+ * @param pkt a uniquely owned, possibly segmented, direct mbuf.
  * @return whether success.
  * @post @p pkt contains only (fragment of) network layer packet.
  *

csrc/ndni/packet.c

@@ -10,8 +10,7 @@ const char* PktType_Strings_[] = {
 bool
 Packet_Parse(Packet* npkt, ParseFor parseFor) {
   struct rte_mbuf* pkt = Packet_ToMbuf(npkt);
-  NDNDPDK_ASSERT(RTE_MBUF_DIRECT(pkt) && rte_pktmbuf_is_contiguous(pkt) &&
-                 rte_mbuf_refcnt_read(pkt) == 1);
+  NDNDPDK_ASSERT(RTE_MBUF_DIRECT(pkt) && rte_mbuf_refcnt_read(pkt) == 1);
   pkt->packet_type = 0;
   PacketPriv* priv = Packet_GetPriv_(npkt);
   NDNDPDK_ASSERT(pkt->priv_size >= sizeof(*priv));
@@ -22,11 +21,6 @@ Packet_Parse(Packet* npkt, ParseFor parseFor) {
     return false;
   }
 
-  if (unlikely(pkt->pkt_len == 0)) {
-    // there isn't any feature that depends on IDLE packets yet
-    return false;
-  }
-
   if (lph->l2.fragCount > 1) {
     Packet_SetType(npkt, PktFragment);
     return true;

csrc/ndni/packet.h

@@ -122,7 +122,7 @@ Packet_GetNackHdr(Packet* npkt) {
 
 /**
  * @brief Parse layer 2 and layer 3 in mbuf.
- * @param npkt a uniquely owned, unsegmented, direct mbuf.
+ * @param npkt a uniquely owned, possibly segmented, direct mbuf.
  * @param parseFor see @c PInterest_Parse and @c PData_Parse .
  * @return whether success.
  * @post If the packet is fragmented, Packet_GetType(npkt) returns @c PktFragment .

csrc/ndni/tlv-decoder.c

@@ -1,5 +1,57 @@
 #include "tlv-decoder.h"
 
+void
+TlvDecoder_Truncate(TlvDecoder* d) {
+  uint32_t length = d->length;
+  NDNDPDK_ASSERT(length > 0);
+
+  if (unlikely(d->m != d->p)) { // d->m is not the first segment
+    // move 1 octet from d->m to d->p so that the first segment is non-empty
+    NDNDPDK_ASSERT(d->p->data_len >= 1);
+    d->p->pkt_len -= (d->p->data_len - 1);
+    d->p->data_len = 1;
+    d->p->data_off = RTE_PKTMBUF_HEADROOM;
+    TlvDecoder_Copy(d, rte_pktmbuf_mtod(d->p, uint8_t*), 1);
+    rte_mbuf_sanity_check(d->p, true);
+
+    if (unlikely(d->length == 0)) { // 1-octet packet, already in d->p
+      d->p->nb_segs -= Mbuf_FreeSegs(&d->p->next, NULL, &d->p->pkt_len);
+      goto FINISH;
+    }
+
+    // delete segments after d->p and before d->m
+    d->p->nb_segs -= Mbuf_FreeSegs(&d->p->next, d->m, &d->p->pkt_len);
+    rte_mbuf_sanity_check(d->p, true);
+  }
+
+  // delete d->m[:d->offset] range
+  d->p->pkt_len -= d->offset;
+  d->m->data_len -= d->offset;
+  d->m->data_off += d->offset;
+  d->offset = 0;
+  rte_mbuf_sanity_check(d->p, true);
+
+  // skip over to end of fragment
+  struct rte_mbuf* last = d->m;
+  TlvDecoder_Skip_(d, d->length, &last);
+  if (d->offset == 0) { // d->m does not contain useful octets
+    // delete d->m and segments after d->m
+    d->p->nb_segs -= Mbuf_FreeSegs(&last->next, NULL, &d->p->pkt_len);
+  } else { // d->m contains useful octets
+    // delete d->m[d->offset:] range
+    d->p->pkt_len -= (d->m->data_len - d->offset);
+    d->m->data_len = d->offset;
+
+    // delete segments after d->m
+    d->p->nb_segs -= Mbuf_FreeSegs(&d->m->next, NULL, &d->p->pkt_len);
+  }
+
+FINISH:;
+  rte_mbuf_sanity_check(d->p, true);
+  NDNDPDK_ASSERT(d->p->pkt_len == length);
+  POISON(d);
+}
+
 void
 TlvDecoder_Copy_(TlvDecoder* d, uint8_t* output, uint16_t count) {
   for (uint16_t remain = count; remain > 0;) {
@@ -122,13 +174,8 @@ TlvDecoder_Fragment(TlvDecoder* d, uint32_t count, struct rte_mbuf* frames[], ui
 
 __attribute__((nonnull)) static void
 Linearize_Delete_(TlvDecoder* d, struct rte_mbuf* c) {
-  for (struct rte_mbuf* seg = c->next; seg != d->m;) {
-    struct rte_mbuf* next = seg->next;
-    rte_pktmbuf_free_seg(seg);
-    --d->p->nb_segs;
-    seg = next;
-  }
-  c->next = d->m;
+  uint32_t unusedPktLen = UINT32_MAX;
+  d->p->nb_segs -= Mbuf_FreeSegs(&c->next, d->m, &unusedPktLen);
   if (likely(d->m != NULL)) {
     d->m->data_len -= d->offset;
     d->m->data_off += d->offset;

csrc/ndni/tlv-decoder.h

@@ -29,14 +29,11 @@ TlvDecoder_Init(struct rte_mbuf* p) {
   };
 }
 
-/**
- * @brief Skip @p count octets.
- * @pre Decoder has no less than @p count remaining octets.
- */
 __attribute__((nonnull)) static inline void
-TlvDecoder_Skip(TlvDecoder* d, uint32_t count) {
+TlvDecoder_Skip_(TlvDecoder* d, uint32_t count, struct rte_mbuf** last) {
   NDNDPDK_ASSERT(count <= d->length);
   for (uint32_t remain = count; remain > 0;) {
+    *last = d->m;
     uint32_t here = d->m->data_len - d->offset;
     if (likely(remain < here)) {
       d->offset += remain;
@@ -49,6 +46,26 @@ TlvDecoder_Skip(TlvDecoder* d, uint32_t count) {
   d->length -= count;
 }
 
+/**
+ * @brief Skip @p count octets.
+ * @pre Decoder has no less than @p count remaining octets.
+ */
+__attribute__((nonnull)) static inline void
+TlvDecoder_Skip(TlvDecoder* d, uint32_t count) {
+  struct rte_mbuf* unusedLast = NULL;
+  TlvDecoder_Skip_(d, count, &unusedLast);
+}
+
+/**
+ * @brief Truncate mbuf to the remaining bytes.
+ * @param d decoder.
+ *          It shall have a uniquely owned, possibly segmented, direct mbuf.
+ *          Its remaining length shall be non-zero.
+ * @post @p d cannot be further used.
+ */
+void
+TlvDecoder_Truncate(TlvDecoder* d);
+
 __attribute__((nonnull)) void
 TlvDecoder_Copy_(TlvDecoder* d, uint8_t* output, uint16_t count);
 
@@ -63,6 +80,15 @@ TlvDecoder_Copy(TlvDecoder* d, uint8_t* output, uint16_t count) {
   if (unlikely(count == 0)) {
     return;
   }
+
+  uint16_t here = d->m->data_len - d->offset;
+  if (likely(count < here)) {
+    rte_memcpy(output, rte_pktmbuf_mtod_offset(d->m, const uint8_t*, d->offset), count);
+    d->offset += count;
+    d->length -= count;
+    return;
+  }
+
   TlvDecoder_Copy_(d, output, count);
 }
 

ndni/README.md

@@ -73,9 +73,9 @@ To receive and parse a packet, calling code should:
 ### Interest Decoding Details
 
 `PInterest_Parse` function decodes an Interest.
-If the Interest carries a *forwarding hint*, up to `PInterestMaxFwHints` delegations are recognized, and any remaining delegations are ignored.
+If the Interest carries a *forwarding hint*, up to `PInterestMaxFwHints` names are recognized, and any remaining names are ignored.
 The decoder only determines the length of each name, but does not parse at component level.
-`PInterest_SelectFwHint` function activates a forwarding hint, parses the delegation into components on demand; only one delegation name can be active at any time.
+`PInterest_SelectFwHint` function activates a forwarding hint, parses the name into components on demand; only one name can be active at any time.
 
 Although the packet format specifies Nonce as optional, it is required when an Interest is transmitted over network links.
 Thus, `PInterest_Parse` requires Nonce to be present.