lib/eal/linux/eal.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2018 Intel Corporation.
   3  * Copyright(c) 2012-2014 6WIND S.A.
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <stdint.h>
   9 #include <string.h>
  10 #include <stdarg.h>
  11 #include <unistd.h>
  12 #include <pthread.h>
  13 #include <syslog.h>
  14 #include <getopt.h>
  15 #include <sys/file.h>
  16 #include <dirent.h>
  17 #include <fcntl.h>
  18 #include <fnmatch.h>
  19 #include <stddef.h>
  20 #include <errno.h>
  21 #include <limits.h>
  22 #include <sys/mman.h>
  23 #include <sys/queue.h>
  24 #include <sys/stat.h>
  25 #if defined(RTE_ARCH_X86)
  26 #include <sys/io.h>
  27 #endif
  28 #include <linux/version.h>
  29
  30 #include <rte_compat.h>
  31 #include <rte_common.h>
  32 #include <rte_debug.h>
  33 #include <rte_memory.h>
  34 #include <rte_launch.h>
  35 #include <rte_eal.h>
  36 #include <rte_errno.h>
  37 #include <rte_per_lcore.h>
  38 #include <rte_lcore.h>
  39 #include <rte_service_component.h>
  40 #include <rte_log.h>
  41 #include <rte_random.h>
  42 #include <rte_cycles.h>
  43 #include <rte_string_fns.h>
  44 #include <rte_cpuflags.h>
  45 #include <rte_interrupts.h>
  46 #include <rte_bus.h>
  47 #include <rte_dev.h>
  48 #include <rte_devargs.h>
  49 #include <rte_version.h>
  50 #include <malloc_heap.h>
  51 #include <rte_vfio.h>
  52
  53 #include <telemetry_internal.h>
  54 #include "eal_private.h"
  55 #include "eal_thread.h"
  56 #include "eal_internal_cfg.h"
  57 #include "eal_filesystem.h"
  58 #include "eal_hugepages.h"
  59 #include "eal_memcfg.h"
  60 #include "eal_trace.h"
  61 #include "eal_log.h"
  62 #include "eal_options.h"
  63 #include "eal_vfio.h"
  64 #include "hotplug_mp.h"
  65
  66 #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
  67
  68 #define SOCKET_MEM_STRLEN (RTE_MAX_NUMA_NODES * 10)
  69
  70 #define KERNEL_IOMMU_GROUPS_PATH "/sys/kernel/iommu_groups"
  71
  72 /* define fd variable here, because file needs to be kept open for the
  73  * duration of the program, as we hold a write lock on it in the primary proc */
  74 static int mem_cfg_fd = -1;
  75
  76 static struct flock wr_lock = {
  77                 .l_type = F_WRLCK,
  78                 .l_whence = SEEK_SET,
  79                 .l_start = offsetof(struct rte_mem_config, memsegs),
  80                 .l_len = RTE_SIZEOF_FIELD(struct rte_mem_config, memsegs),
  81 };
  82
  83 /* internal configuration (per-core) */
  84 struct lcore_config lcore_config[RTE_MAX_LCORE];
  85
  86 /* used by rte_rdtsc() */
  87 int rte_cycles_vmware_tsc_map;
  88
  89
  90 int
  91 eal_clean_runtime_dir(void)
  92 {
  93         const char *runtime_dir = rte_eal_get_runtime_dir();
  94         DIR *dir;
  95         struct dirent *dirent;
  96         int dir_fd, fd, lck_result;
  97         static const char * const filters[] = {
  98                 "fbarray_*",
  99                 "mp_socket_*"
 100         };
 101
 102         /* open directory */
 103         dir = opendir(runtime_dir);
 104         if (!dir) {
 105                 RTE_LOG(ERR, EAL, "Unable to open runtime directory %s\n",
 106                                 runtime_dir);
 107                 goto error;
 108         }
 109         dir_fd = dirfd(dir);
 110
 111         /* lock the directory before doing anything, to avoid races */
 112         if (flock(dir_fd, LOCK_EX) < 0) {
 113                 RTE_LOG(ERR, EAL, "Unable to lock runtime directory %s\n",
 114                         runtime_dir);
 115                 goto error;
 116         }
 117
 118         dirent = readdir(dir);
 119         if (!dirent) {
 120                 RTE_LOG(ERR, EAL, "Unable to read runtime directory %s\n",
 121                                 runtime_dir);
 122                 goto error;
 123         }
 124
 125         while (dirent != NULL) {
 126                 unsigned int f_idx;
 127                 bool skip = true;
 128
 129                 /* skip files that don't match the patterns */
 130                 for (f_idx = 0; f_idx < RTE_DIM(filters); f_idx++) {
 131                         const char *filter = filters[f_idx];
 132
 133                         if (fnmatch(filter, dirent->d_name, 0) == 0) {
 134                                 skip = false;
 135                                 break;
 136                         }
 137                 }
 138                 if (skip) {
 139                         dirent = readdir(dir);
 140                         continue;
 141                 }
 142
 143                 /* try and lock the file */
 144                 fd = openat(dir_fd, dirent->d_name, O_RDONLY);
 145
 146                 /* skip to next file */
 147                 if (fd == -1) {
 148                         dirent = readdir(dir);
 149                         continue;
 150                 }
 151
 152                 /* non-blocking lock */
 153                 lck_result = flock(fd, LOCK_EX | LOCK_NB);
 154
 155                 /* if lock succeeds, remove the file */
 156                 if (lck_result != -1)
 157                         unlinkat(dir_fd, dirent->d_name, 0);
 158                 close(fd);
 159                 dirent = readdir(dir);
 160         }
 161
 162         /* closedir closes dir_fd and drops the lock */
 163         closedir(dir);
 164         return 0;
 165
 166 error:
 167         if (dir)
 168                 closedir(dir);
 169
 170         RTE_LOG(ERR, EAL, "Error while clearing runtime dir: %s\n",
 171                 strerror(errno));
 172
 173         return -1;
 174 }
 175
 176
 177 /* create memory configuration in shared/mmap memory. Take out
 178  * a write lock on the memsegs, so we can auto-detect primary/secondary.
 179  * This means we never close the file while running (auto-close on exit).
 180  * We also don't lock the whole file, so that in future we can use read-locks
 181  * on other parts, e.g. memzones, to detect if there are running secondary
 182  * processes. */
 183 static int
 184 rte_eal_config_create(void)
 185 {
 186         struct rte_config *config = rte_eal_get_configuration();
 187         size_t page_sz = sysconf(_SC_PAGE_SIZE);
 188         size_t cfg_len = sizeof(*config->mem_config);
 189         size_t cfg_len_aligned = RTE_ALIGN(cfg_len, page_sz);
 190         void *rte_mem_cfg_addr, *mapped_mem_cfg_addr;
 191         int retval;
 192         const struct internal_config *internal_conf =
 193                 eal_get_internal_configuration();
 194
 195         const char *pathname = eal_runtime_config_path();
 196
 197         if (internal_conf->no_shconf)
 198                 return 0;
 199
 200         /* map the config before hugepage address so that we don't waste a page */
 201         if (internal_conf->base_virtaddr != 0)
 202                 rte_mem_cfg_addr = (void *)
 203                         RTE_ALIGN_FLOOR(internal_conf->base_virtaddr -
 204                         sizeof(struct rte_mem_config), page_sz);
 205         else
 206                 rte_mem_cfg_addr = NULL;
 207
 208         if (mem_cfg_fd < 0){
 209                 mem_cfg_fd = open(pathname, O_RDWR | O_CREAT, 0600);
 210                 if (mem_cfg_fd < 0) {
 211                         RTE_LOG(ERR, EAL, "Cannot open '%s' for rte_mem_config\n",
 212                                 pathname);
 213                         return -1;
 214                 }
 215         }
 216
 217         retval = ftruncate(mem_cfg_fd, cfg_len);
 218         if (retval < 0){
 219                 close(mem_cfg_fd);
 220                 mem_cfg_fd = -1;
 221                 RTE_LOG(ERR, EAL, "Cannot resize '%s' for rte_mem_config\n",
 222                         pathname);
 223                 return -1;
 224         }
 225
 226         retval = fcntl(mem_cfg_fd, F_SETLK, &wr_lock);
 227         if (retval < 0){
 228                 close(mem_cfg_fd);
 229                 mem_cfg_fd = -1;
 230                 RTE_LOG(ERR, EAL, "Cannot create lock on '%s'. Is another primary "
 231                         "process running?\n", pathname);
 232                 return -1;
 233         }
 234
 235         /* reserve space for config */
 236         rte_mem_cfg_addr = eal_get_virtual_area(rte_mem_cfg_addr,
 237                         &cfg_len_aligned, page_sz, 0, 0);
 238         if (rte_mem_cfg_addr == NULL) {
 239                 RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config\n");
 240                 close(mem_cfg_fd);
 241                 mem_cfg_fd = -1;
 242                 return -1;
 243         }
 244
 245         /* remap the actual file into the space we've just reserved */
 246         mapped_mem_cfg_addr = mmap(rte_mem_cfg_addr,
 247                         cfg_len_aligned, PROT_READ | PROT_WRITE,
 248                         MAP_SHARED | MAP_FIXED, mem_cfg_fd, 0);
 249         if (mapped_mem_cfg_addr == MAP_FAILED) {
 250                 munmap(rte_mem_cfg_addr, cfg_len);
 251                 close(mem_cfg_fd);
 252                 mem_cfg_fd = -1;
 253                 RTE_LOG(ERR, EAL, "Cannot remap memory for rte_config\n");
 254                 return -1;
 255         }
 256
 257         memcpy(rte_mem_cfg_addr, config->mem_config, sizeof(struct rte_mem_config));
 258         config->mem_config = rte_mem_cfg_addr;
 259
 260         /* store address of the config in the config itself so that secondary
 261          * processes could later map the config into this exact location
 262          */
 263         config->mem_config->mem_cfg_addr = (uintptr_t) rte_mem_cfg_addr;
 264         config->mem_config->dma_maskbits = 0;
 265
 266         return 0;
 267 }
 268
 269 /* attach to an existing shared memory config */
 270 static int
 271 rte_eal_config_attach(void)
 272 {
 273         struct rte_config *config = rte_eal_get_configuration();
 274         struct rte_mem_config *mem_config;
 275         const struct internal_config *internal_conf =
 276                 eal_get_internal_configuration();
 277
 278         const char *pathname = eal_runtime_config_path();
 279
 280         if (internal_conf->no_shconf)
 281                 return 0;
 282
 283         if (mem_cfg_fd < 0){
 284                 mem_cfg_fd = open(pathname, O_RDWR);
 285                 if (mem_cfg_fd < 0) {
 286                         RTE_LOG(ERR, EAL, "Cannot open '%s' for rte_mem_config\n",
 287                                 pathname);
 288                         return -1;
 289                 }
 290         }
 291
 292         /* map it as read-only first */
 293         mem_config = (struct rte_mem_config *) mmap(NULL, sizeof(*mem_config),
 294                         PROT_READ, MAP_SHARED, mem_cfg_fd, 0);
 295         if (mem_config == MAP_FAILED) {
 296                 close(mem_cfg_fd);
 297                 mem_cfg_fd = -1;
 298                 RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config! error %i (%s)\n",
 299                         errno, strerror(errno));
 300                 return -1;
 301         }
 302
 303         config->mem_config = mem_config;
 304
 305         return 0;
 306 }
 307
 308 /* reattach the shared config at exact memory location primary process has it */
 309 static int
 310 rte_eal_config_reattach(void)
 311 {
 312         struct rte_config *config = rte_eal_get_configuration();
 313         struct rte_mem_config *mem_config;
 314         void *rte_mem_cfg_addr;
 315         const struct internal_config *internal_conf =
 316                 eal_get_internal_configuration();
 317
 318         if (internal_conf->no_shconf)
 319                 return 0;
 320
 321         /* save the address primary process has mapped shared config to */
 322         rte_mem_cfg_addr =
 323                 (void *) (uintptr_t) config->mem_config->mem_cfg_addr;
 324
 325         /* unmap original config */
 326         munmap(config->mem_config, sizeof(struct rte_mem_config));
 327
 328         /* remap the config at proper address */
 329         mem_config = (struct rte_mem_config *) mmap(rte_mem_cfg_addr,
 330                         sizeof(*mem_config), PROT_READ | PROT_WRITE, MAP_SHARED,
 331                         mem_cfg_fd, 0);
 332
 333         close(mem_cfg_fd);
 334         mem_cfg_fd = -1;
 335
 336         if (mem_config == MAP_FAILED || mem_config != rte_mem_cfg_addr) {
 337                 if (mem_config != MAP_FAILED) {
 338                         /* errno is stale, don't use */
 339                         RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config at [%p], got [%p]"
 340                                 " - please use '--" OPT_BASE_VIRTADDR
 341                                 "' option\n", rte_mem_cfg_addr, mem_config);
 342                         munmap(mem_config, sizeof(struct rte_mem_config));
 343                         return -1;
 344                 }
 345                 RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config! error %i (%s)\n",
 346                         errno, strerror(errno));
 347                 return -1;
 348         }
 349
 350         config->mem_config = mem_config;
 351
 352         return 0;
 353 }
 354
 355 /* Detect if we are a primary or a secondary process */
 356 enum rte_proc_type_t
 357 eal_proc_type_detect(void)
 358 {
 359         enum rte_proc_type_t ptype = RTE_PROC_PRIMARY;
 360         const char *pathname = eal_runtime_config_path();
 361         const struct internal_config *internal_conf =
 362                 eal_get_internal_configuration();
 363
 364         /* if there no shared config, there can be no secondary processes */
 365         if (!internal_conf->no_shconf) {
 366                 /* if we can open the file but not get a write-lock we are a
 367                  * secondary process. NOTE: if we get a file handle back, we
 368                  * keep that open and don't close it to prevent a race condition
 369                  * between multiple opens.
 370                  */
 371                 if (((mem_cfg_fd = open(pathname, O_RDWR)) >= 0) &&
 372                                 (fcntl(mem_cfg_fd, F_SETLK, &wr_lock) < 0))
 373                         ptype = RTE_PROC_SECONDARY;
 374         }
 375
 376         RTE_LOG(INFO, EAL, "Auto-detected process type: %s\n",
 377                         ptype == RTE_PROC_PRIMARY ? "PRIMARY" : "SECONDARY");
 378
 379         return ptype;
 380 }
 381
 382 /* Sets up rte_config structure with the pointer to shared memory config.*/
 383 static int
 384 rte_config_init(void)
 385 {
 386         struct rte_config *config = rte_eal_get_configuration();
 387         const struct internal_config *internal_conf =
 388                 eal_get_internal_configuration();
 389
 390         config->process_type = internal_conf->process_type;
 391
 392         switch (config->process_type) {
 393         case RTE_PROC_PRIMARY:
 394                 if (rte_eal_config_create() < 0)
 395                         return -1;
 396                 eal_mcfg_update_from_internal();
 397                 break;
 398         case RTE_PROC_SECONDARY:
 399                 if (rte_eal_config_attach() < 0)
 400                         return -1;
 401                 eal_mcfg_wait_complete();
 402                 if (eal_mcfg_check_version() < 0) {
 403                         RTE_LOG(ERR, EAL, "Primary and secondary process DPDK version mismatch\n");
 404                         return -1;
 405                 }
 406                 if (rte_eal_config_reattach() < 0)
 407                         return -1;
 408                 if (!__rte_mp_enable()) {
 409                         RTE_LOG(ERR, EAL, "Primary process refused secondary attachment\n");
 410                         return -1;
 411                 }
 412                 eal_mcfg_update_internal();
 413                 break;
 414         case RTE_PROC_AUTO:
 415         case RTE_PROC_INVALID:
 416                 RTE_LOG(ERR, EAL, "Invalid process type %d\n",
 417                         config->process_type);
 418                 return -1;
 419         }
 420
 421         return 0;
 422 }
 423
 424 /* Unlocks hugepage directories that were locked by eal_hugepage_info_init */
 425 static void
 426 eal_hugedirs_unlock(void)
 427 {
 428         int i;
 429         struct internal_config *internal_conf =
 430                 eal_get_internal_configuration();
 431
 432         for (i = 0; i < MAX_HUGEPAGE_SIZES; i++)
 433         {
 434                 /* skip uninitialized */
 435                 if (internal_conf->hugepage_info[i].lock_descriptor < 0)
 436                         continue;
 437                 /* unlock hugepage file */
 438                 flock(internal_conf->hugepage_info[i].lock_descriptor, LOCK_UN);
 439                 close(internal_conf->hugepage_info[i].lock_descriptor);
 440                 /* reset the field */
 441                 internal_conf->hugepage_info[i].lock_descriptor = -1;
 442         }
 443 }
 444
 445 /* display usage */
 446 static void
 447 eal_usage(const char *prgname)
 448 {
 449         rte_usage_hook_t hook = eal_get_application_usage_hook();
 450
 451         printf("\nUsage: %s ", prgname);
 452         eal_common_usage();
 453         printf("EAL Linux options:\n"
 454                "  --"OPT_SOCKET_MEM"        Memory to allocate on sockets (comma separated values)\n"
 455                "  --"OPT_SOCKET_LIMIT"      Limit memory allocation on sockets (comma separated values)\n"
 456                "  --"OPT_HUGE_DIR"          Directory where hugetlbfs is mounted\n"
 457                "  --"OPT_FILE_PREFIX"       Prefix for hugepage filenames\n"
 458                "  --"OPT_CREATE_UIO_DEV"    Create /dev/uioX (usually done by hotplug)\n"
 459                "  --"OPT_VFIO_INTR"         Interrupt mode for VFIO (legacy|msi|msix)\n"
 460                "  --"OPT_VFIO_VF_TOKEN"     VF token (UUID) shared between SR-IOV PF and VFs\n"
 461                "  --"OPT_LEGACY_MEM"        Legacy memory mode (no dynamic allocation, contiguous segments)\n"
 462                "  --"OPT_SINGLE_FILE_SEGMENTS" Put all hugepage memory in single files\n"
 463                "  --"OPT_MATCH_ALLOCATIONS" Free hugepages exactly as allocated\n"
 464                "\n");
 465         /* Allow the application to print its usage message too if hook is set */
 466         if (hook) {
 467                 printf("===== Application Usage =====\n\n");
 468                 (hook)(prgname);
 469         }
 470 }
 471
 472 static int
 473 eal_parse_socket_arg(char *strval, volatile uint64_t *socket_arg)
 474 {
 475         char * arg[RTE_MAX_NUMA_NODES];
 476         char *end;
 477         int arg_num, i, len;
 478
 479         len = strnlen(strval, SOCKET_MEM_STRLEN);
 480         if (len == SOCKET_MEM_STRLEN) {
 481                 RTE_LOG(ERR, EAL, "--socket-mem is too long\n");
 482                 return -1;
 483         }
 484
 485         /* all other error cases will be caught later */
 486         if (!isdigit(strval[len-1]))
 487                 return -1;
 488
 489         /* split the optarg into separate socket values */
 490         arg_num = rte_strsplit(strval, len,
 491                         arg, RTE_MAX_NUMA_NODES, ',');
 492
 493         /* if split failed, or 0 arguments */
 494         if (arg_num <= 0)
 495                 return -1;
 496
 497         /* parse each defined socket option */
 498         errno = 0;
 499         for (i = 0; i < arg_num; i++) {
 500                 uint64_t val;
 501                 end = NULL;
 502                 val = strtoull(arg[i], &end, 10);
 503
 504                 /* check for invalid input */
 505                 if ((errno != 0)  ||
 506                                 (arg[i][0] == '\0') || (end == NULL) || (*end != '\0'))
 507                         return -1;
 508                 val <<= 20;
 509                 socket_arg[i] = val;
 510         }
 511
 512         return 0;
 513 }
 514
 515 static int
 516 eal_parse_vfio_intr(const char *mode)
 517 {
 518         struct internal_config *internal_conf =
 519                 eal_get_internal_configuration();
 520         unsigned i;
 521         static struct {
 522                 const char *name;
 523                 enum rte_intr_mode value;
 524         } map[] = {
 525                 { "legacy", RTE_INTR_MODE_LEGACY },
 526                 { "msi", RTE_INTR_MODE_MSI },
 527                 { "msix", RTE_INTR_MODE_MSIX },
 528         };
 529
 530         for (i = 0; i < RTE_DIM(map); i++) {
 531                 if (!strcmp(mode, map[i].name)) {
 532                         internal_conf->vfio_intr_mode = map[i].value;
 533                         return 0;
 534                 }
 535         }
 536         return -1;
 537 }
 538
 539 static int
 540 eal_parse_vfio_vf_token(const char *vf_token)
 541 {
 542         struct internal_config *cfg = eal_get_internal_configuration();
 543         rte_uuid_t uuid;
 544
 545         if (!rte_uuid_parse(vf_token, uuid)) {
 546                 rte_uuid_copy(cfg->vfio_vf_token, uuid);
 547                 return 0;
 548         }
 549
 550         return -1;
 551 }
 552
 553 /* Parse the arguments for --log-level only */
 554 static void
 555 eal_log_level_parse(int argc, char **argv)
 556 {
 557         int opt;
 558         char **argvopt;
 559         int option_index;
 560         const int old_optind = optind;
 561         const int old_optopt = optopt;
 562         char * const old_optarg = optarg;
 563         struct internal_config *internal_conf =
 564                 eal_get_internal_configuration();
 565
 566         argvopt = argv;
 567         optind = 1;
 568
 569         while ((opt = getopt_long(argc, argvopt, eal_short_options,
 570                                   eal_long_options, &option_index)) != EOF) {
 571
 572                 int ret;
 573
 574                 /* getopt is not happy, stop right now */
 575                 if (opt == '?')
 576                         break;
 577
 578                 ret = (opt == OPT_LOG_LEVEL_NUM) ?
 579                         eal_parse_common_option(opt, optarg, internal_conf) : 0;
 580
 581                 /* common parser is not happy */
 582                 if (ret < 0)
 583                         break;
 584         }
 585
 586         /* restore getopt lib */
 587         optind = old_optind;
 588         optopt = old_optopt;
 589         optarg = old_optarg;
 590 }
 591
 592 /* Parse the argument given in the command line of the application */
 593 static int
 594 eal_parse_args(int argc, char **argv)
 595 {
 596         int opt, ret;
 597         char **argvopt;
 598         int option_index;
 599         char *prgname = argv[0];
 600         const int old_optind = optind;
 601         const int old_optopt = optopt;
 602         char * const old_optarg = optarg;
 603         struct internal_config *internal_conf =
 604                 eal_get_internal_configuration();
 605
 606         argvopt = argv;
 607         optind = 1;
 608
 609         while ((opt = getopt_long(argc, argvopt, eal_short_options,
 610                                   eal_long_options, &option_index)) != EOF) {
 611
 612                 /* getopt didn't recognise the option */
 613                 if (opt == '?') {
 614                         eal_usage(prgname);
 615                         ret = -1;
 616                         goto out;
 617                 }
 618
 619                 /* eal_log_level_parse() already handled this option */
 620                 if (opt == OPT_LOG_LEVEL_NUM)
 621                         continue;
 622
 623                 ret = eal_parse_common_option(opt, optarg, internal_conf);
 624                 /* common parser is not happy */
 625                 if (ret < 0) {
 626                         eal_usage(prgname);
 627                         ret = -1;
 628                         goto out;
 629                 }
 630                 /* common parser handled this option */
 631                 if (ret == 0)
 632                         continue;
 633
 634                 switch (opt) {
 635                 case 'h':
 636                         eal_usage(prgname);
 637                         exit(EXIT_SUCCESS);
 638
 639                 case OPT_HUGE_DIR_NUM:
 640                 {
 641                         char *hdir = strdup(optarg);
 642                         if (hdir == NULL)
 643                                 RTE_LOG(ERR, EAL, "Could not store hugepage directory\n");
 644                         else {
 645                                 /* free old hugepage dir */
 646                                 free(internal_conf->hugepage_dir);
 647                                 internal_conf->hugepage_dir = hdir;
 648                         }
 649                         break;
 650                 }
 651                 case OPT_FILE_PREFIX_NUM:
 652                 {
 653                         char *prefix = strdup(optarg);
 654                         if (prefix == NULL)
 655                                 RTE_LOG(ERR, EAL, "Could not store file prefix\n");
 656                         else {
 657                                 /* free old prefix */
 658                                 free(internal_conf->hugefile_prefix);
 659                                 internal_conf->hugefile_prefix = prefix;
 660                         }
 661                         break;
 662                 }
 663                 case OPT_SOCKET_MEM_NUM:
 664                         if (eal_parse_socket_arg(optarg,
 665                                         internal_conf->socket_mem) < 0) {
 666                                 RTE_LOG(ERR, EAL, "invalid parameters for --"
 667                                                 OPT_SOCKET_MEM "\n");
 668                                 eal_usage(prgname);
 669                                 ret = -1;
 670                                 goto out;
 671                         }
 672                         internal_conf->force_sockets = 1;
 673                         break;
 674
 675                 case OPT_SOCKET_LIMIT_NUM:
 676                         if (eal_parse_socket_arg(optarg,
 677                                         internal_conf->socket_limit) < 0) {
 678                                 RTE_LOG(ERR, EAL, "invalid parameters for --"
 679                                                 OPT_SOCKET_LIMIT "\n");
 680                                 eal_usage(prgname);
 681                                 ret = -1;
 682                                 goto out;
 683                         }
 684                         internal_conf->force_socket_limits = 1;
 685                         break;
 686
 687                 case OPT_VFIO_INTR_NUM:
 688                         if (eal_parse_vfio_intr(optarg) < 0) {
 689                                 RTE_LOG(ERR, EAL, "invalid parameters for --"
 690                                                 OPT_VFIO_INTR "\n");
 691                                 eal_usage(prgname);
 692                                 ret = -1;
 693                                 goto out;
 694                         }
 695                         break;
 696
 697                 case OPT_VFIO_VF_TOKEN_NUM:
 698                         if (eal_parse_vfio_vf_token(optarg) < 0) {
 699                                 RTE_LOG(ERR, EAL, "invalid parameters for --"
 700                                                 OPT_VFIO_VF_TOKEN "\n");
 701                                 eal_usage(prgname);
 702                                 ret = -1;
 703                                 goto out;
 704                         }
 705                         break;
 706
 707                 case OPT_CREATE_UIO_DEV_NUM:
 708                         internal_conf->create_uio_dev = 1;
 709                         break;
 710
 711                 case OPT_MBUF_POOL_OPS_NAME_NUM:
 712                 {
 713                         char *ops_name = strdup(optarg);
 714                         if (ops_name == NULL)
 715                                 RTE_LOG(ERR, EAL, "Could not store mbuf pool ops name\n");
 716                         else {
 717                                 /* free old ops name */
 718                                 free(internal_conf->user_mbuf_pool_ops_name);
 719
 720                                 internal_conf->user_mbuf_pool_ops_name =
 721                                                 ops_name;
 722                         }
 723                         break;
 724                 }
 725                 case OPT_MATCH_ALLOCATIONS_NUM:
 726                         internal_conf->match_allocations = 1;
 727                         break;
 728
 729                 default:
 730                         if (opt < OPT_LONG_MIN_NUM && isprint(opt)) {
 731                                 RTE_LOG(ERR, EAL, "Option %c is not supported "
 732                                         "on Linux\n", opt);
 733                         } else if (opt >= OPT_LONG_MIN_NUM &&
 734                                    opt < OPT_LONG_MAX_NUM) {
 735                                 RTE_LOG(ERR, EAL, "Option %s is not supported "
 736                                         "on Linux\n",
 737                                         eal_long_options[option_index].name);
 738                         } else {
 739                                 RTE_LOG(ERR, EAL, "Option %d is not supported "
 740                                         "on Linux\n", opt);
 741                         }
 742                         eal_usage(prgname);
 743                         ret = -1;
 744                         goto out;
 745                 }
 746         }
 747
 748         /* create runtime data directory. In no_shconf mode, skip any errors */
 749         if (eal_create_runtime_dir() < 0) {
 750                 if (internal_conf->no_shconf == 0) {
 751                         RTE_LOG(ERR, EAL, "Cannot create runtime directory\n");
 752                         ret = -1;
 753                         goto out;
 754                 } else
 755                         RTE_LOG(WARNING, EAL, "No DPDK runtime directory created\n");
 756         }
 757
 758         if (eal_adjust_config(internal_conf) != 0) {
 759                 ret = -1;
 760                 goto out;
 761         }
 762
 763         /* sanity checks */
 764         if (eal_check_common_options(internal_conf) != 0) {
 765                 eal_usage(prgname);
 766                 ret = -1;
 767                 goto out;
 768         }
 769
 770         if (optind >= 0)
 771                 argv[optind-1] = prgname;
 772         ret = optind-1;
 773
 774 out:
 775         /* restore getopt lib */
 776         optind = old_optind;
 777         optopt = old_optopt;
 778         optarg = old_optarg;
 779
 780         return ret;
 781 }
 782
 783 static int
 784 check_socket(const struct rte_memseg_list *msl, void *arg)
 785 {
 786         int *socket_id = arg;
 787
 788         if (msl->external)
 789                 return 0;
 790
 791         return *socket_id == msl->socket_id;
 792 }
 793
 794 static void
 795 eal_check_mem_on_local_socket(void)
 796 {
 797         int socket_id;
 798         const struct rte_config *config = rte_eal_get_configuration();
 799
 800         socket_id = rte_lcore_to_socket_id(config->main_lcore);
 801
 802         if (rte_memseg_list_walk(check_socket, &socket_id) == 0)
 803                 RTE_LOG(WARNING, EAL, "WARNING: Main core has no memory on local socket!\n");
 804 }
 805
 806 static int
 807 sync_func(__rte_unused void *arg)
 808 {
 809         return 0;
 810 }
 811
 812 /*
 813  * Request iopl privilege for all RPL, returns 0 on success
 814  * iopl() call is mostly for the i386 architecture. For other architectures,
 815  * return -1 to indicate IO privilege can't be changed in this way.
 816  */
 817 int
 818 rte_eal_iopl_init(void)
 819 {
 820 #if defined(RTE_ARCH_X86)
 821         if (iopl(3) != 0)
 822                 return -1;
 823 #endif
 824         return 0;
 825 }
 826
 827 #ifdef VFIO_PRESENT
 828 static int rte_eal_vfio_setup(void)
 829 {
 830         if (rte_vfio_enable("vfio"))
 831                 return -1;
 832
 833         return 0;
 834 }
 835 #endif
 836
 837 static void rte_eal_init_alert(const char *msg)
 838 {
 839         fprintf(stderr, "EAL: FATAL: %s\n", msg);
 840         RTE_LOG(ERR, EAL, "%s\n", msg);
 841 }
 842
 843 /*
 844  * On Linux 3.6+, even if VFIO is not loaded, whenever IOMMU is enabled in the
 845  * BIOS and in the kernel, /sys/kernel/iommu_groups path will contain kernel
 846  * IOMMU groups. If IOMMU is not enabled, that path would be empty.
 847  * Therefore, checking if the path is empty will tell us if IOMMU is enabled.
 848  */
 849 static bool
 850 is_iommu_enabled(void)
 851 {
 852         DIR *dir = opendir(KERNEL_IOMMU_GROUPS_PATH);
 853         struct dirent *d;
 854         int n = 0;
 855
 856         /* if directory doesn't exist, assume IOMMU is not enabled */
 857         if (dir == NULL)
 858                 return false;
 859
 860         while ((d = readdir(dir)) != NULL) {
 861                 /* skip dot and dot-dot */
 862                 if (++n > 2)
 863                         break;
 864         }
 865         closedir(dir);
 866
 867         return n > 2;
 868 }
 869
 870 /* Launch threads, called at application init(). */
 871 int
 872 rte_eal_init(int argc, char **argv)
 873 {
 874         int i, fctret, ret;
 875         pthread_t thread_id;
 876         static uint32_t run_once;
 877         uint32_t has_run = 0;
 878         const char *p;
 879         static char logid[PATH_MAX];
 880         char cpuset[RTE_CPU_AFFINITY_STR_LEN];
 881         char thread_name[RTE_MAX_THREAD_NAME_LEN];
 882         bool phys_addrs;
 883         const struct rte_config *config = rte_eal_get_configuration();
 884         struct internal_config *internal_conf =
 885                 eal_get_internal_configuration();
 886
 887         /* checks if the machine is adequate */
 888         if (!rte_cpu_is_supported()) {
 889                 rte_eal_init_alert("unsupported cpu type.");
 890                 rte_errno = ENOTSUP;
 891                 return -1;
 892         }
 893
 894         if (!__atomic_compare_exchange_n(&run_once, &has_run, 1, 0,
 895                                         __ATOMIC_RELAXED, __ATOMIC_RELAXED)) {
 896                 rte_eal_init_alert("already called initialization.");
 897                 rte_errno = EALREADY;
 898                 return -1;
 899         }
 900
 901         p = strrchr(argv[0], '/');
 902         strlcpy(logid, p ? p + 1 : argv[0], sizeof(logid));
 903         thread_id = pthread_self();
 904
 905         eal_reset_internal_config(internal_conf);
 906
 907         /* set log level as early as possible */
 908         eal_log_level_parse(argc, argv);
 909
 910         /* clone argv to report out later in telemetry */
 911         eal_save_args(argc, argv);
 912
 913         if (rte_eal_cpu_init() < 0) {
 914                 rte_eal_init_alert("Cannot detect lcores.");
 915                 rte_errno = ENOTSUP;
 916                 return -1;
 917         }
 918
 919         fctret = eal_parse_args(argc, argv);
 920         if (fctret < 0) {
 921                 rte_eal_init_alert("Invalid 'command line' arguments.");
 922                 rte_errno = EINVAL;
 923                 __atomic_store_n(&run_once, 0, __ATOMIC_RELAXED);
 924                 return -1;
 925         }
 926
 927         if (eal_plugins_init() < 0) {
 928                 rte_eal_init_alert("Cannot init plugins");
 929                 rte_errno = EINVAL;
 930                 __atomic_store_n(&run_once, 0, __ATOMIC_RELAXED);
 931                 return -1;
 932         }
 933
 934         if (eal_trace_init() < 0) {
 935                 rte_eal_init_alert("Cannot init trace");
 936                 rte_errno = EFAULT;
 937                 return -1;
 938         }
 939
 940         if (eal_option_device_parse()) {
 941                 rte_errno = ENODEV;
 942                 __atomic_store_n(&run_once, 0, __ATOMIC_RELAXED);
 943                 return -1;
 944         }
 945
 946         if (rte_config_init() < 0) {
 947                 rte_eal_init_alert("Cannot init config");
 948                 return -1;
 949         }
 950
 951         if (rte_eal_intr_init() < 0) {
 952                 rte_eal_init_alert("Cannot init interrupt-handling thread");
 953                 return -1;
 954         }
 955
 956         if (rte_eal_alarm_init() < 0) {
 957                 rte_eal_init_alert("Cannot init alarm");
 958                 /* rte_eal_alarm_init sets rte_errno on failure. */
 959                 return -1;
 960         }
 961
 962         /* Put mp channel init before bus scan so that we can init the vdev
 963          * bus through mp channel in the secondary process before the bus scan.
 964          */
 965         if (rte_mp_channel_init() < 0 && rte_errno != ENOTSUP) {
 966                 rte_eal_init_alert("failed to init mp channel");
 967                 if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
 968                         rte_errno = EFAULT;
 969                         return -1;
 970                 }
 971         }
 972
 973         /* register multi-process action callbacks for hotplug */
 974         if (eal_mp_dev_hotplug_init() < 0) {
 975                 rte_eal_init_alert("failed to register mp callback for hotplug");
 976                 return -1;
 977         }
 978
 979         if (rte_bus_scan()) {
 980                 rte_eal_init_alert("Cannot scan the buses for devices");
 981                 rte_errno = ENODEV;
 982                 __atomic_store_n(&run_once, 0, __ATOMIC_RELAXED);
 983                 return -1;
 984         }
 985
 986         phys_addrs = rte_eal_using_phys_addrs() != 0;
 987
 988         /* if no EAL option "--iova-mode=<pa|va>", use bus IOVA scheme */
 989         if (internal_conf->iova_mode == RTE_IOVA_DC) {
 990                 /* autodetect the IOVA mapping mode */
 991                 enum rte_iova_mode iova_mode = rte_bus_get_iommu_class();
 992
 993                 if (iova_mode == RTE_IOVA_DC) {
 994                         RTE_LOG(DEBUG, EAL, "Buses did not request a specific IOVA mode.\n");
 995
 996                         if (!phys_addrs) {
 997                                 /* if we have no access to physical addresses,
 998                                  * pick IOVA as VA mode.
 999                                  */
1000                                 iova_mode = RTE_IOVA_VA;
1001                                 RTE_LOG(DEBUG, EAL, "Physical addresses are unavailable, selecting IOVA as VA mode.\n");
1002 #if defined(RTE_LIB_KNI) && LINUX_VERSION_CODE >= KERNEL_VERSION(4, 10, 0)
1003                         } else if (rte_eal_check_module("rte_kni") == 1) {
1004                                 iova_mode = RTE_IOVA_PA;
1005                                 RTE_LOG(DEBUG, EAL, "KNI is loaded, selecting IOVA as PA mode for better KNI performance.\n");
1006 #endif
1007                         } else if (is_iommu_enabled()) {
1008                                 /* we have an IOMMU, pick IOVA as VA mode */
1009                                 iova_mode = RTE_IOVA_VA;
1010                                 RTE_LOG(DEBUG, EAL, "IOMMU is available, selecting IOVA as VA mode.\n");
1011                         } else {
1012                                 /* physical addresses available, and no IOMMU
1013                                  * found, so pick IOVA as PA.
1014                                  */
1015                                 iova_mode = RTE_IOVA_PA;
1016                                 RTE_LOG(DEBUG, EAL, "IOMMU is not available, selecting IOVA as PA mode.\n");
1017                         }
1018                 }
1019 #if defined(RTE_LIB_KNI) && LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)
1020                 /* Workaround for KNI which requires physical address to work
1021                  * in kernels < 4.10
1022                  */
1023                 if (iova_mode == RTE_IOVA_VA &&
1024                                 rte_eal_check_module("rte_kni") == 1) {
1025                         if (phys_addrs) {
1026                                 iova_mode = RTE_IOVA_PA;
1027                                 RTE_LOG(WARNING, EAL, "Forcing IOVA as 'PA' because KNI module is loaded\n");
1028                         } else {
1029                                 RTE_LOG(DEBUG, EAL, "KNI can not work since physical addresses are unavailable\n");
1030                         }
1031                 }
1032 #endif
1033                 rte_eal_get_configuration()->iova_mode = iova_mode;
1034         } else {
1035                 rte_eal_get_configuration()->iova_mode =
1036                         internal_conf->iova_mode;
1037         }
1038
1039         if (rte_eal_iova_mode() == RTE_IOVA_PA && !phys_addrs) {
1040                 rte_eal_init_alert("Cannot use IOVA as 'PA' since physical addresses are not available");
1041                 rte_errno = EINVAL;
1042                 return -1;
1043         }
1044
1045         RTE_LOG(INFO, EAL, "Selected IOVA mode '%s'\n",
1046                 rte_eal_iova_mode() == RTE_IOVA_PA ? "PA" : "VA");
1047
1048         if (internal_conf->no_hugetlbfs == 0) {
1049                 /* rte_config isn't initialized yet */
1050                 ret = internal_conf->process_type == RTE_PROC_PRIMARY ?
1051                                 eal_hugepage_info_init() :
1052                                 eal_hugepage_info_read();
1053                 if (ret < 0) {
1054                         rte_eal_init_alert("Cannot get hugepage information.");
1055                         rte_errno = EACCES;
1056                         __atomic_store_n(&run_once, 0, __ATOMIC_RELAXED);
1057                         return -1;
1058                 }
1059         }
1060
1061         if (internal_conf->memory == 0 && internal_conf->force_sockets == 0) {
1062                 if (internal_conf->no_hugetlbfs)
1063                         internal_conf->memory = MEMSIZE_IF_NO_HUGE_PAGE;
1064         }
1065
1066         if (internal_conf->vmware_tsc_map == 1) {
1067 #ifdef RTE_LIBRTE_EAL_VMWARE_TSC_MAP_SUPPORT
1068                 rte_cycles_vmware_tsc_map = 1;
1069                 RTE_LOG (DEBUG, EAL, "Using VMWARE TSC MAP, "
1070                                 "you must have monitor_control.pseudo_perfctr = TRUE\n");
1071 #else
1072                 RTE_LOG (WARNING, EAL, "Ignoring --vmware-tsc-map because "
1073                                 "RTE_LIBRTE_EAL_VMWARE_TSC_MAP_SUPPORT is not set\n");
1074 #endif
1075         }
1076
1077         if (eal_log_init(logid, internal_conf->syslog_facility) < 0) {
1078                 rte_eal_init_alert("Cannot init logging.");
1079                 rte_errno = ENOMEM;
1080                 __atomic_store_n(&run_once, 0, __ATOMIC_RELAXED);
1081                 return -1;
1082         }
1083
1084 #ifdef VFIO_PRESENT
1085         if (rte_eal_vfio_setup() < 0) {
1086                 rte_eal_init_alert("Cannot init VFIO");
1087                 rte_errno = EAGAIN;
1088                 __atomic_store_n(&run_once, 0, __ATOMIC_RELAXED);
1089                 return -1;
1090         }
1091 #endif
1092         /* in secondary processes, memory init may allocate additional fbarrays
1093          * not present in primary processes, so to avoid any potential issues,
1094          * initialize memzones first.
1095          */
1096         if (rte_eal_memzone_init() < 0) {
1097                 rte_eal_init_alert("Cannot init memzone");
1098                 rte_errno = ENODEV;
1099                 return -1;
1100         }
1101
1102         if (rte_eal_memory_init() < 0) {
1103                 rte_eal_init_alert("Cannot init memory");
1104                 rte_errno = ENOMEM;
1105                 return -1;
1106         }
1107
1108         /* the directories are locked during eal_hugepage_info_init */
1109         eal_hugedirs_unlock();
1110
1111         if (rte_eal_malloc_heap_init() < 0) {
1112                 rte_eal_init_alert("Cannot init malloc heap");
1113                 rte_errno = ENODEV;
1114                 return -1;
1115         }
1116
1117         if (rte_eal_tailqs_init() < 0) {
1118                 rte_eal_init_alert("Cannot init tail queues for objects");
1119                 rte_errno = EFAULT;
1120                 return -1;
1121         }
1122
1123         if (rte_eal_timer_init() < 0) {
1124                 rte_eal_init_alert("Cannot init HPET or TSC timers");
1125                 rte_errno = ENOTSUP;
1126                 return -1;
1127         }
1128
1129         eal_check_mem_on_local_socket();
1130
1131         if (pthread_setaffinity_np(pthread_self(), sizeof(rte_cpuset_t),
1132                         &lcore_config[config->main_lcore].cpuset) != 0) {
1133                 rte_eal_init_alert("Cannot set affinity");
1134                 rte_errno = EINVAL;
1135                 return -1;
1136         }
1137         __rte_thread_init(config->main_lcore,
1138                 &lcore_config[config->main_lcore].cpuset);
1139
1140         ret = eal_thread_dump_current_affinity(cpuset, sizeof(cpuset));
1141         RTE_LOG(DEBUG, EAL, "Main lcore %u is ready (tid=%zx;cpuset=[%s%s])\n",
1142                 config->main_lcore, (uintptr_t)thread_id, cpuset,
1143                 ret == 0 ? "" : "...");
1144
1145         RTE_LCORE_FOREACH_WORKER(i) {
1146
1147                 /*
1148                  * create communication pipes between main thread
1149                  * and children
1150                  */
1151                 if (pipe(lcore_config[i].pipe_main2worker) < 0)
1152                         rte_panic("Cannot create pipe\n");
1153                 if (pipe(lcore_config[i].pipe_worker2main) < 0)
1154                         rte_panic("Cannot create pipe\n");
1155
1156                 lcore_config[i].state = WAIT;
1157
1158                 /* create a thread for each lcore */
1159                 ret = pthread_create(&lcore_config[i].thread_id, NULL,
1160                                      eal_thread_loop, NULL);
1161                 if (ret != 0)
1162                         rte_panic("Cannot create thread\n");
1163
1164                 /* Set thread_name for aid in debugging. */
1165                 snprintf(thread_name, sizeof(thread_name),
1166                         "lcore-worker-%d", i);
1167                 ret = rte_thread_setname(lcore_config[i].thread_id,
1168                                                 thread_name);
1169                 if (ret != 0)
1170                         RTE_LOG(DEBUG, EAL,
1171                                 "Cannot set name for lcore thread\n");
1172
1173                 ret = pthread_setaffinity_np(lcore_config[i].thread_id,
1174                         sizeof(rte_cpuset_t), &lcore_config[i].cpuset);
1175                 if (ret != 0)
1176                         rte_panic("Cannot set affinity\n");
1177         }
1178
1179         /*
1180          * Launch a dummy function on all worker lcores, so that main lcore
1181          * knows they are all ready when this function returns.
1182          */
1183         rte_eal_mp_remote_launch(sync_func, NULL, SKIP_MAIN);
1184         rte_eal_mp_wait_lcore();
1185
1186         /* initialize services so vdevs register service during bus_probe. */
1187         ret = rte_service_init();
1188         if (ret) {
1189                 rte_eal_init_alert("rte_service_init() failed");
1190                 rte_errno = -ret;
1191                 return -1;
1192         }
1193
1194         /* Probe all the buses and devices/drivers on them */
1195         if (rte_bus_probe()) {
1196                 rte_eal_init_alert("Cannot probe devices");
1197                 rte_errno = ENOTSUP;
1198                 return -1;
1199         }
1200
1201 #ifdef VFIO_PRESENT
1202         /* Register mp action after probe() so that we got enough info */
1203         if (rte_vfio_is_enabled("vfio") && vfio_mp_sync_setup() < 0)
1204                 return -1;
1205 #endif
1206
1207         /* initialize default service/lcore mappings and start running. Ignore
1208          * -ENOTSUP, as it indicates no service coremask passed to EAL.
1209          */
1210         ret = rte_service_start_with_defaults();
1211         if (ret < 0 && ret != -ENOTSUP) {
1212                 rte_errno = -ret;
1213                 return -1;
1214         }
1215
1216         /*
1217          * Clean up unused files in runtime directory. We do this at the end of
1218          * init and not at the beginning because we want to clean stuff up
1219          * whether we are primary or secondary process, but we cannot remove
1220          * primary process' files because secondary should be able to run even
1221          * if primary process is dead.
1222          *
1223          * In no_shconf mode, no runtime directory is created in the first
1224          * place, so no cleanup needed.
1225          */
1226         if (!internal_conf->no_shconf && eal_clean_runtime_dir() < 0) {
1227                 rte_eal_init_alert("Cannot clear runtime directory");
1228                 return -1;
1229         }
1230         if (rte_eal_process_type() == RTE_PROC_PRIMARY && !internal_conf->no_telemetry) {
1231                 int tlog = rte_log_register_type_and_pick_level(
1232                                 "lib.telemetry", RTE_LOG_WARNING);
1233                 if (tlog < 0)
1234                         tlog = RTE_LOGTYPE_EAL;
1235                 if (rte_telemetry_init(rte_eal_get_runtime_dir(),
1236                                 rte_version(),
1237                                 &internal_conf->ctrl_cpuset, rte_log, tlog) != 0)
1238                         return -1;
1239         }
1240
1241         eal_mcfg_complete();
1242
1243         return fctret;
1244 }
1245
1246 static int
1247 mark_freeable(const struct rte_memseg_list *msl, const struct rte_memseg *ms,
1248                 void *arg __rte_unused)
1249 {
1250         /* ms is const, so find this memseg */
1251         struct rte_memseg *found;
1252
1253         if (msl->external)
1254                 return 0;
1255
1256         found = rte_mem_virt2memseg(ms->addr, msl);
1257
1258         found->flags &= ~RTE_MEMSEG_FLAG_DO_NOT_FREE;
1259
1260         return 0;
1261 }
1262
1263 int
1264 rte_eal_cleanup(void)
1265 {
1266         /* if we're in a primary process, we need to mark hugepages as freeable
1267          * so that finalization can release them back to the system.
1268          */
1269         struct internal_config *internal_conf =
1270                 eal_get_internal_configuration();
1271
1272         if (rte_eal_process_type() == RTE_PROC_PRIMARY &&
1273                         internal_conf->hugepage_file.unlink_existing)
1274                 rte_memseg_walk(mark_freeable, NULL);
1275
1276         rte_service_finalize();
1277 #ifdef VFIO_PRESENT
1278         vfio_mp_sync_cleanup();
1279 #endif
1280         rte_mp_channel_cleanup();
1281         /* after this point, any DPDK pointers will become dangling */
1282         rte_eal_memory_detach();
1283         eal_mp_dev_hotplug_cleanup();
1284         rte_eal_malloc_heap_cleanup();
1285         rte_eal_alarm_cleanup();
1286         rte_trace_save();
1287         eal_trace_fini();
1288         eal_cleanup_config(internal_conf);
1289         rte_eal_log_cleanup();
1290         return 0;
1291 }
1292
1293 int rte_eal_create_uio_dev(void)
1294 {
1295         const struct internal_config *internal_conf =
1296                 eal_get_internal_configuration();
1297
1298         return internal_conf->create_uio_dev;
1299 }
1300
1301 enum rte_intr_mode
1302 rte_eal_vfio_intr_mode(void)
1303 {
1304         const struct internal_config *internal_conf =
1305                 eal_get_internal_configuration();
1306
1307         return internal_conf->vfio_intr_mode;
1308 }
1309
1310 void
1311 rte_eal_vfio_get_vf_token(rte_uuid_t vf_token)
1312 {
1313         struct internal_config *cfg = eal_get_internal_configuration();
1314
1315         rte_uuid_copy(vf_token, cfg->vfio_vf_token);
1316 }
1317
1318 int
1319 rte_eal_check_module(const char *module_name)
1320 {
1321         char sysfs_mod_name[PATH_MAX];
1322         struct stat st;
1323         int n;
1324
1325         if (NULL == module_name)
1326                 return -1;
1327
1328         /* Check if there is sysfs mounted */
1329         if (stat("/sys/module", &st) != 0) {
1330                 RTE_LOG(DEBUG, EAL, "sysfs is not mounted! error %i (%s)\n",
1331                         errno, strerror(errno));
1332                 return -1;
1333         }
1334
1335         /* A module might be built-in, therefore try sysfs */
1336         n = snprintf(sysfs_mod_name, PATH_MAX, "/sys/module/%s", module_name);
1337         if (n < 0 || n > PATH_MAX) {
1338                 RTE_LOG(DEBUG, EAL, "Could not format module path\n");
1339                 return -1;
1340         }
1341
1342         if (stat(sysfs_mod_name, &st) != 0) {
1343                 RTE_LOG(DEBUG, EAL, "Module %s not found! error %i (%s)\n",
1344                         sysfs_mod_name, errno, strerror(errno));
1345                 return 0;
1346         }
1347
1348         /* Module has been found */
1349         return 1;
1350 }