Skip to contentSkip to conversation

eal: use madvise to exclude unmapped memory from being dumped

PATCH Superseded Li Feng 4 participants 11 messages Apr 24, 2020

lore
Share & tools
lore

Li Feng

author
#0 lore raw

PATCH v2 1/1 eal: use madvise to exclude unmapped memory from being dumped

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

---
V2:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

 lib/librte_eal/common/eal_common_memory.c | 26 ++++++++++++++++++++++++++
 lib/librte_eal/linux/eal_memalloc.c       |  6 ++++++
 2 files changed, 32 insertions(+)
lib/librte_eal/common/eal_common_memory.c +26 -0
index cc7d54e0c..83be94a20 100644
@@ -177,6 +177,32 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
 		after_len = RTE_PTR_DIFF(map_end, aligned_end);
 		if (after_len > 0)
 			munmap(aligned_end, after_len);
+
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
+		if (madvise(aligned_addr, *size, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
+	} else {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(mapped_addr, map_sz, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
+		if (madvise(mapped_addr, map_sz, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
 	}
 
 	return aligned_addr;
lib/librte_eal/linux/eal_memalloc.c +6 -0
index af6d0d023..9d2a6fc6f 100644
@@ -571,6 +571,9 @@ alloc_seg(struct rte_memseg *ms, void *addr, int socket_id,
 		goto resized;
 	}
 
+	if (madvise(addr, alloc_sz, MADV_DODUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
 	/* In linux, hugetlb limitations, like cgroup, are
 	 * enforced at fault time instead of mmap(), even
 	 * with the option of MAP_POPULATE. Kernel will send
@@ -687,6 +690,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
 		return -1;
 	}
 
+	if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
 	exit_early = false;
 
 	/* if we're using anonymous hugepages, nothing to be done */
Signature · 8 lines
2.11.0


-- 
The SmartX email address is only for business purpose. Any sent message 
that is not related to the business is not authorized or permitted by 
SmartX.
本邮箱为北京志凌海纳科技有限公司(SmartX)工作邮箱. 如本邮箱发出的邮件与工作无关,该邮件未得到本公司任何的明示或默示的授权.
#1 lore raw
Quoted 9 lines · Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

Quoted 6 lines

---
V2:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

Isn't this v3 now?

Quoted 30 lines
  lib/librte_eal/common/eal_common_memory.c | 26 ++++++++++++++++++++++++++
  lib/librte_eal/linux/eal_memalloc.c       |  6 ++++++
  2 files changed, 32 insertions(+)
lib/librte_eal/common/eal_common_memory.c +17 -0
index cc7d54e0c..83be94a20 100644
@@ -177,6 +177,32 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
  		after_len = RTE_PTR_DIFF(map_end, aligned_end);
  		if (after_len > 0)
  			munmap(aligned_end, after_len);
+
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
+		if (madvise(aligned_addr, *size, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
+	} else {
+		/*
+		 * Exclude this pages from a core dump.
+		 */

lib/librte_eal/common/eal_common_memory.c eal_get_virtual_area(void *requested_addr, size_t *size, · line 206

Quoted 10 lines
lib/librte_eal/common/eal_common_memory.c +9 -0
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(mapped_addr, map_sz, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
+		if (madvise(mapped_addr, map_sz, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
  	}

DRY (Don't Repeat Yourself) :) Probably easier to do "if (!unmap) ..." than putting this into two places.

lib/librte_eal/linux/eal_memalloc.c alloc_seg(struct rte_memseg *ms, void *addr, int socket_id, · line 576

Quoted 13 lines
lib/librte_eal/common/eal_common_memory.c +0 -0
  	return aligned_addr;
lib/librte_eal/linux/eal_memalloc.c +3 -0
index af6d0d023..9d2a6fc6f 100644
@@ -571,6 +571,9 @@ alloc_seg(struct rte_memseg *ms, void *addr, int socket_id,
  		goto resized;
  	}
 
+	if (madvise(addr, alloc_sz, MADV_DODUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+

See discussion for v2, i believe this is unnecessary.

Quoted 14 lines
lib/librte_eal/linux/eal_memalloc.c +3 -0
  	/* In linux, hugetlb limitations, like cgroup, are
  	 * enforced at fault time instead of mmap(), even
  	 * with the option of MAP_POPULATE. Kernel will send
@@ -687,6 +690,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
  		return -1;
  	}
 
+	if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
  	exit_early = false;
 
  	/* if we're using anonymous hugepages, nothing to be done */
Signature · 2 lines
Thanks,
Anatoly
#2 lore raw
Quoted 54 lines · Anatoly
Quoted 9 lines · Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

Quoted 6 lines

---
V2:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

Isn't this v3 now?

Quoted 35 lines
  lib/librte_eal/common/eal_common_memory.c | 26 ++++++++++++++++++++++++++
  lib/librte_eal/linux/eal_memalloc.c       |  6 ++++++
  2 files changed, 32 insertions(+)
lib/librte_eal/common/eal_common_memory.c +22 -0
index cc7d54e0c..83be94a20 100644
@@ -177,6 +177,32 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
  		after_len = RTE_PTR_DIFF(map_end, aligned_end);
  		if (after_len > 0)
  			munmap(aligned_end, after_len);
+
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
+		if (madvise(aligned_addr, *size, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
+	} else {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(mapped_addr, map_sz, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
Quoted 9 lines

lib/librte_eal/common/eal_common_memory.c eal_get_virtual_area(void *requested_addr, size_t *size, · line 206

Quoted 5 lines
lib/librte_eal/common/eal_common_memory.c +4 -0
+		if (madvise(mapped_addr, map_sz, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
  	}

DRY (Don't Repeat Yourself) :) Probably easier to do "if (!unmap) ..." than putting this into two places.

Can I also suggest putting this at the top of the file:
#ifdef RTE_EXEC_ENV_LINUX
#define RTE_DONTDUMP MADV_DONTDUMP
#elif RTE_EXEC_ENV_FREEBSD
#define RTE_DONTDUMP MADV_NOCORE
#else
#error ....
#endif

and thereafter using RTE_DONTDUMP flag and avoiding any #ifdefs inline in the code.

#3 lore raw
Quoted 73 lines · Bruce Richardson
Quoted 54 lines · Anatoly
Quoted 9 lines · Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

Quoted 6 lines

---
V2:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

Isn't this v3 now?

Quoted 35 lines
   lib/librte_eal/common/eal_common_memory.c | 26 ++++++++++++++++++++++++++
   lib/librte_eal/linux/eal_memalloc.c       |  6 ++++++
   2 files changed, 32 insertions(+)
lib/librte_eal/common/eal_common_memory.c +22 -0
index cc7d54e0c..83be94a20 100644
@@ -177,6 +177,32 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
   		after_len = RTE_PTR_DIFF(map_end, aligned_end);
   		if (after_len > 0)
   			munmap(aligned_end, after_len);
+
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
+		if (madvise(aligned_addr, *size, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
+	} else {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+#ifdef RTE_EXEC_ENV_LINUX
+		if (madvise(mapped_addr, map_sz, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
Quoted 9 lines

lib/librte_eal/common/eal_common_memory.c eal_get_virtual_area(void *requested_addr, size_t *size, · line 206

Quoted 5 lines
lib/librte_eal/common/eal_common_memory.c +4 -0
+		if (madvise(mapped_addr, map_sz, MADV_NOCORE) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+#endif
   	}

DRY (Don't Repeat Yourself) :) Probably easier to do "if (!unmap) ..." than putting this into two places.

Can I also suggest putting this at the top of the file:
#ifdef RTE_EXEC_ENV_LINUX
#define RTE_DONTDUMP MADV_DONTDUMP
#elif RTE_EXEC_ENV_FREEBSD
#define RTE_DONTDUMP MADV_NOCORE
#else
#error ....
#endif

Quoted 3 lines

and thereafter using RTE_DONTDUMP flag and avoiding any #ifdefs inline in the code.

+1

Signature · 2 lines
Thanks,
Anatoly
author
#4 lore raw
In reply to Burakov, Anatoly

Thanks,

Feng Li

Quoted 11 lines · Burakov, Anatoly <[email protected]> 于2020年4月24日周五 下午7:23写道:
Quoted 9 lines · Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

Quoted 8 lines
Quoted 6 lines

---
V2:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

Isn't this v3 now?

My mistake. I will using v4 for next version.

Quoted 36 lines
Quoted 36 lines

  lib/librte_eal/common/eal_common_memory.c | 26 ++++++++++++++++++++++++++
  lib/librte_eal/linux/eal_memalloc.c       |  6 ++++++
  2 files changed, 32 insertions(+)
lib/librte_eal/common/eal_common_memory.c +22 -0
index cc7d54e0c..83be94a20 100644
@@ -177,6 +177,32 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
              after_len = RTE_PTR_DIFF(map_end, aligned_end);
              if (after_len > 0)
                      munmap(aligned_end, after_len);
+
+             /*
+              * Exclude this pages from a core dump.
+              */
+#ifdef RTE_EXEC_ENV_LINUX
+             if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+                     RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+                             strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
+             if (madvise(aligned_addr, *size, MADV_NOCORE) != 0)
+                     RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+                             strerror(errno));
+#endif
+     } else {
+             /*
+              * Exclude this pages from a core dump.
+              */
+#ifdef RTE_EXEC_ENV_LINUX
+             if (madvise(mapped_addr, map_sz, MADV_DONTDUMP) != 0)
+                     RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+                             strerror(errno));
+#elif RTE_EXEC_ENV_FREEBSD
Quoted 8 lines

lib/librte_eal/common/eal_common_memory.c eal_get_virtual_area(void *requested_addr, size_t *size, · line 206

Quoted 5 lines
lib/librte_eal/common/eal_common_memory.c +4 -0
+             if (madvise(mapped_addr, map_sz, MADV_NOCORE) != 0)
+                     RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+                             strerror(errno));
+#endif
      }

DRY (Don't Repeat Yourself) :) Probably easier to do "if (!unmap) ..." than putting this into two places.

OK. I put this into two places, because the size is more accurate in this place.

Quoted 36 lines
Quoted 8 lines
lib/librte_eal/common/eal_common_memory.c +0 -0
      return aligned_addr;
lib/librte_eal/linux/eal_memalloc.c +0 -0
index af6d0d023..9d2a6fc6f 100644

lib/librte_eal/linux/eal_memalloc.c alloc_seg(struct rte_memseg *ms, void *addr, int socket_id, · line 576

Quoted 6 lines
lib/librte_eal/linux/eal_memalloc.c +3 -0
@@ -571,6 +571,9 @@ alloc_seg(struct rte_memseg *ms, void *addr, int socket_id,
              goto resized;
      }
 
+     if (madvise(addr, alloc_sz, MADV_DODUMP) != 0)
+             RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+

See discussion for v2, i believe this is unnecessary.

Quoted 5 lines
lib/librte_eal/linux/eal_memalloc.c +0 -0
      /* In linux, hugetlb limitations, like cgroup, are
       * enforced at fault time instead of mmap(), even
       * with the option of MAP_POPULATE. Kernel will send

lib/librte_eal/linux/eal_memalloc.c free_seg(struct rte_memseg *ms, struct hugepage_info *hi, · line 698

Quoted 9 lines
lib/librte_eal/linux/eal_memalloc.c +3 -0
@@ -687,6 +690,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
              return -1;
      }
 
+     if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+             RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
      exit_early = false;
 
      /* if we're using anonymous hugepages, nothing to be done */

--
Thanks,
Anatoly

Signature · 4 lines
The SmartX email address is only for business purpose. Any sent message 
that is not related to the business is not authorized or permitted by 
SmartX.
本邮箱为北京志凌海纳科技有限公司(SmartX)工作邮箱. 如本邮箱发出的邮件与工作无关,该邮件未得到本公司任何的明示或默示的授权.
author
#5 lore raw

PATCH v4 1/1 eal: use madvise to exclude unmapped memory from being dumped

In reply to Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

---
V4:
- simplify the code;
- remove the undo code in V3;

V3:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

 lib/librte_eal/common/eal_common_memory.c | 17 +++++++++++++++++
 lib/librte_eal/linux/eal_memalloc.c       |  3 +++
 2 files changed, 20 insertions(+)
lib/librte_eal/common/eal_common_memory.c +17 -0
index cc7d54e0c..2fea1bdb2 100644
@@ -40,6 +40,14 @@
 static void *next_baseaddr;
 static uint64_t system_page_sz;
 
+#ifdef RTE_EXEC_ENV_LINUX
+#define RTE_DONTDUMP MADV_DONTDUMP
+#elif RTE_EXEC_ENV_FREEBSD
+#define RTE_DONTDUMP MADV_NOCORE
+#else
+#error "madvise doesn't support this OS"
+#endif
+
 #define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
 void *
 eal_get_virtual_area(void *requested_addr, size_t *size,
@@ -179,6 +187,15 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
 			munmap(aligned_end, after_len);
 	}
 
+    if (!unmap) {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+		if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+	}
+
 	return aligned_addr;
 }
 
lib/librte_eal/linux/eal_memalloc.c +3 -0
index af6d0d023..f628e0991 100644
@@ -687,6 +687,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
 		return -1;
 	}
 
+	if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
 	exit_early = false;
 
 	/* if we're using anonymous hugepages, nothing to be done */
Signature · 8 lines
2.11.0


-- 
The SmartX email address is only for business purpose. Any sent message 
that is not related to the business is not authorized or permitted by 
SmartX.
本邮箱为北京志凌海纳科技有限公司(SmartX)工作邮箱. 如本邮箱发出的邮件与工作无关,该邮件未得到本公司任何的明示或默示的授权.
author
#6 lore raw

PATCH v5 1/1 eal: use madvise to exclude unmapped memory from being dumped

In reply to Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

---
v5:
- fix a code style.

V4:
- simplify the code;
- remove the undo code in V3;

V3:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

 lib/librte_eal/common/eal_common_memory.c | 17 +++++++++++++++++
 lib/librte_eal/linux/eal_memalloc.c       |  3 +++
 2 files changed, 20 insertions(+)
lib/librte_eal/common/eal_common_memory.c +17 -0
index cc7d54e0c..161e49825 100644
@@ -40,6 +40,14 @@
 static void *next_baseaddr;
 static uint64_t system_page_sz;
 
+#ifdef RTE_EXEC_ENV_LINUX
+#define RTE_DONTDUMP MADV_DONTDUMP
+#elif RTE_EXEC_ENV_FREEBSD
+#define RTE_DONTDUMP MADV_NOCORE
+#else
+#error "madvise doesn't support this OS"
+#endif
+
 #define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
 void *
 eal_get_virtual_area(void *requested_addr, size_t *size,
@@ -179,6 +187,15 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
 			munmap(aligned_end, after_len);
 	}
 
+	if (!unmap) {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+		if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+	}
+
 	return aligned_addr;
 }
 
lib/librte_eal/linux/eal_memalloc.c +3 -0
index af6d0d023..f628e0991 100644
@@ -687,6 +687,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
 		return -1;
 	}
 
+	if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
 	exit_early = false;
 
 	/* if we're using anonymous hugepages, nothing to be done */
Signature · 8 lines
2.11.0


-- 
The SmartX email address is only for business purpose. Any sent message 
that is not related to the business is not authorized or permitted by 
SmartX.
本邮箱为北京志凌海纳科技有限公司(SmartX)工作邮箱. 如本邮箱发出的邮件与工作无关,该邮件未得到本公司任何的明示或默示的授权.
#7 lore raw
Quoted 33 lines · Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

---
v5:
- fix a code style.

V4:
- simplify the code;
- remove the undo code in V3;

V3:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

 lib/librte_eal/common/eal_common_memory.c | 17 +++++++++++++++++
 lib/librte_eal/linux/eal_memalloc.c       |  3 +++
 2 files changed, 20 insertions(+)
lib/librte_eal/common/eal_common_memory.c +0 -0
index cc7d54e0c..161e49825 100644
@@ -40,6 +40,14 @@
 static void *next_baseaddr;

lib/librte_eal/common/eal_common_memory.c line 50

Quoted 10 lines
lib/librte_eal/common/eal_common_memory.c +8 -0
 static uint64_t system_page_sz;
 
+#ifdef RTE_EXEC_ENV_LINUX
+#define RTE_DONTDUMP MADV_DONTDUMP
+#elif RTE_EXEC_ENV_FREEBSD
+#define RTE_DONTDUMP MADV_NOCORE
+#else
+#error "madvise doesn't support this OS"
+#endif
+

You forgot to use RTE_DONTDUMP in place of MADV_DONTDUMP below.

Quoted 44 lines
lib/librte_eal/common/eal_common_memory.c +9 -0
 #define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
 void *
 eal_get_virtual_area(void *requested_addr, size_t *size,
@@ -179,6 +187,15 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
 			munmap(aligned_end, after_len);
 	}
 
+	if (!unmap) {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+		if (madvise(aligned_addr, *size, MADV_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+	}
+
 	return aligned_addr;
 }
 
lib/librte_eal/linux/eal_memalloc.c +3 -0
index af6d0d023..f628e0991 100644
@@ -687,6 +687,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
 		return -1;
 	}
 
+	if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
 	exit_early = false;
 
 	/* if we're using anonymous hugepages, nothing to be done */
Signature · 8 lines
2.11.0


-- 
The SmartX email address is only for business purpose. Any sent message 
that is not related to the business is not authorized or permitted by 
SmartX.
本邮箱为北京志凌海纳科技有限公司(SmartX)工作邮箱. 如本邮箱发出的邮件与工作无关,该邮件未得到本公司任何的明示或默示的授权.
author
#8 lore raw

PATCH v6 1/1 eal: use madvise to exclude unmapped memory from being dumped

In reply to Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

---
v6:
- use RTE_DONTDUMP in right place.

v5:
- fix a code style.

V4:
- simplify the code;
- remove the undo code in V3;

V3:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

 lib/librte_eal/common/eal_common_memory.c | 17 +++++++++++++++++
 lib/librte_eal/linux/eal_memalloc.c       |  3 +++
 2 files changed, 20 insertions(+)
lib/librte_eal/common/eal_common_memory.c +17 -0
index cc7d54e0c..cd20672ce 100644
@@ -40,6 +40,14 @@
 static void *next_baseaddr;
 static uint64_t system_page_sz;
 
+#ifdef RTE_EXEC_ENV_LINUX
+#define RTE_DONTDUMP MADV_DONTDUMP
+#elif RTE_EXEC_ENV_FREEBSD
+#define RTE_DONTDUMP MADV_NOCORE
+#else
+#error "madvise doesn't support this OS"
+#endif
+
 #define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
 void *
 eal_get_virtual_area(void *requested_addr, size_t *size,
@@ -179,6 +187,15 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
 			munmap(aligned_end, after_len);
 	}
 
+	if (!unmap) {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+		if (madvise(aligned_addr, *size, RTE_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+	}
+
 	return aligned_addr;
 }
 
lib/librte_eal/linux/eal_memalloc.c +3 -0
index af6d0d023..f628e0991 100644
@@ -687,6 +687,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
 		return -1;
 	}
 
+	if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
 	exit_early = false;
 
 	/* if we're using anonymous hugepages, nothing to be done */
Signature · 8 lines
2.11.0


-- 
The SmartX email address is only for business purpose. Any sent message 
that is not related to the business is not authorized or permitted by 
SmartX.
本邮箱为北京志凌海纳科技有限公司(SmartX)工作邮箱. 如本邮箱发出的邮件与工作无关,该邮件未得到本公司任何的明示或默示的授权.
Acked-by on v6 1/1
#9 lore raw
Quoted 71 lines · Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

---
v6:
- use RTE_DONTDUMP in right place.

v5:
- fix a code style.

V4:
- simplify the code;
- remove the undo code in V3;

V3:
- add support for freebsd.
- when free_seg is called, mark the memory MADV_DONTDUMP.
- when alloc_seg is called, mark the memory MADV_DODUMP.

  lib/librte_eal/common/eal_common_memory.c | 17 +++++++++++++++++
  lib/librte_eal/linux/eal_memalloc.c       |  3 +++
  2 files changed, 20 insertions(+)
lib/librte_eal/common/eal_common_memory.c +17 -0
index cc7d54e0c..cd20672ce 100644
@@ -40,6 +40,14 @@
  static void *next_baseaddr;
  static uint64_t system_page_sz;
 
+#ifdef RTE_EXEC_ENV_LINUX
+#define RTE_DONTDUMP MADV_DONTDUMP
+#elif RTE_EXEC_ENV_FREEBSD
+#define RTE_DONTDUMP MADV_NOCORE
+#else
+#error "madvise doesn't support this OS"
+#endif
+
  #define MAX_MMAP_WITH_DEFINED_ADDR_TRIES 5
  void *
  eal_get_virtual_area(void *requested_addr, size_t *size,
@@ -179,6 +187,15 @@ eal_get_virtual_area(void *requested_addr, size_t *size,
  			munmap(aligned_end, after_len);
  	}
 
+	if (!unmap) {
+		/*
+		 * Exclude this pages from a core dump.
+		 */
+		if (madvise(aligned_addr, *size, RTE_DONTDUMP) != 0)
+			RTE_LOG(DEBUG, EAL, "madvise failed: %s\n",
+				strerror(errno));
+	}
+
  	return aligned_addr;
  }
 
lib/librte_eal/linux/eal_memalloc.c +0 -0
index af6d0d023..f628e0991 100644

lib/librte_eal/linux/eal_memalloc.c free_seg(struct rte_memseg *ms, struct hugepage_info *hi, · line 695

Quoted 9 lines
lib/librte_eal/linux/eal_memalloc.c +3 -0
@@ -687,6 +687,9 @@ free_seg(struct rte_memseg *ms, struct hugepage_info *hi,
  		return -1;
  	}
 
+	if (madvise(ms->addr, ms->len, MADV_DONTDUMP) != 0)
+		RTE_LOG(DEBUG, EAL, "madvise failed: %s\n", strerror(errno));
+
  	exit_early = false;
 
  	/* if we're using anonymous hugepages, nothing to be done */
Signature · 2 lines
Thanks,
Anatoly
Acked-by Anatoly Burakov on v6 1/1 Applied
#10 lore raw
In reply to Li Feng
Quoted 11 lines · Li Feng

Currently, even though memory is mapped with PROT_NONE, this does not cause it to be excluded from core dumps. This is counter-productive, because in a lot of cases, this memory will go unused (e.g. when the memory subsystem preallocates VA space but hasn't yet mapped physical pages into it).

Use madvise() call with MADV_DONTDUMP parameter to exclude the unmapped memory from being dumped.

Applied, thanks.

Signature · 1 line
David Marchand