eal: do not panic on shared memory init

This patch changes some void functions to return a value,
so that the init sequence may tear down orderly
instead of calling panic.

Signed-off-by: Arnon Warshavsky <arnon@qwilt.com>
Reviewed-by: David Marchand <david.marchand@redhat.com>

diff --git a/lib/librte_eal/freebsd/eal/eal.c b/lib/librte_eal/freebsd/eal/eal.c
index 4eaa531..97633a5 100644 (file)
--- a/lib/librte_eal/freebsd/eal/eal.c
+++ b/lib/librte_eal/freebsd/eal/eal.c
@@ -215,7 +215,7 @@ eal_parse_sysfs_value(const char *filename, unsigned long *val)
  * 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
+static int
 rte_eal_config_create(void)
 {
        void *rte_mem_cfg_addr;
@@ -224,60 +224,82 @@ rte_eal_config_create(void)
        const char *pathname = eal_runtime_config_path();
 
        if (internal_config.no_shconf)
-               return;
+               return 0;
 
        if (mem_cfg_fd < 0){
                mem_cfg_fd = open(pathname, O_RDWR | O_CREAT, 0600);
-               if (mem_cfg_fd < 0)
-                       rte_panic("Cannot open '%s' for rte_mem_config\n", pathname);
+               if (mem_cfg_fd < 0) {
+                       RTE_LOG(ERR, EAL, "Cannot open '%s' for rte_mem_config\n",
+                               pathname);
+                       return -1;
+               }
        }
 
        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);
+               mem_cfg_fd = -1;
+               RTE_LOG(ERR, EAL, "Cannot resize '%s' for rte_mem_config\n",
+                       pathname);
+               return -1;
        }
 
        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);
+               mem_cfg_fd = -1;
+               RTE_LOG(ERR, EAL, "Cannot create lock on '%s'. Is another primary "
+                       "process running?\n", pathname);
+               return -1;
        }
 
        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");
+               RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config\n");
+               close(mem_cfg_fd);
+               mem_cfg_fd = -1;
+               return -1;
        }
        memcpy(rte_mem_cfg_addr, &early_mem_config, sizeof(early_mem_config));
        rte_config.mem_config = rte_mem_cfg_addr;
+
+       return 0;
 }
 
 /* attach to an existing shared memory config */
-static void
+static int
 rte_eal_config_attach(void)
 {
        void *rte_mem_cfg_addr;
        const char *pathname = eal_runtime_config_path();
 
        if (internal_config.no_shconf)
-               return;
+               return 0;
 
        if (mem_cfg_fd < 0){
                mem_cfg_fd = open(pathname, O_RDWR);
-               if (mem_cfg_fd < 0)
-                       rte_panic("Cannot open '%s' for rte_mem_config\n", pathname);
+               if (mem_cfg_fd < 0) {
+                       RTE_LOG(ERR, EAL, "Cannot open '%s' for rte_mem_config\n",
+                               pathname);
+                       return -1;
+               }
        }
 
        rte_mem_cfg_addr = mmap(NULL, sizeof(*rte_config.mem_config),
                                PROT_READ | PROT_WRITE, MAP_SHARED, mem_cfg_fd, 0);
        close(mem_cfg_fd);
-       if (rte_mem_cfg_addr == MAP_FAILED)
-               rte_panic("Cannot mmap memory for rte_config\n");
+       mem_cfg_fd = -1;
+       if (rte_mem_cfg_addr == MAP_FAILED) {
+               RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config! error %i (%s)\n",
+                       errno, strerror(errno));
+               return -1;
+       }
 
        rte_config.mem_config = rte_mem_cfg_addr;
+
+       return 0;
 }
 
 /* Detect if we are a primary or a secondary process */
@@ -306,23 +328,29 @@ eal_proc_type_detect(void)
 }
 
 /* Sets up rte_config structure with the pointer to shared memory config.*/
-static void
+static int
 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();
+               if (rte_eal_config_create() < 0)
+                       return -1;
                break;
        case RTE_PROC_SECONDARY:
-               rte_eal_config_attach();
+               if (rte_eal_config_attach() < 0)
+                       return -1;
                rte_eal_mcfg_wait_complete(rte_config.mem_config);
                break;
        case RTE_PROC_AUTO:
        case RTE_PROC_INVALID:
-               rte_panic("Invalid process type\n");
+               RTE_LOG(ERR, EAL, "Invalid process type %d\n",
+                       rte_config.process_type);
+               return -1;
        }
+
+       return 0;
 }
 
 /* display usage */
@@ -655,7 +683,10 @@ rte_eal_init(int argc, char **argv)
                return -1;
        }
 
-       rte_config_init();
+       if (rte_config_init() < 0) {
+               rte_eal_init_alert("Cannot init config");
+               return -1;
+       }
 
        if (rte_eal_intr_init() < 0) {
                rte_eal_init_alert("Cannot init interrupt-handling thread");

diff --git a/lib/librte_eal/linux/eal/eal.c b/lib/librte_eal/linux/eal/eal.c
index 3e1d6eb..d96ed3a 100644 (file)
--- a/lib/librte_eal/linux/eal/eal.c
+++ b/lib/librte_eal/linux/eal/eal.c
@@ -300,7 +300,7 @@ eal_parse_sysfs_value(const char *filename, unsigned long *val)
  * 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
+static int
 rte_eal_config_create(void)
 {
        void *rte_mem_cfg_addr;
@@ -309,7 +309,7 @@ rte_eal_config_create(void)
        const char *pathname = eal_runtime_config_path();
 
        if (internal_config.no_shconf)
-               return;
+               return 0;
 
        /* map the config before hugepage address so that we don't waste a page */
        if (internal_config.base_virtaddr != 0)
@@ -321,29 +321,41 @@ rte_eal_config_create(void)
 
        if (mem_cfg_fd < 0){
                mem_cfg_fd = open(pathname, O_RDWR | O_CREAT, 0600);
-               if (mem_cfg_fd < 0)
-                       rte_panic("Cannot open '%s' for rte_mem_config\n", pathname);
+               if (mem_cfg_fd < 0) {
+                       RTE_LOG(ERR, EAL, "Cannot open '%s' for rte_mem_config\n",
+                               pathname);
+                       return -1;
+               }
        }
 
        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);
+               mem_cfg_fd = -1;
+               RTE_LOG(ERR, EAL, "Cannot resize '%s' for rte_mem_config\n",
+                       pathname);
+               return -1;
        }
 
        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);
+               mem_cfg_fd = -1;
+               RTE_LOG(ERR, EAL, "Cannot create lock on '%s'. Is another primary "
+                       "process running?\n", pathname);
+               return -1;
        }
 
        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");
+               close(mem_cfg_fd);
+               mem_cfg_fd = -1;
+               RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config\n");
+               return -1;
        }
+
        memcpy(rte_mem_cfg_addr, &early_mem_config, sizeof(early_mem_config));
        rte_config.mem_config = rte_mem_cfg_addr;
 
@@ -353,10 +365,11 @@ rte_eal_config_create(void)
 
        rte_config.mem_config->dma_maskbits = 0;
 
+       return 0;
 }
 
 /* attach to an existing shared memory config */
-static void
+static int
 rte_eal_config_attach(void)
 {
        struct rte_mem_config *mem_config;
@@ -364,33 +377,42 @@ rte_eal_config_attach(void)
        const char *pathname = eal_runtime_config_path();
 
        if (internal_config.no_shconf)
-               return;
+               return 0;
 
        if (mem_cfg_fd < 0){
                mem_cfg_fd = open(pathname, O_RDWR);
-               if (mem_cfg_fd < 0)
-                       rte_panic("Cannot open '%s' for rte_mem_config\n", pathname);
+               if (mem_cfg_fd < 0) {
+                       RTE_LOG(ERR, EAL, "Cannot open '%s' for rte_mem_config\n",
+                               pathname);
+                       return -1;
+               }
        }
 
        /* map it as read-only first */
        mem_config = (struct rte_mem_config *) mmap(NULL, sizeof(*mem_config),
                        PROT_READ, MAP_SHARED, mem_cfg_fd, 0);
-       if (mem_config == MAP_FAILED)
-               rte_panic("Cannot mmap memory for rte_config! error %i (%s)\n",
-                         errno, strerror(errno));
+       if (mem_config == MAP_FAILED) {
+               close(mem_cfg_fd);
+               mem_cfg_fd = -1;
+               RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config! error %i (%s)\n",
+                       errno, strerror(errno));
+               return -1;
+       }
 
        rte_config.mem_config = mem_config;
+
+       return 0;
 }
 
 /* reattach the shared config at exact memory location primary process has it */
-static void
+static int
 rte_eal_config_reattach(void)
 {
        struct rte_mem_config *mem_config;
        void *rte_mem_cfg_addr;
 
        if (internal_config.no_shconf)
-               return;
+               return 0;
 
        /* save the address primary process has mapped shared config to */
        rte_mem_cfg_addr = (void *) (uintptr_t) rte_config.mem_config->mem_cfg_addr;
@@ -402,19 +424,26 @@ rte_eal_config_reattach(void)
        mem_config = (struct rte_mem_config *) mmap(rte_mem_cfg_addr,
                        sizeof(*mem_config), PROT_READ | PROT_WRITE, MAP_SHARED,
                        mem_cfg_fd, 0);
+
+       close(mem_cfg_fd);
+       mem_cfg_fd = -1;
+
        if (mem_config == MAP_FAILED || mem_config != rte_mem_cfg_addr) {
-               if (mem_config != MAP_FAILED)
+               if (mem_config != MAP_FAILED) {
                        /* errno is stale, don't use */
-                       rte_panic("Cannot mmap memory for rte_config at [%p], got [%p]"
-                                 " - please use '--base-virtaddr' option\n",
-                                 rte_mem_cfg_addr, mem_config);
-               else
-                       rte_panic("Cannot mmap memory for rte_config! error %i (%s)\n",
-                                 errno, strerror(errno));
+                       RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config at [%p], got [%p]"
+                               " - please use '--base-virtaddr' option\n",
+                               rte_mem_cfg_addr, mem_config);
+                       return -1;
+               }
+               RTE_LOG(ERR, EAL, "Cannot mmap memory for rte_config! error %i (%s)\n",
+                       errno, strerror(errno));
+               return -1;
        }
-       close(mem_cfg_fd);
 
        rte_config.mem_config = mem_config;
+
+       return 0;
 }
 
 /* Detect if we are a primary or a secondary process */
@@ -461,26 +490,33 @@ eal_update_internal_config(void)
 }
 
 /* Sets up rte_config structure with the pointer to shared memory config.*/
-static void
+static int
 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();
+               if (rte_eal_config_create() < 0)
+                       return -1;
                eal_update_mem_config();
                break;
        case RTE_PROC_SECONDARY:
-               rte_eal_config_attach();
+               if (rte_eal_config_attach() < 0)
+                       return -1;
                rte_eal_mcfg_wait_complete(rte_config.mem_config);
-               rte_eal_config_reattach();
+               if (rte_eal_config_reattach() < 0)
+                       return -1;
                eal_update_internal_config();
                break;
        case RTE_PROC_AUTO:
        case RTE_PROC_INVALID:
-               rte_panic("Invalid process type\n");
+               RTE_LOG(ERR, EAL, "Invalid process type %d\n",
+                       rte_config.process_type);
+               return -1;
        }
+
+       return 0;
 }
 
 /* Unlocks hugepage directories that were locked by eal_hugepage_info_init */
@@ -998,7 +1034,10 @@ rte_eal_init(int argc, char **argv)
                return -1;
        }
 
-       rte_config_init();
+       if (rte_config_init() < 0) {
+               rte_eal_init_alert("Cannot init config");
+               return -1;
+       }
 
        if (rte_eal_intr_init() < 0) {
                rte_eal_init_alert("Cannot init interrupt-handling thread");