F: examples/bond/
Linux KNI
-M: Helin Zhang <helin.zhang@intel.com>
+M: Ferruh Yigit <ferruh.yigit@intel.com>
F: lib/librte_eal/linuxapp/kni/
F: lib/librte_kni/
F: doc/guides/prog_guide/kernel_nic_interface.rst
#include <rte_ring.h>
#include <rte_pdump.h>
+#define CMD_LINE_OPT_PDUMP "pdump"
#define PDUMP_PORT_ARG "port"
#define PDUMP_PCI_ARG "device_id"
#define PDUMP_QUEUE_ARG "queue"
#define PDUMP_RING_SIZE_ARG "ring-size"
#define PDUMP_MSIZE_ARG "mbuf-size"
#define PDUMP_NUM_MBUFS_ARG "total-num-mbufs"
+#define CMD_LINE_OPT_SER_SOCK_PATH "server-socket-path"
+#define CMD_LINE_OPT_CLI_SOCK_PATH "client-socket-path"
#define VDEV_PCAP "eth_pcap_%s_%d,tx_pcap=%s"
#define VDEV_IFACE "eth_pcap_%s_%d,tx_iface=%s"
int num_tuples;
static struct rte_eth_conf port_conf_default;
volatile uint8_t quit_signal;
+static char server_socket_path[PATH_MAX];
+static char client_socket_path[PATH_MAX];
/**< display usage */
static void
" tx-dev=<iface or pcap file>,"
"[ring-size=<ring size>default:16384],"
"[mbuf-size=<mbuf data size>default:2176],"
- "[total-num-mbufs=<number of mbufs>default:65535]"
- "'\n",
+ "[total-num-mbufs=<number of mbufs>default:65535]'\n"
+ "[--server-socket-path=<server socket dir>"
+ "default:/var/run/.dpdk/ (or) ~/.dpdk/]\n"
+ "[--client-socket-path=<client socket dir>"
+ "default:/var/run/.dpdk/ (or) ~/.dpdk/]\n",
prgname);
}
/* identify the tx stream type for pcap vdev */
if (if_nametoindex(pt->tx_dev))
pt->tx_vdev_stream_type = IFACE;
- } else {
- printf("invalid dev type %s, must be rx or tx\n", value);
- return -1;
}
return 0;
int option_index;
static struct option long_option[] = {
{"pdump", 1, 0, 0},
+ {"server-socket-path", 1, 0, 0},
+ {"client-socket-path", 1, 0, 0},
{NULL, 0, 0, 0}
};
long_option, &option_index)) != EOF) {
switch (opt) {
case 0:
- if (!strncmp(long_option[option_index].name, "pdump",
- MAX_LONG_OPT_SZ)) {
+ if (!strncmp(long_option[option_index].name,
+ CMD_LINE_OPT_PDUMP,
+ sizeof(CMD_LINE_OPT_PDUMP))) {
ret = parse_pdump(optarg);
if (ret) {
pdump_usage(prgname);
return -1;
}
}
+
+ if (!strncmp(long_option[option_index].name,
+ CMD_LINE_OPT_SER_SOCK_PATH,
+ sizeof(CMD_LINE_OPT_SER_SOCK_PATH))) {
+ snprintf(server_socket_path,
+ sizeof(server_socket_path), "%s",
+ optarg);
+ }
+
+ if (!strncmp(long_option[option_index].name,
+ CMD_LINE_OPT_CLI_SOCK_PATH,
+ sizeof(CMD_LINE_OPT_CLI_SOCK_PATH))) {
+ snprintf(client_socket_path,
+ sizeof(client_socket_path), "%s",
+ optarg);
+ }
+
break;
default:
pdump_usage(prgname);
struct pdump_tuples *pt;
int ret = 0, ret1 = 0;
+ if (server_socket_path[0] != 0)
+ ret = rte_pdump_set_socket_dir(server_socket_path,
+ RTE_PDUMP_SOCKET_SERVER);
+ if (ret == 0 && client_socket_path[0] != 0) {
+ ret = rte_pdump_set_socket_dir(client_socket_path,
+ RTE_PDUMP_SOCKET_CLIENT);
+ }
+ if (ret < 0) {
+ cleanup_pdump_resources();
+ rte_exit(EXIT_FAILURE,
+ "failed to set socket paths of server:%s, "
+ "client:%s\n",
+ server_socket_path,
+ client_socket_path);
+ }
+
for (i = 0; i < num_tuples; i++) {
pt = &pdump_t[i];
if (pt->dir == RTE_PDUMP_FLAG_RXTX) {
RTE_PDUMP_FLAG_RX,
pt->rx_ring,
pt->mp, NULL);
- ret = rte_pdump_enable_by_deviceid(
+ ret1 = rte_pdump_enable_by_deviceid(
pt->device_id,
pt->queue,
RTE_PDUMP_FLAG_TX,
timer_tsc += diff_tsc;
} while ((nb_rx > 0) &&
(timer_tsc < timer_period));
- prev_tsc = cur_tsc;
timer_tsc = 0;
}
}
ifeq ($(CONFIG_RTE_APP_TEST),y)
+# default rule
+all:
+
# Define an externally linked resource. A linked resource is an arbitrary
# file that is linked into the test binary. The application refers to this
# resource by name. The linked generates identifiers beg_<name> and end_<name>
"Func" : default_autotest,
"Report" : None,
},
- {
- "Name" : "Dump rings",
- "Command" : "dump_ring",
- "Func" : dump_autotest,
- "Report" : None,
- },
- {
- "Name" : "Dump mempools",
- "Command" : "dump_mempool",
- "Func" : dump_autotest,
- "Report" : None,
- },
]
},
{
# The main logic behind running autotests in parallel
-import multiprocessing, sys, pexpect, time, os, StringIO, csv
+import multiprocessing, subprocess, sys, pexpect, re, time, os, StringIO, csv
# wait for prompt
def wait_prompt(child):
results.append((0, "Success", "Start %s" % test_group["Prefix"],
time.time() - start_time, startuplog.getvalue(), None))
+ # parse the binary for available test commands
+ binary = cmdline.split()[0]
+ symbols = subprocess.check_output(['nm', binary]).decode('utf-8')
+ avail_cmds = re.findall('test_register_(\w+)', symbols)
+
# run all tests in test group
for test in test_group["Tests"]:
print >>logfile, "\n%s %s\n" % ("-"*20, test["Name"])
# run test function associated with the test
- result = test["Func"](child, test["Command"])
+ if test["Command"] in avail_cmds:
+ result = test["Func"](child, test["Command"])
+ else:
+ result = (0, "Skipped [Not Available]")
# make a note when the test was finished
end_time = time.time()
void add_test_command(struct test_command *t);
-#define REGISTER_TEST_COMMAND(t) \
-static void __attribute__((used)) testfn_##t(void);\
-void __attribute__((constructor, used)) testfn_##t(void)\
-{\
- add_test_command(&t);\
-}
+/* Register a test function with its command string */
+#define REGISTER_TEST_COMMAND(cmd, func) \
+ static struct test_command test_struct_##cmd = { \
+ .command = RTE_STR(cmd), \
+ .callback = func, \
+ }; \
+ static void __attribute__((constructor, used)) \
+ test_register_##cmd(void) \
+ { \
+ add_test_command(&test_struct_##cmd); \
+ }
#endif
return 0;
}
-static struct test_command acl_cmd = {
- .command = "acl_autotest",
- .callback = test_acl,
-};
-REGISTER_TEST_COMMAND(acl_cmd);
+REGISTER_TEST_COMMAND(acl_autotest, test_acl);
return 0;
}
-static struct test_command alarm_cmd = {
- .command = "alarm_autotest",
- .callback = test_alarm,
-};
-REGISTER_TEST_COMMAND(alarm_cmd);
+REGISTER_TEST_COMMAND(alarm_autotest, test_alarm);
return 0;
}
-static struct test_command atomic_cmd = {
- .command = "atomic_autotest",
- .callback = test_atomic,
-};
-REGISTER_TEST_COMMAND(atomic_cmd);
+REGISTER_TEST_COMMAND(atomic_autotest, test_atomic);
return 0;
}
-static struct test_command byteorder_cmd = {
- .command = "byteorder_autotest",
- .callback = test_byteorder,
-};
-REGISTER_TEST_COMMAND(byteorder_cmd);
+REGISTER_TEST_COMMAND(byteorder_autotest, test_byteorder);
return 0;
}
-static struct test_command cmdline_cmd = {
- .command = "cmdline_autotest",
- .callback = test_cmdline,
-};
-REGISTER_TEST_COMMAND(cmdline_cmd);
+REGISTER_TEST_COMMAND(cmdline_autotest, test_cmdline);
return ret;
}
-static struct test_command common_cmd = {
- .command = "common_autotest",
- .callback = test_common,
-};
-REGISTER_TEST_COMMAND(common_cmd);
+REGISTER_TEST_COMMAND(common_autotest, test_common);
return 0;
}
-static struct test_command cpuflags_cmd = {
- .command = "cpuflags_autotest",
- .callback = test_cpuflags,
-};
-REGISTER_TEST_COMMAND(cpuflags_cmd);
+REGISTER_TEST_COMMAND(cpuflags_autotest, test_cpuflags);
gbl_cryptodev_type = RTE_CRYPTODEV_QAT_SYM_PMD;
return unit_test_suite_runner(&cryptodev_qat_testsuite);
}
-static struct test_command cryptodev_qat_cmd = {
- .command = "cryptodev_qat_autotest",
- .callback = test_cryptodev_qat,
-};
static int
test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
return unit_test_suite_runner(&cryptodev_aesni_mb_testsuite);
}
-static struct test_command cryptodev_aesni_mb_cmd = {
- .command = "cryptodev_aesni_mb_autotest",
- .callback = test_cryptodev_aesni_mb,
-};
-
static int
test_cryptodev_aesni_gcm(void)
{
return unit_test_suite_runner(&cryptodev_aesni_gcm_testsuite);
}
-static struct test_command cryptodev_aesni_gcm_cmd = {
- .command = "cryptodev_aesni_gcm_autotest",
- .callback = test_cryptodev_aesni_gcm,
-};
-
static int
test_cryptodev_null(void)
{
return unit_test_suite_runner(&cryptodev_null_testsuite);
}
-static struct test_command cryptodev_null_cmd = {
- .command = "cryptodev_null_autotest",
- .callback = test_cryptodev_null,
-};
-
static int
test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
{
return unit_test_suite_runner(&cryptodev_sw_snow3g_testsuite);
}
-static struct test_command cryptodev_sw_snow3g_cmd = {
- .command = "cryptodev_sw_snow3g_autotest",
- .callback = test_cryptodev_sw_snow3g,
-};
-
static int
test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
{
return unit_test_suite_runner(&cryptodev_sw_kasumi_testsuite);
}
-static struct test_command cryptodev_sw_kasumi_cmd = {
- .command = "cryptodev_sw_kasumi_autotest",
- .callback = test_cryptodev_sw_kasumi,
-};
-
-REGISTER_TEST_COMMAND(cryptodev_qat_cmd);
-REGISTER_TEST_COMMAND(cryptodev_aesni_mb_cmd);
-REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_cmd);
-REGISTER_TEST_COMMAND(cryptodev_null_cmd);
-REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_cmd);
-REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_cmd);
+REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
+REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
+REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
+REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
+REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
+REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
}
-static struct test_command cryptodev_aesni_mb_perf_cmd = {
- .command = "cryptodev_aesni_mb_perftest",
- .callback = perftest_aesni_mb_cryptodev,
-};
-
-static struct test_command cryptodev_qat_perf_cmd = {
- .command = "cryptodev_qat_perftest",
- .callback = perftest_qat_cryptodev,
-};
-
-static struct test_command cryptodev_sw_snow3g_perf_cmd = {
- .command = "cryptodev_sw_snow3g_perftest",
- .callback = perftest_sw_snow3g_cryptodev,
-};
-
-static struct test_command cryptodev_qat_snow3g_perf_cmd = {
- .command = "cryptodev_qat_snow3g_perftest",
- .callback = perftest_qat_snow3g_cryptodev,
-};
-
-REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perf_cmd);
-REGISTER_TEST_COMMAND(cryptodev_qat_perf_cmd);
-REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perf_cmd);
-REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perf_cmd);
+REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
+REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
+REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
+REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
return 0;
}
-static struct test_command cycles_cmd = {
- .command = "cycles_autotest",
- .callback = test_cycles,
-};
-REGISTER_TEST_COMMAND(cycles_cmd);
+REGISTER_TEST_COMMAND(cycles_autotest, test_cycles);
return 0;
}
-static struct test_command debug_cmd = {
- .command = "debug_autotest",
- .callback = test_debug,
-};
-REGISTER_TEST_COMMAND(debug_cmd);
+REGISTER_TEST_COMMAND(debug_autotest, test_debug);
return -1;
}
-static struct test_command devargs_cmd = {
- .command = "devargs_autotest",
- .callback = test_devargs,
-};
-REGISTER_TEST_COMMAND(devargs_cmd);
+REGISTER_TEST_COMMAND(devargs_autotest, test_devargs);
return -1;
}
-static struct test_command distributor_cmd = {
- .command = "distributor_autotest",
- .callback = test_distributor,
-};
-REGISTER_TEST_COMMAND(distributor_cmd);
+REGISTER_TEST_COMMAND(distributor_autotest, test_distributor);
return 0;
}
-static struct test_command distributor_perf_cmd = {
- .command = "distributor_perf_autotest",
- .callback = test_distributor_perf,
-};
-REGISTER_TEST_COMMAND(distributor_perf_cmd);
+REGISTER_TEST_COMMAND(distributor_perf_autotest, test_distributor_perf);
return ret;
}
-static struct test_command eal_flags_cmd = {
- .command = "eal_flags_autotest",
- .callback = test_eal_flags,
-};
-REGISTER_TEST_COMMAND(eal_flags_cmd);
+REGISTER_TEST_COMMAND(eal_flags_autotest, test_eal_flags);
return 0;
}
-static struct test_command eal_fs_cmd = {
- .command = "eal_fs_autotest",
- .callback = test_eal_fs,
-};
-REGISTER_TEST_COMMAND(eal_fs_cmd);
+REGISTER_TEST_COMMAND(eal_fs_autotest, test_eal_fs);
return 0;
}
-static struct test_command errno_cmd = {
- .command = "errno_autotest",
- .callback = test_errno,
-};
-REGISTER_TEST_COMMAND(errno_cmd);
+REGISTER_TEST_COMMAND(errno_autotest, test_errno);
return 0;
}
-static struct test_command func_reentrancy_cmd = {
- .command = "func_reentrancy_autotest",
- .callback = test_func_reentrancy,
-};
-REGISTER_TEST_COMMAND(func_reentrancy_cmd);
+REGISTER_TEST_COMMAND(func_reentrancy_autotest, test_func_reentrancy);
return 0;
}
-static struct test_command hash_cmd = {
- .command = "hash_autotest",
- .callback = test_hash,
-};
-REGISTER_TEST_COMMAND(hash_cmd);
+REGISTER_TEST_COMMAND(hash_autotest, test_hash);
return 0;
}
-static struct test_command hash_functions_cmd = {
- .command = "hash_functions_autotest",
- .callback = test_hash_functions,
-};
-REGISTER_TEST_COMMAND(hash_functions_cmd);
+REGISTER_TEST_COMMAND(hash_functions_autotest, test_hash_functions);
return r;
}
-
-static struct test_command hash_scaling_cmd = {
- .command = "hash_multiwriter_autotest",
- .callback = test_hash_multiwriter_main,
-};
-
-REGISTER_TEST_COMMAND(hash_scaling_cmd);
+REGISTER_TEST_COMMAND(hash_multiwriter_autotest, test_hash_multiwriter_main);
return 0;
}
-static struct test_command hash_perf_cmd = {
- .command = "hash_perf_autotest",
- .callback = test_hash_perf,
-};
-REGISTER_TEST_COMMAND(hash_perf_cmd);
+REGISTER_TEST_COMMAND(hash_perf_autotest, test_hash_perf);
return r;
}
-
-static struct test_command hash_scaling_cmd = {
- .command = "hash_scaling_autotest",
- .callback = test_hash_scaling_main,
-};
-REGISTER_TEST_COMMAND(hash_scaling_cmd);
+REGISTER_TEST_COMMAND(hash_scaling_autotest, test_hash_scaling_main);
return ret;
}
-static struct test_command interrupt_cmd = {
- .command = "interrupt_autotest",
- .callback = test_interrupt,
-};
-REGISTER_TEST_COMMAND(interrupt_cmd);
+REGISTER_TEST_COMMAND(interrupt_autotest, test_interrupt);
return -1;
}
-static struct test_command ivshmem_cmd = {
- .command = "ivshmem_autotest",
- .callback = test_ivshmem,
-};
-REGISTER_TEST_COMMAND(ivshmem_cmd);
+REGISTER_TEST_COMMAND(ivshmem_autotest, test_ivshmem);
return ret;
}
-static struct test_command kni_cmd = {
- .command = "kni_autotest",
- .callback = test_kni,
-};
-REGISTER_TEST_COMMAND(kni_cmd);
+REGISTER_TEST_COMMAND(kni_autotest, test_kni);
return 0;
}
-static struct test_command kvargs_cmd = {
- .command = "kvargs_autotest",
- .callback = test_kvargs,
-};
-REGISTER_TEST_COMMAND(kvargs_cmd);
+REGISTER_TEST_COMMAND(kvargs_autotest, test_kvargs);
return unit_test_suite_runner(&link_bonding_test_suite);
}
-static struct test_command link_bonding_cmd = {
- .command = "link_bonding_autotest",
- .callback = test_link_bonding,
-};
-REGISTER_TEST_COMMAND(link_bonding_cmd);
+REGISTER_TEST_COMMAND(link_bonding_autotest, test_link_bonding);
return unit_test_suite_runner(&link_bonding_mode4_test_suite);
}
-static struct test_command link_bonding_cmd = {
- .command = "link_bonding_mode4_autotest",
- .callback = test_link_bonding_mode4,
-};
-
-REGISTER_TEST_COMMAND(link_bonding_cmd);
+REGISTER_TEST_COMMAND(link_bonding_mode4_autotest, test_link_bonding_mode4);
return unit_test_suite_runner(&link_bonding_rssconf_test_suite);
}
-static struct test_command test_link_bonding_rssconf_cmd = {
- .command = "link_bonding_rssconf_autotest",
- .callback = test_link_bonding_rssconf,
-};
-
-REGISTER_TEST_COMMAND(test_link_bonding_rssconf_cmd);
+REGISTER_TEST_COMMAND(link_bonding_rssconf_autotest, test_link_bonding_rssconf);
return 0;
}
-static struct test_command logs_cmd = {
- .command = "logs_autotest",
- .callback = test_logs,
-};
-REGISTER_TEST_COMMAND(logs_cmd);
+REGISTER_TEST_COMMAND(logs_autotest, test_logs);
return global_status;
}
-static struct test_command lpm_cmd = {
- .command = "lpm_autotest",
- .callback = test_lpm,
-};
-REGISTER_TEST_COMMAND(lpm_cmd);
+REGISTER_TEST_COMMAND(lpm_autotest, test_lpm);
return global_status;
}
-static struct test_command lpm6_cmd = {
- .command = "lpm6_autotest",
- .callback = test_lpm6,
-};
-REGISTER_TEST_COMMAND(lpm6_cmd);
+REGISTER_TEST_COMMAND(lpm6_autotest, test_lpm6);
return 0;
}
-static struct test_command lpm6_perf_cmd = {
- .command = "lpm6_perf_autotest",
- .callback = test_lpm6_perf,
-};
-REGISTER_TEST_COMMAND(lpm6_perf_cmd);
+REGISTER_TEST_COMMAND(lpm6_perf_autotest, test_lpm6_perf);
return 0;
}
-static struct test_command lpm_perf_cmd = {
- .command = "lpm_perf_autotest",
- .callback = test_lpm_perf,
-};
-REGISTER_TEST_COMMAND(lpm_perf_cmd);
+REGISTER_TEST_COMMAND(lpm_perf_autotest, test_lpm_perf);
return 0;
}
-static struct test_command malloc_cmd = {
- .command = "malloc_autotest",
- .callback = test_malloc,
-};
-REGISTER_TEST_COMMAND(malloc_cmd);
+REGISTER_TEST_COMMAND(malloc_autotest, test_malloc);
return 0;
}
-static struct test_command mbuf_cmd = {
- .command = "mbuf_autotest",
- .callback = test_mbuf,
-};
-REGISTER_TEST_COMMAND(mbuf_cmd);
+REGISTER_TEST_COMMAND(mbuf_autotest, test_mbuf);
return 0;
}
-static struct test_command memcpy_cmd = {
- .command = "memcpy_autotest",
- .callback = test_memcpy,
-};
-REGISTER_TEST_COMMAND(memcpy_cmd);
+REGISTER_TEST_COMMAND(memcpy_autotest, test_memcpy);
return 0;
}
-static struct test_command memcpy_perf_cmd = {
- .command = "memcpy_perf_autotest",
- .callback = test_memcpy_perf,
-};
-REGISTER_TEST_COMMAND(memcpy_perf_cmd);
+REGISTER_TEST_COMMAND(memcpy_perf_autotest, test_memcpy_perf);
return 0;
}
-static struct test_command memory_cmd = {
- .command = "memory_autotest",
- .callback = test_memory,
-};
-REGISTER_TEST_COMMAND(memory_cmd);
+REGISTER_TEST_COMMAND(memory_autotest, test_memory);
return -1;
}
-static struct test_command mempool_cmd = {
- .command = "mempool_autotest",
- .callback = test_mempool,
-};
-REGISTER_TEST_COMMAND(mempool_cmd);
+REGISTER_TEST_COMMAND(mempool_autotest, test_mempool);
return 0;
}
-static struct test_command mempool_perf_cmd = {
- .command = "mempool_perf_autotest",
- .callback = test_mempool_perf,
-};
-REGISTER_TEST_COMMAND(mempool_perf_cmd);
+REGISTER_TEST_COMMAND(mempool_perf_autotest, test_mempool_perf);
return 0;
}
-static struct test_command memzone_cmd = {
- .command = "memzone_autotest",
- .callback = test_memzone,
-};
-REGISTER_TEST_COMMAND(memzone_cmd);
+REGISTER_TEST_COMMAND(memzone_autotest, test_memzone);
}
-static struct test_command meter_cmd = {
- .command = "meter_autotest",
- .callback = test_meter,
-};
-REGISTER_TEST_COMMAND(meter_cmd);
+REGISTER_TEST_COMMAND(meter_autotest, test_meter);
return run_object_creation_tests();
}
-static struct test_command multiprocess_cmd = {
- .command = "multiprocess_autotest",
- .callback = test_mp_secondary,
-};
-REGISTER_TEST_COMMAND(multiprocess_cmd);
+REGISTER_TEST_COMMAND(multiprocess_autotest, test_mp_secondary);
return 0;
}
-static struct test_command pci_cmd = {
- .command = "pci_autotest",
- .callback = test_pci,
-};
-REGISTER_TEST_COMMAND(pci_cmd);
+REGISTER_TEST_COMMAND(pci_autotest, test_pci);
return 0;
}
-static struct test_command per_lcore_cmd = {
- .command = "per_lcore_autotest",
- .callback = test_per_lcore,
-};
-REGISTER_TEST_COMMAND(per_lcore_cmd);
+REGISTER_TEST_COMMAND(per_lcore_autotest, test_per_lcore);
return -1;
}
-static struct test_command pmd_perf_cmd = {
- .command = "pmd_perf_autotest",
- .callback = test_pmd_perf,
-};
-REGISTER_TEST_COMMAND(pmd_perf_cmd);
+REGISTER_TEST_COMMAND(pmd_perf_autotest, test_pmd_perf);
return 0;
}
-static struct test_command ring_pmd_cmd = {
- .command = "ring_pmd_autotest",
- .callback = test_pmd_ring,
-};
-REGISTER_TEST_COMMAND(ring_pmd_cmd);
+REGISTER_TEST_COMMAND(ring_pmd_autotest, test_pmd_ring);
return 0;
}
-static struct test_command ring_pmd_perf_cmd = {
- .command = "ring_pmd_perf_autotest",
- .callback = test_ring_pmd_perf,
-};
-REGISTER_TEST_COMMAND(ring_pmd_perf_cmd);
+REGISTER_TEST_COMMAND(ring_pmd_perf_autotest, test_ring_pmd_perf);
return -1;
}
-static struct test_command power_cmd = {
- .command = "power_autotest",
- .callback = test_power,
-};
-REGISTER_TEST_COMMAND(power_cmd);
+REGISTER_TEST_COMMAND(power_autotest, test_power);
return -1;
}
-static struct test_command power_acpi_cpufreq_cmd = {
- .command = "power_acpi_cpufreq_autotest",
- .callback = test_power_acpi_cpufreq,
-};
-REGISTER_TEST_COMMAND(power_acpi_cpufreq_cmd);
+REGISTER_TEST_COMMAND(power_acpi_cpufreq_autotest, test_power_acpi_cpufreq);
return -1;
}
-static struct test_command power_kvm_vm_cmd = {
- .command = "power_kvm_vm_autotest",
- .callback = test_power_kvm_vm,
-};
-REGISTER_TEST_COMMAND(power_kvm_vm_cmd);
+REGISTER_TEST_COMMAND(power_kvm_vm_autotest, test_power_kvm_vm);
return 0;
}
-static struct test_command prefetch_cmd = {
- .command = "prefetch_autotest",
- .callback = test_prefetch,
-};
-REGISTER_TEST_COMMAND(prefetch_cmd);
+REGISTER_TEST_COMMAND(prefetch_autotest, test_prefetch);
return tell_the_result(num_tests, num_pass);
}
-static struct test_command red_cmd = {
- .command = "red_autotest",
- .callback = test_red,
-};
-REGISTER_TEST_COMMAND(red_cmd);
-
-static struct test_command red_cmd_perf = {
- .command = "red_perf",
- .callback = test_red_perf,
-};
-REGISTER_TEST_COMMAND(red_cmd_perf);
-
-static struct test_command red_cmd_all = {
- .command = "red_all",
- .callback = test_red_all,
-};
-REGISTER_TEST_COMMAND(red_cmd_all);
+REGISTER_TEST_COMMAND(red_autotest, test_red);
+REGISTER_TEST_COMMAND(red_perf, test_red_perf);
+REGISTER_TEST_COMMAND(red_all, test_red_all);
return unit_test_suite_runner(&reorder_test_suite);
}
-static struct test_command reorder_cmd = {
- .command = "reorder_autotest",
- .callback = test_reorder,
-};
-REGISTER_TEST_COMMAND(reorder_cmd);
+REGISTER_TEST_COMMAND(reorder_autotest, test_reorder);
return 0;
}
-static struct test_command resource_cmd = {
- .command = "resource_autotest",
- .callback = test_resource,
-};
-REGISTER_TEST_COMMAND(resource_cmd);
+REGISTER_TEST_COMMAND(resource_autotest, test_resource);
return 0;
}
-static struct test_command ring_cmd = {
- .command = "ring_autotest",
- .callback = test_ring,
-};
-REGISTER_TEST_COMMAND(ring_cmd);
+REGISTER_TEST_COMMAND(ring_autotest, test_ring);
return 0;
}
-static struct test_command ring_perf_cmd = {
- .command = "ring_perf_autotest",
- .callback = test_ring_perf,
-};
-REGISTER_TEST_COMMAND(ring_perf_cmd);
+REGISTER_TEST_COMMAND(ring_perf_autotest, test_ring_perf);
return 0;
}
-static struct test_command rwlock_cmd = {
- .command = "rwlock_autotest",
- .callback = test_rwlock,
-};
-REGISTER_TEST_COMMAND(rwlock_cmd);
+REGISTER_TEST_COMMAND(rwlock_autotest, test_rwlock);
return 0;
}
-static struct test_command sched_cmd = {
- .command = "sched_autotest",
- .callback = test_sched,
-};
-REGISTER_TEST_COMMAND(sched_cmd);
+REGISTER_TEST_COMMAND(sched_autotest, test_sched);
return ret;
}
-static struct test_command spinlock_cmd = {
- .command = "spinlock_autotest",
- .callback = test_spinlock,
-};
-REGISTER_TEST_COMMAND(spinlock_cmd);
+REGISTER_TEST_COMMAND(spinlock_autotest, test_spinlock);
return 0;
}
-static struct test_command string_cmd = {
- .command = "string_autotest",
- .callback = test_string_fns,
-};
-REGISTER_TEST_COMMAND(string_cmd);
+REGISTER_TEST_COMMAND(string_autotest, test_string_fns);
return 0;
}
-static struct test_command table_cmd = {
- .command = "table_autotest",
- .callback = test_table,
-};
-REGISTER_TEST_COMMAND(table_cmd);
+REGISTER_TEST_COMMAND(table_autotest, test_table);
return ret;
}
-static struct test_command tailq_cmd = {
- .command = "tailq_autotest",
- .callback = test_tailq,
-};
-REGISTER_TEST_COMMAND(tailq_cmd);
+REGISTER_TEST_COMMAND(tailq_autotest, test_tailq);
return 0;
}
-static struct test_command thash_cmd = {
- .command = "thash_autotest",
- .callback = test_thash,
-};
-REGISTER_TEST_COMMAND(thash_cmd);
+REGISTER_TEST_COMMAND(thash_autotest, test_thash);
return TEST_SUCCESS;
}
-static struct test_command timer_cmd = {
- .command = "timer_autotest",
- .callback = test_timer,
-};
-REGISTER_TEST_COMMAND(timer_cmd);
+REGISTER_TEST_COMMAND(timer_autotest, test_timer);
return 0;
}
-static struct test_command timer_perf_cmd = {
- .command = "timer_perf_autotest",
- .callback = test_timer_perf,
-};
-REGISTER_TEST_COMMAND(timer_perf_cmd);
+REGISTER_TEST_COMMAND(timer_perf_autotest, test_timer_perf);
return TEST_SUCCESS;
}
-static struct test_command timer_racecond_cmd = {
- .command = "timer_racecond_autotest",
- .callback = test_timer_racecond,
-};
-REGISTER_TEST_COMMAND(timer_racecond_cmd);
+REGISTER_TEST_COMMAND(timer_racecond_autotest, test_timer_racecond);
return 0;
}
-static struct test_command version_cmd = {
- .command = "version_autotest",
- .callback = test_version,
-};
-REGISTER_TEST_COMMAND(version_cmd);
+REGISTER_TEST_COMMAND(version_autotest, test_version);
* Patches are reviewed publicly on the mailing list.
* Successfully reviewed patches are merged to the master branch of the repository.
-The mailing list for DPDK development is `dev@dpkg.org <http://dpdk.org/ml/archives/dev/>`_.
+The mailing list for DPDK development is `dev@dpdk.org <http://dpdk.org/ml/archives/dev/>`_.
Contributors will need to `register for the mailing list <http://dpdk.org/ml/listinfo/dev>`_ in order to submit patches.
It is also worth registering for the DPDK `Patchwork <http://dpdk.org/dev/patchwxispork/project/dpdk/list/>`_
be preempted by another pthread doing a multi-consumer dequeue on
the same ring.
- Bypassing this constraint it may cause the 2nd pthread to spin until the 1st one is scheduled again.
+ Bypassing this constraint may cause the 2nd pthread to spin until the 1st one is scheduled again.
Moreover, if the 1st pthread is preempted by a context that has an higher priority, it may even cause a dead lock.
This does not mean it cannot be used, simply, there is a need to narrow down the situation when it is used by multi-pthread on the same core.
The packet capture framework, as part of its initialization, creates the pthread and the server socket in
the pthread. The application that calls the framework initialization will have the server socket created,
-either under the path that the application has passed or under the default path i.e. either ``/var/run`` for
-root user or ``$HOME`` for non root user.
+either under the path that the application has passed or under the default path i.e. either ``/var/run/.dpdk`` for
+root user or ``~/.dpdk`` for non root user.
Applications that request enabling or disabling of the packet capture will have the client socket created either under
-the path that the application has passed or under the default path i.e. either ``/var/run/`` for root user or ``$HOME``
-for not root user to send the requests to the server.
-The server socket will listen for client requests for enabling or disabling the packet capture.
+the path that the application has passed or under the default path i.e. either ``/var/run/.dpdk`` for root user or
+``~/.dpdk`` for not root user to send the requests to the server. The server socket will listen for client requests for
+enabling or disabling the packet capture.
Implementation Details
The library API ``rte_pdump_set_socket_dir()``, sets the given path as either server socket path
or client socket path based on the ``type`` argument of the API.
-If the given path is ``NULL``, default path will be selected, i.e. either ``/var/run/`` for root user or ``$HOME``
+If the given path is ``NULL``, default path will be selected, i.e. either ``/var/run/.dpdk`` for root user or ``~/.dpdk``
for non root user. Clients also need to call this API to set their server socket path if the server socket
path is different from default path.
The initial state is to have a prod_head and prod_tail pointing at the same location.
-Multiple Consumer Enqueue First Step
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multiple Producers Enqueue First Step
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
On both cores, *ring->prod_head* and ring->cons_tail are copied in local variables.
The prod_next local variable points to the next element of the table,
.. figure:: img/ring-mp-enqueue1.*
- Multiple consumer enqueue first step
+ Multiple producer enqueue first step
-Multiple Consumer Enqueue Second Step
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multiple Producers Enqueue Second Step
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The second step is to modify ring->prod_head in the ring structure to point to the same location as prod_next.
This operation is done using a Compare And Swap (CAS) instruction, which does the following operations atomically:
.. figure:: img/ring-mp-enqueue2.*
- Multiple consumer enqueue second step
+ Multiple producer enqueue second step
-Multiple Consumer Enqueue Third Step
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multiple Producers Enqueue Third Step
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The CAS operation is retried on core 2 with success.
.. figure:: img/ring-mp-enqueue3.*
- Multiple consumer enqueue third step
+ Multiple producer enqueue third step
-Multiple Consumer Enqueue Fourth Step
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multiple Producers Enqueue Fourth Step
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Each core now wants to update ring->prod_tail.
A core can only update it if ring->prod_tail is equal to the prod_head local variable.
.. figure:: img/ring-mp-enqueue4.*
- Multiple consumer enqueue fourth step
+ Multiple producer enqueue fourth step
-Multiple Consumer Enqueue Last Step
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Multiple Producers Enqueue Last Step
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Once ring->prod_tail is updated by core 1, core 2 is allowed to update it too.
The operation is also finished on core 2.
.. figure:: img/ring-mp-enqueue5.*
- Multiple consumer enqueue last step
+ Multiple producer enqueue last step
Modulo 32-bit Indexes
librte_mbuf.so.2
+ librte_mempool.so.2
librte_meter.so.1
+ librte_pdump.so.1
librte_pipeline.so.3
librte_pmd_bond.so.1
librte_pmd_ring.so.2
dpdk_pdump Application
======================
-The ``dpdk_pdump`` application is a Data Plane Development Kit (DPDK) application that runs as a DPDK secondary process and
-is capable of enabling packet capture on dpdk ports.
+The ``dpdk_pdump`` tool is a Data Plane Development Kit (DPDK) tool that runs as
+a DPDK secondary process and is capable of enabling packet capture on dpdk ports.
+
+ .. Note::
+
+ * The ``dpdk_pdump`` tool depends on libpcap based PMD which is disabled
+ by default in the build configuration files,
+ owing to an external dependency on the libpcap development files
+ which must be installed on the board.
+ Once the libpcap development files are installed, the libpcap based PMD
+ can be enabled by setting CONFIG_RTE_LIBRTE_PMD_PCAP=y and recompiling the DPDK.
Running the Application
-----------------------
-The application has a ``--pdump`` command line option with various sub arguments:
+The tool has a number of command line options:
.. code-block:: console
[ring-size=<ring size>],
[mbuf-size=<mbuf data size>],
[total-num-mbufs=<number of mbufs>]'
+ [--server-socket-path=<server socket dir>]
+ [--client-socket-path=<client socket dir>]
+
+The ``--pdump`` command line option is mandatory and it takes various sub arguments which are described in
+below section.
+
+ .. Note::
+
+ * Parameters inside the parentheses represents mandatory parameters.
-Note:
+ * Parameters inside the square brackets represents optional parameters.
-* Parameters inside the parentheses represents mandatory parameters.
+ * Multiple instances of ``--pdump`` can be passed to capture packets on different port and queue combinations.
-* Parameters inside the square brackets represents optional parameters.
+The ``--server-socket-path`` command line option is optional. This represents the server socket directory.
+If no value is passed default values are used i.e. ``/var/run/.dpdk/`` for root users and ``~/.dpdk/``
+for non root users.
-Multiple instances of ``--pdump`` can be passed to capture packets on different port and queue combinations.
+The ``--client-socket-path`` command line option is optional. This represents the client socket directory.
+If no value is passed default values are used i.e. ``/var/run/.dpdk/`` for root users and ``~/.dpdk/``
+for non root users.
-Parameters
-~~~~~~~~~~
+The ``--pdump`` parameters
+~~~~~~~~~~~~~~~~~~~~~~~~~~
``port``:
Port id of the eth device on which packets should be captured.
#define DRV_NAME "enic_pmd"
#define DRV_DESCRIPTION "Cisco VIC Ethernet NIC Poll-mode Driver"
-#define DRV_VERSION "1.0.0.6"
#define DRV_COPYRIGHT "Copyright 2008-2015 Cisco Systems, Inc"
#define ENIC_WQ_MAX 8
pos = rte_hash_add_key(enic->fdir.hash, params);
if (pos < 0) {
+ enic->fdir.stats.f_add++;
dev_err(enic, "Add hash key failed\n");
return pos;
}
if (!enic->cq[index].ctrl)
break;
}
-
if (enic->cq_count != index)
return 0;
+ for (index = 0; index < enic->wq_count; index++) {
+ if (!enic->wq[index].ctrl)
+ break;
+ }
+ if (enic->wq_count != index)
+ return 0;
+ /* check start of packet (SOP) RQs only in case scatter is disabled. */
+ for (index = 0; index < enic->rq_count; index++) {
+ if (!enic->rq[enic_sop_rq(index)].ctrl)
+ break;
+ }
+ if (enic->rq_count != index)
+ return 0;
ret = enic_alloc_intr_resources(enic);
if (ret) {
ENICPMD_FUNC_TRACE();
enic_start_wq(enic, queue_idx);
- eth_dev->data->tx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STARTED;
return 0;
}
ret = enic_stop_wq(enic, queue_idx);
if (ret)
dev_err(enic, "error in stopping wq %d\n", queue_idx);
- else
- eth_dev->data->tx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STOPPED;
return ret;
}
ENICPMD_FUNC_TRACE();
enic_start_rq(enic, queue_idx);
- eth_dev->data->rx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STARTED;
return 0;
}
ret = enic_stop_rq(enic, queue_idx);
if (ret)
dev_err(enic, "error in stopping rq %d\n", queue_idx);
- else
- eth_dev->data->rx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STOPPED;
return ret;
}
{
struct rte_mbuf *mbuf = (struct rte_mbuf *)buf->mb;
- rte_mempool_put(mbuf->pool, mbuf);
+ rte_pktmbuf_free_seg(mbuf);
buf->mb = NULL;
}
}
for (i = 0; i < enic_vnic_rq_count(enic); i++) {
+ if (!enic->rq[i].in_use)
+ continue;
error_status = vnic_rq_error_status(&enic->rq[i]);
if (error_status)
dev_err(enic, "RQ[%d] error_status %d\n", i,
* which can make ibytes be slightly higher than it should be.
*/
rx_packet_errors = rte_atomic64_read(&soft_stats->rx_packet_errors);
- rx_truncated = rx_packet_errors - stats->rx.rx_errors;
+ rx_truncated = rx_packet_errors - stats->rx.rx_errors -
+ stats->rx.rx_no_bufs;
r_stats->ipackets = stats->rx.rx_frames_ok - rx_truncated;
r_stats->opackets = stats->tx.tx_frames_ok;
void enic_start_wq(struct enic *enic, uint16_t queue_idx)
{
+ struct rte_eth_dev *eth_dev = enic->rte_dev;
vnic_wq_enable(&enic->wq[queue_idx]);
+ eth_dev->data->tx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STARTED;
}
int enic_stop_wq(struct enic *enic, uint16_t queue_idx)
{
- return vnic_wq_disable(&enic->wq[queue_idx]);
+ struct rte_eth_dev *eth_dev = enic->rte_dev;
+ int ret;
+
+ ret = vnic_wq_disable(&enic->wq[queue_idx]);
+ if (ret)
+ return ret;
+
+ eth_dev->data->tx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STOPPED;
+ return 0;
}
void enic_start_rq(struct enic *enic, uint16_t queue_idx)
{
struct vnic_rq *rq_sop = &enic->rq[enic_sop_rq(queue_idx)];
struct vnic_rq *rq_data = &enic->rq[rq_sop->data_queue_idx];
+ struct rte_eth_dev *eth_dev = enic->rte_dev;
if (rq_data->in_use)
vnic_rq_enable(rq_data);
rte_mb();
vnic_rq_enable(rq_sop);
-
+ eth_dev->data->rx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STARTED;
}
int enic_stop_rq(struct enic *enic, uint16_t queue_idx)
{
int ret1 = 0, ret2 = 0;
-
+ struct rte_eth_dev *eth_dev = enic->rte_dev;
struct vnic_rq *rq_sop = &enic->rq[enic_sop_rq(queue_idx)];
struct vnic_rq *rq_data = &enic->rq[rq_sop->data_queue_idx];
if (ret2)
return ret2;
- else
+ else if (ret1)
return ret1;
+
+ eth_dev->data->rx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STOPPED;
+ return 0;
}
int enic_alloc_rq(struct enic *enic, uint16_t queue_idx,
struct rte_pci_device *pdev = enic->pdev;
int err = -1;
- dev_debug(enic, " Initializing ENIC PMD version %s\n", DRV_VERSION);
+ dev_debug(enic, " Initializing ENIC PMD\n");
enic->bar0.vaddr = (void *)pdev->mem_resource[0].addr;
enic->bar0.len = pdev->mem_resource[0].len;
pool = ((struct rte_mbuf *)buf->mb)->pool;
for (i = 0; i < nb_to_free; i++) {
buf = &wq->bufs[tail_idx];
- m = (struct rte_mbuf *)(buf->mb);
+ m = __rte_pktmbuf_prefree_seg((struct rte_mbuf *)(buf->mb));
+ buf->mb = NULL;
+
+ if (unlikely(m == NULL)) {
+ tail_idx = enic_ring_incr(desc_count, tail_idx);
+ continue;
+ }
+
if (likely(m->pool == pool)) {
RTE_ASSERT(nb_free < ENIC_MAX_WQ_DESCS);
free[nb_free++] = m;
pool = m->pool;
}
tail_idx = enic_ring_incr(desc_count, tail_idx);
- buf->mb = NULL;
}
rte_mempool_put_bulk(pool, (void **)free, nb_free);
txq = dev->data->tx_queues[i];
txq->tx_ftag_en = tx_ftag_en;
/* Check if Vector Tx is satisfied */
- if (fm10k_tx_vec_condition_check(txq)) {
+ if (fm10k_tx_vec_condition_check(txq))
use_sse = 0;
- break;
- }
}
if (use_sse) {
{
struct i40e_pf *pf = I40E_DEV_PRIVATE_TO_PF(dev->data->dev_private);
struct i40e_vsi *vsi = pf->main_vsi;
- struct i40e_hw *hw = I40E_DEV_PRIVATE_TO_HW(dev->data->dev_private);
if (mask & ETH_VLAN_FILTER_MASK) {
- if (dev->data->dev_conf.rxmode.hw_vlan_filter) {
- i40e_aq_set_vsi_vlan_promisc(hw, vsi->seid, false, NULL);
+ if (dev->data->dev_conf.rxmode.hw_vlan_filter)
i40e_vsi_config_vlan_filter(vsi, TRUE);
- } else {
- i40e_aq_set_vsi_vlan_promisc(hw, vsi->seid, true, NULL);
+ else
i40e_vsi_config_vlan_filter(vsi, FALSE);
- }
}
if (mask & ETH_VLAN_STRIP_MASK) {
uint16_t vlan_id, bool on)
{
uint32_t vid_idx, vid_bit;
- struct i40e_hw *hw = I40E_VSI_TO_HW(vsi);
- struct i40e_aqc_add_remove_vlan_element_data vlan_data = {0};
- int ret;
if (vlan_id > ETH_VLAN_ID_MAX)
return;
vid_idx = I40E_VFTA_IDX(vlan_id);
vid_bit = I40E_VFTA_BIT(vlan_id);
- vlan_data.vlan_tag = rte_cpu_to_le_16(vlan_id);
- if (on) {
- ret = i40e_aq_add_vlan(hw, vsi->seid, &vlan_data, 1, NULL);
- if (ret != I40E_SUCCESS)
- PMD_DRV_LOG(ERR, "Failed to add vlan filter");
+ if (on)
vsi->vfta[vid_idx] |= vid_bit;
- } else {
- ret = i40e_aq_remove_vlan(hw, vsi->seid, &vlan_data, 1, NULL);
- if (ret != I40E_SUCCESS)
- PMD_DRV_LOG(ERR, "Failed to remove vlan filter");
+ else
vsi->vfta[vid_idx] &= ~vid_bit;
- }
}
/**
(uint8_t *)addr, 12);
rte_memcpy((uint8_t *)(uintptr_t)wqe->inl.eseg.inline_hdr_start + 12,
&vlan, sizeof(vlan));
- rte_memcpy((uint8_t *)(uintptr_t)wqe->inl.eseg.inline_hdr_start + 16,
- ((uint8_t *)addr + 12), 2);
+ rte_memcpy((uint8_t *)((uintptr_t)wqe->inl.eseg.inline_hdr_start + 16),
+ (uint8_t *)(addr + 12), 2);
addr += MLX5_ETH_VLAN_INLINE_HEADER_SIZE - sizeof(vlan);
length -= MLX5_ETH_VLAN_INLINE_HEADER_SIZE - sizeof(vlan);
size = (sizeof(wqe->inl.ctrl.ctrl) +
goto end;
}
- if (rte_kvargs_count(kvlist, VIRTIO_USER_ARG_PATH) == 1)
+ if (rte_kvargs_count(kvlist, VIRTIO_USER_ARG_PATH) == 1) {
ret = rte_kvargs_process(kvlist, VIRTIO_USER_ARG_PATH,
&get_string_arg, &path);
if (ret < 0) {
VIRTIO_USER_ARG_PATH);
goto end;
}
- else {
+ } else {
PMD_INIT_LOG(ERR, "arg %s is mandatory for virtio-user\n",
VIRTIO_USER_ARG_QUEUE_SIZE);
goto end;
struct rte_mbuf *bufs[BURST_SIZE*2];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs,
BURST_SIZE);
+ if (unlikely(nb_rx == 0)) {
+ if (++port == nb_ports)
+ port = 0;
+ continue;
+ }
app_stats.rx.rx_pkts += nb_rx;
rte_distributor_process(d, bufs, nb_rx);
const uint16_t nb_ret = rte_distributor_returned_pkts(d,
bufs, BURST_SIZE*2);
app_stats.rx.returned_pkts += nb_ret;
- if (unlikely(nb_ret == 0))
+ if (unlikely(nb_ret == 0)) {
+ if (++port == nb_ports)
+ port = 0;
continue;
+ }
uint16_t sent = rte_ring_enqueue_burst(r, (void *)bufs, nb_ret);
app_stats.rx.enqueued_pkts += sent;
}
static inline void
-inbound_sp_sa(struct sp_ctx *sp, struct sa_ctx *sa, struct traffic_type *ip)
+inbound_sp_sa(struct sp_ctx *sp, struct sa_ctx *sa, struct traffic_type *ip,
+ uint16_t lim)
{
struct rte_mbuf *m;
uint32_t i, j, res, sa_idx;
for (i = 0; i < ip->num; i++) {
m = ip->pkts[i];
res = ip->res[i];
- if (res & DISCARD) {
- rte_pktmbuf_free(m);
- continue;
- }
if (res & BYPASS) {
ip->pkts[j++] = m;
continue;
}
- /* Check return SA SPI matches pkt SPI */
+ if (res & DISCARD || i < lim) {
+ rte_pktmbuf_free(m);
+ continue;
+ }
+ /* Only check SPI match for processed IPSec packets */
sa_idx = ip->res[i] & PROTECT_MASK;
if (sa_idx == 0 || !inbound_sa_check(sa, m, sa_idx)) {
rte_pktmbuf_free(m);
struct ipsec_traffic *traffic)
{
struct rte_mbuf *m;
- uint16_t idx, nb_pkts_in, i;
+ uint16_t idx, nb_pkts_in, i, n_ip4, n_ip6;
nb_pkts_in = ipsec_inbound(ipsec_ctx, traffic->ipsec.pkts,
traffic->ipsec.num, MAX_PKT_BURST);
+ n_ip4 = traffic->ip4.num;
+ n_ip6 = traffic->ip6.num;
+
/* SP/ACL Inbound check ipsec and ip4 */
for (i = 0; i < nb_pkts_in; i++) {
m = traffic->ipsec.pkts[i];
rte_pktmbuf_free(m);
}
- inbound_sp_sa(ipsec_ctx->sp4_ctx, ipsec_ctx->sa_ctx, &traffic->ip4);
+ inbound_sp_sa(ipsec_ctx->sp4_ctx, ipsec_ctx->sa_ctx, &traffic->ip4,
+ n_ip4);
- inbound_sp_sa(ipsec_ctx->sp6_ctx, ipsec_ctx->sa_ctx, &traffic->ip6);
+ inbound_sp_sa(ipsec_ctx->sp6_ctx, ipsec_ctx->sa_ctx, &traffic->ip6,
+ n_ip6);
}
static inline void
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
+#include <fcntl.h>
+#include <unistd.h>
#include <rte_atomic.h>
#include <rte_branch_prediction.h>
static void
generate_random_key(uint8_t *key, unsigned length)
{
- unsigned i;
+ int fd;
+ int ret;
+
+ fd = open("/dev/urandom", O_RDONLY);
+ if (fd < 0)
+ rte_exit(EXIT_FAILURE, "Failed to generate random key\n");
- for (i = 0; i < length; i++)
- key[i] = rand() % 0xff;
+ ret = read(fd, key, length);
+ close(fd);
+
+ if (ret != (signed)length)
+ rte_exit(EXIT_FAILURE, "Failed to generate random key\n");
}
static struct rte_cryptodev_sym_session *
static void
l2fwd_crypto_default_options(struct l2fwd_crypto_options *options)
{
- srand(time(NULL));
-
options->portmask = 0xffffffff;
options->nb_ports_per_lcore = 1;
options->refresh_period = 10000;
# from arch dir
SRCS-$(CONFIG_RTE_EXEC_ENV_BSDAPP) += rte_cpuflags.c
+SRCS-$(CONFIG_RTE_ARCH_X86) += rte_spinlock.c
CFLAGS_eal_common_cpuflags.o := $(CPUFLAGS_LIST)
pci_get_sysfs_path;
rte_keepalive_mark_sleep;
rte_keepalive_register_relay_callback;
+ rte_rtm_supported;
rte_thread_setname;
} DPDK_16.04;
--- /dev/null
+/*-
+ * BSD LICENSE
+ *
+ * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * 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.
+ * * Neither the name of Intel Corporation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
+ * OWNER 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.
+ */
+
+#include <stdint.h>
+
+#include "rte_cpuflags.h"
+
+uint8_t rte_rtm_supported; /* cache the flag to avoid the overhead
+ of the rte_cpu_get_flag_enabled function */
+
+static void __attribute__((constructor))
+rte_rtm_init(void)
+{
+ rte_rtm_supported = rte_cpu_get_flag_enabled(RTE_CPUFLAG_RTM);
+}
}
#endif
-static uint8_t rtm_supported; /* cache the flag to avoid the overhead
- of the rte_cpu_get_flag_enabled function */
-
-static inline void __attribute__((constructor))
-rte_rtm_init(void)
-{
- rtm_supported = rte_cpu_get_flag_enabled(RTE_CPUFLAG_RTM);
-}
+extern uint8_t rte_rtm_supported;
static inline int rte_tm_supported(void)
{
- return rtm_supported;
+ return rte_rtm_supported;
}
static inline int
rte_try_tm(volatile int *lock)
{
- if (!rtm_supported)
+ if (!rte_rtm_supported)
return 0;
int retries = RTE_RTM_MAX_RETRIES;
* 0-15 = release candidates
* 16 = release
*/
-#define RTE_VER_RELEASE 2
+#define RTE_VER_RELEASE 3
/**
* Macro to compute a version number usable for comparisons
# from arch dir
SRCS-$(CONFIG_RTE_EXEC_ENV_LINUXAPP) += rte_cpuflags.c
+SRCS-$(CONFIG_RTE_ARCH_X86) += rte_spinlock.c
CFLAGS_eal_common_cpuflags.o := $(CPUFLAGS_LIST)
} else {
memreg[0].offset = reg.offset;
memreg[0].size = table_start;
- memreg[1].offset = table_end;
+ memreg[1].offset = reg.offset + table_end;
memreg[1].size = reg.size - table_end;
RTE_LOG(DEBUG, EAL,
/* if there's a second part, try to map it */
if (map_addr != MAP_FAILED
&& memreg[1].offset && memreg[1].size) {
- void *second_addr = RTE_PTR_ADD(bar_addr, memreg[1].offset);
+ void *second_addr = RTE_PTR_ADD(bar_addr,
+ memreg[1].offset -
+ (uintptr_t)reg.offset);
map_addr = pci_map_resource(second_addr,
vfio_dev_fd, memreg[1].offset,
memreg[1].size,
}
const struct vfio_iommu_type *
-vfio_set_iommu_type(int vfio_container_fd) {
+vfio_set_iommu_type(int vfio_container_fd)
+{
unsigned idx;
for (idx = 0; idx < RTE_DIM(iommu_types); idx++) {
const struct vfio_iommu_type *t = &iommu_types[idx];
}
int
-vfio_has_supported_extensions(int vfio_container_fd) {
+vfio_has_supported_extensions(int vfio_container_fd)
+{
int ret;
unsigned idx, n_extensions = 0;
for (idx = 0; idx < RTE_DIM(iommu_types); idx++) {
pci_get_sysfs_path;
rte_keepalive_mark_sleep;
rte_keepalive_register_relay_callback;
+ rte_rtm_supported;
rte_thread_setname;
} DPDK_16.04;
uint32_t key_len; /**< src/dst key length */
};
-/*
+/**
* @internal Fragmented packet to reassemble.
* First two entries in the frags[] array are for the last and first fragments.
*/
-/*
+/**
* Create a new IP fragmentation table.
*
* @param bucket_num
uint32_t bucket_entries, uint32_t max_entries,
uint64_t max_cycles, int socket_id);
-/*
+/**
* Free allocated IP fragmentation table.
*
- * @param btl
+ * @param tbl
* Fragmentation table to free.
*/
static inline void
-rte_ip_frag_table_destroy( struct rte_ip_frag_tbl *tbl)
+rte_ip_frag_table_destroy(struct rte_ip_frag_tbl *tbl)
{
rte_free(tbl);
}
struct rte_mempool *pool_direct,
struct rte_mempool *pool_indirect);
-/*
+/**
* This function implements reassembly of fragmented IPv6 packets.
* Incoming mbuf should have its l2_len/l3_len fields setup correctly.
*
struct rte_mbuf *mb, uint64_t tms, struct ipv6_hdr *ip_hdr,
struct ipv6_extension_fragment *frag_hdr);
-/*
+/**
* Return a pointer to the packet's fragment header, if found.
* It only looks at the extension header that's right after the fixed IPv6
* header, and doesn't follow the whole chain of extension headers.
struct rte_mempool *pool_direct,
struct rte_mempool *pool_indirect);
-/*
+/**
* This function implements reassembly of fragmented IPv4 packets.
* Incoming mbufs should have its l2_len/l3_len fields setup correclty.
*
struct rte_ip_frag_death_row *dr,
struct rte_mbuf *mb, uint64_t tms, struct ipv4_hdr *ip_hdr);
-/*
+/**
* Check if the IPv4 packet is fragmented
*
* @param hdr
return ip_flag != 0 || ip_ofs != 0;
}
-/*
+/**
* Free mbufs on a given death row.
*
* @param dr
uint32_t prefetch);
-/*
+/**
* Dump fragmentation table statistics to file.
*
* @param f
sz->header_size = RTE_ALIGN_CEIL(sz->header_size,
RTE_MEMPOOL_ALIGN);
+#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
sz->trailer_size = sizeof(struct rte_mempool_objtlr);
+#else
+ sz->trailer_size = 0;
+#endif
/* element size is 8 bytes-aligned at least */
sz->elt_size = RTE_ALIGN_CEIL(elt_size, sizeof(uint64_t));
*/
STAILQ_HEAD(rte_mempool_objhdr_list, rte_mempool_objhdr);
+#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
+
/**
* Mempool object trailer structure
*
* trailer structure containing a cookie preventing memory corruptions.
*/
struct rte_mempool_objtlr {
-#ifdef RTE_LIBRTE_MEMPOOL_DEBUG
uint64_t cookie; /**< Debug cookie. */
-#endif
};
+#endif
+
/**
* A list of memory where objects are stored
*/
char dpdk_dir[PATH_MAX] = {0};
char dir[PATH_MAX] = {0};
char *dir_home = NULL;
+ int ret = 0;
if (type == RTE_PDUMP_SOCKET_SERVER && server_socket_dir[0] != 0)
snprintf(dir, sizeof(dir), "%s", server_socket_dir);
dpdk_dir, SOCKET_DIR);
}
- mkdir(dir, 700);
+ ret = mkdir(dir, 700);
+ /* if user passed socket path is invalid, return immediately */
+ if (ret < 0 && errno != EEXIST) {
+ RTE_LOG(ERR, PDUMP,
+ "Failed to create dir:%s:%s\n", dir,
+ strerror(errno));
+ rte_errno = errno;
+ return -1;
+ }
+
if (type == RTE_PDUMP_SOCKET_SERVER)
snprintf(buffer, bufsz, SERVER_SOCKET, dir);
else
"client socket(): %s:pid(%d):tid(%u), %s:%d\n",
strerror(errno), pid, rte_sys_gettid(),
__func__, __LINE__);
- ret = errno;
- return ret;
+ rte_errno = errno;
+ return -1;
}
ret = pdump_get_socket_path(addr.sun_path, sizeof(addr.sun_path),
RTE_LOG(ERR, PDUMP,
"Failed to get client socket path: %s:%d\n",
__func__, __LINE__);
+ rte_errno = errno;
goto exit;
}
addr.sun_family = AF_UNIX;
RTE_LOG(ERR, PDUMP,
"client bind(): %s, %s:%d\n",
strerror(errno), __func__, __LINE__);
- ret = errno;
+ rte_errno = errno;
break;
}
RTE_LOG(ERR, PDUMP,
"Failed to get server socket path: %s:%d\n",
__func__, __LINE__);
+ rte_errno = errno;
break;
}
serv_addr.sun_family = AF_UNIX;
RTE_LOG(ERR, PDUMP,
"failed to send to server:%s, %s:%d\n",
strerror(errno), __func__, __LINE__);
- ret = errno;
+ rte_errno = errno;
+ ret = -1;
break;
}
RTE_LOG(ERR, PDUMP,
"failed to recv from server:%s, %s:%d\n",
strerror(errno), __func__, __LINE__);
- ret = errno;
+ rte_errno = errno;
+ ret = -1;
break;
}
ret = server_resp.err_value;
struct virtio_net_hdr_mrg_rxbuf virtio_hdr = {{0, 0, 0, 0, 0, 0}, 0};
desc = &vq->desc[desc_idx];
- if (unlikely(desc->len < dev->vhost_hlen))
+ desc_addr = gpa_to_vva(dev, desc->addr);
+ /*
+ * Checking of 'desc_addr' placed outside of 'unlikely' macro to avoid
+ * performance issue with some versions of gcc (4.8.4 and 5.3.0) which
+ * otherwise stores offset on the stack instead of in a register.
+ */
+ if (unlikely(desc->len < dev->vhost_hlen) || !desc_addr)
return -1;
- desc_addr = gpa_to_vva(dev, desc->addr);
rte_prefetch0((void *)(uintptr_t)desc_addr);
virtio_enqueue_offload(m, &virtio_hdr.hdr);
return -1;
desc = &vq->desc[desc->next];
- desc_addr = gpa_to_vva(dev, desc->addr);
+ desc_addr = gpa_to_vva(dev, desc->addr);
+ if (unlikely(!desc_addr))
+ return -1;
+
desc_offset = 0;
desc_avail = desc->len;
}
LOG_DEBUG(VHOST_DATA, "(%d) current index %d | end index %d\n",
dev->vid, cur_idx, end_idx);
- if (buf_vec[vec_idx].buf_len < dev->vhost_hlen)
- return -1;
-
desc_addr = gpa_to_vva(dev, buf_vec[vec_idx].buf_addr);
+ if (buf_vec[vec_idx].buf_len < dev->vhost_hlen || !desc_addr)
+ return 0;
+
rte_prefetch0((void *)(uintptr_t)desc_addr);
virtio_hdr.num_buffers = end_idx - start_idx;
vec_idx++;
desc_addr = gpa_to_vva(dev, buf_vec[vec_idx].buf_addr);
+ if (unlikely(!desc_addr))
+ return 0;
/* Prefetch buffer address. */
rte_prefetch0((void *)(uintptr_t)desc_addr);
*(volatile uint16_t *)&vq->used->idx += nr_used;
vhost_log_used_vring(dev, vq, offsetof(struct vring_used, idx),
sizeof(vq->used->idx));
- vq->last_used_idx = end;
+ vq->last_used_idx += nr_used;
}
if (likely(pkt_idx)) {
return -1;
desc_addr = gpa_to_vva(dev, desc->addr);
+ if (unlikely(!desc_addr))
+ return -1;
+
hdr = (struct virtio_net_hdr *)((uintptr_t)desc_addr);
rte_prefetch0(hdr);
desc = &vq->desc[desc->next];
desc_addr = gpa_to_vva(dev, desc->addr);
+ if (unlikely(!desc_addr))
+ return -1;
+
rte_prefetch0((void *)(uintptr_t)desc_addr);
desc_offset = 0;
desc = &vq->desc[desc->next];
desc_addr = gpa_to_vva(dev, desc->addr);
+ if (unlikely(!desc_addr))
+ return -1;
+
rte_prefetch0((void *)(uintptr_t)desc_addr);
desc_offset = 0;
return fdset_find_fd(pfdset, -1);
}
-static void
+static int
fdset_add_fd(struct fdset *pfdset, int idx, int fd,
fd_cb rcb, fd_cb wcb, void *dat)
{
struct fdentry *pfdentry;
- if (pfdset == NULL || idx >= MAX_FDS)
- return;
+ if (pfdset == NULL || idx >= MAX_FDS || fd >= FD_SETSIZE)
+ return -1;
pfdentry = &pfdset->fd[idx];
pfdentry->fd = fd;
pfdentry->rcb = rcb;
pfdentry->wcb = wcb;
pfdentry->dat = dat;
+
+ return 0;
}
/**
/* Find a free slot in the list. */
i = fdset_find_free_slot(pfdset);
- if (i == -1) {
+ if (i == -1 || fdset_add_fd(pfdset, i, fd, rcb, wcb, dat) < 0) {
pthread_mutex_unlock(&pfdset->fd_mutex);
return -2;
}
- fdset_add_fd(pfdset, i, fd, rcb, wcb, dat);
pfdset->num++;
pthread_mutex_unlock(&pfdset->fd_mutex);
int vid;
size_t size;
struct vhost_user_connection *conn;
+ int ret;
conn = malloc(sizeof(*conn));
if (conn == NULL) {
conn->vsocket = vsocket;
conn->vid = vid;
- fdset_add(&vhost_user.fdset, fd, vhost_user_msg_handler, NULL, conn);
+ ret = fdset_add(&vhost_user.fdset, fd, vhost_user_msg_handler,
+ NULL, conn);
+ if (ret < 0) {
+ free(conn);
+ close(fd);
+ RTE_LOG(ERR, VHOST_CONFIG,
+ "failed to add fd %d into vhost server fdset\n",
+ fd);
+ }
}
/* call back when there is new vhost-user connection from client */
goto err;
vsocket->listenfd = fd;
- fdset_add(&vhost_user.fdset, fd, vhost_user_server_new_connection,
+ ret = fdset_add(&vhost_user.fdset, fd, vhost_user_server_new_connection,
NULL, vsocket);
+ if (ret < 0) {
+ RTE_LOG(ERR, VHOST_CONFIG,
+ "failed to add listen fd %d to vhost server fdset\n",
+ fd);
+ goto err;
+ }
return 0;
LDFLAGS += -rpath=$(RTE_SDK_BIN)/lib
endif
+MAPFLAGS = -Map=$@.map --cref
+
.PHONY: all
all: install
exe2cmd = $(strip $(call dotfile,$(patsubst %,%.cmd,$(1))))
ifeq ($(LINK_USING_CC),1)
-override EXTRA_LDFLAGS := $(call linkerprefix,$(EXTRA_LDFLAGS))
-O_TO_EXE = $(CC) $(CFLAGS) $(LDFLAGS_$(@)) \
- -Wl,-Map=$(@).map,--cref -o $@ $(OBJS-y) $(call linkerprefix,$(LDFLAGS)) \
- $(EXTRA_LDFLAGS) $(call linkerprefix,$(LDLIBS))
+O_TO_EXE = $(CC) -o $@ $(CFLAGS) $(OBJS-y) $(call linkerprefix, \
+ $(LDLIBS) $(LDFLAGS) $(LDFLAGS_$(@)) $(EXTRA_LDFLAGS) \
+ $(MAPFLAGS))
else
-O_TO_EXE = $(LD) $(LDFLAGS) $(LDFLAGS_$(@)) $(EXTRA_LDFLAGS) \
- -Map=$(@).map --cref -o $@ $(OBJS-y) $(LDLIBS)
+O_TO_EXE = $(LD) -o $@ $(OBJS-y) \
+ $(LDLIBS) $(LDFLAGS) $(LDFLAGS_$(@)) $(EXTRA_LDFLAGS) \
+ $(MAPFLAGS)
endif
O_TO_EXE_STR = $(subst ','\'',$(O_TO_EXE)) #'# fix syntax highlight
O_TO_EXE_DISP = $(if $(V),"$(O_TO_EXE_STR)"," LD $(@)")
# - DPDK_DEP_CFLAGS
# - DPDK_DEP_LDFLAGS
# - DPDK_DEP_MOFED (y/[n])
+# - DPDK_DEP_NUMA (y/[n])
# - DPDK_DEP_PCAP (y/[n])
# - DPDK_DEP_SSL (y/[n])
# - DPDK_DEP_SZE (y/[n])
success=false
on_exit ()
{
- if [ "$DPDK_NOTIFY" = notify-send ] ; then
- if $success ; then
+ if $success ; then
+ [ "$DPDK_NOTIFY" != notify-send ] || \
notify-send -u low --icon=dialog-information 'DPDK build' 'finished'
- elif [ -z "$signal" ] ; then
+ elif [ -z "$signal" ] ; then
+ [ -z "$dir" ] || echo "failed to build $dir" >&2
+ [ "$DPDK_NOTIFY" != notify-send ] || \
notify-send -u low --icon=dialog-error 'DPDK build' 'failed'
- fi
fi
}
# catch manual interrupt to ignore notification
unset DPDK_DEP_CFLAGS
unset DPDK_DEP_LDFLAGS
unset DPDK_DEP_MOFED
+ unset DPDK_DEP_NUMA
unset DPDK_DEP_PCAP
unset DPDK_DEP_SSL
unset DPDK_DEP_SZE
sed -ri 's,(TEST_PMD_RECORD_.*=)n,\1y,' $1/.config )
# Automatic configuration
- ! echo $2 | grep -q '^x86_64' || \
+ test "$DPDK_DEP_NUMA" != y || \
sed -ri 's,(NUMA=)n,\1y,' $1/.config
- sed -ri 's,(PCI_CONFIG=)n,\1y,' $1/.config
sed -ri 's,(LIBRTE_IEEE1588=)n,\1y,' $1/.config
sed -ri 's,(BYPASS=)n,\1y,' $1/.config
test "$DPDK_DEP_ARCHIVE" != y || \
O=$(readlink -m $dir/examples/performance-thread)
unset RTE_TARGET
echo "################## $dir done."
+ unset dir
done
if ! $short ; then