* Copyright(c) 2019 Intel Corporation
*/
+#include <stdarg.h>
+
#include <fcntl.h>
#include <io.h>
#include <share.h>
#include <eal_filesystem.h>
#include <eal_options.h>
#include <eal_private.h>
-#include <rte_trace_point.h>
+#include <rte_service_component.h>
+#include <rte_vfio.h>
#include "eal_hugepages.h"
+#include "eal_trace.h"
+#include "eal_log.h"
#include "eal_windows.h"
#define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
- /* Allow the application to print its usage message too if set */
-static rte_usage_hook_t rte_application_usage_hook;
-
/* define fd variable here, because file needs to be kept open for the
* duration of the program, as we hold a write lock on it in the primary proc
*/
static int mem_cfg_fd = -1;
-/* early configuration structure, when memory config is not mmapped */
-static struct rte_mem_config early_mem_config;
-
-/* Address of global and public configuration */
-static struct rte_config rte_config = {
- .mem_config = &early_mem_config,
-};
-
/* internal configuration (per-core) */
struct lcore_config lcore_config[RTE_MAX_LCORE];
-/* internal configuration */
-struct internal_config internal_config;
-
-/* platform-specific runtime dir */
-static char runtime_dir[PATH_MAX];
-
-const char *
-rte_eal_get_runtime_dir(void)
-{
- return runtime_dir;
-}
-
-/* Return a pointer to the configuration structure */
-struct rte_config *
-rte_eal_get_configuration(void)
-{
- return &rte_config;
-}
-
/* Detect if we are a primary or a secondary process */
enum rte_proc_type_t
eal_proc_type_detect(void)
{
enum rte_proc_type_t ptype = RTE_PROC_PRIMARY;
const char *pathname = eal_runtime_config_path();
+ const struct rte_config *config = rte_eal_get_configuration();
/* if we can open the file but not get a write-lock we are a secondary
* process. NOTE: if we get a file handle back, we keep that open
_O_RDWR, _SH_DENYNO, _S_IREAD | _S_IWRITE);
if (err == 0) {
OVERLAPPED soverlapped = { 0 };
- soverlapped.Offset = sizeof(*rte_config.mem_config);
+ soverlapped.Offset = sizeof(*config->mem_config);
soverlapped.OffsetHigh = 0;
HANDLE hwinfilehandle = (HANDLE)_get_osfhandle(mem_cfg_fd);
if (!LockFileEx(hwinfilehandle,
LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0,
- sizeof(*rte_config.mem_config), 0, &soverlapped))
+ sizeof(*config->mem_config), 0, &soverlapped))
ptype = RTE_PROC_SECONDARY;
}
return ptype;
}
+bool
+rte_mp_disable(void)
+{
+ return true;
+}
+
/* display usage */
static void
eal_usage(const char *prgname)
{
+ rte_usage_hook_t hook = eal_get_application_usage_hook();
+
printf("\nUsage: %s ", prgname);
eal_common_usage();
/* Allow the application to print its usage message too
* if hook is set
*/
- if (rte_application_usage_hook) {
+ if (hook) {
printf("===== Application Usage =====\n\n");
- rte_application_usage_hook(prgname);
+ (hook)(prgname);
}
}
int opt;
char **argvopt;
int option_index;
+ struct internal_config *internal_conf =
+ eal_get_internal_configuration();
argvopt = argv;
- eal_reset_internal_config(&internal_config);
+ eal_reset_internal_config(internal_conf);
while ((opt = getopt_long(argc, argvopt, eal_short_options,
eal_long_options, &option_index)) != EOF) {
ret = (opt == OPT_LOG_LEVEL_NUM) ?
eal_parse_common_option(opt, optarg,
- &internal_config) : 0;
+ internal_conf) : 0;
/* common parser is not happy */
if (ret < 0)
char **argvopt;
int option_index;
char *prgname = argv[0];
+ struct internal_config *internal_conf =
+ eal_get_internal_configuration();
argvopt = argv;
return -1;
}
- ret = eal_parse_common_option(opt, optarg, &internal_config);
+ /* eal_log_level_parse() already handled this option */
+ if (opt == OPT_LOG_LEVEL_NUM)
+ continue;
+
+ ret = eal_parse_common_option(opt, optarg, internal_conf);
/* common parser is not happy */
if (ret < 0) {
eal_usage(prgname);
}
}
- if (eal_adjust_config(&internal_config) != 0)
+ if (eal_adjust_config(internal_conf) != 0)
return -1;
/* sanity checks */
- if (eal_check_common_options(&internal_config) != 0) {
+ if (eal_check_common_options(internal_conf) != 0) {
eal_usage(prgname);
return -1;
}
{
}
+void
+trace_mem_per_thread_free(void)
+{
+}
+
void
__rte_trace_point_emit_field(size_t sz, const char *field,
const char *type)
return -ENOTSUP;
}
+int
+rte_eal_cleanup(void)
+{
+ struct internal_config *internal_conf =
+ eal_get_internal_configuration();
+ /* after this point, any DPDK pointers will become dangling */
+ rte_eal_memory_detach();
+ eal_cleanup_config(internal_conf);
+ return 0;
+}
+
/* Launch threads, called at application init(). */
int
rte_eal_init(int argc, char **argv)
{
- int i, fctret;
+ int i, fctret, bscan;
+ const struct rte_config *config = rte_eal_get_configuration();
+ struct internal_config *internal_conf =
+ eal_get_internal_configuration();
+ int ret;
- rte_eal_log_init(NULL, 0);
+ eal_log_init(NULL, 0);
eal_log_level_parse(argc, argv);
if (fctret < 0)
exit(1);
- if (!internal_config.no_hugetlbfs && (eal_hugepage_info_init() < 0)) {
+ if (eal_option_device_parse()) {
+ rte_errno = ENODEV;
+ return -1;
+ }
+
+ /* Prevent creation of shared memory files. */
+ if (internal_conf->in_memory == 0) {
+ RTE_LOG(WARNING, EAL, "Multi-process support is requested, "
+ "but not available.\n");
+ internal_conf->in_memory = 1;
+ internal_conf->no_shconf = 1;
+ }
+
+ if (!internal_conf->no_hugetlbfs && (eal_hugepage_info_init() < 0)) {
rte_eal_init_alert("Cannot get hugepage information");
rte_errno = EACCES;
return -1;
}
- if (internal_config.memory == 0 && !internal_config.force_sockets) {
- if (internal_config.no_hugetlbfs)
- internal_config.memory = MEMSIZE_IF_NO_HUGE_PAGE;
+ if (internal_conf->memory == 0 && !internal_conf->force_sockets) {
+ if (internal_conf->no_hugetlbfs)
+ internal_conf->memory = MEMSIZE_IF_NO_HUGE_PAGE;
+ }
+
+ if (eal_mem_win32api_init() < 0) {
+ rte_eal_init_alert("Cannot access Win32 memory management");
+ rte_errno = ENOTSUP;
+ return -1;
+ }
+
+ if (eal_mem_virt2iova_init() < 0) {
+ /* Non-fatal error if physical addresses are not required. */
+ RTE_LOG(WARNING, EAL, "Cannot access virt2phys driver, "
+ "PA will not be available\n");
+ }
+
+ if (rte_eal_memzone_init() < 0) {
+ rte_eal_init_alert("Cannot init memzone");
+ rte_errno = ENODEV;
+ return -1;
+ }
+
+ if (rte_eal_memory_init() < 0) {
+ rte_eal_init_alert("Cannot init memory");
+ rte_errno = ENOMEM;
+ return -1;
+ }
+
+ if (rte_eal_malloc_heap_init() < 0) {
+ rte_eal_init_alert("Cannot init malloc heap");
+ rte_errno = ENODEV;
+ return -1;
+ }
+
+ if (rte_eal_tailqs_init() < 0) {
+ rte_eal_init_alert("Cannot init tail queues for objects");
+ rte_errno = EFAULT;
+ return -1;
+ }
+
+ if (rte_eal_intr_init() < 0) {
+ rte_eal_init_alert("Cannot init interrupt-handling thread");
+ return -1;
+ }
+
+ if (rte_eal_timer_init() < 0) {
+ rte_eal_init_alert("Cannot init TSC timer");
+ rte_errno = EFAULT;
+ return -1;
}
- eal_thread_init_master(rte_config.master_lcore);
+ __rte_thread_init(config->main_lcore,
+ &lcore_config[config->main_lcore].cpuset);
+
+ bscan = rte_bus_scan();
+ if (bscan < 0) {
+ rte_eal_init_alert("Cannot init PCI");
+ rte_errno = ENODEV;
+ return -1;
+ }
- RTE_LCORE_FOREACH_SLAVE(i) {
+ RTE_LCORE_FOREACH_WORKER(i) {
/*
- * create communication pipes between master thread
+ * create communication pipes between main thread
* and children
*/
- if (_pipe(lcore_config[i].pipe_master2slave,
+ if (_pipe(lcore_config[i].pipe_main2worker,
sizeof(char), _O_BINARY) < 0)
rte_panic("Cannot create pipe\n");
- if (_pipe(lcore_config[i].pipe_slave2master,
+ if (_pipe(lcore_config[i].pipe_worker2main,
sizeof(char), _O_BINARY) < 0)
rte_panic("Cannot create pipe\n");
rte_panic("Cannot create thread\n");
}
+ /* Initialize services so drivers can register services during probe. */
+ ret = rte_service_init();
+ if (ret) {
+ rte_eal_init_alert("rte_service_init() failed");
+ rte_errno = -ret;
+ return -1;
+ }
+
+ if (rte_bus_probe()) {
+ rte_eal_init_alert("Cannot probe devices");
+ rte_errno = ENOTSUP;
+ return -1;
+ }
+
/*
- * Launch a dummy function on all slave lcores, so that master lcore
+ * Launch a dummy function on all worker lcores, so that main lcore
* knows they are all ready when this function returns.
*/
- rte_eal_mp_remote_launch(sync_func, NULL, SKIP_MASTER);
+ rte_eal_mp_remote_launch(sync_func, NULL, SKIP_MAIN);
rte_eal_mp_wait_lcore();
return fctret;
}
+
+/* Don't use MinGW asprintf() to have identical code with all toolchains. */
+int
+eal_asprintf(char **buffer, const char *format, ...)
+{
+ int size, ret;
+ va_list arg;
+
+ va_start(arg, format);
+ size = vsnprintf(NULL, 0, format, arg);
+ va_end(arg);
+ if (size < 0)
+ return -1;
+ size++;
+
+ *buffer = malloc(size);
+ if (*buffer == NULL)
+ return -1;
+
+ va_start(arg, format);
+ ret = vsnprintf(*buffer, size, format, arg);
+ va_end(arg);
+ if (ret != size - 1) {
+ free(*buffer);
+ return -1;
+ }
+ return ret;
+}
+
+int
+rte_vfio_container_dma_map(__rte_unused int container_fd,
+ __rte_unused uint64_t vaddr,
+ __rte_unused uint64_t iova,
+ __rte_unused uint64_t len)
+{
+ return -1;
+}
+
+int
+rte_vfio_container_dma_unmap(__rte_unused int container_fd,
+ __rte_unused uint64_t vaddr,
+ __rte_unused uint64_t iova,
+ __rte_unused uint64_t len)
+{
+ return -1;
+}