New upstream version 16.11.8

[deb_dpdk.git] / drivers / net / pcap / rte_eth_pcap.c

diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c
index 0162f44..deca553 100644 (file)
--- a/drivers/net/pcap/rte_eth_pcap.c
+++ b/drivers/net/pcap/rte_eth_pcap.c
@@ -124,7 +124,7 @@ static struct rte_eth_link pmd_link = {
                .link_speed = ETH_SPEED_NUM_10G,
                .link_duplex = ETH_LINK_FULL_DUPLEX,
                .link_status = ETH_LINK_DOWN,
-               .link_autoneg = ETH_LINK_SPEED_FIXED,
+               .link_autoneg = ETH_LINK_FIXED,
 };
 
 static int
@@ -247,7 +247,7 @@ calculate_timestamp(struct timeval *ts) {
 
        cycles = rte_get_timer_cycles() - start_cycles;
        cur_time.tv_sec = cycles / hz;
-       cur_time.tv_usec = (cycles % hz) * 10e6 / hz;
+       cur_time.tv_usec = (cycles % hz) * 1e6 / hz;
        timeradd(&start_time, &cur_time, ts);
 }
 
@@ -294,9 +294,9 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
                        }
                }
 
-               rte_pktmbuf_free(mbuf);
                num_tx++;
                tx_bytes += mbuf->pkt_len;
+               rte_pktmbuf_free(mbuf);
        }
 
        /*
@@ -411,11 +411,13 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
        /* The dumper is created using the previous pcap_t reference */
        *dumper = pcap_dump_open(tx_pcap, pcap_filename);
        if (*dumper == NULL) {
+               pcap_close(tx_pcap);
                RTE_LOG(ERR, PMD, "Couldn't open %s for writing.\n",
                        pcap_filename);
                return -1;
        }
 
+       pcap_close(tx_pcap);
        return 0;
 }
 
@@ -685,19 +687,19 @@ static const struct eth_dev_ops ops = {
 static int
 open_rx_pcap(const char *key, const char *value, void *extra_args)
 {
-       unsigned int i;
        const char *pcap_filename = value;
        struct pmd_devargs *rx = extra_args;
        pcap_t *pcap = NULL;
 
-       for (i = 0; i < rx->num_of_queue; i++) {
-               if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
-                       return -1;
+       if (rx->num_of_queue >= RTE_PMD_PCAP_MAX_QUEUES)
+               return -1;
+       if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
+               return -1;
 
-               rx->queue[i].pcap = pcap;
-               rx->queue[i].name = pcap_filename;
-               rx->queue[i].type = key;
-       }
+       rx->queue[rx->num_of_queue].pcap = pcap;
+       rx->queue[rx->num_of_queue].name = pcap_filename;
+       rx->queue[rx->num_of_queue].type = key;
+       rx->num_of_queue++;
 
        return 0;
 }
@@ -709,19 +711,19 @@ open_rx_pcap(const char *key, const char *value, void *extra_args)
 static int
 open_tx_pcap(const char *key, const char *value, void *extra_args)
 {
-       unsigned int i;
        const char *pcap_filename = value;
        struct pmd_devargs *dumpers = extra_args;
        pcap_dumper_t *dumper;
 
-       for (i = 0; i < dumpers->num_of_queue; i++) {
-               if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
-                       return -1;
+       if (dumpers->num_of_queue >= RTE_PMD_PCAP_MAX_QUEUES)
+               return -1;
+       if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
+               return -1;
 
-               dumpers->queue[i].dumper = dumper;
-               dumpers->queue[i].name = pcap_filename;
-               dumpers->queue[i].type = key;
-       }
+       dumpers->queue[dumpers->num_of_queue].dumper = dumper;
+       dumpers->queue[dumpers->num_of_queue].name = pcap_filename;
+       dumpers->queue[dumpers->num_of_queue].type = key;
+       dumpers->num_of_queue++;
 
        return 0;
 }
@@ -752,18 +754,18 @@ open_rx_tx_iface(const char *key, const char *value, void *extra_args)
 static inline int
 open_rx_iface(const char *key, const char *value, void *extra_args)
 {
-       unsigned int i;
        const char *iface = value;
        struct pmd_devargs *rx = extra_args;
        pcap_t *pcap = NULL;
 
-       for (i = 0; i < rx->num_of_queue; i++) {
-               if (open_single_iface(iface, &pcap) < 0)
-                       return -1;
-               rx->queue[i].pcap = pcap;
-               rx->queue[i].name = iface;
-               rx->queue[i].type = key;
-       }
+       if (rx->num_of_queue >= RTE_PMD_PCAP_MAX_QUEUES)
+               return -1;
+       if (open_single_iface(iface, &pcap) < 0)
+               return -1;
+       rx->queue[rx->num_of_queue].pcap = pcap;
+       rx->queue[rx->num_of_queue].name = iface;
+       rx->queue[rx->num_of_queue].type = key;
+       rx->num_of_queue++;
 
        return 0;
 }
@@ -774,18 +776,18 @@ open_rx_iface(const char *key, const char *value, void *extra_args)
 static int
 open_tx_iface(const char *key, const char *value, void *extra_args)
 {
-       unsigned int i;
        const char *iface = value;
        struct pmd_devargs *tx = extra_args;
        pcap_t *pcap;
 
-       for (i = 0; i < tx->num_of_queue; i++) {
-               if (open_single_iface(iface, &pcap) < 0)
-                       return -1;
-               tx->queue[i].pcap = pcap;
-               tx->queue[i].name = iface;
-               tx->queue[i].type = key;
-       }
+       if (tx->num_of_queue >= RTE_PMD_PCAP_MAX_QUEUES)
+               return -1;
+       if (open_single_iface(iface, &pcap) < 0)
+               return -1;
+       tx->queue[tx->num_of_queue].pcap = pcap;
+       tx->queue[tx->num_of_queue].name = iface;
+       tx->queue[tx->num_of_queue].type = key;
+       tx->num_of_queue++;
 
        return 0;
 }
@@ -799,7 +801,7 @@ pmd_init_internals(const char *name, const unsigned int nb_rx_queues,
        struct rte_eth_dev_data *data = NULL;
        unsigned int numa_node = rte_socket_id();
 
-       RTE_LOG(INFO, PMD, "Creating pcap-backed ethdev on numa socket %u\n",
+       RTE_LOG(INFO, PMD, "Creating pcap-backed ethdev on numa socket %d\n",
                numa_node);
 
        /* now do all data allocation - for eth_dev structure
@@ -981,15 +983,8 @@ pmd_pcap_probe(const char *name, const char *params)
         * We check whether we want to open a RX stream from a real NIC or a
         * pcap file
         */
-       pcaps.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG);
-       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;
+       is_rx_pcap = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG) ? 1 : 0;
+       pcaps.num_of_queue = 0;
 
        if (is_rx_pcap)
                ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
@@ -1005,15 +1000,8 @@ pmd_pcap_probe(const char *name, const char *params)
         * We check whether we want to open a TX stream to a real NIC or a
         * pcap file
         */
-       dumpers.num_of_queue = rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG);
-       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;
+       is_tx_pcap = rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG) ? 1 : 0;
+       dumpers.num_of_queue = 0;
 
        if (is_tx_pcap)
                ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_PCAP_ARG,
@@ -1040,7 +1028,7 @@ pmd_pcap_remove(const char *name)
 {
        struct rte_eth_dev *eth_dev = NULL;
 
-       RTE_LOG(INFO, PMD, "Closing pcap ethdev on numa socket %u\n",
+       RTE_LOG(INFO, PMD, "Closing pcap ethdev on numa socket %d\n",
                        rte_socket_id());
 
        if (name == NULL)