mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 10:49:33 +00:00
![Amir Goldstein](/assets/img/avatar_default.png)
The implementation of readahead(2) syscall is identical to that of
fadvise64(POSIX_FADV_WILLNEED) with a few exceptions:
1. readahead(2) returns -EINVAL for !mapping->a_ops and fadvise64()
ignores the request and returns 0.
2. fadvise64() checks for integer overflow corner case
3. fadvise64() calls the optional filesystem fadvise() file operation
Unite the two implementations by calling vfs_fadvise() from readahead(2)
syscall. Check the !mapping->a_ops in readahead(2) syscall to preserve
documented syscall ABI behaviour.
Suggested-by: Miklos Szeredi <mszeredi@redhat.com>
Fixes: d1d04ef857
("ovl: stack file ops")
Signed-off-by: Amir Goldstein <amir73il@gmail.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
220 lines
5.3 KiB
C
220 lines
5.3 KiB
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.
|
|
*/
|
|
|
|
static int generic_fadvise(struct file *file, loff_t offset, loff_t len,
|
|
int advice)
|
|
{
|
|
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;
|
|
|
|
inode = file_inode(file);
|
|
if (S_ISFIFO(inode->i_mode))
|
|
return -ESPIPE;
|
|
|
|
mapping = file->f_mapping;
|
|
if (!mapping || len < 0)
|
|
return -EINVAL;
|
|
|
|
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:
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Careful about overflows. Len == 0 means "as much as possible". Use
|
|
* unsigned math because signed overflows are undefined and UBSan
|
|
* complains.
|
|
*/
|
|
endbyte = (u64)offset + (u64)len;
|
|
if (!len || endbyte < len)
|
|
endbyte = -1;
|
|
else
|
|
endbyte--; /* inclusive */
|
|
|
|
switch (advice) {
|
|
case POSIX_FADV_NORMAL:
|
|
file->f_ra.ra_pages = bdi->ra_pages;
|
|
spin_lock(&file->f_lock);
|
|
file->f_mode &= ~FMODE_RANDOM;
|
|
spin_unlock(&file->f_lock);
|
|
break;
|
|
case POSIX_FADV_RANDOM:
|
|
spin_lock(&file->f_lock);
|
|
file->f_mode |= FMODE_RANDOM;
|
|
spin_unlock(&file->f_lock);
|
|
break;
|
|
case POSIX_FADV_SEQUENTIAL:
|
|
file->f_ra.ra_pages = bdi->ra_pages * 2;
|
|
spin_lock(&file->f_lock);
|
|
file->f_mode &= ~FMODE_RANDOM;
|
|
spin_unlock(&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, 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:
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int vfs_fadvise(struct file *file, loff_t offset, loff_t len, int advice)
|
|
{
|
|
if (file->f_op->fadvise)
|
|
return file->f_op->fadvise(file, offset, len, advice);
|
|
|
|
return generic_fadvise(file, offset, len, advice);
|
|
}
|
|
EXPORT_SYMBOL(vfs_fadvise);
|
|
|
|
#ifdef CONFIG_ADVISE_SYSCALLS
|
|
|
|
int ksys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
|
|
{
|
|
struct fd f = fdget(fd);
|
|
int ret;
|
|
|
|
if (!f.file)
|
|
return -EBADF;
|
|
|
|
ret = vfs_fadvise(f.file, offset, len, advice);
|
|
|
|
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
|
|
#endif
|