目录概览.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 //１、拿到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赋值，默认为１
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 //注释１
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}
注释１中的for是将参数读出来，这些参数来自与哪里呢？在上篇博客写过，其实是和下面的代码的for一一对应的，用lowmem_minfree[i] 数组保存水位线，用 lowmem_adj保存每条水位线对应的adj。其中有一个很关键的变量use_inkernel_interface，这个代表是否要使用kernel中的逻辑，默认是等于１的，意味着需要使用kernel中的逻辑，如果不等于１，那么就采用用户空间的逻辑。
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<mOomAdj.length; i++) {
292 buf.putInt((mOomMinFree[i]*1024)/PAGE_SIZE);//五个水位线
293 buf.putInt(mOomAdj[i]);//与上面水位线对应的五个adj数值
294 }
295 //将AMS已经计算好的值通过socket发送到lmkd
296 writeLmkd(buf);
297 SystemProperties.set("sys.sysctl.extra_free_kbytes", Integer.toString(reserve));
298 }
299 // GB: 2048,3072,4096,6144,7168,8192
300 // HC: 8192,10240,12288,14336,16384,20480
301 }
将生成好的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不等于１，就需要使用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完成。如果不等于１，那么lmkd就需要自己维护进程的这些数据结构了。下篇继续分析LowmemoryKiller杀进程机制。
