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

Commit cf7a5625 authored by qctecmdr's avatar qctecmdr Committed by Gerrit - the friendly Code Review server
Browse files

Merge "mm: Support address range reclaim"

parents 01306947 635a7edf

fs/proc/base.c

+3 −0
Original line number 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("mountinfo",  S_IRUGO, proc_mountinfo_operations),

	REG("mountstats", S_IRUSR, proc_mountstats_operations),

#ifdef CONFIG_PROCESS_RECLAIM

	REG("reclaim", 0200, proc_reclaim_operations),

#endif

#ifdef CONFIG_PROC_PAGE_MONITOR

	REG("clear_refs", S_IWUSR, proc_clear_refs_operations),

	REG("smaps",      S_IRUGO, proc_pid_smaps_operations),

fs/proc/internal.h

+1 −0
Original line number 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_pid_link_inode_operations;

extern const struct file_operations proc_reclaim_operations;



void proc_init_kmemcache(void);

void set_proc_pid_nlink(void);

fs/proc/task_mmu.c

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

#include <linux/uaccess.h>

#include <linux/pkeys.h>

#include <linux/mm_inline.h>

#include <linux/ctype.h>



#include <asm/elf.h>

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

#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, vma);

	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[200];

	struct mm_struct *mm;

	struct vm_area_struct *vma;

	enum reclaim_type type;

	char *type_buf;

	struct mm_walk reclaim_walk = {};

	unsigned long start = 0;

	unsigned long end = 0;



	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 if (isdigit(*type_buf))

		type = RECLAIM_RANGE;

	else

		goto out_err;



	if (type == RECLAIM_RANGE) {

		char *token;

		unsigned long long len, len_in, tmp;



		token = strsep(&type_buf, " ");

		if (!token)

			goto out_err;

		tmp = memparse(token, &token);

		if (tmp & ~PAGE_MASK || tmp > ULONG_MAX)

			goto out_err;

		start = tmp;



		token = strsep(&type_buf, " ");

		if (!token)

			goto out_err;

		len_in = memparse(token, &token);

		len = (len_in + ~PAGE_MASK) & PAGE_MASK;

		if (len > ULONG_MAX)

			goto out_err;

		/*

		 * Check to see whether len was rounded up from small -ve

		 * to zero.

		 */

		if (len_in && !len)

			goto out_err;



		end = start + len;

		if (end < start)

			goto out_err;

	}



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

	if (!task)

		return -ESRCH;



	mm = get_task_mm(task);

	if (!mm)

		goto out;



	reclaim_walk.mm = mm;

	reclaim_walk.pmd_entry = reclaim_pte_range;



	down_read(&mm->mmap_sem);

	if (type == RECLAIM_RANGE) {

		vma = find_vma(mm, start);

		while (vma) {

			if (vma->vm_start > end)

				break;

			if (is_vm_hugetlb_page(vma))

				continue;



			reclaim_walk.private = vma;

			walk_page_range(max(vma->vm_start, start),

					min(vma->vm_end, end),

					&reclaim_walk);

			vma = vma->vm_next;

		}

	} else {

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

			if (is_vm_hugetlb_page(vma))

				continue;



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

				continue;



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

				continue;



			reclaim_walk.private = vma;

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

				&reclaim_walk);

		}

	}



	flush_tlb_mm(mm);

	up_read(&mm->mmap_sem);

	mmput(mm);

out:

	put_task_struct(task);

	return count;



out_err:

	return -EINVAL;

}



const struct file_operations proc_reclaim_operations = {

	.write		= reclaim_write,

	.llseek		= noop_llseek,

};

#endif



#ifdef CONFIG_NUMA



struct numa_maps {

include/linux/rmap.h

+9 −2
Original line number Diff line number Diff line
@@ -12,6 +12,11 @@ 
#include <linux/memcontrol.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,

					     struct vm_area_struct *vma);



/*

 * 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:
@@ -203,7 +208,8 @@ static inline void page_dup_rmap(struct page *page, bool compound) 
int page_referenced(struct page *, int is_locked,

			struct mem_cgroup *memcg, unsigned long *vm_flags);



bool try_to_unmap(struct page *, enum ttu_flags flags);

bool try_to_unmap(struct page *page, enum ttu_flags flags,

				struct vm_area_struct *vma);



/* Avoid racy checks */

#define PVMW_SYNC		(1 << 0)
@@ -269,6 +275,7 @@ int page_mapped_in_vma(struct page *page, struct vm_area_struct *vma); 
 */

struct rmap_walk_control {

	void *arg;

	struct vm_area_struct *target_vma;

	/*

	 * Return false if page table scanning in rmap_walk should be stopped.

	 * Otherwise, return true.
@@ -297,7 +304,7 @@ static inline int page_referenced(struct page *page, int is_locked, 
	return 0;

}



#define try_to_unmap(page, refs) false

#define try_to_unmap(page, refs, vma) false



static inline int page_mkclean(struct page *page)

{

mm/Kconfig

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



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.



	 (echo addr size-byte > /proc/PID/reclaim) reclaims pages in

	 (addr, addr + size-bytes) of the process.



	 Any other value is ignored.