1 /* drivers/misc/lowmemorykiller.c
3 * The lowmemorykiller driver lets user-space specify a set of memory thresholds
4 * where processes with a range of oom_adj values will get killed. Specify the
5 * minimum oom_adj values in /sys/module/lowmemorykiller/parameters/adj and the
6 * number of free pages in /sys/module/lowmemorykiller/parameters/minfree. Both
7 * files take a comma separated list of numbers in ascending order.
9 * For example, write "0,8" to /sys/module/lowmemorykiller/parameters/adj and
10 * "1024,4096" to /sys/module/lowmemorykiller/parameters/minfree to kill
11 * processes with a oom_adj value of 8 or higher when the free memory drops
12 * below 4096 pages and kill processes with a oom_adj value of 0 or higher
13 * when the free memory drops below 1024 pages.
15 * The driver considers memory used for caches to be free, but if a large
16 * percentage of the cached memory is locked this can be very inaccurate
17 * and processes may not get killed until the normal oom killer is triggered.
19 * Copyright (C) 2007-2008 Google, Inc.
21 * This software is licensed under the terms of the GNU General Public
22 * License version 2, as published by the Free Software Foundation, and
23 * may be copied, distributed, and modified under those terms.
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
32 #include <linux/module.h>
33 #include <linux/kernel.h>
35 #include <linux/oom.h>
36 #include <linux/sched.h>
37 #include <linux/profile.h>
38 #include <linux/notifier.h>
40 static uint32_t lowmem_debug_level
= 2;
41 static int lowmem_adj
[6] = {
47 static int lowmem_adj_size
= 4;
48 static size_t lowmem_minfree
[6] = {
54 static int lowmem_minfree_size
= 4;
56 static struct task_struct
*lowmem_deathpending
;
58 #define lowmem_print(level, x...) \
60 if (lowmem_debug_level >= (level)) \
65 task_notify_func(struct notifier_block
*self
, unsigned long val
, void *data
);
67 static struct notifier_block task_nb
= {
68 .notifier_call
= task_notify_func
,
72 task_notify_func(struct notifier_block
*self
, unsigned long val
, void *data
)
74 struct task_struct
*task
= data
;
75 if (task
== lowmem_deathpending
) {
76 lowmem_deathpending
= NULL
;
77 task_handoff_unregister(&task_nb
);
82 static int lowmem_shrink(struct shrinker
*s
, struct shrink_control
*sc
)
84 struct task_struct
*p
;
85 struct task_struct
*selected
= NULL
;
89 int min_adj
= OOM_ADJUST_MAX
+ 1;
90 int selected_tasksize
= 0;
92 int array_size
= ARRAY_SIZE(lowmem_adj
);
93 int other_free
= global_page_state(NR_FREE_PAGES
);
94 int other_file
= global_page_state(NR_FILE_PAGES
) -
95 global_page_state(NR_SHMEM
);
98 * If we already have a death outstanding, then
99 * bail out right away; indicating to vmscan
100 * that we have nothing further to offer on
103 * Note: Currently you need CONFIG_PROFILING
104 * for this to work correctly.
106 if (lowmem_deathpending
)
109 if (lowmem_adj_size
< array_size
)
110 array_size
= lowmem_adj_size
;
111 if (lowmem_minfree_size
< array_size
)
112 array_size
= lowmem_minfree_size
;
113 for (i
= 0; i
< array_size
; i
++) {
114 if (other_free
< lowmem_minfree
[i
] &&
115 other_file
< lowmem_minfree
[i
]) {
116 min_adj
= lowmem_adj
[i
];
120 if (sc
->nr_to_scan
> 0)
121 lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d\n",
122 sc
->nr_to_scan
, sc
->gfp_mask
, other_free
,
123 other_file
, min_adj
);
124 rem
= global_page_state(NR_ACTIVE_ANON
) +
125 global_page_state(NR_ACTIVE_FILE
) +
126 global_page_state(NR_INACTIVE_ANON
) +
127 global_page_state(NR_INACTIVE_FILE
);
128 if (sc
->nr_to_scan
<= 0 || min_adj
== OOM_ADJUST_MAX
+ 1) {
129 lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
130 sc
->nr_to_scan
, sc
->gfp_mask
, rem
);
133 selected_oom_adj
= min_adj
;
135 read_lock(&tasklist_lock
);
136 for_each_process(p
) {
137 struct mm_struct
*mm
;
138 struct signal_struct
*sig
;
148 oom_adj
= sig
->oom_adj
;
149 if (oom_adj
< min_adj
) {
153 tasksize
= get_mm_rss(mm
);
158 if (oom_adj
< selected_oom_adj
)
160 if (oom_adj
== selected_oom_adj
&&
161 tasksize
<= selected_tasksize
)
165 selected_tasksize
= tasksize
;
166 selected_oom_adj
= oom_adj
;
167 lowmem_print(2, "select %d (%s), adj %d, size %d, to kill\n",
168 p
->pid
, p
->comm
, oom_adj
, tasksize
);
171 lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
172 selected
->pid
, selected
->comm
,
173 selected_oom_adj
, selected_tasksize
);
175 * If CONFIG_PROFILING is off, then task_handoff_register()
176 * is a nop. In that case we don't want to stall the killer
177 * by setting lowmem_deathpending.
179 #ifdef CONFIG_PROFILING
180 lowmem_deathpending
= selected
;
181 task_handoff_register(&task_nb
);
183 force_sig(SIGKILL
, selected
);
184 rem
-= selected_tasksize
;
186 lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
187 sc
->nr_to_scan
, sc
->gfp_mask
, rem
);
188 read_unlock(&tasklist_lock
);
192 static struct shrinker lowmem_shrinker
= {
193 .shrink
= lowmem_shrink
,
194 .seeks
= DEFAULT_SEEKS
* 16
197 static int __init
lowmem_init(void)
199 register_shrinker(&lowmem_shrinker
);
203 static void __exit
lowmem_exit(void)
205 unregister_shrinker(&lowmem_shrinker
);
208 module_param_named(cost
, lowmem_shrinker
.seeks
, int, S_IRUGO
| S_IWUSR
);
209 module_param_array_named(adj
, lowmem_adj
, int, &lowmem_adj_size
,
211 module_param_array_named(minfree
, lowmem_minfree
, uint
, &lowmem_minfree_size
,
213 module_param_named(debug_level
, lowmem_debug_level
, uint
, S_IRUGO
| S_IWUSR
);
215 module_init(lowmem_init
);
216 module_exit(lowmem_exit
);
218 MODULE_LICENSE("GPL");