Android lowmemorykiller分析

来源:https://www.cnblogs.com/linhaostudy/archive/2020/03/29/12593441.html
-Advertisement-
Play Games

1.概述 Android底層還是基於Linux，在Linux中低記憶體是會有oom killer去殺掉一些進程去釋放記憶體，而Android中的lowmemorykiller就是在此基礎上做了一些調整來的。因為手機上的記憶體畢竟比較有限，而Android中APP在不使用之後並不是馬上被殺掉，雖然上層Act ...


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, &param);
    // 初始化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);
    }
}

上面的處理邏輯主要是：

  1. 按照順序取出數據，裝進lmkd的數組中。
  2. 分別將兩個數組中的數取出，用”,”分隔
  3. lowmem_minfree中的數據拼成的string寫到 “/sys/module/lowmemorykiller/parameters/minfree”
  4. 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殺進程的依據。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • identityserver4源碼解析_3_認證介面
    目錄 "identityserver4源碼解析_1_項目結構" "identityserver4源碼解析_2_元數據介面" "identityserver4源碼解析_3_認證介面" "identityserver4源碼解析_4_令牌發放介面" "identityserver4源碼解析_5_查詢用戶信 ...
  • identityserver4源碼解析_2_元數據介面
    目錄 "identityserver4源碼解析_1_項目結構" "identityserver4源碼解析_2_元數據介面" "identityserver4源碼解析_3_認證介面" "identityserver4源碼解析_4_令牌發放介面" "identityserver4源碼解析_5_查詢用戶信 ...
  • IdentityServer4源碼解析_1_項目結構
    目錄 "identityserver4源碼解析_1_項目結構" "identityserver4源碼解析_2_元數據介面" "identityserver4源碼解析_3_認證介面" "identityserver4源碼解析_4_令牌發放介面" "identityserver4源碼解析_5_查詢用戶信 ...
  • AspNetCore3.1_Secutiry源碼解析_8_Authorization_授權框架
    目錄 "AspNetCore3.1_Secutiry源碼解析_1_目錄" "AspNetCore3.1_Secutiry源碼解析_2_Authentication_核心流程" "AspNetCore3.1_Secutiry源碼解析_3_Authentication_Cookies" "AspNetC ...
  • AspNetCore3.1_Secutiry源碼解析_7_Authentication_其他
    title: "AspNetCore3" date: 2020 03 26T13:23:27+08:00 draft: false 系列文章目錄 "AspNetCore3.1_Secutiry源碼解析_1_目錄" "AspNetCore3.1_Secutiry源碼解析_2_Authenticatio ...
  • Ansible Playbook 初識
    Ansible Playbook 基本概述與使用案例 主機規劃 添加用戶賬號 說明： 1、 運維人員使用的登錄賬號； 2、 所有的業務都放在 /app/ 下「yun用戶的家目錄」，避免業務數據亂放； 3、 該用戶也被 ansible 使用，因為幾乎所有的生產環境都是禁止 root 遠程登錄的（因此該 ...
  • Ubuntu安裝遇到的問題
    Ubuntu安裝過程遇到的問題 系統準備： 以前的系統是win10， 打算安裝Ubuntu雙系統 在win下使用Ultriso製作USB的Ubuntu啟動盤 提前壓縮一個100G空閑空間供Ubuntu使用（windons壓縮捲）。 開始安裝 開機從USB啟動， 按照嚮導一步一步安裝， 中間不要聯網， ...
  • Windows10放大鏡介紹和使用
    原文鏈接: "https://xiaoheidiannao.com/articles/Magnifier.html" 更多電腦使用技巧可以訪問 "https://xiaoheidiannao.com/articles/Magnifier.html" 查看哦! 放大鏡是Windows10中內置的一個 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類