From nobody Sun Dec 14 11:18:36 2025 Received: from smtpout.efficios.com (smtpout.efficios.com [158.69.130.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 20056146A66; Sat, 13 Dec 2025 19:04:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=158.69.130.18 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765652663; cv=none; b=hTEUSXmfvrPo5CF40nEnfC4g+G316CKZNgOWtGItqhUCvw9uV0movOzBNX8cUucaOShcngoM0sJcmNjkO+wJ0UALJwfhEkFnczwRvcz6Fxhappwi2Eai3KN5gq3m2QqvJX2cG9kI8R/shSpkgx1oSDtIFWYAqTfb07iZZxa7XOU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765652663; c=relaxed/simple; bh=NCD4cj9GIUWg1yFiK6tL85+EidtCzaI9w3D/kNcMFsU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=u9fjNo8r61YhfD2MbXhxIZhpjmbGibbi/hauZiOzQ+nHCcbC3YT3zHQlr3l1XTOEAuGY14p5arYukCv4rmSKFs9YRgs48+bPS9ECqLjTkK58FnPIyatlebDdgexZDhjyMxQGRHg84+1AqqPnvNGJ0A7CuFE1TV0GqV04uCIO4x4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=efficios.com; spf=pass smtp.mailfrom=efficios.com; dkim=pass (2048-bit key) header.d=efficios.com header.i=@efficios.com header.b=pfM5tXmx; arc=none smtp.client-ip=158.69.130.18 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=efficios.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=efficios.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=efficios.com header.i=@efficios.com header.b="pfM5tXmx" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=efficios.com; s=smtpout1; t=1765652176; bh=SvNKZ9aFwfw+fFYNP08/KsjB3S08HXQk+/VOcOlRasA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=pfM5tXmxhTIBKdsqblwHY06UFuxpxqvjYcn3qLIVv8pcJzxc/oLE4OC5fq9CiMUxm Mkfae6mICbnp+md+7Dcpe5o2mFcvxcBG/DA1dpTAPU45Iy12aoc15veaGbyU8IEDJc d8akVDytsD951J1MKy+Y+iV01BOApMk2RZ91S4AKnaW6U0xirMDTt6F0qxOqD+UkSb YNdePeQgOEAIm6T7VZY7RsU/B5a9f+dB7muzzcmD1WqVckW5Dyh/zlNtc3r2KNn1F0 0RfYbponls3kANgLt2ZB83MoLXpPtCczfFByex0unCs+AtIgKAaqVUL6rHxhFog5bH +GV5Ol+FVerHw== Received: from thinkos.internal.efficios.com (mtl.efficios.com [216.120.195.104]) by smtpout.efficios.com (Postfix) with ESMTPSA id 4dTFsW5Q6SzYmx; Sat, 13 Dec 2025 13:56:15 -0500 (EST) From: Mathieu Desnoyers To: Andrew Morton Cc: linux-kernel@vger.kernel.org, Mathieu Desnoyers , "Paul E. McKenney" , Steven Rostedt , Masami Hiramatsu , Dennis Zhou , Tejun Heo , Christoph Lameter , Martin Liu , David Rientjes , christian.koenig@amd.com, Shakeel Butt , SeongJae Park , Michal Hocko , Johannes Weiner , Sweet Tea Dorminy , Lorenzo Stoakes , "Liam R . Howlett" , Mike Rapoport , Suren Baghdasaryan , Vlastimil Babka , Christian Brauner , Wei Yang , David Hildenbrand , Miaohe Lin , Al Viro , linux-mm@kvack.org, linux-trace-kernel@vger.kernel.org, Yu Zhao , Roman Gushchin , Mateusz Guzik , Matthew Wilcox , Baolin Wang , Aboorva Devarajan Subject: [PATCH v10 3/3] mm: Implement precise OOM killer task selection Date: Sat, 13 Dec 2025 13:56:08 -0500 Message-Id: <20251213185608.3418096-4-mathieu.desnoyers@efficios.com> X-Mailer: git-send-email 2.39.5 In-Reply-To: <20251213185608.3418096-1-mathieu.desnoyers@efficios.com> References: <20251213185608.3418096-1-mathieu.desnoyers@efficios.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Use the hierarchical tree counter approximation to implement the OOM killer task selection with a 2-pass algorithm. The first pass selects the process that has the highest badness points approximation, and the second pass compares each process using the current max badness points approximation. The second pass uses an approximate comparison to eliminate all processes which are below the current max badness points approximation accuracy range. Summing the per-CPU counters to calculate the precise badness of tasks is only required for tasks with an approximate badness within the accuracy range of the current max points value. Limit to 16 the maximum number of badness sums allowed for an OOM killer task selection before falling back to the approximated comparison. This ensures bounded execution time for scenarios where many tasks have badness within the accuracy of the maximum badness approximation. Tested with the following script: #!/bin/sh for a in $(seq 1 10); do (tail /dev/zero &); done sleep 5 for a in $(seq 1 10); do (tail /dev/zero &); done sleep 2 for a in $(seq 1 10); do (tail /dev/zero &); done echo "Waiting for tasks to finish" wait Results: OOM kill order on a 128GB memory system =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D * systemd and sd-pam are chosen first due to their oom_score_ajd:100: Out of memory: Killed process 3502 (systemd) total-vm:20096kB, anon-rss:0kB= , file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:72kB oom_score_adj:100 Out of memory: Killed process 3503 ((sd-pam)) total-vm:21432kB, anon-rss:0k= B, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:76kB oom_score_adj:100 * The first batch of 10 processes are gradually killed, consecutively picking the one that uses the most memory. The fact that we are freeing memory from the previous processes increases the threshold at which the remaining processes of that group are killed. Processes from the second and third batches of 10 processes have time to start before we complete killing the first 10 processes: Out of memory: Killed process 3703 (tail) total-vm:6591280kB, anon-rss:6578= 176kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:12936kB oom_score_adj= :0 Out of memory: Killed process 3705 (tail) total-vm:6731716kB, anon-rss:6709= 248kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:13212kB oom_score_adj= :0 Out of memory: Killed process 3707 (tail) total-vm:6977216kB, anon-rss:6946= 816kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:13692kB oom_score_adj= :0 Out of memory: Killed process 3699 (tail) total-vm:7205640kB, anon-rss:7184= 384kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:14136kB oom_score_adj= :0 Out of memory: Killed process 3713 (tail) total-vm:7463204kB, anon-rss:7438= 336kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:14644kB oom_score_adj= :0 Out of memory: Killed process 3701 (tail) total-vm:7739204kB, anon-rss:7716= 864kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:15180kB oom_score_adj= :0 Out of memory: Killed process 3709 (tail) total-vm:8050176kB, anon-rss:8028= 160kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:15792kB oom_score_adj= :0 Out of memory: Killed process 3711 (tail) total-vm:8362236kB, anon-rss:8339= 456kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:16404kB oom_score_adj= :0 Out of memory: Killed process 3715 (tail) total-vm:8649360kB, anon-rss:8634= 368kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:16972kB oom_score_adj= :0 Out of memory: Killed process 3697 (tail) total-vm:8951788kB, anon-rss:8929= 280kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:17560kB oom_score_adj= :0 * Even though there is a 2 seconds delay between the 2nd and 3rd batches those appear to execute in mixed order. Therefore, let's consider them as a single batch of 20 processes. We are hitting oom at a lower memory threshold because at this point the 20 remaining proceses are running rather than the previous 10. The process with highest memory usage is selected for oom, thus making room for the remaining processes so they can use more memory before they fill the available memory, thus explaining why the memory use for selected processes gradually increases, until all system memory is used by the last one: Out of memory: Killed process 3731 (tail) total-vm:7089868kB, anon-rss:7077= 888kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:13912kB oom_score_adj= :0 Out of memory: Killed process 3721 (tail) total-vm:7417248kB, anon-rss:7405= 568kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:14556kB oom_score_adj= :0 Out of memory: Killed process 3729 (tail) total-vm:7795864kB, anon-rss:7766= 016kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:15300kB oom_score_adj= :0 Out of memory: Killed process 3723 (tail) total-vm:8259620kB, anon-rss:8224= 768kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:16208kB oom_score_adj= :0 Out of memory: Killed process 3737 (tail) total-vm:8695984kB, anon-rss:8667= 136kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:17060kB oom_score_adj= :0 Out of memory: Killed process 3735 (tail) total-vm:9295980kB, anon-rss:9265= 152kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:18240kB oom_score_adj= :0 Out of memory: Killed process 3727 (tail) total-vm:9907900kB, anon-rss:9895= 936kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:19428kB oom_score_adj= :0 Out of memory: Killed process 3719 (tail) total-vm:10631248kB, anon-rss:106= 00448kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:20844kB oom_score_a= dj:0 Out of memory: Killed process 3733 (tail) total-vm:11341720kB, anon-rss:113= 21344kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:22232kB oom_score_a= dj:0 Out of memory: Killed process 3725 (tail) total-vm:12348124kB, anon-rss:123= 20768kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:24204kB oom_score_a= dj:0 Out of memory: Killed process 3759 (tail) total-vm:12978888kB, anon-rss:129= 67936kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:25440kB oom_score_a= dj:0 Out of memory: Killed process 3751 (tail) total-vm:14386412kB, anon-rss:143= 52384kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:28196kB oom_score_a= dj:0 Out of memory: Killed process 3741 (tail) total-vm:16153168kB, anon-rss:161= 30048kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:31652kB oom_score_a= dj:0 Out of memory: Killed process 3753 (tail) total-vm:18414856kB, anon-rss:183= 91040kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:36076kB oom_score_a= dj:0 Out of memory: Killed process 3745 (tail) total-vm:21389456kB, anon-rss:213= 56544kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:41904kB oom_score_a= dj:0 Out of memory: Killed process 3747 (tail) total-vm:25659348kB, anon-rss:256= 32768kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:50260kB oom_score_a= dj:0 Out of memory: Killed process 3755 (tail) total-vm:32030820kB, anon-rss:320= 06144kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:62720kB oom_score_a= dj:0 Out of memory: Killed process 3743 (tail) total-vm:42648456kB, anon-rss:426= 14784kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:83504kB oom_score_a= dj:0 Out of memory: Killed process 3757 (tail) total-vm:63971028kB, anon-rss:639= 38560kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:125228kB oom_score_= adj:0 Out of memory: Killed process 3749 (tail) total-vm:127799660kB, anon-rss:12= 7778816kB, file-rss:0kB, shmem-rss:0kB, UID:1000 pgtables:250140kB oom_scor= e_adj:0 Signed-off-by: Mathieu Desnoyers Cc: Andrew Morton Cc: "Paul E. McKenney" Cc: Steven Rostedt Cc: Masami Hiramatsu Cc: Mathieu Desnoyers Cc: Dennis Zhou Cc: Tejun Heo Cc: Christoph Lameter Cc: Martin Liu Cc: David Rientjes Cc: christian.koenig@amd.com Cc: Shakeel Butt Cc: SeongJae Park Cc: Michal Hocko Cc: Johannes Weiner Cc: Sweet Tea Dorminy Cc: Lorenzo Stoakes Cc: "Liam R . Howlett" Cc: Mike Rapoport Cc: Suren Baghdasaryan Cc: Vlastimil Babka Cc: Christian Brauner Cc: Wei Yang Cc: David Hildenbrand Cc: Miaohe Lin Cc: Al Viro Cc: linux-mm@kvack.org Cc: linux-trace-kernel@vger.kernel.org Cc: Yu Zhao Cc: Roman Gushchin Cc: Mateusz Guzik Cc: Matthew Wilcox Cc: Baolin Wang Cc: Aboorva Devarajan --- fs/proc/base.c | 2 +- include/linux/mm.h | 34 +++++++++++++++++---- include/linux/oom.h | 12 +++++++- mm/oom_kill.c | 72 +++++++++++++++++++++++++++++++++++++-------- 4 files changed, 101 insertions(+), 19 deletions(-) diff --git a/fs/proc/base.c b/fs/proc/base.c index 6299878e3d97..fa48411835ba 100644 --- a/fs/proc/base.c +++ b/fs/proc/base.c @@ -589,7 +589,7 @@ static int proc_oom_score(struct seq_file *m, struct pi= d_namespace *ns, unsigned long points =3D 0; long badness; =20 - badness =3D oom_badness(task, totalpages); + badness =3D oom_badness(task, totalpages, false, NULL, NULL); /* * Special case OOM_SCORE_ADJ_MIN for all others scale the * badness value into [0, 2000] range which we have been diff --git a/include/linux/mm.h b/include/linux/mm.h index cd81fa8924eb..84a67036d010 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -2702,14 +2702,32 @@ static inline struct percpu_counter_tree_level_item= *get_rss_stat_items(struct m /* * per-process(per-mm_struct) statistics. */ +static inline unsigned long __get_mm_counter(struct mm_struct *mm, int mem= ber, bool approximate, + unsigned int *accuracy_under, unsigned int *accuracy_over) +{ + if (approximate) { + if (accuracy_under && accuracy_over) { + unsigned int under, over; + + percpu_counter_tree_approximate_accuracy_range(&mm->rss_stat[member], &= under, &over); + *accuracy_under +=3D under; + *accuracy_over +=3D over; + } + return percpu_counter_tree_approximate_sum_positive(&mm->rss_stat[member= ]); + } else { + return percpu_counter_tree_precise_sum_positive(&mm->rss_stat[member]); + } +} + static inline unsigned long get_mm_counter(struct mm_struct *mm, int membe= r) { - return percpu_counter_tree_approximate_sum_positive(&mm->rss_stat[member]= ); + return __get_mm_counter(mm, member, true, NULL, NULL); } =20 + static inline unsigned long get_mm_counter_sum(struct mm_struct *mm, int m= ember) { - return percpu_counter_tree_precise_sum_positive(&mm->rss_stat[member]); + return get_mm_counter(mm, member); } =20 void mm_trace_rss_stat(struct mm_struct *mm, int member); @@ -2750,11 +2768,17 @@ static inline int mm_counter(struct folio *folio) return mm_counter_file(folio); } =20 +static inline unsigned long __get_mm_rss(struct mm_struct *mm, bool approx= imate, + unsigned int *accuracy_under, unsigned int *accuracy_over) +{ + return __get_mm_counter(mm, MM_FILEPAGES, approximate, accuracy_under, ac= curacy_over) + + __get_mm_counter(mm, MM_ANONPAGES, approximate, accuracy_under, accuracy= _over) + + __get_mm_counter(mm, MM_SHMEMPAGES, approximate, accuracy_under, accurac= y_over); +} + static inline unsigned long get_mm_rss(struct mm_struct *mm) { - return get_mm_counter(mm, MM_FILEPAGES) + - get_mm_counter(mm, MM_ANONPAGES) + - get_mm_counter(mm, MM_SHMEMPAGES); + return __get_mm_rss(mm, true, NULL, NULL); } =20 static inline unsigned long get_mm_hiwater_rss(struct mm_struct *mm) diff --git a/include/linux/oom.h b/include/linux/oom.h index 7b02bc1d0a7e..ef3919e4c7f2 100644 --- a/include/linux/oom.h +++ b/include/linux/oom.h @@ -48,6 +48,13 @@ struct oom_control { unsigned long totalpages; struct task_struct *chosen; long chosen_points; + bool approximate; + /* + * Number of precise badness points sums performed by this task + * selection. + */ + int nr_precise; + unsigned long accuracy_under; =20 /* Used to print the constraint info. */ enum oom_constraint constraint; @@ -97,7 +104,10 @@ static inline vm_fault_t check_stable_address_space(str= uct mm_struct *mm) } =20 long oom_badness(struct task_struct *p, - unsigned long totalpages); + unsigned long totalpages, + bool approximate, + unsigned int *accuracy_under, + unsigned int *accuracy_over); =20 extern bool out_of_memory(struct oom_control *oc); =20 diff --git a/mm/oom_kill.c b/mm/oom_kill.c index c145b0feecc1..e3f6ca500701 100644 --- a/mm/oom_kill.c +++ b/mm/oom_kill.c @@ -53,6 +53,14 @@ #define CREATE_TRACE_POINTS #include =20 +/* + * Maximum number of badness sums allowed before using an approximated + * comparison. This ensures bounded execution time for scenarios where + * many tasks have badness within the accuracy of the maximum badness + * approximation. + */ +static int max_precise_badness_sums =3D 16; + static int sysctl_panic_on_oom; static int sysctl_oom_kill_allocating_task; static int sysctl_oom_dump_tasks =3D 1; @@ -194,12 +202,16 @@ static bool should_dump_unreclaim_slab(void) * oom_badness - heuristic function to determine which candidate task to k= ill * @p: task struct of which task we should calculate * @totalpages: total present RAM allowed for page allocation + * @approximate: whether the value can be approximated + * @accuracy_under: accuracy of the badness value approximation (under val= ue) + * @accuracy_over: accuracy of the badness value approximation (over value) * * The heuristic for determining which task to kill is made to be as simpl= e and * predictable as possible. The goal is to return the highest value for t= he * task consuming the most memory to avoid subsequent oom failures. */ -long oom_badness(struct task_struct *p, unsigned long totalpages) +long oom_badness(struct task_struct *p, unsigned long totalpages, bool app= roximate, + unsigned int *accuracy_under, unsigned int *accuracy_over) { long points; long adj; @@ -228,7 +240,8 @@ long oom_badness(struct task_struct *p, unsigned long t= otalpages) * The baseline for the badness score is the proportion of RAM that each * task's rss, pagetable and swap space use. */ - points =3D get_mm_rss(p->mm) + get_mm_counter(p->mm, MM_SWAPENTS) + + points =3D __get_mm_rss(p->mm, approximate, accuracy_under, accuracy_over= ) + + __get_mm_counter(p->mm, MM_SWAPENTS, approximate, accuracy_under, accura= cy_over) + mm_pgtables_bytes(p->mm) / PAGE_SIZE; task_unlock(p); =20 @@ -309,6 +322,7 @@ static enum oom_constraint constrained_alloc(struct oom= _control *oc) static int oom_evaluate_task(struct task_struct *task, void *arg) { struct oom_control *oc =3D arg; + unsigned int accuracy_under =3D 0, accuracy_over =3D 0; long points; =20 if (oom_unkillable_task(task)) @@ -339,9 +353,28 @@ static int oom_evaluate_task(struct task_struct *task,= void *arg) goto select; } =20 - points =3D oom_badness(task, oc->totalpages); - if (points =3D=3D LONG_MIN || points < oc->chosen_points) - goto next; + points =3D oom_badness(task, oc->totalpages, true, &accuracy_under, &accu= racy_over); + if (oc->approximate) { + if (points =3D=3D LONG_MIN || points < oc->chosen_points) + goto next; + } else { + /* + * Eliminate processes which are below the chosen + * points accuracy range with an approximation. + */ + if (points =3D=3D LONG_MIN || (long)(points + accuracy_over + oc->accura= cy_under - oc->chosen_points) < 0) + goto next; + + if (oc->nr_precise < max_precise_badness_sums) { + accuracy_under =3D 0; + accuracy_over =3D 0; + oc->nr_precise++; + /* Precise evaluation. */ + points =3D oom_badness(task, oc->totalpages, false, NULL, NULL); + if (points =3D=3D LONG_MIN || (long)(points + oc->accuracy_under - oc->= chosen_points) < 0) + goto next; + } + } =20 select: if (oc->chosen) @@ -349,6 +382,7 @@ static int oom_evaluate_task(struct task_struct *task, = void *arg) get_task_struct(task); oc->chosen =3D task; oc->chosen_points =3D points; + oc->accuracy_under =3D accuracy_under; next: return 0; abort: @@ -358,14 +392,8 @@ static int oom_evaluate_task(struct task_struct *task,= void *arg) return 1; } =20 -/* - * Simple selection loop. We choose the process with the highest number of - * 'points'. In case scan was aborted, oc->chosen is set to -1. - */ -static void select_bad_process(struct oom_control *oc) +static void select_bad_process_iter(struct oom_control *oc) { - oc->chosen_points =3D LONG_MIN; - if (is_memcg_oom(oc)) mem_cgroup_scan_tasks(oc->memcg, oom_evaluate_task, oc); else { @@ -379,6 +407,26 @@ static void select_bad_process(struct oom_control *oc) } } =20 +/* + * Simple selection loop. We choose the process with the highest number of + * 'points'. In case scan was aborted, oc->chosen is set to -1. + */ +static void select_bad_process(struct oom_control *oc) +{ + oc->chosen_points =3D LONG_MIN; + oc->accuracy_under =3D 0; + oc->nr_precise =3D 0; + + /* Approximate scan. */ + oc->approximate =3D true; + select_bad_process_iter(oc); + if (oc->chosen =3D=3D (void *)-1UL) + return; + /* Precise scan. */ + oc->approximate =3D false; + select_bad_process_iter(oc); +} + static int dump_task(struct task_struct *p, void *arg) { struct oom_control *oc =3D arg; --=20 2.39.5