Add a new devarg 'snaplen' to configure the pcap snapshot length, which controls the maximum packet size for capture and output.
The snapshot length affects: - The pcap_set_snaplen() call when capturing from interfaces - The pcap_open_dead() snapshot parameter for output files - The reported max_rx_pktlen in device info - The reported max_mtu in device info (snaplen - ethernet header) The default value is 65535 bytes, preserving backward compatibility with previous driver behavior. Example usage: --vdev 'net_pcap0,iface=eth0,snaplen=1518' --vdev 'net_pcap0,rx_pcap=in.pcap,tx_pcap=out.pcap,snaplen=9000' Signed-off-by: Stephen Hemminger <[email protected]> --- app/test/test_pmd_pcap.c | 194 ++++++++++++++++++++++++- doc/guides/nics/pcap_ring.rst | 17 +++ doc/guides/rel_notes/release_26_03.rst | 1 + drivers/net/pcap/pcap_ethdev.c | 165 ++++++++++++--------- 4 files changed, 306 insertions(+), 71 deletions(-) diff --git a/app/test/test_pmd_pcap.c b/app/test/test_pmd_pcap.c index 8c5d5d76e4..86ec6165f3 100644 --- a/app/test/test_pmd_pcap.c +++ b/app/test/test_pmd_pcap.c @@ -447,6 +447,41 @@ get_pcap_packet_sizes(const char *path, uint16_t *sizes, unsigned int max_pkts) return count; } +/* + * Helper: Verify packets in pcap file are truncated correctly + * Returns 0 if all packets have caplen == expected_caplen and len == expected_len + */ +static int +verify_pcap_truncation(const char *path, uint32_t expected_caplen, + uint32_t expected_len, unsigned int *pkt_count) +{ + pcap_t *pd; + char errbuf[PCAP_ERRBUF_SIZE]; + struct pcap_pkthdr *hdr; + const u_char *data; + unsigned int count = 0; + + pd = pcap_open_offline(path, errbuf); + if (pd == NULL) + return -1; + + while (pcap_next_ex(pd, &hdr, &data) == 1) { + if (hdr->caplen != expected_caplen || hdr->len != expected_len) { + printf("Packet %u: caplen=%u (expected %u), len=%u (expected %u)\n", + count, hdr->caplen, expected_caplen, + hdr->len, expected_len); + pcap_close(pd); + return -1; + } + count++; + } + + pcap_close(pd); + if (pkt_count) + *pkt_count = count; + return 0; +} + /* * Helper: Configure and start a pcap ethdev port */ @@ -1973,7 +2008,7 @@ test_multi_rx_queue_same_file(void) * This test verifies that rte_eth_dev_info_get() returns correct values: * 1. max_rx_queues matches the number of rx_pcap files passed * 2. max_tx_queues matches the number of tx_pcap files passed - * 3. min_mtu and max_mtu are set to reasonable values + * 3. max_rx_pktlen and max_mtu are based on default snapshot length */ static int test_dev_info(void) @@ -1985,6 +2020,9 @@ test_dev_info(void) uint16_t port_id; int ret; unsigned int i; + /* Default snapshot length is 65535 */ + const uint32_t default_snaplen = 65535; + const uint32_t expected_max_mtu = default_snaplen - RTE_ETHER_HDR_LEN; printf("Testing device info reporting\n"); @@ -2023,8 +2061,8 @@ test_dev_info(void) printf(" driver_name: %s\n", dev_info.driver_name); printf(" max_rx_queues: %u (expected: 3)\n", dev_info.max_rx_queues); printf(" max_tx_queues: %u (expected: 2)\n", dev_info.max_tx_queues); - printf(" min_mtu: %u\n", dev_info.min_mtu); - printf(" max_mtu: %u\n", dev_info.max_mtu); + printf(" max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, default_snaplen); + printf(" max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu); /* Verify queue counts match number of pcap files */ TEST_ASSERT_EQUAL(dev_info.max_rx_queues, 3U, @@ -2032,6 +2070,16 @@ test_dev_info(void) TEST_ASSERT_EQUAL(dev_info.max_tx_queues, 2U, "max_tx_queues mismatch: expected 2, got %u", dev_info.max_tx_queues); + /* Verify max_rx_pktlen equals default snapshot length */ + TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, default_snaplen, + "max_rx_pktlen mismatch: expected %u, got %u", + default_snaplen, dev_info.max_rx_pktlen); + + /* Verify max_mtu is snapshot_len minus ethernet header */ + TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu, + "max_mtu mismatch: expected %u, got %u", + expected_max_mtu, dev_info.max_mtu); + rte_vdev_uninit("net_pcap_devinfo"); /* Cleanup temp files */ @@ -2044,6 +2092,144 @@ test_dev_info(void) return TEST_SUCCESS; } +/* + * Test: Custom snapshot length (snaplen) parameter + * + * This test verifies that the snaplen devarg works correctly: + * 1. max_rx_pktlen reflects the custom snapshot length + * 2. max_mtu is calculated as snaplen - ethernet header + */ +static int +test_snaplen(void) +{ + struct rte_eth_dev_info dev_info; + char devargs[512]; + char rx_path[PATH_MAX]; + char tx_path[PATH_MAX]; + uint16_t port_id; + int ret; + const uint32_t custom_snaplen = 9000; + const uint32_t expected_max_mtu = custom_snaplen - RTE_ETHER_HDR_LEN; + + printf("Testing custom snapshot length parameter\n"); + + /* Create temp files */ + TEST_ASSERT(create_temp_path(rx_path, sizeof(rx_path), "pcap_snaplen_rx") == 0, + "Failed to create RX temp path"); + TEST_ASSERT(create_test_pcap(rx_path, 1) == 0, + "Failed to create RX pcap"); + TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_snaplen_tx") == 0, + "Failed to create TX temp path"); + + /* Create device with custom snaplen */ + snprintf(devargs, sizeof(devargs), "rx_pcap=%s,tx_pcap=%s,snaplen=%u", + rx_path, tx_path, custom_snaplen); + + ret = rte_vdev_init("net_pcap_snaplen", devargs); + TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret)); + + ret = rte_eth_dev_get_port_by_name("net_pcap_snaplen", &port_id); + TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device"); + + ret = rte_eth_dev_info_get(port_id, &dev_info); + TEST_ASSERT_SUCCESS(ret, "Failed to get device info: %s", rte_strerror(-ret)); + + printf(" Custom snaplen: %u\n", custom_snaplen); + printf(" max_rx_pktlen: %u (expected: %u)\n", dev_info.max_rx_pktlen, custom_snaplen); + printf(" max_mtu: %u (expected: %u)\n", dev_info.max_mtu, expected_max_mtu); + + /* Verify max_rx_pktlen equals custom snapshot length */ + TEST_ASSERT_EQUAL(dev_info.max_rx_pktlen, custom_snaplen, + "max_rx_pktlen mismatch: expected %u, got %u", + custom_snaplen, dev_info.max_rx_pktlen); + + /* Verify max_mtu is snaplen minus ethernet header */ + TEST_ASSERT_EQUAL(dev_info.max_mtu, expected_max_mtu, + "max_mtu mismatch: expected %u, got %u", + expected_max_mtu, dev_info.max_mtu); + + rte_vdev_uninit("net_pcap_snaplen"); + + /* Cleanup temp files */ + unlink(rx_path); + unlink(tx_path); + + printf("Snapshot length test PASSED\n"); + return TEST_SUCCESS; +} + +/* + * Test: Snapshot length truncation behavior + * + * This test verifies that packets larger than snaplen are properly truncated + * when written to pcap files: + * 1. caplen in pcap header is limited to snaplen + * 2. len in pcap header preserves original packet length + * 3. Only snaplen bytes of data are written + */ +static int +test_snaplen_truncation(void) +{ + struct rte_mbuf *mbufs[NUM_PACKETS]; + char devargs[512]; + char tx_path[PATH_MAX]; + uint16_t port_id; + int ret, nb_tx, nb_gen; + unsigned int pkt_count; + const uint32_t test_snaplen = 100; + const uint8_t pkt_size = 200; + + printf("Testing snaplen truncation behavior\n"); + + /* Create temp TX file */ + TEST_ASSERT(create_temp_path(tx_path, sizeof(tx_path), "pcap_trunc_tx") == 0, + "Failed to create TX temp path"); + + /* Create device with small snaplen */ + snprintf(devargs, sizeof(devargs), "tx_pcap=%s,snaplen=%u", + tx_path, test_snaplen); + + ret = rte_vdev_init("net_pcap_trunc", devargs); + TEST_ASSERT_SUCCESS(ret, "Failed to create pcap PMD: %s", rte_strerror(-ret)); + + ret = rte_eth_dev_get_port_by_name("net_pcap_trunc", &port_id); + TEST_ASSERT_SUCCESS(ret, "Cannot find added pcap device"); + + TEST_ASSERT(setup_pcap_port(port_id) == 0, "Failed to setup port"); + + /* Generate packets larger than snaplen */ + nb_gen = generate_test_packets(mp, mbufs, NUM_PACKETS, pkt_size); + TEST_ASSERT_EQUAL(nb_gen, NUM_PACKETS, + "Failed to generate packets: got %d, expected %d", + nb_gen, NUM_PACKETS); + + printf(" Sending %d packets of size %u with snaplen=%u\n", + NUM_PACKETS, pkt_size, test_snaplen); + + /* Transmit packets */ + nb_tx = rte_eth_tx_burst(port_id, 0, mbufs, NUM_PACKETS); + TEST_ASSERT_EQUAL(nb_tx, NUM_PACKETS, + "TX burst failed: sent %d/%d", nb_tx, NUM_PACKETS); + + cleanup_pcap_vdev("net_pcap_trunc", port_id); + + /* Verify truncation in output file */ + ret = verify_pcap_truncation(tx_path, test_snaplen, pkt_size, &pkt_count); + TEST_ASSERT_SUCCESS(ret, "Truncation verification failed"); + TEST_ASSERT_EQUAL(pkt_count, (unsigned int)NUM_PACKETS, + "Packet count mismatch: got %u, expected %d", + pkt_count, NUM_PACKETS); + + printf(" Verified %u packets: caplen=%u, len=%u\n", + pkt_count, test_snaplen, pkt_size); + + /* Cleanup */ + unlink(tx_path); + + printf("Snaplen truncation test PASSED\n"); + return TEST_SUCCESS; +} + /* * Test: VLAN Strip on RX * @@ -2322,6 +2508,8 @@ static struct unit_test_suite test_pmd_pcap_suite = { TEST_CASE(test_vlan_strip_rx), TEST_CASE(test_vlan_insert_tx), TEST_CASE(test_vlan_no_strip_rx), + TEST_CASE(test_snaplen), + TEST_CASE(test_snaplen_truncation), TEST_CASES_END() } }; diff --git a/doc/guides/nics/pcap_ring.rst b/doc/guides/nics/pcap_ring.rst index 6955e91130..f01107841d 100644 --- a/doc/guides/nics/pcap_ring.rst +++ b/doc/guides/nics/pcap_ring.rst @@ -94,6 +94,23 @@ The different stream types are: iface=eth0 +* snaplen: Set snapshot length (maximum capture size) + + The snapshot length limits the maximum size of captured packets. This can be + set with the ``snaplen`` devarg, for example:: + + snaplen=1518 + + This sets the snapshot length to 1518 bytes. The value affects the reported + ``max_rx_pktlen`` and ``max_mtu`` in device info. The default value is 65535 + bytes, matching the default pcap snapshot length. + + When capturing from interfaces, this limits the amount of data captured per + packet. For pcap file output, packets larger than the snapshot length are + truncated: only the first ``snaplen`` bytes are written, while the original + packet length is preserved in the pcap packet header. + + Runtime Config Options ^^^^^^^^^^^^^^^^^^^^^^ diff --git a/doc/guides/rel_notes/release_26_03.rst b/doc/guides/rel_notes/release_26_03.rst index ddcb693166..edb39f2a37 100644 --- a/doc/guides/rel_notes/release_26_03.rst +++ b/doc/guides/rel_notes/release_26_03.rst @@ -60,6 +60,7 @@ New Features * Changed transmit burst to always return the number of packets requested. Failed sends are counted as transmit errors. * Added support for VLAN insertion and stripping. + * Added ``snaplen`` devarg to configure packet capture snapshot length. * Receive timestamp offload is only done if offload flag set. * Receive timestamps support nanosecond precision. * Added unit test suite. diff --git a/drivers/net/pcap/pcap_ethdev.c b/drivers/net/pcap/pcap_ethdev.c index cc72f7f657..82ead5f136 100644 --- a/drivers/net/pcap/pcap_ethdev.c +++ b/drivers/net/pcap/pcap_ethdev.c @@ -31,8 +31,6 @@ #include "pcap_osdep.h" -#define RTE_ETH_PCAP_SNAPSHOT_LEN 65535 - #define ETH_PCAP_RX_PCAP_ARG "rx_pcap" #define ETH_PCAP_TX_PCAP_ARG "tx_pcap" #define ETH_PCAP_RX_IFACE_ARG "rx_iface" @@ -41,6 +39,9 @@ #define ETH_PCAP_IFACE_ARG "iface" #define ETH_PCAP_PHY_MAC_ARG "phy_mac" #define ETH_PCAP_INFINITE_RX_ARG "infinite_rx" +#define ETH_PCAP_SNAPSHOT_LEN_ARG "snaplen" + +#define ETH_PCAP_SNAPSHOT_LEN_DEFAULT 65535 #define ETH_PCAP_ARG_MAXLEN 64 @@ -98,6 +99,7 @@ struct pmd_internals { char devargs[ETH_PCAP_ARG_MAXLEN]; struct rte_ether_addr eth_addr; int if_index; + uint32_t snapshot_len; bool single_iface; bool phy_mac; bool infinite_rx; @@ -125,6 +127,7 @@ struct pmd_devargs { struct pmd_devargs_all { struct pmd_devargs rx_queues; struct pmd_devargs tx_queues; + uint32_t snapshot_len; bool single_iface; bool is_tx_pcap; bool is_tx_iface; @@ -142,11 +145,16 @@ static const char *valid_arguments[] = { ETH_PCAP_IFACE_ARG, ETH_PCAP_PHY_MAC_ARG, ETH_PCAP_INFINITE_RX_ARG, + ETH_PCAP_SNAPSHOT_LEN_ARG, NULL }; RTE_LOG_REGISTER_DEFAULT(eth_pcap_logtype, NOTICE); +/* Forward declaration */ +static inline int set_iface_direction(const char *iface, pcap_t *pcap, + pcap_direction_t direction); + static struct queue_missed_stat* queue_missed_stat_update(struct rte_eth_dev *dev, unsigned int qid) { @@ -406,25 +414,24 @@ pcap_pktmbuf_read(const struct rte_mbuf *m, static uint16_t eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) { - unsigned int i; - struct pmd_process_private *pp; struct pcap_tx_queue *dumper_q = queue; - pcap_dumper_t *dumper; + struct rte_eth_dev *dev = &rte_eth_devices[dumper_q->port_id]; + struct pmd_internals *internals = dev->data->dev_private; + struct pmd_process_private *pp = dev->process_private; + uint32_t snaplen = internals->snapshot_len; + pcap_dumper_t *dumper = pp->tx_dumper[dumper_q->queue_id]; uint16_t num_tx = 0; uint32_t tx_bytes = 0; struct pcap_pkthdr header; - pp = rte_eth_devices[dumper_q->port_id].process_private; - dumper = pp->tx_dumper[dumper_q->queue_id]; - - if (unlikely(dumper == NULL || nb_pkts == 0)) + if (unlikely(dumper == NULL)) return 0; /* all packets in burst have same timestamp */ calculate_timestamp(&header.ts); /* writes the nb_pkts packets to the previously opened pcap file dumper */ - for (i = 0; i < nb_pkts; i++) { + for (uint16_t i = 0; i < nb_pkts; i++) { struct rte_mbuf *mbuf = bufs[i]; if (mbuf->ol_flags & RTE_MBUF_F_TX_VLAN) { @@ -434,11 +441,12 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) } uint32_t len = rte_pktmbuf_pkt_len(mbuf); + uint32_t caplen = RTE_MIN(len, snaplen); header.len = len; - header.caplen = len; + header.caplen = caplen; void *temp = NULL; - const uint8_t *data = pcap_pktmbuf_read(mbuf, 0, len, &temp); + const uint8_t *data = pcap_pktmbuf_read(mbuf, 0, caplen, &temp); if (likely(data != NULL)) { pcap_dump((u_char *)dumper, &header, data); @@ -537,7 +545,7 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) * pcap_open_live wrapper function */ static inline int -open_iface_live(const char *iface, pcap_t **pcap) +open_iface_live(const char *iface, pcap_t **pcap, uint32_t snaplen) { char errbuf[PCAP_ERRBUF_SIZE]; pcap_t *pc; @@ -564,7 +572,7 @@ open_iface_live(const char *iface, pcap_t **pcap) PMD_LOG(WARNING, "%s: Could not set to promiscuous: %s", iface, pcap_statustostr(status)); - status = pcap_set_snaplen(pc, RTE_ETH_PCAP_SNAPSHOT_LEN); + status = pcap_set_snaplen(pc, snaplen); if (status != 0) PMD_LOG(WARNING, "%s: Could not set snapshot length: %s", iface, pcap_statustostr(status)); @@ -595,9 +603,9 @@ open_iface_live(const char *iface, pcap_t **pcap) } static int -open_single_iface(const char *iface, pcap_t **pcap) +open_single_iface(const char *iface, pcap_t **pcap, uint32_t snaplen) { - if (open_iface_live(iface, pcap) < 0) { + if (open_iface_live(iface, pcap, snaplen) < 0) { PMD_LOG(ERR, "Couldn't open interface %s", iface); return -1; } @@ -606,7 +614,8 @@ open_single_iface(const char *iface, pcap_t **pcap) } static int -open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper) +open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper, + uint32_t snaplen) { pcap_t *tx_pcap; @@ -616,7 +625,7 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper) * pcap holder. */ tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, - RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO); + snaplen, PCAP_TSTAMP_PRECISION_NANO); if (tx_pcap == NULL) { PMD_LOG(ERR, "Couldn't create dead pcap"); return -1; @@ -677,6 +686,7 @@ eth_dev_start(struct rte_eth_dev *dev) struct pmd_process_private *pp = dev->process_private; struct pcap_tx_queue *tx; struct pcap_rx_queue *rx; + uint32_t snaplen = internals->snapshot_len; if (internals->timestamp_offloading) { int ret = rte_mbuf_dyn_rx_timestamp_register(×tamp_dynfield_offset, @@ -694,7 +704,7 @@ eth_dev_start(struct rte_eth_dev *dev) if (!pp->tx_pcap[0] && strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) { - if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0) + if (open_single_iface(tx->name, &pp->tx_pcap[0], snaplen) < 0) return -1; pp->rx_pcap[0] = pp->tx_pcap[0]; } @@ -706,14 +716,11 @@ eth_dev_start(struct rte_eth_dev *dev) for (i = 0; i < dev->data->nb_tx_queues; i++) { tx = &internals->tx_queue[i]; - if (!pp->tx_dumper[i] && - strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) { - if (open_single_tx_pcap(tx->name, - &pp->tx_dumper[i]) < 0) + if (!pp->tx_dumper[i] && strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) { + if (open_single_tx_pcap(tx->name, &pp->tx_dumper[i], snaplen) < 0) return -1; - } else if (!pp->tx_pcap[i] && - strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) { - if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0) + } else if (!pp->tx_pcap[i] && strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) { + if (open_single_iface(tx->name, &pp->tx_pcap[i], snaplen) < 0) return -1; } } @@ -728,9 +735,14 @@ 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, &pp->rx_pcap[i]) < 0) return -1; - } else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) { - if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0) + } else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0 || + strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) { + if (open_single_iface(rx->name, &pp->rx_pcap[i], snaplen) < 0) return -1; + /* Set direction for rx_iface_in */ + if (strcmp(rx->type, ETH_PCAP_RX_IFACE_IN_ARG) == 0) + set_iface_direction(rx->name, pp->rx_pcap[i], + PCAP_D_IN); } } @@ -821,11 +833,11 @@ eth_dev_info(struct rte_eth_dev *dev, dev_info->if_index = internals->if_index; dev_info->max_mac_addrs = 1; - dev_info->max_rx_pktlen = RTE_ETH_PCAP_SNAPSHOT_LEN; + dev_info->max_rx_pktlen = internals->snapshot_len; dev_info->max_rx_queues = dev->data->nb_rx_queues; dev_info->max_tx_queues = dev->data->nb_tx_queues; - dev_info->min_rx_bufsize = 0; - dev_info->max_mtu = RTE_ETH_PCAP_SNAPSHOT_LEN - RTE_ETHER_HDR_LEN; + dev_info->min_rx_bufsize = RTE_ETHER_MIN_LEN; + dev_info->max_mtu = internals->snapshot_len - RTE_ETHER_HDR_LEN; dev_info->tx_offload_capa = RTE_ETH_TX_OFFLOAD_MULTI_SEGS | RTE_ETH_TX_OFFLOAD_VLAN_INSERT; dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_VLAN_STRIP | @@ -1242,41 +1254,32 @@ open_rx_pcap(const char *key, const char *value, void *extra_args) } /* - * Opens a pcap file for writing and stores a reference to it - * for use it later on. + * Store TX pcap file configuration. + * The actual pcap dumper is opened in eth_dev_start(). */ static int open_tx_pcap(const char *key, const char *value, void *extra_args) { const char *pcap_filename = value; struct pmd_devargs *dumpers = extra_args; - pcap_dumper_t *dumper; - - if (open_single_tx_pcap(pcap_filename, &dumper) < 0) - return -1; - if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) { - pcap_dump_close(dumper); + if (add_queue(dumpers, pcap_filename, key, NULL, NULL) < 0) return -1; - } return 0; } /* - * Opens an interface for reading and writing + * Store interface configuration for reading and writing. + * The actual pcap handle is opened in eth_dev_start(). */ static inline int open_rx_tx_iface(const char *key, const char *value, void *extra_args) { const char *iface = value; struct pmd_devargs *tx = extra_args; - pcap_t *pcap = NULL; - if (open_single_iface(iface, &pcap) < 0) - return -1; - - tx->queue[0].pcap = pcap; + tx->queue[0].pcap = NULL; tx->queue[0].name = iface; tx->queue[0].type = key; @@ -1298,42 +1301,30 @@ set_iface_direction(const char *iface, pcap_t *pcap, return 0; } +/* + * Store interface configuration. + * The actual pcap handle is opened in eth_dev_start(). + */ static inline int open_iface(const char *key, const char *value, void *extra_args) { const char *iface = value; struct pmd_devargs *pmd = extra_args; - pcap_t *pcap = NULL; - if (open_single_iface(iface, &pcap) < 0) - return -1; - if (add_queue(pmd, iface, key, pcap, NULL) < 0) { - pcap_close(pcap); + if (add_queue(pmd, iface, key, NULL, NULL) < 0) return -1; - } return 0; } /* - * Opens a NIC for reading packets from it + * Store RX interface configuration. + * The actual pcap handle is opened and direction set in eth_dev_start(). */ static inline int open_rx_iface(const char *key, const char *value, void *extra_args) { - int ret = open_iface(key, value, extra_args); - if (ret < 0) - return ret; - if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) { - struct pmd_devargs *pmd = extra_args; - unsigned int qid = pmd->num_of_queue - 1; - - set_iface_direction(pmd->queue[qid].name, - pmd->queue[qid].pcap, - PCAP_D_IN); - } - - return 0; + return open_iface(key, value, extra_args); } static inline int @@ -1373,6 +1364,29 @@ process_bool_flag(const char *key, const char *value, void *extra_args) return 0; } +static int +process_snapshot_len(const char *key, const char *value, void *extra_args) +{ + uint32_t *snaplen = extra_args; + unsigned long val; + char *endptr; + + if (value == NULL || *value == '\0') { + PMD_LOG(ERR, "Argument '%s' requires a value", key); + return -1; + } + + errno = 0; + val = strtoul(value, &endptr, 10); + if (errno != 0 || *endptr != '\0' || val == 0 || val > UINT32_MAX) { + PMD_LOG(ERR, "Invalid '%s' value '%s'", key, value); + return -1; + } + + *snaplen = (uint32_t)val; + return 0; +} + static int pmd_init_internals(struct rte_vdev_device *vdev, const unsigned int nb_rx_queues, @@ -1537,6 +1551,8 @@ eth_from_pcaps(struct rte_vdev_device *vdev, } internals->infinite_rx = infinite_rx; + internals->snapshot_len = devargs_all->snapshot_len; + /* Assign rx ops. */ if (infinite_rx) eth_dev->rx_pkt_burst = eth_pcap_rx_infinite; @@ -1597,6 +1613,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev) int ret = 0; struct pmd_devargs_all devargs_all = { + .snapshot_len = ETH_PCAP_SNAPSHOT_LEN_DEFAULT, .single_iface = 0, .is_tx_pcap = 0, .is_tx_iface = 0, @@ -1632,6 +1649,17 @@ pmd_pcap_probe(struct rte_vdev_device *dev) return -1; } + /* + * Process optional snapshot length argument. + */ + if (rte_kvargs_count(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG) == 1) { + ret = rte_kvargs_process(kvlist, ETH_PCAP_SNAPSHOT_LEN_ARG, + &process_snapshot_len, + &devargs_all.snapshot_len); + if (ret < 0) + goto free_kvlist; + } + /* * If iface argument is passed we open the NICs and use them for * reading / writing @@ -1837,5 +1865,6 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap, ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> " ETH_PCAP_TX_IFACE_ARG "=<ifc> " ETH_PCAP_IFACE_ARG "=<ifc> " - ETH_PCAP_PHY_MAC_ARG "=<int>" - ETH_PCAP_INFINITE_RX_ARG "=<0|1>"); + ETH_PCAP_PHY_MAC_ARG "=<int> " + ETH_PCAP_INFINITE_RX_ARG "=<0|1> " + ETH_PCAP_SNAPSHOT_LEN_ARG "=<int>"); -- 2.51.0
