From: Greg Kroah-Hartman Date: Sat, 27 Jan 2024 00:40:16 +0000 (-0800) Subject: 5.15-stable patches X-Git-Tag: v6.1.76~91 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=eef5b53b368fb141e2a6f099605299560f8a3508;p=thirdparty%2Fkernel%2Fstable-queue.git 5.15-stable patches added patches: mm-page_alloc-unreserve-highatomic-page-blocks-before-oom.patch --- diff --git a/queue-5.15/mm-page_alloc-unreserve-highatomic-page-blocks-before-oom.patch b/queue-5.15/mm-page_alloc-unreserve-highatomic-page-blocks-before-oom.patch new file mode 100644 index 00000000000..44af3ceb3f6 --- /dev/null +++ b/queue-5.15/mm-page_alloc-unreserve-highatomic-page-blocks-before-oom.patch @@ -0,0 +1,104 @@ +From ac3f3b0a55518056bc80ed32a41931c99e1f7d81 Mon Sep 17 00:00:00 2001 +From: Charan Teja Kalla +Date: Fri, 24 Nov 2023 16:27:25 +0530 +Subject: mm: page_alloc: unreserve highatomic page blocks before oom + +From: Charan Teja Kalla + +commit ac3f3b0a55518056bc80ed32a41931c99e1f7d81 upstream. + +__alloc_pages_direct_reclaim() is called from slowpath allocation where +high atomic reserves can be unreserved after there is a progress in +reclaim and yet no suitable page is found. Later should_reclaim_retry() +gets called from slow path allocation to decide if the reclaim needs to be +retried before OOM kill path is taken. + +should_reclaim_retry() checks the available(reclaimable + free pages) +memory against the min wmark levels of a zone and returns: + +a) true, if it is above the min wmark so that slow path allocation will + do the reclaim retries. + +b) false, thus slowpath allocation takes oom kill path. + +should_reclaim_retry() can also unreserves the high atomic reserves **but +only after all the reclaim retries are exhausted.** + +In a case where there are almost none reclaimable memory and free pages +contains mostly the high atomic reserves but allocation context can't use +these high atomic reserves, makes the available memory below min wmark +levels hence false is returned from should_reclaim_retry() leading the +allocation request to take OOM kill path. This can turn into a early oom +kill if high atomic reserves are holding lot of free memory and +unreserving of them is not attempted. + +(early)OOM is encountered on a VM with the below state: +[ 295.998653] Normal free:7728kB boost:0kB min:804kB low:1004kB +high:1204kB reserved_highatomic:8192KB active_anon:4kB inactive_anon:0kB +active_file:24kB inactive_file:24kB unevictable:1220kB writepending:0kB +present:70732kB managed:49224kB mlocked:0kB bounce:0kB free_pcp:688kB +local_pcp:492kB free_cma:0kB +[ 295.998656] lowmem_reserve[]: 0 32 +[ 295.998659] Normal: 508*4kB (UMEH) 241*8kB (UMEH) 143*16kB (UMEH) +33*32kB (UH) 7*64kB (UH) 0*128kB 0*256kB 0*512kB 0*1024kB 0*2048kB +0*4096kB = 7752kB + +Per above log, the free memory of ~7MB exist in the high atomic reserves +is not freed up before falling back to oom kill path. + +Fix it by trying to unreserve the high atomic reserves in +should_reclaim_retry() before __alloc_pages_direct_reclaim() can fallback +to oom kill path. + +Link: https://lkml.kernel.org/r/1700823445-27531-1-git-send-email-quic_charante@quicinc.com +Fixes: 0aaa29a56e4f ("mm, page_alloc: reserve pageblocks for high-order atomic allocations on demand") +Signed-off-by: Charan Teja Kalla +Reported-by: Chris Goldsworthy +Suggested-by: Michal Hocko +Acked-by: Michal Hocko +Acked-by: David Rientjes +Cc: Chris Goldsworthy +Cc: David Hildenbrand +Cc: Johannes Weiner +Cc: Mel Gorman +Cc: Pavankumar Kondeti +Cc: Vlastimil Babka +Cc: Joakim Tjernlund +Signed-off-by: Andrew Morton +Signed-off-by: Greg Kroah-Hartman +--- + mm/page_alloc.c | 16 ++++++++-------- + 1 file changed, 8 insertions(+), 8 deletions(-) + +--- a/mm/page_alloc.c ++++ b/mm/page_alloc.c +@@ -4793,14 +4793,9 @@ should_reclaim_retry(gfp_t gfp_mask, uns + else + (*no_progress_loops)++; + +- /* +- * Make sure we converge to OOM if we cannot make any progress +- * several times in the row. +- */ +- if (*no_progress_loops > MAX_RECLAIM_RETRIES) { +- /* Before OOM, exhaust highatomic_reserve */ +- return unreserve_highatomic_pageblock(ac, true); +- } ++ if (*no_progress_loops > MAX_RECLAIM_RETRIES) ++ goto out; ++ + + /* + * Keep reclaiming pages while there is a chance this will lead +@@ -4862,6 +4857,11 @@ out: + schedule_timeout_uninterruptible(1); + else + cond_resched(); ++out: ++ /* Before OOM, exhaust highatomic_reserve */ ++ if (!ret) ++ return unreserve_highatomic_pageblock(ac, true); ++ + return ret; + } + diff --git a/queue-5.15/series b/queue-5.15/series index 533cadc0642..6328559d43c 100644 --- a/queue-5.15/series +++ b/queue-5.15/series @@ -40,3 +40,4 @@ rtc-adjust-failure-return-code-for-cmos_set_alarm.patch nouveau-vmm-don-t-set-addr-on-the-fail-path-to-avoid-warning.patch ubifs-ubifs_symlink-fix-memleak-of-inode-i_link-in-error-path.patch rename-fix-the-locking-of-subdirectories.patch +mm-page_alloc-unreserve-highatomic-page-blocks-before-oom.patch