mm, hwpoison: improve handling workload related to hugetlb and memory_hotplug
Subsystems (8)
v3 cover mm, hwpoison: improve handling workload related to hugetlb and memory_hotplug
Hi,
This patchset tries to solve the issue among memory_hotplug, hugetlb and hwpoison. Based on the review over v2 by Miaohe (thank you!), 1/4 takes another approach to prevent hwpoisoned hugepages to be migrated (i.e. the corrupted data is accessed) in memory hotremove.
In this patchset, memory hotplug handles hwpoison pages like below:
- hwpoison pages should not prevent memory hotremove,
- memory block with hwpoison pages should not be onlined.
Any comments and feedbacks would be appreciated.
Thanks,
Naoya Horiguchi
v1: https://lore.kernel.org/linux-mm/[email protected]/T
v2: https://lore.kernel.org/linux-mm/[email protected]/T
---
Summary:
Naoya Horiguchi (4):
mm,hwpoison,hugetlb,memory_hotplug: hotremove memory section with hwpoisoned hugepage mm/hwpoison: move definitions of num_poisoned_pages_* to memory-failure.c mm/hwpoison: pass pfn to num_poisoned_pages_*()
mm/hwpoison: introduce per-memory_block hwpoison counter
arch/parisc/kernel/pdt.c | 5 ++-- drivers/base/memory.c | 36 +++++++++++++++++++++++++++++ include/linux/hugetlb.h | 4 ++-- include/linux/memory.h | 3 +++ include/linux/mm.h | 13 +++++++++++ include/linux/swapops.h | 24 ++------------------ mm/hugetlb.c | 4 ++-- mm/internal.h | 8 ------- mm/memory-failure.c | 59 +++++++++++++++++++++++++++--------------------- mm/sparse.c | 2 -- 10 files changed, 93 insertions(+), 65 deletions(-)
PATCH v3 1/4 mm,hwpoison,hugetlb,memory_hotplug: hotremove memory section with hwpoisoned hugepage
From: Naoya Horiguchi <[email protected]>
HWPoisoned page is not supposed to be accessed once marked, but currently such accesses can happen during memory hotremove because do_migrate_range() can be called before dissolve_free_huge_pages() is called.
Clear HPageMigratable for hwpoisoned hugepages to prevent them from being migrated. This should be done in hugetlb_lock to avoid race against isolate_hugetlb().
get_hwpoison_huge_page() needs to have a flag to show it's called from unpoison to take refcount of hwpoisoned hugepages, so add it.
---
ChangeLog v2 -> v3
- move to the approach of clearing HPageMigratable instead of shifting dissolve_free_huge_pages.
--- include/linux/hugetlb.h | 4 ++-- mm/hugetlb.c | 4 ++-- mm/memory-failure.c | 12 ++++++++++-- 3 files changed, 14 insertions(+), 6 deletions(-)
include/linux/hugetlb.h +2 -2
@@ -181,7 +181,7 @@ bool hugetlb_reserve_pages(struct inode *inode, long from, long to,long hugetlb_unreserve_pages (struct inode *inode,long start,long end,long freed);int isolate_hugetlb (struct page *page,struct list_head *list); -int get_hwpoison_huge_page (struct page *page,bool *hugetlb); +int get_hwpoison_huge_page (struct page *page,bool *hugetlb,bool unpoison);int get_huge_page_for_hwpoison (unsigned long pfn,int flags);void putback_active_hugepage (struct page *page);void move_hugetlb_state (struct page *oldpage,struct page *newpage,int reason);
@@ -425,7 +425,7 @@ static inline int isolate_hugetlb(struct page *page, struct list_head *list)return -EBUSY ; } -static inline int get_hwpoison_huge_page (struct page *page,bool *hugetlb) +static inline int get_hwpoison_huge_page (struct page *page,bool *hugetlb,bool unpoison) {return 0 ; }
mm/hugetlb.c +2 -2
@@ -7257,7 +7257,7 @@ int isolate_hugetlb(struct page *page, struct list_head *list)return ret; } -int get_hwpoison_huge_page (struct page *page,bool *hugetlb) +int get_hwpoison_huge_page (struct page *page,bool *hugetlb,bool unpoison) {int ret =0 ;
@@ -7267,7 +7267,7 @@ int get_hwpoison_huge_page(struct page *page, bool *hugetlb) *hugetlb = true;if (HPageFreed (page)) ret =0 ; -else if (HPageMigratable (page)) +else if (HPageMigratable (page) || unpoison) ret =get_page_unless_zero (page);else ret = -EBUSY ;
mm/memory-failure.c +10 -2
@@ -1244,7 +1244,7 @@ static int __get_hwpoison_page(struct page *page, unsigned long flags)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, false);if (hugetlb)return ret;
@@ -1334,7 +1334,7 @@ static int __get_unpoison_page(struct page *page)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, true);if (hugetlb)return ret;
@@ -1815,6 +1815,13 @@ int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) goto out; } +/* +* Clearing HPageMigratable for hwpoisoned hugepages to prevent them +* from being migrated by memory hotremove. +*/ +if (count_increased) +ClearHPageMigratable (head); +return ret; out:if (count_increased)
@@ -1862,6 +1869,7 @@ static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlbif (hwpoison_filter (p)) {hugetlb_clear_page_hwpoison (head); +SetHPageMigratable (head);unlock_page (head);if (res ==1 )put_page (head);
Signature · 1 line
2.25.1
Miaohe Lin
maintainerRe: [PATCH v3 1/4] mm,hwpoison,hugetlb,memory_hotplug: hotremove memory section with hwpoisoned hugepage
Quoted 10 lines · Naoya Horiguchi
From: Naoya Horiguchi <[email protected]>
HWPoisoned page is not supposed to be accessed once marked, but currently such accesses can happen during memory hotremove because
do_migrate_range()can be called beforedissolve_free_huge_pages()is called.Clear HPageMigratable for hwpoisoned hugepages to prevent them from being migrated. This should be done in
hugetlb_lockto avoid race againstisolate_hugetlb().
Quoted 5 lines
get_hwpoison_huge_page()needs to have a flag to show it's called from unpoison to take refcount of hwpoisoned hugepages, so add it.Reported-by Miaohe Lin <[email protected]>Signed-off-by Naoya Horiguchi <[email protected]>
Thanks for your work, Naoya. Maybe something to improve below.
Quoted 10 lines
---
ChangeLog v2 -> v3
- move to the approach of clearing HPageMigratable instead of shiftingdissolve_free_huge_pages.--- include/linux/hugetlb.h | 4 ++-- mm/hugetlb.c | 4 ++-- mm/memory-failure.c | 12 ++++++++++-- 3 files changed, 14 insertions(+), 6 deletions(-)
<snip>
mm/hugetlb.c int get_hwpoison_huge_page(struct page *page, bool *hugetlb) · line 7270
Quoted 6 lines
mm/hugetlb.c +1
-1@@ -7267,7 +7267,7 @@ int get_hwpoison_huge_page(struct page *page, bool *hugetlb) *hugetlb = true;if (HPageFreed (page)) ret =0 ; -else if (HPageMigratable (page)) +else if (HPageMigratable (page) || unpoison)
Is unpoison_memory() expected to restore the HPageMigratable flag as well ?
Quoted 26 lines
mm/hugetlb.c +0
-0ret =get_page_unless_zero (page); else ret = -EBUSY ;mm/memory-failure.c +2
-2@@ -1244,7 +1244,7 @@ static int __get_hwpoison_page(struct page *page, unsigned long flags)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, false);if (hugetlb)return ret;@@ -1334,7 +1334,7 @@ static int __get_unpoison_page(struct page *page)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, true);if (hugetlb)return ret;
mm/memory-failure.c int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) · line 1823
Quoted 9 lines
mm/memory-failure.c +6
-0@@ -1815,6 +1815,13 @@ int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) goto out; } +/* +* Clearing HPageMigratable for hwpoisoned hugepages to prevent them +* from being migrated by memory hotremove. +*/ +if (count_increased) +ClearHPageMigratable (head);
I believe this can prevent hwpoisoned hugepages from being migrated though there still be some windows.
mm/memory-failure.c static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlb · line 1872
Quoted 9 lines
mm/memory-failure.c +2
-0+return ret; out:if (count_increased)@@ -1862,6 +1869,7 @@ static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlbif (hwpoison_filter (p)) {hugetlb_clear_page_hwpoison (head); +SetHPageMigratable (head);
Would we set HPageMigratable flag for free hugetlb pages here? IIUC, they're not expected to have this flag set.
Thanks,
Miaohe Lin
Quoted 4 lines
mm/memory-failure.c +0
-0unlock_page (head);if (res ==1 )put_page (head);
Re: [PATCH v3 1/4] mm,hwpoison,hugetlb,memory_hotplug: hotremove memory section with hwpoisoned hugepage
Quoted 32 lines · Miaohe Lin
Quoted 10 lines · Naoya Horiguchi
From: Naoya Horiguchi <[email protected]>
HWPoisoned page is not supposed to be accessed once marked, but currently such accesses can happen during memory hotremove because
do_migrate_range()can be called beforedissolve_free_huge_pages()is called.Clear HPageMigratable for hwpoisoned hugepages to prevent them from being migrated. This should be done in
hugetlb_lockto avoid race againstisolate_hugetlb().Quoted 5 lines
get_hwpoison_huge_page()needs to have a flag to show it's called from unpoison to take refcount of hwpoisoned hugepages, so add it.Reported-by Miaohe Lin <[email protected]>Signed-off-by Naoya Horiguchi <[email protected]>Thanks for your work, Naoya. Maybe something to improve below.
Quoted 10 lines
---
ChangeLog v2 -> v3
- move to the approach of clearing HPageMigratable instead of shiftingdissolve_free_huge_pages.--- include/linux/hugetlb.h | 4 ++-- mm/hugetlb.c | 4 ++-- mm/memory-failure.c | 12 ++++++++++-- 3 files changed, 14 insertions(+), 6 deletions(-)<snip>
Quoted 8 lines
mm/hugetlb.c int get_hwpoison_huge_page(struct page *page, bool *hugetlb) · line 7270
Quoted 6 lines
mm/hugetlb.c +1
-1@@ -7267,7 +7267,7 @@ int get_hwpoison_huge_page(struct page *page, bool *hugetlb) *hugetlb = true;if (HPageFreed (page)) ret =0 ; -else if (HPageMigratable (page)) +else if (HPageMigratable (page) || unpoison)Is
unpoison_memory()expected to restore the HPageMigratable flag as well ?
No it isn't. When unpoison_memory() unpoisons a hugepage, the hugepage is sent back to free hugepage pool, so I think that there's no need to restore HPageMigratable for it.
Quoted 30 lines
Quoted 30 lines
mm/hugetlb.c +0
-0ret =get_page_unless_zero (page); else ret = -EBUSY ;mm/memory-failure.c +2
-2@@ -1244,7 +1244,7 @@ static int __get_hwpoison_page(struct page *page, unsigned long flags)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, false);if (hugetlb)return ret;@@ -1334,7 +1334,7 @@ static int __get_unpoison_page(struct page *page)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, true);if (hugetlb)return ret;@@ -1815,6 +1815,13 @@ int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) goto out; }
Quoted 8 lines
mm/memory-failure.c int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) · line 1823
Quoted 6 lines
mm/memory-failure.c +6
-0+/* +* Clearing HPageMigratable for hwpoisoned hugepages to prevent them +* from being migrated by memory hotremove. +*/ +if (count_increased) +ClearHPageMigratable (head);I believe this can prevent hwpoisoned hugepages from being migrated though there still be some windows.
I'm not sure of "still racy" part, so could you elaborate it? Main scenario this patch tries to handle is like below:
CPU 0 CPU 1
get_huge_page_for_hwpoison
// take hugetlb_lock
__get_huge_page_for_hwpoison
scan_movable_pages
if HPageMigratable
goto found
do_migrate_range
if HPageMigratable
get_page_unless_zero
hugetlb_set_page_hwpoison
ClearHPageMigratable
// release hugetlb_lock
isolate_hugetlb
// take hugetlb_lock
if !HPageMigratable
// fails to isolate the hwpoisoned hugetlb.Maybe the following could be possible.
CPU 0 CPU 1
scan_movable_pages
if HPageMigratable
goto found
do_migrate_range
isolate_hugetlb
// the hugetlb is isolated,
// but it's not hwpoisoned yet.
get_huge_page_for_hwpoison
// take hugetlb_lock
__get_huge_page_for_hwpoison
if HPageMigratable
get_page_unless_zero
hugetlb_set_page_hwpoison
ClearHPageMigratable
// release hugetlb_lockIn this case, the hugepage is maybe broken but not marked as hwpoison yet, so it's not detectable.
Quoted 7 lines
Quoted 7 lines
mm/memory-failure.c +1
-0+return ret; out:if (count_increased)@@ -1862,6 +1869,7 @@ static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlb
Quoted 5 lines
mm/memory-failure.c static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlb · line 1872
Quoted 3 lines
mm/memory-failure.c +1
-0if (hwpoison_filter (p)) {hugetlb_clear_page_hwpoison (head); +SetHPageMigratable (head);Would we set HPageMigratable flag for free hugetlb pages here? IIUC, they're not expected to have this flag set.
Thank you, you're right. This should be done in "if (res == 1)" block. (hwpoison_filter often bothers me ...)
Quoted 3 lines
Thanks,
Miaohe Lin
Thank you very much!
- Naoya Horiguchi
Miaohe Lin
maintainerRe: [PATCH v3 1/4] mm,hwpoison,hugetlb,memory_hotplug: hotremove memory section with hwpoisoned hugepage
Quoted 42 lines · Naoya Horiguchi
Quoted 32 lines · Miaohe Lin
Quoted 10 lines · Naoya Horiguchi
From: Naoya Horiguchi <[email protected]>
HWPoisoned page is not supposed to be accessed once marked, but currently such accesses can happen during memory hotremove because
do_migrate_range()can be called beforedissolve_free_huge_pages()is called.Clear HPageMigratable for hwpoisoned hugepages to prevent them from being migrated. This should be done in
hugetlb_lockto avoid race againstisolate_hugetlb().Quoted 5 lines
get_hwpoison_huge_page()needs to have a flag to show it's called from unpoison to take refcount of hwpoisoned hugepages, so add it.Reported-by Miaohe Lin <[email protected]>Signed-off-by Naoya Horiguchi <[email protected]>Thanks for your work, Naoya. Maybe something to improve below.
Quoted 10 lines
---
ChangeLog v2 -> v3
- move to the approach of clearing HPageMigratable instead of shiftingdissolve_free_huge_pages.--- include/linux/hugetlb.h | 4 ++-- mm/hugetlb.c | 4 ++-- mm/memory-failure.c | 12 ++++++++++-- 3 files changed, 14 insertions(+), 6 deletions(-)<snip>
Quoted 8 lines
mm/hugetlb.c int get_hwpoison_huge_page(struct page *page, bool *hugetlb) · line 7270
Quoted 6 lines
mm/hugetlb.c +1
-1@@ -7267,7 +7267,7 @@ int get_hwpoison_huge_page(struct page *page, bool *hugetlb) *hugetlb = true;if (HPageFreed (page)) ret =0 ; -else if (HPageMigratable (page)) +else if (HPageMigratable (page) || unpoison)Is
unpoison_memory()expected to restore the HPageMigratable flag as well ?
Quoted 3 lines
No it isn't. When
unpoison_memory()unpoisons a hugepage, the hugepage is sent back to free hugepage pool, so I think that there's no need to restore HPageMigratable for it.
I tend to agree with you.
Quoted 64 lines
Quoted 31 lines
Quoted 31 lines
mm/hugetlb.c +0
-0ret =get_page_unless_zero (page); else ret = -EBUSY ;mm/memory-failure.c +2
-2@@ -1244,7 +1244,7 @@ static int __get_hwpoison_page(struct page *page, unsigned long flags)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, false);if (hugetlb)return ret;@@ -1334,7 +1334,7 @@ static int __get_unpoison_page(struct page *page)int ret =0 ;bool hugetlb = false; - ret =get_hwpoison_huge_page (head, &hugetlb); + ret =get_hwpoison_huge_page (head, &hugetlb, true);if (hugetlb)return ret;@@ -1815,6 +1815,13 @@ int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) goto out; }Quoted 8 lines
mm/memory-failure.c int __get_huge_page_for_hwpoison(unsigned long pfn, int flags) · line 1823
Quoted 6 lines
mm/memory-failure.c +6
-0+/* +* Clearing HPageMigratable for hwpoisoned hugepages to prevent them +* from being migrated by memory hotremove. +*/ +if (count_increased) +ClearHPageMigratable (head);I believe this can prevent hwpoisoned hugepages from being migrated though there still be some windows.
I'm not sure of "still racy" part, so could you elaborate it? Main scenario this patch tries to handle is like below:
CPU 0 CPU 1
get_huge_page_for_hwpoison// take hugetlb_lock __get_huge_page_for_hwpoison scan_movable_pages if HPageMigratable goto found do_migrate_range if HPageMigratable get_page_unless_zero hugetlb_set_page_hwpoison ClearHPageMigratable // release hugetlb_lock isolate_hugetlb // take hugetlb_lock if !HPageMigratable // fails to isolate the hwpoisoned hugetlb.Maybe the following could be possible.
CPU 0 CPU 1
Quoted 15 lines
scan_movable_pages
if HPageMigratable
goto found
do_migrate_range
isolate_hugetlb
// the hugetlb is isolated,
// but it's not hwpoisoned yet.
get_huge_page_for_hwpoison
// take hugetlb_lock
__get_huge_page_for_hwpoison
if HPageMigratable
get_page_unless_zero
hugetlb_set_page_hwpoison
ClearHPageMigratable
// release hugetlb_lockYes, this is what I mean. For already isolated hugetlb pages, HPageMigratable flags can't help much.
Quoted 11 lines
In this case, the hugepage is maybe broken but not marked as hwpoison yet, so it's not detectable.
Quoted 7 lines
Quoted 7 lines
mm/memory-failure.c +1
-0+return ret; out:if (count_increased)@@ -1862,6 +1869,7 @@ static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlb
Quoted 7 lines
Quoted 5 lines
mm/memory-failure.c static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlb · line 1872
Quoted 3 lines
mm/memory-failure.c +1
-0if (hwpoison_filter (p)) {hugetlb_clear_page_hwpoison (head); +SetHPageMigratable (head);Would we set HPageMigratable flag for free hugetlb pages here? IIUC, they're not expected to have this flag set.
Thank you, you're right. This should be done in "if (res == 1)" block.
If res == 1, it means hugetlb page refcnt is incremented. But it seems this does not necessarily mean HPageMigratable is cleared by __get_huge_page_for_hwpoison() if the hugetlb page is already isolated. If so, we might set HPageMigratable flag back for already isolated hugetlb pages?
Quoted 1 line
(
hwpoison_filteroften bothers me ...)
Agree, hwpoison_filter() makes things more complicated. ;)
Thanks,
Miaohe Lin
Quoted 9 lines
Quoted 4 lines
Thanks,
Miaohe LinThank you very much!
- Naoya Horiguchi
.
Re: [PATCH v3 1/4] mm,hwpoison,hugetlb,memory_hotplug: hotremove memory section with hwpoisoned hugepage
Quoted 2 lines · Miaohe Lin
Quoted 1 line · Naoya Horiguchi
Quoted 1 line
Quoted 1 line
(quoted diff) +0
-0@@ -1815,6 +1815,13 @@ int __get_huge_page_for_hwpoison(unsigned long pfn, int flags)
...
Quoted 8 lines
Quoted 8 lines
Quoted 7 lines
mm/memory-failure.c static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlb · line 1872
Quoted 5 lines
mm/memory-failure.c +1
-0@@ -1862,6 +1869,7 @@ static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlbif (hwpoison_filter (p)) {hugetlb_clear_page_hwpoison (head); +SetHPageMigratable (head);Would we set HPageMigratable flag for free hugetlb pages here? IIUC, they're not expected to have this flag set.
Quoted 5 lines
Quoted 1 line
Thank you, you're right. This should be done in "if (res == 1)" block.
If res == 1, it means hugetlb page refcnt is incremented. But it seems this does not necessarily mean HPageMigratable is cleared by
__get_huge_page_for_hwpoison()if the hugetlb page is already isolated. If so, we might set HPageMigratable flag back for already isolated hugetlb pages?
# sorry for my late reply, I was busy with personal matters these days...
Yes, that could happen (and also in the case where MF_COUNT_INCREASED is set). We need store whether HPageMigratable flag is cleared or not in __get_huge_page_for_hwpoison(). I'll add a parameter to __get_huge_page_for_hwpoison() to return the flag change to the caller. But I also think that there're a few internal states during error handling, so it might be good to add some structure like "struct hwpoison_control" to save such internal states over related functions (not in this series).
Thanks,
Naoya Horiguchi
Miaohe Lin
maintainerRe: [PATCH v3 1/4] mm,hwpoison,hugetlb,memory_hotplug: hotremove memory section with hwpoisoned hugepage
Quoted 12 lines · HORIGUCHI NAOYA(堀口 直也)
Quoted 2 lines · Miaohe Lin
Quoted 1 line · Naoya Horiguchi
Quoted 1 line
Quoted 1 line
(quoted diff) +0
-0@@ -1815,6 +1815,13 @@ int __get_huge_page_for_hwpoison(unsigned long pfn, int flags)...
Quoted 8 lines
Quoted 8 lines
Quoted 7 lines
mm/memory-failure.c static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlb · line 1872
Quoted 5 lines
mm/memory-failure.c +1
-0@@ -1862,6 +1869,7 @@ static int try_memory_failure_hugetlb(unsigned long pfn, int flags, int *hugetlbif (hwpoison_filter (p)) {hugetlb_clear_page_hwpoison (head); +SetHPageMigratable (head);Would we set HPageMigratable flag for free hugetlb pages here? IIUC, they're not expected to have this flag set.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Thank you, you're right. This should be done in "if (res == 1)" block.
If res == 1, it means hugetlb page refcnt is incremented. But it seems this does not necessarily mean HPageMigratable is cleared by
__get_huge_page_for_hwpoison()if the hugetlb page is already isolated. If so, we might set HPageMigratable flag back for already isolated hugetlb pages?# sorry for my late reply, I was busy with personal matters these days...
That's all right. I was back from my vacation too. Thanks for your work. :)
Quoted 8 lines
Yes, that could happen (and also in the case where
MF_COUNT_INCREASEDis set). We need store whether HPageMigratable flag is cleared or not in__get_huge_page_for_hwpoison(). I'll add a parameter to__get_huge_page_for_hwpoison()to return the flag change to the caller. But I also think that there're a few internal states during error handling, so it might be good to add some structure like "structhwpoison_control" to save such internal states over related functions (not in this series).
That sounds like a good idea.
Thanks,
Miaohe Lin
Quoted 4 lines
Thanks,
Naoya Horiguchi
PATCH v3 2/4 mm/hwpoison: move definitions of num_poisoned_pages_* to memory-failure.c
In reply to Naoya HoriguchiFrom: Naoya Horiguchi <[email protected]>
These interfaces will be used by drivers/base/core.c by later patch, so as a preparatory work move them to more common header file visible to the file.
---
ChangeLog v2 -> v3:
- added declaration of num_poisoned_pages_inc() in #ifdef CONFIG_MEMORY_FAILURE
--- arch/parisc/kernel/pdt.c | 3 +-- include/linux/mm.h | 5 +++++ include/linux/swapops.h | 24 ++---------------------- mm/memory-failure.c | 10 ++++++++++ 4 files changed, 18 insertions(+), 24 deletions(-)
arch/parisc/kernel/pdt.c +1 -2
@@ -18,8 +18,7 @@#include <linux/kthread.h> #include <linux/initrd.h> #include <linux/pgtable.h> -#include <linux/swap.h> -#include <linux/swapops.h> +#include <linux/mm.h> #include <asm/pdc.h> #include <asm/pdcpat.h>
include/linux/mm.h +5 -0
@@ -3279,11 +3279,16 @@ extern atomic_long_t num_poisoned_pages __read_mostly;extern int soft_offline_page (unsigned long pfn,int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags); +extern void num_poisoned_pages_inc (void );#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {return 0 ; } + +static inline void num_poisoned_pages_inc (void ) +{ +}#endif #ifndef arch_memory_failure
include/linux/swapops.h +2 -22
@@ -581,8 +581,6 @@ static inline int is_pmd_migration_entry(pmd_t pmd)#ifdef CONFIG_MEMORY_FAILURE -extern atomic_long_t num_poisoned_pages__read_mostly ; -/* * Support for hardware poisoned pages */
@@ -610,17 +608,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) return p; } -static inline void num_poisoned_pages_inc (void ) -{ -atomic_long_inc (&num_poisoned_pages); -} - -static inline void num_poisoned_pages_sub (long i) -{ -atomic_long_sub (i, &num_poisoned_pages); -} - -#else /* CONFIG_MEMORY_FAILURE */ +#else static inline swp_entry_t make_hwpoison_entry (struct page *page) {
@@ -636,15 +624,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) {return NULL ; } - -static inline void num_poisoned_pages_inc (void ) -{ -} - -static inline void num_poisoned_pages_sub (long i) -{ -} -#endif /* CONFIG_MEMORY_FAILURE */ +#endif static inline int non_swap_entry (swp_entry_t entry) {
mm/memory-failure.c +10 -0
@@ -74,6 +74,16 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);static bool hw_memory_failure__read_mostly = false; +static inline void num_poisoned_pages_inc (void ) +{ +atomic_long_inc (&num_poisoned_pages); +} + +static inline void num_poisoned_pages_sub (long i) +{ +atomic_long_sub (i, &num_poisoned_pages); +} +/* * Return values: * 1: the page is dissolved (if needed) and taken off from buddy,
Signature · 1 line
2.25.1
Miaohe Lin
maintainerRe: [PATCH v3 2/4] mm/hwpoison: move definitions of num_poisoned_pages_* to memory-failure.c
Quoted 21 lines · Naoya Horiguchi
From: Naoya Horiguchi <[email protected]>
These interfaces will be used by
drivers/base/core.cby later patch, so as a preparatory work move them to more common header file visible to the file.Signed-off-by Naoya Horiguchi <[email protected]>---
ChangeLog v2 -> v3:
- added declaration ofnum_poisoned_pages_inc()in #ifdefCONFIG_MEMORY_FAILURE--- arch/parisc/kernel/pdt.c | 3 +-- include/linux/mm.h | 5 +++++ include/linux/swapops.h | 24 ++---------------------- mm/memory-failure.c | 10 ++++++++++ 4 files changed, 18 insertions(+), 24 deletions(-)arch/parisc/kernel/pdt.c +0
-0
arch/parisc/kernel/pdt.c line 21
Quoted 4 lines
arch/parisc/kernel/pdt.c +0
-1@@ -18,8 +18,7 @@#include <linux/kthread.h> #include <linux/initrd.h> #include <linux/pgtable.h> -#include <linux/swap.h>
Is header file "linux/swap.h" already unneeded before the code change? It seems there's no code change in that file.
Quoted 80 lines
arch/parisc/kernel/pdt.c +1
-1-#include <linux/swapops.h> +#include <linux/mm.h> #include <asm/pdc.h> #include <asm/pdcpat.h> include/linux/mm.h +5
-0@@ -3279,11 +3279,16 @@ extern atomic_long_t num_poisoned_pages __read_mostly;extern int soft_offline_page (unsigned long pfn,int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags); +extern void num_poisoned_pages_inc (void );#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {return 0 ; } + +static inline void num_poisoned_pages_inc (void ) +{ +}#endif #ifndef arch_memory_failureinclude/linux/swapops.h +2
-22@@ -581,8 +581,6 @@ static inline int is_pmd_migration_entry(pmd_t pmd)#ifdef CONFIG_MEMORY_FAILURE -extern atomic_long_t num_poisoned_pages__read_mostly ; -/* * Support for hardware poisoned pages */ @@ -610,17 +608,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) return p; } -static inline void num_poisoned_pages_inc (void ) -{ -atomic_long_inc (&num_poisoned_pages); -} - -static inline void num_poisoned_pages_sub (long i) -{ -atomic_long_sub (i, &num_poisoned_pages); -} - -#else /* CONFIG_MEMORY_FAILURE */ +#else static inline swp_entry_t make_hwpoison_entry (struct page *page) {@@ -636,15 +624,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) {return NULL ; } - -static inline void num_poisoned_pages_inc (void ) -{ -} - -static inline void num_poisoned_pages_sub (long i) -{ -} -#endif /* CONFIG_MEMORY_FAILURE */ +#endif static inline int non_swap_entry (swp_entry_t entry) {mm/memory-failure.c +0
-0
mm/memory-failure.c atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0); · line 77
Quoted 4 lines
mm/memory-failure.c +1
-0@@ -74,6 +74,16 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);static bool hw_memory_failure__read_mostly = false; +static inline void num_poisoned_pages_inc (void )
This function is defined as "static inline" while it's "extern void num_poisoned_pages_inc(void)" in the header file. Is this expected?
Thanks,
Miaohe Lin
Quoted 13 lines
mm/memory-failure.c +9
-0+{ +atomic_long_inc (&num_poisoned_pages); +} + +static inline void num_poisoned_pages_sub (long i) +{ +atomic_long_sub (i, &num_poisoned_pages); +} +/* * Return values: * 1: the page is dissolved (if needed) and taken off from buddy,
Re: [PATCH v3 2/4] mm/hwpoison: move definitions of num_poisoned_pages_* to memory-failure.c
Quoted 17 lines · Miaohe Lin
Quoted 16 lines · Naoya Horiguchi
From: Naoya Horiguchi <[email protected]>
These interfaces will be used by
drivers/base/core.cby later patch, so as a preparatory work move them to more common header file visible to the file.Signed-off-by Naoya Horiguchi <[email protected]>---
ChangeLog v2 -> v3:
- added declaration ofnum_poisoned_pages_inc()in #ifdefCONFIG_MEMORY_FAILURE--- arch/parisc/kernel/pdt.c | 3 +-- include/linux/mm.h | 5 +++++ include/linux/swapops.h | 24 ++---------------------- mm/memory-failure.c | 10 ++++++++++ 4 files changed, 18 insertions(+), 24 deletions(-)
Quoted 12 lines
arch/parisc/kernel/pdt.c line 21
Quoted 9 lines
arch/parisc/kernel/pdt.c +0
-1@@ -18,8 +18,7 @@#include <linux/kthread.h> #include <linux/initrd.h> #include <linux/pgtable.h> -#include <linux/swap.h> Is header file "
linux/swap.h" already unneeded before the code change? It seems there's no code change in that file.
Maybe yes. I updated this line too because it's introduced together swapops.h by the following commit.
commit 0e5a7ff6e36ad58933d076ddcac36ff14d014692
Author: Helge Deller <[email protected]>
Date: Fri Jul 24 19:17:52 2020 +0200
parisc: Report bad pages as HardwareCorrupted
Quoted 82 lines
Quoted 82 lines
arch/parisc/kernel/pdt.c +1
-1-#include <linux/swapops.h> +#include <linux/mm.h> #include <asm/pdc.h> #include <asm/pdcpat.h> include/linux/mm.h +5
-0@@ -3279,11 +3279,16 @@ extern atomic_long_t num_poisoned_pages __read_mostly;extern int soft_offline_page (unsigned long pfn,int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags); +extern void num_poisoned_pages_inc (void );#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {return 0 ; } + +static inline void num_poisoned_pages_inc (void ) +{ +}#endif #ifndef arch_memory_failureinclude/linux/swapops.h +2
-22@@ -581,8 +581,6 @@ static inline int is_pmd_migration_entry(pmd_t pmd)#ifdef CONFIG_MEMORY_FAILURE -extern atomic_long_t num_poisoned_pages__read_mostly ; -/* * Support for hardware poisoned pages */ @@ -610,17 +608,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) return p; } -static inline void num_poisoned_pages_inc (void ) -{ -atomic_long_inc (&num_poisoned_pages); -} - -static inline void num_poisoned_pages_sub (long i) -{ -atomic_long_sub (i, &num_poisoned_pages); -} - -#else /* CONFIG_MEMORY_FAILURE */ +#else static inline swp_entry_t make_hwpoison_entry (struct page *page) {@@ -636,15 +624,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) {return NULL ; } - -static inline void num_poisoned_pages_inc (void ) -{ -} - -static inline void num_poisoned_pages_sub (long i) -{ -} -#endif /* CONFIG_MEMORY_FAILURE */ +#endif static inline int non_swap_entry (swp_entry_t entry) {mm/memory-failure.c +0
-0@@ -74,6 +74,16 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);
Quoted 6 lines
mm/memory-failure.c atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0); · line 77
Quoted 3 lines
mm/memory-failure.c +1
-0static bool hw_memory_failure__read_mostly = false; +static inline void num_poisoned_pages_inc (void )This function is defined as "static inline" while it's "extern void
num_poisoned_pages_inc(void)" in the header file. Is this expected?
No. 4/4 effectively fixes it, but I should've done this in this patch. Thank you,
- Naoya Horiguchi
Quoted 18 lines
Thanks,
Miaohe LinQuoted 13 lines
mm/memory-failure.c +9
-0+{ +atomic_long_inc (&num_poisoned_pages); +} + +static inline void num_poisoned_pages_sub (long i) +{ +atomic_long_sub (i, &num_poisoned_pages); +} +/* * Return values: * 1: the page is dissolved (if needed) and taken off from buddy,
Re: [PATCH v3 2/4] mm/hwpoison: move definitions of num_poisoned_pages_* to memory-failure.c
Quoted 31 lines · Naoya Horiguchi
Quoted 17 lines · Miaohe Lin
Quoted 16 lines · Naoya Horiguchi
From: Naoya Horiguchi <[email protected]>
These interfaces will be used by
drivers/base/core.cby later patch, so as a preparatory work move them to more common header file visible to the file.Signed-off-by Naoya Horiguchi <[email protected]>---
ChangeLog v2 -> v3:
- added declaration ofnum_poisoned_pages_inc()in #ifdefCONFIG_MEMORY_FAILURE--- arch/parisc/kernel/pdt.c | 3 +-- include/linux/mm.h | 5 +++++ include/linux/swapops.h | 24 ++---------------------- mm/memory-failure.c | 10 ++++++++++ 4 files changed, 18 insertions(+), 24 deletions(-)Quoted 12 lines
arch/parisc/kernel/pdt.c line 21
Quoted 9 lines
arch/parisc/kernel/pdt.c +0
-1@@ -18,8 +18,7 @@#include <linux/kthread.h> #include <linux/initrd.h> #include <linux/pgtable.h> -#include <linux/swap.h> Is header file "
linux/swap.h" already unneeded before the code change? It seems there's no code change in that file.
Quoted 9 lines
Maybe yes. I updated this line too because it's introduced together
swapops.hby the following commit.commit
0e5a7ff6e36ad58933d076ddcac36ff14d014692
Author: Helge Deller <[email protected]>
Date: Fri Jul 24 19:17:52 2020 +0200parisc: Report bad pages as HardwareCorrupted
I see. Many thanks for your explanation.
Quoted 84 lines
Quoted 84 lines
Quoted 84 lines
arch/parisc/kernel/pdt.c +1
-1-#include <linux/swapops.h> +#include <linux/mm.h> #include <asm/pdc.h> #include <asm/pdcpat.h> include/linux/mm.h +5
-0@@ -3279,11 +3279,16 @@ extern atomic_long_t num_poisoned_pages __read_mostly;extern int soft_offline_page (unsigned long pfn,int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags); +extern void num_poisoned_pages_inc (void );#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {return 0 ; } + +static inline void num_poisoned_pages_inc (void ) +{ +}#endif #ifndef arch_memory_failureinclude/linux/swapops.h +2
-22@@ -581,8 +581,6 @@ static inline int is_pmd_migration_entry(pmd_t pmd)#ifdef CONFIG_MEMORY_FAILURE -extern atomic_long_t num_poisoned_pages__read_mostly ; -/* * Support for hardware poisoned pages */ @@ -610,17 +608,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) return p; } -static inline void num_poisoned_pages_inc (void ) -{ -atomic_long_inc (&num_poisoned_pages); -} - -static inline void num_poisoned_pages_sub (long i) -{ -atomic_long_sub (i, &num_poisoned_pages); -} - -#else /* CONFIG_MEMORY_FAILURE */ +#else static inline swp_entry_t make_hwpoison_entry (struct page *page) {@@ -636,15 +624,7 @@ static inline struct page *hwpoison_entry_to_page(swp_entry_t entry) {return NULL ; } - -static inline void num_poisoned_pages_inc (void ) -{ -} - -static inline void num_poisoned_pages_sub (long i) -{ -} -#endif /* CONFIG_MEMORY_FAILURE */ +#endif static inline int non_swap_entry (swp_entry_t entry) {mm/memory-failure.c +0
-0@@ -74,6 +74,16 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);static bool hw_memory_failure__read_mostly = false;
Quoted 8 lines
Quoted 4 lines
mm/memory-failure.c atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0); · line 77
Quoted 1 line
mm/memory-failure.c +1
-0+static inline void num_poisoned_pages_inc (void )This function is defined as "static inline" while it's "extern void
num_poisoned_pages_inc(void)" in the header file. Is this expected?No. 4/4 effectively fixes it, but I should've done this in this patch. Thank you,
- Naoya Horiguchi
Then this patch looks good to me. Thanks.
Thanks,
Miaohe Lin
PATCH v3 3/4 mm/hwpoison: pass pfn to num_poisoned_pages_*()
In reply to Naoya HoriguchiFrom: Naoya Horiguchi <[email protected]>
No functional change.
---
ChangeLog v2 -> v3:
- added declaration of num_poisoned_pages_inc() in #ifdef CONFIG_MEMORY_FAILURE
--- arch/parisc/kernel/pdt.c | 2 +- include/linux/mm.h | 4 ++-- mm/memory-failure.c | 12 ++++++------ 3 files changed, 9 insertions(+), 9 deletions(-)
arch/parisc/kernel/pdt.c +1 -1
@@ -231,7 +231,7 @@ void __init pdc_pdt_init(void)/* mark memory page bad */ memblock_reserve (pdt_entry[i] &PAGE_MASK ,PAGE_SIZE ); -num_poisoned_pages_inc (); +num_poisoned_pages_inc (addr >>PAGE_SHIFT ); } }
include/linux/mm.h +2 -2
@@ -3279,14 +3279,14 @@ extern atomic_long_t num_poisoned_pages __read_mostly;extern int soft_offline_page (unsigned long pfn,int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags); -extern void num_poisoned_pages_inc (void ); +extern void num_poisoned_pages_inc (unsigned long pfn);#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {return 0 ; } -static inline void num_poisoned_pages_inc (void ) +static inline void num_poisoned_pages_inc (unsigned long pfn) { }#endif
mm/memory-failure.c +6 -6
@@ -74,12 +74,12 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);static bool hw_memory_failure__read_mostly = false; -static inline void num_poisoned_pages_inc (void ) +static inline void num_poisoned_pages_inc (unsigned long pfn) {atomic_long_inc (&num_poisoned_pages); } -static inline void num_poisoned_pages_sub (long i) +static inline void num_poisoned_pages_sub (unsigned long pfn,long i) {atomic_long_sub (i, &num_poisoned_pages); }
@@ -125,7 +125,7 @@ static bool page_handle_poison(struct page *page, bool hugepage_or_freepage, booif (release)put_page (page);page_ref_inc (page); -num_poisoned_pages_inc (); +num_poisoned_pages_inc (page_to_pfn (page));return true; }
@@ -1194,7 +1194,7 @@ static void action_result(unsigned long pfn, enum mf_action_page_type type, {trace_memory_failure_event (pfn, type, result); -num_poisoned_pages_inc (); +num_poisoned_pages_inc (pfn);pr_err ("%#lx: recovery action for %s: %s\n" , pfn, action_page_types[type], action_name[result]); }
@@ -1741,7 +1741,7 @@ static int hugetlb_set_page_hwpoison(struct page *hpage, struct page *page)llist_add (&raw_hwp->node, head);/* the first error event will be counted in action_result(). */ if (ret) -num_poisoned_pages_inc (); +num_poisoned_pages_inc (page_to_pfn (page)); }else {/* * Failed to save raw error info. We no longer trace all
@@ -2414,7 +2414,7 @@ int unpoison_memory(unsigned long pfn) unlock_mutex:mutex_unlock (&mf_mutex);if (!ret || freeit) { -num_poisoned_pages_sub (count); +num_poisoned_pages_sub (pfn, count);unpoison_pr_info ("Unpoison: Software-unpoisoned page %#lx\n" ,page_to_pfn (p), &unpoison_rs); }
Signature · 1 line
2.25.1
PATCH v3 4/4 mm/hwpoison: introduce per-memory_block hwpoison counter
In reply to Naoya HoriguchiFrom: Naoya Horiguchi <[email protected]>
Currently PageHWPoison flag does not behave well when experiencing memory hotremove/hotplug. Any data field in struct page is unreliable when the associated memory is offlined, and the current mechanism can't tell whether a memory section is onlined because a new memory devices is installed or because previous failed offline operations are undone. Especially if there's a hwpoisoned memory, it's unclear what the best option is.
So introduce a new mechanism to make struct memory_block remember that a memory block has hwpoisoned memory inside it. And make any online event fail if the onlined memory block contains hwpoison. struct memory_block is freed and reallocated over ACPI-based hotremove/hotplug, but not over sysfs-based hotremove/hotplug. So it's desirable to implement hwpoison counter on this struct.
Note that clear_hwpoisoned_pages() is relocated to be called earlier than now, just before unregistering struct memory_block. Otherwise, the per-memory_block hwpoison counter is freed and we fail to adjust global hwpoison counter properly.
--- drivers/base/memory.c | 36 ++++++++++++++++++++++++++++++++++++ include/linux/memory.h | 3 +++ include/linux/mm.h | 8 ++++++++ mm/internal.h | 8 -------- mm/memory-failure.c | 31 ++++++++++--------------------- mm/sparse.c | 2 -- 6 files changed, 57 insertions(+), 31 deletions(-)
drivers/base/memory.c +36 -0
@@ -183,6 +183,9 @@ static int memory_block_online(struct memory_block *mem)struct zone *zone;int ret; +if (atomic_long_read (&mem->nr_hwpoison)) +return -EHWPOISON ; + zone =zone_for_pfn_range (mem->online_type, mem->nid, mem->group, start_pfn, nr_pages);
@@ -864,6 +867,7 @@ void remove_memory_block_devices(unsigned long start, unsigned long size) mem =find_memory_block_by_id (block_id);if (WARN_ON_ONCE (!mem))continue ; +clear_hwpoisoned_pages (atomic_long_read (&mem->nr_hwpoison));unregister_memory_block_under_nodes (mem);remove_memory_block (mem); }
@@ -1164,3 +1168,35 @@ int walk_dynamic_memory_groups(int nid, walk_memory_groups_func_t func, }return ret; } + +#ifdef CONFIG_MEMORY_FAILURE + +void memblk_nr_poison_inc (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_inc (&mem->nr_hwpoison); +} + +void memblk_nr_poison_sub (unsigned long pfn,long i) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_sub (i, &mem->nr_hwpoison); +} + +unsigned long memblk_nr_poison (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +return atomic_long_read (&mem->nr_hwpoison); +return 0 ; +} + +#endif
include/linux/memory.h +3 -0
@@ -85,6 +85,9 @@ struct memory_block {unsigned long nr_vmemmap_pages;struct memory_group *group;/* group (if any) for this block */ struct list_head group_next;/* next block inside memory group */ +#ifdef CONFIG_MEMORY_FAILURE +atomic_long_t nr_hwpoison; +#endif };int arch_get_memory_phys_device (unsigned long start_pfn);
include/linux/mm.h +8 -0
@@ -3280,6 +3280,10 @@ extern int soft_offline_page(unsigned long pfn, int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags);extern void num_poisoned_pages_inc (unsigned long pfn); +extern void memblk_nr_poison_inc (unsigned long pfn); +extern void memblk_nr_poison_sub (unsigned long pfn,long i); +extern unsigned long memblk_nr_poison (unsigned long pfn); +extern void clear_hwpoisoned_pages (long nr_poison);#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {
@@ -3289,6 +3293,10 @@ static inline int __get_huge_page_for_hwpoison(unsigned long pfn, int flags)static inline void num_poisoned_pages_inc (unsigned long pfn) { } + +static inline void clear_hwpoisoned_pages (long nr_poison) +{ +}#endif #ifndef arch_memory_failure
mm/internal.h +0 -8
@@ -708,14 +708,6 @@ extern u64 hwpoison_filter_flags_value;extern u64 hwpoison_filter_memcg;extern u32 hwpoison_filter_enable; -#ifdef CONFIG_MEMORY_FAILURE -void clear_hwpoisoned_pages (struct page *memmap,int nr_pages); -#else -static inline void clear_hwpoisoned_pages (struct page *memmap,int nr_pages) -{ -} -#endif -extern unsigned long __must_check vm_mmap_pgoff (struct file *,unsigned long ,unsigned long ,unsigned long ,unsigned long ,unsigned long );
mm/memory-failure.c +10 -21
@@ -74,14 +74,17 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);static bool hw_memory_failure__read_mostly = false; -static inline void num_poisoned_pages_inc (unsigned long pfn) +void num_poisoned_pages_inc (unsigned long pfn) {atomic_long_inc (&num_poisoned_pages); +memblk_nr_poison_inc (pfn); }static inline void num_poisoned_pages_sub (unsigned long pfn,long i) {atomic_long_sub (i, &num_poisoned_pages); +if (pfn !=-1UL ) +memblk_nr_poison_sub (pfn, i); }/*
@@ -2414,6 +2417,10 @@ int unpoison_memory(unsigned long pfn) unlock_mutex:mutex_unlock (&mf_mutex);if (!ret || freeit) { +/* +* TODO: per-memory_block counter might break when the page +* size to be unpoisoned is larger than a memory_block. +*/ num_poisoned_pages_sub (pfn, count);unpoison_pr_info ("Unpoison: Software-unpoisoned page %#lx\n" ,page_to_pfn (p), &unpoison_rs);
@@ -2618,25 +2625,7 @@ int soft_offline_page(unsigned long pfn, int flags)return ret; } -void clear_hwpoisoned_pages (struct page *memmap,int nr_pages) +void clear_hwpoisoned_pages (long nr_poison) { -int i, total =0 ; - -/* -* A further optimization is to have per section refcounted -* num_poisoned_pages. But that would need more space per memmap, so -* for now just do a quick global check to speed up this routine in the -* absence of bad pages. -*/ -if (atomic_long_read (&num_poisoned_pages) ==0 ) -return ; - -for (i =0 ; i < nr_pages; i++) { -if (PageHWPoison (&memmap[i])) { - total++; -ClearPageHWPoison (&memmap[i]); - } - } -if (total) -num_poisoned_pages_sub (total); +num_poisoned_pages_sub (-1UL , nr_poison); }
mm/sparse.c +0 -2
@@ -926,8 +926,6 @@ void sparse_remove_section(struct mem_section *ms, unsigned long pfn, unsigned long nr_pages, unsigned long map_offset, struct vmem_altmap *altmap) { - clear_hwpoisoned_pages(pfn_to_page(pfn) + map_offset, - nr_pages - map_offset);section_deactivate (pfn ,nr_pages ,altmap ); }#endif /* CONFIG_MEMORY_HOTPLUG */
Signature · 1 line
2.25.1
PATCH v4 4/4 mm/hwpoison: introduce per-memory_block hwpoison counter counter
From: Naoya Horiguchi <[email protected]>
Currently PageHWPoison flag does not behave well when experiencing memory hotremove/hotplug. Any data field in struct page is unreliable when the associated memory is offlined, and the current mechanism can't tell whether a memory section is onlined because a new memory devices is installed or because previous failed offline operations are undone. Especially if there's a hwpoisoned memory, it's unclear what the best option is.
So introduce a new mechanism to make struct memory_block remember that a memory block has hwpoisoned memory inside it. And make any online event fail if the onlined memory block contains hwpoison. struct memory_block is freed and reallocated over ACPI-based hotremove/hotplug, but not over sysfs-based hotremove/hotplug. So it's desirable to implement hwpoison counter on this struct.
Note that clear_hwpoisoned_pages() is relocated to be called earlier than now, just before unregistering struct memory_block. Otherwise, the per-memory_block hwpoison counter is freed and we fail to adjust global hwpoison counter properly.
---
ChangeLog v3 -> v4:
- fixed build error (https://lore.kernel.org/linux-mm/[email protected]/)
by using memblk_nr_poison() to access to the member ->nr_hwpoison
--- drivers/base/memory.c | 41 +++++++++++++++++++++++++++++++++++++++++ include/linux/memory.h | 3 +++ include/linux/mm.h | 8 ++++++++ mm/internal.h | 8 -------- mm/memory-failure.c | 31 ++++++++++--------------------- mm/sparse.c | 2 -- 6 files changed, 62 insertions(+), 31 deletions(-)
drivers/base/memory.c +41 -0
@@ -183,6 +183,9 @@ static int memory_block_online(struct memory_block *mem)struct zone *zone;int ret; +if (memblk_nr_poison (start_pfn)) +return -EHWPOISON ; + zone =zone_for_pfn_range (mem->online_type, mem->nid, mem->group, start_pfn, nr_pages);
@@ -864,6 +867,7 @@ void remove_memory_block_devices(unsigned long start, unsigned long size) mem =find_memory_block_by_id (block_id);if (WARN_ON_ONCE (!mem))continue ; +clear_hwpoisoned_pages (memblk_nr_poison (start));unregister_memory_block_under_nodes (mem);remove_memory_block (mem); }
@@ -1164,3 +1168,40 @@ int walk_dynamic_memory_groups(int nid, walk_memory_groups_func_t func, }return ret; } + +#ifdef CONFIG_MEMORY_FAILURE + +void memblk_nr_poison_inc (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_inc (&mem->nr_hwpoison); +} + +void memblk_nr_poison_sub (unsigned long pfn,long i) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_sub (i, &mem->nr_hwpoison); +} + +unsigned long memblk_nr_poison (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +return atomic_long_read (&mem->nr_hwpoison); +return 0 ; +} + +#else +unsigned long memblk_nr_poison (unsigned long pfn) +{ +return 0 ; +} +#endif
include/linux/memory.h +3 -0
@@ -85,6 +85,9 @@ struct memory_block {unsigned long nr_vmemmap_pages;struct memory_group *group;/* group (if any) for this block */ struct list_head group_next;/* next block inside memory group */ +#ifdef CONFIG_MEMORY_FAILURE +atomic_long_t nr_hwpoison; +#endif };int arch_get_memory_phys_device (unsigned long start_pfn);
include/linux/mm.h +8 -0
@@ -3280,6 +3280,9 @@ extern int soft_offline_page(unsigned long pfn, int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags);extern void num_poisoned_pages_inc (unsigned long pfn); +extern void memblk_nr_poison_inc (unsigned long pfn); +extern void memblk_nr_poison_sub (unsigned long pfn,long i); +extern void clear_hwpoisoned_pages (long nr_poison);#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {
@@ -3289,7 +3292,12 @@ static inline int __get_huge_page_for_hwpoison(unsigned long pfn, int flags)static inline void num_poisoned_pages_inc (unsigned long pfn) { } + +static inline void clear_hwpoisoned_pages (long nr_poison) +{ +}#endif +extern unsigned long memblk_nr_poison (unsigned long pfn);#ifndef arch_memory_failurestatic inline int arch_memory_failure (unsigned long pfn,int flags)
mm/internal.h +0 -8
@@ -708,14 +708,6 @@ extern u64 hwpoison_filter_flags_value;extern u64 hwpoison_filter_memcg;extern u32 hwpoison_filter_enable; -#ifdef CONFIG_MEMORY_FAILURE -void clear_hwpoisoned_pages (struct page *memmap,int nr_pages); -#else -static inline void clear_hwpoisoned_pages (struct page *memmap,int nr_pages) -{ -} -#endif -extern unsigned long __must_check vm_mmap_pgoff (struct file *,unsigned long ,unsigned long ,unsigned long ,unsigned long ,unsigned long );
mm/memory-failure.c +10 -21
@@ -74,14 +74,17 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);static bool hw_memory_failure__read_mostly = false; -static inline void num_poisoned_pages_inc (unsigned long pfn) +void num_poisoned_pages_inc (unsigned long pfn) {atomic_long_inc (&num_poisoned_pages); +memblk_nr_poison_inc (pfn); }static inline void num_poisoned_pages_sub (unsigned long pfn,long i) {atomic_long_sub (i, &num_poisoned_pages); +if (pfn !=-1UL ) +memblk_nr_poison_sub (pfn, i); }/*
@@ -2414,6 +2417,10 @@ int unpoison_memory(unsigned long pfn) unlock_mutex:mutex_unlock (&mf_mutex);if (!ret || freeit) { +/* +* TODO: per-memory_block counter might break when the page +* size to be unpoisoned is larger than a memory_block. +*/ num_poisoned_pages_sub (pfn, count);unpoison_pr_info ("Unpoison: Software-unpoisoned page %#lx\n" ,page_to_pfn (p), &unpoison_rs);
@@ -2618,25 +2625,7 @@ int soft_offline_page(unsigned long pfn, int flags)return ret; } -void clear_hwpoisoned_pages (struct page *memmap,int nr_pages) +void clear_hwpoisoned_pages (long nr_poison) { -int i, total =0 ; - -/* -* A further optimization is to have per section refcounted -* num_poisoned_pages. But that would need more space per memmap, so -* for now just do a quick global check to speed up this routine in the -* absence of bad pages. -*/ -if (atomic_long_read (&num_poisoned_pages) ==0 ) -return ; - -for (i =0 ; i < nr_pages; i++) { -if (PageHWPoison (&memmap[i])) { - total++; -ClearPageHWPoison (&memmap[i]); - } - } -if (total) -num_poisoned_pages_sub (total); +num_poisoned_pages_sub (-1UL , nr_poison); }
mm/sparse.c +0 -2
@@ -926,8 +926,6 @@ void sparse_remove_section(struct mem_section *ms, unsigned long pfn, unsigned long nr_pages, unsigned long map_offset, struct vmem_altmap *altmap) { - clear_hwpoisoned_pages(pfn_to_page(pfn) + map_offset, - nr_pages - map_offset);section_deactivate (pfn ,nr_pages ,altmap ); }#endif /* CONFIG_MEMORY_HOTPLUG */
Signature · 1 line
2.37.3.518.g79f2338b37
PATCH v5 4/4 mm/hwpoison: introduce per-memory_block hwpoison counter counter
There seems another build error in aarch64 with MEMORY_HOTPLUG disabled.
https://lore.kernel.org/lkml/[email protected]/
, so let me revise this patch again to handle it.
- Naoya Horiguchi
---
From: Naoya Horiguchi <[email protected]>
Date: Fri, 23 Sep 2022 22:51:20 +0900
Subject: [PATCH v5 4/4] mm/hwpoison: introduce per-memory_block hwpoison counter
Currently PageHWPoison flag does not behave well when experiencing memory hotremove/hotplug. Any data field in struct page is unreliable when the associated memory is offlined, and the current mechanism can't tell whether a memory section is onlined because a new memory devices is installed or because previous failed offline operations are undone. Especially if there's a hwpoisoned memory, it's unclear what the best option is.
So introduce a new mechanism to make struct memory_block remember that a memory block has hwpoisoned memory inside it. And make any online event fail if the onlined memory block contains hwpoison. struct memory_block is freed and reallocated over ACPI-based hotremove/hotplug, but not over sysfs-based hotremove/hotplug. So it's desirable to implement hwpoison counter on this struct.
Note that clear_hwpoisoned_pages() is relocated to be called earlier than now, just before unregistering struct memory_block. Otherwise, the per-memory_block hwpoison counter is freed and we fail to adjust global hwpoison counter properly.
---
ChangeLog v4 -> v5:
- add Reported-by of lkp bot,
- check both CONFIG_MEMORY_FAILURE and CONFIG_MEMORY_HOTPLUG in introduced #ifdefs, intending to fix "undefined reference" errors in aarch64.
ChangeLog v3 -> v4:
- fix build error (https://lore.kernel.org/linux-mm/[email protected]/)
by using memblk_nr_poison() to access to the member ->nr_hwpoison
--- drivers/base/memory.c | 34 ++++++++++++++++++++++++++++++++++ include/linux/memory.h | 3 +++ include/linux/mm.h | 24 ++++++++++++++++++++++++ mm/internal.h | 8 -------- mm/memory-failure.c | 31 ++++++++++--------------------- mm/sparse.c | 2 -- 6 files changed, 71 insertions(+), 31 deletions(-)
drivers/base/memory.c +34 -0
@@ -183,6 +183,9 @@ static int memory_block_online(struct memory_block *mem)struct zone *zone;int ret; +if (memblk_nr_poison (start_pfn)) +return -EHWPOISON ; + zone =zone_for_pfn_range (mem->online_type, mem->nid, mem->group, start_pfn, nr_pages);
@@ -864,6 +867,7 @@ void remove_memory_block_devices(unsigned long start, unsigned long size) mem =find_memory_block_by_id (block_id);if (WARN_ON_ONCE (!mem))continue ; +clear_hwpoisoned_pages (memblk_nr_poison (start));unregister_memory_block_under_nodes (mem);remove_memory_block (mem); }
@@ -1164,3 +1168,33 @@ int walk_dynamic_memory_groups(int nid, walk_memory_groups_func_t func, }return ret; } + +#if defined(CONFIG_MEMORY_FAILURE ) && defined(CONFIG_MEMORY_HOTPLUG ) +void memblk_nr_poison_inc (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_inc (&mem->nr_hwpoison); +} + +void memblk_nr_poison_sub (unsigned long pfn,long i) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_sub (i, &mem->nr_hwpoison); +} + +unsigned long memblk_nr_poison (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +return atomic_long_read (&mem->nr_hwpoison); +return 0 ; +} +#endif
include/linux/memory.h +3 -0
@@ -85,6 +85,9 @@ struct memory_block {unsigned long nr_vmemmap_pages;struct memory_group *group;/* group (if any) for this block */ struct list_head group_next;/* next block inside memory group */ +#if defined(CONFIG_MEMORY_FAILURE ) && defined(CONFIG_MEMORY_HOTPLUG ) +atomic_long_t nr_hwpoison; +#endif };int arch_get_memory_phys_device (unsigned long start_pfn);
include/linux/mm.h +24 -0
@@ -3280,6 +3280,7 @@ extern int soft_offline_page(unsigned long pfn, int flags);#ifdef CONFIG_MEMORY_FAILURE extern int __get_huge_page_for_hwpoison (unsigned long pfn,int flags);extern void num_poisoned_pages_inc (unsigned long pfn); +extern void clear_hwpoisoned_pages (long nr_poison);#else static inline int __get_huge_page_for_hwpoison (unsigned long pfn,int flags) {
@@ -3289,6 +3290,29 @@ static inline int __get_huge_page_for_hwpoison(unsigned long pfn, int flags)static inline void num_poisoned_pages_inc (unsigned long pfn) { } + +static inline void clear_hwpoisoned_pages (long nr_poison) +{ +} +#endif + +#if defined(CONFIG_MEMORY_FAILURE ) && defined(CONFIG_MEMORY_HOTPLUG ) +extern void memblk_nr_poison_inc (unsigned long pfn); +extern void memblk_nr_poison_sub (unsigned long pfn,long i); +extern unsigned long memblk_nr_poison (unsigned long pfn); +#else +static inline void memblk_nr_poison_inc (unsigned long pfn) +{ +} + +static inline void memblk_nr_poison_sub (unsigned long pfn,long i) +{ +} + +static inline unsigned long memblk_nr_poison (unsigned long pfn) +{ +return 0 ; +}#endif #ifndef arch_memory_failure
mm/internal.h +0 -8
@@ -708,14 +708,6 @@ extern u64 hwpoison_filter_flags_value;extern u64 hwpoison_filter_memcg;extern u32 hwpoison_filter_enable; -#ifdef CONFIG_MEMORY_FAILURE -void clear_hwpoisoned_pages (struct page *memmap,int nr_pages); -#else -static inline void clear_hwpoisoned_pages (struct page *memmap,int nr_pages) -{ -} -#endif -extern unsigned long __must_check vm_mmap_pgoff (struct file *,unsigned long ,unsigned long ,unsigned long ,unsigned long ,unsigned long );
mm/memory-failure.c +10 -21
@@ -74,14 +74,17 @@ atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);static bool hw_memory_failure__read_mostly = false; -static inline void num_poisoned_pages_inc (unsigned long pfn) +void num_poisoned_pages_inc (unsigned long pfn) {atomic_long_inc (&num_poisoned_pages); +memblk_nr_poison_inc (pfn); }static inline void num_poisoned_pages_sub (unsigned long pfn,long i) {atomic_long_sub (i, &num_poisoned_pages); +if (pfn !=-1UL ) +memblk_nr_poison_sub (pfn, i); }/*
@@ -2414,6 +2417,10 @@ int unpoison_memory(unsigned long pfn) unlock_mutex:mutex_unlock (&mf_mutex);if (!ret || freeit) { +/* +* TODO: per-memory_block counter might break when the page +* size to be unpoisoned is larger than a memory_block. +*/ num_poisoned_pages_sub (pfn, count);unpoison_pr_info ("Unpoison: Software-unpoisoned page %#lx\n" ,page_to_pfn (p), &unpoison_rs);
@@ -2618,25 +2625,7 @@ int soft_offline_page(unsigned long pfn, int flags)return ret; } -void clear_hwpoisoned_pages (struct page *memmap,int nr_pages) +void clear_hwpoisoned_pages (long nr_poison) { -int i, total =0 ; - -/* -* A further optimization is to have per section refcounted -* num_poisoned_pages. But that would need more space per memmap, so -* for now just do a quick global check to speed up this routine in the -* absence of bad pages. -*/ -if (atomic_long_read (&num_poisoned_pages) ==0 ) -return ; - -for (i =0 ; i < nr_pages; i++) { -if (PageHWPoison (&memmap[i])) { - total++; -ClearPageHWPoison (&memmap[i]); - } - } -if (total) -num_poisoned_pages_sub (total); +num_poisoned_pages_sub (-1UL , nr_poison); }
mm/sparse.c +0 -2
@@ -926,8 +926,6 @@ void sparse_remove_section(struct mem_section *ms, unsigned long pfn, unsigned long nr_pages, unsigned long map_offset, struct vmem_altmap *altmap) { - clear_hwpoisoned_pages(pfn_to_page(pfn) + map_offset, - nr_pages - map_offset);section_deactivate (pfn ,nr_pages ,altmap ); }#endif /* CONFIG_MEMORY_HOTPLUG */
Signature · 1 line
2.37.3.518.g79f2338b37
Re: [PATCH v5 4/4] mm/hwpoison: introduce per-memory_block hwpoison counter counter
Quoted 25 lines · Naoya Horiguchi
There seems another build error in aarch64 with
MEMORY_HOTPLUGdisabled.
https://lore.kernel.org/lkml/[email protected]/
, so let me revise this patch again to handle it.- Naoya Horiguchi
---
From: Naoya Horiguchi <[email protected]>
Date: Fri, 23 Sep 2022 22:51:20 +0900
Subject: [PATCH v5 4/4] mm/hwpoison: introduce per-memory_block hwpoison counterCurrently PageHWPoison flag does not behave well when experiencing memory hotremove/hotplug. Any data field in struct page is unreliable when the associated memory is offlined, and the current mechanism can't tell whether a memory section is onlined because a new memory devices is installed or because previous failed offline operations are undone. Especially if there's a hwpoisoned memory, it's unclear what the best option is.
So introduce a new mechanism to make struct
memory_blockremember that a memory block has hwpoisoned memory inside it. And make any online event fail if the onlined memory block contains hwpoison. structmemory_blockis freed and reallocated over ACPI-based hotremove/hotplug, but not over sysfs-based hotremove/hotplug. So it's desirable to implement hwpoison counter on this struct.
Quoted 7 lines
Note that
clear_hwpoisoned_pages()is relocated to be called earlier than now, just before unregistering structmemory_block. Otherwise, the per-memory_block hwpoison counter is freed and we fail to adjust global hwpoison counter properly.Signed-off-by Naoya Horiguchi <[email protected]>Reported-by kernel test robot <[email protected]>
LGTM with some nits below. Thanks.
Quoted 33 lines
---
ChangeLog v4 -> v5:
- add Reported-by of lkp bot,
- check bothCONFIG_MEMORY_FAILUREandCONFIG_MEMORY_HOTPLUGin introduced #ifdefs, intending to fix "undefined reference" errors in aarch64.ChangeLog v3 -> v4:
- fix build error (https://lore.kernel.org/linux-mm/[email protected]/)
by usingmemblk_nr_poison()to access to the member ->nr_hwpoison--- drivers/base/memory.c | 34 ++++++++++++++++++++++++++++++++++ include/linux/memory.h | 3 +++ include/linux/mm.h | 24 ++++++++++++++++++++++++ mm/internal.h | 8 -------- mm/memory-failure.c | 31 ++++++++++--------------------- mm/sparse.c | 2 -- 6 files changed, 71 insertions(+), 31 deletions(-)drivers/base/memory.c +3
-0@@ -183,6 +183,9 @@ static int memory_block_online(struct memory_block *mem)struct zone *zone;int ret; +if (memblk_nr_poison (start_pfn)) +return -EHWPOISON ; + zone =zone_for_pfn_range (mem->online_type, mem->nid, mem->group, start_pfn, nr_pages);
drivers/base/memory.c void remove_memory_block_devices(unsigned long start, unsigned long size) · line 870
Quoted 4 lines
drivers/base/memory.c +1
-0@@ -864,6 +867,7 @@ void remove_memory_block_devices(unsigned long start, unsigned long size) mem =find_memory_block_by_id (block_id);if (WARN_ON_ONCE (!mem))continue ; +clear_hwpoisoned_pages (memblk_nr_poison (start));
clear_hwpoisoned_pages seems not a proper name now? PageHWPoison info is kept now. But this should be trivial.
Quoted 18 lines
drivers/base/memory.c +11
-0unregister_memory_block_under_nodes (mem);remove_memory_block (mem); }@@ -1164,3 +1168,33 @@ int walk_dynamic_memory_groups(int nid, walk_memory_groups_func_t func, }return ret; } + +#if defined(CONFIG_MEMORY_FAILURE ) && defined(CONFIG_MEMORY_HOTPLUG ) +void memblk_nr_poison_inc (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_inc (&mem->nr_hwpoison); +} +
drivers/base/memory.c int walk_dynamic_memory_groups(int nid, walk_memory_groups_func_t func, · line 1191
Quoted 10 lines
drivers/base/memory.c +10
-0+void memblk_nr_poison_sub (unsigned long pfn,long i) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_sub (i, &mem->nr_hwpoison); +} + +unsigned long memblk_nr_poison (unsigned long pfn)
memblk_nr_poison() is only used inside this file. Make it static?
Thanks,
Miaohe Lin
Re: [PATCH v5 4/4] mm/hwpoison: introduce per-memory_block hwpoison counter counter
Quoted 31 lines · Miaohe Lin
Quoted 30 lines · Naoya Horiguchi
There seems another build error in aarch64 with
MEMORY_HOTPLUGdisabled.
https://lore.kernel.org/lkml/[email protected]/
, so let me revise this patch again to handle it.- Naoya Horiguchi
---
From: Naoya Horiguchi <[email protected]>
Date: Fri, 23 Sep 2022 22:51:20 +0900
Subject: [PATCH v5 4/4] mm/hwpoison: introduce per-memory_block hwpoison counterCurrently PageHWPoison flag does not behave well when experiencing memory hotremove/hotplug. Any data field in struct page is unreliable when the associated memory is offlined, and the current mechanism can't tell whether a memory section is onlined because a new memory devices is installed or because previous failed offline operations are undone. Especially if there's a hwpoisoned memory, it's unclear what the best option is.
So introduce a new mechanism to make struct
memory_blockremember that a memory block has hwpoisoned memory inside it. And make any online event fail if the onlined memory block contains hwpoison. structmemory_blockis freed and reallocated over ACPI-based hotremove/hotplug, but not over sysfs-based hotremove/hotplug. So it's desirable to implement hwpoison counter on this struct.Note that
clear_hwpoisoned_pages()is relocated to be called earlier than now, just before unregistering structmemory_block. Otherwise, the per-memory_block hwpoison counter is freed and we fail to adjust global hwpoison counter properly.
Quoted 6 lines
Quoted 2 lines
Signed-off-by Naoya Horiguchi <[email protected]>Reported-by kernel test robot <[email protected]>LGTM with some nits below. Thanks.
Reviewed-by Miaohe Lin <[email protected]>
Thank you.
Quoted 33 lines
Quoted 33 lines
---
ChangeLog v4 -> v5:
- add Reported-by of lkp bot,
- check bothCONFIG_MEMORY_FAILUREandCONFIG_MEMORY_HOTPLUGin introduced #ifdefs, intending to fix "undefined reference" errors in aarch64.ChangeLog v3 -> v4:
- fix build error (https://lore.kernel.org/linux-mm/[email protected]/)
by usingmemblk_nr_poison()to access to the member ->nr_hwpoison--- drivers/base/memory.c | 34 ++++++++++++++++++++++++++++++++++ include/linux/memory.h | 3 +++ include/linux/mm.h | 24 ++++++++++++++++++++++++ mm/internal.h | 8 -------- mm/memory-failure.c | 31 ++++++++++--------------------- mm/sparse.c | 2 -- 6 files changed, 71 insertions(+), 31 deletions(-)drivers/base/memory.c +3
-0@@ -183,6 +183,9 @@ static int memory_block_online(struct memory_block *mem)struct zone *zone;int ret; +if (memblk_nr_poison (start_pfn)) +return -EHWPOISON ; + zone =zone_for_pfn_range (mem->online_type, mem->nid, mem->group, start_pfn, nr_pages);
Quoted 8 lines
drivers/base/memory.c void remove_memory_block_devices(unsigned long start, unsigned long size) · line 870
Quoted 5 lines
drivers/base/memory.c +1
-0@@ -864,6 +867,7 @@ void remove_memory_block_devices(unsigned long start, unsigned long size) mem =find_memory_block_by_id (block_id);if (WARN_ON_ONCE (!mem))continue ; +clear_hwpoisoned_pages (memblk_nr_poison (start));
clear_hwpoisoned_pagesseems not a proper name now? PageHWPoison info is kept now. But this should be trivial.
Right, I think that the name num_poisoned_pages_sub() is clear enough, so I'll open this function.
Quoted 22 lines
Quoted 22 lines
drivers/base/memory.c +15
-0unregister_memory_block_under_nodes (mem);remove_memory_block (mem); }@@ -1164,3 +1168,33 @@ int walk_dynamic_memory_groups(int nid, walk_memory_groups_func_t func, }return ret; } + +#if defined(CONFIG_MEMORY_FAILURE ) && defined(CONFIG_MEMORY_HOTPLUG ) +void memblk_nr_poison_inc (unsigned long pfn) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id); + +if (mem) +atomic_long_inc (&mem->nr_hwpoison); +} + +void memblk_nr_poison_sub (unsigned long pfn,long i) +{ +const unsigned long block_id =pfn_to_block_id (pfn); +struct memory_block *mem =find_memory_block_by_id (block_id);
Quoted 8 lines
drivers/base/memory.c int walk_dynamic_memory_groups(int nid, walk_memory_groups_func_t func, · line 1191
Quoted 6 lines
drivers/base/memory.c +6
-0+ +if (mem) +atomic_long_sub (i, &mem->nr_hwpoison); +} + +unsigned long memblk_nr_poison (unsigned long pfn)
memblk_nr_poison()is only used inside this file. Make it static?
Thanks, I'll add it.
Thanks,
Naoya Horiguchi
Re: [PATCH v5 4/4] mm/hwpoison: introduce per-memory_block hwpoison counter counter
In reply to Naoya Horiguchimm/memory-failure.c int unpoison_memory(unsigned long pfn) · line 2423
Quoted 9 lines
/*
mm/memory-failure.c +4
-0@@ -2414,6 +2417,10 @@ int unpoison_memory(unsigned long pfn) unlock_mutex:mutex_unlock (&mf_mutex);if (!ret || freeit) { +/* +* TODO: per-memory_block counter might break when the page +* size to be unpoisoned is larger than a memory_block. +*/
Hmm, but that happens easily e.g., with 1 GiB hugetlb page and 128 MiB memory section/block size. What would be the right thing to do here? The TODO should rather spell that out instead of just stating the problem.
Signature · 3 lines
Thanks, David / dhildenb
Re: [PATCH v5 4/4] mm/hwpoison: introduce per-memory_block hwpoison counter counter
Quoted 5 lines · David Hildenbrand
Quoted 5 lines
/*
mm/memory-failure.c +0
-0@@ -2414,6 +2417,10 @@ int unpoison_memory(unsigned long pfn) unlock_mutex:mutex_unlock (&mf_mutex);if (!ret || freeit) {
Quoted 8 lines
mm/memory-failure.c int unpoison_memory(unsigned long pfn) · line 2423
Quoted 4 lines
mm/memory-failure.c +4
-0+/* +* TODO: per-memory_block counter might break when the page +* size to be unpoisoned is larger than a memory_block. +*/ Hmm, but that happens easily e.g., with 1 GiB hugetlb page and 128 MiB memory section/block size. What would be the right thing to do here? The TODO should rather spell that out instead of just stating the problem.
What should we need here is to cancel the per-memory_block hwpoison counts in each memory block associated with the hugepage to be unpoisoned. I found that it can be done with additional several lines of code, so v6 will contain them. Then, this TODO comment is no longer needed.
Thanks,
Naoya Horiguchi