1.概要
Androidのは、基礎となるLinuxベースのLinuxでメモリを解放するプロセスの数を殺すために、低メモリOOMキラーがあり、Androidのはlowmemorykillerではこれに基づいている、来ていくつかの調整をした。さ 携帯電話のメモリは、すべての後に、限られているので使用しないで後工程での上位ActivityManagerServiceスケジュールとプロセスを強制終了するための手段には多くありますが、Androidアプリはすぐに、殺されなかったが、すべての後に、また、携帯電話の実際の残りのメモリを考慮する必要があります状況、
時間内に、ActivityManagerServiceの一部を殺すために時間が、ユーザー・プロセスにはあまり重要ではないがなかっ殺すいくつかのメモリを再利用、携帯電話の正常な動作を保証する際にメモリに余裕がないときLowmemorykiller役割があります。
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：現在のプロセスの優先度を表す、この優先順位が上位のこの優先度と優先度との間の変換のカーネルがあることで、物品は、最終的に言及します。
の/ proc / PID / oom_score_adj：最優先、PROCESSLISTに対応して優先
2.initプロセスlmkd
コード所在地：プラットフォーム/システム/コア/ lmkd /
PROCESSLISTは、プロセスの優先度を定義した優先順位を下げ、より重要なプロセス、優先度がAPP 0は、APPのシステムの優先順位は、一般的に負である前景、それはプロセス管理とプロセスは、一般に、上部殺すためのものですAPPであり、AMS内にあるこれらのプロセスの優先順位を調整し、AMSは、計算の後、我々は、対応する処理ノードにファイルが更新され、各プロセスの優先度の構成要素の処理を継続する状態に応じて算出されます、ファイルノードのこの更新は、その完成されないが、それらの間のソケット通信を介して、lmkd。
lmkd上部ActivityManagerが必要な場合updateOomAdjは、優先通信、ソケット及びlmkd介して更新プロセスのために、解放メモリにプロセスを終了行った後に処理するために、携帯電話の永久的なプロセスです。initプロセスを開始するには、中lmkdでlmkd.rcが定義されている場合lmkdが有効にされています。
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通信は、各コマンドは、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を更新し、必要に応じてプロセスを殺すことですがあります。そのため、主な機能は、トップの上にcmdとデータ転送を待ってブロックし、その後、主要なファイルディスクリプタを作成し、ソケットとの接続ActivityManagerを初期化することです。
2.2初期化初期化
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、裁判官への書き込み権限、ロジックカーネル空間の使用にない場合
現在経験しているuse_inkernel_interface
偽のuse_inkernel_interface値の場合：
循環ループのメインループに2.3
// 进入死循环，然后调用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_command_handlerからのデータ転送の2.4処理
このctrl_connect_handlerの上記治療方法において受け入れ、ctrl_data_handlerを開始し、データおよびプロセスを読み取る：ctrl_command_handler。ActivityManagerについて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);
}
洗練されていないここで、上側コードのタイミングを呼び出した後、フォワードキャッチワードはプロセスの優先順位の4つのコンポーネントの状態に応じて調整される上位層であることが、udpateOomAdjでActivityManagerServiceに基本的には、タイムリーに応答なりlmkd、プロセスを殺すためにタイムトリガのメモリは、プロセスを殺すために優先順位が低いから開始します。上部に3つのコマンドコードが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は "/ SYS /モジュール/ lowmemorykiller /パラメータ/ minfreeの" 書き込まれたデータ列を構成します
- lowmem_adjは "/ SYS /モジュール/ lowmemorykiller /パラメータ/ 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まとめ
上記の処理ロジックを見ることができることから、use_inkernel_interfaceの場合にロジックを処理コマンドの3種類が、それは非常に簡単です物事のuse_inkernel_interfaceの場合には特別な処理を行うだけでいくつかのファイルのノードを更新する必要があります。あなたは、カーネルインタフェースを使用しない場合は、テーブルを更新するために、各アップデートの影響調整後の時間に、2つのlmkd自身のテーブルを維持する必要があります。そして、あなたがlowmemorykillerカーネルを使用しない場合、あなたは試合はレベルをMINFREEする場合は、あなたがメモリを解放するためのプロセスのいくつかを殺すために必要な、携帯電話のメモリは、自身の状態をlmkd取得する必要があり、初期化時に見ることができます。
2.5キルプロセス
1つのレベルの携帯電話のメモリマッチング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まとめ
上位層データを受信するソケットActivityManagerに接続され、メインlmkdデータ構造の初期化から開始し、ループを入力すると、この部分が転送され、その後3に記載のように削除するために、異なる更新コマンドを用いて行きました。この変数は、処理からのすべてのコマンドに初期化されている。もちろん、最も重要なことのuse_inkernel_interface密接に、使用されていない場合は、このロジックを持つプロセスからデータ構造を維持する必要性が関連している、我々はminfreeの試合では、ファイルノードの状態を読み取るために携帯電話のメモリを取得する必要がありますとき探しに行くとリリースの十分なメモリまでのプロセスを殺すために。カーネル空間の場合は、それを行うための3つのコマンドのlowmemorykillerは非常に主にファイルノードを更新するために、限定されるものではなく、自分自身をlmdkされると、携帯電話の状態を判断し、優先度の低いプロセスを見つけるために、構造に関連付けられているすべてのプロセスを維持する必要はありません。また、完成lowmemorykillerによって、すべての作業プロセスを殺します。
3. lowmemorykiller
また先に述べたように、ほとんどの場合、実際のカーネルインターフェースを使用して、実際には、lowmemorykillerのカーネルです
コード所在地：/kernel/msm-3.18/drivers/staging/android/lowmemorykiller.c
lowmemorykillerはシュリンカーでlinuxを通じて達成される。これは、Linuxのガベージコレクション機構であり、カーネルスレッドが監視する責任kswapdにより、登録register_shrinkerはときlowmemorykiller初期化。
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_score_adjへの変換oom_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.まとめ
AMSはすぐにプロセスが開始した後のことを行うために、Androidの中で始まっによるプロセスは非常に頻繁にされた後、四つの成分が起動するプロセスに関与している仕上がりグループ置く優先順位の低いことが、低メモリの状況について順に、そしてもしますユーザーは、携帯電話の通常の動作は、メモリリコールをクリーンアッププロセスを持っている必要があります確保するために、携帯電話の残りのメモリの現在の状態に応じて、minfreeの中に現在のレベルを見つけ、ここにいくつかの弱点がありますあまりにも多くを開き、APP、AMSの優先度の高いですこのレベルADJの優先順位はプロセスを強制終了してからリリース十分なメモリまでのプロセスを殺す必要がありますし、このレベルを見つけるために従いました。現在最もlowmemorykillerでカーネルを使用していますが、優先順位が上位を提供するように更新した後、完全なブリッジの役割として、途中でlmkd、ADJノードによってファイルへの書き込みに上位またはAMS APPのユーザーを調整することですlowmemorykillerキルプロセスの基礎。