[RFC 00/21] pcap pmd improvements

[RFC 00/21] pcap pmd improvements

[Ferruh Yigit]

No new feature added, code refactored.
This patch targetted for 16.11 release.

Ferruh Yigit (21):
  net/pcap: create own configuration parameter
  net/pcap: use macros for param string
  net/pcap: reorganize private structs
  net/pcap: add checks for max queue number
  net/pcap: update function to reuse it
  net/pcap: don't carry numa_node argument
  net/pcap: don't carry kvlist argument
  net/pcap: move comment to correct place
  net/pcap: remove duplicated max queue number check
  net/pcap: use single_iface variable instead of hardcoded
  net/pcap: group stats related fields into a struct
  net/pcap: make const array static
  net/pcap: reorder header files
  net/pcap: reorder functions
  net/pcap: update how single iface handled
  net/pcap: remove unnecessary check
  net/pcap: remove redundant assignment
  net/pcap: simplify function
  net/pcap: fix missing tx iface assignment
  net/pcap: coding convention updates
  net/pcap: remove rte prefix from static functions

 config/common_base              |   1 +
 drivers/net/pcap/rte_eth_pcap.c | 590 +++++++++++++++++++---------------------
 2 files changed, 280 insertions(+), 311 deletions(-)

-- 
2.7.4

[RFC 01/21] net/pcap: create own configuration parameter

[Ferruh Yigit]

pcap pmd is using ring pmd configuration parameters to set max number of
queues. This creates an unnecessary dependency and confusion.

Create a new config parameter for pcap PMD:
CONFIG_RTE_PMD_PCAP_MAX_QUEUES

Default value of config is same as ring parameter default.

pcap pmd doesn't need to be configured in a detail to set rx and tx max
queue numbers separately, so using same config item for both queues.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 config/common_base              |  1 +
 drivers/net/pcap/rte_eth_pcap.c | 18 +++++++++---------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/config/common_base b/config/common_base
index 7830535..e32bd61 100644
--- a/config/common_base
+++ b/config/common_base
@@ -307,6 +307,7 @@ CONFIG_RTE_PMD_RING_MAX_TX_RINGS=16
 # Compile software PMD backed by PCAP files
 #
 CONFIG_RTE_LIBRTE_PMD_PCAP=n
+CONFIG_RTE_PMD_PCAP_MAX_QUEUES=16
 
 #
 # Compile link bonding PMD library
diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 7e213eb..6343c0e 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -87,22 +87,22 @@ struct pcap_tx_queue {
 
 struct rx_pcaps {
 	unsigned num_of_rx;
-	pcap_t *pcaps[RTE_PMD_RING_MAX_RX_RINGS];
-	const char *names[RTE_PMD_RING_MAX_RX_RINGS];
-	const char *types[RTE_PMD_RING_MAX_RX_RINGS];
+	pcap_t *pcaps[RTE_PMD_PCAP_MAX_QUEUES];
+	const char *names[RTE_PMD_PCAP_MAX_QUEUES];
+	const char *types[RTE_PMD_PCAP_MAX_QUEUES];
 };
 
 struct tx_pcaps {
 	unsigned num_of_tx;
-	pcap_dumper_t *dumpers[RTE_PMD_RING_MAX_TX_RINGS];
-	pcap_t *pcaps[RTE_PMD_RING_MAX_RX_RINGS];
-	const char *names[RTE_PMD_RING_MAX_RX_RINGS];
-	const char *types[RTE_PMD_RING_MAX_RX_RINGS];
+	pcap_dumper_t *dumpers[RTE_PMD_PCAP_MAX_QUEUES];
+	pcap_t *pcaps[RTE_PMD_PCAP_MAX_QUEUES];
+	const char *names[RTE_PMD_PCAP_MAX_QUEUES];
+	const char *types[RTE_PMD_PCAP_MAX_QUEUES];
 };
 
 struct pmd_internals {
-	struct pcap_rx_queue rx_queue[RTE_PMD_RING_MAX_RX_RINGS];
-	struct pcap_tx_queue tx_queue[RTE_PMD_RING_MAX_TX_RINGS];
+	struct pcap_rx_queue rx_queue[RTE_PMD_PCAP_MAX_QUEUES];
+	struct pcap_tx_queue tx_queue[RTE_PMD_PCAP_MAX_QUEUES];
 	int if_index;
 	int single_iface;
 };
-- 
2.7.4

[RFC 02/21] net/pcap: use macros for param string

[Ferruh Yigit]

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 6343c0e..877e4c2 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -1091,8 +1091,8 @@ static struct rte_driver pmd_pcap_drv = {
 
 PMD_REGISTER_DRIVER(pmd_pcap_drv, eth_pcap);
 DRIVER_REGISTER_PARAM_STRING(eth_pcap,
-	"rx_pcap=<string> "
-	"tx_pcap=<string> "
-	"rx_iface=<ifc> "
-	"tx_iface=<ifc> "
-	"iface=<ifc>");
+	ETH_PCAP_RX_PCAP_ARG"=<string> "
+	ETH_PCAP_TX_PCAP_ARG"=<string> "
+	ETH_PCAP_RX_IFACE_ARG"=<ifc> "
+	ETH_PCAP_TX_IFACE_ARG"=<ifc> "
+	ETH_PCAP_IFACE_ARG"=<ifc>");
-- 
2.7.4

[RFC 03/21] net/pcap: reorganize private structs

[Ferruh Yigit]

struct rx_pcaps and tx_pcaps used to point parsed devargs, but it is not
clear with current names.

Merged both into single struct and modified struct name and field names.

Functionality not changed, only struct names.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 123 +++++++++++++++++++---------------------
 1 file changed, 59 insertions(+), 64 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 877e4c2..34c779a 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -85,21 +85,6 @@ struct pcap_tx_queue {
 	char type[ETH_PCAP_ARG_MAXLEN];
 };
 
-struct rx_pcaps {
-	unsigned num_of_rx;
-	pcap_t *pcaps[RTE_PMD_PCAP_MAX_QUEUES];
-	const char *names[RTE_PMD_PCAP_MAX_QUEUES];
-	const char *types[RTE_PMD_PCAP_MAX_QUEUES];
-};
-
-struct tx_pcaps {
-	unsigned num_of_tx;
-	pcap_dumper_t *dumpers[RTE_PMD_PCAP_MAX_QUEUES];
-	pcap_t *pcaps[RTE_PMD_PCAP_MAX_QUEUES];
-	const char *names[RTE_PMD_PCAP_MAX_QUEUES];
-	const char *types[RTE_PMD_PCAP_MAX_QUEUES];
-};
-
 struct pmd_internals {
 	struct pcap_rx_queue rx_queue[RTE_PMD_PCAP_MAX_QUEUES];
 	struct pcap_tx_queue tx_queue[RTE_PMD_PCAP_MAX_QUEUES];
@@ -107,6 +92,16 @@ struct pmd_internals {
 	int single_iface;
 };
 
+struct pmd_devargs {
+	unsigned num_of_queue;
+	struct devargs_queue {
+		pcap_dumper_t *dumper;
+		pcap_t *pcap;
+		const char *name;
+		const char *type;
+	} queue[RTE_PMD_PCAP_MAX_QUEUES];
+};
+
 const char *valid_arguments[] = {
 	ETH_PCAP_RX_PCAP_ARG,
 	ETH_PCAP_TX_PCAP_ARG,
@@ -625,16 +620,16 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 {
 	unsigned i;
 	const char *pcap_filename = value;
-	struct rx_pcaps *pcaps = extra_args;
+	struct pmd_devargs *rx = extra_args;
 	pcap_t *pcap = NULL;
 
-	for (i = 0; i < pcaps->num_of_rx; i++) {
+	for (i = 0; i < rx->num_of_queue; i++) {
 		if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
 			return -1;
 
-		pcaps->pcaps[i] = pcap;
-		pcaps->names[i] = pcap_filename;
-		pcaps->types[i] = key;
+		rx->queue[i].pcap = pcap;
+		rx->queue[i].name = pcap_filename;
+		rx->queue[i].type = key;
 	}
 
 	return 0;
@@ -659,16 +654,16 @@ open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
 	unsigned i;
 	const char *pcap_filename = value;
-	struct tx_pcaps *dumpers = extra_args;
+	struct pmd_devargs *dumpers = extra_args;
 	pcap_dumper_t *dumper;
 
-	for (i = 0; i < dumpers->num_of_tx; i++) {
+	for (i = 0; i < dumpers->num_of_queue; i++) {
 		if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
 			return -1;
 
-		dumpers->dumpers[i] = dumper;
-		dumpers->names[i] = pcap_filename;
-		dumpers->types[i] = key;
+		dumpers->queue[i].dumper = dumper;
+		dumpers->queue[i].name = pcap_filename;
+		dumpers->queue[i].type = key;
 	}
 
 	return 0;
@@ -721,15 +716,15 @@ static inline int
 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	const char *iface = value;
-	struct rx_pcaps *pcaps = extra_args;
+	struct pmd_devargs *tx = extra_args;
 	pcap_t *pcap = NULL;
 
 	if (open_single_iface(iface, &pcap) < 0)
 		return -1;
 
-	pcaps->pcaps[0] = pcap;
-	pcaps->names[0] = iface;
-	pcaps->types[0] = key;
+	tx->queue[0].pcap = pcap;
+	tx->queue[0].name = iface;
+	tx->queue[0].type = key;
 
 	return 0;
 }
@@ -742,15 +737,15 @@ open_rx_iface(const char *key, const char *value, void *extra_args)
 {
 	unsigned i;
 	const char *iface = value;
-	struct rx_pcaps *pcaps = extra_args;
+	struct pmd_devargs *rx = extra_args;
 	pcap_t *pcap = NULL;
 
-	for (i = 0; i < pcaps->num_of_rx; i++) {
+	for (i = 0; i < rx->num_of_queue; i++) {
 		if (open_single_iface(iface, &pcap) < 0)
 			return -1;
-		pcaps->pcaps[i] = pcap;
-		pcaps->names[i] = iface;
-		pcaps->types[i] = key;
+		rx->queue[i].pcap = pcap;
+		rx->queue[i].name = iface;
+		rx->queue[i].type = key;
 	}
 
 	return 0;
@@ -764,15 +759,15 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 {
 	unsigned i;
 	const char *iface = value;
-	struct tx_pcaps *pcaps = extra_args;
+	struct pmd_devargs *tx = extra_args;
 	pcap_t *pcap;
 
-	for (i = 0; i < pcaps->num_of_tx; i++) {
+	for (i = 0; i < tx->num_of_queue; i++) {
 		if (open_single_iface(iface, &pcap) < 0)
 			return -1;
-		pcaps->pcaps[i] = pcap;
-		pcaps->names[i] = iface;
-		pcaps->types[i] = key;
+		tx->queue[i].pcap = pcap;
+		tx->queue[i].name = iface;
+		tx->queue[i].type = key;
 	}
 
 	return 0;
@@ -872,8 +867,8 @@ error:
 }
 
 static int
-rte_eth_from_pcaps_common(const char *name, struct rx_pcaps *rx_queues,
-		const unsigned nb_rx_queues, struct tx_pcaps *tx_queues,
+rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
+		const unsigned nb_rx_queues, struct pmd_devargs *tx_queues,
 		const unsigned nb_tx_queues, const unsigned numa_node,
 		struct rte_kvargs *kvlist, struct pmd_internals **internals,
 		struct rte_eth_dev **eth_dev)
@@ -891,22 +886,22 @@ rte_eth_from_pcaps_common(const char *name, struct rx_pcaps *rx_queues,
 		return -1;
 
 	for (i = 0; i < nb_rx_queues; i++) {
-		(*internals)->rx_queue[i].pcap = rx_queues->pcaps[i];
+		(*internals)->rx_queue[i].pcap = rx_queues->queue[i].pcap;
 		snprintf((*internals)->rx_queue[i].name,
 			sizeof((*internals)->rx_queue[i].name), "%s",
-			rx_queues->names[i]);
+			rx_queues->queue[i].name);
 		snprintf((*internals)->rx_queue[i].type,
 			sizeof((*internals)->rx_queue[i].type), "%s",
-			rx_queues->types[i]);
+			rx_queues->queue[i].type);
 	}
 	for (i = 0; i < nb_tx_queues; i++) {
-		(*internals)->tx_queue[i].dumper = tx_queues->dumpers[i];
+		(*internals)->tx_queue[i].dumper = tx_queues->queue[i].dumper;
 		snprintf((*internals)->tx_queue[i].name,
 			sizeof((*internals)->tx_queue[i].name), "%s",
-			tx_queues->names[i]);
+			tx_queues->queue[i].name);
 		snprintf((*internals)->tx_queue[i].type,
 			sizeof((*internals)->tx_queue[i].type), "%s",
-			tx_queues->types[i]);
+			tx_queues->queue[i].type);
 	}
 
 	return 0;
@@ -914,9 +909,9 @@ rte_eth_from_pcaps_common(const char *name, struct rx_pcaps *rx_queues,
 
 static int
 rte_eth_from_pcaps_n_dumpers(const char *name,
-		struct rx_pcaps *rx_queues,
+		struct pmd_devargs *rx_queues,
 		const unsigned nb_rx_queues,
-		struct tx_pcaps *tx_queues,
+		struct pmd_devargs *tx_queues,
 		const unsigned nb_tx_queues,
 		const unsigned numa_node,
 		struct rte_kvargs *kvlist)
@@ -943,9 +938,9 @@ rte_eth_from_pcaps_n_dumpers(const char *name,
 
 static int
 rte_eth_from_pcaps(const char *name,
-		struct rx_pcaps *rx_queues,
+		struct pmd_devargs *rx_queues,
 		const unsigned nb_rx_queues,
-		struct tx_pcaps *tx_queues,
+		struct pmd_devargs *tx_queues,
 		const unsigned nb_tx_queues,
 		const unsigned numa_node,
 		struct rte_kvargs *kvlist,
@@ -978,8 +973,8 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	unsigned numa_node, using_dumpers = 0;
 	int ret;
 	struct rte_kvargs *kvlist;
-	struct rx_pcaps pcaps = {0};
-	struct tx_pcaps dumpers = {0};
+	struct pmd_devargs pcaps = {0};
+	struct pmd_devargs dumpers = {0};
 
 	RTE_LOG(INFO, PMD, "Initializing pmd_pcap for %s\n", name);
 
@@ -1003,9 +998,9 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 				&open_rx_tx_iface, &pcaps);
 		if (ret < 0)
 			goto free_kvlist;
-		dumpers.pcaps[0] = pcaps.pcaps[0];
-		dumpers.names[0] = pcaps.names[0];
-		dumpers.types[0] = pcaps.types[0];
+		dumpers.queue[0].pcap = pcaps.queue[0].pcap;
+		dumpers.queue[0].name = pcaps.queue[0].name;
+		dumpers.queue[0].type = pcaps.queue[0].type;
 		ret = rte_eth_from_pcaps(name, &pcaps, 1, &dumpers, 1,
 				numa_node, kvlist, 1);
 		goto free_kvlist;
@@ -1015,11 +1010,11 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	 * We check whether we want to open a RX stream from a real NIC or a
 	 * pcap file
 	 */
-	if ((pcaps.num_of_rx = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG))) {
+	if ((pcaps.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG))) {
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else {
-		pcaps.num_of_rx = rte_kvargs_count(kvlist,
+		pcaps.num_of_queue = rte_kvargs_count(kvlist,
 				ETH_PCAP_RX_IFACE_ARG);
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_IFACE_ARG,
 				&open_rx_iface, &pcaps);
@@ -1032,13 +1027,13 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	 * We check whether we want to open a TX stream to a real NIC or a
 	 * pcap file
 	 */
-	if ((dumpers.num_of_tx = rte_kvargs_count(kvlist,
+	if ((dumpers.num_of_queue = rte_kvargs_count(kvlist,
 			ETH_PCAP_TX_PCAP_ARG))) {
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_PCAP_ARG,
 				&open_tx_pcap, &dumpers);
 		using_dumpers = 1;
 	} else {
-		dumpers.num_of_tx = rte_kvargs_count(kvlist,
+		dumpers.num_of_queue = rte_kvargs_count(kvlist,
 				ETH_PCAP_TX_IFACE_ARG);
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_IFACE_ARG,
 				&open_tx_iface, &dumpers);
@@ -1048,11 +1043,11 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 		goto free_kvlist;
 
 	if (using_dumpers)
-		ret = rte_eth_from_pcaps_n_dumpers(name, &pcaps, pcaps.num_of_rx,
-				&dumpers, dumpers.num_of_tx, numa_node, kvlist);
+		ret = rte_eth_from_pcaps_n_dumpers(name, &pcaps, pcaps.num_of_queue,
+				&dumpers, dumpers.num_of_queue, numa_node, kvlist);
 	else
-		ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_rx, &dumpers,
-			dumpers.num_of_tx, numa_node, kvlist, 0);
+		ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
+			dumpers.num_of_queue, numa_node, kvlist, 0);
 
 free_kvlist:
 	rte_kvargs_free(kvlist);
-- 
2.7.4

[RFC 04/21] net/pcap: add checks for max queue number

[Ferruh Yigit]

Number of queues defined by devargs, a check added to be sure this
number is not bigger than configured queue length.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 34c779a..308b8bc 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -1010,12 +1010,21 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	 * We check whether we want to open a RX stream from a real NIC or a
 	 * pcap file
 	 */
-	if ((pcaps.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG))) {
+	pcaps.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG);
+
+	if (pcaps.num_of_queue) {
+		if (pcaps.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
+			pcaps.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
 				&open_rx_pcap, &pcaps);
 	} else {
 		pcaps.num_of_queue = rte_kvargs_count(kvlist,
 				ETH_PCAP_RX_IFACE_ARG);
+
+		if (pcaps.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
+			pcaps.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_IFACE_ARG,
 				&open_rx_iface, &pcaps);
 	}
@@ -1027,14 +1036,22 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	 * We check whether we want to open a TX stream to a real NIC or a
 	 * pcap file
 	 */
-	if ((dumpers.num_of_queue = rte_kvargs_count(kvlist,
-			ETH_PCAP_TX_PCAP_ARG))) {
+	dumpers.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG);
+
+	if (dumpers.num_of_queue) {
+		if (dumpers.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
+			dumpers.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_PCAP_ARG,
 				&open_tx_pcap, &dumpers);
 		using_dumpers = 1;
 	} else {
 		dumpers.num_of_queue = rte_kvargs_count(kvlist,
 				ETH_PCAP_TX_IFACE_ARG);
+
+		if (dumpers.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
+			dumpers.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
+
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_IFACE_ARG,
 				&open_tx_iface, &dumpers);
 	}
-- 
2.7.4

[RFC 05/21] net/pcap: update function to reuse it

[Ferruh Yigit]

rte_eth_from_pcaps and rte_eth_from_pcaps_n_dumpers functions are very
close, updated rte_eth_from_pcaps function and reused.

No functional update.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 58 +++++++++--------------------------------
 1 file changed, 13 insertions(+), 45 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 308b8bc..14f770c 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -908,43 +908,11 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 }
 
 static int
-rte_eth_from_pcaps_n_dumpers(const char *name,
-		struct pmd_devargs *rx_queues,
-		const unsigned nb_rx_queues,
-		struct pmd_devargs *tx_queues,
-		const unsigned nb_tx_queues,
-		const unsigned numa_node,
-		struct rte_kvargs *kvlist)
-{
-	struct pmd_internals *internals = NULL;
-	struct rte_eth_dev *eth_dev = NULL;
-	int ret;
-
-	ret = rte_eth_from_pcaps_common(name, rx_queues, nb_rx_queues,
-			tx_queues, nb_tx_queues, numa_node, kvlist,
-			&internals, &eth_dev);
-
-	if (ret < 0)
-		return ret;
-
-	/* using multiple pcaps/interfaces */
-	internals->single_iface = 0;
-
-	eth_dev->rx_pkt_burst = eth_pcap_rx;
-	eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
-
-	return 0;
-}
-
-static int
-rte_eth_from_pcaps(const char *name,
-		struct pmd_devargs *rx_queues,
-		const unsigned nb_rx_queues,
-		struct pmd_devargs *tx_queues,
-		const unsigned nb_tx_queues,
-		const unsigned numa_node,
-		struct rte_kvargs *kvlist,
-		int single_iface)
+rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
+		const unsigned nb_rx_queues, struct pmd_devargs *tx_queues,
+		const unsigned nb_tx_queues, const unsigned numa_node,
+		struct rte_kvargs *kvlist, int single_iface,
+		unsigned int using_dumpers)
 {
 	struct pmd_internals *internals = NULL;
 	struct rte_eth_dev *eth_dev = NULL;
@@ -961,7 +929,11 @@ rte_eth_from_pcaps(const char *name,
 	internals->single_iface = single_iface;
 
 	eth_dev->rx_pkt_burst = eth_pcap_rx;
-	eth_dev->tx_pkt_burst = eth_pcap_tx;
+
+	if (using_dumpers)
+		eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
+	else
+		eth_dev->tx_pkt_burst = eth_pcap_tx;
 
 	return 0;
 }
@@ -1002,7 +974,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 		dumpers.queue[0].name = pcaps.queue[0].name;
 		dumpers.queue[0].type = pcaps.queue[0].type;
 		ret = rte_eth_from_pcaps(name, &pcaps, 1, &dumpers, 1,
-				numa_node, kvlist, 1);
+				numa_node, kvlist, 1, using_dumpers);
 		goto free_kvlist;
 	}
 
@@ -1059,12 +1031,8 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	if (ret < 0)
 		goto free_kvlist;
 
-	if (using_dumpers)
-		ret = rte_eth_from_pcaps_n_dumpers(name, &pcaps, pcaps.num_of_queue,
-				&dumpers, dumpers.num_of_queue, numa_node, kvlist);
-	else
-		ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
-			dumpers.num_of_queue, numa_node, kvlist, 0);
+	ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
+		dumpers.num_of_queue, numa_node, kvlist, 0, using_dumpers);
 
 free_kvlist:
 	rte_kvargs_free(kvlist);
-- 
2.7.4

[RFC 06/21] net/pcap: don't carry numa_node argument

[Ferruh Yigit]

Instead of defining numa_node variable upper level of call stack and
carry into sub function, set it where needs to be used.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 40 +++++++++++++++++-----------------------
 1 file changed, 17 insertions(+), 23 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 14f770c..94d7c88 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -786,13 +786,11 @@ open_single_iface(const char *iface, pcap_t **pcap)
 
 static int
 rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
-		const unsigned nb_tx_queues,
-		const unsigned numa_node,
-		struct pmd_internals **internals,
-		struct rte_eth_dev **eth_dev,
-		struct rte_kvargs *kvlist)
+		const unsigned nb_tx_queues, struct pmd_internals **internals,
+		struct rte_eth_dev **eth_dev, struct rte_kvargs *kvlist)
 {
 	struct rte_eth_dev_data *data = NULL;
+	unsigned int numa_node = rte_socket_id();
 	unsigned k_idx;
 	struct rte_kvargs_pair *pair = NULL;
 
@@ -802,8 +800,8 @@ rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 			break;
 	}
 
-	RTE_LOG(INFO, PMD,
-			"Creating pcap-backed ethdev on numa socket %u\n", numa_node);
+	RTE_LOG(INFO, PMD, "Creating pcap-backed ethdev on numa socket %u\n",
+		numa_node);
 
 	/* now do all data allocation - for eth_dev structure
 	 * and internal (private) data
@@ -812,7 +810,8 @@ rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 	if (data == NULL)
 		goto error;
 
-	*internals = rte_zmalloc_socket(name, sizeof(**internals), 0, numa_node);
+	*internals = rte_zmalloc_socket(name, sizeof(**internals), 0,
+			numa_node);
 	if (*internals == NULL)
 		goto error;
 
@@ -869,9 +868,8 @@ error:
 static int
 rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 		const unsigned nb_rx_queues, struct pmd_devargs *tx_queues,
-		const unsigned nb_tx_queues, const unsigned numa_node,
-		struct rte_kvargs *kvlist, struct pmd_internals **internals,
-		struct rte_eth_dev **eth_dev)
+		const unsigned nb_tx_queues, struct rte_kvargs *kvlist,
+		struct pmd_internals **internals, struct rte_eth_dev **eth_dev)
 {
 	unsigned i;
 
@@ -881,8 +879,8 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 	if (tx_queues == NULL && nb_tx_queues > 0)
 		return -1;
 
-	if (rte_pmd_init_internals(name, nb_rx_queues, nb_tx_queues, numa_node,
-			internals, eth_dev, kvlist) < 0)
+	if (rte_pmd_init_internals(name, nb_rx_queues, nb_tx_queues, internals,
+			eth_dev, kvlist) < 0)
 		return -1;
 
 	for (i = 0; i < nb_rx_queues; i++) {
@@ -910,17 +908,15 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 static int
 rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
 		const unsigned nb_rx_queues, struct pmd_devargs *tx_queues,
-		const unsigned nb_tx_queues, const unsigned numa_node,
-		struct rte_kvargs *kvlist, int single_iface,
-		unsigned int using_dumpers)
+		const unsigned nb_tx_queues, struct rte_kvargs *kvlist,
+		int single_iface, unsigned int using_dumpers)
 {
 	struct pmd_internals *internals = NULL;
 	struct rte_eth_dev *eth_dev = NULL;
 	int ret;
 
 	ret = rte_eth_from_pcaps_common(name, rx_queues, nb_rx_queues,
-			tx_queues, nb_tx_queues, numa_node, kvlist,
-			&internals, &eth_dev);
+		tx_queues, nb_tx_queues, kvlist, &internals, &eth_dev);
 
 	if (ret < 0)
 		return ret;
@@ -942,7 +938,7 @@ rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
 static int
 rte_pmd_pcap_devinit(const char *name, const char *params)
 {
-	unsigned numa_node, using_dumpers = 0;
+	unsigned using_dumpers = 0;
 	int ret;
 	struct rte_kvargs *kvlist;
 	struct pmd_devargs pcaps = {0};
@@ -950,8 +946,6 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 
 	RTE_LOG(INFO, PMD, "Initializing pmd_pcap for %s\n", name);
 
-	numa_node = rte_socket_id();
-
 	gettimeofday(&start_time, NULL);
 	start_cycles = rte_get_timer_cycles();
 	hz = rte_get_timer_hz();
@@ -974,7 +968,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 		dumpers.queue[0].name = pcaps.queue[0].name;
 		dumpers.queue[0].type = pcaps.queue[0].type;
 		ret = rte_eth_from_pcaps(name, &pcaps, 1, &dumpers, 1,
-				numa_node, kvlist, 1, using_dumpers);
+				kvlist, 1, using_dumpers);
 		goto free_kvlist;
 	}
 
@@ -1032,7 +1026,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 		goto free_kvlist;
 
 	ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
-		dumpers.num_of_queue, numa_node, kvlist, 0, using_dumpers);
+		dumpers.num_of_queue, kvlist, 0, using_dumpers);
 
 free_kvlist:
 	rte_kvargs_free(kvlist);
-- 
2.7.4

[RFC 07/21] net/pcap: don't carry kvlist argument

[Ferruh Yigit]

Don't carry kvlist argument into sub function and used it, use kvlist
argument in upper level of call stack.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 94d7c88..3eacb82 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -787,18 +787,10 @@ open_single_iface(const char *iface, pcap_t **pcap)
 static int
 rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 		const unsigned nb_tx_queues, struct pmd_internals **internals,
-		struct rte_eth_dev **eth_dev, struct rte_kvargs *kvlist)
+		struct rte_eth_dev **eth_dev)
 {
 	struct rte_eth_dev_data *data = NULL;
 	unsigned int numa_node = rte_socket_id();
-	unsigned k_idx;
-	struct rte_kvargs_pair *pair = NULL;
-
-	for (k_idx = 0; k_idx < kvlist->count; k_idx++) {
-		pair = &kvlist->pairs[k_idx];
-		if (strstr(pair->key, ETH_PCAP_IFACE_ARG) != NULL)
-			break;
-	}
 
 	RTE_LOG(INFO, PMD, "Creating pcap-backed ethdev on numa socket %u\n",
 		numa_node);
@@ -833,11 +825,6 @@ rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 	/* NOTE: we'll replace the data element, of originally allocated eth_dev
 	 * so the rings are local per-process */
 
-	if (pair == NULL)
-		(*internals)->if_index = 0;
-	else
-		(*internals)->if_index = if_nametoindex(pair->value);
-
 	data->dev_private = *internals;
 	data->port_id = (*eth_dev)->data->port_id;
 	snprintf(data->name, sizeof(data->name), "%s", (*eth_dev)->data->name);
@@ -871,6 +858,8 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 		const unsigned nb_tx_queues, struct rte_kvargs *kvlist,
 		struct pmd_internals **internals, struct rte_eth_dev **eth_dev)
 {
+	struct rte_kvargs_pair *pair = NULL;
+	unsigned k_idx;
 	unsigned i;
 
 	/* do some parameter checking */
@@ -880,7 +869,7 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 		return -1;
 
 	if (rte_pmd_init_internals(name, nb_rx_queues, nb_tx_queues, internals,
-			eth_dev, kvlist) < 0)
+			eth_dev) < 0)
 		return -1;
 
 	for (i = 0; i < nb_rx_queues; i++) {
@@ -902,6 +891,17 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 			tx_queues->queue[i].type);
 	}
 
+	for (k_idx = 0; k_idx < kvlist->count; k_idx++) {
+		pair = &kvlist->pairs[k_idx];
+		if (strstr(pair->key, ETH_PCAP_IFACE_ARG) != NULL)
+			break;
+	}
+
+	if (pair == NULL)
+		(*internals)->if_index = 0;
+	else
+		(*internals)->if_index = if_nametoindex(pair->value);
+
 	return 0;
 }
 
-- 
2.7.4

[RFC 08/21] net/pcap: move comment to correct place

[Ferruh Yigit]

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 3eacb82..7524293 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -822,9 +822,6 @@ rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 	 * - point eth_dev_data to internals
 	 * - and point eth_dev structure to new eth_dev_data structure
 	 */
-	/* NOTE: we'll replace the data element, of originally allocated eth_dev
-	 * so the rings are local per-process */
-
 	data->dev_private = *internals;
 	data->port_id = (*eth_dev)->data->port_id;
 	snprintf(data->name, sizeof(data->name), "%s", (*eth_dev)->data->name);
@@ -835,6 +832,10 @@ rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 	strncpy(data->name,
 		(*eth_dev)->data->name, strlen((*eth_dev)->data->name));
 
+	/*
+	 * NOTE: we'll replace the data element, of originally allocated
+	 * eth_dev so the rings are local per-process
+	 */
 	(*eth_dev)->data = data;
 	(*eth_dev)->dev_ops = &ops;
 	(*eth_dev)->driver = NULL;
-- 
2.7.4

[RFC 09/21] net/pcap: remove duplicated max queue number check

[Ferruh Yigit]

Remove duplicated check by reorganizing the code, no functional change.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 49 ++++++++++++++++++-----------------------
 1 file changed, 22 insertions(+), 27 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 7524293..0445c74 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -939,11 +939,11 @@ rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
 static int
 rte_pmd_pcap_devinit(const char *name, const char *params)
 {
-	unsigned using_dumpers = 0;
-	int ret;
+	unsigned int is_rx_pcap = 0, is_tx_pcap = 0;
 	struct rte_kvargs *kvlist;
 	struct pmd_devargs pcaps = {0};
 	struct pmd_devargs dumpers = {0};
+	int ret;
 
 	RTE_LOG(INFO, PMD, "Initializing pmd_pcap for %s\n", name);
 
@@ -969,7 +969,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 		dumpers.queue[0].name = pcaps.queue[0].name;
 		dumpers.queue[0].type = pcaps.queue[0].type;
 		ret = rte_eth_from_pcaps(name, &pcaps, 1, &dumpers, 1,
-				kvlist, 1, using_dumpers);
+				kvlist, 1, is_tx_pcap);
 		goto free_kvlist;
 	}
 
@@ -978,23 +978,21 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	 * pcap file
 	 */
 	pcaps.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG);
-
-	if (pcaps.num_of_queue) {
-		if (pcaps.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
-			pcaps.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
-
-		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
-				&open_rx_pcap, &pcaps);
-	} else {
+	if (pcaps.num_of_queue)
+		is_rx_pcap = 1;
+	else
 		pcaps.num_of_queue = rte_kvargs_count(kvlist,
 				ETH_PCAP_RX_IFACE_ARG);
 
-		if (pcaps.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
-			pcaps.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
+	if (pcaps.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
+		pcaps.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
 
+	if (is_rx_pcap)
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
+				&open_rx_pcap, &pcaps);
+	else
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_IFACE_ARG,
 				&open_rx_iface, &pcaps);
-	}
 
 	if (ret < 0)
 		goto free_kvlist;
@@ -1004,30 +1002,27 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	 * pcap file
 	 */
 	dumpers.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG);
-
-	if (dumpers.num_of_queue) {
-		if (dumpers.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
-			dumpers.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
-
-		ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_PCAP_ARG,
-				&open_tx_pcap, &dumpers);
-		using_dumpers = 1;
-	} else {
+	if (dumpers.num_of_queue)
+		is_tx_pcap = 1;
+	else
 		dumpers.num_of_queue = rte_kvargs_count(kvlist,
 				ETH_PCAP_TX_IFACE_ARG);
 
-		if (dumpers.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
-			dumpers.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
+	if (dumpers.num_of_queue > RTE_PMD_PCAP_MAX_QUEUES)
+		dumpers.num_of_queue = RTE_PMD_PCAP_MAX_QUEUES;
 
+	if (is_tx_pcap)
+		ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_PCAP_ARG,
+				&open_tx_pcap, &dumpers);
+	else
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_IFACE_ARG,
 				&open_tx_iface, &dumpers);
-	}
 
 	if (ret < 0)
 		goto free_kvlist;
 
 	ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
-		dumpers.num_of_queue, kvlist, 0, using_dumpers);
+		dumpers.num_of_queue, kvlist, 0, is_tx_pcap);
 
 free_kvlist:
 	rte_kvargs_free(kvlist);
-- 
2.7.4

[RFC 10/21] net/pcap: use single_iface variable instead of hardcoded

[Ferruh Yigit]

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 0445c74..31eed58 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -943,6 +943,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	struct rte_kvargs *kvlist;
 	struct pmd_devargs pcaps = {0};
 	struct pmd_devargs dumpers = {0};
+	int single_iface = 0;
 	int ret;
 
 	RTE_LOG(INFO, PMD, "Initializing pmd_pcap for %s\n", name);
@@ -963,13 +964,18 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 
 		ret = rte_kvargs_process(kvlist, ETH_PCAP_IFACE_ARG,
 				&open_rx_tx_iface, &pcaps);
+
 		if (ret < 0)
 			goto free_kvlist;
 		dumpers.queue[0].pcap = pcaps.queue[0].pcap;
 		dumpers.queue[0].name = pcaps.queue[0].name;
 		dumpers.queue[0].type = pcaps.queue[0].type;
+
+		single_iface = 1;
+
 		ret = rte_eth_from_pcaps(name, &pcaps, 1, &dumpers, 1,
-				kvlist, 1, is_tx_pcap);
+			kvlist, single_iface, is_tx_pcap);
+
 		goto free_kvlist;
 	}
 
@@ -1022,7 +1028,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 		goto free_kvlist;
 
 	ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
-		dumpers.num_of_queue, kvlist, 0, is_tx_pcap);
+		dumpers.num_of_queue, kvlist, single_iface, is_tx_pcap);
 
 free_kvlist:
 	rte_kvargs_free(kvlist);
-- 
2.7.4

[RFC 11/21] net/pcap: group stats related fields into a struct

[Ferruh Yigit]

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 72 +++++++++++++++++++++--------------------
 1 file changed, 37 insertions(+), 35 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 31eed58..ec25912 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -64,13 +64,17 @@ static struct timeval start_time;
 static uint64_t start_cycles;
 static uint64_t hz;
 
+struct queue_stat {
+	volatile unsigned long pkts;
+	volatile unsigned long bytes;
+	volatile unsigned long err_pkts;
+};
+
 struct pcap_rx_queue {
 	pcap_t *pcap;
 	uint8_t in_port;
 	struct rte_mempool *mb_pool;
-	volatile unsigned long rx_pkts;
-	volatile unsigned long rx_bytes;
-	volatile unsigned long err_pkts;
+	struct queue_stat rx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
 };
@@ -78,9 +82,7 @@ struct pcap_rx_queue {
 struct pcap_tx_queue {
 	pcap_dumper_t *dumper;
 	pcap_t *pcap;
-	volatile unsigned long tx_pkts;
-	volatile unsigned long tx_bytes;
-	volatile unsigned long err_pkts;
+	struct queue_stat tx_stat;
 	char name[PATH_MAX];
 	char type[ETH_PCAP_ARG_MAXLEN];
 };
@@ -234,8 +236,8 @@ eth_pcap_rx(void *queue,
 		num_rx++;
 		rx_bytes += header.caplen;
 	}
-	pcap_q->rx_pkts += num_rx;
-	pcap_q->rx_bytes += rx_bytes;
+	pcap_q->rx_stat.pkts += num_rx;
+	pcap_q->rx_stat.bytes += rx_bytes;
 	return num_rx;
 }
 
@@ -306,9 +308,9 @@ eth_pcap_tx_dumper(void *queue,
 	 * we flush the pcap dumper within each burst.
 	 */
 	pcap_dump_flush(dumper_q->dumper);
-	dumper_q->tx_pkts += num_tx;
-	dumper_q->tx_bytes += tx_bytes;
-	dumper_q->err_pkts += nb_pkts - num_tx;
+	dumper_q->tx_stat.pkts += num_tx;
+	dumper_q->tx_stat.bytes += tx_bytes;
+	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
 	return num_tx;
 }
 
@@ -362,9 +364,9 @@ eth_pcap_tx(void *queue,
 		rte_pktmbuf_free(mbuf);
 	}
 
-	tx_queue->tx_pkts += num_tx;
-	tx_queue->tx_bytes += tx_bytes;
-	tx_queue->err_pkts += nb_pkts - num_tx;
+	tx_queue->tx_stat.pkts += num_tx;
+	tx_queue->tx_stat.bytes += tx_bytes;
+	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
 	return num_tx;
 }
 
@@ -501,7 +503,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 
 static void
 eth_stats_get(struct rte_eth_dev *dev,
-		struct rte_eth_stats *igb_stats)
+		struct rte_eth_stats *stats)
 {
 	unsigned i;
 	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
@@ -511,27 +513,27 @@ eth_stats_get(struct rte_eth_dev *dev,
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
 			i < dev->data->nb_rx_queues; i++) {
-		igb_stats->q_ipackets[i] = internal->rx_queue[i].rx_pkts;
-		igb_stats->q_ibytes[i] = internal->rx_queue[i].rx_bytes;
-		rx_packets_total += igb_stats->q_ipackets[i];
-		rx_bytes_total += igb_stats->q_ibytes[i];
+		stats->q_ipackets[i] = internal->rx_queue[i].rx_stat.pkts;
+		stats->q_ibytes[i] = internal->rx_queue[i].rx_stat.bytes;
+		rx_packets_total += stats->q_ipackets[i];
+		rx_bytes_total += stats->q_ibytes[i];
 	}
 
 	for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
 			i < dev->data->nb_tx_queues; i++) {
-		igb_stats->q_opackets[i] = internal->tx_queue[i].tx_pkts;
-		igb_stats->q_obytes[i] = internal->tx_queue[i].tx_bytes;
-		igb_stats->q_errors[i] = internal->tx_queue[i].err_pkts;
-		tx_packets_total += igb_stats->q_opackets[i];
-		tx_bytes_total += igb_stats->q_obytes[i];
-		tx_packets_err_total += igb_stats->q_errors[i];
+		stats->q_opackets[i] = internal->tx_queue[i].tx_stat.pkts;
+		stats->q_obytes[i] = internal->tx_queue[i].tx_stat.bytes;
+		stats->q_errors[i] = internal->tx_queue[i].tx_stat.err_pkts;
+		tx_packets_total += stats->q_opackets[i];
+		tx_bytes_total += stats->q_obytes[i];
+		tx_packets_err_total += stats->q_errors[i];
 	}
 
-	igb_stats->ipackets = rx_packets_total;
-	igb_stats->ibytes = rx_bytes_total;
-	igb_stats->opackets = tx_packets_total;
-	igb_stats->obytes = tx_bytes_total;
-	igb_stats->oerrors = tx_packets_err_total;
+	stats->ipackets = rx_packets_total;
+	stats->ibytes = rx_bytes_total;
+	stats->opackets = tx_packets_total;
+	stats->obytes = tx_bytes_total;
+	stats->oerrors = tx_packets_err_total;
 }
 
 static void
@@ -540,13 +542,13 @@ eth_stats_reset(struct rte_eth_dev *dev)
 	unsigned i;
 	struct pmd_internals *internal = dev->data->dev_private;
 	for (i = 0; i < dev->data->nb_rx_queues; i++) {
-		internal->rx_queue[i].rx_pkts = 0;
-		internal->rx_queue[i].rx_bytes = 0;
+		internal->rx_queue[i].rx_stat.pkts = 0;
+		internal->rx_queue[i].rx_stat.bytes = 0;
 	}
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
-		internal->tx_queue[i].tx_pkts = 0;
-		internal->tx_queue[i].tx_bytes = 0;
-		internal->tx_queue[i].err_pkts = 0;
+		internal->tx_queue[i].tx_stat.pkts = 0;
+		internal->tx_queue[i].tx_stat.bytes = 0;
+		internal->tx_queue[i].tx_stat.err_pkts = 0;
 	}
 }
 
-- 
2.7.4

[RFC 12/21] net/pcap: make const array static

[Ferruh Yigit]

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index ec25912..3d85a7f 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -104,7 +104,7 @@ struct pmd_devargs {
 	} queue[RTE_PMD_PCAP_MAX_QUEUES];
 };
 
-const char *valid_arguments[] = {
+static const char *valid_arguments[] = {
 	ETH_PCAP_RX_PCAP_ARG,
 	ETH_PCAP_TX_PCAP_ARG,
 	ETH_PCAP_RX_IFACE_ARG,
-- 
2.7.4

[RFC 13/21] net/pcap: reorder header files

[Ferruh Yigit]

Remove unused and sort remaining.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 3d85a7f..a142e38 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -33,19 +33,18 @@
  */
 
 #include <time.h>
-#include <rte_mbuf.h>
-#include <rte_ethdev.h>
-#include <rte_malloc.h>
-#include <rte_memcpy.h>
-#include <rte_string_fns.h>
-#include <rte_cycles.h>
-#include <rte_kvargs.h>
-#include <rte_dev.h>
 
 #include <net/if.h>
 
 #include <pcap.h>
 
+#include <rte_cycles.h>
+#include <rte_dev.h>
+#include <rte_ethdev.h>
+#include <rte_kvargs.h>
+#include <rte_malloc.h>
+#include <rte_mbuf.h>
+
 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
 #define RTE_ETH_PCAP_SNAPLEN ETHER_MAX_JUMBO_FRAME_LEN
 #define RTE_ETH_PCAP_PROMISC 1
-- 
2.7.4

[RFC 14/21] net/pcap: reorder functions

[Ferruh Yigit]

Reorder functions to be able to remove function declarations in .c file.
Function definitions not modified.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 129 ++++++++++++++++++++--------------------
 1 file changed, 64 insertions(+), 65 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index a142e38..8e011ea 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -112,10 +112,6 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static int open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper);
-static int open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap);
-static int open_single_iface(const char *iface, pcap_t **pcap);
-
 static struct ether_addr eth_addr = { .addr_bytes = { 0, 0, 0, 0x1, 0x2, 0x3 } };
 static const char *drivername = "Pcap PMD";
 static struct rte_eth_link pmd_link = {
@@ -369,6 +365,70 @@ eth_pcap_tx(void *queue,
 	return num_tx;
 }
 
+/*
+ * pcap_open_live wrapper function
+ */
+static inline int
+open_iface_live(const char *iface, pcap_t **pcap) {
+	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
+			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
+
+	if (*pcap == NULL) {
+		RTE_LOG(ERR, PMD, "Couldn't open %s: %s\n", iface, errbuf);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+open_single_iface(const char *iface, pcap_t **pcap)
+{
+	if (open_iface_live(iface, pcap) < 0) {
+		RTE_LOG(ERR, PMD, "Couldn't open interface %s\n", iface);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
+{
+	pcap_t *tx_pcap;
+
+	/*
+	 * We need to create a dummy empty pcap_t to use it
+	 * with pcap_dump_open(). We create big enough an Ethernet
+	 * pcap holder.
+	 */
+	if ((tx_pcap = pcap_open_dead(DLT_EN10MB, RTE_ETH_PCAP_SNAPSHOT_LEN))
+			== NULL) {
+		RTE_LOG(ERR, PMD, "Couldn't create dead pcap\n");
+		return -1;
+	}
+
+	/* The dumper is created using the previous pcap_t reference */
+	if ((*dumper = pcap_dump_open(tx_pcap, pcap_filename)) == NULL) {
+		RTE_LOG(ERR, PMD, "Couldn't open %s for writing.\n",
+			pcap_filename);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int
+open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
+{
+	if ((*pcap = pcap_open_offline(pcap_filename, errbuf)) == NULL) {
+		RTE_LOG(ERR, PMD, "Couldn't open %s: %s\n", pcap_filename, errbuf);
+		return -1;
+	}
+
+	return 0;
+}
+
 static int
 eth_dev_start(struct rte_eth_dev *dev)
 {
@@ -636,16 +696,6 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
-static int
-open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
-{
-	if ((*pcap = pcap_open_offline(pcap_filename, errbuf)) == NULL) {
-		RTE_LOG(ERR, PMD, "Couldn't open %s: %s\n", pcap_filename, errbuf);
-		return -1;
-	}
-	return 0;
-}
-
 /*
  * Opens a pcap file for writing and stores a reference to it
  * for use it later on.
@@ -670,46 +720,6 @@ open_tx_pcap(const char *key, const char *value, void *extra_args)
 	return 0;
 }
 
-static int
-open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
-{
-	pcap_t *tx_pcap;
-	/*
-	 * We need to create a dummy empty pcap_t to use it
-	 * with pcap_dump_open(). We create big enough an Ethernet
-	 * pcap holder.
-	 */
-
-	if ((tx_pcap = pcap_open_dead(DLT_EN10MB, RTE_ETH_PCAP_SNAPSHOT_LEN))
-			== NULL) {
-		RTE_LOG(ERR, PMD, "Couldn't create dead pcap\n");
-		return -1;
-	}
-
-	/* The dumper is created using the previous pcap_t reference */
-	if ((*dumper = pcap_dump_open(tx_pcap, pcap_filename)) == NULL) {
-		RTE_LOG(ERR, PMD, "Couldn't open %s for writing.\n", pcap_filename);
-		return -1;
-	}
-
-	return 0;
-}
-
-/*
- * pcap_open_live wrapper function
- */
-static inline int
-open_iface_live(const char *iface, pcap_t **pcap) {
-	*pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
-			RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
-
-	if (*pcap == NULL) {
-		RTE_LOG(ERR, PMD, "Couldn't open %s: %s\n", iface, errbuf);
-		return -1;
-	}
-	return 0;
-}
-
 /*
  * Opens an interface for reading and writing
  */
@@ -775,17 +785,6 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-open_single_iface(const char *iface, pcap_t **pcap)
-{
-	if (open_iface_live(iface, pcap) < 0) {
-		RTE_LOG(ERR, PMD, "Couldn't open interface %s\n", iface);
-		return -1;
-	}
-
-	return 0;
-}
-
-static int
 rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 		const unsigned nb_tx_queues, struct pmd_internals **internals,
 		struct rte_eth_dev **eth_dev)
-- 
2.7.4

[RFC 15/21] net/pcap: update how single iface handled

[Ferruh Yigit]

Remove hardcoded single interface values, make it more obvious.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 8e011ea..fb170db 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -967,16 +967,14 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 
 		if (ret < 0)
 			goto free_kvlist;
-		dumpers.queue[0].pcap = pcaps.queue[0].pcap;
-		dumpers.queue[0].name = pcaps.queue[0].name;
-		dumpers.queue[0].type = pcaps.queue[0].type;
 
-		single_iface = 1;
+		dumpers.queue[0] = pcaps.queue[0];
 
-		ret = rte_eth_from_pcaps(name, &pcaps, 1, &dumpers, 1,
-			kvlist, single_iface, is_tx_pcap);
+		single_iface = 1;
+		pcaps.num_of_queue = 1;
+		dumpers.num_of_queue = 1;
 
-		goto free_kvlist;
+		goto create_eth;
 	}
 
 	/*
@@ -1027,6 +1025,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 	if (ret < 0)
 		goto free_kvlist;
 
+create_eth:
 	ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
 		dumpers.num_of_queue, kvlist, single_iface, is_tx_pcap);
 
-- 
2.7.4

[RFC 16/21] net/pcap: remove unnecessary check

[Ferruh Yigit]

Both fields are fields of same type of struct, one's size can't be bigger
than others.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index fb170db..9cb9861 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -812,10 +812,6 @@ rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 	if (*eth_dev == NULL)
 		goto error;
 
-	/* check length of device name */
-	if ((strlen((*eth_dev)->data->name) + 1) > sizeof(data->name))
-		goto error;
-
 	/* now put it all together
 	 * - store queue data in internals,
 	 * - store numa_node info in eth_dev
-- 
2.7.4

[RFC 17/21] net/pcap: remove redundant assignment

[Ferruh Yigit]

data->name assigned twice.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 9cb9861..83b05e2 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -825,8 +825,6 @@ rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 	data->nb_tx_queues = (uint16_t)nb_tx_queues;
 	data->dev_link = pmd_link;
 	data->mac_addrs = &eth_addr;
-	strncpy(data->name,
-		(*eth_dev)->data->name, strlen((*eth_dev)->data->name));
 
 	/*
 	 * NOTE: we'll replace the data element, of originally allocated
-- 
2.7.4

[RFC 18/21] net/pcap: simplify function

[Ferruh Yigit]

simplify function rte_eth_from_pcaps_common by using interim variables.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 83b05e2..ece7ff0 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -868,22 +868,21 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 		return -1;
 
 	for (i = 0; i < nb_rx_queues; i++) {
-		(*internals)->rx_queue[i].pcap = rx_queues->queue[i].pcap;
-		snprintf((*internals)->rx_queue[i].name,
-			sizeof((*internals)->rx_queue[i].name), "%s",
-			rx_queues->queue[i].name);
-		snprintf((*internals)->rx_queue[i].type,
-			sizeof((*internals)->rx_queue[i].type), "%s",
-			rx_queues->queue[i].type);
+		struct pcap_rx_queue *rx = &(*internals)->rx_queue[i];
+		struct devargs_queue *queue = &rx_queues->queue[i];
+
+		rx->pcap = queue->pcap;
+		snprintf(rx->name, sizeof(rx->name), "%s", queue->name);
+		snprintf(rx->type, sizeof(rx->type), "%s", queue->type);
 	}
+
 	for (i = 0; i < nb_tx_queues; i++) {
-		(*internals)->tx_queue[i].dumper = tx_queues->queue[i].dumper;
-		snprintf((*internals)->tx_queue[i].name,
-			sizeof((*internals)->tx_queue[i].name), "%s",
-			tx_queues->queue[i].name);
-		snprintf((*internals)->tx_queue[i].type,
-			sizeof((*internals)->tx_queue[i].type), "%s",
-			tx_queues->queue[i].type);
+		struct pcap_tx_queue *tx = &(*internals)->tx_queue[i];
+		struct devargs_queue *queue = &tx_queues->queue[i];
+
+		tx->dumper = queue->dumper;
+		snprintf(tx->name, sizeof(tx->name), "%s", queue->name);
+		snprintf(tx->type, sizeof(tx->type), "%s", queue->type);
 	}
 
 	for (k_idx = 0; k_idx < kvlist->count; k_idx++) {
-- 
2.7.4

[RFC 19/21] net/pcap: fix missing tx iface assignment

[Ferruh Yigit]

Missing pcap assignment may cause pcap opened again, and previous one
not closed at all.

Fixes: 1e38a7c66923 ("pcap: fix storage of name and type in queues")

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index ece7ff0..f3df372 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -881,6 +881,7 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 		struct devargs_queue *queue = &tx_queues->queue[i];
 
 		tx->dumper = queue->dumper;
+		tx->pcap = queue->pcap;
 		snprintf(tx->name, sizeof(tx->name), "%s", queue->name);
 		snprintf(tx->type, sizeof(tx->type), "%s", queue->type);
 	}
-- 
2.7.4

[RFC 20/21] net/pcap: coding convention updates

[Ferruh Yigit]

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 63 ++++++++++++++++++++---------------------
 1 file changed, 31 insertions(+), 32 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index f3df372..552a1de 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -49,6 +49,7 @@
 #define RTE_ETH_PCAP_SNAPLEN ETHER_MAX_JUMBO_FRAME_LEN
 #define RTE_ETH_PCAP_PROMISC 1
 #define RTE_ETH_PCAP_TIMEOUT -1
+
 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
@@ -112,7 +113,9 @@ static const char *valid_arguments[] = {
 	NULL
 };
 
-static struct ether_addr eth_addr = { .addr_bytes = { 0, 0, 0, 0x1, 0x2, 0x3 } };
+static struct ether_addr eth_addr = {
+	.addr_bytes = { 0, 0, 0, 0x1, 0x2, 0x3 }
+};
 static const char *drivername = "Pcap PMD";
 static struct rte_eth_link pmd_link = {
 		.link_speed = ETH_SPEED_NUM_10G,
@@ -122,15 +125,12 @@ static struct rte_eth_link pmd_link = {
 };
 
 static int
-eth_pcap_rx_jumbo(struct rte_mempool *mb_pool,
-		  struct rte_mbuf *mbuf,
-		  const u_char *data,
-		  uint16_t data_len)
+eth_pcap_rx_jumbo(struct rte_mempool *mb_pool, struct rte_mbuf *mbuf,
+		const u_char *data, uint16_t data_len)
 {
-	struct rte_mbuf *m = mbuf;
-
 	/* Copy the first segment. */
 	uint16_t len = rte_pktmbuf_tailroom(mbuf);
+	struct rte_mbuf *m = mbuf;
 
 	rte_memcpy(rte_pktmbuf_append(mbuf, len), data, len);
 	data_len -= len;
@@ -170,7 +170,7 @@ eth_pcap_gather_data(unsigned char *data, struct rte_mbuf *mbuf)
 
 	while (mbuf) {
 		rte_memcpy(data + data_len, rte_pktmbuf_mtod(mbuf, void *),
-			   mbuf->data_len);
+			mbuf->data_len);
 
 		data_len += mbuf->data_len;
 		mbuf = mbuf->next;
@@ -178,9 +178,7 @@ eth_pcap_gather_data(unsigned char *data, struct rte_mbuf *mbuf)
 }
 
 static uint16_t
-eth_pcap_rx(void *queue,
-		struct rte_mbuf **bufs,
-		uint16_t nb_pkts)
+eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned i;
 	struct pcap_pkthdr header;
@@ -233,6 +231,7 @@ eth_pcap_rx(void *queue,
 	}
 	pcap_q->rx_stat.pkts += num_rx;
 	pcap_q->rx_stat.bytes += rx_bytes;
+
 	return num_rx;
 }
 
@@ -251,9 +250,7 @@ calculate_timestamp(struct timeval *ts) {
  * Callback to handle writing packets to a pcap file.
  */
 static uint16_t
-eth_pcap_tx_dumper(void *queue,
-		struct rte_mbuf **bufs,
-		uint16_t nb_pkts)
+eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned i;
 	struct rte_mbuf *mbuf;
@@ -306,6 +303,7 @@ eth_pcap_tx_dumper(void *queue,
 	dumper_q->tx_stat.pkts += num_tx;
 	dumper_q->tx_stat.bytes += tx_bytes;
 	dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
+
 	return num_tx;
 }
 
@@ -313,9 +311,7 @@ eth_pcap_tx_dumper(void *queue,
  * Callback to handle sending packets through a real NIC.
  */
 static uint16_t
-eth_pcap_tx(void *queue,
-		struct rte_mbuf **bufs,
-		uint16_t nb_pkts)
+eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	unsigned i;
 	int ret;
@@ -332,14 +328,13 @@ eth_pcap_tx(void *queue,
 
 		if (likely(mbuf->nb_segs == 1)) {
 			ret = pcap_sendpacket(tx_queue->pcap,
-					      rte_pktmbuf_mtod(mbuf, u_char *),
-					      mbuf->pkt_len);
+					rte_pktmbuf_mtod(mbuf, u_char *),
+					mbuf->pkt_len);
 		} else {
 			if (mbuf->pkt_len <= ETHER_MAX_JUMBO_FRAME_LEN) {
 				eth_pcap_gather_data(tx_pcap_data, mbuf);
 				ret = pcap_sendpacket(tx_queue->pcap,
-						      tx_pcap_data,
-						      mbuf->pkt_len);
+						tx_pcap_data, mbuf->pkt_len);
 			} else {
 				RTE_LOG(ERR, PMD,
 					"Dropping PCAP packet. "
@@ -362,6 +357,7 @@ eth_pcap_tx(void *queue,
 	tx_queue->tx_stat.pkts += num_tx;
 	tx_queue->tx_stat.bytes += tx_bytes;
 	tx_queue->tx_stat.err_pkts += nb_pkts - num_tx;
+
 	return num_tx;
 }
 
@@ -457,9 +453,7 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (!tx->dumper && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
 			if (open_single_tx_pcap(tx->name, &tx->dumper) < 0)
 				return -1;
-		}
-
-		else if (!tx->pcap && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
+		} else if (!tx->pcap && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
 			if (open_single_iface(tx->name, &tx->pcap) < 0)
 				return -1;
 		}
@@ -475,17 +469,15 @@ eth_dev_start(struct rte_eth_dev *dev)
 		if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
 			if (open_single_rx_pcap(rx->name, &rx->pcap) < 0)
 				return -1;
-		}
-
-		else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
+		} else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
 			if (open_single_iface(rx->name, &rx->pcap) < 0)
 				return -1;
 		}
 	}
 
 status_up:
-
 	dev->data->dev_link.link_status = ETH_LINK_UP;
+
 	return 0;
 }
 
@@ -550,6 +542,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 		struct rte_eth_dev_info *dev_info)
 {
 	struct pmd_internals *internals = dev->data->dev_private;
+
 	dev_info->driver_name = drivername;
 	dev_info->if_index = internals->if_index;
 	dev_info->max_mac_addrs = 1;
@@ -561,8 +554,7 @@ eth_dev_info(struct rte_eth_dev *dev,
 }
 
 static void
-eth_stats_get(struct rte_eth_dev *dev,
-		struct rte_eth_stats *stats)
+eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
 {
 	unsigned i;
 	unsigned long rx_packets_total = 0, rx_bytes_total = 0;
@@ -600,10 +592,12 @@ eth_stats_reset(struct rte_eth_dev *dev)
 {
 	unsigned i;
 	struct pmd_internals *internal = dev->data->dev_private;
+
 	for (i = 0; i < dev->data->nb_rx_queues; i++) {
 		internal->rx_queue[i].rx_stat.pkts = 0;
 		internal->rx_queue[i].rx_stat.bytes = 0;
 	}
+
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		internal->tx_queue[i].tx_stat.pkts = 0;
 		internal->tx_queue[i].tx_stat.bytes = 0;
@@ -638,9 +632,11 @@ eth_rx_queue_setup(struct rte_eth_dev *dev,
 {
 	struct pmd_internals *internals = dev->data->dev_private;
 	struct pcap_rx_queue *pcap_q = &internals->rx_queue[rx_queue_id];
+
 	pcap_q->mb_pool = mb_pool;
 	dev->data->rx_queues[rx_queue_id] = pcap_q;
 	pcap_q->in_port = dev->data->port_id;
+
 	return 0;
 }
 
@@ -653,13 +649,15 @@ eth_tx_queue_setup(struct rte_eth_dev *dev,
 {
 
 	struct pmd_internals *internals = dev->data->dev_private;
+
 	dev->data->tx_queues[tx_queue_id] = &internals->tx_queue[tx_queue_id];
+
 	return 0;
 }
 
 static const struct eth_dev_ops ops = {
 	.dev_start = eth_dev_start,
-	.dev_stop =	eth_dev_stop,
+	.dev_stop = eth_dev_stop,
 	.dev_close = eth_dev_close,
 	.dev_configure = eth_dev_configure,
 	.dev_infos_get = eth_dev_info,
@@ -916,7 +914,7 @@ rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
 	if (ret < 0)
 		return ret;
 
-	/* store wether we are using a single interface for rx/tx or not */
+	/* store weather we are using a single interface for rx/tx or not */
 	internals->single_iface = single_iface;
 
 	eth_dev->rx_pkt_burst = eth_pcap_rx;
@@ -1025,6 +1023,7 @@ create_eth:
 
 free_kvlist:
 	rte_kvargs_free(kvlist);
+
 	return ret;
 }
 
-- 
2.7.4

[RFC 21/21] net/pcap: remove rte prefix from static functions

[Ferruh Yigit]

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
---
 drivers/net/pcap/rte_eth_pcap.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 552a1de..55ff2c0 100644
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -783,7 +783,7 @@ open_tx_iface(const char *key, const char *value, void *extra_args)
 }
 
 static int
-rte_pmd_init_internals(const char *name, const unsigned nb_rx_queues,
+pmd_init_internals(const char *name, const unsigned nb_rx_queues,
 		const unsigned nb_tx_queues, struct pmd_internals **internals,
 		struct rte_eth_dev **eth_dev)
 {
@@ -846,7 +846,7 @@ error:
 }
 
 static int
-rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
+eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 		const unsigned nb_rx_queues, struct pmd_devargs *tx_queues,
 		const unsigned nb_tx_queues, struct rte_kvargs *kvlist,
 		struct pmd_internals **internals, struct rte_eth_dev **eth_dev)
@@ -861,7 +861,7 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 	if (tx_queues == NULL && nb_tx_queues > 0)
 		return -1;
 
-	if (rte_pmd_init_internals(name, nb_rx_queues, nb_tx_queues, internals,
+	if (pmd_init_internals(name, nb_rx_queues, nb_tx_queues, internals,
 			eth_dev) < 0)
 		return -1;
 
@@ -899,7 +899,7 @@ rte_eth_from_pcaps_common(const char *name, struct pmd_devargs *rx_queues,
 }
 
 static int
-rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
+eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
 		const unsigned nb_rx_queues, struct pmd_devargs *tx_queues,
 		const unsigned nb_tx_queues, struct rte_kvargs *kvlist,
 		int single_iface, unsigned int using_dumpers)
@@ -908,7 +908,7 @@ rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
 	struct rte_eth_dev *eth_dev = NULL;
 	int ret;
 
-	ret = rte_eth_from_pcaps_common(name, rx_queues, nb_rx_queues,
+	ret = eth_from_pcaps_common(name, rx_queues, nb_rx_queues,
 		tx_queues, nb_tx_queues, kvlist, &internals, &eth_dev);
 
 	if (ret < 0)
@@ -929,7 +929,7 @@ rte_eth_from_pcaps(const char *name, struct pmd_devargs *rx_queues,
 
 
 static int
-rte_pmd_pcap_devinit(const char *name, const char *params)
+pmd_pcap_devinit(const char *name, const char *params)
 {
 	unsigned int is_rx_pcap = 0, is_tx_pcap = 0;
 	struct rte_kvargs *kvlist;
@@ -1018,7 +1018,7 @@ rte_pmd_pcap_devinit(const char *name, const char *params)
 		goto free_kvlist;
 
 create_eth:
-	ret = rte_eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
+	ret = eth_from_pcaps(name, &pcaps, pcaps.num_of_queue, &dumpers,
 		dumpers.num_of_queue, kvlist, single_iface, is_tx_pcap);
 
 free_kvlist:
@@ -1028,7 +1028,7 @@ free_kvlist:
 }
 
 static int
-rte_pmd_pcap_devuninit(const char *name)
+pmd_pcap_devuninit(const char *name)
 {
 	struct rte_eth_dev *eth_dev = NULL;
 
@@ -1053,8 +1053,8 @@ rte_pmd_pcap_devuninit(const char *name)
 
 static struct rte_driver pmd_pcap_drv = {
 	.type = PMD_VDEV,
-	.init = rte_pmd_pcap_devinit,
-	.uninit = rte_pmd_pcap_devuninit,
+	.init = pmd_pcap_devinit,
+	.uninit = pmd_pcap_devuninit,
 };
 
 PMD_REGISTER_DRIVER(pmd_pcap_drv, eth_pcap);
-- 
2.7.4