@@ -124,7 +124,7 @@ source_file_deps = {
'test_meter.c': ['meter'],
'test_metrics.c': ['metrics'],
'test_mp_secondary.c': ['hash', 'lpm'],
- 'test_pcapng.c': ['ethdev', 'net', 'pcapng'],
+ 'test_pcapng.c': ['ethdev', 'net', 'pcapng', 'bus_vdev'],
'test_pdcp.c': ['eventdev', 'pdcp', 'net', 'timer', 'security'],
'test_pdump.c': ['pdump'] + sample_packet_forward_deps,
'test_per_lcore.c': [],
@@ -6,25 +6,34 @@
#include <stdlib.h>
#include <unistd.h>
+#include <rte_bus_vdev.h>
#include <rte_ethdev.h>
#include <rte_ether.h>
+#include <rte_ip.h>
#include <rte_mbuf.h>
#include <rte_mempool.h>
#include <rte_net.h>
#include <rte_pcapng.h>
+#include <rte_random.h>
+#include <rte_reciprocal.h>
+#include <rte_time.h>
+#include <rte_udp.h>
#include <pcap/pcap.h>
#include "test.h"
-#define NUM_PACKETS 10
-#define DUMMY_MBUF_NUM 3
+#define PCAPNG_TEST_DEBUG 0
+
+#define TOTAL_PACKETS 4096
+#define MAX_BURST 64
+#define MAX_GAP_US 100000
+#define DUMMY_MBUF_NUM 3
-static rte_pcapng_t *pcapng;
static struct rte_mempool *mp;
static const uint32_t pkt_len = 200;
static uint16_t port_id;
-static char file_name[] = "/tmp/pcapng_test_XXXXXX.pcapng";
+static const char null_dev[] = "net_null0";
/* first mbuf in the packet, should always be at offset 0 */
struct dummy_mbuf {
@@ -61,6 +70,7 @@ mbuf1_prepare(struct dummy_mbuf *dm, uint32_t plen)
struct {
struct rte_ether_hdr eth;
struct rte_ipv4_hdr ip;
+ struct rte_udp_hdr udp;
} pkt = {
.eth = {
.dst_addr.addr_bytes = "\xff\xff\xff\xff\xff\xff",
@@ -68,149 +78,226 @@ mbuf1_prepare(struct dummy_mbuf *dm, uint32_t plen)
},
.ip = {
.version_ihl = RTE_IPV4_VHL_DEF,
- .total_length = rte_cpu_to_be_16(plen),
- .time_to_live = IPDEFTTL,
- .next_proto_id = IPPROTO_RAW,
+ .time_to_live = 1,
+ .next_proto_id = IPPROTO_UDP,
.src_addr = rte_cpu_to_be_32(RTE_IPV4_LOOPBACK),
.dst_addr = rte_cpu_to_be_32(RTE_IPV4_BROADCAST),
- }
+ },
+ .udp = {
+ .dst_port = rte_cpu_to_be_16(9), /* Discard port */
+ },
};
memset(dm, 0, sizeof(*dm));
dummy_mbuf_prep(&dm->mb[0], dm->buf[0], sizeof(dm->buf[0]), plen);
rte_eth_random_addr(pkt.eth.src_addr.addr_bytes);
- memcpy(rte_pktmbuf_mtod(dm->mb, void *), &pkt, RTE_MIN(sizeof(pkt), plen));
+ plen -= sizeof(struct rte_ether_hdr);
+
+ pkt.ip.total_length = rte_cpu_to_be_16(plen);
+ pkt.ip.hdr_checksum = rte_ipv4_cksum(&pkt.ip);
+
+ plen -= sizeof(struct rte_ipv4_hdr);
+ pkt.udp.src_port = rte_rand();
+ pkt.udp.dgram_len = rte_cpu_to_be_16(plen);
+
+ memcpy(rte_pktmbuf_mtod(dm->mb, void *), &pkt, sizeof(pkt));
}
-static int
-test_setup(void)
+/*
+ * Make a timestamp value as used by PCAPNG file format
+ * The library uses nanosecond time resolution so this is
+ * time elapsed since 1970-01-01 00:00:00 UTC.
+ *
+ * Use the same way of calculating as in pdump library.
+ */
+static struct {
+ uint64_t offset_ns; /* ns since 1/1/1970 when initialized */
+ uint64_t tsc_base; /* TSC when initialized */
+ uint64_t tsc_hz; /* copy of rte_tsc_hz() */
+ struct rte_reciprocal_u64 tsc_hz_inverse; /* inverse of tsc_hz */
+} time_base;
+
+static void timestamp_init(void)
{
- int tmp_fd;
+ struct timespec ts;
+ uint64_t cycles;
- port_id = rte_eth_find_next(0);
- if (port_id >= RTE_MAX_ETHPORTS) {
- fprintf(stderr, "No valid Ether port\n");
- return -1;
- }
+ /* Compute time base offsets */
+ cycles = rte_get_tsc_cycles();
+ clock_gettime(CLOCK_REALTIME, &ts);
- tmp_fd = mkstemps(file_name, strlen(".pcapng"));
- if (tmp_fd == -1) {
- perror("mkstemps() failure");
- return -1;
- }
- printf("pcapng: output file %s\n", file_name);
+ /* put initial TSC value in middle of clock_gettime() call */
+ time_base.tsc_base = (cycles + rte_get_tsc_cycles()) / 2;
+ time_base.offset_ns = rte_timespec_to_ns(&ts);
- /* open a test capture file */
- pcapng = rte_pcapng_fdopen(tmp_fd, NULL, NULL, "pcapng_test", NULL);
- if (pcapng == NULL) {
- fprintf(stderr, "rte_pcapng_fdopen failed\n");
- close(tmp_fd);
- return -1;
- }
+ time_base.tsc_hz = rte_get_tsc_hz();
+ time_base.tsc_hz_inverse = rte_reciprocal_value_u64(time_base.tsc_hz);
+}
- /* Add interface to the file */
- if (rte_pcapng_add_interface(pcapng, port_id,
- NULL, NULL, NULL) != 0) {
- fprintf(stderr, "can not add port %u\n", port_id);
- return -1;
+static int
+test_setup(void)
+{
+ port_id = rte_eth_dev_count_avail();
+
+ /* Make a dummy null device to snoop on */
+ if (rte_vdev_init(null_dev, NULL) != 0) {
+ fprintf(stderr, "Failed to create vdev '%s'\n", null_dev);
+ goto fail;
}
/* Make a pool for cloned packets */
- mp = rte_pktmbuf_pool_create_by_ops("pcapng_test_pool", IOV_MAX + NUM_PACKETS,
- 0, 0,
- rte_pcapng_mbuf_size(pkt_len),
+ mp = rte_pktmbuf_pool_create_by_ops("pcapng_test_pool",
+ MAX_BURST, 0, 0,
+ rte_pcapng_mbuf_size(pkt_len) + 128,
SOCKET_ID_ANY, "ring_mp_sc");
if (mp == NULL) {
fprintf(stderr, "Cannot create mempool\n");
- return -1;
+ goto fail;
}
+
+ timestamp_init();
return 0;
+
+fail:
+ rte_vdev_uninit(null_dev);
+ rte_mempool_free(mp);
+ return -1;
}
static int
-test_write_packets(void)
+fill_pcapng_file(rte_pcapng_t *pcapng, unsigned int num_packets)
{
- struct rte_mbuf *orig;
- struct rte_mbuf *clones[NUM_PACKETS] = { };
struct dummy_mbuf mbfs;
- unsigned int i;
+ struct rte_mbuf *orig;
+ unsigned int burst_size;
+ unsigned int count;
ssize_t len;
/* make a dummy packet */
mbuf1_prepare(&mbfs, pkt_len);
-
- /* clone them */
orig = &mbfs.mb[0];
- for (i = 0; i < NUM_PACKETS; i++) {
- struct rte_mbuf *mc;
- mc = rte_pcapng_copy(port_id, 0, orig, mp, pkt_len,
- rte_get_tsc_cycles(), 0, NULL);
- if (mc == NULL) {
- fprintf(stderr, "Cannot copy packet\n");
+ for (count = 0; count < num_packets; count += burst_size) {
+ struct rte_mbuf *clones[MAX_BURST];
+ unsigned int i;
+
+ /* put 1 .. MAX_BURST packets in one write call */
+ burst_size = rte_rand_max(MAX_BURST) + 1;
+ for (i = 0; i < burst_size; i++) {
+ struct rte_mbuf *mc;
+
+ mc = rte_pcapng_copy(port_id, 0, orig, mp, pkt_len,
+ RTE_PCAPNG_DIRECTION_IN,
+ NULL);
+ if (mc == NULL) {
+ fprintf(stderr, "Cannot copy packet\n");
+ return -1;
+ }
+ clones[i] = mc;
+ }
+
+ /* write it to capture file */
+ len = rte_pcapng_write_packets(pcapng, clones, burst_size);
+ rte_pktmbuf_free_bulk(clones, burst_size);
+
+ if (len <= 0) {
+ fprintf(stderr, "Write of packets failed: %s\n",
+ rte_strerror(rte_errno));
return -1;
}
- clones[i] = mc;
+
+ /* Leave a small gap between packets to test for time wrap */
+ usleep(rte_rand_max(MAX_GAP_US));
}
- /* write it to capture file */
- len = rte_pcapng_write_packets(pcapng, clones, NUM_PACKETS);
+ return count;
+}
- rte_pktmbuf_free_bulk(clones, NUM_PACKETS);
+static char *
+fmt_time(char *buf, size_t size, uint64_t ts_ns)
+{
+ time_t sec;
+ size_t len;
- if (len <= 0) {
- fprintf(stderr, "Write of packets failed\n");
- return -1;
- }
+ sec = ts_ns / NS_PER_S;
+ len = strftime(buf, size, "%X", localtime(&sec));
+ snprintf(buf + len, size - len, ".%09lu",
+ (unsigned long)(ts_ns % NS_PER_S));
- return 0;
+ return buf;
}
-static int
-test_write_stats(void)
+/* Context for the pcap_loop callback */
+struct pkt_print_ctx {
+ pcap_t *pcap;
+ unsigned int count;
+};
+
+static void
+print_packet(uint64_t ts_ns, const struct rte_ether_hdr *eh, size_t len)
{
- ssize_t len;
+ char tbuf[128], src[64], dst[64];
- /* write a statistics block */
- len = rte_pcapng_write_stats(pcapng, port_id, NULL,
- 0, 0, 0,
- NUM_PACKETS, 0);
- if (len <= 0) {
- fprintf(stderr, "Write of statistics failed\n");
- return -1;
- }
- return 0;
+ fmt_time(tbuf, sizeof(tbuf), ts_ns);
+ rte_ether_format_addr(dst, sizeof(dst), &eh->dst_addr);
+ rte_ether_format_addr(src, sizeof(src), &eh->src_addr);
+ printf("%s: %s -> %s type %x length %zu\n",
+ tbuf, src, dst, rte_be_to_cpu_16(eh->ether_type), len);
}
+/* Callback from pcap_loop used to validate packets in the file */
static void
-pkt_print(u_char *user, const struct pcap_pkthdr *h,
- const u_char *bytes)
+parse_pcap_packet(u_char *user, const struct pcap_pkthdr *h,
+ const u_char *bytes)
{
- unsigned int *countp = (unsigned int *)user;
+ struct pkt_print_ctx *ctx = (struct pkt_print_ctx *)user;
const struct rte_ether_hdr *eh;
- struct tm *tm;
- char tbuf[128], src[64], dst[64];
+ const struct rte_ipv4_hdr *ip;
+ struct timespec ts;
+ uint64_t ns, now;
- tm = localtime(&h->ts.tv_sec);
- if (tm == NULL) {
- perror("localtime");
- return;
+ eh = (const struct rte_ether_hdr *)bytes;
+ ip = (const struct rte_ipv4_hdr *)(eh + 1);
+
+ ctx->count += 1;
+
+ clock_gettime(CLOCK_REALTIME, &ts);
+ now = rte_timespec_to_ns(&ts);
+
+ /* The pcap library is misleading in reporting timestamp.
+ * packet header struct gives timestamp as a timeval (ie. usec);
+ * but the file is open in nanonsecond mode therefore
+ * the timestamp is really in timespec (ie. nanoseconds).
+ */
+ ns = h->ts.tv_sec * NS_PER_S + h->ts.tv_usec;
+ if (ns < time_base.offset_ns || ns > now) {
+ char tstart[128], tend[128];
+
+ fmt_time(tstart, sizeof(tstart), time_base.offset_ns);
+ fmt_time(tend, sizeof(tend), now);
+ fprintf(stderr, "Timestamp out of range [%s .. %s]\n",
+ tstart, tend);
+ goto error;
}
- if (strftime(tbuf, sizeof(tbuf), "%X", tm) == 0) {
- fprintf(stderr, "strftime returned 0!\n");
- return;
+ if (!rte_is_broadcast_ether_addr(&eh->dst_addr)) {
+ fprintf(stderr, "Destination is not broadcast\n");
+ goto error;
}
- eh = (const struct rte_ether_hdr *)bytes;
- rte_ether_format_addr(dst, sizeof(dst), &eh->dst_addr);
- rte_ether_format_addr(src, sizeof(src), &eh->src_addr);
- printf("%s.%06lu: %s -> %s type %x length %u\n",
- tbuf, (unsigned long)h->ts.tv_usec,
- src, dst, rte_be_to_cpu_16(eh->ether_type), h->len);
+ if (rte_ipv4_cksum(ip) != 0) {
+ fprintf(stderr, "Bad IPv4 checksum\n");
+ goto error;
+ }
+
+ return; /* packet is normal */
- *countp += 1;
+error:
+ print_packet(ns, eh, h->len);
+
+ /* Stop parsing at first error */
+ pcap_breakloop(ctx->pcap);
}
/*
@@ -219,78 +306,98 @@ pkt_print(u_char *user, const struct pcap_pkthdr *h,
* but that creates an unwanted dependency.
*/
static int
-test_validate(void)
+valid_pcapng_file(const char *file_name, unsigned int expected)
{
char errbuf[PCAP_ERRBUF_SIZE];
- unsigned int count = 0;
- pcap_t *pcap;
+ struct pkt_print_ctx ctx;
int ret;
- pcap = pcap_open_offline(file_name, errbuf);
- if (pcap == NULL) {
+ ctx.count = 0;
+ ctx.pcap = pcap_open_offline_with_tstamp_precision(file_name,
+ PCAP_TSTAMP_PRECISION_NANO,
+ errbuf);
+ if (ctx.pcap == NULL) {
fprintf(stderr, "pcap_open_offline('%s') failed: %s\n",
file_name, errbuf);
return -1;
}
- ret = pcap_loop(pcap, 0, pkt_print, (u_char *)&count);
- if (ret == 0)
- printf("Saw %u packets\n", count);
- else
+ ret = pcap_loop(ctx.pcap, 0, parse_pcap_packet, (u_char *)&ctx);
+ if (ret != 0) {
fprintf(stderr, "pcap_dispatch: failed: %s\n",
- pcap_geterr(pcap));
- pcap_close(pcap);
+ pcap_geterr(ctx.pcap));
+ } else if (ctx.count != expected) {
+ printf("Only %u packets, expected %u\n",
+ ctx.count, expected);
+ ret = -1;
+ }
+
+ pcap_close(ctx.pcap);
return ret;
}
static int
-test_write_over_limit_iov_max(void)
+test_write_packets(void)
{
- struct rte_mbuf *orig;
- struct rte_mbuf *clones[IOV_MAX + NUM_PACKETS] = { };
- struct dummy_mbuf mbfs;
- unsigned int i;
- ssize_t len;
-
- /* make a dummy packet */
- mbuf1_prepare(&mbfs, pkt_len);
+ char file_name[] = "/tmp/pcapng_test_XXXXXX.pcapng";
+ static rte_pcapng_t *pcapng;
+ int ret, tmp_fd, count;
- /* clone them */
- orig = &mbfs.mb[0];
- for (i = 0; i < IOV_MAX + NUM_PACKETS; i++) {
- struct rte_mbuf *mc;
+ tmp_fd = mkstemps(file_name, strlen(".pcapng"));
+ if (tmp_fd == -1) {
+ perror("mkstemps() failure");
+ goto fail;
+ }
+ printf("pcapng: output file %s\n", file_name);
- mc = rte_pcapng_copy(port_id, 0, orig, mp, pkt_len,
- rte_get_tsc_cycles(), 0, NULL);
- if (mc == NULL) {
- fprintf(stderr, "Cannot copy packet\n");
- return -1;
- }
- clones[i] = mc;
+ /* open a test capture file */
+ pcapng = rte_pcapng_fdopen(tmp_fd, NULL, NULL, "pcapng_test", NULL);
+ if (pcapng == NULL) {
+ fprintf(stderr, "rte_pcapng_fdopen failed\n");
+ close(tmp_fd);
+ goto fail;
}
- /* write it to capture file */
- len = rte_pcapng_write_packets(pcapng, clones, IOV_MAX + NUM_PACKETS);
+ /* Add interface to the file */
+ ret = rte_pcapng_add_interface(pcapng, port_id,
+ NULL, NULL, NULL);
+ if (ret < 0) {
+ fprintf(stderr, "can not add port %u\n", port_id);
+ goto fail;
+ }
- rte_pktmbuf_free_bulk(clones, IOV_MAX + NUM_PACKETS);
+ count = fill_pcapng_file(pcapng, TOTAL_PACKETS);
+ if (count < 0)
+ goto fail;
- if (len <= 0) {
- fprintf(stderr, "Write of packets failed\n");
- return -1;
+ /* write a statistics block */
+ ret = rte_pcapng_write_stats(pcapng, port_id,
+ count, 0, "end of test");
+ if (ret <= 0) {
+ fprintf(stderr, "Write of statistics failed\n");
+ goto fail;
}
- return 0;
+ rte_pcapng_close(pcapng);
+
+ ret = valid_pcapng_file(file_name, count);
+ /* if test fails want to investigate the file */
+ if (ret == 0)
+ unlink(file_name);
+
+ return ret;
+
+fail:
+ rte_pcapng_close(pcapng);
+ return -1;
}
static void
test_cleanup(void)
{
rte_mempool_free(mp);
-
- if (pcapng)
- rte_pcapng_close(pcapng);
-
+ rte_vdev_uninit(null_dev);
}
static struct
@@ -300,9 +407,6 @@ unit_test_suite test_pcapng_suite = {
.suite_name = "Test Pcapng Unit Test Suite",
.unit_test_cases = {
TEST_CASE(test_write_packets),
- TEST_CASE(test_write_stats),
- TEST_CASE(test_validate),
- TEST_CASE(test_write_over_limit_iov_max),
TEST_CASES_END()
}
};
@@ -313,4 +417,4 @@ test_pcapng(void)
return unit_test_suite_runner(&test_pcapng_suite);
}
-REGISTER_TEST_COMMAND(pcapng_autotest, test_pcapng);
+REGISTER_FAST_TEST(pcapng_autotest, true, true, test_pcapng);