Skip to contentSkip to conversation

mm/z3fold.c: Lock z3fold page before __SetPageMovable()

PATCH Superseded Henry Burns 5 participants 11 messages Jul 2, 2019 – Jul 3, 2019 Memory management

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 mm/z3fold.c: Lock z3fold page before __SetPageMovable()

__SetPageMovable() expects it's page to be locked, but z3fold.c doesn't lock the page. Following zsmalloc.c's example we call trylock_page() and unlock_page(). Also makes z3fold_page_migrate() assert that newpage is passed in locked, as documentation.

---
Changelog since v1:
- Added an if statement around WARN_ON(trylock_page(page)) to avoid unlocking a page locked by a someone else.

 mm/z3fold.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
mm/z3fold.c +5 -1
index e174d1549734..6341435b9610 100644
@@ -918,7 +918,10 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
 		set_bit(PAGE_HEADLESS, &page->private);
 		goto headless;
 	}
-	__SetPageMovable(page, pool->inode->i_mapping);
+	if (!WARN_ON(!trylock_page(page))) {
+		__SetPageMovable(page, pool->inode->i_mapping);
+		unlock_page(page);
+	}
 	z3fold_page_lock(zhdr);
 
 found:
@@ -1325,6 +1328,7 @@ static int z3fold_page_migrate(struct address_space *mapping, struct page *newpa
 
 	VM_BUG_ON_PAGE(!PageMovable(page), page);
 	VM_BUG_ON_PAGE(!PageIsolated(page), page);
+	VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
 
 	zhdr = page_address(page);
 	pool = zhdr_to_pool(zhdr);
Signature · 1 line
2.22.0.410.gd8fdbe21b5-goog
#1 lore raw
Quoted 21 lines · Henry Burns

__SetPageMovable() expects it's page to be locked, but z3fold.c doesn't lock the page. Following zsmalloc.c's example we call trylock_page() and unlock_page(). Also makes z3fold_page_migrate() assert that newpage is passed in locked, as documentation.

---
Changelog since v1:
- Added an if statement around WARN_ON(trylock_page(page)) to avoid unlocking a page locked by a someone else.

 mm/z3fold.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
mm/z3fold.c +0 -0
index e174d1549734..6341435b9610 100644

mm/z3fold.c static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp, · line 924

Quoted 8 lines
mm/z3fold.c +4 -1
@@ -918,7 +918,10 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
                set_bit(PAGE_HEADLESS, &page->private);
                goto headless;
        }
-       __SetPageMovable(page, pool->inode->i_mapping);
+       if (!WARN_ON(!trylock_page(page))) {
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       }

Can you please comment why lock_page() is not used here?

Quoted 14 lines
mm/z3fold.c +1 -1
        z3fold_page_lock(zhdr);
 
 found:
@@ -1325,6 +1328,7 @@ static int z3fold_page_migrate(struct address_space *mapping, struct page *newpa
 
        VM_BUG_ON_PAGE(!PageMovable(page), page);
        VM_BUG_ON_PAGE(!PageIsolated(page), page);
+       VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
 
        zhdr = page_address(page);
        pool = zhdr_to_pool(zhdr);
--

2.22.0.410.gd8fdbe21b5-goog

#2 lore raw
Quoted 18 lines · Shakeel Butt
Quoted 16 lines · Henry Burns

__SetPageMovable() expects it's page to be locked, but z3fold.c doesn't lock the page. Following zsmalloc.c's example we call trylock_page() and unlock_page(). Also makes z3fold_page_migrate() assert that newpage is passed in locked, as documentation.

---
Changelog since v1:
- Added an if statement around WARN_ON(trylock_page(page)) to avoid unlocking a page locked by a someone else.

 mm/z3fold.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
Quoted 15 lines

mm/z3fold.c static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp, · line 924

Quoted 13 lines
mm/z3fold.c +4 -1
index e174d1549734..6341435b9610 100644
@@ -918,7 +918,10 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
                set_bit(PAGE_HEADLESS, &page->private);
                goto headless;
        }
-       __SetPageMovable(page, pool->inode->i_mapping);
+       if (!WARN_ON(!trylock_page(page))) {
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       }

Can you please comment why lock_page() is not used here?

Since z3fold_alloc can be called in atomic or non atomic context, calling lock_page() could trigger a number of
warnings about might_sleep() being called in atomic context. WARN_ON should avoid the problem described
above as well, and in any weird condition where someone else has the page lock, we can avoid calling
__SetPageMovable().

Quoted 15 lines
Quoted 15 lines
mm/z3fold.c +1 -1
        z3fold_page_lock(zhdr);
 
 found:
@@ -1325,6 +1328,7 @@ static int z3fold_page_migrate(struct address_space *mapping, struct page *newpa
 
        VM_BUG_ON_PAGE(!PageMovable(page), page);
        VM_BUG_ON_PAGE(!PageIsolated(page), page);
+       VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
 
        zhdr = page_address(page);
        pool = zhdr_to_pool(zhdr);
--

2.22.0.410.gd8fdbe21b5-goog

maintainer
#3 lore raw
Quoted 1 line · On Mon, 1 Jul 2019 18:16:30 -0700 Henry Burns <[email protected]> wrote:
Cc Vitaly Wool <[email protected]>, Vitaly Vul <[email protected]>

Are these the same person?

Quoted 11 lines

Subject: Re: [PATCH v2] mm/z3fold.c: Lock z3fold page before __SetPageMovable()
Date: Mon, 1 Jul 2019 18:16:30 -0700

Quoted 7 lines · Shakeel Butt
Quoted 5 lines · Henry Burns

__SetPageMovable() expects it's page to be locked, but z3fold.c doesn't lock the page. Following zsmalloc.c's example we call trylock_page() and unlock_page(). Also makes z3fold_page_migrate() assert that newpage is passed in locked, as documentation.

The changelog still doesn't mention that this bug triggers a VM_BUG_ON_PAGE(). It should do so. I did this:

: __SetPageMovable() expects its page to be locked, but z3fold.c doesn't : lock the page. This triggers the VM_BUG_ON_PAGE(!PageLocked(page), page) : in __SetPageMovable().
:
: Following zsmalloc.c's example we call trylock_page() and unlock_page(). : Also make z3fold_page_migrate() assert that newpage is passed in locked, : as per the documentation.

I'll add a cc:stable to this fix.

Quoted 10 lines
Quoted 10 lines
Quoted 10 lines

---
Changelog since v1:
- Added an if statement around WARN_ON(trylock_page(page)) to avoid unlocking a page locked by a someone else.

 mm/z3fold.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
Quoted 15 lines
Quoted 7 lines
Quoted 7 lines
mm/z3fold.c +0 -0
index e174d1549734..6341435b9610 100644
@@ -918,7 +918,10 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
                set_bit(PAGE_HEADLESS, &page->private);
                goto headless;
Quoted 8 lines

mm/z3fold.c static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp, · line 924

Quoted 6 lines
mm/z3fold.c +4 -1
        }
-       __SetPageMovable(page, pool->inode->i_mapping);
+       if (!WARN_ON(!trylock_page(page))) {
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       }

Can you please comment why lock_page() is not used here?

Shakeel asked "please comment" (ie, please add a code comment), not "please comment on". Subtle ;)

Quoted 7 lines

Since z3fold_alloc can be called in atomic or non atomic context, calling lock_page() could trigger a number of
warnings about might_sleep() being called in atomic context. WARN_ON should avoid the problem described
above as well, and in any weird condition where someone else has the page lock, we can avoid calling
__SetPageMovable().

I think this will suffice:

mm/z3fold.c renamed from mm/z3fold.c~mm-z3foldc-lock-z3fold-page-before-__setpagemovable-fix +3 -0
@@ -919,6 +919,9 @@ retry:
 		set_bit(PAGE_HEADLESS, &page->private);
 		goto headless;
 	}
+	/*
+	 * z3fold_alloc() can be called from atomic contexts, hence the trylock
+	 */
 	if (!WARN_ON(!trylock_page(page))) {
 		__SetPageMovable(page, pool->inode->i_mapping);
 		unlock_page(page);

However this code would be more effective if z3fold_alloc() were to be told when it is running in non-atomic context so it can perform a sleeping lock_page() in that case. That's an improvement to consider for later, please.

#4 lore raw
Quoted 6 lines · Andrew Morton
Quoted 1 line · On Mon, 1 Jul 2019 18:16:30 -0700 Henry Burns <[email protected]> wrote:
Cc Vitaly Wool <[email protected]>, Vitaly Vul <[email protected]>

Are these the same person?

I Think it's the same person, but i wasn't sure which email to include because one was
in the list of maintainers and I had contacted the other earlier.

Quoted 78 lines
Quoted 12 lines

Subject: Re: [PATCH v2] mm/z3fold.c: Lock z3fold page before __SetPageMovable()
Date: Mon, 1 Jul 2019 18:16:30 -0700

Quoted 7 lines · Shakeel Butt
Quoted 5 lines · Henry Burns

__SetPageMovable() expects it's page to be locked, but z3fold.c doesn't lock the page. Following zsmalloc.c's example we call trylock_page() and unlock_page(). Also makes z3fold_page_migrate() assert that newpage is passed in locked, as documentation.

The changelog still doesn't mention that this bug triggers a VM_BUG_ON_PAGE(). It should do so. I did this:

: __SetPageMovable() expects its page to be locked, but z3fold.c doesn't : lock the page. This triggers the VM_BUG_ON_PAGE(!PageLocked(page), page) : in __SetPageMovable().
:
: Following zsmalloc.c's example we call trylock_page() and unlock_page(). : Also make z3fold_page_migrate() assert that newpage is passed in locked, : as per the documentation.

I'll add a cc:stable to this fix.

Quoted 10 lines
Quoted 10 lines
Quoted 10 lines

---
Changelog since v1:
- Added an if statement around WARN_ON(trylock_page(page)) to avoid unlocking a page locked by a someone else.

 mm/z3fold.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
Quoted 15 lines
Quoted 7 lines
Quoted 7 lines
mm/z3fold.c +0 -0
index e174d1549734..6341435b9610 100644
@@ -918,7 +918,10 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
                set_bit(PAGE_HEADLESS, &page->private);
                goto headless;
Quoted 8 lines

mm/z3fold.c static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp, · line 924

Quoted 6 lines
mm/z3fold.c +4 -1
        }
-       __SetPageMovable(page, pool->inode->i_mapping);
+       if (!WARN_ON(!trylock_page(page))) {
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       }

Can you please comment why lock_page() is not used here?

Shakeel asked "please comment" (ie, please add a code comment), not "please comment on". Subtle ;)

Quoted 7 lines

Since z3fold_alloc can be called in atomic or non atomic context, calling lock_page() could trigger a number of
warnings about might_sleep() being called in atomic context. WARN_ON should avoid the problem described
above as well, and in any weird condition where someone else has the page lock, we can avoid calling
__SetPageMovable().

I think this will suffice:

mm/z3fold.c renamed from mm/z3fold.c~mm-z3foldc-lock-z3fold-page-before-__setpagemovable-fix +3 -0
@@ -919,6 +919,9 @@ retry:
                set_bit(PAGE_HEADLESS, &page->private);
                goto headless;
        }
+       /*
+        * z3fold_alloc() can be called from atomic contexts, hence the trylock
+        */
        if (!WARN_ON(!trylock_page(page))) {
                __SetPageMovable(page, pool->inode->i_mapping);
                unlock_page(page);
Quoted 5 lines

However this code would be more effective if z3fold_alloc() were to be told when it is running in non-atomic context so it can perform a sleeping lock_page() in that case. That's an improvement to consider for later, please.

z3fold_alloc() can tell when its called in atomic context, new patch incoming! I'm thinking something like this:

Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
Quoted 13 lines
mm/z3fold.c +13 -0
+       if (can_sleep) {
+               lock_page(page);
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       } else {
+               if (!WARN_ON(!trylock_page(page))) {
+                       __SetPageMovable(page, pool->inode->i_mapping);
+                       unlock_page(page);
+               } else {
+                       pr_err("Newly allocated z3fold page is locked\n");
+                       WARN_ON(1);
+               }
+       }
maintainer
#5 lore raw
Quoted 11 lines · On Tue, 2 Jul 2019 15:17:47 -0700 Henry Burns <[email protected]> wrote:
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

Review

Quoted 11 lines
(quoted diff) +11 -0
+       if (can_sleep) {
+               lock_page(page);
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       } else {
+               if (!WARN_ON(!trylock_page(page))) {
+                       __SetPageMovable(page, pool->inode->i_mapping);
+                       unlock_page(page);
+               } else {
+                       pr_err("Newly allocated z3fold page is locked\n");
+                       WARN_ON(1);

The WARN_ON will have already warned in this case.

But the whole idea of warning in this case may be undesirable. We KNOW that the warning will sometimes trigger (yes?). So what's the point in scaring users?

Also, pr_err(...)+WARN_ON(1) can basically be replaced with WARN(1, ...)?

Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
(quoted diff) +2 -0
+               }
+       }
#6 lore raw
Quoted 15 lines · Andrew Morton
Quoted 11 lines · On Tue, 2 Jul 2019 15:17:47 -0700 Henry Burns <[email protected]> wrote:
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

Review

Quoted 11 lines
(quoted diff) +11 -0
+       if (can_sleep) {
+               lock_page(page);
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       } else {
+               if (!WARN_ON(!trylock_page(page))) {
+                       __SetPageMovable(page, pool->inode->i_mapping);
+                       unlock_page(page);
+               } else {
+                       pr_err("Newly allocated z3fold page is locked\n");
+                       WARN_ON(1);
Quoted 5 lines

The WARN_ON will have already warned in this case.

But the whole idea of warning in this case may be undesirable. We KNOW that the warning will sometimes trigger (yes?). So what's the point in scaring users?

Well, normally a newly allocated page that we own should not be locked by someone else so this is worth a warning IMO. With that said, the else branch here appears to be redundant.

~Vitaly

#7 lore raw
Quoted 19 lines · Vitaly Wool
Quoted 17 lines · Andrew Morton
Quoted 11 lines · On Tue, 2 Jul 2019 15:17:47 -0700 Henry Burns <[email protected]> wrote:
Quoted 11 lines
Quoted 11 lines
Quoted 11 lines

Review

Quoted 11 lines
(quoted diff) +11 -0
+       if (can_sleep) {
+               lock_page(page);
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       } else {
+               if (!WARN_ON(!trylock_page(page))) {
+                       __SetPageMovable(page, pool->inode->i_mapping);
+                       unlock_page(page);
+               } else {
+                       pr_err("Newly allocated z3fold page is locked\n");
+                       WARN_ON(1);

The WARN_ON will have already warned in this case.

Quoted 7 lines
Quoted 3 lines

But the whole idea of warning in this case may be undesirable. We KNOW that the warning will sometimes trigger (yes?). So what's the point in scaring users?

Well, normally a newly allocated page that we own should not be locked by someone else so this is worth a warning IMO. With that said, the else branch here appears to be redundant.

The else branch has been removed, and I think it's possible (albeit unlikely) that the trylock could fail due to either compaction or kstaled (In which case the page just won't be movable).

Also Vitaly, do you have a preference between the two emails? I'm not sure which one to include.

#8 lore raw
In reply to Henry Burns
Quoted 11 lines · Henry Burns
Quoted 6 lines · Andrew Morton
Quoted 1 line · On Mon, 1 Jul 2019 18:16:30 -0700 Henry Burns <[email protected]> wrote:
Cc Vitaly Wool <[email protected]>, Vitaly Vul <[email protected]>

Are these the same person?

I Think it's the same person, but i wasn't sure which email to include because one was
in the list of maintainers and I had contacted the other earlier.

This is the same person, it's the transliteration done differently that caused this :)

~Vitaly

Acked-by on v2 1/1
#9 lore raw
In reply to Henry Burns
Quoted 8 lines · Henry Burns

__SetPageMovable() expects it's page to be locked, but z3fold.c doesn't lock the page. Following zsmalloc.c's example we call trylock_page() and unlock_page(). Also makes z3fold_page_migrate() assert that newpage is passed in locked, as documentation.

Thanks!

Quoted 35 lines

---
Changelog since v1:
- Added an if statement around WARN_ON(trylock_page(page)) to avoid unlocking a page locked by a someone else.

 mm/z3fold.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
mm/z3fold.c +5 -2
index e174d1549734..6341435b9610 100644
@@ -918,7 +918,10 @@ static int z3fold_alloc(struct z3fold_pool *pool, size_t size, gfp_t gfp,
                set_bit(PAGE_HEADLESS, &page->private);
                goto headless;
        }
-       __SetPageMovable(page, pool->inode->i_mapping);
+       if (!WARN_ON(!trylock_page(page))) {
+               __SetPageMovable(page, pool->inode->i_mapping);
+               unlock_page(page);
+       }
        z3fold_page_lock(zhdr);
 
 found:
@@ -1325,6 +1328,7 @@ static int z3fold_page_migrate(struct address_space *mapping, struct page *newpa
 
        VM_BUG_ON_PAGE(!PageMovable(page), page);
        VM_BUG_ON_PAGE(!PageIsolated(page), page);
+       VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
 
        zhdr = page_address(page);
        pool = zhdr_to_pool(zhdr);
--

2.22.0.410.gd8fdbe21b5-goog

Acked-by on v2 1/1
#10 lore raw
In reply to Henry Burns
Quoted 7 lines · Henry Burns

__SetPageMovable() expects it's page to be locked, but z3fold.c doesn't lock the page. Following zsmalloc.c's example we call trylock_page() and unlock_page(). Also makes z3fold_page_migrate() assert that newpage is passed in locked, as documentation.