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

Commit 2b3a8fd7 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'nfs-for-3.15-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs 

Pull NFS client updates from Trond Myklebust:
 "Highlights include:

   - Stable fix for a use after free issue in the NFSv4.1 open code
   - Fix the SUNRPC bi-directional RPC code to account for TCP segmentation
   - Optimise usage of readdirplus when confronted with 'ls -l' situations
   - Soft mount bugfixes
   - NFS over RDMA bugfixes
   - NFSv4 close locking fixes
   - Various NFSv4.x client state management optimisations
   - Rename/unlink code cleanups"

* tag 'nfs-for-3.15-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (28 commits)
  nfs: pass string length to pr_notice message about readdir loops
  NFSv4: Fix a use-after-free problem in open()
  SUNRPC: rpc_restart_call/rpc_restart_call_prepare should clear task->tk_status
  SUNRPC: Don't let rpc_delay() clobber non-timeout errors
  SUNRPC: Ensure call_connect_status() deals correctly with SOFTCONN tasks
  SUNRPC: Ensure call_status() deals correctly with SOFTCONN tasks
  NFSv4: Ensure we respect soft mount timeouts during trunking discovery
  NFSv4: Schedule recovery if nfs40_walk_client_list() is interrupted
  NFS: advertise only supported callback netids
  SUNRPC: remove KERN_INFO from dprintk() call sites
  SUNRPC: Fix large reads on NFS/RDMA
  NFS: Clean up: revert increase in READDIR RPC buffer max size
  SUNRPC: Ensure that call_bind times out correctly
  SUNRPC: Ensure that call_connect times out correctly
  nfs: emit a fsnotify_nameremove call in sillyrename codepath
  nfs: remove synchronous rename code
  nfs: convert nfs_rename to use async_rename infrastructure
  nfs: make nfs_async_rename non-static
  nfs: abstract out code needed to complete a sillyrename
  NFSv4: Clear the open state flags if the new stateid does not match
  ...
parents 6f4c98e1 9581a4ae

fs/nfs/callback_proc.c

+12 −7
Original line number Diff line number Diff line
@@ -112,7 +112,8 @@ __be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy, 
 * TODO: keep track of all layouts (and delegations) in a hash table

 * hashed by filehandle.

 */

static struct pnfs_layout_hdr * get_layout_by_fh_locked(struct nfs_client *clp, struct nfs_fh *fh)

static struct pnfs_layout_hdr * get_layout_by_fh_locked(struct nfs_client *clp,

		struct nfs_fh *fh, nfs4_stateid *stateid)

{

	struct nfs_server *server;

	struct inode *ino;
@@ -120,17 +121,19 @@ static struct pnfs_layout_hdr * get_layout_by_fh_locked(struct nfs_client *clp, 


	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {

		list_for_each_entry(lo, &server->layouts, plh_layouts) {

			if (!nfs4_stateid_match_other(&lo->plh_stateid, stateid))

				continue;

			if (nfs_compare_fh(fh, &NFS_I(lo->plh_inode)->fh))

				continue;

			ino = igrab(lo->plh_inode);

			if (!ino)

				continue;

				break;

			spin_lock(&ino->i_lock);

			/* Is this layout in the process of being freed? */

			if (NFS_I(ino)->layout != lo) {

				spin_unlock(&ino->i_lock);

				iput(ino);

				continue;

				break;

			}

			pnfs_get_layout_hdr(lo);

			spin_unlock(&ino->i_lock);
@@ -141,13 +144,14 @@ static struct pnfs_layout_hdr * get_layout_by_fh_locked(struct nfs_client *clp, 
	return NULL;

}



static struct pnfs_layout_hdr * get_layout_by_fh(struct nfs_client *clp, struct nfs_fh *fh)

static struct pnfs_layout_hdr * get_layout_by_fh(struct nfs_client *clp,

		struct nfs_fh *fh, nfs4_stateid *stateid)

{

	struct pnfs_layout_hdr *lo;



	spin_lock(&clp->cl_lock);

	rcu_read_lock();

	lo = get_layout_by_fh_locked(clp, fh);

	lo = get_layout_by_fh_locked(clp, fh, stateid);

	rcu_read_unlock();

	spin_unlock(&clp->cl_lock);
@@ -162,9 +166,9 @@ static u32 initiate_file_draining(struct nfs_client *clp, 
	u32 rv = NFS4ERR_NOMATCHING_LAYOUT;

	LIST_HEAD(free_me_list);



	lo = get_layout_by_fh(clp, &args->cbl_fh);

	lo = get_layout_by_fh(clp, &args->cbl_fh, &args->cbl_stateid);

	if (!lo)

		return NFS4ERR_NOMATCHING_LAYOUT;

		goto out;



	ino = lo->plh_inode;

	spin_lock(&ino->i_lock);
@@ -179,6 +183,7 @@ static u32 initiate_file_draining(struct nfs_client *clp, 
	pnfs_free_lseg_list(&free_me_list);

	pnfs_put_layout_hdr(lo);

	iput(ino);

out:

	return rv;

}

fs/nfs/dir.c

+52 −10
Original line number Diff line number Diff line
@@ -69,21 +69,28 @@ const struct address_space_operations nfs_dir_aops = { 


static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir, struct rpc_cred *cred)

{

	struct nfs_inode *nfsi = NFS_I(dir);

	struct nfs_open_dir_context *ctx;

	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);

	if (ctx != NULL) {

		ctx->duped = 0;

		ctx->attr_gencount = NFS_I(dir)->attr_gencount;

		ctx->attr_gencount = nfsi->attr_gencount;

		ctx->dir_cookie = 0;

		ctx->dup_cookie = 0;

		ctx->cred = get_rpccred(cred);

		spin_lock(&dir->i_lock);

		list_add(&ctx->list, &nfsi->open_files);

		spin_unlock(&dir->i_lock);

		return ctx;

	}

	return  ERR_PTR(-ENOMEM);

}



static void put_nfs_open_dir_context(struct nfs_open_dir_context *ctx)

static void put_nfs_open_dir_context(struct inode *dir, struct nfs_open_dir_context *ctx)

{

	spin_lock(&dir->i_lock);

	list_del(&ctx->list);

	spin_unlock(&dir->i_lock);

	put_rpccred(ctx->cred);

	kfree(ctx);

}
@@ -126,7 +133,7 @@ nfs_opendir(struct inode *inode, struct file *filp) 
static int

nfs_closedir(struct inode *inode, struct file *filp)

{

	put_nfs_open_dir_context(filp->private_data);

	put_nfs_open_dir_context(filp->f_path.dentry->d_inode, filp->private_data);

	return 0;

}
@@ -306,10 +313,9 @@ int nfs_readdir_search_for_cookie(struct nfs_cache_array *array, nfs_readdir_des 
					if (printk_ratelimit()) {

						pr_notice("NFS: directory %pD2 contains a readdir loop."

								"Please contact your server vendor.  "

								"The file: %s has duplicate cookie %llu\n",

								desc->file,

								array->array[i].string.name,

								*desc->dir_cookie);

								"The file: %.*s has duplicate cookie %llu\n",

								desc->file, array->array[i].string.len,

								array->array[i].string.name, *desc->dir_cookie);

					}

					status = -ELOOP;

					goto out;
@@ -437,6 +443,22 @@ void nfs_advise_use_readdirplus(struct inode *dir) 
	set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(dir)->flags);

}



/*

 * This function is mainly for use by nfs_getattr().

 *

 * If this is an 'ls -l', we want to force use of readdirplus.

 * Do this by checking if there is an active file descriptor

 * and calling nfs_advise_use_readdirplus, then forcing a

 * cache flush.

 */

void nfs_force_use_readdirplus(struct inode *dir)

{

	if (!list_empty(&NFS_I(dir)->open_files)) {

		nfs_advise_use_readdirplus(dir);

		nfs_zap_mapping(dir, dir->i_mapping);

	}

}



static

void nfs_prime_dcache(struct dentry *parent, struct nfs_entry *entry)

{
@@ -815,6 +837,17 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc) 
	goto out;

}



static bool nfs_dir_mapping_need_revalidate(struct inode *dir)

{

	struct nfs_inode *nfsi = NFS_I(dir);



	if (nfs_attribute_cache_expired(dir))

		return true;

	if (nfsi->cache_validity & NFS_INO_INVALID_DATA)

		return true;

	return false;

}



/* The file offset position represents the dirent entry number.  A

   last cookie cache takes care of the common case of reading the

   whole directory.
@@ -847,7 +880,7 @@ static int nfs_readdir(struct file *file, struct dir_context *ctx) 
	desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;



	nfs_block_sillyrename(dentry);

	if (ctx->pos == 0 || nfs_attribute_cache_expired(inode))

	if (ctx->pos == 0 || nfs_dir_mapping_need_revalidate(inode))

		res = nfs_revalidate_mapping(inode, file->f_mapping);

	if (res < 0)

		goto out;
@@ -1911,6 +1944,7 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
	struct inode *old_inode = old_dentry->d_inode;

	struct inode *new_inode = new_dentry->d_inode;

	struct dentry *dentry = NULL, *rehash = NULL;

	struct rpc_task *task;

	int error = -EBUSY;



	dfprintk(VFS, "NFS: rename(%pd2 -> %pd2, ct=%d)\n",
@@ -1958,8 +1992,16 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
	if (new_inode != NULL)

		NFS_PROTO(new_inode)->return_delegation(new_inode);



	error = NFS_PROTO(old_dir)->rename(old_dir, &old_dentry->d_name,

					   new_dir, &new_dentry->d_name);

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

	if (IS_ERR(task)) {

		error = PTR_ERR(task);

		goto out;

	}



	error = rpc_wait_for_completion_task(task);

	if (error == 0)

		error = task->tk_status;

	rpc_put_task(task);

	nfs_mark_for_revalidate(old_inode);

out:

	if (rehash)

fs/nfs/inode.c

+27 −7
Original line number Diff line number Diff line
@@ -588,6 +588,25 @@ void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr) 
}

EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);



static void nfs_request_parent_use_readdirplus(struct dentry *dentry)

{

	struct dentry *parent;



	parent = dget_parent(dentry);

	nfs_force_use_readdirplus(parent->d_inode);

	dput(parent);

}



static bool nfs_need_revalidate_inode(struct inode *inode)

{

	if (NFS_I(inode)->cache_validity &

			(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))

		return true;

	if (nfs_attribute_cache_expired(inode))

		return true;

	return false;

}



int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)

{

	struct inode *inode = dentry->d_inode;
@@ -616,10 +635,13 @@ int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 
 	    ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))

		need_atime = 0;



	if (need_atime)

		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);

	else

		err = nfs_revalidate_inode(NFS_SERVER(inode), inode);

	if (need_atime || nfs_need_revalidate_inode(inode)) {

		struct nfs_server *server = NFS_SERVER(inode);



		if (server->caps & NFS_CAP_READDIRPLUS)

			nfs_request_parent_use_readdirplus(dentry);

		err = __nfs_revalidate_inode(server, inode);

	}

	if (!err) {

		generic_fillattr(inode, stat);

		stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
@@ -961,9 +983,7 @@ int nfs_attribute_cache_expired(struct inode *inode) 
 */

int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)

{

	if (!(NFS_I(inode)->cache_validity &

			(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))

			&& !nfs_attribute_cache_expired(inode))

	if (!nfs_need_revalidate_inode(inode))

		return NFS_STALE(inode) ? -ESTALE : 0;

	return __nfs_revalidate_inode(server, inode);

}

fs/nfs/internal.h

+8 −0
Original line number Diff line number Diff line
@@ -301,6 +301,7 @@ extern struct nfs_client *nfs_init_client(struct nfs_client *clp, 
			   const char *ip_addr);



/* dir.c */

extern void nfs_force_use_readdirplus(struct inode *dir);

extern unsigned long nfs_access_cache_count(struct shrinker *shrink,

					    struct shrink_control *sc);

extern unsigned long nfs_access_cache_scan(struct shrinker *shrink,
@@ -474,6 +475,13 @@ extern int nfs_migrate_page(struct address_space *, 
#define nfs_migrate_page NULL

#endif



/* unlink.c */

extern struct rpc_task *

nfs_async_rename(struct inode *old_dir, struct inode *new_dir,

		 struct dentry *old_dentry, struct dentry *new_dentry,

		 void (*complete)(struct rpc_task *, struct nfs_renamedata *));

extern int nfs_sillyrename(struct inode *dir, struct dentry *dentry);



/* direct.c */

void nfs_init_cinfo_from_dreq(struct nfs_commit_info *cinfo,

			      struct nfs_direct_req *dreq);

fs/nfs/nfs3proc.c

+0 −36
Original line number Diff line number Diff line
@@ -478,41 +478,6 @@ nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir, 
	return 1;

}



static int

nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,

		 struct inode *new_dir, struct qstr *new_name)

{

	struct nfs_renameargs	arg = {

		.old_dir	= NFS_FH(old_dir),

		.old_name	= old_name,

		.new_dir	= NFS_FH(new_dir),

		.new_name	= new_name,

	};

	struct nfs_renameres res;

	struct rpc_message msg = {

		.rpc_proc	= &nfs3_procedures[NFS3PROC_RENAME],

		.rpc_argp	= &arg,

		.rpc_resp	= &res,

	};

	int status = -ENOMEM;



	dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);



	res.old_fattr = nfs_alloc_fattr();

	res.new_fattr = nfs_alloc_fattr();

	if (res.old_fattr == NULL || res.new_fattr == NULL)

		goto out;



	status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);

	nfs_post_op_update_inode(old_dir, res.old_fattr);

	nfs_post_op_update_inode(new_dir, res.new_fattr);

out:

	nfs_free_fattr(res.old_fattr);

	nfs_free_fattr(res.new_fattr);

	dprintk("NFS reply rename: %d\n", status);

	return status;

}



static int

nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)

{
@@ -968,7 +933,6 @@ const struct nfs_rpc_ops nfs_v3_clientops = { 
	.unlink_setup	= nfs3_proc_unlink_setup,

	.unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,

	.unlink_done	= nfs3_proc_unlink_done,

	.rename		= nfs3_proc_rename,

	.rename_setup	= nfs3_proc_rename_setup,

	.rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,

	.rename_done	= nfs3_proc_rename_done,