mm: process/cgroup ksm support

This adds the general_profit KSM sysfs knob and the process profit metric knobs to ksm_stat.

1) expose general_profit metric

The documentation mentions a general profit metric, however this metric is not calculated. In addition the formula depends on the size of internal structures, which makes it more difficult for an administrator to make the calculation. Adding the metric for a better user experience.

2) document general_profit sysfs knob

3) calculate ksm process profit metric

The ksm documentation mentions the process profit metric and how to calculate it. This adds the calculation of the metric.

4) mm: expose ksm process profit metric in ksm_stat

This exposes the ksm process profit metric in /proc/<pid>/ksm_stat. The documentation mentions the formula for the ksm process profit metric, however it does not calculate it. In addition the formula depends on the size of internal structures. So it makes sense to expose it.

5) document new procfs ksm knobs

Signed-off-by Stefan Roesch <[email protected]>

Reviewed-by Bagas Sanjaya <[email protected]>

Acked-by David Hildenbrand <[email protected]>

Cc David Hildenbrand <[email protected]>

Cc Johannes Weiner <[email protected]>

Cc Michal Hocko <[email protected]>

Cc Rik van Riel <[email protected]>

Signed-off-by Andrew Morton <[email protected]>

---
 Documentation/ABI/testing/sysfs-kernel-mm-ksm |  8 +++++++
 Documentation/admin-guide/mm/ksm.rst          |  5 ++++-
 fs/proc/base.c                                |  3 +++
 include/linux/ksm.h                           |  4 ++++
 mm/ksm.c                                      | 21 +++++++++++++++++++
 5 files changed, 40 insertions(+), 1 deletion(-)

Documentation/ABI/testing/sysfs-kernel-mm-ksm +8 -0

index d244674a9480..6041a025b65a 100644
@@ -51,3 +51,11 @@ Description:	Control merging pages across different NUMA nodes.
 
 		When it is set to 0 only pages from the same node are merged,
 		otherwise pages from all nodes can be merged together (default).
+
+What:		/sys/kernel/mm/ksm/general_profit
+Date:		April 2023
+KernelVersion:  6.4
+Contact:	Linux memory management mailing list <[email protected]>
+Description:	Measure how effective KSM is.
+		general_profit: how effective is KSM. The formula for the
+		calculation is in Documentation/admin-guide/mm/ksm.rst.

Documentation/admin-guide/mm/ksm.rst +0 -0

Quoted 18 lines

This adds the general_profit KSM sysfs knob and the process profit metric knobs to ksm_stat.

1) expose general_profit metric

The documentation mentions a general profit metric, however this metric is not calculated. In addition the formula depends on the size of internal structures, which makes it more difficult for an administrator to make the calculation. Adding the metric for a better user experience.

2) document general_profit sysfs knob

3) calculate ksm process profit metric

The ksm documentation mentions the process profit metric and how to calculate it. This adds the calculation of the metric.

Quoted 8 lines

4) mm: expose ksm process profit metric in ksm_stat

This exposes the ksm process profit metric in /proc/<pid>/ksm_stat. The documentation mentions the formula for the ksm process profit metric, however it does not calculate it. In addition the formula depends on the size of internal structures. So it makes sense to expose it.

Hi, Stefan, I think you should give some credits to me about my contributions on the concept and formula of ksm profit (process wide and system wide), it's kind of idea stealing.

Besides, the idea of Process control KSM was proposed by me last year although you use prctl instead of /proc fs. you even didn't CC my email. I think you should CC my email ([email protected]) as least.

Quoted 35 lines

5) document new procfs ksm knobs

Signed-off-by Stefan Roesch <[email protected]>

Reviewed-by Bagas Sanjaya <[email protected]>

Acked-by David Hildenbrand <[email protected]>

Cc David Hildenbrand <[email protected]>

Cc Johannes Weiner <[email protected]>

Cc Michal Hocko <[email protected]>

Cc Rik van Riel <[email protected]>

Signed-off-by Andrew Morton <[email protected]>

---
 Documentation/ABI/testing/sysfs-kernel-mm-ksm |  8 +++++++
 Documentation/admin-guide/mm/ksm.rst          |  5 ++++-
 fs/proc/base.c                                |  3 +++
 include/linux/ksm.h                           |  4 ++++
 mm/ksm.c                                      | 21 +++++++++++++++++++
 5 files changed, 40 insertions(+), 1 deletion(-)

Documentation/ABI/testing/sysfs-kernel-mm-ksm +8 -0

index d244674a9480..6041a025b65a 100644
@@ -51,3 +51,11 @@ Description:	Control merging pages across different NUMA nodes.
 
 		When it is set to 0 only pages from the same node are merged,
 		otherwise pages from all nodes can be merged together (default).
+
+What:		/sys/kernel/mm/ksm/general_profit
+Date:		April 2023
+KernelVersion:  6.4
+Contact:	Linux memory management mailing list <[email protected]>
+Description:	Measure how effective KSM is.
+		general_profit: how effective is KSM. The formula for the
+		calculation is in Documentation/admin-guide/mm/ksm.rst.

Documentation/admin-guide/mm/ksm.rst +0 -0

Let's unmerge any KSM pages when setting PR_SET_MEMORY_MERGE=0, and clear the VM_MERGEABLE flag from all VMAs -- just like KSM would. Of course, only do that if we previously set PR_SET_MEMORY_MERGE=1.

Signed-off-by David Hildenbrand <[email protected]>

---
 include/linux/ksm.h |  1 +
 kernel/sys.c        |  7 +------
 mm/ksm.c            | 47 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 49 insertions(+), 6 deletions(-)

include/linux/ksm.h +1 -0

index 590934bdddcf..7108bc65dc2a 100644
@@ -21,6 +21,7 @@ int ksm_madvise(struct vm_area_struct *vma, unsigned long start,
 
 void ksm_add_vma(struct vm_area_struct *vma);
 int ksm_enable_merge_any(struct mm_struct *mm);
+int ksm_disable_merge_any(struct mm_struct *mm);
 
 int __ksm_enter(struct mm_struct *mm);
 void __ksm_exit(struct mm_struct *mm);

kernel/sys.c +0 -0

index 72cdb16e2636..3436376667d7 100644
@@ -2698,12 +2698,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
 		if (arg2) {
 			error = ksm_enable_merge_any(me->mm);

mm/ksm.c +30 -0

index a959e8925413..813f7fbc1832 100644
@@ -2520,6 +2520,22 @@ static void __ksm_add_vma(struct vm_area_struct *vma)
 		vm_flags_set(vma, VM_MERGEABLE);
 }
 
+static int __ksm_del_vma(struct vm_area_struct *vma)
+{
+	int err;
+
+	if (!(vma->vm_flags & VM_MERGEABLE))
+		return 0;
+
+	if (vma->anon_vma) {
+		err = unmerge_ksm_pages(vma, vma->vm_start, vma->vm_end);
+		if (err)
+			return err;
+	}
+
+	vm_flags_clear(vma, VM_MERGEABLE);
+	return 0;
+}
 /**
  * ksm_add_vma - Mark vma as mergeable if compatible
  *

@@ -2542,6 +2558,20 @@ static void ksm_add_vmas(struct mm_struct *mm)
 		__ksm_add_vma(vma);
 }
 
+static int ksm_del_vmas(struct mm_struct *mm)
+{
+	struct vm_area_struct *vma;
+	int err;
+
+	VMA_ITERATOR(vmi, mm, 0);
+	for_each_vma(vmi, vma) {
+		err = __ksm_del_vma(vma);
+		if (err)
+			return err;
+	}
+	return 0;
+}
+
 /**
  * ksm_enable_merge_any - Add mm to mm ksm list and enable merging on all
  *                        compatible VMA's

mm/ksm.c +4 -0

+{
+	int err;
+
+	if (!test_bit(MMF_VM_MERGE_ANY, &mm->flags))

mm/ksm.c +3 -0

+	return 0;
+}
+
 int ksm_madvise(struct vm_area_struct *vma, unsigned long start,

unsigned long end, int advice, unsigned long *vm_flags)
{

Quoted 1 line

nit:
can we do:

     if (arg2)
    	error = ksm_enable_merge_any(me->mm);
	else
    	error = ksm_disable_merge_any(me->mm);
	mmap_write_unlock(me->mm);
	break;

Quoted 53 lines

mm/ksm.c +30 -0

index a959e8925413..813f7fbc1832 100644
@@ -2520,6 +2520,22 @@ static void __ksm_add_vma(struct vm_area_struct *vma)
  		vm_flags_set(vma, VM_MERGEABLE);
  }
 
+static int __ksm_del_vma(struct vm_area_struct *vma)
+{
+	int err;
+
+	if (!(vma->vm_flags & VM_MERGEABLE))
+		return 0;
+
+	if (vma->anon_vma) {
+		err = unmerge_ksm_pages(vma, vma->vm_start, vma->vm_end);
+		if (err)
+			return err;
+	}
+
+	vm_flags_clear(vma, VM_MERGEABLE);
+	return 0;
+}
  /**
   * ksm_add_vma - Mark vma as mergeable if compatible
   *

@@ -2542,6 +2558,20 @@ static void ksm_add_vmas(struct mm_struct *mm)
  		__ksm_add_vma(vma);
  }
 
+static int ksm_del_vmas(struct mm_struct *mm)
+{
+	struct vm_area_struct *vma;
+	int err;
+
+	VMA_ITERATOR(vmi, mm, 0);
+	for_each_vma(vmi, vma) {
+		err = __ksm_del_vma(vma);
+		if (err)
+			return err;
+	}
+	return 0;
+}
+
  /**
   * ksm_enable_merge_any - Add mm to mm ksm list and enable merging on all
   *                        compatible VMA's

@@ -2569,6 +2599,23 @@ int ksm_enable_merge_any(struct mm_struct *mm)
  	return 0;
  }
 

mm/ksm.c int ksm_enable_merge_any(struct mm_struct *mm) · line 2603

Quoted 2 lines

mm/ksm.c +1 -0

+int ksm_disable_merge_any(struct mm_struct *mm)
 

I understand we want to keep the name "symmetric" with ksm_enable_merge_any, but it also unmerges the ksm pages. Do we want to reflect that in the function name?

Can we add a comment for the function?

Quoted 5 lines

mm/ksm.c +4 -0

+{
+	int err;
+
+	if (!test_bit(MMF_VM_MERGE_ANY, &mm->flags))

mm/ksm.c int ksm_enable_merge_any(struct mm_struct *mm)

Quoted 10 lines

mm/ksm.c +9 -0

+		return 0;
+
+	err = ksm_del_vmas(mm);
+	if (err) {
+		ksm_add_vmas(mm);
+		return err;
+	}
+
+	clear_bit(MMF_VM_MERGE_ANY, &mm->flags);
 

We only clear the MMF_VM_MERGE_ANY flag if there are no errors. Is this

what we want? This means that if the process creates new memory regions they would still be marked as mergeable.

Quoted 3 lines

I understand we want to keep the name "symmetric" with ksm_enable_merge_any, but it also unmerges the ksm pages. Do we want to reflect that in the function name?

ksm_disable_merge_any_umerge() is suboptimal.

As ksm_disable_merge_any() now reverts what ksm_enable_merge_any() ended up doing, I think it's just fine.

(it would be a different story if we'd be using "set" / "clear" terminology instead of "enable" / "disable").

We can describe that in the comment.

Quoted 2 lines

Can we add a comment for the function?

Can do for symmetry with ksm_enable_merge_any().

Quoted 11 lines

Quoted 3 lines

I understand we want to keep the name "symmetric" with ksm_enable_merge_any, but it also unmerges the ksm pages. Do we want to reflect that in the function name?

ksm_disable_merge_any_umerge() is suboptimal.
As ksm_disable_merge_any() now reverts what ksm_enable_merge_any() ended up doing, I think it's just fine.
(it would be a different story if we'd be using "set" / "clear" terminology instead of "enable" / "disable").
We can describe that in the comment.

Quoted 1 line

Quoted 3 lines

Quoted 1 line

Can we add a comment for the function?

Can do for symmetry with ksm_enable_merge_any().

+/**
+ * ksm_disable_merge_any - Disable merging on all compatible VMA's of the mm,
+ * previously enabled via ksm_enable_merge_any().
+ *
+ * Disabling merging implies unmerging any merged pages, like setting
+ * MADV_UNMERGEABLE would. If unmerging fails, the whole operation fails and
+ * merging on all compatible VMA's remains enabled.
+ *
+ * @mm: Pointer to mm
+ *
+ * Returns 0 on success, otherwise error code
+ */

Let's test whether setting PR_SET_MEMORY_MERGE to 0 after setting it to 1 will unmerge pages, similar to how setting MADV_UNMERGEABLE after setting MADV_MERGEABLE would.

Signed-off-by David Hildenbrand <[email protected]>

---
 .../selftests/mm/ksm_functional_tests.c       | 46 ++++++++++++++++---
 1 file changed, 40 insertions(+), 6 deletions(-)

tools/testing/selftests/mm/ksm_functional_tests.c +39 -6

index 7bc9fc17c9f0..26853badae70 100644
@@ -91,9 +91,10 @@ static int ksm_merge(void)
 	return 0;
 }
 
-static char *mmap_and_merge_range(char val, unsigned long size)
+static char *mmap_and_merge_range(char val, unsigned long size, bool use_prctl)
 {
 	char *map;
+	int ret;
 
 	map = mmap(NULL, size, PROT_READ|PROT_WRITE,
 		   MAP_PRIVATE|MAP_ANON, -1, 0);

@@ -110,7 +111,17 @@ static char *mmap_and_merge_range(char val, unsigned long size)
 
 	/* Make sure each page contains the same values to merge them. */
 	memset(map, val, size);
-	if (madvise(map, size, MADV_MERGEABLE)) {
+
+	if (use_prctl) {
+		ret = prctl(PR_SET_MEMORY_MERGE, 1, 0, 0, 0);
+		if (ret < 0 && errno == EINVAL) {
+			ksft_test_result_skip("PR_SET_MEMORY_MERGE not supported\n");
+			goto unmap;
+		} else if (ret) {
+			ksft_test_result_fail("PR_SET_MEMORY_MERGE=1 failed\n");
+			goto unmap;
+		}
+	} else if (madvise(map, size, MADV_MERGEABLE)) {
 		ksft_test_result_fail("MADV_MERGEABLE failed\n");
 		goto unmap;
 	}

@@ -133,7 +144,7 @@ static void test_unmerge(void)
 
 	ksft_print_msg("[RUN] %s\n", __func__);
 
-	map = mmap_and_merge_range(0xcf, size);
+	map = mmap_and_merge_range(0xcf, size, false);
 	if (map == MAP_FAILED)
 		return;
 

@@ -155,7 +166,7 @@ static void test_unmerge_discarded(void)
 
 	ksft_print_msg("[RUN] %s\n", __func__);
 
-	map = mmap_and_merge_range(0xcf, size);
+	map = mmap_and_merge_range(0xcf, size, false);
 	if (map == MAP_FAILED)
 		return;
 

@@ -187,7 +198,7 @@ static void test_unmerge_uffd_wp(void)
 
 	ksft_print_msg("[RUN] %s\n", __func__);
 
-	map = mmap_and_merge_range(0xcf, size);
+	map = mmap_and_merge_range(0xcf, size, false);
 	if (map == MAP_FAILED)
 		return;
 

@@ -323,9 +334,31 @@ static void test_prctl_fork(void)
 	ksft_test_result_pass("PR_SET_MEMORY_MERGE value is inherited\n");
 }
 
+static void test_prctl_unmerge(void)
+{
+	const unsigned int size = 2 * MiB;
+	char *map;
+
+	ksft_print_msg("[RUN] %s\n", __func__);
+
+	map = mmap_and_merge_range(0xcf, size, true);
+	if (map == MAP_FAILED)
+		return;
+
+	if (prctl(PR_SET_MEMORY_MERGE, 0, 0, 0, 0)) {
+		ksft_test_result_fail("PR_SET_MEMORY_MERGE=0 failed\n");
+		goto unmap;
+	}
+
+	ksft_test_result(!range_maps_duplicates(map, size),
+			 "Pages were unmerged\n");
+unmap:
+	munmap(map, size);
+}
+
 int main(int argc, char **argv)
 {
-	unsigned int tests = 4;
+	unsigned int tests = 5;
 	int err;
 
 #ifdef __NR_userfaultfd

Let's factor out actual disabling of KSM. The existing "mm->def_flags &= ~VM_MERGEABLE;" was essentially a NOP and can be dropped, because def_flags should never include VM_MERGEABLE. Note that we don't currently prevent re-enabling KSM.

This should now be faster in case KSM was never enabled, because we only conditionally iterate all VMAs. Further, it certainly looks cleaner.

Signed-off-by David Hildenbrand <[email protected]>

---
  arch/s390/mm/gmap.c | 20 +-------------------
  include/linux/ksm.h |  6 ++++++
  mm/ksm.c            | 11 +++++++++++
  3 files changed, 18 insertions(+), 19 deletions(-)

arch/s390/mm/gmap.c +0 -1

index 0949811761e6..dfe905c7bd8e 100644
@@ -2585,30 +2585,12 @@ EXPORT_SYMBOL_GPL(s390_enable_sie);
 
  int gmap_mark_unmergeable(void)
  {
-	struct mm_struct *mm = current->mm;

Quoted 21 lines · David Hildenbrand

Let's factor out actual disabling of KSM. The existing "mm->def_flags &= ~VM_MERGEABLE;" was essentially a NOP and can be dropped, because def_flags should never include VM_MERGEABLE. Note that we don't currently prevent re-enabling KSM.

This should now be faster in case KSM was never enabled, because we only conditionally iterate all VMAs. Further, it certainly looks cleaner.

Signed-off-by David Hildenbrand <[email protected]>

---
   arch/s390/mm/gmap.c | 20 +-------------------
   include/linux/ksm.h |  6 ++++++
   mm/ksm.c            | 11 +++++++++++
   3 files changed, 18 insertions(+), 19 deletions(-)

arch/s390/mm/gmap.c +0 -0

index 0949811761e6..dfe905c7bd8e 100644
@@ -2585,30 +2585,12 @@ EXPORT_SYMBOL_GPL(s390_enable_sie);
 

arch/s390/mm/gmap.c EXPORT_SYMBOL_GPL(s390_enable_sie); · line 2592

Quoted 13 lines

arch/s390/mm/gmap.c +0 -6

   int gmap_mark_unmergeable(void)
   {
-	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma;
-	unsigned long vm_flags;
-	int ret;
-	VMA_ITERATOR(vmi, mm, 0);
-
   	/*
   	 * Make sure to disable KSM (if enabled for the whole process or
   	 * individual VMAs). Note that nothing currently hinders user space
   	 * from re-enabling it.
   	 */

Is that still true?

My KSM knowledge is nearly zero but from what I can see the patch looks ok to me:

Acked-by Janosch Frank <[email protected]>

Let's factor out actual disabling of KSM. The existing "mm->def_flags &= ~VM_MERGEABLE;" was essentially a NOP and can be dropped, because def_flags should never include VM_MERGEABLE. Note that we don't currently prevent re-enabling KSM.

This should now be faster in case KSM was never enabled, because we only conditionally iterate all VMAs. Further, it certainly looks cleaner.

Signed-off-by David Hildenbrand <[email protected]>

---
 arch/s390/mm/gmap.c | 20 +-------------------
 include/linux/ksm.h |  6 ++++++
 mm/ksm.c            | 11 +++++++++++
 3 files changed, 18 insertions(+), 19 deletions(-)

arch/s390/mm/gmap.c +0 -9

index 0949811761e6..dfe905c7bd8e 100644
@@ -2585,30 +2585,12 @@ EXPORT_SYMBOL_GPL(s390_enable_sie);
 
 int gmap_mark_unmergeable(void)
 {
-	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma;
-	unsigned long vm_flags;
-	int ret;
-	VMA_ITERATOR(vmi, mm, 0);
-
 	/*
 	 * Make sure to disable KSM (if enabled for the whole process or
 	 * individual VMAs). Note that nothing currently hinders user space
 	 * from re-enabling it.
 	 */
-	clear_bit(MMF_VM_MERGE_ANY, &mm->flags);
-
-	for_each_vma(vmi, vma) {

arch/s390/mm/gmap.c +1 -1

-	return 0;
+	return ksm_disable(current->mm);
 }
 EXPORT_SYMBOL_GPL(gmap_mark_unmergeable);

include/linux/ksm.h +6 -0

index 7108bc65dc2a..b3d8b7849e18 100644
@@ -22,6 +22,7 @@ int ksm_madvise(struct vm_area_struct *vma, unsigned long start,
 void ksm_add_vma(struct vm_area_struct *vma);
 int ksm_enable_merge_any(struct mm_struct *mm);
 int ksm_disable_merge_any(struct mm_struct *mm);
+int ksm_disable(struct mm_struct *mm);
 
 int __ksm_enter(struct mm_struct *mm);
 void __ksm_exit(struct mm_struct *mm);

@@ -75,6 +76,11 @@ static inline void ksm_add_vma(struct vm_area_struct *vma)
 {
 }
 
+static inline int ksm_disable(struct mm_struct *mm)
+{
+	return 0;
+}
+
 static inline int ksm_fork(struct mm_struct *mm, struct mm_struct *oldmm)
 {
 	return 0;

mm/ksm.c +11 -0

index 813f7fbc1832..208311cbb019 100644
@@ -2616,6 +2616,17 @@ int ksm_disable_merge_any(struct mm_struct *mm)
 	return 0;
 }
 
+int ksm_disable(struct mm_struct *mm)
+{
+	mmap_assert_write_locked(mm);
+
+	if (!test_bit(MMF_VM_MERGEABLE, &mm->flags))
+		return 0;
+	if (test_bit(MMF_VM_MERGE_ANY, &mm->flags))
+		return ksm_disable_merge_any(mm);
+	return ksm_del_vmas(mm);
+}
+
 int ksm_madvise(struct vm_area_struct *vma, unsigned long start,
 		unsigned long end, int advice, unsigned long *vm_flags)
 {

Quoted 24 lines

arch/s390/mm/gmap.c +0 -11

index 0949811761e6..dfe905c7bd8e 100644
@@ -2585,30 +2585,12 @@ EXPORT_SYMBOL_GPL(s390_enable_sie);
 
  int gmap_mark_unmergeable(void)
  {
-	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma;
-	unsigned long vm_flags;
-	int ret;
-	VMA_ITERATOR(vmi, mm, 0);
-
  	/*
  	 * Make sure to disable KSM (if enabled for the whole process or
  	 * individual VMAs). Note that nothing currently hinders user space
  	 * from re-enabling it.
  	 */
-	clear_bit(MMF_VM_MERGE_ANY, &mm->flags);
-
-	for_each_vma(vmi, vma) {
-		/* Copy vm_flags to avoid partial modifications in ksm_madvise */
-		vm_flags = vma->vm_flags;

arch/s390/mm/gmap.c EXPORT_SYMBOL_GPL(s390_enable_sie); · line 2596

Quoted 8 lines

arch/s390/mm/gmap.c +0 -7

-		ret = ksm_madvise(vma, vma->vm_start, vma->vm_end,
-				  MADV_UNMERGEABLE, &vm_flags);
-		if (ret)
-			return ret;
-		vm_flags_reset(vma, vm_flags);
-	}
-	mm->def_flags &= ~VM_MERGEABLE;
 

This clears the def_flags struct member, however, in ksm_disable() we clear the __flags struct member. Is this a problem?

[...]

Quoted 24 lines

Quoted 24 lines

arch/s390/mm/gmap.c +0 -11

index 0949811761e6..dfe905c7bd8e 100644
@@ -2585,30 +2585,12 @@ EXPORT_SYMBOL_GPL(s390_enable_sie);
 
  int gmap_mark_unmergeable(void)
  {
-	struct mm_struct *mm = current->mm;
-	struct vm_area_struct *vma;
-	unsigned long vm_flags;
-	int ret;
-	VMA_ITERATOR(vmi, mm, 0);
-
  	/*
  	 * Make sure to disable KSM (if enabled for the whole process or
  	 * individual VMAs). Note that nothing currently hinders user space
  	 * from re-enabling it.
  	 */
-	clear_bit(MMF_VM_MERGE_ANY, &mm->flags);
-
-	for_each_vma(vmi, vma) {
-		/* Copy vm_flags to avoid partial modifications in ksm_madvise */
-		vm_flags = vma->vm_flags;

Quoted 9 lines

arch/s390/mm/gmap.c EXPORT_SYMBOL_GPL(s390_enable_sie); · line 2596

Quoted 8 lines

arch/s390/mm/gmap.c +0 -7

-		ret = ksm_madvise(vma, vma->vm_start, vma->vm_end,
-				  MADV_UNMERGEABLE, &vm_flags);
-		if (ret)
-			return ret;
-		vm_flags_reset(vma, vm_flags);
-	}
-	mm->def_flags &= ~VM_MERGEABLE;
 

Hi Stefan,

Quoted 2 lines

This clears the def_flags struct member, however, in ksm_disable() we clear the __flags struct member. Is this a problem?

The patch description contains a comment regarding def_flags: "The existing "mm->def_flags &= ~VM_MERGEABLE;" was essentially a NOP and can be dropped, because def_flags should never include VM_MERGEABLE."

We keep clearing the MADV_UNMERGEABLE flag from MADV_UNMERGEABLE. In the old code, ksm_madvise() would have cleared it from local vm_flags and vm_flags_reset() would have modified vma->vm_flags. Now we clear it directly via vm_flags_clear(vma, VM_MERGEABLE);

Long story short, the mm->def_flags code as wrong and most probably copied from thp_split_mm() where we do:

	mm->def_flags |= VM_NOHUGEPAGE;

Which makes more sense.

Thanks!