mm: clean up hwpoison page cache page in fault path
Subsystems (2)
PATCH v2 1/1 mm: clean up hwpoison page cache page in fault path
Sometimes the page offlining code can leave behind a hwpoisoned clean page cache page. This can lead to programs being killed over and over and over again as they fault in the hwpoisoned page, get killed, and then get re-spawned by whatever wanted to run them.
This is particularly embarrassing when the page was offlined due to having too many corrected memory errors. Now we are killing tasks due to them trying to access memory that probably isn't even corrupted.
This problem can be avoided by invalidating the page from the page fault handler, which already has a branch for dealing with these kinds of pages. With this patch we simply pretend the page fault was successful if the page was invalidated, return to userspace, incur another page fault, read in the file from disk (to a new memory page), and then everything works again.
---
v2: fix compiler warning found by kernel test robot
mm/memory.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
mm/memory.c +7 -2
@@ -3871,11 +3871,16 @@ static vm_fault_t __do_fault(struct vm_fault *vmf)return ret;if (unlikely (PageHWPoison (vmf->page))) { -if (ret &VM_FAULT_LOCKED ) +vm_fault_t poisonret =VM_FAULT_HWPOISON ; +if (ret &VM_FAULT_LOCKED ) { +/* Retry if a clean page was removed from the cache. */ +if (invalidate_inode_page (vmf->page)) + poisonret =0 ;unlock_page (vmf->page); + }put_page (vmf->page); vmf->page =NULL ; -return VM_FAULT_HWPOISON ; +return poisonret; }if (unlikely (!(ret &VM_FAULT_LOCKED )))
Signature · 6 lines
2.34.1 -- All rights reversed.
Andrew Morton
maintainerQuoted 2 lines
Subject: [PATCH v2] mm: clean up hwpoison page cache page in fault path
At first scan I thought this was a code cleanup.
I think I'll do s/clean up/invalidate/.
Quoted 2 lines · On Sat, 12 Feb 2022 21:37:40 -0500 Rik van Riel <[email protected]> wrote:
Sometimes the page offlining code can leave behind a hwpoisoned clean page cache page.
Is this correct behaviour?
Quoted 8 lines
This can lead to programs being killed over and over
and over again as they fault in the hwpoisoned page, get killed, and then get re-spawned by whatever wanted to run them.This is particularly embarrassing when the page was offlined due to having too many corrected memory errors. Now we are killing tasks due to them trying to access memory that probably isn't even corrupted.
Quoted 6 lines
This problem can be avoided by invalidating the page from the page fault handler, which already has a branch for dealing with these kinds of pages. With this patch we simply pretend the page fault was successful if the page was invalidated, return to userspace, incur another page fault, read in the file from disk (to a new memory page), and then everything works again.
Is this worth a cc:stable?
Quoted 8 lines · Andrew Morton
Quoted 3 lines
Subject: [PATCH v2] mm: clean up hwpoison page cache page in fault path
At first scan I thought this was a code cleanup.
I think I'll do s/clean up/invalidate/.
OK, that sounds good.
Quoted 8 lines
Quoted 3 lines · On Sat, 12 Feb 2022 21:37:40 -0500 Rik van Riel <[email protected]> wrote:
Sometimes the page offlining code can leave behind a hwpoisoned clean
page cache page.Is this correct behaviour?
It is not desirable, and the soft page offlining code tries to invalidate the page, but I don't think overhauling the way we lock and refcount page cache pages just to make offlining them more reliable would be worthwhile, when we already have a branch in the page fault handler to deal with these pages, anyway.
Quoted 10 lines
Quoted 10 lines
This can lead to programs being killed over and over and over again as they fault in the hwpoisoned page, get killed, and
then get re-spawned by whatever wanted to run them.This is particularly embarrassing when the page was offlined due to having too many corrected memory errors. Now we are killing tasks due to them trying to access memory that probably isn't even corrupted.
Quoted 8 lines
Quoted 6 lines
This problem can be avoided by invalidating the page from the page fault handler, which already has a branch for dealing with these kinds of pages. With this patch we simply pretend the page fault was successful if the page was invalidated, return to userspace, incur another page fault, read in the file from disk (to a new memory page), and then everything works again.
Is this worth a cc:stable?
Maybe. I don't know how far back this issue goes...
Signature · 1 line
All Rights Reversed.
HORIGUCHI NAOYA(堀口 直也)
Acked-byQuoted 18 lines · Rik van Riel
Quoted 8 lines · Andrew Morton
Quoted 3 lines
Subject: [PATCH v2] mm: clean up hwpoison page cache page in fault path
At first scan I thought this was a code cleanup.
I think I'll do s/clean up/invalidate/.
OK, that sounds good.
Quoted 7 lines
Quoted 3 lines · On Sat, 12 Feb 2022 21:37:40 -0500 Rik van Riel <[email protected]> wrote:
Sometimes the page offlining code can leave behind a hwpoisoned clean
page cache page.
Quoted 8 lines
Quoted 1 line
Is this correct behaviour?
It is not desirable, and the soft page offlining code tries to invalidate the page, but I don't think overhauling the way we lock and refcount page cache pages just to make offlining them more reliable would be worthwhile, when we already have a branch in the page fault handler to deal with these pages, anyway.
I don't have any idea about how this kind of page is left on page cache after page offlining. But I agree with the suggested change.
Quoted 18 lines
Quoted 18 lines
Quoted 17 lines
This can lead to programs being killed over and over and over again as they fault in the hwpoisoned page, get killed, and
then get re-spawned by whatever wanted to run them.This is particularly embarrassing when the page was offlined due to having too many corrected memory errors. Now we are killing tasks due to them trying to access memory that probably isn't even corrupted.
This problem can be avoided by invalidating the page from the page fault handler, which already has a branch for dealing with these kinds of pages. With this patch we simply pretend the page fault was successful if the page was invalidated, return to userspace, incur another page fault, read in the file from disk (to a new memory page), and then everything works again.
Quoted 3 lines
Quoted 1 line
Is this worth a cc:stable?
Maybe. I don't know how far back this issue goes...
This issue should be orthogonal with recent changes on hwpoison, and the base code targetted by this patch is unchanged since 2016 (4.10-rc1), so this patch is simply applicable to most of the maintained stable trees (maybe except 4.9.z).
Thanks,
Naoya Horiguchi
Quoted 4 lines · Rik van Riel
Sometimes the page offlining code can leave behind a hwpoisoned clean page cache page. This can lead to programs being killed over and over and over again as they fault in the hwpoisoned page, get killed, and then get re-spawned by whatever wanted to run them.
Hi Rik,
am I correct that you are only talking about soft offlining as triggered from mm/memory-failure.c, not page offlining as in memory offlining mm/memory_hotunplug.c ?
Maybe you can clarify that in the patch description, it made me nervous for a second :)
Signature · 3 lines
Thanks, David / dhildenb
Quoted 9 lines · David Hildenbrand
Quoted 7 lines · Rik van Riel
Sometimes the page offlining code can leave behind a hwpoisoned clean
page cache page. This can lead to programs being killed over and over
and over again as they fault in the hwpoisoned page, get killed, and
then get re-spawned by whatever wanted to run them.
Quoted 6 lines
Hi Rik,
am I correct that you are only talking about soft offlining as triggered
frommm/memory-failure.c, not page offlining as in memory offliningmm/memory_hotunplug.c?
That is correct in that I am talking only about memory-failure.c, however the code in memory-failure.c has both hard and soft offlining modes, and I suppose this patch covers both?
Signature · 1 line
All Rights Reversed.
Quoted 12 lines · Rik van Riel
Quoted 11 lines · David Hildenbrand
Quoted 7 lines · Rik van Riel
Sometimes the page offlining code can leave behind a hwpoisoned clean
page cache page. This can lead to programs being killed over and over
and over again as they fault in the hwpoisoned page, get killed, and
then get re-spawned by whatever wanted to run them.Hi Rik,
Quoted 9 lines
Quoted 4 lines
am I correct that you are only talking about soft offlining as triggered
frommm/memory-failure.c, not page offlining as in memory offliningmm/memory_hotunplug.c?That is correct in that I am talking only about
memory-failure.c, however the code inmemory-failure.chas both hard and soft offlining modes, and I suppose this patch covers both?
Right, for hwpoison handling there is hard and soft offlining of pages ... maybe "hwpoison page offlining" would be clearer, not sure.
Thanks for clarifying!
Signature · 3 lines
Thanks, David / dhildenb
Quoted 4 lines · Rik van Riel
Sometimes the page offlining code can leave behind a hwpoisoned clean page cache page. This can lead to programs being killed over and over and over again as they fault in the hwpoisoned page, get killed, and then get re-spawned by whatever wanted to run them.
Hi Rik,
Do you know how that exactly happens? We should not be really leaving anything behind, and soft-offline (not hard) code works with the premise of only poisoning a page in case it was contained, so I am wondering what is going on here.
In-use pagecache pages are migrated away, and the actual page is contained, and for clean ones, we already do the invalidate_inode_page() and then contain it in case we succeed.
One scenario I can imagine this can happen is if by the time we call page_handle_poison(), someone has taken another refcount on the page, and the put_page() does not really free it, but I am not sure that can happen.
Signature · 2 lines
Oscar Salvador SUSE Labs
Quoted 17 lines · Oscar Salvador
Quoted 7 lines · Rik van Riel
Sometimes the page offlining code can leave behind a hwpoisoned clean
page cache page. This can lead to programs being killed over and over
and over again as they fault in the hwpoisoned page, get killed, and
then get re-spawned by whatever wanted to run them.Hi Rik,
Do you know how that exactly happens? We should not be really leaving anything behind, and soft-offline (not hard) code works with the premise
of only poisoning a page in case it was contained, so I am wondering what is going on here.
Quoted 4 lines
In-use pagecache pages are migrated away, and the actual page is contained, and for clean ones, we already do the
invalidate_inode_page()
and then contain it in case we succeed.
I do not know the exact failure case, since I have never caught a system in the act of leaking one of these pages.
I just know I have seen this issue on systems where the "soft_offline: %#lx: invalidated\n" printk was the only offline method leaving any message in the kernel log.
However, there are a few code paths through the soft offlining code path that don't seem to have any printks, so I am not sure exactly where things went wrong.
I only really found the aftermath, and tested this patch by loading it as a kernel live patch module on some of those systems.
Signature · 1 line
All Rights Reversed.
Quoted 8 lines · Oscar Salvador
Quoted 4 lines · Rik van Riel
Sometimes the page offlining code can leave behind a hwpoisoned clean page cache page. This can lead to programs being killed over and over and over again as they fault in the hwpoisoned page, get killed, and then get re-spawned by whatever wanted to run them.
Hi Rik,
Quoted 9 lines
Do you know how that exactly happens? We should not be really leaving anything behind, and soft-offline (not hard) code works with the premise of only poisoning a page in case it was contained, so I am wondering what is going on here.
In-use pagecache pages are migrated away, and the actual page is contained, and for clean ones, we already do the
invalidate_inode_page()and then contain it in case we succeed.
IIUC, this could not happen when soft-offlining a pagecache page. They're either invalidated or migrated away and then we set PageHWPoison.
I think this may happen on a clean pagecache page when it's isolated. So it's !PageLRU. And identify_page_state treats it as me_unknown because it's non reserved, slab, swapcache and so on ...(see error_states for details). Or am I miss anything?
Thanks.
Quoted 5 lines
One scenario I can imagine this can happen is if by the time we call
page_handle_poison(), someone has taken another refcount on the page, and theput_page()does not really free it, but I am not sure that can happen.
Quoted 5 lines · Miaohe Lin
IIUC, this could not happen when soft-offlining a pagecache page. They're either invalidated or migrated away and then we set PageHWPoison.
I think this may happen on a clean pagecache page when it's isolated. So it's !PageLRU. Andidentify_page_statetreats it asme_unknownbecause it's non reserved, slab, swapcache and so on ...(seeerror_statesfor details). Or am I miss anything?
But the path you are talking about is when we do have a non-recoverable error, so memory_failure() path.
AFAIU, Rik talks about pages with corrected errors, and that is soft_offline().
Signature · 2 lines
Oscar Salvador SUSE Labs
Quoted 11 lines · Oscar Salvador
Quoted 5 lines · Miaohe Lin
IIUC, this could not happen when soft-offlining a pagecache page. They're either invalidated or migrated away and then we set PageHWPoison.
I think this may happen on a clean pagecache page when it's isolated. So it's !PageLRU. Andidentify_page_statetreats it asme_unknownbecause it's non reserved, slab, swapcache and so on ...(seeerror_statesfor details). Or am I miss anything?But the path you are talking about is when we do have a non-recoverable error, so
memory_failure()path.
AFAIU, Rik talks about pages with corrected errors, and that issoft_offline().
Oh, yes, Rik talks about pages with corrected errors. My mistake. Then I really want to understand how we got there too. :)
Thanks.
Quoted 1 line
Quoted 16 lines · Rik van Riel
Sometimes the page offlining code can leave behind a hwpoisoned clean page cache page. This can lead to programs being killed over and over and over again as they fault in the hwpoisoned page, get killed, and then get re-spawned by whatever wanted to run them.
This is particularly embarrassing when the page was offlined due to having too many corrected memory errors. Now we are killing tasks due to them trying to access memory that probably isn't even corrupted.
This problem can be avoided by invalidating the page from the page fault handler, which already has a branch for dealing with these kinds of pages. With this patch we simply pretend the page fault was successful if the page was invalidated, return to userspace, incur another page fault, read in the file from disk (to a new memory page), and then everything works again.
Quoted 2 lines
Signed-off-by Rik van Riel <[email protected]>Reviewed-by Miaohe Lin <[email protected]>
Although I would really loved to understand how we got there, it fixes the problem, so:
Signature · 2 lines
Oscar Salvador SUSE Labs