1.概述
Android底層還是基于Linux，在Linux中低記憶體是會有oom killer去殺掉一些行程去釋放記憶體，而Android中的lowmemorykiller就是在此基礎上做了一些調整來的，因為手機上的記憶體畢竟比較有限，而Android中APP在不使用之后并不是馬上被殺掉，雖然上層ActivityManagerService中也有很多關于行程的調度以及殺行程的手段，但是畢竟還需要考慮手機剩余記憶體的實際情況，
lowmemorykiller的作用就是當記憶體比較緊張的時候去及時殺掉一些ActivityManagerService還沒來得及殺掉但是對用戶來說不那么重要的行程，回收一些記憶體，保證手機的正常運行，
lowmemkiller中會涉及到幾個重要的概念：
/sys/module/lowmemorykiller/parameters/minfree：里面是以”,”分割的一組數，每個數字代表一個記憶體級別
/sys/module/lowmemorykiller/parameters/adj：對應上面的一組數，每個陣列代表一個行程優先級級別
舉個例子：
/sys/module/lowmemorykiller/parameters/minfree：18432,23040,27648,32256,55296,80640
/sys/module/lowmemorykiller/parameters/adj：0,100,200,300,900,906
代表的意思：兩組數一一對應，當手機記憶體低于80640時，就去殺掉優先級906以及以上級別的行程，當記憶體低于55296時，就去殺掉優先級900以及以上的行程，
對每個行程來說：
/proc/pid/oom_adj：代表當前行程的優先級，這個優先級是kernel中的優先級，這個優先級與上層的優先級之間有一個換算，文章最后會提一下，
/proc/pid/oom_score_adj：上層優先級，跟ProcessList中的優先級對應
2.init行程lmkd
代碼位置:platform/system/core/lmkd/
ProcessList中定義有行程的優先級，越重要的行程的優先級越低，前臺APP的優先級為0，系統APP的優先級一般都是負值，所以一般行程管理以及殺行程都是針對與上層的APP來說的，而這些行程的優先級調整都在AMS里面，AMS根據行程中的組件的狀態去不斷的計算每個行程的優先級，計算之后，會及時更新到對應行程的檔案節點中，而這個對檔案節點的更新并不是它完成的，而是lmkd，他們之間通過socket通信，
lmkd在手機中是一個常駐行程，用來處理上層ActivityManager在進行updateOomAdj之后，通過socket與lmkd進行通信，更新行程的優先級，如果必要則殺掉行程釋放記憶體，lmkd是在init行程啟動的時候啟動的，在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
上層AMS跟lmkd通信主要分為三種command，每種command代表一種資料控制方式，在ProcessList以及lmkd中都有定義：
LMK_TARGET：更新/sys/module/lowmemorykiller/parameters/中的minfree以及adj
LMK_PROCPRIO：更新指定行程的優先級，也就是oom_score_adj
LMK_PROCREMOVE：移除行程
在開始介紹lmkd的處理邏輯之前，lmkd.c中有幾個重要的變數與資料結構提前說明一下：
// 記憶體級別限額
#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
// 不同級別記憶體對應要殺的的優先級
#define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"
// 裝載上面兩組數字的陣列
static int lowmem_adj[MAX_TARGETS];
static int lowmem_minfree[MAX_TARGETS];
// 三種command
enum lmk_cmd {
LMK_TARGET,
LMK_PROCPRIO,
LMK_PROCREMOVE,
};
// 優先級的最小值
#define OOM_SCORE_ADJ_MIN (-1000)
// 優先級最大值
#define OOM_SCORE_ADJ_MAX 1000
// 雙向鏈表結構體
struct adjslot_list {
struct adjslot_list *next;
struct adjslot_list *prev;
};
// 行程在lmkd中的資料結構體
struct proc {
struct adjslot_list asl;
int pid;
uid_t uid;
int oomadj;
struct proc *pidhash_next;
};
// 存放行程proc的hashtable，index是通過pid的計算得出
static struct proc *pidhash[PIDHASH_SZ];
// 根據pid計算index的hash演算法
#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
// 行程優先級到陣列的index之間的轉換
// 因為行程的優先級可以是負值，但是陣列的index不能為負值
// 不過因為這個轉換只是簡單加了1000，為了方便，后面的描述中就認為是優先級直接做了index
#define ADJTOSLOT(adj) (adj + -OOM_SCORE_ADJ_MIN)
// table，類似hashtable，不過計算index的方式不是hash，而是oom_score_adj經過轉換后直接作為index
// 陣列的每個元素都是雙向回圈鏈表
// 行程的優先級作為陣列的index
// 即以行程的優先級為index，從-1000到+1000 + 1大小的陣列，根據優先級，同優先級的行程index相同
// 每個元素是一個雙向鏈表，這個鏈表上的所有proc的優先級都相同
// 這樣根據優先級殺行程的時候就會非常方便，要殺指定優先級的行程可以根據優先級獲取到一個行程鏈表，逐個去殺，
static struct adjslot_list procadjslot_list[ADJTOSLOT(OOM_SCORE_ADJ_MAX) + 1];
2.1 lmkd行程啟動入口
int main(int argc __unused, char **argv __unused) {
struct sched_param param = {
.sched_priority = 1,
};
// 將此行程未來使用到的所有記憶體都鎖在物理記憶體中，防止記憶體被交換
mlockall(MCL_FUTURE);
// 設定此執行緒的調度策略為SCHED_FIFO，first-in-first-out，param中主要設定sched_priority
// 由于SCHED_FIFO是一種實時調度策略，在這個策略下優先級從1(low) -> 99(high)
// 實時執行緒通常會比普通執行緒有更高的優先級
sched_setscheduler(0, SCHED_FIFO, ¶m);
// 初始化epoll以及與ActivityManager的socket連接,等待cmd和data
if (!init())
// 進入死回圈epoll_wait等待fd事件
mainloop();
ALOGI("exiting");
return 0;
}
前面已經提到，這個行程存在的主要作用是跟AMS進行通信，更新oomAdj，在必要的時候殺掉行程，所以在main函式中主要就是創建了epoll以及初始化socket并連接ActivityManager，然后阻塞等待上層傳遞cmd以及資料過來，
2.2 init初始化
static int init(void) {
...
// 拿到lmkd的socket fd
ctrl_lfd = android_get_control_socket("lmkd");
if (ctrl_lfd < 0) {
ALOGE("get lmkd control socket failed");
return -1;
}
// server listen
ret = listen(ctrl_lfd, 1);
if (ret < 0) {
ALOGE("lmkd control socket listen failed (errno=%d)", errno);
return -1;
}
epev.events = EPOLLIN;
// ctrl_connect_handler里面完成了soclet的accpet以及read資料，并對資料進行相應的處理
epev.data.ptr = (void *)ctrl_connect_handler;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_lfd, &epev) == -1) {
ALOGE("epoll_ctl for lmkd control socket failed (errno=%d)", errno);
return -1;
}
maxevents++;
// 使用kernel空間的處理
use_inkernel_interface = !access(INKERNEL_MINFREE_PATH, W_OK);
if (use_inkernel_interface) {
ALOGI("Using in-kernel low memory killer interface");
} else {
ret = init_mp(MEMPRESSURE_WATCH_LEVEL, (void *)&mp_event);
if (ret)
ALOGE("Kernel does not support memory pressure events or in-kernel low memory killer");
}
// 雙向鏈表初始化
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;
}
在初始化的時候，有一個很重要的判斷：use_inkernel_interface，這個是根據是否有/sys/module/lowmemorykiller/parameters/minfree的寫權限來判斷的，沒有的情況下就使用kernel空間的邏輯
目前遇到的都是use_inkernel_interface
如果use_inkernel_interface的值為false：
2.3 進入loop回圈mainloop
// 進入死回圈，然后呼叫epoll_wait阻塞等待事件的到來
static void mainloop(void) {
while (1) {
struct epoll_event events[maxevents];
int nevents;
int i;
ctrl_dfd_reopened = 0;
nevents = epoll_wait(epollfd, events, maxevents, -1);
if (nevents == -1) {
if (errno == EINTR)
continue;
ALOGE("epoll_wait failed (errno=%d)", errno);
continue;
}
for (i = 0; i < nevents; ++i) {
if (events[i].events & EPOLLERR)
ALOGD("EPOLLERR on event #%d", i);
if (events[i].data.ptr)
(*(void (*)(uint32_t))events[i].data.ptr)(events[i].events);
}
}
}
2.4 處理socket傳遞過來的資料ctrl_command_handler
前面在ctrl_connect_handler這個方法中處理了accept，并開始了ctrl_data_handler中讀取資料并進行處理：ctrl_command_handler，對于ActivityManager傳遞來的Command以及data的主要處理邏輯就在ctrl_command_handler中，
static void ctrl_command_handler(void) {
int ibuf[CTRL_PACKET_MAX / sizeof(int)];
int len;
int cmd = -1;
int nargs;
int targets;
len = ctrl_data_read((char *)ibuf, CTRL_PACKET_MAX);
if (len <= 0)
return;
nargs = len / sizeof(int) - 1;
if (nargs < 0)
goto wronglen;
cmd = ntohl(ibuf[0]);
// 一共三種command，在前面靜態變數的定義處已經介紹過
switch(cmd) {
// 更新記憶體級別以及對應級別的行程adj
case LMK_TARGET:
targets = nargs / 2;
if (nargs & 0x1 || targets > (int)ARRAY_SIZE(lowmem_adj))
goto wronglen;
cmd_target(targets, &ibuf[1]);
break;
// 根據pid更新adj
case LMK_PROCPRIO:
if (nargs != 3)
goto wronglen;
cmd_procprio(ntohl(ibuf[1]), ntohl(ibuf[2]), ntohl(ibuf[3]));
break;
// 根據pid移除proc
case LMK_PROCREMOVE:
if (nargs != 1)
goto wronglen;
cmd_procremove(ntohl(ibuf[1]));
break;
default:
ALOGE("Received unknown command code %d", cmd);
return;
}
return;
wronglen:
ALOGE("Wrong control socket read length cmd=%d len=%d", cmd, len);
}
上層代碼的呼叫時機這里就不細化了，往前追的話基本都是在ActivityManagerService中的udpateOomAdj中，也就是說上層根據四大組件的狀態對行程的優先級進行調整之后，會及時的反應到lmkd中，在記憶體不足的時候觸發殺行程，會從低優先級開始殺行程，command一共有三種，在上層的代碼是在ProcessList中，
2.4.1 LMK_TARGET
// 上層邏輯是在ProcessList.updateOomLevels中
ByteBuffer buf = ByteBuffer.allocate(4 * (2*mOomAdj.length + 1));
buf.putInt(LMK_TARGET);
for (int i=0; i<mOomAdj.length; i++) {
buf.putInt((mOomMinFree[i]*1024)/PAGE_SIZE);
buf.putInt(mOomAdj[i]);
}
writeLmkd(buf)
// lmkd處理邏輯
static void cmd_target(int ntargets, int *params) {
int i;
if (ntargets > (int)ARRAY_SIZE(lowmem_adj))
return;
// 這個for回圈對應上面的for回圈，將資料讀出裝進陣列中
for (i = 0; i < ntargets; i++) {
lowmem_minfree[i] = ntohl(*params++);
lowmem_adj[i] = ntohl(*params++);
}
lowmem_targets_size = ntargets;
// 使用kernel空間的處理邏輯
if (use_inkernel_interface) {
char minfreestr[128];
char killpriostr[128];
minfreestr[0] = '\0';
killpriostr[0] = '\0';
// 取出兩個陣列中的資料，以","分隔，分別拼接成string
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", lowmem_minfree[i]);
strlcat(minfreestr, val, sizeof(minfreestr));
snprintf(val, sizeof(val), "%d", lowmem_adj[i]);
strlcat(killpriostr, val, sizeof(killpriostr));
}
// 將生成好的string寫入到檔案節點minfree以及adj
writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
writefilestring(INKERNEL_ADJ_PATH, killpriostr);
}
}
上面的處理邏輯主要是：
- 按照順序取出資料，裝進lmkd的陣列中，
- 分別將兩個陣列中的數取出，用”,”分隔
- lowmem_minfree中的資料拼成的string寫到 “/sys/module/lowmemorykiller/parameters/minfree”
- lowmem_adj中的資料拼成的string寫到 “/sys/module/lowmemorykiller/parameters/adj”
2.4.2 LMK_PROCPRIO
// 上層邏輯是在ProcessList.setOomAdj中
public static final void setOomAdj(int pid, int uid, int amt) {
if (amt == UNKNOWN_ADJ)
return;
long start = SystemClock.elapsedRealtime();
ByteBuffer buf = ByteBuffer.allocate(4 * 4);
buf.putInt(LMK_PROCPRIO);
buf.putInt(pid);
buf.putInt(uid);
buf.putInt(amt);
writeLmkd(buf);
long now = SystemClock.elapsedRealtime();
if ((now-start) > 250) {
Slog.w("ActivityManager", "SLOW OOM ADJ: " + (now-start) + "ms for pid " + pid
+ " = " + amt);
}
}
// lmkd處理邏輯
static void cmd_procprio(int pid, int uid, int oomadj) {
struct proc *procp;
char path[80];
char val[20];
if (oomadj < OOM_SCORE_ADJ_MIN || oomadj > OOM_SCORE_ADJ_MAX) {
ALOGE("Invalid PROCPRIO oomadj argument %d", oomadj);
return;
}
// LMK_PROCPRIO的主要作用就是更新行程的oomAdj
// 將上層傳遞過來的資料（pid以及優先級）寫到該行程對應的檔案節點
// /proc/pid/oom_score_adj
snprintf(path, sizeof(path), "/proc/%d/oom_score_adj", pid);
snprintf(val, sizeof(val), "%d", oomadj);
writefilestring(path, val);
// 如果使用kernel的使用邏輯，return
// 即這個command傳遞過來只是更新了對應檔案節點的oom_score_adj
if (use_inkernel_interface)
return;
// 從hashtable中查找proc
procp = pid_lookup(pid);
// 如果沒有查找到，也就是說這個行程是新創建的，lmkd維護的資料結構中還沒有這個proc，因此需要新建并添加到hashtable中
if (!procp) {
procp = malloc(sizeof(struct proc));
if (!procp) {
// Oh, the irony. May need to rebuild our state.
return;
}
procp->pid = pid;
procp->uid = uid;
procp->oomadj = oomadj;
// 將proc插入到lmkd中的資料結構中，主要包括兩個資料結構
// 更新hashtable，通過pid計算hash值，然后存盤，解決沖突是讓新來的作為陣列元素鏈表的頭結點
// 優先級為index的雙向鏈表組成的table
proc_insert(procp);
} else {
// hashtable中已經有這個proc
// 但是因為優先級的變化，需要先把這個proc從原先的優先級table中對應位置的雙向鏈表中remove
// 然后新加到新的優先級對應的雙向鏈表中
// 雙向鏈表的添加是新來的放在頭部
proc_unslot(procp);
procp->oomadj = oomadj;
proc_slot(procp);
}
}
// 其中pid_lookup：查詢hashtable，因為行程的pid是唯一的，然后從中取出該pid在lmkd中的proc結構體，
static struct proc *pid_lookup(int pid) {
struct proc *procp;
for (procp = pidhash[pid_hashfn(pid)]; procp && procp->pid != pid;
procp = procp->pidhash_next)
;
return procp;
}
2.4.3 LMK_PROCREMOVE
// 上層處理邏輯在ProcessList.remove中
public static final void remove(int pid) {
ByteBuffer buf = ByteBuffer.allocate(4 * 2);
buf.putInt(LMK_PROCREMOVE);
buf.putInt(pid);
writeLmkd(buf);
}
// lmkd處理邏輯
static void cmd_procremove(int pid) {
// 如果使用kernel介面,return
if (use_inkernel_interface)
return;
// 更新資料結構，pid的hashtable以及行程優先級的雙向鏈表table
pid_remove(pid);
kill_lasttime = 0;
}
static int pid_remove(int pid) {
int hval = pid_hashfn(pid);
struct proc *procp;
struct proc *prevp;
// pid的hashtable
for (procp = pidhash[hval], prevp = NULL; procp && procp->pid != pid;
procp = procp->pidhash_next)
prevp = procp;
if (!procp)
return -1;
if (!prevp)
pidhash[hval] = procp->pidhash_next;
else
prevp->pidhash_next = procp->pidhash_next;
// 行程優先級的table
proc_unslot(procp);
free(procp);
return 0;
}
2.4.4 小結
從上面的處理邏輯就能看出來，三種command的處理邏輯中都對use_inkernel_interface的情況下做了特殊處理，在use_inkernel_interface的情況下，做的事情都是很簡單的，只是更新一下檔案節點，如果不使用kernel interface，就需要lmkd自己維護兩個table，在每次更新adj的時候去更新table， 且在初始化的時候也能看到，如果不使用kernel的lowmemorykiller，則需要lmkd自己獲取手機記憶體狀態，如果匹配到了minfree中的等級，則需要通過殺掉一些行程釋放記憶體，
2.5 殺行程
初始化的時候已經注冊好了，當獲取到手機的記憶體匹配到minfree中某一個級別時：
2.5.1 查找
// 不使用kernel interface
// 根據當前記憶體的狀態查找需要殺掉的行程
static int find_and_kill_process(int other_free, int other_file, bool first)
{
...
// 主要邏輯是這里的for回圈
// 根據前面最小記憶體級別與優先級的對應關系
// 拿到需要殺的行程的優先級
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;
}
}
if (min_score_adj == OOM_SCORE_ADJ_MAX + 1)
return 0;
for (i = OOM_SCORE_ADJ_MAX; i >= min_score_adj; i--) {
struct proc *procp;
retry:
// 從優先級table中取出一個
// 因為是雙向回圈鏈表，取的時候取出head->prev，也就是最后一個
// 也就是使用的lru演算法，先把近期不用的行程殺掉
procp = proc_adj_lru(i);
if (procp) {
// 殺行程，通過發信號的方式
// 回傳值是殺了該行程之后釋放的記憶體的大小
// 如果釋放記憶體之后依然不滿足要求，則從鏈表上再取一個殺
killed_size = kill_one_process(procp, other_free, other_file, minfree, min_score_adj, first);
if (killed_size < 0) {
goto retry;
} else {
return killed_size;
}
}
}
return 0;
}
2.6 小結
這部分從lmkd的main開始，從一些資料結構的初始化，到進入loop，再到與ActivityManager的socket連接，接收上層傳遞的資料，然后分別根據三種command做出不同的更新與洗掉等，當然最重要的還是use_inkernel_interface這個變數，從初始化到所有命令的處理都與這個邏輯分不開，如果不使用的話，需要自維護行程的資料結構，需要讀取檔案節點獲取手機記憶體狀態，在minfree匹配到時去查找并殺行程，直到釋放足夠多的記憶體，在使用kernel空間lowmemorykiller的情況下，三種命令做的事情會非常有限，主要是更新檔案節點，而lmdk本身根本不需要維護任何跟行程相關的結構，判斷手機狀態并查找低優先級的行程以及殺行程的作業全部都由lowmemorykiller完成，
3. lowmemorykiller
前面也提過，大多情況其實是使用kernel interface的，其實也就是kernel中的lowmemorykiller
代碼位置:/kernel/msm-3.18/drivers/staging/android/lowmemorykiller.c
lowmemorykiller中是通過linux的shrinker實作的，這個是linux的記憶體回識訓制的一種，由內核執行緒kswapd負責監控，在lowmemorykiller初始化的時候注冊register_shrinker，
static int __init lowmem_init(void)
{
register_shrinker(&lowmem_shrinker);
vmpressure_notifier_register(&lmk_vmpr_nb);
return 0;
}
minfree以及min_adj兩個陣列：
// 下面兩個陣列分別代表了兩個引數檔案中的默認值，陣列默認的size都是6
// 對應 "/sys/module/lowmemorykiller/parameters/adj"
static short lowmem_adj[6] = {
0,
1,
6,
12,
};
static int lowmem_adj_size = 4;
// 對應 "/sys/module/lowmemorykiller/parameters/minfree"
static int lowmem_minfree[6] = {
3 * 512, /* 6MB */
2 * 1024, /* 8MB */
4 * 1024, /* 16MB */
16 * 1024, /* 64MB */
};
static int lowmem_minfree_size = 4;
掃描當前記憶體以及殺行程：
static unsigned long lowmem_scan(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
struct task_struct *selected = NULL;
unsigned long rem = 0;
int tasksize;
int i;
// OOM_SCORE_ADJ_MAX = 1000
short min_score_adj = OOM_SCORE_ADJ_MAX + 1;
int minfree = 0;
int selected_tasksize = 0;
short selected_oom_score_adj;
// array_size = 6
int array_size = ARRAY_SIZE(lowmem_adj);
// NR_FREE_PAGES 是在/kernel/msm-3.18/include/linux/mmzone.h中定義的zone_stat_item對應的第一個列舉，下面的列舉以此類推
// global_page_state(NR_FREE_PAGES)即讀取/proc/vmstat 中第一行的值
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) -
global_page_state(NR_UNEVICTABLE) -
total_swapcache_pages();
if (lowmem_adj_size < array_size)
array_size = lowmem_adj_size;
if (lowmem_minfree_size < array_size)
array_size = lowmem_minfree_size;
for (i = 0; i < array_size; i++) {
// 從小到大掃描lowmem_minfree陣列，根據剩余記憶體的大小，確定當前剩余記憶體的級別
minfree = lowmem_minfree[i];
if (other_free < minfree && other_file < (minfree + minfree / 4)) {
// 由于兩個陣列之間的對應關系，minfree中找到當前記憶體所處的等級之后
// 也就可以在lowmem_adj獲取到在這個記憶體級別需要殺掉的行程的優先級
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);
// 經過一輪掃描，發現不需要殺行程，return
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同步機制
rcu_read_lock();
again:
// for_each_process用來遍歷所有的行程
// 定義在 /kernel/msm-3.18/include/linux/sched.h
// #define for_each_process(p) \
// for (p = &init_task ; (p = next_task(p)) != &init_task ; )
for_each_process(tsk) {
struct task_struct *p;
short oom_score_adj;
// 內核執行緒kthread
if (tsk->flags & PF_KTHREAD)
continue;
// 已經被殺，還在等鎖
if (test_tsk_lmk_waiting(tsk)) {
lowmem_print(2, "%s (%d) is already killed, skip\n",
tsk->comm, tsk->pid);
continue;
}
// 一個task
// 定義在 /kernel/msm-3.18/mm/oom_kill.c
p = find_lock_task_mm(tsk);
if (!p)
continue;
oom_score_adj = p->signal->oom_score_adj;
if (oom_score_adj < min_score_adj) {
// 如果當前找到的行程的oom_score_adj比當前需要殺的最小優先級還低，不殺
task_unlock(p);
continue;
}
// 拿到占用的記憶體大小
// 定義在 /kernel/msm-3.18/include/linux/mm.h
tasksize = get_mm_rss(p->mm);
#ifdef CONFIG_ZRAM
tasksize += (get_mm_counter(p->mm, MM_SWAPENTS) / 3);
#endif
task_unlock(p);
if (tasksize <= 0)
continue;
if (selected) {
// 第一次不會進到這
// 第二次，也就是回圈回來，判斷如果當前選中的行程的adj更小
// 或優先級相同但是記憶體比較小，則continue
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;
// 已經選中了行程p，準備kill
lowmem_print(2, "select '%s' (%d, %d), adj %hd, size %d, to kill\n",
p->comm, p->pid, p->tgid, oom_score_adj, tasksize);
}
if (selected) {
task_lock(selected);
// 給該行程發信號 SIGKILL
send_sig(SIGKILL, selected, 0);
if (selected->mm)
task_set_lmk_waiting(selected);
task_unlock(selected);
// 殺行程完畢，列印kernel log, tag是lowmemorykiller
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,
other_file * (long)(PAGE_SIZE / 1024),
minfree * (long)(PAGE_SIZE / 1024),
min_score_adj,
other_free * (long)(PAGE_SIZE / 1024));
lowmem_deathpending_timeout = jiffies + HZ;
// 釋放的記憶體大小
rem += selected_tasksize;
}
// 如果需要殺掉多個行程
// kill_one_more在lmk_vmpressure_notifier中置true
if (kill_one_more) {
selected = NULL;
kill_one_more = false;
lowmem_print(1, "lowmem_scan kill one more process\n");
// 跳轉到遍歷的地方再開始
goto again;
}
lowmem_print(4, "lowmem_scan %lu, %x, return %lu\n",
sc->nr_to_scan, sc->gfp_mask, rem);
rcu_read_unlock();
return rem;
}
lmk_vmpressure_notifier中定義了什么時候去kill_one_more，主要是當記憶體壓力在95以上時
lmk_vmpressure_notifier這個也是在init時注冊：vmpressure_notifier_register(&lmk_vmpr_nb);
static int lmk_vmpressure_notifier(struct notifier_block *nb,
unsigned long action, void *data)
{
unsigned long pressure = action;
if (pressure >= 95) {
if (!kill_one_more) {
kill_one_more = true;
lowmem_print(2, "vmpressure %ld, set kill_one_more true\n",
pressure);
}
} else {
if (kill_one_more) {
kill_one_more = false;
lowmem_print(2, "vmpressure %ld, set kill_one_more false\n",
pressure);
}
}
return 0;
}
oom_adj到oom_score_adj的轉換：
static short lowmem_oom_adj_to_oom_score_adj(short oom_adj)
{
if (oom_adj == OOM_ADJUST_MAX)
return OOM_SCORE_ADJ_MAX;
else
return (oom_adj * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE;
}
4. 總結
由于Android中的行程啟動的很頻繁，四大組件都會涉及到行程啟動，行程啟動之后做完組要做的事情之后就會很快被AMS把優先級降低，但是為了針對低記憶體的情況以及如果用戶開啟太多，且APP的優先級很高，AMS這邊就有一些無力了，為了保證手機正常運行必須有行程清理，記憶體回收，根據當前手機剩余記憶體的狀態，在minfree中找到當前等級，再根據這個等級去adj中找到這個等級應該殺掉的行程的優先級，然后去殺行程，直到釋放足夠的記憶體，目前大多都使用kernel中的lowmemorykiller，但是上層用戶的APP的優先級的調整還是AMS來完成的，lmkd在中間充當了一個橋梁的角色，通過把上層的更新之后的adj寫入到檔案節點，提供lowmemorykiller殺行程的依據，
轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/9868.html
標籤：嵌入式
上一篇：痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啟動那些事（8.A）- SEMC NAND啟動時間(RT1170)
下一篇：關于嵌入式實時作業系統的實時性