diff mbox

[dpdk-dev,4/7] Move EAL common functions

Message ID 1419521597-31978-5-git-send-email-rkerur@gmail.com (mailing list archive)
State Superseded, archived
Headers show

Commit Message

Ravi Kerur Dec. 25, 2014, 3:33 p.m. UTC
Move common functions in eal.c to librte_eal/common directory.
Use RTE_EXEC_ENV_BSDAPP to differentiate minor differences in
common functions.
Makefile changes to reflect new file.
Fix checkpatch warnings and errors.

Signed-off-by: Ravi Kerur <rkerur@gmail.com>
---
 lib/librte_eal/bsdapp/eal/Makefile    |   1 +
 lib/librte_eal/bsdapp/eal/eal.c       | 233 +-----------------------
 lib/librte_eal/common/eal_common.c    | 328 ++++++++++++++++++++++++++++++++++
 lib/librte_eal/common/eal_externs.h   |  42 +++++
 lib/librte_eal/common/eal_hugepages.h |   1 +
 lib/librte_eal/common/eal_private.h   |  47 +++++
 lib/librte_eal/linuxapp/eal/Makefile  |   1 +
 lib/librte_eal/linuxapp/eal/eal.c     | 246 ++-----------------------
 8 files changed, 439 insertions(+), 460 deletions(-)
 create mode 100644 lib/librte_eal/common/eal_common.c
 create mode 100644 lib/librte_eal/common/eal_externs.h

Comments

Neil Horman Dec. 25, 2014, 5:44 p.m. UTC | #1
On Thu, Dec 25, 2014 at 10:33:14AM -0500, Ravi Kerur wrote:
> Move common functions in eal.c to librte_eal/common directory.
> Use RTE_EXEC_ENV_BSDAPP to differentiate minor differences in
> common functions.
> Makefile changes to reflect new file.
> Fix checkpatch warnings and errors.
> 
> Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> ---
>  lib/librte_eal/bsdapp/eal/Makefile    |   1 +
>  lib/librte_eal/bsdapp/eal/eal.c       | 233 +-----------------------
>  lib/librte_eal/common/eal_common.c    | 328 ++++++++++++++++++++++++++++++++++
>  lib/librte_eal/common/eal_externs.h   |  42 +++++
>  lib/librte_eal/common/eal_hugepages.h |   1 +
>  lib/librte_eal/common/eal_private.h   |  47 +++++
>  lib/librte_eal/linuxapp/eal/Makefile  |   1 +
>  lib/librte_eal/linuxapp/eal/eal.c     | 246 ++-----------------------
>  8 files changed, 439 insertions(+), 460 deletions(-)
>  create mode 100644 lib/librte_eal/common/eal_common.c
>  create mode 100644 lib/librte_eal/common/eal_externs.h
> 
> diff --git a/lib/librte_eal/bsdapp/eal/Makefile b/lib/librte_eal/bsdapp/eal/Makefile
> index 92dd9a6..050d70b 100644
> --- a/lib/librte_eal/bsdapp/eal/Makefile
> +++ b/lib/librte_eal/bsdapp/eal/Makefile
> @@ -58,6 +58,7 @@ 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.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..f925da7 100644
> --- a/lib/librte_eal/bsdapp/eal/eal.c
> +++ b/lib/librte_eal/bsdapp/eal/eal.c
> @@ -80,30 +80,10 @@
>  #include "eal_filesystem.h"
>  #include "eal_hugepages.h"
>  #include "eal_options.h"
> +#include "eal_externs.h"
>  
>  #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
>  
> -/* Allow the application to print its usage message too if set */
> -static rte_usage_hook_t	rte_application_usage_hook = 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,93 +93,14 @@ 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)
> +inline void *
> +rte_eal_get_mem_cfg_addr(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)
> -{
> -	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;
> @@ -223,44 +124,11 @@ rte_eal_config_attach(void)
>  	rte_config.mem_config = (struct rte_mem_config *) rte_mem_cfg_addr;
>  }
>  
> -/* 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 */
> @@ -276,37 +144,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 +211,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)
> @@ -476,7 +274,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");
> @@ -548,16 +346,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.c b/lib/librte_eal/common/eal_common.c
> new file mode 100644
> index 0000000..becf9c8
> --- /dev/null
> +++ b/lib/librte_eal/common/eal_common.c
> @@ -0,0 +1,328 @@
> +/*-
> + *   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 <stdio.h>
> +#include <stdlib.h>
> +#include <stdint.h>
> +#include <string.h>
> +#include <stdarg.h>
> +#include <unistd.h>
> +#include <pthread.h>
> +#include <syslog.h>
> +#include <getopt.h>
> +#include <sys/file.h>
> +#include <stddef.h>
> +#include <errno.h>
> +#include <limits.h>
> +#include <errno.h>
> +#include <sys/mman.h>
> +#include <sys/queue.h>
> +
> +#include <rte_common.h>
> +#include <rte_debug.h>
> +#include <rte_memory.h>
> +#include <rte_memzone.h>
> +#include <rte_launch.h>
> +#include <rte_tailq.h>
> +#include <rte_eal.h>
> +#include <rte_eal_memconfig.h>
> +#include <rte_per_lcore.h>
> +#include <rte_lcore.h>
> +#include <rte_log.h>
> +#include <rte_random.h>
> +#include <rte_cycles.h>
> +#include <rte_string_fns.h>
> +#include <rte_cpuflags.h>
> +#include <rte_interrupts.h>
> +#include <rte_pci.h>
> +#include <rte_dev.h>
> +#include <rte_devargs.h>
> +#include <rte_common.h>
> +#include <rte_version.h>
> +#include <rte_atomic.h>
> +#include <malloc_heap.h>
> +#include <rte_eth_ring.h>
> +
> +#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;
> +
> +/* 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;
> +
> +/* 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,
> +};
> +
> +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),
> +};
> +
> +/* 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;
> +
> +	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;
> +}
> +
> +
> +/* 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;
> +
> +	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 = 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;
> +
> +#ifndef RTE_EXEC_ENV_BSDAPP
> +	/* 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;
> +#endif /* RTE_EXEC_ENV_BSDAPP */
Why is this a BSD/Linux Differentiator?
Neil
Ravi Kerur Dec. 25, 2014, 7:17 p.m. UTC | #2
Inline <rk>

On Thu, Dec 25, 2014 at 9:44 AM, Neil Horman <nhorman@tuxdriver.com> wrote:

> On Thu, Dec 25, 2014 at 10:33:14AM -0500, Ravi Kerur wrote:
> > Move common functions in eal.c to librte_eal/common directory.
> > Use RTE_EXEC_ENV_BSDAPP to differentiate minor differences in
> > common functions.
> > Makefile changes to reflect new file.
> > Fix checkpatch warnings and errors.
> >
> > Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> > ---
> >  lib/librte_eal/bsdapp/eal/Makefile    |   1 +
> >  lib/librte_eal/bsdapp/eal/eal.c       | 233 +-----------------------
> >  lib/librte_eal/common/eal_common.c    | 328
> ++++++++++++++++++++++++++++++++++
> >  lib/librte_eal/common/eal_externs.h   |  42 +++++
> >  lib/librte_eal/common/eal_hugepages.h |   1 +
> >  lib/librte_eal/common/eal_private.h   |  47 +++++
> >  lib/librte_eal/linuxapp/eal/Makefile  |   1 +
> >  lib/librte_eal/linuxapp/eal/eal.c     | 246 ++-----------------------
> >  8 files changed, 439 insertions(+), 460 deletions(-)
> >  create mode 100644 lib/librte_eal/common/eal_common.c
> >  create mode 100644 lib/librte_eal/common/eal_externs.h
> >
> > diff --git a/lib/librte_eal/bsdapp/eal/Makefile
> b/lib/librte_eal/bsdapp/eal/Makefile
> > index 92dd9a6..050d70b 100644
> > --- a/lib/librte_eal/bsdapp/eal/Makefile
> > +++ b/lib/librte_eal/bsdapp/eal/Makefile
> > @@ -58,6 +58,7 @@ 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.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..f925da7 100644
> > --- a/lib/librte_eal/bsdapp/eal/eal.c
> > +++ b/lib/librte_eal/bsdapp/eal/eal.c
> > @@ -80,30 +80,10 @@
> >  #include "eal_filesystem.h"
> >  #include "eal_hugepages.h"
> >  #include "eal_options.h"
> > +#include "eal_externs.h"
> >
> >  #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
> >
> > -/* Allow the application to print its usage message too if set */
> > -static rte_usage_hook_t      rte_application_usage_hook = 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,93 +93,14 @@ 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)
> > +inline void *
> > +rte_eal_get_mem_cfg_addr(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)
> > -{
> > -     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;
> > @@ -223,44 +124,11 @@ rte_eal_config_attach(void)
> >       rte_config.mem_config = (struct rte_mem_config *) rte_mem_cfg_addr;
> >  }
> >
> > -/* 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 */
> > @@ -276,37 +144,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 +211,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)
> > @@ -476,7 +274,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");
> > @@ -548,16 +346,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.c
> b/lib/librte_eal/common/eal_common.c
> > new file mode 100644
> > index 0000000..becf9c8
> > --- /dev/null
> > +++ b/lib/librte_eal/common/eal_common.c
> > @@ -0,0 +1,328 @@
> > +/*-
> > + *   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 <stdio.h>
> > +#include <stdlib.h>
> > +#include <stdint.h>
> > +#include <string.h>
> > +#include <stdarg.h>
> > +#include <unistd.h>
> > +#include <pthread.h>
> > +#include <syslog.h>
> > +#include <getopt.h>
> > +#include <sys/file.h>
> > +#include <stddef.h>
> > +#include <errno.h>
> > +#include <limits.h>
> > +#include <errno.h>
> > +#include <sys/mman.h>
> > +#include <sys/queue.h>
> > +
> > +#include <rte_common.h>
> > +#include <rte_debug.h>
> > +#include <rte_memory.h>
> > +#include <rte_memzone.h>
> > +#include <rte_launch.h>
> > +#include <rte_tailq.h>
> > +#include <rte_eal.h>
> > +#include <rte_eal_memconfig.h>
> > +#include <rte_per_lcore.h>
> > +#include <rte_lcore.h>
> > +#include <rte_log.h>
> > +#include <rte_random.h>
> > +#include <rte_cycles.h>
> > +#include <rte_string_fns.h>
> > +#include <rte_cpuflags.h>
> > +#include <rte_interrupts.h>
> > +#include <rte_pci.h>
> > +#include <rte_dev.h>
> > +#include <rte_devargs.h>
> > +#include <rte_common.h>
> > +#include <rte_version.h>
> > +#include <rte_atomic.h>
> > +#include <malloc_heap.h>
> > +#include <rte_eth_ring.h>
> > +
> > +#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;
> > +
> > +/* 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;
> > +
> > +/* 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,
> > +};
> > +
> > +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),
> > +};
> > +
> > +/* 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;
> > +
> > +     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;
> > +}
> > +
> > +
> > +/* 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;
> > +
> > +     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 = 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;
> > +
> > +#ifndef RTE_EXEC_ENV_BSDAPP
> > +     /* 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;
> > +#endif /* RTE_EXEC_ENV_BSDAPP */
> Why is this a BSD/Linux Differentiator?
>

<rk> Existing code where assignment is not present in BSD code hence the
differentiation.

> Neil
>
>
Neil Horman Dec. 26, 2014, 2:42 p.m. UTC | #3
On Thu, Dec 25, 2014 at 11:17:41AM -0800, Ravi Kerur wrote:
> Inline <rk>
> 
> On Thu, Dec 25, 2014 at 9:44 AM, Neil Horman <nhorman@tuxdriver.com> wrote:
> 
> > On Thu, Dec 25, 2014 at 10:33:14AM -0500, Ravi Kerur wrote:
> > > Move common functions in eal.c to librte_eal/common directory.
> > > Use RTE_EXEC_ENV_BSDAPP to differentiate minor differences in
> > > common functions.
> > > Makefile changes to reflect new file.
> > > Fix checkpatch warnings and errors.
> > >
> > > Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> > > ---
> > >  lib/librte_eal/bsdapp/eal/Makefile    |   1 +
> > >  lib/librte_eal/bsdapp/eal/eal.c       | 233 +-----------------------
> > >  lib/librte_eal/common/eal_common.c    | 328
> > ++++++++++++++++++++++++++++++++++
> > >  lib/librte_eal/common/eal_externs.h   |  42 +++++
> > >  lib/librte_eal/common/eal_hugepages.h |   1 +
> > >  lib/librte_eal/common/eal_private.h   |  47 +++++
> > >  lib/librte_eal/linuxapp/eal/Makefile  |   1 +
> > >  lib/librte_eal/linuxapp/eal/eal.c     | 246 ++-----------------------
> > >  8 files changed, 439 insertions(+), 460 deletions(-)
> > >  create mode 100644 lib/librte_eal/common/eal_common.c
> > >  create mode 100644 lib/librte_eal/common/eal_externs.h
> > >
> > > diff --git a/lib/librte_eal/bsdapp/eal/Makefile
> > b/lib/librte_eal/bsdapp/eal/Makefile
> > > index 92dd9a6..050d70b 100644
> > > --- a/lib/librte_eal/bsdapp/eal/Makefile
> > > +++ b/lib/librte_eal/bsdapp/eal/Makefile
> > > @@ -58,6 +58,7 @@ 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.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..f925da7 100644
> > > --- a/lib/librte_eal/bsdapp/eal/eal.c
> > > +++ b/lib/librte_eal/bsdapp/eal/eal.c
> > > @@ -80,30 +80,10 @@
> > >  #include "eal_filesystem.h"
> > >  #include "eal_hugepages.h"
> > >  #include "eal_options.h"
> > > +#include "eal_externs.h"
> > >
> > >  #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
> > >
> > > -/* Allow the application to print its usage message too if set */
> > > -static rte_usage_hook_t      rte_application_usage_hook = 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,93 +93,14 @@ 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)
> > > +inline void *
> > > +rte_eal_get_mem_cfg_addr(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)
> > > -{
> > > -     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;
> > > @@ -223,44 +124,11 @@ rte_eal_config_attach(void)
> > >       rte_config.mem_config = (struct rte_mem_config *) rte_mem_cfg_addr;
> > >  }
> > >
> > > -/* 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 */
> > > @@ -276,37 +144,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 +211,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)
> > > @@ -476,7 +274,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");
> > > @@ -548,16 +346,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.c
> > b/lib/librte_eal/common/eal_common.c
> > > new file mode 100644
> > > index 0000000..becf9c8
> > > --- /dev/null
> > > +++ b/lib/librte_eal/common/eal_common.c
> > > @@ -0,0 +1,328 @@
> > > +/*-
> > > + *   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 <stdio.h>
> > > +#include <stdlib.h>
> > > +#include <stdint.h>
> > > +#include <string.h>
> > > +#include <stdarg.h>
> > > +#include <unistd.h>
> > > +#include <pthread.h>
> > > +#include <syslog.h>
> > > +#include <getopt.h>
> > > +#include <sys/file.h>
> > > +#include <stddef.h>
> > > +#include <errno.h>
> > > +#include <limits.h>
> > > +#include <errno.h>
> > > +#include <sys/mman.h>
> > > +#include <sys/queue.h>
> > > +
> > > +#include <rte_common.h>
> > > +#include <rte_debug.h>
> > > +#include <rte_memory.h>
> > > +#include <rte_memzone.h>
> > > +#include <rte_launch.h>
> > > +#include <rte_tailq.h>
> > > +#include <rte_eal.h>
> > > +#include <rte_eal_memconfig.h>
> > > +#include <rte_per_lcore.h>
> > > +#include <rte_lcore.h>
> > > +#include <rte_log.h>
> > > +#include <rte_random.h>
> > > +#include <rte_cycles.h>
> > > +#include <rte_string_fns.h>
> > > +#include <rte_cpuflags.h>
> > > +#include <rte_interrupts.h>
> > > +#include <rte_pci.h>
> > > +#include <rte_dev.h>
> > > +#include <rte_devargs.h>
> > > +#include <rte_common.h>
> > > +#include <rte_version.h>
> > > +#include <rte_atomic.h>
> > > +#include <malloc_heap.h>
> > > +#include <rte_eth_ring.h>
> > > +
> > > +#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;
> > > +
> > > +/* 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;
> > > +
> > > +/* 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,
> > > +};
> > > +
> > > +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),
> > > +};
> > > +
> > > +/* 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;
> > > +
> > > +     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;
> > > +}
> > > +
> > > +
> > > +/* 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;
> > > +
> > > +     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 = 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;
> > > +
> > > +#ifndef RTE_EXEC_ENV_BSDAPP
> > > +     /* 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;
> > > +#endif /* RTE_EXEC_ENV_BSDAPP */
> > Why is this a BSD/Linux Differentiator?
> >
> 
> <rk> Existing code where assignment is not present in BSD code hence the
> differentiation.
> 
I presume then that the BSD code doesn't use mem_cfg_addr at all?  If so, why
not just assign it unilaterally and avoid the ifdeffery?
Neil

> > Neil
> >
> >
Ravi Kerur Dec. 26, 2014, 3:30 p.m. UTC | #4
On Fri, Dec 26, 2014 at 6:42 AM, Neil Horman <nhorman@tuxdriver.com> wrote:

> On Thu, Dec 25, 2014 at 11:17:41AM -0800, Ravi Kerur wrote:
> > Inline <rk>
> >
> > On Thu, Dec 25, 2014 at 9:44 AM, Neil Horman <nhorman@tuxdriver.com>
> wrote:
> >
> > > On Thu, Dec 25, 2014 at 10:33:14AM -0500, Ravi Kerur wrote:
> > > > Move common functions in eal.c to librte_eal/common directory.
> > > > Use RTE_EXEC_ENV_BSDAPP to differentiate minor differences in
> > > > common functions.
> > > > Makefile changes to reflect new file.
> > > > Fix checkpatch warnings and errors.
> > > >
> > > > Signed-off-by: Ravi Kerur <rkerur@gmail.com>
> > > > ---
> > > >  lib/librte_eal/bsdapp/eal/Makefile    |   1 +
> > > >  lib/librte_eal/bsdapp/eal/eal.c       | 233 +-----------------------
> > > >  lib/librte_eal/common/eal_common.c    | 328
> > > ++++++++++++++++++++++++++++++++++
> > > >  lib/librte_eal/common/eal_externs.h   |  42 +++++
> > > >  lib/librte_eal/common/eal_hugepages.h |   1 +
> > > >  lib/librte_eal/common/eal_private.h   |  47 +++++
> > > >  lib/librte_eal/linuxapp/eal/Makefile  |   1 +
> > > >  lib/librte_eal/linuxapp/eal/eal.c     | 246
> ++-----------------------
> > > >  8 files changed, 439 insertions(+), 460 deletions(-)
> > > >  create mode 100644 lib/librte_eal/common/eal_common.c
> > > >  create mode 100644 lib/librte_eal/common/eal_externs.h
> > > >
> > > > diff --git a/lib/librte_eal/bsdapp/eal/Makefile
> > > b/lib/librte_eal/bsdapp/eal/Makefile
> > > > index 92dd9a6..050d70b 100644
> > > > --- a/lib/librte_eal/bsdapp/eal/Makefile
> > > > +++ b/lib/librte_eal/bsdapp/eal/Makefile
> > > > @@ -58,6 +58,7 @@ 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.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..f925da7 100644
> > > > --- a/lib/librte_eal/bsdapp/eal/eal.c
> > > > +++ b/lib/librte_eal/bsdapp/eal/eal.c
> > > > @@ -80,30 +80,10 @@
> > > >  #include "eal_filesystem.h"
> > > >  #include "eal_hugepages.h"
> > > >  #include "eal_options.h"
> > > > +#include "eal_externs.h"
> > > >
> > > >  #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
> > > >
> > > > -/* Allow the application to print its usage message too if set */
> > > > -static rte_usage_hook_t      rte_application_usage_hook = 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,93 +93,14 @@ 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)
> > > > +inline void *
> > > > +rte_eal_get_mem_cfg_addr(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)
> > > > -{
> > > > -     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;
> > > > @@ -223,44 +124,11 @@ rte_eal_config_attach(void)
> > > >       rte_config.mem_config = (struct rte_mem_config *)
> rte_mem_cfg_addr;
> > > >  }
> > > >
> > > > -/* 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 */
> > > > @@ -276,37 +144,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 +211,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)
> > > > @@ -476,7 +274,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");
> > > > @@ -548,16 +346,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.c
> > > b/lib/librte_eal/common/eal_common.c
> > > > new file mode 100644
> > > > index 0000000..becf9c8
> > > > --- /dev/null
> > > > +++ b/lib/librte_eal/common/eal_common.c
> > > > @@ -0,0 +1,328 @@
> > > > +/*-
> > > > + *   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 <stdio.h>
> > > > +#include <stdlib.h>
> > > > +#include <stdint.h>
> > > > +#include <string.h>
> > > > +#include <stdarg.h>
> > > > +#include <unistd.h>
> > > > +#include <pthread.h>
> > > > +#include <syslog.h>
> > > > +#include <getopt.h>
> > > > +#include <sys/file.h>
> > > > +#include <stddef.h>
> > > > +#include <errno.h>
> > > > +#include <limits.h>
> > > > +#include <errno.h>
> > > > +#include <sys/mman.h>
> > > > +#include <sys/queue.h>
> > > > +
> > > > +#include <rte_common.h>
> > > > +#include <rte_debug.h>
> > > > +#include <rte_memory.h>
> > > > +#include <rte_memzone.h>
> > > > +#include <rte_launch.h>
> > > > +#include <rte_tailq.h>
> > > > +#include <rte_eal.h>
> > > > +#include <rte_eal_memconfig.h>
> > > > +#include <rte_per_lcore.h>
> > > > +#include <rte_lcore.h>
> > > > +#include <rte_log.h>
> > > > +#include <rte_random.h>
> > > > +#include <rte_cycles.h>
> > > > +#include <rte_string_fns.h>
> > > > +#include <rte_cpuflags.h>
> > > > +#include <rte_interrupts.h>
> > > > +#include <rte_pci.h>
> > > > +#include <rte_dev.h>
> > > > +#include <rte_devargs.h>
> > > > +#include <rte_common.h>
> > > > +#include <rte_version.h>
> > > > +#include <rte_atomic.h>
> > > > +#include <malloc_heap.h>
> > > > +#include <rte_eth_ring.h>
> > > > +
> > > > +#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;
> > > > +
> > > > +/* 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;
> > > > +
> > > > +/* 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,
> > > > +};
> > > > +
> > > > +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),
> > > > +};
> > > > +
> > > > +/* 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;
> > > > +
> > > > +     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;
> > > > +}
> > > > +
> > > > +
> > > > +/* 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;
> > > > +
> > > > +     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 = 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;
> > > > +
> > > > +#ifndef RTE_EXEC_ENV_BSDAPP
> > > > +     /* 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;
> > > > +#endif /* RTE_EXEC_ENV_BSDAPP */
> > > Why is this a BSD/Linux Differentiator?
> > >
> >
> > <rk> Existing code where assignment is not present in BSD code hence the
> > differentiation.
> >
> I presume then that the BSD code doesn't use mem_cfg_addr at all?  If so,
> why
> not just assign it unilaterally and avoid the ifdeffery?
> Neil
>
>
<rk> Looking into the code my understanding it's not being used. I will
assign it unilaterally.


> > > Neil
> > >
> > >
>
Thomas Monjalon Jan. 5, 2015, 3:59 p.m. UTC | #5
2014-12-25 10:33, Ravi Kerur:
> Move common functions in eal.c to librte_eal/common directory.
[...]
>  lib/librte_eal/common/eal_common.c    | 328 ++++++++++++++++++++++++++++++++++
>  lib/librte_eal/common/eal_externs.h   |  42 +++++

I don't agree with these new files.
We must try to keep a semantic organization. The file eal_common_options.c
would be better for option-related functions.
Maybe that the split between system config, runtime config and internal config
must be reworked.

By the way, it would be nice to avoid extern variables.
Ravi Kerur Jan. 5, 2015, 4:21 p.m. UTC | #6
Thanks Thomas for the reviews, do you want me to send "v4" version of this
patch series or start a different patch series?

Thanks,
Ravi

On Mon, Jan 5, 2015 at 7:59 AM, Thomas Monjalon <thomas.monjalon@6wind.com>
wrote:

> 2014-12-25 10:33, Ravi Kerur:
> > Move common functions in eal.c to librte_eal/common directory.
> [...]
> >  lib/librte_eal/common/eal_common.c    | 328
> ++++++++++++++++++++++++++++++++++
> >  lib/librte_eal/common/eal_externs.h   |  42 +++++
>
> I don't agree with these new files.
> We must try to keep a semantic organization. The file eal_common_options.c
> would be better for option-related functions.
> Maybe that the split between system config, runtime config and internal
> config
> must be reworked.
>
> By the way, it would be nice to avoid extern variables.
>
> --
> Thomas
>
Ravi Kerur Jan. 5, 2015, 6:56 p.m. UTC | #7
Inline <rk>

On Mon, Jan 5, 2015 at 7:59 AM, Thomas Monjalon <thomas.monjalon@6wind.com>
wrote:

> 2014-12-25 10:33, Ravi Kerur:
> > Move common functions in eal.c to librte_eal/common directory.
> [...]
> >  lib/librte_eal/common/eal_common.c    | 328
> ++++++++++++++++++++++++++++++++++
> >  lib/librte_eal/common/eal_externs.h   |  42 +++++
>
> I don't agree with these new files.
> We must try to keep a semantic organization. The file eal_common_options.c
> would be better for option-related functions.
> Maybe that the split between system config, runtime config and internal
> config
> must be reworked.
>
> By the way, it would be nice to avoid extern variables.
>

<rk> I have taken care of your comments and will generate v4 patch.
Currently I have moved common functions in eal.c into
"eal_common_system_options.c" file. Are you suggesting that we further
divide "eal_common_options.c" and "eal_common_system_options.c(new file
added)" into 3 separate files i.e.

eal_common_system_options.c
eal_common_runtime_options.c
eal_common_internal_options.c

Thanks.


>
> --
> Thomas
>
Thomas Monjalon Jan. 5, 2015, 8:38 p.m. UTC | #8
2015-01-05 10:56, Ravi Kerur:
> On Mon, Jan 5, 2015 at 7:59 AM, Thomas Monjalon <thomas.monjalon@6wind.com>
> wrote:
> > 2014-12-25 10:33, Ravi Kerur:
> > > Move common functions in eal.c to librte_eal/common directory.
> > [...]
> > >  lib/librte_eal/common/eal_common.c    | 328 ++++++++++++++++++++++++++++++++++
> > >  lib/librte_eal/common/eal_externs.h   |  42 +++++
> >
> > I don't agree with these new files.
> > We must try to keep a semantic organization. The file eal_common_options.c
> > would be better for option-related functions.
> > Maybe that the split between system config, runtime config and internal
> > config
> > must be reworked.
> >
> > By the way, it would be nice to avoid extern variables.
> 
> <rk> I have taken care of your comments and will generate v4 patch.

Please do not forget v4 word and changelog when sending patches.
Check http://dpdk.org/dev#send

> Currently I have moved common functions in eal.c into
> "eal_common_system_options.c" file. Are you suggesting that we further
> divide "eal_common_options.c" and "eal_common_system_options.c(new file
> added)" into 3 separate files i.e.
> 
> eal_common_system_options.c
> eal_common_runtime_options.c
> eal_common_internal_options.c

You are already doing big changes. So let's iterate with existing files and
avoid creating new ones.
eal_common_options.c must be kept. But if some code is not really related to
runtime options, we could consider adding a new file eal_common_config.c, not
sure about this one.
Ravi Kerur Jan. 6, 2015, 5:35 p.m. UTC | #9
Inline <rk>

On Mon, Jan 5, 2015 at 12:38 PM, Thomas Monjalon <thomas.monjalon@6wind.com>
wrote:

> 2015-01-05 10:56, Ravi Kerur:
> > On Mon, Jan 5, 2015 at 7:59 AM, Thomas Monjalon <
> thomas.monjalon@6wind.com>
> > wrote:
> > > 2014-12-25 10:33, Ravi Kerur:
> > > > Move common functions in eal.c to librte_eal/common directory.
> > > [...]
> > > >  lib/librte_eal/common/eal_common.c    | 328
> ++++++++++++++++++++++++++++++++++
> > > >  lib/librte_eal/common/eal_externs.h   |  42 +++++
> > >
> > > I don't agree with these new files.
> > > We must try to keep a semantic organization. The file
> eal_common_options.c
> > > would be better for option-related functions.
> > > Maybe that the split between system config, runtime config and internal
> > > config
> > > must be reworked.
> > >
> > > By the way, it would be nice to avoid extern variables.
> >
> > <rk> I have taken care of your comments and will generate v4 patch.
>
> Please do not forget v4 word and changelog when sending patches.
> Check http://dpdk.org/dev#send
>
> > Currently I have moved common functions in eal.c into
> > "eal_common_system_options.c" file. Are you suggesting that we further
> > divide "eal_common_options.c" and "eal_common_system_options.c(new file
> > added)" into 3 separate files i.e.
> >
> > eal_common_system_options.c
> > eal_common_runtime_options.c
> > eal_common_internal_options.c
>
> You are already doing big changes. So let's iterate with existing files and
> avoid creating new ones.
> eal_common_options.c must be kept. But if some code is not really related
> to
> runtime options, we could consider adding a new file eal_common_config.c,
> not
> sure about this one.
>
> --
>

<rk> i have divided eal_common.c (new file which was added in v1 PATCH)
into eal_common_system.c and eal_common_runtime.c and have moved
appropriate functions into it. If file names are not appropriate or changes
are not worth doing the split, I will merge them back into
eal_common_config.c.

Thanks.

> Thomas
>
diff mbox

Patch

diff --git a/lib/librte_eal/bsdapp/eal/Makefile b/lib/librte_eal/bsdapp/eal/Makefile
index 92dd9a6..050d70b 100644
--- a/lib/librte_eal/bsdapp/eal/Makefile
+++ b/lib/librte_eal/bsdapp/eal/Makefile
@@ -58,6 +58,7 @@  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.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..f925da7 100644
--- a/lib/librte_eal/bsdapp/eal/eal.c
+++ b/lib/librte_eal/bsdapp/eal/eal.c
@@ -80,30 +80,10 @@ 
 #include "eal_filesystem.h"
 #include "eal_hugepages.h"
 #include "eal_options.h"
+#include "eal_externs.h"
 
 #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
 
-/* Allow the application to print its usage message too if set */
-static rte_usage_hook_t	rte_application_usage_hook = 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,93 +93,14 @@  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)
+inline void *
+rte_eal_get_mem_cfg_addr(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)
-{
-	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;
@@ -223,44 +124,11 @@  rte_eal_config_attach(void)
 	rte_config.mem_config = (struct rte_mem_config *) rte_mem_cfg_addr;
 }
 
-/* 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 */
@@ -276,37 +144,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 +211,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)
@@ -476,7 +274,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");
@@ -548,16 +346,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.c b/lib/librte_eal/common/eal_common.c
new file mode 100644
index 0000000..becf9c8
--- /dev/null
+++ b/lib/librte_eal/common/eal_common.c
@@ -0,0 +1,328 @@ 
+/*-
+ *   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 <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <syslog.h>
+#include <getopt.h>
+#include <sys/file.h>
+#include <stddef.h>
+#include <errno.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <sys/queue.h>
+
+#include <rte_common.h>
+#include <rte_debug.h>
+#include <rte_memory.h>
+#include <rte_memzone.h>
+#include <rte_launch.h>
+#include <rte_tailq.h>
+#include <rte_eal.h>
+#include <rte_eal_memconfig.h>
+#include <rte_per_lcore.h>
+#include <rte_lcore.h>
+#include <rte_log.h>
+#include <rte_random.h>
+#include <rte_cycles.h>
+#include <rte_string_fns.h>
+#include <rte_cpuflags.h>
+#include <rte_interrupts.h>
+#include <rte_pci.h>
+#include <rte_dev.h>
+#include <rte_devargs.h>
+#include <rte_common.h>
+#include <rte_version.h>
+#include <rte_atomic.h>
+#include <malloc_heap.h>
+#include <rte_eth_ring.h>
+
+#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;
+
+/* 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;
+
+/* 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,
+};
+
+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),
+};
+
+/* 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;
+
+	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;
+}
+
+
+/* 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;
+
+	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 = 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;
+
+#ifndef RTE_EXEC_ENV_BSDAPP
+	/* 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;
+#endif /* RTE_EXEC_ENV_BSDAPP */
+}
+
+/* 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;
+}
+
+/* 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");
+	}
+}
+
+/* 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 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;
+
+	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;
+}
+
+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_externs.h b/lib/librte_eal/common/eal_externs.h
new file mode 100644
index 0000000..b19bea6
--- /dev/null
+++ b/lib/librte_eal/common/eal_externs.h
@@ -0,0 +1,42 @@ 
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef EAL_EXTERNS_H
+#define EAL_EXTERNS_H
+
+/* Extern declarations defined in eal_common.c */
+extern struct rte_config rte_config;
+extern int mem_cfg_fd;
+extern rte_usage_hook_t	rte_application_usage_hook;
+
+#endif
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..b1d68bc 100644
--- a/lib/librte_eal/common/eal_private.h
+++ b/lib/librte_eal/common/eal_private.h
@@ -203,4 +203,51 @@  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);
+
+/**
+ * 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..60cc448 100644
--- a/lib/librte_eal/linuxapp/eal/Makefile
+++ b/lib/librte_eal/linuxapp/eal/Makefile
@@ -70,6 +70,7 @@  SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_ivshmem.c
 endif
 
 # from common dir
+SRCS-$(CONFIG_RTE_LIBRTE_EAL_LINUXAPP) += eal_common.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..6d3f854 100644
--- a/lib/librte_eal/linuxapp/eal/eal.c
+++ b/lib/librte_eal/linuxapp/eal/eal.c
@@ -84,14 +84,12 @@ 
 #include "eal_filesystem.h"
 #include "eal_hugepages.h"
 #include "eal_options.h"
+#include "eal_externs.h"
 
 #define MEMSIZE_IF_NO_HUGE_PAGE (64ULL * 1024ULL * 1024ULL)
 
 #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 +104,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,106 +113,23 @@  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();
-
-	if (internal_config.no_shconf)
-		return;
+	void *mem_cfg_addr;
 
-	/* 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;
@@ -259,7 +155,7 @@  rte_eal_config_attach(void)
 }
 
 /* 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;
@@ -285,47 +181,6 @@  rte_eal_config_reattach(void)
 	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");
-	}
-}
-
 /* Unlocks hugepage directories that were locked by eal_hugepage_info_init */
 static void
 eal_hugedirs_unlock(void)
@@ -371,19 +226,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 +327,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 +467,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,
@@ -750,7 +541,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");
@@ -842,20 +633,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;
-}