/* drivers/misc/lowmemorykiller.c

 *

 * The lowmemorykiller driver lets user-space specify (指定) a set of memory thresholds (阈值)

 * where processes with a range of oom_score_adj values will get killed. Specify

 * the minimum oom_score_adj values in

 * /sys/module/lowmemorykiller/parameters/adj and the number of free pages in

 * /sys/module/lowmemorykiller/parameters/minfree. Both files take a comma

 * separated list of numbers in ascending order (按升序序列).

 *

 * For example, write "0,8" to /sys/module/lowmemorykiller/parameters/adj and

 * "1024,4096" to /sys/module/lowmemorykiller/parameters/minfree to kill

 * processes with a oom_score_adj value of 8 or higher when the free memory

 * drops below 4096 pages and kill processes with a oom_score_adj value of 0 or

 * higher when the free memory drops below 1024 pages.

 *

 * The driver considers memory used for caches to be free, but if a large

 * percentage of the cached memory is locked this can be very inaccurate (不准确)

 * and processes may not get killed until the normal oom killer is triggered.

 */

//msm-google\drivers\staging\android\lowmemorykiller.c

/*

 * /proc/<pid>/oom_score_adj set to OOM_SCORE_ADJ_MIN disables oom killing for

 * pid.

 */

#define OOM_SCORE_ADJ_MIN	(-1000)

#define OOM_SCORE_ADJ_MAX	1000

/*

 * /proc/<pid>/oom_adj set to -17 protects from the oom killer for legacy

 * purposes.

 */

#define OOM_DISABLE (-17)

/* inclusive */

#define OOM_ADJUST_MIN (-16)

#define OOM_ADJUST_MAX 15

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;

}

//msm-google\drivers\staging\android\lowmemorykiller.c

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

	lmk_event_init();

	return 0;

}

//msm-google\include\linux\shrinker.h

/*

 * A callback you can register to apply pressure to ageable caches.

 *

 * @count_objects should return the number of freeable items in the cache. If

 * there are no objects to free or the number of freeable items cannot be

 * determined, it should return 0. No deadlock checks should be done during the

 * count callback - the shrinker relies on aggregating scan counts that couldn't

 * be executed due to potential deadlocks to be run at a later call when the

 * deadlock condition is no longer pending.

 *

 * @scan_objects will only be called if @count_objects returned a non-zero

 * value for the number of freeable objects. The callout should scan the cache

 * and attempt to free items from the cache. It should then return the number

 * of objects freed during the scan, or SHRINK_STOP if progress cannot be made

 * due to potential deadlocks. If SHRINK_STOP is returned, then no further

 * attempts to call the @scan_objects will be made from the current reclaim

 * context.

 *

 * @flags determine the shrinker abilities, like numa awareness

 */

struct shrinker {

	unsigned long (*count_objects)(struct shrinker *,

				       struct shrink_control *sc);

	unsigned long (*scan_objects)(struct shrinker *,

				      struct shrink_control *sc);

	int seeks;	/* seeks to recreate an obj */

	long batch;	/* reclaim batch size, 0 = default */

	unsigned long flags;

	/* These are for internal use */

	struct list_head list;

	/* objs pending delete, per node */

	atomic_long_t *nr_deferred;

};

//msm-google\drivers\staging\android\lowmemorykiller.c

static unsigned long lowmem_count(struct shrinker *s,

				  struct shrink_control *sc)

{

	return global_node_page_state(NR_ACTIVE_ANON) +

		global_node_page_state(NR_ACTIVE_FILE) +

		global_node_page_state(NR_INACTIVE_ANON) +

		global_node_page_state(NR_INACTIVE_FILE);

}

//msm-google\drivers\staging\android\lowmemorykiller.c

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

	// 当前系统剩余内存大小，算法为：基于 free 总量去除其中作为 reserve 管理结构的部分

	int other_free = global_page_state(NR_FREE_PAGES) - totalreserve_pages;

	// 当前系统 page cache 的大小

	int other_file = global_node_page_state(NR_FILE_PAGES) -

				global_node_page_state(NR_SHMEM) -

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

	// 遍历最小内存阈值，如果当前内存低于阈值，同时当前 page cache 也低于阈值，

	//(内存充裕时会有大量内存充当 page cache 以提高系统 IO 性能)

	// 则为 min_score_adj 赋值后退出 for 循环

	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;

		}

	}

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

	// 如果 min_score_adj 等于初值，则表示内存充足，退出函数

	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 (Read-Copy Update) 同步机制

	// 随意读，但更新数据的时候，需要先复制一份副本，在副本上完成修改，再一次性地替换旧数据

	rcu_read_lock();

	// 遍历系统进程，要开始杀进程了

	for_each_process(tsk) {

		struct task_struct *p;

		short oom_score_adj;

		// 内核进程，跳过

		if (tsk->flags & PF_KTHREAD)

			continue;

		// 对于普通用户进程来说，mm 指向虚拟地址空间的用户空间部分，而对于内核线程，mm 为 NULL。

		// 内核线程和普通的进程间的区别在于内核线程没有独立的地址空间，mm 指针被设置为 NULL；

		// 它只在内核空间运行，从来不切换到用户空间去；并且和普通进程一样，可以被调度，也可以被抢占。

		// 如果是内核线程，直接跳过

		p = find_lock_task_mm(tsk);

		if (!p)

			continue;

		if (task_lmk_waiting(p) &&

		    time_before_eq(jiffies, lowmem_deathpending_timeout)) {

			task_unlock(p);

			rcu_read_unlock();

			return 0;

		}

		// 如果当前找到的进程的 oom_score_adj 比当前需要杀的最小优先级还低，不杀

		oom_score_adj = p->signal->oom_score_adj;

		if (oom_score_adj < min_score_adj) {

			task_unlock(p);

			continue;

		}

		// 获取进程的占用内存大小 (rss 值)

		//rss: resident set size, the non-swappend physical memory that a task has used in.

		tasksize = get_mm_rss(p->mm);

		task_unlock(p);

		if (tasksize <= 0)

			continue;

		// 首个进程，selected 值必为 NULL

		if (selected) {

			// 高优先级进程，不杀

			if (oom_score_adj < selected_oom_score_adj)

				continue;

			// 同优先级进程，如果该进程占用内存小于阈值，同样不杀

			if (oom_score_adj == selected_oom_score_adj &&

			    tasksize <= selected_tasksize)

				continue;

		}

		// 已经找到了需要 kill 的进程，更新它的 tasksize 与 oom_score_adj

		selected = p;

		selected_tasksize = tasksize;

		selected_oom_score_adj = oom_score_adj;

		lowmem_print(2, "select '%s' (%d), adj %hd, size %d, to kill\n",

			     p->comm, p->pid, 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);

		task_lock(selected);

		// 发送 SIGKILL 信号，杀死这个进程

		send_sig(SIGKILL, selected, 0);

		if (selected->mm)

			task_set_lmk_waiting(selected);

		task_unlock(selected);

		trace_lowmemory_kill(selected, cache_size, cache_limit, free);

		lowmem_print(1, "Killing '%s' (%d) (tgid %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->tgid,

			     selected_oom_score_adj,

			     selected_tasksize * (long)(PAGE_SIZE / 1024),

			     current->comm, current->pid,

			     cache_size, cache_limit,

			     min_score_adj,

			     free);

		lowmem_deathpending_timeout = jiffies + HZ;

		rem += selected_tasksize;

		get_task_struct(selected);

	}

	lowmem_print(4, "lowmem_scan %lu, %x, return %lu\n",

		     sc->nr_to_scan, sc->gfp_mask, rem);

	rcu_read_unlock();

	if (selected) {

		handle_lmk_event(selected, selected_tasksize, min_score_adj);

		put_task_struct(selected);

	}

	return rem;

}