~hc/RK356X_SDK_RELEASE.git

..	..	@@ -3,6 +3,7 @@
3	3	* Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
4	4	*/
5	5	#include <linux/fs.h>
	6	+#include <linux/sunrpc/addr.h>
6	7	#include <linux/sunrpc/sched.h>
7	8	#include <linux/nfs.h>
8	9	#include <linux/nfs3.h>
..	..	@@ -15,20 +16,42 @@
15	16	#include "pnfs.h"
16	17	#include "nfs4session.h"
17	18	#include "internal.h"
	19	+#include "delegation.h"
	20	+#include "nfs4trace.h"
18	21
19	22	#define NFSDBG_FACILITY NFSDBG_PROC
20	23	static int nfs42_do_offload_cancel_async(struct file dst, nfs4_stateid std);
	24	+
	25	+static void nfs42_set_netaddr(struct file filep, struct nfs42_netaddr naddr)
	26	+{
	27	+ struct nfs_client *clp = (NFS_SERVER(file_inode(filep)))->nfs_client;
	28	+ unsigned short port = 2049;
	29	+
	30	+ rcu_read_lock();
	31	+ naddr->netid_len = scnprintf(naddr->netid,
	32	+ sizeof(naddr->netid), "%s",
	33	+ rpc_peeraddr2str(clp->cl_rpcclient,
	34	+ RPC_DISPLAY_NETID));
	35	+ naddr->addr_len = scnprintf(naddr->addr,
	36	+ sizeof(naddr->addr),
	37	+ "%s.%u.%u",
	38	+ rpc_peeraddr2str(clp->cl_rpcclient,
	39	+ RPC_DISPLAY_ADDR),
	40	+ port >> 8, port & 255);
	41	+ rcu_read_unlock();
	42	+}
21	43
22	44	static int _nfs42_proc_fallocate(struct rpc_message msg, struct file filep,
23	45	struct nfs_lock_context *lock, loff_t offset, loff_t len)
24	46	{
25	47	struct inode *inode = file_inode(filep);
26	48	struct nfs_server *server = NFS_SERVER(inode);
	49	+ u32 bitmask[3];
27	50	struct nfs42_falloc_args args = {
28	51	.falloc_fh = NFS_FH(inode),
29	52	.falloc_offset = offset,
30	53	.falloc_length = len,
31		- .falloc_bitmask = server->cache_consistency_bitmask,
	54	+ .falloc_bitmask = bitmask,
32	55	};
33	56	struct nfs42_falloc_res res = {
34	57	.falloc_server = server,
..	..	@@ -40,8 +63,15 @@
40	63
41	64	status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
42	65	lock, FMODE_WRITE);
43		- if (status)
	66	+ if (status) {
	67	+ if (status == -EAGAIN)
	68	+ status = -NFS4ERR_BAD_STATEID;
44	69	return status;
	70	+ }
	71	+
	72	+ memcpy(bitmask, server->cache_consistency_bitmask, sizeof(bitmask));
	73	+ if (server->attr_bitmask[1] & FATTR4_WORD1_SPACE_USED)
	74	+ bitmask[1] \|= FATTR4_WORD1_SPACE_USED;
45	75
46	76	res.falloc_fattr = nfs_alloc_fattr();
47	77	if (!res.falloc_fattr)
..	..	@@ -50,7 +80,8 @@
50	80	status = nfs4_call_sync(server->client, server, msg,
51	81	&args.seq_args, &res.seq_res, 0);
52	82	if (status == 0)
53		- status = nfs_post_op_update_inode(inode, res.falloc_fattr);
	83	+ status = nfs_post_op_update_inode_force_wcc(inode,
	84	+ res.falloc_fattr);
54	85
55	86	kfree(res.falloc_fattr);
56	87	return status;
..	..	@@ -134,22 +165,26 @@
134	165	}
135	166
136	167	static int handle_async_copy(struct nfs42_copy_res *res,
137		- struct nfs_server *server,
	168	+ struct nfs_server *dst_server,
	169	+ struct nfs_server *src_server,
138	170	struct file *src,
139	171	struct file *dst,
140		- nfs4_stateid *src_stateid)
	172	+ nfs4_stateid *src_stateid,
	173	+ bool *restart)
141	174	{
142	175	struct nfs4_copy_state copy, tmp_copy;
143	176	int status = NFS4_OK;
144	177	bool found_pending = false;
145		- struct nfs_open_context *ctx = nfs_file_open_context(dst);
	178	+ struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);
	179	+ struct nfs_open_context *src_ctx = nfs_file_open_context(src);
146	180
147	181	copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_NOFS);
148	182	if (!copy)
149	183	return -ENOMEM;
150	184
151		- spin_lock(&server->nfs_client->cl_lock);
152		- list_for_each_entry(tmp_copy, &server->nfs_client->pending_cb_stateids,
	185	+ spin_lock(&dst_server->nfs_client->cl_lock);
	186	+ list_for_each_entry(tmp_copy,
	187	+ &dst_server->nfs_client->pending_cb_stateids,
153	188	copies) {
154	189	if (memcmp(&res->write_res.stateid, &tmp_copy->stateid,
155	190	NFS4_STATEID_SIZE))
..	..	@@ -159,7 +194,7 @@
159	194	break;
160	195	}
161	196	if (found_pending) {
162		- spin_unlock(&server->nfs_client->cl_lock);
	197	+ spin_unlock(&dst_server->nfs_client->cl_lock);
163	198	kfree(copy);
164	199	copy = tmp_copy;
165	200	goto out;
..	..	@@ -167,19 +202,32 @@
167	202
168	203	memcpy(&copy->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
169	204	init_completion(&copy->completion);
170		- copy->parent_state = ctx->state;
	205	+ copy->parent_dst_state = dst_ctx->state;
	206	+ copy->parent_src_state = src_ctx->state;
171	207
172		- list_add_tail(&copy->copies, &server->ss_copies);
173		- spin_unlock(&server->nfs_client->cl_lock);
	208	+ list_add_tail(&copy->copies, &dst_server->ss_copies);
	209	+ spin_unlock(&dst_server->nfs_client->cl_lock);
	210	+
	211	+ if (dst_server != src_server) {
	212	+ spin_lock(&src_server->nfs_client->cl_lock);
	213	+ list_add_tail(&copy->src_copies, &src_server->ss_copies);
	214	+ spin_unlock(&src_server->nfs_client->cl_lock);
	215	+ }
174	216
175	217	status = wait_for_completion_interruptible(&copy->completion);
176		- spin_lock(&server->nfs_client->cl_lock);
	218	+ spin_lock(&dst_server->nfs_client->cl_lock);
177	219	list_del_init(&copy->copies);
178		- spin_unlock(&server->nfs_client->cl_lock);
	220	+ spin_unlock(&dst_server->nfs_client->cl_lock);
	221	+ if (dst_server != src_server) {
	222	+ spin_lock(&src_server->nfs_client->cl_lock);
	223	+ list_del_init(&copy->src_copies);
	224	+ spin_unlock(&src_server->nfs_client->cl_lock);
	225	+ }
179	226	if (status == -ERESTARTSYS) {
180	227	goto out_cancel;
181		- } else if (copy->flags) {
	228	+ } else if (copy->flags \|\| copy->error == NFS4ERR_PARTNER_NO_AUTH) {
182	229	status = -EAGAIN;
	230	+ *restart = true;
183	231	goto out_cancel;
184	232	}
185	233	out:
..	..	@@ -187,12 +235,14 @@
187	235	memcpy(&res->write_res.verifier, &copy->verf, sizeof(copy->verf));
188	236	status = -copy->error;
189	237
	238	+out_free:
190	239	kfree(copy);
191	240	return status;
192	241	out_cancel:
193	242	nfs42_do_offload_cancel_async(dst, &copy->stateid);
194		- kfree(copy);
195		- return status;
	243	+ if (!nfs42_files_from_same_server(src, dst))
	244	+ nfs42_do_offload_cancel_async(src, src_stateid);
	245	+ goto out_free;
196	246	}
197	247
198	248	static int process_copy_commit(struct file *dst, loff_t pos_dst,
..	..	@@ -224,7 +274,10 @@
224	274	struct file *dst,
225	275	struct nfs_lock_context *dst_lock,
226	276	struct nfs42_copy_args *args,
227		- struct nfs42_copy_res *res)
	277	+ struct nfs42_copy_res *res,
	278	+ struct nl4_server *nss,
	279	+ nfs4_stateid *cnr_stateid,
	280	+ bool *restart)
228	281	{
229	282	struct rpc_message msg = {
230	283	.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
..	..	@@ -232,17 +285,26 @@
232	285	.rpc_resp = res,
233	286	};
234	287	struct inode *dst_inode = file_inode(dst);
235		- struct nfs_server *server = NFS_SERVER(dst_inode);
	288	+ struct inode *src_inode = file_inode(src);
	289	+ struct nfs_server *dst_server = NFS_SERVER(dst_inode);
	290	+ struct nfs_server *src_server = NFS_SERVER(src_inode);
236	291	loff_t pos_src = args->src_pos;
237	292	loff_t pos_dst = args->dst_pos;
238	293	size_t count = args->count;
239	294	ssize_t status;
240	295
241		- status = nfs4_set_rw_stateid(&args->src_stateid, src_lock->open_context,
242		- src_lock, FMODE_READ);
243		- if (status)
244		- return status;
245		-
	296	+ if (nss) {
	297	+ args->cp_src = nss;
	298	+ nfs4_stateid_copy(&args->src_stateid, cnr_stateid);
	299	+ } else {
	300	+ status = nfs4_set_rw_stateid(&args->src_stateid,
	301	+ src_lock->open_context, src_lock, FMODE_READ);
	302	+ if (status) {
	303	+ if (status == -EAGAIN)
	304	+ status = -NFS4ERR_BAD_STATEID;
	305	+ return status;
	306	+ }
	307	+ }
246	308	status = nfs_filemap_write_and_wait_range(file_inode(src)->i_mapping,
247	309	pos_src, pos_src + (loff_t)count - 1);
248	310	if (status)
..	..	@@ -250,8 +312,11 @@
250	312
251	313	status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
252	314	dst_lock, FMODE_WRITE);
253		- if (status)
	315	+ if (status) {
	316	+ if (status == -EAGAIN)
	317	+ status = -NFS4ERR_BAD_STATEID;
254	318	return status;
	319	+ }
255	320
256	321	status = nfs_sync_inode(dst_inode);
257	322	if (status)
..	..	@@ -264,13 +329,15 @@
264	329	if (!res->commit_res.verf)
265	330	return -ENOMEM;
266	331	}
	332	+ set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
	333	+ &src_lock->open_context->state->flags);
267	334	set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
268	335	&dst_lock->open_context->state->flags);
269	336
270		- status = nfs4_call_sync(server->client, server, &msg,
	337	+ status = nfs4_call_sync(dst_server->client, dst_server, &msg,
271	338	&args->seq_args, &res->seq_res, 0);
272	339	if (status == -ENOTSUPP)
273		- server->caps &= ~NFS_CAP_COPY;
	340	+ dst_server->caps &= ~NFS_CAP_COPY;
274	341	if (status)
275	342	goto out;
276	343
..	..	@@ -282,8 +349,8 @@
282	349	}
283	350
284	351	if (!res->synchronous) {
285		- status = handle_async_copy(res, server, src, dst,
286		- &args->src_stateid);
	352	+ status = handle_async_copy(res, dst_server, src_server, src,
	353	+ dst, &args->src_stateid, restart);
287	354	if (status)
288	355	goto out;
289	356	}
..	..	@@ -298,7 +365,15 @@
298	365	WARN_ON_ONCE(invalidate_inode_pages2_range(dst_inode->i_mapping,
299	366	pos_dst >> PAGE_SHIFT,
300	367	(pos_dst + res->write_res.count - 1) >> PAGE_SHIFT));
301		-
	368	+ spin_lock(&dst_inode->i_lock);
	369	+ NFS_I(dst_inode)->cache_validity \|= (NFS_INO_REVAL_PAGECACHE \|
	370	+ NFS_INO_REVAL_FORCED \| NFS_INO_INVALID_SIZE \|
	371	+ NFS_INO_INVALID_ATTR \| NFS_INO_INVALID_DATA);
	372	+ spin_unlock(&dst_inode->i_lock);
	373	+ spin_lock(&src_inode->i_lock);
	374	+ NFS_I(src_inode)->cache_validity \|= (NFS_INO_REVAL_PAGECACHE \|
	375	+ NFS_INO_REVAL_FORCED \| NFS_INO_INVALID_ATIME);
	376	+ spin_unlock(&src_inode->i_lock);
302	377	status = res->write_res.count;
303	378	out:
304	379	if (args->sync)
..	..	@@ -307,8 +382,9 @@
307	382	}
308	383
309	384	ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
310		- struct file *dst, loff_t pos_dst,
311		- size_t count)
	385	+ struct file *dst, loff_t pos_dst, size_t count,
	386	+ struct nl4_server *nss,
	387	+ nfs4_stateid *cnr_stateid, bool sync)
312	388	{
313	389	struct nfs_server *server = NFS_SERVER(file_inode(dst));
314	390	struct nfs_lock_context *src_lock;
..	..	@@ -319,7 +395,7 @@
319	395	.dst_fh = NFS_FH(file_inode(dst)),
320	396	.dst_pos = pos_dst,
321	397	.count = count,
322		- .sync = false,
	398	+ .sync = sync,
323	399	};
324	400	struct nfs42_copy_res res;
325	401	struct nfs4_exception src_exception = {
..	..	@@ -331,6 +407,7 @@
331	407	.stateid = &args.dst_stateid,
332	408	};
333	409	ssize_t err, err2;
	410	+ bool restart = false;
334	411
335	412	src_lock = nfs_get_lock_context(nfs_file_open_context(src));
336	413	if (IS_ERR(src_lock))
..	..	@@ -350,21 +427,33 @@
350	427	inode_lock(file_inode(dst));
351	428	err = _nfs42_proc_copy(src, src_lock,
352	429	dst, dst_lock,
353		- &args, &res);
	430	+ &args, &res,
	431	+ nss, cnr_stateid, &restart);
354	432	inode_unlock(file_inode(dst));
355	433
356	434	if (err >= 0)
357	435	break;
358		- if (err == -ENOTSUPP) {
	436	+ if (err == -ENOTSUPP &&
	437	+ nfs42_files_from_same_server(src, dst)) {
359	438	err = -EOPNOTSUPP;
360	439	break;
361	440	} else if (err == -EAGAIN) {
362		- dst_exception.retry = 1;
363		- continue;
	441	+ if (!restart) {
	442	+ dst_exception.retry = 1;
	443	+ continue;
	444	+ }
	445	+ break;
364	446	} else if (err == -NFS4ERR_OFFLOAD_NO_REQS && !args.sync) {
365	447	args.sync = true;
366	448	dst_exception.retry = 1;
367	449	continue;
	450	+ } else if ((err == -ESTALE \|\|
	451	+ err == -NFS4ERR_OFFLOAD_DENIED \|\|
	452	+ err == -ENOTSUPP) &&
	453	+ !nfs42_files_from_same_server(src, dst)) {
	454	+ nfs42_do_offload_cancel_async(src, &args.src_stateid);
	455	+ err = -EOPNOTSUPP;
	456	+ break;
368	457	}
369	458
370	459	err2 = nfs4_handle_exception(server, err, &src_exception);
..	..	@@ -462,6 +551,82 @@
462	551	return status;
463	552	}
464	553
	554	+static int _nfs42_proc_copy_notify(struct file src, struct file dst,
	555	+ struct nfs42_copy_notify_args *args,
	556	+ struct nfs42_copy_notify_res *res)
	557	+{
	558	+ struct nfs_server *src_server = NFS_SERVER(file_inode(src));
	559	+ struct rpc_message msg = {
	560	+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY],
	561	+ .rpc_argp = args,
	562	+ .rpc_resp = res,
	563	+ };
	564	+ int status;
	565	+ struct nfs_open_context *ctx;
	566	+ struct nfs_lock_context *l_ctx;
	567	+
	568	+ ctx = get_nfs_open_context(nfs_file_open_context(src));
	569	+ l_ctx = nfs_get_lock_context(ctx);
	570	+ if (IS_ERR(l_ctx)) {
	571	+ status = PTR_ERR(l_ctx);
	572	+ goto out;
	573	+ }
	574	+
	575	+ status = nfs4_set_rw_stateid(&args->cna_src_stateid, ctx, l_ctx,
	576	+ FMODE_READ);
	577	+ nfs_put_lock_context(l_ctx);
	578	+ if (status) {
	579	+ if (status == -EAGAIN)
	580	+ status = -NFS4ERR_BAD_STATEID;
	581	+ goto out;
	582	+ }
	583	+
	584	+ status = nfs4_call_sync(src_server->client, src_server, &msg,
	585	+ &args->cna_seq_args, &res->cnr_seq_res, 0);
	586	+ if (status == -ENOTSUPP)
	587	+ src_server->caps &= ~NFS_CAP_COPY_NOTIFY;
	588	+
	589	+out:
	590	+ put_nfs_open_context(nfs_file_open_context(src));
	591	+ return status;
	592	+}
	593	+
	594	+int nfs42_proc_copy_notify(struct file src, struct file dst,
	595	+ struct nfs42_copy_notify_res *res)
	596	+{
	597	+ struct nfs_server *src_server = NFS_SERVER(file_inode(src));
	598	+ struct nfs42_copy_notify_args *args;
	599	+ struct nfs4_exception exception = {
	600	+ .inode = file_inode(src),
	601	+ };
	602	+ int status;
	603	+
	604	+ if (!(src_server->caps & NFS_CAP_COPY_NOTIFY))
	605	+ return -EOPNOTSUPP;
	606	+
	607	+ args = kzalloc(sizeof(struct nfs42_copy_notify_args), GFP_NOFS);
	608	+ if (args == NULL)
	609	+ return -ENOMEM;
	610	+
	611	+ args->cna_src_fh = NFS_FH(file_inode(src)),
	612	+ args->cna_dst.nl4_type = NL4_NETADDR;
	613	+ nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);
	614	+ exception.stateid = &args->cna_src_stateid;
	615	+
	616	+ do {
	617	+ status = _nfs42_proc_copy_notify(src, dst, args, res);
	618	+ if (status == -ENOTSUPP) {
	619	+ status = -EOPNOTSUPP;
	620	+ goto out;
	621	+ }
	622	+ status = nfs4_handle_exception(src_server, status, &exception);
	623	+ } while (exception.retry);
	624	+
	625	+out:
	626	+ kfree(args);
	627	+ return status;
	628	+}
	629	+
465	630	static loff_t _nfs42_proc_llseek(struct file *filep,
466	631	struct nfs_lock_context *lock, loff_t offset, int whence)
467	632	{
..	..	@@ -486,8 +651,11 @@
486	651
487	652	status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
488	653	lock, FMODE_READ);
489		- if (status)
	654	+ if (status) {
	655	+ if (status == -EAGAIN)
	656	+ status = -NFS4ERR_BAD_STATEID;
490	657	return status;
	658	+ }
491	659
492	660	status = nfs_filemap_write_and_wait_range(inode->i_mapping,
493	661	offset, LLONG_MAX);
..	..	@@ -570,7 +738,7 @@
570	738
571	739	switch (task->tk_status) {
572	740	case 0:
573		- break;
	741	+ return;
574	742	case -NFS4ERR_BADHANDLE:
575	743	case -ESTALE:
576	744	pnfs_destroy_layout(NFS_I(inode));
..	..	@@ -616,6 +784,8 @@
616	784	case -EOPNOTSUPP:
617	785	NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
618	786	}
	787	+
	788	+ trace_nfs4_layoutstats(inode, &data->args.stateid, task->tk_status);
619	789	}
620	790
621	791	static void
..	..	@@ -675,6 +845,173 @@
675	845	return 0;
676	846	}
677	847
	848	+static struct nfs42_layouterror_data *
	849	+nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags)
	850	+{
	851	+ struct nfs42_layouterror_data *data;
	852	+ struct inode *inode = lseg->pls_layout->plh_inode;
	853	+
	854	+ data = kzalloc(sizeof(*data), gfp_flags);
	855	+ if (data) {
	856	+ data->args.inode = data->inode = nfs_igrab_and_active(inode);
	857	+ if (data->inode) {
	858	+ data->lseg = pnfs_get_lseg(lseg);
	859	+ if (data->lseg)
	860	+ return data;
	861	+ nfs_iput_and_deactive(data->inode);
	862	+ }
	863	+ kfree(data);
	864	+ }
	865	+ return NULL;
	866	+}
	867	+
	868	+static void
	869	+nfs42_free_layouterror_data(struct nfs42_layouterror_data *data)
	870	+{
	871	+ pnfs_put_lseg(data->lseg);
	872	+ nfs_iput_and_deactive(data->inode);
	873	+ kfree(data);
	874	+}
	875	+
	876	+static void
	877	+nfs42_layouterror_prepare(struct rpc_task task, void calldata)
	878	+{
	879	+ struct nfs42_layouterror_data *data = calldata;
	880	+ struct inode *inode = data->inode;
	881	+ struct nfs_server *server = NFS_SERVER(inode);
	882	+ struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
	883	+ unsigned i;
	884	+
	885	+ spin_lock(&inode->i_lock);
	886	+ if (!pnfs_layout_is_valid(lo)) {
	887	+ spin_unlock(&inode->i_lock);
	888	+ rpc_exit(task, 0);
	889	+ return;
	890	+ }
	891	+ for (i = 0; i < data->args.num_errors; i++)
	892	+ nfs4_stateid_copy(&data->args.errors[i].stateid,
	893	+ &lo->plh_stateid);
	894	+ spin_unlock(&inode->i_lock);
	895	+ nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
	896	+ &data->res.seq_res, task);
	897	+}
	898	+
	899	+static void
	900	+nfs42_layouterror_done(struct rpc_task task, void calldata)
	901	+{
	902	+ struct nfs42_layouterror_data *data = calldata;
	903	+ struct inode *inode = data->inode;
	904	+ struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
	905	+
	906	+ if (!nfs4_sequence_done(task, &data->res.seq_res))
	907	+ return;
	908	+
	909	+ switch (task->tk_status) {
	910	+ case 0:
	911	+ return;
	912	+ case -NFS4ERR_BADHANDLE:
	913	+ case -ESTALE:
	914	+ pnfs_destroy_layout(NFS_I(inode));
	915	+ break;
	916	+ case -NFS4ERR_EXPIRED:
	917	+ case -NFS4ERR_ADMIN_REVOKED:
	918	+ case -NFS4ERR_DELEG_REVOKED:
	919	+ case -NFS4ERR_STALE_STATEID:
	920	+ case -NFS4ERR_BAD_STATEID:
	921	+ spin_lock(&inode->i_lock);
	922	+ if (pnfs_layout_is_valid(lo) &&
	923	+ nfs4_stateid_match(&data->args.errors[0].stateid,
	924	+ &lo->plh_stateid)) {
	925	+ LIST_HEAD(head);
	926	+
	927	+ /*
	928	+ * Mark the bad layout state as invalid, then retry
	929	+ * with the current stateid.
	930	+ */
	931	+ pnfs_mark_layout_stateid_invalid(lo, &head);
	932	+ spin_unlock(&inode->i_lock);
	933	+ pnfs_free_lseg_list(&head);
	934	+ nfs_commit_inode(inode, 0);
	935	+ } else
	936	+ spin_unlock(&inode->i_lock);
	937	+ break;
	938	+ case -NFS4ERR_OLD_STATEID:
	939	+ spin_lock(&inode->i_lock);
	940	+ if (pnfs_layout_is_valid(lo) &&
	941	+ nfs4_stateid_match_other(&data->args.errors[0].stateid,
	942	+ &lo->plh_stateid)) {
	943	+ /* Do we need to delay before resending? */
	944	+ if (!nfs4_stateid_is_newer(&lo->plh_stateid,
	945	+ &data->args.errors[0].stateid))
	946	+ rpc_delay(task, HZ);
	947	+ rpc_restart_call_prepare(task);
	948	+ }
	949	+ spin_unlock(&inode->i_lock);
	950	+ break;
	951	+ case -ENOTSUPP:
	952	+ case -EOPNOTSUPP:
	953	+ NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
	954	+ }
	955	+
	956	+ trace_nfs4_layouterror(inode, &data->args.errors[0].stateid,
	957	+ task->tk_status);
	958	+}
	959	+
	960	+static void
	961	+nfs42_layouterror_release(void *calldata)
	962	+{
	963	+ struct nfs42_layouterror_data *data = calldata;
	964	+
	965	+ nfs42_free_layouterror_data(data);
	966	+}
	967	+
	968	+static const struct rpc_call_ops nfs42_layouterror_ops = {
	969	+ .rpc_call_prepare = nfs42_layouterror_prepare,
	970	+ .rpc_call_done = nfs42_layouterror_done,
	971	+ .rpc_release = nfs42_layouterror_release,
	972	+};
	973	+
	974	+int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg,
	975	+ const struct nfs42_layout_error *errors, size_t n)
	976	+{
	977	+ struct inode *inode = lseg->pls_layout->plh_inode;
	978	+ struct nfs42_layouterror_data *data;
	979	+ struct rpc_task *task;
	980	+ struct rpc_message msg = {
	981	+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR],
	982	+ };
	983	+ struct rpc_task_setup task_setup = {
	984	+ .rpc_message = &msg,
	985	+ .callback_ops = &nfs42_layouterror_ops,
	986	+ .flags = RPC_TASK_ASYNC,
	987	+ };
	988	+ unsigned int i;
	989	+
	990	+ if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR))
	991	+ return -EOPNOTSUPP;
	992	+ if (n > NFS42_LAYOUTERROR_MAX)
	993	+ return -EINVAL;
	994	+ data = nfs42_alloc_layouterror_data(lseg, GFP_NOFS);
	995	+ if (!data)
	996	+ return -ENOMEM;
	997	+ for (i = 0; i < n; i++) {
	998	+ data->args.errors[i] = errors[i];
	999	+ data->args.num_errors++;
	1000	+ data->res.num_errors++;
	1001	+ }
	1002	+ msg.rpc_argp = &data->args;
	1003	+ msg.rpc_resp = &data->res;
	1004	+ task_setup.callback_data = data;
	1005	+ task_setup.rpc_client = NFS_SERVER(inode)->client;
	1006	+ nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
	1007	+ task = rpc_run_task(&task_setup);
	1008	+ if (IS_ERR(task))
	1009	+ return PTR_ERR(task);
	1010	+ rpc_put_task(task);
	1011	+ return 0;
	1012	+}
	1013	+EXPORT_SYMBOL_GPL(nfs42_proc_layouterror);
	1014	+
678	1015	static int _nfs42_proc_clone(struct rpc_message msg, struct file src_f,
679	1016	struct file dst_f, struct nfs_lock_context src_lock,
680	1017	struct nfs_lock_context *dst_lock, loff_t src_offset,
..	..	@@ -701,13 +1038,18 @@
701	1038
702	1039	status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
703	1040	src_lock, FMODE_READ);
704		- if (status)
	1041	+ if (status) {
	1042	+ if (status == -EAGAIN)
	1043	+ status = -NFS4ERR_BAD_STATEID;
705	1044	return status;
706		-
	1045	+ }
707	1046	status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
708	1047	dst_lock, FMODE_WRITE);
709		- if (status)
	1048	+ if (status) {
	1049	+ if (status == -EAGAIN)
	1050	+ status = -NFS4ERR_BAD_STATEID;
710	1051	return status;
	1052	+ }
711	1053
712	1054	res.dst_fattr = nfs_alloc_fattr();
713	1055	if (!res.dst_fattr)
..	..	@@ -775,3 +1117,256 @@
775	1117	nfs_put_lock_context(src_lock);
776	1118	return err;
777	1119	}
	1120	+
	1121	+#define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
	1122	+
	1123	+static int _nfs42_proc_removexattr(struct inode inode, const char name)
	1124	+{
	1125	+ struct nfs_server *server = NFS_SERVER(inode);
	1126	+ struct nfs42_removexattrargs args = {
	1127	+ .fh = NFS_FH(inode),
	1128	+ .xattr_name = name,
	1129	+ };
	1130	+ struct nfs42_removexattrres res;
	1131	+ struct rpc_message msg = {
	1132	+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVEXATTR],
	1133	+ .rpc_argp = &args,
	1134	+ .rpc_resp = &res,
	1135	+ };
	1136	+ int ret;
	1137	+ unsigned long timestamp = jiffies;
	1138	+
	1139	+ ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
	1140	+ &res.seq_res, 1);
	1141	+ if (!ret)
	1142	+ nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
	1143	+
	1144	+ return ret;
	1145	+}
	1146	+
	1147	+static int _nfs42_proc_setxattr(struct inode inode, const char name,
	1148	+ const void *buf, size_t buflen, int flags)
	1149	+{
	1150	+ struct nfs_server *server = NFS_SERVER(inode);
	1151	+ struct page *pages[NFS4XATTR_MAXPAGES];
	1152	+ struct nfs42_setxattrargs arg = {
	1153	+ .fh = NFS_FH(inode),
	1154	+ .xattr_pages = pages,
	1155	+ .xattr_len = buflen,
	1156	+ .xattr_name = name,
	1157	+ .xattr_flags = flags,
	1158	+ };
	1159	+ struct nfs42_setxattrres res;
	1160	+ struct rpc_message msg = {
	1161	+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETXATTR],
	1162	+ .rpc_argp = &arg,
	1163	+ .rpc_resp = &res,
	1164	+ };
	1165	+ int ret, np;
	1166	+ unsigned long timestamp = jiffies;
	1167	+
	1168	+ if (buflen > server->sxasize)
	1169	+ return -ERANGE;
	1170	+
	1171	+ if (buflen > 0) {
	1172	+ np = nfs4_buf_to_pages_noslab(buf, buflen, arg.xattr_pages);
	1173	+ if (np < 0)
	1174	+ return np;
	1175	+ } else
	1176	+ np = 0;
	1177	+
	1178	+ ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
	1179	+ &res.seq_res, 1);
	1180	+
	1181	+ for (; np > 0; np--)
	1182	+ put_page(pages[np - 1]);
	1183	+
	1184	+ if (!ret)
	1185	+ nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
	1186	+
	1187	+ return ret;
	1188	+}
	1189	+
	1190	+static ssize_t _nfs42_proc_getxattr(struct inode inode, const char name,
	1191	+ void *buf, size_t buflen)
	1192	+{
	1193	+ struct nfs_server *server = NFS_SERVER(inode);
	1194	+ struct page *pages[NFS4XATTR_MAXPAGES] = {};
	1195	+ struct nfs42_getxattrargs arg = {
	1196	+ .fh = NFS_FH(inode),
	1197	+ .xattr_pages = pages,
	1198	+ .xattr_len = buflen,
	1199	+ .xattr_name = name,
	1200	+ };
	1201	+ struct nfs42_getxattrres res;
	1202	+ struct rpc_message msg = {
	1203	+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR],
	1204	+ .rpc_argp = &arg,
	1205	+ .rpc_resp = &res,
	1206	+ };
	1207	+ int ret, np;
	1208	+
	1209	+ ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
	1210	+ &res.seq_res, 0);
	1211	+ if (ret < 0)
	1212	+ return ret;
	1213	+
	1214	+ /*
	1215	+ * Normally, the caching is done one layer up, but for successful
	1216	+ * RPCS, always cache the result here, even if the caller was
	1217	+ * just querying the length, or if the reply was too big for
	1218	+ * the caller. This avoids a second RPC in the case of the
	1219	+ * common query-alloc-retrieve cycle for xattrs.
	1220	+ *
	1221	+ * Note that xattr_len is always capped to XATTR_SIZE_MAX.
	1222	+ */
	1223	+
	1224	+ nfs4_xattr_cache_add(inode, name, NULL, pages, res.xattr_len);
	1225	+
	1226	+ if (buflen) {
	1227	+ if (res.xattr_len > buflen)
	1228	+ return -ERANGE;
	1229	+ _copy_from_pages(buf, pages, 0, res.xattr_len);
	1230	+ }
	1231	+
	1232	+ np = DIV_ROUND_UP(res.xattr_len, PAGE_SIZE);
	1233	+ while (--np >= 0)
	1234	+ __free_page(pages[np]);
	1235	+
	1236	+ return res.xattr_len;
	1237	+}
	1238	+
	1239	+static ssize_t _nfs42_proc_listxattrs(struct inode inode, void buf,
	1240	+ size_t buflen, u64 cookiep, bool eofp)
	1241	+{
	1242	+ struct nfs_server *server = NFS_SERVER(inode);
	1243	+ struct page **pages;
	1244	+ struct nfs42_listxattrsargs arg = {
	1245	+ .fh = NFS_FH(inode),
	1246	+ .cookie = *cookiep,
	1247	+ };
	1248	+ struct nfs42_listxattrsres res = {
	1249	+ .eof = false,
	1250	+ .xattr_buf = buf,
	1251	+ .xattr_len = buflen,
	1252	+ };
	1253	+ struct rpc_message msg = {
	1254	+ .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LISTXATTRS],
	1255	+ .rpc_argp = &arg,
	1256	+ .rpc_resp = &res,
	1257	+ };
	1258	+ u32 xdrlen;
	1259	+ int ret, np, i;
	1260	+
	1261	+
	1262	+ ret = -ENOMEM;
	1263	+ res.scratch = alloc_page(GFP_KERNEL);
	1264	+ if (!res.scratch)
	1265	+ goto out;
	1266	+
	1267	+ xdrlen = nfs42_listxattr_xdrsize(buflen);
	1268	+ if (xdrlen > server->lxasize)
	1269	+ xdrlen = server->lxasize;
	1270	+ np = xdrlen / PAGE_SIZE + 1;
	1271	+
	1272	+ pages = kcalloc(np, sizeof(struct page *), GFP_KERNEL);
	1273	+ if (!pages)
	1274	+ goto out_free_scratch;
	1275	+ for (i = 0; i < np; i++) {
	1276	+ pages[i] = alloc_page(GFP_KERNEL);
	1277	+ if (!pages[i])
	1278	+ goto out_free_pages;
	1279	+ }
	1280	+
	1281	+ arg.xattr_pages = pages;
	1282	+ arg.count = xdrlen;
	1283	+
	1284	+ ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
	1285	+ &res.seq_res, 0);
	1286	+
	1287	+ if (ret >= 0) {
	1288	+ ret = res.copied;
	1289	+ *cookiep = res.cookie;
	1290	+ *eofp = res.eof;
	1291	+ }
	1292	+
	1293	+out_free_pages:
	1294	+ while (--np >= 0) {
	1295	+ if (pages[np])
	1296	+ __free_page(pages[np]);
	1297	+ }
	1298	+ kfree(pages);
	1299	+out_free_scratch:
	1300	+ __free_page(res.scratch);
	1301	+out:
	1302	+ return ret;
	1303	+
	1304	+}
	1305	+
	1306	+ssize_t nfs42_proc_getxattr(struct inode inode, const char name,
	1307	+ void *buf, size_t buflen)
	1308	+{
	1309	+ struct nfs4_exception exception = { };
	1310	+ ssize_t err;
	1311	+
	1312	+ do {
	1313	+ err = _nfs42_proc_getxattr(inode, name, buf, buflen);
	1314	+ if (err >= 0)
	1315	+ break;
	1316	+ err = nfs4_handle_exception(NFS_SERVER(inode), err,
	1317	+ &exception);
	1318	+ } while (exception.retry);
	1319	+
	1320	+ return err;
	1321	+}
	1322	+
	1323	+int nfs42_proc_setxattr(struct inode inode, const char name,
	1324	+ const void *buf, size_t buflen, int flags)
	1325	+{
	1326	+ struct nfs4_exception exception = { };
	1327	+ int err;
	1328	+
	1329	+ do {
	1330	+ err = _nfs42_proc_setxattr(inode, name, buf, buflen, flags);
	1331	+ if (!err)
	1332	+ break;
	1333	+ err = nfs4_handle_exception(NFS_SERVER(inode), err,
	1334	+ &exception);
	1335	+ } while (exception.retry);
	1336	+
	1337	+ return err;
	1338	+}
	1339	+
	1340	+ssize_t nfs42_proc_listxattrs(struct inode inode, void buf,
	1341	+ size_t buflen, u64 cookiep, bool eofp)
	1342	+{
	1343	+ struct nfs4_exception exception = { };
	1344	+ ssize_t err;
	1345	+
	1346	+ do {
	1347	+ err = _nfs42_proc_listxattrs(inode, buf, buflen,
	1348	+ cookiep, eofp);
	1349	+ if (err >= 0)
	1350	+ break;
	1351	+ err = nfs4_handle_exception(NFS_SERVER(inode), err,
	1352	+ &exception);
	1353	+ } while (exception.retry);
	1354	+
	1355	+ return err;
	1356	+}
	1357	+
	1358	+int nfs42_proc_removexattr(struct inode inode, const char name)
	1359	+{
	1360	+ struct nfs4_exception exception = { };
	1361	+ int err;
	1362	+
	1363	+ do {
	1364	+ err = _nfs42_proc_removexattr(inode, name);
	1365	+ if (!err)
	1366	+ break;
	1367	+ err = nfs4_handle_exception(NFS_SERVER(inode), err,
	1368	+ &exception);
	1369	+ } while (exception.retry);
	1370	+
	1371	+ return err;
	1372	+}