2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* linux/fs/nfs/inode.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992 Rick Sladkey
|
|
|
|
*
|
|
|
|
* nfs inode and superblock handling functions
|
|
|
|
*
|
|
|
|
* Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
|
|
|
|
* experimental NFS changes. Modularisation taken straight from SYS5 fs.
|
|
|
|
*
|
|
|
|
* Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
|
|
|
|
* J.S.Peatfield@damtp.cam.ac.uk
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.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 14:22:52 -07:00
|
|
|
#include <linux/sched.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/sunrpc/clnt.h>
|
|
|
|
#include <linux/sunrpc/stats.h>
|
2006-03-20 11:44:22 -07:00
|
|
|
#include <linux/sunrpc/metrics.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <linux/nfs_fs.h>
|
|
|
|
#include <linux/nfs_mount.h>
|
|
|
|
#include <linux/nfs4_mount.h>
|
|
|
|
#include <linux/lockd/bind.h>
|
|
|
|
#include <linux/smp_lock.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/mount.h>
|
|
|
|
#include <linux/nfs_idmap.h>
|
|
|
|
#include <linux/vfs.h>
|
2006-06-09 06:34:28 -07:00
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/nfs_xdr.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
2005-06-22 10:16:21 -07:00
|
|
|
#include "nfs4_fs.h"
|
2006-01-03 01:55:41 -07:00
|
|
|
#include "callback.h"
|
2005-04-16 15:20:36 -07:00
|
|
|
#include "delegation.h"
|
2006-03-20 11:44:13 -07:00
|
|
|
#include "iostat.h"
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
#include "internal.h"
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
#define NFSDBG_FACILITY NFSDBG_VFS
|
|
|
|
|
2007-10-09 09:01:04 -07:00
|
|
|
#define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
|
|
|
|
|
|
|
|
/* Default is to see 64-bit inode numbers */
|
|
|
|
static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
static void nfs_invalidate_inode(struct inode *);
|
2005-12-03 13:20:07 -07:00
|
|
|
static int nfs_update_inode(struct inode *, struct nfs_fattr *);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-06-22 10:16:22 -07:00
|
|
|
static void nfs_zap_acl_cache(struct inode *);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-12-06 21:33:20 -07:00
|
|
|
static struct kmem_cache * nfs_inode_cachep;
|
2005-06-22 10:16:27 -07:00
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
static inline unsigned long
|
|
|
|
nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
|
|
|
|
{
|
|
|
|
return nfs_fileid_to_ino_t(fattr->fileid);
|
|
|
|
}
|
|
|
|
|
2007-10-09 09:01:04 -07:00
|
|
|
/**
|
|
|
|
* nfs_compat_user_ino64 - returns the user-visible inode number
|
|
|
|
* @fileid: 64-bit fileid
|
|
|
|
*
|
|
|
|
* This function returns a 32-bit inode number if the boot parameter
|
|
|
|
* nfs.enable_ino64 is zero.
|
|
|
|
*/
|
|
|
|
u64 nfs_compat_user_ino64(u64 fileid)
|
|
|
|
{
|
|
|
|
int ino;
|
|
|
|
|
|
|
|
if (enable_ino64)
|
|
|
|
return fileid;
|
|
|
|
ino = fileid;
|
|
|
|
if (sizeof(ino) < sizeof(fileid))
|
|
|
|
ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
|
|
|
|
return ino;
|
|
|
|
}
|
|
|
|
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
int nfs_write_inode(struct inode *inode, int sync)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2006-12-13 13:23:47 -07:00
|
|
|
if (sync) {
|
|
|
|
ret = filemap_fdatawait(inode->i_mapping);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = nfs_commit_inode(inode, FLUSH_SYNC);
|
|
|
|
} else
|
|
|
|
ret = nfs_commit_inode(inode, 0);
|
|
|
|
if (ret >= 0)
|
|
|
|
return 0;
|
|
|
|
__mark_inode_dirty(inode, I_DIRTY_DATASYNC);
|
|
|
|
return ret;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
void nfs_clear_inode(struct inode *inode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-06-01 14:26:35 -07:00
|
|
|
/*
|
|
|
|
* The following should never happen...
|
|
|
|
*/
|
|
|
|
BUG_ON(nfs_have_writebacks(inode));
|
2006-07-25 08:28:18 -07:00
|
|
|
BUG_ON(!list_empty(&NFS_I(inode)->open_files));
|
2005-06-22 10:16:22 -07:00
|
|
|
nfs_zap_acl_cache(inode);
|
2006-07-25 08:28:18 -07:00
|
|
|
nfs_access_zap_cache(inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2005-12-13 14:13:54 -07:00
|
|
|
/**
|
|
|
|
* nfs_sync_mapping - helper to flush all mmapped dirty data to disk
|
|
|
|
*/
|
|
|
|
int nfs_sync_mapping(struct address_space *mapping)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (mapping->nrpages == 0)
|
|
|
|
return 0;
|
|
|
|
unmap_mapping_range(mapping, 0, 0, 0);
|
[PATCH] Fix and add EXPORT_SYMBOL(filemap_write_and_wait)
This patch add EXPORT_SYMBOL(filemap_write_and_wait) and use it.
See mm/filemap.c:
And changes the filemap_write_and_wait() and filemap_write_and_wait_range().
Current filemap_write_and_wait() doesn't wait if filemap_fdatawrite()
returns error. However, even if filemap_fdatawrite() returned an
error, it may have submitted the partially data pages to the device.
(e.g. in the case of -ENOSPC)
<quotation>
Andrew Morton writes,
If filemap_fdatawrite() returns an error, this might be due to some
I/O problem: dead disk, unplugged cable, etc. Given the generally
crappy quality of the kernel's handling of such exceptions, there's a
good chance that the filemap_fdatawait() will get stuck in D state
forever.
</quotation>
So, this patch doesn't wait if filemap_fdatawrite() returns the -EIO.
Trond, could you please review the nfs part? Especially I'm not sure,
nfs must use the "filemap_fdatawrite(inode->i_mapping) == 0", or not.
Acked-by: Trond Myklebust <trond.myklebust@fys.uio.no>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-08 02:02:14 -07:00
|
|
|
ret = filemap_write_and_wait(mapping);
|
2005-12-13 14:13:54 -07:00
|
|
|
if (ret != 0)
|
|
|
|
goto out;
|
|
|
|
ret = nfs_wb_all(mapping->host);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* Invalidate the local caches
|
|
|
|
*/
|
2005-11-25 15:10:06 -07:00
|
|
|
static void nfs_zap_caches_locked(struct inode *inode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int mode = inode->i_mode;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
|
|
|
|
|
2007-09-28 16:22:40 -07:00
|
|
|
nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
|
|
|
|
nfsi->attrtimeo_timestamp = jiffies;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
|
|
|
|
if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
|
2005-08-18 11:24:09 -07:00
|
|
|
nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
|
2005-04-16 15:20:36 -07:00
|
|
|
else
|
2005-08-18 11:24:09 -07:00
|
|
|
nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
|
2005-11-25 15:10:06 -07:00
|
|
|
}
|
2005-08-18 11:24:12 -07:00
|
|
|
|
2005-11-25 15:10:06 -07:00
|
|
|
void nfs_zap_caches(struct inode *inode)
|
|
|
|
{
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
nfs_zap_caches_locked(inode);
|
2005-08-18 11:24:12 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-06-22 10:16:22 -07:00
|
|
|
}
|
|
|
|
|
2006-10-19 23:28:40 -07:00
|
|
|
void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
|
|
|
|
{
|
|
|
|
if (mapping->nrpages != 0) {
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-06-22 10:16:22 -07:00
|
|
|
static void nfs_zap_acl_cache(struct inode *inode)
|
|
|
|
{
|
|
|
|
void (*clear_acl_cache)(struct inode *);
|
|
|
|
|
|
|
|
clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
|
|
|
|
if (clear_acl_cache != NULL)
|
|
|
|
clear_acl_cache(inode);
|
2005-08-18 11:24:12 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-08-18 11:24:09 -07:00
|
|
|
NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
|
2005-08-18 11:24:12 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2007-09-28 14:11:45 -07:00
|
|
|
void nfs_invalidate_atime(struct inode *inode)
|
|
|
|
{
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
2005-11-25 15:10:06 -07:00
|
|
|
* Invalidate, but do not unhash, the inode.
|
|
|
|
* NB: must be called with inode->i_lock held!
|
2005-04-16 15:20:36 -07:00
|
|
|
*/
|
2005-11-25 15:10:06 -07:00
|
|
|
static void nfs_invalidate_inode(struct inode *inode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2008-01-22 23:58:59 -07:00
|
|
|
set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
|
2005-11-25 15:10:06 -07:00
|
|
|
nfs_zap_caches_locked(inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
struct nfs_find_desc {
|
|
|
|
struct nfs_fh *fh;
|
|
|
|
struct nfs_fattr *fattr;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In NFSv3 we can have 64bit inode numbers. In order to support
|
|
|
|
* this, and re-exported directories (also seen in NFSv2)
|
|
|
|
* we are forced to allow 2 different inodes to have the same
|
|
|
|
* i_ino.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
nfs_find_actor(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
|
|
|
|
struct nfs_fh *fh = desc->fh;
|
|
|
|
struct nfs_fattr *fattr = desc->fattr;
|
|
|
|
|
|
|
|
if (NFS_FILEID(inode) != fattr->fileid)
|
|
|
|
return 0;
|
|
|
|
if (nfs_compare_fh(NFS_FH(inode), fh))
|
|
|
|
return 0;
|
|
|
|
if (is_bad_inode(inode) || NFS_STALE(inode))
|
|
|
|
return 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
nfs_init_locked(struct inode *inode, void *opaque)
|
|
|
|
{
|
|
|
|
struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
|
|
|
|
struct nfs_fattr *fattr = desc->fattr;
|
|
|
|
|
2008-01-22 23:59:08 -07:00
|
|
|
set_nfs_fileid(inode, fattr->fileid);
|
2005-04-16 15:20:36 -07:00
|
|
|
nfs_copy_fh(NFS_FH(inode), desc->fh);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Don't use READDIRPLUS on directories that we believe are too large */
|
|
|
|
#define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is our front-end to iget that looks up inodes by file handle
|
|
|
|
* instead of inode number.
|
|
|
|
*/
|
|
|
|
struct inode *
|
|
|
|
nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
|
|
|
|
{
|
|
|
|
struct nfs_find_desc desc = {
|
|
|
|
.fh = fh,
|
|
|
|
.fattr = fattr
|
|
|
|
};
|
2006-03-20 11:44:48 -07:00
|
|
|
struct inode *inode = ERR_PTR(-ENOENT);
|
2005-04-16 15:20:36 -07:00
|
|
|
unsigned long hash;
|
|
|
|
|
|
|
|
if ((fattr->valid & NFS_ATTR_FATTR) == 0)
|
|
|
|
goto out_no_inode;
|
|
|
|
|
|
|
|
if (!fattr->nlink) {
|
|
|
|
printk("NFS: Buggy server - nlink == 0!\n");
|
|
|
|
goto out_no_inode;
|
|
|
|
}
|
|
|
|
|
|
|
|
hash = nfs_fattr_to_ino_t(fattr);
|
|
|
|
|
2006-03-20 11:44:48 -07:00
|
|
|
inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
|
|
|
|
if (inode == NULL) {
|
|
|
|
inode = ERR_PTR(-ENOMEM);
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out_no_inode;
|
2006-03-20 11:44:48 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
if (inode->i_state & I_NEW) {
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2007-02-05 15:44:22 -07:00
|
|
|
unsigned long now = jiffies;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* We set i_ino for the few things that still rely on it,
|
|
|
|
* such as stat(2) */
|
|
|
|
inode->i_ino = hash;
|
|
|
|
|
|
|
|
/* We can't support update_atime(), since the server will reset it */
|
|
|
|
inode->i_flags |= S_NOATIME|S_NOCMTIME;
|
|
|
|
inode->i_mode = fattr->mode;
|
|
|
|
/* Why so? Because we want revalidate for devices/FIFOs, and
|
|
|
|
* that's precisely what we have in nfs_file_inode_operations.
|
|
|
|
*/
|
2006-08-22 17:06:12 -07:00
|
|
|
inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
|
2005-04-16 15:20:36 -07:00
|
|
|
if (S_ISREG(inode->i_mode)) {
|
|
|
|
inode->i_fop = &nfs_file_operations;
|
|
|
|
inode->i_data.a_ops = &nfs_file_aops;
|
|
|
|
inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
|
|
|
|
} else if (S_ISDIR(inode->i_mode)) {
|
2006-08-22 17:06:12 -07:00
|
|
|
inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
|
2005-04-16 15:20:36 -07:00
|
|
|
inode->i_fop = &nfs_dir_operations;
|
|
|
|
if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
|
|
|
|
&& fattr->size <= NFS_LIMIT_READDIRPLUS)
|
2008-01-22 23:58:59 -07:00
|
|
|
set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
|
2006-06-09 06:34:19 -07:00
|
|
|
/* Deal with crossing mountpoints */
|
|
|
|
if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) {
|
2006-06-09 06:34:29 -07:00
|
|
|
if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
|
|
|
|
inode->i_op = &nfs_referral_inode_operations;
|
|
|
|
else
|
|
|
|
inode->i_op = &nfs_mountpoint_inode_operations;
|
2006-06-09 06:34:19 -07:00
|
|
|
inode->i_fop = NULL;
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
} else if (S_ISLNK(inode->i_mode))
|
|
|
|
inode->i_op = &nfs_symlink_inode_operations;
|
|
|
|
else
|
|
|
|
init_special_inode(inode, inode->i_mode, fattr->rdev);
|
|
|
|
|
2005-10-27 19:12:39 -07:00
|
|
|
nfsi->read_cache_jiffies = fattr->time_start;
|
2007-02-05 15:44:22 -07:00
|
|
|
nfsi->last_updated = now;
|
|
|
|
nfsi->cache_change_attribute = now;
|
2005-04-16 15:20:36 -07:00
|
|
|
inode->i_atime = fattr->atime;
|
|
|
|
inode->i_mtime = fattr->mtime;
|
|
|
|
inode->i_ctime = fattr->ctime;
|
|
|
|
if (fattr->valid & NFS_ATTR_FATTR_V4)
|
|
|
|
nfsi->change_attr = fattr->change_attr;
|
|
|
|
inode->i_size = nfs_size_to_loff_t(fattr->size);
|
|
|
|
inode->i_nlink = fattr->nlink;
|
|
|
|
inode->i_uid = fattr->uid;
|
|
|
|
inode->i_gid = fattr->gid;
|
|
|
|
if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
|
|
|
|
/*
|
|
|
|
* report the blocks in 512byte units
|
|
|
|
*/
|
|
|
|
inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
|
|
|
|
} else {
|
|
|
|
inode->i_blocks = fattr->du.nfs2.blocks;
|
|
|
|
}
|
|
|
|
nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
|
2007-02-05 15:44:22 -07:00
|
|
|
nfsi->attrtimeo_timestamp = now;
|
2005-04-16 15:20:36 -07:00
|
|
|
memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
|
2006-07-25 08:28:18 -07:00
|
|
|
nfsi->access_cache = RB_ROOT;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
unlock_new_inode(inode);
|
|
|
|
} else
|
|
|
|
nfs_refresh_inode(inode, fattr);
|
|
|
|
dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
|
|
|
|
inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(inode),
|
|
|
|
atomic_read(&inode->i_count));
|
|
|
|
|
|
|
|
out:
|
|
|
|
return inode;
|
|
|
|
|
|
|
|
out_no_inode:
|
2006-03-20 11:44:48 -07:00
|
|
|
dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)
|
|
|
|
|
|
|
|
int
|
|
|
|
nfs_setattr(struct dentry *dentry, struct iattr *attr)
|
|
|
|
{
|
|
|
|
struct inode *inode = dentry->d_inode;
|
|
|
|
struct nfs_fattr fattr;
|
|
|
|
int error;
|
|
|
|
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
|
|
|
|
|
2007-10-18 03:05:21 -07:00
|
|
|
/* skip mode change if it's just for clearing setuid/setgid */
|
|
|
|
if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
|
|
|
|
attr->ia_valid &= ~ATTR_MODE;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
if (attr->ia_valid & ATTR_SIZE) {
|
|
|
|
if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
|
|
|
|
attr->ia_valid &= ~ATTR_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Optimization: if the end result is no change, don't RPC */
|
|
|
|
attr->ia_valid &= NFS_VALID_ATTRS;
|
|
|
|
if (attr->ia_valid == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
lock_kernel();
|
2006-03-20 11:44:06 -07:00
|
|
|
/* Write all dirty data */
|
2007-04-14 16:07:28 -07:00
|
|
|
if (S_ISREG(inode->i_mode)) {
|
|
|
|
filemap_write_and_wait(inode->i_mapping);
|
|
|
|
nfs_wb_all(inode);
|
|
|
|
}
|
2005-10-18 14:20:19 -07:00
|
|
|
/*
|
|
|
|
* Return any delegations if we're going to change ACLs
|
|
|
|
*/
|
|
|
|
if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
|
|
|
|
nfs_inode_return_delegation(inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr);
|
2005-08-16 08:49:44 -07:00
|
|
|
if (error == 0)
|
2005-04-16 15:20:36 -07:00
|
|
|
nfs_refresh_inode(inode, &fattr);
|
2005-08-16 08:49:44 -07:00
|
|
|
unlock_kernel();
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nfs_setattr_update_inode - Update inode metadata after a setattr call.
|
|
|
|
* @inode: pointer to struct inode
|
|
|
|
* @attr: pointer to struct iattr
|
|
|
|
*
|
|
|
|
* Note: we do this in the *proc.c in order to ensure that
|
|
|
|
* it works for things like exclusive creates too.
|
|
|
|
*/
|
|
|
|
void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
|
|
|
|
{
|
|
|
|
if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
|
2005-04-16 15:20:36 -07:00
|
|
|
if ((attr->ia_valid & ATTR_MODE) != 0) {
|
2005-08-16 08:49:44 -07:00
|
|
|
int mode = attr->ia_mode & S_IALLUGO;
|
|
|
|
mode |= inode->i_mode & ~S_IALLUGO;
|
2005-04-16 15:20:36 -07:00
|
|
|
inode->i_mode = mode;
|
|
|
|
}
|
|
|
|
if ((attr->ia_valid & ATTR_UID) != 0)
|
|
|
|
inode->i_uid = attr->ia_uid;
|
|
|
|
if ((attr->ia_valid & ATTR_GID) != 0)
|
|
|
|
inode->i_gid = attr->ia_gid;
|
2005-08-18 11:24:12 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-08-18 11:24:09 -07:00
|
|
|
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
|
2005-08-18 11:24:12 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-08-16 08:49:44 -07:00
|
|
|
}
|
|
|
|
if ((attr->ia_valid & ATTR_SIZE) != 0) {
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
|
2005-08-16 08:49:44 -07:00
|
|
|
inode->i_size = attr->ia_size;
|
|
|
|
vmtruncate(inode, attr->ia_size);
|
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2005-08-18 11:24:11 -07:00
|
|
|
static int nfs_wait_schedule(void *word)
|
|
|
|
{
|
|
|
|
if (signal_pending(current))
|
|
|
|
return -ERESTARTSYS;
|
|
|
|
schedule();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* Wait for the inode to get unlocked.
|
|
|
|
*/
|
2005-08-18 11:24:11 -07:00
|
|
|
static int nfs_wait_on_inode(struct inode *inode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int error;
|
2005-08-18 11:24:11 -07:00
|
|
|
|
|
|
|
error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
|
2007-12-06 14:24:39 -07:00
|
|
|
nfs_wait_schedule, TASK_KILLABLE);
|
2005-08-18 11:24:11 -07:00
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-08-18 11:24:11 -07:00
|
|
|
static void nfs_wake_up_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
|
|
|
|
smp_mb__after_clear_bit();
|
|
|
|
wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
|
|
|
|
{
|
|
|
|
struct inode *inode = dentry->d_inode;
|
2005-08-18 11:24:09 -07:00
|
|
|
int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
|
2005-04-16 15:20:36 -07:00
|
|
|
int err;
|
|
|
|
|
2007-10-26 10:32:13 -07:00
|
|
|
/*
|
|
|
|
* Flush out writes to the server in order to update c/mtime.
|
|
|
|
*
|
|
|
|
* Hold the i_mutex to suspend application writes temporarily;
|
|
|
|
* this prevents long-running writing applications from blocking
|
|
|
|
* nfs_wb_nocommit.
|
|
|
|
*/
|
|
|
|
if (S_ISREG(inode->i_mode)) {
|
|
|
|
mutex_lock(&inode->i_mutex);
|
2007-07-20 10:13:28 -07:00
|
|
|
nfs_wb_nocommit(inode);
|
2007-10-26 10:32:13 -07:00
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
}
|
2006-01-09 21:52:17 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We may force a getattr if the user cares about atime.
|
|
|
|
*
|
|
|
|
* Note that we only have to check the vfsmount flags here:
|
|
|
|
* - NFS always sets S_NOATIME by so checking it would give a
|
|
|
|
* bogus result
|
|
|
|
* - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
|
|
|
|
* no point in checking those.
|
|
|
|
*/
|
|
|
|
if ((mnt->mnt_flags & MNT_NOATIME) ||
|
|
|
|
((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
|
2005-04-16 15:20:36 -07:00
|
|
|
need_atime = 0;
|
2006-01-09 21:52:17 -07:00
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
if (need_atime)
|
|
|
|
err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
|
|
|
else
|
|
|
|
err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
2007-08-03 12:07:10 -07:00
|
|
|
if (!err) {
|
2005-04-16 15:20:36 -07:00
|
|
|
generic_fillattr(inode, stat);
|
2007-10-09 09:01:04 -07:00
|
|
|
stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
|
2007-08-03 12:07:10 -07:00
|
|
|
}
|
2005-04-16 15:20:36 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-03-20 11:44:03 -07:00
|
|
|
static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx;
|
|
|
|
|
2006-09-27 01:49:39 -07:00
|
|
|
ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (ctx != NULL) {
|
2007-06-05 07:42:27 -07:00
|
|
|
ctx->path.dentry = dget(dentry);
|
|
|
|
ctx->path.mnt = mntget(mnt);
|
2005-04-16 15:20:36 -07:00
|
|
|
ctx->cred = get_rpccred(cred);
|
|
|
|
ctx->state = NULL;
|
|
|
|
ctx->lockowner = current->files;
|
|
|
|
ctx->error = 0;
|
2005-06-22 10:16:29 -07:00
|
|
|
ctx->dir_cookie = 0;
|
2007-07-26 09:06:17 -07:00
|
|
|
atomic_set(&ctx->count, 1);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
|
|
|
|
{
|
|
|
|
if (ctx != NULL)
|
2007-07-26 09:06:17 -07:00
|
|
|
atomic_inc(&ctx->count);
|
2005-04-16 15:20:36 -07:00
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
2007-10-18 15:03:27 -07:00
|
|
|
static void __put_nfs_open_context(struct nfs_open_context *ctx, int wait)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2007-07-26 09:06:17 -07:00
|
|
|
struct inode *inode = ctx->path.dentry->d_inode;
|
2007-06-17 13:02:44 -07:00
|
|
|
|
2007-07-26 09:06:17 -07:00
|
|
|
if (!atomic_dec_and_lock(&ctx->count, &inode->i_lock))
|
|
|
|
return;
|
|
|
|
list_del(&ctx->list);
|
|
|
|
spin_unlock(&inode->i_lock);
|
2007-10-18 15:03:27 -07:00
|
|
|
if (ctx->state != NULL) {
|
|
|
|
if (wait)
|
|
|
|
nfs4_close_sync(&ctx->path, ctx->state, ctx->mode);
|
|
|
|
else
|
|
|
|
nfs4_close_state(&ctx->path, ctx->state, ctx->mode);
|
|
|
|
}
|
2007-06-17 13:02:44 -07:00
|
|
|
if (ctx->cred != NULL)
|
|
|
|
put_rpccred(ctx->cred);
|
|
|
|
dput(ctx->path.dentry);
|
|
|
|
mntput(ctx->path.mnt);
|
|
|
|
kfree(ctx);
|
|
|
|
}
|
|
|
|
|
2007-10-18 15:03:27 -07:00
|
|
|
void put_nfs_open_context(struct nfs_open_context *ctx)
|
|
|
|
{
|
|
|
|
__put_nfs_open_context(ctx, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
|
|
|
|
{
|
|
|
|
__put_nfs_open_context(ctx, 1);
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* Ensure that mmap has a recent RPC credential for use when writing out
|
|
|
|
* shared pages
|
|
|
|
*/
|
2006-03-20 11:44:03 -07:00
|
|
|
static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-12-08 03:36:40 -07:00
|
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
filp->private_data = get_nfs_open_context(ctx);
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
list_add(&ctx->list, &nfsi->open_files);
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
}
|
|
|
|
|
2005-11-04 13:33:38 -07:00
|
|
|
/*
|
|
|
|
* Given an inode, search for an open context with the desired characteristics
|
|
|
|
*/
|
|
|
|
struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
struct nfs_open_context *pos, *ctx = NULL;
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
list_for_each_entry(pos, &nfsi->open_files, list) {
|
2005-11-04 13:33:38 -07:00
|
|
|
if (cred != NULL && pos->cred != cred)
|
|
|
|
continue;
|
2005-04-16 15:20:36 -07:00
|
|
|
if ((pos->mode & mode) == mode) {
|
|
|
|
ctx = get_nfs_open_context(pos);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
2006-03-20 11:44:03 -07:00
|
|
|
static void nfs_file_clear_open_context(struct file *filp)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-12-08 03:36:40 -07:00
|
|
|
struct inode *inode = filp->f_path.dentry->d_inode;
|
2007-08-10 14:44:32 -07:00
|
|
|
struct nfs_open_context *ctx = nfs_file_open_context(filp);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
if (ctx) {
|
|
|
|
filp->private_data = NULL;
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
|
|
|
|
spin_unlock(&inode->i_lock);
|
2007-10-18 15:03:27 -07:00
|
|
|
put_nfs_open_context_sync(ctx);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These allocate and release file read/write context information.
|
|
|
|
*/
|
|
|
|
int nfs_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
struct nfs_open_context *ctx;
|
|
|
|
struct rpc_cred *cred;
|
|
|
|
|
|
|
|
cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
|
|
|
|
if (IS_ERR(cred))
|
|
|
|
return PTR_ERR(cred);
|
2006-12-08 03:36:40 -07:00
|
|
|
ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred);
|
2005-04-16 15:20:36 -07:00
|
|
|
put_rpccred(cred);
|
|
|
|
if (ctx == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
ctx->mode = filp->f_mode;
|
|
|
|
nfs_file_set_open_context(filp, ctx);
|
|
|
|
put_nfs_open_context(ctx);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_release(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
nfs_file_clear_open_context(filp);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function is called whenever some part of NFS notices that
|
|
|
|
* the cached attributes have to be refreshed.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
__nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
|
|
|
|
{
|
|
|
|
int status = -ESTALE;
|
|
|
|
struct nfs_fattr fattr;
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
|
|
|
|
inode->i_sb->s_id, (long long)NFS_FILEID(inode));
|
|
|
|
|
2006-05-24 22:41:01 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
|
2005-04-16 15:20:36 -07:00
|
|
|
lock_kernel();
|
2006-10-19 23:28:42 -07:00
|
|
|
if (is_bad_inode(inode))
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out_nowait;
|
|
|
|
if (NFS_STALE(inode))
|
|
|
|
goto out_nowait;
|
|
|
|
|
2005-08-18 11:24:11 -07:00
|
|
|
status = nfs_wait_on_inode(inode);
|
|
|
|
if (status < 0)
|
|
|
|
goto out;
|
2007-09-28 16:11:33 -07:00
|
|
|
|
|
|
|
status = -ESTALE;
|
|
|
|
if (NFS_STALE(inode))
|
|
|
|
goto out;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
|
|
|
|
if (status != 0) {
|
|
|
|
dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
|
|
|
|
inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(inode), status);
|
|
|
|
if (status == -ESTALE) {
|
|
|
|
nfs_zap_caches(inode);
|
|
|
|
if (!S_ISDIR(inode->i_mode))
|
2008-01-22 23:58:59 -07:00
|
|
|
set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-10-27 19:12:39 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
2005-12-03 13:20:07 -07:00
|
|
|
status = nfs_update_inode(inode, &fattr);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (status) {
|
2005-10-27 19:12:39 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-04-16 15:20:36 -07:00
|
|
|
dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
|
|
|
|
inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(inode), status);
|
|
|
|
goto out;
|
|
|
|
}
|
2005-08-18 11:24:12 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2005-08-18 11:24:09 -07:00
|
|
|
|
2005-12-03 13:20:07 -07:00
|
|
|
if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
|
2005-06-22 10:16:22 -07:00
|
|
|
nfs_zap_acl_cache(inode);
|
2005-08-18 11:24:09 -07:00
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
|
|
|
|
inode->i_sb->s_id,
|
|
|
|
(long long)NFS_FILEID(inode));
|
|
|
|
|
2005-08-18 11:24:11 -07:00
|
|
|
out:
|
|
|
|
nfs_wake_up_inode(inode);
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
out_nowait:
|
|
|
|
unlock_kernel();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
int nfs_attribute_timeout(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
if (nfs_have_delegation(inode, FMODE_READ))
|
|
|
|
return 0;
|
Re: [NFS] [PATCH] Attribute timeout handling and wrapping u32 jiffies
I would like to discuss the idea that the current checks for attribute
timeout using time_after are inadequate for 32bit architectures, since
time_after works correctly only when the two timestamps being compared
are within 2^31 jiffies of each other. The signed overflow caused by
comparing values more than 2^31 jiffies apart will flip the result,
causing incorrect assumptions of validity.
2^31 jiffies is a fairly large period of time (~25 days) when compared
to the lifetime of most kernel data structures, but for long lived NFS
mounts that can sit idle for months (think that for some reason autofs
cannot be used), it is easy to compare inode attribute timestamps with
very disparate or even bogus values (as in when jiffies have wrapped
many times, where the comparison doesn't even make sense).
Currently the code tests for attribute timeout by simply adding the
desired amount of jiffies to the stored timestamp and comparing that
with the current timestamp of obtained attribute data with time_after.
This is incorrect, as it returns true for the desired timeout period
and another full 2^31 range of jiffies.
In testing with artificial jumps (several small jumps, not one big
crank) of the jiffies I was able to reproduce a problem found in a
server with very long lived NFS mounts, where attributes would not be
refreshed even after touching files and directories in the server:
Initial uptime:
03:42:01 up 6 min, 0 users, load average: 0.01, 0.12, 0.07
NFS volume is mounted and time is advanced:
03:38:09 up 25 days, 2 min, 0 users, load average: 1.22, 1.05, 1.08
# ls -l /local/A/foo/bar /nfs/A/foo/bar
-rw-r--r-- 1 root root 0 Dec 17 03:38 /local/A/foo/bar
-rw-r--r-- 1 root root 0 Nov 22 00:36 /nfs/A/foo/bar
# touch /local/A/foo/bar
# ls -l /local/A/foo/bar /nfs/A/foo/bar
-rw-r--r-- 1 root root 0 Dec 17 03:47 /local/A/foo/bar
-rw-r--r-- 1 root root 0 Nov 22 00:36 /nfs/A/foo/bar
We can see the local mtime is updated, but the NFS mount still shows
the old value. The patch below makes it work:
Initial setup...
07:11:02 up 25 days, 1 min, 0 users, load average: 0.15, 0.03, 0.04
# ls -l /local/A/foo/bar /nfs/A/foo/bar
-rw-r--r-- 1 root root 0 Jan 11 07:11 /local/A/foo/bar
-rw-r--r-- 1 root root 0 Jan 11 07:11 /nfs/A/foo/bar
# touch /local/A/foo/bar
# ls -l /local/A/foo/bar /nfs/A/foo/bar
-rw-r--r-- 1 root root 0 Jan 11 07:14 /local/A/foo/bar
-rw-r--r-- 1 root root 0 Jan 11 07:14 /nfs/A/foo/bar
Signed-off-by: Fabio Olive Leite <fleite@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2007-07-26 18:59:00 -07:00
|
|
|
return !time_in_range(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* nfs_revalidate_inode - Revalidate the inode attributes
|
|
|
|
* @server - pointer to nfs_server struct
|
|
|
|
* @inode - pointer to inode struct
|
|
|
|
*
|
|
|
|
* Updates inode attribute information by retrieving the data from the server.
|
|
|
|
*/
|
|
|
|
int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
|
|
|
|
{
|
2006-05-24 22:40:59 -07:00
|
|
|
if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
|
2005-04-16 15:20:36 -07:00
|
|
|
&& !nfs_attribute_timeout(inode))
|
|
|
|
return NFS_STALE(inode) ? -ESTALE : 0;
|
|
|
|
return __nfs_revalidate_inode(server, inode);
|
|
|
|
}
|
|
|
|
|
2007-01-24 12:54:55 -07:00
|
|
|
static int nfs_invalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
|
|
|
if (mapping->nrpages != 0) {
|
|
|
|
int ret = invalidate_inode_pages2(mapping);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
|
2007-09-30 12:31:19 -07:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
2007-01-24 12:54:55 -07:00
|
|
|
memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
|
|
|
|
dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
|
|
|
|
inode->i_sb->s_id, (long long)NFS_FILEID(inode));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&inode->i_mutex);
|
|
|
|
if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_DATA) {
|
|
|
|
ret = nfs_sync_mapping(mapping);
|
|
|
|
if (ret == 0)
|
|
|
|
ret = nfs_invalidate_mapping_nolock(inode, mapping);
|
|
|
|
}
|
|
|
|
mutex_unlock(&inode->i_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-06-22 10:16:30 -07:00
|
|
|
/**
|
2007-01-24 12:54:55 -07:00
|
|
|
* nfs_revalidate_mapping_nolock - Revalidate the pagecache
|
2005-06-22 10:16:30 -07:00
|
|
|
* @inode - pointer to host inode
|
|
|
|
* @mapping - pointer to mapping
|
|
|
|
*/
|
2007-01-24 12:54:55 -07:00
|
|
|
int nfs_revalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
|
2005-06-22 10:16:30 -07:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2006-05-24 22:40:59 -07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
|
2007-01-24 12:54:55 -07:00
|
|
|
|| nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
|
2006-05-24 22:40:59 -07:00
|
|
|
ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
2007-01-24 12:54:55 -07:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
|
|
|
|
ret = nfs_invalidate_mapping_nolock(inode, mapping);
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
2005-06-22 10:16:30 -07:00
|
|
|
|
2007-01-24 12:54:55 -07:00
|
|
|
/**
|
|
|
|
* nfs_revalidate_mapping - Revalidate the pagecache
|
|
|
|
* @inode - pointer to host inode
|
|
|
|
* @mapping - pointer to mapping
|
|
|
|
*
|
|
|
|
* This version of the function will take the inode->i_mutex and attempt to
|
|
|
|
* flush out all dirty data if it needs to invalidate the page cache.
|
|
|
|
*/
|
|
|
|
int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int ret = 0;
|
2005-08-18 11:24:12 -07:00
|
|
|
|
2007-01-24 12:54:55 -07:00
|
|
|
if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
|
|
|
|
|| nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
|
|
|
|
ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2005-06-22 10:16:30 -07:00
|
|
|
}
|
2007-01-24 12:54:55 -07:00
|
|
|
if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
|
|
|
|
ret = nfs_invalidate_mapping(inode, mapping);
|
2006-10-19 23:28:40 -07:00
|
|
|
out:
|
2006-05-24 22:40:59 -07:00
|
|
|
return ret;
|
2005-06-22 10:16:30 -07:00
|
|
|
}
|
|
|
|
|
2006-01-03 01:55:40 -07:00
|
|
|
static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
2007-09-30 12:21:24 -07:00
|
|
|
if ((fattr->valid & NFS_ATTR_WCC_V4) != 0 &&
|
|
|
|
nfsi->change_attr == fattr->pre_change_attr) {
|
|
|
|
nfsi->change_attr = fattr->change_attr;
|
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
nfsi->cache_validity |= NFS_INO_INVALID_DATA;
|
|
|
|
}
|
2006-01-03 01:55:40 -07:00
|
|
|
/* If we have atomic WCC data, we may update some attributes */
|
|
|
|
if ((fattr->valid & NFS_ATTR_WCC) != 0) {
|
2007-09-27 07:07:31 -07:00
|
|
|
if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime))
|
2006-01-03 01:55:40 -07:00
|
|
|
memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
|
|
|
|
if (timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
|
|
|
|
memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
|
2007-09-30 14:03:25 -07:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
nfsi->cache_validity |= NFS_INO_INVALID_DATA;
|
2006-01-03 01:55:40 -07:00
|
|
|
}
|
2007-10-26 10:31:47 -07:00
|
|
|
if (inode->i_size == nfs_size_to_loff_t(fattr->pre_size) &&
|
|
|
|
nfsi->npages == 0)
|
|
|
|
inode->i_size = nfs_size_to_loff_t(fattr->size);
|
2006-01-03 01:55:40 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/**
|
2005-10-27 19:12:39 -07:00
|
|
|
* nfs_check_inode_attributes - verify consistency of the inode attribute cache
|
2005-04-16 15:20:36 -07:00
|
|
|
* @inode - pointer to inode
|
|
|
|
* @fattr - updated attributes
|
|
|
|
*
|
|
|
|
* Verifies the attribute cache. If we have just changed the attributes,
|
|
|
|
* so that fattr carries weak cache consistency data, then it may
|
|
|
|
* also update the ctime/mtime/change_attribute.
|
|
|
|
*/
|
2005-10-27 19:12:39 -07:00
|
|
|
static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
loff_t cur_size, new_isize;
|
2007-10-08 11:26:13 -07:00
|
|
|
unsigned long invalid = 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-08-18 11:24:12 -07:00
|
|
|
|
2006-03-20 11:44:07 -07:00
|
|
|
/* Has the inode gone and changed behind our back? */
|
|
|
|
if (nfsi->fileid != fattr->fileid
|
|
|
|
|| (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2006-01-03 01:55:40 -07:00
|
|
|
/* Do atomic weak cache consistency updates */
|
|
|
|
nfs_wcc_update_inode(inode, fattr);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-05-24 22:40:46 -07:00
|
|
|
if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
|
2006-05-24 22:40:55 -07:00
|
|
|
nfsi->change_attr != fattr->change_attr)
|
2007-10-08 11:26:13 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Verify a few of the more important attributes */
|
2006-05-24 22:40:55 -07:00
|
|
|
if (!timespec_equal(&inode->i_mtime, &fattr->mtime))
|
2007-10-08 11:26:13 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
|
2006-03-20 11:44:07 -07:00
|
|
|
|
|
|
|
cur_size = i_size_read(inode);
|
|
|
|
new_isize = nfs_size_to_loff_t(fattr->size);
|
2006-03-20 11:44:08 -07:00
|
|
|
if (cur_size != new_isize && nfsi->npages == 0)
|
2007-10-08 11:26:13 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Have any file permissions changed? */
|
|
|
|
if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)
|
|
|
|
|| inode->i_uid != fattr->uid
|
|
|
|
|| inode->i_gid != fattr->gid)
|
2007-10-08 11:26:13 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/* Has the link count changed? */
|
|
|
|
if (inode->i_nlink != fattr->nlink)
|
2007-10-08 11:26:13 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ATTR;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
if (!timespec_equal(&inode->i_atime, &fattr->atime))
|
2007-10-08 11:26:13 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ATIME;
|
|
|
|
|
|
|
|
if (invalid != 0)
|
|
|
|
nfsi->cache_validity |= invalid;
|
|
|
|
else
|
|
|
|
nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
|
|
|
|
| NFS_INO_INVALID_ATIME
|
|
|
|
| NFS_INO_REVAL_PAGECACHE);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2005-10-27 19:12:39 -07:00
|
|
|
nfsi->read_cache_jiffies = fattr->time_start;
|
2005-04-16 15:20:36 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-27 19:12:39 -07:00
|
|
|
/**
|
|
|
|
* nfs_refresh_inode - try to update the inode attribute cache
|
|
|
|
* @inode - pointer to inode
|
|
|
|
* @fattr - updated attributes
|
|
|
|
*
|
|
|
|
* Check that an RPC call that returned attributes has not overlapped with
|
|
|
|
* other recent updates of the inode metadata, then decide whether it is
|
|
|
|
* safe to do a full update of the inode attributes, or whether just to
|
|
|
|
* call nfs_check_inode_attributes.
|
|
|
|
*/
|
|
|
|
int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if ((fattr->valid & NFS_ATTR_FATTR) == 0)
|
|
|
|
return 0;
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (time_after(fattr->time_start, nfsi->last_updated))
|
2005-12-03 13:20:07 -07:00
|
|
|
status = nfs_update_inode(inode, fattr);
|
2005-10-27 19:12:39 -07:00
|
|
|
else
|
|
|
|
status = nfs_check_inode_attributes(inode, fattr);
|
|
|
|
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-10-27 19:12:39 -07:00
|
|
|
/**
|
|
|
|
* nfs_post_op_update_inode - try to update the inode attribute cache
|
|
|
|
* @inode - pointer to inode
|
|
|
|
* @fattr - updated attributes
|
|
|
|
*
|
|
|
|
* After an operation that has changed the inode metadata, mark the
|
|
|
|
* attribute cache as being invalid, then try to update it.
|
2006-09-20 11:33:04 -07:00
|
|
|
*
|
|
|
|
* NB: if the server didn't return any post op attributes, this
|
|
|
|
* function will force the retrieval of attributes before the next
|
|
|
|
* NFS request. Thus it should be used only for operations that
|
|
|
|
* are expected to change one or more attributes, to avoid
|
|
|
|
* unnecessary NFS requests and trips through nfs_update_inode().
|
2005-10-27 19:12:39 -07:00
|
|
|
*/
|
|
|
|
int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
|
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
|
|
|
|
2007-10-01 06:59:15 -07:00
|
|
|
spin_lock(&inode->i_lock);
|
2007-10-08 11:26:13 -07:00
|
|
|
nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
|
2007-10-08 06:24:22 -07:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
nfsi->cache_validity |= NFS_INO_INVALID_DATA;
|
2007-10-01 06:59:15 -07:00
|
|
|
spin_unlock(&inode->i_lock);
|
2007-10-08 11:26:13 -07:00
|
|
|
return nfs_refresh_inode(inode, fattr);
|
2005-10-27 19:12:39 -07:00
|
|
|
}
|
|
|
|
|
2007-09-30 12:21:24 -07:00
|
|
|
/**
|
|
|
|
* nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
|
|
|
|
* @inode - pointer to inode
|
|
|
|
* @fattr - updated attributes
|
|
|
|
*
|
|
|
|
* After an operation that has changed the inode metadata, mark the
|
|
|
|
* attribute cache as being invalid, then try to update it. Fake up
|
|
|
|
* weak cache consistency data, if none exist.
|
|
|
|
*
|
|
|
|
* This function is mainly designed to be used by the ->write_done() functions.
|
|
|
|
*/
|
|
|
|
int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
|
|
|
|
{
|
|
|
|
if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
|
|
|
|
(fattr->valid & NFS_ATTR_WCC_V4) == 0) {
|
|
|
|
fattr->pre_change_attr = NFS_I(inode)->change_attr;
|
|
|
|
fattr->valid |= NFS_ATTR_WCC_V4;
|
|
|
|
}
|
|
|
|
if ((fattr->valid & NFS_ATTR_FATTR) != 0 &&
|
|
|
|
(fattr->valid & NFS_ATTR_WCC) == 0) {
|
|
|
|
memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
|
|
|
|
memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
|
|
|
|
fattr->pre_size = inode->i_size;
|
|
|
|
fattr->valid |= NFS_ATTR_WCC;
|
|
|
|
}
|
|
|
|
return nfs_post_op_update_inode(inode, fattr);
|
|
|
|
}
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* Many nfs protocol calls return the new file attributes after
|
|
|
|
* an operation. Here we update the inode to reflect the state
|
|
|
|
* of the server's inode.
|
|
|
|
*
|
|
|
|
* This is a bit tricky because we have to make sure all dirty pages
|
|
|
|
* have been sent off to the server before calling invalidate_inode_pages.
|
|
|
|
* To make sure no other process adds more write requests while we try
|
|
|
|
* our best to flush them, we make them sleep during the attribute refresh.
|
|
|
|
*
|
|
|
|
* A very similar scenario holds for the dir cache.
|
|
|
|
*/
|
2005-12-03 13:20:07 -07:00
|
|
|
static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-06-09 06:34:19 -07:00
|
|
|
struct nfs_server *server;
|
2005-04-16 15:20:36 -07:00
|
|
|
struct nfs_inode *nfsi = NFS_I(inode);
|
2005-06-22 10:16:30 -07:00
|
|
|
loff_t cur_isize, new_isize;
|
2007-10-08 11:26:13 -07:00
|
|
|
unsigned long invalid = 0;
|
2007-02-05 15:26:28 -07:00
|
|
|
unsigned long now = jiffies;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
|
|
|
|
__FUNCTION__, inode->i_sb->s_id, inode->i_ino,
|
|
|
|
atomic_read(&inode->i_count), fattr->valid);
|
|
|
|
|
2005-11-30 16:08:55 -07:00
|
|
|
if (nfsi->fileid != fattr->fileid)
|
|
|
|
goto out_fileid;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the inode's type hasn't changed.
|
|
|
|
*/
|
2005-10-27 19:12:39 -07:00
|
|
|
if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out_changed;
|
|
|
|
|
2006-06-09 06:34:19 -07:00
|
|
|
server = NFS_SERVER(inode);
|
2007-06-05 10:26:15 -07:00
|
|
|
/* Update the fsid? */
|
|
|
|
if (S_ISDIR(inode->i_mode)
|
2006-06-09 06:34:19 -07:00
|
|
|
&& !nfs_fsid_equal(&server->fsid, &fattr->fsid))
|
|
|
|
server->fsid = fattr->fsid;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* Update the read time so we don't revalidate too often.
|
|
|
|
*/
|
2005-10-27 19:12:39 -07:00
|
|
|
nfsi->read_cache_jiffies = fattr->time_start;
|
2007-02-05 15:26:28 -07:00
|
|
|
|
2007-08-15 09:49:17 -07:00
|
|
|
nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ATIME
|
|
|
|
| NFS_INO_REVAL_PAGECACHE);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2006-01-03 01:55:40 -07:00
|
|
|
/* Do atomic weak cache consistency updates */
|
|
|
|
nfs_wcc_update_inode(inode, fattr);
|
|
|
|
|
2007-09-27 12:57:24 -07:00
|
|
|
/* More cache consistency checks */
|
|
|
|
if (!(fattr->valid & NFS_ATTR_FATTR_V4)) {
|
|
|
|
/* NFSv2/v3: Check if the mtime agrees */
|
|
|
|
if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
|
|
|
|
dprintk("NFS: mtime change on server for file %s/%ld\n",
|
|
|
|
inode->i_sb->s_id, inode->i_ino);
|
|
|
|
invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
|
2007-10-15 15:18:29 -07:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
nfs_force_lookup_revalidate(inode);
|
2007-09-27 12:57:24 -07:00
|
|
|
}
|
|
|
|
/* If ctime has changed we should definitely clear access+acl caches */
|
2007-10-01 06:56:59 -07:00
|
|
|
if (!timespec_equal(&inode->i_ctime, &fattr->ctime))
|
2007-09-27 12:57:24 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
|
|
|
|
} else if (nfsi->change_attr != fattr->change_attr) {
|
|
|
|
dprintk("NFS: change_attr change on server for file %s/%ld\n",
|
|
|
|
inode->i_sb->s_id, inode->i_ino);
|
|
|
|
invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
|
2007-10-15 15:18:29 -07:00
|
|
|
if (S_ISDIR(inode->i_mode))
|
|
|
|
nfs_force_lookup_revalidate(inode);
|
2007-09-27 12:57:24 -07:00
|
|
|
}
|
|
|
|
|
2005-06-22 10:16:30 -07:00
|
|
|
/* Check if our cached file size is stale */
|
2005-04-16 15:20:36 -07:00
|
|
|
new_isize = nfs_size_to_loff_t(fattr->size);
|
|
|
|
cur_isize = i_size_read(inode);
|
2005-06-22 10:16:30 -07:00
|
|
|
if (new_isize != cur_isize) {
|
2007-09-30 12:13:17 -07:00
|
|
|
/* Do we perhaps have any outstanding writes, or has
|
|
|
|
* the file grown beyond our last write? */
|
|
|
|
if (nfsi->npages == 0 || new_isize > cur_isize) {
|
2005-04-16 15:20:36 -07:00
|
|
|
inode->i_size = new_isize;
|
|
|
|
invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
|
|
|
|
}
|
2005-06-22 10:16:30 -07:00
|
|
|
dprintk("NFS: isize change on server for file %s/%ld\n",
|
|
|
|
inode->i_sb->s_id, inode->i_ino);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-09-27 12:57:24 -07:00
|
|
|
memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
|
|
|
|
memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
|
2005-04-16 15:20:36 -07:00
|
|
|
memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
|
2007-09-27 12:57:24 -07:00
|
|
|
nfsi->change_attr = fattr->change_attr;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) ||
|
|
|
|
inode->i_uid != fattr->uid ||
|
|
|
|
inode->i_gid != fattr->gid)
|
2005-06-22 10:16:22 -07:00
|
|
|
invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
inode->i_mode = fattr->mode;
|
|
|
|
inode->i_nlink = fattr->nlink;
|
|
|
|
inode->i_uid = fattr->uid;
|
|
|
|
inode->i_gid = fattr->gid;
|
|
|
|
|
|
|
|
if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
|
|
|
|
/*
|
|
|
|
* report the blocks in 512byte units
|
|
|
|
*/
|
|
|
|
inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
|
|
|
|
} else {
|
|
|
|
inode->i_blocks = fattr->du.nfs2.blocks;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update attrtimeo value if we're out of the unstable period */
|
|
|
|
if (invalid & NFS_INO_INVALID_ATTR) {
|
2006-03-20 11:44:14 -07:00
|
|
|
nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
|
2005-04-16 15:20:36 -07:00
|
|
|
nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
|
2007-02-05 15:26:28 -07:00
|
|
|
nfsi->attrtimeo_timestamp = now;
|
2007-10-01 15:57:50 -07:00
|
|
|
nfsi->last_updated = now;
|
|
|
|
} else {
|
|
|
|
if (!time_in_range(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
|
|
|
|
if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
|
|
|
|
nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
|
|
|
|
nfsi->attrtimeo_timestamp = now;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Avoid jiffy wraparound issues with nfsi->last_updated
|
|
|
|
*/
|
|
|
|
if (!time_in_range(nfsi->last_updated, nfsi->read_cache_jiffies, now))
|
|
|
|
nfsi->last_updated = nfsi->read_cache_jiffies;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2007-08-15 09:49:17 -07:00
|
|
|
invalid &= ~NFS_INO_INVALID_ATTR;
|
2005-04-16 15:20:36 -07:00
|
|
|
/* Don't invalidate the data if we were to blame */
|
|
|
|
if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
|
|
|
|
|| S_ISLNK(inode->i_mode)))
|
|
|
|
invalid &= ~NFS_INO_INVALID_DATA;
|
2007-07-03 13:10:55 -07:00
|
|
|
if (!nfs_have_delegation(inode, FMODE_READ) ||
|
|
|
|
(nfsi->cache_validity & NFS_INO_REVAL_FORCED))
|
2005-08-18 11:24:09 -07:00
|
|
|
nfsi->cache_validity |= invalid;
|
2007-07-03 13:10:55 -07:00
|
|
|
nfsi->cache_validity &= ~NFS_INO_REVAL_FORCED;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
out_changed:
|
|
|
|
/*
|
|
|
|
* Big trouble! The inode has become a different object.
|
|
|
|
*/
|
|
|
|
printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
|
|
|
|
__FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
|
2005-11-25 15:10:06 -07:00
|
|
|
out_err:
|
2005-04-16 15:20:36 -07:00
|
|
|
/*
|
|
|
|
* No need to worry about unhashing the dentry, as the
|
|
|
|
* lookup validation will know that the inode is bad.
|
|
|
|
* (But we fall through to invalidate the caches.)
|
|
|
|
*/
|
|
|
|
nfs_invalidate_inode(inode);
|
|
|
|
return -ESTALE;
|
2005-11-30 16:08:55 -07:00
|
|
|
|
|
|
|
out_fileid:
|
|
|
|
printk(KERN_ERR "NFS: server %s error: fileid changed\n"
|
|
|
|
"fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
|
NFS: Share NFS superblocks per-protocol per-server per-FSID
The attached patch makes NFS share superblocks between mounts from the same
server and FSID over the same protocol.
It does this by creating each superblock with a false root and returning the
real root dentry in the vfsmount presented by get_sb(). The root dentry set
starts off as an anonymous dentry if we don't already have the dentry for its
inode, otherwise it simply returns the dentry we already have.
We may thus end up with several trees of dentries in the superblock, and if at
some later point one of anonymous tree roots is discovered by normal filesystem
activity to be located in another tree within the superblock, the anonymous
root is named and materialises attached to the second tree at the appropriate
point.
Why do it this way? Why not pass an extra argument to the mount() syscall to
indicate the subpath and then pathwalk from the server root to the desired
directory? You can't guarantee this will work for two reasons:
(1) The root and intervening nodes may not be accessible to the client.
With NFS2 and NFS3, for instance, mountd is called on the server to get
the filehandle for the tip of a path. mountd won't give us handles for
anything we don't have permission to access, and so we can't set up NFS
inodes for such nodes, and so can't easily set up dentries (we'd have to
have ghost inodes or something).
With this patch we don't actually create dentries until we get handles
from the server that we can use to set up their inodes, and we don't
actually bind them into the tree until we know for sure where they go.
(2) Inaccessible symbolic links.
If we're asked to mount two exports from the server, eg:
mount warthog:/warthog/aaa/xxx /mmm
mount warthog:/warthog/bbb/yyy /nnn
We may not be able to access anything nearer the root than xxx and yyy,
but we may find out later that /mmm/www/yyy, say, is actually the same
directory as the one mounted on /nnn. What we might then find out, for
example, is that /warthog/bbb was actually a symbolic link to
/warthog/aaa/xxx/www, but we can't actually determine that by talking to
the server until /warthog is made available by NFS.
This would lead to having constructed an errneous dentry tree which we
can't easily fix. We can end up with a dentry marked as a directory when
it should actually be a symlink, or we could end up with an apparently
hardlinked directory.
With this patch we need not make assumptions about the type of a dentry
for which we can't retrieve information, nor need we assume we know its
place in the grand scheme of things until we actually see that place.
This patch reduces the possibility of aliasing in the inode and page caches for
inodes that may be accessed by more than one NFS export. It also reduces the
number of superblocks required for NFS where there are many NFS exports being
used from a server (home directory server + autofs for example).
This in turn makes it simpler to do local caching of network filesystems, as it
can then be guaranteed that there won't be links from multiple inodes in
separate superblocks to the same cache file.
Obviously, cache aliasing between different levels of NFS protocol could still
be a problem, but at least that gives us another key to use when indexing the
cache.
This patch makes the following changes:
(1) The server record construction/destruction has been abstracted out into
its own set of functions to make things easier to get right. These have
been moved into fs/nfs/client.c.
All the code in fs/nfs/client.c has to do with the management of
connections to servers, and doesn't touch superblocks in any way; the
remaining code in fs/nfs/super.c has to do with VFS superblock management.
(2) The sequence of events undertaken by NFS mount is now reordered:
(a) A volume representation (struct nfs_server) is allocated.
(b) A server representation (struct nfs_client) is acquired. This may be
allocated or shared, and is keyed on server address, port and NFS
version.
(c) If allocated, the client representation is initialised. The state
member variable of nfs_client is used to prevent a race during
initialisation from two mounts.
(d) For NFS4 a simple pathwalk is performed, walking from FH to FH to find
the root filehandle for the mount (fs/nfs/getroot.c). For NFS2/3 we
are given the root FH in advance.
(e) The volume FSID is probed for on the root FH.
(f) The volume representation is initialised from the FSINFO record
retrieved on the root FH.
(g) sget() is called to acquire a superblock. This may be allocated or
shared, keyed on client pointer and FSID.
(h) If allocated, the superblock is initialised.
(i) If the superblock is shared, then the new nfs_server record is
discarded.
(j) The root dentry for this mount is looked up from the root FH.
(k) The root dentry for this mount is assigned to the vfsmount.
(3) nfs_readdir_lookup() creates dentries for each of the entries readdir()
returns; this function now attaches disconnected trees from alternate
roots that happen to be discovered attached to a directory being read (in
the same way nfs_lookup() is made to do for lookup ops).
The new d_materialise_unique() function is now used to do this, thus
permitting the whole thing to be done under one set of locks, and thus
avoiding any race between mount and lookup operations on the same
directory.
(4) The client management code uses a new debug facility: NFSDBG_CLIENT which
is set by echoing 1024 to /proc/net/sunrpc/nfs_debug.
(5) Clone mounts are now called xdev mounts.
(6) Use the dentry passed to the statfs() op as the handle for retrieving fs
statistics rather than the root dentry of the superblock (which is now a
dummy).
Signed-Off-By: David Howells <dhowells@redhat.com>
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2006-08-22 17:06:13 -07:00
|
|
|
NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
|
2005-11-30 16:08:55 -07:00
|
|
|
(long long)nfsi->fileid, (long long)fattr->fileid);
|
|
|
|
goto out_err;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2006-06-09 06:34:19 -07:00
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
#ifdef CONFIG_NFS_V4
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clean out any remaining NFSv4 state that might be left over due
|
|
|
|
* to open() calls that passed nfs_atomic_lookup, but failed to call
|
|
|
|
* nfs_open().
|
|
|
|
*/
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
void nfs4_clear_inode(struct inode *inode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
/* If we are holding a delegation, return it! */
|
2008-01-24 16:14:34 -07:00
|
|
|
nfs_inode_return_delegation_noreclaim(inode);
|
2005-04-16 15:20:36 -07:00
|
|
|
/* First call standard NFS clear_inode() code */
|
|
|
|
nfs_clear_inode(inode);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
struct inode *nfs_alloc_inode(struct super_block *sb)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi;
|
2006-12-06 21:33:17 -07:00
|
|
|
nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (!nfsi)
|
|
|
|
return NULL;
|
2005-08-18 11:24:09 -07:00
|
|
|
nfsi->flags = 0UL;
|
|
|
|
nfsi->cache_validity = 0UL;
|
2005-06-22 10:16:27 -07:00
|
|
|
#ifdef CONFIG_NFS_V3_ACL
|
|
|
|
nfsi->acl_access = ERR_PTR(-EAGAIN);
|
|
|
|
nfsi->acl_default = ERR_PTR(-EAGAIN);
|
|
|
|
#endif
|
2005-06-22 10:16:23 -07:00
|
|
|
#ifdef CONFIG_NFS_V4
|
|
|
|
nfsi->nfs4_acl = NULL;
|
|
|
|
#endif /* CONFIG_NFS_V4 */
|
2005-04-16 15:20:36 -07:00
|
|
|
return &nfsi->vfs_inode;
|
|
|
|
}
|
|
|
|
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
void nfs_destroy_inode(struct inode *inode)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
|
|
|
|
}
|
|
|
|
|
2006-06-25 02:41:26 -07:00
|
|
|
static inline void nfs4_init_once(struct nfs_inode *nfsi)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NFS_V4
|
|
|
|
INIT_LIST_HEAD(&nfsi->open_states);
|
|
|
|
nfsi->delegation = NULL;
|
|
|
|
nfsi->delegation_state = 0;
|
|
|
|
init_rwsem(&nfsi->rwsem);
|
|
|
|
#endif
|
|
|
|
}
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
|
2007-10-16 23:25:51 -07:00
|
|
|
static void init_once(struct kmem_cache * cachep, void *foo)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct nfs_inode *nfsi = (struct nfs_inode *) foo;
|
|
|
|
|
2007-05-16 22:10:57 -07:00
|
|
|
inode_init_once(&nfsi->vfs_inode);
|
|
|
|
INIT_LIST_HEAD(&nfsi->open_files);
|
|
|
|
INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
|
|
|
|
INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
|
|
|
|
INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
|
|
|
|
nfsi->ncommit = 0;
|
|
|
|
nfsi->npages = 0;
|
2007-10-15 15:17:53 -07:00
|
|
|
atomic_set(&nfsi->silly_count, 1);
|
|
|
|
INIT_HLIST_HEAD(&nfsi->silly_list);
|
|
|
|
init_waitqueue_head(&nfsi->waitqueue);
|
2007-05-16 22:10:57 -07:00
|
|
|
nfs4_init_once(nfsi);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2007-07-19 18:11:58 -07:00
|
|
|
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
static int __init nfs_init_inodecache(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
|
|
|
|
sizeof(struct nfs_inode),
|
2006-03-24 04:16:06 -07:00
|
|
|
0, (SLAB_RECLAIM_ACCOUNT|
|
|
|
|
SLAB_MEM_SPREAD),
|
2007-07-19 18:11:58 -07:00
|
|
|
init_once);
|
2005-04-16 15:20:36 -07:00
|
|
|
if (nfs_inode_cachep == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-27 12:59:15 -07:00
|
|
|
static void nfs_destroy_inodecache(void)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
2006-09-27 01:49:40 -07:00
|
|
|
kmem_cache_destroy(nfs_inode_cachep);
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize NFS
|
|
|
|
*/
|
|
|
|
static int __init init_nfs_fs(void)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2006-08-22 17:06:13 -07:00
|
|
|
err = nfs_fs_proc_init();
|
|
|
|
if (err)
|
|
|
|
goto out5;
|
|
|
|
|
2005-04-16 15:20:36 -07:00
|
|
|
err = nfs_init_nfspagecache();
|
|
|
|
if (err)
|
|
|
|
goto out4;
|
|
|
|
|
|
|
|
err = nfs_init_inodecache();
|
|
|
|
if (err)
|
|
|
|
goto out3;
|
|
|
|
|
|
|
|
err = nfs_init_readpagecache();
|
|
|
|
if (err)
|
|
|
|
goto out2;
|
|
|
|
|
|
|
|
err = nfs_init_writepagecache();
|
|
|
|
if (err)
|
|
|
|
goto out1;
|
|
|
|
|
|
|
|
err = nfs_init_directcache();
|
|
|
|
if (err)
|
|
|
|
goto out0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
rpc_proc_register(&nfs_rpcstat);
|
|
|
|
#endif
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
if ((err = register_nfs_fs()) != 0)
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out;
|
|
|
|
return 0;
|
|
|
|
out:
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
rpc_proc_unregister("nfs");
|
|
|
|
#endif
|
|
|
|
nfs_destroy_directcache();
|
2005-11-30 16:08:19 -07:00
|
|
|
out0:
|
|
|
|
nfs_destroy_writepagecache();
|
2005-04-16 15:20:36 -07:00
|
|
|
out1:
|
|
|
|
nfs_destroy_readpagecache();
|
|
|
|
out2:
|
|
|
|
nfs_destroy_inodecache();
|
|
|
|
out3:
|
|
|
|
nfs_destroy_nfspagecache();
|
|
|
|
out4:
|
2006-08-22 17:06:13 -07:00
|
|
|
nfs_fs_proc_exit();
|
|
|
|
out5:
|
2005-04-16 15:20:36 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit exit_nfs_fs(void)
|
|
|
|
{
|
|
|
|
nfs_destroy_directcache();
|
|
|
|
nfs_destroy_writepagecache();
|
|
|
|
nfs_destroy_readpagecache();
|
|
|
|
nfs_destroy_inodecache();
|
|
|
|
nfs_destroy_nfspagecache();
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
rpc_proc_unregister("nfs");
|
|
|
|
#endif
|
NFS: Split fs/nfs/inode.c
As fs/nfs/inode.c is rather large, heterogenous and unwieldy, the attached
patch splits it up into a number of files:
(*) fs/nfs/inode.c
Strictly inode specific functions.
(*) fs/nfs/super.c
Superblock management functions for NFS and NFS4, normal access, clones
and referrals. The NFS4 superblock functions _could_ move out into a
separate conditionally compiled file, but it's probably not worth it as
there're so many common bits.
(*) fs/nfs/namespace.c
Some namespace-specific functions have been moved here.
(*) fs/nfs/nfs4namespace.c
NFS4-specific namespace functions (this could be merged into the previous
file). This file is conditionally compiled.
(*) fs/nfs/internal.h
Inter-file declarations, plus a few simple utility functions moved from
fs/nfs/inode.c.
Additionally, all the in-.c-file externs have been moved here, and those
files they were moved from now includes this file.
For the most part, the functions have not been changed, only some multiplexor
functions have changed significantly.
I've also:
(*) Added some extra banner comments above some functions.
(*) Rearranged the function order within the files to be more logical and
better grouped (IMO), though someone may prefer a different order.
(*) Reduced the number of #ifdefs in .c files.
(*) Added missing __init and __exit directives.
Signed-Off-By: David Howells <dhowells@redhat.com>
2006-06-09 06:34:33 -07:00
|
|
|
unregister_nfs_fs();
|
2006-08-22 17:06:13 -07:00
|
|
|
nfs_fs_proc_exit();
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Not quite true; I just maintain it */
|
|
|
|
MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
|
|
|
|
MODULE_LICENSE("GPL");
|
2007-10-09 09:01:04 -07:00
|
|
|
module_param(enable_ino64, bool, 0644);
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
module_init(init_nfs_fs)
|
|
|
|
module_exit(exit_nfs_fs)
|