LowMemoryKiller机制分析

概述

Linux系统当可用内存较低的时候oom killer机制会根据一定的规则去杀掉一些进程来释放内存，而Android系统的LowMemoryKiller机制就是以此功能为基础做了一些调整。Android系统中的APP在使用完成之后并不会马上被杀掉，而是驻留在内存中，当下一次在此进入此应用的时候可以省去进程创建的过程，加快启动速度。LowMemoryKiller机制会在内存资源紧张的时候，杀掉一些进程来回收内存。

整体架构

LowMemoryKiller机制分为三个部分

LowMemoryKiller整体结构图

1. AMS部分的ProcessList
2. Native进程lmkd
3. 内核中的LowMemoryKiller部分

Framework中的ProcessList和Native的lmkd进程通过Socket进行进程间通信，而lmkd和内核中的LowMemoryKiller通过writeFileString向文件节点写内容方法进行通信。

Framework层通过一定的规则调整进程的adj的值和内存空间阀值，然后通过socket发送给lmkd进程，lmkd两种处理方式， 一种将阀值写入文件节点发送给内核的LowMemoryKiller，由内核进行杀进程处理，另一种是lmkd通过cgroup监控内存使用情况，自行计算杀掉进程。

lmkd的启动和初始化

lmkd是一个native进程，由init进程启动，定义在/system/core/lmkd/lmkd.rc中

service lmkd /system/bin/lmkd
    class core
    group root readproc
    critical
    socket lmkd seqpacket 0660 system system
    writepid /dev/cpuset/system-background/tasks

在lmkd.rc中，启动了lmkd进程，并创建了一个名为lmkd的socket的描述符，用于socket进程间通信。lmkd启动后首先执行main方法。

int main(int argc __unused, char **argv __unused) {
    struct sched_param param = {
            .sched_priority = 1,
    };
    sched_setscheduler(0, SCHED_FIFO, &param);
    if (!init())
        mainloop();
}

main方法首先设置了当前进程的调度规则，然后执行了init方法和mainLoop方法。

static int init(void) {
    struct epoll_event epev;
    int i;
    int ret;
    //获取当前系统的页大小，单位kb
    page_k = sysconf(_SC_PAGESIZE);
    if (page_k == -1)
        page_k = PAGE_SIZE;
    page_k /= 1024;
    // 创建一个epollfd描述符
    epollfd = epoll_create(MAX_EPOLL_EVENTS);
    if (epollfd == -1) {
        ALOGE("epoll_create failed (errno=%d)", errno);
        return -1;
    }

    // mark data connections as not connected
    for (int i = 0; i < MAX_DATA_CONN; i++) {
        data_sock[i].sock = -1;
    }

    // 获取init.rc中创建的lmkd socket描述符
    ctrl_sock.sock = android_get_control_socket("lmkd");
    if (ctrl_sock.sock < 0) {
        ALOGE("get lmkd control socket failed");
        return -1;
    }
    
    // 监听socket的连接，即ProcessList的Socket连接
    ret = listen(ctrl_sock.sock, MAX_DATA_CONN);
    if (ret < 0) {
        ALOGE("lmkd control socket listen failed (errno=%d)", errno);
        return -1;
    }

    // Epoll 设置监听socket中的可读事件，当有可读事件的时候回调ctrl_connect_hander方法
   //处理socket连接过程
    epev.events = EPOLLIN;
    ctrl_sock.handler_info.handler = ctrl_connect_handler;
    epev.data.ptr = (void *)&(ctrl_sock.handler_info);
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_sock.sock, &epev) == -1) {
        ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
        return -1;
    }
    maxevents++;
   
    //检测内核是否支持lowMemoryKiller机制
    has_inkernel_module = !access(INKERNEL_MINFREE_PATH, W_OK);
    use_inkernel_interface = has_inkernel_module;

    //如果内核不支持LowMemoryKiller，则调用init_mp_common初始化，在lmkd中实现进程查杀过程
    if (use_inkernel_interface) {
        ALOGI("Using in-kernel low memory killer interface");
    } else {
        if (!init_mp_common(VMPRESS_LEVEL_LOW) ||
            !init_mp_common(VMPRESS_LEVEL_MEDIUM) ||
            !init_mp_common(VMPRESS_LEVEL_CRITICAL)) {
            ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
            return -1;
        }
    }

    //初始化lmkd中的进程列表
    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;
}

lmkd的init方法中做的工作

1. 获取lmkd的socket描述符
2. 创建epoll来监听socket的连接，如果有连接则回调ctrl_connect_handler方法来处理。
3. 检测是否有minfree接口，即内核是否支持lowmemorykiller,如果内核不支持则调用init_mp_common初始化，在lmkd中实现进程查杀。

为了防止剩余内存过低，Android在内核空间有lowmemorykiller(简称LMK)，LMK是通过注册shrinker来触发低内存回收的，这个机制并不太优雅，可能会拖慢Shrinkers内存扫描速度，已从内核4.12中移除，后续会采用用户空间的LMKD + memory cgroups机制

我们先分析内核实现的LowMemoryKiller进程查杀机制， 然后再分析lmkd实现的机制。两者最终的结果都是在内存紧张的时候杀死一些进程来释放内存， 但是实现机制去不太一样。

static void mainloop(void) {
    struct event_handler_info* handler_info;
    struct epoll_event *evt;

    //循环等待epoll事件的上报
    while (1) {
        struct epoll_event events[maxevents];
        int nevents;
        int i;

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

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

        //获取到对应的epoll事件，分发给对应的handler处理
        for (i = 0, evt = &events[0]; i < nevents; ++i, evt++) {
            if (evt->events & EPOLLERR)
                ALOGD("EPOLLERR on event #%d", i);
            if (evt->events & EPOLLHUP) {
                /* This case was handled in the first pass */
                continue;
            }
            if (evt->data.ptr) {
                handler_info = (struct event_handler_info*)evt->data.ptr;
                handler_info->handler(handler_info->data, evt->events);
            }
        }
    }
}

init执行初始化完成之后， 进入mainloop方法，循环等待epoll事件的上报，init的时候epoll监听的socket连接， 当有socket连接的时候就会调用ctrl_connect_handler方法。

static void ctrl_connect_handler(int data __unused, uint32_t events __unused) {
    struct epoll_event epev;
    int free_dscock_idx = get_free_dsock();

    if (free_dscock_idx < 0) {
        /*
         * Number of data connections exceeded max supported. This should not
         * happen but if it does we drop all existing connections and accept
         * the new one. This prevents inactive connections from monopolizing
         * data socket and if we drop ActivityManager connection it will
         * immediately reconnect.
         */
        for (int i = 0; i < MAX_DATA_CONN; i++) {
            ctrl_data_close(i);
        }
        free_dscock_idx = 0;
    }
    //接受framework的socket连接
    data_sock[free_dscock_idx].sock = accept(ctrl_sock.sock, NULL, NULL);
    if (data_sock[free_dscock_idx].sock < 0) {
        ALOGE("lmkd control socket accept failed; errno=%d", errno);
        return;
    }

    ALOGI("lmkd data connection established");
    //监听连接的socket通信，当socket有消息的时候会掉ctrl_data_handler方法。
    data_sock[free_dscock_idx].handler_info.data = free_dscock_idx;
    data_sock[free_dscock_idx].handler_info.handler = ctrl_data_handler;
    epev.events = EPOLLIN;
    epev.data.ptr = (void *)&(data_sock[free_dscock_idx].handler_info);
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, data_sock[free_dscock_idx].sock, &epev) == -1) {
        ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
        ctrl_data_close(free_dscock_idx);
        return;
    }
    maxevents++;
}

监听到socket连接， 我们知道此时连接lmkd的socket客户端就是framework，当有连接到来的时候accept方法返回连接的socketFD, 然后将连接的socketFD同样加入epoll中， 当socketFD中有可读消息，即framework给lmkd发送消息的时候，epoll唤醒然后会掉ctrl_data_handler方法来处理。

Framework和lmkd通信

Framework和lmkd进程通过socket来进行进程间通信，在lmkd初始化的时候，通过监听socket描述符lmkd来等待Framework发送的消息。
Framework向lmkd发送命令相关的方法有三个。

1. AMS.updateConfiguration
   更新配置，手机屏幕的尺寸和内存大小不一样，对应的最小内存阀值和adj值也不一样, 最终调用ProcessList的updateOomLevel方法向lmkd发送调整命令
2. AMS.applyOomAdjLocked AMS根据一定的规则调整进程的adj值，最用通过ProcessList的setOomAdj方法发送给lmkd调整命令
3. AMS.cleanUpApplicationRecordLocked & AMS.handleAppDiedLocked 进程死亡后，调用ProcessList的remove方法移除进程

上面的三种情况Framework最终是通过socket向lmkd发送了三种消息。

    // LMK_TARGET <minfree> <minkillprio> ... (up to 6 pairs)
    // LMK_PROCPRIO <pid> <uid> <prio>
    // LMK_PROCREMOVE <pid>
    //调整minfree和adj的值
    static final byte LMK_TARGET = 0;
    //设置对应进程的adj值
    static final byte LMK_PROCPRIO = 1;
    //移除对应进程
    static final byte LMK_PROCREMOVE = 2;

lmkd接收命令处理逻辑

static void ctrl_command_handler(int dsock_idx) {
    LMKD_CTRL_PACKET packet;
    int len;
    enum lmk_cmd cmd;
    int nargs;
    int targets;
    //从socket中读取数据
    len = ctrl_data_read(dsock_idx, (char *)packet, CTRL_PACKET_MAX_SIZE);
    if (len <= 0)
        return;

    if (len < (int)sizeof(int)) {
        ALOGE("Wrong control socket read length len=%d", len);
        return;
    }

    //解析Socket的命令和参数
    cmd = lmkd_pack_get_cmd(packet);
    nargs = len / sizeof(int) - 1;
    if (nargs < 0)
        goto wronglen;

    switch(cmd) {
    case LMK_TARGET:
        targets = nargs / 2;
        if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
            goto wronglen;
        //调整minfree和adj阀值
        cmd_target(targets, packet);
        break;
    case LMK_PROCPRIO:
        if (nargs != 3)
            goto wronglen;
        //设置对应进程的adj值
        cmd_procprio(packet);
        break;
    case LMK_PROCREMOVE:
        if (nargs != 1)
            goto wronglen;
        //移除对应的进程
        cmd_procremove(packet);
        break;
    default:
        ALOGE("Received unknown command code %d", cmd);
        return;
    }

    return;

lmkd通过epoll监听socket中是否有数据， 当接受的framework发送的socket命令之后，调用ctrl_cmmand_handler方法处理，显示解析socket中的命令和参数，根据对于的命令来调用不同的方法处理。

• cmd_target 调整最小内存阀值和adj值
• cmd_procprio 调整进程的adj值
• cmd_procremove 移除对应的进程

对于进程查杀有两种实现方式，一种是内核的LMK，通过shrinker来触发低内存回收， 另一种是lmkd通过cgroup监控内存使用情况，自行计算杀掉进程。两种实现不太一样，需要逐个分析。

内核LMK的实现

cmd_target

static void cmd_target(int ntargets, LMKD_CTRL_PACKET packet) {
    int i;
    struct lmk_target target;
    lowmem_targets_size = ntargets;

    //使用kernel中的LMK
    if (has_inkernel_module) {
        char minfreestr[128];
        char killpriostr[128];

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

        //将从framework收到的内存阀值和adj值封装成字符串，以，分隔
       //如 18432,23040,27648,32256,55296,80640 
       //0,100,200,300,900,906
        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", use_inkernel_interface ? lowmem_minfree[i] : 0);
            strlcat(minfreestr, val, sizeof(minfreestr));
            snprintf(val, sizeof(val), "%d", use_inkernel_interface ? lowmem_adj[i] : 0);
            strlcat(killpriostr, val, sizeof(killpriostr));
        }
        // 将字符串分别写入 /sys/module/lowmemorykiller/parameters/minfree
        // 和/sys/module/lowmemorykiller/parameters/adj
        writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
        writefilestring(INKERNEL_ADJ_PATH, killpriostr);
    }
}

设置内存阀值和adj的值就是将从framework收到的数据封装成字符串，通过writefilestring写入到两个文件节点，以供内核LMK使用。
/sys/module/lowmemorykiller/parameters/minfree ： 内存级别限额
/sys/module/lowmemorykiller/parameters/adj ：内存级别限额对应的要杀掉的进程的adj值.

cmd_procprio

static void cmd_procprio(LMKD_CTRL_PACKET packet) {
    struct proc *procp;
    char path[80];
    char val[20];
    int soft_limit_mult;
    struct lmk_procprio params;

    //解析进程adj相关的参数
    lmkd_pack_get_procprio(packet, &params);

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

    //将进程优先级写入到/proc/进程id/oom_score_adj文件中
    snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", params.pid);
    snprintf(val, sizeof(val), "%d", params.oomadj);
    writefilestring(path, val);

    if (use_inkernel_interface)
        return;
}

由于使用内核LMK, 所以调整进程优先级直接将优先级写入对应进程的oom_adj_score文件即可。

cmd_procremove

static void cmd_procremove(LMKD_CTRL_PACKET packet) {
    struct lmk_procremove params;

    //内核LMK,移除进程什么都不需要做，全部有内核处理
    if (use_inkernel_interface)
        return;
}

移除进程的时候不需要做任何操作

内核LowMemoryKiller的实现原理

在linux中，有一个名为kswapd的内核线程，当linux回收存放分页的时候，kswapd线程将会遍历一张shrinker链表，并执行回调，或者某个app启动，发现可用内存不足时，则内核会阻塞请求分配内存的进程分配内存的过程，并在该进程中去执行lowmemorykiller来释放内存。虽然之前没有接触过，大体的理解就是向系统注册了这个shrinker回调函数之后，当系统空闲内存页面不足时会调用这个回调函数。 struct shrinker的定义在linux/kernel/include/linux/shrinker.h中：
内核LowMemoryKiller shrinker的注册过程如下：

static struct shrinker lowmem_shrinker = {
    .scan_objects = lowmem_scan,
    .count_objects = lowmem_count,
    .seeks = DEFAULT_SEEKS * 16
};

static int __init lowmem_init(void)
{
    register_shrinker(&lowmem_shrinker);
    return 0;
}

static void __exit lowmem_exit(void)
{
    unregister_shrinker(&lowmem_shrinker);
}

注册完成之后， 在内存紧张的时候就会回调shrinker, 其中最主要的是lowmem_scan方法。具体实现如下：

static unsigned long lowmem_scan(struct shrinker *s, struct shrink_control *sc)
{
    struct task_struct *tsk;
        //选中要杀掉进程的task_struct
    struct task_struct *selected = NULL;
    unsigned long rem = 0;
    int tasksize;
    int I;
        //min_score_adj 初始值=1000
    short min_score_adj = OOM_SCORE_ADJ_MAX + 1;
    int minfree = 0;
        //要杀掉进程占用内存的大小
    int selected_tasksize = 0;
        //要杀掉进程的adj值
    short selected_oom_score_adj;
        //获取并计算剩余内存的大小
    int array_size = ARRAY_SIZE(lowmem_adj);
    int other_free = global_page_state(NR_FREE_PAGES) - totalreserve_pages;
    int other_file = global_page_state(NR_FILE_PAGES) -
                        global_page_state(NR_SHMEM) -
                        total_swapcache_pages();

        //从minfree中和adj节点中获取的数据初始化内存限额和adj
    if (lowmem_adj_size < array_size)
        array_size = lowmem_adj_size;
    if (lowmem_minfree_size < array_size)
        array_size = lowmem_minfree_size;
        //  内存限额从小到大遍历， 找到剩余内存属于哪一个阀值，并获取它对应的adj值
    for (i = 0; i < array_size; i++) {
        minfree = lowmem_minfree[i];
        if (other_free < minfree && other_file < minfree) {
            min_score_adj = lowmem_adj[i];
            break;
        }
    }

    lowmem_print(3, "lowmem_scan %lu, %x, ofree %d %d, ma %hd\n",
            sc->nr_to_scan, sc->gfp_mask, other_free,
            other_file, min_score_adj);

        //如果adj值为初始值1000，则内存情况良好无需杀掉进程
    if (min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
        lowmem_print(5, "lowmem_scan %lu, %x, return 0\n",
                 sc->nr_to_scan, sc->gfp_mask);
        return 0;
    }

    selected_oom_score_adj = min_score_adj;

    rcu_read_lock();
        //遍历进程列表
    for_each_process(tsk) {
        struct task_struct *p;
        short oom_score_adj;

        if (tsk->flags & PF_KTHREAD)
            continue;

        p = find_lock_task_mm(tsk);
        if (!p)
            continue;

        if (test_tsk_thread_flag(p, TIF_MEMDIE) &&
            time_before_eq(jiffies, lowmem_deathpending_timeout)) {
            task_unlock(p);
            rcu_read_unlock();
            return 0;
        }
                //获取进程的adj值，如果进程的adj值小于目标adj值，则继续寻找
        oom_score_adj = p->signal->oom_score_adj;
        if (oom_score_adj < min_score_adj) {
            task_unlock(p);
            continue;
        }
                //找到adj值大于目标adj的进程后，首先计算该进程占用的内存大小，
               //如果两个进程的adj一般大，则找占用内存大的一个进程
        tasksize = get_mm_rss(p->mm);
        task_unlock(p);
        if (tasksize <= 0)
            continue;
        if (selected) {
            if (oom_score_adj < selected_oom_score_adj)
                continue;
            if (oom_score_adj == selected_oom_score_adj &&
                tasksize <= selected_tasksize)
                continue;
        }
        selected = p;
        selected_tasksize = tasksize;
        selected_oom_score_adj = oom_score_adj;
        lowmem_print(2, "select '%s' (%d), adj %hd, size %d, to kill\n",
                 p->comm, p->pid, oom_score_adj, tasksize);
    }
       //将找到的进程发送SIGKILL杀掉该进程从而释放内存
    if (selected) {
        long cache_size = other_file * (long)(PAGE_SIZE / 1024);
        long cache_limit = minfree * (long)(PAGE_SIZE / 1024);
        long free = other_free * (long)(PAGE_SIZE / 1024);
        trace_lowmemory_kill(selected, cache_size, cache_limit, free);
        lowmem_print(1, "Killing '%s' (%d), adj %hd,\n" \
                "   to free %ldkB on behalf of '%s' (%d) because\n" \
                "   cache %ldkB is below limit %ldkB for oom_score_adj %hd\n" \
                "   Free memory is %ldkB above reserved\n",
                 selected->comm, selected->pid,
                 selected_oom_score_adj,
                 selected_tasksize * (long)(PAGE_SIZE / 1024),
                 current->comm, current->pid,
                 cache_size, cache_limit,
                 min_score_adj,
                 free);
        lowmem_deathpending_timeout = jiffies + HZ;
        set_tsk_thread_flag(selected, TIF_MEMDIE);
        send_sig(SIGKILL, selected, 0);
        rem += selected_tasksize;
    }

    lowmem_print(4, "lowmem_scan %lu, %x, return %lu\n",
             sc->nr_to_scan, sc->gfp_mask, rem);
    rcu_read_unlock();
    return rem;
}

内核LMK的原理很简单：首先注册了shrinker，在内存紧张的时候会触发lowmem_scan方法，这个方法要做的就是找打一个进程，然后杀掉他，释放一些内存。

1. 获取剩余内存的大小，和Minfree内存阀值做比较，找到对应的内存阀值，找到对应的adj值。
2. 遍历所有的进程，大于该adj的值的进程是要杀掉的目标进程， 但是并不是全部杀掉，而是找到adj最大的进程杀掉，如果最大adj有多个相同adj进程，则杀掉占用内存最大的一个

内核LMK的实现逻辑已经分析完了

lmkd内存查杀的实现

lmkd实现内存查实的方式是基于cgroup memory来实现的。
什么是cgroup memory?
Cgroup的memory子系统，即memory cgroup(本文以下简称memcg)，提供了对系统中一组进程的内存行为的管理，从而对整个系统中对内存有不用需求的进程或应用程序区分管理，实现更有效的资源利用和隔离。

cgroup memory相关的文件

cgroup.event_control       #用于eventfd的接口
 memory.usage_in_bytes      #显示当前已用的内存
 memory.limit_in_bytes      #设置/显示当前限制的内存额度
 memory.failcnt             #显示内存使用量达到限制值的次数
 memory.max_usage_in_bytes  #历史内存最大使用量
 memory.soft_limit_in_bytes #设置/显示当前限制的内存软额度
 memory.stat                #显示当前cgroup的内存使用情况
 memory.use_hierarchy       #设置/显示是否将子cgroup的内存使用情况统计到当前cgroup里面
 memory.force_empty         #触发系统立即尽可能的回收当前cgroup中可以回收的内存
 memory.pressure_level      #设置内存压力的通知事件，配合cgroup.event_control一起使用
 memory.swappiness          #设置和显示当前的swappiness
 memory.move_charge_at_immigrate #设置当进程移动到其他cgroup中时，它所占用的内存是否也随着移动过去
 memory.oom_control         #设置/显示oom controls相关的配置
 memory.numa_stat           #显示numa相关的内存

简单的了解了下cgroup的原理，再来看lmkd的init方法

static int init(void) {
    has_inkernel_module = !access(INKERNEL_MINFREE_PATH, W_OK);
    use_inkernel_interface = has_inkernel_module;

    if (use_inkernel_interface) {
        ALOGI("Using in-kernel low memory killer interface");
    } else {
    //如果没有使用内核LMK机制，则初始化memory pressure
        if (!init_mp_common(VMPRESS_LEVEL_LOW) ||
            !init_mp_common(VMPRESS_LEVEL_MEDIUM) ||
            !init_mp_common(VMPRESS_LEVEL_CRITICAL)) {
            ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
            return -1;
        }
    }

    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 bool init_mp_common(enum vmpressure_level level) {
    int mpfd;
    int evfd;
    int evctlfd;
    char buf[256];
    struct epoll_event epev;
    int ret;
    int level_idx = (int)level;
    const char *levelstr = level_name[level_idx];
    
    //打开pressure_level的文件节点
    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;
    }
    //打开event_control的文件节点
    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;
    }
    //创建一个eventfd
    evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
    if (evfd < 0) {
        ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
        goto err_eventfd;
    }

    //往cgroup.event_control中写入：<event_fd> <pressure_level_fd> <level>
    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 = TEMP_FAILURE_RETRY(write(evctlfd, buf, strlen(buf) + 1));
    if (ret == -1) {
        ALOGE("cgroup.event_control write failed for level %s; errno=%d",
              levelstr, errno);
        goto err;
    }
    //然后使用epoll监听evfd, 等待memory pressure_level的事件通知
    epev.events = EPOLLIN;
    /* use data to store event level */
    vmpressure_hinfo[level_idx].data = level_idx;
    vmpressure_hinfo[level_idx].handler = mp_event_common;
    epev.data.ptr = (void *)&vmpressure_hinfo[level_idx];
    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[level] = evfd;
    close(evctlfd);
    return true;

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

先了解下memory pressure_level的用法

memory.pressure_level
这个文件主要用来监控当前cgroup的内存压力，当内存压力大时（即已使用内存快达到设置的限额），在分配内存之前需要先回收部分内存，从而影响内存分配速度，影响性能，而通过监控当前cgroup的内存压力，可以在有压力的时候采取一定的行动来改善当前cgroup的性能，比如关闭当前cgroup中不重要的服务等。目前有三种压力水平：
low
意味着系统在开始为当前cgroup分配内存之前，需要先回收内存中的数据了，这时候回收的是在磁盘上有对应文件的内存数据。
medium
意味着系统已经开始频繁为当前cgroup使用交换空间了。
critical
快撑不住了，系统随时有可能kill掉cgroup中的进程。

如何配置相关的监听事件呢？和memory.oom_control类似，大概步骤如下：

利用函数eventfd(2)创建一个event_fd
打开文件memory.pressure_level，得到pressure_level_fd
往cgroup.event_control中写入这么一串：<event_fd> <pressure_level_fd> <level>
然后通过读event_fd得到通知

init_mp_common方法严格的按照pressure_level的用法，注册了pressure_level的事件回调, pressure_level分为三个等级

static const char *level_name[] = {
"low",
"medium",
"critical"
};

当内存达到相应的等级，就会回调mp_event_common方法， 由mp_event_common方法来处理。

static void mp_event_common(int data, uint32_t events __unused) {
    int ret;
    unsigned long long evcount;
    int64_t mem_usage, memsw_usage;
    int64_t mem_pressure;
    enum vmpressure_level lvl;
    union meminfo mi;
    union zoneinfo zi;
    static struct timeval last_report_tm;
    static unsigned long skip_count = 0;
    enum vmpressure_level level = (enum vmpressure_level)data;
    long other_free = 0, other_file = 0;
    int min_score_adj;
    int pages_to_free = 0;
    int minfree = 0;
    static struct reread_data mem_usage_file_data = {
        .filename = MEMCG_MEMORY_USAGE,
        .fd = -1,
    };
    static struct reread_data memsw_usage_file_data = {
        .filename = MEMCG_MEMORYSW_USAGE,
        .fd = -1,
    };

    //检查触发该方法压力类型，如果大于一种类型出发，则选择压力大的一个
    for (lvl = VMPRESS_LEVEL_LOW; lvl < VMPRESS_LEVEL_COUNT; lvl++) {
        if (mpevfd[lvl] != -1 &&
            TEMP_FAILURE_RETRY(read(mpevfd[lvl],
                               &evcount, sizeof(evcount))) > 0 &&
            evcount > 0 && lvl > level) {
            level = lvl;
        }
    }

    //获取剩余内存的大小
    if (meminfo_parse(&mi) < 0 || zoneinfo_parse(&zi) < 0) {
        ALOGE("Failed to get free memory!");
        return;
    }
 
    //使用设置的最小内存阀值
    if (use_minfree_levels) {
        int i;

        //获取剩余内存大小
        other_free = mi.field.nr_free_pages - zi.field.totalreserve_pages;
        if (mi.field.nr_file_pages > (mi.field.shmem + mi.field.unevictable + mi.field.swap_cached)) {
            other_file = (mi.field.nr_file_pages - mi.field.shmem -
                          mi.field.unevictable - mi.field.swap_cached);
        } else {
            other_file = 0;
        }
        //根据剩余内存大小，找到对应的内存阀值及adj的值
        min_score_adj = OOM_SCORE_ADJ_MAX + 1;
        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;
            }
        }

       //如果得到的adj值=1000， 则表示内存状况良好，无需查杀内存直接返回
        if (min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
            if (debug_process_killing) {
                ALOGI("Ignore %s memory pressure event "
                      "(free memory=%ldkB, cache=%ldkB, limit=%ldkB)",
                      level_name[level], other_free * page_k, other_file * page_k,
                      (long)lowmem_minfree[lowmem_targets_size - 1] * page_k);
            }
            return;
        }
         //计算要达到最大内存阀值情况下需要释放的内存大小
        /* Free up enough pages to push over the highest minfree level */
        pages_to_free = lowmem_minfree[lowmem_targets_size - 1] -
            ((other_free < other_file) ? other_free : other_file);
        goto do_kill;
    }

    if (level == VMPRESS_LEVEL_LOW) {
        record_low_pressure_levels(&mi);
    }
   //内存状况良好， 无需查杀，直接退出
    if (level_oomadj[level] > OOM_SCORE_ADJ_MAX) {
        /* Do not monitor this pressure level */
        return;
    }

    if ((mem_usage = get_memory_usage(&mem_usage_file_data)) < 0) {
        goto do_kill;
    }
    if ((memsw_usage = get_memory_usage(&memsw_usage_file_data)) < 0) {
        goto do_kill;
    }

    // Calculate percent for swappinness.
    mem_pressure = (mem_usage * 100) / memsw_usage;

    //根据一定的规则，计算出压力level
    if (enable_pressure_upgrade && level != VMPRESS_LEVEL_CRITICAL) {
        // We are swapping too much.
        if (mem_pressure < upgrade_pressure) {
            level = upgrade_level(level);
            if (debug_process_killing) {
                ALOGI("Event upgraded to %s", level_name[level]);
            }
        }
    }

    // If the pressure is larger than downgrade_pressure lmk will not
    // kill any process, since enough memory is available.
    if (mem_pressure > downgrade_pressure) {
        if (debug_process_killing) {
            ALOGI("Ignore %s memory pressure", level_name[level]);
        }
        return;
    } else if (level == VMPRESS_LEVEL_CRITICAL &&
               mem_pressure > upgrade_pressure) {
        if (debug_process_killing) {
            ALOGI("Downgrade critical memory pressure");
        }
        // Downgrade event, since enough memory available.
        level = downgrade_level(level);
    }

do_kill:
    if (low_ram_device) {
        //只杀掉一个进程
        if (find_and_kill_processes(level, level_oomadj[level], 0) == 0) {
            if (debug_process_killing) {
                ALOGI("Nothing to kill");
            }
        }
    } else {
        int pages_freed;
        //如果不使用设置的minfree内存阀值，则根据计算level对应的adj来查杀内存
        if (!use_minfree_levels) {
            /* If pressure level is less than critical and enough free swap then ignore */
            if (level < VMPRESS_LEVEL_CRITICAL &&
                mi.field.free_swap > low_pressure_mem.max_nr_free_pages) {
                if (debug_process_killing) {
                    ALOGI("Ignoring pressure since %" PRId64
                          " swap pages are available ",
                          mi.field.free_swap);
                }
                return;
            }
            //计算出需要释放的内存大小
            if (mi.field.nr_free_pages < low_pressure_mem.max_nr_free_pages) {
                pages_to_free = low_pressure_mem.max_nr_free_pages -
                    mi.field.nr_free_pages;
            } else {
                if (debug_process_killing) {
                    ALOGI("Ignoring pressure since more memory is "
                        "available (%" PRId64 ") than watermark (%" PRId64 ")",
                        mi.field.nr_free_pages, low_pressure_mem.max_nr_free_pages);
                }
                return;
            }
            min_score_adj = level_oomadj[level];
        }

       //根据min_score_adj和page_to_free来杀掉进程
       //大于min_score_adj的进程都属于目标进程，循环查杀，并累计杀掉线程释放内存的大小
       //当释放的内存大于page_to_free的大小的时候，就可以停止了
        pages_freed = find_and_kill_processes(level, min_score_adj, pages_to_free);

        if (use_minfree_levels) {
            ALOGI("Killing because cache %ldkB is below "
                  "limit %ldkB for oom_adj %d\n"
                  "   Free memory is %ldkB %s reserved",
                  other_file * page_k, minfree * page_k, min_score_adj,
                  other_free * page_k, other_free >= 0 ? "above" : "below");
        }

        if (pages_freed < pages_to_free) {
            ALOGI("Unable to free enough memory (pages to free=%d, pages freed=%d)",
                  pages_to_free, pages_freed);
        } else {
            ALOGI("Reclaimed enough memory (pages to free=%d, pages freed=%d)",
                  pages_to_free, pages_freed);
            gettimeofday(&last_report_tm, NULL);
        }
    }
}

lmkd内存查杀原理：

1. 当内存压力出发该方法的时候，读取当前的内存压力类型
2. 获取当前剩余内存的大小
3. 根据剩余内存计算要杀掉进程的adj值，以及需要释放内存的大小
   分为两种情况：
   a: 如果使用的是设置的minfree和adj值，则根据剩余内存大小找到对应的adj，和需要释放内存大小
   b:如果不使用设置的内存阀值，则根据当前压力类型计算adj，以及达到上一个等级需要释放内存大小
4. 根据以上计算的adj和需要释放内存大小来查杀内存，从大于adj的进程中开始查杀进程并释放内存，当释放内存大小达到需求 就可以停止查杀内存了。

总结

进程查杀的两种实现方式原理类似，都是注册是的回调，当内存紧张的时候根据剩余内存的adj来查杀大于该adj的内存。内核shrinker方式是只有内存紧张的时候才会去释放，而cgroup方式控制更加精细， 根据不同等级来触发内存回收。