2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* linux/fs/nfs/file.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992 Rick Sladkey
|
|
|
|
*
|
|
|
|
* Changes Copyright (C) 1994 by Florian La Roche
|
|
|
|
* - Do not copy data too often around in the kernel.
|
|
|
|
* - In nfs_file_read the return value of kmalloc wasn't checked.
|
|
|
|
* - Put in a better version of read look-ahead buffering. Original idea
|
|
|
|
* and implementation by Wai S Kok elekokws@ee.nus.sg.
|
|
|
|
*
|
|
|
|
* Expire cache on write to a file by Wai S Kok (Oct 1994).
|
|
|
|
*
|
|
|
|
* Total rewrite of read side for new NFS buffer cache.. Linus.
|
|
|
|
*
|
|
|
|
* nfs regular file handling functions
|
|
|
|
*/
|
|
|
|
|
2012-07-31 04:05:23 +08:00
|
|
|
#include <linux/module.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/nfs_fs.h>
|
|
|
|
#include <linux/nfs_mount.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/pagemap.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/gfp.h>
|
2010-07-31 03:31:54 +08:00
|
|
|
#include <linux/swap.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
#include "delegation.h"
|
2007-07-23 05:09:05 +08:00
|
|
|
#include "internal.h"
|
2006-03-21 02:44:14 +08:00
|
|
|
#include "iostat.h"
|
2009-04-03 23:42:44 +08:00
|
|
|
#include "fscache.h"
|
2014-09-10 23:23:30 +08:00
|
|
|
#include "pnfs.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-20 06:59:33 +08:00
|
|
|
#include "nfstrace.h"
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define NFSDBG_FACILITY NFSDBG_FILE
|
|
|
|
|
2009-09-28 02:29:37 +08:00
|
|
|
static const struct vm_operations_struct nfs_file_vm_ops;
|
2007-07-23 05:09:05 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Hack for future NFS swap support */
|
|
|
|
#ifndef IS_SWAPFILE
|
|
|
|
# define IS_SWAPFILE(inode) (0)
|
|
|
|
#endif
|
|
|
|
|
2012-07-17 04:39:15 +08:00
|
|
|
int nfs_check_flags(int flags)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_check_flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Open file
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
nfs_file_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: open file(%pD2)\n", filp);
|
2008-06-12 05:55:42 +08:00
|
|
|
|
2010-02-02 03:17:14 +08:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSOPEN);
|
2005-04-17 06:20:36 +08:00
|
|
|
res = nfs_check_flags(filp->f_flags);
|
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
|
2008-06-12 04:32:46 +08:00
|
|
|
res = nfs_open(inode, filp);
|
2005-04-17 06:20:36 +08:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2012-07-17 04:39:15 +08:00
|
|
|
int
|
2005-04-17 06:20:36 +08:00
|
|
|
nfs_file_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: release(%pD2)\n", filp);
|
2008-06-12 05:55:58 +08:00
|
|
|
|
2006-03-21 02:44:14 +08:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
|
2015-07-14 02:01:33 +08:00
|
|
|
nfs_file_clear_open_context(filp);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_release);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-06-13 23:14:01 +08:00
|
|
|
/**
|
|
|
|
* nfs_revalidate_size - Revalidate the file size
|
|
|
|
* @inode - pointer to inode struct
|
|
|
|
* @file - pointer to struct file
|
|
|
|
*
|
|
|
|
* Revalidates the file length. This is basically a wrapper around
|
|
|
|
* nfs_revalidate_inode() that takes into account the fact that we may
|
|
|
|
* have cached writes (in which case we don't care about the server's
|
|
|
|
* idea of what the file length is), or O_DIRECT (in which case we
|
|
|
|
* shouldn't trust the cache).
|
|
|
|
*/
|
|
|
|
static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
2010-04-17 04:42:46 +08:00
|
|
|
if (nfs_have_delegated_attributes(inode))
|
|
|
|
goto out_noreval;
|
|
|
|
|
2005-06-13 23:14:01 +08:00
|
|
|
if (filp->f_flags & O_DIRECT)
|
|
|
|
goto force_reval;
|
2010-04-17 04:42:46 +08:00
|
|
|
if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
|
|
|
|
goto force_reval;
|
|
|
|
if (nfs_attribute_timeout(inode))
|
|
|
|
goto force_reval;
|
|
|
|
out_noreval:
|
|
|
|
return 0;
|
2005-06-13 23:14:01 +08:00
|
|
|
force_reval:
|
|
|
|
return __nfs_revalidate_inode(server, inode);
|
|
|
|
}
|
|
|
|
|
2012-12-18 07:59:39 +08:00
|
|
|
loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
|
2005-06-13 23:14:01 +08:00
|
|
|
{
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: llseek file(%pD2, %lld, %d)\n",
|
|
|
|
filp, offset, whence);
|
2008-06-12 05:55:34 +08:00
|
|
|
|
2011-07-19 01:21:38 +08:00
|
|
|
/*
|
2012-12-18 07:59:39 +08:00
|
|
|
* whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
|
2011-07-19 01:21:38 +08:00
|
|
|
* the cached file length
|
|
|
|
*/
|
2012-12-18 07:59:39 +08:00
|
|
|
if (whence != SEEK_SET && whence != SEEK_CUR) {
|
2005-06-13 23:14:01 +08:00
|
|
|
struct inode *inode = filp->f_mapping->host;
|
2008-09-24 05:28:35 +08:00
|
|
|
|
2005-06-13 23:14:01 +08:00
|
|
|
int retval = nfs_revalidate_file_size(inode, filp);
|
|
|
|
if (retval < 0)
|
|
|
|
return (loff_t)retval;
|
2011-09-16 07:06:52 +08:00
|
|
|
}
|
2008-09-24 05:28:35 +08:00
|
|
|
|
2012-12-18 07:59:39 +08:00
|
|
|
return generic_file_llseek(filp, offset, whence);
|
2005-06-13 23:14:01 +08:00
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_llseek);
|
2005-06-13 23:14:01 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Flush all dirty pages, and check for write errors.
|
|
|
|
*/
|
2015-09-06 07:06:58 +08:00
|
|
|
static int
|
2006-06-23 17:05:12 +08:00
|
|
|
nfs_file_flush(struct file *file, fl_owner_t id)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-09-16 22:53:17 +08:00
|
|
|
struct inode *inode = file_inode(file);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: flush(%pD2)\n", file);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-02-02 03:17:14 +08:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((file->f_mode & FMODE_WRITE) == 0)
|
|
|
|
return 0;
|
2007-07-26 02:09:54 +08:00
|
|
|
|
2009-03-20 03:35:50 +08:00
|
|
|
/* Flush writes to the server and return any errors */
|
2010-08-01 02:29:06 +08:00
|
|
|
return vfs_fsync(file, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-07-17 04:39:15 +08:00
|
|
|
ssize_t
|
2014-04-03 08:14:12 +08:00
|
|
|
nfs_file_read(struct kiocb *iocb, struct iov_iter *to)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-09-16 22:53:17 +08:00
|
|
|
struct inode *inode = file_inode(iocb->ki_filp);
|
2005-04-17 06:20:36 +08:00
|
|
|
ssize_t result;
|
|
|
|
|
2015-04-10 01:52:01 +08:00
|
|
|
if (iocb->ki_flags & IOCB_DIRECT)
|
2014-10-14 23:00:44 +08:00
|
|
|
return nfs_file_direct_read(iocb, to, iocb->ki_pos);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-03-05 10:53:33 +08:00
|
|
|
dprintk("NFS: read(%pD2, %zu@%lu)\n",
|
2013-09-16 22:53:17 +08:00
|
|
|
iocb->ki_filp,
|
2014-04-03 08:14:12 +08:00
|
|
|
iov_iter_count(to), (unsigned long) iocb->ki_pos);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-03-03 12:32:08 +08:00
|
|
|
result = nfs_revalidate_mapping_protected(inode, iocb->ki_filp->f_mapping);
|
2010-02-02 03:17:23 +08:00
|
|
|
if (!result) {
|
2014-04-03 08:14:12 +08:00
|
|
|
result = generic_file_read_iter(iocb, to);
|
2010-02-02 03:17:23 +08:00
|
|
|
if (result > 0)
|
|
|
|
nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
return result;
|
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_read);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-07-17 04:39:15 +08:00
|
|
|
ssize_t
|
2007-06-01 17:51:43 +08:00
|
|
|
nfs_file_splice_read(struct file *filp, loff_t *ppos,
|
|
|
|
struct pipe_inode_info *pipe, size_t count,
|
|
|
|
unsigned int flags)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-09-16 22:53:17 +08:00
|
|
|
struct inode *inode = file_inode(filp);
|
2005-04-17 06:20:36 +08:00
|
|
|
ssize_t res;
|
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: splice_read(%pD2, %lu@%Lu)\n",
|
|
|
|
filp, (unsigned long) count, (unsigned long long) *ppos);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-03-03 12:32:08 +08:00
|
|
|
res = nfs_revalidate_mapping_protected(inode, filp->f_mapping);
|
2010-02-02 03:17:32 +08:00
|
|
|
if (!res) {
|
2007-06-01 17:51:43 +08:00
|
|
|
res = generic_file_splice_read(filp, ppos, pipe, count, flags);
|
2010-02-02 03:17:32 +08:00
|
|
|
if (res > 0)
|
|
|
|
nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
return res;
|
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_splice_read);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-07-17 04:39:15 +08:00
|
|
|
int
|
2005-04-17 06:20:36 +08:00
|
|
|
nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
|
|
|
|
{
|
2013-09-16 22:53:17 +08:00
|
|
|
struct inode *inode = file_inode(file);
|
2005-04-17 06:20:36 +08:00
|
|
|
int status;
|
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: mmap(%pD2)\n", file);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-03-12 02:37:54 +08:00
|
|
|
/* Note: generic_file_mmap() returns ENOSYS on nommu systems
|
|
|
|
* so we call that before revalidating the mapping
|
|
|
|
*/
|
|
|
|
status = generic_file_mmap(file, vma);
|
2007-07-23 05:09:05 +08:00
|
|
|
if (!status) {
|
|
|
|
vma->vm_ops = &nfs_file_vm_ops;
|
2009-03-12 02:37:54 +08:00
|
|
|
status = nfs_revalidate_mapping(inode, file->f_mapping);
|
2007-07-23 05:09:05 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_mmap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush any dirty pages for this process, and check for write errors.
|
|
|
|
* The return status from this call provides a reliable indication of
|
|
|
|
* whether any write errors occurred for this process.
|
2010-08-01 02:29:06 +08:00
|
|
|
*
|
|
|
|
* Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
|
|
|
|
* disk, but it retrieves and clears ctx->error after synching, despite
|
|
|
|
* the two being set at the same time in nfs_context_set_write_error().
|
|
|
|
* This is because the former is used to notify the _next_ call to
|
2011-03-31 09:57:33 +08:00
|
|
|
* nfs_file_write() that a write error occurred, and hence cause it to
|
2010-08-01 02:29:06 +08:00
|
|
|
* fall back to doing a synchronous write.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2012-07-17 04:39:15 +08:00
|
|
|
int
|
2012-06-21 03:53:42 +08:00
|
|
|
nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-08-11 05:44:32 +08:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(file);
|
2013-09-16 22:53:17 +08:00
|
|
|
struct inode *inode = file_inode(file);
|
2012-09-12 04:01:22 +08:00
|
|
|
int have_error, do_resend, status;
|
2010-08-01 02:29:06 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-21 02:44:14 +08:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
|
2012-09-12 04:01:22 +08:00
|
|
|
do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
|
2010-08-01 02:29:06 +08:00
|
|
|
have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
|
|
|
|
status = nfs_commit_inode(inode, FLUSH_SYNC);
|
|
|
|
have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
|
2012-09-12 04:01:22 +08:00
|
|
|
if (have_error) {
|
2010-08-01 02:29:06 +08:00
|
|
|
ret = xchg(&ctx->error, 0);
|
2012-09-12 04:01:22 +08:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (status < 0) {
|
2010-08-01 02:29:06 +08:00
|
|
|
ret = status;
|
2012-09-12 04:01:22 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
|
|
|
|
if (do_resend)
|
|
|
|
ret = -EAGAIN;
|
|
|
|
out:
|
2012-06-21 03:53:42 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
|
2012-06-21 03:53:42 +08:00
|
|
|
|
|
|
|
static int
|
|
|
|
nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
|
|
|
|
{
|
|
|
|
int ret;
|
2013-01-24 06:07:38 +08:00
|
|
|
struct inode *inode = file_inode(file);
|
2012-06-21 03:53:42 +08:00
|
|
|
|
2013-08-20 06:59:33 +08:00
|
|
|
trace_nfs_fsync_enter(inode);
|
|
|
|
|
2015-03-26 06:58:53 +08:00
|
|
|
nfs_inode_dio_wait(inode);
|
2012-09-12 04:01:22 +08:00
|
|
|
do {
|
|
|
|
ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
|
|
|
|
if (ret != 0)
|
|
|
|
break;
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
|
|
ret = nfs_file_fsync_commit(file, start, end, datasync);
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
2012-09-12 04:19:38 +08:00
|
|
|
/*
|
|
|
|
* If nfs_file_fsync_commit detected a server reboot, then
|
|
|
|
* resend all dirty pages that might have been covered by
|
|
|
|
* the NFS_CONTEXT_RESEND_WRITES flag
|
|
|
|
*/
|
|
|
|
start = 0;
|
|
|
|
end = LLONG_MAX;
|
2012-09-12 04:01:22 +08:00
|
|
|
} while (ret == -EAGAIN);
|
|
|
|
|
2013-08-20 06:59:33 +08:00
|
|
|
trace_nfs_fsync_exit(inode, ret);
|
2010-08-01 02:29:06 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
NFS: read-modify-write page updating
Hi.
I have a proposal for possibly resolving this issue.
I believe that this situation occurs due to the way that the
Linux NFS client handles writes which modify partial pages.
The Linux NFS client handles partial page modifications by
allocating a page from the page cache, copying the data from
the user level into the page, and then keeping track of the
offset and length of the modified portions of the page. The
page is not marked as up to date because there are portions
of the page which do not contain valid file contents.
When a read call comes in for a portion of the page, the
contents of the page must be read in the from the server.
However, since the page may already contain some modified
data, that modified data must be written to the server
before the file contents can be read back in the from server.
And, since the writing and reading can not be done atomically,
the data must be written and committed to stable storage on
the server for safety purposes. This means either a
FILE_SYNC WRITE or a UNSTABLE WRITE followed by a COMMIT.
This has been discussed at length previously.
This algorithm could be described as modify-write-read. It
is most efficient when the application only updates pages
and does not read them.
My proposed solution is to add a heuristic to decide whether
to do this modify-write-read algorithm or switch to a read-
modify-write algorithm when initially allocating the page
in the write system call path. The heuristic uses the modes
that the file was opened with, the offset in the page to
read from, and the size of the region to read.
If the file was opened for reading in addition to writing
and the page would not be filled completely with data from
the user level, then read in the old contents of the page
and mark it as Uptodate before copying in the new data. If
the page would be completely filled with data from the user
level, then there would be no reason to read in the old
contents because they would just be copied over.
This would optimize for applications which randomly access
and update portions of files. The linkage editor for the
C compiler is an example of such a thing.
I tested the attached patch by using rpmbuild to build the
current Fedora rawhide kernel. The kernel without the
patch generated about 269,500 WRITE requests. The modified
kernel containing the patch generated about 261,000 WRITE
requests. Thus, about 8,500 fewer WRITE requests were
generated. I suspect that many of these additional
WRITE requests were probably FILE_SYNC requests to WRITE
a single page, but I didn't test this theory.
The difference between this patch and the previous one was
to remove the unneeded PageDirty() test. I then retested to
ensure that the resulting system continued to behave as
desired.
Thanx...
ps
Signed-off-by: Peter Staubach <staubach@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-08-10 20:54:16 +08:00
|
|
|
/*
|
|
|
|
* Decide whether a read/modify/write cycle may be more efficient
|
|
|
|
* then a modify/write/read cycle when writing to a page in the
|
|
|
|
* page cache.
|
|
|
|
*
|
|
|
|
* The modify/write/read cycle may occur if a page is read before
|
|
|
|
* being completely filled by the writer. In this situation, the
|
|
|
|
* page must be completely written to stable storage on the server
|
|
|
|
* before it can be refilled by reading in the page from the server.
|
|
|
|
* This can lead to expensive, small, FILE_SYNC mode writes being
|
|
|
|
* done.
|
|
|
|
*
|
|
|
|
* It may be more efficient to read the page first if the file is
|
|
|
|
* open for reading in addition to writing, the page is not marked
|
|
|
|
* as Uptodate, it is not dirty or waiting to be committed,
|
|
|
|
* indicating that it was previously allocated and then modified,
|
|
|
|
* that there were valid bytes of data in that range of the file,
|
|
|
|
* and that the new data won't completely replace the old data in
|
|
|
|
* that range of the file.
|
|
|
|
*/
|
|
|
|
static int nfs_want_read_modify_write(struct file *file, struct page *page,
|
|
|
|
loff_t pos, unsigned len)
|
|
|
|
{
|
|
|
|
unsigned int pglen = nfs_page_length(page);
|
|
|
|
unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
|
|
|
|
unsigned int end = offset + len;
|
|
|
|
|
2014-09-10 23:23:30 +08:00
|
|
|
if (pnfs_ld_read_whole_page(file->f_mapping->host)) {
|
|
|
|
if (!PageUptodate(page))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
NFS: read-modify-write page updating
Hi.
I have a proposal for possibly resolving this issue.
I believe that this situation occurs due to the way that the
Linux NFS client handles writes which modify partial pages.
The Linux NFS client handles partial page modifications by
allocating a page from the page cache, copying the data from
the user level into the page, and then keeping track of the
offset and length of the modified portions of the page. The
page is not marked as up to date because there are portions
of the page which do not contain valid file contents.
When a read call comes in for a portion of the page, the
contents of the page must be read in the from the server.
However, since the page may already contain some modified
data, that modified data must be written to the server
before the file contents can be read back in the from server.
And, since the writing and reading can not be done atomically,
the data must be written and committed to stable storage on
the server for safety purposes. This means either a
FILE_SYNC WRITE or a UNSTABLE WRITE followed by a COMMIT.
This has been discussed at length previously.
This algorithm could be described as modify-write-read. It
is most efficient when the application only updates pages
and does not read them.
My proposed solution is to add a heuristic to decide whether
to do this modify-write-read algorithm or switch to a read-
modify-write algorithm when initially allocating the page
in the write system call path. The heuristic uses the modes
that the file was opened with, the offset in the page to
read from, and the size of the region to read.
If the file was opened for reading in addition to writing
and the page would not be filled completely with data from
the user level, then read in the old contents of the page
and mark it as Uptodate before copying in the new data. If
the page would be completely filled with data from the user
level, then there would be no reason to read in the old
contents because they would just be copied over.
This would optimize for applications which randomly access
and update portions of files. The linkage editor for the
C compiler is an example of such a thing.
I tested the attached patch by using rpmbuild to build the
current Fedora rawhide kernel. The kernel without the
patch generated about 269,500 WRITE requests. The modified
kernel containing the patch generated about 261,000 WRITE
requests. Thus, about 8,500 fewer WRITE requests were
generated. I suspect that many of these additional
WRITE requests were probably FILE_SYNC requests to WRITE
a single page, but I didn't test this theory.
The difference between this patch and the previous one was
to remove the unneeded PageDirty() test. I then retested to
ensure that the resulting system continued to behave as
desired.
Thanx...
ps
Signed-off-by: Peter Staubach <staubach@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-08-10 20:54:16 +08:00
|
|
|
if ((file->f_mode & FMODE_READ) && /* open for read? */
|
|
|
|
!PageUptodate(page) && /* Uptodate? */
|
|
|
|
!PagePrivate(page) && /* i/o request already? */
|
|
|
|
pglen && /* valid bytes of file? */
|
|
|
|
(end < pglen || offset)) /* replace all valid bytes? */
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2007-10-16 16:25:16 +08:00
|
|
|
* This does the "real" work of the write. We must allocate and lock the
|
|
|
|
* page to be sent back to the generic routine, which then copies the
|
|
|
|
* data from user space.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* If the writer ends up delaying the write, the writer needs to
|
|
|
|
* increment the page use counts until he is done with the page.
|
|
|
|
*/
|
2007-10-16 16:25:16 +08:00
|
|
|
static int nfs_write_begin(struct file *file, struct address_space *mapping,
|
|
|
|
loff_t pos, unsigned len, unsigned flags,
|
|
|
|
struct page **pagep, void **fsdata)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-10-16 16:25:16 +08:00
|
|
|
int ret;
|
NFS: read-modify-write page updating
Hi.
I have a proposal for possibly resolving this issue.
I believe that this situation occurs due to the way that the
Linux NFS client handles writes which modify partial pages.
The Linux NFS client handles partial page modifications by
allocating a page from the page cache, copying the data from
the user level into the page, and then keeping track of the
offset and length of the modified portions of the page. The
page is not marked as up to date because there are portions
of the page which do not contain valid file contents.
When a read call comes in for a portion of the page, the
contents of the page must be read in the from the server.
However, since the page may already contain some modified
data, that modified data must be written to the server
before the file contents can be read back in the from server.
And, since the writing and reading can not be done atomically,
the data must be written and committed to stable storage on
the server for safety purposes. This means either a
FILE_SYNC WRITE or a UNSTABLE WRITE followed by a COMMIT.
This has been discussed at length previously.
This algorithm could be described as modify-write-read. It
is most efficient when the application only updates pages
and does not read them.
My proposed solution is to add a heuristic to decide whether
to do this modify-write-read algorithm or switch to a read-
modify-write algorithm when initially allocating the page
in the write system call path. The heuristic uses the modes
that the file was opened with, the offset in the page to
read from, and the size of the region to read.
If the file was opened for reading in addition to writing
and the page would not be filled completely with data from
the user level, then read in the old contents of the page
and mark it as Uptodate before copying in the new data. If
the page would be completely filled with data from the user
level, then there would be no reason to read in the old
contents because they would just be copied over.
This would optimize for applications which randomly access
and update portions of files. The linkage editor for the
C compiler is an example of such a thing.
I tested the attached patch by using rpmbuild to build the
current Fedora rawhide kernel. The kernel without the
patch generated about 269,500 WRITE requests. The modified
kernel containing the patch generated about 261,000 WRITE
requests. Thus, about 8,500 fewer WRITE requests were
generated. I suspect that many of these additional
WRITE requests were probably FILE_SYNC requests to WRITE
a single page, but I didn't test this theory.
The difference between this patch and the previous one was
to remove the unneeded PageDirty() test. I then retested to
ensure that the resulting system continued to behave as
desired.
Thanx...
ps
Signed-off-by: Peter Staubach <staubach@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-08-10 20:54:16 +08:00
|
|
|
pgoff_t index = pos >> PAGE_CACHE_SHIFT;
|
2007-10-16 16:25:16 +08:00
|
|
|
struct page *page;
|
NFS: read-modify-write page updating
Hi.
I have a proposal for possibly resolving this issue.
I believe that this situation occurs due to the way that the
Linux NFS client handles writes which modify partial pages.
The Linux NFS client handles partial page modifications by
allocating a page from the page cache, copying the data from
the user level into the page, and then keeping track of the
offset and length of the modified portions of the page. The
page is not marked as up to date because there are portions
of the page which do not contain valid file contents.
When a read call comes in for a portion of the page, the
contents of the page must be read in the from the server.
However, since the page may already contain some modified
data, that modified data must be written to the server
before the file contents can be read back in the from server.
And, since the writing and reading can not be done atomically,
the data must be written and committed to stable storage on
the server for safety purposes. This means either a
FILE_SYNC WRITE or a UNSTABLE WRITE followed by a COMMIT.
This has been discussed at length previously.
This algorithm could be described as modify-write-read. It
is most efficient when the application only updates pages
and does not read them.
My proposed solution is to add a heuristic to decide whether
to do this modify-write-read algorithm or switch to a read-
modify-write algorithm when initially allocating the page
in the write system call path. The heuristic uses the modes
that the file was opened with, the offset in the page to
read from, and the size of the region to read.
If the file was opened for reading in addition to writing
and the page would not be filled completely with data from
the user level, then read in the old contents of the page
and mark it as Uptodate before copying in the new data. If
the page would be completely filled with data from the user
level, then there would be no reason to read in the old
contents because they would just be copied over.
This would optimize for applications which randomly access
and update portions of files. The linkage editor for the
C compiler is an example of such a thing.
I tested the attached patch by using rpmbuild to build the
current Fedora rawhide kernel. The kernel without the
patch generated about 269,500 WRITE requests. The modified
kernel containing the patch generated about 261,000 WRITE
requests. Thus, about 8,500 fewer WRITE requests were
generated. I suspect that many of these additional
WRITE requests were probably FILE_SYNC requests to WRITE
a single page, but I didn't test this theory.
The difference between this patch and the previous one was
to remove the unneeded PageDirty() test. I then retested to
ensure that the resulting system continued to behave as
desired.
Thanx...
ps
Signed-off-by: Peter Staubach <staubach@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-08-10 20:54:16 +08:00
|
|
|
int once_thru = 0;
|
2007-10-16 16:25:16 +08:00
|
|
|
|
2013-12-18 01:20:16 +08:00
|
|
|
dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
|
2013-09-16 22:53:17 +08:00
|
|
|
file, mapping->host->i_ino, len, (long long) pos);
|
2008-06-12 05:55:50 +08:00
|
|
|
|
NFS: read-modify-write page updating
Hi.
I have a proposal for possibly resolving this issue.
I believe that this situation occurs due to the way that the
Linux NFS client handles writes which modify partial pages.
The Linux NFS client handles partial page modifications by
allocating a page from the page cache, copying the data from
the user level into the page, and then keeping track of the
offset and length of the modified portions of the page. The
page is not marked as up to date because there are portions
of the page which do not contain valid file contents.
When a read call comes in for a portion of the page, the
contents of the page must be read in the from the server.
However, since the page may already contain some modified
data, that modified data must be written to the server
before the file contents can be read back in the from server.
And, since the writing and reading can not be done atomically,
the data must be written and committed to stable storage on
the server for safety purposes. This means either a
FILE_SYNC WRITE or a UNSTABLE WRITE followed by a COMMIT.
This has been discussed at length previously.
This algorithm could be described as modify-write-read. It
is most efficient when the application only updates pages
and does not read them.
My proposed solution is to add a heuristic to decide whether
to do this modify-write-read algorithm or switch to a read-
modify-write algorithm when initially allocating the page
in the write system call path. The heuristic uses the modes
that the file was opened with, the offset in the page to
read from, and the size of the region to read.
If the file was opened for reading in addition to writing
and the page would not be filled completely with data from
the user level, then read in the old contents of the page
and mark it as Uptodate before copying in the new data. If
the page would be completely filled with data from the user
level, then there would be no reason to read in the old
contents because they would just be copied over.
This would optimize for applications which randomly access
and update portions of files. The linkage editor for the
C compiler is an example of such a thing.
I tested the attached patch by using rpmbuild to build the
current Fedora rawhide kernel. The kernel without the
patch generated about 269,500 WRITE requests. The modified
kernel containing the patch generated about 261,000 WRITE
requests. Thus, about 8,500 fewer WRITE requests were
generated. I suspect that many of these additional
WRITE requests were probably FILE_SYNC requests to WRITE
a single page, but I didn't test this theory.
The difference between this patch and the previous one was
to remove the unneeded PageDirty() test. I then retested to
ensure that the resulting system continued to behave as
desired.
Thanx...
ps
Signed-off-by: Peter Staubach <staubach@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-08-10 20:54:16 +08:00
|
|
|
start:
|
2009-03-12 02:10:30 +08:00
|
|
|
/*
|
|
|
|
* Prevent starvation issues if someone is doing a consistency
|
|
|
|
* sync-to-disk
|
|
|
|
*/
|
sched: Remove proliferation of wait_on_bit() action functions
The current "wait_on_bit" interface requires an 'action'
function to be provided which does the actual waiting.
There are over 20 such functions, many of them identical.
Most cases can be satisfied by one of just two functions, one
which uses io_schedule() and one which just uses schedule().
So:
Rename wait_on_bit and wait_on_bit_lock to
wait_on_bit_action and wait_on_bit_lock_action
to make it explicit that they need an action function.
Introduce new wait_on_bit{,_lock} and wait_on_bit{,_lock}_io
which are *not* given an action function but implicitly use
a standard one.
The decision to error-out if a signal is pending is now made
based on the 'mode' argument rather than being encoded in the action
function.
All instances of the old wait_on_bit and wait_on_bit_lock which
can use the new version have been changed accordingly and their
action functions have been discarded.
wait_on_bit{_lock} does not return any specific error code in the
event of a signal so the caller must check for non-zero and
interpolate their own error code as appropriate.
The wait_on_bit() call in __fscache_wait_on_invalidate() was
ambiguous as it specified TASK_UNINTERRUPTIBLE but used
fscache_wait_bit_interruptible as an action function.
David Howells confirms this should be uniformly
"uninterruptible"
The main remaining user of wait_on_bit{,_lock}_action is NFS
which needs to use a freezer-aware schedule() call.
A comment in fs/gfs2/glock.c notes that having multiple 'action'
functions is useful as they display differently in the 'wchan'
field of 'ps'. (and /proc/$PID/wchan).
As the new bit_wait{,_io} functions are tagged "__sched", they
will not show up at all, but something higher in the stack. So
the distinction will still be visible, only with different
function names (gds2_glock_wait versus gfs2_glock_dq_wait in the
gfs2/glock.c case).
Since first version of this patch (against 3.15) two new action
functions appeared, on in NFS and one in CIFS. CIFS also now
uses an action function that makes the same freezer aware
schedule call as NFS.
Signed-off-by: NeilBrown <neilb@suse.de>
Acked-by: David Howells <dhowells@redhat.com> (fscache, keys)
Acked-by: Steven Whitehouse <swhiteho@redhat.com> (gfs2)
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Steve French <sfrench@samba.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Link: http://lkml.kernel.org/r/20140707051603.28027.72349.stgit@notabene.brown
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-07-07 13:16:04 +08:00
|
|
|
ret = wait_on_bit_action(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
|
|
|
|
nfs_wait_bit_killable, TASK_KILLABLE);
|
2009-03-12 02:10:30 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2015-02-28 11:54:19 +08:00
|
|
|
/*
|
|
|
|
* Wait for O_DIRECT to complete
|
|
|
|
*/
|
|
|
|
nfs_inode_dio_wait(mapping->host);
|
2009-03-12 02:10:30 +08:00
|
|
|
|
fs: symlink write_begin allocation context fix
With the write_begin/write_end aops, page_symlink was broken because it
could no longer pass a GFP_NOFS type mask into the point where the
allocations happened. They are done in write_begin, which would always
assume that the filesystem can be entered from reclaim. This bug could
cause filesystem deadlocks.
The funny thing with having a gfp_t mask there is that it doesn't really
allow the caller to arbitrarily tinker with the context in which it can be
called. It couldn't ever be GFP_ATOMIC, for example, because it needs to
take the page lock. The only thing any callers care about is __GFP_FS
anyway, so turn that into a single flag.
Add a new flag for write_begin, AOP_FLAG_NOFS. Filesystems can now act on
this flag in their write_begin function. Change __grab_cache_page to
accept a nofs argument as well, to honour that flag (while we're there,
change the name to grab_cache_page_write_begin which is more instructive
and does away with random leading underscores).
This is really a more flexible way to go in the end anyway -- if a
filesystem happens to want any extra allocations aside from the pagecache
ones in ints write_begin function, it may now use GFP_KERNEL (rather than
GFP_NOFS) for common case allocations (eg. ocfs2_alloc_write_ctxt, for a
random example).
[kosaki.motohiro@jp.fujitsu.com: fix ubifs]
[kosaki.motohiro@jp.fujitsu.com: fix fuse]
Signed-off-by: Nick Piggin <npiggin@suse.de>
Reviewed-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: <stable@kernel.org> [2.6.28.x]
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
[ Cleaned up the calling convention: just pass in the AOP flags
untouched to the grab_cache_page_write_begin() function. That
just simplifies everybody, and may even allow future expansion of the
logic. - Linus ]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-01-05 04:00:53 +08:00
|
|
|
page = grab_cache_page_write_begin(mapping, index, flags);
|
2007-10-16 16:25:16 +08:00
|
|
|
if (!page)
|
|
|
|
return -ENOMEM;
|
|
|
|
*pagep = page;
|
|
|
|
|
|
|
|
ret = nfs_flush_incompatible(file, page);
|
|
|
|
if (ret) {
|
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
NFS: read-modify-write page updating
Hi.
I have a proposal for possibly resolving this issue.
I believe that this situation occurs due to the way that the
Linux NFS client handles writes which modify partial pages.
The Linux NFS client handles partial page modifications by
allocating a page from the page cache, copying the data from
the user level into the page, and then keeping track of the
offset and length of the modified portions of the page. The
page is not marked as up to date because there are portions
of the page which do not contain valid file contents.
When a read call comes in for a portion of the page, the
contents of the page must be read in the from the server.
However, since the page may already contain some modified
data, that modified data must be written to the server
before the file contents can be read back in the from server.
And, since the writing and reading can not be done atomically,
the data must be written and committed to stable storage on
the server for safety purposes. This means either a
FILE_SYNC WRITE or a UNSTABLE WRITE followed by a COMMIT.
This has been discussed at length previously.
This algorithm could be described as modify-write-read. It
is most efficient when the application only updates pages
and does not read them.
My proposed solution is to add a heuristic to decide whether
to do this modify-write-read algorithm or switch to a read-
modify-write algorithm when initially allocating the page
in the write system call path. The heuristic uses the modes
that the file was opened with, the offset in the page to
read from, and the size of the region to read.
If the file was opened for reading in addition to writing
and the page would not be filled completely with data from
the user level, then read in the old contents of the page
and mark it as Uptodate before copying in the new data. If
the page would be completely filled with data from the user
level, then there would be no reason to read in the old
contents because they would just be copied over.
This would optimize for applications which randomly access
and update portions of files. The linkage editor for the
C compiler is an example of such a thing.
I tested the attached patch by using rpmbuild to build the
current Fedora rawhide kernel. The kernel without the
patch generated about 269,500 WRITE requests. The modified
kernel containing the patch generated about 261,000 WRITE
requests. Thus, about 8,500 fewer WRITE requests were
generated. I suspect that many of these additional
WRITE requests were probably FILE_SYNC requests to WRITE
a single page, but I didn't test this theory.
The difference between this patch and the previous one was
to remove the unneeded PageDirty() test. I then retested to
ensure that the resulting system continued to behave as
desired.
Thanx...
ps
Signed-off-by: Peter Staubach <staubach@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2009-08-10 20:54:16 +08:00
|
|
|
} else if (!once_thru &&
|
|
|
|
nfs_want_read_modify_write(file, page, pos, len)) {
|
|
|
|
once_thru = 1;
|
|
|
|
ret = nfs_readpage(file, page);
|
|
|
|
page_cache_release(page);
|
|
|
|
if (!ret)
|
|
|
|
goto start;
|
2007-10-16 16:25:16 +08:00
|
|
|
}
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-10-16 16:25:16 +08:00
|
|
|
static int nfs_write_end(struct file *file, struct address_space *mapping,
|
|
|
|
loff_t pos, unsigned len, unsigned copied,
|
|
|
|
struct page *page, void *fsdata)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-10-16 16:25:16 +08:00
|
|
|
unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
|
2013-08-14 23:59:16 +08:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(file);
|
2007-10-16 16:25:16 +08:00
|
|
|
int status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-12-18 01:20:16 +08:00
|
|
|
dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
|
2013-09-16 22:53:17 +08:00
|
|
|
file, mapping->host->i_ino, len, (long long) pos);
|
2008-06-12 05:55:50 +08:00
|
|
|
|
2008-06-11 06:31:00 +08:00
|
|
|
/*
|
|
|
|
* Zero any uninitialised parts of the page, and then mark the page
|
|
|
|
* as up to date if it turns out that we're extending the file.
|
|
|
|
*/
|
|
|
|
if (!PageUptodate(page)) {
|
|
|
|
unsigned pglen = nfs_page_length(page);
|
|
|
|
unsigned end = offset + len;
|
|
|
|
|
|
|
|
if (pglen == 0) {
|
|
|
|
zero_user_segments(page, 0, offset,
|
|
|
|
end, PAGE_CACHE_SIZE);
|
|
|
|
SetPageUptodate(page);
|
|
|
|
} else if (end >= pglen) {
|
|
|
|
zero_user_segment(page, end, PAGE_CACHE_SIZE);
|
|
|
|
if (offset == 0)
|
|
|
|
SetPageUptodate(page);
|
|
|
|
} else
|
|
|
|
zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
|
|
|
|
}
|
|
|
|
|
2007-10-16 16:25:16 +08:00
|
|
|
status = nfs_updatepage(file, page, offset, copied);
|
|
|
|
|
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
|
2007-12-21 03:55:04 +08:00
|
|
|
if (status < 0)
|
|
|
|
return status;
|
2012-05-25 01:13:24 +08:00
|
|
|
NFS_I(mapping->host)->write_io += copied;
|
2013-08-14 23:59:16 +08:00
|
|
|
|
|
|
|
if (nfs_ctx_key_to_expire(ctx)) {
|
|
|
|
status = nfs_wb_all(mapping->host);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2007-12-21 03:55:04 +08:00
|
|
|
return copied;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-04-03 23:42:41 +08:00
|
|
|
/*
|
|
|
|
* Partially or wholly invalidate a page
|
|
|
|
* - Release the private state associated with a page if undergoing complete
|
|
|
|
* page invalidation
|
2009-04-03 23:42:44 +08:00
|
|
|
* - Called if either PG_private or PG_fscache is set on the page
|
2009-04-03 23:42:41 +08:00
|
|
|
* - Caller holds page lock
|
|
|
|
*/
|
2013-05-22 11:17:23 +08:00
|
|
|
static void nfs_invalidate_page(struct page *page, unsigned int offset,
|
|
|
|
unsigned int length)
|
2006-03-21 02:44:04 +08:00
|
|
|
{
|
2013-05-22 11:17:23 +08:00
|
|
|
dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %u, %u)\n",
|
|
|
|
page, offset, length);
|
2008-06-12 05:55:50 +08:00
|
|
|
|
2013-05-22 11:17:23 +08:00
|
|
|
if (offset != 0 || length < PAGE_CACHE_SIZE)
|
2006-10-10 04:18:38 +08:00
|
|
|
return;
|
2006-05-31 13:13:38 +08:00
|
|
|
/* Cancel any unstarted writes on this page */
|
2012-08-01 07:45:06 +08:00
|
|
|
nfs_wb_page_cancel(page_file_mapping(page)->host, page);
|
2009-04-03 23:42:44 +08:00
|
|
|
|
|
|
|
nfs_fscache_invalidate_page(page, page->mapping->host);
|
2006-03-21 02:44:04 +08:00
|
|
|
}
|
|
|
|
|
2009-04-03 23:42:41 +08:00
|
|
|
/*
|
|
|
|
* Attempt to release the private state associated with a page
|
2009-04-03 23:42:44 +08:00
|
|
|
* - Called if either PG_private or PG_fscache is set on the page
|
2009-04-03 23:42:41 +08:00
|
|
|
* - Caller holds page lock
|
|
|
|
* - Return true (may release page) or false (may not)
|
|
|
|
*/
|
2006-03-21 02:44:04 +08:00
|
|
|
static int nfs_release_page(struct page *page, gfp_t gfp)
|
|
|
|
{
|
2010-07-31 03:31:54 +08:00
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
|
2008-06-12 05:55:50 +08:00
|
|
|
dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
|
|
|
|
|
2014-09-24 09:28:32 +08:00
|
|
|
/* Always try to initiate a 'commit' if relevant, but only
|
2015-11-07 08:28:21 +08:00
|
|
|
* wait for it if the caller allows blocking. Even then,
|
|
|
|
* only wait 1 second and only if the 'bdi' is not congested.
|
2014-09-24 09:28:32 +08:00
|
|
|
* Waiting indefinitely can cause deadlocks when the NFS
|
2014-09-24 09:28:32 +08:00
|
|
|
* server is on this machine, when a new TCP connection is
|
|
|
|
* needed and in other rare cases. There is no particular
|
|
|
|
* need to wait extensively here. A short wait has the
|
|
|
|
* benefit that someone else can worry about the freezer.
|
2012-07-24 01:58:51 +08:00
|
|
|
*/
|
2014-09-24 09:28:32 +08:00
|
|
|
if (mapping) {
|
|
|
|
struct nfs_server *nfss = NFS_SERVER(mapping->host);
|
|
|
|
nfs_commit_inode(mapping->host, 0);
|
2015-11-07 08:28:21 +08:00
|
|
|
if (gfpflags_allow_blocking(gfp) &&
|
2014-09-24 09:28:32 +08:00
|
|
|
!bdi_write_congested(&nfss->backing_dev_info)) {
|
2014-09-24 09:28:32 +08:00
|
|
|
wait_on_page_bit_killable_timeout(page, PG_private,
|
|
|
|
HZ);
|
2014-09-24 09:28:32 +08:00
|
|
|
if (PagePrivate(page))
|
|
|
|
set_bdi_congested(&nfss->backing_dev_info,
|
|
|
|
BLK_RW_ASYNC);
|
2014-09-24 09:28:32 +08:00
|
|
|
}
|
2010-07-31 03:31:54 +08:00
|
|
|
}
|
2007-01-11 15:15:39 +08:00
|
|
|
/* If PagePrivate() is set, then the page is not freeable */
|
2009-04-03 23:42:44 +08:00
|
|
|
if (PagePrivate(page))
|
|
|
|
return 0;
|
|
|
|
return nfs_fscache_release_page(page, gfp);
|
2007-01-11 15:15:39 +08:00
|
|
|
}
|
|
|
|
|
2013-07-04 06:02:06 +08:00
|
|
|
static void nfs_check_dirty_writeback(struct page *page,
|
|
|
|
bool *dirty, bool *writeback)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi;
|
|
|
|
struct address_space *mapping = page_file_mapping(page);
|
|
|
|
|
|
|
|
if (!mapping || PageSwapCache(page))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if an unstable page is currently being committed and
|
|
|
|
* if so, have the VM treat it as if the page is under writeback
|
|
|
|
* so it will not block due to pages that will shortly be freeable.
|
|
|
|
*/
|
|
|
|
nfsi = NFS_I(mapping->host);
|
2015-09-30 08:34:05 +08:00
|
|
|
if (atomic_read(&nfsi->commit_info.rpcs_out)) {
|
2013-07-04 06:02:06 +08:00
|
|
|
*writeback = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If PagePrivate() is set, then the page is not freeable and as the
|
|
|
|
* inode is not being committed, it's not going to be cleaned in the
|
|
|
|
* near future so treat it as dirty
|
|
|
|
*/
|
|
|
|
if (PagePrivate(page))
|
|
|
|
*dirty = true;
|
|
|
|
}
|
|
|
|
|
2009-04-03 23:42:41 +08:00
|
|
|
/*
|
|
|
|
* Attempt to clear the private state associated with a page when an error
|
|
|
|
* occurs that requires the cached contents of an inode to be written back or
|
|
|
|
* destroyed
|
2009-04-03 23:42:44 +08:00
|
|
|
* - Called if either PG_private or fscache is set on the page
|
2009-04-03 23:42:41 +08:00
|
|
|
* - Caller holds page lock
|
|
|
|
* - Return 0 if successful, -error otherwise
|
|
|
|
*/
|
2007-01-11 15:15:39 +08:00
|
|
|
static int nfs_launder_page(struct page *page)
|
|
|
|
{
|
2012-08-01 07:45:06 +08:00
|
|
|
struct inode *inode = page_file_mapping(page)->host;
|
2009-04-03 23:42:44 +08:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2008-06-12 05:55:50 +08:00
|
|
|
|
|
|
|
dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
|
|
|
|
inode->i_ino, (long long)page_offset(page));
|
|
|
|
|
2009-04-03 23:42:44 +08:00
|
|
|
nfs_fscache_wait_on_page_write(nfsi, page);
|
2008-06-12 05:55:50 +08:00
|
|
|
return nfs_wb_page(inode, page);
|
2006-03-21 02:44:04 +08:00
|
|
|
}
|
|
|
|
|
2012-08-01 07:45:12 +08:00
|
|
|
static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
|
|
|
|
sector_t *span)
|
|
|
|
{
|
2014-09-10 21:03:55 +08:00
|
|
|
struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
|
|
|
|
|
2012-08-01 07:45:12 +08:00
|
|
|
*span = sis->pages;
|
2014-09-10 21:03:55 +08:00
|
|
|
|
2015-06-04 04:14:25 +08:00
|
|
|
return rpc_clnt_swap_activate(clnt);
|
2012-08-01 07:45:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void nfs_swap_deactivate(struct file *file)
|
|
|
|
{
|
2014-09-10 21:03:55 +08:00
|
|
|
struct rpc_clnt *clnt = NFS_CLIENT(file->f_mapping->host);
|
|
|
|
|
2015-06-04 04:14:25 +08:00
|
|
|
rpc_clnt_swap_deactivate(clnt);
|
2012-08-01 07:45:12 +08:00
|
|
|
}
|
|
|
|
|
2006-06-28 19:26:44 +08:00
|
|
|
const struct address_space_operations nfs_file_aops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.readpage = nfs_readpage,
|
|
|
|
.readpages = nfs_readpages,
|
2007-07-23 05:09:05 +08:00
|
|
|
.set_page_dirty = __set_page_dirty_nobuffers,
|
2005-04-17 06:20:36 +08:00
|
|
|
.writepage = nfs_writepage,
|
|
|
|
.writepages = nfs_writepages,
|
2007-10-16 16:25:16 +08:00
|
|
|
.write_begin = nfs_write_begin,
|
|
|
|
.write_end = nfs_write_end,
|
2006-03-21 02:44:04 +08:00
|
|
|
.invalidatepage = nfs_invalidate_page,
|
|
|
|
.releasepage = nfs_release_page,
|
2005-04-17 06:20:36 +08:00
|
|
|
.direct_IO = nfs_direct_IO,
|
2009-08-10 20:54:13 +08:00
|
|
|
.migratepage = nfs_migrate_page,
|
2007-01-11 15:15:39 +08:00
|
|
|
.launder_page = nfs_launder_page,
|
2013-07-04 06:02:06 +08:00
|
|
|
.is_dirty_writeback = nfs_check_dirty_writeback,
|
2009-09-16 17:50:17 +08:00
|
|
|
.error_remove_page = generic_error_remove_page,
|
2012-08-01 07:45:12 +08:00
|
|
|
.swap_activate = nfs_swap_activate,
|
|
|
|
.swap_deactivate = nfs_swap_deactivate,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2009-04-03 23:42:41 +08:00
|
|
|
/*
|
|
|
|
* Notification that a PTE pointing to an NFS page is about to be made
|
|
|
|
* writable, implying that someone is about to modify the page through a
|
|
|
|
* shared-writable mapping
|
|
|
|
*/
|
2009-04-01 06:23:21 +08:00
|
|
|
static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
|
2007-07-23 05:09:05 +08:00
|
|
|
{
|
2009-04-01 06:23:21 +08:00
|
|
|
struct page *page = vmf->page;
|
2007-07-23 05:09:05 +08:00
|
|
|
struct file *filp = vma->vm_file;
|
2013-09-16 22:53:17 +08:00
|
|
|
struct inode *inode = file_inode(filp);
|
2007-07-23 05:09:05 +08:00
|
|
|
unsigned pagelen;
|
2010-10-05 05:59:08 +08:00
|
|
|
int ret = VM_FAULT_NOPAGE;
|
2007-10-16 16:25:16 +08:00
|
|
|
struct address_space *mapping;
|
2007-07-23 05:09:05 +08:00
|
|
|
|
2013-12-18 01:20:16 +08:00
|
|
|
dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
|
2013-09-16 22:53:17 +08:00
|
|
|
filp, filp->f_mapping->host->i_ino,
|
2008-06-12 05:55:50 +08:00
|
|
|
(long long)page_offset(page));
|
|
|
|
|
2009-04-03 23:42:44 +08:00
|
|
|
/* make sure the cache has finished storing the page */
|
2013-09-16 22:53:17 +08:00
|
|
|
nfs_fscache_wait_on_page_write(NFS_I(inode), page);
|
2009-04-03 23:42:44 +08:00
|
|
|
|
2015-03-03 13:06:35 +08:00
|
|
|
wait_on_bit_action(&NFS_I(inode)->flags, NFS_INO_INVALIDATING,
|
|
|
|
nfs_wait_bit_killable, TASK_KILLABLE);
|
|
|
|
|
2007-07-23 05:09:05 +08:00
|
|
|
lock_page(page);
|
2012-08-01 07:45:06 +08:00
|
|
|
mapping = page_file_mapping(page);
|
2013-09-16 22:53:17 +08:00
|
|
|
if (mapping != inode->i_mapping)
|
2008-01-23 06:13:06 +08:00
|
|
|
goto out_unlock;
|
|
|
|
|
2012-01-18 11:04:26 +08:00
|
|
|
wait_on_page_writeback(page);
|
|
|
|
|
2007-07-23 05:09:05 +08:00
|
|
|
pagelen = nfs_page_length(page);
|
2008-01-23 06:13:06 +08:00
|
|
|
if (pagelen == 0)
|
|
|
|
goto out_unlock;
|
2007-10-16 16:25:16 +08:00
|
|
|
|
2010-10-05 05:59:08 +08:00
|
|
|
ret = VM_FAULT_LOCKED;
|
|
|
|
if (nfs_flush_incompatible(filp, page) == 0 &&
|
|
|
|
nfs_updatepage(filp, page, 0, pagelen) == 0)
|
|
|
|
goto out;
|
2008-01-23 06:13:06 +08:00
|
|
|
|
2010-10-05 05:59:08 +08:00
|
|
|
ret = VM_FAULT_SIGBUS;
|
2008-01-23 06:13:06 +08:00
|
|
|
out_unlock:
|
|
|
|
unlock_page(page);
|
2010-10-05 05:59:08 +08:00
|
|
|
out:
|
|
|
|
return ret;
|
2007-07-23 05:09:05 +08:00
|
|
|
}
|
|
|
|
|
2009-09-28 02:29:37 +08:00
|
|
|
static const struct vm_operations_struct nfs_file_vm_ops = {
|
2007-07-23 05:09:05 +08:00
|
|
|
.fault = filemap_fault,
|
2014-04-08 06:37:19 +08:00
|
|
|
.map_pages = filemap_map_pages,
|
2007-07-23 05:09:05 +08:00
|
|
|
.page_mkwrite = nfs_vm_page_mkwrite,
|
|
|
|
};
|
|
|
|
|
2015-08-18 05:55:18 +08:00
|
|
|
static int nfs_need_check_write(struct file *filp, struct inode *inode)
|
2007-07-26 02:09:54 +08:00
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx;
|
|
|
|
|
2007-08-11 05:44:32 +08:00
|
|
|
ctx = nfs_file_open_context(filp);
|
2013-08-14 23:59:16 +08:00
|
|
|
if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags) ||
|
|
|
|
nfs_ctx_key_to_expire(ctx))
|
2007-07-26 02:09:54 +08:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-04 02:07:25 +08:00
|
|
|
ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2013-09-16 22:53:17 +08:00
|
|
|
struct file *file = iocb->ki_filp;
|
|
|
|
struct inode *inode = file_inode(file);
|
2010-02-02 03:17:41 +08:00
|
|
|
unsigned long written = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
ssize_t result;
|
2014-04-04 02:07:25 +08:00
|
|
|
size_t count = iov_iter_count(from);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
result = nfs_key_timeout_notify(file, inode);
|
2013-08-14 23:59:16 +08:00
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
2015-04-10 02:11:08 +08:00
|
|
|
if (iocb->ki_flags & IOCB_DIRECT) {
|
|
|
|
result = generic_write_checks(iocb, from);
|
|
|
|
if (result <= 0)
|
|
|
|
return result;
|
|
|
|
return nfs_file_direct_write(iocb, from);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-03-05 10:53:33 +08:00
|
|
|
dprintk("NFS: write(%pD2, %zu@%Ld)\n",
|
2015-04-10 02:11:08 +08:00
|
|
|
file, count, (long long) iocb->ki_pos);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
result = -EBUSY;
|
|
|
|
if (IS_SWAPFILE(inode))
|
|
|
|
goto out_swapfile;
|
2005-06-23 01:16:30 +08:00
|
|
|
/*
|
|
|
|
* O_APPEND implies that we must revalidate the file length.
|
|
|
|
*/
|
2015-04-10 01:52:01 +08:00
|
|
|
if (iocb->ki_flags & IOCB_APPEND) {
|
2013-09-16 22:53:17 +08:00
|
|
|
result = nfs_revalidate_file_size(inode, file);
|
2005-06-23 01:16:30 +08:00
|
|
|
if (result)
|
|
|
|
goto out;
|
2005-06-23 01:16:30 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
result = count;
|
|
|
|
if (!count)
|
|
|
|
goto out;
|
|
|
|
|
2014-04-04 02:07:25 +08:00
|
|
|
result = generic_file_write_iter(iocb, from);
|
2010-02-02 03:17:41 +08:00
|
|
|
if (result > 0)
|
|
|
|
written = result;
|
|
|
|
|
2015-08-18 05:55:18 +08:00
|
|
|
/* Return error values */
|
|
|
|
if (result >= 0 && nfs_need_check_write(file, inode)) {
|
2013-09-16 22:53:17 +08:00
|
|
|
int err = vfs_fsync(file, 0);
|
2006-12-05 13:35:40 +08:00
|
|
|
if (err < 0)
|
|
|
|
result = err;
|
|
|
|
}
|
2010-02-02 03:17:41 +08:00
|
|
|
if (result > 0)
|
|
|
|
nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
|
2005-04-17 06:20:36 +08:00
|
|
|
out:
|
|
|
|
return result;
|
|
|
|
|
|
|
|
out_swapfile:
|
|
|
|
printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_write);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-09-23 20:55:58 +08:00
|
|
|
static int
|
|
|
|
do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct inode *inode = filp->f_mapping->host;
|
|
|
|
int status = 0;
|
2010-11-29 05:04:05 +08:00
|
|
|
unsigned int saved_type = fl->fl_type;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-10-19 05:20:16 +08:00
|
|
|
/* Try local locking first */
|
2007-05-12 04:09:32 +08:00
|
|
|
posix_test_lock(filp, fl);
|
|
|
|
if (fl->fl_type != F_UNLCK) {
|
|
|
|
/* found a conflict */
|
2005-10-19 05:20:16 +08:00
|
|
|
goto out;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2010-11-29 05:04:05 +08:00
|
|
|
fl->fl_type = saved_type;
|
2005-10-19 05:20:16 +08:00
|
|
|
|
2012-06-21 03:53:43 +08:00
|
|
|
if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
|
2005-10-19 05:20:16 +08:00
|
|
|
goto out_noconflict;
|
|
|
|
|
2010-09-23 20:55:58 +08:00
|
|
|
if (is_local)
|
2005-10-19 05:20:16 +08:00
|
|
|
goto out_noconflict;
|
|
|
|
|
|
|
|
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
|
|
|
|
out:
|
2005-04-17 06:20:36 +08:00
|
|
|
return status;
|
2005-10-19 05:20:16 +08:00
|
|
|
out_noconflict:
|
|
|
|
fl->fl_type = F_UNLCK;
|
|
|
|
goto out;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int do_vfs_lock(struct file *file, struct file_lock *fl)
|
|
|
|
{
|
2015-10-23 01:38:14 +08:00
|
|
|
return locks_lock_file_wait(file, fl);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-09-23 20:55:58 +08:00
|
|
|
static int
|
|
|
|
do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct inode *inode = filp->f_mapping->host;
|
2013-04-09 09:49:53 +08:00
|
|
|
struct nfs_lock_context *l_ctx;
|
2005-04-17 06:20:36 +08:00
|
|
|
int status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush all pending writes before doing anything
|
|
|
|
* with locks..
|
|
|
|
*/
|
2015-03-27 03:55:49 +08:00
|
|
|
vfs_fsync(filp, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-04-09 09:49:53 +08:00
|
|
|
l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
|
|
|
|
if (!IS_ERR(l_ctx)) {
|
|
|
|
status = nfs_iocounter_wait(&l_ctx->io_count);
|
|
|
|
nfs_put_lock_context(l_ctx);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* NOTE: special case
|
|
|
|
* If we're signalled while cleaning up locks on process exit, we
|
|
|
|
* still need to complete the unlock.
|
|
|
|
*/
|
2010-09-23 20:55:58 +08:00
|
|
|
/*
|
|
|
|
* Use local locking if mounted with "-onolock" or with appropriate
|
|
|
|
* "-olocal_lock="
|
|
|
|
*/
|
|
|
|
if (!is_local)
|
2005-04-17 06:20:36 +08:00
|
|
|
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
|
|
|
|
else
|
|
|
|
status = do_vfs_lock(filp, fl);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2010-10-13 07:30:05 +08:00
|
|
|
static int
|
|
|
|
is_time_granular(struct timespec *ts) {
|
|
|
|
return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
|
|
|
|
}
|
|
|
|
|
2010-09-23 20:55:58 +08:00
|
|
|
static int
|
|
|
|
do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct inode *inode = filp->f_mapping->host;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush all pending writes before doing anything
|
|
|
|
* with locks..
|
|
|
|
*/
|
2005-12-14 05:13:54 +08:00
|
|
|
status = nfs_sync_mapping(filp->f_mapping);
|
|
|
|
if (status != 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
|
2010-09-23 20:55:58 +08:00
|
|
|
/*
|
|
|
|
* Use local locking if mounted with "-onolock" or with appropriate
|
|
|
|
* "-olocal_lock="
|
|
|
|
*/
|
|
|
|
if (!is_local)
|
2005-04-17 06:20:36 +08:00
|
|
|
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
|
2008-04-02 08:26:52 +08:00
|
|
|
else
|
2005-04-17 06:20:36 +08:00
|
|
|
status = do_vfs_lock(filp, fl);
|
|
|
|
if (status < 0)
|
|
|
|
goto out;
|
2010-10-13 07:30:05 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2010-10-13 07:30:05 +08:00
|
|
|
* Revalidate the cache if the server has time stamps granular
|
|
|
|
* enough to detect subsecond changes. Otherwise, clear the
|
|
|
|
* cache to prevent missing any changes.
|
|
|
|
*
|
2005-04-17 06:20:36 +08:00
|
|
|
* This makes locking act as a cache coherency point.
|
|
|
|
*/
|
2005-12-14 05:13:54 +08:00
|
|
|
nfs_sync_mapping(filp->f_mapping);
|
2012-06-21 03:53:43 +08:00
|
|
|
if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
|
2010-10-13 07:30:05 +08:00
|
|
|
if (is_time_granular(&NFS_SERVER(inode)->time_delta))
|
|
|
|
__nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
|
|
|
else
|
|
|
|
nfs_zap_caches(inode);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock a (portion of) a file
|
|
|
|
*/
|
2012-07-17 04:39:15 +08:00
|
|
|
int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-06-12 05:55:58 +08:00
|
|
|
struct inode *inode = filp->f_mapping->host;
|
2008-05-21 07:34:39 +08:00
|
|
|
int ret = -ENOLCK;
|
2010-09-23 20:55:58 +08:00
|
|
|
int is_local = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
|
|
|
|
filp, fl->fl_type, fl->fl_flags,
|
2005-04-17 06:20:36 +08:00
|
|
|
(long long)fl->fl_start, (long long)fl->fl_end);
|
2008-06-12 05:55:58 +08:00
|
|
|
|
2006-03-21 02:44:14 +08:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSLOCK);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* No mandatory locks over NFS */
|
2007-10-02 05:41:15 +08:00
|
|
|
if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
|
2008-05-21 07:34:39 +08:00
|
|
|
goto out_err;
|
|
|
|
|
2010-09-23 20:55:58 +08:00
|
|
|
if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
|
|
|
|
is_local = 1;
|
|
|
|
|
2008-05-21 07:34:39 +08:00
|
|
|
if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
|
|
|
|
ret = NFS_PROTO(inode)->lock_check_bounds(fl);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_err;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (IS_GETLK(cmd))
|
2010-09-23 20:55:58 +08:00
|
|
|
ret = do_getlk(filp, cmd, fl, is_local);
|
2008-05-21 07:34:39 +08:00
|
|
|
else if (fl->fl_type == F_UNLCK)
|
2010-09-23 20:55:58 +08:00
|
|
|
ret = do_unlk(filp, cmd, fl, is_local);
|
2008-05-21 07:34:39 +08:00
|
|
|
else
|
2010-09-23 20:55:58 +08:00
|
|
|
ret = do_setlk(filp, cmd, fl, is_local);
|
2008-05-21 07:34:39 +08:00
|
|
|
out_err:
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock a (portion of) a file
|
|
|
|
*/
|
2012-07-17 04:39:15 +08:00
|
|
|
int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-09-23 20:55:58 +08:00
|
|
|
struct inode *inode = filp->f_mapping->host;
|
|
|
|
int is_local = 0;
|
|
|
|
|
2013-09-16 22:53:17 +08:00
|
|
|
dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
|
|
|
|
filp, fl->fl_type, fl->fl_flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!(fl->fl_flags & FL_FLOCK))
|
|
|
|
return -ENOLCK;
|
|
|
|
|
2012-07-24 03:46:23 +08:00
|
|
|
/*
|
|
|
|
* The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
|
|
|
|
* any standard. In principle we might be able to support LOCK_MAND
|
|
|
|
* on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
|
|
|
|
* NFS code is not set up for it.
|
|
|
|
*/
|
|
|
|
if (fl->fl_type & LOCK_MAND)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2010-09-23 20:55:58 +08:00
|
|
|
if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
|
|
|
|
is_local = 1;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* We're simulating flock() locks using posix locks on the server */
|
|
|
|
if (fl->fl_type == F_UNLCK)
|
2010-09-23 20:55:58 +08:00
|
|
|
return do_unlk(filp, cmd, fl, is_local);
|
|
|
|
return do_setlk(filp, cmd, fl, is_local);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-07-31 04:05:25 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_flock);
|
2007-06-09 03:23:34 +08:00
|
|
|
|
2011-11-05 01:31:22 +08:00
|
|
|
const struct file_operations nfs_file_operations = {
|
|
|
|
.llseek = nfs_file_llseek,
|
2014-04-03 08:14:12 +08:00
|
|
|
.read_iter = nfs_file_read,
|
2014-04-04 02:07:25 +08:00
|
|
|
.write_iter = nfs_file_write,
|
2011-11-05 01:31:22 +08:00
|
|
|
.mmap = nfs_file_mmap,
|
|
|
|
.open = nfs_file_open,
|
|
|
|
.flush = nfs_file_flush,
|
|
|
|
.release = nfs_file_release,
|
|
|
|
.fsync = nfs_file_fsync,
|
|
|
|
.lock = nfs_lock,
|
|
|
|
.flock = nfs_flock,
|
|
|
|
.splice_read = nfs_file_splice_read,
|
2014-04-05 16:37:17 +08:00
|
|
|
.splice_write = iter_file_splice_write,
|
2011-11-05 01:31:22 +08:00
|
|
|
.check_flags = nfs_check_flags,
|
2014-08-27 18:49:41 +08:00
|
|
|
.setlease = simple_nosetlease,
|
2011-11-05 01:31:22 +08:00
|
|
|
};
|
2012-07-31 04:05:23 +08:00
|
|
|
EXPORT_SYMBOL_GPL(nfs_file_operations);
|