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