mm: memcontrol: do not recurse in direct reclaim
Subsystems (5)
Johannes Weiner
maintainerPATCH 1/1 mm: memcontrol: do not recurse in direct reclaim
On 4.0, we saw a stack corruption from a page fault entering direct memory cgroup reclaim, calling into btrfs_releasepage(), which then tried to allocate an extent and recursed back into a kmem charge ad nauseam:
[...]
[<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bb5b0>] memcg_charge_kmem+0x40/0x80 [<ffffffff811a96a9>] new_slab+0x2d9/0x5a0 [<ffffffff817b2547>] __slab_alloc+0x2fd/0x44f [<ffffffff811a9b03>] kmem_cache_alloc+0x193/0x1e0 [<ffffffff813801e1>] alloc_extent_state+0x21/0xc0 [<ffffffff813820c5>] __clear_extent_bit+0x2b5/0x400 [<ffffffff81386d03>] try_release_extent_mapping+0x1a3/0x220 [<ffffffff813658a1>] __btrfs_releasepage+0x31/0x70 [<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bbfd5>] mem_cgroup_try_charge+0x65/0x1c0 [<ffffffff8118338f>] handle_mm_fault+0x117f/0x1510 [<ffffffff81041cf7>] __do_page_fault+0x177/0x420 [<ffffffff81041fac>] do_page_fault+0xc/0x10 [<ffffffff817c0182>] page_fault+0x22/0x30
On later kernels, kmem charging is opt-in rather than opt-out, and that particular kmem allocation in btrfs_releasepage() is no longer being charged and won't recurse and overrun the stack anymore. But it's not impossible for an accounted allocation to happen from the memcg direct reclaim context, and we needed to reproduce this crash many times before we even got a useful stack trace out of it.
Like other direct reclaimers, mark tasks in memcg reclaim PF_MEMALLOC to avoid recursing into any other form of direct reclaim. Then let recursive charges from PF_MEMALLOC contexts bypass the cgroup limit.
--- mm/memcontrol.c | 9 +++++---- mm/vmscan.c | 2 ++ 2 files changed, 7 insertions(+), 4 deletions(-)
Hey guys, can anyone think of a reason why this might not be a good idea? We've never really needed this in the past because page reclaim doesn't recurse into instantiating another LRU page, especially with GFP_NOFS. But with a wider variety of tracked allocations, it's no longer that obvious. It seems like a risky hole to leave around.
mm/memcontrol.c +5 -4
@@ -1908,13 +1908,14 @@ static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,/* * Unlike in global OOM situations, memcg is not in a physical -* memory shortage. Allow dying and OOM-killed tasks to -* bypass the last charges so that they can exit quickly and -* free their memory. +* memory shortage. Allow dying and OOM-killed tasks to bypass +* the last charges so that they can exit quickly and free +* their memory. The same applies for recursing reclaimers. */ if (unlikely (test_thread_flag (TIF_MEMDIE ) ||fatal_signal_pending (current) || - current->flags &PF_EXITING )) + current->flags &PF_EXITING || + current->flags &PF_MEMALLOC )) goto force;if (unlikely (task_in_memcg_oom (current)))
mm/vmscan.c +2 -0
@@ -3043,7 +3043,9 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg, sc.gfp_mask, sc.reclaim_idx); + current->flags |=PF_MEMALLOC ; nr_reclaimed =do_try_to_free_pages (zonelist, &sc); + current->flags &= ~PF_MEMALLOC ;trace_mm_vmscan_memcg_reclaim_end (nr_reclaimed);
Signature · 7 lines
2.10.0 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 38 lines · Johannes Weiner
On 4.0, we saw a stack corruption from a page fault entering direct memory cgroup reclaim, calling into
btrfs_releasepage(), which then tried to allocate an extent and recursed back into a kmem charge ad nauseam:[...]
[<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bb5b0>] memcg_charge_kmem+0x40/0x80 [<ffffffff811a96a9>] new_slab+0x2d9/0x5a0 [<ffffffff817b2547>] __slab_alloc+0x2fd/0x44f [<ffffffff811a9b03>] kmem_cache_alloc+0x193/0x1e0 [<ffffffff813801e1>] alloc_extent_state+0x21/0xc0 [<ffffffff813820c5>] __clear_extent_bit+0x2b5/0x400 [<ffffffff81386d03>] try_release_extent_mapping+0x1a3/0x220 [<ffffffff813658a1>] __btrfs_releasepage+0x31/0x70 [<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bbfd5>] mem_cgroup_try_charge+0x65/0x1c0 [<ffffffff8118338f>] handle_mm_fault+0x117f/0x1510 [<ffffffff81041cf7>] __do_page_fault+0x177/0x420 [<ffffffff81041fac>] do_page_fault+0xc/0x10 [<ffffffff817c0182>] page_fault+0x22/0x30
Quoted 6 lines
On later kernels, kmem charging is opt-in rather than opt-out, and that particular kmem allocation in
btrfs_releasepage()is no longer being charged and won't recurse and overrun the stack anymore. But it's not impossible for an accounted allocation to happen from the memcg direct reclaim context, and we needed to reproduce this crash many times before we even got a useful stack trace out of it.
I agree that stack overruns are really nasty to debug. Been there done that, hate it...
I would argue that we shouldn't account arbitrary objects and most of them should be directly related to a user visible API which shouldn't happen from the reclaim path. But the reality is that we reuse the code and we can easily end up in the situation similat to the one above so I agree that being more careful is definitely worth it.
Quoted 3 lines
Like other direct reclaimers, mark tasks in memcg reclaim
PF_MEMALLOCto avoid recursing into any other form of direct reclaim. Then let recursive charges fromPF_MEMALLOCcontexts bypass the cgroup limit.
Yes, as long as the allocation is still properly accounted then this is the right way to go. We can breach the limit already. The outer reclaim loop would push back to the limit anyway.
Quoted 1 line
Signed-off-by Johannes Weiner <[email protected]>
One nit below
Quoted 22 lines
--- mm/memcontrol.c | 9 +++++---- mm/vmscan.c | 2 ++ 2 files changed, 7 insertions(+), 4 deletions(-)Hey guys, can anyone think of a reason why this might not be a good idea? We've never really needed this in the past because page reclaim doesn't recurse into instantiating another LRU page, especially with
GFP_NOFS. But with a wider variety of tracked allocations, it's no longer that obvious. It seems like a risky hole to leave around.mm/memcontrol.c +0
-3@@ -1908,13 +1908,14 @@ static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask,/* * Unlike in global OOM situations, memcg is not in a physical -* memory shortage. Allow dying and OOM-killed tasks to -* bypass the last charges so that they can exit quickly and -* free their memory.
mm/memcontrol.c static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask, · line 1919
Quoted 10 lines
mm/memcontrol.c +5
-1+* memory shortage. Allow dying and OOM-killed tasks to bypass +* the last charges so that they can exit quickly and free +* their memory. The same applies for recursing reclaimers. */ if (unlikely (test_thread_flag (TIF_MEMDIE ) ||fatal_signal_pending (current) || - current->flags &PF_EXITING )) + current->flags &PF_EXITING || + current->flags &PF_MEMALLOC )) goto force;
I would prefer to have the PF_MEMALLOC condition in a check on its own with a short explanation that we really do not want to recurse to the reclaim due to stack overflows.
Quoted 17 lines
mm/memcontrol.c +0
-0if (unlikely (task_in_memcg_oom (current)))mm/vmscan.c +2
-0@@ -3043,7 +3043,9 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg, sc.gfp_mask, sc.reclaim_idx); + current->flags |=PF_MEMALLOC ; nr_reclaimed =do_try_to_free_pages (zonelist, &sc); + current->flags &= ~PF_MEMALLOC ;trace_mm_vmscan_memcg_reclaim_end (nr_reclaimed);Signature · 1 line
2.10.0
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Quoted 1 line · Michal Hocko
Acked-by Michal Hocko <[email protected]>
Thank you.
Quoted 3 lines
I would prefer to have the
PF_MEMALLOCcondition in a check on its own with a short explanation that we really do not want to recurse to the reclaim due to stack overflows.
Okay, fair enough. I also added why we prefer temporarily breaching the limit over failing the allocation. How is this?
From 9034d2e6a21036774df9a8e021511720cf432c82 Mon Sep 17 00:00:00 2001
From: Johannes Weiner <[email protected]>
Date: Mon, 24 Oct 2016 16:01:55 -0400
Subject: [PATCH] mm: memcontrol: do not recurse in direct reclaim
On 4.0, we saw a stack corruption from a page fault entering direct memory cgroup reclaim, calling into btrfs_releasepage(), which then tried to allocate an extent and recursed back into a kmem charge ad nauseam:
[...]
[<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bb5b0>] memcg_charge_kmem+0x40/0x80 [<ffffffff811a96a9>] new_slab+0x2d9/0x5a0 [<ffffffff817b2547>] __slab_alloc+0x2fd/0x44f [<ffffffff811a9b03>] kmem_cache_alloc+0x193/0x1e0 [<ffffffff813801e1>] alloc_extent_state+0x21/0xc0 [<ffffffff813820c5>] __clear_extent_bit+0x2b5/0x400 [<ffffffff81386d03>] try_release_extent_mapping+0x1a3/0x220 [<ffffffff813658a1>] __btrfs_releasepage+0x31/0x70 [<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bbfd5>] mem_cgroup_try_charge+0x65/0x1c0 [<ffffffff8118338f>] handle_mm_fault+0x117f/0x1510 [<ffffffff81041cf7>] __do_page_fault+0x177/0x420 [<ffffffff81041fac>] do_page_fault+0xc/0x10 [<ffffffff817c0182>] page_fault+0x22/0x30
On later kernels, kmem charging is opt-in rather than opt-out, and that particular kmem allocation in btrfs_releasepage() is no longer being charged and won't recurse and overrun the stack anymore. But it's not impossible for an accounted allocation to happen from the memcg direct reclaim context, and we needed to reproduce this crash many times before we even got a useful stack trace out of it.
Like other direct reclaimers, mark tasks in memcg reclaim PF_MEMALLOC to avoid recursing into any other form of direct reclaim. Then let recursive charges from PF_MEMALLOC contexts bypass the cgroup limit.
--- mm/memcontrol.c | 9 +++++++++ mm/vmscan.c | 2 ++ 2 files changed, 11 insertions(+)
mm/memcontrol.c +9 -0
@@ -1917,6 +1917,15 @@ static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask, current->flags & PF_EXITING)) goto force; +/* +* Prevent unbounded recursion when reclaim operations need to +* allocate memory. This might exceed the limits temporarily, +* but we prefer facilitating memory reclaim and getting back +* under the limit over triggering OOM kills in these cases. +*/ +if (unlikely (current->flags &PF_MEMALLOC )) + goto force; +if (unlikely (task_in_memcg_oom (current))) goto nomem;
mm/vmscan.c +2 -0
@@ -3043,7 +3043,9 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg, sc.gfp_mask, sc.reclaim_idx); + current->flags |=PF_MEMALLOC ; nr_reclaimed =do_try_to_free_pages (zonelist, &sc); + current->flags &= ~PF_MEMALLOC ;trace_mm_vmscan_memcg_reclaim_end (nr_reclaimed);
Signature · 7 lines
2.10.0 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Michal Hocko
maintainerQuoted 62 lines · Johannes Weiner
Quoted 1 line · Michal Hocko
Acked-by Michal Hocko <[email protected]>Thank you.
Quoted 3 lines
I would prefer to have the
PF_MEMALLOCcondition in a check on its own with a short explanation that we really do not want to recurse to the reclaim due to stack overflows.Okay, fair enough. I also added why we prefer temporarily breaching the limit over failing the allocation. How is this?
Quoted 1 line
From
9034d2e6a21036774df9a8e021511720cf432c82Mon Sep 17 00:00:00 2001From: Johannes Weiner <[email protected]>
Date: Mon, 24 Oct 2016 16:01:55 -0400
Subject: [PATCH] mm: memcontrol: do not recurse in direct reclaimOn 4.0, we saw a stack corruption from a page fault entering direct memory cgroup reclaim, calling into
btrfs_releasepage(), which then tried to allocate an extent and recursed back into a kmem charge ad nauseam:[...]
[<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bb5b0>] memcg_charge_kmem+0x40/0x80 [<ffffffff811a96a9>] new_slab+0x2d9/0x5a0 [<ffffffff817b2547>] __slab_alloc+0x2fd/0x44f [<ffffffff811a9b03>] kmem_cache_alloc+0x193/0x1e0 [<ffffffff813801e1>] alloc_extent_state+0x21/0xc0 [<ffffffff813820c5>] __clear_extent_bit+0x2b5/0x400 [<ffffffff81386d03>] try_release_extent_mapping+0x1a3/0x220 [<ffffffff813658a1>] __btrfs_releasepage+0x31/0x70 [<ffffffff8136590c>] btrfs_releasepage+0x2c/0x30 [<ffffffff811559a2>] try_to_release_page+0x32/0x50 [<ffffffff81168cea>] shrink_page_list+0x6da/0x7a0 [<ffffffff811693b5>] shrink_inactive_list+0x1e5/0x510 [<ffffffff8116a0a5>] shrink_lruvec+0x605/0x7f0 [<ffffffff8116a37e>] shrink_zone+0xee/0x320 [<ffffffff8116a934>] do_try_to_free_pages+0x174/0x440 [<ffffffff8116adf7>] try_to_free_mem_cgroup_pages+0xa7/0x130 [<ffffffff811b738b>] try_charge+0x17b/0x830 [<ffffffff811bbfd5>] mem_cgroup_try_charge+0x65/0x1c0 [<ffffffff8118338f>] handle_mm_fault+0x117f/0x1510 [<ffffffff81041cf7>] __do_page_fault+0x177/0x420 [<ffffffff81041fac>] do_page_fault+0xc/0x10 [<ffffffff817c0182>] page_fault+0x22/0x30On later kernels, kmem charging is opt-in rather than opt-out, and that particular kmem allocation in
btrfs_releasepage()is no longer being charged and won't recurse and overrun the stack anymore. But it's not impossible for an accounted allocation to happen from the memcg direct reclaim context, and we needed to reproduce this crash many times before we even got a useful stack trace out of it.
Quoted 4 lines
Like other direct reclaimers, mark tasks in memcg reclaim
PF_MEMALLOCto avoid recursing into any other form of direct reclaim. Then let recursive charges fromPF_MEMALLOCcontexts bypass the cgroup limit.
Should we mark this for stable (up to 4.5) which changed the out-out to opt-in?
Quoted 14 lines
Signed-off-by Johannes Weiner <[email protected]>Acked-by Michal Hocko <[email protected]>--- mm/memcontrol.c | 9 +++++++++ mm/vmscan.c | 2 ++ 2 files changed, 11 insertions(+)mm/memcontrol.c +0
-0@@ -1917,6 +1917,15 @@ static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask, current->flags & PF_EXITING)) goto force;
mm/memcontrol.c static int try_charge(struct mem_cgroup *memcg, gfp_t gfp_mask, · line 1928
Quoted 10 lines
mm/memcontrol.c +9
-0+/* +* Prevent unbounded recursion when reclaim operations need to +* allocate memory. This might exceed the limits temporarily, +* but we prefer facilitating memory reclaim and getting back +* under the limit over triggering OOM kills in these cases. +*/ +if (unlikely (current->flags &PF_MEMALLOC )) + goto force; +
OK, sounds good to me. THanks!
Quoted 19 lines
mm/memcontrol.c +0
-0if (unlikely (task_in_memcg_oom (current))) goto nomem;mm/vmscan.c +2
-0@@ -3043,7 +3043,9 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg, sc.gfp_mask, sc.reclaim_idx); + current->flags |=PF_MEMALLOC ; nr_reclaimed =do_try_to_free_pages (zonelist, &sc); + current->flags &= ~PF_MEMALLOC ;trace_mm_vmscan_memcg_reclaim_end (nr_reclaimed);Signature · 1 line
2.10.0
Signature · 8 lines
Michal Hocko SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Johannes Weiner
maintainerQuoted 7 lines · Michal Hocko
Quoted 3 lines · Johannes Weiner
Like other direct reclaimers, mark tasks in memcg reclaim
PF_MEMALLOCto avoid recursing into any other form of direct reclaim. Then let recursive charges fromPF_MEMALLOCcontexts bypass the cgroup limit.Should we mark this for stable (up to 4.5) which changed the out-out to opt-in?
Yes, good point.
Internally, we're pulling it into our 4.6 tree as well. The commit that fixes the particular bug we encountered in btrfs is a9bb7e620efd ("memcg: only account kmem allocations marked as __GFP_ACCOUNT") in 4.5+, so you could argue that we don't need the backport in kernels with this commit. And I'm not aware of other manifestations of this problem. But the unbounded recursion hole is still there, technically, so we might just want to put it into all stable kernels and be safe.
So either
or, and I'm leaning toward that, simply
Michal Hocko
maintainerQuoted 19 lines · Johannes Weiner
Quoted 7 lines · Michal Hocko
Quoted 3 lines · Johannes Weiner
Like other direct reclaimers, mark tasks in memcg reclaim
PF_MEMALLOCto avoid recursing into any other form of direct reclaim. Then let recursive charges fromPF_MEMALLOCcontexts bypass the cgroup limit.Should we mark this for stable (up to 4.5) which changed the out-out to opt-in?
Yes, good point.
Internally, we're pulling it into our 4.6 tree as well. The commit that fixes the particular bug we encountered in btrfs is
a9bb7e620efd("memcg: only account kmem allocations marked as__GFP_ACCOUNT") in 4.5+, so you could argue that we don't need the backport in kernels with this commit. And I'm not aware of other manifestations of this problem. But the unbounded recursion hole is still there, technically, so we might just want to put it into all stable kernels and be safe.
Quoted 3 lines
So either
Cc <[email protected]> # up to and including 4.5
As the patch was released in 4.5 it shouldn't be needed in 4.5 stable tree but
Quoted 3 lines
or, and I'm leaning toward that, simply
Cc <[email protected]>
this sounds less confusing I guess.
Signature · 2 lines
Michal Hocko SUSE Labs