Android程序系列第七篇---LowmemoryKiller機制分析(中)

摘要： 目錄概覽.png 前面程序系列已經更新了六篇，本文（基於Android O原始碼），梳理LMK殺程序機制中篇，主要總結LowmemoryKiller的中lmkd的原理部分。 Android程序系列第一篇---程序基礎 And...

上文說到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

回顧一下上文說到的三層模型，就是下圖

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
root5891 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:0000
Gid:0000
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
2class core
3group root readproc
4critical
5socket lmkd seqpacket 0660 system system
6writepid /dev/cpuset/system-background/tasks
7

現在看一下它lmkd的main方法：

/system/core/lmkd/lmkd.c
890int main(int argc __unused, char **argv __unused) {
891struct sched_param param = {
892.sched_priority = 1,
893};
894
......
902
903mlockall(MCL_FUTURE);
//指定程序的排程策略, FIFO方式的實時排程策略
904sched_setscheduler(0, SCHED_FIFO, &param);
//做一些初始化
905if (!init())
//進入主迴圈，等待AMS傳送的請求
906mainloop();
907
908ALOGI("exiting");
909return 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_MAX1000
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 {
54LMK_TARGET,
55LMK_PROCPRIO,
56LMK_PROCREMOVE,
57};

列舉代表三種命令協議

105struct adjslot_list {
106struct adjslot_list *next;
107struct adjslot_list *prev;
108};
109
110struct proc {
111struct adjslot_list asl;
112int pid;
113uid_t uid;
114int oomadj;
115struct 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) {
810struct epoll_event epev;
811int i;
812int ret;
.....
824//１、拿到socket的fd
825ctrl_lfd = android_get_control_socket("lmkd");
826if (ctrl_lfd < 0) {
827ALOGE("get lmkd control socket failed");
828return -1;
829}
830
//2、監聽
831ret = listen(ctrl_lfd, 1);
832if (ret < 0) {
833ALOGE("lmkd control socket listen failed (errno=%d)", errno);
834return -1;
835}
836
837epev.events = EPOLLIN;
　　　//3、ctrl_connect_handler中主要完成soclet的accpet以及資料read,當監聽到socket連線事件後會呼叫ctrl_connect_handler方法
838epev.data.ptr = (void *)ctrl_connect_handler;
839if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
840ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
841return -1;
842}
843maxevents++;
.....
　　　//通過判斷檔案是否可讀來給use_inkernel_interface賦值，預設為１
 　　 use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);
//4、初始化連結串列
857for (i = 0; i <= ADJTOSLOT(OOM_SCORE_ADJ_MAX); i++) {
858procadjslot_list[i].next = &procadjslot_list[i];
859procadjslot_list[i].prev = &procadjslot_list[i];
860}
861
862return 0;
863}

2.4、lmkd的main方法

/system/core/lmkd/lmkd.c
865static void mainloop(void) {
866while (1) {
867struct epoll_event events[maxevents];
868int nevents;
869int i;
870
871ctrl_dfd_reopened = 0;
//epollfd:由epoll_create 生成的epoll專用的檔案描述符；
//events:用於回傳代處理事件的陣列；
//maxevents:每次能處理的事件數；
//timeout:等待I/O事件發生的超時值(單位我也不太清楚)；-1相當於阻塞，0相當於非阻塞。一般用-1即可
872nevents = epoll_wait(epollfd, events, maxevents, -1);
873
874if (nevents == -1) {
875if (errno == EINTR)
876continue;
877ALOGE("epoll_wait failed (errno=%d)", errno);
878continue;
879}
880
881for (i = 0; i < nevents; ++i) {
882if (events[i].events & EPOLLERR)
883ALOGD("EPOLLERR on event #%d", i);
884if (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) {
346int ibuf[CTRL_PACKET_MAX / sizeof(int)];
347int len;
348int cmd = -1;
349int nargs;
350int targets;
351// 讀取socket管道資訊
352len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
353if (len <= 0)
354return;
355
356nargs = len / sizeof(int) - 1;
357if (nargs < 0)
358goto wronglen;
359// 獲取buffer中的命令協議
360cmd = ntohl(ibuf[0]);
361
362switch(cmd) {
　　　　//處理LMK_TARGET事件，設定水位線，也就是更新/sys/module/lowmemorykiller/parameters/中的minfree以及adj
363case LMK_TARGET:
364targets = nargs / 2;
365if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
366goto wronglen;
367cmd_target(targets, &ibuf[1]);
368break;
　　　　//處理LMK_PROCPRIO事件，根據pid，設定指定程序的優先順序，也就是oom_score_adj
369case LMK_PROCPRIO:
370if (nargs != 3)
371goto wronglen;
372cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
373break;
　　　　//處理LMK_PROCREMOVE事件，根據pid，移除程序，
374case LMK_PROCREMOVE:
375if (nargs != 1)
376goto wronglen;
377cmd_procremove(ntohl(ibuf[1]));
378break;
379default:
380ALOGE("Received unknown command code %d", cmd);
381return;
382}
383
384return;
385
386wronglen:
387ALOGE("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) {
285int i;
286
287if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
288return;
289//註釋１
290for (i = 0; i < ntargets; i++) {
291lowmem_minfree[i] = ntohl(*params++);
292lowmem_adj[i] = ntohl(*params++);
293}
294
295lowmem_targets_size = ntargets;
296　//是否使用kernel空間的處理邏輯
297if (use_inkernel_interface) {
298char minfreestr[128];
299char killpriostr[128];
300
301minfreestr[0] = '\0';
302killpriostr[0] = '\0';
303
304for (i = 0; i < lowmem_targets_size; i++) {
305char val[40];
306
307if (i) {
308strlcat(minfreestr, ",", sizeof(minfreestr));
309strlcat(killpriostr, ",", sizeof(killpriostr));
310}
311
312snprintf(val, sizeof(val), "%d", lowmem_minfree[i]);
313strlcat(minfreestr, val, sizeof(minfreestr));
314snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
315strlcat(killpriostr, val, sizeof(killpriostr));
316}
317
318writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
319writefilestring(INKERNEL_ADJ_PATH, killpriostr);
320}
321}

註釋１中的for是將引數讀出來，這些引數來自與哪裡呢？在上篇部落格寫過，其實是和下面的程式碼的for一一對應的，用lowmem_minfree[i] 陣列儲存水位線，用 lowmem_adj儲存每條水位線對應的adj。其中有一個很關鍵的變數use_inkernel_interface，這個代表是否要使用kernel中的邏輯，預設是等於１的，意味著需要使用kernel中的邏輯，如果不等於１，那麼就採用使用者空間的邏輯。

287
288if (write) {
289ByteBuffer buf = ByteBuffer.allocate(4 * (2*mOomAdj.length + 1));
290buf.putInt(LMK_TARGET);
291for (int i=0; i<mOomAdj.length; i++) {
292buf.putInt((mOomMinFree[i]*1024)/PAGE_SIZE);//五個水位線
293buf.putInt(mOomAdj[i]);//與上面水位線對應的五個adj數值
294}
295//將AMS已經計算好的值通過socket傳送到lmkd
296writeLmkd(buf);
297SystemProperties.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) {
221int fd = open(path, O_WRONLY | O_CLOEXEC);
222int len = strlen(s);
223int ret;
224
225if (fd < 0) {
226ALOGE("Error opening %s; errno=%d", path, errno);
227return;
228}
229
230ret = write(fd, s, len);
231if (ret < 0) {
232ALOGE("Error writing %s; errno=%d", path, errno);
233} else if (ret < len) {
234ALOGE("Short write on %s; length=%d", path, ret);
235}
236
237close(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) {
241struct proc *procp;
242char path[80];
243char val[20];
244
245if (oomadj < OOM_SCORE_ADJ_MIN || oomadj > OOM_SCORE_ADJ_MAX) {
246ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
247return;
248}
249
250snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
251snprintf(val, sizeof(val), "%d", oomadj);
//寫到檔案中
252writefilestring(path, val);
253
254if (use_inkernel_interface)
255return;
256　//從hashtable找到對應的程序
257procp = pid_lookup(pid);
258if (!procp) {
　　　　　//如果沒有找到，分配一個結點，呼叫proc_insert插入hashtable中
259procp = malloc(sizeof(struct proc));
260if (!procp) {
261// Oh, the irony.May need to rebuild our state.
262return;
263}
264
265procp->pid = pid;
266procp->uid = uid;
267procp->oomadj = oomadj;
268proc_insert(procp);
269} else {
　　　　//如果已經存在，將原來優先順序的proc移除，然後新的優先順序的proc新增到雙向連結串列中
270proc_unslot(procp);
271procp->oomadj = oomadj;
272proc_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
651public static final void remove(int pid) {
652ByteBuffer buf = ByteBuffer.allocate(4 * 2);
653buf.putInt(LMK_PROCREMOVE);
654buf.putInt(pid);
655writeLmkd(buf);
656}

緊接著就會執行pid_remove， 更新hashtable和雙向連結串列

http://androidxref.com/8.0.0_r4/xref/system/core/lmkd/lmkd.c
276static void cmd_procremove(int pid) {
277if (use_inkernel_interface)
278return;
279
280pid_remove(pid);
281kill_lasttime = 0;
282}
283

198static int pid_remove(int pid) {
199int hval = pid_hashfn(pid);
200struct proc *procp;
201struct proc *prevp;
202
203for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
204procp = procp->pidhash_next)
205prevp = procp;
206
207if (!procp)
208return -1;
209
210if (!prevp)
211pidhash[hval] = procp->pidhash_next;
212else
213prevp->pidhash_next = procp->pidhash_next;
214
215proc_unslot(procp);
216free(procp);
217return 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{
594int i;
595int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
596int minfree = 0;
597int killed_size = 0;
598
599for (i = 0; i < lowmem_targets_size; i++) {
600minfree = lowmem_minfree[i];
601if (other_free < minfree && other_file < minfree) {
602min_score_adj = lowmem_adj[i];
603break;
604}
605}
606
607if (min_score_adj == OOM_SCORE_ADJ_MAX + 1)
608return 0;
609
610for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
611struct proc *procp;
612
613retry:
614procp = proc_adj_lru(i);
615
616if (procp) {
617killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
618if (killed_size < 0) {
619goto retry;
620} else {
621return killed_size;
622}
623}
624}
625
626return 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,
550int minfree, int min_score_adj, bool first)
551{
552int pid = procp->pid;
553uid_t uid = procp->uid;
554char *taskname;
555int tasksize;
556int r;
557
558taskname = proc_get_name(pid);
559if (!taskname) {
560pid_remove(pid);
561return -1;
562}
563
564tasksize = proc_get_size(pid);
565if (tasksize <= 0) {
566pid_remove(pid);
567return -1;
568}
569
570ALOGI("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",
573taskname, pid, uid, procp->oomadj, tasksize * page_k,
574first ? "" : "~", other_file * page_k, minfree * page_k, min_score_adj,
575first ? "" : "~", other_free * page_k, other_free >= 0 ? "above" : "below");
576r = kill(pid, SIGKILL);
577killProcessGroup(uid, pid, SIGKILL);
578pid_remove(pid);
579
580if (r) {
581ALOGE("kill(%d): errno=%d", procp->pid, errno);
582return -1;
583} else {
584return tasksize;
585}
586}

2.7、總結

上面的篇幅主要梳理了lmkd這一層，瞭解了AMS三種command在lmkd程序中是如何處理的。並且注意到三種command都對use_inkernel_interface進行了判斷，如果use_inkernel_interface等於1，那麼就執行kernel空間的邏輯，lmkd中資料結構也不用更新，也不用lmkd中殺程序的邏輯，全部都交給lmk完成。如果不等於１，那麼lmkd就需要自己維護程序的這些資料結構了。下篇繼續分析LowmemoryKiller殺程序機制。