path: root/mm/fadvise.c (plain)
blob: eb3269e590024c1708cf686692abf1de800cfbfc

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