lael-labs/linux

fs/nfs/Makefile+1−1

@@ -7,7 +7,7 @@ obj-$(CONFIG_NFS_FS) += nfs.o · 6 unmodified lines
7	CFLAGS_nfstrace.o += -I$(src)	7	CFLAGS_nfstrace.o += -I$(src)
8	nfs-y := client.o dir.o file.o getroot.o inode.o super.o \	8	nfs-y := client.o dir.o file.o getroot.o inode.o super.o \
9	io.o direct.o pagelist.o read.o symlink.o unlink.o \	9	io.o direct.o pagelist.o read.o symlink.o unlink.o \
10	write.o namespace.o mount_clnt.o nfstrace.o	10	write.o namespace.o mount_clnt.o nfstrace.o export.o
11	nfs-$(CONFIG_ROOT_NFS) += nfsroot.o	11	nfs-$(CONFIG_ROOT_NFS) += nfsroot.o
12	nfs-$(CONFIG_SYSCTL) += sysctl.o	12	nfs-$(CONFIG_SYSCTL) += sysctl.o
13	nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o	13	nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o

fs/nfs/dir.c+26−16

@@ -151,7 +151,7 @@ struct nfs_cache_array { · 150 unmodified lines
151	struct nfs_cache_array_entry array[0];	151	struct nfs_cache_array_entry array[0];
152	};	152	};
153		153
154	typedef int (decode_dirent_t)(struct xdr_stream , struct nfs_entry *, int);	154	typedef int (decode_dirent_t)(struct xdr_stream , struct nfs_entry *, bool);
155	typedef struct {	155	typedef struct {
156	struct file *file;	156	struct file *file;
157	struct page *page;	157	struct page *page;
@@ -165,8 +165,8 @@ typedef struct { · 7 unmodified lines
165	unsigned long timestamp;	165	unsigned long timestamp;
166	unsigned long gencount;	166	unsigned long gencount;
167	unsigned int cache_entry_index;	167	unsigned int cache_entry_index;
168	unsigned int plus:1;	168	bool plus;
169	unsigned int eof:1;	169	bool eof;
170	} nfs_readdir_descriptor_t;	170	} nfs_readdir_descriptor_t;
171		171
172	/*	172	/*
@@ -355,7 +355,7 @@ int nfs_readdir_xdr_filler(struct page *pages, nfs_readdir_descriptor_t desc, · 182 unmodified lines
355	if (error == -ENOTSUPP && desc->plus) {	355	if (error == -ENOTSUPP && desc->plus) {
356	NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;	356	NFS_SERVER(inode)->caps &= ~NFS_CAP_READDIRPLUS;
357	clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);	357	clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
358	desc->plus = 0;	358	desc->plus = false;
359	goto again;	359	goto again;
360	}	360	}
361	goto error;	361	goto error;
@@ -557,7 +557,7 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t desc, struct nfs_entry en · 195 unmodified lines
557		557
558	count++;	558	count++;
559		559
560	if (desc->plus != 0)	560	if (desc->plus)
561	nfs_prime_dcache(file_dentry(desc->file), entry);	561	nfs_prime_dcache(file_dentry(desc->file), entry);
562		562
563	status = nfs_readdir_add_to_array(entry, page);	563	status = nfs_readdir_add_to_array(entry, page);
@@ -860,7 +860,7 @@ static int nfs_readdir(struct file file, struct dir_context ctx) · 296 unmodified lines
860	desc->ctx = ctx;	860	desc->ctx = ctx;
861	desc->dir_cookie = &dir_ctx->dir_cookie;	861	desc->dir_cookie = &dir_ctx->dir_cookie;
862	desc->decode = NFS_PROTO(inode)->decode_dirent;	862	desc->decode = NFS_PROTO(inode)->decode_dirent;
863	desc->plus = nfs_use_readdirplus(inode, ctx) ? 1 : 0;	863	desc->plus = nfs_use_readdirplus(inode, ctx);
864		864
865	if (ctx->pos == 0 \|\| nfs_attribute_cache_expired(inode))	865	if (ctx->pos == 0 \|\| nfs_attribute_cache_expired(inode))
866	res = nfs_revalidate_mapping(inode, file->f_mapping);	866	res = nfs_revalidate_mapping(inode, file->f_mapping);
@@ -885,8 +885,8 @@ static int nfs_readdir(struct file file, struct dir_context ctx) · 18 unmodified lines
885	clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);	885	clear_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
886	nfs_zap_caches(inode);	886	nfs_zap_caches(inode);
887	desc->page_index = 0;	887	desc->page_index = 0;
888	desc->plus = 0;	888	desc->plus = false;
889	desc->eof = 0;	889	desc->eof = false;
890	continue;	890	continue;
891	}	891	}
892	if (res < 0)	892	if (res < 0)
@@ -1115,11 +1115,13 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags) · 222 unmodified lines
1115	/* Force a full look up iff the parent directory has changed */	1115	/* Force a full look up iff the parent directory has changed */
1116	if (!nfs_is_exclusive_create(dir, flags) &&	1116	if (!nfs_is_exclusive_create(dir, flags) &&
1117	nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {	1117	nfs_check_verifier(dir, dentry, flags & LOOKUP_RCU)) {
1118		1118	error = nfs_lookup_verify_inode(inode, flags);
1119	if (nfs_lookup_verify_inode(inode, flags)) {	1119	if (error) {
1120	if (flags & LOOKUP_RCU)	1120	if (flags & LOOKUP_RCU)
1121	return -ECHILD;	1121	return -ECHILD;
1122	goto out_zap_parent;	1122	if (error == -ESTALE)
		1123	goto out_zap_parent;
		1124	goto out_error;
1123	}	1125	}
1124	nfs_advise_use_readdirplus(dir);	1126	nfs_advise_use_readdirplus(dir);
1125	goto out_valid;	1127	goto out_valid;
@@ -1144,8 +1146,10 @@ static int nfs_lookup_revalidate(struct dentry *dentry, unsigned int flags) · 18 unmodified lines
1144	trace_nfs_lookup_revalidate_enter(dir, dentry, flags);	1146	trace_nfs_lookup_revalidate_enter(dir, dentry, flags);
1145	error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);	1147	error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, label);
1146	trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);	1148	trace_nfs_lookup_revalidate_exit(dir, dentry, flags, error);
1147	if (error)	1149	if (error == -ESTALE \|\| error == -ENOENT)
1148	goto out_bad;	1150	goto out_bad;
		1151	if (error)
		1152	goto out_error;
1149	if (nfs_compare_fh(NFS_FH(inode), fhandle))	1153	if (nfs_compare_fh(NFS_FH(inode), fhandle))
1150	goto out_bad;	1154	goto out_bad;
1151	if ((error = nfs_refresh_inode(inode, fattr)) != 0)	1155	if ((error = nfs_refresh_inode(inode, fattr)) != 0)
@@ -1427,8 +1431,10 @@ static int nfs_finish_open(struct nfs_open_context *ctx, · 275 unmodified lines
1427	err = finish_open(file, dentry, do_open, opened);	1431	err = finish_open(file, dentry, do_open, opened);
1428	if (err)	1432	if (err)
1429	goto out;	1433	goto out;
1430	nfs_file_set_open_context(file, ctx);	1434	if (S_ISREG(file->f_path.dentry->d_inode->i_mode))
1431		1435	nfs_file_set_open_context(file, ctx);
		1436	else
		1437	err = -ESTALE;
1432	out:	1438	out:
1433	return err;	1439	return err;
1434	}	1440	}
@@ -1512,7 +1518,7 @@ int nfs_atomic_open(struct inode dir, struct dentry dentry, · 77 unmodified lines
1512	d_drop(dentry);	1518	d_drop(dentry);
1513	switch (err) {	1519	switch (err) {
1514	case -ENOENT:	1520	case -ENOENT:
1515	d_add(dentry, NULL);	1521	d_splice_alias(NULL, dentry);
1516	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));	1522	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
1517	break;	1523	break;
1518	case -EISDIR:	1524	case -EISDIR:
@@ -2035,7 +2041,11 @@ int nfs_rename(struct inode old_dir, struct dentry old_dentry, · 516 unmodified lines
2035	}	2041	}
2036		2042
2037	error = rpc_wait_for_completion_task(task);	2043	error = rpc_wait_for_completion_task(task);
2038	if (error == 0)	2044	if (error != 0) {
		2045	((struct nfs_renamedata *)task->tk_calldata)->cancelled = 1;
		2046	/* Paired with the atomic_dec_and_test() barrier in rpc_do_put_task() */
		2047	smp_wmb();
		2048	} else
2039	error = task->tk_status;	2049	error = task->tk_status;
2040	rpc_put_task(task);	2050	rpc_put_task(task);
2041	nfs_mark_for_revalidate(old_inode);	2051	nfs_mark_for_revalidate(old_inode);

fs/nfs/export.c+177−0

@@ -0,0 +1,177 @@
	1	/*
	2	* Copyright (c) 2015, Primary Data, Inc. All rights reserved.
	3	*
	4	* Tao Peng <bergwolf@primarydata.com>
	5	*/
	6	#include <linux/dcache.h>
	7	#include <linux/exportfs.h>
	8	#include <linux/nfs.h>
	9	#include <linux/nfs_fs.h>
	10
	11	#include "internal.h"
	12	#include "nfstrace.h"
	13
	14	#define NFSDBG_FACILITY NFSDBG_VFS
	15
	16	enum {
	17	FILEID_HIGH_OFF = 0, /* inode fileid high */
	18	FILEID_LOW_OFF, /* inode fileid low */
	19	FILE_I_TYPE_OFF, /* inode type */
	20	EMBED_FH_OFF /* embeded server fh */
	21	};
	22
	23
	24	static struct nfs_fh nfs_exp_embedfh(__u32 p)
	25	{
	26	return (struct nfs_fh *)(p + EMBED_FH_OFF);
	27	}
	28
	29	/*
	30	* Let's break subtree checking for now... otherwise we'll have to embed parent fh
	31	* but there might not be enough space.
	32	*/
	33	static int
	34	nfs_encode_fh(struct inode inode, __u32 p, int max_len, struct inode parent)
	35	{
	36	struct nfs_fh *server_fh = NFS_FH(inode);
	37	struct nfs_fh *clnt_fh = nfs_exp_embedfh(p);
	38	size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;
	39	int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);
	40
	41	dprintk("%s: max fh len %d inode %p parent %p",
	42	__func__, *max_len, inode, parent);
	43
	44	if (*max_len < len \|\| IS_AUTOMOUNT(inode)) {
	45	dprintk("%s: fh len %d too small, required %d\n",
	46	__func__, *max_len, len);
	47	*max_len = len;
	48	return FILEID_INVALID;
	49	}
	50	if (IS_AUTOMOUNT(inode)) {
	51	*max_len = FILEID_INVALID;
	52	goto out;
	53	}
	54
	55	p[FILEID_HIGH_OFF] = NFS_FILEID(inode) >> 32;
	56	p[FILEID_LOW_OFF] = NFS_FILEID(inode);
	57	p[FILE_I_TYPE_OFF] = inode->i_mode & S_IFMT;
	58	p[len - 1] = 0; /* Padding */
	59	nfs_copy_fh(clnt_fh, server_fh);
	60	*max_len = len;
	61	out:
	62	dprintk("%s: result fh fileid %llu mode %u size %d\n",
	63	__func__, NFS_FILEID(inode), inode->i_mode, *max_len);
	64	return *max_len;
	65	}
	66
	67	static struct dentry *
	68	nfs_fh_to_dentry(struct super_block sb, struct fid fid,
	69	int fh_len, int fh_type)
	70	{
	71	struct nfs4_label *label = NULL;
	72	struct nfs_fattr *fattr = NULL;
	73	struct nfs_fh *server_fh = nfs_exp_embedfh(fid->raw);
	74	size_t fh_size = offsetof(struct nfs_fh, data) + server_fh->size;
	75	const struct nfs_rpc_ops *rpc_ops;
	76	struct dentry *dentry;
	77	struct inode *inode;
	78	int len = EMBED_FH_OFF + XDR_QUADLEN(fh_size);
	79	u32 *p = fid->raw;
	80	int ret;
	81
	82	/* NULL translates to ESTALE */
	83	if (fh_len < len \|\| fh_type != len)
	84	return NULL;
	85
	86	fattr = nfs_alloc_fattr();
	87	if (fattr == NULL) {
	88	dentry = ERR_PTR(-ENOMEM);
	89	goto out;
	90	}
	91
	92	fattr->fileid = ((u64)p[FILEID_HIGH_OFF] << 32) + p[FILEID_LOW_OFF];
	93	fattr->mode = p[FILE_I_TYPE_OFF];
	94	fattr->valid \|= NFS_ATTR_FATTR_FILEID \| NFS_ATTR_FATTR_TYPE;
	95
	96	dprintk("%s: fileid %llu mode %d\n", __func__, fattr->fileid, fattr->mode);
	97
	98	inode = nfs_ilookup(sb, fattr, server_fh);
	99	if (inode)
	100	goto out_found;
	101
	102	label = nfs4_label_alloc(NFS_SB(sb), GFP_KERNEL);
	103	if (IS_ERR(label)) {
	104	dentry = ERR_CAST(label);
	105	goto out_free_fattr;
	106	}
	107
	108	rpc_ops = NFS_SB(sb)->nfs_client->rpc_ops;
	109	ret = rpc_ops->getattr(NFS_SB(sb), server_fh, fattr, label);
	110	if (ret) {
	111	dprintk("%s: getattr failed %d\n", __func__, ret);
	112	dentry = ERR_PTR(ret);
	113	goto out_free_label;
	114	}
	115
	116	inode = nfs_fhget(sb, server_fh, fattr, label);
	117
	118	out_found:
	119	dentry = d_obtain_alias(inode);
	120
	121	out_free_label:
	122	nfs4_label_free(label);
	123	out_free_fattr:
	124	nfs_free_fattr(fattr);
	125	out:
	126	return dentry;
	127	}
	128
	129	static struct dentry *
	130	nfs_get_parent(struct dentry *dentry)
	131	{
	132	int ret;
	133	struct inode inode = d_inode(dentry), pinode;
	134	struct super_block *sb = inode->i_sb;
	135	struct nfs_server *server = NFS_SB(sb);
	136	struct nfs_fattr *fattr = NULL;
	137	struct nfs4_label *label = NULL;
	138	struct dentry *parent;
	139	struct nfs_rpc_ops const *ops = server->nfs_client->rpc_ops;
	140	struct nfs_fh fh;
	141
	142	if (!ops->lookupp)
	143	return ERR_PTR(-EACCES);
	144
	145	fattr = nfs_alloc_fattr();
	146	if (fattr == NULL) {
	147	parent = ERR_PTR(-ENOMEM);
	148	goto out;
	149	}
	150
	151	label = nfs4_label_alloc(server, GFP_KERNEL);
	152	if (IS_ERR(label)) {
	153	parent = ERR_CAST(label);
	154	goto out_free_fattr;
	155	}
	156
	157	ret = ops->lookupp(inode, &fh, fattr, label);
	158	if (ret) {
	159	parent = ERR_PTR(ret);
	160	goto out_free_label;
	161	}
	162
	163	pinode = nfs_fhget(sb, &fh, fattr, label);
	164	parent = d_obtain_alias(pinode);
	165	out_free_label:
	166	nfs4_label_free(label);
	167	out_free_fattr:
	168	nfs_free_fattr(fattr);
	169	out:
	170	return parent;
	171	}
	172
	173	const struct export_operations nfs_export_ops = {
	174	.encode_fh = nfs_encode_fh,
	175	.fh_to_dentry = nfs_fh_to_dentry,
	176	.get_parent = nfs_get_parent,
	177	};

fs/nfs/filelayout/filelayout.c+2−29

 {
 	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:
 	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 */
 			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

@@ -1050,34 +1050,10 @@ static int ff_layout_async_handle_error_v4(struct rpc_task *task, · 1049 unmodified lines
1050	{	1050	{
1051	struct pnfs_layout_hdr *lo = lseg->pls_layout;	1051	struct pnfs_layout_hdr *lo = lseg->pls_layout;
1052	struct inode *inode = lo->plh_inode;	1052	struct inode *inode = lo->plh_inode;
1053	struct nfs_server *mds_server = NFS_SERVER(inode);
1054
1055	struct nfs4_deviceid_node *devid = FF_LAYOUT_DEVID_NODE(lseg, idx);	1053	struct nfs4_deviceid_node *devid = FF_LAYOUT_DEVID_NODE(lseg, idx);
1056	struct nfs_client *mds_client = mds_server->nfs_client;
1057	struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table;	1054	struct nfs4_slot_table *tbl = &clp->cl_session->fc_slot_table;
1058		1055
1059	switch (task->tk_status) {	1056	switch (task->tk_status) {
1060	/* MDS state errors */
1061	case -NFS4ERR_DELEG_REVOKED:
1062	case -NFS4ERR_ADMIN_REVOKED:
1063	case -NFS4ERR_BAD_STATEID:
1064	if (state == NULL)
1065	break;
1066	nfs_remove_bad_delegation(state->inode, NULL);
1067	case -NFS4ERR_OPENMODE:
1068	if (state == NULL)
1069	break;
1070	if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)
1071	goto out_bad_stateid;
1072	goto wait_on_recovery;
1073	case -NFS4ERR_EXPIRED:
1074	if (state != NULL) {
1075	if (nfs4_schedule_stateid_recovery(mds_server, state) < 0)
1076	goto out_bad_stateid;
1077	}
1078	nfs4_schedule_lease_recovery(mds_client);
1079	goto wait_on_recovery;
1080	/* DS session errors */
1081	case -NFS4ERR_BADSESSION:	1057	case -NFS4ERR_BADSESSION:
1082	case -NFS4ERR_BADSLOT:	1058	case -NFS4ERR_BADSLOT:
1083	case -NFS4ERR_BAD_HIGH_SLOT:	1059	case -NFS4ERR_BAD_HIGH_SLOT:
@@ -1137,17 +1113,8 @@ reset: · 53 unmodified lines
1137	task->tk_status);	1113	task->tk_status);
1138	return -NFS4ERR_RESET_TO_MDS;	1114	return -NFS4ERR_RESET_TO_MDS;
1139	}	1115	}
1140	out:
1141	task->tk_status = 0;	1116	task->tk_status = 0;
1142	return -EAGAIN;	1117	return -EAGAIN;
1143	out_bad_stateid:
1144	task->tk_status = -EIO;
1145	return 0;
1146	wait_on_recovery:
1147	rpc_sleep_on(&mds_client->cl_rpcwaitq, task, NULL);
1148	if (test_bit(NFS4CLNT_MANAGER_RUNNING, &mds_client->cl_state) == 0)
1149	rpc_wake_up_queued_task(&mds_client->cl_rpcwaitq, task);
1150	goto out;
1151	}	1118	}
1152		1119
1153	/* Retry all errors through either pNFS or MDS except for -EJUKEBOX */	1120	/* Retry all errors through either pNFS or MDS except for -EJUKEBOX */

fs/nfs/inode.c+32−4

@@ -386,6 +386,28 @@ void nfs_setsecurity(struct inode inode, struct nfs_fattr fattr, · 385 unmodified lines
386	#endif	386	#endif
387	EXPORT_SYMBOL_GPL(nfs_setsecurity);	387	EXPORT_SYMBOL_GPL(nfs_setsecurity);
388		388
		389	/* Search for inode identified by fh, fileid and i_mode in inode cache. */
		390	struct inode *
		391	nfs_ilookup(struct super_block sb, struct nfs_fattr fattr, struct nfs_fh *fh)
		392	{
		393	struct nfs_find_desc desc = {
		394	.fh = fh,
		395	.fattr = fattr,
		396	};
		397	struct inode *inode;
		398	unsigned long hash;
		399
		400	if (!(fattr->valid & NFS_ATTR_FATTR_FILEID) \|\|
		401	!(fattr->valid & NFS_ATTR_FATTR_TYPE))
		402	return NULL;
		403
		404	hash = nfs_fattr_to_ino_t(fattr);
		405	inode = ilookup5(sb, hash, nfs_find_actor, &desc);
		406
		407	dprintk("%s: returning %p\n", __func__, inode);
		408	return inode;
		409	}
		410
389	/*	411	/*
390	* This is our front-end to iget that looks up inodes by file handle	412	* This is our front-end to iget that looks up inodes by file handle
391	* instead of inode number.	413	* instead of inode number.
@@ -525,8 +547,14 @@ nfs_fhget(struct super_block sb, struct nfs_fh fh, struct nfs_fattr *fattr, st · 133 unmodified lines
525	nfs_fscache_init_inode(inode);	547	nfs_fscache_init_inode(inode);
526		548
527	unlock_new_inode(inode);	549	unlock_new_inode(inode);
528	} else	550	} else {
529	nfs_refresh_inode(inode, fattr);	551	int err = nfs_refresh_inode(inode, fattr);
		552	if (err < 0) {
		553	iput(inode);
		554	inode = ERR_PTR(err);
		555	goto out_no_inode;
		556	}
		557	}
530	dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",	558	dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
531	inode->i_sb->s_id,	559	inode->i_sb->s_id,
532	(unsigned long long)NFS_FILEID(inode),	560	(unsigned long long)NFS_FILEID(inode),
@@ -1315,9 +1343,9 @@ static int nfs_check_inode_attributes(struct inode inode, struct nfs_fattr fat · 782 unmodified lines
1315	return 0;	1343	return 0;
1316	/* Has the inode gone and changed behind our back? */	1344	/* Has the inode gone and changed behind our back? */
1317	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)	1345	if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
1318	return -EIO;	1346	return -ESTALE;
1319	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))	1347	if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
1320	return -EIO;	1348	return -ESTALE;
1321		1349
1322	if (!nfs_file_has_buffered_writers(nfsi)) {	1350	if (!nfs_file_has_buffered_writers(nfsi)) {
1323	/* Verify a few of the more important attributes */	1351	/* Verify a few of the more important attributes */

fs/nfs/internal.h+5−3

 #define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
+extern const struct export_operations nfs_export_ops;
 struct nfs_string;
 /* Maximum number of readahead requests
 /* nfs2xdr.c */
 extern const struct rpc_procinfo nfs_procedures[];
 extern int nfs2_decode_dirent(struct xdr_stream *,
-				struct nfs_entry *, int);
+				struct nfs_entry *, bool);
 /* nfs3xdr.c */
 extern const struct rpc_procinfo nfs3_procedures[];
 extern int nfs3_decode_dirent(struct xdr_stream *,
-				struct nfs_entry *, int);
+				struct nfs_entry *, bool);
 /* nfs4xdr.c */
 #if IS_ENABLED(CONFIG_NFS_V4)
 extern int nfs4_decode_dirent(struct xdr_stream *,
-				struct nfs_entry *, int);
+				struct nfs_entry *, bool);
 #endif
 #ifdef CONFIG_NFS_V4_1
 extern const u32 nfs41_maxread_overhead;

fs/nfs/nfs2xdr.c+1−1

@@ -939,7 +939,7 @@ static int nfs2_xdr_dec_writeres(struct rpc_rqst req, struct xdr_stream xdr, · 938 unmodified lines
939	* };	939	* };
940	*/	940	*/
941	int nfs2_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,	941	int nfs2_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,
942	int plus)	942	bool plus)
943	{	943	{
944	__be32 *p;	944	__be32 *p;
945	int error;	945	int error;

fs/nfs/nfs3proc.c+1−1

@@ -621,7 +621,7 @@ out: · 620 unmodified lines
621	*/	621	*/
622	static int	622	static int
623	nfs3_proc_readdir(struct dentry dentry, struct rpc_cred cred,	623	nfs3_proc_readdir(struct dentry dentry, struct rpc_cred cred,
624	u64 cookie, struct page **pages, unsigned int count, int plus)	624	u64 cookie, struct page **pages, unsigned int count, bool plus)
625	{	625	{
626	struct inode *dir = d_inode(dentry);	626	struct inode *dir = d_inode(dentry);
627	__be32 *verf = NFS_I(dir)->cookieverf;	627	__be32 *verf = NFS_I(dir)->cookieverf;

fs/nfs/nfs3xdr.c+1−1

@@ -1991,7 +1991,7 @@ out_status: · 1990 unmodified lines
1991	* };	1991	* };
1992	*/	1992	*/
1993	int nfs3_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,	1993	int nfs3_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,
1994	int plus)	1994	bool plus)
1995	{	1995	{
1996	struct nfs_entry old = *entry;	1996	struct nfs_entry old = *entry;
1997	__be32 *p;	1997	__be32 *p;

fs/nfs/nfs42proc.c+1−1

@@ -146,7 +146,7 @@ static ssize_t _nfs42_proc_copy(struct file *src, · 145 unmodified lines
146	loff_t pos_src = args->src_pos;	146	loff_t pos_src = args->src_pos;
147	loff_t pos_dst = args->dst_pos;	147	loff_t pos_dst = args->dst_pos;
148	size_t count = args->count;	148	size_t count = args->count;
149	int status;	149	ssize_t status;
150		150
151	status = nfs4_set_rw_stateid(&args->src_stateid, src_lock->open_context,	151	status = nfs4_set_rw_stateid(&args->src_stateid, src_lock->open_context,
152	src_lock, FMODE_READ);	152	src_lock, FMODE_READ);

fs/nfs/nfs4client.c+5−0

 	if (clp != old)
 		clp->cl_preserve_clid = true;
 	nfs_put_client(clp);
+	clear_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags);
 	return old;
 error:
 		set_bit(NFS_CS_NORESVPORT, &cl_init.init_flags);
 	if (server->options & NFS_OPTION_MIGRATION)
 		set_bit(NFS_CS_MIGRATION, &cl_init.init_flags);
+	if (test_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status))
+		set_bit(NFS_CS_TSM_POSSIBLE, &cl_init.init_flags);
 	/* Allocate or find a client reference we can use */
 	clp = nfs_get_client(&cl_init);
 		return -EAFNOSUPPORT;
 	nfs_server_remove_lists(server);
+	set_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
 	error = nfs4_set_client(server, hostname, sap, salen, buf,
 				clp->cl_proto, clnt->cl_timeout,
 				clp->cl_minorversion, net);
+	clear_bit(NFS_MIG_TSM_POSSIBLE, &server->mig_status);
 	nfs_put_client(clp);
 	if (error != 0) {
 		nfs_server_insert_lists(server);

fs/nfs/nfs4idmap.c+2−1

 		ret = -EINVAL;
 	} else {
 		ret = kstrtol(id_str, 10, &id_long);
-		*id = (__u32)id_long;
+		if (!ret)
+			*id = (__u32)id_long;
 	}
 	return ret;
 }

fs/nfs/nfs4proc.c+80−29

 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
 		struct nfs4_readdir_arg *readdir)
 {
+	unsigned int attrs = FATTR4_WORD0_FILEID | FATTR4_WORD0_TYPE;
 	__be32 *start, *p;
 	if (cookie > 2) {
 		memcpy(p, ".\0\0\0", 4);                        /* entry */
 		p++;
 		*p++ = xdr_one;                         /* bitmap length */
-		*p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
+		*p++ = htonl(attrs);                           /* bitmap */
-		*p++ = htonl(8);              /* attribute buffer length */
+		*p++ = htonl(12);             /* attribute buffer length */
+		*p++ = htonl(NF4DIR);
 		p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
 	}
 	memcpy(p, "..\0\0", 4);                         /* entry */
 	p++;
 	*p++ = xdr_one;                         /* bitmap length */
-	*p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
+	*p++ = htonl(attrs);                           /* bitmap */
-	*p++ = htonl(8);              /* attribute buffer length */
+	*p++ = htonl(12);             /* attribute buffer length */
+	*p++ = htonl(NF4DIR);
 	p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
 	readdir->pgbase = (char *)p - (char *)start;
 	struct nfs4_state *state;
 	struct iattr attrs;
 	unsigned long timestamp;
-	unsigned int rpc_done : 1;
+	bool rpc_done;
-	unsigned int file_created : 1;
+	bool file_created;
-	unsigned int is_recover : 1;
+	bool is_recover;
+	bool cancelled;
 	int rpc_status;
-	int cancelled;
 };
 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
 		nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
 		nfs_confirm_seqid(&data->owner->so_seqid, 0);
 		renew_lease(data->o_res.server, data->timestamp);
-		data->rpc_done = 1;
+		data->rpc_done = true;
 	}
 }
 	struct nfs4_state *state = NULL;
 	/* If this request hasn't been cancelled, do nothing */
-	if (data->cancelled == 0)
+	if (!data->cancelled)
 		goto out_free;
 	/* In case of error, no cleanup! */
 	if (!data->rpc_done)
 	nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1);
 	kref_get(&data->kref);
-	data->rpc_done = 0;
+	data->rpc_done = false;
 	data->rpc_status = 0;
 	data->timestamp = jiffies;
 	if (data->is_recover)
 		return PTR_ERR(task);
 	status = rpc_wait_for_completion_task(task);
 	if (status != 0) {
-		data->cancelled = 1;
+		data->cancelled = true;
 		smp_wmb();
 	} else
 		status = data->rpc_status;
 		if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
 			nfs_confirm_seqid(&data->owner->so_seqid, 0);
 	}
-	data->rpc_done = 1;
+	data->rpc_done = true;
 }
 static void nfs4_open_release(void *calldata)
 	struct nfs4_state *state = NULL;
 	/* If this request hasn't been cancelled, do nothing */
-	if (data->cancelled == 0)
+	if (!data->cancelled)
 		goto out_free;
 	/* In case of error, no cleanup! */
 	if (data->rpc_status != 0 || !data->rpc_done)
 	nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
 	kref_get(&data->kref);
-	data->rpc_done = 0;
+	data->rpc_done = false;
 	data->rpc_status = 0;
-	data->cancelled = 0;
+	data->cancelled = false;
-	data->is_recover = 0;
+	data->is_recover = false;
 	if (isrecover) {
 		nfs4_set_sequence_privileged(&o_arg->seq_args);
-		data->is_recover = 1;
+		data->is_recover = true;
 	}
 	task = rpc_run_task(&task_setup_data);
 	if (IS_ERR(task))
 		return PTR_ERR(task);
 	status = rpc_wait_for_completion_task(task);
 	if (status != 0) {
-		data->cancelled = 1;
+		data->cancelled = true;
 		smp_wmb();
 	} else
 		status = data->rpc_status;
 	if (o_arg->open_flags & O_CREAT) {
 		if (o_arg->open_flags & O_EXCL)
-			data->file_created = 1;
+			data->file_created = true;
 		else if (o_res->cinfo.before != o_res->cinfo.after)
-			data->file_created = 1;
+			data->file_created = true;
 		if (data->file_created || dir->i_version != o_res->cinfo.after)
 			update_changeattr(dir, &o_res->cinfo,
 					o_res->f_attr->time_start);
 	return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client;
 }
+static int _nfs4_proc_lookupp(struct inode *inode,
+		struct nfs_fh *fhandle, struct nfs_fattr *fattr,
+		struct nfs4_label *label)
+{
+	struct rpc_clnt *clnt = NFS_CLIENT(inode);
+	struct nfs_server *server = NFS_SERVER(inode);
+	int		       status;
+	struct nfs4_lookupp_arg args = {
+		.bitmask = server->attr_bitmask,
+		.fh = NFS_FH(inode),
+	};
+	struct nfs4_lookupp_res res = {
+		.server = server,
+		.fattr = fattr,
+		.label = label,
+		.fh = fhandle,
+	};
+	struct rpc_message msg = {
+		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUPP],
+		.rpc_argp = &args,
+		.rpc_resp = &res,
+	};
+	args.bitmask = nfs4_bitmask(server, label);
+	nfs_fattr_init(fattr);
+	dprintk("NFS call  lookupp ino=0x%lx\n", inode->i_ino);
+	status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
+				&res.seq_res, 0);
+	dprintk("NFS reply lookupp: %d\n", status);
+	return status;
+}
+static int nfs4_proc_lookupp(struct inode *inode, struct nfs_fh *fhandle,
+			     struct nfs_fattr *fattr, struct nfs4_label *label)
+{
+	struct nfs4_exception exception = { };
+	int err;
+	do {
+		err = _nfs4_proc_lookupp(inode, fhandle, fattr, label);
+		trace_nfs4_lookupp(inode, err);
+		err = nfs4_handle_exception(NFS_SERVER(inode), err,
+				&exception);
+	} while (exception.retry);
+	return err;
+}
 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
 {
 	struct nfs_server *server = NFS_SERVER(inode);
 }
 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
-		u64 cookie, struct page **pages, unsigned int count, int plus)
+		u64 cookie, struct page **pages, unsigned int count, bool plus)
 {
 	struct inode		*dir = d_inode(dentry);
 	struct nfs4_readdir_arg args = {
 }
 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
-		u64 cookie, struct page **pages, unsigned int count, int plus)
+		u64 cookie, struct page **pages, unsigned int count, bool plus)
 {
 	struct nfs4_exception exception = { };
 	int err;
 	dprintk("%s: begin!\n", __func__);
 	nfs_free_seqid(data->arg.open_seqid);
-	if (data->cancelled != 0) {
+	if (data->cancelled) {
 		struct rpc_task *task;
 		task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
 				data->arg.lock_seqid);
 			nfs4_handle_setlk_error(data->server, data->lsp,
 					data->arg.new_lock_owner, ret);
 	} else
-		data->cancelled = 1;
+		data->cancelled = true;
 	rpc_put_task(task);
 	dprintk("%s: done, ret = %d!\n", __func__, ret);
 	trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
 	if (status == 0) {
 		clp->cl_clientid = cdata->res.clientid;
 		clp->cl_exchange_flags = cdata->res.flags;
+		clp->cl_seqid = cdata->res.seqid;
 		/* Client ID is not confirmed */
-		if (!(cdata->res.flags & EXCHGID4_FLAG_CONFIRMED_R)) {
+		if (!(cdata->res.flags & EXCHGID4_FLAG_CONFIRMED_R))
 			clear_bit(NFS4_SESSION_ESTABLISHED,
-			&clp->cl_session->session_state);
+				  &clp->cl_session->session_state);
-			clp->cl_seqid = cdata->res.seqid;
-		}
 		kfree(clp->cl_serverowner);
 		clp->cl_serverowner = cdata->res.server_owner;
 	.getattr	= nfs4_proc_getattr,
 	.setattr	= nfs4_proc_setattr,
 	.lookup		= nfs4_proc_lookup,
+	.lookupp	= nfs4_proc_lookupp,
 	.access		= nfs4_proc_access,
 	.readlink	= nfs4_proc_readlink,
 	.create		= nfs4_proc_create,

fs/nfs/nfs4state.c+11−5

 	if (clp != *result)
 		return 0;
-	/* Purge state if the client id was established in a prior instance */
+	/*
-	if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R)
+	 * Purge state if the client id was established in a prior
-		set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
+	 * instance and the client id could not have arrived on the
-	else
+	 * server via Transparent State Migration.
-		set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
+	 */
+	if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R) {
+		if (!test_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags))
+			set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
+		else
+			set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
+	}
 	nfs4_schedule_state_manager(clp);
 	status = nfs_wait_client_init_complete(clp);
 	if (status < 0)

fs/nfs/nfs4trace.h+29−0

@@ -891,6 +891,35 @@ DEFINE_NFS4_LOOKUP_EVENT(nfs4_remove); · 890 unmodified lines
891	DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);	891	DEFINE_NFS4_LOOKUP_EVENT(nfs4_get_fs_locations);
892	DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);	892	DEFINE_NFS4_LOOKUP_EVENT(nfs4_secinfo);
893		893
		894	TRACE_EVENT(nfs4_lookupp,
		895	TP_PROTO(
		896	const struct inode *inode,
		897	int error
		898	),
		899
		900	TP_ARGS(inode, error),
		901
		902	TP_STRUCT__entry(
		903	__field(dev_t, dev)
		904	__field(u64, ino)
		905	__field(int, error)
		906	),
		907
		908	TP_fast_assign(
		909	__entry->dev = inode->i_sb->s_dev;
		910	__entry->ino = NFS_FILEID(inode);
		911	__entry->error = error;
		912	),
		913
		914	TP_printk(
		915	"error=%d (%s) inode=%02x:%02x:%llu",
		916	__entry->error,
		917	show_nfsv4_errors(__entry->error),
		918	MAJOR(__entry->dev), MINOR(__entry->dev),
		919	(unsigned long long)__entry->ino
		920	)
		921	);
		922
894	TRACE_EVENT(nfs4_rename,	923	TRACE_EVENT(nfs4_rename,
895	TP_PROTO(	924	TP_PROTO(
896	const struct inode *olddir,	925	const struct inode *olddir,

fs/nfs/nfs4xdr.c+76−1

@@ -159,6 +159,8 @@ static int nfs4_stat_to_errno(int); · 158 unmodified lines
159	(op_decode_hdr_maxsz)	159	(op_decode_hdr_maxsz)
160	#define encode_lookup_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)	160	#define encode_lookup_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
161	#define decode_lookup_maxsz (op_decode_hdr_maxsz)	161	#define decode_lookup_maxsz (op_decode_hdr_maxsz)
		162	#define encode_lookupp_maxsz (op_encode_hdr_maxsz)
		163	#define decode_lookupp_maxsz (op_decode_hdr_maxsz)
162	#define encode_share_access_maxsz \	164	#define encode_share_access_maxsz \
163	(2)	165	(2)
164	#define encode_createmode_maxsz (1 + encode_attrs_maxsz + encode_verifier_maxsz)	166	#define encode_createmode_maxsz (1 + encode_attrs_maxsz + encode_verifier_maxsz)
@@ -618,6 +620,18 @@ static int nfs4_stat_to_errno(int); · 453 unmodified lines
618	decode_lookup_maxsz + \	620	decode_lookup_maxsz + \
619	decode_getattr_maxsz + \	621	decode_getattr_maxsz + \
620	decode_getfh_maxsz)	622	decode_getfh_maxsz)
		623	#define NFS4_enc_lookupp_sz (compound_encode_hdr_maxsz + \
		624	encode_sequence_maxsz + \
		625	encode_putfh_maxsz + \
		626	encode_lookupp_maxsz + \
		627	encode_getattr_maxsz + \
		628	encode_getfh_maxsz)
		629	#define NFS4_dec_lookupp_sz (compound_decode_hdr_maxsz + \
		630	decode_sequence_maxsz + \
		631	decode_putfh_maxsz + \
		632	decode_lookupp_maxsz + \
		633	decode_getattr_maxsz + \
		634	decode_getfh_maxsz)
621	#define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \	635	#define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
622	encode_sequence_maxsz + \	636	encode_sequence_maxsz + \
623	encode_putrootfh_maxsz + \	637	encode_putrootfh_maxsz + \
@@ -1368,6 +1382,11 @@ static void encode_lookup(struct xdr_stream xdr, const struct qstr name, struc · 744 unmodified lines
1368	encode_string(xdr, name->len, name->name);	1382	encode_string(xdr, name->len, name->name);
1369	}	1383	}
1370		1384
		1385	static void encode_lookupp(struct xdr_stream xdr, struct compound_hdr hdr)
		1386	{
		1387	encode_op_hdr(xdr, OP_LOOKUPP, decode_lookupp_maxsz, hdr);
		1388	}
		1389
1371	static void encode_share_access(struct xdr_stream *xdr, u32 share_access)	1390	static void encode_share_access(struct xdr_stream *xdr, u32 share_access)
1372	{	1391	{
1373	__be32 *p;	1392	__be32 *p;
@@ -2122,6 +2141,26 @@ static void nfs4_xdr_enc_lookup(struct rpc_rqst req, struct xdr_stream xdr, · 748 unmodified lines
2122	encode_nops(&hdr);	2141	encode_nops(&hdr);
2123	}	2142	}
2124		2143
		2144	/*
		2145	* Encode LOOKUPP request
		2146	*/
		2147	static void nfs4_xdr_enc_lookupp(struct rpc_rqst req, struct xdr_stream xdr,
		2148	const void *data)
		2149	{
		2150	const struct nfs4_lookupp_arg *args = data;
		2151	struct compound_hdr hdr = {
		2152	.minorversion = nfs4_xdr_minorversion(&args->seq_args),
		2153	};
		2154
		2155	encode_compound_hdr(xdr, req, &hdr);
		2156	encode_sequence(xdr, &args->seq_args, &hdr);
		2157	encode_putfh(xdr, args->fh, &hdr);
		2158	encode_lookupp(xdr, &hdr);
		2159	encode_getfh(xdr, &hdr);
		2160	encode_getfattr(xdr, args->bitmask, &hdr);
		2161	encode_nops(&hdr);
		2162	}
		2163
2125	/*	2164	/*
2126	* Encode LOOKUP_ROOT request	2165	* Encode LOOKUP_ROOT request
2127	*/	2166	*/
@@ -5058,6 +5097,11 @@ static int decode_lookup(struct xdr_stream *xdr) · 2930 unmodified lines
5058	return decode_op_hdr(xdr, OP_LOOKUP);	5097	return decode_op_hdr(xdr, OP_LOOKUP);
5059	}	5098	}
5060		5099
		5100	static int decode_lookupp(struct xdr_stream *xdr)
		5101	{
		5102	return decode_op_hdr(xdr, OP_LOOKUPP);
		5103	}
		5104
5061	/* This is too sick! */	5105	/* This is too sick! */
5062	static int decode_space_limit(struct xdr_stream *xdr,	5106	static int decode_space_limit(struct xdr_stream *xdr,
5063	unsigned long *pagemod_limit)	5107	unsigned long *pagemod_limit)
@@ -6237,6 +6281,36 @@ out: · 1173 unmodified lines
6237	return status;	6281	return status;
6238	}	6282	}
6239		6283
		6284	/*
		6285	* Decode LOOKUPP response
		6286	*/
		6287	static int nfs4_xdr_dec_lookupp(struct rpc_rqst rqstp, struct xdr_stream xdr,
		6288	void *data)
		6289	{
		6290	struct nfs4_lookupp_res *res = data;
		6291	struct compound_hdr hdr;
		6292	int status;
		6293
		6294	status = decode_compound_hdr(xdr, &hdr);
		6295	if (status)
		6296	goto out;
		6297	status = decode_sequence(xdr, &res->seq_res, rqstp);
		6298	if (status)
		6299	goto out;
		6300	status = decode_putfh(xdr);
		6301	if (status)
		6302	goto out;
		6303	status = decode_lookupp(xdr);
		6304	if (status)
		6305	goto out;
		6306	status = decode_getfh(xdr, res->fh);
		6307	if (status)
		6308	goto out;
		6309	status = decode_getfattr_label(xdr, res->fattr, res->label, res->server);
		6310	out:
		6311	return status;
		6312	}
		6313
6240	/*	6314	/*
6241	* Decode LOOKUP_ROOT response	6315	* Decode LOOKUP_ROOT response
6242	*/	6316	*/
@@ -7447,7 +7521,7 @@ out: · 1204 unmodified lines
7447	* on a directory already in our cache.	7521	* on a directory already in our cache.
7448	*/	7522	*/
7449	int nfs4_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,	7523	int nfs4_decode_dirent(struct xdr_stream xdr, struct nfs_entry entry,
7450	int plus)	7524	bool plus)
7451	{	7525	{
7452	unsigned int savep;	7526	unsigned int savep;
7453	uint32_t bitmap[3] = {0};	7527	uint32_t bitmap[3] = {0};
@@ -7614,6 +7688,7 @@ const struct rpc_procinfo nfs4_procedures[] = { · 160 unmodified lines
7614	PROC(ACCESS, enc_access, dec_access),	7688	PROC(ACCESS, enc_access, dec_access),
7615	PROC(GETATTR, enc_getattr, dec_getattr),	7689	PROC(GETATTR, enc_getattr, dec_getattr),
7616	PROC(LOOKUP, enc_lookup, dec_lookup),	7690	PROC(LOOKUP, enc_lookup, dec_lookup),
		7691	PROC(LOOKUPP, enc_lookupp, dec_lookupp),
7617	PROC(LOOKUP_ROOT, enc_lookup_root, dec_lookup_root),	7692	PROC(LOOKUP_ROOT, enc_lookup_root, dec_lookup_root),
7618	PROC(REMOVE, enc_remove, dec_remove),	7693	PROC(REMOVE, enc_remove, dec_remove),
7619	PROC(RENAME, enc_rename, dec_rename),	7694	PROC(RENAME, enc_rename, dec_rename),

fs/nfs/pagelist.c+20−3

 	hdr->cred = hdr->req->wb_context->cred;
 	hdr->io_start = req_offset(hdr->req);
 	hdr->good_bytes = mirror->pg_count;
+	hdr->io_completion = desc->pg_io_completion;
 	hdr->dreq = desc->pg_dreq;
-	hdr->layout_private = desc->pg_layout_private;
 	hdr->release = release;
 	hdr->completion_ops = desc->pg_completion_ops;
 	if (hdr->completion_ops->init_hdr)
 	if (!test_and_set_bit(PG_HEADLOCK, &head->wb_flags))
 		return 0;
-	if (!nonblock)
+	if (!nonblock) {
+		set_bit(PG_CONTENDED1, &head->wb_flags);
+		smp_mb__after_atomic();
 		return wait_on_bit_lock(&head->wb_flags, PG_HEADLOCK,
 				TASK_UNINTERRUPTIBLE);
+	}
 	return -EAGAIN;
 }
 	WARN_ON_ONCE(head != head->wb_head);
+	if (!test_bit(PG_HEADLOCK, &head->wb_flags))
+		return;
+	set_bit(PG_CONTENDED1, &head->wb_flags);
+	smp_mb__after_atomic();
 	wait_on_bit(&head->wb_flags, PG_HEADLOCK,
 		TASK_UNINTERRUPTIBLE);
 }
 	smp_mb__before_atomic();
 	clear_bit(PG_HEADLOCK, &head->wb_flags);
 	smp_mb__after_atomic();
+	if (!test_bit(PG_CONTENDED1, &head->wb_flags))
+		return;
 	wake_up_bit(&head->wb_flags, PG_HEADLOCK);
 }
 	smp_mb__before_atomic();
 	clear_bit(PG_BUSY, &req->wb_flags);
 	smp_mb__after_atomic();
+	if (!test_bit(PG_CONTENDED2, &req->wb_flags))
+		return;
 	wake_up_bit(&req->wb_flags, PG_BUSY);
 }
 int
 nfs_wait_on_request(struct nfs_page *req)
 {
+	if (!test_bit(PG_BUSY, &req->wb_flags))
+		return 0;
+	set_bit(PG_CONTENDED2, &req->wb_flags);
+	smp_mb__after_atomic();
 	return wait_on_bit_io(&req->wb_flags, PG_BUSY,
 			      TASK_UNINTERRUPTIBLE);
 }
 	desc->pg_ioflags = io_flags;
 	desc->pg_error = 0;
 	desc->pg_lseg = NULL;
+	desc->pg_io_completion = NULL;
 	desc->pg_dreq = NULL;
-	desc->pg_layout_private = NULL;
 	desc->pg_bsize = bsize;
 	desc->pg_mirror_count = 1;
 	gfp_t gfp_flags = GFP_KERNEL;
 	pagecount = nfs_page_array_len(mirror->pg_base, mirror->pg_count);
+	pg_array->npages = pagecount;
 	if (pagecount <= ARRAY_SIZE(pg_array->page_array))
 		pg_array->pagevec = pg_array->page_array;
 {
 	LIST_HEAD(failed);
+	desc->pg_io_completion = hdr->io_completion;
 	desc->pg_dreq = hdr->dreq;
 	while (!list_empty(&hdr->pages)) {
 		struct nfs_page *req = nfs_list_entry(hdr->pages.next);

fs/nfs/proc.c+1−1

@@ -485,7 +485,7 @@ nfs_proc_rmdir(struct inode dir, const struct qstr name) · 484 unmodified lines
485	*/	485	*/
486	static int	486	static int
487	nfs_proc_readdir(struct dentry dentry, struct rpc_cred cred,	487	nfs_proc_readdir(struct dentry dentry, struct rpc_cred cred,
488	u64 cookie, struct page **pages, unsigned int count, int plus)	488	u64 cookie, struct page **pages, unsigned int count, bool plus)
489	{	489	{
490	struct inode *dir = d_inode(dentry);	490	struct inode *dir = d_inode(dentry);
491	struct nfs_readdirargs arg = {	491	struct nfs_readdirargs arg = {

fs/nfs/super.c+3−1

 	if (nfss->options & NFS_OPTION_FSCACHE) {
 		seq_printf(m, "\n\tfsc:\t");
 		for (i = 0; i < __NFSIOS_FSCACHEMAX; i++)
-			seq_printf(m, "%Lu ", totals.bytes[i]);
+			seq_printf(m, "%Lu ", totals.fscache[i]);
 	}
 #endif
 	seq_printf(m, "\n");
 		 */
 		sb->s_flags |= MS_POSIXACL;
 		sb->s_time_gran = 1;
+		sb->s_export_op = &nfs_export_ops;
 	}
  	nfs_initialise_sb(sb);
 	sb->s_xattr = old_sb->s_xattr;
 	sb->s_op = old_sb->s_op;
 	sb->s_time_gran = 1;
+	sb->s_export_op = old_sb->s_export_op;
 	if (server->nfs_client->rpc_ops->version != 2) {
 		/* The VFS shouldn't apply the umask to mode bits. We will do

fs/nfs/unlink.c+13−0

@@ -288,6 +288,19 @@ static void nfs_async_rename_release(void *calldata) · 287 unmodified lines
288	if (d_really_is_positive(data->old_dentry))	288	if (d_really_is_positive(data->old_dentry))
289	nfs_mark_for_revalidate(d_inode(data->old_dentry));	289	nfs_mark_for_revalidate(d_inode(data->old_dentry));
290		290
		291	/* The result of the rename is unknown. Play it safe by
		292	* forcing a new lookup */
		293	if (data->cancelled) {
		294	spin_lock(&data->old_dir->i_lock);
		295	nfs_force_lookup_revalidate(data->old_dir);
		296	spin_unlock(&data->old_dir->i_lock);
		297	if (data->new_dir != data->old_dir) {
		298	spin_lock(&data->new_dir->i_lock);
		299	nfs_force_lookup_revalidate(data->new_dir);
		300	spin_unlock(&data->new_dir->i_lock);
		301	}
		302	}
		303
291	dput(data->old_dentry);	304	dput(data->old_dentry);
292	dput(data->new_dentry);	305	dput(data->new_dentry);
293	iput(data->old_dir);	306	iput(data->old_dir);

fs/nfs/write.c+58−1

@@ -40,6 +40,12 @@ · 39 unmodified lines
40	#define MIN_POOL_WRITE (32)	40	#define MIN_POOL_WRITE (32)
41	#define MIN_POOL_COMMIT (4)	41	#define MIN_POOL_COMMIT (4)
42		42
		43	struct nfs_io_completion {
		44	void (complete)(void data);
		45	void *data;
		46	struct kref refcount;
		47	};
		48
43	/*	49	/*
44	* Local function declarations	50	* Local function declarations
45	*/	51	*/
@@ -108,6 +114,39 @@ static void nfs_writehdr_free(struct nfs_pgio_header *hdr) · 62 unmodified lines
108	mempool_free(hdr, nfs_wdata_mempool);	114	mempool_free(hdr, nfs_wdata_mempool);
109	}	115	}
110		116
		117	static struct nfs_io_completion *nfs_io_completion_alloc(gfp_t gfp_flags)
		118	{
		119	return kmalloc(sizeof(struct nfs_io_completion), gfp_flags);
		120	}
		121
		122	static void nfs_io_completion_init(struct nfs_io_completion *ioc,
		123	void (complete)(void ), void *data)
		124	{
		125	ioc->complete = complete;
		126	ioc->data = data;
		127	kref_init(&ioc->refcount);
		128	}
		129
		130	static void nfs_io_completion_release(struct kref *kref)
		131	{
		132	struct nfs_io_completion *ioc = container_of(kref,
		133	struct nfs_io_completion, refcount);
		134	ioc->complete(ioc->data);
		135	kfree(ioc);
		136	}
		137
		138	static void nfs_io_completion_get(struct nfs_io_completion *ioc)
		139	{
		140	if (ioc != NULL)
		141	kref_get(&ioc->refcount);
		142	}
		143
		144	static void nfs_io_completion_put(struct nfs_io_completion *ioc)
		145	{
		146	if (ioc != NULL)
		147	kref_put(&ioc->refcount, nfs_io_completion_release);
		148	}
		149
111	static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)	150	static void nfs_context_set_write_error(struct nfs_open_context *ctx, int error)
112	{	151	{
113	ctx->error = error;	152	ctx->error = error;
@@ -681,18 +720,29 @@ static int nfs_writepages_callback(struct page page, struct writeback_control · 567 unmodified lines
681	return ret;	720	return ret;
682	}	721	}
683		722
		723	static void nfs_io_completion_commit(void *inode)
		724	{
		725	nfs_commit_inode(inode, 0);
		726	}
		727
684	int nfs_writepages(struct address_space mapping, struct writeback_control wbc)	728	int nfs_writepages(struct address_space mapping, struct writeback_control wbc)
685	{	729	{
686	struct inode *inode = mapping->host;	730	struct inode *inode = mapping->host;
687	struct nfs_pageio_descriptor pgio;	731	struct nfs_pageio_descriptor pgio;
		732	struct nfs_io_completion *ioc = nfs_io_completion_alloc(GFP_NOFS);
688	int err;	733	int err;
689		734
690	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);	735	nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGES);
691		736
		737	if (ioc)
		738	nfs_io_completion_init(ioc, nfs_io_completion_commit, inode);
		739
692	nfs_pageio_init_write(&pgio, inode, wb_priority(wbc), false,	740	nfs_pageio_init_write(&pgio, inode, wb_priority(wbc), false,
693	&nfs_async_write_completion_ops);	741	&nfs_async_write_completion_ops);
		742	pgio.pg_io_completion = ioc;
694	err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);	743	err = write_cache_pages(mapping, wbc, nfs_writepages_callback, &pgio);
695	nfs_pageio_complete(&pgio);	744	nfs_pageio_complete(&pgio);
		745	nfs_io_completion_put(ioc);
696		746
697	if (err < 0)	747	if (err < 0)
698	goto out_err;	748	goto out_err;
@@ -940,6 +990,11 @@ int nfs_write_need_commit(struct nfs_pgio_header *hdr) · 241 unmodified lines
940	return hdr->verf.committed != NFS_FILE_SYNC;	990	return hdr->verf.committed != NFS_FILE_SYNC;
941	}	991	}
942		992
		993	static void nfs_async_write_init(struct nfs_pgio_header *hdr)
		994	{
		995	nfs_io_completion_get(hdr->io_completion);
		996	}
		997
943	static void nfs_write_completion(struct nfs_pgio_header *hdr)	998	static void nfs_write_completion(struct nfs_pgio_header *hdr)
944	{	999	{
945	struct nfs_commit_info cinfo;	1000	struct nfs_commit_info cinfo;
@@ -973,6 +1028,7 @@ next: · 27 unmodified lines
973	nfs_release_request(req);	1028	nfs_release_request(req);
974	}	1029	}
975	out:	1030	out:
		1031	nfs_io_completion_put(hdr->io_completion);
976	hdr->release(hdr);	1032	hdr->release(hdr);
977	}	1033	}
978		1034
@@ -1378,6 +1434,7 @@ static void nfs_async_write_reschedule_io(struct nfs_pgio_header *hdr) · 399 unmodified lines
1378	}	1434	}
1379		1435
1380	static const struct nfs_pgio_completion_ops nfs_async_write_completion_ops = {	1436	static const struct nfs_pgio_completion_ops nfs_async_write_completion_ops = {
		1437	.init_hdr = nfs_async_write_init,
1381	.error_cleanup = nfs_async_write_error,	1438	.error_cleanup = nfs_async_write_error,
1382	.completion = nfs_write_completion,	1439	.completion = nfs_write_completion,
1383	.reschedule_io = nfs_async_write_reschedule_io,	1440	.reschedule_io = nfs_async_write_reschedule_io,
@@ -1884,7 +1941,7 @@ int nfs_write_inode(struct inode inode, struct writeback_control wbc) · 500 unmodified lines
1884	/* Don't commit yet if this is a non-blocking flush and there	1941	/* Don't commit yet if this is a non-blocking flush and there
1885	* are a lot of outstanding writes for this mapping.	1942	* are a lot of outstanding writes for this mapping.
1886	*/	1943	*/
1887	if (nfsi->commit_info.ncommit <= (nfsi->nrequests >> 1))	1944	if (mapping_tagged(inode->i_mapping, PAGECACHE_TAG_WRITEBACK))
1888	goto out_mark_dirty;	1945	goto out_mark_dirty;
1889		1946
1890	/* don't wait for the COMMIT response */	1947	/* don't wait for the COMMIT response */

include/linux/nfs4.h+1−0

@@ -479,6 +479,7 @@ enum { · 478 unmodified lines
479	NFSPROC4_CLNT_ACCESS,	479	NFSPROC4_CLNT_ACCESS,
480	NFSPROC4_CLNT_GETATTR,	480	NFSPROC4_CLNT_GETATTR,
481	NFSPROC4_CLNT_LOOKUP,	481	NFSPROC4_CLNT_LOOKUP,
		482	NFSPROC4_CLNT_LOOKUPP,
482	NFSPROC4_CLNT_LOOKUP_ROOT,	483	NFSPROC4_CLNT_LOOKUP_ROOT,
483	NFSPROC4_CLNT_REMOVE,	484	NFSPROC4_CLNT_REMOVE,
484	NFSPROC4_CLNT_RENAME,	485	NFSPROC4_CLNT_RENAME,

include/linux/nfs_fs.h+1−0

@@ -332,6 +332,7 @@ extern void nfs_zap_caches(struct inode *); · 331 unmodified lines
332	extern void nfs_invalidate_atime(struct inode *);	332	extern void nfs_invalidate_atime(struct inode *);
333	extern struct inode nfs_fhget(struct super_block , struct nfs_fh *,	333	extern struct inode nfs_fhget(struct super_block , struct nfs_fh *,
334	struct nfs_fattr , struct nfs4_label );	334	struct nfs_fattr , struct nfs4_label );
		335	struct inode nfs_ilookup(struct super_block sb, struct nfs_fattr , struct nfs_fh );
335	extern int nfs_refresh_inode(struct inode , struct nfs_fattr );	336	extern int nfs_refresh_inode(struct inode , struct nfs_fattr );
336	extern int nfs_post_op_update_inode(struct inode inode, struct nfs_fattr fattr);	337	extern int nfs_post_op_update_inode(struct inode inode, struct nfs_fattr fattr);
337	extern int nfs_post_op_update_inode_force_wcc(struct inode inode, struct nfs_fattr fattr);	338	extern int nfs_post_op_update_inode_force_wcc(struct inode inode, struct nfs_fattr fattr);

include/linux/nfs_fs_sb.h+2−0

 #define NFS_CS_MIGRATION	2		/* - transparent state migr */
 #define NFS_CS_INFINITE_SLOTS	3		/* - don't limit TCP slots */
 #define NFS_CS_NO_RETRANS_TIMEOUT	4	/* - Disable retransmit timeouts */
+#define NFS_CS_TSM_POSSIBLE	5		/* - Maybe state migration */
 	struct sockaddr_storage	cl_addr;	/* server identifier */
 	size_t			cl_addrlen;
 	char *			cl_hostname;	/* hostname of server */
 	unsigned long		mig_status;
 #define NFS_MIG_IN_TRANSITION		(1)
 #define NFS_MIG_FAILED			(2)
+#define NFS_MIG_TSM_POSSIBLE		(3)
 	void (*destroy)(struct nfs_server *);

include/linux/nfs_page.h+3−1

 	PG_UPTODATE,		/* page group sync bit in read path */
 	PG_WB_END,		/* page group sync bit in write path */
 	PG_REMOVE,		/* page group sync bit in write path */
+	PG_CONTENDED1,		/* Is someone waiting for a lock? */
+	PG_CONTENDED2,		/* Is someone waiting for a lock? */
 };
 struct nfs_inode;
 	const struct rpc_call_ops *pg_rpc_callops;
 	const struct nfs_pgio_completion_ops *pg_completion_ops;
 	struct pnfs_layout_segment *pg_lseg;
+	struct nfs_io_completion *pg_io_completion;
 	struct nfs_direct_req	*pg_dreq;
-	void			*pg_layout_private;
 	unsigned int		pg_bsize;	/* default bsize for mirrors */
 	u32			pg_mirror_count;

include/linux/nfs_xdr.h+24−7

 	struct nfs_fh *		fh;
 	__u64			cookie;
 	__be32			verf[2];
-	int			plus;
+	bool			plus;
 	unsigned int            count;
 	struct page **		pages;
 };
 struct nfs3_readdirres {
 	struct nfs_fattr *	dir_attr;
 	__be32 *		verf;
-	int			plus;
+	bool			plus;
 };
 struct nfs3_getaclres {
 	struct nfs_fattr *		dir_attr;
 };
 struct nfs4_lookup_arg {
 	struct nfs4_sequence_args	seq_args;
 	const struct nfs_fh *		dir_fh;
 	struct nfs4_label		*label;
 };
+struct nfs4_lookupp_arg {
+	struct nfs4_sequence_args	seq_args;
+	const struct nfs_fh		*fh;
+	const u32			*bitmask;
+};
+struct nfs4_lookupp_res {
+	struct nfs4_sequence_res	seq_res;
+	const struct nfs_server		*server;
+	struct nfs_fattr		*fattr;
+	struct nfs_fh			*fh;
+	struct nfs4_label		*label;
+};
 struct nfs4_lookup_root_arg {
 	struct nfs4_sequence_args	seq_args;
 	const u32 *			bitmask;
 	struct page **			pages;	/* zero-copy data */
 	unsigned int			pgbase;	/* zero-copy data */
 	const u32 *			bitmask;
-	int				plus;
+	bool				plus;
 };
 struct nfs4_readdir_res {
 	NFS_IOHDR_STAT,
 };
+struct nfs_io_completion;
 struct nfs_pgio_header {
 	struct inode		*inode;
 	struct rpc_cred		*cred;
 	void (*release) (struct nfs_pgio_header *hdr);
 	const struct nfs_pgio_completion_ops *completion_ops;
 	const struct nfs_rw_ops	*rw_ops;
+	struct nfs_io_completion *io_completion;
 	struct nfs_direct_req	*dreq;
-	void			*layout_private;
 	spinlock_t		lock;
 	/* fields protected by lock */
 	int			pnfs_error;
 	struct nfs_fattr	new_fattr;
 	void (*complete)(struct rpc_task *, struct nfs_renamedata *);
 	long timeout;
+	bool cancelled;
 };
 struct nfs_access_entry;
 	int	(*lookup)  (struct inode *, const struct qstr *,
 			    struct nfs_fh *, struct nfs_fattr *,
 			    struct nfs4_label *);
+	int	(*lookupp) (struct inode *, struct nfs_fh *,
+			    struct nfs_fattr *, struct nfs4_label *);
 	int	(*access)  (struct inode *, struct nfs_access_entry *);
 	int	(*readlink)(struct inode *, struct page *, unsigned int,
 			    unsigned int);
 	int	(*mkdir)   (struct inode *, struct dentry *, struct iattr *);
 	int	(*rmdir)   (struct inode *, const struct qstr *);
 	int	(*readdir) (struct dentry *, struct rpc_cred *,
-			    u64, struct page **, unsigned int, int);
+			    u64, struct page **, unsigned int, bool);
 	int	(*mknod)   (struct inode *, struct dentry *, struct iattr *,
 			    dev_t);
 	int	(*statfs)  (struct nfs_server *, struct nfs_fh *,
 	int	(*pathconf) (struct nfs_server *, struct nfs_fh *,
 			     struct nfs_pathconf *);
 	int	(*set_capabilities)(struct nfs_server *, struct nfs_fh *);
-	int	(*decode_dirent)(struct xdr_stream *, struct nfs_entry *, int);
+	int	(*decode_dirent)(struct xdr_stream *, struct nfs_entry *, bool);
 	int	(*pgio_rpc_prepare)(struct rpc_task *,
 				    struct nfs_pgio_header *);
 	void	(*read_setup)(struct nfs_pgio_header *, struct rpc_message *);

net/sunrpc/auth_gss/gss_krb5_crypto.c+2−1

  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
+#include <crypto/algapi.h>
 #include <crypto/hash.h>
 #include <crypto/skcipher.h>
 #include <linux/err.h>
 	if (ret)
 		goto out_err;
-	if (memcmp(pkt_hmac, our_hmac, kctx->gk5e->cksumlength) != 0) {
+	if (crypto_memneq(pkt_hmac, our_hmac, kctx->gk5e->cksumlength) != 0) {
 		ret = GSS_S_BAD_SIG;
 		goto out_err;
 	}

net/sunrpc/xprt.c+5−3

 	return ret;
 }
-static struct rpc_rqst *xprt_dynamic_alloc_slot(struct rpc_xprt *xprt, gfp_t gfp_flags)
+static struct rpc_rqst *xprt_dynamic_alloc_slot(struct rpc_xprt *xprt)
 {
 	struct rpc_rqst *req = ERR_PTR(-EAGAIN);
 	if (!atomic_add_unless(&xprt->num_reqs, 1, xprt->max_reqs))
 		goto out;
-	req = kzalloc(sizeof(struct rpc_rqst), gfp_flags);
+	spin_unlock(&xprt->reserve_lock);
+	req = kzalloc(sizeof(struct rpc_rqst), GFP_NOFS);
+	spin_lock(&xprt->reserve_lock);
 	if (req != NULL)
 		goto out;
 	atomic_dec(&xprt->num_reqs);
 		list_del(&req->rq_list);
 		goto out_init_req;
 	}
-	req = xprt_dynamic_alloc_slot(xprt, GFP_NOWAIT|__GFP_NOWARN);
+	req = xprt_dynamic_alloc_slot(xprt);
 	if (!IS_ERR(req))
 		goto out_init_req;
 	switch (PTR_ERR(req)) {

net/sunrpc/xprtrdma/fmr_ops.c+26−21

 	list_add(&mw->fmr.fm_mr->list, &l);
 	rc = ib_unmap_fmr(&l);
-	list_del_init(&mw->fmr.fm_mr->list);
+	list_del(&mw->fmr.fm_mr->list);
 	return rc;
 }
 		    offset_in_page((seg-1)->mr_offset + (seg-1)->mr_len))
 			break;
 	}
-	mw->mw_nents = i;
 	mw->mw_dir = rpcrdma_data_dir(writing);
-	if (i == 0)
-		goto out_dmamap_err;
-	if (!ib_dma_map_sg(r_xprt->rx_ia.ri_device,
+	mw->mw_nents = ib_dma_map_sg(r_xprt->rx_ia.ri_device,
-			   mw->mw_sg, mw->mw_nents, mw->mw_dir))
+				     mw->mw_sg, i, mw->mw_dir);
+	if (!mw->mw_nents)
 		goto out_dmamap_err;
 	for (i = 0, dma_pages = mw->fmr.fm_physaddrs; i < mw->mw_nents; i++)
 	return mw->mw_nents;
 out_dmamap_err:
-	pr_err("rpcrdma: failed to dma map sg %p sg_nents %u\n",
+	pr_err("rpcrdma: failed to DMA map sg %p sg_nents %d\n",
-	       mw->mw_sg, mw->mw_nents);
+	       mw->mw_sg, i);
-	rpcrdma_defer_mr_recovery(mw);
+	rpcrdma_put_mw(r_xprt, mw);
 	return -EIO;
 out_maperr:
 	pr_err("rpcrdma: ib_map_phys_fmr %u@0x%llx+%i (%d) status %i\n",
 	       len, (unsigned long long)dma_pages[0],
 	       pageoff, mw->mw_nents, rc);
-	rpcrdma_defer_mr_recovery(mw);
+	ib_dma_unmap_sg(r_xprt->rx_ia.ri_device,
+			mw->mw_sg, mw->mw_nents, mw->mw_dir);
+	rpcrdma_put_mw(r_xprt, mw);
 	return -EIO;
 }
  * Sleeps until it is safe for the host CPU to access the
  * previously mapped memory regions.
  *
- * Caller ensures that req->rl_registered is not empty.
+ * Caller ensures that @mws is not empty before the call. This
+ * function empties the list.
  */
 static void
-fmr_op_unmap_sync(struct rpcrdma_xprt *r_xprt, struct rpcrdma_req *req)
+fmr_op_unmap_sync(struct rpcrdma_xprt *r_xprt, struct list_head *mws)
 {
-	struct rpcrdma_mw *mw, *tmp;
+	struct rpcrdma_mw *mw;
 	LIST_HEAD(unmap_list);
 	int rc;
-	dprintk("RPC:       %s: req %p\n", __func__, req);
 	/* ORDER: Invalidate all of the req's MRs first
 	 *
 	 * ib_unmap_fmr() is slow, so use a single call instead
 	 * of one call per mapped FMR.
 	 */
-	list_for_each_entry(mw, &req->rl_registered, mw_list)
+	list_for_each_entry(mw, mws, mw_list) {
+		dprintk("RPC:       %s: unmapping fmr %p\n",
+			__func__, &mw->fmr);
 		list_add_tail(&mw->fmr.fm_mr->list, &unmap_list);
+	}
 	r_xprt->rx_stats.local_inv_needed++;
 	rc = ib_unmap_fmr(&unmap_list);
 	if (rc)
 	/* ORDER: Now DMA unmap all of the req's MRs, and return
 	 * them to the free MW list.
 	 */
-	list_for_each_entry_safe(mw, tmp, &req->rl_registered, mw_list) {
+	while (!list_empty(mws)) {
-		list_del_init(&mw->mw_list);
+		mw = rpcrdma_pop_mw(mws);
-		list_del_init(&mw->fmr.fm_mr->list);
+		dprintk("RPC:       %s: DMA unmapping fmr %p\n",
+			__func__, &mw->fmr);
+		list_del(&mw->fmr.fm_mr->list);
 		ib_dma_unmap_sg(r_xprt->rx_ia.ri_device,
 				mw->mw_sg, mw->mw_nents, mw->mw_dir);
 		rpcrdma_put_mw(r_xprt, mw);
 out_reset:
 	pr_err("rpcrdma: ib_unmap_fmr failed (%i)\n", rc);
-	list_for_each_entry_safe(mw, tmp, &req->rl_registered, mw_list) {
+	while (!list_empty(mws)) {
-		list_del_init(&mw->fmr.fm_mr->list);
+		mw = rpcrdma_pop_mw(mws);
+		list_del(&mw->fmr.fm_mr->list);
 		fmr_op_recover_mr(mw);
 	}
 }

net/sunrpc/xprtrdma/frwr_ops.c+33−36

@@ -277,7 +277,7 @@ __frwr_sendcompletion_flush(struct ib_wc wc, const char wr) · 276 unmodified lines
277	}	277	}
278		278
279	/**	279	/**
280	* frwr_wc_fastreg - Invoked by RDMA provider for each polled FastReg WC	280	* frwr_wc_fastreg - Invoked by RDMA provider for a flushed FastReg WC
281	* @cq: completion queue (ignored)	281	* @cq: completion queue (ignored)
282	* @wc: completed WR	282	* @wc: completed WR
283	*	283	*
@@ -298,7 +298,7 @@ frwr_wc_fastreg(struct ib_cq cq, struct ib_wc wc) · 14 unmodified lines
298	}	298	}
299		299
300	/**	300	/**
301	* frwr_wc_localinv - Invoked by RDMA provider for each polled LocalInv WC	301	* frwr_wc_localinv - Invoked by RDMA provider for a flushed LocalInv WC
302	* @cq: completion queue (ignored)	302	* @cq: completion queue (ignored)
303	* @wc: completed WR	303	* @wc: completed WR
304	*	304	*
@@ -319,7 +319,7 @@ frwr_wc_localinv(struct ib_cq cq, struct ib_wc wc) · 14 unmodified lines
319	}	319	}
320		320
321	/**	321	/**
322	* frwr_wc_localinv - Invoked by RDMA provider for each polled LocalInv WC	322	* frwr_wc_localinv_wake - Invoked by RDMA provider for a signaled LocalInv WC
323	* @cq: completion queue (ignored)	323	* @cq: completion queue (ignored)
324	* @wc: completed WR	324	* @wc: completed WR
325	*	325	*
@@ -355,7 +355,7 @@ frwr_op_map(struct rpcrdma_xprt r_xprt, struct rpcrdma_mr_seg seg, · 29 unmodified lines
355	struct ib_mr *mr;	355	struct ib_mr *mr;
356	struct ib_reg_wr *reg_wr;	356	struct ib_reg_wr *reg_wr;
357	struct ib_send_wr *bad_wr;	357	struct ib_send_wr *bad_wr;
358	int rc, i, n, dma_nents;	358	int rc, i, n;
359	u8 key;	359	u8 key;
360		360
361	mw = NULL;	361	mw = NULL;
@@ -391,14 +391,10 @@ frwr_op_map(struct rpcrdma_xprt r_xprt, struct rpcrdma_mr_seg seg, · 29 unmodified lines
391	offset_in_page((seg-1)->mr_offset + (seg-1)->mr_len))	391	offset_in_page((seg-1)->mr_offset + (seg-1)->mr_len))
392	break;	392	break;
393	}	393	}
394	mw->mw_nents = i;
395	mw->mw_dir = rpcrdma_data_dir(writing);	394	mw->mw_dir = rpcrdma_data_dir(writing);
396	if (i == 0)
397	goto out_dmamap_err;
398		395
399	dma_nents = ib_dma_map_sg(ia->ri_device,	396	mw->mw_nents = ib_dma_map_sg(ia->ri_device, mw->mw_sg, i, mw->mw_dir);
400	mw->mw_sg, mw->mw_nents, mw->mw_dir);	397	if (!mw->mw_nents)
401	if (!dma_nents)
402	goto out_dmamap_err;	398	goto out_dmamap_err;
403		399
404	n = ib_map_mr_sg(mr, mw->mw_sg, mw->mw_nents, NULL, PAGE_SIZE);	400	n = ib_map_mr_sg(mr, mw->mw_sg, mw->mw_nents, NULL, PAGE_SIZE);
@@ -436,13 +432,14 @@ frwr_op_map(struct rpcrdma_xprt r_xprt, struct rpcrdma_mr_seg seg, · 31 unmodified lines
436	return mw->mw_nents;	432	return mw->mw_nents;
437		433
438	out_dmamap_err:	434	out_dmamap_err:
439	pr_err("rpcrdma: failed to dma map sg %p sg_nents %u\n",	435	pr_err("rpcrdma: failed to DMA map sg %p sg_nents %d\n",
440	mw->mw_sg, mw->mw_nents);	436	mw->mw_sg, i);
441	rpcrdma_defer_mr_recovery(mw);	437	frmr->fr_state = FRMR_IS_INVALID;
		438	rpcrdma_put_mw(r_xprt, mw);
442	return -EIO;	439	return -EIO;
443		440
444	out_mapmr_err:	441	out_mapmr_err:
445	pr_err("rpcrdma: failed to map mr %p (%u/%u)\n",	442	pr_err("rpcrdma: failed to map mr %p (%d/%d)\n",
446	frmr->fr_mr, n, mw->mw_nents);	443	frmr->fr_mr, n, mw->mw_nents);
447	rpcrdma_defer_mr_recovery(mw);	444	rpcrdma_defer_mr_recovery(mw);
448	return -EIO;	445	return -EIO;
@@ -458,21 +455,19 @@ out_senderr: · 9 unmodified lines
458	* Sleeps until it is safe for the host CPU to access the	455	* Sleeps until it is safe for the host CPU to access the
459	* previously mapped memory regions.	456	* previously mapped memory regions.
460	*	457	*
461	* Caller ensures that req->rl_registered is not empty.	458	* Caller ensures that @mws is not empty before the call. This
		459	* function empties the list.
462	*/	460	*/
463	static void	461	static void
464	frwr_op_unmap_sync(struct rpcrdma_xprt r_xprt, struct rpcrdma_req req)	462	frwr_op_unmap_sync(struct rpcrdma_xprt r_xprt, struct list_head mws)
465	{	463	{
466	struct ib_send_wr first, prev, last, *bad_wr;	464	struct ib_send_wr first, prev, last, *bad_wr;
467	struct rpcrdma_rep *rep = req->rl_reply;
468	struct rpcrdma_ia *ia = &r_xprt->rx_ia;	465	struct rpcrdma_ia *ia = &r_xprt->rx_ia;
469	struct rpcrdma_frmr *f;	466	struct rpcrdma_frmr *f;
470	struct rpcrdma_mw *mw;	467	struct rpcrdma_mw *mw;
471	int count, rc;	468	int count, rc;
472		469
473	dprintk("RPC: %s: req %p\n", __func__, req);	470	/* ORDER: Invalidate all of the MRs first
474
475	/* ORDER: Invalidate all of the req's MRs first
476	*	471	*
477	* Chain the LOCAL_INV Work Requests and post them with	472	* Chain the LOCAL_INV Work Requests and post them with
478	* a single ib_post_send() call.	473	* a single ib_post_send() call.
@@ -480,11 +475,10 @@ frwr_op_unmap_sync(struct rpcrdma_xprt r_xprt, struct rpcrdma_req req) · 1 unmodified line
480	f = NULL;	475	f = NULL;
481	count = 0;	476	count = 0;
482	prev = &first;	477	prev = &first;
483	list_for_each_entry(mw, &req->rl_registered, mw_list) {	478	list_for_each_entry(mw, mws, mw_list) {
484	mw->frmr.fr_state = FRMR_IS_INVALID;	479	mw->frmr.fr_state = FRMR_IS_INVALID;
485		480
486	if ((rep->rr_wc_flags & IB_WC_WITH_INVALIDATE) &&	481	if (mw->mw_flags & RPCRDMA_MW_F_RI)
487	(mw->mw_handle == rep->rr_inv_rkey))
488	continue;	482	continue;
489		483
490	f = &mw->frmr;	484	f = &mw->frmr;
@@ -524,18 +518,19 @@ frwr_op_unmap_sync(struct rpcrdma_xprt r_xprt, struct rpcrdma_req req) · 33 unmodified lines
524	* unless ri_id->qp is a valid pointer.	518	* unless ri_id->qp is a valid pointer.
525	*/	519	*/
526	r_xprt->rx_stats.local_inv_needed++;	520	r_xprt->rx_stats.local_inv_needed++;
		521	bad_wr = NULL;
527	rc = ib_post_send(ia->ri_id->qp, first, &bad_wr);	522	rc = ib_post_send(ia->ri_id->qp, first, &bad_wr);
		523	if (bad_wr != first)
		524	wait_for_completion(&f->fr_linv_done);
528	if (rc)	525	if (rc)
529	goto reset_mrs;	526	goto reset_mrs;
530		527
531	wait_for_completion(&f->fr_linv_done);	528	/* ORDER: Now DMA unmap all of the MRs, and return
532
533	/* ORDER: Now DMA unmap all of the req's MRs, and return
534	* them to the free MW list.	529	* them to the free MW list.
535	*/	530	*/
536	unmap:	531	unmap:
537	while (!list_empty(&req->rl_registered)) {	532	while (!list_empty(mws)) {
538	mw = rpcrdma_pop_mw(&req->rl_registered);	533	mw = rpcrdma_pop_mw(mws);
539	dprintk("RPC: %s: DMA unmapping frmr %p\n",	534	dprintk("RPC: %s: DMA unmapping frmr %p\n",
540	__func__, &mw->frmr);	535	__func__, &mw->frmr);
541	ib_dma_unmap_sg(ia->ri_device,	536	ib_dma_unmap_sg(ia->ri_device,
@@ -546,17 +541,19 @@ unmap: · 4 unmodified lines
546		541
547	reset_mrs:	542	reset_mrs:
548	pr_err("rpcrdma: FRMR invalidate ib_post_send returned %i\n", rc);	543	pr_err("rpcrdma: FRMR invalidate ib_post_send returned %i\n", rc);
549	rdma_disconnect(ia->ri_id);
550		544
551	/* Find and reset the MRs in the LOCAL_INV WRs that did not	545	/* Find and reset the MRs in the LOCAL_INV WRs that did not
552	* get posted. This is synchronous, and slow.	546	* get posted.
553	*/	547	*/
554	list_for_each_entry(mw, &req->rl_registered, mw_list) {	548	rpcrdma_init_cqcount(&r_xprt->rx_ep, -count);
555	f = &mw->frmr;	549	while (bad_wr) {
556	if (mw->mw_handle == bad_wr->ex.invalidate_rkey) {	550	f = container_of(bad_wr, struct rpcrdma_frmr,
557	__frwr_reset_mr(ia, mw);	551	fr_invwr);
558	bad_wr = bad_wr->next;	552	mw = container_of(f, struct rpcrdma_mw, frmr);
559	}	553
		554	__frwr_reset_mr(ia, mw);
		555
		556	bad_wr = bad_wr->next;
560	}	557	}
561	goto unmap;	558	goto unmap;
562	}	559	}

net/sunrpc/xprtrdma/rpc_rdma.c+81−44

 	if (xdr->page_len) {
 		remaining = xdr->page_len;
-		offset = xdr->page_base & ~PAGE_MASK;
+		offset = offset_in_page(xdr->page_base);
 		count = 0;
 		while (remaining) {
 			remaining -= min_t(unsigned int,
 	len = xdrbuf->page_len;
 	ppages = xdrbuf->pages + (xdrbuf->page_base >> PAGE_SHIFT);
-	page_base = xdrbuf->page_base & ~PAGE_MASK;
+	page_base = offset_in_page(xdrbuf->page_base);
 	p = 0;
 	while (len && n < RPCRDMA_MAX_SEGS) {
 		if (!ppages[p]) {
 			goto out;
 		page = virt_to_page(xdr->tail[0].iov_base);
-		page_base = (unsigned long)xdr->tail[0].iov_base & ~PAGE_MASK;
+		page_base = offset_in_page(xdr->tail[0].iov_base);
 		/* If the content in the page list is an odd length,
 		 * xdr_write_pages() has added a pad at the beginning
 	 */
 	if (xdr->page_len) {
 		ppages = xdr->pages + (xdr->page_base >> PAGE_SHIFT);
-		page_base = xdr->page_base & ~PAGE_MASK;
+		page_base = offset_in_page(xdr->page_base);
 		remaining = xdr->page_len;
 		while (remaining) {
 			sge_no++;
 	 */
 	if (xdr->tail[0].iov_len) {
 		page = virt_to_page(xdr->tail[0].iov_base);
-		page_base = (unsigned long)xdr->tail[0].iov_base & ~PAGE_MASK;
+		page_base = offset_in_page(xdr->tail[0].iov_base);
 		len = xdr->tail[0].iov_len;
 map_tail:
 		rpclen = 0;
 	}
+	req->rl_xid = rqst->rq_xid;
+	rpcrdma_insert_req(&r_xprt->rx_buf, req);
 	/* This implementation supports the following combinations
 	 * of chunk lists in one RPC-over-RDMA Call message:
 	 *
 	srcp += curlen;
 	copy_len -= curlen;
-	page_base = rqst->rq_rcv_buf.page_base;
+	ppages = rqst->rq_rcv_buf.pages +
-	ppages = rqst->rq_rcv_buf.pages + (page_base >> PAGE_SHIFT);
+		(rqst->rq_rcv_buf.page_base >> PAGE_SHIFT);
-	page_base &= ~PAGE_MASK;
+	page_base = offset_in_page(rqst->rq_rcv_buf.page_base);
 	fixup_copy_count = 0;
 	if (copy_len && rqst->rq_rcv_buf.page_len) {
 		int pagelist_len;
 	return fixup_copy_count;
 }
+/* Caller must guarantee @rep remains stable during this call.
+ */
+static void
+rpcrdma_mark_remote_invalidation(struct list_head *mws,
+				 struct rpcrdma_rep *rep)
+{
+	struct rpcrdma_mw *mw;
+	if (!(rep->rr_wc_flags & IB_WC_WITH_INVALIDATE))
+		return;
+	list_for_each_entry(mw, mws, mw_list)
+		if (mw->mw_handle == rep->rr_inv_rkey) {
+			mw->mw_flags = RPCRDMA_MW_F_RI;
+			break; /* only one invalidated MR per RPC */
+		}
+}
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
 /* By convention, backchannel calls arrive via rdma_msg type
  * messages, and never populate the chunk lists. This makes
 {
 	struct rpcrdma_rep *rep =
 			container_of(work, struct rpcrdma_rep, rr_work);
+	struct rpcrdma_xprt *r_xprt = rep->rr_rxprt;
+	struct rpcrdma_buffer *buf = &r_xprt->rx_buf;
+	struct rpc_xprt *xprt = &r_xprt->rx_xprt;
 	struct rpcrdma_msg *headerp;
 	struct rpcrdma_req *req;
 	struct rpc_rqst *rqst;
-	struct rpcrdma_xprt *r_xprt = rep->rr_rxprt;
-	struct rpc_xprt *xprt = &r_xprt->rx_xprt;
 	__be32 *iptr;
 	int rdmalen, status, rmerr;
 	unsigned long cwnd;
+	struct list_head mws;
 	dprintk("RPC:       %s: incoming rep %p\n", __func__, rep);
 	/* Match incoming rpcrdma_rep to an rpcrdma_req to
 	 * get context for handling any incoming chunks.
 	 */
-	spin_lock_bh(&xprt->transport_lock);
+	spin_lock(&buf->rb_lock);
-	rqst = xprt_lookup_rqst(xprt, headerp->rm_xid);
+	req = rpcrdma_lookup_req_locked(&r_xprt->rx_buf,
-	if (!rqst)
+					headerp->rm_xid);
+	if (!req)
 		goto out_nomatch;
-	req = rpcr_to_rdmar(rqst);
 	if (req->rl_reply)
 		goto out_duplicate;
-	/* Sanity checking has passed. We are now committed
+	list_replace_init(&req->rl_registered, &mws);
-	 * to complete this transaction.
+	rpcrdma_mark_remote_invalidation(&mws, rep);
+	/* Avoid races with signals and duplicate replies
+	 * by marking this req as matched.
 	 */
-	list_del_init(&rqst->rq_list);
+	req->rl_reply = rep;
-	spin_unlock_bh(&xprt->transport_lock);
+	spin_unlock(&buf->rb_lock);
 	dprintk("RPC:       %s: reply %p completes request %p (xid 0x%08x)\n",
 		__func__, rep, req, be32_to_cpu(headerp->rm_xid));
-	/* from here on, the reply is no longer an orphan */
+	/* Invalidate and unmap the data payloads before waking the
-	req->rl_reply = rep;
+	 * waiting application. This guarantees the memory regions
-	xprt->reestablish_timeout = 0;
+	 * are properly fenced from the server before the application
+	 * accesses the data. It also ensures proper send flow control:
+	 * waking the next RPC waits until this RPC has relinquished
+	 * all its Send Queue entries.
+	 */
+	if (!list_empty(&mws))
+		r_xprt->rx_ia.ri_ops->ro_unmap_sync(r_xprt, &mws);
+	/* Perform XID lookup, reconstruction of the RPC reply, and
+	 * RPC completion while holding the transport lock to ensure
+	 * the rep, rqst, and rq_task pointers remain stable.
+	 */
+	spin_lock_bh(&xprt->transport_lock);
+	rqst = xprt_lookup_rqst(xprt, headerp->rm_xid);
+	if (!rqst)
+		goto out_norqst;
+	xprt->reestablish_timeout = 0;
 	if (headerp->rm_vers != rpcrdma_version)
 		goto out_badversion;
 	case rdma_msg:
 		/* never expect read chunks */
 		/* never expect reply chunks (two ways to check) */
-		/* never expect write chunks without having offered RDMA */
 		if (headerp->rm_body.rm_chunks[0] != xdr_zero ||
 		    (headerp->rm_body.rm_chunks[1] == xdr_zero &&
-		     headerp->rm_body.rm_chunks[2] != xdr_zero) ||
+		     headerp->rm_body.rm_chunks[2] != xdr_zero))
-		    (headerp->rm_body.rm_chunks[1] != xdr_zero &&
-		     list_empty(&req->rl_registered)))
 			goto badheader;
 		if (headerp->rm_body.rm_chunks[1] != xdr_zero) {
 			/* count any expected write chunks in read reply */
 		/* never expect read or write chunks, always reply chunks */
 		if (headerp->rm_body.rm_chunks[0] != xdr_zero ||
 		    headerp->rm_body.rm_chunks[1] != xdr_zero ||
-		    headerp->rm_body.rm_chunks[2] != xdr_one ||
+		    headerp->rm_body.rm_chunks[2] != xdr_one)
-		    list_empty(&req->rl_registered))
 			goto badheader;
 		iptr = (__be32 *)((unsigned char *)headerp +
 							RPCRDMA_HDRLEN_MIN);
 	}
 out:
-	/* Invalidate and flush the data payloads before waking the
-	 * waiting application. This guarantees the memory region is
-	 * properly fenced from the server before the application
-	 * accesses the data. It also ensures proper send flow
-	 * control: waking the next RPC waits until this RPC has
-	 * relinquished all its Send Queue entries.
-	 */
-	if (!list_empty(&req->rl_registered))
-		r_xprt->rx_ia.ri_ops->ro_unmap_sync(r_xprt, req);
-	spin_lock_bh(&xprt->transport_lock);
 	cwnd = xprt->cwnd;
 	xprt->cwnd = atomic_read(&r_xprt->rx_buf.rb_credits) << RPC_CWNDSHIFT;
 	if (xprt->cwnd > cwnd)
 	xprt_complete_rqst(rqst->rq_task, status);
 	spin_unlock_bh(&xprt->transport_lock);
 	dprintk("RPC:       %s: xprt_complete_rqst(0x%p, 0x%p, %d)\n",
-			__func__, xprt, rqst, status);
+		__func__, xprt, rqst, status);
 	return;
 out_badstatus:
 	r_xprt->rx_stats.bad_reply_count++;
 	goto out;
-/* If no pending RPC transaction was matched, post a replacement
+/* The req was still available, but by the time the transport_lock
- * receive buffer before returning.
+ * was acquired, the rqst and task had been released. Thus the RPC
+ * has already been terminated.
  */
+out_norqst:
+	spin_unlock_bh(&xprt->transport_lock);
+	rpcrdma_buffer_put(req);
+	dprintk("RPC:       %s: race, no rqst left for req %p\n",
+		__func__, req);
+	return;
 out_shortreply:
 	dprintk("RPC:       %s: short/invalid reply\n", __func__);
 	goto repost;
 out_nomatch:
-	spin_unlock_bh(&xprt->transport_lock);
+	spin_unlock(&buf->rb_lock);
 	dprintk("RPC:       %s: no match for incoming xid 0x%08x len %d\n",
 		__func__, be32_to_cpu(headerp->rm_xid),
 		rep->rr_len);
 	goto repost;
 out_duplicate:
-	spin_unlock_bh(&xprt->transport_lock);
+	spin_unlock(&buf->rb_lock);
 	dprintk("RPC:       %s: "
 		"duplicate reply %p to RPC request %p: xid 0x%08x\n",
 		__func__, rep, req, be32_to_cpu(headerp->rm_xid));
+/* If no pending RPC transaction was matched, post a replacement
+ * receive buffer before returning.
+ */
 repost:
 	r_xprt->rx_stats.bad_reply_count++;
 	if (rpcrdma_ep_post_recv(&r_xprt->rx_ia, rep))

net/sunrpc/xprtrdma/transport.c+2−1

@@ -684,7 +684,8 @@ xprt_rdma_free(struct rpc_task *task) · 683 unmodified lines
684		684
685	dprintk("RPC: %s: called on 0x%p\n", __func__, req->rl_reply);	685	dprintk("RPC: %s: called on 0x%p\n", __func__, req->rl_reply);
686		686
687	if (unlikely(!list_empty(&req->rl_registered)))	687	rpcrdma_remove_req(&r_xprt->rx_buf, req);
		688	if (!list_empty(&req->rl_registered))
688	ia->ri_ops->ro_unmap_safe(r_xprt, req, !RPC_IS_ASYNC(task));	689	ia->ri_ops->ro_unmap_safe(r_xprt, req, !RPC_IS_ASYNC(task));
689	rpcrdma_unmap_sges(ia, req);	690	rpcrdma_unmap_sges(ia, req);
690	rpcrdma_buffer_put(req);	691	rpcrdma_buffer_put(req);

net/sunrpc/xprtrdma/verbs.c+14−41

 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 	struct sockaddr *sap = (struct sockaddr *)&ep->rep_remote_addr;
 #endif
-	struct ib_qp_attr *attr = &ia->ri_qp_attr;
-	struct ib_qp_init_attr *iattr = &ia->ri_qp_init_attr;
 	int connstate = 0;
 	switch (event->event) {
 		break;
 	case RDMA_CM_EVENT_DEVICE_REMOVAL:
 #if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
-		pr_info("rpcrdma: removing device for %pIS:%u\n",
+		pr_info("rpcrdma: removing device %s for %pIS:%u\n",
+			ia->ri_device->name,
 			sap, rpc_get_port(sap));
 #endif
 		set_bit(RPCRDMA_IAF_REMOVING, &ia->ri_flags);
 		return 1;
 	case RDMA_CM_EVENT_ESTABLISHED:
 		connstate = 1;
-		ib_query_qp(ia->ri_id->qp, attr,
-			    IB_QP_MAX_QP_RD_ATOMIC | IB_QP_MAX_DEST_RD_ATOMIC,
-			    iattr);
-		dprintk("RPC:       %s: %d responder resources"
-			" (%d initiator)\n",
-			__func__, attr->max_dest_rd_atomic,
-			attr->max_rd_atomic);
 		rpcrdma_update_connect_private(xprt, &event->param.conn);
 		goto connected;
 	case RDMA_CM_EVENT_CONNECT_ERROR:
 		connstate = -ENETDOWN;
 		goto connected;
 	case RDMA_CM_EVENT_REJECTED:
-#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
+		dprintk("rpcrdma: connection to %pIS:%u rejected: %s\n",
-		pr_info("rpcrdma: connection to %pIS:%u on %s rejected: %s\n",
+			sap, rpc_get_port(sap),
-			sap, rpc_get_port(sap), ia->ri_device->name,
 			rdma_reject_msg(id, event->status));
-#endif
 		connstate = -ECONNREFUSED;
 		if (event->status == IB_CM_REJ_STALE_CONN)
 			connstate = -EAGAIN;
 	case RDMA_CM_EVENT_DISCONNECTED:
 		connstate = -ECONNABORTED;
 connected:
-		dprintk("RPC:       %s: %sconnected\n",
-					__func__, connstate > 0 ? "" : "dis");
 		atomic_set(&xprt->rx_buf.rb_credits, 1);
 		ep->rep_connected = connstate;
 		rpcrdma_conn_func(ep);
 		wake_up_all(&ep->rep_connect_wait);
 		/*FALLTHROUGH*/
 	default:
-		dprintk("RPC:       %s: %pIS:%u (ep 0x%p): %s\n",
+		dprintk("RPC:       %s: %pIS:%u on %s/%s (ep 0x%p): %s\n",
-			__func__, sap, rpc_get_port(sap), ep,
+			__func__, sap, rpc_get_port(sap),
-			rdma_event_msg(event->event));
+			ia->ri_device->name, ia->ri_ops->ro_displayname,
+			ep, rdma_event_msg(event->event));
 		break;
 	}
-#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
-	if (connstate == 1) {
-		int ird = attr->max_dest_rd_atomic;
-		int tird = ep->rep_remote_cma.responder_resources;
-		pr_info("rpcrdma: connection to %pIS:%u on %s, memreg '%s', %d credits, %d responders%s\n",
-			sap, rpc_get_port(sap),
-			ia->ri_device->name,
-			ia->ri_ops->ro_displayname,
-			xprt->rx_buf.rb_max_requests,
-			ird, ird < 4 && ird < tird / 2 ? " (low!)" : "");
-	} else if (connstate < 0) {
-		pr_info("rpcrdma: connection to %pIS:%u closed (%d)\n",
-			sap, rpc_get_port(sap), connstate);
-	}
-#endif
 	return 0;
 }
 	if (req == NULL)
 		return ERR_PTR(-ENOMEM);
-	INIT_LIST_HEAD(&req->rl_free);
 	spin_lock(&buffer->rb_reqslock);
 	list_add(&req->rl_all, &buffer->rb_allreqs);
 	spin_unlock(&buffer->rb_reqslock);
 	spin_lock_init(&buf->rb_recovery_lock);
 	INIT_LIST_HEAD(&buf->rb_mws);
 	INIT_LIST_HEAD(&buf->rb_all);
+	INIT_LIST_HEAD(&buf->rb_pending);
 	INIT_LIST_HEAD(&buf->rb_stale_mrs);
 	INIT_DELAYED_WORK(&buf->rb_refresh_worker,
 			  rpcrdma_mr_refresh_worker);
 			goto out;
 		}
 		req->rl_backchannel = false;
-		list_add(&req->rl_free, &buf->rb_send_bufs);
+		list_add(&req->rl_list, &buf->rb_send_bufs);
 	}
 	INIT_LIST_HEAD(&buf->rb_recv_bufs);
 	struct rpcrdma_req *req;
 	req = list_first_entry(&buf->rb_send_bufs,
-			       struct rpcrdma_req, rl_free);
+			       struct rpcrdma_req, rl_list);
-	list_del(&req->rl_free);
+	list_del_init(&req->rl_list);
 	return req;
 }
 	if (!mw)
 		goto out_nomws;
+	mw->mw_flags = 0;
 	return mw;
 out_nomws:
 	spin_lock(&buffers->rb_lock);
 	buffers->rb_send_count--;
-	list_add_tail(&req->rl_free, &buffers->rb_send_bufs);
+	list_add_tail(&req->rl_list, &buffers->rb_send_bufs);
 	if (rep) {
 		buffers->rb_recv_count--;
 		list_add_tail(&rep->rr_list, &buffers->rb_recv_bufs);

net/sunrpc/xprtrdma/xprt_rdma.h+38−2

 	struct scatterlist	*mw_sg;
 	int			mw_nents;
 	enum dma_data_direction	mw_dir;
+	unsigned long		mw_flags;
 	union {
 		struct rpcrdma_fmr	fmr;
 		struct rpcrdma_frmr	frmr;
 	struct list_head	mw_all;
 };
+/* mw_flags */
+enum {
+	RPCRDMA_MW_F_RI		= 1,
+};
 /*
  * struct rpcrdma_req -- structure central to the request/reply sequence.
  *
 struct rpcrdma_buffer;
 struct rpcrdma_req {
-	struct list_head	rl_free;
+	struct list_head	rl_list;
+	__be32			rl_xid;
 	unsigned int		rl_mapped_sges;
 	unsigned int		rl_connect_cookie;
 	struct rpcrdma_buffer	*rl_buffer;
 	int			rb_send_count, rb_recv_count;
 	struct list_head	rb_send_bufs;
 	struct list_head	rb_recv_bufs;
+	struct list_head	rb_pending;
 	u32			rb_max_requests;
 	atomic_t		rb_credits;	/* most recent credit grant */
 				  struct rpcrdma_mr_seg *, int, bool,
 				  struct rpcrdma_mw **);
 	void		(*ro_unmap_sync)(struct rpcrdma_xprt *,
-					 struct rpcrdma_req *);
+					 struct list_head *);
 	void		(*ro_unmap_safe)(struct rpcrdma_xprt *,
 					 struct rpcrdma_req *, bool);
 	void		(*ro_recover_mr)(struct rpcrdma_mw *);
 int rpcrdma_buffer_create(struct rpcrdma_xprt *);
 void rpcrdma_buffer_destroy(struct rpcrdma_buffer *);
+static inline void
+rpcrdma_insert_req(struct rpcrdma_buffer *buffers, struct rpcrdma_req *req)
+{
+	spin_lock(&buffers->rb_lock);
+	if (list_empty(&req->rl_list))
+		list_add_tail(&req->rl_list, &buffers->rb_pending);
+	spin_unlock(&buffers->rb_lock);
+}
+static inline struct rpcrdma_req *
+rpcrdma_lookup_req_locked(struct rpcrdma_buffer *buffers, __be32 xid)
+{
+	struct rpcrdma_req *pos;
+	list_for_each_entry(pos, &buffers->rb_pending, rl_list)
+		if (pos->rl_xid == xid)
+			return pos;
+	return NULL;
+}
+static inline void
+rpcrdma_remove_req(struct rpcrdma_buffer *buffers, struct rpcrdma_req *req)
+{
+	spin_lock(&buffers->rb_lock);
+	list_del(&req->rl_list);
+	spin_unlock(&buffers->rb_lock);
+}
 struct rpcrdma_mw *rpcrdma_get_mw(struct rpcrdma_xprt *);
 void rpcrdma_put_mw(struct rpcrdma_xprt *, struct rpcrdma_mw *);
 struct rpcrdma_req *rpcrdma_buffer_get(struct rpcrdma_buffer *);

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code