/*-
* BSD LICENSE
*
- * Copyright(c) 2010-2013 Intel Corporation. All rights reserved.
+ * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ * Copyright(c) 2014 6WIND S.A.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include <rte_memcpy.h>
#include <rte_string_fns.h>
#include <rte_cycles.h>
+#include <rte_kvargs.h>
#include "rte_eth_pcap.h"
-#include "rte_eth_pcap_arg_parser.h"
#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
#define RTE_ETH_PCAP_SNAPLEN 4096
#define RTE_ETH_PCAP_PROMISC 1
#define RTE_ETH_PCAP_TIMEOUT -1
-#define RTE_ETH_PCAP_MBUFS 64
#define ETH_PCAP_RX_PCAP_ARG "rx_pcap"
#define ETH_PCAP_TX_PCAP_ARG "tx_pcap"
#define ETH_PCAP_RX_IFACE_ARG "rx_iface"
break;
/* Now get the space available for data in the mbuf */
- mbp_priv = (struct rte_pktmbuf_pool_private *)
- ((char *)pcap_q->mb_pool + sizeof(struct rte_mempool));
+ mbp_priv = rte_mempool_get_priv(pcap_q->mb_pool);
buf_size = (uint16_t) (mbp_priv->mbuf_data_room_size -
RTE_PKTMBUF_HEADROOM);
* reference of it for use it later on.
*/
static int
-open_rx_pcap(char *value, void *extra_args)
+open_rx_pcap(const char *key __rte_unused, const char *value, void *extra_args)
{
unsigned i;
- char *pcap_filename = value;
+ const char *pcap_filename = value;
struct rx_pcaps *pcaps = extra_args;
pcap_t *rx_pcap;
* for use it later on.
*/
static int
-open_tx_pcap(char *value, void *extra_args)
+open_tx_pcap(const char *key __rte_unused, const char *value, void *extra_args)
{
unsigned i;
- char *pcap_filename = value;
+ const char *pcap_filename = value;
struct tx_pcaps *dumpers = extra_args;
pcap_t *tx_pcap;
pcap_dumper_t *dumper;
* Opens an interface for reading and writing
*/
static inline int
-open_rx_tx_iface(char *value, void *extra_args)
+open_rx_tx_iface(const char *key __rte_unused, const char *value, void *extra_args)
{
const char *iface = value;
pcap_t **pcap = extra_args;
* Opens a NIC for reading packets from it
*/
static inline int
-open_rx_iface(char *value, void *extra_args)
+open_rx_iface(const char *key __rte_unused, const char *value, void *extra_args)
{
unsigned i;
const char *iface = value;
* Opens a NIC for writing packets to it
*/
static inline int
-open_tx_iface(char *value, void *extra_args)
+open_tx_iface(const char *key __rte_unused, const char *value, void *extra_args)
{
unsigned i;
const char *iface = value;
{
unsigned numa_node, using_dumpers = 0;
int ret;
- struct args_dict dict;
+ struct rte_kvargs *kvlist;
struct rx_pcaps pcaps;
struct tx_pcaps dumpers;
- rte_eth_pcap_init_args_dict(&dict);
+ RTE_LOG(INFO, PMD, "Initializing pmd_pcap for %s\n", name);
numa_node = rte_socket_id();
start_cycles = rte_get_timer_cycles();
hz = rte_get_timer_hz();
- if (rte_eth_pcap_parse_args(&dict, name, params, valid_arguments) < 0)
+ kvlist = rte_kvargs_parse(params, valid_arguments);
+ if (kvlist == NULL)
return -1;
/*
* If iface argument is passed we open the NICs and use them for
* reading / writing
*/
- if (rte_eth_pcap_num_of_args(&dict, ETH_PCAP_IFACE_ARG) == 1) {
+ if (rte_kvargs_count(kvlist, ETH_PCAP_IFACE_ARG) == 1) {
- ret = rte_eth_pcap_post_process_arguments(&dict, ETH_PCAP_IFACE_ARG,
+ ret = rte_kvargs_process(kvlist, ETH_PCAP_IFACE_ARG,
&open_rx_tx_iface, &pcaps.pcaps[0]);
if (ret < 0)
return -1;
* We check whether we want to open a RX stream from a real NIC or a
* pcap file
*/
- if ((pcaps.num_of_rx = rte_eth_pcap_num_of_args(&dict, ETH_PCAP_RX_PCAP_ARG))) {
- ret = rte_eth_pcap_post_process_arguments(&dict, ETH_PCAP_RX_PCAP_ARG,
+ if ((pcaps.num_of_rx = 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_eth_pcap_num_of_args(&dict,
+ pcaps.num_of_rx = rte_kvargs_count(kvlist,
ETH_PCAP_RX_IFACE_ARG);
- ret = rte_eth_pcap_post_process_arguments(&dict, ETH_PCAP_RX_IFACE_ARG,
+ ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_IFACE_ARG,
&open_rx_iface, &pcaps);
}
* We check whether we want to open a TX stream to a real NIC or a
* pcap file
*/
- if ((dumpers.num_of_tx = rte_eth_pcap_num_of_args(&dict,
+ if ((dumpers.num_of_tx = rte_kvargs_count(kvlist,
ETH_PCAP_TX_PCAP_ARG))) {
- ret = rte_eth_pcap_post_process_arguments(&dict, 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_eth_pcap_num_of_args(&dict,
+ dumpers.num_of_tx = rte_kvargs_count(kvlist,
ETH_PCAP_TX_IFACE_ARG);
- ret = rte_eth_pcap_post_process_arguments(&dict, ETH_PCAP_TX_IFACE_ARG,
+ ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_IFACE_ARG,
&open_tx_iface, &dumpers);
}