lmkd/lmkd.c - android_system_core - Gitiles

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "lowmemorykiller"

 #include <arpa/inet.h>
 #include <errno.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <sys/cdefs.h>
 #include <sys/epoll.h>
 #include <sys/eventfd.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include <cutils/sockets.h>
 #include <log/log.h>
 #include <processgroup/processgroup.h>

 #ifndef __unused
 #define __unused __attribute__((__unused__))
 #endif

 #define MEMCG_SYSFS_PATH "/dev/memcg/"
 #define MEMPRESSURE_WATCH_LEVEL "low"
 #define ZONEINFO_PATH "/proc/zoneinfo"
 #define LINE_MAX 128

 #define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
 #define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"

 #define ARRAY_SIZE(x)   (sizeof(x) / sizeof(*(x)))

 enum lmk_cmd {
     LMK_TARGET,
     LMK_PROCPRIO,
     LMK_PROCREMOVE,
 };

 #define MAX_TARGETS 6
 /*
  * longest is LMK_TARGET followed by MAX_TARGETS each minfree and minkillprio
  * values
  */
 #define CTRL_PACKET_MAX (sizeof(int) * (MAX_TARGETS * 2 + 1))

 /* default to old in-kernel interface if no memory pressure events */
 static int use_inkernel_interface = 1;

 /* memory pressure level medium event */
 static int mpevfd;

 /* control socket listen and data */
 static int ctrl_lfd;
 static int ctrl_dfd = -1;
 static int ctrl_dfd_reopened; /* did we reopen ctrl conn on this loop? */

 /* 1 memory pressure level, 1 ctrl listen socket, 1 ctrl data socket */
 #define MAX_EPOLL_EVENTS 3
 static int epollfd;
 static int maxevents;

 /* OOM score values used by both kernel and framework */
 #define OOM_SCORE_ADJ_MIN       (-1000)
 #define OOM_SCORE_ADJ_MAX       1000

 static int lowmem_adj[MAX_TARGETS];
 static int lowmem_minfree[MAX_TARGETS];
 static int lowmem_targets_size;

 struct sysmeminfo {
     int nr_free_pages;
     int nr_file_pages;
     int nr_shmem;
     int totalreserve_pages;
 };

 struct adjslot_list {
     struct adjslot_list *next;
     struct adjslot_list *prev;
 };

 struct proc {
     struct adjslot_list asl;
     int pid;
     uid_t uid;
     int oomadj;
     struct proc *pidhash_next;
 };

 #define PIDHASH_SZ 1024
 static struct proc *pidhash[PIDHASH_SZ];
 #define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))

 #define ADJTOSLOT(adj) (adj + -OOM_SCORE_ADJ_MIN)
 static struct adjslot_list procadjslot_list[ADJTOSLOT(OOM_SCORE_ADJ_MAX) + 1];

 /*
  * Wait 1-2 seconds for the death report of a killed process prior to
  * considering killing more processes.
  */
 #define KILL_TIMEOUT 2
 /* Time of last process kill we initiated, stop me before I kill again */
 static time_t kill_lasttime;

 /* PAGE_SIZE / 1024 */
 static long page_k;

 static ssize_t read_all(int fd, char *buf, size_t max_len)
 {
     ssize_t ret = 0;

     while (max_len > 0) {
         ssize_t r = read(fd, buf, max_len);
         if (r == 0) {
             break;
         }
         if (r == -1) {
             return -1;
         }
         ret += r;
         buf += r;
         max_len -= r;
     }

     return ret;
 }

 static struct proc *pid_lookup(int pid) {
     struct proc *procp;

     for (procp = pidhash[pid_hashfn(pid)]; procp && procp->pid != pid;
          procp = procp->pidhash_next)
             ;

     return procp;
 }

 static void adjslot_insert(struct adjslot_list *head, struct adjslot_list *new)
 {
     struct adjslot_list *next = head->next;
     new->prev = head;
     new->next = next;
     next->prev = new;
     head->next = new;
 }

 static void adjslot_remove(struct adjslot_list *old)
 {
     struct adjslot_list *prev = old->prev;
     struct adjslot_list *next = old->next;
     next->prev = prev;
     prev->next = next;
 }

 static struct adjslot_list *adjslot_tail(struct adjslot_list *head) {
     struct adjslot_list *asl = head->prev;

     return asl == head ? NULL : asl;
 }

 static void proc_slot(struct proc *procp) {
     int adjslot = ADJTOSLOT(procp->oomadj);

     adjslot_insert(&procadjslot_list[adjslot], &procp->asl);
 }

 static void proc_unslot(struct proc *procp) {
     adjslot_remove(&procp->asl);
 }

 static void proc_insert(struct proc *procp) {
     int hval = pid_hashfn(procp->pid);

     procp->pidhash_next = pidhash[hval];
     pidhash[hval] = procp;
     proc_slot(procp);
 }

 static int pid_remove(int pid) {
     int hval = pid_hashfn(pid);
     struct proc *procp;
     struct proc *prevp;

     for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
          procp = procp->pidhash_next)
             prevp = procp;

     if (!procp)
         return -1;

     if (!prevp)
         pidhash[hval] = procp->pidhash_next;
     else
         prevp->pidhash_next = procp->pidhash_next;

     proc_unslot(procp);
     free(procp);
     return 0;
 }

 static void writefilestring(char *path, char *s) {
     int fd = open(path, O_WRONLY | O_CLOEXEC);
     int len = strlen(s);
     int ret;

     if (fd < 0) {
         ALOGE("Error opening %s; errno=%d", path, errno);
         return;
     }

     ret = write(fd, s, len);
     if (ret < 0) {
         ALOGE("Error writing %s; errno=%d", path, errno);
     } else if (ret < len) {
         ALOGE("Short write on %s; length=%d", path, ret);
     }

     close(fd);
 }

 static void cmd_procprio(int pid, int uid, int oomadj) {
     struct proc *procp;
     char path[80];
     char val[20];

     if (oomadj < OOM_SCORE_ADJ_MIN || oomadj > OOM_SCORE_ADJ_MAX) {
         ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
         return;
     }

     snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
     snprintf(val, sizeof(val), "%d", oomadj);
     writefilestring(path, val);

     if (use_inkernel_interface)
         return;

     procp = pid_lookup(pid);
     if (!procp) {
             procp = malloc(sizeof(struct proc));
             if (!procp) {
                 // Oh, the irony.  May need to rebuild our state.
                 return;
             }

             procp->pid = pid;
             procp->uid = uid;
             procp->oomadj = oomadj;
             proc_insert(procp);
     } else {
         proc_unslot(procp);
         procp->oomadj = oomadj;
         proc_slot(procp);
     }
 }

 static void cmd_procremove(int pid) {
     if (use_inkernel_interface)
         return;

     pid_remove(pid);
     kill_lasttime = 0;
 }

 static void cmd_target(int ntargets, int *params) {
     int i;

     if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
         return;

     for (i = 0; i < ntargets; i++) {
         lowmem_minfree[i] = ntohl(*params++);
         lowmem_adj[i] = ntohl(*params++);
     }

     lowmem_targets_size = ntargets;

     if (use_inkernel_interface) {
         char minfreestr[128];
         char killpriostr[128];

         minfreestr[0] = '\0';
         killpriostr[0] = '\0';

         for (i = 0; i < lowmem_targets_size; i++) {
             char val[40];

             if (i) {
                 strlcat(minfreestr, ",", sizeof(minfreestr));
                 strlcat(killpriostr, ",", sizeof(killpriostr));
             }

             snprintf(val, sizeof(val), "%d", lowmem_minfree[i]);
             strlcat(minfreestr, val, sizeof(minfreestr));
             snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
             strlcat(killpriostr, val, sizeof(killpriostr));
         }

         writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
         writefilestring(INKERNEL_ADJ_PATH, killpriostr);
     }
 }

 static void ctrl_data_close(void) {
     ALOGI("Closing Activity Manager data connection");
     close(ctrl_dfd);
     ctrl_dfd = -1;
     maxevents--;
 }

 static int ctrl_data_read(char *buf, size_t bufsz) {
     int ret = 0;

     ret = read(ctrl_dfd, buf, bufsz);

     if (ret == -1) {
         ALOGE("control data socket read failed; errno=%d", errno);
     } else if (ret == 0) {
         ALOGE("Got EOF on control data socket");
         ret = -1;
     }

     return ret;
 }

 static void ctrl_command_handler(void) {
     int ibuf[CTRL_PACKET_MAX / sizeof(int)];
     int len;
     int cmd = -1;
     int nargs;
     int targets;

     len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
     if (len <= 0)
         return;

     nargs = len / sizeof(int) - 1;
     if (nargs < 0)
         goto wronglen;

     cmd = ntohl(ibuf[0]);

     switch(cmd) {
     case LMK_TARGET:
         targets = nargs / 2;
         if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
             goto wronglen;
         cmd_target(targets, &ibuf[1]);
         break;
     case LMK_PROCPRIO:
         if (nargs != 3)
             goto wronglen;
         cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
         break;
     case LMK_PROCREMOVE:
         if (nargs != 1)
             goto wronglen;
         cmd_procremove(ntohl(ibuf[1]));
         break;
     default:
         ALOGE("Received unknown command code %d", cmd);
         return;
     }

     return;

 wronglen:
     ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
 }

 static void ctrl_data_handler(uint32_t events) {
     if (events & EPOLLHUP) {
         ALOGI("ActivityManager disconnected");
         if (!ctrl_dfd_reopened)
             ctrl_data_close();
     } else if (events & EPOLLIN) {
         ctrl_command_handler();
     }
 }

 static void ctrl_connect_handler(uint32_t events __unused) {
     struct sockaddr_storage ss;
     struct sockaddr *addrp = (struct sockaddr *)&ss;
     socklen_t alen;
     struct epoll_event epev;

     if (ctrl_dfd >= 0) {
         ctrl_data_close();
         ctrl_dfd_reopened = 1;
     }

     alen = sizeof(ss);
     ctrl_dfd = accept(ctrl_lfd, addrp, &alen);

     if (ctrl_dfd < 0) {
         ALOGE("lmkd control socket accept failed; errno=%d", errno);
         return;
     }

     ALOGI("ActivityManager connected");
     maxevents++;
     epev.events = EPOLLIN;
     epev.data.ptr = (void *)ctrl_data_handler;
     if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_dfd, &epev) == -1) {
         ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
         ctrl_data_close();
         return;
     }
 }

 static int zoneinfo_parse_protection(char *cp) {
     int max = 0;
     int zoneval;
     char *save_ptr;

     for (cp = strtok_r(cp, "(), ", &save_ptr); cp; cp = strtok_r(NULL, "), ", &save_ptr)) {
         zoneval = strtol(cp, &cp, 0);
         if (zoneval > max)
             max = zoneval;
     }

     return max;
 }

 static void zoneinfo_parse_line(char *line, struct sysmeminfo *mip) {
     char *cp = line;
     char *ap;
     char *save_ptr;

     cp = strtok_r(line, " ", &save_ptr);
     if (!cp)
         return;

     ap = strtok_r(NULL, " ", &save_ptr);
     if (!ap)
         return;

     if (!strcmp(cp, "nr_free_pages"))
         mip->nr_free_pages += strtol(ap, NULL, 0);
     else if (!strcmp(cp, "nr_file_pages"))
         mip->nr_file_pages += strtol(ap, NULL, 0);
     else if (!strcmp(cp, "nr_shmem"))
         mip->nr_shmem += strtol(ap, NULL, 0);
     else if (!strcmp(cp, "high"))
         mip->totalreserve_pages += strtol(ap, NULL, 0);
     else if (!strcmp(cp, "protection:"))
         mip->totalreserve_pages += zoneinfo_parse_protection(ap);
 }

 static int zoneinfo_parse(struct sysmeminfo *mip) {
     int fd;
     ssize_t size;
     char buf[PAGE_SIZE];
     char *save_ptr;
     char *line;

     memset(mip, 0, sizeof(struct sysmeminfo));

     fd = open(ZONEINFO_PATH, O_RDONLY | O_CLOEXEC);
     if (fd == -1) {
         ALOGE("%s open: errno=%d", ZONEINFO_PATH, errno);
         return -1;
     }

     size = read_all(fd, buf, sizeof(buf) - 1);
     if (size < 0) {
         ALOGE("%s read: errno=%d", ZONEINFO_PATH, errno);
         close(fd);
         return -1;
     }
     ALOG_ASSERT((size_t)size < sizeof(buf) - 1, "/proc/zoneinfo too large");
     buf[size] = 0;

     for (line = strtok_r(buf, "\n", &save_ptr); line; line = strtok_r(NULL, "\n", &save_ptr))
             zoneinfo_parse_line(line, mip);

     close(fd);
     return 0;
 }

 static int proc_get_size(int pid) {
     char path[PATH_MAX];
     char line[LINE_MAX];
     int fd;
     int rss = 0;
     int total;
     ssize_t ret;

     snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
     fd = open(path, O_RDONLY | O_CLOEXEC);
     if (fd == -1)
         return -1;

     ret = read_all(fd, line, sizeof(line) - 1);
     if (ret < 0) {
         close(fd);
         return -1;
     }

     sscanf(line, "%d %d ", &total, &rss);
     close(fd);
     return rss;
 }

 static char *proc_get_name(int pid) {
     char path[PATH_MAX];
     static char line[LINE_MAX];
     int fd;
     char *cp;
     ssize_t ret;

     snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
     fd = open(path, O_RDONLY | O_CLOEXEC);
     if (fd == -1)
         return NULL;
     ret = read_all(fd, line, sizeof(line) - 1);
     close(fd);
     if (ret < 0) {
         return NULL;
     }

     cp = strchr(line, ' ');
     if (cp)
         *cp = '\0';

     return line;
 }

 static struct proc *proc_adj_lru(int oomadj) {
     return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
 }

 /* Kill one process specified by procp.  Returns the size of the process killed */
 static int kill_one_process(struct proc *procp, int other_free, int other_file,
         int minfree, int min_score_adj, bool first)
 {
     int pid = procp->pid;
     uid_t uid = procp->uid;
     char *taskname;
     int tasksize;
     int r;

     taskname = proc_get_name(pid);
     if (!taskname) {
         pid_remove(pid);
         return -1;
     }

     tasksize = proc_get_size(pid);
     if (tasksize <= 0) {
         pid_remove(pid);
         return -1;
     }

     ALOGI("Killing '%s' (%d), uid %d, adj %d\n"
           "   to free %ldkB because cache %s%ldkB is below limit %ldkB for oom_adj %d\n"
           "   Free memory is %s%ldkB %s reserved",
           taskname, pid, uid, procp->oomadj, tasksize * page_k,
           first ? "" : "~", other_file * page_k, minfree * page_k, min_score_adj,
           first ? "" : "~", other_free * page_k, other_free >= 0 ? "above" : "below");
     r = kill(pid, SIGKILL);
     killProcessGroup(uid, pid, SIGKILL);
     pid_remove(pid);

     if (r) {
         ALOGE("kill(%d): errno=%d", procp->pid, errno);
         return -1;
     } else {
         return tasksize;
     }
 }

 /*
  * Find a process to kill based on the current (possibly estimated) free memory
  * and cached memory sizes.  Returns the size of the killed processes.
  */
 static int find_and_kill_process(int other_free, int other_file, bool first)
 {
     int i;
     int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
     int minfree = 0;
     int killed_size = 0;

     for (i = 0; i < lowmem_targets_size; i++) {
         minfree = lowmem_minfree[i];
         if (other_free < minfree && other_file < minfree) {
             min_score_adj = lowmem_adj[i];
             break;
         }
     }

     if (min_score_adj == OOM_SCORE_ADJ_MAX + 1)
         return 0;

     for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
         struct proc *procp;

 retry:
         procp = proc_adj_lru(i);

         if (procp) {
             killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
             if (killed_size < 0) {
                 goto retry;
             } else {
                 return killed_size;
             }
         }
     }

     return 0;
 }

 static void mp_event(uint32_t events __unused) {
     int ret;
     unsigned long long evcount;
     struct sysmeminfo mi;
     int other_free;
     int other_file;
     int killed_size;
     bool first = true;

     ret = read(mpevfd, &evcount, sizeof(evcount));
     if (ret < 0)
         ALOGE("Error reading memory pressure event fd; errno=%d",
               errno);

     if (time(NULL) - kill_lasttime < KILL_TIMEOUT)
         return;

     while (zoneinfo_parse(&mi) < 0) {
         // Failed to read /proc/zoneinfo, assume ENOMEM and kill something
         find_and_kill_process(0, 0, true);
     }

     other_free = mi.nr_free_pages - mi.totalreserve_pages;
     other_file = mi.nr_file_pages - mi.nr_shmem;

     do {
         killed_size = find_and_kill_process(other_free, other_file, first);
         if (killed_size > 0) {
             first = false;
             other_free += killed_size;
             other_file += killed_size;
         }
     } while (killed_size > 0);
 }

 static int init_mp(char *levelstr, void *event_handler)
 {
     int mpfd;
     int evfd;
     int evctlfd;
     char buf[256];
     struct epoll_event epev;
     int ret;

     mpfd = open(MEMCG_SYSFS_PATH "memory.pressure_level", O_RDONLY | O_CLOEXEC);
     if (mpfd < 0) {
         ALOGI("No kernel memory.pressure_level support (errno=%d)", errno);
         goto err_open_mpfd;
     }

     evctlfd = open(MEMCG_SYSFS_PATH "cgroup.event_control", O_WRONLY | O_CLOEXEC);
     if (evctlfd < 0) {
         ALOGI("No kernel memory cgroup event control (errno=%d)", errno);
         goto err_open_evctlfd;
     }

     evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
     if (evfd < 0) {
         ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
         goto err_eventfd;
     }

     ret = snprintf(buf, sizeof(buf), "%d %d %s", evfd, mpfd, levelstr);
     if (ret >= (ssize_t)sizeof(buf)) {
         ALOGE("cgroup.event_control line overflow for level %s", levelstr);
         goto err;
     }

     ret = write(evctlfd, buf, strlen(buf) + 1);
     if (ret == -1) {
         ALOGE("cgroup.event_control write failed for level %s; errno=%d",
               levelstr, errno);
         goto err;
     }

     epev.events = EPOLLIN;
     epev.data.ptr = event_handler;
     ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, evfd, &epev);
     if (ret == -1) {
         ALOGE("epoll_ctl for level %s failed; errno=%d", levelstr, errno);
         goto err;
     }
     maxevents++;
     mpevfd = evfd;
     return 0;

 err:
     close(evfd);
 err_eventfd:
     close(evctlfd);
 err_open_evctlfd:
     close(mpfd);
 err_open_mpfd:
     return -1;
 }

 static int init(void) {
     struct epoll_event epev;
     int i;
     int ret;

     page_k = sysconf(_SC_PAGESIZE);
     if (page_k == -1)
         page_k = PAGE_SIZE;
     page_k /= 1024;

     epollfd = epoll_create(MAX_EPOLL_EVENTS);
     if (epollfd == -1) {
         ALOGE("epoll_create failed (errno=%d)", errno);
         return -1;
     }

     ctrl_lfd = android_get_control_socket("lmkd");
     if (ctrl_lfd < 0) {
         ALOGE("get lmkd control socket failed");
         return -1;
     }

     ret = listen(ctrl_lfd, 1);
     if (ret < 0) {
         ALOGE("lmkd control socket listen failed (errno=%d)", errno);
         return -1;
     }

     epev.events = EPOLLIN;
     epev.data.ptr = (void *)ctrl_connect_handler;
     if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
         ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
         return -1;
     }
     maxevents++;

     use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);

     if (use_inkernel_interface) {
         ALOGI("Using in-kernel low memory killer interface");
     } else {
         ret = init_mp(MEMPRESSURE_WATCH_LEVEL, (void *)&mp_event);
         if (ret)
             ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
     }

     for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
         procadjslot_list[i].next = &procadjslot_list[i];
         procadjslot_list[i].prev = &procadjslot_list[i];
     }

     return 0;
 }

 static void mainloop(void) {
     while (1) {
         struct epoll_event events[maxevents];
         int nevents;
         int i;

         ctrl_dfd_reopened = 0;
         nevents = epoll_wait(epollfd, events, maxevents, -1);

         if (nevents == -1) {
             if (errno == EINTR)
                 continue;
             ALOGE("epoll_wait failed (errno=%d)", errno);
             continue;
         }

         for (i = 0; i < nevents; ++i) {
             if (events[i].events & EPOLLERR)
                 ALOGD("EPOLLERR on event #%d", i);
             if (events[i].data.ptr)
                 (*(void (*)(uint32_t))events[i].data.ptr)(events[i].events);
         }
     }
 }

 int main(int argc __unused, char **argv __unused) {
     struct sched_param param = {
             .sched_priority = 1,
     };

     mlockall(MCL_FUTURE);
     sched_setscheduler(0, SCHED_FIFO, &param);
     if (!init())
         mainloop();

     ALOGI("exiting");
     return 0;
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "lowmemorykiller"

	#include <arpa/inet.h>
	#include <errno.h>
	#include <signal.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include <sys/cdefs.h>
	#include <sys/epoll.h>
	#include <sys/eventfd.h>
	#include <sys/mman.h>
	#include <sys/socket.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <cutils/sockets.h>
	#include <log/log.h>
	#include <processgroup/processgroup.h>

	#ifndef __unused
	#define __unused __attribute__((__unused__))
	#endif

	#define MEMCG_SYSFS_PATH "/dev/memcg/"
	#define MEMPRESSURE_WATCH_LEVEL "low"
	#define ZONEINFO_PATH "/proc/zoneinfo"
	#define LINE_MAX 128

	#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
	#define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"

	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))

	enum lmk_cmd {
	LMK_TARGET,
	LMK_PROCPRIO,
	LMK_PROCREMOVE,
	};

	#define MAX_TARGETS 6
	/*
	* longest is LMK_TARGET followed by MAX_TARGETS each minfree and minkillprio
	* values
	*/
	#define CTRL_PACKET_MAX (sizeof(int) * (MAX_TARGETS * 2 + 1))

	/* default to old in-kernel interface if no memory pressure events */
	static int use_inkernel_interface = 1;

	/* memory pressure level medium event */
	static int mpevfd;

	/* control socket listen and data */
	static int ctrl_lfd;
	static int ctrl_dfd = -1;
	static int ctrl_dfd_reopened; /* did we reopen ctrl conn on this loop? */

	/* 1 memory pressure level, 1 ctrl listen socket, 1 ctrl data socket */
	#define MAX_EPOLL_EVENTS 3
	static int epollfd;
	static int maxevents;

	/* OOM score values used by both kernel and framework */
	#define OOM_SCORE_ADJ_MIN (-1000)
	#define OOM_SCORE_ADJ_MAX 1000

	static int lowmem_adj[MAX_TARGETS];
	static int lowmem_minfree[MAX_TARGETS];
	static int lowmem_targets_size;

	struct sysmeminfo {
	int nr_free_pages;
	int nr_file_pages;
	int nr_shmem;
	int totalreserve_pages;
	};

	struct adjslot_list {
	struct adjslot_list *next;
	struct adjslot_list *prev;
	};

	struct proc {
	struct adjslot_list asl;
	int pid;
	uid_t uid;
	int oomadj;
	struct proc *pidhash_next;
	};

	#define PIDHASH_SZ 1024
	static struct proc *pidhash[PIDHASH_SZ];
	#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))

	#define ADJTOSLOT(adj) (adj + -OOM_SCORE_ADJ_MIN)
	static struct adjslot_list procadjslot_list[ADJTOSLOT(OOM_SCORE_ADJ_MAX) + 1];

	/*
	* Wait 1-2 seconds for the death report of a killed process prior to
	* considering killing more processes.
	*/
	#define KILL_TIMEOUT 2
	/* Time of last process kill we initiated, stop me before I kill again */
	static time_t kill_lasttime;

	/* PAGE_SIZE / 1024 */
	static long page_k;

	static ssize_t read_all(int fd, char *buf, size_t max_len)
	{
	ssize_t ret = 0;

	while (max_len > 0) {
	ssize_t r = read(fd, buf, max_len);
	if (r == 0) {
	break;
	}
	if (r == -1) {
	return -1;
	}
	ret += r;
	buf += r;
	max_len -= r;
	}

	return ret;
	}

	static struct proc *pid_lookup(int pid) {
	struct proc *procp;

	for (procp = pidhash[pid_hashfn(pid)]; procp && procp->pid != pid;
	procp = procp->pidhash_next)
	;

	return procp;
	}

	static void adjslot_insert(struct adjslot_list head, struct adjslot_list new)
	{
	struct adjslot_list *next = head->next;
	new->prev = head;
	new->next = next;
	next->prev = new;
	head->next = new;
	}

	static void adjslot_remove(struct adjslot_list *old)
	{
	struct adjslot_list *prev = old->prev;
	struct adjslot_list *next = old->next;
	next->prev = prev;
	prev->next = next;
	}

	static struct adjslot_list adjslot_tail(struct adjslot_list head) {
	struct adjslot_list *asl = head->prev;

	return asl == head ? NULL : asl;
	}

	static void proc_slot(struct proc *procp) {
	int adjslot = ADJTOSLOT(procp->oomadj);

	adjslot_insert(&procadjslot_list[adjslot], &procp->asl);
	}

	static void proc_unslot(struct proc *procp) {
	adjslot_remove(&procp->asl);
	}

	static void proc_insert(struct proc *procp) {
	int hval = pid_hashfn(procp->pid);

	procp->pidhash_next = pidhash[hval];
	pidhash[hval] = procp;
	proc_slot(procp);
	}

	static int pid_remove(int pid) {
	int hval = pid_hashfn(pid);
	struct proc *procp;
	struct proc *prevp;

	for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
	procp = procp->pidhash_next)
	prevp = procp;

	if (!procp)
	return -1;

	if (!prevp)
	pidhash[hval] = procp->pidhash_next;
	else
	prevp->pidhash_next = procp->pidhash_next;

	proc_unslot(procp);
	free(procp);
	return 0;
	}

	static void writefilestring(char path, char s) {
	int fd = open(path, O_WRONLY \| O_CLOEXEC);
	int len = strlen(s);
	int ret;

	if (fd < 0) {
	ALOGE("Error opening %s; errno=%d", path, errno);
	return;
	}

	ret = write(fd, s, len);
	if (ret < 0) {
	ALOGE("Error writing %s; errno=%d", path, errno);
	} else if (ret < len) {
	ALOGE("Short write on %s; length=%d", path, ret);
	}

	close(fd);
	}

	static void cmd_procprio(int pid, int uid, int oomadj) {
	struct proc *procp;
	char path[80];
	char val[20];

	if (oomadj < OOM_SCORE_ADJ_MIN \|\| oomadj > OOM_SCORE_ADJ_MAX) {
	ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
	return;
	}

	snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
	snprintf(val, sizeof(val), "%d", oomadj);
	writefilestring(path, val);

	if (use_inkernel_interface)
	return;

	procp = pid_lookup(pid);
	if (!procp) {
	procp = malloc(sizeof(struct proc));
	if (!procp) {
	// Oh, the irony. May need to rebuild our state.
	return;
	}

	procp->pid = pid;
	procp->uid = uid;
	procp->oomadj = oomadj;
	proc_insert(procp);
	} else {
	proc_unslot(procp);
	procp->oomadj = oomadj;
	proc_slot(procp);
	}
	}

	static void cmd_procremove(int pid) {
	if (use_inkernel_interface)
	return;

	pid_remove(pid);
	kill_lasttime = 0;
	}

	static void cmd_target(int ntargets, int *params) {
	int i;

	if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
	return;

	for (i = 0; i < ntargets; i++) {
	lowmem_minfree[i] = ntohl(*params++);
	lowmem_adj[i] = ntohl(*params++);
	}

	lowmem_targets_size = ntargets;

	if (use_inkernel_interface) {
	char minfreestr[128];
	char killpriostr[128];

	minfreestr[0] = '\0';
	killpriostr[0] = '\0';

	for (i = 0; i < lowmem_targets_size; i++) {
	char val[40];

	if (i) {
	strlcat(minfreestr, ",", sizeof(minfreestr));
	strlcat(killpriostr, ",", sizeof(killpriostr));
	}

	snprintf(val, sizeof(val), "%d", lowmem_minfree[i]);
	strlcat(minfreestr, val, sizeof(minfreestr));
	snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
	strlcat(killpriostr, val, sizeof(killpriostr));
	}

	writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
	writefilestring(INKERNEL_ADJ_PATH, killpriostr);
	}
	}

	static void ctrl_data_close(void) {
	ALOGI("Closing Activity Manager data connection");
	close(ctrl_dfd);
	ctrl_dfd = -1;
	maxevents--;
	}

	static int ctrl_data_read(char *buf, size_t bufsz) {
	int ret = 0;

	ret = read(ctrl_dfd, buf, bufsz);

	if (ret == -1) {
	ALOGE("control data socket read failed; errno=%d", errno);
	} else if (ret == 0) {
	ALOGE("Got EOF on control data socket");
	ret = -1;
	}

	return ret;
	}

	static void ctrl_command_handler(void) {
	int ibuf[CTRL_PACKET_MAX / sizeof(int)];
	int len;
	int cmd = -1;
	int nargs;
	int targets;

	len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
	if (len <= 0)
	return;

	nargs = len / sizeof(int) - 1;
	if (nargs < 0)
	goto wronglen;

	cmd = ntohl(ibuf[0]);

	switch(cmd) {
	case LMK_TARGET:
	targets = nargs / 2;
	if (nargs & 0x1 \|\| targets > (int)ARRAY_SIZE(lowmem_adj))
	goto wronglen;
	cmd_target(targets, &ibuf[1]);
	break;
	case LMK_PROCPRIO:
	if (nargs != 3)
	goto wronglen;
	cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
	break;
	case LMK_PROCREMOVE:
	if (nargs != 1)
	goto wronglen;
	cmd_procremove(ntohl(ibuf[1]));
	break;
	default:
	ALOGE("Received unknown command code %d", cmd);
	return;
	}

	return;

	wronglen:
	ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
	}

	static void ctrl_data_handler(uint32_t events) {
	if (events & EPOLLHUP) {
	ALOGI("ActivityManager disconnected");
	if (!ctrl_dfd_reopened)
	ctrl_data_close();
	} else if (events & EPOLLIN) {
	ctrl_command_handler();
	}
	}

	static void ctrl_connect_handler(uint32_t events __unused) {
	struct sockaddr_storage ss;
	struct sockaddr addrp = (struct sockaddr )&ss;
	socklen_t alen;
	struct epoll_event epev;

	if (ctrl_dfd >= 0) {
	ctrl_data_close();
	ctrl_dfd_reopened = 1;
	}

	alen = sizeof(ss);
	ctrl_dfd = accept(ctrl_lfd, addrp, &alen);

	if (ctrl_dfd < 0) {
	ALOGE("lmkd control socket accept failed; errno=%d", errno);
	return;
	}

	ALOGI("ActivityManager connected");
	maxevents++;
	epev.events = EPOLLIN;
	epev.data.ptr = (void *)ctrl_data_handler;
	if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_dfd, &epev) == -1) {
	ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
	ctrl_data_close();
	return;
	}
	}

	static int zoneinfo_parse_protection(char *cp) {
	int max = 0;
	int zoneval;
	char *save_ptr;

	for (cp = strtok_r(cp, "(), ", &save_ptr); cp; cp = strtok_r(NULL, "), ", &save_ptr)) {
	zoneval = strtol(cp, &cp, 0);
	if (zoneval > max)
	max = zoneval;
	}

	return max;
	}

	static void zoneinfo_parse_line(char line, struct sysmeminfo mip) {
	char *cp = line;
	char *ap;
	char *save_ptr;

	cp = strtok_r(line, " ", &save_ptr);
	if (!cp)
	return;

	ap = strtok_r(NULL, " ", &save_ptr);
	if (!ap)
	return;

	if (!strcmp(cp, "nr_free_pages"))
	mip->nr_free_pages += strtol(ap, NULL, 0);
	else if (!strcmp(cp, "nr_file_pages"))
	mip->nr_file_pages += strtol(ap, NULL, 0);
	else if (!strcmp(cp, "nr_shmem"))
	mip->nr_shmem += strtol(ap, NULL, 0);
	else if (!strcmp(cp, "high"))
	mip->totalreserve_pages += strtol(ap, NULL, 0);
	else if (!strcmp(cp, "protection:"))
	mip->totalreserve_pages += zoneinfo_parse_protection(ap);
	}

	static int zoneinfo_parse(struct sysmeminfo *mip) {
	int fd;
	ssize_t size;
	char buf[PAGE_SIZE];
	char *save_ptr;
	char *line;

	memset(mip, 0, sizeof(struct sysmeminfo));

	fd = open(ZONEINFO_PATH, O_RDONLY \| O_CLOEXEC);
	if (fd == -1) {
	ALOGE("%s open: errno=%d", ZONEINFO_PATH, errno);
	return -1;
	}

	size = read_all(fd, buf, sizeof(buf) - 1);
	if (size < 0) {
	ALOGE("%s read: errno=%d", ZONEINFO_PATH, errno);
	close(fd);
	return -1;
	}
	ALOG_ASSERT((size_t)size < sizeof(buf) - 1, "/proc/zoneinfo too large");
	buf[size] = 0;

	for (line = strtok_r(buf, "\n", &save_ptr); line; line = strtok_r(NULL, "\n", &save_ptr))
	zoneinfo_parse_line(line, mip);

	close(fd);
	return 0;
	}

	static int proc_get_size(int pid) {
	char path[PATH_MAX];
	char line[LINE_MAX];
	int fd;
	int rss = 0;
	int total;
	ssize_t ret;

	snprintf(path, PATH_MAX, "/proc/%d/statm", pid);
	fd = open(path, O_RDONLY \| O_CLOEXEC);
	if (fd == -1)
	return -1;

	ret = read_all(fd, line, sizeof(line) - 1);
	if (ret < 0) {
	close(fd);
	return -1;
	}

	sscanf(line, "%d %d ", &total, &rss);
	close(fd);
	return rss;
	}

	static char *proc_get_name(int pid) {
	char path[PATH_MAX];
	static char line[LINE_MAX];
	int fd;
	char *cp;
	ssize_t ret;

	snprintf(path, PATH_MAX, "/proc/%d/cmdline", pid);
	fd = open(path, O_RDONLY \| O_CLOEXEC);
	if (fd == -1)
	return NULL;
	ret = read_all(fd, line, sizeof(line) - 1);
	close(fd);
	if (ret < 0) {
	return NULL;
	}

	cp = strchr(line, ' ');
	if (cp)
	*cp = '\0';

	return line;
	}

	static struct proc *proc_adj_lru(int oomadj) {
	return (struct proc *)adjslot_tail(&procadjslot_list[ADJTOSLOT(oomadj)]);
	}

	/* Kill one process specified by procp. Returns the size of the process killed */
	static int kill_one_process(struct proc *procp, int other_free, int other_file,
	int minfree, int min_score_adj, bool first)
	{
	int pid = procp->pid;
	uid_t uid = procp->uid;
	char *taskname;
	int tasksize;
	int r;

	taskname = proc_get_name(pid);
	if (!taskname) {
	pid_remove(pid);
	return -1;
	}

	tasksize = proc_get_size(pid);
	if (tasksize <= 0) {
	pid_remove(pid);
	return -1;
	}

	ALOGI("Killing '%s' (%d), uid %d, adj %d\n"
	" to free %ldkB because cache %s%ldkB is below limit %ldkB for oom_adj %d\n"
	" Free memory is %s%ldkB %s reserved",
	taskname, pid, uid, procp->oomadj, tasksize * page_k,
	first ? "" : "~", other_file * page_k, minfree * page_k, min_score_adj,
	first ? "" : "~", other_free * page_k, other_free >= 0 ? "above" : "below");
	r = kill(pid, SIGKILL);
	killProcessGroup(uid, pid, SIGKILL);
	pid_remove(pid);

	if (r) {
	ALOGE("kill(%d): errno=%d", procp->pid, errno);
	return -1;
	} else {
	return tasksize;
	}
	}

	/*
	* Find a process to kill based on the current (possibly estimated) free memory
	* and cached memory sizes. Returns the size of the killed processes.
	*/
	static int find_and_kill_process(int other_free, int other_file, bool first)
	{
	int i;
	int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
	int minfree = 0;
	int killed_size = 0;

	for (i = 0; i < lowmem_targets_size; i++) {
	minfree = lowmem_minfree[i];
	if (other_free < minfree && other_file < minfree) {
	min_score_adj = lowmem_adj[i];
	break;
	}
	}

	if (min_score_adj == OOM_SCORE_ADJ_MAX + 1)
	return 0;

	for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
	struct proc *procp;

	retry:
	procp = proc_adj_lru(i);

	if (procp) {
	killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
	if (killed_size < 0) {
	goto retry;
	} else {
	return killed_size;
	}
	}
	}

	return 0;
	}

	static void mp_event(uint32_t events __unused) {
	int ret;
	unsigned long long evcount;
	struct sysmeminfo mi;
	int other_free;
	int other_file;
	int killed_size;
	bool first = true;

	ret = read(mpevfd, &evcount, sizeof(evcount));
	if (ret < 0)
	ALOGE("Error reading memory pressure event fd; errno=%d",
	errno);

	if (time(NULL) - kill_lasttime < KILL_TIMEOUT)
	return;

	while (zoneinfo_parse(&mi) < 0) {
	// Failed to read /proc/zoneinfo, assume ENOMEM and kill something
	find_and_kill_process(0, 0, true);
	}

	other_free = mi.nr_free_pages - mi.totalreserve_pages;
	other_file = mi.nr_file_pages - mi.nr_shmem;

	do {
	killed_size = find_and_kill_process(other_free, other_file, first);
	if (killed_size > 0) {
	first = false;
	other_free += killed_size;
	other_file += killed_size;
	}
	} while (killed_size > 0);
	}

	static int init_mp(char levelstr, void event_handler)
	{
	int mpfd;
	int evfd;
	int evctlfd;
	char buf[256];
	struct epoll_event epev;
	int ret;

	mpfd = open(MEMCG_SYSFS_PATH "memory.pressure_level", O_RDONLY \| O_CLOEXEC);
	if (mpfd < 0) {
	ALOGI("No kernel memory.pressure_level support (errno=%d)", errno);
	goto err_open_mpfd;
	}

	evctlfd = open(MEMCG_SYSFS_PATH "cgroup.event_control", O_WRONLY \| O_CLOEXEC);
	if (evctlfd < 0) {
	ALOGI("No kernel memory cgroup event control (errno=%d)", errno);
	goto err_open_evctlfd;
	}

	evfd = eventfd(0, EFD_NONBLOCK \| EFD_CLOEXEC);
	if (evfd < 0) {
	ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
	goto err_eventfd;
	}

	ret = snprintf(buf, sizeof(buf), "%d %d %s", evfd, mpfd, levelstr);
	if (ret >= (ssize_t)sizeof(buf)) {
	ALOGE("cgroup.event_control line overflow for level %s", levelstr);
	goto err;
	}

	ret = write(evctlfd, buf, strlen(buf) + 1);
	if (ret == -1) {
	ALOGE("cgroup.event_control write failed for level %s; errno=%d",
	levelstr, errno);
	goto err;
	}

	epev.events = EPOLLIN;
	epev.data.ptr = event_handler;
	ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, evfd, &epev);
	if (ret == -1) {
	ALOGE("epoll_ctl for level %s failed; errno=%d", levelstr, errno);
	goto err;
	}
	maxevents++;
	mpevfd = evfd;
	return 0;

	err:
	close(evfd);
	err_eventfd:
	close(evctlfd);
	err_open_evctlfd:
	close(mpfd);
	err_open_mpfd:
	return -1;
	}

	static int init(void) {
	struct epoll_event epev;
	int i;
	int ret;

	page_k = sysconf(_SC_PAGESIZE);
	if (page_k == -1)
	page_k = PAGE_SIZE;
	page_k /= 1024;

	epollfd = epoll_create(MAX_EPOLL_EVENTS);
	if (epollfd == -1) {
	ALOGE("epoll_create failed (errno=%d)", errno);
	return -1;
	}

	ctrl_lfd = android_get_control_socket("lmkd");
	if (ctrl_lfd < 0) {
	ALOGE("get lmkd control socket failed");
	return -1;
	}

	ret = listen(ctrl_lfd, 1);
	if (ret < 0) {
	ALOGE("lmkd control socket listen failed (errno=%d)", errno);
	return -1;
	}

	epev.events = EPOLLIN;
	epev.data.ptr = (void *)ctrl_connect_handler;
	if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
	ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
	return -1;
	}
	maxevents++;

	use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);

	if (use_inkernel_interface) {
	ALOGI("Using in-kernel low memory killer interface");
	} else {
	ret = init_mp(MEMPRESSURE_WATCH_LEVEL, (void *)&mp_event);
	if (ret)
	ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
	}

	for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
	procadjslot_list[i].next = &procadjslot_list[i];
	procadjslot_list[i].prev = &procadjslot_list[i];
	}

	return 0;
	}

	static void mainloop(void) {
	while (1) {
	struct epoll_event events[maxevents];
	int nevents;
	int i;

	ctrl_dfd_reopened = 0;
	nevents = epoll_wait(epollfd, events, maxevents, -1);

	if (nevents == -1) {
	if (errno == EINTR)
	continue;
	ALOGE("epoll_wait failed (errno=%d)", errno);
	continue;
	}

	for (i = 0; i < nevents; ++i) {
	if (events[i].events & EPOLLERR)
	ALOGD("EPOLLERR on event #%d", i);
	if (events[i].data.ptr)
	((void ()(uint32_t))events[i].data.ptr)(events[i].events);
	}
	}
	}

	int main(int argc __unused, char **argv __unused) {
	struct sched_param param = {
	.sched_priority = 1,
	};

	mlockall(MCL_FUTURE);
	sched_setscheduler(0, SCHED_FIFO, &param);
	if (!init())
	mainloop();

	ALOGI("exiting");
	return 0;
	}