Android 8.1原始碼_程序篇 -- LowMemoryKiller 原理分析

摘要： 核心原始碼 關鍵類 路徑 lmkd.c system/core/lmkd/lmkd.c lmkd.rc ...

核心原始碼

關鍵類	路徑
lmkd.c	system/core/lmkd/lmkd.c
lmkd.rc	system/core/lmkd/lmkd.rc
lowmemorykiller.c	kernel-3.18/drivers/staging/android/lowmemorykiller.c
ProcessList.java	frameworks/base/services/core/java/com/android/server/am/ProcessList.java

程序生命週期

Android系統的設計理念正是希望應用程序能儘量長時間地存活，以提升使用者體驗。應用首次開啟比較慢，這個過程有程序建立以及Application等資訊的初始化，所以應用在啟動之後，即便退到後臺並非立刻殺死，而是存活一段時間，這樣下次再使用則會非常快。對於APP同樣希望自身儘可能存活更長的時間，甚至探索各種保活黑科技。物極必反，系統處於低記憶體的狀態下，手機效能會有所下降；系統繼續放任所有程序一直存活，系統記憶體很快就會枯竭而亡，那麼需要合理地程序回收機制。

到底該回收哪個程序呢？系統根據程序的元件狀態來決定每個程序的優先順序值ADJ，系統根據一定策略先殺優先順序最低的程序，然後逐步殺優先順序更低的程序，依此類推，以回收預期的可用系統資源，從而保證系統正常運轉。

LowMemoryKiller 機制就是系統用於判定是否需要殺程序和殺哪些程序的一個機制。

程序優先順序

系統內程序優先順序分 5 級：

程序	說明
前臺程序（Foreground process）	使用者當前操作所必需的程序。
可見程序（Visible process）	沒有任何前臺元件、但仍會影響使用者在螢幕上所見內容的程序。 可見程序被視為是極其重要的程序，除非為了維持所有前臺程序同時執行而必須終止，否則系統不會終止這些程序。
服務程序（Service process）	正在執行已使用 startService() 方法啟動的服務且不屬於上述兩個更高類別程序的程序。 儘管服務程序與使用者所見內容沒有直接關聯，但是它們通常在執行一些使用者關心的操作 （例如，在後臺播放音樂或從網路下載資料）。 因此，除非記憶體不足以維持所有前臺程序和可見程序同時執行，否則系統會讓服務程序保持執行狀態。
後臺程序（Background process）	包含目前對使用者不可見的 Activity 的程序（已呼叫 Activity 的 onStop() 方法）。 這些程序對使用者體驗沒有直接影響，系統可能隨時終止它們，以回收記憶體供前臺程序、可見程序或服務程序使用。
空程序 （Empty process）	不含任何活動應用元件的程序。保留這種程序的的唯一目的是用作快取，以縮短下次在其中執行元件所需的啟動時間。 為使總體系統資源在程序快取和底層核心快取之間保持平衡，系統往往會終止這些程序。

Framework OOM Adjustment

我們看看程序優先順序的相關程式碼：

ADJ 級別

ADJ 定義在 ProcessList.java 中：oom_adj劃分為16級，取值範圍[-1000~1001]

ADJ 級別	取值	說明
UNKNOWN_ADJ	1001	一般指將要會快取程序，無法獲取確定值
CACHED_APP_MAX_ADJ	906	不可見程序的 adj 最大值
CACHED_APP_MIN_ADJ	900	不可見程序的 adj 最小值
SERVICE_B_AD	800	B List中的Service（較老的、使用可能性更小）
PREVIOUS_APP_ADJ	700	上一個App的程序(往往通過按返回鍵)
HOME_APP_ADJ	600	Home程序
SERVICE_ADJ	500	服務程序(Service process)
HEAVY_WEIGHT_APP_ADJ	400	後臺的重量級程序，system/rootdir/init.rc檔案中設定
BACKUP_APP_ADJ	300	備份程序
PERCEPTIBLE_APP_ADJ	200	可感知程序，比如後臺音樂播放
VISIBLE_APP_ADJ	100	可見程序(Visible process)
FOREGROUND_APP_ADJ	0	前臺程序（Foreground process）
PERSISTENT_SERVICE_ADJ	-700	關聯著系統或 persistent 程序
PERSISTENT_PROC_ADJ	-800	系統 persistent 程序，比如 telephony
SYSTEM_ADJ	-900	系統程序，僅指system_server程序
NATIVE_ADJ	-1000	native程序（不被系統管理）

從Android 7.0開始，ADJ採用100、200、300；在這之前的版本ADJ採用數字1、2、3，這樣的調整可以更進一步地細化程序的優先順序，比如在VISIBLE_APP_ADJ(100)與PERCEPTIBLE_APP_ADJ(200)之間，可以有ADJ=101、102級別的程序。

state 級別

STATE 定義在 ActivityManager.java中：process_state 劃分20類，取值範圍[-1~18]

STATE 級別	取值	說明
PROCESS_STATE_NONEXISTENT	18	不存在的程序
PROCESS_STATE_CACHED_EMPTY	17	程序處於cached狀態，且為空程序
PROCESS_STATE_CACHED_ACTIVITY_CLIENT	16	程序處於cached狀態，且為另一個cached程序(內含Activity)的client程序 adj 最大值
PROCESS_STATE_CACHED_ACTIVITY	15	程序處於cached狀態，且內含Activity
PROCESS_STATE_LAST_ACTIVITY	14	後臺程序，且擁有上一次顯示的Activity
PROCESS_STATE_HOME	14	後臺程序，且擁有home Activity
PROCESS_STATE_RECEIVER	12	後臺程序，且正在執行receiver
PROCESS_STATE_SERVICE	11	後臺程序，且正在執行service
PROCESS_STATE_HEAVY_WEIGHT	10	後臺程序，但無法執行restore，因此儘量避免kill該程序
PROCESS_STATE_BACKUP	9	後臺程序，正在執行backup/restore操作
PROCESS_STATE_TRANSIENT_BACKGROUND	8	程序短暫進入後臺，我們應該儘量保持執行
PROCESS_STATE_IMPORTANT_BACKGROUND	7	對使用者很重要的程序，使用者不可感知其存在
PROCESS_STATE_IMPORTANT_FOREGROUND	6	對使用者很重要的程序，使用者可感知其存在
PROCESS_STATE_TOP_SLEEPING	5	與PROCESS_STATE_TOP一樣，但此時裝置正處於休眠狀態
PROCESS_STATE_FOREGROUND_SERVICE	4	擁有給一個前臺Service
PROCESS_STATE_BOUND_FOREGROUND_SERVICE	3	擁有給一個前臺Service，且由系統繫結
PROCESS_STATE_TOP	2	擁有當前使用者可見的top Activity
PROCESS_STATE_PERSISTENT_UI	1	persistent系統程序，並正在執行UI操作
PROCESS_STATE_PERSISTENT	0	persistent系統程序
PROCESS_STATE_UNKNOWN	-1	不可知的程序

這裡做個特殊說明：從 Android 7.0 開始，省去 lmk 對 oom_score_adj 的計算過程，Android 7.0 之前的版本，oom_score_adj= oom_adj * 1000/17；
而 Android 7.0 開始，oom_score_adj= oom_adj，不用再經過一次轉換。（我們後面會講解到這個）

Read The Fucking Code

lmkd

ProcessList 中定義有程序的優先順序，越重要的程序的優先順序越低，前臺 APP 的優先順序為 0，系統 APP 的優先順序一般都是負值，所以一般程序管理以及殺程序都是針對與上層的 APP 來說的，而這些程序的優先順序調整都在 AMS 裡面，AMS 根據程序中元件的狀態去不斷的計算每個程序的優先順序，計算之後會及時更新到對應程序的檔案節點中，而這個對檔案節點的更新並不是它完成的，而是 lmkd ，他們之間通過 socket 通訊。

lmkd 在手機中是一個常駐程序，用來處理上層 ActivityManager 在進行 updateOomAdj 之後，通過 socket 與 lmkd 進行通訊，更新程序的優先順序，如果必要則殺掉程序釋放記憶體。

lmkd 是在 init 程序啟動的時候啟動的，通過解析 init.rc 檔案來啟動 lmkd 守護程序。在 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 會建立名為 lmkd 的 socket，節點位於/dev/socket/lmkd，該 socket 用於跟上層 framework 互動。

上層 AMS 跟 lmkd 通訊主要分為三種 command，每種 command 代表一種資料控制方式，在 ProcessList 以及 lmkd 中都有定義，ProcessList 中檔案的定義必須跟 lmkd.c 定義完全一致，格式如下：

LMK_TARGET <minfree> <minkillprio> ... (up to 6 pairs)
LMK_PROCPRIO <pid> <uid> <prio>
LMK_PROCREMOVE <pid>

上述3個命令的使用都通過 ProcessList.java 中的如下方法:

功能	命令	對應方法
LMK_TARGET	更新 oom_adj	PorcessList.setOomAdj()
LMK_PROCPRIO	設定程序 adj	PorcessList.updateOomLevels()
LMK_PROCREMOVE	移除程序	PorcessList.remove()

在開始分析 lmkd 的處理邏輯之前，lmkd.c 中有幾個重要的變數與資料結構提前說明一下：

... ...

// 記憶體級別限額
#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"

// 不同級別記憶體對應要殺的的優先順序
#define INKERNEL_ADJ_PATH "/sys/module/lowmemorykiller/parameters/adj"

... ...

// 三種 command
enum lmk_cmd {
LMK_TARGET,
LMK_PROCPRIO,
LMK_PROCREMOVE,
LMK_MEDLOOSEN,
};

... ...

/* OOM score values used by both kernel and framework */
// 優先順序的最小值
#define OOM_SCORE_ADJ_MIN(-1000)

// 優先順序的最大值
#define OOM_SCORE_ADJ_MAX1000

static int lowmem_adj[MAX_TARGETS];
static int lowmem_minfree[MAX_TARGETS];

... ...

// 雙向連結串列結構體
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];

lmkd 啟動後，接下里的操作都在 /system/core/lmkd/lmkd.c 檔案，首先進入 main() 方法：

main

我們看看 lmkd 程序的入口函式 main：

int main(int argc __unused, char **argv __unused) {
struct sched_param param = {
.sched_priority = 1,
};

medium_oomadj = property_get_int32("ro.lmk.medium", 800);
orig_medium_oomadj = medium_oomadj;
critical_oomadj = property_get_int32("ro.lmk.critical", 0);
debug_process_killing = property_get_bool("ro.lmk.debug", false);
enable_pressure_upgrade = property_get_bool("ro.lmk.critical_upgrade", false);
upgrade_pressure = (int64_t)property_get_int32("ro.lmk.upgrade_pressure", 50);
downgrade_pressure = (int64_t)property_get_int32("ro.lmk.downgrade_pressure", 60);
is_go_device = property_get_bool("ro.config.low_ram", false);

if (mlockall(MCL_CURRENT | MCL_FUTURE))
ALOGW("mlockall failed: errno=%d", errno);

// 設定此執行緒的排程策略為 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
// :boom: :boom: :boom: :boom: :boom: :boom: 重點討論 :boom: :boom: :boom: :boom: :boom: :boom:
if (!init())
// 進入死迴圈epoll_wait等待fd事件
mainloop();// :boom: :boom: :boom: :boom: :boom: :boom: 重點討論 :boom: :boom: :boom: :boom: :boom: :boom:

ALOGI("exiting");
return 0;
}

前面已經提到，這個程序存在的主要作用是跟 AMS 進行通訊，更新 oomAdj ，在必要的時候殺掉程序。所以在 main 函式中主要就是建立了 epoll 以及初始化 socket 並連線 ActivityManager ，然後阻塞等待上層傳遞 cmd 以及 資料 過來。

重點分析下 init()：

init

static int init(void) {
struct epoll_event epev;
int i;
int ret;

page_k = sysconf(_SC_PAGESIZE);
if (page_k == -1)
page_k = PAGE_SIZE;
page_k /= 1024;

// 建立 epoll 監聽檔案控制代碼
epollfd = epoll_create(MAX_EPOLL_EVENTS);
if (epollfd == -1) {
ALOGE("epoll_create failed (errno=%d)", errno);
return -1;
}

// 獲取 lmkd 的 socket fd
ctrl_lfd = android_get_control_socket("lmkd");
if (ctrl_lfd < 0) {
ALOGE("get lmkd control socket failed");
return -1;
}

// 監聽 lmkd socket
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 資料，並對資料進行相應的處理
// :boom: :boom: :boom: :boom: :boom: :boom: 下面會重點討論 :boom: :boom: :boom: :boom: :boom: :boom:
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++;

// 該路徑是否具有可寫的許可權
/*
* 這裡，通過檢驗 /sys/module/lowmemorykiller/parameters/minfree 節點是否具有可寫許可權
*
*#define INKERNEL_MINFREE_PATH "/sys/module/lowmemorykiller/parameters/minfree"
* 
* 來判斷是否使用 kernel 介面來管理 lmk 事件。
* 預設該節點是具有系統可寫的許可權，也就意味著 use_inkernel_interface = 1
*/
has_inkernel_module = !access(INKERNEL_MINFREE_PATH, W_OK);
use_inkernel_interface = has_inkernel_module && !is_go_device;

// 這個 use_inkernel_interface 是根據是否有 “/sys/module/lowmemorykiller/parameters/minfree” 的寫許可權來判斷的，沒有的情況下就使用 kernel 空間的邏輯
// 目前遇到的都是 use_inkernel_interface
if (use_inkernel_interface) {
ALOGI("Using in-kernel low memory killer interface");
} else {
ret = init_mp_medium();
ret |= init_mp_critical();
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;
}

mainloop

來看看 mainloop 的邏輯：

// 進入死迴圈，然後呼叫 epoll_wait 阻塞等待事件的到來
static void mainloop(void) {
while (1) {
struct epoll_event events[maxevents];
int nevents;
int i;

ctrl_dfd_reopened = 0;
// 等待 epoll_wait 上的事件
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);
// 當事件到來，則呼叫 ctrl_connect_handler 方法
if (events[i].data.ptr)
(*(void (*)(uint32_t))events[i].data.ptr)(events[i].events);
}
}
}

主迴圈呼叫 epoll_wait()，等待 epollfd 上的事件，當接收到中斷或者不存在事件，則執行 continue 操作。當事件到來，則呼叫的 ctrl_connect_handler 方法，該方法是由 init() 過程中設定的方法（我們之前在分析 init() 的時候提過）。

ctrl_connect_handler

我們之前在 init() 中看到以下程式碼：

// ctrl_connect_handler 裡面完成了 soclet 的 accpet 以及 read 資料，並對資料進行相應的處理
epev.data.ptr = (void *)ctrl_connect_handler;

它是專門處理 Socket 傳遞過來的資料的，我們跟下程式碼：

static void ctrl_connect_handler(uint32_t events __unused) {
struct epoll_event epev;

if (ctrl_dfd >= 0) {
ctrl_data_close();
ctrl_dfd_reopened = 1;
}

ctrl_dfd = accept(ctrl_lfd, NULL, NULL);

if (ctrl_dfd < 0) {
ALOGE("lmkd control socket accept failed; errno=%d", errno);
return;
}

ALOGI("ActivityManager connected");
maxevents++;
epev.events = EPOLLIN;
epev.data.ptr = (void *)ctrl_data_handler;

// 將 ctrl_dfd 新增到 epollfd
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctrl_dfd, &epev) == -1) {
ALOGE("epoll_ctl for data connection socket failed; errno=%d", errno);
ctrl_data_close();
return;
}
}

ctrl_data_handler

當事件觸發，則呼叫 ctrl_data_handler()：

static void ctrl_data_handler(uint32_t events) {
if (events & EPOLLHUP) {
ALOGI("ActivityManager disconnected");
// ActivityManager 連線斷開
if (!ctrl_dfd_reopened)
ctrl_data_close();
} else if (events & EPOLLIN) {
ctrl_command_handler();
}
}

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;
// :boom: :boom: :boom: :boom: :boom: :boom: 下面會重點討論 :boom: :boom: :boom: :boom: :boom: :boom:
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;
case LMK_MEDLOOSEN:
if (nargs != 1)
goto wronglen;
cmd_medloosen(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);
}

獲取 framework 傳遞過來的 buf 資料後，根據 3 種不同的命令，進入不同的分支。

LMK_TARGET

// 上層邏輯是在 ProcessList.updateOomLevels 中
if (write) {
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);
SystemProperties.set("sys.sysctl.extra_free_kbytes", Integer.toString(reserve));
}

// 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 (has_inkernel_module) {
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", 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));
}

// 將生成好的 string 寫入到檔案節點 minfree 以及 adj
writefilestring(INKERNEL_MINFREE_PATH, minfreestr);
writefilestring(INKERNEL_ADJ_PATH, killpriostr);
}
}

上面的處理邏輯主要是：

:sparkles: 1. 按照順序取出資料，裝進lmkd的陣列中

:sparkles: 2. 分別將兩個陣列中的數取出，用”,”分隔

:sparkles: 3. lowmem_minfree中的資料拼成的string寫到 “/sys/module/lowmemorykiller/parameters/minfree”

:sparkles: 4. lowmem_adj中的資料拼成的string寫到 “/sys/module/lowmemorykiller/parameters/adj”

LMK_PROCPRIO

// 上層邏輯是在 ProcessList.setOomAdj 中
public static final void setOomAdj(int pid, int uid, int amt) {
// 當 adj = 16，則直接返回
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);
// 將 16Byte 位元組寫入 socket
// buf 大小為 16 個位元組，依次寫入 LMK_PROCPRIO(命令型別), pid(程序pid), uid(程序uid), amt(目標adj)，將這些位元組通過 socket 傳送給 lmkd.
writeLmkd(buf);
long now = SystemClock.elapsedRealtime();
if ((now-start) > 250) {
Slog.w("ActivityManager", "SLOW OOM ADJ: " + (now-start) + "ms for pid " + pid
+ " = " + amt);
}
}

writeLmkd

private static void writeLmkd(ByteBuffer buf) {
// 當 socket 開啟失敗會嘗試 3 次
for (int i = 0; i < 3; i++) {
if (sLmkdSocket == null) {
// 開啟 socket
if (openLmkdSocket() == false) {
try {
Thread.sleep(1000);
} catch (InterruptedException ie) {
}
continue;
}
}

try {
將 buf 資訊寫入 lmkd socket
sLmkdOutputStream.write(buf.array(), 0, buf.position());
return;
} catch (IOException ex) {
Slog.w(TAG, "Error writing to lowmemorykiller socket");

try {
sLmkdSocket.close();
} catch (IOException ex2) {
}

sLmkdSocket = null;
}
}
}

openLmkdSocket

private static boolean openLmkdSocket() {
try {
sLmkdSocket = new LocalSocket(LocalSocket.SOCKET_SEQPACKET);
// 與遠端 lmkd 守護程序建立 socket 連線
sLmkdSocket.connect(
new LocalSocketAddress("lmkd",
LocalSocketAddress.Namespace.RESERVED));
sLmkdOutputStream = sLmkdSocket.getOutputStream();
} catch (IOException ex) {
Slog.w(TAG, "lowmemorykiller daemon socket open failed");
sLmkdSocket = null;
return false;
}

return true;
}

該方法是開啟一個名為 lmkd 的 socket，型別為 LocalSocket.SOCKET_SEQPACKET，這只是一個封裝，真實型別就是 SOCK_SEQPACKET。先跟遠端 lmkd 守護程序建立連線，再向其通過 write() 將資料寫入該 socket，再接下來進入 lmkd 過程。

我們看看lmkd的處理邏輯：

// lmkd 處理邏輯
static void cmd_procprio(int pid, int uid, int oomadj) {
struct proc *procp;
char path[80];
char val[20];
int soft_limit_mult;

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);
// 向節店 /proc/<pid>/oom_score_adj 寫入 oomAdj
writefilestring(path, val);

// 如果使用 kernel 的邏輯，則 return
// 即這個 command 傳遞過來只是更新了對應檔案節點的 oom_score_adj
if (use_inkernel_interface)
return;

if (oomadj >= 900) {
soft_limit_mult = 0;
} else if (oomadj >= 800) {
soft_limit_mult = 0;
} else if (oomadj >= 700) {
soft_limit_mult = 0;
} else if (oomadj >= 600) {
// Launcher should be perceptible, don't kill it.
oomadj = 200;
soft_limit_mult = 1;
} else if (oomadj >= 500) {
soft_limit_mult = 0;
} else if (oomadj >= 400) {
soft_limit_mult = 0;
} else if (oomadj >= 300) {
soft_limit_mult = 1;
} else if (oomadj >= 200) {
soft_limit_mult = 2;
} else if (oomadj >= 100) {
soft_limit_mult = 10;
} else if (oomadj >=0) {
soft_limit_mult = 20;
} else {
// Persistent processes will have a large
// soft limit 512MB.
soft_limit_mult = 64;
}

snprintf(path, sizeof(path), "/dev/memcg/apps/uid_%d/pid_%d/memory.soft_limit_in_bytes", uid, pid);
snprintf(val, sizeof(val), "%d", soft_limit_mult * EIGHT_MEGA);
writefilestring(path, val);

// 從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;
}

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);
}

static int pid_remove(int pid) {
int hval = pid_hashfn(pid);
struct proc *procp;
struct proc *prevp;

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;
}

從上面的處理邏輯就能看出來，三種 command 的處理邏輯中都對 use_inkernel_interface 的情況下做了特殊處理，在 use_inkernel_interface 的情況下，做的事情都是很簡單的，只是更新一下檔案節點。如果不使用 kernel interface，就需要 lmkd 自己維護兩個 table，在每次更新 adj 的時候去更新 table。 且在初始化的時候也能看到，如果不使用 kernel 的 lowmemorykiller，則需要 lmkd 自己獲取手機記憶體狀態，如果匹配到了 minfree 中的等級，則需要通過殺掉一些程序釋放記憶體。

小結

use_inkernel_interface 該值後續應該會逐漸採用使用者空間策略。不過目前仍為 use_inkernel_interface = 1 ，則：

:sparkles: 1. LMK_TARGET：AMS.updateConfiguration() 的過程中呼叫 updateOomLevels() 方法, 分別向 /sys/module/lowmemorykiller/parameters 目錄下的 minfree 和 adj 節點寫入相應資訊；

:sparkles: 2. LMK_PROCPRIO: AMS.applyOomAdjLocked() 的過程中呼叫 setOomAdj(),向 /proc/<pid>/oom_score_adj 寫入 oomadj，則直接返回；

:sparkles: 3. LMK_PROCREMOVE：AMS.handleAppDiedLocked 或者 AMS.cleanUpApplicationRecordLocked() 的過程，呼叫 remove()，目前不做任何事，直接返回；

Kernel

前面提過，大多情況其實是使用 kernel interface 的，其實也就是 kernel 中的 lowmemorykiller。

lowmemorykiller driver 位於 kernel-3.18/drivers/staging/android/lowmemorykiller.c。

lowmemorykiller 中是通過 linux 的 shrinker 實現的，這個是 linux 的記憶體回收機制的一種，由核心執行緒 kswapd 負責監控，在 lowmemorykiller 初始化的時候註冊 register_shrinker。

lowmemorykiller 初始化

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);

... ...
}

static void __exit lowmem_exit(void)
{
unregister_shrinker(&lowmem_shrinker);
}

通過 register_shrinker 和 unregister_shrinker 分別用於初始化和退出。

minfree/min_adj

// 下面兩個陣列分別代表了兩個引數檔案中的預設值，陣列預設的 size 都是 9
// 對應 "/sys/module/lowmemorykiller/parameters/adj"
static short lowmem_adj[9] = {
0,
1,
6,
12,
};
// 對應 "/sys/module/lowmemorykiller/parameters/minfree"
static int lowmem_adj_size = 9;
int lowmem_minfree[9] = {
3 * 512,/* 6MB */
2 * 1024,/* 8MB */
4 * 1024,/* 16MB */
16 * 1024,/* 64MB */
};
static int lowmem_minfree_size = 9;

shrinker

當記憶體不足時 kswapd 執行緒會遍歷一張 shrinker 連結串列，並回調已註冊的 shrinker 函式來回收記憶體 page，kswapd 還會週期性喚醒來執行記憶體操作。每個 zone 維護 active_list 和 inactive_list 連結串列，核心根據頁面活動狀態將 page 在這兩個連結串列之間移動，最終通過 shrink_slab 和 shrink_zone 來回收記憶體頁，有興趣想進一步瞭解 linux 記憶體回收機制，可自行研究。

lowmem_count

static unsigned long lowmem_count(struct shrinker *s,
struct shrink_control *sc)
{
... ...

// ANON代表匿名對映，沒有後備儲存器；FILE代表檔案對映； 記憶體計算公式= 活動匿名記憶體 + 活動檔案記憶體 + 不活動匿名記憶體 + 不活動檔案記憶體
return global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
}

lowmem_scan

當觸發 lmkd，則先殺 oom_score_adj 最大的程序，當 oom_adj 相等時,則選擇 rss 最大的程序。

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;
short min_score_adj = OOM_SCORE_ADJ_MAX + 1;
int minfree = 0;
int selected_tasksize = 0;
short selected_oom_score_adj;
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) -
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;

// 遍歷 lowmem_minfree 陣列找出相應的最小 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;
}
}

... ...

if (min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
... ...
return 0;
}

selected_oom_score_adj = min_score_adj;


rcu_read_lock();
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();
spin_unlock(&lowmem_shrink_lock);
return SHRINK_STOP;
}
oom_score_adj = p->signal->oom_score_adj;

// 小於目標adj的程序，則忽略
if (oom_score_adj < min_score_adj) {
task_unlock(p);
continue;
}

// 獲取的是程序的 Resident Set Size，也就是程序獨佔記憶體 + 共享庫大小
tasksize = get_mm_rss(p->mm);

task_unlock(p);
if (tasksize <= 0)
continue;
// 演算法關鍵，選擇 oom_score_adj 最大的程序中，並且 rss 記憶體最大的程序
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 %d, score_adj %hd, size %d, to kill\n",
p->comm, p->pid, REVERT_ADJ(oom_score_adj), oom_score_adj, tasksize);
}

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);

// 輸出 kill 的 log
lowmem_print(1, "Killing '%s' (%d), adj %d, score_adj %hd, state(%ld)\n"...);
lowmem_deathpending_timeout = jiffies + LOWMEM_DEATHPENDING_TIMEOUT;
set_tsk_thread_flag(selected, TIF_MEMDIE);
... ...

// //向選中的目標程序傳送 signal 9 來殺掉目標程序
send_sig(SIGKILL, selected, 0);
rem += selected_tasksize;
} else {
if (d_state_is_found == 1)
lowmem_print(2, "No selected (full of D-state processes at %d)\n", (int)min_score_adj);
}

lowmem_print(4, "lowmem_scan %lu, %x, return %lu\n",
sc->nr_to_scan, sc->gfp_mask, rem);
rcu_read_unlock();
spin_unlock(&lowmem_shrink_lock);
return rem;
}

當如下節點資料傳送變化時，會通過修改 lowmem_minfree[] 和 lowmem_adj[] 陣列：

/sys/module/lowmemorykiller/parameters/minfree
/sys/module/lowmemorykiller/parameters/adj

總結

本文主要從 frameworks 的 ProcessList.java 調整 adj，通過 socket 通訊將事件傳送給 native 的守護程序 lmkd；lmkd 再根據具體的命令來執行相應操作，其主要功能 更新程序的 oom_score_adj 值以及 lowmemorykiller 驅動的 parameters (包括 minfree 和 adj )；

最後講到了 lowmemorykiller 驅動，通過註冊 shrinker，藉助 linux 標準的記憶體回收機制，根據當前系統可用記憶體以及 parameters 配置引數( adj , minfree )來選取合適的 selected_oom_score_adj，再從所有程序中選擇 adj 大於該目標值的並且佔用 rss 記憶體最大的程序，將其殺掉，從而釋放出記憶體。

參考

01.ofollow,noindex" target="_blank">http://gityuan.com/2016/09/17...

02.https://blog.csdn.net/u011733...

03.https://blog.csdn.net/su74952...

04.http://gityuan.com/2018/05/19...