1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/oom.h>
21#include <linux/mm.h>
22#include <linux/err.h>
23#include <linux/gfp.h>
24#include <linux/sched.h>
25#include <linux/sched/mm.h>
26#include <linux/sched/coredump.h>
27#include <linux/sched/task.h>
28#include <linux/swap.h>
29#include <linux/timex.h>
30#include <linux/jiffies.h>
31#include <linux/cpuset.h>
32#include <linux/export.h>
33#include <linux/notifier.h>
34#include <linux/memcontrol.h>
35#include <linux/mempolicy.h>
36#include <linux/security.h>
37#include <linux/ptrace.h>
38#include <linux/freezer.h>
39#include <linux/ftrace.h>
40#include <linux/ratelimit.h>
41#include <linux/kthread.h>
42#include <linux/init.h>
43#include <linux/mmu_notifier.h>
44
45#include <asm/tlb.h>
46#include "internal.h"
47#include "slab.h"
48
49#define CREATE_TRACE_POINTS
50#include <trace/events/oom.h>
51
52int sysctl_panic_on_oom;
53int sysctl_oom_kill_allocating_task;
54int sysctl_oom_dump_tasks = 1;
55
56DEFINE_MUTEX(oom_lock);
57
58#ifdef CONFIG_NUMA
59
60
61
62
63
64
65
66
67
68static bool has_intersects_mems_allowed(struct task_struct *start,
69 const nodemask_t *mask)
70{
71 struct task_struct *tsk;
72 bool ret = false;
73
74 rcu_read_lock();
75 for_each_thread(start, tsk) {
76 if (mask) {
77
78
79
80
81
82
83 ret = mempolicy_nodemask_intersects(tsk, mask);
84 } else {
85
86
87
88
89 ret = cpuset_mems_allowed_intersects(current, tsk);
90 }
91 if (ret)
92 break;
93 }
94 rcu_read_unlock();
95
96 return ret;
97}
98#else
99static bool has_intersects_mems_allowed(struct task_struct *tsk,
100 const nodemask_t *mask)
101{
102 return true;
103}
104#endif
105
106
107
108
109
110
111
112struct task_struct *find_lock_task_mm(struct task_struct *p)
113{
114 struct task_struct *t;
115
116 rcu_read_lock();
117
118 for_each_thread(p, t) {
119 task_lock(t);
120 if (likely(t->mm))
121 goto found;
122 task_unlock(t);
123 }
124 t = NULL;
125found:
126 rcu_read_unlock();
127
128 return t;
129}
130
131
132
133
134
135static inline bool is_sysrq_oom(struct oom_control *oc)
136{
137 return oc->order == -1;
138}
139
140static inline bool is_memcg_oom(struct oom_control *oc)
141{
142 return oc->memcg != NULL;
143}
144
145
146static bool oom_unkillable_task(struct task_struct *p,
147 struct mem_cgroup *memcg, const nodemask_t *nodemask)
148{
149 if (is_global_init(p))
150 return true;
151 if (p->flags & PF_KTHREAD)
152 return true;
153
154
155 if (memcg && !task_in_mem_cgroup(p, memcg))
156 return true;
157
158
159 if (!has_intersects_mems_allowed(p, nodemask))
160 return true;
161
162 return false;
163}
164
165
166
167
168
169static bool is_dump_unreclaim_slabs(void)
170{
171 unsigned long nr_lru;
172
173 nr_lru = global_node_page_state(NR_ACTIVE_ANON) +
174 global_node_page_state(NR_INACTIVE_ANON) +
175 global_node_page_state(NR_ACTIVE_FILE) +
176 global_node_page_state(NR_INACTIVE_FILE) +
177 global_node_page_state(NR_ISOLATED_ANON) +
178 global_node_page_state(NR_ISOLATED_FILE) +
179 global_node_page_state(NR_UNEVICTABLE);
180
181 return (global_node_page_state(NR_SLAB_UNRECLAIMABLE) > nr_lru);
182}
183
184
185
186
187
188
189
190
191
192
193
194
195unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg,
196 const nodemask_t *nodemask, unsigned long totalpages)
197{
198 long points;
199 long adj;
200
201 if (oom_unkillable_task(p, memcg, nodemask))
202 return 0;
203
204 p = find_lock_task_mm(p);
205 if (!p)
206 return 0;
207
208
209
210
211
212
213 adj = (long)p->signal->oom_score_adj;
214 if (adj == OOM_SCORE_ADJ_MIN ||
215 test_bit(MMF_OOM_SKIP, &p->mm->flags) ||
216 in_vfork(p)) {
217 task_unlock(p);
218 return 0;
219 }
220
221
222
223
224
225 points = get_mm_rss(p->mm) + get_mm_counter(p->mm, MM_SWAPENTS) +
226 mm_pgtables_bytes(p->mm) / PAGE_SIZE;
227 task_unlock(p);
228
229
230 adj *= totalpages / 1000;
231 points += adj;
232
233
234
235
236
237 return points > 0 ? points : 1;
238}
239
240enum oom_constraint {
241 CONSTRAINT_NONE,
242 CONSTRAINT_CPUSET,
243 CONSTRAINT_MEMORY_POLICY,
244 CONSTRAINT_MEMCG,
245};
246
247
248
249
250static enum oom_constraint constrained_alloc(struct oom_control *oc)
251{
252 struct zone *zone;
253 struct zoneref *z;
254 enum zone_type high_zoneidx = gfp_zone(oc->gfp_mask);
255 bool cpuset_limited = false;
256 int nid;
257
258 if (is_memcg_oom(oc)) {
259 oc->totalpages = mem_cgroup_get_limit(oc->memcg) ?: 1;
260 return CONSTRAINT_MEMCG;
261 }
262
263
264 oc->totalpages = totalram_pages + total_swap_pages;
265
266 if (!IS_ENABLED(CONFIG_NUMA))
267 return CONSTRAINT_NONE;
268
269 if (!oc->zonelist)
270 return CONSTRAINT_NONE;
271
272
273
274
275
276 if (oc->gfp_mask & __GFP_THISNODE)
277 return CONSTRAINT_NONE;
278
279
280
281
282
283
284 if (oc->nodemask &&
285 !nodes_subset(node_states[N_MEMORY], *oc->nodemask)) {
286 oc->totalpages = total_swap_pages;
287 for_each_node_mask(nid, *oc->nodemask)
288 oc->totalpages += node_spanned_pages(nid);
289 return CONSTRAINT_MEMORY_POLICY;
290 }
291
292
293 for_each_zone_zonelist_nodemask(zone, z, oc->zonelist,
294 high_zoneidx, oc->nodemask)
295 if (!cpuset_zone_allowed(zone, oc->gfp_mask))
296 cpuset_limited = true;
297
298 if (cpuset_limited) {
299 oc->totalpages = total_swap_pages;
300 for_each_node_mask(nid, cpuset_current_mems_allowed)
301 oc->totalpages += node_spanned_pages(nid);
302 return CONSTRAINT_CPUSET;
303 }
304 return CONSTRAINT_NONE;
305}
306
307static int oom_evaluate_task(struct task_struct *task, void *arg)
308{
309 struct oom_control *oc = arg;
310 unsigned long points;
311
312 if (oom_unkillable_task(task, NULL, oc->nodemask))
313 goto next;
314
315
316
317
318
319
320
321 if (!is_sysrq_oom(oc) && tsk_is_oom_victim(task)) {
322 if (test_bit(MMF_OOM_SKIP, &task->signal->oom_mm->flags))
323 goto next;
324 goto abort;
325 }
326
327
328
329
330
331 if (oom_task_origin(task)) {
332 points = ULONG_MAX;
333 goto select;
334 }
335
336 points = oom_badness(task, NULL, oc->nodemask, oc->totalpages);
337 if (!points || points < oc->chosen_points)
338 goto next;
339
340
341 if (points == oc->chosen_points && thread_group_leader(oc->chosen))
342 goto next;
343select:
344 if (oc->chosen)
345 put_task_struct(oc->chosen);
346 get_task_struct(task);
347 oc->chosen = task;
348 oc->chosen_points = points;
349next:
350 return 0;
351abort:
352 if (oc->chosen)
353 put_task_struct(oc->chosen);
354 oc->chosen = (void *)-1UL;
355 return 1;
356}
357
358
359
360
361
362static void select_bad_process(struct oom_control *oc)
363{
364 if (is_memcg_oom(oc))
365 mem_cgroup_scan_tasks(oc->memcg, oom_evaluate_task, oc);
366 else {
367 struct task_struct *p;
368
369 rcu_read_lock();
370 for_each_process(p)
371 if (oom_evaluate_task(p, oc))
372 break;
373 rcu_read_unlock();
374 }
375
376 oc->chosen_points = oc->chosen_points * 1000 / oc->totalpages;
377}
378
379
380
381
382
383
384
385
386
387
388
389
390static void dump_tasks(struct mem_cgroup *memcg, const nodemask_t *nodemask)
391{
392 struct task_struct *p;
393 struct task_struct *task;
394
395 pr_info("[ pid ] uid tgid total_vm rss pgtables_bytes swapents oom_score_adj name\n");
396 rcu_read_lock();
397 for_each_process(p) {
398 if (oom_unkillable_task(p, memcg, nodemask))
399 continue;
400
401 task = find_lock_task_mm(p);
402 if (!task) {
403
404
405
406
407
408 continue;
409 }
410
411 pr_info("[%5d] %5d %5d %8lu %8lu %8ld %8lu %5hd %s\n",
412 task->pid, from_kuid(&init_user_ns, task_uid(task)),
413 task->tgid, task->mm->total_vm, get_mm_rss(task->mm),
414 mm_pgtables_bytes(task->mm),
415 get_mm_counter(task->mm, MM_SWAPENTS),
416 task->signal->oom_score_adj, task->comm);
417 task_unlock(task);
418 }
419 rcu_read_unlock();
420}
421
422static void dump_header(struct oom_control *oc, struct task_struct *p)
423{
424 pr_warn("%s invoked oom-killer: gfp_mask=%#x(%pGg), nodemask=%*pbl, order=%d, oom_score_adj=%hd\n",
425 current->comm, oc->gfp_mask, &oc->gfp_mask,
426 nodemask_pr_args(oc->nodemask), oc->order,
427 current->signal->oom_score_adj);
428 if (!IS_ENABLED(CONFIG_COMPACTION) && oc->order)
429 pr_warn("COMPACTION is disabled!!!\n");
430
431 cpuset_print_current_mems_allowed();
432 dump_stack();
433 if (is_memcg_oom(oc))
434 mem_cgroup_print_oom_info(oc->memcg, p);
435 else {
436 show_mem(SHOW_MEM_FILTER_NODES, oc->nodemask);
437 if (is_dump_unreclaim_slabs())
438 dump_unreclaimable_slab();
439 }
440 if (sysctl_oom_dump_tasks)
441 dump_tasks(oc->memcg, oc->nodemask);
442}
443
444
445
446
447static atomic_t oom_victims = ATOMIC_INIT(0);
448static DECLARE_WAIT_QUEUE_HEAD(oom_victims_wait);
449
450static bool oom_killer_disabled __read_mostly;
451
452#define K(x) ((x) << (PAGE_SHIFT-10))
453
454
455
456
457
458
459
460bool process_shares_mm(struct task_struct *p, struct mm_struct *mm)
461{
462 struct task_struct *t;
463
464 for_each_thread(p, t) {
465 struct mm_struct *t_mm = READ_ONCE(t->mm);
466 if (t_mm)
467 return t_mm == mm;
468 }
469 return false;
470}
471
472#ifdef CONFIG_MMU
473
474
475
476
477static struct task_struct *oom_reaper_th;
478static DECLARE_WAIT_QUEUE_HEAD(oom_reaper_wait);
479static struct task_struct *oom_reaper_list;
480static DEFINE_SPINLOCK(oom_reaper_lock);
481
482void __oom_reap_task_mm(struct mm_struct *mm)
483{
484 struct vm_area_struct *vma;
485
486
487
488
489
490
491
492 set_bit(MMF_UNSTABLE, &mm->flags);
493
494 for (vma = mm->mmap ; vma; vma = vma->vm_next) {
495 if (!can_madv_dontneed_vma(vma))
496 continue;
497
498
499
500
501
502
503
504
505
506
507
508 if (vma_is_anonymous(vma) || !(vma->vm_flags & VM_SHARED)) {
509 const unsigned long start = vma->vm_start;
510 const unsigned long end = vma->vm_end;
511 struct mmu_gather tlb;
512
513 tlb_gather_mmu(&tlb, mm, start, end);
514 mmu_notifier_invalidate_range_start(mm, start, end);
515 unmap_page_range(&tlb, vma, start, end, NULL);
516 mmu_notifier_invalidate_range_end(mm, start, end);
517 tlb_finish_mmu(&tlb, start, end);
518 }
519 }
520}
521
522static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)
523{
524 bool ret = true;
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540 mutex_lock(&oom_lock);
541
542 if (!down_read_trylock(&mm->mmap_sem)) {
543 ret = false;
544 trace_skip_task_reaping(tsk->pid);
545 goto unlock_oom;
546 }
547
548
549
550
551
552
553
554 if (mm_has_blockable_invalidate_notifiers(mm)) {
555 up_read(&mm->mmap_sem);
556 schedule_timeout_idle(HZ);
557 goto unlock_oom;
558 }
559
560
561
562
563
564
565
566 if (test_bit(MMF_OOM_SKIP, &mm->flags)) {
567 up_read(&mm->mmap_sem);
568 trace_skip_task_reaping(tsk->pid);
569 goto unlock_oom;
570 }
571
572 trace_start_task_reaping(tsk->pid);
573
574 __oom_reap_task_mm(mm);
575
576 pr_info("oom_reaper: reaped process %d (%s), now anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
577 task_pid_nr(tsk), tsk->comm,
578 K(get_mm_counter(mm, MM_ANONPAGES)),
579 K(get_mm_counter(mm, MM_FILEPAGES)),
580 K(get_mm_counter(mm, MM_SHMEMPAGES)));
581 up_read(&mm->mmap_sem);
582
583 trace_finish_task_reaping(tsk->pid);
584unlock_oom:
585 mutex_unlock(&oom_lock);
586 return ret;
587}
588
589#define MAX_OOM_REAP_RETRIES 10
590static void oom_reap_task(struct task_struct *tsk)
591{
592 int attempts = 0;
593 struct mm_struct *mm = tsk->signal->oom_mm;
594
595
596 while (attempts++ < MAX_OOM_REAP_RETRIES && !oom_reap_task_mm(tsk, mm))
597 schedule_timeout_idle(HZ/10);
598
599 if (attempts <= MAX_OOM_REAP_RETRIES ||
600 test_bit(MMF_OOM_SKIP, &mm->flags))
601 goto done;
602
603 pr_info("oom_reaper: unable to reap pid:%d (%s)\n",
604 task_pid_nr(tsk), tsk->comm);
605 debug_show_all_locks();
606
607done:
608 tsk->oom_reaper_list = NULL;
609
610
611
612
613
614 set_bit(MMF_OOM_SKIP, &mm->flags);
615
616
617 put_task_struct(tsk);
618}
619
620static int oom_reaper(void *unused)
621{
622 while (true) {
623 struct task_struct *tsk = NULL;
624
625 wait_event_freezable(oom_reaper_wait, oom_reaper_list != NULL);
626 spin_lock(&oom_reaper_lock);
627 if (oom_reaper_list != NULL) {
628 tsk = oom_reaper_list;
629 oom_reaper_list = tsk->oom_reaper_list;
630 }
631 spin_unlock(&oom_reaper_lock);
632
633 if (tsk)
634 oom_reap_task(tsk);
635 }
636
637 return 0;
638}
639
640static void wake_oom_reaper(struct task_struct *tsk)
641{
642
643 if (tsk == oom_reaper_list || tsk->oom_reaper_list)
644 return;
645
646 get_task_struct(tsk);
647
648 spin_lock(&oom_reaper_lock);
649 tsk->oom_reaper_list = oom_reaper_list;
650 oom_reaper_list = tsk;
651 spin_unlock(&oom_reaper_lock);
652 trace_wake_reaper(tsk->pid);
653 wake_up(&oom_reaper_wait);
654}
655
656static int __init oom_init(void)
657{
658 oom_reaper_th = kthread_run(oom_reaper, NULL, "oom_reaper");
659 return 0;
660}
661subsys_initcall(oom_init)
662#else
663static inline void wake_oom_reaper(struct task_struct *tsk)
664{
665}
666#endif
667
668
669
670
671
672
673
674
675
676
677
678static void mark_oom_victim(struct task_struct *tsk)
679{
680 struct mm_struct *mm = tsk->mm;
681
682 WARN_ON(oom_killer_disabled);
683
684 if (test_and_set_tsk_thread_flag(tsk, TIF_MEMDIE))
685 return;
686
687
688 if (!cmpxchg(&tsk->signal->oom_mm, NULL, mm)) {
689 mmgrab(tsk->signal->oom_mm);
690 set_bit(MMF_OOM_VICTIM, &mm->flags);
691 }
692
693
694
695
696
697
698
699 __thaw_task(tsk);
700 atomic_inc(&oom_victims);
701 trace_mark_victim(tsk->pid);
702}
703
704
705
706
707void exit_oom_victim(void)
708{
709 clear_thread_flag(TIF_MEMDIE);
710
711 if (!atomic_dec_return(&oom_victims))
712 wake_up_all(&oom_victims_wait);
713}
714
715
716
717
718void oom_killer_enable(void)
719{
720 oom_killer_disabled = false;
721 pr_info("OOM killer enabled.\n");
722}
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739bool oom_killer_disable(signed long timeout)
740{
741 signed long ret;
742
743
744
745
746
747 if (mutex_lock_killable(&oom_lock))
748 return false;
749 oom_killer_disabled = true;
750 mutex_unlock(&oom_lock);
751
752 ret = wait_event_interruptible_timeout(oom_victims_wait,
753 !atomic_read(&oom_victims), timeout);
754 if (ret <= 0) {
755 oom_killer_enable();
756 return false;
757 }
758 pr_info("OOM killer disabled.\n");
759
760 return true;
761}
762
763static inline bool __task_will_free_mem(struct task_struct *task)
764{
765 struct signal_struct *sig = task->signal;
766
767
768
769
770
771
772 if (sig->flags & SIGNAL_GROUP_COREDUMP)
773 return false;
774
775 if (sig->flags & SIGNAL_GROUP_EXIT)
776 return true;
777
778 if (thread_group_empty(task) && (task->flags & PF_EXITING))
779 return true;
780
781 return false;
782}
783
784
785
786
787
788
789
790
791static bool task_will_free_mem(struct task_struct *task)
792{
793 struct mm_struct *mm = task->mm;
794 struct task_struct *p;
795 bool ret = true;
796
797
798
799
800
801
802 if (!mm)
803 return false;
804
805 if (!__task_will_free_mem(task))
806 return false;
807
808
809
810
811
812 if (test_bit(MMF_OOM_SKIP, &mm->flags))
813 return false;
814
815 if (atomic_read(&mm->mm_users) <= 1)
816 return true;
817
818
819
820
821
822
823 rcu_read_lock();
824 for_each_process(p) {
825 if (!process_shares_mm(p, mm))
826 continue;
827 if (same_thread_group(task, p))
828 continue;
829 ret = __task_will_free_mem(p);
830 if (!ret)
831 break;
832 }
833 rcu_read_unlock();
834
835 return ret;
836}
837
838static void oom_kill_process(struct oom_control *oc, const char *message)
839{
840 struct task_struct *p = oc->chosen;
841 unsigned int points = oc->chosen_points;
842 struct task_struct *victim = p;
843 struct task_struct *child;
844 struct task_struct *t;
845 struct mm_struct *mm;
846 unsigned int victim_points = 0;
847 static DEFINE_RATELIMIT_STATE(oom_rs, DEFAULT_RATELIMIT_INTERVAL,
848 DEFAULT_RATELIMIT_BURST);
849 bool can_oom_reap = true;
850
851
852
853
854
855
856 task_lock(p);
857 if (task_will_free_mem(p)) {
858 mark_oom_victim(p);
859 wake_oom_reaper(p);
860 task_unlock(p);
861 put_task_struct(p);
862 return;
863 }
864 task_unlock(p);
865
866 if (__ratelimit(&oom_rs))
867 dump_header(oc, p);
868
869 pr_err("%s: Kill process %d (%s) score %u or sacrifice child\n",
870 message, task_pid_nr(p), p->comm, points);
871
872
873
874
875
876
877
878 read_lock(&tasklist_lock);
879 for_each_thread(p, t) {
880 list_for_each_entry(child, &t->children, sibling) {
881 unsigned int child_points;
882
883 if (process_shares_mm(child, p->mm))
884 continue;
885
886
887
888 child_points = oom_badness(child,
889 oc->memcg, oc->nodemask, oc->totalpages);
890 if (child_points > victim_points) {
891 put_task_struct(victim);
892 victim = child;
893 victim_points = child_points;
894 get_task_struct(victim);
895 }
896 }
897 }
898 read_unlock(&tasklist_lock);
899
900 p = find_lock_task_mm(victim);
901 if (!p) {
902 put_task_struct(victim);
903 return;
904 } else if (victim != p) {
905 get_task_struct(p);
906 put_task_struct(victim);
907 victim = p;
908 }
909
910
911 mm = victim->mm;
912 mmgrab(mm);
913
914
915 count_vm_event(OOM_KILL);
916 count_memcg_event_mm(mm, OOM_KILL);
917
918
919
920
921
922
923 do_send_sig_info(SIGKILL, SEND_SIG_FORCED, victim, true);
924 mark_oom_victim(victim);
925 pr_err("Killed process %d (%s) total-vm:%lukB, anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
926 task_pid_nr(victim), victim->comm, K(victim->mm->total_vm),
927 K(get_mm_counter(victim->mm, MM_ANONPAGES)),
928 K(get_mm_counter(victim->mm, MM_FILEPAGES)),
929 K(get_mm_counter(victim->mm, MM_SHMEMPAGES)));
930 task_unlock(victim);
931
932
933
934
935
936
937
938
939
940
941 rcu_read_lock();
942 for_each_process(p) {
943 if (!process_shares_mm(p, mm))
944 continue;
945 if (same_thread_group(p, victim))
946 continue;
947 if (is_global_init(p)) {
948 can_oom_reap = false;
949 set_bit(MMF_OOM_SKIP, &mm->flags);
950 pr_info("oom killer %d (%s) has mm pinned by %d (%s)\n",
951 task_pid_nr(victim), victim->comm,
952 task_pid_nr(p), p->comm);
953 continue;
954 }
955
956
957
958
959 if (unlikely(p->flags & PF_KTHREAD))
960 continue;
961 do_send_sig_info(SIGKILL, SEND_SIG_FORCED, p, true);
962 }
963 rcu_read_unlock();
964
965 if (can_oom_reap)
966 wake_oom_reaper(victim);
967
968 mmdrop(mm);
969 put_task_struct(victim);
970}
971#undef K
972
973
974
975
976static void check_panic_on_oom(struct oom_control *oc,
977 enum oom_constraint constraint)
978{
979 if (likely(!sysctl_panic_on_oom))
980 return;
981 if (sysctl_panic_on_oom != 2) {
982
983
984
985
986
987 if (constraint != CONSTRAINT_NONE)
988 return;
989 }
990
991 if (is_sysrq_oom(oc))
992 return;
993 dump_header(oc, NULL);
994 panic("Out of memory: %s panic_on_oom is enabled\n",
995 sysctl_panic_on_oom == 2 ? "compulsory" : "system-wide");
996}
997
998static BLOCKING_NOTIFIER_HEAD(oom_notify_list);
999
1000int register_oom_notifier(struct notifier_block *nb)
1001{
1002 return blocking_notifier_chain_register(&oom_notify_list, nb);
1003}
1004EXPORT_SYMBOL_GPL(register_oom_notifier);
1005
1006int unregister_oom_notifier(struct notifier_block *nb)
1007{
1008 return blocking_notifier_chain_unregister(&oom_notify_list, nb);
1009}
1010EXPORT_SYMBOL_GPL(unregister_oom_notifier);
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021bool out_of_memory(struct oom_control *oc)
1022{
1023 unsigned long freed = 0;
1024 enum oom_constraint constraint = CONSTRAINT_NONE;
1025
1026 if (oom_killer_disabled)
1027 return false;
1028
1029 if (!is_memcg_oom(oc)) {
1030 blocking_notifier_call_chain(&oom_notify_list, 0, &freed);
1031 if (freed > 0)
1032
1033 return true;
1034 }
1035
1036
1037
1038
1039
1040
1041 if (task_will_free_mem(current)) {
1042 mark_oom_victim(current);
1043 wake_oom_reaper(current);
1044 return true;
1045 }
1046
1047
1048
1049
1050
1051
1052
1053 if (oc->gfp_mask && !(oc->gfp_mask & __GFP_FS))
1054 return true;
1055
1056
1057
1058
1059
1060 constraint = constrained_alloc(oc);
1061 if (constraint != CONSTRAINT_MEMORY_POLICY)
1062 oc->nodemask = NULL;
1063 check_panic_on_oom(oc, constraint);
1064
1065 if (!is_memcg_oom(oc) && sysctl_oom_kill_allocating_task &&
1066 current->mm && !oom_unkillable_task(current, NULL, oc->nodemask) &&
1067 current->signal->oom_score_adj != OOM_SCORE_ADJ_MIN) {
1068 get_task_struct(current);
1069 oc->chosen = current;
1070 oom_kill_process(oc, "Out of memory (oom_kill_allocating_task)");
1071 return true;
1072 }
1073
1074 select_bad_process(oc);
1075
1076 if (!oc->chosen && !is_sysrq_oom(oc) && !is_memcg_oom(oc)) {
1077 dump_header(oc, NULL);
1078 panic("Out of memory and no killable processes...\n");
1079 }
1080 if (oc->chosen && oc->chosen != (void *)-1UL) {
1081 oom_kill_process(oc, !is_memcg_oom(oc) ? "Out of memory" :
1082 "Memory cgroup out of memory");
1083
1084
1085
1086
1087 schedule_timeout_killable(1);
1088 }
1089 return !!oc->chosen;
1090}
1091
1092
1093
1094
1095
1096
1097void pagefault_out_of_memory(void)
1098{
1099 struct oom_control oc = {
1100 .zonelist = NULL,
1101 .nodemask = NULL,
1102 .memcg = NULL,
1103 .gfp_mask = 0,
1104 .order = 0,
1105 };
1106
1107 if (mem_cgroup_oom_synchronize(true))
1108 return;
1109
1110 if (!mutex_trylock(&oom_lock))
1111 return;
1112 out_of_memory(&oc);
1113 mutex_unlock(&oom_lock);
1114}
1115