Android进程系列第七篇---LowmemoryKiller机制分析(中)

目录概览.png

前面进程系列已经更新了六篇,本文(基于Android O源码),梳理LMK杀进程机制中篇,主要总结LowmemoryKiller的中lmkd的原理部分。
Android进程系列第一篇---进程基础
Android进程系列第二篇---Zygote进程的创建流程
Android进程系列第三篇---SystemServer进程的创建流程
Android进程系列第四篇---SystemServer进程的启动流程
Android进程系列第五篇---应用进程的创建流程
Android进程系列第六篇---LowmemoryKiller机制分析(上)

上文说到LowmemoryKiller核心原理就是Framework层通过调整adj的值和阈值数组,输送给kernel中的lmk,为lmk提供杀进程的原材料。AMS中给lmkd发送数据原材料有三个入口,对应携带的也有三种命令协议,每种协议代表内核中一种数据的控制方式,如下表。

功能 AMS对应方法 命令 内核对应函数
LMK_PROCPRIO PL.setOomAdj() 设置指定进程的优先级,也就是oom_score_adj cmd_procprio
LMK_TARGET PL.updateOomLevels() 更新/sys/module/lowmemorykiller/parameters/中的minfree以及adj cmd_target
LMK_PROCREMOVE PL.remove() 移除进程 cmd_procremove

回顾一下上文说到的三层模型,就是下图


LMK三层架构.png

Framework层通过调整adj的值和阈值数组,输送给kernel中的lmk,为lmk提供杀进程的原材料,因为用户空间和内核空间相互隔离,就采用了文件节点进行通讯,用socket将adj的值与阈值数组传给lmkd(5.0之后不在由AMS直接与lmk通信,引入lmkd守护进程),lmkd将这些值写到内核节点中。lmk通过读取这些节点,实现进程的kill,所以整个lmk机制大概就分成三层,第一篇我们梳理了Framework层,现在看后面两层,首先是lmkd层。

二、lmkd机制分析

2.1、lmkd初步见面

lmkd是什么?怀疑是一个进程呢,还是一个system进程中的一个名词概念?找个手机先ps一把看看

sakura:/ # ps -ef |grep lmkd
root           589     1 0 11:10:07 ?     00:00:02 lmkd

哟呵,确实是一个单独的进程,那么父进程是谁呢?cd 到proc/589目录下,查看status文件

sakura:/proc/589 # cat status                                                                                                                                                                              
Name:   lmkd
State:  S (sleeping)
Tgid:   589
Pid:    589
PPid:   1
TracerPid:  0
Uid:    0   0   0   0
Gid:    0   0   0   0
Ngid:   0
FDSize: 64
Groups: 3009 
VmPeak:     9952 kB
VmSize:     9484 kB
VmLck:       256 kB
VmPin:         0 kB
VmHWM:      2044 kB
VmRSS:       900 kB
VmData:     4848 kB
VmStk:       132 kB
VmExe:        16 kB
VmLib:      3172 kB
VmPTE:        32 kB
VmSwap:      384 kB
Threads:    1
SigQ:   2/10400

PPid为1,说明父进程是init进程,确实是这样的,在/system/core/lmkd/lmkd.rc中有清楚的定义

1service lmkd /system/bin/lmkd
2    class core
3    group root readproc
4    critical
5    socket lmkd seqpacket 0660 system system
6    writepid /dev/cpuset/system-background/tasks
7

现在看一下它lmkd的main方法:

/system/core/lmkd/lmkd.c
890int main(int argc __unused, char **argv __unused) {
891    struct sched_param param = {
892            .sched_priority = 1,
893    };
894
         ......
902
903    mlockall(MCL_FUTURE);
         //指定进程的调度策略, FIFO方式的实时调度策略
904    sched_setscheduler(0, SCHED_FIFO, ¶m);
         //做一些初始化
905    if (!init())
            //进入主循环,等待AMS发送的请求
906        mainloop();
907
908    ALOGI("exiting");
909    return 0;
910}
911
2.2、lmkd的数据结构

在具体跟踪main方法之前,需要看看lmkd的数据结构,下面所有的代码都在lmkd.c文件中

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

minfree和adj文件分别表示水位线和水位线对应的adj,在之前已经介绍过,可以回顾上篇博客。

90/* OOM score values used by both kernel and framework */
91#define OOM_SCORE_ADJ_MIN       (-1000)
92#define OOM_SCORE_ADJ_MAX       1000
93
94static int lowmem_adj[MAX_TARGETS];
95static int lowmem_minfree[MAX_TARGETS];

minfree和adj文件中的值实质是来自lowmem_minfree和lowmem_adj两个数组。lowmem_minfree[]和lowmem_adj[]数组大小个数都为6。

53enum lmk_cmd {
54    LMK_TARGET,
55    LMK_PROCPRIO,
56    LMK_PROCREMOVE,
57};

枚举代表三种命令协议

105struct adjslot_list {
106    struct adjslot_list *next;
107    struct adjslot_list *prev;
108};
109
110struct proc {
111    struct adjslot_list asl;
112    int pid;
113    uid_t uid;
114    int oomadj;
115    struct proc *pidhash_next;
116};
117

在AMS中进程的数据结构是ProcessRocord,在lmkd中进程的数据结构是proc,adjslot_list是双向链表。

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

procadjslot_list是一个双向的链表,数组的下标index就是进程的优先级,系统中同一个时刻,有很多进程的优先级都是相同的,那么根据指定的优先级就能从数组中获取一个链表,这个链表上的所有proc的优先级都是相同的,根据这个链表进一步选择杀掉哪些进程。由于进程的优先级可能是一个负数,所以加上了一个-OOM_SCORE_ADJ_MIN(1000)。

2.3、lmkd的初始化
/system/core/lmkd/lmkd.c
809static int init(void) {
810    struct epoll_event epev;
811    int i;
812    int ret;
.....    
824    //1、拿到socket的fd
825    ctrl_lfd = android_get_control_socket("lmkd");
826    if (ctrl_lfd < 0) {
827        ALOGE("get lmkd control socket failed");
828        return -1;
829    }
830
       //2、监听
831    ret = listen(ctrl_lfd, 1);
832    if (ret < 0) {
833        ALOGE("lmkd control socket listen failed (errno=%d)", errno);
834        return -1;
835    }
836
837    epev.events = EPOLLIN;
   //3、ctrl_connect_handler中主要完成soclet的accpet以及数据read,当监听到socket连接事件后会调用ctrl_connect_handler方法
838    epev.data.ptr = (void *)ctrl_connect_handler;
839    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
840        ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
841        return -1;
842    }
843    maxevents++;
.....   
   //通过判断文件是否可读来给use_inkernel_interface赋值,默认为1
    use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);
         //4、初始化链表
857    for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
858        procadjslot_list[i].next = &procadjslot_list[i];
859        procadjslot_list[i].prev = &procadjslot_list[i];
860    }
861
862    return 0;
863}

2.4、lmkd的main方法
/system/core/lmkd/lmkd.c
865static void mainloop(void) {
866    while (1) {
867        struct epoll_event events[maxevents];
868        int nevents;
869        int i;
870
871        ctrl_dfd_reopened = 0;
          //epollfd:由epoll_create 生成的epoll专用的文件描述符;
          //events:用于回传代处理事件的数组;
          //maxevents:每次能处理的事件数;
          //timeout:等待I/O事件发生的超时值(单位我也不太清楚);-1相当于阻塞,0相当于非阻塞。一般用-1即可
872        nevents = epoll_wait(epollfd, events, maxevents, -1);
873
874        if (nevents == -1) {
875            if (errno == EINTR)
876                continue;
877            ALOGE("epoll_wait failed (errno=%d)", errno);
878            continue;
879        }
880
881        for (i = 0; i < nevents; ++i) {
882            if (events[i].events & EPOLLERR)
883                ALOGD("EPOLLERR on event #%d", i);
884            if (events[i].data.ptr)
885                (*(void (*)(uint32_t))events[i].data.ptr)(events[i].events);
886        }
887    }
888}

调用epoll_wait阻塞,等待socket事件的到来

2.5、ctrl_command_handler函数对上层command的分发
345static void ctrl_command_handler(void) {
346    int ibuf[CTRL_PACKET_MAX / sizeof(int)];
347    int len;
348    int cmd = -1;
349    int nargs;
350    int targets;
351    // 读取socket管道信息
352    len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
353    if (len <= 0)
354        return;
355
356    nargs = len / sizeof(int) - 1;
357    if (nargs < 0)
358        goto wronglen;
359    // 获取buffer中的命令协议
360    cmd = ntohl(ibuf[0]);
361
362    switch(cmd) {
    //处理LMK_TARGET事件,设置水位线,也就是更新/sys/module/lowmemorykiller/parameters/中的minfree以及adj
363    case LMK_TARGET:
364        targets = nargs / 2;
365        if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
366            goto wronglen;
367        cmd_target(targets, &ibuf[1]);
368        break;
    //处理LMK_PROCPRIO事件,根据pid,设置指定进程的优先级,也就是oom_score_adj
369    case LMK_PROCPRIO:
370        if (nargs != 3)
371            goto wronglen;
372        cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
373        break;
    //处理LMK_PROCREMOVE事件,根据pid,移除进程,
374    case LMK_PROCREMOVE:
375        if (nargs != 1)
376            goto wronglen;
377        cmd_procremove(ntohl(ibuf[1]));
378        break;
379    default:
380        ALOGE("Received unknown command code %d", cmd);
381        return;
382    }
383
384    return;
385
386wronglen:
387    ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
388}

在init中注册了ctrl_connect_handler的回调函数,然后ctrl_connect_handler->ctrl_data_handler-> ctrl_command_handler的调用,对上层的command命令进行不同的处理。

2.5.1、LMK_TARGET命令--- cmd_target
http://androidxref.com/8.0.0_r4/xref/system/core/lmkd/lmkd.c
284static void cmd_target(int ntargets, int *params) {
285    int i;
286
287    if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
288        return;
289     //注释1
290    for (i = 0; i < ntargets; i++) {
291        lowmem_minfree[i] = ntohl(*params++);
292        lowmem_adj[i] = ntohl(*params++);
293    }
294
295    lowmem_targets_size = ntargets;
296 //是否使用kernel空间的处理逻辑
297    if (use_inkernel_interface) {
298        char minfreestr[128];
299        char killpriostr[128];
300
301        minfreestr[0] = '\0';
302        killpriostr[0] = '\0';
303
304        for (i = 0; i < lowmem_targets_size; i++) {
305            char val[40];
306
307            if (i) {
308                strlcat(minfreestr, ",", sizeof(minfreestr));
309                strlcat(killpriostr, ",", sizeof(killpriostr));
310            }
311
312            snprintf(val, sizeof(val), "%d", lowmem_minfree[i]);
313            strlcat(minfreestr, val, sizeof(minfreestr));
314            snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
315            strlcat(killpriostr, val, sizeof(killpriostr));
316        }
317
318        writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
319        writefilestring(INKERNEL_ADJ_PATH, killpriostr);
320    }
321}

注释1中的for是将参数读出来,这些参数来自与哪里呢?在上篇博客写过,其实是和下面的代码的for一一对应的,用lowmem_minfree[i] 数组保存水位线,用 lowmem_adj保存每条水位线对应的adj。其中有一个很关键的变量use_inkernel_interface,这个代表是否要使用kernel中的逻辑,默认是等于1的,意味着需要使用kernel中的逻辑,如果不等于1,那么就采用用户空间的逻辑。

287
288        if (write) {
289            ByteBuffer buf = ByteBuffer.allocate(4 * (2*mOomAdj.length + 1));
290            buf.putInt(LMK_TARGET);
291            for (int i=0; i

将生成好的string写入到文件节点minfree以及adj

220static void writefilestring(char *path, char *s) {
221    int fd = open(path, O_WRONLY | O_CLOEXEC);
222    int len = strlen(s);
223    int ret;
224
225    if (fd < 0) {
226        ALOGE("Error opening %s; errno=%d", path, errno);
227        return;
228    }
229
230    ret = write(fd, s, len);
231    if (ret < 0) {
232        ALOGE("Error writing %s; errno=%d", path, errno);
233    } else if (ret < len) {
234        ALOGE("Short write on %s; length=%d", path, ret);
235    }
236
237    close(fd);
238}
239
2.5.2、LMK_PROCPRIO命令--- cmd_procprio
http://androidxref.com/8.0.0_r4/xref/system/core/lmkd/lmkd.c
240static void cmd_procprio(int pid, int uid, int oomadj) {
241    struct proc *procp;
242    char path[80];
243    char val[20];
244
245    if (oomadj < OOM_SCORE_ADJ_MIN || oomadj > OOM_SCORE_ADJ_MAX) {
246        ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
247        return;
248    }
249   
250    snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
251    snprintf(val, sizeof(val), "%d", oomadj);
       //写到文件中
252    writefilestring(path, val);
253
254    if (use_inkernel_interface)
255        return;
256 //从hashtable找到对应的进程
257    procp = pid_lookup(pid);
258    if (!procp) {
     //如果没有找到,分配一个结点,调用proc_insert插入hashtable中
259            procp = malloc(sizeof(struct proc));
260            if (!procp) {
261                // Oh, the irony.  May need to rebuild our state.
262                return;
263            }
264
265            procp->pid = pid;
266            procp->uid = uid;
267            procp->oomadj = oomadj;
268            proc_insert(procp);
269    } else {
    //如果已经存在,将原来优先级的proc移除,然后新的优先级的proc添加到双向链表中
270        proc_unslot(procp);
271        procp->oomadj = oomadj;
272        proc_slot(procp);
273    }
274}

这段逻辑也很清晰,就是更新进程的oom_score_adj

2.5.3、LMK_PROCREMOVE命令---cmd_procremove

进程死掉后,会调用该进程的ProcessList.remove方法,也会通过Socket通知lmkd更新adj。

/frameworks/base/services/core/java/com/android/server/am/ProcessList.java
651    public static final void remove(int pid) {
652        ByteBuffer buf = ByteBuffer.allocate(4 * 2);
653        buf.putInt(LMK_PROCREMOVE);
654        buf.putInt(pid);
655        writeLmkd(buf);
656    }

紧接着就会执行pid_remove, 更新hashtable和双向链表

http://androidxref.com/8.0.0_r4/xref/system/core/lmkd/lmkd.c
276static void cmd_procremove(int pid) {
277    if (use_inkernel_interface)
278        return;
279
280    pid_remove(pid);
281    kill_lasttime = 0;
282}
283
198static int pid_remove(int pid) {
199    int hval = pid_hashfn(pid);
200    struct proc *procp;
201    struct proc *prevp;
202
203    for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
204         procp = procp->pidhash_next)
205            prevp = procp;
206
207    if (!procp)
208        return -1;
209
210    if (!prevp)
211        pidhash[hval] = procp->pidhash_next;
212    else
213        prevp->pidhash_next = procp->pidhash_next;
214
215    proc_unslot(procp);
216    free(procp);
217    return 0;
218}
2.6、lmkd如何杀进程

当use_inkernel_interface不等于1,就需要使用lmkd中杀进程的逻辑,无需使用kernel中的LowmemoryKiller机制。

http://androidxref.com/8.0.0_r4/xref/system/core/lmkd/lmkd.c
588/*
589 * Find a process to kill based on the current (possibly estimated) free memory
590 * and cached memory sizes.  Returns the size of the killed processes.
591 */
592static int find_and_kill_process(int other_free, int other_file, bool first)
593{
594    int i;
595    int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
596    int minfree = 0;
597    int killed_size = 0;
598
599    for (i = 0; i < lowmem_targets_size; i++) {
600        minfree = lowmem_minfree[i];
601        if (other_free < minfree && other_file < minfree) {
602            min_score_adj = lowmem_adj[i];
603            break;
604        }
605    }
606
607    if (min_score_adj == OOM_SCORE_ADJ_MAX + 1)
608        return 0;
609
610    for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
611        struct proc *procp;
612
613retry:
614        procp = proc_adj_lru(i);
615
616        if (procp) {
617            killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
618            if (killed_size < 0) {
619                goto retry;
620            } else {
621                return killed_size;
622            }
623        }
624    }
625
626    return 0;
627}
548/* Kill one process specified by procp.  Returns the size of the process killed */
549static int kill_one_process(struct proc *procp, int other_free, int other_file,
550        int minfree, int min_score_adj, bool first)
551{
552    int pid = procp->pid;
553    uid_t uid = procp->uid;
554    char *taskname;
555    int tasksize;
556    int r;
557
558    taskname = proc_get_name(pid);
559    if (!taskname) {
560        pid_remove(pid);
561        return -1;
562    }
563
564    tasksize = proc_get_size(pid);
565    if (tasksize <= 0) {
566        pid_remove(pid);
567        return -1;
568    }
569
570    ALOGI("Killing '%s' (%d), uid %d, adj %d\n"
571          "   to free %ldkB because cache %s%ldkB is below limit %ldkB for oom_adj %d\n"
572          "   Free memory is %s%ldkB %s reserved",
573          taskname, pid, uid, procp->oomadj, tasksize * page_k,
574          first ? "" : "~", other_file * page_k, minfree * page_k, min_score_adj,
575          first ? "" : "~", other_free * page_k, other_free >= 0 ? "above" : "below");
576    r = kill(pid, SIGKILL);
577    killProcessGroup(uid, pid, SIGKILL);
578    pid_remove(pid);
579
580    if (r) {
581        ALOGE("kill(%d): errno=%d", procp->pid, errno);
582        return -1;
583    } else {
584        return tasksize;
585    }
586}
2.7、总结

上面的篇幅主要梳理了lmkd这一层,了解了AMS三种command在lmkd进程中是如何处理的。并且注意到三种command都对use_inkernel_interface进行了判断,如果use_inkernel_interface等于1,那么就执行kernel空间的逻辑,lmkd中数据结构也不用更新,也不用lmkd中杀进程的逻辑,全部都交给lmk完成。如果不等于1,那么lmkd就需要自己维护进程的这些数据结构了。下篇继续分析LowmemoryKiller杀进程机制。

你可能感兴趣的:(Android进程系列第七篇---LowmemoryKiller机制分析(中))