drivers/nfb: add dynfield for header metadata

Author: martinspinler

drivers/net/nfb/nfb.h

@@ -40,7 +40,9 @@
 #define RTE_NFB_DRIVER_NAME net_nfb
 
 /* Device arguments */
-static const char * const VALID_KEYS[] = {NULL};
+#define NFB_ARG_RXHDR_DYNFIELD "rxhdr_dynfield"
+
+static const char * const VALID_KEYS[] = {NFB_ARG_RXHDR_DYNFIELD, NULL};
 
 struct eth_node{
 	struct mdio_if_info if_info;

drivers/net/nfb/nfb_ethdev.c

@@ -274,6 +274,43 @@ nfb_eth_dev_configure(struct rte_eth_dev *dev)
 	int ret;
 	struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
 
+	static struct rte_mbuf_dynflag df_ndp_hdr_vld = {
+		.name = "rte_net_nfb_dynflag_header_vld",
+	};
+
+	static struct rte_mbuf_dynfield df_ndp_hdr_off = {
+		.name = "rte_net_nfb_dynfield_header_offset",
+		.align = 2,
+		.size = 2,
+	};
+
+	static struct rte_mbuf_dynfield df_ndp_hdr_len = {
+		.name = "rte_net_nfb_dynfield_header_len",
+		.align = 2,
+		.size = 2,
+	};
+
+	static struct rte_mbuf_dynfield df_ndp_flags = {
+		.name = "rte_net_nfb_dynfield_ndp_flags",
+		.align = 2,
+		.size = 2,
+	};
+
+	if (nfb_ndp_df_header_enable) {
+		ret = rte_mbuf_dynflag_register(&df_ndp_hdr_vld);
+		nfb_ndp_df_header_vld = RTE_BIT64(ret);
+		nfb_ndp_df_header_offset = rte_mbuf_dynfield_register(&df_ndp_hdr_off);
+		nfb_ndp_df_header_length = rte_mbuf_dynfield_register(&df_ndp_hdr_len);
+		nfb_ndp_df_flags = rte_mbuf_dynfield_register(&df_ndp_flags);
+
+		if (ret == -1 || nfb_ndp_df_header_offset == -1 ||
+				nfb_ndp_df_header_length == -1 ||
+				nfb_ndp_df_flags == -1) {
+			ret = -rte_errno;
+			goto err_hdr_register;
+		}
+	}
+
 	if (dev_conf->rxmode.offloads & RTE_ETH_RX_OFFLOAD_TIMESTAMP) {
 		ret = rte_mbuf_dyn_rx_timestamp_register
 				(&nfb_timestamp_dynfield_offset,
@@ -289,6 +326,7 @@ nfb_eth_dev_configure(struct rte_eth_dev *dev)
 	return 0;
 
 err_ts_register:
+err_hdr_register:
 	nfb_eth_dev_uninit(dev);
 	return ret;
 }
@@ -733,6 +771,13 @@ nfb_eth_dev_init(struct rte_eth_dev *dev, void *init_data)
 			ret = -EINVAL;
 			goto err_devargs_inval;
 		}
+
+		if ((arg_val = rte_kvargs_get(kvlist, NFB_ARG_RXHDR_DYNFIELD))) {
+			if (strcmp(arg_val, "1") == 0) {
+				nfb_ndp_df_header_enable = 1;
+			}
+		}
+
 		rte_kvargs_free(kvlist);
 	}
 
@@ -974,3 +1019,5 @@ static struct rte_pci_driver nfb_eth_driver = {
 RTE_PMD_REGISTER_PCI(RTE_NFB_DRIVER_NAME, nfb_eth_driver);
 RTE_PMD_REGISTER_PCI_TABLE(RTE_NFB_DRIVER_NAME, nfb_pci_id_table);
 RTE_PMD_REGISTER_KMOD_DEP(RTE_NFB_DRIVER_NAME, "* nfb");
+RTE_PMD_REGISTER_PARAM_STRING(RTE_NFB_DRIVER_NAME,
+		NFB_ARG_RXHDR_DYNFIELD"=<0|1>");

drivers/net/nfb/nfb_rx.c

@@ -12,6 +12,13 @@
 uint64_t nfb_timestamp_rx_dynflag;
 int nfb_timestamp_dynfield_offset = -1;
 
+int nfb_ndp_df_header_offset;
+int nfb_ndp_df_header_length;
+int nfb_ndp_df_flags;
+uint64_t nfb_ndp_df_header_vld;
+
+int nfb_ndp_df_header_enable = 0;
+
 int
 nfb_eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rxq_id)
 {

drivers/net/nfb/nfb_rx.h

@@ -18,6 +18,13 @@
 extern uint64_t nfb_timestamp_rx_dynflag;
 extern int nfb_timestamp_dynfield_offset;
 
+extern int nfb_ndp_df_header_offset;
+extern int nfb_ndp_df_header_length;
+extern int nfb_ndp_df_flags;
+extern uint64_t nfb_ndp_df_header_vld;
+
+extern int nfb_ndp_df_header_enable;
+
 static inline rte_mbuf_timestamp_t *
 nfb_timestamp_dynfield(struct rte_mbuf *mbuf)
 {
@@ -171,6 +178,8 @@ nfb_eth_ndp_rx(void *queue,
 	uint16_t nb_pkts)
 {
 	struct ndp_rx_queue *ndp = queue;
+	uint16_t data_len;
+	uint16_t hdr_len;
 	uint16_t packet_size;
 	uint64_t num_bytes = 0;
 	uint16_t num_rx;
@@ -183,6 +192,10 @@ nfb_eth_ndp_rx(void *queue,
 
 	struct rte_mbuf *mbufs[nb_pkts];
 
+	uint16_t *df_hdr_off;
+	uint16_t *df_hdr_len;
+	uint16_t *flags;
+
 	if (unlikely(ndp->queue == NULL || nb_pkts == 0)) {
 		RTE_LOG(ERR, PMD, "RX invalid arguments!\n");
 		return 0;
@@ -212,19 +225,34 @@ nfb_eth_ndp_rx(void *queue,
 		mbuf = mbufs[i];
 
 		/* get the space available for data in the mbuf */
-		packet_size = packets[i].data_length;
+		data_len = packets[i].data_length;
+		hdr_len = packets[i].header_length;
+		packet_size = data_len + hdr_len;
 
 		if (likely(packet_size <= buf_size)) {
 			/* NDP packet will fit in one mbuf, go ahead and copy */
-			rte_memcpy(rte_pktmbuf_mtod(mbuf, void *),
-				packets[i].data, packet_size);
-
-			mbuf->data_len = (uint16_t)packet_size;
 
 			mbuf->pkt_len = packet_size;
+			mbuf->data_len = (uint16_t)packet_size;
 			mbuf->port = ndp->in_port;
 			mbuf->ol_flags = 0;
 
+			if (nfb_ndp_df_header_enable) {
+				df_hdr_off = RTE_MBUF_DYNFIELD(mbuf, nfb_ndp_df_header_offset, uint16_t*);
+				df_hdr_len = RTE_MBUF_DYNFIELD(mbuf, nfb_ndp_df_header_length, uint16_t*);
+				flags      = RTE_MBUF_DYNFIELD(mbuf, nfb_ndp_df_flags, uint16_t*);
+
+				*df_hdr_off = mbuf->data_off;
+				*df_hdr_len = hdr_len;
+				*flags = packets[i].flags;
+
+				mbuf->ol_flags |= nfb_ndp_df_header_vld;
+
+				rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packets[i].header, hdr_len);
+			}
+			rte_pktmbuf_adj(mbuf, hdr_len);
+			rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packets[i].data, data_len);
+
 			nfb_rx_fetch_timestamp(ndp, mbuf, packets[i].header, packets[i].header_length);
 
 			bufs[num_rx++] = mbuf;