blob: 733b7845d1eaa18e9a19e6d8ffa7cd6a5d04ed13 [file] [log] [blame]
Todd Poynor3948f802013-07-09 19:35:14 -07001/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "lowmemorykiller"
18
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070019#include <arpa/inet.h>
Todd Poynor3948f802013-07-09 19:35:14 -070020#include <errno.h>
21#include <signal.h>
Todd Poynor3948f802013-07-09 19:35:14 -070022#include <stdlib.h>
23#include <string.h>
24#include <time.h>
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070025#include <sys/cdefs.h>
Todd Poynor3948f802013-07-09 19:35:14 -070026#include <sys/epoll.h>
27#include <sys/eventfd.h>
Colin Crossb28ff912014-07-11 17:15:44 -070028#include <sys/mman.h>
Todd Poynor3948f802013-07-09 19:35:14 -070029#include <sys/socket.h>
30#include <sys/types.h>
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070031#include <unistd.h>
32
Todd Poynor3948f802013-07-09 19:35:14 -070033#include <cutils/sockets.h>
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070034#include <log/log.h>
Colin Crossfef95222014-06-11 14:53:41 -070035#include <processgroup/processgroup.h>
Mark Salyzyne6ed68b2014-04-30 13:36:35 -070036
37#ifndef __unused
38#define __unused __attribute__((__unused__))
39#endif
Todd Poynor3948f802013-07-09 19:35:14 -070040
41#define MEMCG_SYSFS_PATH "/dev/memcg/"
42#define MEMPRESSURE_WATCH_LEVEL "medium"
43#define ZONEINFO_PATH "/proc/zoneinfo"
44#define LINE_MAX 128
45
46#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
47#define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"
48
49#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
50
51enum lmk_cmd {
52 LMK_TARGET,
53 LMK_PROCPRIO,
54 LMK_PROCREMOVE,
55};
56
57#define MAX_TARGETS 6
58/*
59 * longest is LMK_TARGET followed by MAX_TARGETS each minfree and minkillprio
60 * values
61 */
62#define CTRL_PACKET_MAX (sizeof(int) * (MAX_TARGETS * 2 + 1))
63
64/* default to old in-kernel interface if no memory pressure events */
65static int use_inkernel_interface = 1;
66
67/* memory pressure level medium event */
68static int mpevfd;
69
70/* control socket listen and data */
71static int ctrl_lfd;
72static int ctrl_dfd = -1;
73static int ctrl_dfd_reopened; /* did we reopen ctrl conn on this loop? */
74
75/* 1 memory pressure level, 1 ctrl listen socket, 1 ctrl data socket */
76#define MAX_EPOLL_EVENTS 3
77static int epollfd;
78static int maxevents;
79
80#define OOM_DISABLE (-17)
81/* inclusive */
82#define OOM_ADJUST_MIN (-16)
83#define OOM_ADJUST_MAX 15
84
Todd Poynor16b60992013-09-16 19:26:47 -070085/* kernel OOM score values */
86#define OOM_SCORE_ADJ_MIN (-1000)
87#define OOM_SCORE_ADJ_MAX 1000
88
Todd Poynor3948f802013-07-09 19:35:14 -070089static int lowmem_adj[MAX_TARGETS];
90static int lowmem_minfree[MAX_TARGETS];
91static int lowmem_targets_size;
92
93struct sysmeminfo {
94 int nr_free_pages;
95 int nr_file_pages;
96 int nr_shmem;
97 int totalreserve_pages;
98};
99
100struct adjslot_list {
101 struct adjslot_list *next;
102 struct adjslot_list *prev;
103};
104
105struct proc {
106 struct adjslot_list asl;
107 int pid;
Colin Crossfbb78c62014-06-13 14:52:43 -0700108 uid_t uid;
Todd Poynor3948f802013-07-09 19:35:14 -0700109 int oomadj;
110 struct proc *pidhash_next;
111};
112
113#define PIDHASH_SZ 1024
114static struct proc *pidhash[PIDHASH_SZ];
115#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
116
Chih-Hung Hsieh2b82e912016-05-18 15:37:20 -0700117#define ADJTOSLOT(adj) ((adj) + -OOM_ADJUST_MIN)
Todd Poynor3948f802013-07-09 19:35:14 -0700118static struct adjslot_list procadjslot_list[ADJTOSLOT(OOM_ADJUST_MAX) + 1];
119
120/*
121 * Wait 1-2 seconds for the death report of a killed process prior to
122 * considering killing more processes.
123 */
124#define KILL_TIMEOUT 2
125/* Time of last process kill we initiated, stop me before I kill again */
126static time_t kill_lasttime;
127
128/* PAGE_SIZE / 1024 */
129static long page_k;
130
Colin Crossce85d952014-07-11 17:53:27 -0700131static ssize_t read_all(int fd, char *buf, size_t max_len)
132{
133 ssize_t ret = 0;
134
135 while (max_len > 0) {
136 ssize_t r = read(fd, buf, max_len);
137 if (r == 0) {
138 break;
139 }
140 if (r == -1) {
141 return -1;
142 }
143 ret += r;
144 buf += r;
145 max_len -= r;
146 }
147
148 return ret;
149}
150
Todd Poynor16b60992013-09-16 19:26:47 -0700151static int lowmem_oom_adj_to_oom_score_adj(int oom_adj)
152{
153 if (oom_adj == OOM_ADJUST_MAX)
154 return OOM_SCORE_ADJ_MAX;
155 else
156 return (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
157}
158
Todd Poynor3948f802013-07-09 19:35:14 -0700159static struct proc *pid_lookup(int pid) {
160 struct proc *procp;
161
162 for (procp = pidhash[pid_hashfn(pid)]; procp && procp->pid != pid;
163 procp = procp->pidhash_next)
164 ;
165
166 return procp;
167}
168
169static void adjslot_insert(struct adjslot_list *head, struct adjslot_list *new)
170{
171 struct adjslot_list *next = head->next;
172 new->prev = head;
173 new->next = next;
174 next->prev = new;
175 head->next = new;
176}
177
178static void adjslot_remove(struct adjslot_list *old)
179{
180 struct adjslot_list *prev = old->prev;
181 struct adjslot_list *next = old->next;
182 next->prev = prev;
183 prev->next = next;
184}
185
186static struct adjslot_list *adjslot_tail(struct adjslot_list *head) {
187 struct adjslot_list *asl = head->prev;
188
189 return asl == head ? NULL : asl;
190}
191
192static void proc_slot(struct proc *procp) {
193 int adjslot = ADJTOSLOT(procp->oomadj);
194
195 adjslot_insert(&procadjslot_list[adjslot], &procp->asl);
196}
197
198static void proc_unslot(struct proc *procp) {
199 adjslot_remove(&procp->asl);
200}
201
202static void proc_insert(struct proc *procp) {
203 int hval = pid_hashfn(procp->pid);
204
205 procp->pidhash_next = pidhash[hval];
206 pidhash[hval] = procp;
207 proc_slot(procp);
208}
209
210static int pid_remove(int pid) {
211 int hval = pid_hashfn(pid);
212 struct proc *procp;
213 struct proc *prevp;
214
215 for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
216 procp = procp->pidhash_next)
217 prevp = procp;
218
219 if (!procp)
220 return -1;
221
222 if (!prevp)
223 pidhash[hval] = procp->pidhash_next;
224 else
225 prevp->pidhash_next = procp->pidhash_next;
226
227 proc_unslot(procp);
228 free(procp);
229 return 0;
230}
231
232static void writefilestring(char *path, char *s) {
Nick Kralevichc68c8862015-12-18 20:52:37 -0800233 int fd = open(path, O_WRONLY | O_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -0700234 int len = strlen(s);
235 int ret;
236
237 if (fd < 0) {
238 ALOGE("Error opening %s; errno=%d", path, errno);
239 return;
240 }
241
242 ret = write(fd, s, len);
243 if (ret < 0) {
244 ALOGE("Error writing %s; errno=%d", path, errno);
245 } else if (ret < len) {
246 ALOGE("Short write on %s; length=%d", path, ret);
247 }
248
249 close(fd);
250}
251
Colin Crossfbb78c62014-06-13 14:52:43 -0700252static void cmd_procprio(int pid, int uid, int oomadj) {
Todd Poynor3948f802013-07-09 19:35:14 -0700253 struct proc *procp;
254 char path[80];
255 char val[20];
256
257 if (oomadj < OOM_DISABLE || oomadj > OOM_ADJUST_MAX) {
258 ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
259 return;
260 }
261
Todd Poynor16b60992013-09-16 19:26:47 -0700262 snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
263 snprintf(val, sizeof(val), "%d", lowmem_oom_adj_to_oom_score_adj(oomadj));
Todd Poynor3948f802013-07-09 19:35:14 -0700264 writefilestring(path, val);
265
266 if (use_inkernel_interface)
267 return;
268
269 procp = pid_lookup(pid);
270 if (!procp) {
271 procp = malloc(sizeof(struct proc));
272 if (!procp) {
273 // Oh, the irony. May need to rebuild our state.
274 return;
275 }
276
277 procp->pid = pid;
Colin Crossfbb78c62014-06-13 14:52:43 -0700278 procp->uid = uid;
Todd Poynor3948f802013-07-09 19:35:14 -0700279 procp->oomadj = oomadj;
280 proc_insert(procp);
281 } else {
282 proc_unslot(procp);
283 procp->oomadj = oomadj;
284 proc_slot(procp);
285 }
286}
287
288static void cmd_procremove(int pid) {
Todd Poynor3948f802013-07-09 19:35:14 -0700289 if (use_inkernel_interface)
290 return;
291
292 pid_remove(pid);
293 kill_lasttime = 0;
294}
295
296static void cmd_target(int ntargets, int *params) {
297 int i;
298
299 if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
300 return;
301
302 for (i = 0; i < ntargets; i++) {
303 lowmem_minfree[i] = ntohl(*params++);
304 lowmem_adj[i] = ntohl(*params++);
305 }
306
307 lowmem_targets_size = ntargets;
308
309 if (use_inkernel_interface) {
310 char minfreestr[128];
311 char killpriostr[128];
312
313 minfreestr[0] = '\0';
314 killpriostr[0] = '\0';
315
316 for (i = 0; i < lowmem_targets_size; i++) {
317 char val[40];
318
319 if (i) {
320 strlcat(minfreestr, ",", sizeof(minfreestr));
321 strlcat(killpriostr, ",", sizeof(killpriostr));
322 }
323
324 snprintf(val, sizeof(val), "%d", lowmem_minfree[i]);
325 strlcat(minfreestr, val, sizeof(minfreestr));
326 snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
327 strlcat(killpriostr, val, sizeof(killpriostr));
328 }
329
330 writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
331 writefilestring(INKERNEL_ADJ_PATH, killpriostr);
332 }
333}
334
335static void ctrl_data_close(void) {
336 ALOGI("Closing Activity Manager data connection");
337 close(ctrl_dfd);
338 ctrl_dfd = -1;
339 maxevents--;
340}
341
342static int ctrl_data_read(char *buf, size_t bufsz) {
343 int ret = 0;
344
345 ret = read(ctrl_dfd, buf, bufsz);
346
347 if (ret == -1) {
348 ALOGE("control data socket read failed; errno=%d", errno);
349 } else if (ret == 0) {
350 ALOGE("Got EOF on control data socket");
351 ret = -1;
352 }
353
354 return ret;
355}
356
357static void ctrl_command_handler(void) {
358 int ibuf[CTRL_PACKET_MAX / sizeof(int)];
359 int len;
360 int cmd = -1;
361 int nargs;
362 int targets;
363
364 len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
365 if (len <= 0)
366 return;
367
368 nargs = len / sizeof(int) - 1;
369 if (nargs < 0)
370 goto wronglen;
371
372 cmd = ntohl(ibuf[0]);
373
374 switch(cmd) {
375 case LMK_TARGET:
376 targets = nargs / 2;
377 if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
378 goto wronglen;
379 cmd_target(targets, &ibuf[1]);
380 break;
381 case LMK_PROCPRIO:
Colin Crossfbb78c62014-06-13 14:52:43 -0700382 if (nargs != 3)
Todd Poynor3948f802013-07-09 19:35:14 -0700383 goto wronglen;
Colin Crossfbb78c62014-06-13 14:52:43 -0700384 cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
Todd Poynor3948f802013-07-09 19:35:14 -0700385 break;
386 case LMK_PROCREMOVE:
387 if (nargs != 1)
388 goto wronglen;
389 cmd_procremove(ntohl(ibuf[1]));
390 break;
391 default:
392 ALOGE("Received unknown command code %d", cmd);
393 return;
394 }
395
396 return;
397
398wronglen:
399 ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
400}
401
402static void ctrl_data_handler(uint32_t events) {
403 if (events & EPOLLHUP) {
404 ALOGI("ActivityManager disconnected");
405 if (!ctrl_dfd_reopened)
406 ctrl_data_close();
407 } else if (events & EPOLLIN) {
408 ctrl_command_handler();
409 }
410}
411
Mark Salyzyne6ed68b2014-04-30 13:36:35 -0700412static void ctrl_connect_handler(uint32_t events __unused) {
Todd Poynor3948f802013-07-09 19:35:14 -0700413 struct epoll_event epev;
414
415 if (ctrl_dfd >= 0) {
416 ctrl_data_close();
417 ctrl_dfd_reopened = 1;
418 }
419
Elliott Hughes3dcfa3f2016-08-23 12:50:00 -0700420 ctrl_dfd = accept(ctrl_lfd, NULL, NULL);
Todd Poynor3948f802013-07-09 19:35:14 -0700421
422 if (ctrl_dfd < 0) {
423 ALOGE("lmkd control socket accept failed; errno=%d", errno);
424 return;
425 }
426
427 ALOGI("ActivityManager connected");
428 maxevents++;
429 epev.events = EPOLLIN;
430 epev.data.ptr = (void *)ctrl_data_handler;
431 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_dfd, &epev) == -1) {
432 ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
433 ctrl_data_close();
434 return;
435 }
436}
437
438static int zoneinfo_parse_protection(char *cp) {
439 int max = 0;
440 int zoneval;
Colin Crossce85d952014-07-11 17:53:27 -0700441 char *save_ptr;
Todd Poynor3948f802013-07-09 19:35:14 -0700442
Colin Crossce85d952014-07-11 17:53:27 -0700443 for (cp = strtok_r(cp, "(), ", &save_ptr); cp; cp = strtok_r(NULL, "), ", &save_ptr)) {
Todd Poynor3948f802013-07-09 19:35:14 -0700444 zoneval = strtol(cp, &cp, 0);
Todd Poynor3948f802013-07-09 19:35:14 -0700445 if (zoneval > max)
446 max = zoneval;
Colin Crossce85d952014-07-11 17:53:27 -0700447 }
Todd Poynor3948f802013-07-09 19:35:14 -0700448
449 return max;
450}
451
452static void zoneinfo_parse_line(char *line, struct sysmeminfo *mip) {
453 char *cp = line;
454 char *ap;
Colin Crossce85d952014-07-11 17:53:27 -0700455 char *save_ptr;
Todd Poynor3948f802013-07-09 19:35:14 -0700456
Colin Crossce85d952014-07-11 17:53:27 -0700457 cp = strtok_r(line, " ", &save_ptr);
Todd Poynor3948f802013-07-09 19:35:14 -0700458 if (!cp)
459 return;
460
Colin Crossce85d952014-07-11 17:53:27 -0700461 ap = strtok_r(NULL, " ", &save_ptr);
Todd Poynor3948f802013-07-09 19:35:14 -0700462 if (!ap)
463 return;
464
465 if (!strcmp(cp, "nr_free_pages"))
466 mip->nr_free_pages += strtol(ap, NULL, 0);
467 else if (!strcmp(cp, "nr_file_pages"))
468 mip->nr_file_pages += strtol(ap, NULL, 0);
469 else if (!strcmp(cp, "nr_shmem"))
470 mip->nr_shmem += strtol(ap, NULL, 0);
471 else if (!strcmp(cp, "high"))
472 mip->totalreserve_pages += strtol(ap, NULL, 0);
473 else if (!strcmp(cp, "protection:"))
474 mip->totalreserve_pages += zoneinfo_parse_protection(ap);
475}
476
477static int zoneinfo_parse(struct sysmeminfo *mip) {
Colin Crossce85d952014-07-11 17:53:27 -0700478 int fd;
479 ssize_t size;
480 char buf[PAGE_SIZE];
481 char *save_ptr;
482 char *line;
Todd Poynor3948f802013-07-09 19:35:14 -0700483
484 memset(mip, 0, sizeof(struct sysmeminfo));
Colin Crossce85d952014-07-11 17:53:27 -0700485
Nick Kralevichc68c8862015-12-18 20:52:37 -0800486 fd = open(ZONEINFO_PATH, O_RDONLY | O_CLOEXEC);
Colin Crossce85d952014-07-11 17:53:27 -0700487 if (fd == -1) {
Todd Poynor3948f802013-07-09 19:35:14 -0700488 ALOGE("%s open: errno=%d", ZONEINFO_PATH, errno);
489 return -1;
490 }
491
Colin Crossce85d952014-07-11 17:53:27 -0700492 size = read_all(fd, buf, sizeof(buf) - 1);
493 if (size < 0) {
494 ALOGE("%s read: errno=%d", ZONEINFO_PATH, errno);
495 close(fd);
496 return -1;
497 }
498 ALOG_ASSERT((size_t)size < sizeof(buf) - 1, "/proc/zoneinfo too large");
499 buf[size] = 0;
500
501 for (line = strtok_r(buf, "\n", &save_ptr); line; line = strtok_r(NULL, "\n", &save_ptr))
Todd Poynor3948f802013-07-09 19:35:14 -0700502 zoneinfo_parse_line(line, mip);
503
Colin Crossce85d952014-07-11 17:53:27 -0700504 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -0700505 return 0;
506}
507
508static int proc_get_size(int pid) {
509 char path[PATH_MAX];
510 char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -0700511 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -0700512 int rss = 0;
513 int total;
Colin Crossce85d952014-07-11 17:53:27 -0700514 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -0700515
516 snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
Nick Kralevichc68c8862015-12-18 20:52:37 -0800517 fd = open(path, O_RDONLY | O_CLOEXEC);
Colin Crossce85d952014-07-11 17:53:27 -0700518 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -0700519 return -1;
Colin Crossce85d952014-07-11 17:53:27 -0700520
521 ret = read_all(fd, line, sizeof(line) - 1);
522 if (ret < 0) {
523 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -0700524 return -1;
525 }
526
527 sscanf(line, "%d %d ", &total, &rss);
Colin Crossce85d952014-07-11 17:53:27 -0700528 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -0700529 return rss;
530}
531
532static char *proc_get_name(int pid) {
533 char path[PATH_MAX];
534 static char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -0700535 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -0700536 char *cp;
Colin Crossce85d952014-07-11 17:53:27 -0700537 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -0700538
539 snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
Nick Kralevichc68c8862015-12-18 20:52:37 -0800540 fd = open(path, O_RDONLY | O_CLOEXEC);
Colin Crossce85d952014-07-11 17:53:27 -0700541 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -0700542 return NULL;
Colin Crossce85d952014-07-11 17:53:27 -0700543 ret = read_all(fd, line, sizeof(line) - 1);
544 close(fd);
545 if (ret < 0) {
Todd Poynor3948f802013-07-09 19:35:14 -0700546 return NULL;
547 }
548
549 cp = strchr(line, ' ');
550 if (cp)
551 *cp = '\0';
552
553 return line;
554}
555
556static struct proc *proc_adj_lru(int oomadj) {
557 return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
558}
559
Colin Cross16b09462014-07-14 12:39:56 -0700560/* Kill one process specified by procp. Returns the size of the process killed */
561static int kill_one_process(struct proc *procp, int other_free, int other_file,
562 int minfree, int min_score_adj, bool first)
563{
564 int pid = procp->pid;
565 uid_t uid = procp->uid;
566 char *taskname;
567 int tasksize;
568 int r;
569
570 taskname = proc_get_name(pid);
571 if (!taskname) {
572 pid_remove(pid);
573 return -1;
574 }
575
576 tasksize = proc_get_size(pid);
577 if (tasksize <= 0) {
578 pid_remove(pid);
579 return -1;
580 }
581
582 ALOGI("Killing '%s' (%d), uid %d, adj %d\n"
583 " to free %ldkB because cache %s%ldkB is below limit %ldkB for oom_adj %d\n"
584 " Free memory is %s%ldkB %s reserved",
585 taskname, pid, uid, procp->oomadj, tasksize * page_k,
586 first ? "" : "~", other_file * page_k, minfree * page_k, min_score_adj,
587 first ? "" : "~", other_free * page_k, other_free >= 0 ? "above" : "below");
588 r = kill(pid, SIGKILL);
589 killProcessGroup(uid, pid, SIGKILL);
590 pid_remove(pid);
591
592 if (r) {
593 ALOGE("kill(%d): errno=%d", procp->pid, errno);
594 return -1;
595 } else {
596 return tasksize;
597 }
598}
599
600/*
601 * Find a process to kill based on the current (possibly estimated) free memory
602 * and cached memory sizes. Returns the size of the killed processes.
603 */
604static int find_and_kill_process(int other_free, int other_file, bool first)
605{
606 int i;
Colin Cross16b09462014-07-14 12:39:56 -0700607 int min_score_adj = OOM_ADJUST_MAX + 1;
608 int minfree = 0;
609 int killed_size = 0;
610
611 for (i = 0; i < lowmem_targets_size; i++) {
612 minfree = lowmem_minfree[i];
613 if (other_free < minfree && other_file < minfree) {
614 min_score_adj = lowmem_adj[i];
615 break;
616 }
617 }
618
619 if (min_score_adj == OOM_ADJUST_MAX + 1)
620 return 0;
621
622 for (i = OOM_ADJUST_MAX; i >= min_score_adj; i--) {
623 struct proc *procp;
624
625retry:
626 procp = proc_adj_lru(i);
627
628 if (procp) {
629 killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
630 if (killed_size < 0) {
631 goto retry;
632 } else {
633 return killed_size;
634 }
635 }
636 }
637
638 return 0;
639}
640
Mark Salyzyne6ed68b2014-04-30 13:36:35 -0700641static void mp_event(uint32_t events __unused) {
Todd Poynor3948f802013-07-09 19:35:14 -0700642 int ret;
643 unsigned long long evcount;
644 struct sysmeminfo mi;
645 int other_free;
646 int other_file;
Colin Cross16b09462014-07-14 12:39:56 -0700647 int killed_size;
648 bool first = true;
Todd Poynor3948f802013-07-09 19:35:14 -0700649
650 ret = read(mpevfd, &evcount, sizeof(evcount));
651 if (ret < 0)
652 ALOGE("Error reading memory pressure event fd; errno=%d",
653 errno);
654
655 if (time(NULL) - kill_lasttime < KILL_TIMEOUT)
656 return;
657
Colin Crossf8857cc2014-07-11 17:16:56 -0700658 while (zoneinfo_parse(&mi) < 0) {
659 // Failed to read /proc/zoneinfo, assume ENOMEM and kill something
660 find_and_kill_process(0, 0, true);
661 }
Todd Poynor3948f802013-07-09 19:35:14 -0700662
663 other_free = mi.nr_free_pages - mi.totalreserve_pages;
664 other_file = mi.nr_file_pages - mi.nr_shmem;
665
Colin Cross16b09462014-07-14 12:39:56 -0700666 do {
667 killed_size = find_and_kill_process(other_free, other_file, first);
668 if (killed_size > 0) {
669 first = false;
670 other_free += killed_size;
671 other_file += killed_size;
Todd Poynor3948f802013-07-09 19:35:14 -0700672 }
Colin Cross16b09462014-07-14 12:39:56 -0700673 } while (killed_size > 0);
Todd Poynor3948f802013-07-09 19:35:14 -0700674}
675
676static int init_mp(char *levelstr, void *event_handler)
677{
678 int mpfd;
679 int evfd;
680 int evctlfd;
681 char buf[256];
682 struct epoll_event epev;
683 int ret;
684
Nick Kralevichc68c8862015-12-18 20:52:37 -0800685 mpfd = open(MEMCG_SYSFS_PATH "memory.pressure_level", O_RDONLY | O_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -0700686 if (mpfd < 0) {
687 ALOGI("No kernel memory.pressure_level support (errno=%d)", errno);
688 goto err_open_mpfd;
689 }
690
Nick Kralevichc68c8862015-12-18 20:52:37 -0800691 evctlfd = open(MEMCG_SYSFS_PATH "cgroup.event_control", O_WRONLY | O_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -0700692 if (evctlfd < 0) {
693 ALOGI("No kernel memory cgroup event control (errno=%d)", errno);
694 goto err_open_evctlfd;
695 }
696
Nick Kralevichc68c8862015-12-18 20:52:37 -0800697 evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
Todd Poynor3948f802013-07-09 19:35:14 -0700698 if (evfd < 0) {
699 ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
700 goto err_eventfd;
701 }
702
703 ret = snprintf(buf, sizeof(buf), "%d %d %s", evfd, mpfd, levelstr);
704 if (ret >= (ssize_t)sizeof(buf)) {
705 ALOGE("cgroup.event_control line overflow for level %s", levelstr);
706 goto err;
707 }
708
709 ret = write(evctlfd, buf, strlen(buf) + 1);
710 if (ret == -1) {
711 ALOGE("cgroup.event_control write failed for level %s; errno=%d",
712 levelstr, errno);
713 goto err;
714 }
715
716 epev.events = EPOLLIN;
717 epev.data.ptr = event_handler;
718 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, evfd, &epev);
719 if (ret == -1) {
720 ALOGE("epoll_ctl for level %s failed; errno=%d", levelstr, errno);
721 goto err;
722 }
723 maxevents++;
724 mpevfd = evfd;
725 return 0;
726
727err:
728 close(evfd);
729err_eventfd:
730 close(evctlfd);
731err_open_evctlfd:
732 close(mpfd);
733err_open_mpfd:
734 return -1;
735}
736
737static int init(void) {
738 struct epoll_event epev;
739 int i;
740 int ret;
741
742 page_k = sysconf(_SC_PAGESIZE);
743 if (page_k == -1)
744 page_k = PAGE_SIZE;
745 page_k /= 1024;
746
747 epollfd = epoll_create(MAX_EPOLL_EVENTS);
748 if (epollfd == -1) {
749 ALOGE("epoll_create failed (errno=%d)", errno);
750 return -1;
751 }
752
753 ctrl_lfd = android_get_control_socket("lmkd");
754 if (ctrl_lfd < 0) {
755 ALOGE("get lmkd control socket failed");
756 return -1;
757 }
758
759 ret = listen(ctrl_lfd, 1);
760 if (ret < 0) {
761 ALOGE("lmkd control socket listen failed (errno=%d)", errno);
762 return -1;
763 }
764
765 epev.events = EPOLLIN;
766 epev.data.ptr = (void *)ctrl_connect_handler;
767 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
768 ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
769 return -1;
770 }
771 maxevents++;
772
773 use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);
774
775 if (use_inkernel_interface) {
776 ALOGI("Using in-kernel low memory killer interface");
777 } else {
778 ret = init_mp(MEMPRESSURE_WATCH_LEVEL, (void *)&mp_event);
779 if (ret)
780 ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
781 }
782
783 for (i = 0; i <= ADJTOSLOT(OOM_ADJUST_MAX); i++) {
784 procadjslot_list[i].next = &procadjslot_list[i];
785 procadjslot_list[i].prev = &procadjslot_list[i];
786 }
787
788 return 0;
789}
790
791static void mainloop(void) {
792 while (1) {
793 struct epoll_event events[maxevents];
794 int nevents;
795 int i;
796
797 ctrl_dfd_reopened = 0;
798 nevents = epoll_wait(epollfd, events, maxevents, -1);
799
800 if (nevents == -1) {
801 if (errno == EINTR)
802 continue;
803 ALOGE("epoll_wait failed (errno=%d)", errno);
804 continue;
805 }
806
807 for (i = 0; i < nevents; ++i) {
808 if (events[i].events & EPOLLERR)
809 ALOGD("EPOLLERR on event #%d", i);
810 if (events[i].data.ptr)
811 (*(void (*)(uint32_t))events[i].data.ptr)(events[i].events);
812 }
813 }
814}
815
Mark Salyzyne6ed68b2014-04-30 13:36:35 -0700816int main(int argc __unused, char **argv __unused) {
Colin Cross1a0d9be2014-07-14 14:31:15 -0700817 struct sched_param param = {
818 .sched_priority = 1,
819 };
820
Colin Crossb28ff912014-07-11 17:15:44 -0700821 mlockall(MCL_FUTURE);
Colin Cross1a0d9be2014-07-14 14:31:15 -0700822 sched_setscheduler(0, SCHED_FIFO, &param);
Todd Poynor3948f802013-07-09 19:35:14 -0700823 if (!init())
824 mainloop();
825
826 ALOGI("exiting");
827 return 0;
828}