Commit 0280e3c5 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull NFS client updates from Anna Schumaker:
 "New Features:

   - Basic handling for case insensitive filesystems

   - Initial support for fs_locations and server trunking

  Bugfixes and Cleanups:

   - Cleanups to how the "struct cred *" is handled for the
     nfs_access_entry

   - Ensure the server has an up to date ctimes before hardlinking or
     renaming

   - Update 'blocks used' after writeback, fallocate, and clone

   - nfs_atomic_open() fixes

   - Improvements to sunrpc tracing

   - Various null check & indenting related cleanups

   - Some improvements to the sunrpc sysfs code:
      - Use default_groups in kobj_type
      - Fix some potential races and reference leaks

   - A few tracepoint cleanups in xprtrdma"

[ This should have gone in during the merge window, but didn't. The
  original pull request - sent during the merge window - had gotten
  marked as spam and discarded due missing DKIM headers in the email
  from Anna.   - Linus ]

* tag 'nfs-for-5.17-1' of git://git.linux-nfs.org/projects/anna/linux-nfs: (35 commits)
  SUNRPC: Don't dereference xprt->snd_task if it's a cookie
  xprtrdma: Remove definitions of RPCDBG_FACILITY
  xprtrdma: Remove final dprintk call sites from xprtrdma
  sunrpc: Fix potential race conditions in rpc_sysfs_xprt_state_change()
  net/sunrpc: fix reference count leaks in rpc_sysfs_xprt_state_change
  NFSv4.1 test and add 4.1 trunking transport
  SUNRPC allow for unspecified transport time in rpc_clnt_add_xprt
  NFSv4 handle port presence in fs_location server string
  NFSv4 expose nfs_parse_server_name function
  NFSv4.1 query for fs_location attr on a new file system
  NFSv4 store server support for fs_location attribute
  NFSv4 remove zero number of fs_locations entries error check
  NFSv4: nfs_atomic_open() can race when looking up a non-regular file
  NFSv4: Handle case where the lookup of a directory fails
  NFSv42: Fallocate and clone should also request 'blocks used'
  NFSv4: Allow writebacks to request 'blocks used'
  SUNRPC: use default_groups in kobj_type
  NFS: use default_groups in kobj_type
  NFS: Fix the verifier for case sensitive filesystem in nfs_atomic_open()
  NFS: Add a helper to remove case-insensitive aliases
  ...
parents 7938d615 aed28b7a

fs/nfs/callback.h

+1 −1
Original line number Diff line number Diff line
@@ -170,7 +170,7 @@ struct cb_devicenotifyitem { 
};



struct cb_devicenotifyargs {

	int				 ndevs;

	uint32_t			 ndevs;

	struct cb_devicenotifyitem	 *devs;

};

fs/nfs/callback_proc.c

+1 −1
Original line number Diff line number Diff line
@@ -358,7 +358,7 @@ __be32 nfs4_callback_devicenotify(void *argp, void *resp, 
				  struct cb_process_state *cps)

{

	struct cb_devicenotifyargs *args = argp;

	int i;

	uint32_t i;

	__be32 res = 0;

	struct nfs_client *clp = cps->clp;

	struct nfs_server *server = NULL;

fs/nfs/callback_xdr.c

+9 −9
Original line number Diff line number Diff line
@@ -258,11 +258,9 @@ __be32 decode_devicenotify_args(struct svc_rqst *rqstp, 
				void *argp)

{

	struct cb_devicenotifyargs *args = argp;

	uint32_t tmp, n, i;

	__be32 *p;

	__be32 status = 0;

	u32 tmp;

	int n, i;

	args->ndevs = 0;



	/* Num of device notifications */

	p = xdr_inline_decode(xdr, sizeof(uint32_t));
@@ -271,7 +269,7 @@ __be32 decode_devicenotify_args(struct svc_rqst *rqstp, 
		goto out;

	}

	n = ntohl(*p++);

	if (n <= 0)

	if (n == 0)

		goto out;

	if (n > ULONG_MAX / sizeof(*args->devs)) {

		status = htonl(NFS4ERR_BADXDR);
@@ -330,19 +328,21 @@ __be32 decode_devicenotify_args(struct svc_rqst *rqstp, 
			dev->cbd_immediate = 0;

		}



		args->ndevs++;



		dprintk("%s: type %d layout 0x%x immediate %d\n",

			__func__, dev->cbd_notify_type, dev->cbd_layout_type,

			dev->cbd_immediate);

	}

	args->ndevs = n;

	dprintk("%s: ndevs %d\n", __func__, args->ndevs);

	return 0;

err:

	kfree(args->devs);

out:

	args->devs = NULL;

	args->ndevs = 0;

	dprintk("%s: status %d ndevs %d\n",

		__func__, ntohl(status), args->ndevs);

	return status;

err:

	kfree(args->devs);

	goto out;

}



static __be32 decode_sessionid(struct xdr_stream *xdr,

fs/nfs/client.c

+7 −0
Original line number Diff line number Diff line
@@ -856,6 +856,13 @@ static int nfs_probe_fsinfo(struct nfs_server *server, struct nfs_fh *mntfh, str 
			server->namelen = pathinfo.max_namelen;

	}



	if (clp->rpc_ops->discover_trunking != NULL &&

			(server->caps & NFS_CAP_FS_LOCATIONS)) {

		error = clp->rpc_ops->discover_trunking(server, mntfh);

		if (error < 0)

			return error;

	}



	return 0;

}

fs/nfs/dir.c

+118 −28
Original line number Diff line number Diff line
@@ -1325,6 +1325,14 @@ void nfs_clear_verifier_delegated(struct inode *inode) 
EXPORT_SYMBOL_GPL(nfs_clear_verifier_delegated);

#endif /* IS_ENABLED(CONFIG_NFS_V4) */



static int nfs_dentry_verify_change(struct inode *dir, struct dentry *dentry)

{

	if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE) &&

	    d_really_is_negative(dentry))

		return dentry->d_time == inode_peek_iversion_raw(dir);

	return nfs_verify_change_attribute(dir, dentry->d_time);

}



/*

 * A check for whether or not the parent directory has changed.

 * In the case it has, we assume that the dentries are untrustworthy
@@ -1338,7 +1346,7 @@ static int nfs_check_verifier(struct inode *dir, struct dentry *dentry, 
		return 1;

	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONE)

		return 0;

	if (!nfs_verify_change_attribute(dir, dentry->d_time))

	if (!nfs_dentry_verify_change(dir, dentry))

		return 0;

	/* Revalidate nfsi->cache_change_attribute before we declare a match */

	if (nfs_mapping_need_revalidate_inode(dir)) {
@@ -1347,7 +1355,7 @@ static int nfs_check_verifier(struct inode *dir, struct dentry *dentry, 
		if (__nfs_revalidate_inode(NFS_SERVER(dir), dir) < 0)

			return 0;

	}

	if (!nfs_verify_change_attribute(dir, dentry->d_time))

	if (!nfs_dentry_verify_change(dir, dentry))

		return 0;

	return 1;

}
@@ -1437,6 +1445,9 @@ int nfs_neg_need_reval(struct inode *dir, struct dentry *dentry, 
		return 0;

	if (NFS_SERVER(dir)->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG)

		return 1;

	/* Case insensitive server? Revalidate negative dentries */

	if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))

		return 1;

	return !nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU);

}
@@ -1537,7 +1548,7 @@ nfs_lookup_revalidate_dentry(struct inode *dir, struct dentry *dentry, 
	 * If the lookup failed despite the dentry change attribute being

	 * a match, then we should revalidate the directory cache.

	 */

	if (!ret && nfs_verify_change_attribute(dir, dentry->d_time))

	if (!ret && nfs_dentry_verify_change(dir, dentry))

		nfs_mark_dir_for_revalidate(dir);

	return nfs_lookup_revalidate_done(dir, dentry, inode, ret);

}
@@ -1776,8 +1787,11 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in 
	dir_verifier = nfs_save_change_attribute(dir);

	trace_nfs_lookup_enter(dir, dentry, flags);

	error = NFS_PROTO(dir)->lookup(dir, dentry, fhandle, fattr);

	if (error == -ENOENT)

	if (error == -ENOENT) {

		if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))

			dir_verifier = inode_peek_iversion_raw(dir);

		goto no_entry;

	}

	if (error < 0) {

		res = ERR_PTR(error);

		goto out;
@@ -1806,6 +1820,14 @@ struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, unsigned in 
}

EXPORT_SYMBOL_GPL(nfs_lookup);



void nfs_d_prune_case_insensitive_aliases(struct inode *inode)

{

	/* Case insensitive server? Revalidate dentries */

	if (inode && nfs_server_capable(inode, NFS_CAP_CASE_INSENSITIVE))

		d_prune_aliases(inode);

}

EXPORT_SYMBOL_GPL(nfs_d_prune_case_insensitive_aliases);



#if IS_ENABLED(CONFIG_NFS_V4)

static int nfs4_lookup_revalidate(struct dentry *, unsigned int);
@@ -1867,6 +1889,7 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry, 
	struct iattr attr = { .ia_valid = ATTR_OPEN };

	struct inode *inode;

	unsigned int lookup_flags = 0;

	unsigned long dir_verifier;

	bool switched = false;

	int created = 0;

	int err;
@@ -1940,7 +1963,11 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry, 
		switch (err) {

		case -ENOENT:

			d_splice_alias(NULL, dentry);

			nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

			if (nfs_server_capable(dir, NFS_CAP_CASE_INSENSITIVE))

				dir_verifier = inode_peek_iversion_raw(dir);

			else

				dir_verifier = nfs_save_change_attribute(dir);

			nfs_set_verifier(dentry, dir_verifier);

			break;

		case -EISDIR:

		case -ENOTDIR:
@@ -1968,6 +1995,24 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry, 


no_open:

	res = nfs_lookup(dir, dentry, lookup_flags);

	if (!res) {

		inode = d_inode(dentry);

		if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&

		    !S_ISDIR(inode->i_mode))

			res = ERR_PTR(-ENOTDIR);

		else if (inode && S_ISREG(inode->i_mode))

			res = ERR_PTR(-EOPENSTALE);

	} else if (!IS_ERR(res)) {

		inode = d_inode(res);

		if ((lookup_flags & LOOKUP_DIRECTORY) && inode &&

		    !S_ISDIR(inode->i_mode)) {

			dput(res);

			res = ERR_PTR(-ENOTDIR);

		} else if (inode && S_ISREG(inode->i_mode)) {

			dput(res);

			res = ERR_PTR(-EOPENSTALE);

		}

	}

	if (switched) {

		d_lookup_done(dentry);

		if (!res)
@@ -2186,8 +2231,10 @@ static void nfs_dentry_remove_handle_error(struct inode *dir, 
	switch (error) {

	case -ENOENT:

		d_delete(dentry);

		fallthrough;

		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

		break;

	case 0:

		nfs_d_prune_case_insensitive_aliases(d_inode(dentry));

		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

	}

}
@@ -2380,6 +2427,8 @@ nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 


	trace_nfs_link_enter(inode, dir, dentry);

	d_drop(dentry);

	if (S_ISREG(inode->i_mode))

		nfs_sync_inode(inode);

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

	if (error == 0) {

		nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
@@ -2469,6 +2518,8 @@ int nfs_rename(struct user_namespace *mnt_userns, struct inode *old_dir, 
		}

	}



	if (S_ISREG(old_inode->i_mode))

		nfs_sync_inode(old_inode);

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

	if (IS_ERR(task)) {

		error = PTR_ERR(task);
@@ -2529,7 +2580,7 @@ MODULE_PARM_DESC(nfs_access_max_cachesize, "NFS access maximum total cache lengt 


static void nfs_access_free_entry(struct nfs_access_entry *entry)

{

	put_cred(entry->cred);

	put_group_info(entry->group_info);

	kfree_rcu(entry, rcu_head);

	smp_mb__before_atomic();

	atomic_long_dec(&nfs_access_nr_entries);
@@ -2655,6 +2706,43 @@ void nfs_access_zap_cache(struct inode *inode) 
}

EXPORT_SYMBOL_GPL(nfs_access_zap_cache);



static int access_cmp(const struct cred *a, const struct nfs_access_entry *b)

{

	struct group_info *ga, *gb;

	int g;



	if (uid_lt(a->fsuid, b->fsuid))

		return -1;

	if (uid_gt(a->fsuid, b->fsuid))

		return 1;



	if (gid_lt(a->fsgid, b->fsgid))

		return -1;

	if (gid_gt(a->fsgid, b->fsgid))

		return 1;



	ga = a->group_info;

	gb = b->group_info;

	if (ga == gb)

		return 0;

	if (ga == NULL)

		return -1;

	if (gb == NULL)

		return 1;

	if (ga->ngroups < gb->ngroups)

		return -1;

	if (ga->ngroups > gb->ngroups)

		return 1;



	for (g = 0; g < ga->ngroups; g++) {

		if (gid_lt(ga->gid[g], gb->gid[g]))

			return -1;

		if (gid_gt(ga->gid[g], gb->gid[g]))

			return 1;

	}

	return 0;

}



static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, const struct cred *cred)

{

	struct rb_node *n = NFS_I(inode)->access_cache.rb_node;
@@ -2662,7 +2750,7 @@ static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, co 
	while (n != NULL) {

		struct nfs_access_entry *entry =

			rb_entry(n, struct nfs_access_entry, rb_node);

		int cmp = cred_fscmp(cred, entry->cred);

		int cmp = access_cmp(cred, entry);



		if (cmp < 0)

			n = n->rb_left;
@@ -2674,7 +2762,7 @@ static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, co 
	return NULL;

}



static int nfs_access_get_cached_locked(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res, bool may_block)

static int nfs_access_get_cached_locked(struct inode *inode, const struct cred *cred, u32 *mask, bool may_block)

{

	struct nfs_inode *nfsi = NFS_I(inode);

	struct nfs_access_entry *cache;
@@ -2704,8 +2792,7 @@ static int nfs_access_get_cached_locked(struct inode *inode, const struct cred * 
		spin_lock(&inode->i_lock);

		retry = false;

	}

	res->cred = cache->cred;

	res->mask = cache->mask;

	*mask = cache->mask;

	list_move_tail(&cache->lru, &nfsi->access_cache_entry_lru);

	err = 0;

out:
@@ -2717,7 +2804,7 @@ static int nfs_access_get_cached_locked(struct inode *inode, const struct cred * 
	return -ENOENT;

}



static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res)

static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *cred, u32 *mask)

{

	/* Only check the most recently returned cache entry,

	 * but do it without locking.
@@ -2733,35 +2820,36 @@ static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *cre 
	lh = rcu_dereference(list_tail_rcu(&nfsi->access_cache_entry_lru));

	cache = list_entry(lh, struct nfs_access_entry, lru);

	if (lh == &nfsi->access_cache_entry_lru ||

	    cred_fscmp(cred, cache->cred) != 0)

	    access_cmp(cred, cache) != 0)

		cache = NULL;

	if (cache == NULL)

		goto out;

	if (nfs_check_cache_invalid(inode, NFS_INO_INVALID_ACCESS))

		goto out;

	res->cred = cache->cred;

	res->mask = cache->mask;

	*mask = cache->mask;

	err = 0;

out:

	rcu_read_unlock();

	return err;

}



int nfs_access_get_cached(struct inode *inode, const struct cred *cred, struct

nfs_access_entry *res, bool may_block)

int nfs_access_get_cached(struct inode *inode, const struct cred *cred,

			  u32 *mask, bool may_block)

{

	int status;



	status = nfs_access_get_cached_rcu(inode, cred, res);

	status = nfs_access_get_cached_rcu(inode, cred, mask);

	if (status != 0)

		status = nfs_access_get_cached_locked(inode, cred, res,

		status = nfs_access_get_cached_locked(inode, cred, mask,

		    may_block);



	return status;

}

EXPORT_SYMBOL_GPL(nfs_access_get_cached);



static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)

static void nfs_access_add_rbtree(struct inode *inode,

				  struct nfs_access_entry *set,

				  const struct cred *cred)

{

	struct nfs_inode *nfsi = NFS_I(inode);

	struct rb_root *root_node = &nfsi->access_cache;
@@ -2774,7 +2862,7 @@ static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry * 
	while (*p != NULL) {

		parent = *p;

		entry = rb_entry(parent, struct nfs_access_entry, rb_node);

		cmp = cred_fscmp(set->cred, entry->cred);

		cmp = access_cmp(cred, entry);



		if (cmp < 0)

			p = &parent->rb_left;
@@ -2796,13 +2884,16 @@ static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry * 
	nfs_access_free_entry(entry);

}



void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set)

void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set,

			  const struct cred *cred)

{

	struct nfs_access_entry *cache = kmalloc(sizeof(*cache), GFP_KERNEL);

	if (cache == NULL)

		return;

	RB_CLEAR_NODE(&cache->rb_node);

	cache->cred = get_cred(set->cred);

	cache->fsuid = cred->fsuid;

	cache->fsgid = cred->fsgid;

	cache->group_info = get_group_info(cred->group_info);

	cache->mask = set->mask;



	/* The above field assignments must be visible
@@ -2810,7 +2901,7 @@ void nfs_access_add_cache(struct inode *inode, struct nfs_access_entry *set) 
	 * use rcu_assign_pointer, so just force the memory barrier.

	 */

	smp_wmb();

	nfs_access_add_rbtree(inode, cache);

	nfs_access_add_rbtree(inode, cache, cred);



	/* Update accounting */

	smp_mb__before_atomic();
@@ -2875,7 +2966,7 @@ static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask) 


	trace_nfs_access_enter(inode);



	status = nfs_access_get_cached(inode, cred, &cache, may_block);

	status = nfs_access_get_cached(inode, cred, &cache.mask, may_block);

	if (status == 0)

		goto out_cached;
@@ -2895,8 +2986,7 @@ static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask) 
		cache.mask |= NFS_ACCESS_DELETE | NFS_ACCESS_LOOKUP;

	else

		cache.mask |= NFS_ACCESS_EXECUTE;

	cache.cred = cred;

	status = NFS_PROTO(inode)->access(inode, &cache);

	status = NFS_PROTO(inode)->access(inode, &cache, cred);

	if (status != 0) {

		if (status == -ESTALE) {

			if (!S_ISDIR(inode->i_mode))
@@ -2906,7 +2996,7 @@ static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask) 
		}

		goto out;

	}

	nfs_access_add_cache(inode, &cache);

	nfs_access_add_cache(inode, &cache, cred);

out_cached:

	cache_mask = nfs_access_calc_mask(cache.mask, inode->i_mode);

	if ((mask & ~cache_mask & (MAY_READ | MAY_WRITE | MAY_EXEC)) != 0)