[mirror_ubuntu-jammy-kernel.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/pagewalk.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 <linux/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,
				   __always_unused int depth,
				   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;
}

static const struct mm_walk_ops mincore_walk_ops = {
	.pmd_entry		= mincore_pte_range,
	.pte_hole		= mincore_unmapped_range,
	.hugetlb_entry		= mincore_hugetlb,
};

/*
 * 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;

	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;
	}
	err = walk_page_range(vma->vm_mm, addr, end, &mincore_walk_ops, vec);
	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;

	start = untagged_addr(start);

	/* 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>
a520110e	13	#include <linux/pagewalk.h>
1da177e4 LT	14	#include <linux/mman.h>
1da177e4 LT	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>
ca5999fd	22	#include <linux/pgtable.h>
1da177e4	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,
b7a16c7a	115	__always_unused int depth,
30bac164 LT	116	struct mm_walk *walk)
	117	{
	118	walk->private += __mincore_unmapped_range(addr, end,
	119	walk->vma, walk->private);
1e25a271	120	return 0;
f4884010 JW	121	}
f4884010 JW	122
1e25a271 NH	123	static int mincore_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
1e25a271 NH	124	struct mm_walk *walk)
f4884010 JW	125	{
f4884010 JW	126	spinlock_t *ptl;
1e25a271	127	struct vm_area_struct *vma = walk->vma;
f4884010	128	pte_t *ptep;
1e25a271 NH	129	unsigned char *vec = walk->private;
	130	int nr = (end - addr) >> PAGE_SHIFT;
	131
b6ec57f4 KS	132	ptl = pmd_trans_huge_lock(pmd, vma);
b6ec57f4 KS	133	if (ptl) {
1e25a271 NH	134	memset(vec, 1, nr);
	135	spin_unlock(ptl);
	136	goto out;
	137	}
f4884010	138
1e25a271	139	if (pmd_trans_unstable(pmd)) {
30bac164	140	__mincore_unmapped_range(addr, end, vma, vec);
1e25a271 NH	141	goto out;
	142	}
	143
	144	ptep = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
	145	for (; addr != end; ptep++, addr += PAGE_SIZE) {
f4884010	146	pte_t pte = *ptep;
f4884010 JW	147
f4884010 JW	148	if (pte_none(pte))
30bac164 LT	149	__mincore_unmapped_range(addr, addr + PAGE_SIZE,
30bac164 LT	150	vma, vec);
f4884010	151	else if (pte_present(pte))
25ef0e50	152	*vec = 1;
0661a336	153	else { /* pte is a swap entry */
f4884010 JW	154	swp_entry_t entry = pte_to_swp_entry(pte);
f4884010 JW	155
30bac164 LT	156	if (non_swap_entry(entry)) {
	157	/*
	158	* migration or hwpoison entries are always
	159	* uptodate
	160	*/
	161	*vec = 1;
	162	} else {
	163	#ifdef CONFIG_SWAP
	164	*vec = mincore_page(swap_address_space(entry),
	165	swp_offset(entry));
	166	#else
	167	WARN_ON(1);
	168	*vec = 1;
	169	#endif
	170	}
f4884010	171	}
25ef0e50	172	vec++;
1e25a271	173	}
f4884010	174	pte_unmap_unlock(ptep - 1, ptl);
1e25a271 NH	175	out:
	176	walk->private += nr;
	177	cond_resched();
	178	return 0;
e48293fd JW	179	}
e48293fd JW	180
134fca90 JK	181	static inline bool can_do_mincore(struct vm_area_struct *vma)
	182	{
	183	if (vma_is_anonymous(vma))
	184	return true;
	185	if (!vma->vm_file)
	186	return false;
	187	/*
	188	* Reveal pagecache information only for non-anonymous mappings that
	189	* correspond to the files the calling process could (if tried) open
	190	* for writing; otherwise we'd be including shared non-exclusive
	191	* mappings, which opens a side channel.
	192	*/
	193	return inode_owner_or_capable(file_inode(vma->vm_file)) \|\|
	194	inode_permission(file_inode(vma->vm_file), MAY_WRITE) == 0;
	195	}
	196
7b86ac33 CH	197	static const struct mm_walk_ops mincore_walk_ops = {
	198	.pmd_entry = mincore_pte_range,
	199	.pte_hole = mincore_unmapped_range,
	200	.hugetlb_entry = mincore_hugetlb,
	201	};
	202
2f77d107 LT	203	/*
	204	* Do a chunk of "sys_mincore()". We've already checked
	205	* all the arguments, we hold the mmap semaphore: we should
	206	* just return the amount of info we're asked for.
	207	*/
6a60f1b3	208	static long do_mincore(unsigned long addr, unsigned long pages, unsigned char *vec)
1da177e4	209	{
6a60f1b3	210	struct vm_area_struct *vma;
25ef0e50	211	unsigned long end;
1e25a271	212	int err;
1da177e4	213
6a60f1b3	214	vma = find_vma(current->mm, addr);
4fb23e43 LT	215	if (!vma \|\| addr < vma->vm_start)
4fb23e43 LT	216	return -ENOMEM;
25ef0e50	217	end = min(vma->vm_end, addr + (pages << PAGE_SHIFT));
134fca90 JK	218	if (!can_do_mincore(vma)) {
	219	unsigned long pages = DIV_ROUND_UP(end - addr, PAGE_SIZE);
	220	memset(vec, 1, pages);
	221	return pages;
	222	}
7b86ac33	223	err = walk_page_range(vma->vm_mm, addr, end, &mincore_walk_ops, vec);
1e25a271 NH	224	if (err < 0)
1e25a271 NH	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
057d3389 AK	260	start = untagged_addr(start);
057d3389 AK	261
2f77d107	262	/* Check the start address: needs to be page-aligned.. */
09cbfeaf	263	if (start & ~PAGE_MASK)
2f77d107	264	return -EINVAL;
1da177e4	265
2f77d107	266	/* ..and we need to be passed a valid user-space range */
96d4f267	267	if (!access_ok((void __user *) start, len))
2f77d107	268	return -ENOMEM;
1da177e4	269
ea1754a0	270	/* This also avoids any overflows on PAGE_ALIGN */
2f77d107	271	pages = len >> PAGE_SHIFT;
e7bbdd07	272	pages += (offset_in_page(len)) != 0;
1da177e4	273
96d4f267	274	if (!access_ok(vec, pages))
2f77d107	275	return -EFAULT;
1da177e4	276
2f77d107 LT	277	tmp = (void *) __get_free_page(GFP_USER);
2f77d107 LT	278	if (!tmp)
4fb23e43	279	return -EAGAIN;
2f77d107 LT	280
	281	retval = 0;
	282	while (pages) {
	283	/*
	284	* Do at most PAGE_SIZE entries per iteration, due to
	285	* the temporary buffer size.
	286	*/
	287	down_read(&current->mm->mmap_sem);
6a60f1b3	288	retval = do_mincore(start, min(pages, PAGE_SIZE), tmp);
2f77d107 LT	289	up_read(&current->mm->mmap_sem);
	290
	291	if (retval <= 0)
	292	break;
	293	if (copy_to_user(vec, tmp, retval)) {
	294	retval = -EFAULT;
	295	break;
1da177e4	296	}
2f77d107 LT	297	pages -= retval;
	298	vec += retval;
	299	start += retval << PAGE_SHIFT;
	300	retval = 0;
1da177e4	301	}
2f77d107 LT	302	free_page((unsigned long) tmp);
2f77d107 LT	303	return retval;
1da177e4	304	}