[linux-2.6-block.git] / mm / fadvise.c

// SPDX-License-Identifier: GPL-2.0
/*
 * mm/fadvise.c
 *
 * Copyright (C) 2002, Linus Torvalds
 *
 * 11Jan2003	Andrew Morton
 *		Initial version.
 */

#include <linux/kernel.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
#include <linux/backing-dev.h>
#include <linux/pagevec.h>
#include <linux/fadvise.h>
#include <linux/writeback.h>
#include <linux/syscalls.h>
#include <linux/swap.h>

#include <asm/unistd.h>

/*
 * POSIX_FADV_WILLNEED could set PG_Referenced, and POSIX_FADV_NOREUSE could
 * deactivate the pages and clear PG_Referenced.
 */

int ksys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
{
	struct fd f = fdget(fd);
	struct inode *inode;
	struct address_space *mapping;
	struct backing_dev_info *bdi;
	loff_t endbyte;			/* inclusive */
	pgoff_t start_index;
	pgoff_t end_index;
	unsigned long nrpages;
	int ret = 0;

	if (!f.file)
		return -EBADF;

	inode = file_inode(f.file);
	if (S_ISFIFO(inode->i_mode)) {
		ret = -ESPIPE;
		goto out;
	}

	mapping = f.file->f_mapping;
	if (!mapping || len < 0) {
		ret = -EINVAL;
		goto out;
	}

	bdi = inode_to_bdi(mapping->host);

	if (IS_DAX(inode) || (bdi == &noop_backing_dev_info)) {
		switch (advice) {
		case POSIX_FADV_NORMAL:
		case POSIX_FADV_RANDOM:
		case POSIX_FADV_SEQUENTIAL:
		case POSIX_FADV_WILLNEED:
		case POSIX_FADV_NOREUSE:
		case POSIX_FADV_DONTNEED:
			/* no bad return value, but ignore advice */
			break;
		default:
			ret = -EINVAL;
		}
		goto out;
	}

	/* Careful about overflows. Len == 0 means "as much as possible" */
	endbyte = offset + len;
	if (!len || endbyte < len)
		endbyte = -1;
	else
		endbyte--;		/* inclusive */

	switch (advice) {
	case POSIX_FADV_NORMAL:
		f.file->f_ra.ra_pages = bdi->ra_pages;
		spin_lock(&f.file->f_lock);
		f.file->f_mode &= ~FMODE_RANDOM;
		spin_unlock(&f.file->f_lock);
		break;
	case POSIX_FADV_RANDOM:
		spin_lock(&f.file->f_lock);
		f.file->f_mode |= FMODE_RANDOM;
		spin_unlock(&f.file->f_lock);
		break;
	case POSIX_FADV_SEQUENTIAL:
		f.file->f_ra.ra_pages = bdi->ra_pages * 2;
		spin_lock(&f.file->f_lock);
		f.file->f_mode &= ~FMODE_RANDOM;
		spin_unlock(&f.file->f_lock);
		break;
	case POSIX_FADV_WILLNEED:
		/* First and last PARTIAL page! */
		start_index = offset >> PAGE_SHIFT;
		end_index = endbyte >> PAGE_SHIFT;

		/* Careful about overflow on the "+1" */
		nrpages = end_index - start_index + 1;
		if (!nrpages)
			nrpages = ~0UL;

		/*
		 * Ignore return value because fadvise() shall return
		 * success even if filesystem can't retrieve a hint,
		 */
		force_page_cache_readahead(mapping, f.file, start_index,
					   nrpages);
		break;
	case POSIX_FADV_NOREUSE:
		break;
	case POSIX_FADV_DONTNEED:
		if (!inode_write_congested(mapping->host))
			__filemap_fdatawrite_range(mapping, offset, endbyte,
						   WB_SYNC_NONE);

		/*
		 * First and last FULL page! Partial pages are deliberately
		 * preserved on the expectation that it is better to preserve
		 * needed memory than to discard unneeded memory.
		 */
		start_index = (offset+(PAGE_SIZE-1)) >> PAGE_SHIFT;
		end_index = (endbyte >> PAGE_SHIFT);
		/*
		 * The page at end_index will be inclusively discarded according
		 * by invalidate_mapping_pages(), so subtracting 1 from
		 * end_index means we will skip the last page.  But if endbyte
		 * is page aligned or is at the end of file, we should not skip
		 * that page - discarding the last page is safe enough.
		 */
		if ((endbyte & ~PAGE_MASK) != ~PAGE_MASK &&
				endbyte != inode->i_size - 1) {
			/* First page is tricky as 0 - 1 = -1, but pgoff_t
			 * is unsigned, so the end_index >= start_index
			 * check below would be true and we'll discard the whole
			 * file cache which is not what was asked.
			 */
			if (end_index == 0)
				break;

			end_index--;
		}

		if (end_index >= start_index) {
			unsigned long count;

			/*
			 * It's common to FADV_DONTNEED right after
			 * the read or write that instantiates the
			 * pages, in which case there will be some
			 * sitting on the local LRU cache. Try to
			 * avoid the expensive remote drain and the
			 * second cache tree walk below by flushing
			 * them out right away.
			 */
			lru_add_drain();

			count = invalidate_mapping_pages(mapping,
						start_index, end_index);

			/*
			 * If fewer pages were invalidated than expected then
			 * it is possible that some of the pages were on
			 * a per-cpu pagevec for a remote CPU. Drain all
			 * pagevecs and try again.
			 */
			if (count < (end_index - start_index + 1)) {
				lru_add_drain_all();
				invalidate_mapping_pages(mapping, start_index,
						end_index);
			}
		}
		break;
	default:
		ret = -EINVAL;
	}
out:
	fdput(f);
	return ret;
}

SYSCALL_DEFINE4(fadvise64_64, int, fd, loff_t, offset, loff_t, len, int, advice)
{
	return ksys_fadvise64_64(fd, offset, len, advice);
}

#ifdef __ARCH_WANT_SYS_FADVISE64

SYSCALL_DEFINE4(fadvise64, int, fd, loff_t, offset, size_t, len, int, advice)
{
	return ksys_fadvise64_64(fd, offset, len, advice);
}

#endif
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* mm/fadvise.c
	4	*
	5	* Copyright (C) 2002, Linus Torvalds
	6	*
e1f8e874	7	* 11Jan2003 Andrew Morton
1da177e4 LT	8	* Initial version.
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/file.h>
	13	#include <linux/fs.h>
	14	#include <linux/mm.h>
	15	#include <linux/pagemap.h>
	16	#include <linux/backing-dev.h>
	17	#include <linux/pagevec.h>
	18	#include <linux/fadvise.h>
ebcf28e1	19	#include <linux/writeback.h>
1da177e4	20	#include <linux/syscalls.h>
67d46b29	21	#include <linux/swap.h>
1da177e4 LT	22
	23	#include <asm/unistd.h>
	24
	25	/*
	26	* POSIX_FADV_WILLNEED could set PG_Referenced, and POSIX_FADV_NOREUSE could
	27	* deactivate the pages and clear PG_Referenced.
	28	*/
9d5b7c95 DB	29
9d5b7c95 DB	30	int ksys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
1da177e4	31	{
2903ff01	32	struct fd f = fdget(fd);
e748dcd0	33	struct inode *inode;
1da177e4 LT	34	struct address_space *mapping;
1da177e4 LT	35	struct backing_dev_info *bdi;
ebcf28e1	36	loff_t endbyte; /* inclusive */
1da177e4 LT	37	pgoff_t start_index;
	38	pgoff_t end_index;
	39	unsigned long nrpages;
	40	int ret = 0;
	41
2903ff01	42	if (!f.file)
1da177e4 LT	43	return -EBADF;
1da177e4 LT	44
e748dcd0 MW	45	inode = file_inode(f.file);
e748dcd0 MW	46	if (S_ISFIFO(inode->i_mode)) {
87ba81db VB	47	ret = -ESPIPE;
	48	goto out;
	49	}
	50
2903ff01	51	mapping = f.file->f_mapping;
1da177e4 LT	52	if (!mapping \|\| len < 0) {
	53	ret = -EINVAL;
	54	goto out;
	55	}
	56
3a77d214 SB	57	bdi = inode_to_bdi(mapping->host);
	58
	59	if (IS_DAX(inode) \|\| (bdi == &noop_backing_dev_info)) {
b5beb1ca MY	60	switch (advice) {
	61	case POSIX_FADV_NORMAL:
	62	case POSIX_FADV_RANDOM:
	63	case POSIX_FADV_SEQUENTIAL:
	64	case POSIX_FADV_WILLNEED:
	65	case POSIX_FADV_NOREUSE:
	66	case POSIX_FADV_DONTNEED:
	67	/* no bad return value, but ignore advice */
	68	break;
	69	default:
	70	ret = -EINVAL;
	71	}
fe77ba6f	72	goto out;
b5beb1ca	73	}
fe77ba6f	74
1da177e4 LT	75	/* Careful about overflows. Len == 0 means "as much as possible" */
	76	endbyte = offset + len;
	77	if (!len \|\| endbyte < len)
	78	endbyte = -1;
ebcf28e1 AM	79	else
ebcf28e1 AM	80	endbyte--; /* inclusive */
1da177e4	81
1da177e4 LT	82	switch (advice) {
1da177e4 LT	83	case POSIX_FADV_NORMAL:
2903ff01 AV	84	f.file->f_ra.ra_pages = bdi->ra_pages;
	85	spin_lock(&f.file->f_lock);
	86	f.file->f_mode &= ~FMODE_RANDOM;
	87	spin_unlock(&f.file->f_lock);
1da177e4 LT	88	break;
1da177e4 LT	89	case POSIX_FADV_RANDOM:
2903ff01 AV	90	spin_lock(&f.file->f_lock);
	91	f.file->f_mode \|= FMODE_RANDOM;
	92	spin_unlock(&f.file->f_lock);
1da177e4 LT	93	break;
1da177e4 LT	94	case POSIX_FADV_SEQUENTIAL:
2903ff01 AV	95	f.file->f_ra.ra_pages = bdi->ra_pages * 2;
	96	spin_lock(&f.file->f_lock);
	97	f.file->f_mode &= ~FMODE_RANDOM;
	98	spin_unlock(&f.file->f_lock);
1da177e4 LT	99	break;
1da177e4 LT	100	case POSIX_FADV_WILLNEED:
1da177e4	101	/* First and last PARTIAL page! */
09cbfeaf KS	102	start_index = offset >> PAGE_SHIFT;
09cbfeaf KS	103	end_index = endbyte >> PAGE_SHIFT;
1da177e4 LT	104
	105	/* Careful about overflow on the "+1" */
	106	nrpages = end_index - start_index + 1;
	107	if (!nrpages)
	108	nrpages = ~0UL;
3d3727cd KM	109
	110	/*
	111	* Ignore return value because fadvise() shall return
	112	* success even if filesystem can't retrieve a hint,
	113	*/
2903ff01	114	force_page_cache_readahead(mapping, f.file, start_index,
3d3727cd	115	nrpages);
1da177e4	116	break;
60c371bc AM	117	case POSIX_FADV_NOREUSE:
60c371bc AM	118	break;
1da177e4	119	case POSIX_FADV_DONTNEED:
703c2708	120	if (!inode_write_congested(mapping->host))
ad8a1b55 SB	121	__filemap_fdatawrite_range(mapping, offset, endbyte,
ad8a1b55 SB	122	WB_SYNC_NONE);
1da177e4	123
441c228f MG	124	/*
	125	* First and last FULL page! Partial pages are deliberately
	126	* preserved on the expectation that it is better to preserve
	127	* needed memory than to discard unneeded memory.
	128	*/
09cbfeaf KS	129	start_index = (offset+(PAGE_SIZE-1)) >> PAGE_SHIFT;
09cbfeaf KS	130	end_index = (endbyte >> PAGE_SHIFT);
a7ab400d	131	/*
	132	* The page at end_index will be inclusively discarded according
	133	* by invalidate_mapping_pages(), so subtracting 1 from
	134	* end_index means we will skip the last page. But if endbyte
	135	* is page aligned or is at the end of file, we should not skip
	136	* that page - discarding the last page is safe enough.
	137	*/
	138	if ((endbyte & ~PAGE_MASK) != ~PAGE_MASK &&
	139	endbyte != inode->i_size - 1) {
18aba41c OD	140	/* First page is tricky as 0 - 1 = -1, but pgoff_t
	141	* is unsigned, so the end_index >= start_index
	142	* check below would be true and we'll discard the whole
	143	* file cache which is not what was asked.
	144	*/
	145	if (end_index == 0)
	146	break;
	147
	148	end_index--;
	149	}
1da177e4	150
67d46b29	151	if (end_index >= start_index) {
4dd72b4a JW	152	unsigned long count;
	153
	154	/*
	155	* It's common to FADV_DONTNEED right after
	156	* the read or write that instantiates the
	157	* pages, in which case there will be some
	158	* sitting on the local LRU cache. Try to
	159	* avoid the expensive remote drain and the
	160	* second cache tree walk below by flushing
	161	* them out right away.
	162	*/
	163	lru_add_drain();
	164
	165	count = invalidate_mapping_pages(mapping,
67d46b29 MG	166	start_index, end_index);
	167
	168	/*
	169	* If fewer pages were invalidated than expected then
	170	* it is possible that some of the pages were on
	171	* a per-cpu pagevec for a remote CPU. Drain all
	172	* pagevecs and try again.
	173	*/
	174	if (count < (end_index - start_index + 1)) {
	175	lru_add_drain_all();
	176	invalidate_mapping_pages(mapping, start_index,
ebcf28e1	177	end_index);
67d46b29 MG	178	}
67d46b29 MG	179	}
ebcf28e1	180	break;
1da177e4 LT	181	default:
	182	ret = -EINVAL;
	183	}
	184	out:
2903ff01	185	fdput(f);
1da177e4 LT	186	return ret;
	187	}
	188
9d5b7c95 DB	189	SYSCALL_DEFINE4(fadvise64_64, int, fd, loff_t, offset, loff_t, len, int, advice)
	190	{
	191	return ksys_fadvise64_64(fd, offset, len, advice);
	192	}
	193
1da177e4 LT	194	#ifdef __ARCH_WANT_SYS_FADVISE64
1da177e4 LT	195
4a0fd5bf	196	SYSCALL_DEFINE4(fadvise64, int, fd, loff_t, offset, size_t, len, int, advice)
1da177e4	197	{
9d5b7c95	198	return ksys_fadvise64_64(fd, offset, len, advice);
1da177e4 LT	199	}
	200
	201	#endif