目錄概覽.png
前面進程系列已經(jīng)更新了六篇，本文（基于Android O源碼），梳理LMK殺進程機制中篇，主要總結(jié)LowmemoryKiller的中l(wèi)mkd的原理部分。
Android進程系列第一篇---進程基礎
Android進程系列第二篇---Zygote進程的創(chuàng)建流程
Android進程系列第三篇---SystemServer進程的創(chuàng)建流程
Android進程系列第四篇---SystemServer進程的啟動流程
Android進程系列第五篇---應用進程的創(chuàng)建流程
Android進程系列第六篇---LowmemoryKiller機制分析(上)
上文說到LowmemoryKiller核心原理就是Framework層通過調(diào)整adj的值和閾值數(shù)組，輸送給kernel中的lmk，為lmk提供殺進程的原材料。AMS中給lmkd發(fā)送數(shù)據(jù)原材料有三個入口，對應攜帶的也有三種命令協(xié)議，每種協(xié)議代表內(nèi)核中一種數(shù)據(jù)的控制方式，如下表。
| 功能 | AMS對應方法 | 命令 | 內(nèi)核對應函數(shù) | |
|---|---|---|---|---|
| LMK_PROCPRIO | PL.setOomAdj() | 設置指定進程的優(yōu)先級，也就是oom_score_adj | cmd_procprio | |
| LMK_TARGET | PL.updateOomLevels() | 更新/sys/module/lowmemorykiller/parameters/中的minfree以及adj | cmd_target | |
| LMK_PROCREMOVE | PL.remove() | 移除進程 | cmd_procremove |
回顧一下上文說到的三層模型，就是下圖
LMK三層架構(gòu).png
Framework層通過調(diào)整adj的值和閾值數(shù)組，輸送給kernel中的lmk，為lmk提供殺進程的原材料，因為用戶空間和內(nèi)核空間相互隔離，就采用了文件節(jié)點進行通訊，用socket將adj的值與閾值數(shù)組傳給lmkd(5.0之后不在由AMS直接與lmk通信，引入lmkd守護進程)，lmkd將這些值寫到內(nèi)核節(jié)點中。lmk通過讀取這些節(jié)點，實現(xiàn)進程的kill，所以整個lmk機制大概就分成三層，第一篇我們梳理了Framework層，現(xiàn)在看后面兩層，首先是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
現(xiàn)在看一下它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);
//指定進程的調(diào)度策略, FIFO方式的實時調(diào)度策略
904 sched_setscheduler(0, SCHED_FIFO, ¶m);
//做一些初始化
905 if (!init())
//進入主循環(huán)，等待AMS發(fā)送的請求
906 mainloop();
907
908 ALOGI("exiting");
909 return 0;
910}
911
2.2、lmkd的數(shù)據(jù)結(jié)構(gòu)
在具體跟蹤main方法之前，需要看看lmkd的數(shù)據(jù)結(jié)構(gòu)，下面所有的代碼都在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，在之前已經(jīng)介紹過，可以回顧上篇博客。
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文件中的值實質(zhì)是來自lowmem_minfree和lowmem_adj兩個數(shù)組。lowmem_minfree[]和lowmem_adj[]數(shù)組大小個數(shù)都為6。
53enum lmk_cmd {
54 LMK_TARGET,
55 LMK_PROCPRIO,
56 LMK_PROCREMOVE,
57};
枚舉代表三種命令協(xié)議
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中進程的數(shù)據(jù)結(jié)構(gòu)是ProcessRocord，在lmkd中進程的數(shù)據(jù)結(jié)構(gòu)是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是一個雙向的鏈表，數(shù)組的下標index就是進程的優(yōu)先級，系統(tǒng)中同一個時刻，有很多進程的優(yōu)先級都是相同的，那么根據(jù)指定的優(yōu)先級就能從數(shù)組中獲取一個鏈表，這個鏈表上的所有proc的優(yōu)先級都是相同的，根據(jù)這個鏈表進一步選擇殺掉哪些進程。由于進程的優(yōu)先級可能是一個負數(shù)，所以加上了一個-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、監(jiān)聽
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以及數(shù)據(jù)read,當監(jiān)聽到socket連接事件后會調(diào)用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:用于回傳代處理事件的數(shù)組；
//maxevents:每次能處理的事件數(shù)；
//timeout:等待I/O事件發(fā)生的超時值(單位我也不太清楚)；-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}
調(diào)用epoll_wait阻塞，等待socket事件的到來
2.5、ctrl_command_handler函數(shù)對上層command的分發(fā)
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中的命令協(xié)議
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事件，根據(jù)pid，設置指定進程的優(yōu)先級，也就是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事件，根據(jù)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的回調(diào)函數(shù)，然后ctrl_connect_handler->ctrl_data_handler-> ctrl_command_handler的調(diào)用，對上層的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是將參數(shù)讀出來，這些參數(shù)來自與哪里呢？在上篇博客寫過，其實是和下面的代碼的for一一對應的，用lowmem_minfree[i] 數(shù)組保存水位線，用 lowmem_adj保存每條水位線對應的adj。其中有一個很關(guān)鍵的變量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數(shù)值
294 }
295 //將AMS已經(jīng)計算好的值通過socket發(fā)送到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寫入到文件節(jié)點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) {
//如果沒有找到，分配一個結(jié)點，調(diào)用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 {
//如果已經(jīng)存在，將原來優(yōu)先級的proc移除，然后新的優(yōu)先級的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
進程死掉后，會調(diào)用該進程的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 }
緊接著就會執(zhí)行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、總結(jié)
上面的篇幅主要梳理了lmkd這一層，了解了AMS三種command在lmkd進程中是如何處理的。并且注意到三種command都對use_inkernel_interface進行了判斷，如果use_inkernel_interface等于1，那么就執(zhí)行kernel空間的邏輯，lmkd中數(shù)據(jù)結(jié)構(gòu)也不用更新，也不用lmkd中殺進程的邏輯，全部都交給lmk完成。如果不等于１，那么lmkd就需要自己維護進程的這些數(shù)據(jù)結(jié)構(gòu)了。下篇繼續(xù)分析LowmemoryKiller殺進程機制。
