Skip to contentSkip to conversation

+ mm-reclaim-madv_free-pages.patch added to -mm tree

PATCH [email protected] 5 participants 10 messages Mar 1, 2017 – Mar 7, 2017

Subsystems (2)
lore
Share & tools
lore

[email protected]

author maintainer tree notice
#0 lore raw

The patch titled
Subject: mm: reclaim MADV_FREE pages
has been added to the -mm tree. Its filename is
mm-reclaim-madv_free-pages.patch

This patch should soon appear at
http://ozlabs.org/~akpm/mmots/broken-out/mm-reclaim-madv_free-pages.patch
and later at
http://ozlabs.org/~akpm/mmotm/broken-out/mm-reclaim-madv_free-pages.patch

Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/SubmitChecklist when testing your code ***

The -mm tree is included into linux-next and is updated there every 3-4 working days

------------------------------------------------------
From: Shaohua Li <[email protected]>
Subject: mm: reclaim MADV_FREE pages

When memory pressure is high, we free MADV_FREE pages. If the pages are not dirty in pte, the pages could be freed immediately. Otherwise we can't reclaim them. We put the pages back to anonumous LRU list (by setting SwapBacked flag) and the pages will be reclaimed in normal swapout way.

We use normal page reclaim policy. Since MADV_FREE pages are put into inactive file list, such pages and inactive file pages are reclaimed according to their age. This is expected, because we don't want to reclaim too many MADV_FREE pages before used once pages.

Based on Minchan's original patch

---

 include/linux/rmap.h |    2 +-
 mm/huge_memory.c     |    2 ++
 mm/madvise.c         |    1 +
 mm/rmap.c            |   40 +++++++++++++++++-----------------------
 mm/vmscan.c          |   34 ++++++++++++++++++++++------------
 5 files changed, 43 insertions(+), 36 deletions(-)
include/linux/rmap.h renamed from include/linux/rmap.h~mm-reclaim-madv_free-pages +1 -1
diff -puN include/linux/rmap.h~mm-reclaim-madv_free-pages include/linux/rmap.h
@@ -298,6 +298,6 @@ static inline int page_mkclean(struct pa
 #define SWAP_AGAIN	1
 #define SWAP_FAIL	2
 #define SWAP_MLOCK	3
-#define SWAP_LZFREE	4
+#define SWAP_DIRTY	4
 
 #endif	/* _LINUX_RMAP_H */
mm/huge_memory.c renamed from mm/huge_memory.c~mm-reclaim-madv_free-pages +2 -0
diff -puN mm/huge_memory.c~mm-reclaim-madv_free-pages mm/huge_memory.c
@@ -1571,6 +1571,8 @@ bool madvise_free_huge_pmd(struct mmu_ga
 		set_pmd_at(mm, addr, pmd, orig_pmd);
 		tlb_remove_pmd_tlb_entry(tlb, pmd, addr);
 	}
+
+	mark_page_lazyfree(page);
 	ret = true;
 out:
 	spin_unlock(ptl);
mm/madvise.c renamed from mm/madvise.c~mm-reclaim-madv_free-pages +1 -0
diff -puN mm/madvise.c~mm-reclaim-madv_free-pages mm/madvise.c
@@ -413,6 +413,7 @@ static int madvise_free_pte_range(pmd_t
 			set_pte_at(mm, addr, pte, ptent);
 			tlb_remove_tlb_entry(tlb, pte, addr);
 		}
+		mark_page_lazyfree(page);
 	}
 out:
 	if (nr_swap) {
mm/rmap.c renamed from mm/rmap.c~mm-reclaim-madv_free-pages +17 -23
diff -puN mm/rmap.c~mm-reclaim-madv_free-pages mm/rmap.c
@@ -1281,11 +1281,6 @@ void page_remove_rmap(struct page *page,
 	 */
 }
 
-struct rmap_private {
-	enum ttu_flags flags;
-	int lazyfreed;
-};
-
 /*
  * @arg: enum ttu_flags will be passed to this argument
  */
@@ -1301,8 +1296,7 @@ static int try_to_unmap_one(struct page
 	pte_t pteval;
 	struct page *subpage;
 	int ret = SWAP_AGAIN;
-	struct rmap_private *rp = arg;
-	enum ttu_flags flags = rp->flags;
+	enum ttu_flags flags = (enum ttu_flags)arg;
 
 	/* munlock has nothing to gain from examining un-locked vmas */
 	if ((flags & TTU_MUNLOCK) && !(vma->vm_flags & VM_LOCKED))
@@ -1419,11 +1413,21 @@ static int try_to_unmap_one(struct page
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			if (!PageDirty(page)) {
+			/*
+			 * swapin page could be clean, it has data stored in
+			 * swap. We can't silently discard it without setting
+			 * swap entry in the page table.
+			 */
+			if (!PageDirty(page) && !PageSwapCache(page)) {
 				/* It's a freeable page by MADV_FREE */
 				dec_mm_counter(mm, MM_ANONPAGES);
-				rp->lazyfreed++;
 				goto discard;
+			} else if (!PageSwapBacked(page)) {
+				/* dirty MADV_FREE page */
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = SWAP_DIRTY;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
 			}
 
 			if (swap_duplicate(entry) < 0) {
@@ -1491,18 +1495,15 @@ static int page_mapcount_is_zero(struct
  * SWAP_AGAIN	- we missed a mapping, try again later
  * SWAP_FAIL	- the page is unswappable
  * SWAP_MLOCK	- page is mlocked.
+ * SWAP_DIRTY	- page is dirty MADV_FREE page
  */
 int try_to_unmap(struct page *page, enum ttu_flags flags)
 {
 	int ret;
-	struct rmap_private rp = {
-		.flags = flags,
-		.lazyfreed = 0,
-	};
 
 	struct rmap_walk_control rwc = {
 		.rmap_one = try_to_unmap_one,
-		.arg = &rp,
+		.arg = (void *)flags,
 		.done = page_mapcount_is_zero,
 		.anon_lock = page_lock_anon_vma_read,
 	};
@@ -1523,11 +1524,8 @@ int try_to_unmap(struct page *page, enum
 	else
 		ret = rmap_walk(page, &rwc);
 
-	if (ret != SWAP_MLOCK && !page_mapcount(page)) {
+	if (ret != SWAP_MLOCK && !page_mapcount(page))
 		ret = SWAP_SUCCESS;
-		if (rp.lazyfreed && !PageDirty(page))
-			ret = SWAP_LZFREE;
-	}
 	return ret;
 }
 
@@ -1554,14 +1552,10 @@ static int page_not_mapped(struct page *
 int try_to_munlock(struct page *page)
 {
 	int ret;
-	struct rmap_private rp = {
-		.flags = TTU_MUNLOCK,
-		.lazyfreed = 0,
-	};
 
 	struct rmap_walk_control rwc = {
 		.rmap_one = try_to_unmap_one,
-		.arg = &rp,
+		.arg = (void *)TTU_MUNLOCK,
 		.done = page_not_mapped,
 		.anon_lock = page_lock_anon_vma_read,
 
mm/vmscan.c renamed from mm/vmscan.c~mm-reclaim-madv_free-pages +22 -11
diff -puN mm/vmscan.c~mm-reclaim-madv_free-pages mm/vmscan.c
@@ -905,7 +905,8 @@ static void page_check_dirty_writeback(s
 	 * Anonymous pages are not handled by flushers and must be written
 	 * from reclaim context. Do not stall reclaim based on them
 	 */
-	if (!page_is_file_cache(page)) {
+	if (!page_is_file_cache(page) ||
+	    (PageAnon(page) && !PageSwapBacked(page))) {
 		*dirty = false;
 		*writeback = false;
 		return;
@@ -986,7 +987,8 @@ static unsigned long shrink_page_list(st
 			goto keep_locked;
 
 		/* Double the slab pressure for mapped and swapcache pages */
-		if (page_mapped(page) || PageSwapCache(page))
+		if ((page_mapped(page) || PageSwapCache(page)) &&
+		    !(PageAnon(page) && !PageSwapBacked(page)))
 			sc->nr_scanned++;
 
 		may_enter_fs = (sc->gfp_mask & __GFP_FS) ||
@@ -1112,8 +1114,10 @@ static unsigned long shrink_page_list(st
 		/*
 		 * Anonymous process memory has backing store?
 		 * Try to allocate it some swap space here.
+		 * Lazyfree page could be freed directly
 		 */
-		if (PageAnon(page) && !PageSwapCache(page)) {
+		if (PageAnon(page) && PageSwapBacked(page) &&
+		    !PageSwapCache(page)) {
 			if (!(sc->gfp_mask & __GFP_IO))
 				goto keep_locked;
 			if (!add_to_swap(page, page_list))
@@ -1134,9 +1138,12 @@ static unsigned long shrink_page_list(st
 		 * The page is mapped into the page tables of one or more
 		 * processes. Try to unmap it here.
 		 */
-		if (page_mapped(page) && mapping) {
+		if (page_mapped(page)) {
 			switch (ret = try_to_unmap(page,
 				ttu_flags | TTU_BATCH_FLUSH)) {
+			case SWAP_DIRTY:
+				SetPageSwapBacked(page);
+				/* fall through */
 			case SWAP_FAIL:
 				nr_unmap_fail++;
 				goto activate_locked;
@@ -1144,8 +1151,6 @@ static unsigned long shrink_page_list(st
 				goto keep_locked;
 			case SWAP_MLOCK:
 				goto cull_mlocked;
-			case SWAP_LZFREE:
-				goto lazyfree;
 			case SWAP_SUCCESS:
 				; /* try to free the page below */
 			}
@@ -1257,10 +1262,18 @@ static unsigned long shrink_page_list(st
 			}
 		}
 
-lazyfree:
-		if (!mapping || !__remove_mapping(mapping, page, true))
-			goto keep_locked;
+		if (PageAnon(page) && !PageSwapBacked(page)) {
+			/* follow __remove_mapping for reference */
+			if (!page_ref_freeze(page, 1))
+				goto keep_locked;
+			if (PageDirty(page)) {
+				page_ref_unfreeze(page, 1);
+				goto keep_locked;
+			}
 
+			count_vm_event(PGLAZYFREED);
+		} else if (!mapping || !__remove_mapping(mapping, page, true))
+			goto keep_locked;
 		/*
 		 * At this point, we have no other references and there is
 		 * no way to pick any more up (removed from LRU, removed
@@ -1270,9 +1283,6 @@ lazyfree:
 		 */
 		__ClearPageLocked(page);
 free_it:
-		if (ret == SWAP_LZFREE)
-			count_vm_event(PGLAZYFREED);
#1 lore raw

Hi,

Quoted 50 lines · On Tue, Feb 28, 2017 at 04:32:38PM -0800, [email protected] wrote:

The patch titled
Subject: mm: reclaim MADV_FREE pages
has been added to the -mm tree. Its filename is
mm-reclaim-madv_free-pages.patch

This patch should soon appear at
http://ozlabs.org/~akpm/mmots/broken-out/mm-reclaim-madv_free-pages.patch
and later at
http://ozlabs.org/~akpm/mmotm/broken-out/mm-reclaim-madv_free-pages.patch

Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/SubmitChecklist when testing your code ***

The -mm tree is included into linux-next and is updated there every 3-4 working days

------------------------------------------------------
From: Shaohua Li <[email protected]>
Subject: mm: reclaim MADV_FREE pages

When memory pressure is high, we free MADV_FREE pages. If the pages are not dirty in pte, the pages could be freed immediately. Otherwise we can't reclaim them. We put the pages back to anonumous LRU list (by setting SwapBacked flag) and the pages will be reclaimed in normal swapout way.

We use normal page reclaim policy. Since MADV_FREE pages are put into inactive file list, such pages and inactive file pages are reclaimed according to their age. This is expected, because we don't want to reclaim too many MADV_FREE pages before used once pages.

Based on Minchan's original patch

---

< snip >

Quoted 12 lines
(quoted diff) +6 -1
@@ -1419,11 +1413,21 @@ static int try_to_unmap_one(struct page
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			if (!PageDirty(page)) {
+			/*
+			 * swapin page could be clean, it has data stored in
+			 * swap. We can't silently discard it without setting
+			 * swap entry in the page table.
+			 */
+			if (!PageDirty(page) && !PageSwapCache(page)) {
 				/* It's a freeable page by MADV_FREE */

Review static int try_to_unmap_one(struct page · line 1431

Quoted 10 lines
(quoted diff) +6 -1
 				dec_mm_counter(mm, MM_ANONPAGES);
-				rp->lazyfreed++;
 				goto discard;
+			} else if (!PageSwapBacked(page)) {
+				/* dirty MADV_FREE page */
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = SWAP_DIRTY;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
 			}

There is no point to make this logic complicated with clean swapin-page.

Andrew,
Could you fold below patch into the mm-reclaim-madv_free-pages.patch if others are not against?

Thanks.

Quoted 1 line

From 0c28f6560fbc4e65da4f4a8cc4664ab9f7b11cf3 Mon Sep 17 00:00:00 2001

From: Minchan Kim <[email protected]>
Date: Fri, 3 Mar 2017 11:42:52 +0900
Subject: [PATCH] mm: clean up lazyfree page handling

We can make it simple to understand without need to be aware of clean-swapin page.
This patch just clean up lazyfree page handling in try_to_unmap_one.

---
 mm/rmap.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)
mm/rmap.c +11 -11
index bb45712..f7eab40 100644
@@ -1413,17 +1413,17 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			/*
-			 * swapin page could be clean, it has data stored in
-			 * swap. We can't silently discard it without setting
-			 * swap entry in the page table.
-			 */
-			if (!PageDirty(page) && !PageSwapCache(page)) {
-				/* It's a freeable page by MADV_FREE */
-				dec_mm_counter(mm, MM_ANONPAGES);
-				goto discard;
-			} else if (!PageSwapBacked(page)) {
-				/* dirty MADV_FREE page */
+			/* MADV_FREE page check */
+			if (!PageSwapBacked(page)) {
+				if (!PageDirty(page)) {
+					dec_mm_counter(mm, MM_ANONPAGES);
+					goto discard;
+				}
+
+				/*
+				 * If the page was redirtied, it cannot be
+				 * discarded. Remap the page to page table.
+				 */
 				set_pte_at(mm, address, pvmw.pte, pteval);
 				ret = SWAP_DIRTY;
 				page_vma_mapped_walk_done(&pvmw);
Signature · 1 line
2.7.4
#2 lore raw
Quoted 90 lines · Minchan Kim
Quoted 50 lines · On Tue, Feb 28, 2017 at 04:32:38PM -0800, [email protected] wrote:

The patch titled
Subject: mm: reclaim MADV_FREE pages
has been added to the -mm tree. Its filename is
mm-reclaim-madv_free-pages.patch

This patch should soon appear at
http://ozlabs.org/~akpm/mmots/broken-out/mm-reclaim-madv_free-pages.patch
and later at
http://ozlabs.org/~akpm/mmotm/broken-out/mm-reclaim-madv_free-pages.patch

Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/SubmitChecklist when testing your code ***

The -mm tree is included into linux-next and is updated there every 3-4 working days

------------------------------------------------------
From: Shaohua Li <[email protected]>
Subject: mm: reclaim MADV_FREE pages

When memory pressure is high, we free MADV_FREE pages. If the pages are not dirty in pte, the pages could be freed immediately. Otherwise we can't reclaim them. We put the pages back to anonumous LRU list (by setting SwapBacked flag) and the pages will be reclaimed in normal swapout way.

We use normal page reclaim policy. Since MADV_FREE pages are put into inactive file list, such pages and inactive file pages are reclaimed according to their age. This is expected, because we don't want to reclaim too many MADV_FREE pages before used once pages.

Based on Minchan's original patch

---

< snip >

Quoted 12 lines
(quoted diff) +6 -1
@@ -1419,11 +1413,21 @@ static int try_to_unmap_one(struct page
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			if (!PageDirty(page)) {
+			/*
+			 * swapin page could be clean, it has data stored in
+			 * swap. We can't silently discard it without setting
+			 * swap entry in the page table.
+			 */
+			if (!PageDirty(page) && !PageSwapCache(page)) {
 				/* It's a freeable page by MADV_FREE */

Review static int try_to_unmap_one(struct page · line 1431

Quoted 10 lines
(quoted diff) +6 -1
 				dec_mm_counter(mm, MM_ANONPAGES);
-				rp->lazyfreed++;
 				goto discard;
+			} else if (!PageSwapBacked(page)) {
+				/* dirty MADV_FREE page */
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = SWAP_DIRTY;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
 			}

There is no point to make this logic complicated with clean swapin-page.

Andrew,
Could you fold below patch into the mm-reclaim-madv_free-pages.patch if others are not against?

Thanks.

From 0c28f6560fbc4e65da4f4a8cc4664ab9f7b11cf3 Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Fri, 3 Mar 2017 11:42:52 +0900
Subject: [PATCH] mm: clean up lazyfree page handling

Quoted 5 lines

We can make it simple to understand without need to be aware of clean-swapin page.
This patch just clean up lazyfree page handling in try_to_unmap_one.

Agreed, this is a litle easier to follow.

mm/rmap.c static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1414

Quoted 11 lines
---
 mm/rmap.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)
mm/rmap.c +0 -0
index bb45712..f7eab40 100644
@@ -1413,17 +1413,17 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);

Since you're removing the PageSwapCache() check and we're now assuming that !swapbacked is not in the swapcache, can you modify this to check PageSwapBacked(page) != PageSwapCache(page)?

Better yet, change it into a warning and SWAP_FAIL.

#3 lore raw
Quoted 95 lines · Johannes Weiner
Quoted 94 lines · Minchan Kim
Quoted 50 lines · On Tue, Feb 28, 2017 at 04:32:38PM -0800, [email protected] wrote:

The patch titled
Subject: mm: reclaim MADV_FREE pages
has been added to the -mm tree. Its filename is
mm-reclaim-madv_free-pages.patch

This patch should soon appear at
http://ozlabs.org/~akpm/mmots/broken-out/mm-reclaim-madv_free-pages.patch
and later at
http://ozlabs.org/~akpm/mmotm/broken-out/mm-reclaim-madv_free-pages.patch

Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/SubmitChecklist when testing your code ***

The -mm tree is included into linux-next and is updated there every 3-4 working days

------------------------------------------------------
From: Shaohua Li <[email protected]>
Subject: mm: reclaim MADV_FREE pages

When memory pressure is high, we free MADV_FREE pages. If the pages are not dirty in pte, the pages could be freed immediately. Otherwise we can't reclaim them. We put the pages back to anonumous LRU list (by setting SwapBacked flag) and the pages will be reclaimed in normal swapout way.

We use normal page reclaim policy. Since MADV_FREE pages are put into inactive file list, such pages and inactive file pages are reclaimed according to their age. This is expected, because we don't want to reclaim too many MADV_FREE pages before used once pages.

Based on Minchan's original patch

---

< snip >

Quoted 12 lines
(quoted diff) +6 -1
@@ -1419,11 +1413,21 @@ static int try_to_unmap_one(struct page
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			if (!PageDirty(page)) {
+			/*
+			 * swapin page could be clean, it has data stored in
+			 * swap. We can't silently discard it without setting
+			 * swap entry in the page table.
+			 */
+			if (!PageDirty(page) && !PageSwapCache(page)) {
 				/* It's a freeable page by MADV_FREE */

Review static int try_to_unmap_one(struct page · line 1431

Quoted 10 lines
(quoted diff) +6 -1
 				dec_mm_counter(mm, MM_ANONPAGES);
-				rp->lazyfreed++;
 				goto discard;
+			} else if (!PageSwapBacked(page)) {
+				/* dirty MADV_FREE page */
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = SWAP_DIRTY;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
 			}

There is no point to make this logic complicated with clean swapin-page.

Andrew,
Could you fold below patch into the mm-reclaim-madv_free-pages.patch if others are not against?

Thanks.

From 0c28f6560fbc4e65da4f4a8cc4664ab9f7b11cf3 Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Fri, 3 Mar 2017 11:42:52 +0900
Subject: [PATCH] mm: clean up lazyfree page handling

We can make it simple to understand without need to be aware of clean-swapin page.
This patch just clean up lazyfree page handling in try_to_unmap_one.

Quoted 5 lines
Quoted 1 line

Agreed, this is a litle easier to follow.

Thanks, Johannes.

Quoted 17 lines

mm/rmap.c static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1414

Quoted 12 lines
---
 mm/rmap.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)
mm/rmap.c +0 -0
index bb45712..f7eab40 100644
@@ -1413,17 +1413,17 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);

Since you're removing the PageSwapCache() check and we're now assuming that !swapbacked is not in the swapcache, can you modify this to check PageSwapBacked(page) != PageSwapCache(page)?

Quoted 1 line

Better yet, change it into a warning and SWAP_FAIL.

Maybe, what you wanted is

!!PageSwapBacked(page) != !!PageSwapCache(page)

Personally, I prefer && style rather than equation expression in this case.

How about this?
If others are not against, I will resend it to Andrew with Acked|Reviewed-by all I got until now.

Thanks.

commit 118cfee42600

Author: Minchan Kim <[email protected]>
Date:   Sat Mar 4 01:01:38 2017 +0000

mm: clean up lazyfree page handling

We can make it simple to understand without need to be aware of clean-swapin page.
This patch just clean up lazyfree page handling in try_to_unmap_one.

mm/rmap.c +17 -13
index 3d86036d96ec..1377f7b0361e 100644
@@ -1413,20 +1413,24 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			 * Store the swap location in the pte.
 			 * See handle_pte_fault() ...
 			 */
-			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
-				page);
+			if (VM_WARN_ON_ONCE(PageSwapBacked(page) &&
+						!PageSwapCache(page))) {
+				ret = SWAP_FAIL;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+			}
 
-			/*
-			 * swapin page could be clean, it has data stored in
-			 * swap. We can't silently discard it without setting
-			 * swap entry in the page table.
-			 */
-			if (!PageDirty(page) && !PageSwapCache(page)) {
-				/* It's a freeable page by MADV_FREE */
-				dec_mm_counter(mm, MM_ANONPAGES);
-				goto discard;
-			} else if (!PageSwapBacked(page)) {
-				/* dirty MADV_FREE page */
+			/* MADV_FREE page check */
+			if (!PageSwapBacked(page)) {
+				if (!PageDirty(page)) {
+					dec_mm_counter(mm, MM_ANONPAGES);
+					goto discard;
+				}
+
+				/*
+				 * If the page was redirtied, it cannot be
+				 * discarded. Remap the page to page table.
+				 */
 				set_pte_at(mm, address, pvmw.pte, pteval);
 				ret = SWAP_DIRTY;
 				page_vma_mapped_walk_done(&pvmw);
#4 lore raw
Quoted 121 lines · Minchan Kim
Quoted 95 lines · Johannes Weiner
Quoted 94 lines · Minchan Kim
Quoted 50 lines · On Tue, Feb 28, 2017 at 04:32:38PM -0800, [email protected] wrote:

The patch titled
Subject: mm: reclaim MADV_FREE pages
has been added to the -mm tree. Its filename is
mm-reclaim-madv_free-pages.patch

This patch should soon appear at
http://ozlabs.org/~akpm/mmots/broken-out/mm-reclaim-madv_free-pages.patch
and later at
http://ozlabs.org/~akpm/mmotm/broken-out/mm-reclaim-madv_free-pages.patch

Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/SubmitChecklist when testing your code ***

The -mm tree is included into linux-next and is updated there every 3-4 working days

------------------------------------------------------
From: Shaohua Li <[email protected]>
Subject: mm: reclaim MADV_FREE pages

When memory pressure is high, we free MADV_FREE pages. If the pages are not dirty in pte, the pages could be freed immediately. Otherwise we can't reclaim them. We put the pages back to anonumous LRU list (by setting SwapBacked flag) and the pages will be reclaimed in normal swapout way.

We use normal page reclaim policy. Since MADV_FREE pages are put into inactive file list, such pages and inactive file pages are reclaimed according to their age. This is expected, because we don't want to reclaim too many MADV_FREE pages before used once pages.

Based on Minchan's original patch

---

< snip >

Quoted 12 lines
(quoted diff) +6 -1
@@ -1419,11 +1413,21 @@ static int try_to_unmap_one(struct page
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			if (!PageDirty(page)) {
+			/*
+			 * swapin page could be clean, it has data stored in
+			 * swap. We can't silently discard it without setting
+			 * swap entry in the page table.
+			 */
+			if (!PageDirty(page) && !PageSwapCache(page)) {
 				/* It's a freeable page by MADV_FREE */

Review static int try_to_unmap_one(struct page · line 1431

Quoted 10 lines
(quoted diff) +6 -1
 				dec_mm_counter(mm, MM_ANONPAGES);
-				rp->lazyfreed++;
 				goto discard;
+			} else if (!PageSwapBacked(page)) {
+				/* dirty MADV_FREE page */
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = SWAP_DIRTY;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
 			}

There is no point to make this logic complicated with clean swapin-page.

Andrew,
Could you fold below patch into the mm-reclaim-madv_free-pages.patch if others are not against?

Thanks.

From 0c28f6560fbc4e65da4f4a8cc4664ab9f7b11cf3 Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Fri, 3 Mar 2017 11:42:52 +0900
Subject: [PATCH] mm: clean up lazyfree page handling

We can make it simple to understand without need to be aware of clean-swapin page.
This patch just clean up lazyfree page handling in try_to_unmap_one.

Quoted 5 lines
Quoted 1 line

Agreed, this is a litle easier to follow.

Thanks, Johannes.

Quoted 17 lines

mm/rmap.c static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1414

Quoted 12 lines
---
 mm/rmap.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)
mm/rmap.c +0 -0
index bb45712..f7eab40 100644
@@ -1413,17 +1413,17 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);

Since you're removing the PageSwapCache() check and we're now assuming that !swapbacked is not in the swapcache, can you modify this to check PageSwapBacked(page) != PageSwapCache(page)?

Quoted 5 lines
Quoted 1 line

Better yet, change it into a warning and SWAP_FAIL.

Maybe, what you wanted is

!!PageSwapBacked(page) != !!PageSwapCache(page)

Those testers return 0 or 1 ints, on x86 even bool.

mm/rmap.c static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1418

Quoted 12 lines

Personally, I prefer && style rather than equation expression in this case.

mm/rmap.c +3 -2
@@ -1413,20 +1413,24 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			 * Store the swap location in the pte.
 			 * See handle_pte_fault() ...
 			 */
-			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
-				page);
+			if (VM_WARN_ON_ONCE(PageSwapBacked(page) &&
+						!PageSwapCache(page))) {
+				ret = SWAP_FAIL;

But you're not adding the !swapbacked && swapcache case?

Quoted 3 lines
mm/rmap.c +3 -0
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+			}

[...]

Quoted 7 lines
mm/rmap.c +0 -7
-			/*
-			 * swapin page could be clean, it has data stored in
-			 * swap. We can't silently discard it without setting
-			 * swap entry in the page table.
-			 */
-			if (!PageDirty(page) && !PageSwapCache(page)) {
-				/* It's a freeable page by MADV_FREE */

mm/rmap.c static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1428

Quoted 10 lines
mm/rmap.c +6 -4
-				dec_mm_counter(mm, MM_ANONPAGES);
-				goto discard;
-			} else if (!PageSwapBacked(page)) {
-				/* dirty MADV_FREE page */
+			/* MADV_FREE page check */
+			if (!PageSwapBacked(page)) {
+				if (!PageDirty(page)) {
+					dec_mm_counter(mm, MM_ANONPAGES);
+					goto discard;
+				}

Andrew already has this, you might want to send the warning changes as a separate patch on top of this one.

#5 lore raw
Quoted 122 lines · Johannes Weiner
Quoted 121 lines · Minchan Kim
Quoted 95 lines · Johannes Weiner
Quoted 94 lines · Minchan Kim
Quoted 50 lines · On Tue, Feb 28, 2017 at 04:32:38PM -0800, [email protected] wrote:

The patch titled
Subject: mm: reclaim MADV_FREE pages
has been added to the -mm tree. Its filename is
mm-reclaim-madv_free-pages.patch

This patch should soon appear at
http://ozlabs.org/~akpm/mmots/broken-out/mm-reclaim-madv_free-pages.patch
and later at
http://ozlabs.org/~akpm/mmotm/broken-out/mm-reclaim-madv_free-pages.patch

Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/SubmitChecklist when testing your code ***

The -mm tree is included into linux-next and is updated there every 3-4 working days

------------------------------------------------------
From: Shaohua Li <[email protected]>
Subject: mm: reclaim MADV_FREE pages

When memory pressure is high, we free MADV_FREE pages. If the pages are not dirty in pte, the pages could be freed immediately. Otherwise we can't reclaim them. We put the pages back to anonumous LRU list (by setting SwapBacked flag) and the pages will be reclaimed in normal swapout way.

We use normal page reclaim policy. Since MADV_FREE pages are put into inactive file list, such pages and inactive file pages are reclaimed according to their age. This is expected, because we don't want to reclaim too many MADV_FREE pages before used once pages.

Based on Minchan's original patch

---

< snip >

Quoted 12 lines
(quoted diff) +6 -1
@@ -1419,11 +1413,21 @@ static int try_to_unmap_one(struct page
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			if (!PageDirty(page)) {
+			/*
+			 * swapin page could be clean, it has data stored in
+			 * swap. We can't silently discard it without setting
+			 * swap entry in the page table.
+			 */
+			if (!PageDirty(page) && !PageSwapCache(page)) {
 				/* It's a freeable page by MADV_FREE */

Review static int try_to_unmap_one(struct page · line 1431

Quoted 10 lines
(quoted diff) +6 -1
 				dec_mm_counter(mm, MM_ANONPAGES);
-				rp->lazyfreed++;
 				goto discard;
+			} else if (!PageSwapBacked(page)) {
+				/* dirty MADV_FREE page */
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = SWAP_DIRTY;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
 			}

There is no point to make this logic complicated with clean swapin-page.

Andrew,
Could you fold below patch into the mm-reclaim-madv_free-pages.patch if others are not against?

Thanks.

From 0c28f6560fbc4e65da4f4a8cc4664ab9f7b11cf3 Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Fri, 3 Mar 2017 11:42:52 +0900
Subject: [PATCH] mm: clean up lazyfree page handling

We can make it simple to understand without need to be aware of clean-swapin page.
This patch just clean up lazyfree page handling in try_to_unmap_one.

Quoted 5 lines
Quoted 1 line

Agreed, this is a litle easier to follow.

Thanks, Johannes.

Quoted 17 lines

mm/rmap.c static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1414

Quoted 12 lines
---
 mm/rmap.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)
mm/rmap.c +0 -0
index bb45712..f7eab40 100644
@@ -1413,17 +1413,17 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);

Since you're removing the PageSwapCache() check and we're now assuming that !swapbacked is not in the swapcache, can you modify this to check PageSwapBacked(page) != PageSwapCache(page)?

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

Better yet, change it into a warning and SWAP_FAIL.

Maybe, what you wanted is

!!PageSwapBacked(page) != !!PageSwapCache(page)

Those testers return 0 or 1 ints, on x86 even bool.

You're right.
It seems PageXXX() was not in old day. Hmm, but seem to have corrected.

Quoted 4 lines
Quoted 3 lines

Personally, I prefer && style rather than equation expression in this case.

Quoted 11 lines

mm/rmap.c static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1418

Quoted 9 lines
mm/rmap.c +3 -2
@@ -1413,20 +1413,24 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			 * Store the swap location in the pte.
 			 * See handle_pte_fault() ...
 			 */
-			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
-				page);
+			if (VM_WARN_ON_ONCE(PageSwapBacked(page) &&
+						!PageSwapCache(page))) {
+				ret = SWAP_FAIL;

But you're not adding the !swapbacked && swapcache case?

PageSwapcache checks already includes PageSwapBacked check so practically, it would be pointless at this moment. But yes, it would be bad on relying on the current implemenation as considering the future.

As a bonus from side-effect, seeing the warning always only means it is from PageSwapbacked && !swapcache so we don't need to introduce VM_WARN_ON_ONCE_PAGE at this moment. :)

I will resend it.

Thanks for the review!

#6 lore raw
In reply to Johannes Weiner

On Mon, Mar 06, 2017 at 10:49:06AM -0500, Johannes Weiner wrote:

< snip >

Quoted 30 lines

Review static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma, · line 1418

Quoted 9 lines
(quoted diff) +3 -2
@@ -1413,20 +1413,24 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			 * Store the swap location in the pte.
 			 * See handle_pte_fault() ...
 			 */
-			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
-				page);
+			if (VM_WARN_ON_ONCE(PageSwapBacked(page) &&
+						!PageSwapCache(page))) {
+				ret = SWAP_FAIL;

But you're not adding the !swapbacked && swapcache case?

Quoted 3 lines
(quoted diff) +3 -0
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+			}

[...]

Quoted 12 lines
(quoted diff) +1 -11
-			/*
-			 * swapin page could be clean, it has data stored in
-			 * swap. We can't silently discard it without setting
-			 * swap entry in the page table.
-			 */
-			if (!PageDirty(page) && !PageSwapCache(page)) {
-				/* It's a freeable page by MADV_FREE */
-				dec_mm_counter(mm, MM_ANONPAGES);
-				goto discard;
-			} else if (!PageSwapBacked(page)) {
-				/* dirty MADV_FREE page */
+			/* MADV_FREE page check */
Quoted 8 lines

Review

Quoted 5 lines
(quoted diff) +5 -0
+			if (!PageSwapBacked(page)) {
+				if (!PageDirty(page)) {
+					dec_mm_counter(mm, MM_ANONPAGES);
+					goto discard;
+				}

Andrew already has this, you might want to send the warning changes as a separate patch on top of this one.

Here it goes.

Quoted 1 line

From d42d296950c3bbce74afddcff307fa18eef305fe Mon Sep 17 00:00:00 2001

From: Minchan Kim <[email protected]>
Date: Tue, 7 Mar 2017 14:48:37 +0900
Subject: [PATCH] mm: fix lazyfree bug on check in try_to_unmap_one

If a page is swapbacked, it means it should be in swapcache in try_to_unmap_one's path.

If a page is !swapbacked, it mean it shouldn't be in swapcache in try_to_unmap_one's path.

Check both two cases all at once and if it fails, warn and return SWAP_FAIL. Such bug never mean we should shut down the kernel.

---
 mm/rmap.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)
mm/rmap.c +7 -2
index 35acb83..9925f32 100644
@@ -1413,8 +1413,13 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			 * Store the swap location in the pte.
 			 * See handle_pte_fault() ...
 			 */
-			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
-				page);
+			if (VM_WARN_ON_ONCE(PageSwapBacked(page) !=
+						PageSwapCache(page))) {
+				ret = SWAP_FAIL;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+
+			}
 
 			/* MADV_FREE page check */
 			if (!PageSwapBacked(page)) {
Signature · 1 line
2.7.4
Acked-by
#7 lore raw

On Tue 07-03-17 14:55:51, Minchan Kim wrote:
[...]

Quoted 11 lines
Quoted 1 line

From d42d296950c3bbce74afddcff307fa18eef305fe Mon Sep 17 00:00:00 2001

From: Minchan Kim <[email protected]>
Date: Tue, 7 Mar 2017 14:48:37 +0900
Subject: [PATCH] mm: fix lazyfree bug on check in try_to_unmap_one

If a page is swapbacked, it means it should be in swapcache in try_to_unmap_one's path.

If a page is !swapbacked, it mean it shouldn't be in swapcache in try_to_unmap_one's path.

Quoted 6 lines

Check both two cases all at once and if it fails, warn and return SWAP_FAIL. Such bug never mean we should shut down the kernel.

looks good to me

Quoted 27 lines
---
 mm/rmap.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)
mm/rmap.c +7 -2
index 35acb83..9925f32 100644
@@ -1413,8 +1413,13 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			 * Store the swap location in the pte.
 			 * See handle_pte_fault() ...
 			 */
-			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
-				page);
+			if (VM_WARN_ON_ONCE(PageSwapBacked(page) !=
+						PageSwapCache(page))) {
+				ret = SWAP_FAIL;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+
+			}
 
 			/* MADV_FREE page check */
 			if (!PageSwapBacked(page)) {
Signature · 1 line
2.7.4
Signature · 2 lines
Michal Hocko
SUSE Labs
#8 lore raw
In reply to Minchan Kim
Quoted 11 lines · Minchan Kim

From d42d296950c3bbce74afddcff307fa18eef305fe Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Tue, 7 Mar 2017 14:48:37 +0900
Subject: [PATCH] mm: fix lazyfree bug on check in try_to_unmap_one

If a page is swapbacked, it means it should be in swapcache in try_to_unmap_one's path.

If a page is !swapbacked, it mean it shouldn't be in swapcache in try_to_unmap_one's path.

Quoted 6 lines

Check both two cases all at once and if it fails, warn and return SWAP_FAIL. Such bug never mean we should shut down the kernel.

Thanks Minchan

Reviewed-by
#9 lore raw
In reply to Minchan Kim
Quoted 87 lines · Minchan Kim

Hi,

Quoted 50 lines · On Tue, Feb 28, 2017 at 04:32:38PM -0800, [email protected] wrote:

The patch titled
Subject: mm: reclaim MADV_FREE pages
has been added to the -mm tree. Its filename is
mm-reclaim-madv_free-pages.patch

This patch should soon appear at

    https://urldefense.proofpoint.com/v2/url?u=http-3A__ozlabs.org_-7Eakpm_mmots_broken-2Dout_mm-2Dreclaim-2Dmadv-5Ffree-2Dpages.patch&d=DwIBAg&c=5VD0RTtNlTh3ycd41b3MUw&r=X13hAPkxmvBro1Ug8vcKHw&m=oMKTke-r00qQPnpEwo0Cn43po669gckvribhR9LQWf0&s=wzX_7IDavzBkFEMl7HDTMwrFXo1skB35mu0CjZmfFOg&e= 

and later at
https://urldefense.proofpoint.com/v2/url?u=http-3A__ozlabs.org_-7Eakpm_mmotm_broken-2Dout_mm-2Dreclaim-2Dmadv-5Ffree-2Dpages.patch&d=DwIBAg&c=5VD0RTtNlTh3ycd41b3MUw&r=X13hAPkxmvBro1Ug8vcKHw&m=oMKTke-r00qQPnpEwo0Cn43po669gckvribhR9LQWf0&s=eUYtR1qeasKBGvuNWsZP6jE4XwoKwMb4CdKQU7OXGYM&e=

Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/SubmitChecklist when testing your code ***

The -mm tree is included into linux-next and is updated there every 3-4 working days

------------------------------------------------------
From: Shaohua Li <[email protected]>
Subject: mm: reclaim MADV_FREE pages

When memory pressure is high, we free MADV_FREE pages. If the pages are not dirty in pte, the pages could be freed immediately. Otherwise we can't reclaim them. We put the pages back to anonumous LRU list (by setting SwapBacked flag) and the pages will be reclaimed in normal swapout way.

We use normal page reclaim policy. Since MADV_FREE pages are put into inactive file list, such pages and inactive file pages are reclaimed according to their age. This is expected, because we don't want to reclaim too many MADV_FREE pages before used once pages.

Based on Minchan's original patch

---

< snip >

Quoted 12 lines
(quoted diff) +6 -1
@@ -1419,11 +1413,21 @@ static int try_to_unmap_one(struct page
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			if (!PageDirty(page)) {
+			/*
+			 * swapin page could be clean, it has data stored in
+			 * swap. We can't silently discard it without setting
+			 * swap entry in the page table.
+			 */
+			if (!PageDirty(page) && !PageSwapCache(page)) {
 				/* It's a freeable page by MADV_FREE */

Review static int try_to_unmap_one(struct page · line 1431

Quoted 10 lines
(quoted diff) +6 -1
 				dec_mm_counter(mm, MM_ANONPAGES);
-				rp->lazyfreed++;
 				goto discard;
+			} else if (!PageSwapBacked(page)) {
+				/* dirty MADV_FREE page */
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = SWAP_DIRTY;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
 			}

There is no point to make this logic complicated with clean swapin-page.

Andrew,
Could you fold below patch into the mm-reclaim-madv_free-pages.patch if others are not against?

Thanks.

Quoted 8 lines

From 0c28f6560fbc4e65da4f4a8cc4664ab9f7b11cf3 Mon Sep 17 00:00:00 2001
From: Minchan Kim <[email protected]>
Date: Fri, 3 Mar 2017 11:42:52 +0900
Subject: [PATCH] mm: clean up lazyfree page handling

We can make it simple to understand without need to be aware of clean-swapin page.
This patch just clean up lazyfree page handling in try_to_unmap_one.

Looks good, thanks!

Quoted 41 lines
---
 mm/rmap.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)
mm/rmap.c +11 -11
index bb45712..f7eab40 100644
@@ -1413,17 +1413,17 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			VM_BUG_ON_PAGE(!PageSwapCache(page) && PageSwapBacked(page),
 				page);
 
-			/*
-			 * swapin page could be clean, it has data stored in
-			 * swap. We can't silently discard it without setting
-			 * swap entry in the page table.
-			 */
-			if (!PageDirty(page) && !PageSwapCache(page)) {
-				/* It's a freeable page by MADV_FREE */
-				dec_mm_counter(mm, MM_ANONPAGES);
-				goto discard;
-			} else if (!PageSwapBacked(page)) {
-				/* dirty MADV_FREE page */
+			/* MADV_FREE page check */
+			if (!PageSwapBacked(page)) {
+				if (!PageDirty(page)) {
+					dec_mm_counter(mm, MM_ANONPAGES);
+					goto discard;
+				}
+
+				/*
+				 * If the page was redirtied, it cannot be
+				 * discarded. Remap the page to page table.
+				 */
 				set_pte_at(mm, address, pvmw.pte, pteval);
 				ret = SWAP_DIRTY;
 				page_vma_mapped_walk_done(&pvmw);
Signature · 1 line
2.7.4