Android lowmemorykiller分析

目录

• 概述
• lmkd
• lowmemorykiller
• 总结
   

1.概述

 Android底层还是基于Linux，在Linux中低内存是会有oom killer去杀掉一些进程去释放内存，而Android中的lowmemorykiller就是在此基础上做了一些调整来的。因为手机上的内存毕竟比较有限，而Android中APP在不使用之后并不是马上被杀掉，虽然上层ActivityManagerService中也有很多关于进程的调度以及杀进程的手段，但是毕竟还需要考虑手机剩余内存的实际情况，lowmemorykiller的作用就是当内存比较紧张的时候去及时杀掉一些ActivityManagerService还没来得及杀掉但是对用户来说不那么重要的进程，回收一些内存，保证手机的正常运行。

lowmemkiller中会涉及到几个重要的概念：
/sys/module/lowmemorykiller/parameters/minfree：里面是以”,”分割的一组数，每个数字代表一个内存级别
/sys/module/lowmemorykiller/parameters/adj：对应上面的一组数，每个数组代表一个进程优先级级别
举个例子：
/sys/module/lowmemorykiller/parameters/minfree：18432,23040,27648,32256,55296,80640
/sys/module/lowmemorykiller/parameters/adj：0,100,200,300,900,906

代表的意思：两组数一一对应，当手机内存低于80640时，就去杀掉优先级906以及以上级别的进程，当内存低于55296时，就去杀掉优先级900以及以上的进程。

对每个进程来说：
/proc/pid/oom_adj：代表当前进程的优先级，这个优先级是kernel中的优先级，这个优先级与上层的优先级之间有一个换算，文章最后会提一下。
/proc/pid/oom_score_adj：上层优先级，跟ProcessList中的优先级对应

2.init进程lmkd

代码位置:platform/system/core/lmkd/

ProcessList中定义有进程的优先级，越重要的进程的优先级越低，前台APP的优先级为0，系统APP的优先级一般都是负值，所以一般进程管理以及杀进程都是针对与上层的APP来说的，而这些进程的优先级调整都在AMS里面，AMS根据进程中的组件的状态去不断的计算每个进程的优先级，计算之后，会及时更新到对应进程的文件节点中，而这个对文件节点的更新并不是它完成的，而是lmkd，他们之间通过socket通信。
lmkd在手机中是一个常驻进程，用来处理上层ActivityManager在进行updateOomAdj之后，通过socket与lmkd进行通信，更新进程的优先级，如果必要则杀掉进程释放内存。lmkd是在init进程启动的时候启动的，在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

上层AMS跟lmkd通信主要分为三种command，每种command代表一种数据控制方式，在ProcessList以及lmkd中都有定义：

LMK_TARGET：更新/sys/module/lowmemorykiller/parameters/中的minfree以及adjLMK_PROCPRIO：更新指定进程的优先级，也就是oom_score_adjLMK_PROCREMOVE：移除进程

在开始介绍lmkd的处理逻辑之前，lmkd.c中有几个重要的变量与数据结构提前说明一下：

// 内存级别限额#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"// 不同级别内存对应要杀的的优先级#define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"// 装载上面两组数字的数组static int lowmem_adj[MAX_TARGETS];static int lowmem_minfree[MAX_TARGETS];// 三种commandenum lmk_cmd {    LMK_TARGET,    LMK_PROCPRIO,    LMK_PROCREMOVE,};// 优先级的最小值#define OOM_SCORE_ADJ_MIN       (-1000)// 优先级最大值#define OOM_SCORE_ADJ_MAX       1000// 双向链表结构体struct adjslot_list {    struct adjslot_list *next;    struct adjslot_list *prev;};// 进程在lmkd中的数据结构体struct proc {    struct adjslot_list asl;    int pid;    uid_t uid;    int oomadj;    struct proc *pidhash_next;};// 存放进程proc的hashtable，index是通过pid的计算得出static struct proc *pidhash[PIDHASH_SZ];// 根据pid计算index的hash算法#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))// 进程优先级到数组的index之间的转换// 因为进程的优先级可以是负值，但是数组的index不能为负值// 不过因为这个转换只是简单加了1000，为了方便，后面的描述中就认为是优先级直接做了index#define ADJTOSLOT(adj) (adj + -OOM_SCORE_ADJ_MIN)// table，类似hashtable，不过计算index的方式不是hash，而是oom_score_adj经过转换后直接作为index// 数组的每个元素都是双向循环链表// 进程的优先级作为数组的index// 即以进程的优先级为index，从-1000到+1000 + 1大小的数组，根据优先级，同优先级的进程index相同// 每个元素是一个双向链表，这个链表上的所有proc的优先级都相同// 这样根据优先级杀进程的时候就会非常方便，要杀指定优先级的进程可以根据优先级获取到一个进程链表，逐个去杀。static struct adjslot_list procadjslot_list[ADJTOSLOT(OOM_SCORE_ADJ_MAX) + 1];

2.1 lmkd进程启动入口

int main(int argc __unused, char **argv __unused) {    struct sched_param param = {            .sched_priority = 1,    };    // 将此进程未来使用到的所有内存都锁在物理内存中，防止内存被交换    mlockall(MCL_FUTURE);    // 设置此线程的调度策略为SCHED_FIFO，first-in-first-out，param中主要设置sched_priority    // 由于SCHED_FIFO是一种实时调度策略，在这个策略下优先级从1(low) -> 99(high)    // 实时线程通常会比普通线程有更高的优先级    sched_setscheduler(0, SCHED_FIFO, &param);    // 初始化epoll以及与ActivityManager的socket连接,等待cmd和data    if (!init())        // 进入死循环epoll_wait等待fd事件        mainloop();    ALOGI("exiting");    return 0;}

前面已经提到，这个进程存在的主要作用是跟AMS进行通信，更新oomAdj，在必要的时候杀掉进程。所以在main函数中主要就是创建了epoll以及初始化socket并连接ActivityManager，然后阻塞等待上层传递cmd以及数据过来。

2.2 init初始化

static int init(void) {    ...    // 拿到lmkd的socket fd    ctrl_lfd = android_get_control_socket("lmkd");    if (ctrl_lfd < 0) {        ALOGE("get lmkd control socket failed");        return -1;    }    // server listen    ret = listen(ctrl_lfd, 1);    if (ret < 0) {        ALOGE("lmkd control socket listen failed (errno=%d)", errno);        return -1;    }    epev.events = EPOLLIN;    // ctrl_connect_handler里面完成了soclet的accpet以及read数据，并对数据进行相应的处理    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++;    // 使用kernel空间的处理    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;}

在初始化的时候，有一个很重要的判断：use_inkernel_interface，这个是根据是否有/sys/module/lowmemorykiller/parameters/minfree的写权限来判断的，没有的情况下就使用kernel空间的逻辑
目前遇到的都是use_inkernel_interface
如果use_inkernel_interface的值为false：

// 不使用kernel interface时，init_mp初始化static int init_mp(char *levelstr, void *event_handler){    ...    // 读取文件节点/dev/memcg/下的属性值 -- memory.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;    }    // 写入cgroup.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;    }    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;}// 获取手机当前的内存状态，如果内存匹配minfree中的等级，则开始杀该等级对应的优先级的进程static void mp_event(uint32_t events __unused) {    ...    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        // 通过read /proc/zoneinfo，获取当前的内存状态        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);}

2.3 进入loop循环mainloop

// 进入死循环，然后调用epoll_wait阻塞等待事件的到来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);        }    }}

2.4 处理socket传递过来的数据ctrl_command_handler

前面在ctrl_connect_handler这个方法中处理了accept，并开始了ctrl_data_handler中读取数据并进行处理：ctrl_command_handler。对于ActivityManager传递来的Command以及data的主要处理逻辑就在ctrl_command_handler中。

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]);    // 一共三种command，在前面静态变量的定义处已经介绍过    switch(cmd) {    // 更新内存级别以及对应级别的进程adj    case LMK_TARGET:        targets = nargs / 2;        if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))            goto wronglen;        cmd_target(targets, &ibuf[1]);        break;    // 根据pid更新adj    case LMK_PROCPRIO:        if (nargs != 3)            goto wronglen;        cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));        break;    // 根据pid移除proc    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);}

上层代码的调用时机这里就不细化了，往前追的话基本都是在ActivityManagerService中的udpateOomAdj中，也就是说上层根据四大组件的状态对进程的优先级进行调整之后，会及时的反应到lmkd中，在内存不足的时候触发杀进程，会从低优先级开始杀进程。command一共有三种，在上层的代码是在ProcessList中。

2.4.1 LMK_TARGET

// 上层逻辑是在ProcessList.updateOomLevels中ByteBuffer buf = ByteBuffer.allocate(4 * (2*mOomAdj.length + 1));buf.putInt(LMK_TARGET);for (int i=0; i<mOomAdj.length; i++) {    buf.putInt((mOomMinFree[i]*1024)/PAGE_SIZE);    buf.putInt(mOomAdj[i]);}writeLmkd(buf)// lmkd处理逻辑static void cmd_target(int ntargets, int *params) {    int i;    if (ntargets > (int)ARRAY_SIZE(lowmem_adj))        return;    // 这个for循环对应上面的for循环，将数据读出装进数组中    for (i = 0; i < ntargets; i++) {        lowmem_minfree[i] = ntohl(*params++);        lowmem_adj[i] = ntohl(*params++);    }    lowmem_targets_size = ntargets;    // 使用kernel空间的处理逻辑    if (use_inkernel_interface) {        char minfreestr[128];        char killpriostr[128];        minfreestr[0] = '\0';        killpriostr[0] = '\0';        // 取出两个数组中的数据，以","分隔，分别拼接成string        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));        }        // 将生成好的string写入到文件节点minfree以及adj        writefilestring(INKERNEL_MINFREE_PATH, minfreestr);        writefilestring(INKERNEL_ADJ_PATH, killpriostr);    }}

上面的处理逻辑主要是：
1. 按照顺序取出数据，装进lmkd的数组中。
2. 分别将两个数组中的数取出，用”,”分隔
3. lowmem_minfree中的数据拼成的string写到 “/sys/module/lowmemorykiller/parameters/minfree”
4. lowmem_adj中的数据拼成的string写到 “/sys/module/lowmemorykiller/parameters/adj”

2.4.2 LMK_PROCPRIO

// 上层逻辑是在ProcessList.setOomAdj中public static final void setOomAdj(int pid, int uid, int amt) {    if (amt == UNKNOWN_ADJ)        return;    long start = SystemClock.elapsedRealtime();    ByteBuffer buf = ByteBuffer.allocate(4 * 4);    buf.putInt(LMK_PROCPRIO);    buf.putInt(pid);    buf.putInt(uid);    buf.putInt(amt);    writeLmkd(buf);    long now = SystemClock.elapsedRealtime();    if ((now-start) > 250) {        Slog.w("ActivityManager", "SLOW OOM ADJ: " + (now-start) + "ms for pid " + pid                + " = " + amt);    }}// lmkd处理逻辑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;    }    // LMK_PROCPRIO的主要作用就是更新进程的oomAdj    // 将上层传递过来的数据（pid以及优先级）写到该进程对应的文件节点    // /proc/pid/oom_score_adj    snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);    snprintf(val, sizeof(val), "%d", oomadj);    writefilestring(path, val);    // 如果使用kernel的使用逻辑，return    // 即这个command传递过来只是更新了对应文件节点的oom_score_adj    if (use_inkernel_interface)        return;    // 从hashtable中查找proc    procp = pid_lookup(pid);    // 如果没有查找到，也就是说这个进程是新创建的，lmkd维护的数据结构中还没有这个proc，因此需要新建并添加到hashtable中    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插入到lmkd中的数据结构中，主要包括两个数据结构            // 更新hashtable，通过pid计算hash值，然后存储，解决冲突是让新来的作为数组元素链表的头结点            // 优先级为index的双向链表组成的table            proc_insert(procp);    } else {        // hashtable中已经有这个proc        // 但是因为优先级的变化，需要先把这个proc从原先的优先级table中对应位置的双向链表中remove        // 然后新加到新的优先级对应的双向链表中        // 双向链表的添加是新来的放在头部        proc_unslot(procp);        procp->oomadj = oomadj;        proc_slot(procp);    }}// 其中pid_lookup：查询hashtable，因为进程的pid是唯一的，然后从中取出该pid在lmkd中的proc结构体。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;}

2.4.3 LMK_PROCREMOVE

// 上层处理逻辑在ProcessList.remove中public static final void remove(int pid) {    ByteBuffer buf = ByteBuffer.allocate(4 * 2);    buf.putInt(LMK_PROCREMOVE);    buf.putInt(pid);    writeLmkd(buf);}// lmkd处理逻辑static void cmd_procremove(int pid) {    // 如果使用kernel接口,return    if (use_inkernel_interface)        return;    // 更新数据结构，pid的hashtable以及进程优先级的双向链表table    pid_remove(pid);    kill_lasttime = 0;}static int pid_remove(int pid) {    int hval = pid_hashfn(pid);    struct proc *procp;    struct proc *prevp;    // pid的hashtable    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;    // 进程优先级的table    proc_unslot(procp);    free(procp);    return 0;}

2.4.4 小结

从上面的处理逻辑就能看出来，三种command的处理逻辑中都对use_inkernel_interface的情况下做了特殊处理，在use_inkernel_interface的情况下，做的事情都是很简单的，只是更新一下文件节点。如果不使用kernel interface，就需要lmkd自己维护两个table，在每次更新adj的时候去更新table。 且在初始化的时候也能看到，如果不使用kernel的lowmemorykiller，则需要lmkd自己获取手机内存状态，如果匹配到了minfree中的等级，则需要通过杀掉一些进程释放内存。

2.5 杀进程

初始化的时候已经注册好了，当获取到手机的内存匹配到minfree中某一个级别时：

2.5.1 查找

// 不使用kernel interface// 根据当前内存的状态查找需要杀掉的进程static int find_and_kill_process(int other_free, int other_file, bool first){    ...    // 主要逻辑是这里的for循环    // 根据前面最小内存级别与优先级的对应关系    // 拿到需要杀的进程的优先级    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:        // 从优先级table中取出一个        // 因为是双向循环链表，取的时候取出head->prev，也就是最后一个        // 也就是使用的lru算法，先把近期不用的进程杀掉        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;}

2.5.2 杀进程

这里的逻辑比较简单，主要是将这个proc从数据结构中删除，也就是两个table，删除之后直接发信号杀进程。可以看到这个地方杀进程之后是有log的，可以在logcat中查看是否有lmk杀进程。

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;    }    // 通过读取/proc/pid/statm    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");    // send signal SIGKILL    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;    }}

2.6 小结

这部分从lmkd的main开始，从一些数据结构的初始化，到进入loop，再到与ActivityManager的socket连接，接收上层传递的数据，然后分别根据三种command做出不同的更新与删除等。当然最重要的还是use_inkernel_interface这个变量，从初始化到所有命令的处理都与这个逻辑分不开，如果不使用的话，需要自维护进程的数据结构，需要读取文件节点获取手机内存状态，在minfree匹配到时去查找并杀进程，直到释放足够多的内存。在使用kernel空间lowmemorykiller的情况下，三种命令做的事情会非常有限，主要是更新文件节点，而lmdk本身根本不需要维护任何跟进程相关的结构，判断手机状态并查找低优先级的进程以及杀进程的工作全部都由lowmemorykiller完成。

3. lowmemorykiller

前面也提过，大多情况其实是使用kernel interface的，其实也就是kernel中的lowmemorykiller

代码位置:/kernel/msm-3.18/drivers/staging/android/lowmemorykiller.c

lowmemorykiller中是通过linux的shrinker实现的，这个是linux的内存回收机制的一种，由内核线程kswapd负责监控，在lowmemorykiller初始化的时候注册register_shrinker。

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

minfree以及min_adj两个数组：

// 下面两个数组分别代表了两个参数文件中的默认值，数组默认的size都是6// 对应 "/sys/module/lowmemorykiller/parameters/adj"static short lowmem_adj[6] = {    0,    1,    6,    12,};static int lowmem_adj_size = 4;// 对应 "/sys/module/lowmemorykiller/parameters/minfree"static int lowmem_minfree[6] = {    3 * 512,    /* 6MB */    2 * 1024,   /* 8MB */    4 * 1024,   /* 16MB */    16 * 1024,  /* 64MB */};static int lowmem_minfree_size = 4;

扫描当前内存以及杀进程：

static unsigned long lowmem_scan(struct shrinker *s, struct shrink_control *sc){    struct task_struct *tsk;    struct task_struct *selected = NULL;    unsigned long rem = 0;    int tasksize;    int i;    // OOM_SCORE_ADJ_MAX = 1000    short min_score_adj = OOM_SCORE_ADJ_MAX + 1;    int minfree = 0;    int selected_tasksize = 0;    short selected_oom_score_adj;    // array_size = 6    int array_size = ARRAY_SIZE(lowmem_adj);    // NR_FREE_PAGES 是在/kernel/msm-3.18/include/linux/mmzone.h中定义的zone_stat_item对应的第一个枚举，下面的枚举以此类推    // global_page_state(NR_FREE_PAGES)即读取/proc/vmstat 中第一行的值    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) -                        global_page_state(NR_UNEVICTABLE) -                        total_swapcache_pages();    if (lowmem_adj_size < array_size)        array_size = lowmem_adj_size;    if (lowmem_minfree_size < array_size)        array_size = lowmem_minfree_size;    for (i = 0; i < array_size; i++) {        // 从小到大扫描lowmem_minfree数组，根据剩余内存的大小，确定当前剩余内存的级别        minfree = lowmem_minfree[i];        if (other_free < minfree && other_file < (minfree + minfree / 4)) {            // 由于两个数组之间的对应关系，minfree中找到当前内存所处的等级之后            // 也就可以在lowmem_adj获取到在这个内存级别需要杀掉的进程的优先级            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);    // 经过一轮扫描，发现不需要杀进程，return    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同步机制    rcu_read_lock();again:    // for_each_process用来遍历所有的进程    // 定义在 /kernel/msm-3.18/include/linux/sched.h    // #define for_each_process(p) \    //  for (p = &init_task ; (p = next_task(p)) != &init_task ; )    for_each_process(tsk) {        struct task_struct *p;        short oom_score_adj;        // 内核线程kthread        if (tsk->flags & PF_KTHREAD)            continue;        // 已经被杀，还在等锁        if (test_tsk_lmk_waiting(tsk)) {            lowmem_print(2, "%s (%d) is already killed, skip\n",                tsk->comm, tsk->pid);            continue;        }        // 一个task        // 定义在 /kernel/msm-3.18/mm/oom_kill.c        p = find_lock_task_mm(tsk);        if (!p)            continue;        oom_score_adj = p->signal->oom_score_adj;        if (oom_score_adj < min_score_adj) {            // 如果当前找到的进程的oom_score_adj比当前需要杀的最小优先级还低，不杀            task_unlock(p);            continue;        }        // 拿到占用的内存大小        // 定义在 /kernel/msm-3.18/include/linux/mm.h        tasksize = get_mm_rss(p->mm);#ifdef CONFIG_ZRAM        tasksize += (get_mm_counter(p->mm, MM_SWAPENTS) / 3);#endif        task_unlock(p);        if (tasksize <= 0)            continue;        if (selected) {        // 第一次不会进到这        // 第二次，也就是循环回来，判断如果当前选中的进程的adj更小        // 或优先级相同但是内存比较小，则continue            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;        // 已经选中了进程p，准备kill        lowmem_print(2, "select '%s' (%d, %d), adj %hd, size %d, to kill\n",                 p->comm, p->pid, p->tgid, oom_score_adj, tasksize);    }    if (selected) {        task_lock(selected);        // 给该进程发信号 SIGKILL        send_sig(SIGKILL, selected, 0);        if (selected->mm)            task_set_lmk_waiting(selected);        task_unlock(selected);        // 杀进程完毕，打印kernel log, tag是lowmemorykiller        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,                 other_file * (long)(PAGE_SIZE / 1024),                 minfree * (long)(PAGE_SIZE / 1024),                 min_score_adj,                 other_free * (long)(PAGE_SIZE / 1024));        lowmem_deathpending_timeout = jiffies + HZ;        // 释放的内存大小        rem += selected_tasksize;    }    // 如果需要杀掉多个进程    // kill_one_more在lmk_vmpressure_notifier中置true    if (kill_one_more) {        selected = NULL;        kill_one_more = false;        lowmem_print(1, "lowmem_scan kill one more process\n");        // 跳转到遍历的地方再开始        goto again;    }    lowmem_print(4, "lowmem_scan %lu, %x, return %lu\n",             sc->nr_to_scan, sc->gfp_mask, rem);    rcu_read_unlock();    return rem;}

lmk_vmpressure_notifier中定义了什么时候去kill_one_more，主要是当内存压力在95以上时
lmk_vmpressure_notifier这个也是在init时注册：vmpressure_notifier_register(&lmk_vmpr_nb);

static int lmk_vmpressure_notifier(struct notifier_block *nb,            unsigned long action, void *data){    unsigned long pressure = action;    if (pressure >= 95) {        if (!kill_one_more) {            kill_one_more = true;            lowmem_print(2, "vmpressure %ld, set kill_one_more true\n",                pressure);        }    } else {        if (kill_one_more) {            kill_one_more = false;            lowmem_print(2, "vmpressure %ld, set kill_one_more false\n",                pressure);        }    }    return 0;}

oom_adj到oom_score_adj的转换：

static short lowmem_oom_adj_to_oom_score_adj(short oom_adj){    if (oom_adj == OOM_ADJUST_MAX)        return OOM_SCORE_ADJ_MAX;    else        return (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;}

4. 总结

由于Android中的进程启动的很频繁，四大组件都会涉及到进程启动，进程启动之后做完组要做的事情之后就会很快被AMS把优先级降低，但是为了针对低内存的情况以及如果用户开启太多，且APP的优先级很高，AMS这边就有一些无力了，为了保证手机正常运行必须有进程清理，内存回收，根据当前手机剩余内存的状态，在minfree中找到当前等级，再根据这个等级去adj中找到这个等级应该杀掉的进程的优先级，然后去杀进程，直到释放足够的内存。目前大多都使用kernel中的lowmemorykiller，但是上层用户的APP的优先级的调整还是AMS来完成的，lmkd在中间充当了一个桥梁的角色，通过把上层的更新之后的adj写入到文件节点，提供lowmemorykiller杀进程的依据。