From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pd0-f176.google.com (mail-pd0-f176.google.com [209.85.192.176]) by dpdk.org (Postfix) with ESMTP id 06E625938 for ; Tue, 6 Jan 2015 18:27:17 +0100 (CET) Received: by mail-pd0-f176.google.com with SMTP id r10so30742949pdi.7 for ; Tue, 06 Jan 2015 09:27:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=4YLaQ1HsRXtd1cFjgqeKucZM/QXUURcQ5f9vIj0dLOw=; b=v5Wc4I7jRAUf8qm1pDvSqm7MdKhw/8QQ01lcaB9eN+iA/1zwRJcLrrEyVlYghSkmOi WkyZNC+3xEep7PQ1AW3R+gotTCu26pUucLwMAaF9cQaGzW+ffFjmgp9mdSHam1tDjDk5 SE4DjAxrYLFTPSZxRQZyWVcCQdDlIbSUTgFbpGlFB+HXqUcroVktiRvLclnZWinkzgLt PXubs/cs7Uej6rZwE4qW/5XFs3eQdpgja9mr3gKjBTCyZmywYUEH3t058arIy7kL2/bW ePvxLT3p/oxMc4XHrKVqYTiIAeVOWy245gHOQg4gEZY20XOZcWOe84h42SbDaYALawux 5/Hw== X-Received: by 10.68.141.204 with SMTP id rq12mr155511614pbb.7.1420565236339; Tue, 06 Jan 2015 09:27:16 -0800 (PST) Received: from iaas-l305162.englab.brocade.com ([144.49.130.148]) by mx.google.com with ESMTPSA id nl14sm46887340pdb.81.2015.01.06.09.27.15 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Tue, 06 Jan 2015 09:27:15 -0800 (PST) From: Ravi Kerur To: dev@dpdk.org Date: Tue, 6 Jan 2015 12:26:49 -0500 Message-Id: <1420565213-17429-3-git-send-email-rkerur@gmail.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1420565213-17429-1-git-send-email-rkerur@gmail.com> References: <1420565170-17365-1-git-send-email-rkerur@gmail.com> <1420565213-17429-1-git-send-email-rkerur@gmail.com> Subject: [dpdk-dev] [PATCH v4 3/7] Move common functions in eal.c X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 06 Jan 2015 17:27:17 -0000 Changes in v4 Remove eal_externs.h file, instead use _get_ and _set_ APIS to access those variables. Split eal_common.c into eal_common_system.c and and eal_common_runtime.c rte_eal prefix functions are moved to _runtime_ and eal prefix functions are moved to _system_ files respectively Changes in v3 Changed subject to be more explicit on file name inclusion. Changes in v2 In function rte_eal_config_create remove #ifdef _BSDAPP_ and initialize mem_cfg_addr unconditionally. Changes in v1 Move common functions in eal.c to librte_eal/common/eal_common.c. Following functions are moved to eal_common.c file. struct rte_config *rte_eal_get_configuration(void); int eal_parse_sysfs_value(const char *filename, unsigned long *val); static void rte_eal_config_create(void); enum rte_proc_type_t eal_proc_type_detect(void); void rte_eal_config_init(void); rte_usage_hook_t rte_set_application_usage_hook(rte_usage_hook_t usage_func); inline size_t eal_get_hugepage_mem_size(void); void eal_check_mem_on_local_socket(void); int sync_func(__attribute__((unused)) void *arg); inline void rte_eal_mcfg_complete(void); int rte_eal_has_hugepages(void); enum rte_lcore_role_t rte_eal_lcore_role(unsigned lcore_id); enum rte_proc_type_t rte_eal_process_type(void); Makefile changes to reflect new files added. Fix checkpatch warnings and errors. Signed-off-by: Ravi Kerur --- lib/librte_eal/bsdapp/eal/Makefile | 2 + lib/librte_eal/bsdapp/eal/eal.c | 269 ++++---------------------- lib/librte_eal/common/eal_common_runtime.c | 201 ++++++++++++++++++++ lib/librte_eal/common/eal_common_system.c | 203 ++++++++++++++++++++ lib/librte_eal/common/eal_hugepages.h | 1 + lib/librte_eal/common/eal_private.h | 78 ++++++++ lib/librte_eal/linuxapp/eal/Makefile | 2 + lib/librte_eal/linuxapp/eal/eal.c | 290 +++++------------------------ 8 files changed, 563 insertions(+), 483 deletions(-) create mode 100644 lib/librte_eal/common/eal_common_runtime.c create mode 100644 lib/librte_eal/common/eal_common_system.c diff --git a/lib/librte_eal/bsdapp/eal/Makefile b/lib/librte_eal/bsdapp/eal/Makefile index 92dd9a6..c0b73e9 100644 --- a/lib/librte_eal/bsdapp/eal/Makefile +++ b/lib/librte_eal/bsdapp/eal/Makefile @@ -58,6 +58,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_interrupts.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_alarm.c # from common dir +SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_system.c +SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_runtime.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_memzone.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_log.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_BSDAPP) += eal_common_launch.c diff --git a/lib/librte_eal/bsdapp/eal/eal.c b/lib/librte_eal/bsdapp/eal/eal.c index 69f3c03..4bba352 100644 --- a/lib/librte_eal/bsdapp/eal/eal.c +++ b/lib/librte_eal/bsdapp/eal/eal.c @@ -83,27 +83,6 @@ #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 = NULL; -/* early configuration structure, when memory config is not mmapped */ -static struct rte_mem_config early_mem_config; - -/* 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; - -static struct flock wr_lock = { - .l_type = F_WRLCK, - .l_whence = SEEK_SET, - .l_start = offsetof(struct rte_mem_config, memseg), - .l_len = sizeof(early_mem_config.memseg), -}; - -/* 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]; @@ -113,160 +92,58 @@ struct internal_config internal_config; /* used by rte_rdtsc() */ int rte_cycles_vmware_tsc_map; -/* Return a pointer to the configuration structure */ -struct rte_config * -rte_eal_get_configuration(void) -{ - return &rte_config; -} - -/* parse a sysfs (or other) file containing one integer value */ -int -eal_parse_sysfs_value(const char *filename, unsigned long *val) +inline void * +rte_eal_get_mem_cfg_addr(void) { - FILE *f; - char buf[BUFSIZ]; - char *end = NULL; - - if ((f = fopen(filename, "r")) == NULL) { - RTE_LOG(ERR, EAL, "%s(): cannot open sysfs value %s\n", - __func__, filename); - return -1; - } - - if (fgets(buf, sizeof(buf), f) == NULL) { - RTE_LOG(ERR, EAL, "%s(): cannot read sysfs value %s\n", - __func__, filename); - fclose(f); - return -1; - } - *val = strtoul(buf, &end, 0); - if ((buf[0] == '\0') || (end == NULL) || (*end != '\n')) { - RTE_LOG(ERR, EAL, "%s(): cannot parse sysfs value %s\n", - __func__, filename); - fclose(f); - return -1; - } - fclose(f); - return 0; -} - - -/* create memory configuration in shared/mmap memory. Take out - * a write lock on the memsegs, so we can auto-detect primary/secondary. - * This means we never close the file while running (auto-close on exit). - * We also don't lock the whole file, so that in future we can use read-locks - * on other parts, e.g. memzones, to detect if there are running secondary - * processes. */ -static void -rte_eal_config_create(void) -{ - void *rte_mem_cfg_addr; - int retval; - - const char *pathname = eal_runtime_config_path(); - - if (internal_config.no_shconf) - return; - - if (mem_cfg_fd < 0){ - mem_cfg_fd = open(pathname, O_RDWR | O_CREAT, 0660); - if (mem_cfg_fd < 0) - rte_panic("Cannot open '%s' for rte_mem_config\n", pathname); - } - - retval = ftruncate(mem_cfg_fd, sizeof(*rte_config.mem_config)); - if (retval < 0){ - close(mem_cfg_fd); - rte_panic("Cannot resize '%s' for rte_mem_config\n", pathname); - } - - retval = fcntl(mem_cfg_fd, F_SETLK, &wr_lock); - if (retval < 0){ - close(mem_cfg_fd); - rte_exit(EXIT_FAILURE, "Cannot create lock on '%s'. Is another primary " - "process running?\n", pathname); - } - - rte_mem_cfg_addr = mmap(NULL, sizeof(*rte_config.mem_config), - PROT_READ | PROT_WRITE, MAP_SHARED, mem_cfg_fd, 0); - - if (rte_mem_cfg_addr == MAP_FAILED){ - 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; + return NULL; } /* attach to an existing shared memory config */ -static void +void rte_eal_config_attach(void) { - void *rte_mem_cfg_addr; + struct rte_mem_config *mem_config; + struct rte_config *rte_config; const char *pathname = eal_runtime_config_path(); + int *mem_cfg_fd = eal_get_mem_cfg_fd(); if (internal_config.no_shconf) return; - if (mem_cfg_fd < 0){ - mem_cfg_fd = open(pathname, O_RDWR); - if (mem_cfg_fd < 0) + rte_config = rte_eal_get_configuration(); + if (rte_config == NULL) + return; + + if (*mem_cfg_fd < 0) { + *mem_cfg_fd = open(pathname, O_RDWR); + if (*mem_cfg_fd < 0) rte_panic("Cannot open '%s' for rte_mem_config\n", pathname); } - 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) + mem_config = (struct rte_mem_config *) mmap(NULL, sizeof(*mem_config), + PROT_READ | PROT_WRITE, + MAP_SHARED, *mem_cfg_fd, 0); + close(*mem_cfg_fd); + if (mem_config == 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 = mem_config; } -/* Detect if we are a primary or a secondary process */ -enum rte_proc_type_t -eal_proc_type_detect(void) +/* NOP for BSD */ +void +rte_eal_config_reattach(void) { - enum rte_proc_type_t ptype = RTE_PROC_PRIMARY; - const char *pathname = eal_runtime_config_path(); - - /* 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 - * and don't close it to prevent a race condition between multiple opens */ - if (((mem_cfg_fd = open(pathname, O_RDWR)) >= 0) && - (fcntl(mem_cfg_fd, F_SETLK, &wr_lock) < 0)) - ptype = RTE_PROC_SECONDARY; - - RTE_LOG(INFO, EAL, "Auto-detected process type: %s\n", - ptype == RTE_PROC_PRIMARY ? "PRIMARY" : "SECONDARY"); - - return ptype; -} -/* Sets up rte_config structure with the pointer to shared memory config.*/ -static void -rte_config_init(void) -{ - rte_config.process_type = internal_config.process_type; - - switch (rte_config.process_type){ - case RTE_PROC_PRIMARY: - rte_eal_config_create(); - break; - case RTE_PROC_SECONDARY: - rte_eal_config_attach(); - rte_eal_mcfg_wait_complete(rte_config.mem_config); - break; - case RTE_PROC_AUTO: - case RTE_PROC_INVALID: - rte_panic("Invalid process type\n"); - } } /* display usage */ static void eal_usage(const char *prgname) { + rte_usage_hook_t rte_application_usage_hook = + rte_get_application_usage_hook(); + printf("\nUsage: %s ", prgname); eal_common_usage(); /* Allow the application to print its usage message too if hook is set */ @@ -276,37 +153,6 @@ eal_usage(const char *prgname) } } -/* Set a per-application usage message */ -rte_usage_hook_t -rte_set_application_usage_hook( rte_usage_hook_t usage_func ) -{ - rte_usage_hook_t old_func; - - /* Will be NULL on the first call to denote the last usage routine. */ - old_func = rte_application_usage_hook; - rte_application_usage_hook = usage_func; - - return old_func; -} - -static inline size_t -eal_get_hugepage_mem_size(void) -{ - uint64_t size = 0; - unsigned i, j; - - for (i = 0; i < internal_config.num_hugepage_sizes; i++) { - struct hugepage_info *hpi = &internal_config.hugepage_info[i]; - if (hpi->hugedir != NULL) { - for (j = 0; j < RTE_MAX_NUMA_NODES; j++) { - size += hpi->hugepage_sz * hpi->num_pages[j]; - } - } - } - - return (size < SIZE_MAX) ? (size_t)(size) : SIZE_MAX; -} - /* Parse the argument given in the command line of the application */ static int eal_parse_args(int argc, char **argv) @@ -374,45 +220,6 @@ eal_parse_args(int argc, char **argv) return ret; } -static void -eal_check_mem_on_local_socket(void) -{ - const struct rte_memseg *ms; - int i, socket_id; - - socket_id = rte_lcore_to_socket_id(rte_config.master_lcore); - - ms = rte_eal_get_physmem_layout(); - - for (i = 0; i < RTE_MAX_MEMSEG; i++) - if (ms[i].socket_id == socket_id && - ms[i].len > 0) - return; - - RTE_LOG(WARNING, EAL, "WARNING: Master core has no " - "memory on local socket!\n"); -} - -static int -sync_func(__attribute__((unused)) void *arg) -{ - return 0; -} - -inline static void -rte_eal_mcfg_complete(void) -{ - /* ALL shared mem_config related INIT DONE */ - if (rte_config.process_type == RTE_PROC_PRIMARY) - rte_config.mem_config->magic = RTE_MAGIC; -} - -/* return non-zero if hugepages are enabled. */ -int rte_eal_has_hugepages(void) -{ - return !internal_config.no_hugetlbfs; -} - /* Abstraction for port I/0 privilege */ int rte_eal_iopl_init(void) @@ -431,8 +238,13 @@ rte_eal_init(int argc, char **argv) { int i, fctret, ret; pthread_t thread_id; + struct rte_config *rte_config; static rte_atomic32_t run_once = RTE_ATOMIC32_INIT(0); + rte_config = rte_eal_get_configuration(); + if (rte_config == NULL) + return -1; + if (!rte_atomic32_test_and_set(&run_once)) return -1; @@ -476,7 +288,7 @@ rte_eal_init(int argc, char **argv) rte_srand(rte_rdtsc()); - rte_config_init(); + rte_eal_config_init(); if (rte_eal_memory_init() < 0) rte_panic("Cannot init memory\n"); @@ -503,7 +315,7 @@ rte_eal_init(int argc, char **argv) rte_panic("Cannot init PCI\n"); RTE_LOG(DEBUG, EAL, "Master core %u is ready (tid=%p)\n", - rte_config.master_lcore, thread_id); + rte_config->master_lcore, thread_id); eal_check_mem_on_local_socket(); @@ -532,7 +344,7 @@ rte_eal_init(int argc, char **argv) rte_panic("Cannot create thread\n"); } - eal_thread_init_master(rte_config.master_lcore); + eal_thread_init_master(rte_config->master_lcore); /* * Launch a dummy function on all slave lcores, so that master lcore @@ -548,16 +360,3 @@ rte_eal_init(int argc, char **argv) return fctret; } -/* get core role */ -enum rte_lcore_role_t -rte_eal_lcore_role(unsigned lcore_id) -{ - return (rte_config.lcore_role[lcore_id]); -} - -enum rte_proc_type_t -rte_eal_process_type(void) -{ - return (rte_config.process_type); -} - diff --git a/lib/librte_eal/common/eal_common_runtime.c b/lib/librte_eal/common/eal_common_runtime.c new file mode 100644 index 0000000..a7f8c8e --- /dev/null +++ b/lib/librte_eal/common/eal_common_runtime.c @@ -0,0 +1,201 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2014 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 + * 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 +#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" +#include "eal_options.h" + +/* Allow the application to print its usage message too if set */ +rte_usage_hook_t rte_application_usage_hook = NULL; + +/* early configuration structure, when memory config is not mmapped */ +static struct rte_mem_config early_mem_config; + +/* Address of global and public configuration */ +struct rte_config rte_config = { + .mem_config = &early_mem_config, +}; + +/* Return a pointer to the configuration structure */ +struct rte_config * +rte_eal_get_configuration(void) +{ + return &rte_config; +} + +/* create memory configuration in shared/mmap memory. Take out + * a write lock on the memsegs, so we can auto-detect primary/secondary. + * This means we never close the file while running (auto-close on exit). + * We also don't lock the whole file, so that in future we can use read-locks + * on other parts, e.g. memzones, to detect if there are running secondary + * processes. */ +static void +rte_eal_config_create(void) +{ + void *rte_mem_cfg_addr; + int retval; + int *mem_cfg_fd = eal_get_mem_cfg_fd(); + + const char *pathname = eal_runtime_config_path(); + + if (internal_config.no_shconf) + return; + + rte_mem_cfg_addr = rte_eal_get_mem_cfg_addr(); + + if (*mem_cfg_fd < 0) { + *mem_cfg_fd = open(pathname, O_RDWR | O_CREAT, 0660); + if (*mem_cfg_fd < 0) + rte_panic("Cannot open '%s' for rte_mem_config\n", + pathname); + } + + retval = eal_ftruncate_and_fcntl(mem_cfg_fd, + sizeof(*rte_config.mem_config)); + + if (retval == -1) { + close(*mem_cfg_fd); + rte_panic("Cannot resize '%s' for rte_mem_config\n", pathname); + } else if (retval == -2) { + close(*mem_cfg_fd); + rte_exit(EXIT_FAILURE, "Cannot create lock on '%s'. " + "Is another primary process running?\n", pathname); + } + + rte_mem_cfg_addr = mmap(rte_mem_cfg_addr, + sizeof(*rte_config.mem_config), PROT_READ | PROT_WRITE, + MAP_SHARED, *mem_cfg_fd, 0); + + if (rte_mem_cfg_addr == MAP_FAILED) + 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; + + /* store address of the config in the config itself so that secondary + * processes could later map the config into this exact location + */ + rte_config.mem_config->mem_cfg_addr = (uintptr_t) rte_mem_cfg_addr; +} + +/* Sets up rte_config structure with the pointer to shared memory config.*/ +void +rte_eal_config_init(void) +{ + rte_config.process_type = internal_config.process_type; + + switch (rte_config.process_type) { + case RTE_PROC_PRIMARY: + rte_eal_config_create(); + break; + case RTE_PROC_SECONDARY: + rte_eal_config_attach(); + rte_eal_mcfg_wait_complete(rte_config.mem_config); + rte_eal_config_reattach(); + break; + case RTE_PROC_AUTO: + case RTE_PROC_INVALID: + rte_panic("Invalid process type\n"); + } +} + +/* Get per-application usage message */ +rte_usage_hook_t +rte_get_application_usage_hook(void) +{ + return rte_application_usage_hook; +} + +/* Set a per-application usage message */ +rte_usage_hook_t +rte_set_application_usage_hook(rte_usage_hook_t usage_func) +{ + rte_usage_hook_t old_func; + + /* Will be NULL on the first call to denote the last usage routine. */ + old_func = rte_application_usage_hook; + rte_application_usage_hook = usage_func; + + return old_func; +} + +inline void +rte_eal_mcfg_complete(void) +{ + /* ALL shared mem_config related INIT DONE */ + if (rte_config.process_type == RTE_PROC_PRIMARY) + rte_config.mem_config->magic = RTE_MAGIC; +} + +/* return non-zero if hugepages are enabled. */ +int rte_eal_has_hugepages(void) +{ + return !internal_config.no_hugetlbfs; +} + +/* get core role */ +enum rte_lcore_role_t +rte_eal_lcore_role(unsigned lcore_id) +{ + return rte_config.lcore_role[lcore_id]; +} + +enum rte_proc_type_t +rte_eal_process_type(void) +{ + return rte_config.process_type; +} diff --git a/lib/librte_eal/common/eal_common_system.c b/lib/librte_eal/common/eal_common_system.c new file mode 100644 index 0000000..1fd48cc --- /dev/null +++ b/lib/librte_eal/common/eal_common_system.c @@ -0,0 +1,203 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2014 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 + * 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 +#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" +#include "eal_options.h" + +#include +#include +#include + +/* 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 */ +int mem_cfg_fd = -1; + +static struct flock wr_lock = { + .l_type = F_WRLCK, + .l_whence = SEEK_SET, + .l_start = offsetof(struct rte_mem_config, memseg), + .l_len = sizeof(((struct rte_mem_config *)0)->memseg), +}; + +/* Return memory config file descriptor */ +int* +eal_get_mem_cfg_fd(void) +{ + return &mem_cfg_fd; +} + +/* parse a sysfs (or other) file containing one integer value */ +int +eal_parse_sysfs_value(const char *filename, unsigned long *val) +{ + FILE *f; + char buf[BUFSIZ]; + char *end = NULL; + + f = fopen(filename, "r"); + if (f == NULL) { + RTE_LOG(ERR, EAL, "%s(): cannot open sysfs value %s\n", + __func__, filename); + return -1; + } + + if (fgets(buf, sizeof(buf), f) == NULL) { + RTE_LOG(ERR, EAL, "%s(): cannot read sysfs value %s\n", + __func__, filename); + fclose(f); + return -1; + } + *val = strtoul(buf, &end, 0); + if ((buf[0] == '\0') || (end == NULL) || (*end != '\n')) { + RTE_LOG(ERR, EAL, "%s(): cannot parse sysfs value %s\n", + __func__, filename); + fclose(f); + return -1; + } + fclose(f); + return 0; +} + +/* 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(); + + /* 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 and don't close it to prevent a race + * condition between multiple opens + */ + mem_cfg_fd = open(pathname, O_RDWR); + if ((mem_cfg_fd >= 0) && + (fcntl(mem_cfg_fd, F_SETLK, &wr_lock) < 0)) + ptype = RTE_PROC_SECONDARY; + + RTE_LOG(INFO, EAL, "Auto-detected process type: %s\n", + ptype == RTE_PROC_PRIMARY ? "PRIMARY" : "SECONDARY"); + + return ptype; +} + +inline size_t +eal_get_hugepage_mem_size(void) +{ + uint64_t size = 0; + unsigned i, j; + + for (i = 0; i < internal_config.num_hugepage_sizes; i++) { + struct hugepage_info *hpi = &internal_config.hugepage_info[i]; + + if (hpi->hugedir != NULL) { + for (j = 0; j < RTE_MAX_NUMA_NODES; j++) + size += hpi->hugepage_sz * hpi->num_pages[j]; + } + } + + return (size < SIZE_MAX) ? (size_t)(size) : SIZE_MAX; +} + +void +eal_check_mem_on_local_socket(void) +{ + const struct rte_memseg *ms; + int i, socket_id; + struct rte_config *rte_config = + rte_eal_get_configuration(); + + if (rte_config == NULL) { + RTE_LOG(WARNING, EAL, "WARNING: rte_config NULL!\n"); + return; + } + + socket_id = rte_lcore_to_socket_id(rte_config->master_lcore); + + ms = rte_eal_get_physmem_layout(); + + for (i = 0; i < RTE_MAX_MEMSEG; i++) + if (ms[i].socket_id == socket_id && + ms[i].len > 0) + return; + + RTE_LOG(WARNING, EAL, "WARNING: Master core has no " + "memory on local socket!\n"); +} + +int +sync_func(__attribute__((unused)) void *arg) +{ + return 0; +} + +/* + * Perform ftruncate and fcntl operations on + * memory config file descriptor. + */ +int +eal_ftruncate_and_fcntl(int *mem_cfg_fd, size_t size) +{ + int retval; + + retval = ftruncate(*mem_cfg_fd, size); + if (retval < 0) + return -1; + + retval = fcntl(*mem_cfg_fd, F_SETLK, &wr_lock); + if (retval < 0) + return -2; + return 0; +} diff --git a/lib/librte_eal/common/eal_hugepages.h b/lib/librte_eal/common/eal_hugepages.h index 38edac0..0b4d7a2 100644 --- a/lib/librte_eal/common/eal_hugepages.h +++ b/lib/librte_eal/common/eal_hugepages.h @@ -63,5 +63,6 @@ struct hugepage_file { * for the EAL to use */ int eal_hugepage_info_init(void); +inline size_t eal_get_hugepage_mem_size(void); #endif /* EAL_HUGEPAGES_H */ diff --git a/lib/librte_eal/common/eal_private.h b/lib/librte_eal/common/eal_private.h index 232fcec..6675bc4 100644 --- a/lib/librte_eal/common/eal_private.h +++ b/lib/librte_eal/common/eal_private.h @@ -36,6 +36,8 @@ #include +#include + /** * Initialize the memzone subsystem (private to eal). * @@ -203,4 +205,80 @@ int rte_eal_alarm_init(void); */ int rte_eal_dev_init(void); +/** + * This function sets up rte_config structure + * + * This function is private to the EAL. + */ +void rte_eal_config_init(void); + +/** + * This function checks memory on local socket(NUMA) + * + * This function is private to the EAL. + */ +void eal_check_mem_on_local_socket(void); + +/** + * This function updates shared mem_config INIT DONE + * + * This function is private to the EAL. + */ +inline void rte_eal_mcfg_complete(void); + +/** + * + * This function is private to the EAL. + */ +int sync_func(__attribute__((unused)) void *arg); + +/** + * + * This function is private to the EAL. + */ +inline void *rte_eal_get_mem_cfg_addr(void); + +/** + * Return a pointer to the configuration structure + * + * This function is private to the EAL. + */ +struct rte_config *rte_eal_get_configuration(void); + +/** + * Return memory config file descriptor + * + * This function is private to the EAL. + */ +int *eal_get_mem_cfg_fd(void); + +/** + * Perform ftruncate and fcntl operations on + * memory config file descriptor. + * + * This function is private to the EAL. + */ +int eal_ftruncate_and_fcntl(int *mem_cfg_fd, size_t size); + +/** + * Get per-application usage message + * + * This function is private to the EAL. + */ +rte_usage_hook_t rte_get_application_usage_hook(void); + +/** + * This function attaches shared memory config + * + * This function is private to the EAL. + */ +void rte_eal_config_attach(void); + +/** + * This function reattaches shared memory config + * + * This function is private to the EAL. + */ +void rte_eal_config_reattach(void); + #endif /* _EAL_PRIVATE_H_ */ diff --git a/lib/librte_eal/linuxapp/eal/Makefile b/lib/librte_eal/linuxapp/eal/Makefile index 9252333..f3600d8 100644 --- a/lib/librte_eal/linuxapp/eal/Makefile +++ b/lib/librte_eal/linuxapp/eal/Makefile @@ -70,6 +70,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_ivshmem.c endif # from common dir +SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_system.c +SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_runtime.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_memzone.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_log.c SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common_launch.c diff --git a/lib/librte_eal/linuxapp/eal/eal.c b/lib/librte_eal/linuxapp/eal/eal.c index 2fb1acc..677ccf1 100644 --- a/lib/librte_eal/linuxapp/eal/eal.c +++ b/lib/librte_eal/linuxapp/eal/eal.c @@ -89,9 +89,6 @@ #define SOCKET_MEM_STRLEN (RTE_MAX_NUMA_NODES * 10) -/* Allow the application to print its usage message too if set */ -static rte_usage_hook_t rte_application_usage_hook = NULL; - TAILQ_HEAD(shared_driver_list, shared_driver); /* Definition for shared object drivers. */ @@ -106,25 +103,6 @@ struct shared_driver { static struct shared_driver_list solib_list = TAILQ_HEAD_INITIALIZER(solib_list); -/* early configuration structure, when memory config is not mmapped */ -static struct rte_mem_config early_mem_config; - -/* 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; - -static struct flock wr_lock = { - .l_type = F_WRLCK, - .l_whence = SEEK_SET, - .l_start = offsetof(struct rte_mem_config, memseg), - .l_len = sizeof(early_mem_config.memseg), -}; - -/* 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]; @@ -134,196 +112,85 @@ struct internal_config internal_config; /* used by rte_rdtsc() */ int rte_cycles_vmware_tsc_map; -/* Return a pointer to the configuration structure */ -struct rte_config * -rte_eal_get_configuration(void) -{ - return &rte_config; -} - -/* parse a sysfs (or other) file containing one integer value */ -int -eal_parse_sysfs_value(const char *filename, unsigned long *val) -{ - FILE *f; - char buf[BUFSIZ]; - char *end = NULL; - - if ((f = fopen(filename, "r")) == NULL) { - RTE_LOG(ERR, EAL, "%s(): cannot open sysfs value %s\n", - __func__, filename); - return -1; - } - - if (fgets(buf, sizeof(buf), f) == NULL) { - RTE_LOG(ERR, EAL, "%s(): cannot read sysfs value %s\n", - __func__, filename); - fclose(f); - return -1; - } - *val = strtoul(buf, &end, 0); - if ((buf[0] == '\0') || (end == NULL) || (*end != '\n')) { - RTE_LOG(ERR, EAL, "%s(): cannot parse sysfs value %s\n", - __func__, filename); - fclose(f); - return -1; - } - fclose(f); - return 0; -} - - -/* create memory configuration in shared/mmap memory. Take out - * a write lock on the memsegs, so we can auto-detect primary/secondary. - * This means we never close the file while running (auto-close on exit). - * We also don't lock the whole file, so that in future we can use read-locks - * on other parts, e.g. memzones, to detect if there are running secondary - * processes. */ -static void -rte_eal_config_create(void) +inline void * +rte_eal_get_mem_cfg_addr(void) { - void *rte_mem_cfg_addr; - int retval; - - const char *pathname = eal_runtime_config_path(); + void *mem_cfg_addr; - if (internal_config.no_shconf) - return; - - /* map the config before hugepage address so that we don't waste a page */ if (internal_config.base_virtaddr != 0) - rte_mem_cfg_addr = (void *) + mem_cfg_addr = (void *) RTE_ALIGN_FLOOR(internal_config.base_virtaddr - sizeof(struct rte_mem_config), sysconf(_SC_PAGE_SIZE)); else - rte_mem_cfg_addr = NULL; - - if (mem_cfg_fd < 0){ - mem_cfg_fd = open(pathname, O_RDWR | O_CREAT, 0660); - if (mem_cfg_fd < 0) - rte_panic("Cannot open '%s' for rte_mem_config\n", pathname); - } - - retval = ftruncate(mem_cfg_fd, sizeof(*rte_config.mem_config)); - if (retval < 0){ - close(mem_cfg_fd); - rte_panic("Cannot resize '%s' for rte_mem_config\n", pathname); - } - - retval = fcntl(mem_cfg_fd, F_SETLK, &wr_lock); - if (retval < 0){ - close(mem_cfg_fd); - rte_exit(EXIT_FAILURE, "Cannot create lock on '%s'. Is another primary " - "process running?\n", pathname); - } - - rte_mem_cfg_addr = mmap(rte_mem_cfg_addr, sizeof(*rte_config.mem_config), - PROT_READ | PROT_WRITE, MAP_SHARED, mem_cfg_fd, 0); - - if (rte_mem_cfg_addr == MAP_FAILED){ - 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; - - /* store address of the config in the config itself so that secondary - * processes could later map the config into this exact location */ - rte_config.mem_config->mem_cfg_addr = (uintptr_t) rte_mem_cfg_addr; + mem_cfg_addr = NULL; + return mem_cfg_addr; } /* attach to an existing shared memory config */ -static void +void rte_eal_config_attach(void) { struct rte_mem_config *mem_config; + struct rte_config *rte_config; + int *mem_cfg_fd = eal_get_mem_cfg_fd(); const char *pathname = eal_runtime_config_path(); if (internal_config.no_shconf) return; - if (mem_cfg_fd < 0){ - mem_cfg_fd = open(pathname, O_RDWR); - if (mem_cfg_fd < 0) + rte_config = rte_eal_get_configuration(); + if (rte_config == NULL) + return; + + if (*mem_cfg_fd < 0) { + *mem_cfg_fd = open(pathname, O_RDWR); + if (*mem_cfg_fd < 0) rte_panic("Cannot open '%s' for rte_mem_config\n", pathname); } /* map it as read-only first */ mem_config = (struct rte_mem_config *) mmap(NULL, sizeof(*mem_config), - PROT_READ, MAP_SHARED, mem_cfg_fd, 0); + PROT_READ, MAP_SHARED, *mem_cfg_fd, 0); if (mem_config == MAP_FAILED) rte_panic("Cannot mmap memory for rte_config\n"); - rte_config.mem_config = mem_config; + rte_config->mem_config = mem_config; } /* reattach the shared config at exact memory location primary process has it */ -static void +void rte_eal_config_reattach(void) { struct rte_mem_config *mem_config; void *rte_mem_cfg_addr; + struct rte_config *rte_config; + int *mem_cfg_fd = eal_get_mem_cfg_fd(); if (internal_config.no_shconf) return; + rte_config = rte_eal_get_configuration(); + if (rte_config == NULL) + return; + /* save the address primary process has mapped shared config to */ - rte_mem_cfg_addr = (void *) (uintptr_t) rte_config.mem_config->mem_cfg_addr; + rte_mem_cfg_addr = + (void *) (uintptr_t) rte_config->mem_config->mem_cfg_addr; /* unmap original config */ - munmap(rte_config.mem_config, sizeof(struct rte_mem_config)); + munmap(rte_config->mem_config, sizeof(struct rte_mem_config)); /* remap the config at proper address */ mem_config = (struct rte_mem_config *) mmap(rte_mem_cfg_addr, sizeof(*mem_config), PROT_READ | PROT_WRITE, MAP_SHARED, - mem_cfg_fd, 0); - close(mem_cfg_fd); + *mem_cfg_fd, 0); + close(*mem_cfg_fd); if (mem_config == MAP_FAILED || mem_config != rte_mem_cfg_addr) rte_panic("Cannot mmap memory for rte_config\n"); - rte_config.mem_config = mem_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(); - - /* 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 - * and don't close it to prevent a race condition between multiple opens */ - if (((mem_cfg_fd = open(pathname, O_RDWR)) >= 0) && - (fcntl(mem_cfg_fd, F_SETLK, &wr_lock) < 0)) - ptype = RTE_PROC_SECONDARY; - - RTE_LOG(INFO, EAL, "Auto-detected process type: %s\n", - ptype == RTE_PROC_PRIMARY ? "PRIMARY" : "SECONDARY"); - - return ptype; -} - -/* Sets up rte_config structure with the pointer to shared memory config.*/ -static void -rte_config_init(void) -{ - rte_config.process_type = internal_config.process_type; - - switch (rte_config.process_type){ - case RTE_PROC_PRIMARY: - rte_eal_config_create(); - break; - case RTE_PROC_SECONDARY: - rte_eal_config_attach(); - rte_eal_mcfg_wait_complete(rte_config.mem_config); - rte_eal_config_reattach(); - break; - case RTE_PROC_AUTO: - case RTE_PROC_INVALID: - rte_panic("Invalid process type\n"); - } + rte_config->mem_config = mem_config; } /* Unlocks hugepage directories that were locked by eal_hugepage_info_init */ @@ -349,6 +216,9 @@ eal_hugedirs_unlock(void) static void eal_usage(const char *prgname) { + rte_usage_hook_t rte_application_usage_hook = + rte_get_application_usage_hook(); + printf("\nUsage: %s ", prgname); eal_common_usage(); printf("EAL Linux options:\n" @@ -371,19 +241,6 @@ eal_usage(const char *prgname) } } -/* Set a per-application usage message */ -rte_usage_hook_t -rte_set_application_usage_hook( rte_usage_hook_t usage_func ) -{ - rte_usage_hook_t old_func; - - /* Will be NULL on the first call to denote the last usage routine. */ - old_func = rte_application_usage_hook; - rte_application_usage_hook = usage_func; - - return old_func; -} - static int eal_parse_socket_mem(char *socket_mem) { @@ -485,24 +342,6 @@ eal_parse_vfio_intr(const char *mode) return -1; } -static inline size_t -eal_get_hugepage_mem_size(void) -{ - uint64_t size = 0; - unsigned i, j; - - for (i = 0; i < internal_config.num_hugepage_sizes; i++) { - struct hugepage_info *hpi = &internal_config.hugepage_info[i]; - if (hpi->hugedir != NULL) { - for (j = 0; j < RTE_MAX_NUMA_NODES; j++) { - size += hpi->hugepage_sz * hpi->num_pages[j]; - } - } - } - - return (size < SIZE_MAX) ? (size_t)(size) : SIZE_MAX; -} - /* Parse the argument given in the command line of the application */ static int eal_parse_args(int argc, char **argv) @@ -643,39 +482,6 @@ eal_parse_args(int argc, char **argv) return ret; } -static void -eal_check_mem_on_local_socket(void) -{ - const struct rte_memseg *ms; - int i, socket_id; - - socket_id = rte_lcore_to_socket_id(rte_config.master_lcore); - - ms = rte_eal_get_physmem_layout(); - - for (i = 0; i < RTE_MAX_MEMSEG; i++) - if (ms[i].socket_id == socket_id && - ms[i].len > 0) - return; - - RTE_LOG(WARNING, EAL, "WARNING: Master core has no " - "memory on local socket!\n"); -} - -static int -sync_func(__attribute__((unused)) void *arg) -{ - return 0; -} - -inline static void -rte_eal_mcfg_complete(void) -{ - /* ALL shared mem_config related INIT DONE */ - if (rte_config.process_type == RTE_PROC_PRIMARY) - rte_config.mem_config->magic = RTE_MAGIC; -} - /* * Request iopl privilege for all RPL, returns 0 on success * iopl() call is mostly for the i386 architecture. For other architectures, @@ -702,10 +508,15 @@ rte_eal_init(int argc, char **argv) static rte_atomic32_t run_once = RTE_ATOMIC32_INIT(0); struct shared_driver *solib = NULL; const char *logid; + struct rte_config *rte_config; if (!rte_atomic32_test_and_set(&run_once)) return -1; + rte_config = rte_eal_get_configuration(); + if (rte_config == NULL) + return -1; + logid = strrchr(argv[0], '/'); logid = strdup(logid ? logid + 1: argv[0]); @@ -750,7 +561,7 @@ rte_eal_init(int argc, char **argv) rte_srand(rte_rdtsc()); - rte_config_init(); + rte_eal_config_init(); if (rte_eal_pci_init() < 0) rte_panic("Cannot init PCI\n"); @@ -800,10 +611,10 @@ rte_eal_init(int argc, char **argv) RTE_LOG(WARNING, EAL, "%s\n", dlerror()); } - eal_thread_init_master(rte_config.master_lcore); + eal_thread_init_master(rte_config->master_lcore); RTE_LOG(DEBUG, EAL, "Master core %u is ready (tid=%x)\n", - rte_config.master_lcore, (int)thread_id); + rte_config->master_lcore, (int)thread_id); if (rte_eal_dev_init() < 0) rte_panic("Cannot init pmd devices\n"); @@ -842,20 +653,3 @@ rte_eal_init(int argc, char **argv) return fctret; } -/* get core role */ -enum rte_lcore_role_t -rte_eal_lcore_role(unsigned lcore_id) -{ - return (rte_config.lcore_role[lcore_id]); -} - -enum rte_proc_type_t -rte_eal_process_type(void) -{ - return (rte_config.process_type); -} - -int rte_eal_has_hugepages(void) -{ - return ! internal_config.no_hugetlbfs; -} -- 1.9.1