1 /*
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
19 #include <arpa/inet.h>
20 #include <errno.h>
21 #include <sched.h>
22 #include <signal.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <time.h>
26 #include <sys/cdefs.h>
27 #include <sys/epoll.h>
28 #include <sys/eventfd.h>
29 #include <sys/mman.h>
30 #include <sys/socket.h>
31 #include <sys/types.h>
32 #include <unistd.h>
33
34 #include <cutils/sockets.h>
35 #include <log/log.h>
36 #include <processgroup/processgroup.h>
37
38 #ifndef __unused
39 #define __unused __attribute__((__unused__))
40 #endif
41
42 #define MEMCG_SYSFS_PATH "/dev/memcg/"
43 #define MEMPRESSURE_WATCH_LEVEL "low"
44 #define ZONEINFO_PATH "/proc/zoneinfo"
45 #define LINE_MAX 128
46
47 #define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
48 #define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"
49
50 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
51
52 enum lmk_cmd {
53 LMK_TARGET,
54 LMK_PROCPRIO,
55 LMK_PROCREMOVE,
56 };
57
58 #define MAX_TARGETS 6
59 /*
60 * longest is LMK_TARGET followed by MAX_TARGETS each minfree and minkillprio
61 * values
62 */
63 #define CTRL_PACKET_MAX (sizeof(int) * (MAX_TARGETS * 2 + 1))
64
65 /* default to old in-kernel interface if no memory pressure events */
66 static int use_inkernel_interface = 1;
67
68 /* memory pressure level medium event */
69 static int mpevfd;
70
71 /* control socket listen and data */
72 static int ctrl_lfd;
73 static int ctrl_dfd = -1;
74 static int ctrl_dfd_reopened; /* did we reopen ctrl conn on this loop? */
75
76 /* 1 memory pressure level, 1 ctrl listen socket, 1 ctrl data socket */
77 #define MAX_EPOLL_EVENTS 3
78 static int epollfd;
79 static int maxevents;
80
81 /* OOM score values used by both kernel and framework */
82 #define OOM_SCORE_ADJ_MIN (-1000)
83 #define OOM_SCORE_ADJ_MAX 1000
84
85 static int lowmem_adj[MAX_TARGETS];
86 static int lowmem_minfree[MAX_TARGETS];
87 static int lowmem_targets_size;
88
89 struct sysmeminfo {
90 int nr_free_pages;
91 int nr_file_pages;
92 int nr_shmem;
93 int totalreserve_pages;
94 };
95
96 struct adjslot_list {
97 struct adjslot_list *next;
98 struct adjslot_list *prev;
99 };
100
101 struct proc {
102 struct adjslot_list asl;
103 int pid;
104 uid_t uid;
105 int oomadj;
106 struct proc *pidhash_next;
107 };
108
109 #define PIDHASH_SZ 1024
110 static struct proc *pidhash[PIDHASH_SZ];
111 #define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
112
113 #define ADJTOSLOT(adj) ((adj) + -OOM_SCORE_ADJ_MIN)
114 static struct adjslot_list procadjslot_list[ADJTOSLOT(OOM_SCORE_ADJ_MAX) + 1];
115
116 /*
117 * Wait 1-2 seconds for the death report of a killed process prior to
118 * considering killing more processes.
119 */
120 #define KILL_TIMEOUT 2
121 /* Time of last process kill we initiated, stop me before I kill again */
122 static time_t kill_lasttime;
123
124 /* PAGE_SIZE / 1024 */
125 static long page_k;
126
read_all(int fd,char * buf,size_t max_len)127 static ssize_t read_all(int fd, char *buf, size_t max_len)
128 {
129 ssize_t ret = 0;
130
131 while (max_len > 0) {
132 ssize_t r = read(fd, buf, max_len);
133 if (r == 0) {
134 break;
135 }
136 if (r == -1) {
137 return -1;
138 }
139 ret += r;
140 buf += r;
141 max_len -= r;
142 }
143
144 return ret;
145 }
146
pid_lookup(int pid)147 static struct proc *pid_lookup(int pid) {
148 struct proc *procp;
149
150 for (procp = pidhash[pid_hashfn(pid)]; procp && procp->pid != pid;
151 procp = procp->pidhash_next)
152 ;
153
154 return procp;
155 }
156
adjslot_insert(struct adjslot_list * head,struct adjslot_list * new)157 static void adjslot_insert(struct adjslot_list *head, struct adjslot_list *new)
158 {
159 struct adjslot_list *next = head->next;
160 new->prev = head;
161 new->next = next;
162 next->prev = new;
163 head->next = new;
164 }
165
adjslot_remove(struct adjslot_list * old)166 static void adjslot_remove(struct adjslot_list *old)
167 {
168 struct adjslot_list *prev = old->prev;
169 struct adjslot_list *next = old->next;
170 next->prev = prev;
171 prev->next = next;
172 }
173
adjslot_tail(struct adjslot_list * head)174 static struct adjslot_list *adjslot_tail(struct adjslot_list *head) {
175 struct adjslot_list *asl = head->prev;
176
177 return asl == head ? NULL : asl;
178 }
179
proc_slot(struct proc * procp)180 static void proc_slot(struct proc *procp) {
181 int adjslot = ADJTOSLOT(procp->oomadj);
182
183 adjslot_insert(&procadjslot_list[adjslot], &procp->asl);
184 }
185
proc_unslot(struct proc * procp)186 static void proc_unslot(struct proc *procp) {
187 adjslot_remove(&procp->asl);
188 }
189
proc_insert(struct proc * procp)190 static void proc_insert(struct proc *procp) {
191 int hval = pid_hashfn(procp->pid);
192
193 procp->pidhash_next = pidhash[hval];
194 pidhash[hval] = procp;
195 proc_slot(procp);
196 }
197
pid_remove(int pid)198 static int pid_remove(int pid) {
199 int hval = pid_hashfn(pid);
200 struct proc *procp;
201 struct proc *prevp;
202
203 for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
204 procp = procp->pidhash_next)
205 prevp = procp;
206
207 if (!procp)
208 return -1;
209
210 if (!prevp)
211 pidhash[hval] = procp->pidhash_next;
212 else
213 prevp->pidhash_next = procp->pidhash_next;
214
215 proc_unslot(procp);
216 free(procp);
217 return 0;
218 }
219
writefilestring(char * path,char * s)220 static void writefilestring(char *path, char *s) {
221 int fd = open(path, O_WRONLY | O_CLOEXEC);
222 int len = strlen(s);
223 int ret;
224
225 if (fd < 0) {
226 ALOGE("Error opening %s; errno=%d", path, errno);
227 return;
228 }
229
230 ret = write(fd, s, len);
231 if (ret < 0) {
232 ALOGE("Error writing %s; errno=%d", path, errno);
233 } else if (ret < len) {
234 ALOGE("Short write on %s; length=%d", path, ret);
235 }
236
237 close(fd);
238 }
239
cmd_procprio(int pid,int uid,int oomadj)240 static void cmd_procprio(int pid, int uid, int oomadj) {
241 struct proc *procp;
242 char path[80];
243 char val[20];
244
245 if (oomadj < OOM_SCORE_ADJ_MIN || oomadj > OOM_SCORE_ADJ_MAX) {
246 ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
247 return;
248 }
249
250 snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
251 snprintf(val, sizeof(val), "%d", oomadj);
252 writefilestring(path, val);
253
254 if (use_inkernel_interface)
255 return;
256
257 procp = pid_lookup(pid);
258 if (!procp) {
259 procp = malloc(sizeof(struct proc));
260 if (!procp) {
261 // Oh, the irony. May need to rebuild our state.
262 return;
263 }
264
265 procp->pid = pid;
266 procp->uid = uid;
267 procp->oomadj = oomadj;
268 proc_insert(procp);
269 } else {
270 proc_unslot(procp);
271 procp->oomadj = oomadj;
272 proc_slot(procp);
273 }
274 }
275
cmd_procremove(int pid)276 static void cmd_procremove(int pid) {
277 if (use_inkernel_interface)
278 return;
279
280 pid_remove(pid);
281 kill_lasttime = 0;
282 }
283
cmd_target(int ntargets,int * params)284 static void cmd_target(int ntargets, int *params) {
285 int i;
286
287 if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
288 return;
289
290 for (i = 0; i < ntargets; i++) {
291 lowmem_minfree[i] = ntohl(*params++);
292 lowmem_adj[i] = ntohl(*params++);
293 }
294
295 lowmem_targets_size = ntargets;
296
297 if (use_inkernel_interface) {
298 char minfreestr[128];
299 char killpriostr[128];
300
301 minfreestr[0] = '\0';
302 killpriostr[0] = '\0';
303
304 for (i = 0; i < lowmem_targets_size; i++) {
305 char val[40];
306
307 if (i) {
308 strlcat(minfreestr, ",", sizeof(minfreestr));
309 strlcat(killpriostr, ",", sizeof(killpriostr));
310 }
311
312 snprintf(val, sizeof(val), "%d", lowmem_minfree[i]);
313 strlcat(minfreestr, val, sizeof(minfreestr));
314 snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
315 strlcat(killpriostr, val, sizeof(killpriostr));
316 }
317
318 writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
319 writefilestring(INKERNEL_ADJ_PATH, killpriostr);
320 }
321 }
322
ctrl_data_close(void)323 static void ctrl_data_close(void) {
324 ALOGI("Closing Activity Manager data connection");
325 close(ctrl_dfd);
326 ctrl_dfd = -1;
327 maxevents--;
328 }
329
ctrl_data_read(char * buf,size_t bufsz)330 static int ctrl_data_read(char *buf, size_t bufsz) {
331 int ret = 0;
332
333 ret = read(ctrl_dfd, buf, bufsz);
334
335 if (ret == -1) {
336 ALOGE("control data socket read failed; errno=%d", errno);
337 } else if (ret == 0) {
338 ALOGE("Got EOF on control data socket");
339 ret = -1;
340 }
341
342 return ret;
343 }
344
ctrl_command_handler(void)345 static void ctrl_command_handler(void) {
346 int ibuf[CTRL_PACKET_MAX / sizeof(int)];
347 int len;
348 int cmd = -1;
349 int nargs;
350 int targets;
351
352 len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
353 if (len <= 0)
354 return;
355
356 nargs = len / sizeof(int) - 1;
357 if (nargs < 0)
358 goto wronglen;
359
360 cmd = ntohl(ibuf[0]);
361
362 switch(cmd) {
363 case LMK_TARGET:
364 targets = nargs / 2;
365 if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
366 goto wronglen;
367 cmd_target(targets, &ibuf[1]);
368 break;
369 case LMK_PROCPRIO:
370 if (nargs != 3)
371 goto wronglen;
372 cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
373 break;
374 case LMK_PROCREMOVE:
375 if (nargs != 1)
376 goto wronglen;
377 cmd_procremove(ntohl(ibuf[1]));
378 break;
379 default:
380 ALOGE("Received unknown command code %d", cmd);
381 return;
382 }
383
384 return;
385
386 wronglen:
387 ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
388 }
389
ctrl_data_handler(uint32_t events)390 static void ctrl_data_handler(uint32_t events) {
391 if (events & EPOLLHUP) {
392 ALOGI("ActivityManager disconnected");
393 if (!ctrl_dfd_reopened)
394 ctrl_data_close();
395 } else if (events & EPOLLIN) {
396 ctrl_command_handler();
397 }
398 }
399
ctrl_connect_handler(uint32_t events __unused)400 static void ctrl_connect_handler(uint32_t events __unused) {
401 struct epoll_event epev;
402
403 if (ctrl_dfd >= 0) {
404 ctrl_data_close();
405 ctrl_dfd_reopened = 1;
406 }
407
408 ctrl_dfd = accept(ctrl_lfd, NULL, NULL);
409
410 if (ctrl_dfd < 0) {
411 ALOGE("lmkd control socket accept failed; errno=%d", errno);
412 return;
413 }
414
415 ALOGI("ActivityManager connected");
416 maxevents++;
417 epev.events = EPOLLIN;
418 epev.data.ptr = (void *)ctrl_data_handler;
419 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_dfd, &epev) == -1) {
420 ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
421 ctrl_data_close();
422 return;
423 }
424 }
425
zoneinfo_parse_protection(char * cp)426 static int zoneinfo_parse_protection(char *cp) {
427 int max = 0;
428 int zoneval;
429 char *save_ptr;
430
431 for (cp = strtok_r(cp, "(), ", &save_ptr); cp; cp = strtok_r(NULL, "), ", &save_ptr)) {
432 zoneval = strtol(cp, &cp, 0);
433 if (zoneval > max)
434 max = zoneval;
435 }
436
437 return max;
438 }
439
zoneinfo_parse_line(char * line,struct sysmeminfo * mip)440 static void zoneinfo_parse_line(char *line, struct sysmeminfo *mip) {
441 char *cp = line;
442 char *ap;
443 char *save_ptr;
444
445 cp = strtok_r(line, " ", &save_ptr);
446 if (!cp)
447 return;
448
449 ap = strtok_r(NULL, " ", &save_ptr);
450 if (!ap)
451 return;
452
453 if (!strcmp(cp, "nr_free_pages"))
454 mip->nr_free_pages += strtol(ap, NULL, 0);
455 else if (!strcmp(cp, "nr_file_pages"))
456 mip->nr_file_pages += strtol(ap, NULL, 0);
457 else if (!strcmp(cp, "nr_shmem"))
458 mip->nr_shmem += strtol(ap, NULL, 0);
459 else if (!strcmp(cp, "high"))
460 mip->totalreserve_pages += strtol(ap, NULL, 0);
461 else if (!strcmp(cp, "protection:"))
462 mip->totalreserve_pages += zoneinfo_parse_protection(ap);
463 }
464
zoneinfo_parse(struct sysmeminfo * mip)465 static int zoneinfo_parse(struct sysmeminfo *mip) {
466 int fd;
467 ssize_t size;
468 char buf[PAGE_SIZE];
469 char *save_ptr;
470 char *line;
471
472 memset(mip, 0, sizeof(struct sysmeminfo));
473
474 fd = open(ZONEINFO_PATH, O_RDONLY | O_CLOEXEC);
475 if (fd == -1) {
476 ALOGE("%s open: errno=%d", ZONEINFO_PATH, errno);
477 return -1;
478 }
479
480 size = read_all(fd, buf, sizeof(buf) - 1);
481 if (size < 0) {
482 ALOGE("%s read: errno=%d", ZONEINFO_PATH, errno);
483 close(fd);
484 return -1;
485 }
486 ALOG_ASSERT((size_t)size < sizeof(buf) - 1, "/proc/zoneinfo too large");
487 buf[size] = 0;
488
489 for (line = strtok_r(buf, "\n", &save_ptr); line; line = strtok_r(NULL, "\n", &save_ptr))
490 zoneinfo_parse_line(line, mip);
491
492 close(fd);
493 return 0;
494 }
495
proc_get_size(int pid)496 static int proc_get_size(int pid) {
497 char path[PATH_MAX];
498 char line[LINE_MAX];
499 int fd;
500 int rss = 0;
501 int total;
502 ssize_t ret;
503
504 snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
505 fd = open(path, O_RDONLY | O_CLOEXEC);
506 if (fd == -1)
507 return -1;
508
509 ret = read_all(fd, line, sizeof(line) - 1);
510 if (ret < 0) {
511 close(fd);
512 return -1;
513 }
514
515 sscanf(line, "%d %d ", &total, &rss);
516 close(fd);
517 return rss;
518 }
519
proc_get_name(int pid)520 static char *proc_get_name(int pid) {
521 char path[PATH_MAX];
522 static char line[LINE_MAX];
523 int fd;
524 char *cp;
525 ssize_t ret;
526
527 snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
528 fd = open(path, O_RDONLY | O_CLOEXEC);
529 if (fd == -1)
530 return NULL;
531 ret = read_all(fd, line, sizeof(line) - 1);
532 close(fd);
533 if (ret < 0) {
534 return NULL;
535 }
536
537 cp = strchr(line, ' ');
538 if (cp)
539 *cp = '\0';
540
541 return line;
542 }
543
proc_adj_lru(int oomadj)544 static struct proc *proc_adj_lru(int oomadj) {
545 return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
546 }
547
548 /* Kill one process specified by procp. Returns the size of the process killed */
kill_one_process(struct proc * procp,int other_free,int other_file,int minfree,int min_score_adj,bool first)549 static int kill_one_process(struct proc *procp, int other_free, int other_file,
550 int minfree, int min_score_adj, bool first)
551 {
552 int pid = procp->pid;
553 uid_t uid = procp->uid;
554 char *taskname;
555 int tasksize;
556 int r;
557
558 taskname = proc_get_name(pid);
559 if (!taskname) {
560 pid_remove(pid);
561 return -1;
562 }
563
564 tasksize = proc_get_size(pid);
565 if (tasksize <= 0) {
566 pid_remove(pid);
567 return -1;
568 }
569
570 ALOGI("Killing '%s' (%d), uid %d, adj %d\n"
571 " to free %ldkB because cache %s%ldkB is below limit %ldkB for oom_adj %d\n"
572 " Free memory is %s%ldkB %s reserved",
573 taskname, pid, uid, procp->oomadj, tasksize * page_k,
574 first ? "" : "~", other_file * page_k, minfree * page_k, min_score_adj,
575 first ? "" : "~", other_free * page_k, other_free >= 0 ? "above" : "below");
576 r = kill(pid, SIGKILL);
577 killProcessGroup(uid, pid, SIGKILL);
578 pid_remove(pid);
579
580 if (r) {
581 ALOGE("kill(%d): errno=%d", procp->pid, errno);
582 return -1;
583 } else {
584 return tasksize;
585 }
586 }
587
588 /*
589 * Find a process to kill based on the current (possibly estimated) free memory
590 * and cached memory sizes. Returns the size of the killed processes.
591 */
find_and_kill_process(int other_free,int other_file,bool first)592 static int find_and_kill_process(int other_free, int other_file, bool first)
593 {
594 int i;
595 int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
596 int minfree = 0;
597 int killed_size = 0;
598
599 for (i = 0; i < lowmem_targets_size; i++) {
600 minfree = lowmem_minfree[i];
601 if (other_free < minfree && other_file < minfree) {
602 min_score_adj = lowmem_adj[i];
603 break;
604 }
605 }
606
607 if (min_score_adj == OOM_SCORE_ADJ_MAX + 1)
608 return 0;
609
610 for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
611 struct proc *procp;
612
613 retry:
614 procp = proc_adj_lru(i);
615
616 if (procp) {
617 killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
618 if (killed_size < 0) {
619 goto retry;
620 } else {
621 return killed_size;
622 }
623 }
624 }
625
626 return 0;
627 }
628
mp_event(uint32_t events __unused)629 static void mp_event(uint32_t events __unused) {
630 int ret;
631 unsigned long long evcount;
632 struct sysmeminfo mi;
633 int other_free;
634 int other_file;
635 int killed_size;
636 bool first = true;
637
638 ret = read(mpevfd, &evcount, sizeof(evcount));
639 if (ret < 0)
640 ALOGE("Error reading memory pressure event fd; errno=%d",
641 errno);
642
643 if (time(NULL) - kill_lasttime < KILL_TIMEOUT)
644 return;
645
646 while (zoneinfo_parse(&mi) < 0) {
647 // Failed to read /proc/zoneinfo, assume ENOMEM and kill something
648 find_and_kill_process(0, 0, true);
649 }
650
651 other_free = mi.nr_free_pages - mi.totalreserve_pages;
652 other_file = mi.nr_file_pages - mi.nr_shmem;
653
654 do {
655 killed_size = find_and_kill_process(other_free, other_file, first);
656 if (killed_size > 0) {
657 first = false;
658 other_free += killed_size;
659 other_file += killed_size;
660 }
661 } while (killed_size > 0);
662 }
663
init_mp(char * levelstr,void * event_handler)664 static int init_mp(char *levelstr, void *event_handler)
665 {
666 int mpfd;
667 int evfd;
668 int evctlfd;
669 char buf[256];
670 struct epoll_event epev;
671 int ret;
672
673 mpfd = open(MEMCG_SYSFS_PATH "memory.pressure_level", O_RDONLY | O_CLOEXEC);
674 if (mpfd < 0) {
675 ALOGI("No kernel memory.pressure_level support (errno=%d)", errno);
676 goto err_open_mpfd;
677 }
678
679 evctlfd = open(MEMCG_SYSFS_PATH "cgroup.event_control", O_WRONLY | O_CLOEXEC);
680 if (evctlfd < 0) {
681 ALOGI("No kernel memory cgroup event control (errno=%d)", errno);
682 goto err_open_evctlfd;
683 }
684
685 evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
686 if (evfd < 0) {
687 ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
688 goto err_eventfd;
689 }
690
691 ret = snprintf(buf, sizeof(buf), "%d %d %s", evfd, mpfd, levelstr);
692 if (ret >= (ssize_t)sizeof(buf)) {
693 ALOGE("cgroup.event_control line overflow for level %s", levelstr);
694 goto err;
695 }
696
697 ret = write(evctlfd, buf, strlen(buf) + 1);
698 if (ret == -1) {
699 ALOGE("cgroup.event_control write failed for level %s; errno=%d",
700 levelstr, errno);
701 goto err;
702 }
703
704 epev.events = EPOLLIN;
705 epev.data.ptr = event_handler;
706 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, evfd, &epev);
707 if (ret == -1) {
708 ALOGE("epoll_ctl for level %s failed; errno=%d", levelstr, errno);
709 goto err;
710 }
711 maxevents++;
712 mpevfd = evfd;
713 return 0;
714
715 err:
716 close(evfd);
717 err_eventfd:
718 close(evctlfd);
719 err_open_evctlfd:
720 close(mpfd);
721 err_open_mpfd:
722 return -1;
723 }
724
init(void)725 static int init(void) {
726 struct epoll_event epev;
727 int i;
728 int ret;
729
730 page_k = sysconf(_SC_PAGESIZE);
731 if (page_k == -1)
732 page_k = PAGE_SIZE;
733 page_k /= 1024;
734
735 epollfd = epoll_create(MAX_EPOLL_EVENTS);
736 if (epollfd == -1) {
737 ALOGE("epoll_create failed (errno=%d)", errno);
738 return -1;
739 }
740
741 ctrl_lfd = android_get_control_socket("lmkd");
742 if (ctrl_lfd < 0) {
743 ALOGE("get lmkd control socket failed");
744 return -1;
745 }
746
747 ret = listen(ctrl_lfd, 1);
748 if (ret < 0) {
749 ALOGE("lmkd control socket listen failed (errno=%d)", errno);
750 return -1;
751 }
752
753 epev.events = EPOLLIN;
754 epev.data.ptr = (void *)ctrl_connect_handler;
755 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
756 ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
757 return -1;
758 }
759 maxevents++;
760
761 use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);
762
763 if (use_inkernel_interface) {
764 ALOGI("Using in-kernel low memory killer interface");
765 } else {
766 ret = init_mp(MEMPRESSURE_WATCH_LEVEL, (void *)&mp_event);
767 if (ret)
768 ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
769 }
770
771 for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
772 procadjslot_list[i].next = &procadjslot_list[i];
773 procadjslot_list[i].prev = &procadjslot_list[i];
774 }
775
776 return 0;
777 }
778
mainloop(void)779 static void mainloop(void) {
780 while (1) {
781 struct epoll_event events[maxevents];
782 int nevents;
783 int i;
784
785 ctrl_dfd_reopened = 0;
786 nevents = epoll_wait(epollfd, events, maxevents, -1);
787
788 if (nevents == -1) {
789 if (errno == EINTR)
790 continue;
791 ALOGE("epoll_wait failed (errno=%d)", errno);
792 continue;
793 }
794
795 for (i = 0; i < nevents; ++i) {
796 if (events[i].events & EPOLLERR)
797 ALOGD("EPOLLERR on event #%d", i);
798 if (events[i].data.ptr)
799 (*(void (*)(uint32_t))events[i].data.ptr)(events[i].events);
800 }
801 }
802 }
803
main(int argc __unused,char ** argv __unused)804 int main(int argc __unused, char **argv __unused) {
805 struct sched_param param = {
806 .sched_priority = 1,
807 };
808
809 mlockall(MCL_FUTURE);
810 sched_setscheduler(0, SCHED_FIFO, ¶m);
811 if (!init())
812 mainloop();
813
814 ALOGI("exiting");
815 return 0;
816 }
817