ethport: match GTP-U with RAW item on i40e

yoursunny · yoursunny · commit f036c341c8b5 · 2025-03-12T15:00:25.000-06:00
diff --git a/csrc/dpdk/ethdev.h b/csrc/dpdk/ethdev.h
@@ -29,12 +29,15 @@ typedef enum EthFlowFlags {
    */
   EthFlowFlagsVxRaw = RTE_BIT32(8),
 
-  /**
-   * @brief How to generate GTP-U flow item.
-   * 0 = prefer @c RTE_FLOW_ITEM_TYPE_GTPU .
-   * 1 = prefer @c RTE_FLOW_ITEM_TYPE_GTP .
-   */
-  EthFlowFlagsGtp = RTE_BIT32(12),
+  /** @brief Bitmask to indicate how to generate GTP-U flow items. */
+  EthFlowFlagsGtpMask = RTE_GENMASK32(13, 12),
+
+  /** @brief Generate GTP-U flow item as @c RTE_FLOW_ITEM_TYPE_GTPU . */
+  EthFlowFlagsGtpGtpu = RTE_SHIFT_VAL32(0, 12),
+  /** @brief Generate GTP-U flow item as @c RTE_FLOW_ITEM_TYPE_GTP . */
+  EthFlowFlagsGtpGtp = RTE_SHIFT_VAL32(1, 12),
+  /** @brief Generate GTP-U flow item as @c RTE_FLOW_ITEM_TYPE_RAW . */
+  EthFlowFlagsGtpRaw = RTE_SHIFT_VAL32(2, 12),
 
   /**
    * @brief How to generate actions when RSS is used.
diff --git a/csrc/ethface/flowdef.c b/csrc/ethface/flowdef.c
@@ -17,6 +17,21 @@ AppendItem(EthFlowDef* flow, size_t* i, enum rte_flow_item_type typ, const void*
   NDNDPDK_ASSERT(*i < RTE_DIM(flow->pattern));
 }
 
+__attribute__((nonnull)) static inline void
+PrepareRawItem(EthFlowDef* flow, int32_t offset, uint16_t length, const void* spec,
+               const void* mask) {
+  NDNDPDK_ASSERT(length <= sizeof(flow->rawSpecBuf));
+  memmove(flow->rawSpecBuf, spec, length);
+  memmove(flow->rawMaskBuf, mask, length);
+
+  flow->rawSpec.relative = 1;
+  flow->rawSpec.offset = offset;
+  flow->rawSpec.length = length;
+  flow->rawSpec.pattern = flow->rawSpecBuf;
+  flow->rawMask = rte_flow_item_raw_mask;
+  flow->rawMask.pattern = flow->rawMaskBuf;
+}
+
 __attribute__((nonnull)) static inline void
 PrepareVxlan(const EthLocator* loc, struct rte_vxlan_hdr* vxlanSpec,
              struct rte_vxlan_hdr* vxlanMask, struct rte_ether_hdr* innerEthSpec,
@@ -101,15 +116,7 @@ GeneratePattern(EthFlowDef* flow, size_t specLen[], const EthLocator* loc, EthLo
         } __rte_aligned(2) spec = {0}, mask = {0};
         PrepareVxlan(loc, &spec.vxlan, &mask.vxlan, &spec.eth, &mask.eth);
         static_assert(sizeof(spec) == 4 + 16 + 2, "");
-        rte_mov16(flow->rawSpecBuf, RTE_PTR_ADD(&spec, 4));
-        rte_mov16(flow->rawMaskBuf, RTE_PTR_ADD(&mask, 4));
-
-        flow->rawSpec.relative = 1;
-        flow->rawSpec.offset = 4;
-        flow->rawSpec.length = 16;
-        flow->rawSpec.pattern = flow->rawSpecBuf;
-        flow->rawMask = rte_flow_item_raw_mask;
-        flow->rawMask.pattern = flow->rawMaskBuf;
+        PrepareRawItem(flow, 4, 16, RTE_PTR_ADD(&spec, 4), RTE_PTR_ADD(&mask, 4));
         APPEND(RAW, raw);
       } else {
         PrepareVxlan(loc, &flow->vxlanSpec.hdr, &flow->vxlanMask.hdr, &flow->innerEthSpec.hdr,
@@ -120,15 +127,36 @@ GeneratePattern(EthFlowDef* flow, size_t specLen[], const EthLocator* loc, EthLo
       break;
     }
     case 'G': {
-      EthGtpHdr spec = {0};
+      EthGtpHdr spec = {0}, mask = {0};
       PutGtpHdr((uint8_t*)&spec, true, loc->ulTEID, loc->ulQFI);
-      flow->gtpSpec.hdr = spec.hdr;
-      MASK(flow->gtpMask.hdr.teid);
 
-      if (flowFlags & EthFlowFlagsGtp) {
-        APPEND(GTP, gtp);
-      } else {
-        APPEND(GTPU, gtp);
+      switch (flowFlags & EthFlowFlagsGtpMask) {
+        case EthFlowFlagsGtpGtpu: {
+          APPEND(GTPU, gtp);
+          goto FILL_GTP_ITEM;
+        }
+        case EthFlowFlagsGtpGtp: {
+          APPEND(GTP, gtp);
+        FILL_GTP_ITEM:
+          flow->gtpSpec.hdr = spec.hdr;
+          MASK(flow->gtpMask.hdr.teid);
+          break;
+        }
+        case EthFlowFlagsGtpRaw: {
+          // In i40e driver, RAW item can have up to I40E_FDIR_MAX_FLEX_LEN=16 uint16 words, of
+          // which up to I40E_FDIR_BITMASK_NUM_WORD=2 words may have a "bit mask" i.e. mask other
+          // than 0000 and FFFF, see i40e_flow_store_flex_mask(). We use bit masks on the first and
+          // eighth words. mask.hdr.ver is unmasked because masking it seems to cause packet loss.
+          mask.hdr.pt = 1;
+          mask.hdr.e = 1;
+          MASK(mask.hdr.msg_type);
+          MASK(mask.hdr.teid);
+          mask.psc.qfi = 0b111111;
+          static_assert(sizeof(spec) == 16);
+          PrepareRawItem(flow, 0, 16, &spec, &mask);
+          APPEND(RAW, raw);
+          break;
+        }
       }
       break;
     }
@@ -215,8 +243,12 @@ __attribute__((nonnull)) static inline void
 PrintDef(const EthFlowDef* flow, size_t specLen[]) {
   for (int i = 0; i >= 0; ++i) {
     const struct rte_flow_item* item = &flow->pattern[i];
-    char b16Spec[Base16_BufferSize(64)] = {'-', 0};
-    char b16Mask[Base16_BufferSize(64)] = {'-', 0};
+    enum {
+      b16BufOctets = 64,
+      b16BufSize = Base16_BufferSize(b16BufOctets),
+    };
+    char b16Spec[b16BufSize] = {'-', 0};
+    char b16Mask[b16BufSize] = {'-', 0};
     if (item->spec != NULL && item->mask != NULL) {
       NDNDPDK_ASSERT(specLen[i] <= 64);
       Base16_Encode(b16Spec, sizeof(b16Spec), item->spec, specLen[i]);
@@ -227,25 +259,29 @@ PrintDef(const EthFlowDef* flow, size_t specLen[]) {
                       (const void*)(uintptr_t)item->type, NULL) <= 0) {
       typeName = "-";
     }
-    N_LOGD("^ pattern index=%d type=%d~%s spec=%s mask=%s", i, (int)item->type, typeName, b16Spec,
-           b16Mask);
     switch (item->type) {
       case RTE_FLOW_ITEM_TYPE_END:
         i = -2; // break loop
         break;
       case RTE_FLOW_ITEM_TYPE_RAW: {
         const struct rte_flow_item_raw* spec = item->spec;
         const struct rte_flow_item_raw* mask = item->mask;
-        Base16_Encode(b16Spec, sizeof(b16Spec), spec->pattern, spec->length);
-        Base16_Encode(b16Mask, sizeof(b16Mask), mask->pattern, spec->length);
-        N_LOGD("^ pattern-raw index=%d relative=%" PRIu32 " offset=%" PRId32
-               " spec.pattern=%s mask.pattern=%s",
-               i, spec->relative, spec->offset, b16Spec, b16Mask);
+        NDNDPDK_ASSERT(sizeof(*spec) + 1 + spec->length <= b16BufOctets);
+        int b16Offset = 2 * sizeof(*spec);
+        b16Spec[b16Offset] = '+';
+        b16Mask[b16Offset] = '+';
+        ++b16Offset;
+        Base16_Encode(RTE_PTR_ADD(b16Spec, b16Offset), sizeof(b16Spec) - b16Offset, spec->pattern,
+                      spec->length);
+        Base16_Encode(RTE_PTR_ADD(b16Mask, b16Offset), sizeof(b16Mask) - b16Offset, mask->pattern,
+                      spec->length);
         break;
       }
       default:
         break;
     }
+    N_LOGD("^ pattern index=%d type=%d~%s spec=%s mask=%s", i, (int)item->type, typeName, b16Spec,
+           b16Mask);
   }
 
   for (int i = 0;; ++i) {
diff --git a/docs/face.md b/docs/face.md
@@ -68,7 +68,7 @@ Example commands:
 dpdk-devbind.py --status-dev net
 
 # change kernel driver binding (only needed for some NICs, see DPDK docs on what driver to use)
-sudo dpdk-devbind.py -b uio_pci_generic 04:00.0
+sudo dpdk-devbind.py -b vfio-pci 04:00.0
 
 # create an Ethernet port with PCI driver, enable RxFlow with 16 queues
 ndndpdk-ctrl create-eth-port --pci 04:00.0 --mtu 1500 --rx-flow 16
diff --git a/docs/nics.md b/docs/nics.md
@@ -231,6 +231,7 @@ The VXLAN item in `pattern_vxlan_[12]` patterns are unusable because the parser
 GTP-U tunnel face is supported through `pattern_fdir_ipv4_gtpu`.
 This pattern relies on [Dynamic Device Personalization (DDP)](https://www.intel.com/content/www/us/en/developer/articles/technical/dynamic-device-personalization-for-intel-ethernet-700-series.html) feature.
 You must manually download the [GTPv1 DDP profile](https://downloadcenter.intel.com/download/27587) and place it at `/lib/firmware/intel/i40e/ddp/gtp.pkg`.
+To use this in Docker, you also need to bind-mount the directory into the container with `--mount type=bind,source=/lib/firmware/intel/i40e/ddp,target=/lib/firmware/intel/i40e/ddp,readonly=true` flag.
 If the profile is found, you would see "upload DDP package success" log message during Ethernet port creation.
 Without the profile, GTP-U face creation on RxFlow fails with "GTP is not supported by default" error.
 During NDN-DPDK service shutdown, a profile rollback will be attempted.
diff --git a/dpdk/ethdev/ddp.go b/dpdk/ethdev/ddp.go
@@ -20,9 +20,10 @@ import (
 
 // DdpProfile represents a Dynamic Device Personalization profile.
 type DdpProfile struct {
-	pkg    []byte
-	info   C.struct_rte_pmd_i40e_profile_info
-	zapPkg zap.Field
+	pkg       []byte
+	info      C.struct_rte_pmd_i40e_profile_info
+	protocols []string
+	zapPkg    zap.Field
 }
 
 func (dp *DdpProfile) process(dev EthDev, buf []byte, op C.enum_rte_pmd_i40e_package_op, act string) error {
@@ -75,19 +76,41 @@ func OpenDdpProfile(name string) (dp *DdpProfile, e error) {
 		return nil, e
 	}
 
-	if res := C.rte_pmd_i40e_get_ddp_info((*C.uint8_t)(&dp.pkg[0]), C.uint32_t(len(dp.pkg)),
-		(*C.uint8_t)(unsafe.Pointer(&dp.info)), C.uint32_t(unsafe.Sizeof(dp.info)),
-		C.RTE_PMD_I40E_PKG_INFO_GLOBAL_HEADER); res != 0 {
-		e = eal.MakeErrno(res)
-		logEntry.Warn("parse DDP profile error", zap.Error(e))
-		return nil, fmt.Errorf("rte_pmd_i40e_get_ddp_info %w", e)
+	if e := getDdpInfo(dp.pkg, C.RTE_PMD_I40E_PKG_INFO_GLOBAL_HEADER, &dp.info, 1); e != nil {
+		return nil, e
+	}
+
+	var nProtocols uint32
+	if e := getDdpInfo(dp.pkg, C.RTE_PMD_I40E_PKG_INFO_PROTOCOL_NUM, &nProtocols, 1); e != nil {
+		return nil, e
+	}
+
+	protoInfos := make([]C.struct_rte_pmd_i40e_proto_info, nProtocols)
+	if nProtocols > 0 {
+		if e := getDdpInfo(dp.pkg, C.RTE_PMD_I40E_PKG_INFO_PROTOCOL_LIST, unsafe.SliceData(protoInfos), len(protoInfos)); e != nil {
+			return nil, e
+		}
+	}
+
+	for _, pcType := range protoInfos {
+		dp.protocols = append(dp.protocols, C.GoString(unsafe.SliceData(pcType.name[:])))
 	}
 
 	dp.zapPkg = zap.Dict("pkg",
 		zap.Uint32("track-id", uint32(dp.info.track_id)),
 		zap.String("name", C.GoString((*C.char)(unsafe.Pointer(&dp.info.name[0])))),
 		zap.String("version", fmt.Sprintf("%d.%d.%d.%d",
 			dp.info.version.major, dp.info.version.minor, dp.info.version.update, dp.info.version.draft)),
+		zap.Strings("protocols", dp.protocols),
 	)
 	return dp, nil
 }
+
+func getDdpInfo[T any](pkg []byte, typ C.enum_rte_pmd_i40e_package_info, info *T, count int) error {
+	res := C.rte_pmd_i40e_get_ddp_info((*C.uint8_t)(unsafe.SliceData(pkg)), C.uint32_t(len(pkg)),
+		(*C.uint8_t)(unsafe.Pointer(info)), C.uint32_t(unsafe.Sizeof(*info)*uintptr(count)), typ)
+	if res != 0 {
+		return fmt.Errorf("rte_pmd_i40e_get_ddp_info(%d) error %w", typ, eal.MakeErrno(res))
+	}
+	return nil
+}
diff --git a/dpdk/ethdev/info.go b/dpdk/ethdev/info.go
@@ -8,6 +8,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"reflect"
+	"slices"
 	"unsafe"
 
 	"github.com/usnistgov/ndn-dpdk/core/cptr"
@@ -111,13 +112,24 @@ func (info DevInfo) FlowFlags() (flags uint32) {
 	case DriverAfPacket, DriverTAP, DriverXDP, DriverRing, DriverMemif:
 		flags |= C.EthFlowFlagsDisabled
 	case DriverMlx5:
-		flags |= C.EthFlowFlagsGtp
+		flags |= C.EthFlowFlagsGtpGtp
 	case DriverI40e:
 		flags |= C.EthFlowFlagsPassthruArp | C.EthFlowFlagsVxRaw | C.EthFlowFlagsRssUnmarked | C.EthFlowFlagsEtherUnmarked
+		flags |= C.EthFlowFlagsGtpRaw // further updated by DdpProfile.UpdateFlowFlags
 	}
 	return
 }
 
+// UpdateFlowFlags adjust flow flags after loading a profile.
+func (dp *DdpProfile) UpdateFlowFlags(flags *uint32) {
+	// If the GTPv1 DDP package is loaded, flow must use GTPU item, RAW item will not match.
+	// If the GTPv1 DDP package is not loaded, GTPU item cannot be used, flow may use RAW item.
+	if slices.Contains(dp.protocols, "GTPU") {
+		*flags &= ^uint32(C.EthFlowFlagsGtpMask)
+		*flags |= C.EthFlowFlagsGtpGtpu
+	}
+}
+
 // MarshalJSON implements json.Marshaler interface.
 func (info DevInfo) MarshalJSON() ([]byte, error) {
 	return infoJSON(info, info.DevInfoC)
diff --git a/iface/ethport/port.go b/iface/ethport/port.go
@@ -79,6 +79,7 @@ type Port struct {
 	logger       *zap.Logger
 	dev          ethdev.EthDev
 	devInfo      ethdev.DevInfo
+	flowFlags    uint32
 	ddpRollback  func() error
 	faces        map[iface.ID]*Face
 	rxBouncePool *pktmbuf.Pool
@@ -157,7 +158,10 @@ func (port *Port) startDev(nRxQueues int, promisc bool) (e error) {
 
 	if port.devInfo.Driver() == ethdev.DriverI40e {
 		if dp, e := ethdev.OpenDdpProfile("gtp"); e == nil {
-			port.ddpRollback, _ = dp.Upload(port.dev)
+			port.ddpRollback, e = dp.Upload(port.dev)
+			if e == nil {
+				dp.UpdateFlowFlags(&port.flowFlags)
+			}
 		}
 	}
 
@@ -215,6 +219,7 @@ func New(cfg Config) (port *Port, e error) {
 		devInfo: cfg.EthDev.DevInfo(),
 		faces:   map[iface.ID]*Face{},
 	}
+	port.flowFlags = port.devInfo.FlowFlags()
 	switch port.devInfo.Driver() {
 	case ethdev.DriverXDP:
 		if port.rxBouncePool, e = pktmbuf.NewPool(pktmbuf.PoolConfig{
diff --git a/iface/ethport/rxflow.go b/iface/ethport/rxflow.go
@@ -68,7 +68,6 @@ func destroyFlow(face *Face) error {
 }
 
 type rxFlow struct {
-	flowFlags   C.EthFlowFlags
 	availQueues []uint16
 }
 
@@ -101,10 +100,9 @@ func (impl *rxFlow) setIsolate(port *Port, enable bool) error {
 
 func (impl *rxFlow) Init(port *Port) error {
 	*impl = rxFlow{}
-	impl.flowFlags = C.EthFlowFlags(port.devInfo.FlowFlags())
 	needPromisc := false
 	if e := impl.setIsolate(port, true); e == nil {
-		impl.flowFlags |= C.EthFlowFlagsIsolated
+		port.flowFlags |= C.EthFlowFlagsIsolated
 	} else {
 		port.logger.Info("flow isolate mode unavailable", zap.Error(e))
 		needPromisc = true
@@ -136,7 +134,7 @@ func (impl *rxFlow) Start(face *Face) error {
 	}
 
 	queues := impl.availQueues[:nRxQueues]
-	if e := setupFlow(face, queues, impl.flowFlags, zap.WarnLevel); e != nil {
+	if e := setupFlow(face, queues, C.EthFlowFlags(face.port.flowFlags), zap.WarnLevel); e != nil {
 		return e
 	}
 
diff --git a/iface/ethport/rxtable.go b/iface/ethport/rxtable.go
@@ -19,8 +19,7 @@ import (
 )
 
 type rxTable struct {
-	rxt       *rxgTable
-	flowFlags C.EthFlowFlags
+	rxt *rxgTable
 }
 
 func (rxTable) String() string {
@@ -36,13 +35,12 @@ func (impl *rxTable) Init(port *Port) error {
 		return e
 	}
 	impl.rxt = newRxgTable(port)
-	impl.flowFlags = C.EthFlowFlags(port.devInfo.FlowFlags())
 	return nil
 }
 
 func (impl *rxTable) Start(face *Face) error {
-	if impl.flowFlags&C.EthFlowFlagsDisabled == 0 {
-		setupFlow(face, []uint16{0}, impl.flowFlags, zap.InfoLevel)
+	if flowFlags := face.port.flowFlags; flowFlags&C.EthFlowFlagsDisabled == 0 {
+		setupFlow(face, []uint16{0}, C.EthFlowFlags(flowFlags), zap.InfoLevel)
 	}
 
 	if face.loc.Scheme() == SchemePassthru {

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,6 @@ func destroyFlow(face *Face) error {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`type rxFlow struct {`
`71`		`- flowFlags C.EthFlowFlags`
`72`	`71`	`availQueues []uint16`
`73`	`72`	`}`
`74`	`73`
`@@ -101,10 +100,9 @@ func (impl rxFlow) setIsolate(port Port, enable bool) error {`
`101`	`100`
`102`	`101`	`func (impl rxFlow) Init(port Port) error {`
`103`	`102`	`*impl = rxFlow{}`
`104`		`- impl.flowFlags = C.EthFlowFlags(port.devInfo.FlowFlags())`
`105`	`103`	`needPromisc := false`
`106`	`104`	`if e := impl.setIsolate(port, true); e == nil {`
`107`		`- impl.flowFlags \|= C.EthFlowFlagsIsolated`
	`105`	`+ port.flowFlags \|= C.EthFlowFlagsIsolated`
`108`	`106`	`} else {`
`109`	`107`	`port.logger.Info("flow isolate mode unavailable", zap.Error(e))`
`110`	`108`	`needPromisc = true`
`@@ -136,7 +134,7 @@ func (impl rxFlow) Start(face Face) error {`
`136`	`134`	`}`
`137`	`135`
`138`	`136`	`queues := impl.availQueues[:nRxQueues]`
`139`		`- if e := setupFlow(face, queues, impl.flowFlags, zap.WarnLevel); e != nil {`
	`137`	`+ if e := setupFlow(face, queues, C.EthFlowFlags(face.port.flowFlags), zap.WarnLevel); e != nil {`
`140`	`138`	`return e`
`141`	`139`	`}`
`142`	`140`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,7 @@ import (`
`19`	`19`	`)`
`20`	`20`
`21`	`21`	`type rxTable struct {`
`22`		`- rxt *rxgTable`
`23`		`- flowFlags C.EthFlowFlags`
	`22`	`+ rxt *rxgTable`
`24`	`23`	`}`
`25`	`24`
`26`	`25`	`func (rxTable) String() string {`
`@@ -36,13 +35,12 @@ func (impl rxTable) Init(port Port) error {`
`36`	`35`	`return e`
`37`	`36`	`}`
`38`	`37`	`impl.rxt = newRxgTable(port)`
`39`		`- impl.flowFlags = C.EthFlowFlags(port.devInfo.FlowFlags())`
`40`	`38`	`return nil`
`41`	`39`	`}`
`42`	`40`
`43`	`41`	`func (impl rxTable) Start(face Face) error {`
`44`		`- if impl.flowFlags&C.EthFlowFlagsDisabled == 0 {`
`45`		`- setupFlow(face, []uint16{0}, impl.flowFlags, zap.InfoLevel)`
	`42`	`+ if flowFlags := face.port.flowFlags; flowFlags&C.EthFlowFlagsDisabled == 0 {`
	`43`	`+ setupFlow(face, []uint16{0}, C.EthFlowFlags(flowFlags), zap.InfoLevel)`
`46`	`44`	`}`
`47`	`45`
`48`	`46`	`if face.loc.Scheme() == SchemePassthru {`