X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fpcap%2Frte_eth_pcap.c;h=4e6d49370eb345e17e5e3cf9c26ce7f2cdff5c9f;hb=d23d73d088c1;hp=65bbd7e2f4a31c7b5faeba49bea84d2dd1352b5c;hpb=9b3d42207c35516b1c62fbdf19da288e5c3d8356;p=dpdk.git diff --git a/drivers/net/pcap/rte_eth_pcap.c b/drivers/net/pcap/rte_eth_pcap.c index 65bbd7e2f4..4e6d49370e 100644 --- a/drivers/net/pcap/rte_eth_pcap.c +++ b/drivers/net/pcap/rte_eth_pcap.c @@ -11,7 +11,7 @@ #include #include -#if defined(RTE_EXEC_ENV_BSDAPP) +#if defined(RTE_EXEC_ENV_FREEBSD) #include #include #endif @@ -28,7 +28,7 @@ #include #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535 -#define RTE_ETH_PCAP_SNAPLEN ETHER_MAX_JUMBO_FRAME_LEN +#define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN #define RTE_ETH_PCAP_PROMISC 1 #define RTE_ETH_PCAP_TIMEOUT -1 @@ -39,18 +39,21 @@ #define ETH_PCAP_TX_IFACE_ARG "tx_iface" #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_ARG_MAXLEN 64 #define RTE_PMD_PCAP_MAX_QUEUES 16 static char errbuf[PCAP_ERRBUF_SIZE]; -static unsigned char tx_pcap_data[RTE_ETH_PCAP_SNAPLEN]; static struct timeval start_time; static uint64_t start_cycles; static uint64_t hz; static uint8_t iface_idx; +static uint64_t timestamp_rx_dynflag; +static int timestamp_dynfield_offset = -1; + struct queue_stat { volatile unsigned long pkts; volatile unsigned long bytes; @@ -64,6 +67,9 @@ struct pcap_rx_queue { struct queue_stat rx_stat; char name[PATH_MAX]; char type[ETH_PCAP_ARG_MAXLEN]; + + /* Contains pre-generated packets to be looped through */ + struct rte_ring *pkts; }; struct pcap_tx_queue { @@ -78,10 +84,11 @@ 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]; char devargs[ETH_PCAP_ARG_MAXLEN]; - struct ether_addr eth_addr; + struct rte_ether_addr eth_addr; int if_index; int single_iface; int phy_mac; + unsigned int infinite_rx; }; struct pmd_process_private { @@ -101,6 +108,17 @@ struct pmd_devargs { int phy_mac; }; +struct pmd_devargs_all { + struct pmd_devargs rx_queues; + struct pmd_devargs tx_queues; + int single_iface; + unsigned int is_tx_pcap; + unsigned int is_tx_iface; + unsigned int is_rx_pcap; + unsigned int is_rx_iface; + unsigned int infinite_rx; +}; + static const char *valid_arguments[] = { ETH_PCAP_RX_PCAP_ARG, ETH_PCAP_TX_PCAP_ARG, @@ -109,6 +127,7 @@ static const char *valid_arguments[] = { ETH_PCAP_TX_IFACE_ARG, ETH_PCAP_IFACE_ARG, ETH_PCAP_PHY_MAC_ARG, + ETH_PCAP_INFINITE_RX_ARG, NULL }; @@ -119,7 +138,7 @@ static struct rte_eth_link pmd_link = { .link_autoneg = ETH_LINK_FIXED, }; -static int eth_pcap_logtype; +RTE_LOG_REGISTER(eth_pcap_logtype, pmd.net.pcap, NOTICE); #define PMD_LOG(level, fmt, args...) \ rte_log(RTE_LOG_ ## level, eth_pcap_logtype, \ @@ -163,19 +182,41 @@ eth_pcap_rx_jumbo(struct rte_mempool *mb_pool, struct rte_mbuf *mbuf, return mbuf->nb_segs; } -/* Copy data from mbuf chain to a buffer suitable for writing to a PCAP file. */ -static void -eth_pcap_gather_data(unsigned char *data, struct rte_mbuf *mbuf) +static uint16_t +eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) { - uint16_t data_len = 0; + int i; + struct pcap_rx_queue *pcap_q = queue; + uint32_t rx_bytes = 0; + + if (unlikely(nb_pkts == 0)) + return 0; - while (mbuf) { - rte_memcpy(data + data_len, rte_pktmbuf_mtod(mbuf, void *), - mbuf->data_len); + if (rte_pktmbuf_alloc_bulk(pcap_q->mb_pool, bufs, nb_pkts) != 0) + return 0; - data_len += mbuf->data_len; - mbuf = mbuf->next; + for (i = 0; i < nb_pkts; i++) { + struct rte_mbuf *pcap_buf; + int err = rte_ring_dequeue(pcap_q->pkts, (void **)&pcap_buf); + if (err) + return i; + + rte_memcpy(rte_pktmbuf_mtod(bufs[i], void *), + rte_pktmbuf_mtod(pcap_buf, void *), + pcap_buf->data_len); + bufs[i]->data_len = pcap_buf->data_len; + bufs[i]->pkt_len = pcap_buf->pkt_len; + bufs[i]->port = pcap_q->port_id; + rx_bytes += pcap_buf->data_len; + + /* Enqueue packet back on ring to allow infinite rx. */ + rte_ring_enqueue(pcap_q->pkts, pcap_buf); } + + pcap_q->rx_stat.pkts += i; + pcap_q->rx_stat.bytes += rx_bytes; + + return i; } static uint16_t @@ -188,7 +229,6 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) struct rte_mbuf *mbuf; struct pcap_rx_queue *pcap_q = queue; uint16_t num_rx = 0; - uint16_t buf_size; uint32_t rx_bytes = 0; pcap_t *pcap; @@ -211,11 +251,7 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) if (unlikely(mbuf == NULL)) break; - /* Now get the space available for data in the mbuf */ - buf_size = rte_pktmbuf_data_room_size(pcap_q->mb_pool) - - RTE_PKTMBUF_HEADROOM; - - if (header.caplen <= buf_size) { + if (header.caplen <= rte_pktmbuf_tailroom(mbuf)) { /* pcap packet will fit in the mbuf, can copy it */ rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packet, header.caplen); @@ -232,6 +268,11 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) } mbuf->pkt_len = (uint16_t)header.caplen; + *RTE_MBUF_DYNFIELD(mbuf, timestamp_dynfield_offset, + rte_mbuf_timestamp_t *) = + (uint64_t)header.ts.tv_sec * 1000000 + + header.ts.tv_usec; + mbuf->ol_flags |= timestamp_rx_dynflag; mbuf->port = pcap_q->port_id; bufs[num_rx] = mbuf; num_rx++; @@ -243,6 +284,16 @@ eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) return num_rx; } +static uint16_t +eth_null_rx(void *queue __rte_unused, + struct rte_mbuf **bufs __rte_unused, + uint16_t nb_pkts __rte_unused) +{ + return 0; +} + +#define NSEC_PER_SEC 1000000000L + static inline void calculate_timestamp(struct timeval *ts) { uint64_t cycles; @@ -250,8 +301,14 @@ calculate_timestamp(struct timeval *ts) { cycles = rte_get_timer_cycles() - start_cycles; cur_time.tv_sec = cycles / hz; - cur_time.tv_usec = (cycles % hz) * 1e6 / hz; - timeradd(&start_time, &cur_time, ts); + cur_time.tv_usec = (cycles % hz) * NSEC_PER_SEC / hz; + + ts->tv_sec = start_time.tv_sec + cur_time.tv_sec; + ts->tv_usec = start_time.tv_usec + cur_time.tv_usec; + if (ts->tv_usec >= NSEC_PER_SEC) { + ts->tv_usec -= NSEC_PER_SEC; + ts->tv_sec += 1; + } } /* @@ -268,6 +325,8 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) uint32_t tx_bytes = 0; struct pcap_pkthdr header; pcap_dumper_t *dumper; + unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN]; + size_t len, caplen; pp = rte_eth_devices[dumper_q->port_id].process_private; dumper = pp->tx_dumper[dumper_q->queue_id]; @@ -279,31 +338,24 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) * dumper */ for (i = 0; i < nb_pkts; i++) { mbuf = bufs[i]; - calculate_timestamp(&header.ts); - header.len = mbuf->pkt_len; - header.caplen = header.len; - - if (likely(mbuf->nb_segs == 1)) { - pcap_dump((u_char *)dumper, &header, - rte_pktmbuf_mtod(mbuf, void*)); - } else { - if (mbuf->pkt_len <= ETHER_MAX_JUMBO_FRAME_LEN) { - eth_pcap_gather_data(tx_pcap_data, mbuf); - pcap_dump((u_char *)dumper, &header, - tx_pcap_data); - } else { - PMD_LOG(ERR, - "Dropping PCAP packet. Size (%d) > max jumbo size (%d).", - mbuf->pkt_len, - ETHER_MAX_JUMBO_FRAME_LEN); - - rte_pktmbuf_free(mbuf); - break; - } + len = caplen = rte_pktmbuf_pkt_len(mbuf); + if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && + len > sizeof(temp_data))) { + caplen = sizeof(temp_data); } + calculate_timestamp(&header.ts); + header.len = len; + header.caplen = caplen; + /* rte_pktmbuf_read() returns a pointer to the data directly + * in the mbuf (when the mbuf is contiguous) or, otherwise, + * a pointer to temp_data after copying into it. + */ + pcap_dump((u_char *)dumper, &header, + rte_pktmbuf_read(mbuf, 0, caplen, temp_data)); + num_tx++; - tx_bytes += mbuf->pkt_len; + tx_bytes += caplen; rte_pktmbuf_free(mbuf); } @@ -317,7 +369,31 @@ eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) dumper_q->tx_stat.bytes += tx_bytes; dumper_q->tx_stat.err_pkts += nb_pkts - num_tx; - return num_tx; + return nb_pkts; +} + +/* + * Callback to handle dropping packets in the infinite rx case. + */ +static uint16_t +eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) +{ + unsigned int i; + uint32_t tx_bytes = 0; + struct pcap_tx_queue *tx_queue = queue; + + if (unlikely(nb_pkts == 0)) + return 0; + + for (i = 0; i < nb_pkts; i++) { + tx_bytes += bufs[i]->data_len; + rte_pktmbuf_free(bufs[i]); + } + + tx_queue->tx_stat.pkts += nb_pkts; + tx_queue->tx_stat.bytes += tx_bytes; + + return i; } /* @@ -334,6 +410,8 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) uint16_t num_tx = 0; uint32_t tx_bytes = 0; pcap_t *pcap; + unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN]; + size_t len; pp = rte_eth_devices[tx_queue->port_id].process_private; pcap = pp->tx_pcap[tx_queue->queue_id]; @@ -343,39 +421,34 @@ eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) for (i = 0; i < nb_pkts; i++) { mbuf = bufs[i]; - - if (likely(mbuf->nb_segs == 1)) { - ret = pcap_sendpacket(pcap, - 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(pcap, - tx_pcap_data, mbuf->pkt_len); - } else { - PMD_LOG(ERR, - "Dropping PCAP packet. Size (%d) > max jumbo size (%d).", - mbuf->pkt_len, - ETHER_MAX_JUMBO_FRAME_LEN); - - rte_pktmbuf_free(mbuf); - break; - } + len = rte_pktmbuf_pkt_len(mbuf); + if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) && + len > sizeof(temp_data))) { + PMD_LOG(ERR, + "Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).", + len, sizeof(temp_data)); + rte_pktmbuf_free(mbuf); + continue; } + /* rte_pktmbuf_read() returns a pointer to the data directly + * in the mbuf (when the mbuf is contiguous) or, otherwise, + * a pointer to temp_data after copying into it. + */ + ret = pcap_sendpacket(pcap, + rte_pktmbuf_read(mbuf, 0, len, temp_data), len); if (unlikely(ret != 0)) break; num_tx++; - tx_bytes += mbuf->pkt_len; + tx_bytes += len; rte_pktmbuf_free(mbuf); } tx_queue->tx_stat.pkts += num_tx; tx_queue->tx_stat.bytes += tx_bytes; - tx_queue->tx_stat.err_pkts += nb_pkts - num_tx; + tx_queue->tx_stat.err_pkts += i - num_tx; - return num_tx; + return i; } /* @@ -415,7 +488,8 @@ open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper) * with pcap_dump_open(). We create big enough an Ethernet * pcap holder. */ - tx_pcap = pcap_open_dead(DLT_EN10MB, RTE_ETH_PCAP_SNAPSHOT_LEN); + tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB, + RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO); if (tx_pcap == NULL) { PMD_LOG(ERR, "Couldn't create dead pcap"); return -1; @@ -447,6 +521,24 @@ open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap) return 0; } +static uint64_t +count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q) +{ + const u_char *packet; + struct pcap_pkthdr header; + uint64_t pcap_pkt_count = 0; + + while ((packet = pcap_next(*pcap, &header))) + pcap_pkt_count++; + + /* The pcap is reopened so it can be used as normal later. */ + pcap_close(*pcap); + *pcap = NULL; + open_single_rx_pcap(pcap_q->name, pcap); + + return pcap_pkt_count; +} + static int eth_dev_start(struct rte_eth_dev *dev) { @@ -520,7 +612,7 @@ status_up: * Is the only place for us to close all the tx streams dumpers. * If not called the dumpers will be flushed within each tx burst. */ -static void +static int eth_dev_stop(struct rte_eth_dev *dev) { unsigned int i; @@ -562,15 +654,26 @@ status_down: dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED; dev->data->dev_link.link_status = ETH_LINK_DOWN; + + return 0; } static int eth_dev_configure(struct rte_eth_dev *dev __rte_unused) { + int ret; + + ret = rte_mbuf_dyn_rx_timestamp_register(×tamp_dynfield_offset, + ×tamp_rx_dynflag); + if (ret != 0) { + PMD_LOG(ERR, "Failed to register Rx timestamp field/flag"); + return -rte_errno; + } + return 0; } -static void +static int eth_dev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) { @@ -582,6 +685,8 @@ eth_dev_info(struct rte_eth_dev *dev, 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; + + return 0; } static int @@ -605,10 +710,9 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) i < dev->data->nb_tx_queues; 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]; + tx_packets_err_total += internal->tx_queue[i].tx_stat.err_pkts; } stats->ipackets = rx_packets_total; @@ -620,7 +724,7 @@ eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) return 0; } -static void +static int eth_stats_reset(struct rte_eth_dev *dev) { unsigned int i; @@ -636,11 +740,50 @@ eth_stats_reset(struct rte_eth_dev *dev) internal->tx_queue[i].tx_stat.bytes = 0; internal->tx_queue[i].tx_stat.err_pkts = 0; } + + return 0; } -static void -eth_dev_close(struct rte_eth_dev *dev __rte_unused) +static int +eth_dev_close(struct rte_eth_dev *dev) { + unsigned int i; + struct pmd_internals *internals = dev->data->dev_private; + + PMD_LOG(INFO, "Closing pcap ethdev on NUMA socket %d", + rte_socket_id()); + + rte_free(dev->process_private); + + if (rte_eal_process_type() != RTE_PROC_PRIMARY) + return 0; + + /* Device wide flag, but cleanup must be performed per queue. */ + if (internals->infinite_rx) { + for (i = 0; i < dev->data->nb_rx_queues; i++) { + struct pcap_rx_queue *pcap_q = &internals->rx_queue[i]; + struct rte_mbuf *pcap_buf; + + /* + * 'pcap_q->pkts' can be NULL if 'eth_dev_close()' + * called before 'eth_rx_queue_setup()' has been called + */ + if (pcap_q->pkts == NULL) + continue; + + while (!rte_ring_dequeue(pcap_q->pkts, + (void **)&pcap_buf)) + rte_pktmbuf_free(pcap_buf); + + rte_ring_free(pcap_q->pkts); + } + } + + if (internals->phy_mac == 0) + /* not dynamically allocated, must not be freed */ + dev->data->mac_addrs = NULL; + + return 0; } static void @@ -671,6 +814,59 @@ eth_rx_queue_setup(struct rte_eth_dev *dev, pcap_q->queue_id = rx_queue_id; dev->data->rx_queues[rx_queue_id] = pcap_q; + if (internals->infinite_rx) { + struct pmd_process_private *pp; + char ring_name[NAME_MAX]; + static uint32_t ring_number; + uint64_t pcap_pkt_count = 0; + struct rte_mbuf *bufs[1]; + pcap_t **pcap; + + pp = rte_eth_devices[pcap_q->port_id].process_private; + pcap = &pp->rx_pcap[pcap_q->queue_id]; + + if (unlikely(*pcap == NULL)) + return -ENOENT; + + pcap_pkt_count = count_packets_in_pcap(pcap, pcap_q); + + snprintf(ring_name, sizeof(ring_name), "PCAP_RING%" PRIu16, + ring_number); + + pcap_q->pkts = rte_ring_create(ring_name, + rte_align64pow2(pcap_pkt_count + 1), 0, + RING_F_SP_ENQ | RING_F_SC_DEQ); + ring_number++; + if (!pcap_q->pkts) + return -ENOENT; + + /* Fill ring with packets from PCAP file one by one. */ + while (eth_pcap_rx(pcap_q, bufs, 1)) { + /* Check for multiseg mbufs. */ + if (bufs[0]->nb_segs != 1) { + rte_pktmbuf_free(*bufs); + + while (!rte_ring_dequeue(pcap_q->pkts, + (void **)bufs)) + rte_pktmbuf_free(*bufs); + + rte_ring_free(pcap_q->pkts); + PMD_LOG(ERR, "Multiseg mbufs are not supported in infinite_rx " + "mode."); + return -EINVAL; + } + + rte_ring_enqueue_bulk(pcap_q->pkts, + (void * const *)bufs, 1, NULL); + } + /* + * Reset the stats for this queue since eth_pcap_rx calls above + * didn't result in the application receiving packets. + */ + pcap_q->rx_stat.pkts = 0; + pcap_q->rx_stat.bytes = 0; + } + return 0; } @@ -908,7 +1104,19 @@ select_phy_mac(const char *key __rte_unused, const char *value, return 0; } -static struct rte_vdev_driver pmd_pcap_drv; +static int +get_infinite_rx_arg(const char *key __rte_unused, + const char *value, void *extra_args) +{ + if (extra_args) { + const int infinite_rx = atoi(value); + int *enable_infinite_rx = extra_args; + + if (infinite_rx > 0) + *enable_infinite_rx = 1; + } + return 0; +} static int pmd_init_internals(struct rte_vdev_device *vdev, @@ -953,7 +1161,7 @@ pmd_init_internals(struct rte_vdev_device *vdev, * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx' * where the middle 4 characters are converted to hex. */ - (*internals)->eth_addr = (struct ether_addr) { + (*internals)->eth_addr = (struct rte_ether_addr) { .addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ } }; (*internals)->phy_mac = 0; @@ -962,6 +1170,9 @@ pmd_init_internals(struct rte_vdev_device *vdev, data->nb_tx_queues = (uint16_t)nb_tx_queues; data->dev_link = pmd_link; data->mac_addrs = &(*internals)->eth_addr; + data->promiscuous = 1; + data->all_multicast = 1; + data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS; /* * NOTE: we'll replace the data element, of originally allocated @@ -979,7 +1190,7 @@ static int eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev, const unsigned int numa_node) { -#if defined(RTE_EXEC_ENV_LINUXAPP) +#if defined(RTE_EXEC_ENV_LINUX) void *mac_addrs; struct ifreq ifr; int if_fd = socket(AF_INET, SOCK_DGRAM, 0); @@ -993,7 +1204,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev, return -1; } - mac_addrs = rte_zmalloc_socket(NULL, ETHER_ADDR_LEN, 0, numa_node); + mac_addrs = rte_zmalloc_socket(NULL, RTE_ETHER_ADDR_LEN, 0, numa_node); if (!mac_addrs) { close(if_fd); return -1; @@ -1002,13 +1213,13 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev, PMD_LOG(INFO, "Setting phy MAC for %s", if_name); eth_dev->data->mac_addrs = mac_addrs; rte_memcpy(eth_dev->data->mac_addrs[0].addr_bytes, - ifr.ifr_hwaddr.sa_data, ETHER_ADDR_LEN); + ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN); close(if_fd); return 0; -#elif defined(RTE_EXEC_ENV_BSDAPP) +#elif defined(RTE_EXEC_ENV_FREEBSD) void *mac_addrs; struct if_msghdr *ifm; struct sockaddr_dl *sdl; @@ -1040,7 +1251,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev, ifm = (struct if_msghdr *)buf; sdl = (struct sockaddr_dl *)(ifm + 1); - mac_addrs = rte_zmalloc_socket(NULL, ETHER_ADDR_LEN, 0, numa_node); + mac_addrs = rte_zmalloc_socket(NULL, RTE_ETHER_ADDR_LEN, 0, numa_node); if (!mac_addrs) { rte_free(buf); return -1; @@ -1049,7 +1260,7 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev, PMD_LOG(INFO, "Setting phy MAC for %s", if_name); eth_dev->data->mac_addrs = mac_addrs; rte_memcpy(eth_dev->data->mac_addrs[0].addr_bytes, - LLADDR(sdl), ETHER_ADDR_LEN); + LLADDR(sdl), RTE_ETHER_ADDR_LEN); rte_free(buf); @@ -1061,19 +1272,16 @@ eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev, static int eth_from_pcaps_common(struct rte_vdev_device *vdev, - struct pmd_devargs *rx_queues, const unsigned int nb_rx_queues, - struct pmd_devargs *tx_queues, const unsigned int nb_tx_queues, + struct pmd_devargs_all *devargs_all, struct pmd_internals **internals, struct rte_eth_dev **eth_dev) { struct pmd_process_private *pp; + struct pmd_devargs *rx_queues = &devargs_all->rx_queues; + struct pmd_devargs *tx_queues = &devargs_all->tx_queues; + const unsigned int nb_rx_queues = rx_queues->num_of_queue; + const unsigned int nb_tx_queues = tx_queues->num_of_queue; unsigned int i; - /* do some parameter checking */ - if (rx_queues == NULL && nb_rx_queues > 0) - return -1; - if (tx_queues == NULL && nb_tx_queues > 0) - return -1; - if (pmd_init_internals(vdev, nb_rx_queues, nb_tx_queues, internals, eth_dev) < 0) return -1; @@ -1084,8 +1292,8 @@ eth_from_pcaps_common(struct rte_vdev_device *vdev, struct devargs_queue *queue = &rx_queues->queue[i]; pp->rx_pcap[i] = queue->pcap; - snprintf(rx->name, sizeof(rx->name), "%s", queue->name); - snprintf(rx->type, sizeof(rx->type), "%s", queue->type); + strlcpy(rx->name, queue->name, sizeof(rx->name)); + strlcpy(rx->type, queue->type, sizeof(rx->type)); } for (i = 0; i < nb_tx_queues; i++) { @@ -1094,8 +1302,8 @@ eth_from_pcaps_common(struct rte_vdev_device *vdev, pp->tx_dumper[i] = queue->dumper; pp->tx_pcap[i] = queue->pcap; - snprintf(tx->name, sizeof(tx->name), "%s", queue->name); - snprintf(tx->type, sizeof(tx->type), "%s", queue->type); + strlcpy(tx->name, queue->name, sizeof(tx->name)); + strlcpy(tx->type, queue->type, sizeof(tx->type)); } return 0; @@ -1103,16 +1311,16 @@ eth_from_pcaps_common(struct rte_vdev_device *vdev, static int eth_from_pcaps(struct rte_vdev_device *vdev, - struct pmd_devargs *rx_queues, const unsigned int nb_rx_queues, - struct pmd_devargs *tx_queues, const unsigned int nb_tx_queues, - int single_iface, unsigned int using_dumpers) + struct pmd_devargs_all *devargs_all) { struct pmd_internals *internals = NULL; struct rte_eth_dev *eth_dev = NULL; + struct pmd_devargs *rx_queues = &devargs_all->rx_queues; + int single_iface = devargs_all->single_iface; + unsigned int infinite_rx = devargs_all->infinite_rx; int ret; - ret = eth_from_pcaps_common(vdev, rx_queues, nb_rx_queues, - tx_queues, nb_tx_queues, &internals, ð_dev); + ret = eth_from_pcaps_common(vdev, devargs_all, &internals, ð_dev); if (ret < 0) return ret; @@ -1132,12 +1340,23 @@ eth_from_pcaps(struct rte_vdev_device *vdev, } } - eth_dev->rx_pkt_burst = eth_pcap_rx; + internals->infinite_rx = infinite_rx; + /* Assign rx ops. */ + if (infinite_rx) + eth_dev->rx_pkt_burst = eth_pcap_rx_infinite; + else if (devargs_all->is_rx_pcap || devargs_all->is_rx_iface || + single_iface) + eth_dev->rx_pkt_burst = eth_pcap_rx; + else + eth_dev->rx_pkt_burst = eth_null_rx; - if (using_dumpers) + /* Assign tx ops. */ + if (devargs_all->is_tx_pcap) eth_dev->tx_pkt_burst = eth_pcap_tx_dumper; - else + else if (devargs_all->is_tx_iface || single_iface) eth_dev->tx_pkt_burst = eth_pcap_tx; + else + eth_dev->tx_pkt_burst = eth_tx_drop; rte_eth_dev_probing_finish(eth_dev); return 0; @@ -1147,14 +1366,19 @@ static int pmd_pcap_probe(struct rte_vdev_device *dev) { const char *name; - unsigned int is_rx_pcap = 0, is_tx_pcap = 0; struct rte_kvargs *kvlist; struct pmd_devargs pcaps = {0}; struct pmd_devargs dumpers = {0}; struct rte_eth_dev *eth_dev = NULL; struct pmd_internals *internal; - int single_iface = 0; - int ret; + int ret = 0; + + struct pmd_devargs_all devargs_all = { + .single_iface = 0, + .is_tx_pcap = 0, + .is_tx_iface = 0, + .infinite_rx = 0, + }; name = rte_vdev_device_name(dev); PMD_LOG(INFO, "Initializing pmd_pcap for %s", name); @@ -1202,7 +1426,7 @@ pmd_pcap_probe(struct rte_vdev_device *dev) dumpers.phy_mac = pcaps.phy_mac; - single_iface = 1; + devargs_all.single_iface = 1; pcaps.num_of_queue = 1; dumpers.num_of_queue = 1; @@ -1210,36 +1434,94 @@ pmd_pcap_probe(struct rte_vdev_device *dev) } /* - * We check whether we want to open a RX stream from a real NIC or a - * pcap file + * We check whether we want to open a RX stream from a real NIC, a + * pcap file or open a dummy RX stream */ - is_rx_pcap = rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG) ? 1 : 0; + devargs_all.is_rx_pcap = + rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG) ? 1 : 0; + devargs_all.is_rx_iface = + (rte_kvargs_count(kvlist, ETH_PCAP_RX_IFACE_ARG) + + rte_kvargs_count(kvlist, ETH_PCAP_RX_IFACE_IN_ARG)) ? 1 : 0; pcaps.num_of_queue = 0; - if (is_rx_pcap) { + devargs_all.is_tx_pcap = + rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG) ? 1 : 0; + devargs_all.is_tx_iface = + rte_kvargs_count(kvlist, ETH_PCAP_TX_IFACE_ARG) ? 1 : 0; + dumpers.num_of_queue = 0; + + if (devargs_all.is_rx_pcap) { + /* + * We check whether we want to infinitely rx the pcap file. + */ + unsigned int infinite_rx_arg_cnt = rte_kvargs_count(kvlist, + ETH_PCAP_INFINITE_RX_ARG); + + if (infinite_rx_arg_cnt == 1) { + ret = rte_kvargs_process(kvlist, + ETH_PCAP_INFINITE_RX_ARG, + &get_infinite_rx_arg, + &devargs_all.infinite_rx); + if (ret < 0) + goto free_kvlist; + PMD_LOG(INFO, "infinite_rx has been %s for %s", + devargs_all.infinite_rx ? "enabled" : "disabled", + name); + + } else if (infinite_rx_arg_cnt > 1) { + PMD_LOG(WARNING, "infinite_rx has not been enabled since the " + "argument has been provided more than once " + "for %s", name); + } + ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG, &open_rx_pcap, &pcaps); - } else { + } else if (devargs_all.is_rx_iface) { ret = rte_kvargs_process(kvlist, NULL, &rx_iface_args_process, &pcaps); - } + } else if (devargs_all.is_tx_iface || devargs_all.is_tx_pcap) { + unsigned int i; + + /* Count number of tx queue args passed before dummy rx queue + * creation so a dummy rx queue can be created for each tx queue + */ + unsigned int num_tx_queues = + (rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG) + + rte_kvargs_count(kvlist, ETH_PCAP_TX_IFACE_ARG)); + PMD_LOG(INFO, "Creating null rx queue since no rx queues were provided."); + + /* Creating a dummy rx queue for each tx queue passed */ + for (i = 0; i < num_tx_queues; i++) + ret = add_queue(&pcaps, "dummy_rx", "rx_null", NULL, + NULL); + } else { + PMD_LOG(ERR, "Error - No rx or tx queues provided"); + ret = -ENOENT; + } if (ret < 0) goto free_kvlist; /* - * We check whether we want to open a TX stream to a real NIC or a - * pcap file + * We check whether we want to open a TX stream to a real NIC, + * a pcap file, or drop packets on tx */ - is_tx_pcap = rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG) ? 1 : 0; - dumpers.num_of_queue = 0; - - if (is_tx_pcap) + if (devargs_all.is_tx_pcap) { ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_PCAP_ARG, &open_tx_pcap, &dumpers); - else + } else if (devargs_all.is_tx_iface) { ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_IFACE_ARG, &open_tx_iface, &dumpers); + } else { + unsigned int i; + + PMD_LOG(INFO, "Dropping packets on tx since no tx queues were provided."); + + /* Add 1 dummy queue per rxq which counts and drops packets. */ + for (i = 0; i < pcaps.num_of_queue; i++) + ret = add_queue(&dumpers, "dummy_tx", "tx_drop", NULL, + NULL); + } if (ret < 0) goto free_kvlist; @@ -1276,7 +1558,7 @@ create_eth: eth_dev->process_private = pp; eth_dev->rx_pkt_burst = eth_pcap_rx; - if (is_tx_pcap) + if (devargs_all.is_tx_pcap) eth_dev->tx_pkt_burst = eth_pcap_tx_dumper; else eth_dev->tx_pkt_burst = eth_pcap_tx; @@ -1285,8 +1567,10 @@ create_eth: goto free_kvlist; } - ret = eth_from_pcaps(dev, &pcaps, pcaps.num_of_queue, &dumpers, - dumpers.num_of_queue, single_iface, is_tx_pcap); + devargs_all.rx_queues = pcaps; + devargs_all.tx_queues = dumpers; + + ret = eth_from_pcaps(dev, &devargs_all); free_kvlist: rte_kvargs_free(kvlist); @@ -1297,28 +1581,16 @@ free_kvlist: static int pmd_pcap_remove(struct rte_vdev_device *dev) { - struct pmd_internals *internals = NULL; struct rte_eth_dev *eth_dev = NULL; - PMD_LOG(INFO, "Closing pcap ethdev on numa socket %d", - rte_socket_id()); - if (!dev) return -1; - /* reserve an ethdev entry */ eth_dev = rte_eth_dev_allocated(rte_vdev_device_name(dev)); if (eth_dev == NULL) - return -1; + return 0; /* port already released */ - if (rte_eal_process_type() == RTE_PROC_PRIMARY) { - internals = eth_dev->data->dev_private; - if (internals != NULL && internals->phy_mac == 0) - /* not dynamically allocated, must not be freed */ - eth_dev->data->mac_addrs = NULL; - } - - rte_free(eth_dev->process_private); + eth_dev_close(eth_dev); rte_eth_dev_release_port(eth_dev); return 0; @@ -1338,11 +1610,5 @@ RTE_PMD_REGISTER_PARAM_STRING(net_pcap, ETH_PCAP_RX_IFACE_IN_ARG "= " ETH_PCAP_TX_IFACE_ARG "= " ETH_PCAP_IFACE_ARG "= " - ETH_PCAP_PHY_MAC_ARG "="); - -RTE_INIT(eth_pcap_init_log) -{ - eth_pcap_logtype = rte_log_register("pmd.net.pcap"); - if (eth_pcap_logtype >= 0) - rte_log_set_level(eth_pcap_logtype, RTE_LOG_NOTICE); -} + ETH_PCAP_PHY_MAC_ARG "=" + ETH_PCAP_INFINITE_RX_ARG "=<0|1>");