ethdev: allow drivers to return error on close
[dpdk.git] / drivers / net / pcap / rte_eth_pcap.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2016 Intel Corporation.
3  * Copyright(c) 2014 6WIND S.A.
4  * All rights reserved.
5  */
6
7 #include <time.h>
8
9 #include <net/if.h>
10 #include <sys/socket.h>
11 #include <sys/ioctl.h>
12 #include <unistd.h>
13
14 #if defined(RTE_EXEC_ENV_FREEBSD)
15 #include <sys/sysctl.h>
16 #include <net/if_dl.h>
17 #endif
18
19 #include <pcap.h>
20
21 #include <rte_cycles.h>
22 #include <rte_ethdev_driver.h>
23 #include <rte_ethdev_vdev.h>
24 #include <rte_kvargs.h>
25 #include <rte_malloc.h>
26 #include <rte_mbuf.h>
27 #include <rte_bus_vdev.h>
28 #include <rte_string_fns.h>
29
30 #define RTE_ETH_PCAP_SNAPSHOT_LEN 65535
31 #define RTE_ETH_PCAP_SNAPLEN RTE_ETHER_MAX_JUMBO_FRAME_LEN
32 #define RTE_ETH_PCAP_PROMISC 1
33 #define RTE_ETH_PCAP_TIMEOUT -1
34
35 #define ETH_PCAP_RX_PCAP_ARG  "rx_pcap"
36 #define ETH_PCAP_TX_PCAP_ARG  "tx_pcap"
37 #define ETH_PCAP_RX_IFACE_ARG "rx_iface"
38 #define ETH_PCAP_RX_IFACE_IN_ARG "rx_iface_in"
39 #define ETH_PCAP_TX_IFACE_ARG "tx_iface"
40 #define ETH_PCAP_IFACE_ARG    "iface"
41 #define ETH_PCAP_PHY_MAC_ARG  "phy_mac"
42 #define ETH_PCAP_INFINITE_RX_ARG  "infinite_rx"
43
44 #define ETH_PCAP_ARG_MAXLEN     64
45
46 #define RTE_PMD_PCAP_MAX_QUEUES 16
47
48 static char errbuf[PCAP_ERRBUF_SIZE];
49 static struct timeval start_time;
50 static uint64_t start_cycles;
51 static uint64_t hz;
52 static uint8_t iface_idx;
53
54 struct queue_stat {
55         volatile unsigned long pkts;
56         volatile unsigned long bytes;
57         volatile unsigned long err_pkts;
58 };
59
60 struct pcap_rx_queue {
61         uint16_t port_id;
62         uint16_t queue_id;
63         struct rte_mempool *mb_pool;
64         struct queue_stat rx_stat;
65         char name[PATH_MAX];
66         char type[ETH_PCAP_ARG_MAXLEN];
67
68         /* Contains pre-generated packets to be looped through */
69         struct rte_ring *pkts;
70 };
71
72 struct pcap_tx_queue {
73         uint16_t port_id;
74         uint16_t queue_id;
75         struct queue_stat tx_stat;
76         char name[PATH_MAX];
77         char type[ETH_PCAP_ARG_MAXLEN];
78 };
79
80 struct pmd_internals {
81         struct pcap_rx_queue rx_queue[RTE_PMD_PCAP_MAX_QUEUES];
82         struct pcap_tx_queue tx_queue[RTE_PMD_PCAP_MAX_QUEUES];
83         char devargs[ETH_PCAP_ARG_MAXLEN];
84         struct rte_ether_addr eth_addr;
85         int if_index;
86         int single_iface;
87         int phy_mac;
88         unsigned int infinite_rx;
89 };
90
91 struct pmd_process_private {
92         pcap_t *rx_pcap[RTE_PMD_PCAP_MAX_QUEUES];
93         pcap_t *tx_pcap[RTE_PMD_PCAP_MAX_QUEUES];
94         pcap_dumper_t *tx_dumper[RTE_PMD_PCAP_MAX_QUEUES];
95 };
96
97 struct pmd_devargs {
98         unsigned int num_of_queue;
99         struct devargs_queue {
100                 pcap_dumper_t *dumper;
101                 pcap_t *pcap;
102                 const char *name;
103                 const char *type;
104         } queue[RTE_PMD_PCAP_MAX_QUEUES];
105         int phy_mac;
106 };
107
108 struct pmd_devargs_all {
109         struct pmd_devargs rx_queues;
110         struct pmd_devargs tx_queues;
111         int single_iface;
112         unsigned int is_tx_pcap;
113         unsigned int is_tx_iface;
114         unsigned int is_rx_pcap;
115         unsigned int is_rx_iface;
116         unsigned int infinite_rx;
117 };
118
119 static const char *valid_arguments[] = {
120         ETH_PCAP_RX_PCAP_ARG,
121         ETH_PCAP_TX_PCAP_ARG,
122         ETH_PCAP_RX_IFACE_ARG,
123         ETH_PCAP_RX_IFACE_IN_ARG,
124         ETH_PCAP_TX_IFACE_ARG,
125         ETH_PCAP_IFACE_ARG,
126         ETH_PCAP_PHY_MAC_ARG,
127         ETH_PCAP_INFINITE_RX_ARG,
128         NULL
129 };
130
131 static struct rte_eth_link pmd_link = {
132                 .link_speed = ETH_SPEED_NUM_10G,
133                 .link_duplex = ETH_LINK_FULL_DUPLEX,
134                 .link_status = ETH_LINK_DOWN,
135                 .link_autoneg = ETH_LINK_FIXED,
136 };
137
138 RTE_LOG_REGISTER(eth_pcap_logtype, pmd.net.pcap, NOTICE);
139
140 #define PMD_LOG(level, fmt, args...) \
141         rte_log(RTE_LOG_ ## level, eth_pcap_logtype, \
142                 "%s(): " fmt "\n", __func__, ##args)
143
144 static int
145 eth_pcap_rx_jumbo(struct rte_mempool *mb_pool, struct rte_mbuf *mbuf,
146                 const u_char *data, uint16_t data_len)
147 {
148         /* Copy the first segment. */
149         uint16_t len = rte_pktmbuf_tailroom(mbuf);
150         struct rte_mbuf *m = mbuf;
151
152         rte_memcpy(rte_pktmbuf_append(mbuf, len), data, len);
153         data_len -= len;
154         data += len;
155
156         while (data_len > 0) {
157                 /* Allocate next mbuf and point to that. */
158                 m->next = rte_pktmbuf_alloc(mb_pool);
159
160                 if (unlikely(!m->next))
161                         return -1;
162
163                 m = m->next;
164
165                 /* Headroom is not needed in chained mbufs. */
166                 rte_pktmbuf_prepend(m, rte_pktmbuf_headroom(m));
167                 m->pkt_len = 0;
168                 m->data_len = 0;
169
170                 /* Copy next segment. */
171                 len = RTE_MIN(rte_pktmbuf_tailroom(m), data_len);
172                 rte_memcpy(rte_pktmbuf_append(m, len), data, len);
173
174                 mbuf->nb_segs++;
175                 data_len -= len;
176                 data += len;
177         }
178
179         return mbuf->nb_segs;
180 }
181
182 static uint16_t
183 eth_pcap_rx_infinite(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
184 {
185         int i;
186         struct pcap_rx_queue *pcap_q = queue;
187         uint32_t rx_bytes = 0;
188
189         if (unlikely(nb_pkts == 0))
190                 return 0;
191
192         if (rte_pktmbuf_alloc_bulk(pcap_q->mb_pool, bufs, nb_pkts) != 0)
193                 return 0;
194
195         for (i = 0; i < nb_pkts; i++) {
196                 struct rte_mbuf *pcap_buf;
197                 int err = rte_ring_dequeue(pcap_q->pkts, (void **)&pcap_buf);
198                 if (err)
199                         return i;
200
201                 rte_memcpy(rte_pktmbuf_mtod(bufs[i], void *),
202                                 rte_pktmbuf_mtod(pcap_buf, void *),
203                                 pcap_buf->data_len);
204                 bufs[i]->data_len = pcap_buf->data_len;
205                 bufs[i]->pkt_len = pcap_buf->pkt_len;
206                 bufs[i]->port = pcap_q->port_id;
207                 rx_bytes += pcap_buf->data_len;
208
209                 /* Enqueue packet back on ring to allow infinite rx. */
210                 rte_ring_enqueue(pcap_q->pkts, pcap_buf);
211         }
212
213         pcap_q->rx_stat.pkts += i;
214         pcap_q->rx_stat.bytes += rx_bytes;
215
216         return i;
217 }
218
219 static uint16_t
220 eth_pcap_rx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
221 {
222         unsigned int i;
223         struct pcap_pkthdr header;
224         struct pmd_process_private *pp;
225         const u_char *packet;
226         struct rte_mbuf *mbuf;
227         struct pcap_rx_queue *pcap_q = queue;
228         uint16_t num_rx = 0;
229         uint32_t rx_bytes = 0;
230         pcap_t *pcap;
231
232         pp = rte_eth_devices[pcap_q->port_id].process_private;
233         pcap = pp->rx_pcap[pcap_q->queue_id];
234
235         if (unlikely(pcap == NULL || nb_pkts == 0))
236                 return 0;
237
238         /* Reads the given number of packets from the pcap file one by one
239          * and copies the packet data into a newly allocated mbuf to return.
240          */
241         for (i = 0; i < nb_pkts; i++) {
242                 /* Get the next PCAP packet */
243                 packet = pcap_next(pcap, &header);
244                 if (unlikely(packet == NULL))
245                         break;
246
247                 mbuf = rte_pktmbuf_alloc(pcap_q->mb_pool);
248                 if (unlikely(mbuf == NULL))
249                         break;
250
251                 if (header.caplen <= rte_pktmbuf_tailroom(mbuf)) {
252                         /* pcap packet will fit in the mbuf, can copy it */
253                         rte_memcpy(rte_pktmbuf_mtod(mbuf, void *), packet,
254                                         header.caplen);
255                         mbuf->data_len = (uint16_t)header.caplen;
256                 } else {
257                         /* Try read jumbo frame into multi mbufs. */
258                         if (unlikely(eth_pcap_rx_jumbo(pcap_q->mb_pool,
259                                                        mbuf,
260                                                        packet,
261                                                        header.caplen) == -1)) {
262                                 rte_pktmbuf_free(mbuf);
263                                 break;
264                         }
265                 }
266
267                 mbuf->pkt_len = (uint16_t)header.caplen;
268                 mbuf->timestamp = (uint64_t)header.ts.tv_sec * 1000000
269                                                         + header.ts.tv_usec;
270                 mbuf->ol_flags |= PKT_RX_TIMESTAMP;
271                 mbuf->port = pcap_q->port_id;
272                 bufs[num_rx] = mbuf;
273                 num_rx++;
274                 rx_bytes += header.caplen;
275         }
276         pcap_q->rx_stat.pkts += num_rx;
277         pcap_q->rx_stat.bytes += rx_bytes;
278
279         return num_rx;
280 }
281
282 static uint16_t
283 eth_null_rx(void *queue __rte_unused,
284                 struct rte_mbuf **bufs __rte_unused,
285                 uint16_t nb_pkts __rte_unused)
286 {
287         return 0;
288 }
289
290 #define NSEC_PER_SEC    1000000000L
291
292 static inline void
293 calculate_timestamp(struct timeval *ts) {
294         uint64_t cycles;
295         struct timeval cur_time;
296
297         cycles = rte_get_timer_cycles() - start_cycles;
298         cur_time.tv_sec = cycles / hz;
299         cur_time.tv_usec = (cycles % hz) * NSEC_PER_SEC / hz;
300
301         ts->tv_sec = start_time.tv_sec + cur_time.tv_sec;
302         ts->tv_usec = start_time.tv_usec + cur_time.tv_usec;
303         if (ts->tv_usec >= NSEC_PER_SEC) {
304                 ts->tv_usec -= NSEC_PER_SEC;
305                 ts->tv_sec += 1;
306         }
307 }
308
309 /*
310  * Callback to handle writing packets to a pcap file.
311  */
312 static uint16_t
313 eth_pcap_tx_dumper(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
314 {
315         unsigned int i;
316         struct rte_mbuf *mbuf;
317         struct pmd_process_private *pp;
318         struct pcap_tx_queue *dumper_q = queue;
319         uint16_t num_tx = 0;
320         uint32_t tx_bytes = 0;
321         struct pcap_pkthdr header;
322         pcap_dumper_t *dumper;
323         unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
324         size_t len, caplen;
325
326         pp = rte_eth_devices[dumper_q->port_id].process_private;
327         dumper = pp->tx_dumper[dumper_q->queue_id];
328
329         if (dumper == NULL || nb_pkts == 0)
330                 return 0;
331
332         /* writes the nb_pkts packets to the previously opened pcap file
333          * dumper */
334         for (i = 0; i < nb_pkts; i++) {
335                 mbuf = bufs[i];
336                 len = caplen = rte_pktmbuf_pkt_len(mbuf);
337                 if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
338                                 len > sizeof(temp_data))) {
339                         caplen = sizeof(temp_data);
340                 }
341
342                 calculate_timestamp(&header.ts);
343                 header.len = len;
344                 header.caplen = caplen;
345                 /* rte_pktmbuf_read() returns a pointer to the data directly
346                  * in the mbuf (when the mbuf is contiguous) or, otherwise,
347                  * a pointer to temp_data after copying into it.
348                  */
349                 pcap_dump((u_char *)dumper, &header,
350                         rte_pktmbuf_read(mbuf, 0, caplen, temp_data));
351
352                 num_tx++;
353                 tx_bytes += caplen;
354                 rte_pktmbuf_free(mbuf);
355         }
356
357         /*
358          * Since there's no place to hook a callback when the forwarding
359          * process stops and to make sure the pcap file is actually written,
360          * we flush the pcap dumper within each burst.
361          */
362         pcap_dump_flush(dumper);
363         dumper_q->tx_stat.pkts += num_tx;
364         dumper_q->tx_stat.bytes += tx_bytes;
365         dumper_q->tx_stat.err_pkts += nb_pkts - num_tx;
366
367         return nb_pkts;
368 }
369
370 /*
371  * Callback to handle dropping packets in the infinite rx case.
372  */
373 static uint16_t
374 eth_tx_drop(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
375 {
376         unsigned int i;
377         uint32_t tx_bytes = 0;
378         struct pcap_tx_queue *tx_queue = queue;
379
380         if (unlikely(nb_pkts == 0))
381                 return 0;
382
383         for (i = 0; i < nb_pkts; i++) {
384                 tx_bytes += bufs[i]->data_len;
385                 rte_pktmbuf_free(bufs[i]);
386         }
387
388         tx_queue->tx_stat.pkts += nb_pkts;
389         tx_queue->tx_stat.bytes += tx_bytes;
390
391         return i;
392 }
393
394 /*
395  * Callback to handle sending packets through a real NIC.
396  */
397 static uint16_t
398 eth_pcap_tx(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
399 {
400         unsigned int i;
401         int ret;
402         struct rte_mbuf *mbuf;
403         struct pmd_process_private *pp;
404         struct pcap_tx_queue *tx_queue = queue;
405         uint16_t num_tx = 0;
406         uint32_t tx_bytes = 0;
407         pcap_t *pcap;
408         unsigned char temp_data[RTE_ETH_PCAP_SNAPLEN];
409         size_t len;
410
411         pp = rte_eth_devices[tx_queue->port_id].process_private;
412         pcap = pp->tx_pcap[tx_queue->queue_id];
413
414         if (unlikely(nb_pkts == 0 || pcap == NULL))
415                 return 0;
416
417         for (i = 0; i < nb_pkts; i++) {
418                 mbuf = bufs[i];
419                 len = rte_pktmbuf_pkt_len(mbuf);
420                 if (unlikely(!rte_pktmbuf_is_contiguous(mbuf) &&
421                                 len > sizeof(temp_data))) {
422                         PMD_LOG(ERR,
423                                 "Dropping multi segment PCAP packet. Size (%zd) > max size (%zd).",
424                                 len, sizeof(temp_data));
425                         rte_pktmbuf_free(mbuf);
426                         continue;
427                 }
428
429                 /* rte_pktmbuf_read() returns a pointer to the data directly
430                  * in the mbuf (when the mbuf is contiguous) or, otherwise,
431                  * a pointer to temp_data after copying into it.
432                  */
433                 ret = pcap_sendpacket(pcap,
434                         rte_pktmbuf_read(mbuf, 0, len, temp_data), len);
435                 if (unlikely(ret != 0))
436                         break;
437                 num_tx++;
438                 tx_bytes += len;
439                 rte_pktmbuf_free(mbuf);
440         }
441
442         tx_queue->tx_stat.pkts += num_tx;
443         tx_queue->tx_stat.bytes += tx_bytes;
444         tx_queue->tx_stat.err_pkts += i - num_tx;
445
446         return i;
447 }
448
449 /*
450  * pcap_open_live wrapper function
451  */
452 static inline int
453 open_iface_live(const char *iface, pcap_t **pcap) {
454         *pcap = pcap_open_live(iface, RTE_ETH_PCAP_SNAPLEN,
455                         RTE_ETH_PCAP_PROMISC, RTE_ETH_PCAP_TIMEOUT, errbuf);
456
457         if (*pcap == NULL) {
458                 PMD_LOG(ERR, "Couldn't open %s: %s", iface, errbuf);
459                 return -1;
460         }
461
462         return 0;
463 }
464
465 static int
466 open_single_iface(const char *iface, pcap_t **pcap)
467 {
468         if (open_iface_live(iface, pcap) < 0) {
469                 PMD_LOG(ERR, "Couldn't open interface %s", iface);
470                 return -1;
471         }
472
473         return 0;
474 }
475
476 static int
477 open_single_tx_pcap(const char *pcap_filename, pcap_dumper_t **dumper)
478 {
479         pcap_t *tx_pcap;
480
481         /*
482          * We need to create a dummy empty pcap_t to use it
483          * with pcap_dump_open(). We create big enough an Ethernet
484          * pcap holder.
485          */
486         tx_pcap = pcap_open_dead_with_tstamp_precision(DLT_EN10MB,
487                         RTE_ETH_PCAP_SNAPSHOT_LEN, PCAP_TSTAMP_PRECISION_NANO);
488         if (tx_pcap == NULL) {
489                 PMD_LOG(ERR, "Couldn't create dead pcap");
490                 return -1;
491         }
492
493         /* The dumper is created using the previous pcap_t reference */
494         *dumper = pcap_dump_open(tx_pcap, pcap_filename);
495         if (*dumper == NULL) {
496                 pcap_close(tx_pcap);
497                 PMD_LOG(ERR, "Couldn't open %s for writing.",
498                         pcap_filename);
499                 return -1;
500         }
501
502         pcap_close(tx_pcap);
503         return 0;
504 }
505
506 static int
507 open_single_rx_pcap(const char *pcap_filename, pcap_t **pcap)
508 {
509         *pcap = pcap_open_offline(pcap_filename, errbuf);
510         if (*pcap == NULL) {
511                 PMD_LOG(ERR, "Couldn't open %s: %s", pcap_filename,
512                         errbuf);
513                 return -1;
514         }
515
516         return 0;
517 }
518
519 static uint64_t
520 count_packets_in_pcap(pcap_t **pcap, struct pcap_rx_queue *pcap_q)
521 {
522         const u_char *packet;
523         struct pcap_pkthdr header;
524         uint64_t pcap_pkt_count = 0;
525
526         while ((packet = pcap_next(*pcap, &header)))
527                 pcap_pkt_count++;
528
529         /* The pcap is reopened so it can be used as normal later. */
530         pcap_close(*pcap);
531         *pcap = NULL;
532         open_single_rx_pcap(pcap_q->name, pcap);
533
534         return pcap_pkt_count;
535 }
536
537 static int
538 eth_dev_start(struct rte_eth_dev *dev)
539 {
540         unsigned int i;
541         struct pmd_internals *internals = dev->data->dev_private;
542         struct pmd_process_private *pp = dev->process_private;
543         struct pcap_tx_queue *tx;
544         struct pcap_rx_queue *rx;
545
546         /* Special iface case. Single pcap is open and shared between tx/rx. */
547         if (internals->single_iface) {
548                 tx = &internals->tx_queue[0];
549                 rx = &internals->rx_queue[0];
550
551                 if (!pp->tx_pcap[0] &&
552                         strcmp(tx->type, ETH_PCAP_IFACE_ARG) == 0) {
553                         if (open_single_iface(tx->name, &pp->tx_pcap[0]) < 0)
554                                 return -1;
555                         pp->rx_pcap[0] = pp->tx_pcap[0];
556                 }
557
558                 goto status_up;
559         }
560
561         /* If not open already, open tx pcaps/dumpers */
562         for (i = 0; i < dev->data->nb_tx_queues; i++) {
563                 tx = &internals->tx_queue[i];
564
565                 if (!pp->tx_dumper[i] &&
566                                 strcmp(tx->type, ETH_PCAP_TX_PCAP_ARG) == 0) {
567                         if (open_single_tx_pcap(tx->name,
568                                 &pp->tx_dumper[i]) < 0)
569                                 return -1;
570                 } else if (!pp->tx_pcap[i] &&
571                                 strcmp(tx->type, ETH_PCAP_TX_IFACE_ARG) == 0) {
572                         if (open_single_iface(tx->name, &pp->tx_pcap[i]) < 0)
573                                 return -1;
574                 }
575         }
576
577         /* If not open already, open rx pcaps */
578         for (i = 0; i < dev->data->nb_rx_queues; i++) {
579                 rx = &internals->rx_queue[i];
580
581                 if (pp->rx_pcap[i] != NULL)
582                         continue;
583
584                 if (strcmp(rx->type, ETH_PCAP_RX_PCAP_ARG) == 0) {
585                         if (open_single_rx_pcap(rx->name, &pp->rx_pcap[i]) < 0)
586                                 return -1;
587                 } else if (strcmp(rx->type, ETH_PCAP_RX_IFACE_ARG) == 0) {
588                         if (open_single_iface(rx->name, &pp->rx_pcap[i]) < 0)
589                                 return -1;
590                 }
591         }
592
593 status_up:
594         for (i = 0; i < dev->data->nb_rx_queues; i++)
595                 dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
596
597         for (i = 0; i < dev->data->nb_tx_queues; i++)
598                 dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED;
599
600         dev->data->dev_link.link_status = ETH_LINK_UP;
601
602         return 0;
603 }
604
605 /*
606  * This function gets called when the current port gets stopped.
607  * Is the only place for us to close all the tx streams dumpers.
608  * If not called the dumpers will be flushed within each tx burst.
609  */
610 static void
611 eth_dev_stop(struct rte_eth_dev *dev)
612 {
613         unsigned int i;
614         struct pmd_internals *internals = dev->data->dev_private;
615         struct pmd_process_private *pp = dev->process_private;
616
617         /* Special iface case. Single pcap is open and shared between tx/rx. */
618         if (internals->single_iface) {
619                 pcap_close(pp->tx_pcap[0]);
620                 pp->tx_pcap[0] = NULL;
621                 pp->rx_pcap[0] = NULL;
622                 goto status_down;
623         }
624
625         for (i = 0; i < dev->data->nb_tx_queues; i++) {
626                 if (pp->tx_dumper[i] != NULL) {
627                         pcap_dump_close(pp->tx_dumper[i]);
628                         pp->tx_dumper[i] = NULL;
629                 }
630
631                 if (pp->tx_pcap[i] != NULL) {
632                         pcap_close(pp->tx_pcap[i]);
633                         pp->tx_pcap[i] = NULL;
634                 }
635         }
636
637         for (i = 0; i < dev->data->nb_rx_queues; i++) {
638                 if (pp->rx_pcap[i] != NULL) {
639                         pcap_close(pp->rx_pcap[i]);
640                         pp->rx_pcap[i] = NULL;
641                 }
642         }
643
644 status_down:
645         for (i = 0; i < dev->data->nb_rx_queues; i++)
646                 dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
647
648         for (i = 0; i < dev->data->nb_tx_queues; i++)
649                 dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED;
650
651         dev->data->dev_link.link_status = ETH_LINK_DOWN;
652 }
653
654 static int
655 eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
656 {
657         return 0;
658 }
659
660 static int
661 eth_dev_info(struct rte_eth_dev *dev,
662                 struct rte_eth_dev_info *dev_info)
663 {
664         struct pmd_internals *internals = dev->data->dev_private;
665
666         dev_info->if_index = internals->if_index;
667         dev_info->max_mac_addrs = 1;
668         dev_info->max_rx_pktlen = (uint32_t) -1;
669         dev_info->max_rx_queues = dev->data->nb_rx_queues;
670         dev_info->max_tx_queues = dev->data->nb_tx_queues;
671         dev_info->min_rx_bufsize = 0;
672
673         return 0;
674 }
675
676 static int
677 eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
678 {
679         unsigned int i;
680         unsigned long rx_packets_total = 0, rx_bytes_total = 0;
681         unsigned long tx_packets_total = 0, tx_bytes_total = 0;
682         unsigned long tx_packets_err_total = 0;
683         const struct pmd_internals *internal = dev->data->dev_private;
684
685         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
686                         i < dev->data->nb_rx_queues; i++) {
687                 stats->q_ipackets[i] = internal->rx_queue[i].rx_stat.pkts;
688                 stats->q_ibytes[i] = internal->rx_queue[i].rx_stat.bytes;
689                 rx_packets_total += stats->q_ipackets[i];
690                 rx_bytes_total += stats->q_ibytes[i];
691         }
692
693         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
694                         i < dev->data->nb_tx_queues; i++) {
695                 stats->q_opackets[i] = internal->tx_queue[i].tx_stat.pkts;
696                 stats->q_obytes[i] = internal->tx_queue[i].tx_stat.bytes;
697                 tx_packets_total += stats->q_opackets[i];
698                 tx_bytes_total += stats->q_obytes[i];
699                 tx_packets_err_total += internal->tx_queue[i].tx_stat.err_pkts;
700         }
701
702         stats->ipackets = rx_packets_total;
703         stats->ibytes = rx_bytes_total;
704         stats->opackets = tx_packets_total;
705         stats->obytes = tx_bytes_total;
706         stats->oerrors = tx_packets_err_total;
707
708         return 0;
709 }
710
711 static int
712 eth_stats_reset(struct rte_eth_dev *dev)
713 {
714         unsigned int i;
715         struct pmd_internals *internal = dev->data->dev_private;
716
717         for (i = 0; i < dev->data->nb_rx_queues; i++) {
718                 internal->rx_queue[i].rx_stat.pkts = 0;
719                 internal->rx_queue[i].rx_stat.bytes = 0;
720         }
721
722         for (i = 0; i < dev->data->nb_tx_queues; i++) {
723                 internal->tx_queue[i].tx_stat.pkts = 0;
724                 internal->tx_queue[i].tx_stat.bytes = 0;
725                 internal->tx_queue[i].tx_stat.err_pkts = 0;
726         }
727
728         return 0;
729 }
730
731 static int
732 eth_dev_close(struct rte_eth_dev *dev)
733 {
734         unsigned int i;
735         struct pmd_internals *internals = dev->data->dev_private;
736
737         /* Device wide flag, but cleanup must be performed per queue. */
738         if (internals->infinite_rx) {
739                 for (i = 0; i < dev->data->nb_rx_queues; i++) {
740                         struct pcap_rx_queue *pcap_q = &internals->rx_queue[i];
741                         struct rte_mbuf *pcap_buf;
742
743                         while (!rte_ring_dequeue(pcap_q->pkts,
744                                         (void **)&pcap_buf))
745                                 rte_pktmbuf_free(pcap_buf);
746
747                         rte_ring_free(pcap_q->pkts);
748                 }
749         }
750
751         return 0;
752 }
753
754 static void
755 eth_queue_release(void *q __rte_unused)
756 {
757 }
758
759 static int
760 eth_link_update(struct rte_eth_dev *dev __rte_unused,
761                 int wait_to_complete __rte_unused)
762 {
763         return 0;
764 }
765
766 static int
767 eth_rx_queue_setup(struct rte_eth_dev *dev,
768                 uint16_t rx_queue_id,
769                 uint16_t nb_rx_desc __rte_unused,
770                 unsigned int socket_id __rte_unused,
771                 const struct rte_eth_rxconf *rx_conf __rte_unused,
772                 struct rte_mempool *mb_pool)
773 {
774         struct pmd_internals *internals = dev->data->dev_private;
775         struct pcap_rx_queue *pcap_q = &internals->rx_queue[rx_queue_id];
776
777         pcap_q->mb_pool = mb_pool;
778         pcap_q->port_id = dev->data->port_id;
779         pcap_q->queue_id = rx_queue_id;
780         dev->data->rx_queues[rx_queue_id] = pcap_q;
781
782         if (internals->infinite_rx) {
783                 struct pmd_process_private *pp;
784                 char ring_name[NAME_MAX];
785                 static uint32_t ring_number;
786                 uint64_t pcap_pkt_count = 0;
787                 struct rte_mbuf *bufs[1];
788                 pcap_t **pcap;
789
790                 pp = rte_eth_devices[pcap_q->port_id].process_private;
791                 pcap = &pp->rx_pcap[pcap_q->queue_id];
792
793                 if (unlikely(*pcap == NULL))
794                         return -ENOENT;
795
796                 pcap_pkt_count = count_packets_in_pcap(pcap, pcap_q);
797
798                 snprintf(ring_name, sizeof(ring_name), "PCAP_RING%" PRIu16,
799                                 ring_number);
800
801                 pcap_q->pkts = rte_ring_create(ring_name,
802                                 rte_align64pow2(pcap_pkt_count + 1), 0,
803                                 RING_F_SP_ENQ | RING_F_SC_DEQ);
804                 ring_number++;
805                 if (!pcap_q->pkts)
806                         return -ENOENT;
807
808                 /* Fill ring with packets from PCAP file one by one. */
809                 while (eth_pcap_rx(pcap_q, bufs, 1)) {
810                         /* Check for multiseg mbufs. */
811                         if (bufs[0]->nb_segs != 1) {
812                                 rte_pktmbuf_free(*bufs);
813
814                                 while (!rte_ring_dequeue(pcap_q->pkts,
815                                                 (void **)bufs))
816                                         rte_pktmbuf_free(*bufs);
817
818                                 rte_ring_free(pcap_q->pkts);
819                                 PMD_LOG(ERR, "Multiseg mbufs are not supported in infinite_rx "
820                                                 "mode.");
821                                 return -EINVAL;
822                         }
823
824                         rte_ring_enqueue_bulk(pcap_q->pkts,
825                                         (void * const *)bufs, 1, NULL);
826                 }
827                 /*
828                  * Reset the stats for this queue since eth_pcap_rx calls above
829                  * didn't result in the application receiving packets.
830                  */
831                 pcap_q->rx_stat.pkts = 0;
832                 pcap_q->rx_stat.bytes = 0;
833         }
834
835         return 0;
836 }
837
838 static int
839 eth_tx_queue_setup(struct rte_eth_dev *dev,
840                 uint16_t tx_queue_id,
841                 uint16_t nb_tx_desc __rte_unused,
842                 unsigned int socket_id __rte_unused,
843                 const struct rte_eth_txconf *tx_conf __rte_unused)
844 {
845         struct pmd_internals *internals = dev->data->dev_private;
846         struct pcap_tx_queue *pcap_q = &internals->tx_queue[tx_queue_id];
847
848         pcap_q->port_id = dev->data->port_id;
849         pcap_q->queue_id = tx_queue_id;
850         dev->data->tx_queues[tx_queue_id] = pcap_q;
851
852         return 0;
853 }
854
855 static int
856 eth_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
857 {
858         dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
859
860         return 0;
861 }
862
863 static int
864 eth_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id)
865 {
866         dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
867
868         return 0;
869 }
870
871 static int
872 eth_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rx_queue_id)
873 {
874         dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED;
875
876         return 0;
877 }
878
879 static int
880 eth_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
881 {
882         dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED;
883
884         return 0;
885 }
886
887 static const struct eth_dev_ops ops = {
888         .dev_start = eth_dev_start,
889         .dev_stop = eth_dev_stop,
890         .dev_close = eth_dev_close,
891         .dev_configure = eth_dev_configure,
892         .dev_infos_get = eth_dev_info,
893         .rx_queue_setup = eth_rx_queue_setup,
894         .tx_queue_setup = eth_tx_queue_setup,
895         .rx_queue_start = eth_rx_queue_start,
896         .tx_queue_start = eth_tx_queue_start,
897         .rx_queue_stop = eth_rx_queue_stop,
898         .tx_queue_stop = eth_tx_queue_stop,
899         .rx_queue_release = eth_queue_release,
900         .tx_queue_release = eth_queue_release,
901         .link_update = eth_link_update,
902         .stats_get = eth_stats_get,
903         .stats_reset = eth_stats_reset,
904 };
905
906 static int
907 add_queue(struct pmd_devargs *pmd, const char *name, const char *type,
908                 pcap_t *pcap, pcap_dumper_t *dumper)
909 {
910         if (pmd->num_of_queue >= RTE_PMD_PCAP_MAX_QUEUES)
911                 return -1;
912         if (pcap)
913                 pmd->queue[pmd->num_of_queue].pcap = pcap;
914         if (dumper)
915                 pmd->queue[pmd->num_of_queue].dumper = dumper;
916         pmd->queue[pmd->num_of_queue].name = name;
917         pmd->queue[pmd->num_of_queue].type = type;
918         pmd->num_of_queue++;
919         return 0;
920 }
921
922 /*
923  * Function handler that opens the pcap file for reading a stores a
924  * reference of it for use it later on.
925  */
926 static int
927 open_rx_pcap(const char *key, const char *value, void *extra_args)
928 {
929         const char *pcap_filename = value;
930         struct pmd_devargs *rx = extra_args;
931         pcap_t *pcap = NULL;
932
933         if (open_single_rx_pcap(pcap_filename, &pcap) < 0)
934                 return -1;
935
936         if (add_queue(rx, pcap_filename, key, pcap, NULL) < 0) {
937                 pcap_close(pcap);
938                 return -1;
939         }
940
941         return 0;
942 }
943
944 /*
945  * Opens a pcap file for writing and stores a reference to it
946  * for use it later on.
947  */
948 static int
949 open_tx_pcap(const char *key, const char *value, void *extra_args)
950 {
951         const char *pcap_filename = value;
952         struct pmd_devargs *dumpers = extra_args;
953         pcap_dumper_t *dumper;
954
955         if (open_single_tx_pcap(pcap_filename, &dumper) < 0)
956                 return -1;
957
958         if (add_queue(dumpers, pcap_filename, key, NULL, dumper) < 0) {
959                 pcap_dump_close(dumper);
960                 return -1;
961         }
962
963         return 0;
964 }
965
966 /*
967  * Opens an interface for reading and writing
968  */
969 static inline int
970 open_rx_tx_iface(const char *key, const char *value, void *extra_args)
971 {
972         const char *iface = value;
973         struct pmd_devargs *tx = extra_args;
974         pcap_t *pcap = NULL;
975
976         if (open_single_iface(iface, &pcap) < 0)
977                 return -1;
978
979         tx->queue[0].pcap = pcap;
980         tx->queue[0].name = iface;
981         tx->queue[0].type = key;
982
983         return 0;
984 }
985
986 static inline int
987 set_iface_direction(const char *iface, pcap_t *pcap,
988                 pcap_direction_t direction)
989 {
990         const char *direction_str = (direction == PCAP_D_IN) ? "IN" : "OUT";
991         if (pcap_setdirection(pcap, direction) < 0) {
992                 PMD_LOG(ERR, "Setting %s pcap direction %s failed - %s\n",
993                                 iface, direction_str, pcap_geterr(pcap));
994                 return -1;
995         }
996         PMD_LOG(INFO, "Setting %s pcap direction %s\n",
997                         iface, direction_str);
998         return 0;
999 }
1000
1001 static inline int
1002 open_iface(const char *key, const char *value, void *extra_args)
1003 {
1004         const char *iface = value;
1005         struct pmd_devargs *pmd = extra_args;
1006         pcap_t *pcap = NULL;
1007
1008         if (open_single_iface(iface, &pcap) < 0)
1009                 return -1;
1010         if (add_queue(pmd, iface, key, pcap, NULL) < 0) {
1011                 pcap_close(pcap);
1012                 return -1;
1013         }
1014
1015         return 0;
1016 }
1017
1018 /*
1019  * Opens a NIC for reading packets from it
1020  */
1021 static inline int
1022 open_rx_iface(const char *key, const char *value, void *extra_args)
1023 {
1024         int ret = open_iface(key, value, extra_args);
1025         if (ret < 0)
1026                 return ret;
1027         if (strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0) {
1028                 struct pmd_devargs *pmd = extra_args;
1029                 unsigned int qid = pmd->num_of_queue - 1;
1030
1031                 set_iface_direction(pmd->queue[qid].name,
1032                                 pmd->queue[qid].pcap,
1033                                 PCAP_D_IN);
1034         }
1035
1036         return 0;
1037 }
1038
1039 static inline int
1040 rx_iface_args_process(const char *key, const char *value, void *extra_args)
1041 {
1042         if (strcmp(key, ETH_PCAP_RX_IFACE_ARG) == 0 ||
1043                         strcmp(key, ETH_PCAP_RX_IFACE_IN_ARG) == 0)
1044                 return open_rx_iface(key, value, extra_args);
1045
1046         return 0;
1047 }
1048
1049 /*
1050  * Opens a NIC for writing packets to it
1051  */
1052 static int
1053 open_tx_iface(const char *key, const char *value, void *extra_args)
1054 {
1055         return open_iface(key, value, extra_args);
1056 }
1057
1058 static int
1059 select_phy_mac(const char *key __rte_unused, const char *value,
1060                 void *extra_args)
1061 {
1062         if (extra_args) {
1063                 const int phy_mac = atoi(value);
1064                 int *enable_phy_mac = extra_args;
1065
1066                 if (phy_mac)
1067                         *enable_phy_mac = 1;
1068         }
1069         return 0;
1070 }
1071
1072 static int
1073 get_infinite_rx_arg(const char *key __rte_unused,
1074                 const char *value, void *extra_args)
1075 {
1076         if (extra_args) {
1077                 const int infinite_rx = atoi(value);
1078                 int *enable_infinite_rx = extra_args;
1079
1080                 if (infinite_rx > 0)
1081                         *enable_infinite_rx = 1;
1082         }
1083         return 0;
1084 }
1085
1086 static int
1087 pmd_init_internals(struct rte_vdev_device *vdev,
1088                 const unsigned int nb_rx_queues,
1089                 const unsigned int nb_tx_queues,
1090                 struct pmd_internals **internals,
1091                 struct rte_eth_dev **eth_dev)
1092 {
1093         struct rte_eth_dev_data *data;
1094         struct pmd_process_private *pp;
1095         unsigned int numa_node = vdev->device.numa_node;
1096
1097         PMD_LOG(INFO, "Creating pcap-backed ethdev on numa socket %d",
1098                 numa_node);
1099
1100         pp = (struct pmd_process_private *)
1101                 rte_zmalloc(NULL, sizeof(struct pmd_process_private),
1102                                 RTE_CACHE_LINE_SIZE);
1103
1104         if (pp == NULL) {
1105                 PMD_LOG(ERR,
1106                         "Failed to allocate memory for process private");
1107                 return -1;
1108         }
1109
1110         /* reserve an ethdev entry */
1111         *eth_dev = rte_eth_vdev_allocate(vdev, sizeof(**internals));
1112         if (!(*eth_dev)) {
1113                 rte_free(pp);
1114                 return -1;
1115         }
1116         (*eth_dev)->process_private = pp;
1117         /* now put it all together
1118          * - store queue data in internals,
1119          * - store numa_node info in eth_dev
1120          * - point eth_dev_data to internals
1121          * - and point eth_dev structure to new eth_dev_data structure
1122          */
1123         *internals = (*eth_dev)->data->dev_private;
1124         /*
1125          * Interface MAC = 02:70:63:61:70:<iface_idx>
1126          * derived from: 'locally administered':'p':'c':'a':'p':'iface_idx'
1127          * where the middle 4 characters are converted to hex.
1128          */
1129         (*internals)->eth_addr = (struct rte_ether_addr) {
1130                 .addr_bytes = { 0x02, 0x70, 0x63, 0x61, 0x70, iface_idx++ }
1131         };
1132         (*internals)->phy_mac = 0;
1133         data = (*eth_dev)->data;
1134         data->nb_rx_queues = (uint16_t)nb_rx_queues;
1135         data->nb_tx_queues = (uint16_t)nb_tx_queues;
1136         data->dev_link = pmd_link;
1137         data->mac_addrs = &(*internals)->eth_addr;
1138         data->promiscuous = 1;
1139         data->all_multicast = 1;
1140
1141         /*
1142          * NOTE: we'll replace the data element, of originally allocated
1143          * eth_dev so the rings are local per-process
1144          */
1145         (*eth_dev)->dev_ops = &ops;
1146
1147         strlcpy((*internals)->devargs, rte_vdev_device_args(vdev),
1148                         ETH_PCAP_ARG_MAXLEN);
1149
1150         return 0;
1151 }
1152
1153 static int
1154 eth_pcap_update_mac(const char *if_name, struct rte_eth_dev *eth_dev,
1155                 const unsigned int numa_node)
1156 {
1157 #if defined(RTE_EXEC_ENV_LINUX)
1158         void *mac_addrs;
1159         struct ifreq ifr;
1160         int if_fd = socket(AF_INET, SOCK_DGRAM, 0);
1161
1162         if (if_fd == -1)
1163                 return -1;
1164
1165         rte_strscpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
1166         if (ioctl(if_fd, SIOCGIFHWADDR, &ifr)) {
1167                 close(if_fd);
1168                 return -1;
1169         }
1170
1171         mac_addrs = rte_zmalloc_socket(NULL, RTE_ETHER_ADDR_LEN, 0, numa_node);
1172         if (!mac_addrs) {
1173                 close(if_fd);
1174                 return -1;
1175         }
1176
1177         PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
1178         eth_dev->data->mac_addrs = mac_addrs;
1179         rte_memcpy(eth_dev->data->mac_addrs[0].addr_bytes,
1180                         ifr.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
1181
1182         close(if_fd);
1183
1184         return 0;
1185
1186 #elif defined(RTE_EXEC_ENV_FREEBSD)
1187         void *mac_addrs;
1188         struct if_msghdr *ifm;
1189         struct sockaddr_dl *sdl;
1190         int mib[6];
1191         size_t len = 0;
1192         char *buf;
1193
1194         mib[0] = CTL_NET;
1195         mib[1] = AF_ROUTE;
1196         mib[2] = 0;
1197         mib[3] = AF_LINK;
1198         mib[4] = NET_RT_IFLIST;
1199         mib[5] = if_nametoindex(if_name);
1200
1201         if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0)
1202                 return -1;
1203
1204         if (len == 0)
1205                 return -1;
1206
1207         buf = rte_malloc(NULL, len, 0);
1208         if (!buf)
1209                 return -1;
1210
1211         if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
1212                 rte_free(buf);
1213                 return -1;
1214         }
1215         ifm = (struct if_msghdr *)buf;
1216         sdl = (struct sockaddr_dl *)(ifm + 1);
1217
1218         mac_addrs = rte_zmalloc_socket(NULL, RTE_ETHER_ADDR_LEN, 0, numa_node);
1219         if (!mac_addrs) {
1220                 rte_free(buf);
1221                 return -1;
1222         }
1223
1224         PMD_LOG(INFO, "Setting phy MAC for %s", if_name);
1225         eth_dev->data->mac_addrs = mac_addrs;
1226         rte_memcpy(eth_dev->data->mac_addrs[0].addr_bytes,
1227                         LLADDR(sdl), RTE_ETHER_ADDR_LEN);
1228
1229         rte_free(buf);
1230
1231         return 0;
1232 #else
1233         return -1;
1234 #endif
1235 }
1236
1237 static int
1238 eth_from_pcaps_common(struct rte_vdev_device *vdev,
1239                 struct pmd_devargs_all *devargs_all,
1240                 struct pmd_internals **internals, struct rte_eth_dev **eth_dev)
1241 {
1242         struct pmd_process_private *pp;
1243         struct pmd_devargs *rx_queues = &devargs_all->rx_queues;
1244         struct pmd_devargs *tx_queues = &devargs_all->tx_queues;
1245         const unsigned int nb_rx_queues = rx_queues->num_of_queue;
1246         const unsigned int nb_tx_queues = tx_queues->num_of_queue;
1247         unsigned int i;
1248
1249         if (pmd_init_internals(vdev, nb_rx_queues, nb_tx_queues, internals,
1250                         eth_dev) < 0)
1251                 return -1;
1252
1253         pp = (*eth_dev)->process_private;
1254         for (i = 0; i < nb_rx_queues; i++) {
1255                 struct pcap_rx_queue *rx = &(*internals)->rx_queue[i];
1256                 struct devargs_queue *queue = &rx_queues->queue[i];
1257
1258                 pp->rx_pcap[i] = queue->pcap;
1259                 strlcpy(rx->name, queue->name, sizeof(rx->name));
1260                 strlcpy(rx->type, queue->type, sizeof(rx->type));
1261         }
1262
1263         for (i = 0; i < nb_tx_queues; i++) {
1264                 struct pcap_tx_queue *tx = &(*internals)->tx_queue[i];
1265                 struct devargs_queue *queue = &tx_queues->queue[i];
1266
1267                 pp->tx_dumper[i] = queue->dumper;
1268                 pp->tx_pcap[i] = queue->pcap;
1269                 strlcpy(tx->name, queue->name, sizeof(tx->name));
1270                 strlcpy(tx->type, queue->type, sizeof(tx->type));
1271         }
1272
1273         return 0;
1274 }
1275
1276 static int
1277 eth_from_pcaps(struct rte_vdev_device *vdev,
1278                 struct pmd_devargs_all *devargs_all)
1279 {
1280         struct pmd_internals *internals = NULL;
1281         struct rte_eth_dev *eth_dev = NULL;
1282         struct pmd_devargs *rx_queues = &devargs_all->rx_queues;
1283         int single_iface = devargs_all->single_iface;
1284         unsigned int infinite_rx = devargs_all->infinite_rx;
1285         int ret;
1286
1287         ret = eth_from_pcaps_common(vdev, devargs_all, &internals, &eth_dev);
1288
1289         if (ret < 0)
1290                 return ret;
1291
1292         /* store weather we are using a single interface for rx/tx or not */
1293         internals->single_iface = single_iface;
1294
1295         if (single_iface) {
1296                 internals->if_index = if_nametoindex(rx_queues->queue[0].name);
1297
1298                 /* phy_mac arg is applied only only if "iface" devarg is provided */
1299                 if (rx_queues->phy_mac) {
1300                         int ret = eth_pcap_update_mac(rx_queues->queue[0].name,
1301                                         eth_dev, vdev->device.numa_node);
1302                         if (ret == 0)
1303                                 internals->phy_mac = 1;
1304                 }
1305         }
1306
1307         internals->infinite_rx = infinite_rx;
1308         /* Assign rx ops. */
1309         if (infinite_rx)
1310                 eth_dev->rx_pkt_burst = eth_pcap_rx_infinite;
1311         else if (devargs_all->is_rx_pcap || devargs_all->is_rx_iface ||
1312                         single_iface)
1313                 eth_dev->rx_pkt_burst = eth_pcap_rx;
1314         else
1315                 eth_dev->rx_pkt_burst = eth_null_rx;
1316
1317         /* Assign tx ops. */
1318         if (devargs_all->is_tx_pcap)
1319                 eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
1320         else if (devargs_all->is_tx_iface || single_iface)
1321                 eth_dev->tx_pkt_burst = eth_pcap_tx;
1322         else
1323                 eth_dev->tx_pkt_burst = eth_tx_drop;
1324
1325         rte_eth_dev_probing_finish(eth_dev);
1326         return 0;
1327 }
1328
1329 static int
1330 pmd_pcap_probe(struct rte_vdev_device *dev)
1331 {
1332         const char *name;
1333         struct rte_kvargs *kvlist;
1334         struct pmd_devargs pcaps = {0};
1335         struct pmd_devargs dumpers = {0};
1336         struct rte_eth_dev *eth_dev =  NULL;
1337         struct pmd_internals *internal;
1338         int ret = 0;
1339
1340         struct pmd_devargs_all devargs_all = {
1341                 .single_iface = 0,
1342                 .is_tx_pcap = 0,
1343                 .is_tx_iface = 0,
1344                 .infinite_rx = 0,
1345         };
1346
1347         name = rte_vdev_device_name(dev);
1348         PMD_LOG(INFO, "Initializing pmd_pcap for %s", name);
1349
1350         gettimeofday(&start_time, NULL);
1351         start_cycles = rte_get_timer_cycles();
1352         hz = rte_get_timer_hz();
1353
1354         if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
1355                 eth_dev = rte_eth_dev_attach_secondary(name);
1356                 if (!eth_dev) {
1357                         PMD_LOG(ERR, "Failed to probe %s", name);
1358                         return -1;
1359                 }
1360
1361                 internal = eth_dev->data->dev_private;
1362
1363                 kvlist = rte_kvargs_parse(internal->devargs, valid_arguments);
1364                 if (kvlist == NULL)
1365                         return -1;
1366         } else {
1367                 kvlist = rte_kvargs_parse(rte_vdev_device_args(dev),
1368                                 valid_arguments);
1369                 if (kvlist == NULL)
1370                         return -1;
1371         }
1372
1373         /*
1374          * If iface argument is passed we open the NICs and use them for
1375          * reading / writing
1376          */
1377         if (rte_kvargs_count(kvlist, ETH_PCAP_IFACE_ARG) == 1) {
1378
1379                 ret = rte_kvargs_process(kvlist, ETH_PCAP_IFACE_ARG,
1380                                 &open_rx_tx_iface, &pcaps);
1381                 if (ret < 0)
1382                         goto free_kvlist;
1383
1384                 dumpers.queue[0] = pcaps.queue[0];
1385
1386                 ret = rte_kvargs_process(kvlist, ETH_PCAP_PHY_MAC_ARG,
1387                                 &select_phy_mac, &pcaps.phy_mac);
1388                 if (ret < 0)
1389                         goto free_kvlist;
1390
1391                 dumpers.phy_mac = pcaps.phy_mac;
1392
1393                 devargs_all.single_iface = 1;
1394                 pcaps.num_of_queue = 1;
1395                 dumpers.num_of_queue = 1;
1396
1397                 goto create_eth;
1398         }
1399
1400         /*
1401          * We check whether we want to open a RX stream from a real NIC, a
1402          * pcap file or open a dummy RX stream
1403          */
1404         devargs_all.is_rx_pcap =
1405                 rte_kvargs_count(kvlist, ETH_PCAP_RX_PCAP_ARG) ? 1 : 0;
1406         devargs_all.is_rx_iface =
1407                 rte_kvargs_count(kvlist, ETH_PCAP_RX_IFACE_ARG) ? 1 : 0;
1408         pcaps.num_of_queue = 0;
1409
1410         devargs_all.is_tx_pcap =
1411                 rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG) ? 1 : 0;
1412         devargs_all.is_tx_iface =
1413                 rte_kvargs_count(kvlist, ETH_PCAP_TX_IFACE_ARG) ? 1 : 0;
1414         dumpers.num_of_queue = 0;
1415
1416         if (devargs_all.is_rx_pcap) {
1417                 /*
1418                  * We check whether we want to infinitely rx the pcap file.
1419                  */
1420                 unsigned int infinite_rx_arg_cnt = rte_kvargs_count(kvlist,
1421                                 ETH_PCAP_INFINITE_RX_ARG);
1422
1423                 if (infinite_rx_arg_cnt == 1) {
1424                         ret = rte_kvargs_process(kvlist,
1425                                         ETH_PCAP_INFINITE_RX_ARG,
1426                                         &get_infinite_rx_arg,
1427                                         &devargs_all.infinite_rx);
1428                         if (ret < 0)
1429                                 goto free_kvlist;
1430                         PMD_LOG(INFO, "infinite_rx has been %s for %s",
1431                                         devargs_all.infinite_rx ? "enabled" : "disabled",
1432                                         name);
1433
1434                 } else if (infinite_rx_arg_cnt > 1) {
1435                         PMD_LOG(WARNING, "infinite_rx has not been enabled since the "
1436                                         "argument has been provided more than once "
1437                                         "for %s", name);
1438                 }
1439
1440                 ret = rte_kvargs_process(kvlist, ETH_PCAP_RX_PCAP_ARG,
1441                                 &open_rx_pcap, &pcaps);
1442         } else if (devargs_all.is_rx_iface) {
1443                 ret = rte_kvargs_process(kvlist, NULL,
1444                                 &rx_iface_args_process, &pcaps);
1445         } else if (devargs_all.is_tx_iface || devargs_all.is_tx_pcap) {
1446                 unsigned int i;
1447
1448                 /* Count number of tx queue args passed before dummy rx queue
1449                  * creation so a dummy rx queue can be created for each tx queue
1450                  */
1451                 unsigned int num_tx_queues =
1452                         (rte_kvargs_count(kvlist, ETH_PCAP_TX_PCAP_ARG) +
1453                         rte_kvargs_count(kvlist, ETH_PCAP_TX_IFACE_ARG));
1454
1455                 PMD_LOG(INFO, "Creating null rx queue since no rx queues were provided.");
1456
1457                 /* Creating a dummy rx queue for each tx queue passed */
1458                 for (i = 0; i < num_tx_queues; i++)
1459                         ret = add_queue(&pcaps, "dummy_rx", "rx_null", NULL,
1460                                         NULL);
1461         } else {
1462                 PMD_LOG(ERR, "Error - No rx or tx queues provided");
1463                 ret = -ENOENT;
1464         }
1465         if (ret < 0)
1466                 goto free_kvlist;
1467
1468         /*
1469          * We check whether we want to open a TX stream to a real NIC,
1470          * a pcap file, or drop packets on tx
1471          */
1472         if (devargs_all.is_tx_pcap) {
1473                 ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_PCAP_ARG,
1474                                 &open_tx_pcap, &dumpers);
1475         } else if (devargs_all.is_tx_iface) {
1476                 ret = rte_kvargs_process(kvlist, ETH_PCAP_TX_IFACE_ARG,
1477                                 &open_tx_iface, &dumpers);
1478         } else {
1479                 unsigned int i;
1480
1481                 PMD_LOG(INFO, "Dropping packets on tx since no tx queues were provided.");
1482
1483                 /* Add 1 dummy queue per rxq which counts and drops packets. */
1484                 for (i = 0; i < pcaps.num_of_queue; i++)
1485                         ret = add_queue(&dumpers, "dummy_tx", "tx_drop", NULL,
1486                                         NULL);
1487         }
1488
1489         if (ret < 0)
1490                 goto free_kvlist;
1491
1492 create_eth:
1493         if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
1494                 struct pmd_process_private *pp;
1495                 unsigned int i;
1496
1497                 internal = eth_dev->data->dev_private;
1498                         pp = (struct pmd_process_private *)
1499                                 rte_zmalloc(NULL,
1500                                         sizeof(struct pmd_process_private),
1501                                         RTE_CACHE_LINE_SIZE);
1502
1503                 if (pp == NULL) {
1504                         PMD_LOG(ERR,
1505                                 "Failed to allocate memory for process private");
1506                         ret = -1;
1507                         goto free_kvlist;
1508                 }
1509
1510                 eth_dev->dev_ops = &ops;
1511                 eth_dev->device = &dev->device;
1512
1513                 /* setup process private */
1514                 for (i = 0; i < pcaps.num_of_queue; i++)
1515                         pp->rx_pcap[i] = pcaps.queue[i].pcap;
1516
1517                 for (i = 0; i < dumpers.num_of_queue; i++) {
1518                         pp->tx_dumper[i] = dumpers.queue[i].dumper;
1519                         pp->tx_pcap[i] = dumpers.queue[i].pcap;
1520                 }
1521
1522                 eth_dev->process_private = pp;
1523                 eth_dev->rx_pkt_burst = eth_pcap_rx;
1524                 if (devargs_all.is_tx_pcap)
1525                         eth_dev->tx_pkt_burst = eth_pcap_tx_dumper;
1526                 else
1527                         eth_dev->tx_pkt_burst = eth_pcap_tx;
1528
1529                 rte_eth_dev_probing_finish(eth_dev);
1530                 goto free_kvlist;
1531         }
1532
1533         devargs_all.rx_queues = pcaps;
1534         devargs_all.tx_queues = dumpers;
1535
1536         ret = eth_from_pcaps(dev, &devargs_all);
1537
1538 free_kvlist:
1539         rte_kvargs_free(kvlist);
1540
1541         return ret;
1542 }
1543
1544 static int
1545 pmd_pcap_remove(struct rte_vdev_device *dev)
1546 {
1547         struct pmd_internals *internals = NULL;
1548         struct rte_eth_dev *eth_dev = NULL;
1549
1550         PMD_LOG(INFO, "Closing pcap ethdev on numa socket %d",
1551                         rte_socket_id());
1552
1553         if (!dev)
1554                 return -1;
1555
1556         /* reserve an ethdev entry */
1557         eth_dev = rte_eth_dev_allocated(rte_vdev_device_name(dev));
1558         if (eth_dev == NULL)
1559                 return -1;
1560
1561         if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
1562                 internals = eth_dev->data->dev_private;
1563                 if (internals != NULL && internals->phy_mac == 0)
1564                         /* not dynamically allocated, must not be freed */
1565                         eth_dev->data->mac_addrs = NULL;
1566         }
1567
1568         eth_dev_close(eth_dev);
1569
1570         rte_free(eth_dev->process_private);
1571         rte_eth_dev_release_port(eth_dev);
1572
1573         return 0;
1574 }
1575
1576 static struct rte_vdev_driver pmd_pcap_drv = {
1577         .probe = pmd_pcap_probe,
1578         .remove = pmd_pcap_remove,
1579 };
1580
1581 RTE_PMD_REGISTER_VDEV(net_pcap, pmd_pcap_drv);
1582 RTE_PMD_REGISTER_ALIAS(net_pcap, eth_pcap);
1583 RTE_PMD_REGISTER_PARAM_STRING(net_pcap,
1584         ETH_PCAP_RX_PCAP_ARG "=<string> "
1585         ETH_PCAP_TX_PCAP_ARG "=<string> "
1586         ETH_PCAP_RX_IFACE_ARG "=<ifc> "
1587         ETH_PCAP_RX_IFACE_IN_ARG "=<ifc> "
1588         ETH_PCAP_TX_IFACE_ARG "=<ifc> "
1589         ETH_PCAP_IFACE_ARG "=<ifc> "
1590         ETH_PCAP_PHY_MAC_ARG "=<int>"
1591         ETH_PCAP_INFINITE_RX_ARG "=<0|1>");