void tune_lmk_zone_param(struct zonelist *zonelist, int classzone_idx,
int *other_free, int *other_file)
{
struct zone *zone;
struct zoneref *zoneref;
int zone_idx;
for_each_zone_zonelist(zone, zoneref, zonelist, MAX_NR_ZONES) {
zone_idx = zonelist_zone_idx(zoneref);
if (zone_idx == ZONE_MOVABLE) {
continue;
}
if (zone_idx > classzone_idx) {
if (other_free != NULL)
*other_free -= zone_page_state(zone,
NR_FREE_PAGES);
if (other_file != NULL)
*other_file -= zone_page_state(zone,
NR_FILE_PAGES)
- zone_page_state(zone, NR_SHMEM);
} else if (zone_idx < classzone_idx) {
if (zone_watermark_ok(zone, 0, 0, classzone_idx, 0)) {
*other_free -=
zone->lowmem_reserve[classzone_idx];
} else {
*other_free -=
zone_page_state(zone, NR_FREE_PAGES);
}
}
}
static unsigned long highmem_dirtyable_memory(unsigned long total)
{
#ifdef CONFIG_HIGHMEM
int node;
unsigned long x = 0;
for_each_node_state(node, N_HIGH_MEMORY) {
struct zone *z =
&NODE_DATA(node)->node_zones[ZONE_HIGHMEM];
x += zone_page_state(z, NR_FREE_PAGES)
+ zone_page_state(z, NR_INACTIVE)
+ zone_page_state(z, NR_ACTIVE);
}
/*
* Make sure that the number of highmem pages is never larger
* than the number of the total dirtyable memory. This can only
* occur in very strange VM situations but we want to make sure
* that this does not occur.
*/
return min(x, total);
#else
return 0;
#endif
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *p;
struct task_struct *selected = NULL;
int rem = 0;
int tasksize;
int i;
int min_adj = OOM_ADJUST_MAX + 1;
int selected_tasksize = 0;
int selected_oom_adj;
int array_size = ARRAY_SIZE(lowmem_adj);
int other_free = global_page_state(NR_FREE_PAGES);
int other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM);
int lru_file = global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_FILE);
struct zone *zone;
int fork_boost;
int *adj_array;
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
*/
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout)) {
dump_deathpending(lowmem_deathpending);
return 0;
}
if (lowmem_fork_boost &&
time_before_eq(jiffies, lowmem_fork_boost_timeout)) {
fork_boost = lowmem_minfree[lowmem_minfree_size - 1] >> discount;
if (unlikely(other_file < fork_boost))
other_file = 0;
else
other_file -= fork_boost;
adj_array = fork_boost_adj;
lowmem_print(3, "lowmem_shrink other_file: %d, fork_boost: %d\n",
other_file, fork_boost);
}
int swsusp_shrink_memory(void)
{
long tmp;
struct zone *zone;
unsigned long pages = 0;
unsigned int i = 0;
char *p = "-\\|/";
struct timeval start, stop;
printk("Shrinking memory... ");
do_gettimeofday(&start);
do {
long size, highmem_size;
highmem_size = count_highmem_pages();
size = count_data_pages() + PAGES_FOR_IO;
tmp = size;
size += highmem_size;
for_each_zone (zone)
if (populated_zone(zone)) {
if (is_highmem(zone)) {
highmem_size -=
zone_page_state(zone, NR_FREE_PAGES);
} else {
tmp -= zone_page_state(zone, NR_FREE_PAGES);
tmp += zone->lowmem_reserve[ZONE_NORMAL];
tmp += snapshot_additional_pages(zone);
}
}
if (highmem_size < 0)
highmem_size = 0;
tmp += highmem_size;
if (tmp > 0) {
tmp = __shrink_memory(tmp);
if (!tmp)
return -ENOMEM;
pages += tmp;
} else if (size > image_size / PAGE_SIZE) {
tmp = __shrink_memory(size - (image_size / PAGE_SIZE));
pages += tmp;
}
printk("\b%c", p[i++%4]);
} while (tmp > 0);
do_gettimeofday(&stop);
printk("\bdone (%lu pages freed)\n", pages);
swsusp_show_speed(&start, &stop, pages, "Freed");
return 0;
}
unsigned int nr_free_highpages (void)
{
pg_data_t *pgdat;
unsigned int pages = 0;
for_each_online_pgdat(pgdat) {
pages += zone_page_state(&pgdat->node_zones[ZONE_HIGHMEM],
NR_FREE_PAGES);
if (zone_movable_is_highmem())
pages += zone_page_state(
&pgdat->node_zones[ZONE_MOVABLE],
NR_FREE_PAGES);
}
return pages;
}
static unsigned long max_pages(unsigned long min_pages)
{
unsigned long node_free_pages, max;
struct zone *zones = NODE_DATA(numa_node_id())->node_zones;
node_free_pages =
#ifdef CONFIG_ZONE_DMA
zone_page_state(&zones[ZONE_DMA], NR_FREE_PAGES) +
#endif
#ifdef CONFIG_ZONE_DMA32
zone_page_state(&zones[ZONE_DMA32], NR_FREE_PAGES) +
#endif
zone_page_state(&zones[ZONE_NORMAL], NR_FREE_PAGES);
max = node_free_pages / FRACTION_OF_NODE_MEM;
return max(max, min_pages);
}
static inline void get_free_ram(int *other_free, int *other_file)
{
struct zone *zone;
*other_free = global_page_state(NR_FREE_PAGES);
*other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM);
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
*other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
}
/**
* workingset_refault - evaluate the refault of a previously evicted page
* @shadow: shadow entry of the evicted page
*
* Calculates and evaluates the refault distance of the previously
* evicted page in the context of the zone it was allocated in.
*
* Returns %true if the page should be activated, %false otherwise.
*/
bool workingset_refault(void *shadow)
{
unsigned long refault_distance;
struct zone *zone;
unpack_shadow(shadow, &zone, &refault_distance);
inc_zone_state(zone, WORKINGSET_REFAULT);
if (refault_distance <= zone_page_state(zone, NR_ACTIVE_FILE)) {
inc_zone_state(zone, WORKINGSET_ACTIVATE);
return true;
}
return false;
}
static unsigned long max_pages(unsigned long min_pages)
{
unsigned long node_free_pages, max;
int node = numa_node_id();
struct zone *zones = NODE_DATA(node)->node_zones;
int num_cpus_on_node;
node_free_pages =
#ifdef CONFIG_ZONE_DMA
zone_page_state(&zones[ZONE_DMA], NR_FREE_PAGES) +
#endif
#ifdef CONFIG_ZONE_DMA32
zone_page_state(&zones[ZONE_DMA32], NR_FREE_PAGES) +
#endif
zone_page_state(&zones[ZONE_NORMAL], NR_FREE_PAGES);
max = node_free_pages / FRACTION_OF_NODE_MEM;
num_cpus_on_node = cpumask_weight(cpumask_of_node(node));
max /= num_cpus_on_node;
return max(max, min_pages);
}
void tune_lmk_param(int *other_free, int *other_file, struct shrink_control *sc)
{
gfp_t gfp_mask;
struct zone *preferred_zone;
struct zonelist *zonelist;
enum zone_type high_zoneidx, classzone_idx;
unsigned long balance_gap;
gfp_mask = sc->gfp_mask;
zonelist = node_zonelist(0, gfp_mask);
high_zoneidx = gfp_zone(gfp_mask);
first_zones_zonelist(zonelist, high_zoneidx, NULL, &preferred_zone);
classzone_idx = zone_idx(preferred_zone);
balance_gap = min(low_wmark_pages(preferred_zone),
(preferred_zone->present_pages +
KSWAPD_ZONE_BALANCE_GAP_RATIO-1) /
KSWAPD_ZONE_BALANCE_GAP_RATIO);
if (likely(current_is_kswapd() && zone_watermark_ok(preferred_zone, 0,
high_wmark_pages(preferred_zone) + SWAP_CLUSTER_MAX +
balance_gap, 0, 0))) {
if (lmk_fast_run)
tune_lmk_zone_param(zonelist, classzone_idx, other_free,
other_file);
else
tune_lmk_zone_param(zonelist, classzone_idx, other_free,
NULL);
if (zone_watermark_ok(preferred_zone, 0, 0, ZONE_HIGHMEM, 0))
*other_free -=
preferred_zone->lowmem_reserve[ZONE_HIGHMEM];
else
*other_free -= zone_page_state(preferred_zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink of kswapd tunning for highmem "
"ofree %d, %d\n", *other_free, *other_file);
} else {
tune_lmk_zone_param(zonelist, classzone_idx, other_free,
other_file);
lowmem_print(4, "lowmem_shrink tunning for others ofree %d, "
"%d\n", *other_free, *other_file);
}
}
/* Called when a more accurate view of NR_FREE_PAGES is needed */
unsigned long zone_nr_free_pages(struct zone *zone)
{
unsigned long nr_free_pages = zone_page_state(zone, NR_FREE_PAGES);
/*
* While kswapd is awake, it is considered the zone is under some
* memory pressure. Under pressure, there is a risk that
* per-cpu-counter-drift will allow the min watermark to be breached
* potentially causing a live-lock. While kswapd is awake and
* free pages are low, get a better estimate for free pages
*/
if (nr_free_pages < zone->percpu_drift_mark &&
!waitqueue_active(&zone->zone_pgdat->kswapd_wait))
return zone_page_state_snapshot(zone, NR_FREE_PAGES);
return nr_free_pages;
}
static unsigned long highmem_dirtyable_memory(unsigned long total)
{
#ifdef CONFIG_HIGHMEM
int node;
unsigned long x = 0;
for_each_node_state(node, N_HIGH_MEMORY) {
unsigned long nr_pages;
struct zone *z =
&NODE_DATA(node)->node_zones[ZONE_HIGHMEM];
nr_pages = zone_page_state(z, NR_FREE_PAGES) +
zone_reclaimable_pages(z);
/*
* make sure that the number of pages for this node
* is never "negative".
*/
nr_pages -= min(nr_pages, z->dirty_balance_reserve);
x += nr_pages;
}
int bad_memory_status(void)
{
struct zone *zone;
unsigned long free_pages, min_pages;
for_each_populated_zone(zone) {
if (!strcmp(zone->name, "Normal")) {
free_pages = zone_page_state(zone, NR_FREE_PAGES);
min_pages = min_wmark_pages(zone);
if (free_pages < (min_pages + HIB_PAGE_FREE_DELTA)) {
hib_warn("abort hibernate due to %s memory status: (%lu:%lu)\n",
zone->name, free_pages, min_pages);
return -1;
} else {
hib_warn("%s memory status: (%lu:%lu)\n", zone->name, free_pages,
min_pages);
}
}
}
return 0;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
struct task_struct *selected = NULL;
int 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);
int print_extra_info = 0;
static unsigned long lowmem_print_extra_info_timeout = 0;
#ifdef CONFIG_MTK_GMO_RAM_OPTIMIZE
int other_anon = global_page_state(NR_INACTIVE_ANON) - global_page_state(NR_ACTIVE_ANON);
#endif
#ifdef CONFIG_MT_ENG_BUILD
/*dump memory info when framework low memory*/
int pid_dump = -1; // process which need to be dump
//int pid_sec_mem = -1;
int max_mem = 0;
static int pid_flm_warn = -1;
static unsigned long flm_warn_timeout = 0;
#endif // CONFIG_MT_ENG_BUILD
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
*/
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return -1;
/* We are in MTKPASR stage! */
if (unlikely(current->flags & PF_MTKPASR)) {
return -1;
}
if (!spin_trylock(&lowmem_shrink_lock)){
lowmem_print(4, "lowmem_shrink lock faild\n");
return -1;
}
#ifdef CONFIG_ZRAM
other_file -= total_swapcache_pages();
#endif
#ifdef CONFIG_HIGHMEM
/*
* Check whether it is caused by low memory in normal zone!
* This will help solve over-reclaiming situation while total free pages is enough, but normal zone is under low memory.
*/
if (gfp_zone(sc->gfp_mask) == ZONE_NORMAL) {
int nid;
struct zone *z;
/* Restore other_free */
other_free += totalreserve_pages;
/* Go through all memory nodes & substract (free, file) from ZONE_HIGHMEM */
for_each_online_node(nid) {
z = &NODE_DATA(nid)->node_zones[ZONE_HIGHMEM];
other_free -= zone_page_state(z, NR_FREE_PAGES);
other_file -= zone_page_state(z, NR_FILE_PAGES);
/* Don't substract NR_SHMEM twice! */
other_file += zone_page_state(z, NR_SHMEM);
/* Subtract high watermark of normal zone */
z = &NODE_DATA(nid)->node_zones[ZONE_NORMAL];
other_free -= high_wmark_pages(z);
}
/* Normalize */
other_free *= total_low_ratio;
other_file *= total_low_ratio;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *p;
struct task_struct *selected = NULL;
int rem = 0;
int tasksize;
int i;
int min_adj = OOM_ADJUST_MAX + 1;
int selected_tasksize = 0;
int selected_oom_adj;
int array_size = ARRAY_SIZE(lowmem_adj);
int other_free = global_page_state(NR_FREE_PAGES);
int other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM);
int lru_file = global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_FILE);
struct zone *zone;
int fork_boost = 0;
size_t minfree_boosted[6] = {0, 0, 0, 0, 0, 0};
size_t *min_array;
int *adj_array;
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
*/
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout)) {
dump_deathpending(lowmem_deathpending);
return 0;
}
if (lowmem_fork_boost &&
time_before_eq(jiffies, lowmem_fork_boost_timeout)) {
for (i = 0; i < lowmem_minfree_size; i++)
minfree_boosted[i] = lowmem_minfree[i] + lowmem_fork_boost_minfree[i] ;
/* Switch to fork_boost adj/minfree within boost_duration */
adj_array = fork_boost_adj;
min_array = minfree_boosted;
} else {
adj_array = lowmem_adj;
min_array = lowmem_minfree;
}
#ifdef CONFIG_SWAP
if(fudgeswap != 0){
struct sysinfo si;
si_swapinfo(&si);
if(si.freeswap > 0){
if(fudgeswap > si.freeswap)
other_file += si.freeswap;
else
other_file += fudgeswap;
}
}
#endif
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++) {
if (other_free < min_array[i]) {
if (other_file < min_array[i] ||
(lowmem_check_filepages &&
(lru_file < min_array[i]))) {
min_adj = adj_array[i];
fork_boost = lowmem_fork_boost_minfree[i];
break;
}
}
}
if (sc->nr_to_scan > 0)
lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d\n",
sc->nr_to_scan, sc->gfp_mask, other_free, other_file,
min_adj);
rem = global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
if (sc->nr_to_scan <= 0 || min_adj == OOM_ADJUST_MAX + 1) {
lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
return rem;
}
selected_oom_adj = min_adj;
read_lock(&tasklist_lock);
for_each_process(p) {
struct mm_struct *mm;
struct signal_struct *sig;
int oom_adj;
task_lock(p);
mm = p->mm;
sig = p->signal;
if (!mm || !sig) {
task_unlock(p);
continue;
}
oom_adj = sig->oom_adj;
if (oom_adj < min_adj) {
task_unlock(p);
continue;
}
tasksize = get_mm_rss(mm);
task_unlock(p);
if (tasksize <= 0)
continue;
if (selected) {
if (oom_adj < selected_oom_adj)
continue;
if (oom_adj == selected_oom_adj &&
tasksize <= selected_tasksize)
continue;
}
selected = p;
selected_tasksize = tasksize;
selected_oom_adj = oom_adj;
lowmem_print(2, "select %d (%s), adj %d, size %d, to kill\n",
p->pid, p->comm, oom_adj, tasksize);
}
if (selected) {
lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
selected->pid, selected->comm,
selected_oom_adj, selected_tasksize);
if (lowmem_fork_boost)
lowmem_print(1, "current=[%s], min_adj=%d,"
" reclaim=%dK, free=%dK,"
" file=%dK, fork_boost=%dK\n",
current->comm, min_adj,
selected_tasksize << 2, other_free << 2,
other_file << 2, fork_boost << 2);
/* Show memory info if we reach certain adjs */
if (selected_oom_adj < last_min_selected_adj &&
(selected_oom_adj == 12 || selected_oom_adj == 9 ||
selected_oom_adj == 7)) {
last_min_selected_adj = selected_oom_adj;
show_mem(SHOW_MEM_FILTER_NODES);
dump_tasks();
}
/* Dump tasks if we hit low-memory condition */
if (selected_oom_adj < 7) {
show_mem(SHOW_MEM_FILTER_NODES);
dump_tasks();
}
lowmem_deathpending = selected;
lowmem_deathpending_timeout = jiffies + HZ;
force_sig(SIGKILL, selected);
rem -= selected_tasksize;
}
lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
read_unlock(&tasklist_lock);
return rem;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
struct task_struct *selected = NULL;
int rem = 0;
int tasksize;
int i;
int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
int selected_tasksize = 0;
int selected_oom_score_adj;
int array_size = ARRAY_SIZE(lowmem_adj);
int other_free = global_page_state(NR_FREE_PAGES);
int other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM);
int lru_file = global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_FILE);
struct zone *zone;
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
#ifdef CONFIG_SWAP
if(fudgeswap != 0){
struct sysinfo si;
si_swapinfo(&si);
if(si.freeswap > 0){
if(fudgeswap > si.freeswap)
other_file += si.freeswap;
else
other_file += fudgeswap;
}
}
#endif
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++) {
if (other_free < lowmem_minfree[i]) {
if (other_file < lowmem_minfree[i] ||
(lowmem_check_filepages &&
(lru_file < lowmem_minfile[i]))) {
min_score_adj = lowmem_adj[i];
break;
}
}
}
if (sc->nr_to_scan > 0)
lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d\n",
sc->nr_to_scan, sc->gfp_mask, other_free, other_file,
min_score_adj);
rem = global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
if (sc->nr_to_scan <= 0 || min_score_adj == OOM_ADJUST_MAX + 1) {
lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
return rem;
}
selected_oom_score_adj = min_score_adj;
rcu_read_lock();
for_each_process(tsk) {
struct task_struct *p;
int 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();
return 0;
}
oom_score_adj = p->signal->oom_score_adj;
if (oom_score_adj < min_score_adj) {
task_unlock(p);
continue;
}
tasksize = get_mm_rss(p->mm);
task_unlock(p);
if (tasksize <= 0)
continue;
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 %d (%s), adj %d, size %d, to kill\n",
p->pid, p->comm, oom_score_adj, tasksize);
}
if (selected) {
lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
selected->pid, selected->comm,
selected_oom_score_adj, selected_tasksize);
lowmem_deathpending_timeout = jiffies + HZ;
send_sig(SIGKILL, selected, 0);
set_tsk_thread_flag(selected, TIF_MEMDIE);
rem -= selected_tasksize;
}
lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
rcu_read_unlock();
return rem;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
struct task_struct *selected = NULL;
int rem = 0;
int tasksize;
int i;
int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
int minfree = 0;
int selected_tasksize = 0;
int 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);
#ifdef CONFIG_MT_ENG_BUILD
int print_extra_info = 0;
static unsigned long lowmem_print_extra_info_timeout = 0;
/*dump memory info when framework low memory*/
int pid_dump = -1; // process which need to be dump
int pid_sec_mem = -1;
int max_mem = 0;
#endif // CONFIG_MT_ENG_BUILD
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
*/
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return 0;
#ifdef CONFIG_MT_ENG_BUILD
add_kmem_status_lmk_counter();
#endif
#ifdef CONFIG_SWAP
other_file -= total_swapcache_pages;
#endif
#ifdef CONFIG_HIGHMEM
/*
* Check whether it is caused by low memory in normal zone!
* This will help solve over-reclaiming situation while total free pages is enough, but normal zone is under low memory.
*/
if (gfp_zone(sc->gfp_mask) == ZONE_NORMAL) {
int nid;
struct zone *z;
/* Go through all memory nodes & substract (free, file) from ZONE_HIGHMEM */
for_each_online_node(nid) {
z = &NODE_DATA(nid)->node_zones[ZONE_HIGHMEM];
other_free -= zone_page_state(z, NR_FREE_PAGES);
other_file -= zone_page_state(z, NR_FILE_PAGES);
/* Don't substract it twice! */
other_file += zone_page_state(z, NR_SHMEM);
}
other_free *= total_low_ratio;
other_file *= total_low_ratio;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
#ifdef ENHANCED_LMK_ROUTINE
struct task_struct *selected[LOWMEM_DEATHPENDING_DEPTH] = {NULL,};
#else
struct task_struct *selected = NULL;
#endif
int rem = 0;
int tasksize;
int i;
int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
#ifdef ENHANCED_LMK_ROUTINE
int selected_tasksize[LOWMEM_DEATHPENDING_DEPTH] = {0,};
int selected_oom_score_adj[LOWMEM_DEATHPENDING_DEPTH] = {OOM_ADJUST_MAX,};
int all_selected_oom = 0;
int max_selected_oom_idx = 0;
#else
int selected_tasksize = 0;
int selected_oom_score_adj;
#endif
#ifdef CONFIG_SAMP_HOTNESS
int selected_hotness_adj = 0;
#endif
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);
struct zone *zone;
#if defined(CONFIG_ZRAM_FOR_ANDROID) || defined(CONFIG_ZSWAP)
other_file -= total_swapcache_pages;
#endif
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
* Note: Currently you need CONFIG_PROFILING
* for this to work correctly.
*/
#ifdef ENHANCED_LMK_ROUTINE
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++) {
if (lowmem_deathpending[i] &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return 0;
}
#else
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return 0;
#endif
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++) {
if (other_free < lowmem_minfree[i] &&
other_file < lowmem_minfree[i]) {
min_score_adj = lowmem_adj[i];
break;
}
}
if (sc->nr_to_scan > 0)
lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d\n",
sc->nr_to_scan, sc->gfp_mask, other_free,
other_file, min_score_adj);
rem = global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
if (sc->nr_to_scan <= 0 || min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
return rem;
}
#ifdef ENHANCED_LMK_ROUTINE
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++)
selected_oom_score_adj[i] = min_score_adj;
#else
selected_oom_score_adj = min_score_adj;
#endif
#ifdef CONFIG_ZRAM_FOR_ANDROID
atomic_set(&s_reclaim.lmk_running, 1);
#endif
read_lock(&tasklist_lock);
for_each_process(tsk) {
struct task_struct *p;
int oom_score_adj;
#ifdef ENHANCED_LMK_ROUTINE
int is_exist_oom_task = 0;
#endif
#ifdef CONFIG_SAMP_HOTNESS
int hotness_adj = 0;
#endif
if (tsk->flags & PF_KTHREAD)
continue;
p = find_lock_task_mm(tsk);
if (!p)
continue;
oom_score_adj = p->signal->oom_score_adj;
if (oom_score_adj < min_score_adj) {
task_unlock(p);
continue;
}
tasksize = get_mm_rss(p->mm);
#ifdef CONFIG_SAMP_HOTNESS
hotness_adj = p->signal->hotness_adj;
#endif
task_unlock(p);
if (tasksize <= 0)
continue;
#ifdef ENHANCED_LMK_ROUTINE
if (all_selected_oom < LOWMEM_DEATHPENDING_DEPTH) {
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++) {
if (!selected[i]) {
is_exist_oom_task = 1;
max_selected_oom_idx = i;
break;
}
}
} else if (selected_oom_score_adj[max_selected_oom_idx] < oom_score_adj ||
(selected_oom_score_adj[max_selected_oom_idx] == oom_score_adj &&
selected_tasksize[max_selected_oom_idx] < tasksize)) {
is_exist_oom_task = 1;
}
if (is_exist_oom_task) {
selected[max_selected_oom_idx] = p;
selected_tasksize[max_selected_oom_idx] = tasksize;
selected_oom_score_adj[max_selected_oom_idx] = oom_score_adj;
if (all_selected_oom < LOWMEM_DEATHPENDING_DEPTH)
all_selected_oom++;
if (all_selected_oom == LOWMEM_DEATHPENDING_DEPTH) {
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++) {
if (selected_oom_score_adj[i] < selected_oom_score_adj[max_selected_oom_idx])
max_selected_oom_idx = i;
else if (selected_oom_score_adj[i] == selected_oom_score_adj[max_selected_oom_idx] &&
selected_tasksize[i] < selected_tasksize[max_selected_oom_idx])
max_selected_oom_idx = i;
}
}
lowmem_print(2, "select %d (%s), adj %d, \
size %d, to kill\n",
p->pid, p->comm, oom_score_adj, tasksize);
}
#else
if (selected) {
#ifdef CONFIG_SAMP_HOTNESS
if (min_score_adj <= lowmem_adj[4]) {
#endif
if (oom_score_adj < selected_oom_score_adj)
continue;
if (oom_score_adj == selected_oom_score_adj &&
tasksize <= selected_tasksize)
continue;
#ifdef CONFIG_SAMP_HOTNESS
} else {
if (hotness_adj > selected_hotness_adj)
continue;
if (hotness_adj == selected_hotness_adj && tasksize <= selected_tasksize)
continue;
}
#endif
}
selected = p;
selected_tasksize = tasksize;
selected_oom_score_adj = oom_score_adj;
#ifdef CONFIG_SAMP_HOTNESS
selected_hotness_adj = hotness_adj;
#endif
lowmem_print(2, "select %d (%s), adj %d, size %d, to kill\n",
p->pid, p->comm, oom_score_adj, tasksize);
#endif
}
#ifdef ENHANCED_LMK_ROUTINE
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++) {
if (selected[i]) {
#ifdef CONFIG_SAMP_HOTNESS
lowmem_print(1, "send sigkill to %d (%s), adj %d,\
size %d ,hotness %d\n",
selected[i]->pid, selected[i]->comm,
selected_oom_score_adj[i],
selected_tasksize[i],
selected_hotness_adj);
#else
lowmem_print(1, "send sigkill to %d (%s), adj %d,\
size %d\n",
selected[i]->pid, selected[i]->comm,
selected_oom_score_adj[i],
selected_tasksize[i]);
#endif
lowmem_deathpending[i] = selected[i];
lowmem_deathpending_timeout = jiffies + HZ;
send_sig(SIGKILL, selected[i], 0);
rem -= selected_tasksize[i];
#ifdef LMK_COUNT_READ
lmk_count++;
#endif
}
}
#else
if (selected) {
#ifdef CONFIG_SAMP_HOTNESS
lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d ,hotness %d\n",
selected->pid, selected->comm,
selected_oom_score_adj, selected_tasksize,selected_hotness_adj);
#else
lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
selected->pid, selected->comm,
selected_oom_score_adj, selected_tasksize);
#endif
lowmem_deathpending_timeout = jiffies + HZ;
send_sig(SIGKILL, selected, 0);
set_tsk_thread_flag(selected, TIF_MEMDIE);
rem -= selected_tasksize;
#ifdef LMK_COUNT_READ
lmk_count++;
#endif
}
#endif
lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
read_unlock(&tasklist_lock);
#ifdef CONFIG_ZRAM_FOR_ANDROID
atomic_set(&s_reclaim.lmk_running, 0);
#endif
return rem;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
struct task_struct *selected = NULL;
int rem = 0;
int tasksize;
int i;
int min_adj = OOM_ADJUST_MAX + 1;
int selected_tasksize = 0;
int selected_oom_adj;
int array_size = ARRAY_SIZE(lowmem_adj);
int other_free = global_page_state(NR_FREE_PAGES);
int other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM) - global_page_state(NR_MLOCK);
int fork_boost = 0;
int *adj_array;
size_t *min_array;
struct zone *zone;
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
*/
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return 0;
if (lowmem_fork_boost &&
time_before_eq(jiffies, lowmem_fork_boost_timeout)) {
for (i = 0; i < lowmem_minfree_size; i++)
minfree_tmp[i] = lowmem_minfree[i] + lowmem_fork_boost_minfree[i] ;
adj_array = fork_boost_adj;
min_array = minfree_tmp;
}
else {
adj_array = lowmem_adj;
min_array = lowmem_minfree;
}
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++) {
if (other_free < min_array[i] &&
(other_file < min_array[i] || !shrink_cache_possible(sc->gfp_mask))) {
min_adj = adj_array[i];
fork_boost = lowmem_fork_boost_minfree[i];
break;
}
}
if (sc->nr_to_scan > 0)
lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d\n",
sc->nr_to_scan, sc->gfp_mask, other_free, other_file,
min_adj);
rem = global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
if (sc->nr_to_scan <= 0 || min_adj == OOM_ADJUST_MAX + 1) {
lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
return rem;
}
selected_oom_adj = min_adj;
rcu_read_lock();
for_each_process(tsk) {
struct task_struct *p;
int oom_adj;
if (tsk->flags & PF_KTHREAD)
continue;
p = find_lock_task_mm(tsk);
if (!p)
continue;
oom_adj = p->signal->oom_adj;
if (oom_adj < min_adj) {
task_unlock(p);
continue;
}
tasksize = get_mm_rss(p->mm);
task_unlock(p);
if (tasksize <= 0)
continue;
if (selected) {
if (oom_adj < selected_oom_adj)
continue;
if (oom_adj == selected_oom_adj &&
tasksize <= selected_tasksize)
continue;
}
selected = p;
selected_tasksize = tasksize;
selected_oom_adj = oom_adj;
lowmem_print(2, "select %d (%s), adj %d, size %d, to kill\n",
p->pid, p->comm, oom_adj, tasksize);
}
if (selected) {
if (last_min_adj > selected_oom_adj &&
(selected_oom_adj == 12 || selected_oom_adj == 9 || selected_oom_adj == 7)) {
last_min_adj = selected_oom_adj;
lowmem_print(1, "lowmem_shrink: monitor memory status at selected_oom_adj=%d\n", selected_oom_adj);
show_meminfo();
dump_tasks();
}
lowmem_print(1, "[%s] send sigkill to %d (%s), adj %d, size %dK, min_adj=%d,"
" free=%dK, file=%dK, fork_boost=%d\n",
current->comm, selected->pid, selected->comm,
selected_oom_adj, selected_tasksize << 2, min_adj,
other_free << 2, other_file << 2, fork_boost << 2);
lowmem_deathpending = selected;
lowmem_deathpending_timeout = jiffies + HZ;
if (selected_oom_adj < 7)
{
show_meminfo();
dump_tasks();
}
send_sig(SIGKILL, selected, 0);
rem -= selected_tasksize;
}
lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
rcu_read_unlock();
return rem;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *tsk;
struct task_struct *selected = NULL;
int rem = 0;
int tasksize;
int i;
int min_score_adj = OOM_SCORE_ADJ_MAX + 1;
int selected_tasksize = 0;
int selected_oom_score_adj;
int selected_oom_adj = 0;
int array_size = ARRAY_SIZE(lowmem_adj);
int other_free;
int other_file;
int reserved_free = 0;
int cma_free = 0;
unsigned long nr_to_scan = sc->nr_to_scan;
struct zone *zone;
int use_cma = can_use_cma_pages(sc->gfp_mask);
if (nr_to_scan > 0) {
if (!mutex_trylock(&scan_mutex)) {
if (!(lowmem_only_kswapd_sleep && !current_is_kswapd())) {
msleep_interruptible(lowmem_sleep_ms);
}
return 0;
}
}
for_each_zone(zone)
{
if (is_normal(zone))
reserved_free = zone->watermark[WMARK_MIN] + zone->lowmem_reserve[_ZONE];
cma_free += zone_page_state(zone, NR_FREE_CMA_PAGES);
}
other_free = global_page_state(NR_FREE_PAGES);
if (global_page_state(NR_SHMEM) + global_page_state(NR_MLOCK) + total_swapcache_pages <
global_page_state(NR_FILE_PAGES))
other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM) -
global_page_state(NR_MLOCK) -
total_swapcache_pages;
else
other_file = 0;
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++) {
if ((other_free - reserved_free - (use_cma ? 0 : cma_free)) < lowmem_minfree[i] &&
other_file < lowmem_minfree[i]) {
min_score_adj = lowmem_adj[i];
break;
}
}
if (nr_to_scan > 0)
lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d, rfree %d\n",
nr_to_scan, sc->gfp_mask, other_free,
other_file, min_score_adj, reserved_free);
rem = global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
if (nr_to_scan <= 0 || min_score_adj == OOM_SCORE_ADJ_MAX + 1) {
lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
nr_to_scan, sc->gfp_mask, rem);
if (nr_to_scan > 0)
mutex_unlock(&scan_mutex);
return rem;
}
selected_oom_score_adj = min_score_adj;
rcu_read_lock();
for_each_process(tsk) {
struct task_struct *p;
int oom_score_adj;
if (tsk->flags & PF_KTHREAD)
continue;
if (test_task_flag(tsk, TIF_MM_RELEASED))
continue;
if (time_before_eq(jiffies, lowmem_deathpending_timeout)) {
if (test_task_flag(tsk, TIF_MEMDIE)) {
lowmem_print(2, "skipping , waiting for process %d (%s) dead\n",
tsk->pid, tsk->comm);
rcu_read_unlock();
if (!(lowmem_only_kswapd_sleep && !current_is_kswapd())) {
msleep_interruptible(lowmem_sleep_ms);
}
mutex_unlock(&scan_mutex);
return 0;
}
}
p = find_lock_task_mm(tsk);
if (!p)
continue;
oom_score_adj = p->signal->oom_score_adj;
if (oom_score_adj < min_score_adj) {
task_unlock(p);
continue;
}
tasksize = get_mm_rss(p->mm);
task_unlock(p);
if (tasksize <= 0)
continue;
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;
selected_oom_adj = p->signal->oom_adj;
lowmem_print(2, "select %d (%s), oom_adj %d score_adj %d, size %d, to kill\n",
p->pid, p->comm, selected_oom_adj, oom_score_adj, tasksize);
}
if (selected) {
bool should_dump_meminfo = false;
lowmem_print(1, "[%s] send sigkill to %d (%s), oom_adj %d, score_adj %d,"
" min_score_adj %d, size %dK, free %dK, file %dK, "
" reserved_free %dK, cma_free %dK, use_cma %d\n",
current->comm, selected->pid, selected->comm,
selected_oom_adj, selected_oom_score_adj,
min_score_adj, selected_tasksize << 2,
other_free << 2, other_file << 2, reserved_free << 2, cma_free << 2, use_cma);
if (!current_is_kswapd() && current->reclaim_state)
current->reclaim_state->trigger_lmk++;
lowmem_deathpending_timeout = jiffies + HZ;
#ifdef CONFIG_ANDROID_LOW_MEMORY_KILLER_AUTODETECT_OOM_ADJ_VALUES
#define DUMP_INFO_OOM_SCORE_ADJ_THRESHOLD ((7 * OOM_SCORE_ADJ_MAX) / -OOM_DISABLE)
if (selected_oom_score_adj < DUMP_INFO_OOM_SCORE_ADJ_THRESHOLD)
#else
if (selected->signal->oom_adj < 7)
#endif
should_dump_meminfo = true;
send_sig(SIGKILL, selected, 0);
set_tsk_thread_flag(selected, TIF_MEMDIE);
rem -= selected_tasksize;
rcu_read_unlock();
if (should_dump_meminfo) {
show_meminfo();
dump_tasks();
}
if (!(lowmem_only_kswapd_sleep && !current_is_kswapd()))
msleep_interruptible(lowmem_sleep_ms);
} else
rcu_read_unlock();
lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
nr_to_scan, sc->gfp_mask, rem);
mutex_unlock(&scan_mutex);
return rem;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *p;
struct task_struct *selected = NULL;
int rem = 0;
int tasksize;
int i;
int min_adj = OOM_ADJUST_MAX + 1;
int selected_tasksize = 0;
int selected_oom_adj;
int array_size = ARRAY_SIZE(lowmem_adj);
int other_free = global_page_state(NR_FREE_PAGES);
int other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM);
struct zone *zone;
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
*/
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return 0;
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++) {
if (other_free < lowmem_minfree[i] &&
other_file < lowmem_minfree[i]) {
min_adj = lowmem_adj[i];
break;
}
}
if (sc->nr_to_scan > 0)
lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d\n",
sc->nr_to_scan, sc->gfp_mask, other_free, other_file,
min_adj);
rem = global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
if (sc->nr_to_scan <= 0 || min_adj == OOM_ADJUST_MAX + 1) {
lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
return rem;
}
selected_oom_adj = min_adj;
read_lock(&tasklist_lock);
for_each_process(p) {
struct mm_struct *mm;
struct signal_struct *sig;
int oom_adj;
task_lock(p);
mm = p->mm;
sig = p->signal;
if (!mm || !sig) {
task_unlock(p);
continue;
}
oom_adj = sig->oom_adj;
if (oom_adj < min_adj) {
task_unlock(p);
continue;
}
tasksize = get_mm_rss(mm);
task_unlock(p);
if (tasksize <= 0)
continue;
if (selected) {
if (oom_adj < selected_oom_adj)
continue;
if (oom_adj == selected_oom_adj &&
tasksize <= selected_tasksize)
continue;
}
selected = p;
selected_tasksize = tasksize;
selected_oom_adj = oom_adj;
lowmem_print(2, "select %d (%s), adj %d, size %d, to kill\n",
p->pid, p->comm, oom_adj, tasksize);
}
if (selected) {
lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
selected->pid, selected->comm,
selected_oom_adj, selected_tasksize);
lowmem_deathpending = selected;
lowmem_deathpending_timeout = jiffies + HZ;
force_sig(SIGKILL, selected);
rem -= selected_tasksize;
}
lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
read_unlock(&tasklist_lock);
return rem;
}
static int lowmem_shrink(struct shrinker *s, struct shrink_control *sc)
{
struct task_struct *p;
#ifdef ENHANCED_LMK_ROUTINE
struct task_struct *selected[LOWMEM_DEATHPENDING_DEPTH] = {NULL,};
#else
struct task_struct *selected = NULL;
#endif
int rem = 0;
int tasksize;
int i;
int min_adj = OOM_ADJUST_MAX + 1;
#ifdef ENHANCED_LMK_ROUTINE
int selected_tasksize[LOWMEM_DEATHPENDING_DEPTH] = {0,};
int selected_oom_adj[LOWMEM_DEATHPENDING_DEPTH] = {OOM_ADJUST_MAX,};
int all_selected_oom = 0;
int bSelected=0;
int kicked_out_size=0x7FFFFFFF;
int kicked_out_idx=-1;
#else
int selected_tasksize = 0;
int selected_oom_adj;
#endif
int array_size = ARRAY_SIZE(lowmem_adj);
int other_free = global_page_state(NR_FREE_PAGES);
int other_file = global_page_state(NR_FILE_PAGES) -
global_page_state(NR_SHMEM);
struct zone *zone;
if (offlining) {
/* Discount all free space in the section being offlined */
for_each_zone(zone) {
if (zone_idx(zone) == ZONE_MOVABLE) {
other_free -= zone_page_state(zone,
NR_FREE_PAGES);
lowmem_print(4, "lowmem_shrink discounted "
"%lu pages in movable zone\n",
zone_page_state(zone, NR_FREE_PAGES));
}
}
}
/*
* If we already have a death outstanding, then
* bail out right away; indicating to vmscan
* that we have nothing further to offer on
* this pass.
*
*/
#ifdef ENHANCED_LMK_ROUTINE
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++) {
if (lowmem_deathpending[i] &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return 0;
}
#else
if (lowmem_deathpending &&
time_before_eq(jiffies, lowmem_deathpending_timeout))
return 0;
#endif
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++) {
if (other_free < lowmem_minfree[i] &&
other_file < lowmem_minfree[i]) {
min_adj = lowmem_adj[i];
break;
}
}
if (min_adj == OOM_ADJUST_MAX + 1)
return 0;
if (sc->nr_to_scan > 0)
lowmem_print(3, "lowmem_shrink %lu, %x, ofree %d %d, ma %d\n",
sc->nr_to_scan, sc->gfp_mask, other_free, other_file,
min_adj);
rem = global_page_state(NR_ACTIVE_ANON) +
global_page_state(NR_ACTIVE_FILE) +
global_page_state(NR_INACTIVE_ANON) +
global_page_state(NR_INACTIVE_FILE);
if (sc->nr_to_scan <= 0) {
lowmem_print(5, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
return rem;
}
#ifdef ENHANCED_LMK_ROUTINE
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++)
selected_oom_adj[i] = min_adj;
#else
selected_oom_adj = min_adj;
#endif
read_lock(&tasklist_lock);
for_each_process(p) {
struct mm_struct *mm;
struct signal_struct *sig;
int oom_adj;
task_lock(p);
mm = p->mm;
sig = p->signal;
if (!mm || !sig) {
task_unlock(p);
continue;
}
oom_adj = sig->oom_adj;
if (oom_adj < min_adj) {
task_unlock(p);
continue;
}
tasksize = get_mm_rss(mm);
task_unlock(p);
if (tasksize <= 0)
continue;
#ifdef ENHANCED_LMK_ROUTINE
bSelected=0;
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++) {
/* Check if slots are full */
if (all_selected_oom < LOWMEM_DEATHPENDING_DEPTH) {
if (selected[i])
continue;
all_selected_oom++;
}
else if (oom_adj <= selected_oom_adj[i])
continue;
selected[i] = p;
selected_tasksize[i] = tasksize;
selected_oom_adj[i] = oom_adj;
lowmem_print(2, "select[%d] %d (%s), adj %d, size %d, to kill\n",
i,p->pid, p->comm, oom_adj, tasksize);
bSelected=1;
break;
}
/* Find the smallest size slot among the same oom_adj slots */
kicked_out_idx=-1;
kicked_out_size=0x7FFFFFFF;
for (i = 0; !bSelected && i < LOWMEM_DEATHPENDING_DEPTH; i++) {
if (selected[i]) {
if (oom_adj == selected_oom_adj[i]
&& selected_tasksize[i]<kicked_out_size) {
kicked_out_idx=i;
kicked_out_size=selected_tasksize[i];
}
}
}
/* Replace the smallest size slot with the bigger one.*/
if (kicked_out_idx != -1 && tasksize > kicked_out_size) {
selected[kicked_out_idx] = p;
selected_tasksize[kicked_out_idx] = tasksize;
selected_oom_adj[kicked_out_idx] = oom_adj;
lowmem_print(2, "reselect[%d] %d (%s), adj %d, size %d, to kill\n",
kicked_out_idx,p->pid, p->comm, oom_adj, tasksize);
}
#else
if (selected) {
if (oom_adj < selected_oom_adj)
continue;
if (oom_adj == selected_oom_adj &&
tasksize <= selected_tasksize)
continue;
}
selected = p;
selected_tasksize = tasksize;
selected_oom_adj = oom_adj;
lowmem_print(2, "select %d (%s), adj %d, size %d, to kill\n",
p->pid, p->comm, oom_adj, tasksize);
#endif
}
#ifdef ENHANCED_LMK_ROUTINE
for (i = 0; i < LOWMEM_DEATHPENDING_DEPTH; i++) {
if (selected[i]) {
lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
selected[i]->pid, selected[i]->comm,
selected_oom_adj[i], selected_tasksize[i]);
lowmem_deathpending[i] = selected[i];
lowmem_deathpending_timeout = jiffies + HZ;
force_sig(SIGKILL, selected[i]);
rem -= selected_tasksize[i];
}
}
#else
if (selected) {
lowmem_print(1, "send sigkill to %d (%s), adj %d, size %d\n",
selected->pid, selected->comm,
selected_oom_adj, selected_tasksize);
lowmem_deathpending = selected;
lowmem_deathpending_timeout = jiffies + HZ;
force_sig(SIGKILL, selected);
rem -= selected_tasksize;
}
#endif
lowmem_print(4, "lowmem_shrink %lu, %x, return %d\n",
sc->nr_to_scan, sc->gfp_mask, rem);
read_unlock(&tasklist_lock);
return rem;
}
