memory: do not attempt to reserve hugepages or lock memory in unprivileged environments

common

@@ -1 +1 @@
-Subproject commit b8778630eae7caf7af8ceef27f201639b095ead3
+Subproject commit 59eaf21fc8cd57eba035baa128f9d21743747eed

lib/memory.cpp

@@ -66,8 +66,12 @@ int memory_lock(size_t lock)
 {
 	int ret;
 
-#ifdef __linux__
+	if (!utils::isPrivileged()) {
+		logger->warn("Running in an unprivileged environment. Memory is not locked to RAM!");
+		return 0;
+	}
 
+#ifdef __linux__
 #ifndef __arm__
 	struct rlimit l;
 
@@ -79,7 +83,7 @@ int memory_lock(size_t lock)
 	if (l.rlim_cur < lock) {
 		if (l.rlim_max < lock) {
 			if (getuid() != 0) {
-				logger->warn("Failed to in increase ressource limit of locked memory. Please increase manually by running as root:");
+				logger->warn("Failed to increase ressource limit of locked memory. Please increase manually by running as root:");
 				logger->warn("   $ ulimit -Hl {}", lock);
 
 				return 0;

lib/memory/mmap.cpp

@@ -57,53 +57,49 @@ int memory_mmap_init(int hugepages)
 	if (pgsz < 0)
 		return -1;
 
-	if (hugepages > 0) {
-		hugepgsz = kernel::getHugePageSize();
-		if (hugepgsz < 0) {
-			logger->warn("Failed to determine hugepage size.");
+	if (hugepages == 0) {
+		logger->warn("Hugepage allocator disabled.");
 
-			memory_default = &memory_mmap;
-			return 0;
-		}
+		memory_default = &memory_mmap;
+		return 0;
+	}
+
+	if (!utils::isPrivileged()) {
+		logger->warn("Running in an unprivileged environment. Hugepages are not used!");
+
+		memory_default = &memory_mmap;
+		return 0;
+	}
+
+	hugepgsz = kernel::getHugePageSize();
+	if (hugepgsz < 0) {
+		logger->warn("Failed to determine hugepage size.");
+
+		return -1;
+	}
 
 #if defined(__linux__) && defined(__x86_64__)
-		int ret, pagecnt;
+	int ret, pagecnt;
 
-		pagecnt = kernel::getNrHugepages();
-		if (pagecnt < hugepages) {
-			if (getuid() == 0) {
-				ret = kernel::setNrHugepages(hugepages);
-				if (ret) {
-					logger->warn("Failed to increase number of reserved hugepages. Falling back to standard mmap() allocator.");
+	pagecnt = kernel::getNrHugepages();
+	if (pagecnt < hugepages) {
+		ret = kernel::setNrHugepages(hugepages);
+		if (ret) {
+			logger->warn("Failed to reserved hugepages. Please reserve manually by running as root:");
+			logger->warn("   $ echo {} > /proc/sys/vm/nr_hugepages", hugepages);
 
-					if (isContainer()) {
-						logger->warn("Please run the container in the privileged mode:");
-						logger->warn("    $ docker run --privileged ...");
-					}
-
-					memory_default = &memory_mmap;
-				}
-				else {
-					logger->debug("Increased number of reserved hugepages from {} to {}", pagecnt, hugepages);
-					memory_default = &memory_mmap_hugetlb;
-				}
-			}
-			else {
-				logger->warn("Failed to reserved hugepages. Please reserve manually by running as root:");
-				logger->warn("   $ echo {} > /proc/sys/vm/nr_hugepages", hugepages);
-				memory_default = &memory_mmap;
-			}
+			return -1;
 		}
-		else
-			memory_default = &memory_mmap_hugetlb;
+
+		logger->debug("Increased number of reserved hugepages from {} to {}", pagecnt, hugepages);
+	}
+
+	memory_default = &memory_mmap_hugetlb;
 #else
-		memory_default = &memory_mmap;
+	logger->debug("Hugepages not supported on this system. Falling back to standard mmap() allocator.");
+
+	memory_default = &memory_mmap;
 #endif
-	}
-	else {
-		logger->warn("Hugepage allocator disabled.");
-		memory_default = &memory_mmap;
-	}
 
 	return 0;
 }

tests/unit/memory.cpp

@@ -28,6 +28,9 @@
 #include <villas/memory.h>
 #include <villas/utils.hpp>
 #include <villas/log.hpp>
+#include <villas/utils.hpp>
+
+using namespace villas;
 
 extern void init_memory();
 
@@ -45,6 +48,9 @@ Theory((size_t len, size_t align, struct memory_type *mt), memory, aligned, .ini
 	int ret;
 	void *ptr;
 
+	if (!utils::isPrivileged() && mt == &memory_mmap_hugetlb)
+		cr_skip_test("Skipping memory_mmap_hugetlb tests allocatpr because we are running in an unprivileged environment.");
+
 	ptr = memory_alloc_aligned(len, align, mt);
 	cr_assert_not_null(ptr, "Failed to allocate memory");
 

tests/unit/pool.cpp

@@ -27,6 +27,9 @@
 
 #include <villas/pool.h>
 #include <villas/utils.hpp>
+#include <villas/log.hpp>
+
+using namespace villas;
 
 extern void init_memory();
 
@@ -40,10 +43,10 @@ struct param {
 ParameterizedTestParameters(pool, basic)
 {
 	static struct param params[] = {
-		{ 1,	4096,	150,	&memory_heap },
-		{ 1,	128,	8,	&memory_mmap_hugetlb },
-		{ 1,	4,	8192,	&memory_mmap_hugetlb },
-		{ 1,	1 << 13, 4,	&memory_mmap_hugetlb }
+		{ 1, 4096,    150,  &memory_heap },
+		{ 1, 128,     8,    &memory_mmap },
+		{ 1, 4,       8192, &memory_mmap_hugetlb },
+		{ 1, 1 << 13, 4,    &memory_mmap_hugetlb }
 	};
 
 	return cr_make_param_array(struct param, params, ARRAY_LEN(params));
@@ -55,8 +58,15 @@ ParameterizedTest(struct param *p, pool, basic, .init = init_memory)
 	int ret;
 	struct pool pool;
 
+	// some strange LTO stuff is going on here..
+	auto *m  __attribute__((unused)) = &memory_mmap;
+
 	void *ptr, *ptrs[p->pool_size];
 
+	if (!utils::isPrivileged() && p->mt == &memory_mmap_hugetlb) {
+		cr_skip_test("Skipping memory_mmap_hugetlb tests allocatpr because we are running in an unprivileged environment.");
+	}
+
 	ret = pool_init(&pool, p->pool_size, p->block_size, p->mt);
 	cr_assert_eq(ret, 0, "Failed to create pool");
 
@@ -81,5 +91,4 @@ ParameterizedTest(struct param *p, pool, basic, .init = init_memory)
 
 	ret = pool_destroy(&pool);
 	cr_assert_eq(ret, 0, "Failed to destroy pool");
-
 }

tests/unit/queue.cpp

@@ -295,6 +295,9 @@ ParameterizedTest(struct param *p, queue, multi_threaded, .timeout = 20, .init =
 
 	Logger logger = logging.get("test:queue:multi_threaded");
 
+	if (!utils::isPrivileged() && p->mt == &memory_mmap_hugetlb)
+		cr_skip_test("Skipping memory_mmap_hugetlb tests allocatpr because we are running in an unprivileged environment.");
+
 	pthread_t threads[p->thread_count];
 
 	p->start = 0;