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以及adjLMK_PROCPRIO：更新指定程序的優先順序，也就是oom_score_adjLMK_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];// 三種commandenum 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];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); } }}前面在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;}// 上層處理邏輯在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;}從上面的處理邏輯就能看出來，三種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;}這部分從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;}由於Android中的程序啟動的很頻繁，四大元件都會涉及到程序啟動，程序啟動之後做完組要做的事情之後就會很快被AMS把優先順序降低，但是為了針對低記憶體的情況以及如果使用者開啟太多，且APP的優先順序很高，AMS這邊就有一些無力了，為了保證手機正常執行必須有程序清理，記憶體回收，根據當前手機剩餘記憶體的狀態，在minfree中找到當前等級，再根據這個等級去adj中找到這個等級應該殺掉的程序的優先順序，然後去殺程序，直到釋放足夠的記憶體。目前大多都使用kernel中的lowmemorykiller，但是上層使用者的APP的優先順序的調整還是AMS來完成的，lmkd在中間充當了一個橋樑的角色，通過把上層的更新之後的adj寫入到檔案節點，提供lowmemorykiller殺程序的依據。