X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_eal%2Flinuxapp%2Feal%2Feal_hugepage_info.c;h=07eb7e560f222d242bcad1377c345a5be14567e6;hb=b6df9fc8715f9a925136006b18fdd65f9c621757;hp=d1ed49ac135fd8364f2db7250a804c1055abe590;hpb=af75078fece3615088e561357c1e97603e43a5fe;p=dpdk.git diff --git a/lib/librte_eal/linuxapp/eal/eal_hugepage_info.c b/lib/librte_eal/linuxapp/eal/eal_hugepage_info.c index d1ed49ac13..07eb7e560f 100644 --- a/lib/librte_eal/linuxapp/eal/eal_hugepage_info.c +++ b/lib/librte_eal/linuxapp/eal/eal_hugepage_info.c @@ -1,7 +1,7 @@ /*- * BSD LICENSE * - * Copyright(c) 2010-2012 Intel Corporation. All rights reserved. + * Copyright(c) 2010-2013 Intel Corporation. All rights reserved. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -30,51 +30,63 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * - * version: DPDK.L.1.2.3-3 */ #include #include +#include #include #include #include #include +#include #include #include +#include #include #include -#include "rte_memory.h" -#include "rte_memzone.h" -#include "rte_tailq.h" -#include "rte_eal.h" -#include "rte_launch.h" -#include "rte_per_lcore.h" -#include "rte_lcore.h" -#include "rte_debug.h" -#include "rte_log.h" -#include "rte_common.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "rte_string_fns.h" #include "eal_internal_cfg.h" #include "eal_hugepages.h" +#include "eal_filesystem.h" static const char sys_dir_path[] = "/sys/kernel/mm/hugepages"; static int32_t get_num_hugepages(const char *subdir) { - const char nr_hp_file[] = "nr_hugepages"; - char path[BUFSIZ]; - unsigned num_pages = 0; + char path[PATH_MAX]; + long unsigned num_pages = 0; + const char *nr_hp_file; + + /* if secondary process, just look at the number of hugepages, + * otherwise look at number of free hugepages */ + if (internal_config.process_type == RTE_PROC_SECONDARY) + nr_hp_file = "nr_hugepages"; + else + nr_hp_file = "free_hugepages"; rte_snprintf(path, sizeof(path), "%s/%s/%s", sys_dir_path, subdir, nr_hp_file); - FILE *fd = fopen(path, "r"); - if (fd == NULL || fscanf(fd, "%u", &num_pages) != 1) - rte_panic("Error reading file '%s'\n", path); - fclose(fd); - return num_pages; + if (eal_parse_sysfs_value(path, &num_pages) < 0) + return 0; + + if (num_pages == 0) + RTE_LOG(ERR, EAL, "Error - no free hugepages available!\n"); + + return (int32_t)num_pages; } static uint64_t @@ -170,11 +182,86 @@ static inline void swap_hpi(struct hugepage_info *a, struct hugepage_info *b) { char buf[sizeof(*a)]; - memcpy(buf, a, sizeof(*a)); - memcpy(a, b, sizeof(*a)); - memcpy(b, buf, sizeof(*a)); + memcpy(buf, a, sizeof(buf)); + memcpy(a, b, sizeof(buf)); + memcpy(b, buf, sizeof(buf)); +} + +/* + * Clear the hugepage directory of whatever hugepage files + * there are. Checks if the file is locked (i.e. + * if it's in use by another DPDK process). + */ +static int +clear_hugedir(const char * hugedir) +{ + DIR *dir; + struct dirent *dirent; + int dir_fd, fd, lck_result; + const char filter[] = "*map_*"; /* matches hugepage files */ + + /* open directory */ + dir = opendir(hugedir); + if (!dir) { + RTE_LOG(INFO, EAL, "Unable to open hugepage directory %s\n", + hugedir); + goto error; + } + dir_fd = dirfd(dir); + + dirent = readdir(dir); + if (!dirent) { + RTE_LOG(INFO, EAL, "Unable to read hugepage directory %s\n", + hugedir); + goto error; + } + + while(dirent != NULL){ + /* skip files that don't match the hugepage pattern */ + if (fnmatch(filter, dirent->d_name, 0) > 0) { + dirent = readdir(dir); + continue; + } + + /* try and lock the file */ + fd = openat(dir_fd, dirent->d_name, O_RDONLY); + + /* skip to next file */ + if (fd == -1) { + dirent = readdir(dir); + continue; + } + + /* non-blocking lock */ + lck_result = flock(fd, LOCK_EX | LOCK_NB); + + /* if lock succeeds, unlock and remove the file */ + if (lck_result != -1) { + flock(fd, LOCK_UN); + unlinkat(dir_fd, dirent->d_name, 0); + } + close (fd); + dirent = readdir(dir); + } + + closedir(dir); + return 0; + +error: + if (dir) + closedir(dir); + + RTE_LOG(INFO, EAL, "Error while clearing hugepage dir: %s\n", + strerror(errno)); + + return -1; } +/* + * when we initialize the hugepage info, everything goes + * to socket 0 by default. it will later get sorted by memory + * initialization procedure. + */ int eal_hugepage_info_init(void) { @@ -193,16 +280,39 @@ eal_hugepage_info_init(void) struct hugepage_info *hpi = \ &internal_config.hugepage_info[num_sizes]; hpi->hugepage_sz = rte_str_to_size(&dirent->d_name[dirent_start_len]); - hpi->num_pages = get_num_hugepages(dirent->d_name); hpi->hugedir = get_hugepage_dir(hpi->hugepage_sz); + + /* first, check if we have a mountpoint */ if (hpi->hugedir == NULL){ RTE_LOG(INFO, EAL, "%u hugepages of size %llu reserved, "\ "but no mounted hugetlbfs found for that size\n", - hpi->num_pages, + (unsigned) get_num_hugepages(dirent->d_name), (unsigned long long)hpi->hugepage_sz); - hpi->num_pages = 0; - } else + } else { + /* try to obtain a writelock */ + hpi->lock_descriptor = open(hpi->hugedir, O_RDONLY); + + /* if blocking lock failed */ + if (flock(hpi->lock_descriptor, LOCK_EX) == -1) { + RTE_LOG(CRIT, EAL, "Failed to lock hugepage directory!\n"); + return -1; + } + /* clear out the hugepages dir from unused pages */ + if (clear_hugedir(hpi->hugedir) == -1) + return -1; + + /* for now, put all pages into socket 0, + * later they will be sorted */ + hpi->num_pages[0] = get_num_hugepages(dirent->d_name); + +#ifndef RTE_ARCH_X86_64 + /* for 32-bit systems, limit number of hugepages to 1GB per page size */ + hpi->num_pages[0] = RTE_MIN(hpi->num_pages[0], + RTE_PGSIZE_1G / hpi->hugepage_sz); +#endif + num_sizes++; + } } dirent = readdir(dir); } @@ -222,8 +332,9 @@ eal_hugepage_info_init(void) /* now we have all info, check we have at least one valid size */ for (i = 0; i < num_sizes; i++) if (internal_config.hugepage_info[i].hugedir != NULL && - internal_config.hugepage_info[i].num_pages > 0) + internal_config.hugepage_info[i].num_pages[0] > 0) return 0; + /* no valid hugepage mounts available, return error */ return -1; }