Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fd3a0c01 authored by Minchan Kim's avatar Minchan Kim Committed by Gerrit - the friendly Code Review server
Browse files

mm: Per process reclaim 



These day, there are many platforms available in the embedded market
and they are smarter than kernel which has very limited information
about working set so they want to involve memory management more heavily
like android's lowmemory killer and ashmem or recent many lowmemory
notifier.

One of the simple imagine scenario about userspace's intelligence is that
platform can manage tasks as forground and background so it would be
better to reclaim background's task pages for end-user's *responsibility*
although it has frequent referenced pages.

This patch adds new knob "reclaim under proc/<pid>/" so task manager
can reclaim any target process anytime, anywhere. It could give another
method to platform for using memory efficiently.

It can avoid process killing for getting free memory, which was really
terrible experience because I lost my best score of game I had ever
after I switch the phone call while I enjoyed the game.

Reclaim file-backed pages only.
	echo file > /proc/PID/reclaim
Reclaim anonymous pages only.
	echo anon > /proc/PID/reclaim
Reclaim all pages
	echo all > /proc/PID/reclaim

Change-Id: Iabdb7bc2ef3dc4d94e3ea005fbe18f4cd06739ab
Signed-off-by: default avatarMinchan Kim <minchan@kernel.org>
Patch-mainline: linux-mm @ 9 May 2013 16:21:24
[vinmenon@codeaurora.org: merge conflict fixes, minor tweak of the commit msg]
Signed-off-by: default avatarVinayak Menon <vinmenon@codeaurora.org>
parent a9842d93

fs/proc/base.c

+3 −0
Original line number Original line Diff line number Diff line
@@ -3151,6 +3151,9 @@ static const struct pid_entry tgid_base_stuff[] = { 
	REG("mounts",     S_IRUGO, proc_mounts_operations),

	REG("mounts",     S_IRUGO, proc_mounts_operations),

	REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),

	REG("mountinfo",  S_IRUGO, proc_mountinfo_operations),

	REG("mountstats", S_IRUSR, proc_mountstats_operations),

	REG("mountstats", S_IRUSR, proc_mountstats_operations),

#ifdef CONFIG_PROCESS_RECLAIM

	REG("reclaim", 0200, proc_reclaim_operations),

#endif

#ifdef CONFIG_PROC_PAGE_MONITOR

#ifdef CONFIG_PROC_PAGE_MONITOR

	REG("clear_refs", S_IWUSR, proc_clear_refs_operations),

	REG("clear_refs", S_IWUSR, proc_clear_refs_operations),

	REG("smaps",      S_IRUGO, proc_pid_smaps_operations),

	REG("smaps",      S_IRUGO, proc_pid_smaps_operations),

fs/proc/internal.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -208,6 +208,7 @@ struct pde_opener { 
extern const struct inode_operations proc_link_inode_operations;

extern const struct inode_operations proc_link_inode_operations;





extern const struct inode_operations proc_pid_link_inode_operations;

extern const struct inode_operations proc_pid_link_inode_operations;

extern const struct file_operations proc_reclaim_operations;





void proc_init_kmemcache(void);

void proc_init_kmemcache(void);

void set_proc_pid_nlink(void);

void set_proc_pid_nlink(void);

fs/proc/task_mmu.c

+121 −0
Original line number Original line Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include <linux/shmem_fs.h>

#include <linux/shmem_fs.h>

#include <linux/uaccess.h>

#include <linux/uaccess.h>

#include <linux/pkeys.h>

#include <linux/pkeys.h>

#include <linux/mm_inline.h>





#include <asm/elf.h>

#include <asm/elf.h>

#include <asm/tlb.h>

#include <asm/tlb.h>
@@ -1632,6 +1633,126 @@ const struct file_operations proc_pagemap_operations = { 
};

};

#endif /* CONFIG_PROC_PAGE_MONITOR */

#endif /* CONFIG_PROC_PAGE_MONITOR */





#ifdef CONFIG_PROCESS_RECLAIM

static int reclaim_pte_range(pmd_t *pmd, unsigned long addr,

				unsigned long end, struct mm_walk *walk)

{

	struct vm_area_struct *vma = walk->private;

	pte_t *pte, ptent;

	spinlock_t *ptl;

	struct page *page;

	LIST_HEAD(page_list);

	int isolated;



	split_huge_pmd(vma, addr, pmd);

	if (pmd_trans_unstable(pmd))

		return 0;

cont:

	isolated = 0;

	pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);

	for (; addr != end; pte++, addr += PAGE_SIZE) {

		ptent = *pte;

		if (!pte_present(ptent))

			continue;



		page = vm_normal_page(vma, addr, ptent);

		if (!page)

			continue;



		if (isolate_lru_page(page))

			continue;



		list_add(&page->lru, &page_list);

		inc_node_page_state(page, NR_ISOLATED_ANON +

				page_is_file_cache(page));

		isolated++;

		if (isolated >= SWAP_CLUSTER_MAX)

			break;

	}

	pte_unmap_unlock(pte - 1, ptl);

	reclaim_pages_from_list(&page_list);

	if (addr != end)

		goto cont;



	cond_resched();

	return 0;

}



enum reclaim_type {

	RECLAIM_FILE,

	RECLAIM_ANON,

	RECLAIM_ALL,

	RECLAIM_RANGE,

};



static ssize_t reclaim_write(struct file *file, const char __user *buf,

				size_t count, loff_t *ppos)

{

	struct task_struct *task;

	char buffer[PROC_NUMBUF];

	struct mm_struct *mm;

	struct vm_area_struct *vma;

	enum reclaim_type type;

	char *type_buf;



	memset(buffer, 0, sizeof(buffer));

	if (count > sizeof(buffer) - 1)

		count = sizeof(buffer) - 1;



	if (copy_from_user(buffer, buf, count))

		return -EFAULT;



	type_buf = strstrip(buffer);

	if (!strcmp(type_buf, "file"))

		type = RECLAIM_FILE;

	else if (!strcmp(type_buf, "anon"))

		type = RECLAIM_ANON;

	else if (!strcmp(type_buf, "all"))

		type = RECLAIM_ALL;

	else

		return -EINVAL;



	task = get_proc_task(file->f_path.dentry->d_inode);

	if (!task)

		return -ESRCH;



	mm = get_task_mm(task);

	if (mm) {

		struct mm_walk reclaim_walk = {

			.pmd_entry = reclaim_pte_range,

			.mm = mm,

		};



		down_read(&mm->mmap_sem);

		for (vma = mm->mmap; vma; vma = vma->vm_next) {

			reclaim_walk.private = vma;



			if (is_vm_hugetlb_page(vma))

				continue;



			if (type == RECLAIM_ANON && vma->vm_file)

				continue;

			if (type == RECLAIM_FILE && !vma->vm_file)

				continue;



			walk_page_range(vma->vm_start, vma->vm_end,

					&reclaim_walk);

		}

		flush_tlb_mm(mm);

		up_read(&mm->mmap_sem);

		mmput(mm);

	}

	put_task_struct(task);



	return count;

}



const struct file_operations proc_reclaim_operations = {

	.write		= reclaim_write,

	.llseek		= noop_llseek,

};

#endif



#ifdef CONFIG_NUMA

#ifdef CONFIG_NUMA





struct numa_maps {

struct numa_maps {

include/linux/rmap.h

+4 −0
Original line number Original line Diff line number Diff line
@@ -12,6 +12,10 @@ 
#include <linux/memcontrol.h>

#include <linux/memcontrol.h>

#include <linux/highmem.h>

#include <linux/highmem.h>





extern int isolate_lru_page(struct page *page);

extern void putback_lru_page(struct page *page);

extern unsigned long reclaim_pages_from_list(struct list_head *page_list);



/*

/*

 * The anon_vma heads a list of private "related" vmas, to scan if

 * The anon_vma heads a list of private "related" vmas, to scan if

 * an anonymous page pointing to this anon_vma needs to be unmapped:

 * an anonymous page pointing to this anon_vma needs to be unmapped:

mm/Kconfig

+13 −0
Original line number Original line Diff line number Diff line
@@ -816,3 +816,16 @@ config ARCH_HAS_PTE_SPECIAL 
	bool

	bool





endmenu

endmenu



config PROCESS_RECLAIM

	bool "Enable process reclaim"

	depends on PROC_FS

	default y

	help

	 It allows to reclaim pages of the process by /proc/pid/reclaim.



	 (echo file > /proc/PID/reclaim) reclaims file-backed pages only.

	 (echo anon > /proc/PID/reclaim) reclaims anonymous pages only.

	 (echo all > /proc/PID/reclaim) reclaims all pages.



	 Any other value is ignored.