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

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

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

Pull NFS client updates from Anna Schumaker:
 "Stable bugfixes:
   - Fix -EACCESS on commit to DS handling
   - Fix initialization of nfs_page_array->npages
   - Only invalidate dentries that are actually invalid

  Features:
   - Enable NFSoRDMA transparent state migration
   - Add support for lookup-by-filehandle
   - Add support for nfs re-exporting

  Other bugfixes and cleanups:
   - Christoph cleaned up the way we declare NFS operations
   - Clean up various internal structures
   - Various cleanups to commits
   - Various improvements to error handling
   - Set the dt_type of . and .. entries in NFS v4
   - Make slot allocation more reliable
   - Fix fscache stat printing
   - Fix uninitialized variable warnings
   - Fix potential list overrun in nfs_atomic_open()
   - Fix a race in NFSoRDMA RPC reply handler
   - Fix return size for nfs42_proc_copy()
   - Fix against MAC forgery timing attacks"

* tag 'nfs-for-4.13-1' of git://git.linux-nfs.org/projects/anna/linux-nfs: (68 commits)
  NFS: Don't run wake_up_bit() when nobody is waiting...
  nfs: add export operations
  nfs4: add NFSv4 LOOKUPP handlers
  nfs: add a nfs_ilookup helper
  nfs: replace d_add with d_splice_alias in atomic_open
  sunrpc: use constant time memory comparison for mac
  NFSv4.2 fix size storage for nfs42_proc_copy
  xprtrdma: Fix documenting comments in frwr_ops.c
  xprtrdma: Replace PAGE_MASK with offset_in_page()
  xprtrdma: FMR does not need list_del_init()
  xprtrdma: Demote "connect" log messages
  NFSv4.1: Use seqid returned by EXCHANGE_ID after state migration
  NFSv4.1: Handle EXCHGID4_FLAG_CONFIRMED_R during NFSv4.1 migration
  xprtrdma: Don't defer MR recovery if ro_map fails
  xprtrdma: Fix FRWR invalidation error recovery
  xprtrdma: Fix client lock-up after application signal fires
  xprtrdma: Rename rpcrdma_req::rl_free
  xprtrdma: Pass only the list of registered MRs to ro_unmap_sync
  xprtrdma: Pre-mark remotely invalidated MRs
  xprtrdma: On invalidation failure, remove MWs from rl_registered
  ...
parents 48ea2ced b4f937cf

fs/nfs/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -7,7 +7,7 @@ obj-$(CONFIG_NFS_FS) += nfs.o 
CFLAGS_nfstrace.o += -I$(src)

nfs-y 			:= client.o dir.o file.o getroot.o inode.o super.o \

			   io.o direct.o pagelist.o read.o symlink.o unlink.o \

			   write.o namespace.o mount_clnt.o nfstrace.o

			   write.o namespace.o mount_clnt.o nfstrace.o export.o

nfs-$(CONFIG_ROOT_NFS)	+= nfsroot.o

nfs-$(CONFIG_SYSCTL)	+= sysctl.o

nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o

fs/nfs/dir.c

+26 −16
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ struct nfs_cache_array { 
	struct nfs_cache_array_entry array[0];

};



typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, int);

typedef int (*decode_dirent_t)(struct xdr_stream *, struct nfs_entry *, bool);

typedef struct {

	struct file	*file;

	struct page	*page;
@@ -165,8 +165,8 @@ typedef struct { 
	unsigned long	timestamp;

	unsigned long	gencount;

	unsigned int	cache_entry_index;

	unsigned int	plus:1;

	unsigned int	eof:1;

	bool plus;

	bool eof;

} nfs_readdir_descriptor_t;



/*
@@ -355,7 +355,7 @@ int nfs_readdir_xdr_filler(struct page **pages, nfs_readdir_descriptor_t *desc, 
		if (error == -ENOTSUPP && desc->plus) {

			NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;

			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);

			desc->plus = 0;

			desc->plus = false;

			goto again;

		}

		goto error;
@@ -557,7 +557,7 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *en 


		count++;



		if (desc->plus != 0)

		if (desc->plus)

			nfs_prime_dcache(file_dentry(desc->file), entry);



		status = nfs_readdir_add_to_array(entry, page);
@@ -860,7 +860,7 @@ static int nfs_readdir(struct file *file, struct dir_context *ctx) 
	desc->ctx = ctx;

	desc->dir_cookie = &dir_ctx->dir_cookie;

	desc->decode = NFS_PROTO(inode)->decode_dirent;

	desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;

	desc->plus = nfs_use_readdirplus(inode, ctx);



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

		res = nfs_revalidate_mapping(inode, file->f_mapping);
@@ -885,8 +885,8 @@ static int nfs_readdir(struct file *file, struct dir_context *ctx) 
			clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);

			nfs_zap_caches(inode);

			desc->page_index = 0;

			desc->plus = 0;

			desc->eof = 0;

			desc->plus = false;

			desc->eof = false;

			continue;

		}

		if (res < 0)
@@ -1115,11 +1115,13 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags) 
	/* Force a full look up iff the parent directory has changed */

	if (!nfs_is_exclusive_create(dir, flags) &&

	    nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {



		if (nfs_lookup_verify_inode(inode, flags)) {

		error = nfs_lookup_verify_inode(inode, flags);

		if (error) {

			if (flags & LOOKUP_RCU)

				return -ECHILD;

			if (error == -ESTALE)

				goto out_zap_parent;

			goto out_error;

		}

		nfs_advise_use_readdirplus(dir);

		goto out_valid;
@@ -1144,8 +1146,10 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags) 
	trace_nfs_lookup_revalidate_enter(dir, dentry, flags);

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

	trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);

	if (error)

	if (error == -ESTALE || error == -ENOENT)

		goto out_bad;

	if (error)

		goto out_error;

	if (nfs_compare_fh(NFS_FH(inode), fhandle))

		goto out_bad;

	if ((error = nfs_refresh_inode(inode, fattr)) != 0)
@@ -1427,8 +1431,10 @@ static int nfs_finish_open(struct nfs_open_context *ctx, 
	err = finish_open(file, dentry, do_open, opened);

	if (err)

		goto out;

	if (S_ISREG(file->f_path.dentry->d_inode->i_mode))

		nfs_file_set_open_context(file, ctx);



	else

		err = -ESTALE;

out:

	return err;

}
@@ -1512,7 +1518,7 @@ int nfs_atomic_open(struct inode *dir, struct dentry *dentry, 
		d_drop(dentry);

		switch (err) {

		case -ENOENT:

			d_add(dentry, NULL);

			d_splice_alias(NULL, dentry);

			nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

			break;

		case -EISDIR:
@@ -2035,7 +2041,11 @@ int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 
	}



	error = rpc_wait_for_completion_task(task);

	if (error == 0)

	if (error != 0) {

		((struct nfs_renamedata *)task->tk_calldata)->cancelled = 1;

		/* Paired with the atomic_dec_and_test() barrier in rpc_do_put_task() */

		smp_wmb();

	} else

		error = task->tk_status;

	rpc_put_task(task);

	nfs_mark_for_revalidate(old_inode);

fs/nfs/export.c

0 → 100644
+177 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2015, Primary Data, Inc. All rights reserved.

 *

 * Tao Peng <bergwolf@primarydata.com>

 */

#include <linux/dcache.h>

#include <linux/exportfs.h>

#include <linux/nfs.h>

#include <linux/nfs_fs.h>



#include "internal.h"

#include "nfstrace.h"



#define NFSDBG_FACILITY		NFSDBG_VFS



enum {

	FILEID_HIGH_OFF = 0,	/* inode fileid high */

	FILEID_LOW_OFF,		/* inode fileid low */

	FILE_I_TYPE_OFF,	/* inode type */

	EMBED_FH_OFF		/* embeded server fh */

};





static struct nfs_fh *nfs_exp_embedfh(__u32 *p)

{

	return (struct nfs_fh *)(p + EMBED_FH_OFF);

}



/*

 * Let's break subtree checking for now... otherwise we'll have to embed parent fh

 * but there might not be enough space.

 */

static int

nfs_encode_fh(struct inode *inode, __u32 *p, int *max_len, struct inode *parent)

{

	struct nfs_fh *server_fh = NFS_FH(inode);

	struct nfs_fh *clnt_fh = nfs_exp_embedfh(p);

	size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;

	int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);



	dprintk("%s: max fh len %d inode %p parent %p",

		__func__, *max_len, inode, parent);



	if (*max_len < len || IS_AUTOMOUNT(inode)) {

		dprintk("%s: fh len %d too small, required %d\n",

			__func__, *max_len, len);

		*max_len = len;

		return FILEID_INVALID;

	}

	if (IS_AUTOMOUNT(inode)) {

		*max_len = FILEID_INVALID;

		goto out;

	}



	p[FILEID_HIGH_OFF] = NFS_FILEID(inode) >> 32;

	p[FILEID_LOW_OFF] = NFS_FILEID(inode);

	p[FILE_I_TYPE_OFF] = inode->i_mode & S_IFMT;

	p[len - 1] = 0; /* Padding */

	nfs_copy_fh(clnt_fh, server_fh);

	*max_len = len;

out:

	dprintk("%s: result fh fileid %llu mode %u size %d\n",

		__func__, NFS_FILEID(inode), inode->i_mode, *max_len);

	return *max_len;

}



static struct dentry *

nfs_fh_to_dentry(struct super_block *sb, struct fid *fid,

		 int fh_len, int fh_type)

{

	struct nfs4_label *label = NULL;

	struct nfs_fattr *fattr = NULL;

	struct nfs_fh *server_fh = nfs_exp_embedfh(fid->raw);

	size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;

	const struct nfs_rpc_ops *rpc_ops;

	struct dentry *dentry;

	struct inode *inode;

	int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);

	u32 *p = fid->raw;

	int ret;



	/* NULL translates to ESTALE */

	if (fh_len < len || fh_type != len)

		return NULL;



	fattr = nfs_alloc_fattr();

	if (fattr == NULL) {

		dentry = ERR_PTR(-ENOMEM);

		goto out;

	}



	fattr->fileid = ((u64)p[FILEID_HIGH_OFF] << 32) + p[FILEID_LOW_OFF];

	fattr->mode = p[FILE_I_TYPE_OFF];

	fattr->valid |= NFS_ATTR_FATTR_FILEID | NFS_ATTR_FATTR_TYPE;



	dprintk("%s: fileid %llu mode %d\n", __func__, fattr->fileid, fattr->mode);



	inode = nfs_ilookup(sb, fattr, server_fh);

	if (inode)

		goto out_found;



	label = nfs4_label_alloc(NFS_SB(sb), GFP_KERNEL);

	if (IS_ERR(label)) {

		dentry = ERR_CAST(label);

		goto out_free_fattr;

	}



	rpc_ops = NFS_SB(sb)->nfs_client->rpc_ops;

	ret = rpc_ops->getattr(NFS_SB(sb), server_fh, fattr, label);

	if (ret) {

		dprintk("%s: getattr failed %d\n", __func__, ret);

		dentry = ERR_PTR(ret);

		goto out_free_label;

	}



	inode = nfs_fhget(sb, server_fh, fattr, label);



out_found:

	dentry = d_obtain_alias(inode);



out_free_label:

	nfs4_label_free(label);

out_free_fattr:

	nfs_free_fattr(fattr);

out:

	return dentry;

}



static struct dentry *

nfs_get_parent(struct dentry *dentry)

{

	int ret;

	struct inode *inode = d_inode(dentry), *pinode;

	struct super_block *sb = inode->i_sb;

	struct nfs_server *server = NFS_SB(sb);

	struct nfs_fattr *fattr = NULL;

	struct nfs4_label *label = NULL;

	struct dentry *parent;

	struct nfs_rpc_ops const *ops = server->nfs_client->rpc_ops;

	struct nfs_fh fh;



	if (!ops->lookupp)

		return ERR_PTR(-EACCES);



	fattr = nfs_alloc_fattr();

	if (fattr == NULL) {

		parent = ERR_PTR(-ENOMEM);

		goto out;

	}



	label = nfs4_label_alloc(server, GFP_KERNEL);

	if (IS_ERR(label)) {

		parent = ERR_CAST(label);

		goto out_free_fattr;

	}



	ret = ops->lookupp(inode, &fh, fattr, label);

	if (ret) {

		parent = ERR_PTR(ret);

		goto out_free_label;

	}



	pinode = nfs_fhget(sb, &fh, fattr, label);

	parent = d_obtain_alias(pinode);

out_free_label:

	nfs4_label_free(label);

out_free_fattr:

	nfs_free_fattr(fattr);

out:

	return parent;

}



const struct export_operations nfs_export_ops = {

	.encode_fh = nfs_encode_fh,

	.fh_to_dentry = nfs_fh_to_dentry,

	.get_parent = nfs_get_parent,

};

fs/nfs/filelayout/filelayout.c

+2 −29
Original line number Diff line number Diff line
@@ -126,32 +126,13 @@ static int filelayout_async_handle_error(struct rpc_task *task, 
{

	struct pnfs_layout_hdr *lo = lseg->pls_layout;

	struct inode *inode = lo->plh_inode;

	struct nfs_server *mds_server = NFS_SERVER(inode);

	struct nfs4_deviceid_node *devid = FILELAYOUT_DEVID_NODE(lseg);

	struct nfs_client *mds_client = mds_server->nfs_client;

	struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table;



	if (task->tk_status >= 0)

		return 0;



	switch (task->tk_status) {

	/* MDS state errors */

	case -NFS4ERR_DELEG_REVOKED:

	case -NFS4ERR_ADMIN_REVOKED:

	case -NFS4ERR_BAD_STATEID:

	case -NFS4ERR_OPENMODE:

		if (state == NULL)

			break;

		if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)

			goto out_bad_stateid;

		goto wait_on_recovery;

	case -NFS4ERR_EXPIRED:

		if (state != NULL) {

			if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)

				goto out_bad_stateid;

		}

		nfs4_schedule_lease_recovery(mds_client);

		goto wait_on_recovery;

	/* DS session errors */

	case -NFS4ERR_BADSESSION:

	case -NFS4ERR_BADSLOT:
@@ -172,6 +153,7 @@ static int filelayout_async_handle_error(struct rpc_task *task, 
	case -NFS4ERR_RETRY_UNCACHED_REP:

		break;

	/* Invalidate Layout errors */

	case -NFS4ERR_ACCESS:

	case -NFS4ERR_PNFS_NO_LAYOUT:

	case -ESTALE:           /* mapped NFS4ERR_STALE */

	case -EBADHANDLE:       /* mapped NFS4ERR_BADHANDLE */
@@ -202,26 +184,17 @@ static int filelayout_async_handle_error(struct rpc_task *task, 
			task->tk_status);

		nfs4_mark_deviceid_unavailable(devid);

		pnfs_error_mark_layout_for_return(inode, lseg);

		pnfs_set_lo_fail(lseg);

		rpc_wake_up(&tbl->slot_tbl_waitq);

		/* fall through */

	default:

		pnfs_set_lo_fail(lseg);

reset:

		dprintk("%s Retry through MDS. Error %d\n", __func__,

			task->tk_status);

		return -NFS4ERR_RESET_TO_MDS;

	}

out:

	task->tk_status = 0;

	return -EAGAIN;

out_bad_stateid:

	task->tk_status = -EIO;

	return 0;

wait_on_recovery:

	rpc_sleep_on(&mds_client->cl_rpcwaitq, task, NULL);

	if (test_bit(NFS4CLNT_MANAGER_RUNNING, &mds_client->cl_state) == 0)

		rpc_wake_up_queued_task(&mds_client->cl_rpcwaitq, task);

	goto out;

}



/* NFS_PROTO call done callback routines */

fs/nfs/flexfilelayout/flexfilelayout.c

+0 −33
Original line number Diff line number Diff line
@@ -1050,34 +1050,10 @@ static int ff_layout_async_handle_error_v4(struct rpc_task *task, 
{

	struct pnfs_layout_hdr *lo = lseg->pls_layout;

	struct inode *inode = lo->plh_inode;

	struct nfs_server *mds_server = NFS_SERVER(inode);



	struct nfs4_deviceid_node *devid = FF_LAYOUT_DEVID_NODE(lseg, idx);

	struct nfs_client *mds_client = mds_server->nfs_client;

	struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table;



	switch (task->tk_status) {

	/* MDS state errors */

	case -NFS4ERR_DELEG_REVOKED:

	case -NFS4ERR_ADMIN_REVOKED:

	case -NFS4ERR_BAD_STATEID:

		if (state == NULL)

			break;

		nfs_remove_bad_delegation(state->inode, NULL);

	case -NFS4ERR_OPENMODE:

		if (state == NULL)

			break;

		if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)

			goto out_bad_stateid;

		goto wait_on_recovery;

	case -NFS4ERR_EXPIRED:

		if (state != NULL) {

			if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)

				goto out_bad_stateid;

		}

		nfs4_schedule_lease_recovery(mds_client);

		goto wait_on_recovery;

	/* DS session errors */

	case -NFS4ERR_BADSESSION:

	case -NFS4ERR_BADSLOT:

	case -NFS4ERR_BAD_HIGH_SLOT:
@@ -1137,17 +1113,8 @@ static int ff_layout_async_handle_error_v4(struct rpc_task *task, 
			task->tk_status);

		return -NFS4ERR_RESET_TO_MDS;

	}

out:

	task->tk_status = 0;

	return -EAGAIN;

out_bad_stateid:

	task->tk_status = -EIO;

	return 0;

wait_on_recovery:

	rpc_sleep_on(&mds_client->cl_rpcwaitq, task, NULL);

	if (test_bit(NFS4CLNT_MANAGER_RUNNING, &mds_client->cl_state) == 0)

		rpc_wake_up_queued_task(&mds_client->cl_rpcwaitq, task);

	goto out;

}



/* Retry all errors through either pNFS or MDS except for -EJUKEBOX */