概述
Linux系統(tǒng)當(dāng)可用內(nèi)存較低的時(shí)候oom killer機(jī)制會(huì)根據(jù)一定的規(guī)則去殺掉一些進(jìn)程來釋放內(nèi)存坊谁，而Android系統(tǒng)的LowMemoryKiller機(jī)制就是以此功能為基礎(chǔ)做了一些調(diào)整费彼。Android系統(tǒng)中的APP在使用完成之后并不會(huì)馬上被殺掉，而是駐留在內(nèi)存中口芍，當(dāng)下一次在此進(jìn)入此應(yīng)用的時(shí)候可以省去進(jìn)程創(chuàng)建的過程箍铲，加快啟動(dòng)速度。LowMemoryKiller機(jī)制會(huì)在內(nèi)存資源緊張的時(shí)候鬓椭，殺掉一些進(jìn)程來回收內(nèi)存颠猴。
整體架構(gòu)
LowMemoryKiller機(jī)制分為三個(gè)部分
LowMemoryKiller整體結(jié)構(gòu)圖
- AMS部分的ProcessList
- Native進(jìn)程lmkd
- 內(nèi)核中的LowMemoryKiller部分
Framework中的ProcessList和Native的lmkd進(jìn)程通過Socket進(jìn)行進(jìn)程間通信，而lmkd和內(nèi)核中的LowMemoryKiller通過writeFileString向文件節(jié)點(diǎn)寫內(nèi)容方法進(jìn)行通信小染。
Framework層通過一定的規(guī)則調(diào)整進(jìn)程的adj的值和內(nèi)存空間閥值翘瓮，然后通過socket發(fā)送給lmkd進(jìn)程，lmkd兩種處理方式裤翩， 一種將閥值寫入文件節(jié)點(diǎn)發(fā)送給內(nèi)核的LowMemoryKiller资盅，由內(nèi)核進(jìn)行殺進(jìn)程處理，另一種是lmkd通過cgroup監(jiān)控內(nèi)存使用情況踊赠，自行計(jì)算殺掉進(jìn)程呵扛。
lmkd的啟動(dòng)和初始化
lmkd是一個(gè)native進(jìn)程，由init進(jìn)程啟動(dòng)筐带，定義在/system/core/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
在lmkd.rc中今穿，啟動(dòng)了lmkd進(jìn)程，并創(chuàng)建了一個(gè)名為lmkd的socket的描述符伦籍，用于socket進(jìn)程間通信荣赶。lmkd啟動(dòng)后首先執(zhí)行main方法。
int main(int argc __unused, char **argv __unused) {
struct sched_param param = {
.sched_priority = 1,
};
sched_setscheduler(0, SCHED_FIFO, ¶m);
if (!init())
mainloop();
}
main方法首先設(shè)置了當(dāng)前進(jìn)程的調(diào)度規(guī)則鸽斟，然后執(zhí)行了init方法和mainLoop方法。
static int init(void) {
struct epoll_event epev;
int i;
int ret;
//獲取當(dāng)前系統(tǒng)的頁大小利诺，單位kb
page_k = sysconf(_SC_PAGESIZE);
if (page_k == -1)
page_k = PAGE_SIZE;
page_k /= 1024;
// 創(chuàng)建一個(gè)epollfd描述符
epollfd = epoll_create(MAX_EPOLL_EVENTS);
if (epollfd == -1) {
ALOGE("epoll_create failed (errno=%d)", errno);
return -1;
}
// mark data connections as not connected
for (int i = 0; i < MAX_DATA_CONN; i++) {
data_sock[i].sock = -1;
}
// 獲取init.rc中創(chuàng)建的lmkd socket描述符
ctrl_sock.sock = android_get_control_socket("lmkd");
if (ctrl_sock.sock < 0) {
ALOGE("get lmkd control socket failed");
return -1;
}
// 監(jiān)聽socket的連接富蓄，即ProcessList的Socket連接
ret = listen(ctrl_sock.sock, MAX_DATA_CONN);
if (ret < 0) {
ALOGE("lmkd control socket listen failed (errno=%d)", errno);
return -1;
}
// Epoll 設(shè)置監(jiān)聽socket中的可讀事件，當(dāng)有可讀事件的時(shí)候回調(diào)ctrl_connect_hander方法
//處理socket連接過程
epev.events = EPOLLIN;
ctrl_sock.handler_info.handler = ctrl_connect_handler;
epev.data.ptr = (void *)&(ctrl_sock.handler_info);
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_sock.sock, &epev) == -1) {
ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
return -1;
}
maxevents++;
//檢測(cè)內(nèi)核是否支持lowMemoryKiller機(jī)制
has_inkernel_module = !access(INKERNEL_MINFREE_PATH, W_OK);
use_inkernel_interface = has_inkernel_module;
//如果內(nèi)核不支持LowMemoryKiller慢逾，則調(diào)用init_mp_common初始化立倍，在lmkd中實(shí)現(xiàn)進(jìn)程查殺過程
if (use_inkernel_interface) {
ALOGI("Using in-kernel low memory killer interface");
} else {
if (!init_mp_common(VMPRESS_LEVEL_LOW) ||
!init_mp_common(VMPRESS_LEVEL_MEDIUM) ||
!init_mp_common(VMPRESS_LEVEL_CRITICAL)) {
ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
return -1;
}
}
//初始化lmkd中的進(jìn)程列表
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;
}
lmkd的init方法中做的工作
- 獲取lmkd的socket描述符
- 創(chuàng)建epoll來監(jiān)聽socket的連接，如果有連接則回調(diào)ctrl_connect_handler方法來處理侣滩。
- 檢測(cè)是否有minfree接口口注，即內(nèi)核是否支持lowmemorykiller,如果內(nèi)核不支持則調(diào)用init_mp_common初始化，在lmkd中實(shí)現(xiàn)進(jìn)程查殺君珠。
為了防止剩余內(nèi)存過低寝志，Android在內(nèi)核空間有l(wèi)owmemorykiller(簡(jiǎn)稱LMK)，LMK是通過注冊(cè)shrinker來觸發(fā)低內(nèi)存回收的，這個(gè)機(jī)制并不太優(yōu)雅材部，可能會(huì)拖慢Shrinkers內(nèi)存掃描速度毫缆，已從內(nèi)核4.12中移除，后續(xù)會(huì)采用用戶空間的LMKD + memory cgroups機(jī)制
我們先分析內(nèi)核實(shí)現(xiàn)的LowMemoryKiller進(jìn)程查殺機(jī)制乐导， 然后再分析lmkd實(shí)現(xiàn)的機(jī)制苦丁。兩者最終的結(jié)果都是在內(nèi)存緊張的時(shí)候殺死一些進(jìn)程來釋放內(nèi)存， 但是實(shí)現(xiàn)機(jī)制去不太一樣物臂。
static void mainloop(void) {
struct event_handler_info* handler_info;
struct epoll_event *evt;
//循環(huán)等待epoll事件的上報(bào)
while (1) {
struct epoll_event events[maxevents];
int nevents;
int i;
nevents = epoll_wait(epollfd, events, maxevents, -1);
if (nevents == -1) {
if (errno == EINTR)
continue;
ALOGE("epoll_wait failed (errno=%d)", errno);
continue;
}
//獲取到對(duì)應(yīng)的epoll事件旺拉，分發(fā)給對(duì)應(yīng)的handler處理
for (i = 0, evt = &events[0]; i < nevents; ++i, evt++) {
if (evt->events & EPOLLERR)
ALOGD("EPOLLERR on event #%d", i);
if (evt->events & EPOLLHUP) {
/* This case was handled in the first pass */
continue;
}
if (evt->data.ptr) {
handler_info = (struct event_handler_info*)evt->data.ptr;
handler_info->handler(handler_info->data, evt->events);
}
}
}
}
init執(zhí)行初始化完成之后， 進(jìn)入mainloop方法棵磷，循環(huán)等待epoll事件的上報(bào)蛾狗，init的時(shí)候epoll監(jiān)聽的socket連接， 當(dāng)有socket連接的時(shí)候就會(huì)調(diào)用ctrl_connect_handler方法泽本。
static void ctrl_connect_handler(int data __unused, uint32_t events __unused) {
struct epoll_event epev;
int free_dscock_idx = get_free_dsock();
if (free_dscock_idx < 0) {
/*
* Number of data connections exceeded max supported. This should not
* happen but if it does we drop all existing connections and accept
* the new one. This prevents inactive connections from monopolizing
* data socket and if we drop ActivityManager connection it will
* immediately reconnect.
*/
for (int i = 0; i < MAX_DATA_CONN; i++) {
ctrl_data_close(i);
}
free_dscock_idx = 0;
}
//接受framework的socket連接
data_sock[free_dscock_idx].sock = accept(ctrl_sock.sock, NULL, NULL);
if (data_sock[free_dscock_idx].sock < 0) {
ALOGE("lmkd control socket accept failed; errno=%d", errno);
return;
}
ALOGI("lmkd data connection established");
//監(jiān)聽連接的socket通信淘太，當(dāng)socket有消息的時(shí)候會(huì)掉ctrl_data_handler方法。
data_sock[free_dscock_idx].handler_info.data = free_dscock_idx;
data_sock[free_dscock_idx].handler_info.handler = ctrl_data_handler;
epev.events = EPOLLIN;
epev.data.ptr = (void *)&(data_sock[free_dscock_idx].handler_info);
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, data_sock[free_dscock_idx].sock, &epev) == -1) {
ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
ctrl_data_close(free_dscock_idx);
return;
}
maxevents++;
}
監(jiān)聽到socket連接规丽， 我們知道此時(shí)連接lmkd的socket客戶端就是framework蒲牧，當(dāng)有連接到來的時(shí)候accept方法返回連接的socketFD, 然后將連接的socketFD同樣加入epoll中， 當(dāng)socketFD中有可讀消息赌莺，即framework給lmkd發(fā)送消息的時(shí)候冰抢，epoll喚醒然后會(huì)掉ctrl_data_handler方法來處理。
Framework和lmkd通信
Framework和lmkd進(jìn)程通過socket來進(jìn)行進(jìn)程間通信艘狭，在lmkd初始化的時(shí)候挎扰，通過監(jiān)聽socket描述符lmkd來等待Framework發(fā)送的消息。
Framework向lmkd發(fā)送命令相關(guān)的方法有三個(gè)巢音。
- AMS.updateConfiguration
更新配置遵倦，手機(jī)屏幕的尺寸和內(nèi)存大小不一樣，對(duì)應(yīng)的最小內(nèi)存閥值和adj值也不一樣, 最終調(diào)用ProcessList的updateOomLevel方法向lmkd發(fā)送調(diào)整命令- AMS.applyOomAdjLocked AMS根據(jù)一定的規(guī)則調(diào)整進(jìn)程的adj值官撼，最用通過ProcessList的setOomAdj方法發(fā)送給lmkd調(diào)整命令
- AMS.cleanUpApplicationRecordLocked & AMS.handleAppDiedLocked 進(jìn)程死亡后梧躺，調(diào)用ProcessList的remove方法移除進(jìn)程
上面的三種情況Framework最終是通過socket向lmkd發(fā)送了三種消息。
// LMK_TARGET <minfree> <minkillprio> ... (up to 6 pairs)
// LMK_PROCPRIO <pid> <uid> <prio>
// LMK_PROCREMOVE <pid>
//調(diào)整minfree和adj的值
static final byte LMK_TARGET = 0;
//設(shè)置對(duì)應(yīng)進(jìn)程的adj值
static final byte LMK_PROCPRIO = 1;
//移除對(duì)應(yīng)進(jìn)程
static final byte LMK_PROCREMOVE = 2;
lmkd接收命令處理邏輯
static void ctrl_command_handler(int dsock_idx) {
LMKD_CTRL_PACKET packet;
int len;
enum lmk_cmd cmd;
int nargs;
int targets;
//從socket中讀取數(shù)據(jù)
len = ctrl_data_read(dsock_idx, (char *)packet, CTRL_PACKET_MAX_SIZE);
if (len <= 0)
return;
if (len < (int)sizeof(int)) {
ALOGE("Wrong control socket read length len=%d", len);
return;
}
//解析Socket的命令和參數(shù)
cmd = lmkd_pack_get_cmd(packet);
nargs = len / sizeof(int) - 1;
if (nargs < 0)
goto wronglen;
switch(cmd) {
case LMK_TARGET:
targets = nargs / 2;
if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
goto wronglen;
//調(diào)整minfree和adj閥值
cmd_target(targets, packet);
break;
case LMK_PROCPRIO:
if (nargs != 3)
goto wronglen;
//設(shè)置對(duì)應(yīng)進(jìn)程的adj值
cmd_procprio(packet);
break;
case LMK_PROCREMOVE:
if (nargs != 1)
goto wronglen;
//移除對(duì)應(yīng)的進(jìn)程
cmd_procremove(packet);
break;
default:
ALOGE("Received unknown command code %d", cmd);
return;
}
return;
lmkd通過epoll監(jiān)聽socket中是否有數(shù)據(jù)傲绣， 當(dāng)接受的framework發(fā)送的socket命令之后掠哥，調(diào)用ctrl_cmmand_handler方法處理，顯示解析socket中的命令和參數(shù)秃诵，根據(jù)對(duì)于的命令來調(diào)用不同的方法處理续搀。
- cmd_target 調(diào)整最小內(nèi)存閥值和adj值
- cmd_procprio 調(diào)整進(jìn)程的adj值
- cmd_procremove 移除對(duì)應(yīng)的進(jìn)程
對(duì)于進(jìn)程查殺有兩種實(shí)現(xiàn)方式，一種是內(nèi)核的LMK菠净，通過shrinker來觸發(fā)低內(nèi)存回收禁舷， 另一種是lmkd通過cgroup監(jiān)控內(nèi)存使用情況彪杉，自行計(jì)算殺掉進(jìn)程。兩種實(shí)現(xiàn)不太一樣榛了，需要逐個(gè)分析在讶。
內(nèi)核LMK的實(shí)現(xiàn)
cmd_target
static void cmd_target(int ntargets, LMKD_CTRL_PACKET packet) {
int i;
struct lmk_target target;
lowmem_targets_size = ntargets;
//使用kernel中的LMK
if (has_inkernel_module) {
char minfreestr[128];
char killpriostr[128];
minfreestr[0] = '\0';
killpriostr[0] = '\0';
//將從framework收到的內(nèi)存閥值和adj值封裝成字符串，以霜大，分隔
//如 18432,23040,27648,32256,55296,80640
//0,100,200,300,900,906
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", use_inkernel_interface ? lowmem_minfree[i] : 0);
strlcat(minfreestr, val, sizeof(minfreestr));
snprintf(val, sizeof(val), "%d", use_inkernel_interface ? lowmem_adj[i] : 0);
strlcat(killpriostr, val, sizeof(killpriostr));
}
// 將字符串分別寫入 /sys/module/lowmemorykiller/parameters/minfree
// 和/sys/module/lowmemorykiller/parameters/adj
writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
writefilestring(INKERNEL_ADJ_PATH, killpriostr);
}
}
設(shè)置內(nèi)存閥值和adj的值就是將從framework收到的數(shù)據(jù)封裝成字符串构哺，通過writefilestring寫入到兩個(gè)文件節(jié)點(diǎn)，以供內(nèi)核LMK使用战坤。
/sys/module/lowmemorykiller/parameters/minfree ： 內(nèi)存級(jí)別限額
/sys/module/lowmemorykiller/parameters/adj ：內(nèi)存級(jí)別限額對(duì)應(yīng)的要?dú)⒌舻倪M(jìn)程的adj值.
cmd_procprio
static void cmd_procprio(LMKD_CTRL_PACKET packet) {
struct proc *procp;
char path[80];
char val[20];
int soft_limit_mult;
struct lmk_procprio params;
//解析進(jìn)程adj相關(guān)的參數(shù)
lmkd_pack_get_procprio(packet, ¶ms);
if (params.oomadj < OOM_SCORE_ADJ_MIN ||
params.oomadj > OOM_SCORE_ADJ_MAX) {
ALOGE("Invalid PROCPRIO oomadj argument %d", params.oomadj);
return;
}
//將進(jìn)程優(yōu)先級(jí)寫入到/proc/進(jìn)程id/oom_score_adj文件中
snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", params.pid);
snprintf(val, sizeof(val), "%d", params.oomadj);
writefilestring(path, val);
if (use_inkernel_interface)
return;
}
由于使用內(nèi)核LMK, 所以調(diào)整進(jìn)程優(yōu)先級(jí)直接將優(yōu)先級(jí)寫入對(duì)應(yīng)進(jìn)程的oom_adj_score文件即可曙强。
cmd_procremove
static void cmd_procremove(LMKD_CTRL_PACKET packet) {
struct lmk_procremove params;
//內(nèi)核LMK,移除進(jìn)程什么都不需要做，全部有內(nèi)核處理
if (use_inkernel_interface)
return;
}
移除進(jìn)程的時(shí)候不需要做任何操作
內(nèi)核LowMemoryKiller的實(shí)現(xiàn)原理
在linux中途茫，有一個(gè)名為kswapd的內(nèi)核線程碟嘴，當(dāng)linux回收存放分頁的時(shí)候，kswapd線程將會(huì)遍歷一張shrinker鏈表囊卜，并執(zhí)行回調(diào)娜扇，或者某個(gè)app啟動(dòng)，發(fā)現(xiàn)可用內(nèi)存不足時(shí)栅组，則內(nèi)核會(huì)阻塞請(qǐng)求分配內(nèi)存的進(jìn)程分配內(nèi)存的過程雀瓢，并在該進(jìn)程中去執(zhí)行l(wèi)owmemorykiller來釋放內(nèi)存。雖然之前沒有接觸過玉掸，大體的理解就是向系統(tǒng)注冊(cè)了這個(gè)shrinker回調(diào)函數(shù)之后刃麸，當(dāng)系統(tǒng)空閑內(nèi)存頁面不足時(shí)會(huì)調(diào)用這個(gè)回調(diào)函數(shù)。 struct shrinker的定義在linux/kernel/include/linux/shrinker.h中：
內(nèi)核LowMemoryKiller shrinker的注冊(cè)過程如下：
static struct shrinker lowmem_shrinker = {
.scan_objects = lowmem_scan,
.count_objects = lowmem_count,
.seeks = DEFAULT_SEEKS * 16
};
static int __init lowmem_init(void)
{
register_shrinker(&lowmem_shrinker);
return 0;
}
static void __exit lowmem_exit(void)
{
unregister_shrinker(&lowmem_shrinker);
}
注冊(cè)完成之后司浪， 在內(nèi)存緊張的時(shí)候就會(huì)回調(diào)shrinker, 其中最主要的是lowmem_scan方法泊业。具體實(shí)現(xiàn)如下：
static unsigned long lowmem_scan(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
//選中要?dú)⒌暨M(jìn)程的task_struct
struct task_struct *selected = NULL;
unsigned long rem = 0;
int tasksize;
int I;
//min_score_adj 初始值=1000
short min_score_adj = OOM_SCORE_ADJ_MAX + 1;
int minfree = 0;
//要?dú)⒌暨M(jìn)程占用內(nèi)存的大小
int selected_tasksize = 0;
//要?dú)⒌暨M(jìn)程的adj值
short selected_oom_score_adj;
//獲取并計(jì)算剩余內(nèi)存的大小
int array_size = ARRAY_SIZE(lowmem_adj);
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) -
total_swapcache_pages();
//從minfree中和adj節(jié)點(diǎn)中獲取的數(shù)據(jù)初始化內(nèi)存限額和adj
if (lowmem_adj_size < array_size)
array_size = lowmem_adj_size;
if (lowmem_minfree_size < array_size)
array_size = lowmem_minfree_size;
// 內(nèi)存限額從小到大遍歷， 找到剩余內(nèi)存屬于哪一個(gè)閥值啊易，并獲取它對(duì)應(yīng)的adj值
for (i = 0; i < array_size; i++) {
minfree = lowmem_minfree[i];
if (other_free < minfree && other_file < minfree) {
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);
//如果adj值為初始值1000吁伺，則內(nèi)存情況良好無需殺掉進(jìn)程
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_read_lock();
//遍歷進(jìn)程列表
for_each_process(tsk) {
struct task_struct *p;
short oom_score_adj;
if (tsk->flags & PF_KTHREAD)
continue;
p = find_lock_task_mm(tsk);
if (!p)
continue;
if (test_tsk_thread_flag(p, TIF_MEMDIE) &&
time_before_eq(jiffies, lowmem_deathpending_timeout)) {
task_unlock(p);
rcu_read_unlock();
return 0;
}
//獲取進(jìn)程的adj值，如果進(jìn)程的adj值小于目標(biāo)adj值租谈，則繼續(xù)尋找
oom_score_adj = p->signal->oom_score_adj;
if (oom_score_adj < min_score_adj) {
task_unlock(p);
continue;
}
//找到adj值大于目標(biāo)adj的進(jìn)程后箱蝠，首先計(jì)算該進(jìn)程占用的內(nèi)存大小，
//如果兩個(gè)進(jìn)程的adj一般大垦垂，則找占用內(nèi)存大的一個(gè)進(jìn)程
tasksize = get_mm_rss(p->mm);
task_unlock(p);
if (tasksize <= 0)
continue;
if (selected) {
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;
lowmem_print(2, "select '%s' (%d), adj %hd, size %d, to kill\n",
p->comm, p->pid, oom_score_adj, tasksize);
}
//將找到的進(jìn)程發(fā)送SIGKILL殺掉該進(jìn)程從而釋放內(nèi)存
if (selected) {
long cache_size = other_file * (long)(PAGE_SIZE / 1024);
long cache_limit = minfree * (long)(PAGE_SIZE / 1024);
long free = other_free * (long)(PAGE_SIZE / 1024);
trace_lowmemory_kill(selected, cache_size, cache_limit, free);
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,
cache_size, cache_limit,
min_score_adj,
free);
lowmem_deathpending_timeout = jiffies + HZ;
set_tsk_thread_flag(selected, TIF_MEMDIE);
send_sig(SIGKILL, selected, 0);
rem += selected_tasksize;
}
lowmem_print(4, "lowmem_scan %lu, %x, return %lu\n",
sc->nr_to_scan, sc->gfp_mask, rem);
rcu_read_unlock();
return rem;
}
內(nèi)核LMK的原理很簡(jiǎn)單：首先注冊(cè)了shrinker，在內(nèi)存緊張的時(shí)候會(huì)觸發(fā)lowmem_scan方法牙瓢，這個(gè)方法要做的就是找打一個(gè)進(jìn)程劫拗，然后殺掉他，釋放一些內(nèi)存矾克。
- 獲取剩余內(nèi)存的大小页慷，和Minfree內(nèi)存閥值做比較，找到對(duì)應(yīng)的內(nèi)存閥值，找到對(duì)應(yīng)的adj值酒繁。
- 遍歷所有的進(jìn)程滓彰，大于該adj的值的進(jìn)程是要?dú)⒌舻哪繕?biāo)進(jìn)程， 但是并不是全部殺掉州袒，而是找到adj最大的進(jìn)程殺掉揭绑，如果最大adj有多個(gè)相同adj進(jìn)程，則殺掉占用內(nèi)存最大的一個(gè)
內(nèi)核LMK的實(shí)現(xiàn)邏輯已經(jīng)分析完了
lmkd內(nèi)存查殺的實(shí)現(xiàn)
lmkd實(shí)現(xiàn)內(nèi)存查實(shí)的方式是基于cgroup memory來實(shí)現(xiàn)的郎哭。
什么是cgroup memory?
Cgroup的memory子系統(tǒng)他匪，即memory cgroup(本文以下簡(jiǎn)稱memcg)，提供了對(duì)系統(tǒng)中一組進(jìn)程的內(nèi)存行為的管理夸研，從而對(duì)整個(gè)系統(tǒng)中對(duì)內(nèi)存有不用需求的進(jìn)程或應(yīng)用程序區(qū)分管理邦蜜，實(shí)現(xiàn)更有效的資源利用和隔離。
cgroup memory相關(guān)的文件
cgroup.event_control #用于eventfd的接口
memory.usage_in_bytes #顯示當(dāng)前已用的內(nèi)存
memory.limit_in_bytes #設(shè)置/顯示當(dāng)前限制的內(nèi)存額度
memory.failcnt #顯示內(nèi)存使用量達(dá)到限制值的次數(shù)
memory.max_usage_in_bytes #歷史內(nèi)存最大使用量
memory.soft_limit_in_bytes #設(shè)置/顯示當(dāng)前限制的內(nèi)存軟額度
memory.stat #顯示當(dāng)前cgroup的內(nèi)存使用情況
memory.use_hierarchy #設(shè)置/顯示是否將子cgroup的內(nèi)存使用情況統(tǒng)計(jì)到當(dāng)前cgroup里面
memory.force_empty #觸發(fā)系統(tǒng)立即盡可能的回收當(dāng)前cgroup中可以回收的內(nèi)存
memory.pressure_level #設(shè)置內(nèi)存壓力的通知事件亥至，配合cgroup.event_control一起使用
memory.swappiness #設(shè)置和顯示當(dāng)前的swappiness
memory.move_charge_at_immigrate #設(shè)置當(dāng)進(jìn)程移動(dòng)到其他cgroup中時(shí)悼沈，它所占用的內(nèi)存是否也隨著移動(dòng)過去
memory.oom_control #設(shè)置/顯示oom controls相關(guān)的配置
memory.numa_stat #顯示numa相關(guān)的內(nèi)存
簡(jiǎn)單的了解了下cgroup的原理，再來看lmkd的init方法
static int init(void) {
has_inkernel_module = !access(INKERNEL_MINFREE_PATH, W_OK);
use_inkernel_interface = has_inkernel_module;
if (use_inkernel_interface) {
ALOGI("Using in-kernel low memory killer interface");
} else {
//如果沒有使用內(nèi)核LMK機(jī)制姐扮，則初始化memory pressure
if (!init_mp_common(VMPRESS_LEVEL_LOW) ||
!init_mp_common(VMPRESS_LEVEL_MEDIUM) ||
!init_mp_common(VMPRESS_LEVEL_CRITICAL)) {
ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
return -1;
}
}
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;
}
static bool init_mp_common(enum vmpressure_level level) {
int mpfd;
int evfd;
int evctlfd;
char buf[256];
struct epoll_event epev;
int ret;
int level_idx = (int)level;
const char *levelstr = level_name[level_idx];
//打開pressure_level的文件節(jié)點(diǎn)
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;
}
//打開event_control的文件節(jié)點(diǎn)
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;
}
//創(chuàng)建一個(gè)eventfd
evfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
if (evfd < 0) {
ALOGE("eventfd failed for level %s; errno=%d", levelstr, errno);
goto err_eventfd;
}
//往cgroup.event_control中寫入：<event_fd> <pressure_level_fd> <level>
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 = TEMP_FAILURE_RETRY(write(evctlfd, buf, strlen(buf) + 1));
if (ret == -1) {
ALOGE("cgroup.event_control write failed for level %s; errno=%d",
levelstr, errno);
goto err;
}
//然后使用epoll監(jiān)聽evfd, 等待memory pressure_level的事件通知
epev.events = EPOLLIN;
/* use data to store event level */
vmpressure_hinfo[level_idx].data = level_idx;
vmpressure_hinfo[level_idx].handler = mp_event_common;
epev.data.ptr = (void *)&vmpressure_hinfo[level_idx];
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[level] = evfd;
close(evctlfd);
return true;
err:
close(evfd);
err_eventfd:
close(evctlfd);
err_open_evctlfd:
close(mpfd);
err_open_mpfd:
return false;
}
先了解下memory pressure_level的用法
memory.pressure_level
這個(gè)文件主要用來監(jiān)控當(dāng)前cgroup的內(nèi)存壓力絮供，當(dāng)內(nèi)存壓力大時(shí)（即已使用內(nèi)存快達(dá)到設(shè)置的限額），在分配內(nèi)存之前需要先回收部分內(nèi)存溶握，從而影響內(nèi)存分配速度杯缺，影響性能，而通過監(jiān)控當(dāng)前cgroup的內(nèi)存壓力睡榆，可以在有壓力的時(shí)候采取一定的行動(dòng)來改善當(dāng)前cgroup的性能萍肆，比如關(guān)閉當(dāng)前cgroup中不重要的服務(wù)等。目前有三種壓力水平：
low
意味著系統(tǒng)在開始為當(dāng)前cgroup分配內(nèi)存之前胀屿，需要先回收內(nèi)存中的數(shù)據(jù)了塘揣，這時(shí)候回收的是在磁盤上有對(duì)應(yīng)文件的內(nèi)存數(shù)據(jù)。
medium
意味著系統(tǒng)已經(jīng)開始頻繁為當(dāng)前cgroup使用交換空間了宿崭。
critical
快撐不住了亲铡，系統(tǒng)隨時(shí)有可能kill掉cgroup中的進(jìn)程。如何配置相關(guān)的監(jiān)聽事件呢葡兑？和memory.oom_control類似奖蔓，大概步驟如下：
利用函數(shù)eventfd(2)創(chuàng)建一個(gè)event_fd
打開文件memory.pressure_level，得到pressure_level_fd
往cgroup.event_control中寫入這么一串：<event_fd> <pressure_level_fd> <level>
然后通過讀event_fd得到通知
init_mp_common方法嚴(yán)格的按照pressure_level的用法讹堤，注冊(cè)了pressure_level的事件回調(diào), pressure_level分為三個(gè)等級(jí)
static const char *level_name[] = {
"low",
"medium",
"critical"
};
當(dāng)內(nèi)存達(dá)到相應(yīng)的等級(jí)吆鹤，就會(huì)回調(diào)mp_event_common方法， 由mp_event_common方法來處理洲守。
static void mp_event_common(int data, uint32_t events __unused) {
int ret;
unsigned long long evcount;
int64_t mem_usage, memsw_usage;
int64_t mem_pressure;
enum vmpressure_level lvl;
union meminfo mi;
union zoneinfo zi;
static struct timeval last_report_tm;
static unsigned long skip_count = 0;
enum vmpressure_level level = (enum vmpressure_level)data;
long other_free = 0, other_file = 0;
int min_score_adj;
int pages_to_free = 0;
int minfree = 0;
static struct reread_data mem_usage_file_data = {
.filename = MEMCG_MEMORY_USAGE,
.fd = -1,
};
static struct reread_data memsw_usage_file_data = {
.filename = MEMCG_MEMORYSW_USAGE,
.fd = -1,
};
//檢查觸發(fā)該方法壓力類型疑务，如果大于一種類型出發(fā)沾凄，則選擇壓力大的一個(gè)
for (lvl = VMPRESS_LEVEL_LOW; lvl < VMPRESS_LEVEL_COUNT; lvl++) {
if (mpevfd[lvl] != -1 &&
TEMP_FAILURE_RETRY(read(mpevfd[lvl],
&evcount, sizeof(evcount))) > 0 &&
evcount > 0 && lvl > level) {
level = lvl;
}
}
//獲取剩余內(nèi)存的大小
if (meminfo_parse(&mi) < 0 || zoneinfo_parse(&zi) < 0) {
ALOGE("Failed to get free memory!");
return;
}
//使用設(shè)置的最小內(nèi)存閥值
if (use_minfree_levels) {
int i;
//獲取剩余內(nèi)存大小
other_free = mi.field.nr_free_pages - zi.field.totalreserve_pages;
if (mi.field.nr_file_pages > (mi.field.shmem + mi.field.unevictable + mi.field.swap_cached)) {
other_file = (mi.field.nr_file_pages - mi.field.shmem -
mi.field.unevictable - mi.field.swap_cached);
} else {
other_file = 0;
}
//根據(jù)剩余內(nèi)存大小，找到對(duì)應(yīng)的內(nèi)存閥值及adj的值
min_score_adj = OOM_SCORE_ADJ_MAX + 1;
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;
}
}
//如果得到的adj值=1000知允， 則表示內(nèi)存狀況良好撒蟀，無需查殺內(nèi)存直接返回
if (min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
if (debug_process_killing) {
ALOGI("Ignore %s memory pressure event "
"(free memory=%ldkB, cache=%ldkB, limit=%ldkB)",
level_name[level], other_free * page_k, other_file * page_k,
(long)lowmem_minfree[lowmem_targets_size - 1] * page_k);
}
return;
}
//計(jì)算要達(dá)到最大內(nèi)存閥值情況下需要釋放的內(nèi)存大小
/* Free up enough pages to push over the highest minfree level */
pages_to_free = lowmem_minfree[lowmem_targets_size - 1] -
((other_free < other_file) ? other_free : other_file);
goto do_kill;
}
if (level == VMPRESS_LEVEL_LOW) {
record_low_pressure_levels(&mi);
}
//內(nèi)存狀況良好， 無需查殺温鸽，直接退出
if (level_oomadj[level] > OOM_SCORE_ADJ_MAX) {
/* Do not monitor this pressure level */
return;
}
if ((mem_usage = get_memory_usage(&mem_usage_file_data)) < 0) {
goto do_kill;
}
if ((memsw_usage = get_memory_usage(&memsw_usage_file_data)) < 0) {
goto do_kill;
}
// Calculate percent for swappinness.
mem_pressure = (mem_usage * 100) / memsw_usage;
//根據(jù)一定的規(guī)則保屯，計(jì)算出壓力level
if (enable_pressure_upgrade && level != VMPRESS_LEVEL_CRITICAL) {
// We are swapping too much.
if (mem_pressure < upgrade_pressure) {
level = upgrade_level(level);
if (debug_process_killing) {
ALOGI("Event upgraded to %s", level_name[level]);
}
}
}
// If the pressure is larger than downgrade_pressure lmk will not
// kill any process, since enough memory is available.
if (mem_pressure > downgrade_pressure) {
if (debug_process_killing) {
ALOGI("Ignore %s memory pressure", level_name[level]);
}
return;
} else if (level == VMPRESS_LEVEL_CRITICAL &&
mem_pressure > upgrade_pressure) {
if (debug_process_killing) {
ALOGI("Downgrade critical memory pressure");
}
// Downgrade event, since enough memory available.
level = downgrade_level(level);
}
do_kill:
if (low_ram_device) {
//只殺掉一個(gè)進(jìn)程
if (find_and_kill_processes(level, level_oomadj[level], 0) == 0) {
if (debug_process_killing) {
ALOGI("Nothing to kill");
}
}
} else {
int pages_freed;
//如果不使用設(shè)置的minfree內(nèi)存閥值，則根據(jù)計(jì)算level對(duì)應(yīng)的adj來查殺內(nèi)存
if (!use_minfree_levels) {
/* If pressure level is less than critical and enough free swap then ignore */
if (level < VMPRESS_LEVEL_CRITICAL &&
mi.field.free_swap > low_pressure_mem.max_nr_free_pages) {
if (debug_process_killing) {
ALOGI("Ignoring pressure since %" PRId64
" swap pages are available ",
mi.field.free_swap);
}
return;
}
//計(jì)算出需要釋放的內(nèi)存大小
if (mi.field.nr_free_pages < low_pressure_mem.max_nr_free_pages) {
pages_to_free = low_pressure_mem.max_nr_free_pages -
mi.field.nr_free_pages;
} else {
if (debug_process_killing) {
ALOGI("Ignoring pressure since more memory is "
"available (%" PRId64 ") than watermark (%" PRId64 ")",
mi.field.nr_free_pages, low_pressure_mem.max_nr_free_pages);
}
return;
}
min_score_adj = level_oomadj[level];
}
//根據(jù)min_score_adj和page_to_free來殺掉進(jìn)程
//大于min_score_adj的進(jìn)程都屬于目標(biāo)進(jìn)程嗤朴，循環(huán)查殺配椭，并累計(jì)殺掉線程釋放內(nèi)存的大小
//當(dāng)釋放的內(nèi)存大于page_to_free的大小的時(shí)候，就可以停止了
pages_freed = find_and_kill_processes(level, min_score_adj, pages_to_free);
if (use_minfree_levels) {
ALOGI("Killing because cache %ldkB is below "
"limit %ldkB for oom_adj %d\n"
" Free memory is %ldkB %s reserved",
other_file * page_k, minfree * page_k, min_score_adj,
other_free * page_k, other_free >= 0 ? "above" : "below");
}
if (pages_freed < pages_to_free) {
ALOGI("Unable to free enough memory (pages to free=%d, pages freed=%d)",
pages_to_free, pages_freed);
} else {
ALOGI("Reclaimed enough memory (pages to free=%d, pages freed=%d)",
pages_to_free, pages_freed);
gettimeofday(&last_report_tm, NULL);
}
}
}
lmkd內(nèi)存查殺原理：
- 當(dāng)內(nèi)存壓力出發(fā)該方法的時(shí)候雹姊，讀取當(dāng)前的內(nèi)存壓力類型
- 獲取當(dāng)前剩余內(nèi)存的大小
- 根據(jù)剩余內(nèi)存計(jì)算要?dú)⒌暨M(jìn)程的adj值股缸，以及需要釋放內(nèi)存的大小
分為兩種情況：
a: 如果使用的是設(shè)置的minfree和adj值，則根據(jù)剩余內(nèi)存大小找到對(duì)應(yīng)的adj吱雏，和需要釋放內(nèi)存大小
b:如果不使用設(shè)置的內(nèi)存閥值敦姻，則根據(jù)當(dāng)前壓力類型計(jì)算adj，以及達(dá)到上一個(gè)等級(jí)需要釋放內(nèi)存大小 - 根據(jù)以上計(jì)算的adj和需要釋放內(nèi)存大小來查殺內(nèi)存歧杏，從大于adj的進(jìn)程中開始查殺進(jìn)程并釋放內(nèi)存镰惦，當(dāng)釋放內(nèi)存大小達(dá)到需求 就可以停止查殺內(nèi)存了。
總結(jié)
進(jìn)程查殺的兩種實(shí)現(xiàn)方式原理類似犬绒，都是注冊(cè)是的回調(diào)旺入，當(dāng)內(nèi)存緊張的時(shí)候根據(jù)剩余內(nèi)存的adj來查殺大于該adj的內(nèi)存。內(nèi)核shrinker方式是只有內(nèi)存緊張的時(shí)候才會(huì)去釋放凯力，而cgroup方式控制更加精細(xì)茵瘾， 根據(jù)不同等級(jí)來觸發(fā)內(nèi)存回收。
