Merge tag 'nfs-for-5.6-2' of git://git.linux-nfs.org/projects/anna/linux-nfs (829e6944) · Commits · 戴 / test

fs/nfs/delegation.c

+40 −10

Original line number	Diff line number	Diff line
		@@ -42,13 +42,27 @@ static void nfs_mark_delegation_revoked(struct nfs_delegation *delegation)
		if (!test_and_set_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
		delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
		atomic_long_dec(&nfs_active_delegations);
		if (!test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
		nfs_clear_verifier_delegated(delegation->inode);
		}
		}

		static struct nfs_delegation nfs_get_delegation(struct nfs_delegation delegation)
		{
		refcount_inc(&delegation->refcount);
		return delegation;
		}

		static void nfs_put_delegation(struct nfs_delegation *delegation)
		{
		if (refcount_dec_and_test(&delegation->refcount))
		__nfs_free_delegation(delegation);
		}

		static void nfs_free_delegation(struct nfs_delegation *delegation)
		{
		nfs_mark_delegation_revoked(delegation);
		__nfs_free_delegation(delegation);
		nfs_put_delegation(delegation);
		}

		/**
		@@ -241,13 +255,18 @@ void nfs_inode_reclaim_delegation(struct inode inode, const struct cred cred,

		static int nfs_do_return_delegation(struct inode inode, struct nfs_delegation delegation, int issync)
		{
		const struct cred *cred;
		int res = 0;

		if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
		res = nfs4_proc_delegreturn(inode,
		delegation->cred,
		if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
		spin_lock(&delegation->lock);
		cred = get_cred(delegation->cred);
		spin_unlock(&delegation->lock);
		res = nfs4_proc_delegreturn(inode, cred,
		&delegation->stateid,
		issync);
		put_cred(cred);
		}
		return res;
		}

		@@ -273,9 +292,13 @@ nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
		if (delegation == NULL)
		goto out;
		spin_lock(&delegation->lock);
		if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
		ret = delegation;
		if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
		/* Refcount matched in nfs_end_delegation_return() */
		ret = nfs_get_delegation(delegation);
		}
		spin_unlock(&delegation->lock);
		if (ret)
		nfs_clear_verifier_delegated(&nfsi->vfs_inode);
		out:
		return ret;
		}
		@@ -393,6 +416,7 @@ int nfs_inode_set_delegation(struct inode inode, const struct cred cred,
		if (delegation == NULL)
		return -ENOMEM;
		nfs4_stateid_copy(&delegation->stateid, stateid);
		refcount_set(&delegation->refcount, 1);
		delegation->type = type;
		delegation->pagemod_limit = pagemod_limit;
		delegation->change_attr = inode_peek_iversion_raw(inode);
		@@ -492,6 +516,8 @@ static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation

		err = nfs_do_return_delegation(inode, delegation, issync);
		out:
		/* Refcount matched in nfs_start_delegation_return_locked() */
		nfs_put_delegation(delegation);
		return err;
		}

		@@ -686,9 +712,12 @@ void nfs4_inode_return_delegation_on_close(struct inode *inode)
		list_empty(&NFS_I(inode)->open_files) &&
		!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
		clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
		ret = delegation;
		/* Refcount matched in nfs_end_delegation_return() */
		ret = nfs_get_delegation(delegation);
		}
		spin_unlock(&delegation->lock);
		if (ret)
		nfs_clear_verifier_delegated(inode);
		}
		out:
		rcu_read_unlock();
		@@ -1088,10 +1117,11 @@ restart:
		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
		rcu_read_unlock();
		if (delegation != NULL) {
		delegation = nfs_detach_delegation(NFS_I(inode),
		delegation, server);
		if (delegation != NULL)
		if (nfs_detach_delegation(NFS_I(inode), delegation,
		server) != NULL)
		nfs_free_delegation(delegation);
		/* Match nfs_start_delegation_return_locked */
		nfs_put_delegation(delegation);
		}
		iput(inode);
		nfs_sb_deactive(server->super);

fs/nfs/delegation.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@ struct nfs_delegation {
		unsigned long pagemod_limit;
		__u64 change_attr;
		unsigned long flags;
		refcount_t refcount;
		spinlock_t lock;
		struct rcu_head rcu;
		};

fs/nfs/dir.c

+116 −10

Original line number	Diff line number	Diff line
		@@ -155,6 +155,7 @@ typedef struct {
		loff_t current_index;
		decode_dirent_t decode;

		unsigned long dir_verifier;
		unsigned long timestamp;
		unsigned long gencount;
		unsigned int cache_entry_index;
		@@ -353,6 +354,7 @@ int nfs_readdir_xdr_filler(struct page *pages, nfs_readdir_descriptor_t desc,
		again:
		timestamp = jiffies;
		gencount = nfs_inc_attr_generation_counter();
		desc->dir_verifier = nfs_save_change_attribute(inode);
		error = NFS_PROTO(inode)->readdir(file_dentry(file), cred, entry->cookie, pages,
		NFS_SERVER(inode)->dtsize, desc->plus);
		if (error < 0) {
		@@ -455,13 +457,13 @@ void nfs_force_use_readdirplus(struct inode *dir)
		}

		static
		void nfs_prime_dcache(struct dentry parent, struct nfs_entry entry)
		void nfs_prime_dcache(struct dentry parent, struct nfs_entry entry,
		unsigned long dir_verifier)
		{
		struct qstr filename = QSTR_INIT(entry->name, entry->len);
		DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
		struct dentry *dentry;
		struct dentry *alias;
		struct inode *dir = d_inode(parent);
		struct inode *inode;
		int status;

		@@ -500,7 +502,7 @@ again:
		if (nfs_same_file(dentry, entry)) {
		if (!entry->fh->size)
		goto out;
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
		nfs_set_verifier(dentry, dir_verifier);
		status = nfs_refresh_inode(d_inode(dentry), entry->fattr);
		if (!status)
		nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label);
		@@ -526,7 +528,7 @@ again:
		dput(dentry);
		dentry = alias;
		}
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
		nfs_set_verifier(dentry, dir_verifier);
		out:
		dput(dentry);
		}
		@@ -564,7 +566,8 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t desc, struct nfs_entry en
		count++;

		if (desc->plus)
		nfs_prime_dcache(file_dentry(desc->file), entry);
		nfs_prime_dcache(file_dentry(desc->file), entry,
		desc->dir_verifier);

		status = nfs_readdir_add_to_array(entry, page);
		if (status != 0)
		@@ -983,14 +986,113 @@ static int nfs_fsync_dir(struct file *filp, loff_t start, loff_t end,
		* full lookup on all child dentries of 'dir' whenever a change occurs
		* on the server that might have invalidated our dcache.
		*
		* Note that we reserve bit '0' as a tag to let us know when a dentry
		* was revalidated while holding a delegation on its inode.
		*
		* The caller should be holding dir->i_lock
		*/
		void nfs_force_lookup_revalidate(struct inode *dir)
		{
		NFS_I(dir)->cache_change_attribute++;
		NFS_I(dir)->cache_change_attribute += 2;
		}
		EXPORT_SYMBOL_GPL(nfs_force_lookup_revalidate);

		/**
		* nfs_verify_change_attribute - Detects NFS remote directory changes
		* @dir: pointer to parent directory inode
		* @verf: previously saved change attribute
		*
		* Return "false" if the verifiers doesn't match the change attribute.
		* This would usually indicate that the directory contents have changed on
		* the server, and that any dentries need revalidating.
		*/
		static bool nfs_verify_change_attribute(struct inode *dir, unsigned long verf)
		{
		return (verf & ~1UL) == nfs_save_change_attribute(dir);
		}

		static void nfs_set_verifier_delegated(unsigned long *verf)
		{
		*verf \|= 1UL;
		}

		#if IS_ENABLED(CONFIG_NFS_V4)
		static void nfs_unset_verifier_delegated(unsigned long *verf)
		{
		*verf &= ~1UL;
		}
		#endif /* IS_ENABLED(CONFIG_NFS_V4) */

		static bool nfs_test_verifier_delegated(unsigned long verf)
		{
		return verf & 1;
		}

		static bool nfs_verifier_is_delegated(struct dentry *dentry)
		{
		return nfs_test_verifier_delegated(dentry->d_time);
		}

		static void nfs_set_verifier_locked(struct dentry *dentry, unsigned long verf)
		{
		struct inode *inode = d_inode(dentry);

		if (!nfs_verifier_is_delegated(dentry) &&
		!nfs_verify_change_attribute(d_inode(dentry->d_parent), verf))
		goto out;
		if (inode && NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
		nfs_set_verifier_delegated(&verf);
		out:
		dentry->d_time = verf;
		}

		/**
		* nfs_set_verifier - save a parent directory verifier in the dentry
		* @dentry: pointer to dentry
		* @verf: verifier to save
		*
		* Saves the parent directory verifier in @dentry. If the inode has
		* a delegation, we also tag the dentry as having been revalidated
		* while holding a delegation so that we know we don't have to
		* look it up again after a directory change.
		*/
		void nfs_set_verifier(struct dentry *dentry, unsigned long verf)
		{

		spin_lock(&dentry->d_lock);
		nfs_set_verifier_locked(dentry, verf);
		spin_unlock(&dentry->d_lock);
		}
		EXPORT_SYMBOL_GPL(nfs_set_verifier);

		#if IS_ENABLED(CONFIG_NFS_V4)
		/**
		* nfs_clear_verifier_delegated - clear the dir verifier delegation tag
		* @inode: pointer to inode
		*
		* Iterates through the dentries in the inode alias list and clears
		* the tag used to indicate that the dentry has been revalidated
		* while holding a delegation.
		* This function is intended for use when the delegation is being
		* returned or revoked.
		*/
		void nfs_clear_verifier_delegated(struct inode *inode)
		{
		struct dentry *alias;

		if (!inode)
		return;
		spin_lock(&inode->i_lock);
		hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
		spin_lock(&alias->d_lock);
		nfs_unset_verifier_delegated(&alias->d_time);
		spin_unlock(&alias->d_lock);
		}
		spin_unlock(&inode->i_lock);
		}
		EXPORT_SYMBOL_GPL(nfs_clear_verifier_delegated);
		#endif /* IS_ENABLED(CONFIG_NFS_V4) */

		/*
		* A check for whether or not the parent directory has changed.
		* In the case it has, we assume that the dentries are untrustworthy
		@@ -1159,6 +1261,7 @@ nfs_lookup_revalidate_dentry(struct inode dir, struct dentry dentry,
		struct nfs_fh *fhandle;
		struct nfs_fattr *fattr;
		struct nfs4_label *label;
		unsigned long dir_verifier;
		int ret;

		ret = -ENOMEM;
		@@ -1168,6 +1271,7 @@ nfs_lookup_revalidate_dentry(struct inode dir, struct dentry dentry,
		if (fhandle == NULL \|\| fattr == NULL \|\| IS_ERR(label))
		goto out;

		dir_verifier = nfs_save_change_attribute(dir);
		ret = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
		if (ret < 0) {
		switch (ret) {
		@@ -1188,7 +1292,7 @@ nfs_lookup_revalidate_dentry(struct inode dir, struct dentry dentry,
		goto out;

		nfs_setsecurity(inode, fattr, label);
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
		nfs_set_verifier(dentry, dir_verifier);

		/* set a readdirplus hint that we had a cache miss */
		nfs_force_use_readdirplus(dir);
		@@ -1230,7 +1334,7 @@ nfs_do_lookup_revalidate(struct inode dir, struct dentry dentry,
		goto out_bad;
		}

		if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
		if (nfs_verifier_is_delegated(dentry))
		return nfs_lookup_revalidate_delegated(dir, dentry, inode);

		/* Force a full look up iff the parent directory has changed */
		@@ -1415,6 +1519,7 @@ struct dentry nfs_lookup(struct inode dir, struct dentry * dentry, unsigned in
		struct nfs_fh *fhandle = NULL;
		struct nfs_fattr *fattr = NULL;
		struct nfs4_label *label = NULL;
		unsigned long dir_verifier;
		int error;

		dfprintk(VFS, "NFS: lookup(%pd2)\n", dentry);
		@@ -1440,6 +1545,7 @@ struct dentry nfs_lookup(struct inode dir, struct dentry * dentry, unsigned in
		if (IS_ERR(label))
		goto out;

		dir_verifier = nfs_save_change_attribute(dir);
		trace_nfs_lookup_enter(dir, dentry, flags);
		error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr, label);
		if (error == -ENOENT)
		@@ -1463,7 +1569,7 @@ no_entry:
		goto out_label;
		dentry = res;
		}
		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
		nfs_set_verifier(dentry, dir_verifier);
		out_label:
		trace_nfs_lookup_exit(dir, dentry, flags, error);
		nfs4_label_free(label);
		@@ -1668,7 +1774,7 @@ nfs4_do_lookup_revalidate(struct inode dir, struct dentry dentry,
		if (inode == NULL)
		goto full_reval;

		if (NFS_PROTO(dir)->have_delegation(inode, FMODE_READ))
		if (nfs_verifier_is_delegated(dentry))
		return nfs_lookup_revalidate_delegated(dir, dentry, inode);

		/* NFS only supports OPEN on regular files */

fs/nfs/inode.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -2114,6 +2114,7 @@ static void init_once(void *foo)
		init_rwsem(&nfsi->rmdir_sem);
		mutex_init(&nfsi->commit_mutex);
		nfs4_init_once(nfsi);
		nfsi->cache_change_attribute = 0;
		}

		static int __init nfs_init_inodecache(void)

fs/nfs/nfs4file.c

+0 −1

Original line number	Diff line number	Diff line
		@@ -87,7 +87,6 @@ nfs4_file_open(struct inode inode, struct file filp)
		if (inode != d_inode(dentry))
		goto out_drop;

		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
		nfs_file_set_open_context(filp, ctx);
		nfs_fscache_open_file(inode, filp);
		err = 0;

Admin message