[thirdparty/linux.git] / mm / mincore.c

// SPDX-License-Identifier: GPL-2.0
/*
 *	linux/mm/mincore.c
 *
 * Copyright (C) 1994-2006  Linus Torvalds
 */

/*
 * The mincore() system call.
 */
#include <linux/pagemap.h>
#include <linux/gfp.h>
#include <linux/mm.h>
#include <linux/mman.h>
#include <linux/syscalls.h>
#include <linux/swap.h>
#include <linux/swapops.h>
#include <linux/shmem_fs.h>
#include <linux/hugetlb.h>

#include <linux/uaccess.h>
#include <asm/pgtable.h>

static int mincore_hugetlb(pte_t *pte, unsigned long hmask, unsigned long addr,
			unsigned long end, struct mm_walk *walk)
{
#ifdef CONFIG_HUGETLB_PAGE
	unsigned char present;
	unsigned char *vec = walk->private;

	/*
	 * Hugepages under user process are always in RAM and never
	 * swapped out, but theoretically it needs to be checked.
	 */
	present = pte && !huge_pte_none(huge_ptep_get(pte));
	for (; addr != end; vec++, addr += PAGE_SIZE)
		*vec = present;
	walk->private = vec;
#else
	BUG();
#endif
	return 0;
}

/*
 * Later we can get more picky about what "in core" means precisely.
 * For now, simply check to see if the page is in the page cache,
 * and is up to date; i.e. that no page-in operation would be required
 * at this time if an application were to map and access this page.
 */
static unsigned char mincore_page(struct address_space *mapping, pgoff_t pgoff)
{
	unsigned char present = 0;
	struct page *page;

	/*
	 * When tmpfs swaps out a page from a file, any process mapping that
	 * file will not get a swp_entry_t in its pte, but rather it is like
	 * any other file mapping (ie. marked !present and faulted in with
	 * tmpfs's .fault). So swapped out tmpfs mappings are tested here.
	 */
#ifdef CONFIG_SWAP
	if (shmem_mapping(mapping)) {
		page = find_get_entry(mapping, pgoff);
		/*
		 * shmem/tmpfs may return swap: account for swapcache
		 * page too.
		 */
		if (xa_is_value(page)) {
			swp_entry_t swp = radix_to_swp_entry(page);
			struct swap_info_struct *si;

			/* Prevent swap device to being swapoff under us */
			si = get_swap_device(swp);
			if (si) {
				page = find_get_page(swap_address_space(swp),
						     swp_offset(swp));
				put_swap_device(si);
			} else
				page = NULL;
		}
	} else
		page = find_get_page(mapping, pgoff);
#else
	page = find_get_page(mapping, pgoff);
#endif
	if (page) {
		present = PageUptodate(page);
		put_page(page);
	}

	return present;
}

static int __mincore_unmapped_range(unsigned long addr, unsigned long end,
				struct vm_area_struct *vma, unsigned char *vec)
{
	unsigned long nr = (end - addr) >> PAGE_SHIFT;
	int i;

	if (vma->vm_file) {
		pgoff_t pgoff;

		pgoff = linear_page_index(vma, addr);
		for (i = 0; i < nr; i++, pgoff++)
			vec[i] = mincore_page(vma->vm_file->f_mapping, pgoff);
	} else {
		for (i = 0; i < nr; i++)
			vec[i] = 0;
	}
	return nr;
}

static int mincore_unmapped_range(unsigned long addr, unsigned long end,
				   struct mm_walk *walk)
{
	walk->private += __mincore_unmapped_range(addr, end,
						  walk->vma, walk->private);
	return 0;
}

static int mincore_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
			struct mm_walk *walk)
{
	spinlock_t *ptl;
	struct vm_area_struct *vma = walk->vma;
	pte_t *ptep;
	unsigned char *vec = walk->private;
	int nr = (end - addr) >> PAGE_SHIFT;

	ptl = pmd_trans_huge_lock(pmd, vma);
	if (ptl) {
		memset(vec, 1, nr);
		spin_unlock(ptl);
		goto out;
	}

	if (pmd_trans_unstable(pmd)) {
		__mincore_unmapped_range(addr, end, vma, vec);
		goto out;
	}

	ptep = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
	for (; addr != end; ptep++, addr += PAGE_SIZE) {
		pte_t pte = *ptep;

		if (pte_none(pte))
			__mincore_unmapped_range(addr, addr + PAGE_SIZE,
						 vma, vec);
		else if (pte_present(pte))
			*vec = 1;
		else { /* pte is a swap entry */
			swp_entry_t entry = pte_to_swp_entry(pte);

			if (non_swap_entry(entry)) {
				/*
				 * migration or hwpoison entries are always
				 * uptodate
				 */
				*vec = 1;
			} else {
#ifdef CONFIG_SWAP
				*vec = mincore_page(swap_address_space(entry),
						    swp_offset(entry));
#else
				WARN_ON(1);
				*vec = 1;
#endif
			}
		}
		vec++;
	}
	pte_unmap_unlock(ptep - 1, ptl);
out:
	walk->private += nr;
	cond_resched();
	return 0;
}

static inline bool can_do_mincore(struct vm_area_struct *vma)
{
	if (vma_is_anonymous(vma))
		return true;
	if (!vma->vm_file)
		return false;
	/*
	 * Reveal pagecache information only for non-anonymous mappings that
	 * correspond to the files the calling process could (if tried) open
	 * for writing; otherwise we'd be including shared non-exclusive
	 * mappings, which opens a side channel.
	 */
	return inode_owner_or_capable(file_inode(vma->vm_file)) ||
		inode_permission(file_inode(vma->vm_file), MAY_WRITE) == 0;
}

/*
 * Do a chunk of "sys_mincore()". We've already checked
 * all the arguments, we hold the mmap semaphore: we should
 * just return the amount of info we're asked for.
 */
static long do_mincore(unsigned long addr, unsigned long pages, unsigned char *vec)
{
	struct vm_area_struct *vma;
	unsigned long end;
	int err;
	struct mm_walk mincore_walk = {
		.pmd_entry = mincore_pte_range,
		.pte_hole = mincore_unmapped_range,
		.hugetlb_entry = mincore_hugetlb,
		.private = vec,
	};

	vma = find_vma(current->mm, addr);
	if (!vma || addr < vma->vm_start)
		return -ENOMEM;
	end = min(vma->vm_end, addr + (pages << PAGE_SHIFT));
	if (!can_do_mincore(vma)) {
		unsigned long pages = DIV_ROUND_UP(end - addr, PAGE_SIZE);
		memset(vec, 1, pages);
		return pages;
	}
	mincore_walk.mm = vma->vm_mm;
	err = walk_page_range(addr, end, &mincore_walk);
	if (err < 0)
		return err;
	return (end - addr) >> PAGE_SHIFT;
}

/*
 * The mincore(2) system call.
 *
 * mincore() returns the memory residency status of the pages in the
 * current process's address space specified by [addr, addr + len).
 * The status is returned in a vector of bytes.  The least significant
 * bit of each byte is 1 if the referenced page is in memory, otherwise
 * it is zero.
 *
 * Because the status of a page can change after mincore() checks it
 * but before it returns to the application, the returned vector may
 * contain stale information.  Only locked pages are guaranteed to
 * remain in memory.
 *
 * return values:
 *  zero    - success
 *  -EFAULT - vec points to an illegal address
 *  -EINVAL - addr is not a multiple of PAGE_SIZE
 *  -ENOMEM - Addresses in the range [addr, addr + len] are
 *		invalid for the address space of this process, or
 *		specify one or more pages which are not currently
 *		mapped
 *  -EAGAIN - A kernel resource was temporarily unavailable.
 */
SYSCALL_DEFINE3(mincore, unsigned long, start, size_t, len,
		unsigned char __user *, vec)
{
	long retval;
	unsigned long pages;
	unsigned char *tmp;

	/* Check the start address: needs to be page-aligned.. */
	if (start & ~PAGE_MASK)
		return -EINVAL;

	/* ..and we need to be passed a valid user-space range */
	if (!access_ok((void __user *) start, len))
		return -ENOMEM;

	/* This also avoids any overflows on PAGE_ALIGN */
	pages = len >> PAGE_SHIFT;
	pages += (offset_in_page(len)) != 0;

	if (!access_ok(vec, pages))
		return -EFAULT;

	tmp = (void *) __get_free_page(GFP_USER);
	if (!tmp)
		return -EAGAIN;

	retval = 0;
	while (pages) {
		/*
		 * Do at most PAGE_SIZE entries per iteration, due to
		 * the temporary buffer size.
		 */
		down_read(&current->mm->mmap_sem);
		retval = do_mincore(start, min(pages, PAGE_SIZE), tmp);
		up_read(&current->mm->mmap_sem);

		if (retval <= 0)
			break;
		if (copy_to_user(vec, tmp, retval)) {
			retval = -EFAULT;
			break;
		}
		pages -= retval;
		vec += retval;
		start += retval << PAGE_SHIFT;
		retval = 0;
	}
	free_page((unsigned long) tmp);
	return retval;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* linux/mm/mincore.c
	4	*
2f77d107	5	* Copyright (C) 1994-2006 Linus Torvalds
1da177e4 LT	6	*/
	7
	8	/*
	9	* The mincore() system call.
	10	*/
1da177e4	11	#include <linux/pagemap.h>
5a0e3ad6	12	#include <linux/gfp.h>
1da177e4 LT	13	#include <linux/mm.h>
	14	#include <linux/mman.h>
	15	#include <linux/syscalls.h>
42da9cbd NP	16	#include <linux/swap.h>
42da9cbd NP	17	#include <linux/swapops.h>
3a4f8a0b	18	#include <linux/shmem_fs.h>
4f16fc10	19	#include <linux/hugetlb.h>
1da177e4	20
7c0f6ba6	21	#include <linux/uaccess.h>
1da177e4 LT	22	#include <asm/pgtable.h>
1da177e4 LT	23
1e25a271 NH	24	static int mincore_hugetlb(pte_t *pte, unsigned long hmask, unsigned long addr,
1e25a271 NH	25	unsigned long end, struct mm_walk *walk)
f4884010 JW	26	{
f4884010 JW	27	#ifdef CONFIG_HUGETLB_PAGE
1e25a271 NH	28	unsigned char present;
1e25a271 NH	29	unsigned char *vec = walk->private;
f4884010	30
1e25a271 NH	31	/*
	32	* Hugepages under user process are always in RAM and never
	33	* swapped out, but theoretically it needs to be checked.
	34	*/
	35	present = pte && !huge_pte_none(huge_ptep_get(pte));
	36	for (; addr != end; vec++, addr += PAGE_SIZE)
	37	*vec = present;
	38	walk->private = vec;
f4884010 JW	39	#else
	40	BUG();
	41	#endif
1e25a271	42	return 0;
f4884010 JW	43	}
f4884010 JW	44
30bac164 LT	45	/*
	46	* Later we can get more picky about what "in core" means precisely.
	47	* For now, simply check to see if the page is in the page cache,
	48	* and is up to date; i.e. that no page-in operation would be required
	49	* at this time if an application were to map and access this page.
	50	*/
	51	static unsigned char mincore_page(struct address_space *mapping, pgoff_t pgoff)
	52	{
	53	unsigned char present = 0;
	54	struct page *page;
	55
	56	/*
	57	* When tmpfs swaps out a page from a file, any process mapping that
	58	* file will not get a swp_entry_t in its pte, but rather it is like
	59	* any other file mapping (ie. marked !present and faulted in with
	60	* tmpfs's .fault). So swapped out tmpfs mappings are tested here.
	61	*/
	62	#ifdef CONFIG_SWAP
	63	if (shmem_mapping(mapping)) {
	64	page = find_get_entry(mapping, pgoff);
	65	/*
	66	* shmem/tmpfs may return swap: account for swapcache
	67	* page too.
	68	*/
	69	if (xa_is_value(page)) {
	70	swp_entry_t swp = radix_to_swp_entry(page);
aeb309b8 HY	71	struct swap_info_struct *si;
	72
	73	/* Prevent swap device to being swapoff under us */
	74	si = get_swap_device(swp);
	75	if (si) {
	76	page = find_get_page(swap_address_space(swp),
	77	swp_offset(swp));
	78	put_swap_device(si);
	79	} else
	80	page = NULL;
30bac164 LT	81	}
	82	} else
	83	page = find_get_page(mapping, pgoff);
	84	#else
	85	page = find_get_page(mapping, pgoff);
	86	#endif
	87	if (page) {
	88	present = PageUptodate(page);
	89	put_page(page);
	90	}
	91
	92	return present;
	93	}
	94
	95	static int __mincore_unmapped_range(unsigned long addr, unsigned long end,
	96	struct vm_area_struct vma, unsigned char vec)
1e25a271	97	{
574823bf	98	unsigned long nr = (end - addr) >> PAGE_SHIFT;
30bac164	99	int i;
574823bf	100
30bac164 LT	101	if (vma->vm_file) {
	102	pgoff_t pgoff;
	103
	104	pgoff = linear_page_index(vma, addr);
	105	for (i = 0; i < nr; i++, pgoff++)
	106	vec[i] = mincore_page(vma->vm_file->f_mapping, pgoff);
	107	} else {
	108	for (i = 0; i < nr; i++)
	109	vec[i] = 0;
	110	}
	111	return nr;
	112	}
	113
	114	static int mincore_unmapped_range(unsigned long addr, unsigned long end,
	115	struct mm_walk *walk)
	116	{
	117	walk->private += __mincore_unmapped_range(addr, end,
	118	walk->vma, walk->private);
1e25a271	119	return 0;
f4884010 JW	120	}
f4884010 JW	121
1e25a271 NH	122	static int mincore_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
1e25a271 NH	123	struct mm_walk *walk)
f4884010 JW	124	{
f4884010 JW	125	spinlock_t *ptl;
1e25a271	126	struct vm_area_struct *vma = walk->vma;
f4884010	127	pte_t *ptep;
1e25a271 NH	128	unsigned char *vec = walk->private;
	129	int nr = (end - addr) >> PAGE_SHIFT;
	130
b6ec57f4 KS	131	ptl = pmd_trans_huge_lock(pmd, vma);
b6ec57f4 KS	132	if (ptl) {
1e25a271 NH	133	memset(vec, 1, nr);
	134	spin_unlock(ptl);
	135	goto out;
	136	}
f4884010	137
1e25a271	138	if (pmd_trans_unstable(pmd)) {
30bac164	139	__mincore_unmapped_range(addr, end, vma, vec);
1e25a271 NH	140	goto out;
	141	}
	142
	143	ptep = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
	144	for (; addr != end; ptep++, addr += PAGE_SIZE) {
f4884010	145	pte_t pte = *ptep;
f4884010 JW	146
f4884010 JW	147	if (pte_none(pte))
30bac164 LT	148	__mincore_unmapped_range(addr, addr + PAGE_SIZE,
30bac164 LT	149	vma, vec);
f4884010	150	else if (pte_present(pte))
25ef0e50	151	*vec = 1;
0661a336	152	else { /* pte is a swap entry */
f4884010 JW	153	swp_entry_t entry = pte_to_swp_entry(pte);
f4884010 JW	154
30bac164 LT	155	if (non_swap_entry(entry)) {
	156	/*
	157	* migration or hwpoison entries are always
	158	* uptodate
	159	*/
	160	*vec = 1;
	161	} else {
	162	#ifdef CONFIG_SWAP
	163	*vec = mincore_page(swap_address_space(entry),
	164	swp_offset(entry));
	165	#else
	166	WARN_ON(1);
	167	*vec = 1;
	168	#endif
	169	}
f4884010	170	}
25ef0e50	171	vec++;
1e25a271	172	}
f4884010	173	pte_unmap_unlock(ptep - 1, ptl);
1e25a271 NH	174	out:
	175	walk->private += nr;
	176	cond_resched();
	177	return 0;
e48293fd JW	178	}
e48293fd JW	179
134fca90 JK	180	static inline bool can_do_mincore(struct vm_area_struct *vma)
	181	{
	182	if (vma_is_anonymous(vma))
	183	return true;
	184	if (!vma->vm_file)
	185	return false;
	186	/*
	187	* Reveal pagecache information only for non-anonymous mappings that
	188	* correspond to the files the calling process could (if tried) open
	189	* for writing; otherwise we'd be including shared non-exclusive
	190	* mappings, which opens a side channel.
	191	*/
	192	return inode_owner_or_capable(file_inode(vma->vm_file)) \|\|
	193	inode_permission(file_inode(vma->vm_file), MAY_WRITE) == 0;
	194	}
	195
2f77d107 LT	196	/*
	197	* Do a chunk of "sys_mincore()". We've already checked
	198	* all the arguments, we hold the mmap semaphore: we should
	199	* just return the amount of info we're asked for.
	200	*/
6a60f1b3	201	static long do_mincore(unsigned long addr, unsigned long pages, unsigned char *vec)
1da177e4	202	{
6a60f1b3	203	struct vm_area_struct *vma;
25ef0e50	204	unsigned long end;
1e25a271 NH	205	int err;
	206	struct mm_walk mincore_walk = {
	207	.pmd_entry = mincore_pte_range,
	208	.pte_hole = mincore_unmapped_range,
	209	.hugetlb_entry = mincore_hugetlb,
	210	.private = vec,
	211	};
1da177e4	212
6a60f1b3	213	vma = find_vma(current->mm, addr);
4fb23e43 LT	214	if (!vma \|\| addr < vma->vm_start)
4fb23e43 LT	215	return -ENOMEM;
25ef0e50	216	end = min(vma->vm_end, addr + (pages << PAGE_SHIFT));
134fca90 JK	217	if (!can_do_mincore(vma)) {
	218	unsigned long pages = DIV_ROUND_UP(end - addr, PAGE_SIZE);
	219	memset(vec, 1, pages);
	220	return pages;
	221	}
	222	mincore_walk.mm = vma->vm_mm;
1e25a271 NH	223	err = walk_page_range(addr, end, &mincore_walk);
	224	if (err < 0)
	225	return err;
25ef0e50	226	return (end - addr) >> PAGE_SHIFT;
1da177e4 LT	227	}
	228
	229	/*
	230	* The mincore(2) system call.
	231	*
	232	* mincore() returns the memory residency status of the pages in the
	233	* current process's address space specified by [addr, addr + len).
	234	* The status is returned in a vector of bytes. The least significant
	235	* bit of each byte is 1 if the referenced page is in memory, otherwise
	236	* it is zero.
	237	*
	238	* Because the status of a page can change after mincore() checks it
	239	* but before it returns to the application, the returned vector may
	240	* contain stale information. Only locked pages are guaranteed to
	241	* remain in memory.
	242	*
	243	* return values:
	244	* zero - success
	245	* -EFAULT - vec points to an illegal address
ea1754a0	246	* -EINVAL - addr is not a multiple of PAGE_SIZE
1da177e4 LT	247	* -ENOMEM - Addresses in the range [addr, addr + len] are
	248	* invalid for the address space of this process, or
	249	* specify one or more pages which are not currently
	250	* mapped
	251	* -EAGAIN - A kernel resource was temporarily unavailable.
	252	*/
3480b257 HC	253	SYSCALL_DEFINE3(mincore, unsigned long, start, size_t, len,
3480b257 HC	254	unsigned char __user *, vec)
1da177e4	255	{
2f77d107 LT	256	long retval;
	257	unsigned long pages;
	258	unsigned char *tmp;
1da177e4	259
2f77d107	260	/* Check the start address: needs to be page-aligned.. */
09cbfeaf	261	if (start & ~PAGE_MASK)
2f77d107	262	return -EINVAL;
1da177e4	263
2f77d107	264	/* ..and we need to be passed a valid user-space range */
96d4f267	265	if (!access_ok((void __user *) start, len))
2f77d107	266	return -ENOMEM;
1da177e4	267
ea1754a0	268	/* This also avoids any overflows on PAGE_ALIGN */
2f77d107	269	pages = len >> PAGE_SHIFT;
e7bbdd07	270	pages += (offset_in_page(len)) != 0;
1da177e4	271
96d4f267	272	if (!access_ok(vec, pages))
2f77d107	273	return -EFAULT;
1da177e4	274
2f77d107 LT	275	tmp = (void *) __get_free_page(GFP_USER);
2f77d107 LT	276	if (!tmp)
4fb23e43	277	return -EAGAIN;
2f77d107 LT	278
	279	retval = 0;
	280	while (pages) {
	281	/*
	282	* Do at most PAGE_SIZE entries per iteration, due to
	283	* the temporary buffer size.
	284	*/
	285	down_read(&current->mm->mmap_sem);
6a60f1b3	286	retval = do_mincore(start, min(pages, PAGE_SIZE), tmp);
2f77d107 LT	287	up_read(&current->mm->mmap_sem);
	288
	289	if (retval <= 0)
	290	break;
	291	if (copy_to_user(vec, tmp, retval)) {
	292	retval = -EFAULT;
	293	break;
1da177e4	294	}
2f77d107 LT	295	pages -= retval;
	296	vec += retval;
	297	start += retval << PAGE_SHIFT;
	298	retval = 0;
1da177e4	299	}
2f77d107 LT	300	free_page((unsigned long) tmp);
2f77d107 LT	301	return retval;
1da177e4	302	}