blob: cb9598e7572e127b4f0220de5f17ac134d7f39f1 [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
Chong Zhang0a4acdf2015-10-14 16:19:53 -070080/* OOM score values used by both kernel and framework */
Todd Poynor16b60992013-09-16 19:26:47 -070081#define OOM_SCORE_ADJ_MIN (-1000)
82#define OOM_SCORE_ADJ_MAX 1000
83
Todd Poynor3948f802013-07-09 19:35:14 -070084static int lowmem_adj[MAX_TARGETS];
85static int lowmem_minfree[MAX_TARGETS];
86static int lowmem_targets_size;
87
88struct sysmeminfo {
89 int nr_free_pages;
90 int nr_file_pages;
91 int nr_shmem;
92 int totalreserve_pages;
93};
94
95struct adjslot_list {
96 struct adjslot_list *next;
97 struct adjslot_list *prev;
98};
99
100struct proc {
101 struct adjslot_list asl;
102 int pid;
Colin Crossfbb78c62014-06-13 14:52:43 -0700103 uid_t uid;
Todd Poynor3948f802013-07-09 19:35:14 -0700104 int oomadj;
105 struct proc *pidhash_next;
106};
107
108#define PIDHASH_SZ 1024
109static struct proc *pidhash[PIDHASH_SZ];
110#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
111
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700112#define ADJTOSLOT(adj) (adj + -OOM_SCORE_ADJ_MIN)
113static struct adjslot_list procadjslot_list[ADJTOSLOT(OOM_SCORE_ADJ_MAX) + 1];
Todd Poynor3948f802013-07-09 19:35:14 -0700114
115/*
116 * Wait 1-2 seconds for the death report of a killed process prior to
117 * considering killing more processes.
118 */
119#define KILL_TIMEOUT 2
120/* Time of last process kill we initiated, stop me before I kill again */
121static time_t kill_lasttime;
122
123/* PAGE_SIZE / 1024 */
124static long page_k;
125
Colin Crossce85d952014-07-11 17:53:27 -0700126static ssize_t read_all(int fd, char *buf, size_t max_len)
127{
128 ssize_t ret = 0;
129
130 while (max_len > 0) {
131 ssize_t r = read(fd, buf, max_len);
132 if (r == 0) {
133 break;
134 }
135 if (r == -1) {
136 return -1;
137 }
138 ret += r;
139 buf += r;
140 max_len -= r;
141 }
142
143 return ret;
144}
145
Todd Poynor3948f802013-07-09 19:35:14 -0700146static struct proc *pid_lookup(int pid) {
147 struct proc *procp;
148
149 for (procp = pidhash[pid_hashfn(pid)]; procp && procp->pid != pid;
150 procp = procp->pidhash_next)
151 ;
152
153 return procp;
154}
155
156static void adjslot_insert(struct adjslot_list *head, struct adjslot_list *new)
157{
158 struct adjslot_list *next = head->next;
159 new->prev = head;
160 new->next = next;
161 next->prev = new;
162 head->next = new;
163}
164
165static void adjslot_remove(struct adjslot_list *old)
166{
167 struct adjslot_list *prev = old->prev;
168 struct adjslot_list *next = old->next;
169 next->prev = prev;
170 prev->next = next;
171}
172
173static struct adjslot_list *adjslot_tail(struct adjslot_list *head) {
174 struct adjslot_list *asl = head->prev;
175
176 return asl == head ? NULL : asl;
177}
178
179static void proc_slot(struct proc *procp) {
180 int adjslot = ADJTOSLOT(procp->oomadj);
181
182 adjslot_insert(&procadjslot_list[adjslot], &procp->asl);
183}
184
185static void proc_unslot(struct proc *procp) {
186 adjslot_remove(&procp->asl);
187}
188
189static void proc_insert(struct proc *procp) {
190 int hval = pid_hashfn(procp->pid);
191
192 procp->pidhash_next = pidhash[hval];
193 pidhash[hval] = procp;
194 proc_slot(procp);
195}
196
197static int pid_remove(int pid) {
198 int hval = pid_hashfn(pid);
199 struct proc *procp;
200 struct proc *prevp;
201
202 for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
203 procp = procp->pidhash_next)
204 prevp = procp;
205
206 if (!procp)
207 return -1;
208
209 if (!prevp)
210 pidhash[hval] = procp->pidhash_next;
211 else
212 prevp->pidhash_next = procp->pidhash_next;
213
214 proc_unslot(procp);
215 free(procp);
216 return 0;
217}
218
219static void writefilestring(char *path, char *s) {
220 int fd = open(path, O_WRONLY);
221 int len = strlen(s);
222 int ret;
223
224 if (fd < 0) {
225 ALOGE("Error opening %s; errno=%d", path, errno);
226 return;
227 }
228
229 ret = write(fd, s, len);
230 if (ret < 0) {
231 ALOGE("Error writing %s; errno=%d", path, errno);
232 } else if (ret < len) {
233 ALOGE("Short write on %s; length=%d", path, ret);
234 }
235
236 close(fd);
237}
238
Colin Crossfbb78c62014-06-13 14:52:43 -0700239static void cmd_procprio(int pid, int uid, int oomadj) {
Todd Poynor3948f802013-07-09 19:35:14 -0700240 struct proc *procp;
241 char path[80];
242 char val[20];
243
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700244 if (oomadj < OOM_SCORE_ADJ_MIN || oomadj > OOM_SCORE_ADJ_MAX) {
Todd Poynor3948f802013-07-09 19:35:14 -0700245 ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
246 return;
247 }
248
Todd Poynor16b60992013-09-16 19:26:47 -0700249 snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700250 snprintf(val, sizeof(val), "%d", oomadj);
Todd Poynor3948f802013-07-09 19:35:14 -0700251 writefilestring(path, val);
252
253 if (use_inkernel_interface)
254 return;
255
256 procp = pid_lookup(pid);
257 if (!procp) {
258 procp = malloc(sizeof(struct proc));
259 if (!procp) {
260 // Oh, the irony. May need to rebuild our state.
261 return;
262 }
263
264 procp->pid = pid;
Colin Crossfbb78c62014-06-13 14:52:43 -0700265 procp->uid = uid;
Todd Poynor3948f802013-07-09 19:35:14 -0700266 procp->oomadj = oomadj;
267 proc_insert(procp);
268 } else {
269 proc_unslot(procp);
270 procp->oomadj = oomadj;
271 proc_slot(procp);
272 }
273}
274
275static void cmd_procremove(int pid) {
Todd Poynor3948f802013-07-09 19:35:14 -0700276 if (use_inkernel_interface)
277 return;
278
279 pid_remove(pid);
280 kill_lasttime = 0;
281}
282
283static void cmd_target(int ntargets, int *params) {
284 int i;
285
286 if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
287 return;
288
289 for (i = 0; i < ntargets; i++) {
290 lowmem_minfree[i] = ntohl(*params++);
291 lowmem_adj[i] = ntohl(*params++);
292 }
293
294 lowmem_targets_size = ntargets;
295
296 if (use_inkernel_interface) {
297 char minfreestr[128];
298 char killpriostr[128];
299
300 minfreestr[0] = '\0';
301 killpriostr[0] = '\0';
302
303 for (i = 0; i < lowmem_targets_size; i++) {
304 char val[40];
305
306 if (i) {
307 strlcat(minfreestr, ",", sizeof(minfreestr));
308 strlcat(killpriostr, ",", sizeof(killpriostr));
309 }
310
311 snprintf(val, sizeof(val), "%d", lowmem_minfree[i]);
312 strlcat(minfreestr, val, sizeof(minfreestr));
313 snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
314 strlcat(killpriostr, val, sizeof(killpriostr));
315 }
316
317 writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
318 writefilestring(INKERNEL_ADJ_PATH, killpriostr);
319 }
320}
321
322static void ctrl_data_close(void) {
323 ALOGI("Closing Activity Manager data connection");
324 close(ctrl_dfd);
325 ctrl_dfd = -1;
326 maxevents--;
327}
328
329static int ctrl_data_read(char *buf, size_t bufsz) {
330 int ret = 0;
331
332 ret = read(ctrl_dfd, buf, bufsz);
333
334 if (ret == -1) {
335 ALOGE("control data socket read failed; errno=%d", errno);
336 } else if (ret == 0) {
337 ALOGE("Got EOF on control data socket");
338 ret = -1;
339 }
340
341 return ret;
342}
343
344static void ctrl_command_handler(void) {
345 int ibuf[CTRL_PACKET_MAX / sizeof(int)];
346 int len;
347 int cmd = -1;
348 int nargs;
349 int targets;
350
351 len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
352 if (len <= 0)
353 return;
354
355 nargs = len / sizeof(int) - 1;
356 if (nargs < 0)
357 goto wronglen;
358
359 cmd = ntohl(ibuf[0]);
360
361 switch(cmd) {
362 case LMK_TARGET:
363 targets = nargs / 2;
364 if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
365 goto wronglen;
366 cmd_target(targets, &ibuf[1]);
367 break;
368 case LMK_PROCPRIO:
Colin Crossfbb78c62014-06-13 14:52:43 -0700369 if (nargs != 3)
Todd Poynor3948f802013-07-09 19:35:14 -0700370 goto wronglen;
Colin Crossfbb78c62014-06-13 14:52:43 -0700371 cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
Todd Poynor3948f802013-07-09 19:35:14 -0700372 break;
373 case LMK_PROCREMOVE:
374 if (nargs != 1)
375 goto wronglen;
376 cmd_procremove(ntohl(ibuf[1]));
377 break;
378 default:
379 ALOGE("Received unknown command code %d", cmd);
380 return;
381 }
382
383 return;
384
385wronglen:
386 ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
387}
388
389static void ctrl_data_handler(uint32_t events) {
390 if (events & EPOLLHUP) {
391 ALOGI("ActivityManager disconnected");
392 if (!ctrl_dfd_reopened)
393 ctrl_data_close();
394 } else if (events & EPOLLIN) {
395 ctrl_command_handler();
396 }
397}
398
Mark Salyzyne6ed68b2014-04-30 13:36:35 -0700399static void ctrl_connect_handler(uint32_t events __unused) {
Todd Poynor3948f802013-07-09 19:35:14 -0700400 struct sockaddr addr;
401 socklen_t alen;
402 struct epoll_event epev;
403
404 if (ctrl_dfd >= 0) {
405 ctrl_data_close();
406 ctrl_dfd_reopened = 1;
407 }
408
409 alen = sizeof(addr);
410 ctrl_dfd = accept(ctrl_lfd, &addr, &alen);
411
412 if (ctrl_dfd < 0) {
413 ALOGE("lmkd control socket accept failed; errno=%d", errno);
414 return;
415 }
416
417 ALOGI("ActivityManager connected");
418 maxevents++;
419 epev.events = EPOLLIN;
420 epev.data.ptr = (void *)ctrl_data_handler;
421 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_dfd, &epev) == -1) {
422 ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
423 ctrl_data_close();
424 return;
425 }
426}
427
428static int zoneinfo_parse_protection(char *cp) {
429 int max = 0;
430 int zoneval;
Colin Crossce85d952014-07-11 17:53:27 -0700431 char *save_ptr;
Todd Poynor3948f802013-07-09 19:35:14 -0700432
Colin Crossce85d952014-07-11 17:53:27 -0700433 for (cp = strtok_r(cp, "(), ", &save_ptr); cp; cp = strtok_r(NULL, "), ", &save_ptr)) {
Todd Poynor3948f802013-07-09 19:35:14 -0700434 zoneval = strtol(cp, &cp, 0);
Todd Poynor3948f802013-07-09 19:35:14 -0700435 if (zoneval > max)
436 max = zoneval;
Colin Crossce85d952014-07-11 17:53:27 -0700437 }
Todd Poynor3948f802013-07-09 19:35:14 -0700438
439 return max;
440}
441
442static void zoneinfo_parse_line(char *line, struct sysmeminfo *mip) {
443 char *cp = line;
444 char *ap;
Colin Crossce85d952014-07-11 17:53:27 -0700445 char *save_ptr;
Todd Poynor3948f802013-07-09 19:35:14 -0700446
Colin Crossce85d952014-07-11 17:53:27 -0700447 cp = strtok_r(line, " ", &save_ptr);
Todd Poynor3948f802013-07-09 19:35:14 -0700448 if (!cp)
449 return;
450
Colin Crossce85d952014-07-11 17:53:27 -0700451 ap = strtok_r(NULL, " ", &save_ptr);
Todd Poynor3948f802013-07-09 19:35:14 -0700452 if (!ap)
453 return;
454
455 if (!strcmp(cp, "nr_free_pages"))
456 mip->nr_free_pages += strtol(ap, NULL, 0);
457 else if (!strcmp(cp, "nr_file_pages"))
458 mip->nr_file_pages += strtol(ap, NULL, 0);
459 else if (!strcmp(cp, "nr_shmem"))
460 mip->nr_shmem += strtol(ap, NULL, 0);
461 else if (!strcmp(cp, "high"))
462 mip->totalreserve_pages += strtol(ap, NULL, 0);
463 else if (!strcmp(cp, "protection:"))
464 mip->totalreserve_pages += zoneinfo_parse_protection(ap);
465}
466
467static int zoneinfo_parse(struct sysmeminfo *mip) {
Colin Crossce85d952014-07-11 17:53:27 -0700468 int fd;
469 ssize_t size;
470 char buf[PAGE_SIZE];
471 char *save_ptr;
472 char *line;
Todd Poynor3948f802013-07-09 19:35:14 -0700473
474 memset(mip, 0, sizeof(struct sysmeminfo));
Colin Crossce85d952014-07-11 17:53:27 -0700475
476 fd = open(ZONEINFO_PATH, O_RDONLY);
477 if (fd == -1) {
Todd Poynor3948f802013-07-09 19:35:14 -0700478 ALOGE("%s open: errno=%d", ZONEINFO_PATH, errno);
479 return -1;
480 }
481
Colin Crossce85d952014-07-11 17:53:27 -0700482 size = read_all(fd, buf, sizeof(buf) - 1);
483 if (size < 0) {
484 ALOGE("%s read: errno=%d", ZONEINFO_PATH, errno);
485 close(fd);
486 return -1;
487 }
488 ALOG_ASSERT((size_t)size < sizeof(buf) - 1, "/proc/zoneinfo too large");
489 buf[size] = 0;
490
491 for (line = strtok_r(buf, "\n", &save_ptr); line; line = strtok_r(NULL, "\n", &save_ptr))
Todd Poynor3948f802013-07-09 19:35:14 -0700492 zoneinfo_parse_line(line, mip);
493
Colin Crossce85d952014-07-11 17:53:27 -0700494 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -0700495 return 0;
496}
497
498static int proc_get_size(int pid) {
499 char path[PATH_MAX];
500 char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -0700501 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -0700502 int rss = 0;
503 int total;
Colin Crossce85d952014-07-11 17:53:27 -0700504 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -0700505
506 snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
Colin Crossce85d952014-07-11 17:53:27 -0700507 fd = open(path, O_RDONLY);
508 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -0700509 return -1;
Colin Crossce85d952014-07-11 17:53:27 -0700510
511 ret = read_all(fd, line, sizeof(line) - 1);
512 if (ret < 0) {
513 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -0700514 return -1;
515 }
516
517 sscanf(line, "%d %d ", &total, &rss);
Colin Crossce85d952014-07-11 17:53:27 -0700518 close(fd);
Todd Poynor3948f802013-07-09 19:35:14 -0700519 return rss;
520}
521
522static char *proc_get_name(int pid) {
523 char path[PATH_MAX];
524 static char line[LINE_MAX];
Colin Crossce85d952014-07-11 17:53:27 -0700525 int fd;
Todd Poynor3948f802013-07-09 19:35:14 -0700526 char *cp;
Colin Crossce85d952014-07-11 17:53:27 -0700527 ssize_t ret;
Todd Poynor3948f802013-07-09 19:35:14 -0700528
529 snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
Colin Crossce85d952014-07-11 17:53:27 -0700530 fd = open(path, O_RDONLY);
531 if (fd == -1)
Todd Poynor3948f802013-07-09 19:35:14 -0700532 return NULL;
Colin Crossce85d952014-07-11 17:53:27 -0700533 ret = read_all(fd, line, sizeof(line) - 1);
534 close(fd);
535 if (ret < 0) {
Todd Poynor3948f802013-07-09 19:35:14 -0700536 return NULL;
537 }
538
539 cp = strchr(line, ' ');
540 if (cp)
541 *cp = '\0';
542
543 return line;
544}
545
546static struct proc *proc_adj_lru(int oomadj) {
547 return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
548}
549
Colin Cross16b09462014-07-14 12:39:56 -0700550/* Kill one process specified by procp. Returns the size of the process killed */
551static int kill_one_process(struct proc *procp, int other_free, int other_file,
552 int minfree, int min_score_adj, bool first)
553{
554 int pid = procp->pid;
555 uid_t uid = procp->uid;
556 char *taskname;
557 int tasksize;
558 int r;
559
560 taskname = proc_get_name(pid);
561 if (!taskname) {
562 pid_remove(pid);
563 return -1;
564 }
565
566 tasksize = proc_get_size(pid);
567 if (tasksize <= 0) {
568 pid_remove(pid);
569 return -1;
570 }
571
572 ALOGI("Killing '%s' (%d), uid %d, adj %d\n"
573 " to free %ldkB because cache %s%ldkB is below limit %ldkB for oom_adj %d\n"
574 " Free memory is %s%ldkB %s reserved",
575 taskname, pid, uid, procp->oomadj, tasksize * page_k,
576 first ? "" : "~", other_file * page_k, minfree * page_k, min_score_adj,
577 first ? "" : "~", other_free * page_k, other_free >= 0 ? "above" : "below");
578 r = kill(pid, SIGKILL);
579 killProcessGroup(uid, pid, SIGKILL);
580 pid_remove(pid);
581
582 if (r) {
583 ALOGE("kill(%d): errno=%d", procp->pid, errno);
584 return -1;
585 } else {
586 return tasksize;
587 }
588}
589
590/*
591 * Find a process to kill based on the current (possibly estimated) free memory
592 * and cached memory sizes. Returns the size of the killed processes.
593 */
594static int find_and_kill_process(int other_free, int other_file, bool first)
595{
596 int i;
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700597 int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
Colin Cross16b09462014-07-14 12:39:56 -0700598 int minfree = 0;
599 int killed_size = 0;
600
601 for (i = 0; i < lowmem_targets_size; i++) {
602 minfree = lowmem_minfree[i];
603 if (other_free < minfree && other_file < minfree) {
604 min_score_adj = lowmem_adj[i];
605 break;
606 }
607 }
608
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700609 if (min_score_adj == OOM_SCORE_ADJ_MAX + 1)
Colin Cross16b09462014-07-14 12:39:56 -0700610 return 0;
611
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700612 for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
Colin Cross16b09462014-07-14 12:39:56 -0700613 struct proc *procp;
614
615retry:
616 procp = proc_adj_lru(i);
617
618 if (procp) {
619 killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
620 if (killed_size < 0) {
621 goto retry;
622 } else {
623 return killed_size;
624 }
625 }
626 }
627
628 return 0;
629}
630
Mark Salyzyne6ed68b2014-04-30 13:36:35 -0700631static void mp_event(uint32_t events __unused) {
Todd Poynor3948f802013-07-09 19:35:14 -0700632 int ret;
633 unsigned long long evcount;
634 struct sysmeminfo mi;
635 int other_free;
636 int other_file;
Colin Cross16b09462014-07-14 12:39:56 -0700637 int killed_size;
638 bool first = true;
Todd Poynor3948f802013-07-09 19:35:14 -0700639
640 ret = read(mpevfd, &evcount, sizeof(evcount));
641 if (ret < 0)
642 ALOGE("Error reading memory pressure event fd; errno=%d",
643 errno);
644
645 if (time(NULL) - kill_lasttime < KILL_TIMEOUT)
646 return;
647
Colin Crossf8857cc2014-07-11 17:16:56 -0700648 while (zoneinfo_parse(&mi) < 0) {
649 // Failed to read /proc/zoneinfo, assume ENOMEM and kill something
650 find_and_kill_process(0, 0, true);
651 }
Todd Poynor3948f802013-07-09 19:35:14 -0700652
653 other_free = mi.nr_free_pages - mi.totalreserve_pages;
654 other_file = mi.nr_file_pages - mi.nr_shmem;
655
Colin Cross16b09462014-07-14 12:39:56 -0700656 do {
657 killed_size = find_and_kill_process(other_free, other_file, first);
658 if (killed_size > 0) {
659 first = false;
660 other_free += killed_size;
661 other_file += killed_size;
Todd Poynor3948f802013-07-09 19:35:14 -0700662 }
Colin Cross16b09462014-07-14 12:39:56 -0700663 } while (killed_size > 0);
Todd Poynor3948f802013-07-09 19:35:14 -0700664}
665
666static int init_mp(char *levelstr, void *event_handler)
667{
668 int mpfd;
669 int evfd;
670 int evctlfd;
671 char buf[256];
672 struct epoll_event epev;
673 int ret;
674
675 mpfd = open(MEMCG_SYSFS_PATH "memory.pressure_level", O_RDONLY);
676 if (mpfd < 0) {
677 ALOGI("No kernel memory.pressure_level support (errno=%d)", errno);
678 goto err_open_mpfd;
679 }
680
681 evctlfd = open(MEMCG_SYSFS_PATH "cgroup.event_control", O_WRONLY);
682 if (evctlfd < 0) {
683 ALOGI("No kernel memory cgroup event control (errno=%d)", errno);
684 goto err_open_evctlfd;
685 }
686
687 evfd = eventfd(0, EFD_NONBLOCK);
688 if (evfd < 0) {
689 ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
690 goto err_eventfd;
691 }
692
693 ret = snprintf(buf, sizeof(buf), "%d %d %s", evfd, mpfd, levelstr);
694 if (ret >= (ssize_t)sizeof(buf)) {
695 ALOGE("cgroup.event_control line overflow for level %s", levelstr);
696 goto err;
697 }
698
699 ret = write(evctlfd, buf, strlen(buf) + 1);
700 if (ret == -1) {
701 ALOGE("cgroup.event_control write failed for level %s; errno=%d",
702 levelstr, errno);
703 goto err;
704 }
705
706 epev.events = EPOLLIN;
707 epev.data.ptr = event_handler;
708 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, evfd, &epev);
709 if (ret == -1) {
710 ALOGE("epoll_ctl for level %s failed; errno=%d", levelstr, errno);
711 goto err;
712 }
713 maxevents++;
714 mpevfd = evfd;
715 return 0;
716
717err:
718 close(evfd);
719err_eventfd:
720 close(evctlfd);
721err_open_evctlfd:
722 close(mpfd);
723err_open_mpfd:
724 return -1;
725}
726
727static int init(void) {
728 struct epoll_event epev;
729 int i;
730 int ret;
731
732 page_k = sysconf(_SC_PAGESIZE);
733 if (page_k == -1)
734 page_k = PAGE_SIZE;
735 page_k /= 1024;
736
737 epollfd = epoll_create(MAX_EPOLL_EVENTS);
738 if (epollfd == -1) {
739 ALOGE("epoll_create failed (errno=%d)", errno);
740 return -1;
741 }
742
743 ctrl_lfd = android_get_control_socket("lmkd");
744 if (ctrl_lfd < 0) {
745 ALOGE("get lmkd control socket failed");
746 return -1;
747 }
748
749 ret = listen(ctrl_lfd, 1);
750 if (ret < 0) {
751 ALOGE("lmkd control socket listen failed (errno=%d)", errno);
752 return -1;
753 }
754
755 epev.events = EPOLLIN;
756 epev.data.ptr = (void *)ctrl_connect_handler;
757 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
758 ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
759 return -1;
760 }
761 maxevents++;
762
763 use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);
764
765 if (use_inkernel_interface) {
766 ALOGI("Using in-kernel low memory killer interface");
767 } else {
768 ret = init_mp(MEMPRESSURE_WATCH_LEVEL, (void *)&mp_event);
769 if (ret)
770 ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
771 }
772
Chong Zhang0a4acdf2015-10-14 16:19:53 -0700773 for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
Todd Poynor3948f802013-07-09 19:35:14 -0700774 procadjslot_list[i].next = &procadjslot_list[i];
775 procadjslot_list[i].prev = &procadjslot_list[i];
776 }
777
778 return 0;
779}
780
781static void mainloop(void) {
782 while (1) {
783 struct epoll_event events[maxevents];
784 int nevents;
785 int i;
786
787 ctrl_dfd_reopened = 0;
788 nevents = epoll_wait(epollfd, events, maxevents, -1);
789
790 if (nevents == -1) {
791 if (errno == EINTR)
792 continue;
793 ALOGE("epoll_wait failed (errno=%d)", errno);
794 continue;
795 }
796
797 for (i = 0; i < nevents; ++i) {
798 if (events[i].events & EPOLLERR)
799 ALOGD("EPOLLERR on event #%d", i);
800 if (events[i].data.ptr)
801 (*(void (*)(uint32_t))events[i].data.ptr)(events[i].events);
802 }
803 }
804}
805
Mark Salyzyne6ed68b2014-04-30 13:36:35 -0700806int main(int argc __unused, char **argv __unused) {
Colin Cross1a0d9be2014-07-14 14:31:15 -0700807 struct sched_param param = {
808 .sched_priority = 1,
809 };
810
Colin Crossb28ff912014-07-11 17:15:44 -0700811 mlockall(MCL_FUTURE);
Colin Cross1a0d9be2014-07-14 14:31:15 -0700812 sched_setscheduler(0, SCHED_FIFO, &param);
Todd Poynor3948f802013-07-09 19:35:14 -0700813 if (!init())
814 mainloop();
815
816 ALOGI("exiting");
817 return 0;
818}