X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=lib%2Flibrte_eal%2Flinuxapp%2Feal%2Feal_memory.c;h=fcc7db33cb0de50d6785638b037d66ac46ea8f1e;hb=b6df9fc8715f9a925136006b18fdd65f9c621757;hp=dd2afeed912c551ec1ed7d2481db5eb0fefad812;hpb=dada9ef6edc59015b6674b5a95258787c71401b0;p=dpdk.git

diff --git a/lib/librte_eal/linuxapp/eal/eal_memory.c b/lib/librte_eal/linuxapp/eal/eal_memory.c
index dd2afeed91..fcc7db33cb 100644
--- a/lib/librte_eal/linuxapp/eal/eal_memory.c
+++ b/lib/librte_eal/linuxapp/eal/eal_memory.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 
@@ -31,6 +31,36 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * 
  */
+/*   BSD LICENSE
+ *
+ *   Copyright(c) 2013 6WIND.
+ *
+ *   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 6WIND S.A. 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 <errno.h>
 #include <stdarg.h>
@@ -44,11 +74,13 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/queue.h>
-#include <fcntl.h>
+#include <sys/file.h>
 #include <unistd.h>
 #include <limits.h>
 #include <errno.h>
 #include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 
 #include <rte_log.h>
 #include <rte_memory.h>
@@ -56,6 +88,7 @@
 #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_common.h>
@@ -63,7 +96,7 @@
 
 #include "eal_private.h"
 #include "eal_internal_cfg.h"
-#include "eal_fs_paths.h"
+#include "eal_filesystem.h"
 #include "eal_hugepages.h"
 
 /**
@@ -111,6 +144,44 @@ aslr_enabled(void)
 	}
 }
 
+/*
+ * Increase limit for open files for current process
+ */
+static int
+increase_open_file_limit(void)
+{
+	struct rlimit limit;
+
+	/* read current limits */
+	if (getrlimit(RLIMIT_NOFILE, &limit) != 0) {
+		RTE_LOG(ERR, EAL, "Error reading resource limit: %s\n",
+				strerror(errno));
+		return -1;
+	}
+
+	/* check if current soft limit matches the hard limit */
+	if (limit.rlim_cur < limit.rlim_max) {
+		/* set soft limit to match hard limit */
+		limit.rlim_cur = limit.rlim_max;
+	}
+	else {
+		/* we can't increase the soft limit so now we try to increase
+		 * soft and hard limit. this might fail when run as non-root.
+		 */
+		limit.rlim_cur *= 2;
+		limit.rlim_max *= 2;
+	}
+
+	/* set current resource limit */
+	if (setrlimit(RLIMIT_NOFILE, &limit) != 0) {
+		RTE_LOG(ERR, EAL, "Error increasing open files limit: %s\n",
+				strerror(errno));
+		return -1;
+	}
+
+	return 0;
+}
+
 /*
  * Try to mmap *size bytes in /dev/zero. If it is succesful, return the
  * pointer to the mmap'd area and keep *size unmodified. Else, retry
@@ -176,7 +247,7 @@ map_all_hugepages(struct hugepage *hugepg_tbl,
 	void *vma_addr = NULL;
 	uint64_t vma_len = 0;
 
-	for (i = 0; i < hpi->num_pages; i++) {
+	for (i = 0; i < hpi->num_pages[0]; i++) {
 		uint64_t hugepage_sz = hpi->hugepage_sz;
 
 		if (orig) {
@@ -203,7 +274,7 @@ map_all_hugepages(struct hugepage *hugepg_tbl,
 			/* reserve a virtual area for next contiguous
 			 * physical block: count the number of
 			 * contiguous physical pages. */
-			for (j = i+1; j < hpi->num_pages ; j++) {
+			for (j = i+1; j < hpi->num_pages[0] ; j++) {
 				if (hugepg_tbl[j].physaddr !=
 				    hugepg_tbl[j-1].physaddr + hugepage_sz)
 					break;
@@ -219,9 +290,10 @@ map_all_hugepages(struct hugepage *hugepg_tbl,
 				vma_len = hugepage_sz;
 		}
 
+		/* try to create hugepage file */
 		fd = open(hugepg_tbl[i].filepath, O_CREAT | O_RDWR, 0755);
 		if (fd < 0) {
-			RTE_LOG(ERR, EAL, "%s(): open failed: %s", __func__,
+			RTE_LOG(ERR, EAL, "%s(): open failed: %s\n", __func__,
 					strerror(errno));
 			return -1;
 		}
@@ -229,11 +301,12 @@ map_all_hugepages(struct hugepage *hugepg_tbl,
 		virtaddr = mmap(vma_addr, hugepage_sz, PROT_READ | PROT_WRITE,
 				MAP_SHARED, fd, 0);
 		if (virtaddr == MAP_FAILED) {
-			RTE_LOG(ERR, EAL, "%s(): mmap failed: %s", __func__,
+			RTE_LOG(ERR, EAL, "%s(): mmap failed: %s\n", __func__,
 					strerror(errno));
 			close(fd);
 			return -1;
 		}
+
 		if (orig) {
 			hugepg_tbl[i].orig_va = virtaddr;
 			memset(virtaddr, 0, hugepage_sz);
@@ -242,9 +315,11 @@ map_all_hugepages(struct hugepage *hugepg_tbl,
 			hugepg_tbl[i].final_va = virtaddr;
 		}
 
+		/* close the file descriptor, files will be locked later */
+		close(fd);
+
 		vma_addr = (char *)vma_addr + hugepage_sz;
 		vma_len -= hugepage_sz;
-		close(fd);
 	}
 	return 0;
 }
@@ -254,7 +329,7 @@ static int
 unmap_all_hugepages_orig(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 {
 	unsigned i;
-	for (i = 0; i < hpi->num_pages; i++) {
+	for (i = 0; i < hpi->num_pages[0]; i++) {
 		if (hugepg_tbl[i].orig_va) {
 			munmap(hugepg_tbl[i].orig_va, hpi->hugepage_sz);
 			hugepg_tbl[i].orig_va = NULL;
@@ -281,24 +356,24 @@ find_physaddr(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 
 	fd = open("/proc/self/pagemap", O_RDONLY);
 	if (fd < 0) {
-		RTE_LOG(ERR, EAL, "%s(): cannot open /proc/self/pagemap: %s",
+		RTE_LOG(ERR, EAL, "%s(): cannot open /proc/self/pagemap: %s\n",
 			__func__, strerror(errno));
 		return -1;
 	}
 
-	for (i = 0; i < hpi->num_pages; i++) {
+	for (i = 0; i < hpi->num_pages[0]; i++) {
 		off_t offset;
 		virt_pfn = (unsigned long)hugepg_tbl[i].orig_va /
 			page_size;
 		offset = sizeof(uint64_t) * virt_pfn;
-		if (lseek(fd, offset, SEEK_SET) != offset){
-			RTE_LOG(ERR, EAL, "%s(): seek error in /proc/self/pagemap: %s",
+		if (lseek(fd, offset, SEEK_SET) == (off_t) -1) {
+			RTE_LOG(ERR, EAL, "%s(): seek error in /proc/self/pagemap: %s\n",
 					__func__, strerror(errno));
 			close(fd);
 			return -1;
 		}
 		if (read(fd, &page, sizeof(uint64_t)) < 0) {
-			RTE_LOG(ERR, EAL, "%s(): cannot read /proc/self/pagemap: %s",
+			RTE_LOG(ERR, EAL, "%s(): cannot read /proc/self/pagemap: %s\n",
 					__func__, strerror(errno));
 			close(fd);
 			return -1;
@@ -332,7 +407,7 @@ find_numasocket(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 	f = fopen("/proc/self/numa_maps", "r");
 	if (f == NULL) {
 		RTE_LOG(INFO, EAL, "cannot open /proc/self/numa_maps,"
-				"consider that all memory is in socket_id 0");
+				" consider that all memory is in socket_id 0\n");
 		return 0;
 	}
 
@@ -376,7 +451,7 @@ find_numasocket(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 		}
 
 		/* if we find this page in our mappings, set socket_id */
-		for (i = 0; i < hpi->num_pages; i++) {
+		for (i = 0; i < hpi->num_pages[0]; i++) {
 			void *va = (void *)(unsigned long)virt_addr;
 			if (hugepg_tbl[i].orig_va == va) {
 				hugepg_tbl[i].socket_id = socket_id;
@@ -384,8 +459,10 @@ find_numasocket(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 			}
 		}
 	}
-	if (hp_count < hpi->num_pages)
+
+	if (hp_count < hpi->num_pages[0])
 		goto error;
+
 	fclose(f);
 	return 0;
 
@@ -407,7 +484,7 @@ sort_by_physaddr(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 	uint64_t smallest_addr;
 	struct hugepage tmp;
 
-	for (i = 0; i < hpi->num_pages; i++) {
+	for (i = 0; i < hpi->num_pages[0]; i++) {
 		smallest_addr = 0;
 		smallest_idx = -1;
 
@@ -415,7 +492,7 @@ sort_by_physaddr(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 		 * browse all entries starting at 'i', and find the
 		 * entry with the smallest addr
 		 */
-		for (j=i; j<hpi->num_pages; j++) {
+		for (j=i; j< hpi->num_pages[0]; j++) {
 
 			if (smallest_addr == 0 ||
 			    hugepg_tbl[j].physaddr < smallest_addr) {
@@ -441,7 +518,7 @@ sort_by_physaddr(struct hugepage *hugepg_tbl, struct hugepage_info *hpi)
 
 /*
  * Uses mmap to create a shared memory area for storage of data
- *Used in this file to store the hugepage file map on disk
+ * Used in this file to store the hugepage file map on disk
  */
 static void *
 create_shared_memory(const char *filename, const size_t mem_size)
@@ -460,53 +537,202 @@ create_shared_memory(const char *filename, const size_t mem_size)
 }
 
 /*
- * This function takes in the list of hugepage sizes and the
+ * this copies *active* hugepages from one hugepage table to another.
+ * destination is typically the shared memory.
+ */
+static int
+copy_hugepages_to_shared_mem(struct hugepage * dst, int dest_size,
+		const struct hugepage * src, int src_size)
+{
+	int src_pos, dst_pos = 0;
+
+	for (src_pos = 0; src_pos < src_size; src_pos++) {
+		if (src[src_pos].final_va != NULL) {
+			/* error on overflow attempt */
+			if (dst_pos == dest_size)
+				return -1;
+			memcpy(&dst[dst_pos], &src[src_pos], sizeof(struct hugepage));
+			dst_pos++;
+		}
+	}
+	return 0;
+}
+
+/*
+ * unmaps hugepages that are not going to be used. since we originally allocate
+ * ALL hugepages (not just those we need), additional unmapping needs to be done.
+ */
+static int
+unmap_unneeded_hugepages(struct hugepage *hugepg_tbl,
+		struct hugepage_info *hpi,
+		unsigned num_hp_info)
+{
+	unsigned socket, size;
+	int page, nrpages = 0;
+	int fd;
+
+	/* get total number of hugepages */
+	for (size = 0; size < num_hp_info; size++)
+		for (socket = 0; socket < RTE_MAX_NUMA_NODES; socket++)
+			nrpages += internal_config.hugepage_info[size].num_pages[socket];
+
+	for (size = 0; size < num_hp_info; size++) {
+		for (socket = 0; socket < RTE_MAX_NUMA_NODES; socket++) {
+			unsigned pages_found = 0;
+			/* traverse until we have unmapped all the unused pages */
+			for (page = 0; page < nrpages; page++) {
+				struct hugepage *hp = &hugepg_tbl[page];
+
+				/* find a page that matches the criteria */
+				if ((hp->size == hpi[size].hugepage_sz) &&
+						(hp->socket_id == (int) socket)) {
+
+					/* if we skipped enough pages, unmap the rest */
+					if (pages_found == hpi[size].num_pages[socket]) {
+						munmap(hp->final_va, hp->size);
+						hp->final_va = NULL;
+					}
+					/* lock the page and skip */
+					else {
+						/* try and open the hugepage file */
+						while ((fd = open(hp->filepath, O_CREAT | O_RDWR, 0755)) < 0) {
+							/* if we can't open due to resource limits */
+							if (errno == EMFILE) {
+								RTE_LOG(INFO, EAL, "Increasing open file limit\n");
+
+								/* if we manage to increase resource limit, try again */
+								if (increase_open_file_limit() == 0)
+									continue;
+							}
+							else
+								RTE_LOG(ERR, EAL, "%s(): open failed: %s\n", __func__,
+										strerror(errno));
+							return -1;
+						}
+						/* try and lock the hugepage */
+						if (flock(fd, LOCK_SH | LOCK_NB) == -1) {
+							RTE_LOG(ERR, EAL, "Locking hugepage file failed!\n");
+							close(fd);
+							return -1;
+						}
+						hp->page_lock = fd;
+						pages_found++;
+					}
+				} /* match page */
+			} /* foreach page */
+		} /* foreach socket */
+	} /* foreach pagesize */
+
+	return 0;
+}
+
+static inline uint64_t
+get_socket_mem_size(int socket)
+{
+	uint64_t size = 0;
+	unsigned i;
+
+	for (i = 0; i < internal_config.num_hugepage_sizes; i++){
+		struct hugepage_info *hpi = &internal_config.hugepage_info[i];
+		if (hpi->hugedir != NULL)
+			size += hpi->hugepage_sz * hpi->num_pages[socket];
+	}
+
+	return (size);
+}
+
+/*
+ * This function is a NUMA-aware equivalent of calc_num_pages.
+ * It takes in the list of hugepage sizes and the
  * number of pages thereof, and calculates the best number of
  * pages of each size to fulfill the request for <memory> ram
  */
 static int
-calc_num_pages(uint64_t memory,
+calc_num_pages_per_socket(uint64_t * memory,
 		struct hugepage_info *hp_info,
 		struct hugepage_info *hp_used,
 		unsigned num_hp_info)
 {
-	unsigned i = 0;
+	unsigned socket, j, i = 0;
+	unsigned requested, available;
 	int total_num_pages = 0;
+	uint64_t remaining_mem, cur_mem;
+	uint64_t total_mem = internal_config.memory;
+
 	if (num_hp_info == 0)
 		return -1;
 
-	for (i = 0; i < num_hp_info; i++){
-		hp_used[i].hugepage_sz = hp_info[i].hugepage_sz;
-		hp_used[i].hugedir = hp_info[i].hugedir;
-		hp_used[i].num_pages = RTE_MIN(memory / hp_info[i].hugepage_sz,
-				hp_info[i].num_pages);
-
-		memory -= hp_used[i].num_pages * hp_used[i].hugepage_sz;
-		total_num_pages += hp_used[i].num_pages;
-
-		/* check if we have met all memory requests */
-		if (memory == 0)
-			break;
-		/* check if we have any more pages left at this size, if so
-		 * move on to next size */
-		if (hp_used[i].num_pages == hp_info[i].num_pages)
-			continue;
-		/* At this point we know that there are more pages available that are
-		 * bigger than the memory we want, so lets see if we can get enough
-		 * from other page sizes.
-		 */
-		unsigned j;
-		uint64_t remaining_mem = 0;
-		for (j = i+1; j < num_hp_info; j++)
-			remaining_mem += hp_info[j].hugepage_sz * hp_info[j].num_pages;
-
-		/* is there enough other memory, if not allocate another page and quit*/
-		if (remaining_mem < memory){
-			memory -= hp_info[i].hugepage_sz;
-			hp_used[i].num_pages++;
-			total_num_pages++;
-			break; /* we are done */
+	for (socket = 0; socket < RTE_MAX_NUMA_NODES && total_mem != 0; socket++) {
+		/* if specific memory amounts per socket weren't requested */
+		if (internal_config.force_sockets == 0) {
+			/* take whatever is available */
+			memory[socket] = RTE_MIN(get_socket_mem_size(socket),
+					total_mem);
 		}
+		/* skips if the memory on specific socket wasn't requested */
+		for (i = 0; i < num_hp_info && memory[socket] != 0; i++){
+			hp_used[i].hugedir = hp_info[i].hugedir;
+			hp_used[i].num_pages[socket] = RTE_MIN(
+					memory[socket] / hp_info[i].hugepage_sz,
+					hp_info[i].num_pages[socket]);
+
+			cur_mem = hp_used[i].num_pages[socket] *
+					hp_used[i].hugepage_sz;
+
+			memory[socket] -= cur_mem;
+			total_mem -= cur_mem;
+
+			total_num_pages += hp_used[i].num_pages[socket];
+
+			/* check if we have met all memory requests */
+			if (memory[socket] == 0)
+				break;
+
+			/* check if we have any more pages left at this size, if so
+			 * move on to next size */
+			if (hp_used[i].num_pages[socket] == hp_info[i].num_pages[socket])
+				continue;
+			/* At this point we know that there are more pages available that are
+			 * bigger than the memory we want, so lets see if we can get enough
+			 * from other page sizes.
+			 */
+			remaining_mem = 0;
+			for (j = i+1; j < num_hp_info; j++)
+				remaining_mem += hp_info[j].hugepage_sz *
+				hp_info[j].num_pages[socket];
+
+			/* is there enough other memory, if not allocate another page and quit */
+			if (remaining_mem < memory[socket]){
+				cur_mem = RTE_MIN(memory[socket],
+						hp_info[i].hugepage_sz);
+				memory[socket] -= cur_mem;
+				total_mem -= cur_mem;
+				hp_used[i].num_pages[socket]++;
+				total_num_pages++;
+				break; /* we are done with this socket*/
+			}
+		}
+		/* if we didn't satisfy all memory requirements per socket */
+		if (memory[socket] > 0) {
+			/* to prevent icc errors */
+			requested = (unsigned) (internal_config.socket_mem[socket] /
+					0x100000);
+			available = requested -
+					((unsigned) (memory[socket] / 0x100000));
+			RTE_LOG(INFO, EAL, "Not enough memory available on socket %u! "
+					"Requested: %uMB, available: %uMB\n", socket,
+					requested, available);
+			return -1;
+		}
+	}
+
+	/* if we didn't satisfy total memory requirements */
+	if (total_mem > 0) {
+		requested = (unsigned) (internal_config.memory / 0x100000);
+		available = requested - (unsigned) (total_mem / 0x100000);
+		RTE_LOG(INFO, EAL, "Not enough memory available! Requested: %uMB,"
+				" available: %uMB\n", requested, available);
+		return -1;
 	}
 	return total_num_pages;
 }
@@ -526,10 +752,14 @@ static int
 rte_eal_hugepage_init(void)
 {
 	struct rte_mem_config *mcfg;
-	struct hugepage *hugepage;
+	struct hugepage *hugepage, *tmp_hp = NULL;
 	struct hugepage_info used_hp[MAX_HUGEPAGE_SIZES];
+
+	uint64_t memory[RTE_MAX_NUMA_NODES];
+
+	unsigned hp_offset;
 	int i, j, new_memseg;
-	int nrpages;
+	int nrpages, total_pages = 0;
 	void *addr;
 
 	memset(used_hp, 0, sizeof(used_hp));
@@ -540,66 +770,169 @@ rte_eal_hugepage_init(void)
 	/* for debug purposes, hugetlbfs can be disabled */
 	if (internal_config.no_hugetlbfs) {
 		addr = malloc(internal_config.memory);
-		mcfg->memseg[0].phys_addr = (unsigned long)addr;
+		mcfg->memseg[0].phys_addr = (phys_addr_t)(uintptr_t)addr;
 		mcfg->memseg[0].addr = addr;
 		mcfg->memseg[0].len = internal_config.memory;
 		mcfg->memseg[0].socket_id = 0;
 		return 0;
 	}
 
-	nrpages = calc_num_pages(internal_config.memory,
-			&internal_config.hugepage_info[0], &used_hp[0],
-			internal_config.num_hugepage_sizes);
-	for (i = 0; i < (int)internal_config.num_hugepage_sizes; i++)
-		RTE_LOG(INFO, EAL, "Requesting %u pages of size %"PRIu64"\n",
-				used_hp[i].num_pages, used_hp[i].hugepage_sz);
 
-	hugepage = create_shared_memory(eal_hugepage_info_path(),
-			nrpages * sizeof(struct hugepage));
-	if (hugepage == NULL)
-		return -1;
-	memset(hugepage, 0, nrpages * sizeof(struct hugepage));
+	/* calculate total number of hugepages available. at this point we haven't
+	 * yet started sorting them so they all are on socket 0 */
+	for (i = 0; i < (int) internal_config.num_hugepage_sizes; i++) {
+		/* meanwhile, also initialize used_hp hugepage sizes in used_hp */
+		used_hp[i].hugepage_sz = internal_config.hugepage_info[i].hugepage_sz;
+
+		total_pages += internal_config.hugepage_info[i].num_pages[0];
+	}
+
+	/*
+	 * allocate a memory area for hugepage table.
+	 * this isn't shared memory yet. due to the fact that we need some
+	 * processing done on these pages, shared memory will be created
+	 * at a later stage.
+	 */
+	tmp_hp = malloc(total_pages * sizeof(struct hugepage));
+	if (tmp_hp == NULL)
+		goto fail;
+
+	memset(tmp_hp, 0, total_pages * sizeof(struct hugepage));
+
+	hp_offset = 0; /* where we start the current page size entries */
 
-	unsigned hp_offset = 0; /* where we start the current page size entries */
+	/* map all hugepages and sort them */
 	for (i = 0; i < (int)internal_config.num_hugepage_sizes; i ++){
-		struct hugepage_info *hpi = &used_hp[i];
+		struct hugepage_info *hpi;
+
+		/*
+		 * we don't yet mark hugepages as used at this stage, so
+		 * we just map all hugepages available to the system
+		 * all hugepages are still located on socket 0
+		 */
+		hpi = &internal_config.hugepage_info[i];
+
 		if (hpi->num_pages == 0)
 			continue;
 
-		if (map_all_hugepages(&hugepage[hp_offset], hpi, 1) < 0){
+		/* map all hugepages available */
+		if (map_all_hugepages(&tmp_hp[hp_offset], hpi, 1) < 0){
 			RTE_LOG(DEBUG, EAL, "Failed to mmap %u MB hugepages\n",
 					(unsigned)(hpi->hugepage_sz / 0x100000));
 			goto fail;
 		}
 
-		if (find_physaddr(&hugepage[hp_offset], hpi) < 0){
+		/* find physical addresses and sockets for each hugepage */
+		if (find_physaddr(&tmp_hp[hp_offset], hpi) < 0){
 			RTE_LOG(DEBUG, EAL, "Failed to find phys addr for %u MB pages\n",
 					(unsigned)(hpi->hugepage_sz / 0x100000));
 			goto fail;
 		}
 
-		if (find_numasocket(&hugepage[hp_offset], hpi) < 0){
+		if (find_numasocket(&tmp_hp[hp_offset], hpi) < 0){
 			RTE_LOG(DEBUG, EAL, "Failed to find NUMA socket for %u MB pages\n",
 					(unsigned)(hpi->hugepage_sz / 0x100000));
 			goto fail;
 		}
 
-		if (sort_by_physaddr(&hugepage[hp_offset], hpi) < 0)
+		if (sort_by_physaddr(&tmp_hp[hp_offset], hpi) < 0)
 			goto fail;
 
-		if (map_all_hugepages(&hugepage[hp_offset], hpi, 0) < 0){
+		/* remap all hugepages */
+		if (map_all_hugepages(&tmp_hp[hp_offset], hpi, 0) < 0){
 			RTE_LOG(DEBUG, EAL, "Failed to remap %u MB pages\n",
 					(unsigned)(hpi->hugepage_sz / 0x100000));
 			goto fail;
 		}
 
-		if (unmap_all_hugepages_orig(&hugepage[hp_offset], hpi) < 0)
+		/* unmap original mappings */
+		if (unmap_all_hugepages_orig(&tmp_hp[hp_offset], hpi) < 0)
 			goto fail;
 
 		/* we have processed a num of hugepages of this size, so inc offset */
-		hp_offset += hpi->num_pages;
+		hp_offset += hpi->num_pages[0];
+	}
+
+	/* clean out the numbers of pages */
+	for (i = 0; i < (int) internal_config.num_hugepage_sizes; i++)
+		for (j = 0; j < RTE_MAX_NUMA_NODES; j++)
+			internal_config.hugepage_info[i].num_pages[j] = 0;
+
+	/* get hugepages for each socket */
+	for (i = 0; i < total_pages; i++) {
+		int socket = tmp_hp[i].socket_id;
+
+		/* find a hugepage info with right size and increment num_pages */
+		for (j = 0; j < (int) internal_config.num_hugepage_sizes; j++) {
+			if (tmp_hp[i].size ==
+					internal_config.hugepage_info[j].hugepage_sz) {
+				internal_config.hugepage_info[j].num_pages[socket]++;
+			}
+		}
+	}
+
+	/* make a copy of socket_mem, needed for number of pages calculation */
+	for (i = 0; i < RTE_MAX_NUMA_NODES; i++)
+		memory[i] = internal_config.socket_mem[i];
+
+	/* calculate final number of pages */
+	nrpages = calc_num_pages_per_socket(memory,
+			internal_config.hugepage_info, used_hp,
+			internal_config.num_hugepage_sizes);
+
+	/* error if not enough memory available */
+	if (nrpages < 0)
+		goto fail;
+
+	/* reporting in! */
+	for (i = 0; i < (int) internal_config.num_hugepage_sizes; i++) {
+		for (j = 0; j < RTE_MAX_NUMA_NODES; j++) {
+			if (used_hp[i].num_pages[j] > 0) {
+				RTE_LOG(INFO, EAL,
+						"Requesting %u pages of size %uMB"
+						" from socket %i\n",
+						used_hp[i].num_pages[j],
+						(unsigned)
+							(used_hp[i].hugepage_sz / 0x100000),
+						j);
+			}
+		}
+	}
+
+	/* create shared memory */
+	hugepage = create_shared_memory(eal_hugepage_info_path(),
+					nrpages * sizeof(struct hugepage));
+
+	if (hugepage == NULL) {
+		RTE_LOG(ERR, EAL, "Failed to create shared memory!\n");
+		goto fail;
 	}
 
+	/*
+	 * unmap pages that we won't need (looks at used_hp).
+	 * also, sets final_va to NULL on pages that were unmapped.
+	 */
+	if (unmap_unneeded_hugepages(tmp_hp, used_hp,
+			internal_config.num_hugepage_sizes) < 0) {
+		RTE_LOG(ERR, EAL, "Unmapping and locking hugepages failed!\n");
+		goto fail;
+	}
+
+	/*
+	 * copy stuff from malloc'd hugepage* to the actual shared memory.
+	 * this procedure only copies those hugepages that have final_va
+	 * not NULL. has overflow protection.
+	 */
+	if (copy_hugepages_to_shared_mem(hugepage, nrpages,
+			tmp_hp, total_pages) < 0) {
+		RTE_LOG(ERR, EAL, "Copying tables to shared memory failed!\n");
+		goto fail;
+	}
+
+	/* free the temporary hugepage table */
+	free(tmp_hp);
+	tmp_hp = NULL;
+
 	memset(mcfg->memseg, 0, sizeof(mcfg->memseg));
 	j = -1;
 	for (i = 0; i < nrpages; i++) {
@@ -613,10 +946,10 @@ rte_eal_hugepage_init(void)
 		else if (hugepage[i].size != hugepage[i-1].size)
 			new_memseg = 1;
 		else if ((hugepage[i].physaddr - hugepage[i-1].physaddr) !=
-			 hugepage[i].size)
+		    hugepage[i].size)
 			new_memseg = 1;
 		else if (((unsigned long)hugepage[i].final_va -
-		     (unsigned long)hugepage[i-1].final_va) != hugepage[i].size)
+		    (unsigned long)hugepage[i-1].final_va) != hugepage[i].size)
 			new_memseg = 1;
 
 		if (new_memseg) {
@@ -637,10 +970,24 @@ rte_eal_hugepage_init(void)
 		hugepage[i].memseg_id = j;
 	}
 
+	if (i < nrpages) {
+		RTE_LOG(ERR, EAL, "Can only reserve %d pages "
+			"from %d requested\n"
+			"Current %s=%d is not enough\n"
+			"Please either increase it or request less amount "
+			"of memory.\n",
+			i, nrpages, RTE_STR(CONFIG_RTE_MAX_MEMSEG),
+			RTE_MAX_MEMSEG);
+		return (-ENOMEM);
+	}
+	
+
 	return 0;
 
 
- fail:
+fail:
+	if (tmp_hp)
+		free(tmp_hp);
 	return -1;
 }
 
@@ -782,6 +1129,7 @@ rte_eal_memdevice_init(void)
 int
 rte_eal_memory_init(void)
 {
+	RTE_LOG(INFO, EAL, "Setting up hugepage memory...\n");
 	const int retval = rte_eal_process_type() == RTE_PROC_PRIMARY ?
 			rte_eal_hugepage_init() :
 			rte_eal_hugepage_attach();