X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_eal%2Fbsdapp%2Feal%2Feal.c;h=8d88119fcd23fb3cf992ecc10c44e22e6b7ecdb6;hb=7e9b25a738dc722c6db43c650311d9908f5bd15d;hp=3b2b47f73b77cd6d90db745dc3de0088577e3c44;hpb=4bf3fe634a4d9dfce90c4167f3a47d0e2ddf1e64;p=dpdk.git diff --git a/lib/librte_eal/bsdapp/eal/eal.c b/lib/librte_eal/bsdapp/eal/eal.c index 3b2b47f73b..8d88119fcd 100644 --- a/lib/librte_eal/bsdapp/eal/eal.c +++ b/lib/librte_eal/bsdapp/eal/eal.c @@ -1,14 +1,14 @@ /*- * BSD LICENSE - * - * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. + * + * Copyright(c) 2010-2016 Intel Corporation. All rights reserved. * Copyright(c) 2014 6WIND S.A. * 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 @@ -18,7 +18,7 @@ * * 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 @@ -45,77 +45,41 @@ #include #include #include -#include #include #include #include #include #include -#include #include -#include #include #include +#include #include #include +#include #include #include #include #include #include #include -#include +#include +#include #include -#include #include #include #include -#include #include "eal_private.h" #include "eal_thread.h" #include "eal_internal_cfg.h" #include "eal_filesystem.h" #include "eal_hugepages.h" - -#define OPT_HUGE_DIR "huge-dir" -#define OPT_PROC_TYPE "proc-type" -#define OPT_NO_SHCONF "no-shconf" -#define OPT_NO_HPET "no-hpet" -#define OPT_VMWARE_TSC_MAP "vmware-tsc-map" -#define OPT_NO_PCI "no-pci" -#define OPT_NO_HUGE "no-huge" -#define OPT_FILE_PREFIX "file-prefix" -#define OPT_SOCKET_MEM "socket-mem" -#define OPT_USE_DEVICE "use-device" -#define OPT_PCI_WHITELIST "pci-whitelist" -#define OPT_PCI_BLACKLIST "pci-blacklist" -#define OPT_VDEV "vdev" -#define OPT_SYSLOG "syslog" - -#define RTE_EAL_BLACKLIST_SIZE 0x100 +#include "eal_options.h" #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL) -#define SOCKET_MEM_STRLEN (RTE_MAX_NUMA_NODES * 10) - -#define HIGHEST_RPL 3 - -#define BITS_PER_HEX 4 - -#define GET_BLACKLIST_FIELD(in, fd, lim, dlm) \ -{ \ - unsigned long val; \ - char *end; \ - errno = 0; \ - val = strtoul((in), &end, 16); \ - if (errno != 0 || end[0] != (dlm) || val > (lim)) \ - return (-EINVAL); \ - (fd) = (typeof (fd))val; \ - (in) = end + 1; \ -} - /* Allow the application to print its usage message too if set */ static rte_usage_hook_t rte_application_usage_hook = NULL; /* early configuration structure, when memory config is not mmapped */ @@ -146,6 +110,13 @@ struct internal_config internal_config; /* used by rte_rdtsc() */ int rte_cycles_vmware_tsc_map; +/* Return mbuf pool ops name */ +const char * +rte_eal_mbuf_default_mempool_ops(void) +{ + return internal_config.mbuf_pool_ops_name; +} + /* Return a pointer to the configuration structure */ struct rte_config * rte_eal_get_configuration(void) @@ -153,6 +124,12 @@ rte_eal_get_configuration(void) return &rte_config; } +enum rte_iova_mode +rte_eal_iova_mode(void) +{ + return rte_eal_get_configuration()->iova_mode; +} + /* parse a sysfs (or other) file containing one integer value */ int eal_parse_sysfs_value(const char *filename, unsigned long *val) @@ -228,7 +205,7 @@ rte_eal_config_create(void) rte_panic("Cannot mmap memory for rte_config\n"); } memcpy(rte_mem_cfg_addr, &early_mem_config, sizeof(early_mem_config)); - rte_config.mem_config = (struct rte_mem_config *) rte_mem_cfg_addr; + rte_config.mem_config = rte_mem_cfg_addr; } /* attach to an existing shared memory config */ @@ -247,17 +224,17 @@ rte_eal_config_attach(void) rte_panic("Cannot open '%s' for rte_mem_config\n", pathname); } - rte_mem_cfg_addr = mmap(NULL, sizeof(*rte_config.mem_config), + rte_mem_cfg_addr = mmap(NULL, sizeof(*rte_config.mem_config), PROT_READ | PROT_WRITE, MAP_SHARED, mem_cfg_fd, 0); close(mem_cfg_fd); if (rte_mem_cfg_addr == MAP_FAILED) rte_panic("Cannot mmap memory for rte_config\n"); - rte_config.mem_config = (struct rte_mem_config *) rte_mem_cfg_addr; + rte_config.mem_config = rte_mem_cfg_addr; } /* Detect if we are a primary or a secondary process */ -static enum rte_proc_type_t +enum rte_proc_type_t eal_proc_type_detect(void) { enum rte_proc_type_t ptype = RTE_PROC_PRIMARY; @@ -280,11 +257,7 @@ eal_proc_type_detect(void) static void rte_config_init(void) { - /* set the magic in configuration structure */ - rte_config.magic = RTE_MAGIC; - rte_config.process_type = (internal_config.process_type == RTE_PROC_AUTO) ? - eal_proc_type_detect() : /* for auto, detect the type */ - internal_config.process_type; /* otherwise use what's already set */ + rte_config.process_type = internal_config.process_type; switch (rte_config.process_type){ case RTE_PROC_PRIMARY: @@ -304,35 +277,8 @@ rte_config_init(void) static void eal_usage(const char *prgname) { - printf("\nUsage: %s -c COREMASK -n NUM [-m NB] [-r NUM] [-b ]" - "[--proc-type primary|secondary|auto] \n\n" - "EAL options:\n" - " -c COREMASK : A hexadecimal bitmask of cores to run on\n" - " -n NUM : Number of memory channels\n" - " -v : Display version information on startup\n" - " (multiple -b options are allowed)\n" - " -m MB : memory to allocate\n" - " -r NUM : force number of memory ranks (don't detect)\n" - " --"OPT_PROC_TYPE" : type of this process\n" - " --"OPT_PCI_BLACKLIST", -b: add a PCI device in black list.\n" - " Prevent EAL from using this PCI device. The argument\n" - " format is .\n" - " --"OPT_PCI_WHITELIST", -w: add a PCI device in white list.\n" - " Only use the specified PCI devices. The argument format\n" - " is <[domain:]bus:devid.func>. This option can be present\n" - " several times (once per device).\n" - " [NOTE: PCI whitelist cannot be used with -b option]\n" - " --"OPT_VDEV": add a virtual device.\n" - " The argument format is [,key=val,...]\n" - " (ex: --vdev=eth_pcap0,iface=eth2).\n" - " --"OPT_VMWARE_TSC_MAP": use VMware TSC map instead of " - "native RDTSC\n" - "\nEAL options for DEBUG use only:\n" - " --"OPT_NO_HUGE" : use malloc instead of hugetlbfs\n" - " --"OPT_NO_PCI" : disable pci\n" - " --"OPT_NO_SHCONF": no shared config (mmap'd files)\n" - "\n", - prgname); + 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 ) { printf("===== Application Usage =====\n\n"); @@ -353,114 +299,6 @@ rte_set_application_usage_hook( rte_usage_hook_t usage_func ) return old_func; } -/* - * Parse the coremask given as argument (hexadecimal string) and fill - * the global configuration (core role and core count) with the parsed - * value. - */ -static int xdigit2val(unsigned char c) -{ - int val; - if(isdigit(c)) - val = c - '0'; - else if(isupper(c)) - val = c - 'A' + 10; - else - val = c - 'a' + 10; - return val; -} -static int -eal_parse_coremask(const char *coremask) -{ - struct rte_config *cfg = rte_eal_get_configuration(); - int i, j, idx = 0 ; - unsigned count = 0; - char c; - int val; - - if (coremask == NULL) - return -1; - /* Remove all blank characters ahead and after . - * Remove 0x/0X if exists. - */ - while (isblank(*coremask)) - coremask++; - if (coremask[0] == '0' && ((coremask[1] == 'x') - || (coremask[1] == 'X')) ) - coremask += 2; - i = strnlen(coremask, sysconf(_SC_ARG_MAX)); - while ((i > 0) && isblank(coremask[i - 1])) - i--; - if (i == 0) - return -1; - - for (i = i - 1; i >= 0 && idx < RTE_MAX_LCORE; i--) { - c = coremask[i]; - if (isxdigit(c) == 0) { - /* invalid characters */ - return (-1); - } - val = xdigit2val(c); - for(j = 0; j < BITS_PER_HEX && idx < RTE_MAX_LCORE; j++, idx++) { - if((1 << j) & val) { - cfg->lcore_role[idx] = ROLE_RTE; - if(count == 0) - cfg->master_lcore = idx; - count++; - } else { - cfg->lcore_role[idx] = ROLE_OFF; - } - } - } - for(; i >= 0; i--) - if(coremask[i] != '0') - return -1; - for(; idx < RTE_MAX_LCORE; idx++) - cfg->lcore_role[idx] = ROLE_OFF; - if(count == 0) - return -1; - return 0; -} - -static int -eal_parse_syslog(const char *facility) -{ - int i; - static struct { - const char *name; - int value; - } map[] = { - { "auth", LOG_AUTH }, - { "cron", LOG_CRON }, - { "daemon", LOG_DAEMON }, - { "ftp", LOG_FTP }, - { "kern", LOG_KERN }, - { "lpr", LOG_LPR }, - { "mail", LOG_MAIL }, - { "news", LOG_NEWS }, - { "syslog", LOG_SYSLOG }, - { "user", LOG_USER }, - { "uucp", LOG_UUCP }, - { "local0", LOG_LOCAL0 }, - { "local1", LOG_LOCAL1 }, - { "local2", LOG_LOCAL2 }, - { "local3", LOG_LOCAL3 }, - { "local4", LOG_LOCAL4 }, - { "local5", LOG_LOCAL5 }, - { "local6", LOG_LOCAL6 }, - { "local7", LOG_LOCAL7 }, - { NULL, 0 } - }; - - for (i = 0; map[i].name; i++) { - if (!strcmp(facility, map[i].name)) { - internal_config.syslog_facility = map[i].value; - return 0; - } - } - return -1; -} - static inline size_t eal_get_hugepage_mem_size(void) { @@ -479,268 +317,133 @@ eal_get_hugepage_mem_size(void) return (size < SIZE_MAX) ? (size_t)(size) : SIZE_MAX; } -static enum rte_proc_type_t -eal_parse_proc_type(const char *arg) +/* Parse the arguments for --log-level only */ +static void +eal_log_level_parse(int argc, char **argv) { - if (strncasecmp(arg, "primary", sizeof("primary")) == 0) - return RTE_PROC_PRIMARY; - if (strncasecmp(arg, "secondary", sizeof("secondary")) == 0) - return RTE_PROC_SECONDARY; - if (strncasecmp(arg, "auto", sizeof("auto")) == 0) - return RTE_PROC_AUTO; - - return RTE_PROC_INVALID; + int opt; + char **argvopt; + int option_index; + const int old_optind = optind; + const int old_optopt = optopt; + const int old_optreset = optreset; + char * const old_optarg = optarg; + + argvopt = argv; + optind = 1; + optreset = 1; + + while ((opt = getopt_long(argc, argvopt, eal_short_options, + eal_long_options, &option_index)) != EOF) { + + int ret; + + /* getopt is not happy, stop right now */ + if (opt == '?') + break; + + ret = (opt == OPT_LOG_LEVEL_NUM) ? + eal_parse_common_option(opt, optarg, &internal_config) : 0; + + /* common parser is not happy */ + if (ret < 0) + break; + } + + /* restore getopt lib */ + optind = old_optind; + optopt = old_optopt; + optreset = old_optreset; + optarg = old_optarg; } /* Parse the argument given in the command line of the application */ static int eal_parse_args(int argc, char **argv) { - int opt, ret, i; + int opt, ret; char **argvopt; int option_index; - int coremask_ok = 0; char *prgname = argv[0]; - static struct option lgopts[] = { - {OPT_NO_HUGE, 0, 0, 0}, - {OPT_NO_PCI, 0, 0, 0}, - {OPT_NO_HPET, 0, 0, 0}, - {OPT_VMWARE_TSC_MAP, 0, 0, 0}, - {OPT_HUGE_DIR, 1, 0, 0}, - {OPT_NO_SHCONF, 0, 0, 0}, - {OPT_PROC_TYPE, 1, 0, 0}, - {OPT_FILE_PREFIX, 1, 0, 0}, - {OPT_SOCKET_MEM, 1, 0, 0}, - {OPT_PCI_WHITELIST, 1, 0, 0}, - {OPT_PCI_BLACKLIST, 1, 0, 0}, - {OPT_VDEV, 1, 0, 0}, - {OPT_SYSLOG, 1, NULL, 0}, - {0, 0, 0, 0} - }; + const int old_optind = optind; + const int old_optopt = optopt; + const int old_optreset = optreset; + char * const old_optarg = optarg; argvopt = argv; + optind = 1; + optreset = 1; - internal_config.memory = 0; - internal_config.force_nrank = 0; - internal_config.force_nchannel = 0; - internal_config.hugefile_prefix = HUGEFILE_PREFIX_DEFAULT; - internal_config.hugepage_dir = NULL; - internal_config.force_sockets = 0; - internal_config.syslog_facility = LOG_DAEMON; -#ifdef RTE_LIBEAL_USE_HPET - internal_config.no_hpet = 0; -#else - internal_config.no_hpet = 1; -#endif - /* zero out the NUMA config */ - for (i = 0; i < RTE_MAX_NUMA_NODES; i++) - internal_config.socket_mem[i] = 0; - - /* zero out hugedir descriptors */ - for (i = 0; i < MAX_HUGEPAGE_SIZES; i++) - internal_config.hugepage_info[i].lock_descriptor = 0; + while ((opt = getopt_long(argc, argvopt, eal_short_options, + eal_long_options, &option_index)) != EOF) { - internal_config.vmware_tsc_map = 0; + /* getopt is not happy, stop right now */ + if (opt == '?') { + eal_usage(prgname); + ret = -1; + goto out; + } - while ((opt = getopt_long(argc, argvopt, "b:w:c:m:n:r:v", - lgopts, &option_index)) != EOF) { + ret = eal_parse_common_option(opt, optarg, &internal_config); + /* common parser is not happy */ + if (ret < 0) { + eal_usage(prgname); + ret = -1; + goto out; + } + /* common parser handled this option */ + if (ret == 0) + continue; switch (opt) { - /* blacklist */ - case 'b': - if (rte_eal_devargs_add(RTE_DEVTYPE_BLACKLISTED_PCI, - optarg) < 0) { - eal_usage(prgname); - return (-1); - } - break; - /* whitelist */ - case 'w': - if (rte_eal_devargs_add(RTE_DEVTYPE_WHITELISTED_PCI, - optarg) < 0) { - eal_usage(prgname); - return -1; - } + case OPT_MBUF_POOL_OPS_NAME_NUM: + internal_config.mbuf_pool_ops_name = optarg; break; - /* coremask */ - case 'c': - if (eal_parse_coremask(optarg) < 0) { - RTE_LOG(ERR, EAL, "invalid coremask\n"); - eal_usage(prgname); - return -1; - } - coremask_ok = 1; - break; - /* size of memory */ - case 'm': - internal_config.memory = atoi(optarg); - internal_config.memory *= 1024ULL; - internal_config.memory *= 1024ULL; - break; - /* force number of channels */ - case 'n': - internal_config.force_nchannel = atoi(optarg); - if (internal_config.force_nchannel == 0 || - internal_config.force_nchannel > 4) { - RTE_LOG(ERR, EAL, "invalid channel number\n"); - eal_usage(prgname); - return -1; - } - break; - /* force number of ranks */ - case 'r': - internal_config.force_nrank = atoi(optarg); - if (internal_config.force_nrank == 0 || - internal_config.force_nrank > 16) { - RTE_LOG(ERR, EAL, "invalid rank number\n"); - eal_usage(prgname); - return -1; - } - break; - case 'v': - /* since message is explicitly requested by user, we - * write message at highest log level so it can always be seen - * even if info or warning messages are disabled */ - RTE_LOG(CRIT, EAL, "RTE Version: '%s'\n", rte_version()); - break; - - /* long options */ - case 0: - if (!strcmp(lgopts[option_index].name, OPT_NO_HUGE)) { - internal_config.no_hugetlbfs = 1; - } - else if (!strcmp(lgopts[option_index].name, OPT_NO_PCI)) { - internal_config.no_pci = 1; - } - else if (!strcmp(lgopts[option_index].name, OPT_NO_HPET)) { - internal_config.no_hpet = 1; - } - else if (!strcmp(lgopts[option_index].name, OPT_VMWARE_TSC_MAP)) { - internal_config.vmware_tsc_map = 1; - } - else if (!strcmp(lgopts[option_index].name, OPT_NO_SHCONF)) { - internal_config.no_shconf = 1; - } - else if (!strcmp(lgopts[option_index].name, OPT_HUGE_DIR)) { - RTE_LOG(ERR, EAL, "Option "OPT_HUGE_DIR" is not supported on" - "FreeBSD\n"); - return -1; - } - else if (!strcmp(lgopts[option_index].name, OPT_PROC_TYPE)) { - internal_config.process_type = eal_parse_proc_type(optarg); - } - else if (!strcmp(lgopts[option_index].name, OPT_FILE_PREFIX)) { - RTE_LOG(ERR, EAL, "Option "OPT_FILE_PREFIX" is not supported on" - "FreeBSD\n"); - return -1; - } - else if (!strcmp(lgopts[option_index].name, OPT_SOCKET_MEM)) { - RTE_LOG(ERR, EAL, "Option "OPT_SOCKET_MEM" is not supported on" - "FreeBSD\n"); - return -1; - } - else if (!strcmp(lgopts[option_index].name, OPT_USE_DEVICE)) { - printf("The --use-device option is deprecated, please use\n" - "--whitelist or --vdev instead.\n"); - eal_usage(prgname); - return -1; - } - else if (!strcmp(lgopts[option_index].name, OPT_PCI_BLACKLIST)) { - if (rte_eal_devargs_add(RTE_DEVTYPE_BLACKLISTED_PCI, - optarg) < 0) { - eal_usage(prgname); - return -1; - } - } - else if (!strcmp(lgopts[option_index].name, OPT_PCI_WHITELIST)) { - if (rte_eal_devargs_add(RTE_DEVTYPE_WHITELISTED_PCI, - optarg) < 0) { - eal_usage(prgname); - return -1; - } - } - else if (!strcmp(lgopts[option_index].name, OPT_VDEV)) { - if (rte_eal_devargs_add(RTE_DEVTYPE_VIRTUAL, - optarg) < 0) { - eal_usage(prgname); - return -1; - } - } - else if (!strcmp(lgopts[option_index].name, OPT_SYSLOG)) { - if (eal_parse_syslog(optarg) < 0) { - RTE_LOG(ERR, EAL, "invalid parameters for --" - OPT_SYSLOG "\n"); - eal_usage(prgname); - return -1; - } - } - break; - + case 'h': + eal_usage(prgname); + exit(EXIT_SUCCESS); default: + if (opt < OPT_LONG_MIN_NUM && isprint(opt)) { + RTE_LOG(ERR, EAL, "Option %c is not supported " + "on FreeBSD\n", opt); + } else if (opt >= OPT_LONG_MIN_NUM && + opt < OPT_LONG_MAX_NUM) { + RTE_LOG(ERR, EAL, "Option %s is not supported " + "on FreeBSD\n", + eal_long_options[option_index].name); + } else { + RTE_LOG(ERR, EAL, "Option %d is not supported " + "on FreeBSD\n", opt); + } eal_usage(prgname); - return -1; + ret = -1; + goto out; } } - /* sanity checks */ - if (!coremask_ok) { - RTE_LOG(ERR, EAL, "coremask not specified\n"); - eal_usage(prgname); - return -1; - } - if (internal_config.process_type == RTE_PROC_AUTO){ - internal_config.process_type = eal_proc_type_detect(); - } - if (internal_config.process_type == RTE_PROC_INVALID){ - RTE_LOG(ERR, EAL, "Invalid process type specified\n"); - eal_usage(prgname); - return -1; - } - if (internal_config.process_type == RTE_PROC_PRIMARY && - internal_config.force_nchannel == 0) { - RTE_LOG(ERR, EAL, "Number of memory channels (-n) not specified\n"); - eal_usage(prgname); - return -1; - } - if (index(internal_config.hugefile_prefix,'%') != NULL){ - RTE_LOG(ERR, EAL, "Invalid char, '%%', in '"OPT_FILE_PREFIX"' option\n"); - eal_usage(prgname); - return -1; - } - if (internal_config.memory > 0 && internal_config.force_sockets == 1) { - RTE_LOG(ERR, EAL, "Options -m and --socket-mem cannot be specified " - "at the same time\n"); - eal_usage(prgname); - return -1; - } - /* --no-huge doesn't make sense with either -m or --socket-mem */ - if (internal_config.no_hugetlbfs && - (internal_config.memory > 0 || - internal_config.force_sockets == 1)) { - RTE_LOG(ERR, EAL, "Options -m or --socket-mem cannot be specified " - "together with --no-huge!\n"); - eal_usage(prgname); - return -1; + if (eal_adjust_config(&internal_config) != 0) { + ret = -1; + goto out; } - if (rte_eal_devargs_type_count(RTE_DEVTYPE_WHITELISTED_PCI) != 0 && - rte_eal_devargs_type_count(RTE_DEVTYPE_BLACKLISTED_PCI) != 0) { - RTE_LOG(ERR, EAL, "Error: blacklist [-b] and whitelist " - "[-w] options cannot be used at the same time\n"); + /* sanity checks */ + if (eal_check_common_options(&internal_config) != 0) { eal_usage(prgname); - return -1; + ret = -1; + goto out; } if (optind >= 0) argv[optind-1] = prgname; + ret = optind-1; - /* if no memory amounts were requested, this will result in 0 and - * will be overriden later, right after eal_hugepage_info_init() */ - for (i = 0; i < RTE_MAX_NUMA_NODES; i++) - internal_config.memory += internal_config.socket_mem[i]; +out: + /* restore getopt lib */ + optind = old_optind; + optopt = old_optopt; + optreset = old_optreset; + optarg = old_optarg; - ret = optind-1; - optind = 0; /* reset getopt lib */ return ret; } @@ -769,7 +472,7 @@ sync_func(__attribute__((unused)) void *arg) return 0; } -inline static void +inline static void rte_eal_mcfg_complete(void) { /* ALL shared mem_config related INIT DONE */ @@ -783,17 +486,25 @@ int rte_eal_has_hugepages(void) return !internal_config.no_hugetlbfs; } -/* Abstraction for port I/0 privilage */ -static int +/* Abstraction for port I/0 privilege */ +int rte_eal_iopl_init(void) { - int fd = -1; + static int fd; + fd = open("/dev/io", O_RDWR); if (fd < 0) return -1; + /* keep fd open for iopl */ return 0; } +static void rte_eal_init_alert(const char *msg) +{ + fprintf(stderr, "EAL: FATAL: %s\n", msg); + RTE_LOG(ERR, EAL, "%s\n", msg); +} + /* Launch threads, called at application init(). */ int rte_eal_init(int argc, char **argv) @@ -801,23 +512,74 @@ rte_eal_init(int argc, char **argv) int i, fctret, ret; pthread_t thread_id; static rte_atomic32_t run_once = RTE_ATOMIC32_INIT(0); + char cpuset[RTE_CPU_AFFINITY_STR_LEN]; + char thread_name[RTE_MAX_THREAD_NAME_LEN]; - if (!rte_atomic32_test_and_set(&run_once)) + /* checks if the machine is adequate */ + if (!rte_cpu_is_supported()) { + rte_eal_init_alert("unsupported cpu type."); + rte_errno = ENOTSUP; return -1; + } + + if (!rte_atomic32_test_and_set(&run_once)) { + rte_eal_init_alert("already called initialization."); + rte_errno = EALREADY; + return -1; + } thread_id = pthread_self(); - if (rte_eal_log_early_init() < 0) - rte_panic("Cannot init early logs\n"); + eal_reset_internal_config(&internal_config); + + /* set log level as early as possible */ + eal_log_level_parse(argc, argv); + + if (rte_eal_cpu_init() < 0) { + rte_eal_init_alert("Cannot detect lcores."); + rte_errno = ENOTSUP; + return -1; + } fctret = eal_parse_args(argc, argv); - if (fctret < 0) - exit(1); + if (fctret < 0) { + rte_eal_init_alert("Invalid 'command line' arguments."); + rte_errno = EINVAL; + rte_atomic32_clear(&run_once); + return -1; + } + + if (eal_plugins_init() < 0) { + rte_eal_init_alert("Cannot init plugins\n"); + rte_errno = EINVAL; + rte_atomic32_clear(&run_once); + return -1; + } + + if (eal_option_device_parse()) { + rte_errno = ENODEV; + rte_atomic32_clear(&run_once); + return -1; + } + + if (rte_bus_scan()) { + rte_eal_init_alert("Cannot scan the buses for devices\n"); + rte_errno = ENODEV; + rte_atomic32_clear(&run_once); + return -1; + } + + /* autodetect the iova mapping mode (default is iova_pa) */ + rte_eal_get_configuration()->iova_mode = rte_bus_get_iommu_class(); if (internal_config.no_hugetlbfs == 0 && internal_config.process_type != RTE_PROC_SECONDARY && - eal_hugepage_info_init() < 0) - rte_panic("Cannot get hugepage information\n"); + eal_hugepage_info_init() < 0) { + rte_eal_init_alert("Cannot get hugepage information."); + rte_errno = EACCES; + rte_atomic32_clear(&run_once); + return -1; + } if (internal_config.memory == 0 && internal_config.force_sockets == 0) { if (internal_config.no_hugetlbfs) @@ -841,45 +603,50 @@ rte_eal_init(int argc, char **argv) rte_config_init(); - if (rte_eal_iopl_init() == 0) - rte_config.flags |= EAL_FLG_HIGH_IOPL; - - if (rte_eal_cpu_init() < 0) - rte_panic("Cannot detect lcores\n"); - - if (rte_eal_memory_init() < 0) - rte_panic("Cannot init memory\n"); - - if (rte_eal_memzone_init() < 0) - rte_panic("Cannot init memzone\n"); - - if (rte_eal_tailqs_init() < 0) - rte_panic("Cannot init tail queues for objects\n"); - -/* if (rte_eal_log_init(argv[0], internal_config.syslog_facility) < 0) - rte_panic("Cannot init logs\n");*/ + if (rte_eal_memory_init() < 0) { + rte_eal_init_alert("Cannot init memory\n"); + rte_errno = ENOMEM; + return -1; + } - if (rte_eal_alarm_init() < 0) - rte_panic("Cannot init interrupt-handling thread\n"); + if (rte_eal_memzone_init() < 0) { + rte_eal_init_alert("Cannot init memzone\n"); + rte_errno = ENODEV; + return -1; + } - if (rte_eal_intr_init() < 0) - rte_panic("Cannot init interrupt-handling thread\n"); + if (rte_eal_tailqs_init() < 0) { + rte_eal_init_alert("Cannot init tail queues for objects\n"); + rte_errno = EFAULT; + return -1; + } - if (rte_eal_timer_init() < 0) - rte_panic("Cannot init HPET or TSC timers\n"); + if (rte_eal_alarm_init() < 0) { + rte_eal_init_alert("Cannot init interrupt-handling thread\n"); + /* rte_eal_alarm_init sets rte_errno on failure. */ + return -1; + } - if (rte_eal_pci_init() < 0) - rte_panic("Cannot init PCI\n"); + if (rte_eal_intr_init() < 0) { + rte_eal_init_alert("Cannot init interrupt-handling thread\n"); + return -1; + } - RTE_LOG(DEBUG, EAL, "Master core %u is ready (tid=%p)\n", - rte_config.master_lcore, thread_id); + if (rte_eal_timer_init() < 0) { + rte_eal_init_alert("Cannot init HPET or TSC timers\n"); + rte_errno = ENOTSUP; + return -1; + } eal_check_mem_on_local_socket(); - rte_eal_mcfg_complete(); + eal_thread_init_master(rte_config.master_lcore); - if (rte_eal_vdev_init() < 0) - rte_panic("Cannot init virtual devices\n"); + ret = eal_thread_dump_affinity(cpuset, sizeof(cpuset)); + + RTE_LOG(DEBUG, EAL, "Master lcore %u is ready (tid=%p;cpuset=[%s%s])\n", + rte_config.master_lcore, thread_id, cpuset, + ret == 0 ? "" : "..."); RTE_LCORE_FOREACH_SLAVE(i) { @@ -899,9 +666,12 @@ rte_eal_init(int argc, char **argv) eal_thread_loop, NULL); if (ret != 0) rte_panic("Cannot create thread\n"); - } - eal_thread_init_master(rte_config.master_lcore); + /* Set thread_name for aid in debugging. */ + snprintf(thread_name, RTE_MAX_THREAD_NAME_LEN, + "lcore-slave-%d", i); + rte_thread_setname(lcore_config[i].thread_id, thread_name); + } /* * Launch a dummy function on all slave lcores, so that master lcore @@ -910,6 +680,32 @@ rte_eal_init(int argc, char **argv) rte_eal_mp_remote_launch(sync_func, NULL, SKIP_MASTER); rte_eal_mp_wait_lcore(); + /* initialize services so vdevs register service during bus_probe. */ + ret = rte_service_init(); + if (ret) { + rte_eal_init_alert("rte_service_init() failed\n"); + rte_errno = ENOEXEC; + return -1; + } + + /* Probe all the buses and devices/drivers on them */ + if (rte_bus_probe()) { + rte_eal_init_alert("Cannot probe devices\n"); + rte_errno = ENOTSUP; + return -1; + } + + /* initialize default service/lcore mappings and start running. Ignore + * -ENOTSUP, as it indicates no service coremask passed to EAL. + */ + ret = rte_service_start_with_defaults(); + if (ret < 0 && ret != -ENOTSUP) { + rte_errno = ENOEXEC; + return -1; + } + + rte_eal_mcfg_complete(); + return fctret; } @@ -917,12 +713,68 @@ rte_eal_init(int argc, char **argv) enum rte_lcore_role_t rte_eal_lcore_role(unsigned lcore_id) { - return (rte_config.lcore_role[lcore_id]); + return rte_config.lcore_role[lcore_id]; } enum rte_proc_type_t rte_eal_process_type(void) { - return (rte_config.process_type); + return rte_config.process_type; +} + +int rte_eal_has_pci(void) +{ + return !internal_config.no_pci; } +int rte_eal_create_uio_dev(void) +{ + return internal_config.create_uio_dev; +} + +enum rte_intr_mode +rte_eal_vfio_intr_mode(void) +{ + return RTE_INTR_MODE_NONE; +} + +/* dummy forward declaration. */ +struct vfio_device_info; + +/* dummy prototypes. */ +int rte_vfio_setup_device(const char *sysfs_base, const char *dev_addr, + int *vfio_dev_fd, struct vfio_device_info *device_info); +int rte_vfio_release_device(const char *sysfs_base, const char *dev_addr, int fd); +int rte_vfio_enable(const char *modname); +int rte_vfio_is_enabled(const char *modname); +int rte_vfio_noiommu_is_enabled(void); + +int rte_vfio_setup_device(__rte_unused const char *sysfs_base, + __rte_unused const char *dev_addr, + __rte_unused int *vfio_dev_fd, + __rte_unused struct vfio_device_info *device_info) +{ + return -1; +} + +int rte_vfio_release_device(__rte_unused const char *sysfs_base, + __rte_unused const char *dev_addr, + __rte_unused int fd) +{ + return -1; +} + +int rte_vfio_enable(__rte_unused const char *modname) +{ + return -1; +} + +int rte_vfio_is_enabled(__rte_unused const char *modname) +{ + return 0; +} + +int rte_vfio_noiommu_is_enabled(void) +{ + return 0; +}