Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a1bf4c7d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'nfs-for-4.17-1' of git://git.linux-nfs.org/projects/anna/linux-nfs 

Pull NFS client updates from Anna Schumaker:
 "Stable bugfixes:
   - xprtrdma: Fix corner cases when handling device removal # v4.12+
   - xprtrdma: Fix latency regression on NUMA NFS/RDMA clients # v4.15+

  Features:
   - New sunrpc tracepoint for RPC pings
   - Finer grained NFSv4 attribute checking
   - Don't unnecessarily return NFS v4 delegations

  Other bugfixes and cleanups:
   - Several other small NFSoRDMA cleanups
   - Improvements to the sunrpc RTT measurements
   - A few sunrpc tracepoint cleanups
   - Various fixes for NFS v4 lock notifications
   - Various sunrpc and NFS v4 XDR encoding cleanups
   - Switch to the ida_simple API
   - Fix NFSv4.1 exclusive create
   - Forget acl cache after setattr operation
   - Don't advance the nfs_entry readdir cookie if xdr decoding fails"

* tag 'nfs-for-4.17-1' of git://git.linux-nfs.org/projects/anna/linux-nfs: (47 commits)
  NFS: advance nfs_entry cookie only after decoding completes successfully
  NFSv3/acl: forget acl cache after setattr
  NFSv4.1: Fix exclusive create
  NFSv4: Declare the size up to date after it was set.
  nfs: Use ida_simple API
  NFSv4: Fix the nfs_inode_set_delegation() arguments
  NFSv4: Clean up CB_GETATTR encoding
  NFSv4: Don't ask for attributes when ACCESS is protected by a delegation
  NFSv4: Add a helper to encode/decode struct timespec
  NFSv4: Clean up encode_attrs
  NFSv4; Clean up XDR encoding of type bitmap4
  NFSv4: Allow GFP_NOIO sleeps in decode_attr_owner/decode_attr_group
  SUNRPC: Add a helper for encoding opaque data inline
  SUNRPC: Add helpers for decoding opaque and string types
  NFSv4: Ignore change attribute invalidations if we hold a delegation
  NFS: More fine grained attribute tracking
  NFS: Don't force unnecessary cache invalidation in nfs_update_inode()
  NFS: Don't redirty the attribute cache in nfs_wcc_update_inode()
  NFS: Don't force a revalidation of all attributes if change is missing
  NFS: Convert NFS_INO_INVALID flags to unsigned long
  ...
parents 7214dd4e 98de9ce6

fs/nfs/callback_xdr.c

+8 −29
Original line number Diff line number Diff line
@@ -535,35 +535,10 @@ static __be32 encode_string(struct xdr_stream *xdr, unsigned int len, const char 
	return 0;

}



#define CB_SUPPORTED_ATTR0 (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE)

#define CB_SUPPORTED_ATTR1 (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY)

static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, __be32 **savep)

static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, size_t sz)

{

	__be32 bm[2];

	__be32 *p;



	bm[0] = htonl(bitmap[0] & CB_SUPPORTED_ATTR0);

	bm[1] = htonl(bitmap[1] & CB_SUPPORTED_ATTR1);

	if (bm[1] != 0) {

		p = xdr_reserve_space(xdr, 16);

		if (unlikely(p == NULL))

			return htonl(NFS4ERR_RESOURCE);

		*p++ = htonl(2);

		*p++ = bm[0];

		*p++ = bm[1];

	} else if (bm[0] != 0) {

		p = xdr_reserve_space(xdr, 12);

		if (unlikely(p == NULL))

			return htonl(NFS4ERR_RESOURCE);

		*p++ = htonl(1);

		*p++ = bm[0];

	} else {

		p = xdr_reserve_space(xdr, 8);

		if (unlikely(p == NULL))

			return htonl(NFS4ERR_RESOURCE);

		*p++ = htonl(0);

	}

	*savep = p;

	if (xdr_stream_encode_uint32_array(xdr, bitmap, sz) < 0)

		return cpu_to_be32(NFS4ERR_RESOURCE);

	return 0;

}
@@ -656,9 +631,13 @@ static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr, 
	

	if (unlikely(status != 0))

		goto out;

	status = encode_attr_bitmap(xdr, res->bitmap, &savep);

	status = encode_attr_bitmap(xdr, res->bitmap, ARRAY_SIZE(res->bitmap));

	if (unlikely(status != 0))

		goto out;

	status = cpu_to_be32(NFS4ERR_RESOURCE);

	savep = xdr_reserve_space(xdr, sizeof(*savep));

	if (unlikely(!savep))

		goto out;

	status = encode_attr_change(xdr, res->bitmap, res->change_attr);

	if (unlikely(status != 0))

		goto out;

fs/nfs/delegation.c

+39 −13
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include <linux/nfs_xdr.h>



#include "nfs4_fs.h"

#include "nfs4session.h"

#include "delegation.h"

#include "internal.h"

#include "nfs4trace.h"
@@ -171,11 +172,15 @@ static int nfs_delegation_claim_opens(struct inode *inode, 
 * nfs_inode_reclaim_delegation - process a delegation reclaim request

 * @inode: inode to process

 * @cred: credential to use for request

 * @res: new delegation state from server

 * @type: delegation type

 * @stateid: delegation stateid

 * @pagemod_limit: write delegation "space_limit"

 *

 */

void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,

				  struct nfs_openres *res)

				  fmode_t type,

				  const nfs4_stateid *stateid,

				  unsigned long pagemod_limit)

{

	struct nfs_delegation *delegation;

	struct rpc_cred *oldcred = NULL;
@@ -185,9 +190,9 @@ void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, 
	if (delegation != NULL) {

		spin_lock(&delegation->lock);

		if (delegation->inode != NULL) {

			nfs4_stateid_copy(&delegation->stateid, &res->delegation);

			delegation->type = res->delegation_type;

			delegation->pagemod_limit = res->pagemod_limit;

			nfs4_stateid_copy(&delegation->stateid, stateid);

			delegation->type = type;

			delegation->pagemod_limit = pagemod_limit;

			oldcred = delegation->cred;

			delegation->cred = get_rpccred(cred);

			clear_bit(NFS_DELEGATION_NEED_RECLAIM,
@@ -195,14 +200,14 @@ void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, 
			spin_unlock(&delegation->lock);

			rcu_read_unlock();

			put_rpccred(oldcred);

			trace_nfs4_reclaim_delegation(inode, res->delegation_type);

			trace_nfs4_reclaim_delegation(inode, type);

			return;

		}

		/* We appear to have raced with a delegation return. */

		spin_unlock(&delegation->lock);

	}

	rcu_read_unlock();

	nfs_inode_set_delegation(inode, cred, res);

	nfs_inode_set_delegation(inode, cred, type, stateid, pagemod_limit);

}



static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
@@ -329,11 +334,16 @@ nfs_update_inplace_delegation(struct nfs_delegation *delegation, 
 * nfs_inode_set_delegation - set up a delegation on an inode

 * @inode: inode to which delegation applies

 * @cred: cred to use for subsequent delegation processing

 * @res: new delegation state from server

 * @type: delegation type

 * @stateid: delegation stateid

 * @pagemod_limit: write delegation "space_limit"

 *

 * Returns zero on success, or a negative errno value.

 */

int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)

int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred,

				  fmode_t type,

				  const nfs4_stateid *stateid,

				  unsigned long pagemod_limit)

{

	struct nfs_server *server = NFS_SERVER(inode);

	struct nfs_client *clp = server->nfs_client;
@@ -345,9 +355,9 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct 
	delegation = kmalloc(sizeof(*delegation), GFP_NOFS);

	if (delegation == NULL)

		return -ENOMEM;

	nfs4_stateid_copy(&delegation->stateid, &res->delegation);

	delegation->type = res->delegation_type;

	delegation->pagemod_limit = res->pagemod_limit;

	nfs4_stateid_copy(&delegation->stateid, stateid);

	delegation->type = type;

	delegation->pagemod_limit = pagemod_limit;

	delegation->change_attr = inode_peek_iversion_raw(inode);

	delegation->cred = get_rpccred(cred);

	delegation->inode = inode;
@@ -392,7 +402,7 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct 
	rcu_assign_pointer(nfsi->delegation, delegation);

	delegation = NULL;



	trace_nfs4_set_delegation(inode, res->delegation_type);

	trace_nfs4_set_delegation(inode, type);



out:

	spin_unlock(&clp->cl_lock);
@@ -547,6 +557,22 @@ int nfs4_inode_return_delegation(struct inode *inode) 
	return err;

}



/**

 * nfs4_inode_make_writeable

 * @inode: pointer to inode

 *

 * Make the inode writeable by returning the delegation if necessary

 *

 * Returns zero on success, or a negative errno value.

 */

int nfs4_inode_make_writeable(struct inode *inode)

{

	if (!nfs4_has_session(NFS_SERVER(inode)->nfs_client) ||

	    !nfs4_check_delegation(inode, FMODE_WRITE))

		return nfs4_inode_return_delegation(inode);

	return 0;

}



static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,

		struct nfs_delegation *delegation)

{

fs/nfs/delegation.h

+5 −2
Original line number Diff line number Diff line
@@ -36,8 +36,10 @@ enum { 
	NFS_DELEGATION_TEST_EXPIRED,

};



int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res);

void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res);

int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred,

		fmode_t type, const nfs4_stateid *stateid, unsigned long pagemod_limit);

void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,

		fmode_t type, const nfs4_stateid *stateid, unsigned long pagemod_limit);

int nfs4_inode_return_delegation(struct inode *inode);

int nfs_async_inode_return_delegation(struct inode *inode, const nfs4_stateid *stateid);

void nfs_inode_return_delegation_noreclaim(struct inode *inode);
@@ -70,6 +72,7 @@ int nfs4_check_delegation(struct inode *inode, fmode_t flags); 
bool nfs4_delegation_flush_on_close(const struct inode *inode);

void nfs_inode_find_delegation_state_and_recover(struct inode *inode,

		const nfs4_stateid *stateid);

int nfs4_inode_make_writeable(struct inode *inode);



#endif

fs/nfs/dir.c

+5 −10
Original line number Diff line number Diff line
@@ -1272,7 +1272,9 @@ static void nfs_drop_nlink(struct inode *inode) 
	/* drop the inode if we're reasonably sure this is the last link */

	if (inode->i_nlink == 1)

		clear_nlink(inode);

	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;

	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE

		| NFS_INO_INVALID_CTIME

		| NFS_INO_INVALID_OTHER;

	spin_unlock(&inode->i_lock);

}
@@ -1798,12 +1800,11 @@ static int nfs_safe_remove(struct dentry *dentry) 


	trace_nfs_remove_enter(dir, dentry);

	if (inode != NULL) {

		NFS_PROTO(inode)->return_delegation(inode);

		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);

		error = NFS_PROTO(dir)->remove(dir, dentry);

		if (error == 0)

			nfs_drop_nlink(inode);

	} else

		error = NFS_PROTO(dir)->remove(dir, &dentry->d_name);

		error = NFS_PROTO(dir)->remove(dir, dentry);

	if (error == -ENOENT)

		nfs_dentry_handle_enoent(dentry);

	trace_nfs_remove_exit(dir, dentry, error);
@@ -1932,8 +1933,6 @@ nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 
		old_dentry, dentry);



	trace_nfs_link_enter(inode, dir, dentry);

	NFS_PROTO(inode)->return_delegation(inode);



	d_drop(dentry);

	error = NFS_PROTO(dir)->link(inode, dir, &dentry->d_name);

	if (error == 0) {
@@ -2023,10 +2022,6 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
		}

	}



	NFS_PROTO(old_inode)->return_delegation(old_inode);

	if (new_inode != NULL)

		NFS_PROTO(new_inode)->return_delegation(new_inode);



	task = nfs_async_rename(old_dir, new_dir, old_dentry, new_dentry, NULL);

	if (IS_ERR(task)) {

		error = PTR_ERR(task);

fs/nfs/inode.c

+76 −62
Original line number Diff line number Diff line
@@ -195,7 +195,10 @@ bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags) 
static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)

{

	struct nfs_inode *nfsi = NFS_I(inode);

	bool have_delegation = nfs_have_delegated_attributes(inode);



	if (have_delegation)

		flags &= ~(NFS_INO_INVALID_CHANGE|NFS_INO_REVAL_PAGECACHE);

	if (inode->i_mapping->nrpages == 0)

		flags &= ~NFS_INO_INVALID_DATA;

	nfsi->cache_validity |= flags;
@@ -447,7 +450,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st 
		inode->i_mode = fattr->mode;

		if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0

				&& nfs_server_capable(inode, NFS_CAP_MODE))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);

		/* Why so? Because we want revalidate for devices/FIFOs, and

		 * that's precisely what we have in nfs_file_inode_operations.

		 */
@@ -493,37 +496,35 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st 
		if (fattr->valid & NFS_ATTR_FATTR_ATIME)

			inode->i_atime = fattr->atime;

		else if (nfs_server_capable(inode, NFS_CAP_ATIME))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);

		if (fattr->valid & NFS_ATTR_FATTR_MTIME)

			inode->i_mtime = fattr->mtime;

		else if (nfs_server_capable(inode, NFS_CAP_MTIME))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);

		if (fattr->valid & NFS_ATTR_FATTR_CTIME)

			inode->i_ctime = fattr->ctime;

		else if (nfs_server_capable(inode, NFS_CAP_CTIME))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME);

		if (fattr->valid & NFS_ATTR_FATTR_CHANGE)

			inode_set_iversion_raw(inode, fattr->change_attr);

		else

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR

				| NFS_INO_REVAL_PAGECACHE);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);

		if (fattr->valid & NFS_ATTR_FATTR_SIZE)

			inode->i_size = nfs_size_to_loff_t(fattr->size);

		else

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR

				| NFS_INO_REVAL_PAGECACHE);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE);

		if (fattr->valid & NFS_ATTR_FATTR_NLINK)

			set_nlink(inode, fattr->nlink);

		else if (nfs_server_capable(inode, NFS_CAP_NLINK))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);

		if (fattr->valid & NFS_ATTR_FATTR_OWNER)

			inode->i_uid = fattr->uid;

		else if (nfs_server_capable(inode, NFS_CAP_OWNER))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);

		if (fattr->valid & NFS_ATTR_FATTR_GROUP)

			inode->i_gid = fattr->gid;

		else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);

		if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)

			inode->i_blocks = fattr->du.nfs2.blocks;

		if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
@@ -608,11 +609,6 @@ nfs_setattr(struct dentry *dentry, struct iattr *attr) 
		goto out;

	}



	/*

	 * Return any delegations if we're going to change ACLs

	 */

	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)

		NFS_PROTO(inode)->return_delegation(inode);

	error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);

	if (error == 0)

		error = nfs_refresh_inode(inode, fattr);
@@ -645,6 +641,7 @@ static int nfs_vmtruncate(struct inode * inode, loff_t offset) 
	/* Optimisation */

	if (offset == 0)

		NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA;

	NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;



	spin_unlock(&inode->i_lock);

	truncate_pagecache(inode, offset);
@@ -657,6 +654,7 @@ static int nfs_vmtruncate(struct inode * inode, loff_t offset) 
 * nfs_setattr_update_inode - Update inode metadata after a setattr call.

 * @inode: pointer to struct inode

 * @attr: pointer to struct iattr

 * @fattr: pointer to struct nfs_fattr

 *

 * Note: we do this in the *proc.c in order to ensure that

 *       it works for things like exclusive creates too.
@@ -669,6 +667,8 @@ void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr, 


	spin_lock(&inode->i_lock);

	NFS_I(inode)->attr_gencount = fattr->gencount;

	nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE

			| NFS_INO_INVALID_CTIME);

	if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {

		if ((attr->ia_valid & ATTR_MODE) != 0) {

			int mode = attr->ia_mode & S_IALLUGO;
@@ -683,13 +683,12 @@ void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr, 
				| NFS_INO_INVALID_ACL);

	}

	if ((attr->ia_valid & ATTR_SIZE) != 0) {

		nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);

		nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);

		nfs_vmtruncate(inode, attr->ia_size);

	}

	if (fattr->valid)

		nfs_update_inode(inode, fattr);

	else

		NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;

	spin_unlock(&inode->i_lock);

}

EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
@@ -1303,24 +1302,20 @@ static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi) 
	return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi);

}



static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)

static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)

{

	unsigned long ret = 0;



	if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)

			&& (fattr->valid & NFS_ATTR_FATTR_CHANGE)

			&& inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {

		inode_set_iversion_raw(inode, fattr->change_attr);

		if (S_ISDIR(inode->i_mode))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);

		ret |= NFS_INO_INVALID_ATTR;

	}

	/* If we have atomic WCC data, we may update some attributes */

	if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)

			&& (fattr->valid & NFS_ATTR_FATTR_CTIME)

			&& timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {

		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));

		ret |= NFS_INO_INVALID_ATTR;

	}



	if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
@@ -1329,17 +1324,13 @@ static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr 
		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));

		if (S_ISDIR(inode->i_mode))

			nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);

		ret |= NFS_INO_INVALID_ATTR;

	}

	if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)

			&& (fattr->valid & NFS_ATTR_FATTR_SIZE)

			&& i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)

			&& !nfs_have_writebacks(inode)) {

		i_size_write(inode, nfs_size_to_loff_t(fattr->size));

		ret |= NFS_INO_INVALID_ATTR;

	}



	return ret;

}



/**
@@ -1369,33 +1360,41 @@ static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fat 
	if (!nfs_file_has_buffered_writers(nfsi)) {

		/* Verify a few of the more important attributes */

		if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))

			invalid |= NFS_INO_INVALID_ATTR | NFS_INO_REVAL_PAGECACHE;

			invalid |= NFS_INO_INVALID_CHANGE

				| NFS_INO_REVAL_PAGECACHE;



		if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))

			invalid |= NFS_INO_INVALID_ATTR;

			invalid |= NFS_INO_INVALID_MTIME;



		if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec_equal(&inode->i_ctime, &fattr->ctime))

			invalid |= NFS_INO_INVALID_ATTR;

			invalid |= NFS_INO_INVALID_CTIME;



		if (fattr->valid & NFS_ATTR_FATTR_SIZE) {

			cur_size = i_size_read(inode);

			new_isize = nfs_size_to_loff_t(fattr->size);

			if (cur_size != new_isize)

				invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;

				invalid |= NFS_INO_INVALID_SIZE

					| NFS_INO_REVAL_PAGECACHE;

		}

	}



	/* Have any file permissions changed? */

	if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))

		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;

		invalid |= NFS_INO_INVALID_ACCESS

			| NFS_INO_INVALID_ACL

			| NFS_INO_INVALID_OTHER;

	if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))

		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;

		invalid |= NFS_INO_INVALID_ACCESS

			| NFS_INO_INVALID_ACL

			| NFS_INO_INVALID_OTHER;

	if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))

		invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;

		invalid |= NFS_INO_INVALID_ACCESS

			| NFS_INO_INVALID_ACL

			| NFS_INO_INVALID_OTHER;



	/* Has the link count changed? */

	if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)

		invalid |= NFS_INO_INVALID_ATTR;

		invalid |= NFS_INO_INVALID_OTHER;



	if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))

		invalid |= NFS_INO_INVALID_ATIME;
@@ -1597,10 +1596,9 @@ int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr) 
}

EXPORT_SYMBOL_GPL(nfs_refresh_inode);



static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)

static int nfs_post_op_update_inode_locked(struct inode *inode,

		struct nfs_fattr *fattr, unsigned int invalid)

{

	unsigned long invalid = NFS_INO_INVALID_ATTR;



	if (S_ISDIR(inode->i_mode))

		invalid |= NFS_INO_INVALID_DATA;

	nfs_set_cache_invalid(inode, invalid);
@@ -1629,7 +1627,9 @@ int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr) 


	spin_lock(&inode->i_lock);

	nfs_fattr_set_barrier(fattr);

	status = nfs_post_op_update_inode_locked(inode, fattr);

	status = nfs_post_op_update_inode_locked(inode, fattr,

			NFS_INO_INVALID_CHANGE

			| NFS_INO_INVALID_CTIME);

	spin_unlock(&inode->i_lock);



	return status;
@@ -1681,7 +1681,10 @@ int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fa 
		fattr->valid |= NFS_ATTR_FATTR_PRESIZE;

	}

out_noforce:

	status = nfs_post_op_update_inode_locked(inode, fattr);

	status = nfs_post_op_update_inode_locked(inode, fattr,

			NFS_INO_INVALID_CHANGE

			| NFS_INO_INVALID_CTIME

			| NFS_INO_INVALID_MTIME);

	return status;

}
@@ -1789,7 +1792,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
			| NFS_INO_REVAL_PAGECACHE);



	/* Do atomic weak cache consistency updates */

	invalid |= nfs_wcc_update_inode(inode, fattr);

	nfs_wcc_update_inode(inode, fattr);



	if (pnfs_layoutcommit_outstanding(inode)) {

		nfsi->cache_validity |= save_cache_validity & NFS_INO_INVALID_ATTR;
@@ -1803,17 +1806,25 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
					inode->i_sb->s_id, inode->i_ino);

			/* Could it be a race with writeback? */

			if (!have_writers) {

				invalid |= NFS_INO_INVALID_ATTR

				invalid |= NFS_INO_INVALID_CHANGE

					| NFS_INO_INVALID_DATA

					| NFS_INO_INVALID_ACCESS

					| NFS_INO_INVALID_ACL;

				/* Force revalidate of all attributes */

				save_cache_validity |= NFS_INO_INVALID_CTIME

					| NFS_INO_INVALID_MTIME

					| NFS_INO_INVALID_SIZE

					| NFS_INO_INVALID_OTHER;

				if (S_ISDIR(inode->i_mode))

					nfs_force_lookup_revalidate(inode);

			}

			inode_set_iversion_raw(inode, fattr->change_attr);

		}

	} else {

		nfsi->cache_validity |= save_cache_validity;

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_CHANGE

				| NFS_INO_REVAL_PAGECACHE

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}
@@ -1821,7 +1832,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
		memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));

	} else if (server->caps & NFS_CAP_MTIME) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				(NFS_INO_INVALID_MTIME

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}
@@ -1830,7 +1841,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
		memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));

	} else if (server->caps & NFS_CAP_CTIME) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				(NFS_INO_INVALID_CTIME

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}
@@ -1845,7 +1856,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
			if (!nfs_have_writebacks(inode) || new_isize > cur_isize) {

				i_size_write(inode, new_isize);

				if (!have_writers)

					invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;

					invalid |= NFS_INO_INVALID_DATA;

			}

			dprintk("NFS: isize change on server for file %s/%ld "

					"(%Ld to %Ld)\n",
@@ -1856,7 +1867,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
		}

	} else {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				(NFS_INO_INVALID_SIZE

				| NFS_INO_REVAL_PAGECACHE

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;
@@ -1877,55 +1888,61 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
			umode_t newmode = inode->i_mode & S_IFMT;

			newmode |= fattr->mode & S_IALLUGO;

			inode->i_mode = newmode;

			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;

			invalid |= NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_INVALID_OTHER;

		}

	} else if (server->caps & NFS_CAP_MODE) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_INVALID_ACCESS

				(NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_INVALID_OTHER

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_OWNER) {

		if (!uid_eq(inode->i_uid, fattr->uid)) {

			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;

			invalid |= NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_INVALID_OTHER;

			inode->i_uid = fattr->uid;

		}

	} else if (server->caps & NFS_CAP_OWNER) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_INVALID_ACCESS

				(NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_INVALID_OTHER

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_GROUP) {

		if (!gid_eq(inode->i_gid, fattr->gid)) {

			invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;

			invalid |= NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_INVALID_OTHER;

			inode->i_gid = fattr->gid;

		}

	} else if (server->caps & NFS_CAP_OWNER_GROUP) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				| NFS_INO_INVALID_ACCESS

				(NFS_INO_INVALID_ACCESS

				| NFS_INO_INVALID_ACL

				| NFS_INO_INVALID_OTHER

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}



	if (fattr->valid & NFS_ATTR_FATTR_NLINK) {

		if (inode->i_nlink != fattr->nlink) {

			invalid |= NFS_INO_INVALID_ATTR;

			invalid |= NFS_INO_INVALID_OTHER;

			if (S_ISDIR(inode->i_mode))

				invalid |= NFS_INO_INVALID_DATA;

			set_nlink(inode, fattr->nlink);

		}

	} else if (server->caps & NFS_CAP_NLINK) {

		nfsi->cache_validity |= save_cache_validity &

				(NFS_INO_INVALID_ATTR

				(NFS_INO_INVALID_OTHER

				| NFS_INO_REVAL_FORCED);

		cache_revalidated = false;

	}
@@ -1942,6 +1959,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 


	/* Update attrtimeo value if we're out of the unstable period */

	if (invalid & NFS_INO_INVALID_ATTR) {

		invalid &= ~NFS_INO_INVALID_ATTR;

		nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);

		nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);

		nfsi->attrtimeo_timestamp = now;
@@ -1962,10 +1980,6 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr) 
			nfsi->attr_gencount = fattr->gencount;

	}



	/* Don't declare attrcache up to date if there were no attrs! */

	if (cache_revalidated)

		invalid &= ~NFS_INO_INVALID_ATTR;



	/* 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)))