aboutsummaryrefslogtreecommitdiff
path: root/tests/sys/netmap/ctrl-api-test.c
diff options
context:
space:
mode:
Diffstat (limited to 'tests/sys/netmap/ctrl-api-test.c')
-rw-r--r--tests/sys/netmap/ctrl-api-test.c2328
1 files changed, 2328 insertions, 0 deletions
diff --git a/tests/sys/netmap/ctrl-api-test.c b/tests/sys/netmap/ctrl-api-test.c
new file mode 100644
index 000000000000..36c131980360
--- /dev/null
+++ b/tests/sys/netmap/ctrl-api-test.c
@@ -0,0 +1,2328 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * Copyright (C) 2018 Vincenzo Maffione
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * This program contains a suite of unit tests for the netmap control device.
+ *
+ * On FreeBSD, you can run these tests with Kyua once installed in the system:
+ * # kyua test -k /usr/tests/sys/netmap/Kyuafile
+ *
+ * On Linux, you can run them directly:
+ * # ./ctrl-api-test
+ */
+
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <libnetmap.h>
+#include <net/if.h>
+#include <net/netmap.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stddef.h>
+
+#ifdef __FreeBSD__
+static int
+eventfd(int x __unused, int y __unused)
+{
+ errno = ENODEV;
+ return -1;
+}
+#else /* __linux__ */
+#include <sys/eventfd.h>
+#endif
+
+#define NM_IFNAMSZ 64
+
+static int
+exec_command(int argc, const char *const argv[])
+{
+ pid_t child_pid;
+ pid_t wret;
+ int child_status;
+ int i;
+
+ printf("Executing command: ");
+ for (i = 0; i < argc - 1; i++) {
+ if (!argv[i]) {
+ /* Invalid argument. */
+ return -1;
+ }
+ if (i > 0) {
+ putchar(' ');
+ }
+ printf("%s", argv[i]);
+ }
+ putchar('\n');
+
+ child_pid = fork();
+ if (child_pid == 0) {
+ char **av;
+ int fds[3];
+
+ /* Child process. Redirect stdin, stdout
+ * and stderr. */
+ for (i = 0; i < 3; i++) {
+ close(i);
+ fds[i] = open("/dev/null", O_RDONLY);
+ if (fds[i] < 0) {
+ for (i--; i >= 0; i--) {
+ close(fds[i]);
+ }
+ return -1;
+ }
+ }
+
+ /* Make a copy of the arguments, passing them to execvp. */
+ av = calloc(argc, sizeof(av[0]));
+ if (!av) {
+ exit(EXIT_FAILURE);
+ }
+ for (i = 0; i < argc - 1; i++) {
+ av[i] = strdup(argv[i]);
+ if (!av[i]) {
+ exit(EXIT_FAILURE);
+ }
+ }
+ execvp(av[0], av);
+ perror("execvp()");
+ exit(EXIT_FAILURE);
+ }
+
+ wret = waitpid(child_pid, &child_status, 0);
+ if (wret < 0) {
+ fprintf(stderr, "waitpid() failed: %s\n", strerror(errno));
+ return wret;
+ }
+ if (WIFEXITED(child_status)) {
+ return WEXITSTATUS(child_status);
+ }
+
+ return -1;
+}
+
+
+#define THRET_SUCCESS ((void *)128)
+#define THRET_FAILURE ((void *)0)
+
+struct TestContext {
+ char ifname[NM_IFNAMSZ];
+ char ifname_ext[NM_IFNAMSZ];
+ char bdgname[NM_IFNAMSZ];
+ uint32_t nr_tx_slots; /* slots in tx rings */
+ uint32_t nr_rx_slots; /* slots in rx rings */
+ uint16_t nr_tx_rings; /* number of tx rings */
+ uint16_t nr_rx_rings; /* number of rx rings */
+ uint16_t nr_host_tx_rings; /* number of host tx rings */
+ uint16_t nr_host_rx_rings; /* number of host rx rings */
+ uint16_t nr_mem_id; /* id of the memory allocator */
+ uint16_t nr_ringid; /* ring(s) we care about */
+ uint32_t nr_mode; /* specify NR_REG_* modes */
+ uint32_t nr_extra_bufs; /* number of requested extra buffers */
+ uint64_t nr_flags; /* additional flags (see below) */
+ uint32_t nr_hdr_len; /* for PORT_HDR_SET and PORT_HDR_GET */
+ uint32_t nr_first_cpu_id; /* vale polling */
+ uint32_t nr_num_polling_cpus; /* vale polling */
+ uint32_t sync_kloop_mode; /* sync-kloop */
+ int fd; /* netmap file descriptor */
+
+ void *csb; /* CSB entries (atok and ktoa) */
+ struct nmreq_option *nr_opt; /* list of options */
+ sem_t *sem; /* for thread synchronization */
+
+ struct nmctx *nmctx;
+ const char *ifparse;
+ struct nmport_d *nmport; /* nmport descriptor from libnetmap */
+};
+
+static struct TestContext ctx_;
+
+typedef int (*testfunc_t)(struct TestContext *ctx);
+
+static void
+nmreq_hdr_init(struct nmreq_header *hdr, const char *ifname)
+{
+ memset(hdr, 0, sizeof(*hdr));
+ hdr->nr_version = NETMAP_API;
+ assert(strlen(ifname) < NM_IFNAMSZ);
+ strncpy(hdr->nr_name, ifname, sizeof(hdr->nr_name));
+}
+
+/* Single NETMAP_REQ_PORT_INFO_GET. */
+static int
+port_info_get(struct TestContext *ctx)
+{
+ struct nmreq_port_info_get req;
+ struct nmreq_header hdr;
+ int success;
+ int ret;
+
+ printf("Testing NETMAP_REQ_PORT_INFO_GET on '%s'\n", ctx->ifname_ext);
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_PORT_INFO_GET;
+ hdr.nr_body = (uintptr_t)&req;
+ memset(&req, 0, sizeof(req));
+ req.nr_mem_id = ctx->nr_mem_id;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, PORT_INFO_GET)");
+ return ret;
+ }
+ printf("nr_memsize %llu\n", (unsigned long long)req.nr_memsize);
+ printf("nr_tx_slots %u\n", req.nr_tx_slots);
+ printf("nr_rx_slots %u\n", req.nr_rx_slots);
+ printf("nr_tx_rings %u\n", req.nr_tx_rings);
+ printf("nr_rx_rings %u\n", req.nr_rx_rings);
+ printf("nr_mem_id %u\n", req.nr_mem_id);
+
+ success = req.nr_memsize && req.nr_tx_slots && req.nr_rx_slots &&
+ req.nr_tx_rings && req.nr_rx_rings && req.nr_tx_rings;
+ if (!success) {
+ return -1;
+ }
+
+ /* Write back results to the context structure. */
+ ctx->nr_tx_slots = req.nr_tx_slots;
+ ctx->nr_rx_slots = req.nr_rx_slots;
+ ctx->nr_tx_rings = req.nr_tx_rings;
+ ctx->nr_rx_rings = req.nr_rx_rings;
+ ctx->nr_mem_id = req.nr_mem_id;
+
+ return 0;
+}
+
+/* Single NETMAP_REQ_REGISTER, no use. */
+static int
+port_register(struct TestContext *ctx)
+{
+ struct nmreq_register req;
+ struct nmreq_header hdr;
+ int success;
+ int ret;
+
+ printf("Testing NETMAP_REQ_REGISTER(mode=%d,ringid=%d,"
+ "flags=0x%llx) on '%s'\n",
+ ctx->nr_mode, ctx->nr_ringid, (unsigned long long)ctx->nr_flags,
+ ctx->ifname_ext);
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_REGISTER;
+ hdr.nr_body = (uintptr_t)&req;
+ hdr.nr_options = (uintptr_t)ctx->nr_opt;
+ memset(&req, 0, sizeof(req));
+ req.nr_mem_id = ctx->nr_mem_id;
+ req.nr_mode = ctx->nr_mode;
+ req.nr_ringid = ctx->nr_ringid;
+ req.nr_flags = ctx->nr_flags;
+ req.nr_tx_slots = ctx->nr_tx_slots;
+ req.nr_rx_slots = ctx->nr_rx_slots;
+ req.nr_tx_rings = ctx->nr_tx_rings;
+ req.nr_host_tx_rings = ctx->nr_host_tx_rings;
+ req.nr_host_rx_rings = ctx->nr_host_rx_rings;
+ req.nr_rx_rings = ctx->nr_rx_rings;
+ req.nr_extra_bufs = ctx->nr_extra_bufs;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, REGISTER)");
+ return ret;
+ }
+ printf("nr_offset 0x%llx\n", (unsigned long long)req.nr_offset);
+ printf("nr_memsize %llu\n", (unsigned long long)req.nr_memsize);
+ printf("nr_tx_slots %u\n", req.nr_tx_slots);
+ printf("nr_rx_slots %u\n", req.nr_rx_slots);
+ printf("nr_tx_rings %u\n", req.nr_tx_rings);
+ printf("nr_rx_rings %u\n", req.nr_rx_rings);
+ printf("nr_host_tx_rings %u\n", req.nr_host_tx_rings);
+ printf("nr_host_rx_rings %u\n", req.nr_host_rx_rings);
+ printf("nr_mem_id %u\n", req.nr_mem_id);
+ printf("nr_extra_bufs %u\n", req.nr_extra_bufs);
+
+ success = req.nr_memsize && (ctx->nr_mode == req.nr_mode) &&
+ (ctx->nr_ringid == req.nr_ringid) &&
+ (ctx->nr_flags == req.nr_flags) &&
+ ((!ctx->nr_tx_slots && req.nr_tx_slots) ||
+ (ctx->nr_tx_slots == req.nr_tx_slots)) &&
+ ((!ctx->nr_rx_slots && req.nr_rx_slots) ||
+ (ctx->nr_rx_slots == req.nr_rx_slots)) &&
+ ((!ctx->nr_tx_rings && req.nr_tx_rings) ||
+ (ctx->nr_tx_rings == req.nr_tx_rings)) &&
+ ((!ctx->nr_rx_rings && req.nr_rx_rings) ||
+ (ctx->nr_rx_rings == req.nr_rx_rings)) &&
+ ((!ctx->nr_host_tx_rings && req.nr_host_tx_rings) ||
+ (ctx->nr_host_tx_rings == req.nr_host_tx_rings)) &&
+ ((!ctx->nr_host_rx_rings && req.nr_host_rx_rings) ||
+ (ctx->nr_host_rx_rings == req.nr_host_rx_rings)) &&
+ ((!ctx->nr_mem_id && req.nr_mem_id) ||
+ (ctx->nr_mem_id == req.nr_mem_id)) &&
+ (ctx->nr_extra_bufs == req.nr_extra_bufs);
+ if (!success) {
+ return -1;
+ }
+
+ /* Write back results to the context structure.*/
+ ctx->nr_tx_slots = req.nr_tx_slots;
+ ctx->nr_rx_slots = req.nr_rx_slots;
+ ctx->nr_tx_rings = req.nr_tx_rings;
+ ctx->nr_rx_rings = req.nr_rx_rings;
+ ctx->nr_host_tx_rings = req.nr_host_tx_rings;
+ ctx->nr_host_rx_rings = req.nr_host_rx_rings;
+ ctx->nr_mem_id = req.nr_mem_id;
+ ctx->nr_extra_bufs = req.nr_extra_bufs;
+
+ return 0;
+}
+
+static int
+niocregif(struct TestContext *ctx, int netmap_api)
+{
+ struct nmreq req;
+ int success;
+ int ret;
+
+ printf("Testing legacy NIOCREGIF on '%s'\n", ctx->ifname_ext);
+
+ memset(&req, 0, sizeof(req));
+ memcpy(req.nr_name, ctx->ifname_ext, sizeof(req.nr_name));
+ req.nr_name[sizeof(req.nr_name) - 1] = '\0';
+ req.nr_version = netmap_api;
+ req.nr_ringid = ctx->nr_ringid;
+ req.nr_flags = ctx->nr_mode | ctx->nr_flags;
+ req.nr_tx_slots = ctx->nr_tx_slots;
+ req.nr_rx_slots = ctx->nr_rx_slots;
+ req.nr_tx_rings = ctx->nr_tx_rings;
+ req.nr_rx_rings = ctx->nr_rx_rings;
+ req.nr_arg2 = ctx->nr_mem_id;
+ req.nr_arg3 = ctx->nr_extra_bufs;
+
+ ret = ioctl(ctx->fd, NIOCREGIF, &req);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCREGIF)");
+ return ret;
+ }
+
+ printf("nr_offset 0x%x\n", req.nr_offset);
+ printf("nr_memsize %u\n", req.nr_memsize);
+ printf("nr_tx_slots %u\n", req.nr_tx_slots);
+ printf("nr_rx_slots %u\n", req.nr_rx_slots);
+ printf("nr_tx_rings %u\n", req.nr_tx_rings);
+ printf("nr_rx_rings %u\n", req.nr_rx_rings);
+ printf("nr_version %d\n", req.nr_version);
+ printf("nr_ringid %x\n", req.nr_ringid);
+ printf("nr_flags %x\n", req.nr_flags);
+ printf("nr_arg2 %u\n", req.nr_arg2);
+ printf("nr_arg3 %u\n", req.nr_arg3);
+
+ success = req.nr_memsize &&
+ (ctx->nr_ringid == req.nr_ringid) &&
+ ((ctx->nr_mode | ctx->nr_flags) == req.nr_flags) &&
+ ((!ctx->nr_tx_slots && req.nr_tx_slots) ||
+ (ctx->nr_tx_slots == req.nr_tx_slots)) &&
+ ((!ctx->nr_rx_slots && req.nr_rx_slots) ||
+ (ctx->nr_rx_slots == req.nr_rx_slots)) &&
+ ((!ctx->nr_tx_rings && req.nr_tx_rings) ||
+ (ctx->nr_tx_rings == req.nr_tx_rings)) &&
+ ((!ctx->nr_rx_rings && req.nr_rx_rings) ||
+ (ctx->nr_rx_rings == req.nr_rx_rings)) &&
+ ((!ctx->nr_mem_id && req.nr_arg2) ||
+ (ctx->nr_mem_id == req.nr_arg2)) &&
+ (ctx->nr_extra_bufs == req.nr_arg3);
+ if (!success) {
+ return -1;
+ }
+
+ /* Write back results to the context structure.*/
+ ctx->nr_tx_slots = req.nr_tx_slots;
+ ctx->nr_rx_slots = req.nr_rx_slots;
+ ctx->nr_tx_rings = req.nr_tx_rings;
+ ctx->nr_rx_rings = req.nr_rx_rings;
+ ctx->nr_mem_id = req.nr_arg2;
+ ctx->nr_extra_bufs = req.nr_arg3;
+
+ return ret;
+}
+
+/* The 11 ABI is the one right before the introduction of the new NIOCCTRL
+ * ABI. The 11 ABI is useful to perform tests with legacy applications
+ * (which use the 11 ABI) and new kernel (which uses 12, or higher).
+ * However, version 14 introduced a change in the layout of struct netmap_if,
+ * so that binary backward compatibility to 11 is not supported anymore.
+ */
+#define NETMAP_API_NIOCREGIF 14
+
+static int
+legacy_regif_default(struct TestContext *ctx)
+{
+ return niocregif(ctx, NETMAP_API_NIOCREGIF);
+}
+
+static int
+legacy_regif_all_nic(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ return niocregif(ctx, NETMAP_API);
+}
+
+static int
+legacy_regif_12(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ return niocregif(ctx, NETMAP_API_NIOCREGIF+1);
+}
+
+static int
+legacy_regif_sw(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_SW;
+ return niocregif(ctx, NETMAP_API_NIOCREGIF);
+}
+
+static int
+legacy_regif_future(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_NIC_SW;
+ /* Test forward compatibility for the legacy ABI. This means
+ * using an older kernel (with ABI 12 or higher) and a newer
+ * application (with ABI greater than NETMAP_API). */
+ return niocregif(ctx, NETMAP_API+2);
+}
+
+static int
+legacy_regif_extra_bufs(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ ctx->nr_extra_bufs = 20; /* arbitrary number of extra bufs */
+ return niocregif(ctx, NETMAP_API_NIOCREGIF);
+}
+
+static int
+legacy_regif_extra_bufs_pipe(struct TestContext *ctx)
+{
+ strncat(ctx->ifname_ext, "{pipeexbuf", sizeof(ctx->ifname_ext));
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ ctx->nr_extra_bufs = 58; /* arbitrary number of extra bufs */
+
+ return niocregif(ctx, NETMAP_API_NIOCREGIF);
+}
+
+static int
+legacy_regif_extra_bufs_pipe_vale(struct TestContext *ctx)
+{
+ strncpy(ctx->ifname_ext, "valeX1:Y4", sizeof(ctx->ifname_ext));
+ return legacy_regif_extra_bufs_pipe(ctx);
+}
+
+/* Only valid after a successful port_register(). */
+static int
+num_registered_rings(struct TestContext *ctx)
+{
+ if (ctx->nr_flags & NR_TX_RINGS_ONLY) {
+ return ctx->nr_tx_rings;
+ }
+ if (ctx->nr_flags & NR_RX_RINGS_ONLY) {
+ return ctx->nr_rx_rings;
+ }
+
+ return ctx->nr_tx_rings + ctx->nr_rx_rings;
+}
+
+static int
+port_register_hwall_host(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_NIC_SW;
+ return port_register(ctx);
+}
+
+static int
+port_register_hostall(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_SW;
+ return port_register(ctx);
+}
+
+static int
+port_register_hwall(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ return port_register(ctx);
+}
+
+static int
+port_register_single_hw_pair(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ONE_NIC;
+ ctx->nr_ringid = 0;
+ return port_register(ctx);
+}
+
+static int
+port_register_single_host_pair(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ONE_SW;
+ ctx->nr_host_tx_rings = 2;
+ ctx->nr_host_rx_rings = 2;
+ ctx->nr_ringid = 1;
+ return port_register(ctx);
+}
+
+static int
+port_register_hostall_many(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_SW;
+ ctx->nr_host_tx_rings = 5;
+ ctx->nr_host_rx_rings = 4;
+ return port_register(ctx);
+}
+
+static int
+port_register_hwall_tx(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ ctx->nr_flags |= NR_TX_RINGS_ONLY;
+ return port_register(ctx);
+}
+
+static int
+port_register_hwall_rx(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ ctx->nr_flags |= NR_RX_RINGS_ONLY;
+ return port_register(ctx);
+}
+
+
+static int
+vale_mkname(char *vpname, struct TestContext *ctx)
+{
+ if (snprintf(vpname, NM_IFNAMSZ, "%s:%s", ctx->bdgname, ctx->ifname_ext) >= NM_IFNAMSZ) {
+ fprintf(stderr, "%s:%s too long (max %d chars)\n", ctx->bdgname, ctx->ifname_ext,
+ NM_IFNAMSZ - 1);
+ return -1;
+ }
+ return 0;
+}
+
+
+/* NETMAP_REQ_VALE_ATTACH */
+static int
+vale_attach(struct TestContext *ctx)
+{
+ struct nmreq_vale_attach req;
+ struct nmreq_header hdr;
+ char vpname[NM_IFNAMSZ];
+ int ret;
+
+ if (vale_mkname(vpname, ctx) < 0)
+ return -1;
+
+ printf("Testing NETMAP_REQ_VALE_ATTACH on '%s'\n", vpname);
+ nmreq_hdr_init(&hdr, vpname);
+ hdr.nr_reqtype = NETMAP_REQ_VALE_ATTACH;
+ hdr.nr_body = (uintptr_t)&req;
+ memset(&req, 0, sizeof(req));
+ req.reg.nr_mem_id = ctx->nr_mem_id;
+ if (ctx->nr_mode == 0) {
+ ctx->nr_mode = NR_REG_ALL_NIC; /* default */
+ }
+ req.reg.nr_mode = ctx->nr_mode;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, VALE_ATTACH)");
+ return ret;
+ }
+ printf("nr_mem_id %u\n", req.reg.nr_mem_id);
+
+ return ((!ctx->nr_mem_id && req.reg.nr_mem_id > 1) ||
+ (ctx->nr_mem_id == req.reg.nr_mem_id)) &&
+ (ctx->nr_flags == req.reg.nr_flags)
+ ? 0
+ : -1;
+}
+
+/* NETMAP_REQ_VALE_DETACH */
+static int
+vale_detach(struct TestContext *ctx)
+{
+ struct nmreq_header hdr;
+ struct nmreq_vale_detach req;
+ char vpname[NM_IFNAMSZ];
+ int ret;
+
+ if (vale_mkname(vpname, ctx) < 0)
+ return -1;
+
+ printf("Testing NETMAP_REQ_VALE_DETACH on '%s'\n", vpname);
+ nmreq_hdr_init(&hdr, vpname);
+ hdr.nr_reqtype = NETMAP_REQ_VALE_DETACH;
+ hdr.nr_body = (uintptr_t)&req;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, VALE_DETACH)");
+ return ret;
+ }
+
+ return 0;
+}
+
+/* First NETMAP_REQ_VALE_ATTACH, then NETMAP_REQ_VALE_DETACH. */
+static int
+vale_attach_detach(struct TestContext *ctx)
+{
+ int ret;
+
+ if ((ret = vale_attach(ctx)) != 0) {
+ return ret;
+ }
+
+ return vale_detach(ctx);
+}
+
+static int
+vale_attach_detach_host_rings(struct TestContext *ctx)
+{
+ ctx->nr_mode = NR_REG_NIC_SW;
+ return vale_attach_detach(ctx);
+}
+
+/* First NETMAP_REQ_PORT_HDR_SET and the NETMAP_REQ_PORT_HDR_GET
+ * to check that we get the same value. */
+static int
+port_hdr_set_and_get(struct TestContext *ctx)
+{
+ struct nmreq_port_hdr req;
+ struct nmreq_header hdr;
+ int ret;
+
+ printf("Testing NETMAP_REQ_PORT_HDR_SET on '%s'\n", ctx->ifname_ext);
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_PORT_HDR_SET;
+ hdr.nr_body = (uintptr_t)&req;
+ memset(&req, 0, sizeof(req));
+ req.nr_hdr_len = ctx->nr_hdr_len;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, PORT_HDR_SET)");
+ return ret;
+ }
+
+ if (req.nr_hdr_len != ctx->nr_hdr_len) {
+ return -1;
+ }
+
+ printf("Testing NETMAP_REQ_PORT_HDR_GET on '%s'\n", ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_PORT_HDR_GET;
+ req.nr_hdr_len = 0;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, PORT_HDR_SET)");
+ return ret;
+ }
+ printf("nr_hdr_len %u\n", req.nr_hdr_len);
+
+ return (req.nr_hdr_len == ctx->nr_hdr_len) ? 0 : -1;
+}
+
+/*
+ * Possible lengths for the VirtIO network header, as specified by
+ * the standard:
+ * http://docs.oasis-open.org/virtio/virtio/v1.0/cs04/virtio-v1.0-cs04.html
+ */
+#define VIRTIO_NET_HDR_LEN 10
+#define VIRTIO_NET_HDR_LEN_WITH_MERGEABLE_RXBUFS 12
+
+static int
+vale_ephemeral_port_hdr_manipulation(struct TestContext *ctx)
+{
+ int ret;
+
+ strncpy(ctx->ifname_ext, "vale:eph0", sizeof(ctx->ifname_ext));
+ ctx->nr_mode = NR_REG_ALL_NIC;
+ if ((ret = port_register(ctx))) {
+ return ret;
+ }
+ /* Try to set and get all the acceptable values. */
+ ctx->nr_hdr_len = VIRTIO_NET_HDR_LEN_WITH_MERGEABLE_RXBUFS;
+ if ((ret = port_hdr_set_and_get(ctx))) {
+ return ret;
+ }
+ ctx->nr_hdr_len = 0;
+ if ((ret = port_hdr_set_and_get(ctx))) {
+ return ret;
+ }
+ ctx->nr_hdr_len = VIRTIO_NET_HDR_LEN;
+ if ((ret = port_hdr_set_and_get(ctx))) {
+ return ret;
+ }
+ return 0;
+}
+
+static int
+vale_persistent_port(struct TestContext *ctx)
+{
+ struct nmreq_vale_newif req;
+ struct nmreq_header hdr;
+ int result;
+ int ret;
+
+ strncpy(ctx->ifname_ext, "per4", sizeof(ctx->ifname_ext));
+
+ printf("Testing NETMAP_REQ_VALE_NEWIF on '%s'\n", ctx->ifname_ext);
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_VALE_NEWIF;
+ hdr.nr_body = (uintptr_t)&req;
+ memset(&req, 0, sizeof(req));
+ req.nr_mem_id = ctx->nr_mem_id;
+ req.nr_tx_slots = ctx->nr_tx_slots;
+ req.nr_rx_slots = ctx->nr_rx_slots;
+ req.nr_tx_rings = ctx->nr_tx_rings;
+ req.nr_rx_rings = ctx->nr_rx_rings;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, VALE_NEWIF)");
+ return ret;
+ }
+
+ /* Attach the persistent VALE port to a switch and then detach. */
+ result = vale_attach_detach(ctx);
+
+ printf("Testing NETMAP_REQ_VALE_DELIF on '%s'\n", ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_VALE_DELIF;
+ hdr.nr_body = (uintptr_t)NULL;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, VALE_NEWIF)");
+ if (result == 0) {
+ result = ret;
+ }
+ }
+
+ return result;
+}
+
+/* Single NETMAP_REQ_POOLS_INFO_GET. */
+static int
+pools_info_get(struct TestContext *ctx)
+{
+ struct nmreq_pools_info req;
+ struct nmreq_header hdr;
+ int ret;
+
+ printf("Testing NETMAP_REQ_POOLS_INFO_GET on '%s'\n", ctx->ifname_ext);
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_POOLS_INFO_GET;
+ hdr.nr_body = (uintptr_t)&req;
+ memset(&req, 0, sizeof(req));
+ req.nr_mem_id = ctx->nr_mem_id;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, POOLS_INFO_GET)");
+ return ret;
+ }
+ printf("nr_memsize %llu\n", (unsigned long long)req.nr_memsize);
+ printf("nr_mem_id %u\n", req.nr_mem_id);
+ printf("nr_if_pool_offset 0x%llx\n",
+ (unsigned long long)req.nr_if_pool_offset);
+ printf("nr_if_pool_objtotal %u\n", req.nr_if_pool_objtotal);
+ printf("nr_if_pool_objsize %u\n", req.nr_if_pool_objsize);
+ printf("nr_ring_pool_offset 0x%llx\n",
+ (unsigned long long)req.nr_if_pool_offset);
+ printf("nr_ring_pool_objtotal %u\n", req.nr_ring_pool_objtotal);
+ printf("nr_ring_pool_objsize %u\n", req.nr_ring_pool_objsize);
+ printf("nr_buf_pool_offset 0x%llx\n",
+ (unsigned long long)req.nr_buf_pool_offset);
+ printf("nr_buf_pool_objtotal %u\n", req.nr_buf_pool_objtotal);
+ printf("nr_buf_pool_objsize %u\n", req.nr_buf_pool_objsize);
+
+ return req.nr_memsize && req.nr_if_pool_objtotal &&
+ req.nr_if_pool_objsize &&
+ req.nr_ring_pool_objtotal &&
+ req.nr_ring_pool_objsize &&
+ req.nr_buf_pool_objtotal &&
+ req.nr_buf_pool_objsize
+ ? 0
+ : -1;
+}
+
+static int
+pools_info_get_and_register(struct TestContext *ctx)
+{
+ int ret;
+
+ /* Check that we can get pools info before we register
+ * a netmap interface. */
+ ret = pools_info_get(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ctx->nr_mode = NR_REG_ONE_NIC;
+ ret = port_register(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ ctx->nr_mem_id = 1;
+
+ /* Check that we can get pools info also after we register. */
+ return pools_info_get(ctx);
+}
+
+static int
+pools_info_get_empty_ifname(struct TestContext *ctx)
+{
+ strncpy(ctx->ifname_ext, "", sizeof(ctx->ifname_ext));
+ return pools_info_get(ctx) != 0 ? 0 : -1;
+}
+
+static int
+pipe_master(struct TestContext *ctx)
+{
+ strncat(ctx->ifname_ext, "{pipeid1", sizeof(ctx->ifname_ext));
+ ctx->nr_mode = NR_REG_NIC_SW;
+
+ if (port_register(ctx) == 0) {
+ printf("pipes should not accept NR_REG_NIC_SW\n");
+ return -1;
+ }
+ ctx->nr_mode = NR_REG_ALL_NIC;
+
+ return port_register(ctx);
+}
+
+static int
+pipe_slave(struct TestContext *ctx)
+{
+ strncat(ctx->ifname_ext, "}pipeid2", sizeof(ctx->ifname_ext));
+ ctx->nr_mode = NR_REG_ALL_NIC;
+
+ return port_register(ctx);
+}
+
+/* Test PORT_INFO_GET and POOLS_INFO_GET on a pipe. This is useful to test the
+ * registration request used internally by netmap. */
+static int
+pipe_port_info_get(struct TestContext *ctx)
+{
+ strncat(ctx->ifname_ext, "}pipeid3", sizeof(ctx->ifname_ext));
+
+ return port_info_get(ctx);
+}
+
+static int
+pipe_pools_info_get(struct TestContext *ctx)
+{
+ strncat(ctx->ifname_ext, "{xid", sizeof(ctx->ifname_ext));
+
+ return pools_info_get(ctx);
+}
+
+/* NETMAP_REQ_VALE_POLLING_ENABLE */
+static int
+vale_polling_enable(struct TestContext *ctx)
+{
+ struct nmreq_vale_polling req;
+ struct nmreq_header hdr;
+ char vpname[NM_IFNAMSZ];
+ int ret;
+
+ if (vale_mkname(vpname, ctx) < 0)
+ return -1;
+
+ printf("Testing NETMAP_REQ_VALE_POLLING_ENABLE on '%s'\n", vpname);
+
+ nmreq_hdr_init(&hdr, vpname);
+ hdr.nr_reqtype = NETMAP_REQ_VALE_POLLING_ENABLE;
+ hdr.nr_body = (uintptr_t)&req;
+ memset(&req, 0, sizeof(req));
+ req.nr_mode = ctx->nr_mode;
+ req.nr_first_cpu_id = ctx->nr_first_cpu_id;
+ req.nr_num_polling_cpus = ctx->nr_num_polling_cpus;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, VALE_POLLING_ENABLE)");
+ return ret;
+ }
+
+ return (req.nr_mode == ctx->nr_mode &&
+ req.nr_first_cpu_id == ctx->nr_first_cpu_id &&
+ req.nr_num_polling_cpus == ctx->nr_num_polling_cpus)
+ ? 0
+ : -1;
+}
+
+/* NETMAP_REQ_VALE_POLLING_DISABLE */
+static int
+vale_polling_disable(struct TestContext *ctx)
+{
+ struct nmreq_vale_polling req;
+ struct nmreq_header hdr;
+ char vpname[NM_IFNAMSZ];
+ int ret;
+
+ if (vale_mkname(vpname, ctx) < 0)
+ return -1;
+
+ printf("Testing NETMAP_REQ_VALE_POLLING_DISABLE on '%s'\n", vpname);
+
+ nmreq_hdr_init(&hdr, vpname);
+ hdr.nr_reqtype = NETMAP_REQ_VALE_POLLING_DISABLE;
+ hdr.nr_body = (uintptr_t)&req;
+ memset(&req, 0, sizeof(req));
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, VALE_POLLING_DISABLE)");
+ return ret;
+ }
+
+ return 0;
+}
+
+static int
+vale_polling_enable_disable(struct TestContext *ctx)
+{
+ int ret = 0;
+
+ if ((ret = vale_attach(ctx)) != 0) {
+ return ret;
+ }
+
+ ctx->nr_mode = NETMAP_POLLING_MODE_SINGLE_CPU;
+ ctx->nr_num_polling_cpus = 1;
+ ctx->nr_first_cpu_id = 0;
+ if ((ret = vale_polling_enable(ctx))) {
+ vale_detach(ctx);
+#ifdef __FreeBSD__
+ /* NETMAP_REQ_VALE_POLLING_DISABLE is disabled on FreeBSD,
+ * because it is currently broken. We are happy to see that
+ * it fails. */
+ return 0;
+#else
+ return ret;
+#endif
+ }
+
+ if ((ret = vale_polling_disable(ctx))) {
+ vale_detach(ctx);
+ return ret;
+ }
+
+ return vale_detach(ctx);
+}
+
+static void
+push_option(struct nmreq_option *opt, struct TestContext *ctx)
+{
+ opt->nro_next = (uintptr_t)ctx->nr_opt;
+ ctx->nr_opt = opt;
+}
+
+static void
+clear_options(struct TestContext *ctx)
+{
+ ctx->nr_opt = NULL;
+}
+
+static int
+checkoption(struct nmreq_option *opt, struct nmreq_option *exp)
+{
+ if (opt->nro_next != exp->nro_next) {
+ printf("nro_next %p expected %p\n",
+ (void *)(uintptr_t)opt->nro_next,
+ (void *)(uintptr_t)exp->nro_next);
+ return -1;
+ }
+ if (opt->nro_reqtype != exp->nro_reqtype) {
+ printf("nro_reqtype %u expected %u\n", opt->nro_reqtype,
+ exp->nro_reqtype);
+ return -1;
+ }
+ if (opt->nro_status != exp->nro_status) {
+ printf("nro_status %u expected %u\n", opt->nro_status,
+ exp->nro_status);
+ return -1;
+ }
+ return 0;
+}
+
+static int
+unsupported_option(struct TestContext *ctx)
+{
+ struct nmreq_option opt, save;
+
+ printf("Testing unsupported option on %s\n", ctx->ifname_ext);
+
+ memset(&opt, 0, sizeof(opt));
+ opt.nro_reqtype = 1234;
+ push_option(&opt, ctx);
+ save = opt;
+
+ if (port_register_hwall(ctx) >= 0)
+ return -1;
+
+ clear_options(ctx);
+ save.nro_status = EOPNOTSUPP;
+ return checkoption(&opt, &save);
+}
+
+static int
+infinite_options(struct TestContext *ctx)
+{
+ struct nmreq_option opt;
+
+ printf("Testing infinite list of options on %s (invalid options)\n", ctx->ifname_ext);
+
+ memset(&opt, 0, sizeof(opt));
+ opt.nro_reqtype = NETMAP_REQ_OPT_MAX + 1;
+ push_option(&opt, ctx);
+ opt.nro_next = (uintptr_t)&opt;
+ if (port_register_hwall(ctx) >= 0)
+ return -1;
+ clear_options(ctx);
+ return (errno == EMSGSIZE ? 0 : -1);
+}
+
+static int
+infinite_options2(struct TestContext *ctx)
+{
+ struct nmreq_option opt;
+
+ printf("Testing infinite list of options on %s (valid options)\n", ctx->ifname_ext);
+
+ memset(&opt, 0, sizeof(opt));
+ opt.nro_reqtype = NETMAP_REQ_OPT_OFFSETS;
+ push_option(&opt, ctx);
+ opt.nro_next = (uintptr_t)&opt;
+ if (port_register_hwall(ctx) >= 0)
+ return -1;
+ clear_options(ctx);
+ return (errno == EINVAL ? 0 : -1);
+}
+
+#ifdef CONFIG_NETMAP_EXTMEM
+int
+change_param(const char *pname, unsigned long newv, unsigned long *poldv)
+{
+#ifdef __linux__
+ char param[256] = "/sys/module/netmap/parameters/";
+ unsigned long oldv;
+ FILE *f;
+
+ strncat(param, pname, sizeof(param) - 1);
+
+ f = fopen(param, "r+");
+ if (f == NULL) {
+ perror(param);
+ return -1;
+ }
+ if (fscanf(f, "%ld", &oldv) != 1) {
+ perror(param);
+ fclose(f);
+ return -1;
+ }
+ if (poldv)
+ *poldv = oldv;
+ rewind(f);
+ if (fprintf(f, "%ld\n", newv) < 0) {
+ perror(param);
+ fclose(f);
+ return -1;
+ }
+ fclose(f);
+ printf("change_param: %s: %ld -> %ld\n", pname, oldv, newv);
+#endif /* __linux__ */
+ return 0;
+}
+
+static int
+push_extmem_option(struct TestContext *ctx, const struct nmreq_pools_info *pi,
+ struct nmreq_opt_extmem *e)
+{
+ void *addr;
+
+ addr = mmap(NULL, pi->nr_memsize, PROT_READ | PROT_WRITE,
+ MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+ if (addr == MAP_FAILED) {
+ perror("mmap");
+ return -1;
+ }
+
+ memset(e, 0, sizeof(*e));
+ e->nro_opt.nro_reqtype = NETMAP_REQ_OPT_EXTMEM;
+ e->nro_info = *pi;
+ e->nro_usrptr = (uintptr_t)addr;
+
+ push_option(&e->nro_opt, ctx);
+
+ return 0;
+}
+
+static int
+pop_extmem_option(struct TestContext *ctx, struct nmreq_opt_extmem *exp)
+{
+ struct nmreq_opt_extmem *e;
+ int ret;
+
+ e = (struct nmreq_opt_extmem *)(uintptr_t)ctx->nr_opt;
+ ctx->nr_opt = (struct nmreq_option *)(uintptr_t)ctx->nr_opt->nro_next;
+
+ if ((ret = checkoption(&e->nro_opt, &exp->nro_opt))) {
+ return ret;
+ }
+
+ if (e->nro_usrptr != exp->nro_usrptr) {
+ printf("usrptr %" PRIu64 " expected %" PRIu64 "\n",
+ e->nro_usrptr, exp->nro_usrptr);
+ return -1;
+ }
+ if (e->nro_info.nr_memsize != exp->nro_info.nr_memsize) {
+ printf("memsize %" PRIu64 " expected %" PRIu64 "\n",
+ e->nro_info.nr_memsize, exp->nro_info.nr_memsize);
+ return -1;
+ }
+
+ if ((ret = munmap((void *)(uintptr_t)e->nro_usrptr,
+ e->nro_info.nr_memsize)))
+ return ret;
+
+ return 0;
+}
+
+static int
+_extmem_option(struct TestContext *ctx,
+ const struct nmreq_pools_info *pi)
+{
+ struct nmreq_opt_extmem e, save;
+ int ret;
+
+ if ((ret = push_extmem_option(ctx, pi, &e)) < 0)
+ return ret;
+
+ save = e;
+
+ strncpy(ctx->ifname_ext, "vale0:0", sizeof(ctx->ifname_ext));
+ ctx->nr_tx_slots = 16;
+ ctx->nr_rx_slots = 16;
+
+ if ((ret = port_register_hwall(ctx)))
+ return ret;
+
+ ret = pop_extmem_option(ctx, &save);
+
+ return ret;
+}
+
+static size_t
+pools_info_min_memsize(const struct nmreq_pools_info *pi)
+{
+ size_t tot = 0;
+
+ tot += pi->nr_if_pool_objtotal * pi->nr_if_pool_objsize;
+ tot += pi->nr_ring_pool_objtotal * pi->nr_ring_pool_objsize;
+ tot += pi->nr_buf_pool_objtotal * pi->nr_buf_pool_objsize;
+
+ return tot;
+}
+
+/*
+ * Fill the specification of a netmap memory allocator to be
+ * used with the 'struct nmreq_opt_extmem' option. Arbitrary
+ * values are used for the parameters, but with enough netmap
+ * rings, netmap ifs, and buffers to support a VALE port.
+ */
+static void
+pools_info_fill(struct nmreq_pools_info *pi)
+{
+ pi->nr_if_pool_objtotal = 2;
+ pi->nr_if_pool_objsize = 1024;
+ pi->nr_ring_pool_objtotal = 64;
+ pi->nr_ring_pool_objsize = 512;
+ pi->nr_buf_pool_objtotal = 4096;
+ pi->nr_buf_pool_objsize = 2048;
+ pi->nr_memsize = pools_info_min_memsize(pi);
+}
+
+static int
+extmem_option(struct TestContext *ctx)
+{
+ struct nmreq_pools_info pools_info;
+
+ pools_info_fill(&pools_info);
+
+ printf("Testing extmem option on vale0:0\n");
+ return _extmem_option(ctx, &pools_info);
+}
+
+static int
+bad_extmem_option(struct TestContext *ctx)
+{
+ struct nmreq_pools_info pools_info;
+
+ printf("Testing bad extmem option on vale0:0\n");
+
+ pools_info_fill(&pools_info);
+ /* Request a large ring size, to make sure that the kernel
+ * rejects our request. */
+ pools_info.nr_ring_pool_objsize = (1 << 20);
+
+ return _extmem_option(ctx, &pools_info) < 0 ? 0 : -1;
+}
+
+static int
+duplicate_extmem_options(struct TestContext *ctx)
+{
+ struct nmreq_opt_extmem e1, save1, e2, save2;
+ struct nmreq_pools_info pools_info;
+ int ret;
+
+ printf("Testing duplicate extmem option on vale0:0\n");
+
+ pools_info_fill(&pools_info);
+
+ if ((ret = push_extmem_option(ctx, &pools_info, &e1)) < 0)
+ return ret;
+
+ if ((ret = push_extmem_option(ctx, &pools_info, &e2)) < 0) {
+ clear_options(ctx);
+ return ret;
+ }
+
+ save1 = e1;
+ save2 = e2;
+
+ strncpy(ctx->ifname_ext, "vale0:0", sizeof(ctx->ifname_ext));
+ ctx->nr_tx_slots = 16;
+ ctx->nr_rx_slots = 16;
+
+ ret = port_register_hwall(ctx);
+ if (ret >= 0) {
+ printf("duplicate option not detected\n");
+ return -1;
+ }
+
+ save2.nro_opt.nro_status = EINVAL;
+ if ((ret = pop_extmem_option(ctx, &save2)))
+ return ret;
+
+ save1.nro_opt.nro_status = EINVAL;
+ if ((ret = pop_extmem_option(ctx, &save1)))
+ return ret;
+
+ return 0;
+}
+#endif /* CONFIG_NETMAP_EXTMEM */
+
+static int
+push_csb_option(struct TestContext *ctx, struct nmreq_opt_csb *opt)
+{
+ size_t csb_size;
+ int num_entries;
+ int ret;
+
+ ctx->nr_flags |= NR_EXCLUSIVE;
+
+ /* Get port info in order to use num_registered_rings(). */
+ ret = port_info_get(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ num_entries = num_registered_rings(ctx);
+
+ csb_size = (sizeof(struct nm_csb_atok) + sizeof(struct nm_csb_ktoa)) *
+ num_entries;
+ assert(csb_size > 0);
+ if (ctx->csb) {
+ free(ctx->csb);
+ }
+ ret = posix_memalign(&ctx->csb, sizeof(struct nm_csb_atok), csb_size);
+ if (ret != 0) {
+ printf("Failed to allocate CSB memory\n");
+ exit(EXIT_FAILURE);
+ }
+
+ memset(opt, 0, sizeof(*opt));
+ opt->nro_opt.nro_reqtype = NETMAP_REQ_OPT_CSB;
+ opt->csb_atok = (uintptr_t)ctx->csb;
+ opt->csb_ktoa = (uintptr_t)(((uint8_t *)ctx->csb) +
+ sizeof(struct nm_csb_atok) * num_entries);
+
+ printf("Pushing option NETMAP_REQ_OPT_CSB\n");
+ push_option(&opt->nro_opt, ctx);
+
+ return 0;
+}
+
+static int
+csb_mode(struct TestContext *ctx)
+{
+ struct nmreq_opt_csb opt;
+ int ret;
+
+ ret = push_csb_option(ctx, &opt);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ret = port_register_hwall(ctx);
+ clear_options(ctx);
+
+ return ret;
+}
+
+static int
+csb_mode_invalid_memory(struct TestContext *ctx)
+{
+ struct nmreq_opt_csb opt;
+ int ret;
+
+ memset(&opt, 0, sizeof(opt));
+ opt.nro_opt.nro_reqtype = NETMAP_REQ_OPT_CSB;
+ opt.csb_atok = (uintptr_t)0x10;
+ opt.csb_ktoa = (uintptr_t)0x800;
+ push_option(&opt.nro_opt, ctx);
+
+ ctx->nr_flags = NR_EXCLUSIVE;
+ ret = port_register_hwall(ctx);
+ clear_options(ctx);
+
+ return (ret < 0) ? 0 : -1;
+}
+
+static int
+sync_kloop_stop(struct TestContext *ctx)
+{
+ struct nmreq_header hdr;
+ int ret;
+
+ printf("Testing NETMAP_REQ_SYNC_KLOOP_STOP on '%s'\n", ctx->ifname_ext);
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_SYNC_KLOOP_STOP;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, SYNC_KLOOP_STOP)");
+ }
+
+ return ret;
+}
+
+static void *
+sync_kloop_worker(void *opaque)
+{
+ struct TestContext *ctx = opaque;
+ struct nmreq_sync_kloop_start req;
+ struct nmreq_header hdr;
+ int ret;
+
+ printf("Testing NETMAP_REQ_SYNC_KLOOP_START on '%s'\n", ctx->ifname_ext);
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_SYNC_KLOOP_START;
+ hdr.nr_body = (uintptr_t)&req;
+ hdr.nr_options = (uintptr_t)ctx->nr_opt;
+ memset(&req, 0, sizeof(req));
+ req.sleep_us = 500;
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, SYNC_KLOOP_START)");
+ }
+
+ if (ctx->sem) {
+ sem_post(ctx->sem);
+ }
+
+ pthread_exit(ret ? (void *)THRET_FAILURE : (void *)THRET_SUCCESS);
+}
+
+static int
+sync_kloop_start_stop(struct TestContext *ctx)
+{
+ pthread_t th;
+ void *thret = THRET_FAILURE;
+ int ret;
+
+ ret = pthread_create(&th, NULL, sync_kloop_worker, ctx);
+ if (ret != 0) {
+ printf("pthread_create(kloop): %s\n", strerror(ret));
+ return -1;
+ }
+
+ ret = sync_kloop_stop(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ret = pthread_join(th, &thret);
+ if (ret != 0) {
+ printf("pthread_join(kloop): %s\n", strerror(ret));
+ }
+
+ return thret == THRET_SUCCESS ? 0 : -1;
+}
+
+static int
+sync_kloop(struct TestContext *ctx)
+{
+ int ret;
+
+ ret = csb_mode(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+
+ return sync_kloop_start_stop(ctx);
+}
+
+static int
+sync_kloop_eventfds(struct TestContext *ctx)
+{
+ struct nmreq_opt_sync_kloop_eventfds *evopt = NULL;
+ struct nmreq_opt_sync_kloop_mode modeopt;
+ struct nmreq_option evsave;
+ int num_entries;
+ size_t opt_size;
+ int ret, i;
+
+ memset(&modeopt, 0, sizeof(modeopt));
+ modeopt.nro_opt.nro_reqtype = NETMAP_REQ_OPT_SYNC_KLOOP_MODE;
+ modeopt.mode = ctx->sync_kloop_mode;
+ push_option(&modeopt.nro_opt, ctx);
+
+ num_entries = num_registered_rings(ctx);
+ opt_size = sizeof(*evopt) + num_entries * sizeof(evopt->eventfds[0]);
+ evopt = calloc(1, opt_size);
+ evopt->nro_opt.nro_next = 0;
+ evopt->nro_opt.nro_reqtype = NETMAP_REQ_OPT_SYNC_KLOOP_EVENTFDS;
+ evopt->nro_opt.nro_status = 0;
+ evopt->nro_opt.nro_size = opt_size;
+ for (i = 0; i < num_entries; i++) {
+ int efd = eventfd(0, 0);
+
+ evopt->eventfds[i].ioeventfd = efd;
+ efd = eventfd(0, 0);
+ evopt->eventfds[i].irqfd = efd;
+ }
+
+ push_option(&evopt->nro_opt, ctx);
+ evsave = evopt->nro_opt;
+
+ ret = sync_kloop_start_stop(ctx);
+ if (ret != 0) {
+ free(evopt);
+ clear_options(ctx);
+ return ret;
+ }
+#ifdef __linux__
+ evsave.nro_status = 0;
+#else /* !__linux__ */
+ evsave.nro_status = EOPNOTSUPP;
+#endif /* !__linux__ */
+
+ ret = checkoption(&evopt->nro_opt, &evsave);
+ free(evopt);
+ clear_options(ctx);
+
+ return ret;
+}
+
+static int
+sync_kloop_eventfds_all_mode(struct TestContext *ctx,
+ uint32_t sync_kloop_mode)
+{
+ int ret;
+
+ ret = csb_mode(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ctx->sync_kloop_mode = sync_kloop_mode;
+
+ return sync_kloop_eventfds(ctx);
+}
+
+static int
+sync_kloop_eventfds_all(struct TestContext *ctx)
+{
+ return sync_kloop_eventfds_all_mode(ctx, 0);
+}
+
+static int
+sync_kloop_eventfds_all_tx(struct TestContext *ctx)
+{
+ struct nmreq_opt_csb opt;
+ int ret;
+
+ ret = push_csb_option(ctx, &opt);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ret = port_register_hwall_tx(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ clear_options(ctx);
+
+ return sync_kloop_eventfds(ctx);
+}
+
+static int
+sync_kloop_eventfds_all_direct(struct TestContext *ctx)
+{
+ return sync_kloop_eventfds_all_mode(ctx,
+ NM_OPT_SYNC_KLOOP_DIRECT_TX | NM_OPT_SYNC_KLOOP_DIRECT_RX);
+}
+
+static int
+sync_kloop_eventfds_all_direct_tx(struct TestContext *ctx)
+{
+ return sync_kloop_eventfds_all_mode(ctx,
+ NM_OPT_SYNC_KLOOP_DIRECT_TX);
+}
+
+static int
+sync_kloop_eventfds_all_direct_rx(struct TestContext *ctx)
+{
+ return sync_kloop_eventfds_all_mode(ctx,
+ NM_OPT_SYNC_KLOOP_DIRECT_RX);
+}
+
+static int
+sync_kloop_nocsb(struct TestContext *ctx)
+{
+ int ret;
+
+ ret = port_register_hwall(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+
+ /* Sync kloop must fail because we did not use
+ * NETMAP_REQ_CSB_ENABLE. */
+ return sync_kloop_start_stop(ctx) != 0 ? 0 : -1;
+}
+
+static int
+csb_enable(struct TestContext *ctx)
+{
+ struct nmreq_option saveopt;
+ struct nmreq_opt_csb opt;
+ struct nmreq_header hdr;
+ int ret;
+
+ ret = push_csb_option(ctx, &opt);
+ if (ret != 0) {
+ return ret;
+ }
+ saveopt = opt.nro_opt;
+ saveopt.nro_status = 0;
+
+ nmreq_hdr_init(&hdr, ctx->ifname_ext);
+ hdr.nr_reqtype = NETMAP_REQ_CSB_ENABLE;
+ hdr.nr_options = (uintptr_t)ctx->nr_opt;
+ hdr.nr_body = (uintptr_t)NULL;
+
+ printf("Testing NETMAP_REQ_CSB_ENABLE on '%s'\n", ctx->ifname_ext);
+
+ ret = ioctl(ctx->fd, NIOCCTRL, &hdr);
+ if (ret != 0) {
+ perror("ioctl(/dev/netmap, NIOCCTRL, CSB_ENABLE)");
+ return ret;
+ }
+
+ ret = checkoption(&opt.nro_opt, &saveopt);
+ clear_options(ctx);
+
+ return ret;
+}
+
+static int
+sync_kloop_csb_enable(struct TestContext *ctx)
+{
+ int ret;
+
+ ctx->nr_flags |= NR_EXCLUSIVE;
+ ret = port_register_hwall(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ret = csb_enable(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+
+ return sync_kloop_start_stop(ctx);
+}
+
+#if 0
+static int
+sync_kloop_conflict(struct TestContext *ctx)
+{
+ struct nmreq_opt_csb opt;
+ pthread_t th1, th2;
+ void *thret1 = THRET_FAILURE, *thret2 = THRET_FAILURE;
+ struct timespec to;
+ sem_t sem;
+ int err = 0;
+ int ret;
+
+ ret = push_csb_option(ctx, &opt);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ret = port_register_hwall(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ clear_options(ctx);
+
+ ret = sem_init(&sem, 0, 0);
+ if (ret != 0) {
+ printf("sem_init() failed: %s\n", strerror(ret));
+ return ret;
+ }
+ ctx->sem = &sem;
+
+ ret = pthread_create(&th1, NULL, sync_kloop_worker, ctx);
+ err |= ret;
+ if (ret != 0) {
+ printf("pthread_create(kloop1): %s\n", strerror(ret));
+ }
+
+ ret = pthread_create(&th2, NULL, sync_kloop_worker, ctx);
+ err |= ret;
+ if (ret != 0) {
+ printf("pthread_create(kloop2): %s\n", strerror(ret));
+ }
+
+ /* Wait for one of the two threads to fail to start the kloop, to
+ * avoid a race condition where th1 starts the loop and stops,
+ * and after that th2 starts the loop successfully. */
+ /*
+ * XXX: This doesn't fully close the race. th2 might fail to
+ * start executing since th1 can enter the kernel and hog the
+ * CPU on a single-CPU system until the semaphore timeout
+ * awakens this thread and it calls sync_kloop_stop. Once th1
+ * exits the kernel, th2 can finally run and will then loop
+ * forever in the ioctl handler.
+ */
+ clock_gettime(CLOCK_REALTIME, &to);
+ to.tv_sec += 2;
+ ret = sem_timedwait(&sem, &to);
+ err |= ret;
+ if (ret != 0) {
+ printf("sem_timedwait() failed: %s\n", strerror(errno));
+ }
+
+ err |= sync_kloop_stop(ctx);
+
+ ret = pthread_join(th1, &thret1);
+ err |= ret;
+ if (ret != 0) {
+ printf("pthread_join(kloop1): %s\n", strerror(ret));
+ }
+
+ ret = pthread_join(th2, &thret2);
+ err |= ret;
+ if (ret != 0) {
+ printf("pthread_join(kloop2): %s %d\n", strerror(ret), ret);
+ }
+
+ sem_destroy(&sem);
+ ctx->sem = NULL;
+ if (err) {
+ return err;
+ }
+
+ /* Check that one of the two failed, while the other one succeeded. */
+ return ((thret1 == THRET_SUCCESS && thret2 == THRET_FAILURE) ||
+ (thret1 == THRET_FAILURE && thret2 == THRET_SUCCESS))
+ ? 0
+ : -1;
+}
+#endif
+
+static int
+sync_kloop_eventfds_mismatch(struct TestContext *ctx)
+{
+ struct nmreq_opt_csb opt;
+ int ret;
+
+ ret = push_csb_option(ctx, &opt);
+ if (ret != 0) {
+ return ret;
+ }
+
+ ret = port_register_hwall_rx(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ clear_options(ctx);
+
+ /* Deceive num_registered_rings() to trigger a failure of
+ * sync_kloop_eventfds(). The latter will think that all the
+ * rings were registered, and allocate the wrong number of
+ * eventfds. */
+ ctx->nr_flags &= ~NR_RX_RINGS_ONLY;
+
+ return (sync_kloop_eventfds(ctx) != 0) ? 0 : -1;
+}
+
+static int
+null_port(struct TestContext *ctx)
+{
+ int ret;
+
+ ctx->nr_mem_id = 1;
+ ctx->nr_mode = NR_REG_NULL;
+ ctx->nr_tx_rings = 10;
+ ctx->nr_rx_rings = 5;
+ ctx->nr_tx_slots = 256;
+ ctx->nr_rx_slots = 100;
+ ret = port_register(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ return 0;
+}
+
+static int
+null_port_all_zero(struct TestContext *ctx)
+{
+ int ret;
+
+ ctx->nr_mem_id = 1;
+ ctx->nr_mode = NR_REG_NULL;
+ ctx->nr_tx_rings = 0;
+ ctx->nr_rx_rings = 0;
+ ctx->nr_tx_slots = 0;
+ ctx->nr_rx_slots = 0;
+ ret = port_register(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ return 0;
+}
+
+static int
+null_port_sync(struct TestContext *ctx)
+{
+ int ret;
+
+ ctx->nr_mem_id = 1;
+ ctx->nr_mode = NR_REG_NULL;
+ ctx->nr_tx_rings = 10;
+ ctx->nr_rx_rings = 5;
+ ctx->nr_tx_slots = 256;
+ ctx->nr_rx_slots = 100;
+ ret = port_register(ctx);
+ if (ret != 0) {
+ return ret;
+ }
+ ret = ioctl(ctx->fd, NIOCTXSYNC, 0);
+ if (ret != 0) {
+ return ret;
+ }
+ return 0;
+}
+
+struct nmreq_parse_test {
+ const char *ifname;
+ const char *exp_port;
+ const char *exp_suff;
+ int exp_error;
+ uint32_t exp_mode;
+ uint16_t exp_ringid;
+ uint64_t exp_flags;
+};
+
+static struct nmreq_parse_test nmreq_parse_tests[] = {
+ /* port spec is the input. The expected results are as follows:
+ * - port: what should go into hdr.nr_name
+ * - suff: the trailing part of the input after parsing (NULL means equal to port spec)
+ * - err: the expected return value, interpreted as follows
+ * err > 0 => nmreq_header_parse should fail with the given error
+ * err < 0 => nrmeq_header_parse should succeed, but nmreq_register_decode should
+ * fail with error |err|
+ * err = 0 => should succeed
+ * - mode, ringid flags: what should go into the corresponding nr_* fields in the
+ * nmreq_register struct in case of success
+ */
+
+ /*port spec*/ /*port*/ /*suff*/ /*err*/ /*mode*/ /*ringid*/ /*flags*/
+ { "netmap:eth0", "eth0", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "netmap:eth0-1", "eth0", "", 0, NR_REG_ONE_NIC, 1, 0 },
+ { "netmap:eth0-", "eth0", "-", -EINVAL,0, 0, 0 },
+ { "netmap:eth0/x", "eth0", "", 0, NR_REG_ALL_NIC, 0, NR_EXCLUSIVE },
+ { "netmap:eth0/z", "eth0", "", 0, NR_REG_ALL_NIC, 0, NR_ZCOPY_MON },
+ { "netmap:eth0/r", "eth0", "", 0, NR_REG_ALL_NIC, 0, NR_MONITOR_RX },
+ { "netmap:eth0/t", "eth0", "", 0, NR_REG_ALL_NIC, 0, NR_MONITOR_TX },
+ { "netmap:eth0-2/Tx", "eth0", "", 0, NR_REG_ONE_NIC, 2, NR_TX_RINGS_ONLY|NR_EXCLUSIVE },
+ { "netmap:eth0*", "eth0", "", 0, NR_REG_NIC_SW, 0, 0 },
+ { "netmap:eth0^", "eth0", "", 0, NR_REG_SW, 0, 0 },
+ { "netmap:eth0@2", "eth0", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "netmap:eth0@2/R", "eth0", "", 0, NR_REG_ALL_NIC, 0, NR_RX_RINGS_ONLY },
+ { "netmap:eth0@netmap:lo/R", "eth0", "@netmap:lo/R", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "netmap:eth0/R@xxx", "eth0", "@xxx", 0, NR_REG_ALL_NIC, 0, NR_RX_RINGS_ONLY },
+ { "netmap:eth0@2/R@2", "eth0", "", 0, NR_REG_ALL_NIC, 0, NR_RX_RINGS_ONLY },
+ { "netmap:eth0@2/R@3", "eth0", "@2/R@3", -EINVAL,0, 0, 0 },
+ { "netmap:eth0@", "eth0", "@", -EINVAL,0, 0, 0 },
+ { "netmap:", "", NULL, EINVAL, 0, 0, 0 },
+ { "netmap:^", "", NULL, EINVAL, 0, 0, 0 },
+ { "netmap:{", "", NULL, EINVAL, 0, 0, 0 },
+ { "eth0", NULL, NULL, EINVAL, 0, 0, 0 },
+ { "vale0:0", "vale0:0", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "vale:0", "vale:0", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "valeXXX:YYY", "valeXXX:YYY", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "valeXXX:YYY-4", "valeXXX:YYY", "", 0, NR_REG_ONE_NIC, 4, 0 },
+ { "netmapXXX:eth0", NULL, NULL, EINVAL, 0, 0, 0 },
+ { "netmap:14", "14", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "netmap:pipe{0", "pipe{0", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "netmap:pipe{in", "pipe{in", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "netmap:pipe{in-7", "pipe{in", "", 0, NR_REG_ONE_NIC, 7, 0 },
+ { "vale0:0{0", "vale0:0{0", "", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "netmap:pipe{1}2", NULL, NULL, EINVAL, 0, 0, 0 },
+ { "vale0:0@opt", "vale0:0", "@opt", 0, NR_REG_ALL_NIC, 0, 0 },
+ { "vale0:0/Tx@opt", "vale0:0", "@opt", 0, NR_REG_ALL_NIC, 0, NR_TX_RINGS_ONLY|NR_EXCLUSIVE },
+ { "vale0:0-3@opt", "vale0:0", "@opt", 0, NR_REG_ONE_NIC, 3, 0 },
+ { "vale0:0@", "vale0:0", "@", -EINVAL,0, 0, 0 },
+ { "", NULL, NULL, EINVAL, 0, 0, 0 },
+ { NULL, NULL, NULL, 0, 0, 0, 0 },
+};
+
+static void
+randomize(void *dst, size_t n)
+{
+ size_t i;
+ char *dst_ = dst;
+
+ for (i = 0; i < n; i++)
+ dst_[i] = (char)random();
+}
+
+static int
+nmreq_hdr_parsing(struct TestContext *ctx,
+ struct nmreq_parse_test *t,
+ struct nmreq_header *hdr)
+{
+ const char *save;
+ struct nmreq_header orig_hdr;
+
+ save = ctx->ifparse = t->ifname;
+ orig_hdr = *hdr;
+
+ printf("nmreq_header: \"%s\"\n", ctx->ifparse);
+ if (nmreq_header_decode(&ctx->ifparse, hdr, ctx->nmctx) < 0) {
+ if (t->exp_error > 0) {
+ if (errno != t->exp_error) {
+ printf("!!! got errno=%d, want %d\n",
+ errno, t->exp_error);
+ return -1;
+ }
+ if (ctx->ifparse != save) {
+ printf("!!! parse error, but first arg changed\n");
+ return -1;
+ }
+ if (memcmp(&orig_hdr, hdr, sizeof(*hdr))) {
+ printf("!!! parse error, but header changed\n");
+ return -1;
+ }
+ return 0;
+ }
+ printf ("!!! nmreq_header_decode was expected to succeed, but it failed with error %d\n", errno);
+ return -1;
+ }
+ if (t->exp_error > 0) {
+ printf("!!! nmreq_header_decode returns 0, but error %d was expected\n", t->exp_error);
+ return -1;
+ }
+ if (strcmp(t->exp_port, hdr->nr_name) != 0) {
+ printf("!!! got '%s', want '%s'\n", hdr->nr_name, t->exp_port);
+ return -1;
+ }
+ if (hdr->nr_reqtype != orig_hdr.nr_reqtype ||
+ hdr->nr_options != orig_hdr.nr_options ||
+ hdr->nr_body != orig_hdr.nr_body) {
+ printf("!!! some fields of the nmreq_header where changed unexpectedly\n");
+ return -1;
+ }
+ return 0;
+}
+
+static int
+nmreq_reg_parsing(struct TestContext *ctx,
+ struct nmreq_parse_test *t,
+ struct nmreq_register *reg)
+{
+ const char *save;
+ struct nmreq_register orig_reg;
+
+
+ save = ctx->ifparse;
+ orig_reg = *reg;
+
+ printf("nmreq_register: \"%s\"\n", ctx->ifparse);
+ if (nmreq_register_decode(&ctx->ifparse, reg, ctx->nmctx) < 0) {
+ if (t->exp_error < 0) {
+ if (errno != -t->exp_error) {
+ printf("!!! got errno=%d, want %d\n",
+ errno, -t->exp_error);
+ return -1;
+ }
+ if (ctx->ifparse != save) {
+ printf("!!! parse error, but first arg changed\n");
+ return -1;
+ }
+ if (memcmp(&orig_reg, reg, sizeof(*reg))) {
+ printf("!!! parse error, but nmreq_register changed\n");
+ return -1;
+ }
+ return 0;
+ }
+ printf ("!!! parse failed but it should have succeeded\n");
+ return -1;
+ }
+ if (t->exp_error < 0) {
+ printf("!!! nmreq_register_decode returns 0, but error %d was expected\n", -t->exp_error);
+ return -1;
+ }
+ if (reg->nr_mode != t->exp_mode) {
+ printf("!!! got nr_mode '%d', want '%d'\n", reg->nr_mode, t->exp_mode);
+ return -1;
+ }
+ if (reg->nr_ringid != t->exp_ringid) {
+ printf("!!! got nr_ringid '%d', want '%d'\n", reg->nr_ringid, t->exp_ringid);
+ return -1;
+ }
+ if (reg->nr_flags != t->exp_flags) {
+ printf("!!! got nm_flags '%llx', want '%llx\n", (unsigned long long)reg->nr_flags,
+ (unsigned long long)t->exp_flags);
+ return -1;
+ }
+ if (reg->nr_offset != orig_reg.nr_offset ||
+ reg->nr_memsize != orig_reg.nr_memsize ||
+ reg->nr_tx_slots != orig_reg.nr_tx_slots ||
+ reg->nr_rx_slots != orig_reg.nr_rx_slots ||
+ reg->nr_tx_rings != orig_reg.nr_tx_rings ||
+ reg->nr_rx_rings != orig_reg.nr_rx_rings ||
+ reg->nr_extra_bufs != orig_reg.nr_extra_bufs)
+ {
+ printf("!!! some fields of the nmreq_register where changed unexpectedly\n");
+ return -1;
+ }
+ return 0;
+}
+
+static void
+nmctx_parsing_error(struct nmctx *ctx, const char *msg)
+{
+ (void)ctx;
+ printf(" got message: %s\n", msg);
+}
+
+static int
+nmreq_parsing(struct TestContext *ctx)
+{
+ struct nmreq_parse_test *t;
+ struct nmreq_header hdr;
+ struct nmreq_register reg;
+ struct nmctx test_nmctx, *nmctx;
+ int ret = 0;
+
+ nmctx = nmctx_get();
+ if (nmctx == NULL) {
+ printf("Failed to acquire nmctx: %s", strerror(errno));
+ return -1;
+ }
+ test_nmctx = *nmctx;
+ test_nmctx.error = nmctx_parsing_error;
+ ctx->nmctx = &test_nmctx;
+ for (t = nmreq_parse_tests; t->ifname != NULL; t++) {
+ const char *exp_suff = t->exp_suff != NULL ?
+ t->exp_suff : t->ifname;
+
+ randomize(&hdr, sizeof(hdr));
+ randomize(&reg, sizeof(reg));
+ reg.nr_mem_id = 0;
+ if (nmreq_hdr_parsing(ctx, t, &hdr) < 0) {
+ ret = -1;
+ } else if (t->exp_error <= 0 && nmreq_reg_parsing(ctx, t, &reg) < 0) {
+ ret = -1;
+ }
+ if (strcmp(ctx->ifparse, exp_suff) != 0) {
+ printf("!!! string suffix after parse is '%s', but it should be '%s'\n",
+ ctx->ifparse, exp_suff);
+ ret = -1;
+ }
+ }
+ ctx->nmctx = NULL;
+ return ret;
+}
+
+static int
+binarycomp(struct TestContext *ctx)
+{
+#define ckroff(f, o) do {\
+ if (offsetof(struct netmap_ring, f) != (o)) {\
+ printf("offset of netmap_ring.%s is %zd, but it should be %d",\
+ #f, offsetof(struct netmap_ring, f), (o));\
+ return -1;\
+ }\
+} while (0)
+
+ (void)ctx;
+
+ ckroff(buf_ofs, 0);
+ ckroff(num_slots, 8);
+ ckroff(nr_buf_size, 12);
+ ckroff(ringid, 16);
+ ckroff(dir, 18);
+ ckroff(head, 20);
+ ckroff(cur, 24);
+ ckroff(tail, 28);
+ ckroff(flags, 32);
+ ckroff(ts, 40);
+ ckroff(offset_mask, 56);
+ ckroff(buf_align, 64);
+ ckroff(sem, 128);
+ ckroff(slot, 256);
+
+ return 0;
+}
+
+static void
+usage(const char *prog)
+{
+ printf("%s -i IFNAME\n"
+ "[-j TEST_NUM1[-[TEST_NUM2]] | -[TEST_NUM_2]]\n"
+ "[-l (list test cases)]\n",
+ prog);
+}
+
+struct mytest {
+ testfunc_t test;
+ const char *name;
+};
+
+#define decltest(f) \
+ { \
+ .test = f, .name = #f \
+ }
+
+static struct mytest tests[] = {
+ decltest(port_info_get),
+ decltest(port_register_hwall_host),
+ decltest(port_register_hwall),
+ decltest(port_register_hostall),
+ decltest(port_register_single_hw_pair),
+ decltest(port_register_single_host_pair),
+ decltest(port_register_hostall_many),
+ decltest(vale_attach_detach),
+ decltest(vale_attach_detach_host_rings),
+ decltest(vale_ephemeral_port_hdr_manipulation),
+ decltest(vale_persistent_port),
+ decltest(pools_info_get_and_register),
+ decltest(pools_info_get_empty_ifname),
+ decltest(pipe_master),
+ decltest(pipe_slave),
+ decltest(pipe_port_info_get),
+ decltest(pipe_pools_info_get),
+ decltest(vale_polling_enable_disable),
+ decltest(unsupported_option),
+ decltest(infinite_options),
+ decltest(infinite_options2),
+#ifdef CONFIG_NETMAP_EXTMEM
+ decltest(extmem_option),
+ decltest(bad_extmem_option),
+ decltest(duplicate_extmem_options),
+#endif /* CONFIG_NETMAP_EXTMEM */
+ decltest(csb_mode),
+ decltest(csb_mode_invalid_memory),
+ decltest(sync_kloop),
+ decltest(sync_kloop_eventfds_all),
+ decltest(sync_kloop_eventfds_all_tx),
+ decltest(sync_kloop_eventfds_all_direct),
+ decltest(sync_kloop_eventfds_all_direct_tx),
+ decltest(sync_kloop_eventfds_all_direct_rx),
+ decltest(sync_kloop_nocsb),
+ decltest(sync_kloop_csb_enable),
+#if 0
+ decltest(sync_kloop_conflict),
+#endif
+ decltest(sync_kloop_eventfds_mismatch),
+ decltest(null_port),
+ decltest(null_port_all_zero),
+ decltest(null_port_sync),
+ decltest(legacy_regif_default),
+ decltest(legacy_regif_all_nic),
+ decltest(legacy_regif_12),
+ decltest(legacy_regif_sw),
+ decltest(legacy_regif_future),
+ decltest(legacy_regif_extra_bufs),
+ decltest(legacy_regif_extra_bufs_pipe),
+ decltest(legacy_regif_extra_bufs_pipe_vale),
+ decltest(nmreq_parsing),
+ decltest(binarycomp),
+};
+
+static void
+context_cleanup(struct TestContext *ctx)
+{
+ if (ctx->csb) {
+ free(ctx->csb);
+ ctx->csb = NULL;
+ }
+
+ close(ctx->fd);
+ ctx->fd = -1;
+}
+
+static int
+parse_interval(const char *arg, int *j, int *k)
+{
+ const char *scan = arg;
+ char *rest;
+
+ *j = 0;
+ *k = -1;
+ if (*scan == '-') {
+ scan++;
+ goto get_k;
+ }
+ if (!isdigit(*scan))
+ goto err;
+ *k = strtol(scan, &rest, 10);
+ *j = *k - 1;
+ scan = rest;
+ if (*scan == '-') {
+ *k = -1;
+ scan++;
+ }
+get_k:
+ if (*scan == '\0')
+ return 0;
+ if (!isdigit(*scan))
+ goto err;
+ *k = strtol(scan, &rest, 10);
+ scan = rest;
+ if (!(*scan == '\0'))
+ goto err;
+
+ return 0;
+
+err:
+ fprintf(stderr, "syntax error in '%s', must be num[-[num]] or -[num]\n", arg);
+ return -1;
+}
+
+#define ARGV_APPEND(_av, _ac, _x)\
+ do {\
+ assert((int)(_ac) < (int)(sizeof(_av)/sizeof((_av)[0])));\
+ (_av)[(_ac)++] = _x;\
+ } while (0)
+
+static void
+tap_cleanup(int signo)
+{
+ const char *av[8];
+ int ac = 0;
+
+ (void)signo;
+#ifdef __FreeBSD__
+ ARGV_APPEND(av, ac, "ifconfig");
+ ARGV_APPEND(av, ac, ctx_.ifname);
+ ARGV_APPEND(av, ac, "destroy");
+#else
+ ARGV_APPEND(av, ac, "ip");
+ ARGV_APPEND(av, ac, "link");
+ ARGV_APPEND(av, ac, "del");
+ ARGV_APPEND(av, ac, ctx_.ifname);
+#endif
+ ARGV_APPEND(av, ac, NULL);
+ if (exec_command(ac, av)) {
+ printf("Failed to destroy tap interface\n");
+ }
+}
+
+int
+main(int argc, char **argv)
+{
+ int create_tap = 1;
+ int num_tests;
+ int ret = 0;
+ int j = 0;
+ int k = -1;
+ int list = 0;
+ int opt;
+ int i;
+
+ memset(&ctx_, 0, sizeof(ctx_));
+
+ {
+ struct timespec t;
+ int idx;
+
+ clock_gettime(CLOCK_REALTIME, &t);
+ srand((unsigned int)t.tv_nsec);
+ idx = rand() % 8000 + 100;
+ snprintf(ctx_.ifname, sizeof(ctx_.ifname), "tap%d", idx);
+ idx = rand() % 800 + 100;
+ snprintf(ctx_.bdgname, sizeof(ctx_.bdgname), "vale%d", idx);
+ }
+
+ while ((opt = getopt(argc, argv, "hi:j:l")) != -1) {
+ switch (opt) {
+ case 'h':
+ usage(argv[0]);
+ return 0;
+
+ case 'i':
+ strncpy(ctx_.ifname, optarg, sizeof(ctx_.ifname) - 1);
+ create_tap = 0;
+ break;
+
+ case 'j':
+ if (parse_interval(optarg, &j, &k) < 0) {
+ usage(argv[0]);
+ return -1;
+ }
+ break;
+
+ case 'l':
+ list = 1;
+ create_tap = 0;
+ break;
+
+ default:
+ printf(" Unrecognized option %c\n", opt);
+ usage(argv[0]);
+ return -1;
+ }
+ }
+
+ num_tests = sizeof(tests) / sizeof(tests[0]);
+
+ if (j < 0 || j >= num_tests || k > num_tests) {
+ fprintf(stderr, "Test interval %d-%d out of range (%d-%d)\n",
+ j + 1, k, 1, num_tests + 1);
+ return -1;
+ }
+
+ if (k < 0)
+ k = num_tests;
+
+ if (list) {
+ printf("Available tests:\n");
+ for (i = 0; i < num_tests; i++) {
+ printf("#%03d: %s\n", i + 1, tests[i].name);
+ }
+ return 0;
+ }
+
+ if (create_tap) {
+ struct sigaction sa;
+ const char *av[8];
+ int ac = 0;
+#ifdef __FreeBSD__
+ ARGV_APPEND(av, ac, "ifconfig");
+ ARGV_APPEND(av, ac, ctx_.ifname);
+ ARGV_APPEND(av, ac, "create");
+ ARGV_APPEND(av, ac, "up");
+#else
+ ARGV_APPEND(av, ac, "ip");
+ ARGV_APPEND(av, ac, "tuntap");
+ ARGV_APPEND(av, ac, "add");
+ ARGV_APPEND(av, ac, "mode");
+ ARGV_APPEND(av, ac, "tap");
+ ARGV_APPEND(av, ac, "name");
+ ARGV_APPEND(av, ac, ctx_.ifname);
+#endif
+ ARGV_APPEND(av, ac, NULL);
+ if (exec_command(ac, av)) {
+ printf("Failed to create tap interface\n");
+ return -1;
+ }
+
+ sa.sa_handler = tap_cleanup;
+ sigemptyset(&sa.sa_mask);
+ sa.sa_flags = SA_RESTART;
+ ret = sigaction(SIGINT, &sa, NULL);
+ if (ret) {
+ perror("sigaction(SIGINT)");
+ goto out;
+ }
+ ret = sigaction(SIGTERM, &sa, NULL);
+ if (ret) {
+ perror("sigaction(SIGTERM)");
+ goto out;
+ }
+ }
+
+ for (i = j; i < k; i++) {
+ struct TestContext ctxcopy;
+ int fd;
+ printf("==> Start of Test #%d [%s]\n", i + 1, tests[i].name);
+ fd = open("/dev/netmap", O_RDWR);
+ if (fd < 0) {
+ perror("open(/dev/netmap)");
+ ret = fd;
+ goto out;
+ }
+ memcpy(&ctxcopy, &ctx_, sizeof(ctxcopy));
+ ctxcopy.fd = fd;
+ memcpy(ctxcopy.ifname_ext, ctxcopy.ifname,
+ sizeof(ctxcopy.ifname));
+ ret = tests[i].test(&ctxcopy);
+ if (ret != 0) {
+ printf("Test #%d [%s] failed\n", i + 1, tests[i].name);
+ goto out;
+ }
+ printf("==> Test #%d [%s] successful\n", i + 1, tests[i].name);
+ context_cleanup(&ctxcopy);
+ }
+out:
+ tap_cleanup(0);
+
+ return ret;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-09 22:11:29 +0000