2005-04-17 00:20:36 +02: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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#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>
|
Detach sched.h from mm.h
First thing mm.h does is including sched.h solely for can_do_mlock() inline
function which has "current" dereference inside. By dealing with can_do_mlock()
mm.h can be detached from sched.h which is good. See below, why.
This patch
a) removes unconditional inclusion of sched.h from mm.h
b) makes can_do_mlock() normal function in mm/mlock.c
c) exports can_do_mlock() to not break compilation
d) adds sched.h inclusions back to files that were getting it indirectly.
e) adds less bloated headers to some files (asm/signal.h, jiffies.h) that were
getting them indirectly
Net result is:
a) mm.h users would get less code to open, read, preprocess, parse, ... if
they don't need sched.h
b) sched.h stops being dependency for significant number of files:
on x86_64 allmodconfig touching sched.h results in recompile of 4083 files,
after patch it's only 3744 (-8.3%).
Cross-compile tested on
all arm defconfigs, all mips defconfigs, all powerpc defconfigs,
alpha alpha-up
arm
i386 i386-up i386-defconfig i386-allnoconfig
ia64 ia64-up
m68k
mips
parisc parisc-up
powerpc powerpc-up
s390 s390-up
sparc sparc-up
sparc64 sparc64-up
um-x86_64
x86_64 x86_64-up x86_64-defconfig x86_64-allnoconfig
as well as my two usual configs.
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-20 23:22:52 +02:00
|
|
|
#include <linux/aio.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 09:04:11 +01:00
|
|
|
#include <linux/gfp.h>
|
2010-07-30 21:31:54 +02:00
|
|
|
#include <linux/swap.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
|
|
|
|
#include "delegation.h"
|
2007-07-22 23:09:05 +02:00
|
|
|
#include "internal.h"
|
2006-03-20 19:44:14 +01:00
|
|
|
#include "iostat.h"
|
2009-04-03 17:42:44 +02:00
|
|
|
#include "fscache.h"
|
2010-10-20 06:18:01 +02:00
|
|
|
#include "pnfs.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#define NFSDBG_FACILITY NFSDBG_FILE
|
|
|
|
|
|
|
|
static int nfs_file_open(struct inode *, struct file *);
|
|
|
|
static int nfs_file_release(struct inode *, struct file *);
|
2005-06-13 17:14:01 +02:00
|
|
|
static loff_t nfs_file_llseek(struct file *file, loff_t offset, int origin);
|
2005-04-17 00:20:36 +02:00
|
|
|
static int nfs_file_mmap(struct file *, struct vm_area_struct *);
|
2007-06-01 11:51:43 +02:00
|
|
|
static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
|
|
|
|
struct pipe_inode_info *pipe,
|
|
|
|
size_t count, unsigned int flags);
|
2006-10-01 08:28:46 +02:00
|
|
|
static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos);
|
2009-06-18 03:02:09 +02:00
|
|
|
static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
|
|
|
|
struct file *filp, loff_t *ppos,
|
|
|
|
size_t count, unsigned int flags);
|
2006-10-01 08:28:46 +02:00
|
|
|
static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos);
|
2006-06-23 11:05:12 +02:00
|
|
|
static int nfs_file_flush(struct file *, fl_owner_t id);
|
2010-05-26 17:53:25 +02:00
|
|
|
static int nfs_file_fsync(struct file *, int datasync);
|
2005-04-17 00:20:36 +02:00
|
|
|
static int nfs_check_flags(int flags);
|
|
|
|
static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl);
|
|
|
|
static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl);
|
2007-06-08 21:23:34 +02:00
|
|
|
static int nfs_setlease(struct file *file, long arg, struct file_lock **fl);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-09-27 20:29:37 +02:00
|
|
|
static const struct vm_operations_struct nfs_file_vm_ops;
|
2007-07-22 23:09:05 +02:00
|
|
|
|
2006-03-28 11:56:42 +02:00
|
|
|
const struct file_operations nfs_file_operations = {
|
2005-06-13 17:14:01 +02:00
|
|
|
.llseek = nfs_file_llseek,
|
2005-04-17 00:20:36 +02:00
|
|
|
.read = do_sync_read,
|
|
|
|
.write = do_sync_write,
|
2006-10-01 08:28:46 +02:00
|
|
|
.aio_read = nfs_file_read,
|
|
|
|
.aio_write = nfs_file_write,
|
2005-04-17 00:20:36 +02:00
|
|
|
.mmap = nfs_file_mmap,
|
|
|
|
.open = nfs_file_open,
|
|
|
|
.flush = nfs_file_flush,
|
|
|
|
.release = nfs_file_release,
|
2008-05-27 22:29:07 +02:00
|
|
|
.fsync = nfs_file_fsync,
|
2005-04-17 00:20:36 +02:00
|
|
|
.lock = nfs_lock,
|
|
|
|
.flock = nfs_flock,
|
2007-06-01 11:51:43 +02:00
|
|
|
.splice_read = nfs_file_splice_read,
|
2009-06-18 03:02:09 +02:00
|
|
|
.splice_write = nfs_file_splice_write,
|
2005-04-17 00:20:36 +02:00
|
|
|
.check_flags = nfs_check_flags,
|
2007-06-08 21:23:34 +02:00
|
|
|
.setlease = nfs_setlease,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2007-02-12 09:55:39 +01:00
|
|
|
const struct inode_operations nfs_file_inode_operations = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.permission = nfs_permission,
|
|
|
|
.getattr = nfs_getattr,
|
|
|
|
.setattr = nfs_setattr,
|
|
|
|
};
|
|
|
|
|
2005-06-22 19:16:27 +02:00
|
|
|
#ifdef CONFIG_NFS_V3
|
2007-02-12 09:55:39 +01:00
|
|
|
const struct inode_operations nfs3_file_inode_operations = {
|
2005-06-22 19:16:27 +02:00
|
|
|
.permission = nfs_permission,
|
|
|
|
.getattr = nfs_getattr,
|
|
|
|
.setattr = nfs_setattr,
|
|
|
|
.listxattr = nfs3_listxattr,
|
|
|
|
.getxattr = nfs3_getxattr,
|
|
|
|
.setxattr = nfs3_setxattr,
|
|
|
|
.removexattr = nfs3_removexattr,
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_NFS_v3 */
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Hack for future NFS swap support */
|
|
|
|
#ifndef IS_SWAPFILE
|
|
|
|
# define IS_SWAPFILE(inode) (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int nfs_check_flags(int flags)
|
|
|
|
{
|
|
|
|
if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Open file
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
nfs_file_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: open file(%s/%s)\n",
|
2008-06-11 23:55:42 +02:00
|
|
|
filp->f_path.dentry->d_parent->d_name.name,
|
|
|
|
filp->f_path.dentry->d_name.name);
|
|
|
|
|
2010-02-01 20:17:14 +01:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSOPEN);
|
2005-04-17 00:20:36 +02:00
|
|
|
res = nfs_check_flags(filp->f_flags);
|
|
|
|
if (res)
|
|
|
|
return res;
|
|
|
|
|
2008-06-11 22:32:46 +02:00
|
|
|
res = nfs_open(inode, filp);
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nfs_file_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
2008-06-11 23:55:58 +02:00
|
|
|
struct dentry *dentry = filp->f_path.dentry;
|
|
|
|
|
|
|
|
dprintk("NFS: release(%s/%s)\n",
|
|
|
|
dentry->d_parent->d_name.name,
|
|
|
|
dentry->d_name.name);
|
|
|
|
|
2006-03-20 19:44:14 +01:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
|
2008-06-11 22:32:46 +02:00
|
|
|
return nfs_release(inode, filp);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-13 17:14:01 +02: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-16 22:42:46 +02:00
|
|
|
if (nfs_have_delegated_attributes(inode))
|
|
|
|
goto out_noreval;
|
|
|
|
|
2005-06-13 17:14:01 +02:00
|
|
|
if (filp->f_flags & O_DIRECT)
|
|
|
|
goto force_reval;
|
2010-04-16 22:42:46 +02: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 17:14:01 +02:00
|
|
|
force_reval:
|
|
|
|
return __nfs_revalidate_inode(server, inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
|
|
|
|
{
|
2008-06-27 11:05:24 +02:00
|
|
|
loff_t loff;
|
2008-07-16 00:34:16 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
|
2008-06-11 23:55:34 +02:00
|
|
|
filp->f_path.dentry->d_parent->d_name.name,
|
|
|
|
filp->f_path.dentry->d_name.name,
|
|
|
|
offset, origin);
|
|
|
|
|
2005-06-13 17:14:01 +02:00
|
|
|
/* origin == SEEK_END => we must revalidate the cached file length */
|
2006-09-17 03:09:32 +02:00
|
|
|
if (origin == SEEK_END) {
|
2005-06-13 17:14:01 +02:00
|
|
|
struct inode *inode = filp->f_mapping->host;
|
2008-09-23 23:28:35 +02:00
|
|
|
|
2005-06-13 17:14:01 +02:00
|
|
|
int retval = nfs_revalidate_file_size(inode, filp);
|
|
|
|
if (retval < 0)
|
|
|
|
return (loff_t)retval;
|
2008-09-23 23:28:35 +02:00
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
loff = generic_file_llseek_unlocked(filp, offset, origin);
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
} else
|
|
|
|
loff = generic_file_llseek_unlocked(filp, offset, origin);
|
2008-06-27 11:05:24 +02:00
|
|
|
return loff;
|
2005-06-13 17:14:01 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Flush all dirty pages, and check for write errors.
|
|
|
|
*/
|
|
|
|
static int
|
2006-06-23 11:05:12 +02:00
|
|
|
nfs_file_flush(struct file *file, fl_owner_t id)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-06-11 23:55:58 +02:00
|
|
|
struct dentry *dentry = file->f_path.dentry;
|
|
|
|
struct inode *inode = dentry->d_inode;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: flush(%s/%s)\n",
|
|
|
|
dentry->d_parent->d_name.name,
|
|
|
|
dentry->d_name.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-02-01 20:17:14 +01:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((file->f_mode & FMODE_WRITE) == 0)
|
|
|
|
return 0;
|
2007-07-25 20:09:54 +02:00
|
|
|
|
2009-03-19 20:35:50 +01:00
|
|
|
/* Flush writes to the server and return any errors */
|
2010-07-31 20:29:06 +02:00
|
|
|
return vfs_fsync(file, 0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2006-10-01 08:28:46 +02:00
|
|
|
nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-12-08 11:36:40 +01:00
|
|
|
struct dentry * dentry = iocb->ki_filp->f_path.dentry;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode * inode = dentry->d_inode;
|
|
|
|
ssize_t result;
|
2006-10-01 08:28:46 +02:00
|
|
|
size_t count = iov_length(iov, nr_segs);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (iocb->ki_filp->f_flags & O_DIRECT)
|
2006-10-01 08:28:46 +02:00
|
|
|
return nfs_file_direct_read(iocb, iov, nr_segs, pos);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: read(%s/%s, %lu@%lu)\n",
|
2005-04-17 00:20:36 +02:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
(unsigned long) count, (unsigned long) pos);
|
|
|
|
|
2006-05-25 07:40:59 +02:00
|
|
|
result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
|
2010-02-01 20:17:23 +01:00
|
|
|
if (!result) {
|
2006-10-01 08:28:46 +02:00
|
|
|
result = generic_file_aio_read(iocb, iov, nr_segs, pos);
|
2010-02-01 20:17:23 +01:00
|
|
|
if (result > 0)
|
|
|
|
nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
2007-06-01 11:51:43 +02: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 00:20:36 +02:00
|
|
|
{
|
2006-12-08 11:36:40 +01:00
|
|
|
struct dentry *dentry = filp->f_path.dentry;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
ssize_t res;
|
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
|
2005-04-17 00:20:36 +02:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
(unsigned long) count, (unsigned long long) *ppos);
|
|
|
|
|
2006-05-25 07:40:59 +02:00
|
|
|
res = nfs_revalidate_mapping(inode, filp->f_mapping);
|
2010-02-01 20:17:32 +01:00
|
|
|
if (!res) {
|
2007-06-01 11:51:43 +02:00
|
|
|
res = generic_file_splice_read(filp, ppos, pipe, count, flags);
|
2010-02-01 20:17:32 +01:00
|
|
|
if (res > 0)
|
|
|
|
nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
|
|
|
|
{
|
2006-12-08 11:36:40 +01:00
|
|
|
struct dentry *dentry = file->f_path.dentry;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
int status;
|
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: mmap(%s/%s)\n",
|
2005-04-17 00:20:36 +02:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name);
|
|
|
|
|
2009-03-11 19:37:54 +01: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-22 23:09:05 +02:00
|
|
|
if (!status) {
|
|
|
|
vma->vm_ops = &nfs_file_vm_ops;
|
2009-03-11 19:37:54 +01:00
|
|
|
status = nfs_revalidate_mapping(inode, file->f_mapping);
|
2007-07-22 23:09:05 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-07-31 20:29:06 +02: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
|
|
|
|
* nfs_file_write() that a write error occured, and hence cause it to
|
|
|
|
* fall back to doing a synchronous write.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
static int
|
2010-05-26 17:53:25 +02:00
|
|
|
nfs_file_fsync(struct file *file, int datasync)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-05-26 17:53:25 +02:00
|
|
|
struct dentry *dentry = file->f_path.dentry;
|
2007-08-10 23:44:32 +02:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(file);
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode *inode = dentry->d_inode;
|
2010-07-31 20:29:06 +02:00
|
|
|
int have_error, status;
|
|
|
|
int ret = 0;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: fsync file(%s/%s) datasync %d\n",
|
2008-05-27 22:29:07 +02:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
datasync);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-20 19:44:14 +01:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
|
2010-07-31 20:29:06 +02: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);
|
|
|
|
if (have_error)
|
|
|
|
ret = xchg(&ctx->error, 0);
|
2010-08-11 19:10:16 +02:00
|
|
|
if (!ret && status < 0)
|
2010-07-31 20:29:06 +02:00
|
|
|
ret = status;
|
2011-03-23 14:27:54 +01:00
|
|
|
if (!ret && !datasync)
|
|
|
|
/* application has asked for meta-data sync */
|
2011-03-12 08:58:10 +01:00
|
|
|
ret = pnfs_layoutcommit_inode(inode, true);
|
2010-07-31 20:29:06 +02:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02: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 14:54:16 +02: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;
|
|
|
|
|
|
|
|
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 00:20:36 +02:00
|
|
|
/*
|
2007-10-16 10:25:16 +02: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 00:20:36 +02: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 10:25:16 +02: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 00:20:36 +02:00
|
|
|
{
|
2007-10-16 10:25:16 +02: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 14:54:16 +02:00
|
|
|
pgoff_t index = pos >> PAGE_CACHE_SHIFT;
|
2007-10-16 10:25:16 +02: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 14:54:16 +02:00
|
|
|
int once_thru = 0;
|
2007-10-16 10:25:16 +02:00
|
|
|
|
2008-06-11 23:55:50 +02:00
|
|
|
dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
|
|
|
|
file->f_path.dentry->d_parent->d_name.name,
|
|
|
|
file->f_path.dentry->d_name.name,
|
|
|
|
mapping->host->i_ino, len, (long long) pos);
|
|
|
|
|
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 14:54:16 +02:00
|
|
|
start:
|
2009-03-11 19:10:30 +01:00
|
|
|
/*
|
|
|
|
* Prevent starvation issues if someone is doing a consistency
|
|
|
|
* sync-to-disk
|
|
|
|
*/
|
|
|
|
ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
|
|
|
|
nfs_wait_bit_killable, TASK_KILLABLE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
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-04 21:00:53 +01:00
|
|
|
page = grab_cache_page_write_begin(mapping, index, flags);
|
2007-10-16 10:25:16 +02: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 14:54:16 +02: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 10:25:16 +02:00
|
|
|
}
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-16 10:25:16 +02: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 00:20:36 +02:00
|
|
|
{
|
2007-10-16 10:25:16 +02:00
|
|
|
unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
|
|
|
|
int status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:50 +02:00
|
|
|
dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
|
|
|
|
file->f_path.dentry->d_parent->d_name.name,
|
|
|
|
file->f_path.dentry->d_name.name,
|
|
|
|
mapping->host->i_ino, len, (long long) pos);
|
|
|
|
|
2008-06-11 00:31:00 +02: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 10:25:16 +02:00
|
|
|
status = nfs_updatepage(file, page, offset, copied);
|
|
|
|
|
|
|
|
unlock_page(page);
|
|
|
|
page_cache_release(page);
|
|
|
|
|
2007-12-20 20:55:04 +01:00
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
return copied;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-04-03 17:42:41 +02:00
|
|
|
/*
|
|
|
|
* Partially or wholly invalidate a page
|
|
|
|
* - Release the private state associated with a page if undergoing complete
|
|
|
|
* page invalidation
|
2009-04-03 17:42:44 +02:00
|
|
|
* - Called if either PG_private or PG_fscache is set on the page
|
2009-04-03 17:42:41 +02:00
|
|
|
* - Caller holds page lock
|
|
|
|
*/
|
2006-03-26 11:37:18 +02:00
|
|
|
static void nfs_invalidate_page(struct page *page, unsigned long offset)
|
2006-03-20 19:44:04 +01:00
|
|
|
{
|
2008-06-11 23:55:50 +02:00
|
|
|
dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %lu)\n", page, offset);
|
|
|
|
|
2006-10-09 22:18:38 +02:00
|
|
|
if (offset != 0)
|
|
|
|
return;
|
2006-05-31 07:13:38 +02:00
|
|
|
/* Cancel any unstarted writes on this page */
|
2007-08-28 16:29:36 +02:00
|
|
|
nfs_wb_page_cancel(page->mapping->host, page);
|
2009-04-03 17:42:44 +02:00
|
|
|
|
|
|
|
nfs_fscache_invalidate_page(page, page->mapping->host);
|
2006-03-20 19:44:04 +01:00
|
|
|
}
|
|
|
|
|
2009-04-03 17:42:41 +02:00
|
|
|
/*
|
|
|
|
* Attempt to release the private state associated with a page
|
2009-04-03 17:42:44 +02:00
|
|
|
* - Called if either PG_private or PG_fscache is set on the page
|
2009-04-03 17:42:41 +02:00
|
|
|
* - Caller holds page lock
|
|
|
|
* - Return true (may release page) or false (may not)
|
|
|
|
*/
|
2006-03-20 19:44:04 +01:00
|
|
|
static int nfs_release_page(struct page *page, gfp_t gfp)
|
|
|
|
{
|
2010-07-30 21:31:54 +02:00
|
|
|
struct address_space *mapping = page->mapping;
|
|
|
|
|
2008-06-11 23:55:50 +02:00
|
|
|
dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
|
|
|
|
|
2010-03-19 18:55:17 +01:00
|
|
|
/* Only do I/O if gfp is a superset of GFP_KERNEL */
|
2010-07-30 21:31:54 +02:00
|
|
|
if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL) {
|
|
|
|
int how = FLUSH_SYNC;
|
|
|
|
|
|
|
|
/* Don't let kswapd deadlock waiting for OOM RPC calls */
|
|
|
|
if (current_is_kswapd())
|
|
|
|
how = 0;
|
|
|
|
nfs_commit_inode(mapping->host, how);
|
|
|
|
}
|
2007-01-11 08:15:39 +01:00
|
|
|
/* If PagePrivate() is set, then the page is not freeable */
|
2009-04-03 17:42:44 +02:00
|
|
|
if (PagePrivate(page))
|
|
|
|
return 0;
|
|
|
|
return nfs_fscache_release_page(page, gfp);
|
2007-01-11 08:15:39 +01:00
|
|
|
}
|
|
|
|
|
2009-04-03 17:42:41 +02: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 17:42:44 +02:00
|
|
|
* - Called if either PG_private or fscache is set on the page
|
2009-04-03 17:42:41 +02:00
|
|
|
* - Caller holds page lock
|
|
|
|
* - Return 0 if successful, -error otherwise
|
|
|
|
*/
|
2007-01-11 08:15:39 +01:00
|
|
|
static int nfs_launder_page(struct page *page)
|
|
|
|
{
|
2008-06-11 23:55:50 +02:00
|
|
|
struct inode *inode = page->mapping->host;
|
2009-04-03 17:42:44 +02:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2008-06-11 23:55:50 +02:00
|
|
|
|
|
|
|
dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
|
|
|
|
inode->i_ino, (long long)page_offset(page));
|
|
|
|
|
2009-04-03 17:42:44 +02:00
|
|
|
nfs_fscache_wait_on_page_write(nfsi, page);
|
2008-06-11 23:55:50 +02:00
|
|
|
return nfs_wb_page(inode, page);
|
2006-03-20 19:44:04 +01:00
|
|
|
}
|
|
|
|
|
2006-06-28 13:26:44 +02:00
|
|
|
const struct address_space_operations nfs_file_aops = {
|
2005-04-17 00:20:36 +02:00
|
|
|
.readpage = nfs_readpage,
|
|
|
|
.readpages = nfs_readpages,
|
2007-07-22 23:09:05 +02:00
|
|
|
.set_page_dirty = __set_page_dirty_nobuffers,
|
2005-04-17 00:20:36 +02:00
|
|
|
.writepage = nfs_writepage,
|
|
|
|
.writepages = nfs_writepages,
|
2007-10-16 10:25:16 +02:00
|
|
|
.write_begin = nfs_write_begin,
|
|
|
|
.write_end = nfs_write_end,
|
2006-03-20 19:44:04 +01:00
|
|
|
.invalidatepage = nfs_invalidate_page,
|
|
|
|
.releasepage = nfs_release_page,
|
2005-04-17 00:20:36 +02:00
|
|
|
.direct_IO = nfs_direct_IO,
|
2009-08-10 14:54:13 +02:00
|
|
|
.migratepage = nfs_migrate_page,
|
2007-01-11 08:15:39 +01:00
|
|
|
.launder_page = nfs_launder_page,
|
2009-09-16 11:50:17 +02:00
|
|
|
.error_remove_page = generic_error_remove_page,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2009-04-03 17:42:41 +02: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 00:23:21 +02:00
|
|
|
static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
|
2007-07-22 23:09:05 +02:00
|
|
|
{
|
2009-04-01 00:23:21 +02:00
|
|
|
struct page *page = vmf->page;
|
2007-07-22 23:09:05 +02:00
|
|
|
struct file *filp = vma->vm_file;
|
2008-06-11 23:55:50 +02:00
|
|
|
struct dentry *dentry = filp->f_path.dentry;
|
2007-07-22 23:09:05 +02:00
|
|
|
unsigned pagelen;
|
2010-10-04 23:59:08 +02:00
|
|
|
int ret = VM_FAULT_NOPAGE;
|
2007-10-16 10:25:16 +02:00
|
|
|
struct address_space *mapping;
|
2007-07-22 23:09:05 +02:00
|
|
|
|
2008-06-11 23:55:50 +02:00
|
|
|
dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
|
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
filp->f_mapping->host->i_ino,
|
|
|
|
(long long)page_offset(page));
|
|
|
|
|
2009-04-03 17:42:44 +02:00
|
|
|
/* make sure the cache has finished storing the page */
|
|
|
|
nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page);
|
|
|
|
|
2007-07-22 23:09:05 +02:00
|
|
|
lock_page(page);
|
2007-10-16 10:25:16 +02:00
|
|
|
mapping = page->mapping;
|
2008-06-11 23:55:50 +02:00
|
|
|
if (mapping != dentry->d_inode->i_mapping)
|
2008-01-22 23:13:06 +01:00
|
|
|
goto out_unlock;
|
|
|
|
|
2007-07-22 23:09:05 +02:00
|
|
|
pagelen = nfs_page_length(page);
|
2008-01-22 23:13:06 +01:00
|
|
|
if (pagelen == 0)
|
|
|
|
goto out_unlock;
|
2007-10-16 10:25:16 +02:00
|
|
|
|
2010-10-04 23:59:08 +02:00
|
|
|
ret = VM_FAULT_LOCKED;
|
|
|
|
if (nfs_flush_incompatible(filp, page) == 0 &&
|
|
|
|
nfs_updatepage(filp, page, 0, pagelen) == 0)
|
|
|
|
goto out;
|
2008-01-22 23:13:06 +01:00
|
|
|
|
2010-10-04 23:59:08 +02:00
|
|
|
ret = VM_FAULT_SIGBUS;
|
2008-01-22 23:13:06 +01:00
|
|
|
out_unlock:
|
|
|
|
unlock_page(page);
|
2010-10-04 23:59:08 +02:00
|
|
|
out:
|
|
|
|
return ret;
|
2007-07-22 23:09:05 +02:00
|
|
|
}
|
|
|
|
|
2009-09-27 20:29:37 +02:00
|
|
|
static const struct vm_operations_struct nfs_file_vm_ops = {
|
2007-07-22 23:09:05 +02:00
|
|
|
.fault = filemap_fault,
|
|
|
|
.page_mkwrite = nfs_vm_page_mkwrite,
|
|
|
|
};
|
|
|
|
|
2007-07-25 20:09:54 +02:00
|
|
|
static int nfs_need_sync_write(struct file *filp, struct inode *inode)
|
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx;
|
|
|
|
|
2009-10-27 11:05:28 +01:00
|
|
|
if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC))
|
2007-07-25 20:09:54 +02:00
|
|
|
return 1;
|
2007-08-10 23:44:32 +02:00
|
|
|
ctx = nfs_file_open_context(filp);
|
2007-07-25 20:09:54 +02:00
|
|
|
if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags))
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-01 08:28:46 +02:00
|
|
|
static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
|
|
|
|
unsigned long nr_segs, loff_t pos)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-12-08 11:36:40 +01:00
|
|
|
struct dentry * dentry = iocb->ki_filp->f_path.dentry;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct inode * inode = dentry->d_inode;
|
2010-02-01 20:17:41 +01:00
|
|
|
unsigned long written = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
ssize_t result;
|
2006-10-01 08:28:46 +02:00
|
|
|
size_t count = iov_length(iov, nr_segs);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (iocb->ki_filp->f_flags & O_DIRECT)
|
2006-10-01 08:28:46 +02:00
|
|
|
return nfs_file_direct_write(iocb, iov, nr_segs, pos);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
|
2005-04-17 00:20:36 +02:00
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
2008-06-11 23:55:58 +02:00
|
|
|
(unsigned long) count, (long long) pos);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
result = -EBUSY;
|
|
|
|
if (IS_SWAPFILE(inode))
|
|
|
|
goto out_swapfile;
|
2005-06-22 19:16:30 +02:00
|
|
|
/*
|
|
|
|
* O_APPEND implies that we must revalidate the file length.
|
|
|
|
*/
|
|
|
|
if (iocb->ki_filp->f_flags & O_APPEND) {
|
|
|
|
result = nfs_revalidate_file_size(inode, iocb->ki_filp);
|
|
|
|
if (result)
|
|
|
|
goto out;
|
2005-06-22 19:16:30 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
result = count;
|
|
|
|
if (!count)
|
|
|
|
goto out;
|
|
|
|
|
2006-10-01 08:28:46 +02:00
|
|
|
result = generic_file_aio_write(iocb, iov, nr_segs, pos);
|
2010-02-01 20:17:41 +01:00
|
|
|
if (result > 0)
|
|
|
|
written = result;
|
|
|
|
|
2009-10-27 11:05:28 +01:00
|
|
|
/* Return error values for O_DSYNC and IS_SYNC() */
|
2007-07-25 20:09:54 +02:00
|
|
|
if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
|
2010-07-31 20:29:06 +02:00
|
|
|
int err = vfs_fsync(iocb->ki_filp, 0);
|
2006-12-05 06:35:40 +01:00
|
|
|
if (err < 0)
|
|
|
|
result = err;
|
|
|
|
}
|
2010-02-01 20:17:41 +01:00
|
|
|
if (result > 0)
|
|
|
|
nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return result;
|
|
|
|
|
|
|
|
out_swapfile:
|
|
|
|
printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-06-18 03:02:09 +02:00
|
|
|
static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
|
|
|
|
struct file *filp, loff_t *ppos,
|
|
|
|
size_t count, unsigned int flags)
|
|
|
|
{
|
|
|
|
struct dentry *dentry = filp->f_path.dentry;
|
|
|
|
struct inode *inode = dentry->d_inode;
|
2010-02-01 20:17:41 +01:00
|
|
|
unsigned long written = 0;
|
2009-06-18 03:02:09 +02:00
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
|
|
|
|
dentry->d_parent->d_name.name, dentry->d_name.name,
|
|
|
|
(unsigned long) count, (unsigned long long) *ppos);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The combination of splice and an O_APPEND destination is disallowed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
|
2010-02-01 20:17:41 +01:00
|
|
|
if (ret > 0)
|
|
|
|
written = ret;
|
|
|
|
|
2009-06-18 03:02:09 +02:00
|
|
|
if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
|
2010-07-31 20:29:06 +02:00
|
|
|
int err = vfs_fsync(filp, 0);
|
2009-06-18 03:02:09 +02:00
|
|
|
if (err < 0)
|
|
|
|
ret = err;
|
|
|
|
}
|
2010-02-01 20:17:41 +01:00
|
|
|
if (ret > 0)
|
|
|
|
nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
|
2009-06-18 03:02:09 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-09-23 14:55:58 +02:00
|
|
|
static int
|
|
|
|
do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inode *inode = filp->f_mapping->host;
|
|
|
|
int status = 0;
|
2010-11-28 22:04:05 +01:00
|
|
|
unsigned int saved_type = fl->fl_type;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-10-18 23:20:16 +02:00
|
|
|
/* Try local locking first */
|
2007-05-11 22:09:32 +02:00
|
|
|
posix_test_lock(filp, fl);
|
|
|
|
if (fl->fl_type != F_UNLCK) {
|
|
|
|
/* found a conflict */
|
2005-10-18 23:20:16 +02:00
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2010-11-28 22:04:05 +01:00
|
|
|
fl->fl_type = saved_type;
|
2005-10-18 23:20:16 +02:00
|
|
|
|
|
|
|
if (nfs_have_delegation(inode, FMODE_READ))
|
|
|
|
goto out_noconflict;
|
|
|
|
|
2010-09-23 14:55:58 +02:00
|
|
|
if (is_local)
|
2005-10-18 23:20:16 +02:00
|
|
|
goto out_noconflict;
|
|
|
|
|
|
|
|
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
|
|
|
|
out:
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
2005-10-18 23:20:16 +02:00
|
|
|
out_noconflict:
|
|
|
|
fl->fl_type = F_UNLCK;
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int do_vfs_lock(struct file *file, struct file_lock *fl)
|
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
|
|
|
|
case FL_POSIX:
|
|
|
|
res = posix_lock_file_wait(file, fl);
|
|
|
|
break;
|
|
|
|
case FL_FLOCK:
|
|
|
|
res = flock_lock_file_wait(file, fl);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2010-09-23 14:55:58 +02:00
|
|
|
static int
|
|
|
|
do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inode *inode = filp->f_mapping->host;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush all pending writes before doing anything
|
|
|
|
* with locks..
|
|
|
|
*/
|
2005-12-13 22:13:54 +01:00
|
|
|
nfs_sync_mapping(filp->f_mapping);
|
2005-04-17 00:20:36 +02: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 14:55:58 +02:00
|
|
|
/*
|
|
|
|
* Use local locking if mounted with "-onolock" or with appropriate
|
|
|
|
* "-olocal_lock="
|
|
|
|
*/
|
|
|
|
if (!is_local)
|
2005-04-17 00:20:36 +02:00
|
|
|
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
|
|
|
|
else
|
|
|
|
status = do_vfs_lock(filp, fl);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2010-10-13 01:30:05 +02:00
|
|
|
static int
|
|
|
|
is_time_granular(struct timespec *ts) {
|
|
|
|
return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
|
|
|
|
}
|
|
|
|
|
2010-09-23 14:55:58 +02:00
|
|
|
static int
|
|
|
|
do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct inode *inode = filp->f_mapping->host;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Flush all pending writes before doing anything
|
|
|
|
* with locks..
|
|
|
|
*/
|
2005-12-13 22:13:54 +01:00
|
|
|
status = nfs_sync_mapping(filp->f_mapping);
|
|
|
|
if (status != 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
|
|
|
|
2010-09-23 14:55:58 +02:00
|
|
|
/*
|
|
|
|
* Use local locking if mounted with "-onolock" or with appropriate
|
|
|
|
* "-olocal_lock="
|
|
|
|
*/
|
|
|
|
if (!is_local)
|
2005-04-17 00:20:36 +02:00
|
|
|
status = NFS_PROTO(inode)->lock(filp, cmd, fl);
|
2008-04-02 02:26:52 +02:00
|
|
|
else
|
2005-04-17 00:20:36 +02:00
|
|
|
status = do_vfs_lock(filp, fl);
|
|
|
|
if (status < 0)
|
|
|
|
goto out;
|
2010-10-13 01:30:05 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2010-10-13 01:30:05 +02: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 00:20:36 +02:00
|
|
|
* This makes locking act as a cache coherency point.
|
|
|
|
*/
|
2005-12-13 22:13:54 +01:00
|
|
|
nfs_sync_mapping(filp->f_mapping);
|
2010-10-13 01:30:05 +02:00
|
|
|
if (!nfs_have_delegation(inode, FMODE_READ)) {
|
|
|
|
if (is_time_granular(&NFS_SERVER(inode)->time_delta))
|
|
|
|
__nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
|
|
|
else
|
|
|
|
nfs_zap_caches(inode);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock a (portion of) a file
|
|
|
|
*/
|
|
|
|
static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
|
|
|
|
{
|
2008-06-11 23:55:58 +02:00
|
|
|
struct inode *inode = filp->f_mapping->host;
|
2008-05-21 01:34:39 +02:00
|
|
|
int ret = -ENOLCK;
|
2010-09-23 14:55:58 +02:00
|
|
|
int is_local = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
|
|
|
|
filp->f_path.dentry->d_parent->d_name.name,
|
|
|
|
filp->f_path.dentry->d_name.name,
|
2005-04-17 00:20:36 +02:00
|
|
|
fl->fl_type, fl->fl_flags,
|
|
|
|
(long long)fl->fl_start, (long long)fl->fl_end);
|
2008-06-11 23:55:58 +02:00
|
|
|
|
2006-03-20 19:44:14 +01:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSLOCK);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* No mandatory locks over NFS */
|
2007-10-01 23:41:15 +02:00
|
|
|
if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
|
2008-05-21 01:34:39 +02:00
|
|
|
goto out_err;
|
|
|
|
|
2010-09-23 14:55:58 +02:00
|
|
|
if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
|
|
|
|
is_local = 1;
|
|
|
|
|
2008-05-21 01:34:39 +02: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 00:20:36 +02:00
|
|
|
|
|
|
|
if (IS_GETLK(cmd))
|
2010-09-23 14:55:58 +02:00
|
|
|
ret = do_getlk(filp, cmd, fl, is_local);
|
2008-05-21 01:34:39 +02:00
|
|
|
else if (fl->fl_type == F_UNLCK)
|
2010-09-23 14:55:58 +02:00
|
|
|
ret = do_unlk(filp, cmd, fl, is_local);
|
2008-05-21 01:34:39 +02:00
|
|
|
else
|
2010-09-23 14:55:58 +02:00
|
|
|
ret = do_setlk(filp, cmd, fl, is_local);
|
2008-05-21 01:34:39 +02:00
|
|
|
out_err:
|
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lock a (portion of) a file
|
|
|
|
*/
|
|
|
|
static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
|
|
|
|
{
|
2010-09-23 14:55:58 +02:00
|
|
|
struct inode *inode = filp->f_mapping->host;
|
|
|
|
int is_local = 0;
|
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
|
|
|
|
filp->f_path.dentry->d_parent->d_name.name,
|
|
|
|
filp->f_path.dentry->d_name.name,
|
2005-04-17 00:20:36 +02:00
|
|
|
fl->fl_type, fl->fl_flags);
|
|
|
|
|
|
|
|
if (!(fl->fl_flags & FL_FLOCK))
|
|
|
|
return -ENOLCK;
|
|
|
|
|
2010-09-23 14:55:58 +02:00
|
|
|
if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
|
|
|
|
is_local = 1;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* We're simulating flock() locks using posix locks on the server */
|
|
|
|
fl->fl_owner = (fl_owner_t)filp;
|
|
|
|
fl->fl_start = 0;
|
|
|
|
fl->fl_end = OFFSET_MAX;
|
|
|
|
|
|
|
|
if (fl->fl_type == F_UNLCK)
|
2010-09-23 14:55:58 +02:00
|
|
|
return do_unlk(filp, cmd, fl, is_local);
|
|
|
|
return do_setlk(filp, cmd, fl, is_local);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2007-06-08 21:23:34 +02:00
|
|
|
|
2008-06-11 23:55:58 +02:00
|
|
|
/*
|
|
|
|
* There is no protocol support for leases, so we have no way to implement
|
|
|
|
* them correctly in the face of opens by other clients.
|
|
|
|
*/
|
2007-06-08 21:23:34 +02:00
|
|
|
static int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
|
|
|
|
{
|
2008-06-11 23:55:58 +02:00
|
|
|
dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
|
|
|
|
file->f_path.dentry->d_parent->d_name.name,
|
|
|
|
file->f_path.dentry->d_name.name, arg);
|
2007-06-08 21:23:34 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|