~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,12 +1,8 @@
	1	+// SPDX-License-Identifier: GPL-2.0-or-later
1	2	/* AFS File Server client stubs
2	3	*
3	4	* Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4	5	* Written by David Howells (dhowells@redhat.com)
5		- *
6		- * This program is free software; you can redistribute it and/or
7		- * modify it under the terms of the GNU General Public License
8		- * as published by the Free Software Foundation; either version
9		- * 2 of the License, or (at your option) any later version.
10	6	*/
11	7
12	8	#include <linux/init.h>
..	..	@@ -17,19 +13,6 @@
17	13	#include "internal.h"
18	14	#include "afs_fs.h"
19	15	#include "xdr_fs.h"
20		-
21		-static const struct afs_fid afs_zero_fid;
22		-
23		-/*
24		- * We need somewhere to discard into in case the server helpfully returns more
25		- * than we asked for in FS.FetchData{,64}.
26		- */
27		-static u8 afs_discard_buffer[64];
28		-
29		-static inline void afs_use_fs_server(struct afs_call call, struct afs_cb_interest cbi)
30		-{
31		- call->cbi = afs_get_cb_interest(cbi);
32		-}
33	16
34	17	/*
35	18	* decode an AFSFid block
..	..	@@ -65,79 +48,17 @@
65	48	}
66	49
67	50	/*
68		- * Update the core inode struct from a returned status record.
69		- */
70		-void afs_update_inode_from_status(struct afs_vnode *vnode,
71		- struct afs_file_status *status,
72		- const afs_dataversion_t *expected_version,
73		- u8 flags)
74		-{
75		- struct timespec64 t;
76		- umode_t mode;
77		-
78		- t.tv_sec = status->mtime_client;
79		- t.tv_nsec = 0;
80		- vnode->vfs_inode.i_ctime = t;
81		- vnode->vfs_inode.i_mtime = t;
82		- vnode->vfs_inode.i_atime = t;
83		-
84		- if (flags & (AFS_VNODE_META_CHANGED \| AFS_VNODE_NOT_YET_SET)) {
85		- vnode->vfs_inode.i_uid = make_kuid(&init_user_ns, status->owner);
86		- vnode->vfs_inode.i_gid = make_kgid(&init_user_ns, status->group);
87		- set_nlink(&vnode->vfs_inode, status->nlink);
88		-
89		- mode = vnode->vfs_inode.i_mode;
90		- mode &= ~S_IALLUGO;
91		- mode \|= status->mode;
92		- barrier();
93		- vnode->vfs_inode.i_mode = mode;
94		- }
95		-
96		- if (!(flags & AFS_VNODE_NOT_YET_SET)) {
97		- if (expected_version &&
98		- *expected_version != status->data_version) {
99		- _debug("vnode modified %llx on {%x:%u} [exp %llx]",
100		- (unsigned long long) status->data_version,
101		- vnode->fid.vid, vnode->fid.vnode,
102		- (unsigned long long) *expected_version);
103		- vnode->invalid_before = status->data_version;
104		- if (vnode->status.type == AFS_FTYPE_DIR) {
105		- if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
106		- afs_stat_v(vnode, n_inval);
107		- } else {
108		- set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
109		- }
110		- } else if (vnode->status.type == AFS_FTYPE_DIR) {
111		- /* Expected directory change is handled elsewhere so
112		- * that we can locally edit the directory and save on a
113		- * download.
114		- */
115		- if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
116		- flags &= ~AFS_VNODE_DATA_CHANGED;
117		- }
118		- }
119		-
120		- if (flags & (AFS_VNODE_DATA_CHANGED \| AFS_VNODE_NOT_YET_SET)) {
121		- inode_set_iversion_raw(&vnode->vfs_inode, status->data_version);
122		- i_size_write(&vnode->vfs_inode, status->size);
123		- }
124		-}
125		-
126		-/*
127	51	* decode an AFSFetchStatus block
128	52	*/
129		-static int xdr_decode_AFSFetchStatus(struct afs_call *call,
130		- const __be32 **_bp,
131		- struct afs_file_status *status,
132		- struct afs_vnode *vnode,
133		- const afs_dataversion_t *expected_version,
134		- struct afs_read *read_req)
	53	+static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
	54	+ struct afs_call *call,
	55	+ struct afs_status_cb *scb)
135	56	{
136	57	const struct afs_xdr_AFSFetchStatus xdr = (const void )*_bp;
	58	+ struct afs_file_status *status = &scb->status;
137	59	bool inline_error = (call->operation_ID == afs_FS_InlineBulkStatus);
138	60	u64 data_version, size;
139	61	u32 type, abort_code;
140		- u8 flags = 0;
141	62
142	63	abort_code = ntohl(xdr->abort_code);
143	64
..	..	@@ -150,7 +71,8 @@
150	71	* case.
151	72	*/
152	73	status->abort_code = abort_code;
153		- return 0;
	74	+ scb->have_error = true;
	75	+ goto advance;
154	76	}
155	77
156	78	pr_warn("Unknown AFSFetchStatus version %u\n", ntohl(xdr->if_version));
..	..	@@ -159,7 +81,8 @@
159	81
160	82	if (abort_code != 0 && inline_error) {
161	83	status->abort_code = abort_code;
162		- return 0;
	84	+ scb->have_error = true;
	85	+ goto advance;
163	86	}
164	87
165	88	type = ntohl(xdr->type);
..	..	@@ -167,42 +90,25 @@
167	90	case AFS_FTYPE_FILE:
168	91	case AFS_FTYPE_DIR:
169	92	case AFS_FTYPE_SYMLINK:
170		- if (type != status->type &&
171		- vnode &&
172		- !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
173		- pr_warning("Vnode %x:%x:%x changed type %u to %u\n",
174		- vnode->fid.vid,
175		- vnode->fid.vnode,
176		- vnode->fid.unique,
177		- status->type, type);
178		- goto bad;
179		- }
180	93	status->type = type;
181	94	break;
182	95	default:
183	96	goto bad;
184	97	}
185	98
186		-#define EXTRACT_M(FIELD) \
187		- do { \
188		- u32 x = ntohl(xdr->FIELD); \
189		- if (status->FIELD != x) { \
190		- flags \|= AFS_VNODE_META_CHANGED; \
191		- status->FIELD = x; \
192		- } \
193		- } while (0)
	99	+ status->nlink = ntohl(xdr->nlink);
	100	+ status->author = ntohl(xdr->author);
	101	+ status->owner = ntohl(xdr->owner);
	102	+ status->caller_access = ntohl(xdr->caller_access); /* Ticket dependent */
	103	+ status->anon_access = ntohl(xdr->anon_access);
	104	+ status->mode = ntohl(xdr->mode) & S_IALLUGO;
	105	+ status->group = ntohl(xdr->group);
	106	+ status->lock_count = ntohl(xdr->lock_count);
194	107
195		- EXTRACT_M(nlink);
196		- EXTRACT_M(author);
197		- EXTRACT_M(owner);
198		- EXTRACT_M(caller_access); /* call ticket dependent */
199		- EXTRACT_M(anon_access);
200		- EXTRACT_M(mode);
201		- EXTRACT_M(group);
202		-
203		- status->mtime_client = ntohl(xdr->mtime_client);
204		- status->mtime_server = ntohl(xdr->mtime_server);
205		- status->lock_count = ntohl(xdr->lock_count);
	108	+ status->mtime_client.tv_sec = ntohl(xdr->mtime_client);
	109	+ status->mtime_client.tv_nsec = 0;
	110	+ status->mtime_server.tv_sec = ntohl(xdr->mtime_server);
	111	+ status->mtime_server.tv_nsec = 0;
206	112
207	113	size = (u64)ntohl(xdr->size_lo);
208	114	size \|= (u64)ntohl(xdr->size_hi) << 32;
..	..	@@ -210,97 +116,34 @@
210	116
211	117	data_version = (u64)ntohl(xdr->data_version_lo);
212	118	data_version \|= (u64)ntohl(xdr->data_version_hi) << 32;
213		- if (data_version != status->data_version) {
214		- status->data_version = data_version;
215		- flags \|= AFS_VNODE_DATA_CHANGED;
216		- }
217		-
218		- if (read_req) {
219		- read_req->data_version = data_version;
220		- read_req->file_size = size;
221		- }
222		-
	119	+ status->data_version = data_version;
	120	+ scb->have_status = true;
	121	+advance:
223	122	_bp = (const void )_bp + sizeof(xdr);
224		-
225		- if (vnode) {
226		- if (test_bit(AFS_VNODE_UNSET, &vnode->flags))
227		- flags \|= AFS_VNODE_NOT_YET_SET;
228		- afs_update_inode_from_status(vnode, status, expected_version,
229		- flags);
230		- }
231		-
232		- return 0;
	123	+ return;
233	124
234	125	bad:
235	126	xdr_dump_bad(*_bp);
236		- return afs_protocol_error(call, -EBADMSG);
	127	+ afs_protocol_error(call, afs_eproto_bad_status);
	128	+ goto advance;
237	129	}
238	130
239		-/*
240		- * Decode the file status. We need to lock the target vnode if we're going to
241		- * update its status so that stat() sees the attributes update atomically.
242		- */
243		-static int afs_decode_status(struct afs_call *call,
244		- const __be32 **_bp,
245		- struct afs_file_status *status,
246		- struct afs_vnode *vnode,
247		- const afs_dataversion_t *expected_version,
248		- struct afs_read *read_req)
	131	+static time64_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
249	132	{
250		- int ret;
251		-
252		- if (!vnode)
253		- return xdr_decode_AFSFetchStatus(call, _bp, status, vnode,
254		- expected_version, read_req);
255		-
256		- write_seqlock(&vnode->cb_lock);
257		- ret = xdr_decode_AFSFetchStatus(call, _bp, status, vnode,
258		- expected_version, read_req);
259		- write_sequnlock(&vnode->cb_lock);
260		- return ret;
	133	+ return ktime_divns(call->issue_time, NSEC_PER_SEC) + expiry;
261	134	}
262	135
263		-/*
264		- * decode an AFSCallBack block
265		- */
266		-static void xdr_decode_AFSCallBack(struct afs_call *call,
267		- struct afs_vnode *vnode,
268		- const __be32 **_bp)
	136	+static void xdr_decode_AFSCallBack(const __be32 **_bp,
	137	+ struct afs_call *call,
	138	+ struct afs_status_cb *scb)
269	139	{
270		- struct afs_cb_interest old, cbi = call->cbi;
271		- const __be32 bp = _bp;
272		- u32 cb_expiry;
273		-
274		- write_seqlock(&vnode->cb_lock);
275		-
276		- if (call->cb_break == afs_cb_break_sum(vnode, cbi)) {
277		- vnode->cb_version = ntohl(*bp++);
278		- cb_expiry = ntohl(*bp++);
279		- vnode->cb_type = ntohl(*bp++);
280		- vnode->cb_expires_at = cb_expiry + ktime_get_real_seconds();
281		- old = vnode->cb_interest;
282		- if (old != call->cbi) {
283		- vnode->cb_interest = cbi;
284		- cbi = old;
285		- }
286		- set_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
287		- } else {
288		- bp += 3;
289		- }
290		-
291		- write_sequnlock(&vnode->cb_lock);
292		- call->cbi = cbi;
293		- *_bp = bp;
294		-}
295		-
296		-static void xdr_decode_AFSCallBack_raw(const __be32 **_bp,
297		- struct afs_callback *cb)
298		-{
	140	+ struct afs_callback *cb = &scb->callback;
299	141	const __be32 bp = _bp;
300	142
301		- cb->version = ntohl(*bp++);
302		- cb->expiry = ntohl(*bp++);
303		- cb->type = ntohl(*bp++);
	143	+ bp++; /* version */
	144	+ cb->expires_at = xdr_decode_expiry(call, ntohl(*bp++));
	145	+ bp++; /* type */
	146	+ scb->have_cb = true;
304	147	*_bp = bp;
305	148	}
306	149
..	..	@@ -311,14 +154,18 @@
311	154	struct afs_volsync *volsync)
312	155	{
313	156	const __be32 bp = _bp;
	157	+ u32 creation;
314	158
315		- volsync->creation = ntohl(*bp++);
	159	+ creation = ntohl(*bp++);
316	160	bp++; /* spare2 */
317	161	bp++; /* spare3 */
318	162	bp++; /* spare4 */
319	163	bp++; /* spare5 */
320	164	bp++; /* spare6 */
321	165	*_bp = bp;
	166	+
	167	+ if (volsync)
	168	+ volsync->creation = creation;
322	169	}
323	170
324	171	/*
..	..	@@ -379,15 +226,18 @@
379	226	vs->blocks_in_use = ntohl(*bp++);
380	227	vs->part_blocks_avail = ntohl(*bp++);
381	228	vs->part_max_blocks = ntohl(*bp++);
	229	+ vs->vol_copy_date = 0;
	230	+ vs->vol_backup_date = 0;
382	231	*_bp = bp;
383	232	}
384	233
385	234	/*
386	235	* deliver reply data to an FS.FetchStatus
387	236	*/
388		-static int afs_deliver_fs_fetch_status_vnode(struct afs_call *call)
	237	+static int afs_deliver_fs_fetch_status(struct afs_call *call)
389	238	{
390		- struct afs_vnode *vnode = call->reply[0];
	239	+ struct afs_operation *op = call->op;
	240	+ struct afs_vnode_param *vp = &op->file[op->fetch_status.which];
391	241	const __be32 *bp;
392	242	int ret;
393	243
..	..	@@ -395,16 +245,11 @@
395	245	if (ret < 0)
396	246	return ret;
397	247
398		- _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
399		-
400	248	/* unmarshall the reply once we've received all of it */
401	249	bp = call->buffer;
402		- if (afs_decode_status(call, &bp, &vnode->status, vnode,
403		- &call->expected_version, NULL) < 0)
404		- return afs_protocol_error(call, -EBADMSG);
405		- xdr_decode_AFSCallBack(call, vnode, &bp);
406		- if (call->reply[1])
407		- xdr_decode_AFSVolSync(&bp, call->reply[1]);
	250	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	251	+ xdr_decode_AFSCallBack(&bp, call, &vp->scb);
	252	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
408	253
409	254	_leave(" = 0 [done]");
410	255	return 0;
..	..	@@ -413,50 +258,39 @@
413	258	/*
414	259	* FS.FetchStatus operation type
415	260	*/
416		-static const struct afs_call_type afs_RXFSFetchStatus_vnode = {
417		- .name = "FS.FetchStatus(vnode)",
	261	+static const struct afs_call_type afs_RXFSFetchStatus = {
	262	+ .name = "FS.FetchStatus",
418	263	.op = afs_FS_FetchStatus,
419		- .deliver = afs_deliver_fs_fetch_status_vnode,
	264	+ .deliver = afs_deliver_fs_fetch_status,
420	265	.destructor = afs_flat_call_destructor,
421	266	};
422	267
423	268	/*
424	269	* fetch the status information for a file
425	270	*/
426		-int afs_fs_fetch_file_status(struct afs_fs_cursor fc, struct afs_volsync volsync,
427		- bool new_inode)
	271	+void afs_fs_fetch_status(struct afs_operation *op)
428	272	{
429		- struct afs_vnode *vnode = fc->vnode;
	273	+ struct afs_vnode_param *vp = &op->file[op->fetch_status.which];
430	274	struct afs_call *call;
431		- struct afs_net *net = afs_v2net(vnode);
432	275	__be32 *bp;
433	276
434		- _enter(",%x,{%x:%u},,",
435		- key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
	277	+ _enter(",%x,{%llx:%llu},,",
	278	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
436	279
437		- call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus_vnode,
	280	+ call = afs_alloc_flat_call(op->net, &afs_RXFSFetchStatus,
438	281	16, (21 + 3 + 6) * 4);
439		- if (!call) {
440		- fc->ac.error = -ENOMEM;
441		- return -ENOMEM;
442		- }
443		-
444		- call->key = fc->key;
445		- call->reply[0] = vnode;
446		- call->reply[1] = volsync;
447		- call->expected_version = new_inode ? 1 : vnode->status.data_version;
	282	+ if (!call)
	283	+ return afs_op_nomem(op);
448	284
449	285	/* marshall the parameters */
450	286	bp = call->request;
451	287	bp[0] = htonl(FSFETCHSTATUS);
452		- bp[1] = htonl(vnode->fid.vid);
453		- bp[2] = htonl(vnode->fid.vnode);
454		- bp[3] = htonl(vnode->fid.unique);
	288	+ bp[1] = htonl(vp->fid.vid);
	289	+ bp[2] = htonl(vp->fid.vnode);
	290	+ bp[3] = htonl(vp->fid.unique);
455	291
456		- call->cb_break = fc->cb_break;
457		- afs_use_fs_server(call, fc->cbi);
458		- trace_afs_make_fs_call(call, &vnode->fid);
459		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	292	+ trace_afs_make_fs_call(call, &vp->fid);
	293	+ afs_make_op_call(op, call, GFP_NOFS);
460	294	}
461	295
462	296	/*
..	..	@@ -464,155 +298,131 @@
464	298	*/
465	299	static int afs_deliver_fs_fetch_data(struct afs_call *call)
466	300	{
467		- struct afs_vnode *vnode = call->reply[0];
468		- struct afs_read *req = call->reply[2];
	301	+ struct afs_operation *op = call->op;
	302	+ struct afs_vnode_param *vp = &op->file[0];
	303	+ struct afs_read *req = op->fetch.req;
469	304	const __be32 *bp;
470	305	unsigned int size;
471		- void *buffer;
472	306	int ret;
473	307
474		- _enter("{%u,%zu/%u;%llu/%llu}",
475		- call->unmarshall, call->offset, call->count,
476		- req->remain, req->actual_len);
	308	+ _enter("{%u,%zu/%llu}",
	309	+ call->unmarshall, iov_iter_count(call->iter), req->actual_len);
477	310
478	311	switch (call->unmarshall) {
479	312	case 0:
480	313	req->actual_len = 0;
481		- call->offset = 0;
482		- call->unmarshall++;
483		- if (call->operation_ID != FSFETCHDATA64) {
484		- call->unmarshall++;
485		- goto no_msw;
486		- }
487		-
488		- /* extract the upper part of the returned data length of an
489		- * FSFETCHDATA64 op (which should always be 0 using this
490		- * client) */
491		- case 1:
492		- _debug("extract data length (MSW)");
493		- ret = afs_extract_data(call, &call->tmp, 4, true);
494		- if (ret < 0)
495		- return ret;
496		-
497		- req->actual_len = ntohl(call->tmp);
498		- req->actual_len <<= 32;
499		- call->offset = 0;
500		- call->unmarshall++;
501		-
502		- no_msw:
503		- /* extract the returned data length */
504		- case 2:
505		- _debug("extract data length");
506		- ret = afs_extract_data(call, &call->tmp, 4, true);
507		- if (ret < 0)
508		- return ret;
509		-
510		- req->actual_len \|= ntohl(call->tmp);
511		- _debug("DATA length: %llu", req->actual_len);
512		-
513		- req->remain = req->actual_len;
514		- call->offset = req->pos & (PAGE_SIZE - 1);
515	314	req->index = 0;
516		- if (req->actual_len == 0)
	315	+ req->offset = req->pos & (PAGE_SIZE - 1);
	316	+ call->unmarshall++;
	317	+ if (call->operation_ID == FSFETCHDATA64) {
	318	+ afs_extract_to_tmp64(call);
	319	+ } else {
	320	+ call->tmp_u = htonl(0);
	321	+ afs_extract_to_tmp(call);
	322	+ }
	323	+ fallthrough;
	324	+
	325	+ /* extract the returned data length */
	326	+ case 1:
	327	+ _debug("extract data length");
	328	+ ret = afs_extract_data(call, true);
	329	+ if (ret < 0)
	330	+ return ret;
	331	+
	332	+ req->actual_len = be64_to_cpu(call->tmp64);
	333	+ _debug("DATA length: %llu", req->actual_len);
	334	+ req->remain = min(req->len, req->actual_len);
	335	+ if (req->remain == 0)
517	336	goto no_more_data;
	337	+
518	338	call->unmarshall++;
519	339
520	340	begin_page:
521	341	ASSERTCMP(req->index, <, req->nr_pages);
522		- if (req->remain > PAGE_SIZE - call->offset)
523		- size = PAGE_SIZE - call->offset;
	342	+ if (req->remain > PAGE_SIZE - req->offset)
	343	+ size = PAGE_SIZE - req->offset;
524	344	else
525	345	size = req->remain;
526		- call->count = call->offset + size;
527		- ASSERTCMP(call->count, <=, PAGE_SIZE);
528		- req->remain -= size;
	346	+ call->bvec[0].bv_len = size;
	347	+ call->bvec[0].bv_offset = req->offset;
	348	+ call->bvec[0].bv_page = req->pages[req->index];
	349	+ iov_iter_bvec(&call->def_iter, READ, call->bvec, 1, size);
	350	+ ASSERTCMP(size, <=, PAGE_SIZE);
	351	+ fallthrough;
529	352
530	353	/* extract the returned data */
531		- case 3:
532		- _debug("extract data %llu/%llu %zu/%u",
533		- req->remain, req->actual_len, call->offset, call->count);
	354	+ case 2:
	355	+ _debug("extract data %zu/%llu",
	356	+ iov_iter_count(call->iter), req->remain);
534	357
535		- buffer = kmap(req->pages[req->index]);
536		- ret = afs_extract_data(call, buffer, call->count, true);
537		- kunmap(req->pages[req->index]);
	358	+ ret = afs_extract_data(call, true);
538	359	if (ret < 0)
539	360	return ret;
540		- if (call->offset == PAGE_SIZE) {
541		- if (req->page_done)
542		- req->page_done(call, req);
	361	+ req->remain -= call->bvec[0].bv_len;
	362	+ req->offset += call->bvec[0].bv_len;
	363	+ ASSERTCMP(req->offset, <=, PAGE_SIZE);
	364	+ if (req->offset == PAGE_SIZE) {
	365	+ req->offset = 0;
543	366	req->index++;
544		- if (req->remain > 0) {
545		- call->offset = 0;
546		- if (req->index >= req->nr_pages) {
547		- call->unmarshall = 4;
548		- goto begin_discard;
549		- }
	367	+ if (req->remain > 0)
550	368	goto begin_page;
551		- }
552	369	}
553		- goto no_more_data;
	370	+
	371	+ ASSERTCMP(req->remain, ==, 0);
	372	+ if (req->actual_len <= req->len)
	373	+ goto no_more_data;
554	374
555	375	/* Discard any excess data the server gave us */
556		- begin_discard:
557		- case 4:
558		- size = min_t(loff_t, sizeof(afs_discard_buffer), req->remain);
559		- call->count = size;
560		- _debug("extract discard %llu/%llu %zu/%u",
561		- req->remain, req->actual_len, call->offset, call->count);
	376	+ afs_extract_discard(call, req->actual_len - req->len);
	377	+ call->unmarshall = 3;
	378	+ fallthrough;
562	379
563		- call->offset = 0;
564		- ret = afs_extract_data(call, afs_discard_buffer, call->count, true);
565		- req->remain -= call->offset;
	380	+ case 3:
	381	+ _debug("extract discard %zu/%llu",
	382	+ iov_iter_count(call->iter), req->actual_len - req->len);
	383	+
	384	+ ret = afs_extract_data(call, true);
566	385	if (ret < 0)
567	386	return ret;
568		- if (req->remain > 0)
569		- goto begin_discard;
570	387
571	388	no_more_data:
572		- call->offset = 0;
573		- call->unmarshall = 5;
	389	+ call->unmarshall = 4;
	390	+ afs_extract_to_buf(call, (21 + 3 + 6) * 4);
	391	+ fallthrough;
574	392
575	393	/* extract the metadata */
576		- case 5:
577		- ret = afs_extract_data(call, call->buffer,
578		- (21 + 3 + 6) * 4, false);
	394	+ case 4:
	395	+ ret = afs_extract_data(call, false);
579	396	if (ret < 0)
580	397	return ret;
581	398
582	399	bp = call->buffer;
583		- if (afs_decode_status(call, &bp, &vnode->status, vnode,
584		- &vnode->status.data_version, req) < 0)
585		- return afs_protocol_error(call, -EBADMSG);
586		- xdr_decode_AFSCallBack(call, vnode, &bp);
587		- if (call->reply[1])
588		- xdr_decode_AFSVolSync(&bp, call->reply[1]);
	400	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	401	+ xdr_decode_AFSCallBack(&bp, call, &vp->scb);
	402	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
589	403
590		- call->offset = 0;
	404	+ req->data_version = vp->scb.status.data_version;
	405	+ req->file_size = vp->scb.status.size;
	406	+
591	407	call->unmarshall++;
592	408
593		- case 6:
	409	+ case 5:
594	410	break;
595	411	}
596	412
597	413	for (; req->index < req->nr_pages; req->index++) {
598		- if (call->count < PAGE_SIZE)
	414	+ if (req->offset < PAGE_SIZE)
599	415	zero_user_segment(req->pages[req->index],
600		- call->count, PAGE_SIZE);
601		- if (req->page_done)
602		- req->page_done(call, req);
603		- call->count = 0;
	416	+ req->offset, PAGE_SIZE);
	417	+ req->offset = 0;
604	418	}
	419	+
	420	+ if (req->page_done)
	421	+ for (req->index = 0; req->index < req->nr_pages; req->index++)
	422	+ req->page_done(req);
605	423
606	424	_leave(" = 0 [done]");
607	425	return 0;
608		-}
609		-
610		-static void afs_fetch_data_destructor(struct afs_call *call)
611		-{
612		- struct afs_read *req = call->reply[2];
613		-
614		- afs_put_read(req);
615		- afs_flat_call_destructor(call);
616	426	}
617	427
618	428	/*
..	..	@@ -622,97 +432,79 @@
622	432	.name = "FS.FetchData",
623	433	.op = afs_FS_FetchData,
624	434	.deliver = afs_deliver_fs_fetch_data,
625		- .destructor = afs_fetch_data_destructor,
	435	+ .destructor = afs_flat_call_destructor,
626	436	};
627	437
628	438	static const struct afs_call_type afs_RXFSFetchData64 = {
629	439	.name = "FS.FetchData64",
630	440	.op = afs_FS_FetchData64,
631	441	.deliver = afs_deliver_fs_fetch_data,
632		- .destructor = afs_fetch_data_destructor,
	442	+ .destructor = afs_flat_call_destructor,
633	443	};
634	444
635	445	/*
636	446	* fetch data from a very large file
637	447	*/
638		-static int afs_fs_fetch_data64(struct afs_fs_cursor fc, struct afs_read req)
	448	+static void afs_fs_fetch_data64(struct afs_operation *op)
639	449	{
640		- struct afs_vnode *vnode = fc->vnode;
	450	+ struct afs_vnode_param *vp = &op->file[0];
	451	+ struct afs_read *req = op->fetch.req;
641	452	struct afs_call *call;
642		- struct afs_net *net = afs_v2net(vnode);
643	453	__be32 *bp;
644	454
645	455	_enter("");
646	456
647		- call = afs_alloc_flat_call(net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
	457	+ call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
648	458	if (!call)
649		- return -ENOMEM;
650		-
651		- call->key = fc->key;
652		- call->reply[0] = vnode;
653		- call->reply[1] = NULL; /* volsync */
654		- call->reply[2] = req;
655		- call->expected_version = vnode->status.data_version;
	459	+ return afs_op_nomem(op);
656	460
657	461	/* marshall the parameters */
658	462	bp = call->request;
659	463	bp[0] = htonl(FSFETCHDATA64);
660		- bp[1] = htonl(vnode->fid.vid);
661		- bp[2] = htonl(vnode->fid.vnode);
662		- bp[3] = htonl(vnode->fid.unique);
	464	+ bp[1] = htonl(vp->fid.vid);
	465	+ bp[2] = htonl(vp->fid.vnode);
	466	+ bp[3] = htonl(vp->fid.unique);
663	467	bp[4] = htonl(upper_32_bits(req->pos));
664	468	bp[5] = htonl(lower_32_bits(req->pos));
665	469	bp[6] = 0;
666	470	bp[7] = htonl(lower_32_bits(req->len));
667	471
668		- refcount_inc(&req->usage);
669		- call->cb_break = fc->cb_break;
670		- afs_use_fs_server(call, fc->cbi);
671		- trace_afs_make_fs_call(call, &vnode->fid);
672		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	472	+ trace_afs_make_fs_call(call, &vp->fid);
	473	+ afs_make_op_call(op, call, GFP_NOFS);
673	474	}
674	475
675	476	/*
676	477	* fetch data from a file
677	478	*/
678		-int afs_fs_fetch_data(struct afs_fs_cursor fc, struct afs_read req)
	479	+void afs_fs_fetch_data(struct afs_operation *op)
679	480	{
680		- struct afs_vnode *vnode = fc->vnode;
	481	+ struct afs_vnode_param *vp = &op->file[0];
681	482	struct afs_call *call;
682		- struct afs_net *net = afs_v2net(vnode);
	483	+ struct afs_read *req = op->fetch.req;
683	484	__be32 *bp;
684	485
685	486	if (upper_32_bits(req->pos) \|\|
686	487	upper_32_bits(req->len) \|\|
687	488	upper_32_bits(req->pos + req->len))
688		- return afs_fs_fetch_data64(fc, req);
	489	+ return afs_fs_fetch_data64(op);
689	490
690	491	_enter("");
691	492
692		- call = afs_alloc_flat_call(net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
	493	+ call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
693	494	if (!call)
694		- return -ENOMEM;
695		-
696		- call->key = fc->key;
697		- call->reply[0] = vnode;
698		- call->reply[1] = NULL; /* volsync */
699		- call->reply[2] = req;
700		- call->expected_version = vnode->status.data_version;
	495	+ return afs_op_nomem(op);
701	496
702	497	/* marshall the parameters */
703	498	bp = call->request;
704	499	bp[0] = htonl(FSFETCHDATA);
705		- bp[1] = htonl(vnode->fid.vid);
706		- bp[2] = htonl(vnode->fid.vnode);
707		- bp[3] = htonl(vnode->fid.unique);
	500	+ bp[1] = htonl(vp->fid.vid);
	501	+ bp[2] = htonl(vp->fid.vnode);
	502	+ bp[3] = htonl(vp->fid.unique);
708	503	bp[4] = htonl(lower_32_bits(req->pos));
709	504	bp[5] = htonl(lower_32_bits(req->len));
710	505
711		- refcount_inc(&req->usage);
712		- call->cb_break = fc->cb_break;
713		- afs_use_fs_server(call, fc->cbi);
714		- trace_afs_make_fs_call(call, &vnode->fid);
715		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	506	+ trace_afs_make_fs_call(call, &vp->fid);
	507	+ afs_make_op_call(op, call, GFP_NOFS);
716	508	}
717	509
718	510	/*
..	..	@@ -720,11 +512,11 @@
720	512	*/
721	513	static int afs_deliver_fs_create_vnode(struct afs_call *call)
722	514	{
723		- struct afs_vnode *vnode = call->reply[0];
	515	+ struct afs_operation *op = call->op;
	516	+ struct afs_vnode_param *dvp = &op->file[0];
	517	+ struct afs_vnode_param *vp = &op->file[1];
724	518	const __be32 *bp;
725	519	int ret;
726		-
727		- _enter("{%u}", call->unmarshall);
728	520
729	521	ret = afs_transfer_reply(call);
730	522	if (ret < 0)
..	..	@@ -732,13 +524,11 @@
732	524
733	525	/* unmarshall the reply once we've received all of it */
734	526	bp = call->buffer;
735		- xdr_decode_AFSFid(&bp, call->reply[1]);
736		- if (afs_decode_status(call, &bp, call->reply[2], NULL, NULL, NULL) < 0 \|\|
737		- afs_decode_status(call, &bp, &vnode->status, vnode,
738		- &call->expected_version, NULL) < 0)
739		- return afs_protocol_error(call, -EBADMSG);
740		- xdr_decode_AFSCallBack_raw(&bp, call->reply[3]);
741		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
	527	+ xdr_decode_AFSFid(&bp, &op->file[1].fid);
	528	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	529	+ xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
	530	+ xdr_decode_AFSCallBack(&bp, call, &vp->scb);
	531	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
742	532
743	533	_leave(" = 0 [done]");
744	534	return 0;
..	..	@@ -754,6 +544,52 @@
754	544	.destructor = afs_flat_call_destructor,
755	545	};
756	546
	547	+/*
	548	+ * Create a file.
	549	+ */
	550	+void afs_fs_create_file(struct afs_operation *op)
	551	+{
	552	+ const struct qstr *name = &op->dentry->d_name;
	553	+ struct afs_vnode_param *dvp = &op->file[0];
	554	+ struct afs_call *call;
	555	+ size_t namesz, reqsz, padsz;
	556	+ __be32 *bp;
	557	+
	558	+ _enter("");
	559	+
	560	+ namesz = name->len;
	561	+ padsz = (4 - (namesz & 3)) & 3;
	562	+ reqsz = (5 * 4) + namesz + padsz + (6 * 4);
	563	+
	564	+ call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile,
	565	+ reqsz, (3 + 21 + 21 + 3 + 6) * 4);
	566	+ if (!call)
	567	+ return afs_op_nomem(op);
	568	+
	569	+ /* marshall the parameters */
	570	+ bp = call->request;
	571	+ *bp++ = htonl(FSCREATEFILE);
	572	+ *bp++ = htonl(dvp->fid.vid);
	573	+ *bp++ = htonl(dvp->fid.vnode);
	574	+ *bp++ = htonl(dvp->fid.unique);
	575	+ *bp++ = htonl(namesz);
	576	+ memcpy(bp, name->name, namesz);
	577	+ bp = (void *) bp + namesz;
	578	+ if (padsz > 0) {
	579	+ memset(bp, 0, padsz);
	580	+ bp = (void *) bp + padsz;
	581	+ }
	582	+ *bp++ = htonl(AFS_SET_MODE \| AFS_SET_MTIME);
	583	+ bp++ = htonl(op->mtime.tv_sec); / mtime */
	584	+ bp++ = 0; / owner */
	585	+ bp++ = 0; / group */
	586	+ bp++ = htonl(op->create.mode & S_IALLUGO); / unix mode */
	587	+ bp++ = 0; / segment size */
	588	+
	589	+ trace_afs_make_fs_call1(call, &dvp->fid, name);
	590	+ afs_make_op_call(op, call, GFP_NOFS);
	591	+}
	592	+
757	593	static const struct afs_call_type afs_RXFSMakeDir = {
758	594	.name = "FS.MakeDir",
759	595	.op = afs_FS_MakeDir,
..	..	@@ -762,76 +598,60 @@
762	598	};
763	599
764	600	/*
765		- * create a file or make a directory
	601	+ * Create a new directory
766	602	*/
767		-int afs_fs_create(struct afs_fs_cursor *fc,
768		- const char *name,
769		- umode_t mode,
770		- u64 current_data_version,
771		- struct afs_fid *newfid,
772		- struct afs_file_status *newstatus,
773		- struct afs_callback *newcb)
	603	+void afs_fs_make_dir(struct afs_operation *op)
774	604	{
775		- struct afs_vnode *vnode = fc->vnode;
	605	+ const struct qstr *name = &op->dentry->d_name;
	606	+ struct afs_vnode_param *dvp = &op->file[0];
776	607	struct afs_call *call;
777		- struct afs_net *net = afs_v2net(vnode);
778	608	size_t namesz, reqsz, padsz;
779	609	__be32 *bp;
780	610
781	611	_enter("");
782	612
783		- namesz = strlen(name);
	613	+ namesz = name->len;
784	614	padsz = (4 - (namesz & 3)) & 3;
785	615	reqsz = (5 * 4) + namesz + padsz + (6 * 4);
786	616
787		- call = afs_alloc_flat_call(
788		- net, S_ISDIR(mode) ? &afs_RXFSMakeDir : &afs_RXFSCreateFile,
789		- reqsz, (3 + 21 + 21 + 3 + 6) * 4);
	617	+ call = afs_alloc_flat_call(op->net, &afs_RXFSMakeDir,
	618	+ reqsz, (3 + 21 + 21 + 3 + 6) * 4);
790	619	if (!call)
791		- return -ENOMEM;
792		-
793		- call->key = fc->key;
794		- call->reply[0] = vnode;
795		- call->reply[1] = newfid;
796		- call->reply[2] = newstatus;
797		- call->reply[3] = newcb;
798		- call->expected_version = current_data_version + 1;
	620	+ return afs_op_nomem(op);
799	621
800	622	/* marshall the parameters */
801	623	bp = call->request;
802		- *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE);
803		- *bp++ = htonl(vnode->fid.vid);
804		- *bp++ = htonl(vnode->fid.vnode);
805		- *bp++ = htonl(vnode->fid.unique);
	624	+ *bp++ = htonl(FSMAKEDIR);
	625	+ *bp++ = htonl(dvp->fid.vid);
	626	+ *bp++ = htonl(dvp->fid.vnode);
	627	+ *bp++ = htonl(dvp->fid.unique);
806	628	*bp++ = htonl(namesz);
807		- memcpy(bp, name, namesz);
	629	+ memcpy(bp, name->name, namesz);
808	630	bp = (void *) bp + namesz;
809	631	if (padsz > 0) {
810	632	memset(bp, 0, padsz);
811	633	bp = (void *) bp + padsz;
812	634	}
813	635	*bp++ = htonl(AFS_SET_MODE \| AFS_SET_MTIME);
814		- bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); / mtime */
	636	+ bp++ = htonl(op->mtime.tv_sec); / mtime */
815	637	bp++ = 0; / owner */
816	638	bp++ = 0; / group */
817		- bp++ = htonl(mode & S_IALLUGO); / unix mode */
	639	+ bp++ = htonl(op->create.mode & S_IALLUGO); / unix mode */
818	640	bp++ = 0; / segment size */
819	641
820		- afs_use_fs_server(call, fc->cbi);
821		- trace_afs_make_fs_call(call, &vnode->fid);
822		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	642	+ trace_afs_make_fs_call1(call, &dvp->fid, name);
	643	+ afs_make_op_call(op, call, GFP_NOFS);
823	644	}
824	645
825	646	/*
826		- * deliver reply data to an FS.RemoveFile or FS.RemoveDir
	647	+ * Deliver reply data to any operation that returns status and volume sync.
827	648	*/
828		-static int afs_deliver_fs_remove(struct afs_call *call)
	649	+static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
829	650	{
830		- struct afs_vnode *vnode = call->reply[0];
	651	+ struct afs_operation *op = call->op;
	652	+ struct afs_vnode_param *vp = &op->file[0];
831	653	const __be32 *bp;
832	654	int ret;
833		-
834		- _enter("{%u}", call->unmarshall);
835	655
836	656	ret = afs_transfer_reply(call);
837	657	if (ret < 0)
..	..	@@ -839,77 +659,108 @@
839	659
840	660	/* unmarshall the reply once we've received all of it */
841	661	bp = call->buffer;
842		- if (afs_decode_status(call, &bp, &vnode->status, vnode,
843		- &call->expected_version, NULL) < 0)
844		- return afs_protocol_error(call, -EBADMSG);
845		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
	662	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	663	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
846	664
847	665	_leave(" = 0 [done]");
848	666	return 0;
849	667	}
850	668
851	669	/*
852		- * FS.RemoveDir/FS.RemoveFile operation type
	670	+ * FS.RemoveFile operation type
853	671	*/
854	672	static const struct afs_call_type afs_RXFSRemoveFile = {
855	673	.name = "FS.RemoveFile",
856	674	.op = afs_FS_RemoveFile,
857		- .deliver = afs_deliver_fs_remove,
858		- .destructor = afs_flat_call_destructor,
859		-};
860		-
861		-static const struct afs_call_type afs_RXFSRemoveDir = {
862		- .name = "FS.RemoveDir",
863		- .op = afs_FS_RemoveDir,
864		- .deliver = afs_deliver_fs_remove,
	675	+ .deliver = afs_deliver_fs_file_status_and_vol,
865	676	.destructor = afs_flat_call_destructor,
866	677	};
867	678
868	679	/*
869		- * remove a file or directory
	680	+ * Remove a file.
870	681	*/
871		-int afs_fs_remove(struct afs_fs_cursor fc, const char name, bool isdir,
872		- u64 current_data_version)
	682	+void afs_fs_remove_file(struct afs_operation *op)
873	683	{
874		- struct afs_vnode *vnode = fc->vnode;
	684	+ const struct qstr *name = &op->dentry->d_name;
	685	+ struct afs_vnode_param *dvp = &op->file[0];
875	686	struct afs_call *call;
876		- struct afs_net *net = afs_v2net(vnode);
877	687	size_t namesz, reqsz, padsz;
878	688	__be32 *bp;
879	689
880	690	_enter("");
881	691
882		- namesz = strlen(name);
	692	+ namesz = name->len;
883	693	padsz = (4 - (namesz & 3)) & 3;
884	694	reqsz = (5 * 4) + namesz + padsz;
885	695
886		- call = afs_alloc_flat_call(
887		- net, isdir ? &afs_RXFSRemoveDir : &afs_RXFSRemoveFile,
888		- reqsz, (21 + 6) * 4);
	696	+ call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveFile,
	697	+ reqsz, (21 + 6) * 4);
889	698	if (!call)
890		- return -ENOMEM;
891		-
892		- call->key = fc->key;
893		- call->reply[0] = vnode;
894		- call->expected_version = current_data_version + 1;
	699	+ return afs_op_nomem(op);
895	700
896	701	/* marshall the parameters */
897	702	bp = call->request;
898		- *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE);
899		- *bp++ = htonl(vnode->fid.vid);
900		- *bp++ = htonl(vnode->fid.vnode);
901		- *bp++ = htonl(vnode->fid.unique);
	703	+ *bp++ = htonl(FSREMOVEFILE);
	704	+ *bp++ = htonl(dvp->fid.vid);
	705	+ *bp++ = htonl(dvp->fid.vnode);
	706	+ *bp++ = htonl(dvp->fid.unique);
902	707	*bp++ = htonl(namesz);
903		- memcpy(bp, name, namesz);
	708	+ memcpy(bp, name->name, namesz);
904	709	bp = (void *) bp + namesz;
905	710	if (padsz > 0) {
906	711	memset(bp, 0, padsz);
907	712	bp = (void *) bp + padsz;
908	713	}
909	714
910		- afs_use_fs_server(call, fc->cbi);
911		- trace_afs_make_fs_call(call, &vnode->fid);
912		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	715	+ trace_afs_make_fs_call1(call, &dvp->fid, name);
	716	+ afs_make_op_call(op, call, GFP_NOFS);
	717	+}
	718	+
	719	+static const struct afs_call_type afs_RXFSRemoveDir = {
	720	+ .name = "FS.RemoveDir",
	721	+ .op = afs_FS_RemoveDir,
	722	+ .deliver = afs_deliver_fs_file_status_and_vol,
	723	+ .destructor = afs_flat_call_destructor,
	724	+};
	725	+
	726	+/*
	727	+ * Remove a directory.
	728	+ */
	729	+void afs_fs_remove_dir(struct afs_operation *op)
	730	+{
	731	+ const struct qstr *name = &op->dentry->d_name;
	732	+ struct afs_vnode_param *dvp = &op->file[0];
	733	+ struct afs_call *call;
	734	+ size_t namesz, reqsz, padsz;
	735	+ __be32 *bp;
	736	+
	737	+ _enter("");
	738	+
	739	+ namesz = name->len;
	740	+ padsz = (4 - (namesz & 3)) & 3;
	741	+ reqsz = (5 * 4) + namesz + padsz;
	742	+
	743	+ call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveDir,
	744	+ reqsz, (21 + 6) * 4);
	745	+ if (!call)
	746	+ return afs_op_nomem(op);
	747	+
	748	+ /* marshall the parameters */
	749	+ bp = call->request;
	750	+ *bp++ = htonl(FSREMOVEDIR);
	751	+ *bp++ = htonl(dvp->fid.vid);
	752	+ *bp++ = htonl(dvp->fid.vnode);
	753	+ *bp++ = htonl(dvp->fid.unique);
	754	+ *bp++ = htonl(namesz);
	755	+ memcpy(bp, name->name, namesz);
	756	+ bp = (void *) bp + namesz;
	757	+ if (padsz > 0) {
	758	+ memset(bp, 0, padsz);
	759	+ bp = (void *) bp + padsz;
	760	+ }
	761	+
	762	+ trace_afs_make_fs_call1(call, &dvp->fid, name);
	763	+ afs_make_op_call(op, call, GFP_NOFS);
913	764	}
914	765
915	766	/*
..	..	@@ -917,7 +768,9 @@
917	768	*/
918	769	static int afs_deliver_fs_link(struct afs_call *call)
919	770	{
920		- struct afs_vnode dvnode = call->reply[0], vnode = call->reply[1];
	771	+ struct afs_operation *op = call->op;
	772	+ struct afs_vnode_param *dvp = &op->file[0];
	773	+ struct afs_vnode_param *vp = &op->file[1];
921	774	const __be32 *bp;
922	775	int ret;
923	776
..	..	@@ -929,11 +782,9 @@
929	782
930	783	/* unmarshall the reply once we've received all of it */
931	784	bp = call->buffer;
932		- if (afs_decode_status(call, &bp, &vnode->status, vnode, NULL, NULL) < 0 \|\|
933		- afs_decode_status(call, &bp, &dvnode->status, dvnode,
934		- &call->expected_version, NULL) < 0)
935		- return afs_protocol_error(call, -EBADMSG);
936		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
	785	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	786	+ xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
	787	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
937	788
938	789	_leave(" = 0 [done]");
939	790	return 0;
..	..	@@ -952,50 +803,44 @@
952	803	/*
953	804	* make a hard link
954	805	*/
955		-int afs_fs_link(struct afs_fs_cursor fc, struct afs_vnode vnode,
956		- const char *name, u64 current_data_version)
	806	+void afs_fs_link(struct afs_operation *op)
957	807	{
958		- struct afs_vnode *dvnode = fc->vnode;
	808	+ const struct qstr *name = &op->dentry->d_name;
	809	+ struct afs_vnode_param *dvp = &op->file[0];
	810	+ struct afs_vnode_param *vp = &op->file[1];
959	811	struct afs_call *call;
960		- struct afs_net *net = afs_v2net(vnode);
961	812	size_t namesz, reqsz, padsz;
962	813	__be32 *bp;
963	814
964	815	_enter("");
965	816
966		- namesz = strlen(name);
	817	+ namesz = name->len;
967	818	padsz = (4 - (namesz & 3)) & 3;
968	819	reqsz = (5 * 4) + namesz + padsz + (3 * 4);
969	820
970		- call = afs_alloc_flat_call(net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
	821	+ call = afs_alloc_flat_call(op->net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
971	822	if (!call)
972		- return -ENOMEM;
973		-
974		- call->key = fc->key;
975		- call->reply[0] = dvnode;
976		- call->reply[1] = vnode;
977		- call->expected_version = current_data_version + 1;
	823	+ return afs_op_nomem(op);
978	824
979	825	/* marshall the parameters */
980	826	bp = call->request;
981	827	*bp++ = htonl(FSLINK);
982		- *bp++ = htonl(dvnode->fid.vid);
983		- *bp++ = htonl(dvnode->fid.vnode);
984		- *bp++ = htonl(dvnode->fid.unique);
	828	+ *bp++ = htonl(dvp->fid.vid);
	829	+ *bp++ = htonl(dvp->fid.vnode);
	830	+ *bp++ = htonl(dvp->fid.unique);
985	831	*bp++ = htonl(namesz);
986		- memcpy(bp, name, namesz);
	832	+ memcpy(bp, name->name, namesz);
987	833	bp = (void *) bp + namesz;
988	834	if (padsz > 0) {
989	835	memset(bp, 0, padsz);
990	836	bp = (void *) bp + padsz;
991	837	}
992		- *bp++ = htonl(vnode->fid.vid);
993		- *bp++ = htonl(vnode->fid.vnode);
994		- *bp++ = htonl(vnode->fid.unique);
	838	+ *bp++ = htonl(vp->fid.vid);
	839	+ *bp++ = htonl(vp->fid.vnode);
	840	+ *bp++ = htonl(vp->fid.unique);
995	841
996		- afs_use_fs_server(call, fc->cbi);
997		- trace_afs_make_fs_call(call, &vnode->fid);
998		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	842	+ trace_afs_make_fs_call1(call, &vp->fid, name);
	843	+ afs_make_op_call(op, call, GFP_NOFS);
999	844	}
1000	845
1001	846	/*
..	..	@@ -1003,7 +848,9 @@
1003	848	*/
1004	849	static int afs_deliver_fs_symlink(struct afs_call *call)
1005	850	{
1006		- struct afs_vnode *vnode = call->reply[0];
	851	+ struct afs_operation *op = call->op;
	852	+ struct afs_vnode_param *dvp = &op->file[0];
	853	+ struct afs_vnode_param *vp = &op->file[1];
1007	854	const __be32 *bp;
1008	855	int ret;
1009	856
..	..	@@ -1015,12 +862,10 @@
1015	862
1016	863	/* unmarshall the reply once we've received all of it */
1017	864	bp = call->buffer;
1018		- xdr_decode_AFSFid(&bp, call->reply[1]);
1019		- if (afs_decode_status(call, &bp, call->reply[2], NULL, NULL, NULL) \|\|
1020		- afs_decode_status(call, &bp, &vnode->status, vnode,
1021		- &call->expected_version, NULL) < 0)
1022		- return afs_protocol_error(call, -EBADMSG);
1023		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
	865	+ xdr_decode_AFSFid(&bp, &vp->fid);
	866	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	867	+ xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
	868	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
1024	869
1025	870	_leave(" = 0 [done]");
1026	871	return 0;
..	..	@@ -1039,70 +884,58 @@
1039	884	/*
1040	885	* create a symbolic link
1041	886	*/
1042		-int afs_fs_symlink(struct afs_fs_cursor *fc,
1043		- const char *name,
1044		- const char *contents,
1045		- u64 current_data_version,
1046		- struct afs_fid *newfid,
1047		- struct afs_file_status *newstatus)
	887	+void afs_fs_symlink(struct afs_operation *op)
1048	888	{
1049		- struct afs_vnode *vnode = fc->vnode;
	889	+ const struct qstr *name = &op->dentry->d_name;
	890	+ struct afs_vnode_param *dvp = &op->file[0];
1050	891	struct afs_call *call;
1051		- struct afs_net *net = afs_v2net(vnode);
1052	892	size_t namesz, reqsz, padsz, c_namesz, c_padsz;
1053	893	__be32 *bp;
1054	894
1055	895	_enter("");
1056	896
1057		- namesz = strlen(name);
	897	+ namesz = name->len;
1058	898	padsz = (4 - (namesz & 3)) & 3;
1059	899
1060		- c_namesz = strlen(contents);
	900	+ c_namesz = strlen(op->create.symlink);
1061	901	c_padsz = (4 - (c_namesz & 3)) & 3;
1062	902
1063	903	reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
1064	904
1065		- call = afs_alloc_flat_call(net, &afs_RXFSSymlink, reqsz,
	905	+ call = afs_alloc_flat_call(op->net, &afs_RXFSSymlink, reqsz,
1066	906	(3 + 21 + 21 + 6) * 4);
1067	907	if (!call)
1068		- return -ENOMEM;
1069		-
1070		- call->key = fc->key;
1071		- call->reply[0] = vnode;
1072		- call->reply[1] = newfid;
1073		- call->reply[2] = newstatus;
1074		- call->expected_version = current_data_version + 1;
	908	+ return afs_op_nomem(op);
1075	909
1076	910	/* marshall the parameters */
1077	911	bp = call->request;
1078	912	*bp++ = htonl(FSSYMLINK);
1079		- *bp++ = htonl(vnode->fid.vid);
1080		- *bp++ = htonl(vnode->fid.vnode);
1081		- *bp++ = htonl(vnode->fid.unique);
	913	+ *bp++ = htonl(dvp->fid.vid);
	914	+ *bp++ = htonl(dvp->fid.vnode);
	915	+ *bp++ = htonl(dvp->fid.unique);
1082	916	*bp++ = htonl(namesz);
1083		- memcpy(bp, name, namesz);
	917	+ memcpy(bp, name->name, namesz);
1084	918	bp = (void *) bp + namesz;
1085	919	if (padsz > 0) {
1086	920	memset(bp, 0, padsz);
1087	921	bp = (void *) bp + padsz;
1088	922	}
1089	923	*bp++ = htonl(c_namesz);
1090		- memcpy(bp, contents, c_namesz);
	924	+ memcpy(bp, op->create.symlink, c_namesz);
1091	925	bp = (void *) bp + c_namesz;
1092	926	if (c_padsz > 0) {
1093	927	memset(bp, 0, c_padsz);
1094	928	bp = (void *) bp + c_padsz;
1095	929	}
1096	930	*bp++ = htonl(AFS_SET_MODE \| AFS_SET_MTIME);
1097		- bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); / mtime */
	931	+ bp++ = htonl(op->mtime.tv_sec); / mtime */
1098	932	bp++ = 0; / owner */
1099	933	bp++ = 0; / group */
1100	934	bp++ = htonl(S_IRWXUGO); / unix mode */
1101	935	bp++ = 0; / segment size */
1102	936
1103		- afs_use_fs_server(call, fc->cbi);
1104		- trace_afs_make_fs_call(call, &vnode->fid);
1105		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	937	+ trace_afs_make_fs_call1(call, &dvp->fid, name);
	938	+ afs_make_op_call(op, call, GFP_NOFS);
1106	939	}
1107	940
1108	941	/*
..	..	@@ -1110,26 +943,23 @@
1110	943	*/
1111	944	static int afs_deliver_fs_rename(struct afs_call *call)
1112	945	{
1113		- struct afs_vnode orig_dvnode = call->reply[0], new_dvnode = call->reply[1];
	946	+ struct afs_operation *op = call->op;
	947	+ struct afs_vnode_param *orig_dvp = &op->file[0];
	948	+ struct afs_vnode_param *new_dvp = &op->file[1];
1114	949	const __be32 *bp;
1115	950	int ret;
1116		-
1117		- _enter("{%u}", call->unmarshall);
1118	951
1119	952	ret = afs_transfer_reply(call);
1120	953	if (ret < 0)
1121	954	return ret;
1122	955
1123		- /* unmarshall the reply once we've received all of it */
1124	956	bp = call->buffer;
1125		- if (afs_decode_status(call, &bp, &orig_dvnode->status, orig_dvnode,
1126		- &call->expected_version, NULL) < 0)
1127		- return afs_protocol_error(call, -EBADMSG);
1128		- if (new_dvnode != orig_dvnode &&
1129		- afs_decode_status(call, &bp, &new_dvnode->status, new_dvnode,
1130		- &call->expected_version_2, NULL) < 0)
1131		- return afs_protocol_error(call, -EBADMSG);
1132		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
	957	+ /* If the two dirs are the same, we have two copies of the same status
	958	+ * report, so we just decode it twice.
	959	+ */
	960	+ xdr_decode_AFSFetchStatus(&bp, call, &orig_dvp->scb);
	961	+ xdr_decode_AFSFetchStatus(&bp, call, &new_dvp->scb);
	962	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
1133	963
1134	964	_leave(" = 0 [done]");
1135	965	return 0;
..	..	@@ -1146,27 +976,24 @@
1146	976	};
1147	977
1148	978	/*
1149		- * create a symbolic link
	979	+ * Rename/move a file or directory.
1150	980	*/
1151		-int afs_fs_rename(struct afs_fs_cursor *fc,
1152		- const char *orig_name,
1153		- struct afs_vnode *new_dvnode,
1154		- const char *new_name,
1155		- u64 current_orig_data_version,
1156		- u64 current_new_data_version)
	981	+void afs_fs_rename(struct afs_operation *op)
1157	982	{
1158		- struct afs_vnode *orig_dvnode = fc->vnode;
	983	+ struct afs_vnode_param *orig_dvp = &op->file[0];
	984	+ struct afs_vnode_param *new_dvp = &op->file[1];
	985	+ const struct qstr *orig_name = &op->dentry->d_name;
	986	+ const struct qstr *new_name = &op->dentry_2->d_name;
1159	987	struct afs_call *call;
1160		- struct afs_net *net = afs_v2net(orig_dvnode);
1161	988	size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
1162	989	__be32 *bp;
1163	990
1164	991	_enter("");
1165	992
1166		- o_namesz = strlen(orig_name);
	993	+ o_namesz = orig_name->len;
1167	994	o_padsz = (4 - (o_namesz & 3)) & 3;
1168	995
1169		- n_namesz = strlen(new_name);
	996	+ n_namesz = new_name->len;
1170	997	n_padsz = (4 - (n_namesz & 3)) & 3;
1171	998
1172	999	reqsz = (4 * 4) +
..	..	@@ -1174,52 +1001,46 @@
1174	1001	(3 * 4) +
1175	1002	4 + n_namesz + n_padsz;
1176	1003
1177		- call = afs_alloc_flat_call(net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
	1004	+ call = afs_alloc_flat_call(op->net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
1178	1005	if (!call)
1179		- return -ENOMEM;
1180		-
1181		- call->key = fc->key;
1182		- call->reply[0] = orig_dvnode;
1183		- call->reply[1] = new_dvnode;
1184		- call->expected_version = current_orig_data_version + 1;
1185		- call->expected_version_2 = current_new_data_version + 1;
	1006	+ return afs_op_nomem(op);
1186	1007
1187	1008	/* marshall the parameters */
1188	1009	bp = call->request;
1189	1010	*bp++ = htonl(FSRENAME);
1190		- *bp++ = htonl(orig_dvnode->fid.vid);
1191		- *bp++ = htonl(orig_dvnode->fid.vnode);
1192		- *bp++ = htonl(orig_dvnode->fid.unique);
	1011	+ *bp++ = htonl(orig_dvp->fid.vid);
	1012	+ *bp++ = htonl(orig_dvp->fid.vnode);
	1013	+ *bp++ = htonl(orig_dvp->fid.unique);
1193	1014	*bp++ = htonl(o_namesz);
1194		- memcpy(bp, orig_name, o_namesz);
	1015	+ memcpy(bp, orig_name->name, o_namesz);
1195	1016	bp = (void *) bp + o_namesz;
1196	1017	if (o_padsz > 0) {
1197	1018	memset(bp, 0, o_padsz);
1198	1019	bp = (void *) bp + o_padsz;
1199	1020	}
1200	1021
1201		- *bp++ = htonl(new_dvnode->fid.vid);
1202		- *bp++ = htonl(new_dvnode->fid.vnode);
1203		- *bp++ = htonl(new_dvnode->fid.unique);
	1022	+ *bp++ = htonl(new_dvp->fid.vid);
	1023	+ *bp++ = htonl(new_dvp->fid.vnode);
	1024	+ *bp++ = htonl(new_dvp->fid.unique);
1204	1025	*bp++ = htonl(n_namesz);
1205		- memcpy(bp, new_name, n_namesz);
	1026	+ memcpy(bp, new_name->name, n_namesz);
1206	1027	bp = (void *) bp + n_namesz;
1207	1028	if (n_padsz > 0) {
1208	1029	memset(bp, 0, n_padsz);
1209	1030	bp = (void *) bp + n_padsz;
1210	1031	}
1211	1032
1212		- afs_use_fs_server(call, fc->cbi);
1213		- trace_afs_make_fs_call(call, &orig_dvnode->fid);
1214		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1033	+ trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name);
	1034	+ afs_make_op_call(op, call, GFP_NOFS);
1215	1035	}
1216	1036
1217	1037	/*
1218		- * deliver reply data to an FS.StoreData
	1038	+ * Deliver reply data to FS.StoreData or FS.StoreStatus
1219	1039	*/
1220	1040	static int afs_deliver_fs_store_data(struct afs_call *call)
1221	1041	{
1222		- struct afs_vnode *vnode = call->reply[0];
	1042	+ struct afs_operation *op = call->op;
	1043	+ struct afs_vnode_param *vp = &op->file[0];
1223	1044	const __be32 *bp;
1224	1045	int ret;
1225	1046
..	..	@@ -1231,12 +1052,8 @@
1231	1052
1232	1053	/* unmarshall the reply once we've received all of it */
1233	1054	bp = call->buffer;
1234		- if (afs_decode_status(call, &bp, &vnode->status, vnode,
1235		- &call->expected_version, NULL) < 0)
1236		- return afs_protocol_error(call, -EBADMSG);
1237		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
1238		-
1239		- afs_pages_written_back(vnode, call);
	1055	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	1056	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
1240	1057
1241	1058	_leave(" = 0 [done]");
1242	1059	return 0;
..	..	@@ -1262,84 +1079,69 @@
1262	1079	/*
1263	1080	* store a set of pages to a very large file
1264	1081	*/
1265		-static int afs_fs_store_data64(struct afs_fs_cursor *fc,
1266		- struct address_space *mapping,
1267		- pgoff_t first, pgoff_t last,
1268		- unsigned offset, unsigned to,
1269		- loff_t size, loff_t pos, loff_t i_size)
	1082	+static void afs_fs_store_data64(struct afs_operation *op,
	1083	+ loff_t pos, loff_t size, loff_t i_size)
1270	1084	{
1271		- struct afs_vnode *vnode = fc->vnode;
	1085	+ struct afs_vnode_param *vp = &op->file[0];
1272	1086	struct afs_call *call;
1273		- struct afs_net *net = afs_v2net(vnode);
1274	1087	__be32 *bp;
1275	1088
1276		- _enter(",%x,{%x:%u},,",
1277		- key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
	1089	+ _enter(",%x,{%llx:%llu},,",
	1090	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1278	1091
1279		- call = afs_alloc_flat_call(net, &afs_RXFSStoreData64,
	1092	+ call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64,
1280	1093	(4 + 6 + 3 * 2) * 4,
1281	1094	(21 + 6) * 4);
1282	1095	if (!call)
1283		- return -ENOMEM;
	1096	+ return afs_op_nomem(op);
1284	1097
1285		- call->key = fc->key;
1286		- call->mapping = mapping;
1287		- call->reply[0] = vnode;
1288		- call->first = first;
1289		- call->last = last;
1290		- call->first_offset = offset;
1291		- call->last_to = to;
1292	1098	call->send_pages = true;
1293		- call->expected_version = vnode->status.data_version + 1;
1294	1099
1295	1100	/* marshall the parameters */
1296	1101	bp = call->request;
1297	1102	*bp++ = htonl(FSSTOREDATA64);
1298		- *bp++ = htonl(vnode->fid.vid);
1299		- *bp++ = htonl(vnode->fid.vnode);
1300		- *bp++ = htonl(vnode->fid.unique);
	1103	+ *bp++ = htonl(vp->fid.vid);
	1104	+ *bp++ = htonl(vp->fid.vnode);
	1105	+ *bp++ = htonl(vp->fid.unique);
1301	1106
1302	1107	bp++ = htonl(AFS_SET_MTIME); / mask */
1303		- bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); / mtime */
	1108	+ bp++ = htonl(op->mtime.tv_sec); / mtime */
1304	1109	bp++ = 0; / owner */
1305	1110	bp++ = 0; / group */
1306	1111	bp++ = 0; / unix mode */
1307	1112	bp++ = 0; / segment size */
1308	1113
1309		- *bp++ = htonl(pos >> 32);
1310		- *bp++ = htonl((u32) pos);
1311		- *bp++ = htonl(size >> 32);
1312		- *bp++ = htonl((u32) size);
1313		- *bp++ = htonl(i_size >> 32);
1314		- *bp++ = htonl((u32) i_size);
	1114	+ *bp++ = htonl(upper_32_bits(pos));
	1115	+ *bp++ = htonl(lower_32_bits(pos));
	1116	+ *bp++ = htonl(upper_32_bits(size));
	1117	+ *bp++ = htonl(lower_32_bits(size));
	1118	+ *bp++ = htonl(upper_32_bits(i_size));
	1119	+ *bp++ = htonl(lower_32_bits(i_size));
1315	1120
1316		- trace_afs_make_fs_call(call, &vnode->fid);
1317		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1121	+ trace_afs_make_fs_call(call, &vp->fid);
	1122	+ afs_make_op_call(op, call, GFP_NOFS);
1318	1123	}
1319	1124
1320	1125	/*
1321	1126	* store a set of pages
1322	1127	*/
1323		-int afs_fs_store_data(struct afs_fs_cursor fc, struct address_space mapping,
1324		- pgoff_t first, pgoff_t last,
1325		- unsigned offset, unsigned to)
	1128	+void afs_fs_store_data(struct afs_operation *op)
1326	1129	{
1327		- struct afs_vnode *vnode = fc->vnode;
	1130	+ struct afs_vnode_param *vp = &op->file[0];
1328	1131	struct afs_call *call;
1329		- struct afs_net *net = afs_v2net(vnode);
1330	1132	loff_t size, pos, i_size;
1331	1133	__be32 *bp;
1332	1134
1333		- _enter(",%x,{%x:%u},,",
1334		- key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
	1135	+ _enter(",%x,{%llx:%llu},,",
	1136	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1335	1137
1336		- size = (loff_t)to - (loff_t)offset;
1337		- if (first != last)
1338		- size += (loff_t)(last - first) << PAGE_SHIFT;
1339		- pos = (loff_t)first << PAGE_SHIFT;
1340		- pos += offset;
	1138	+ size = (loff_t)op->store.last_to - (loff_t)op->store.first_offset;
	1139	+ if (op->store.first != op->store.last)
	1140	+ size += (loff_t)(op->store.last - op->store.first) << PAGE_SHIFT;
	1141	+ pos = (loff_t)op->store.first << PAGE_SHIFT;
	1142	+ pos += op->store.first_offset;
1341	1143
1342		- i_size = i_size_read(&vnode->vfs_inode);
	1144	+ i_size = i_size_read(&vp->vnode->vfs_inode);
1343	1145	if (pos + size > i_size)
1344	1146	i_size = size + pos;
1345	1147
..	..	@@ -1347,73 +1149,38 @@
1347	1149	(unsigned long long) size, (unsigned long long) pos,
1348	1150	(unsigned long long) i_size);
1349	1151
1350		- if (pos >> 32 \|\| i_size >> 32 \|\| size >> 32 \|\| (pos + size) >> 32)
1351		- return afs_fs_store_data64(fc, mapping, first, last, offset, to,
1352		- size, pos, i_size);
	1152	+ if (upper_32_bits(pos) \|\| upper_32_bits(i_size) \|\| upper_32_bits(size) \|\|
	1153	+ upper_32_bits(pos + size))
	1154	+ return afs_fs_store_data64(op, pos, size, i_size);
1353	1155
1354		- call = afs_alloc_flat_call(net, &afs_RXFSStoreData,
	1156	+ call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData,
1355	1157	(4 + 6 + 3) * 4,
1356	1158	(21 + 6) * 4);
1357	1159	if (!call)
1358		- return -ENOMEM;
	1160	+ return afs_op_nomem(op);
1359	1161
1360		- call->key = fc->key;
1361		- call->mapping = mapping;
1362		- call->reply[0] = vnode;
1363		- call->first = first;
1364		- call->last = last;
1365		- call->first_offset = offset;
1366		- call->last_to = to;
1367	1162	call->send_pages = true;
1368		- call->expected_version = vnode->status.data_version + 1;
1369	1163
1370	1164	/* marshall the parameters */
1371	1165	bp = call->request;
1372	1166	*bp++ = htonl(FSSTOREDATA);
1373		- *bp++ = htonl(vnode->fid.vid);
1374		- *bp++ = htonl(vnode->fid.vnode);
1375		- *bp++ = htonl(vnode->fid.unique);
	1167	+ *bp++ = htonl(vp->fid.vid);
	1168	+ *bp++ = htonl(vp->fid.vnode);
	1169	+ *bp++ = htonl(vp->fid.unique);
1376	1170
1377	1171	bp++ = htonl(AFS_SET_MTIME); / mask */
1378		- bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); / mtime */
	1172	+ bp++ = htonl(op->mtime.tv_sec); / mtime */
1379	1173	bp++ = 0; / owner */
1380	1174	bp++ = 0; / group */
1381	1175	bp++ = 0; / unix mode */
1382	1176	bp++ = 0; / segment size */
1383	1177
1384		- *bp++ = htonl(pos);
1385		- *bp++ = htonl(size);
1386		- *bp++ = htonl(i_size);
	1178	+ *bp++ = htonl(lower_32_bits(pos));
	1179	+ *bp++ = htonl(lower_32_bits(size));
	1180	+ *bp++ = htonl(lower_32_bits(i_size));
1387	1181
1388		- afs_use_fs_server(call, fc->cbi);
1389		- trace_afs_make_fs_call(call, &vnode->fid);
1390		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1391		-}
1392		-
1393		-/*
1394		- * deliver reply data to an FS.StoreStatus
1395		- */
1396		-static int afs_deliver_fs_store_status(struct afs_call *call)
1397		-{
1398		- struct afs_vnode *vnode = call->reply[0];
1399		- const __be32 *bp;
1400		- int ret;
1401		-
1402		- _enter("");
1403		-
1404		- ret = afs_transfer_reply(call);
1405		- if (ret < 0)
1406		- return ret;
1407		-
1408		- /* unmarshall the reply once we've received all of it */
1409		- bp = call->buffer;
1410		- if (afs_decode_status(call, &bp, &vnode->status, vnode,
1411		- &call->expected_version, NULL) < 0)
1412		- return afs_protocol_error(call, -EBADMSG);
1413		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
1414		-
1415		- _leave(" = 0 [done]");
1416		- return 0;
	1182	+ trace_afs_make_fs_call(call, &vp->fid);
	1183	+ afs_make_op_call(op, call, GFP_NOFS);
1417	1184	}
1418	1185
1419	1186	/*
..	..	@@ -1422,21 +1189,21 @@
1422	1189	static const struct afs_call_type afs_RXFSStoreStatus = {
1423	1190	.name = "FS.StoreStatus",
1424	1191	.op = afs_FS_StoreStatus,
1425		- .deliver = afs_deliver_fs_store_status,
	1192	+ .deliver = afs_deliver_fs_store_data,
1426	1193	.destructor = afs_flat_call_destructor,
1427	1194	};
1428	1195
1429	1196	static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1430	1197	.name = "FS.StoreData",
1431	1198	.op = afs_FS_StoreData,
1432		- .deliver = afs_deliver_fs_store_status,
	1199	+ .deliver = afs_deliver_fs_store_data,
1433	1200	.destructor = afs_flat_call_destructor,
1434	1201	};
1435	1202
1436	1203	static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1437	1204	.name = "FS.StoreData64",
1438	1205	.op = afs_FS_StoreData64,
1439		- .deliver = afs_deliver_fs_store_status,
	1206	+ .deliver = afs_deliver_fs_store_data,
1440	1207	.destructor = afs_flat_call_destructor,
1441	1208	};
1442	1209
..	..	@@ -1444,134 +1211,119 @@
1444	1211	* set the attributes on a very large file, using FS.StoreData rather than
1445	1212	* FS.StoreStatus so as to alter the file size also
1446	1213	*/
1447		-static int afs_fs_setattr_size64(struct afs_fs_cursor fc, struct iattr attr)
	1214	+static void afs_fs_setattr_size64(struct afs_operation *op)
1448	1215	{
1449		- struct afs_vnode *vnode = fc->vnode;
	1216	+ struct afs_vnode_param *vp = &op->file[0];
1450	1217	struct afs_call *call;
1451		- struct afs_net *net = afs_v2net(vnode);
	1218	+ struct iattr *attr = op->setattr.attr;
1452	1219	__be32 *bp;
1453	1220
1454		- _enter(",%x,{%x:%u},,",
1455		- key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
	1221	+ _enter(",%x,{%llx:%llu},,",
	1222	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1456	1223
1457	1224	ASSERT(attr->ia_valid & ATTR_SIZE);
1458	1225
1459		- call = afs_alloc_flat_call(net, &afs_RXFSStoreData64_as_Status,
	1226	+ call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64_as_Status,
1460	1227	(4 + 6 + 3 * 2) * 4,
1461	1228	(21 + 6) * 4);
1462	1229	if (!call)
1463		- return -ENOMEM;
1464		-
1465		- call->key = fc->key;
1466		- call->reply[0] = vnode;
1467		- call->expected_version = vnode->status.data_version + 1;
	1230	+ return afs_op_nomem(op);
1468	1231
1469	1232	/* marshall the parameters */
1470	1233	bp = call->request;
1471	1234	*bp++ = htonl(FSSTOREDATA64);
1472		- *bp++ = htonl(vnode->fid.vid);
1473		- *bp++ = htonl(vnode->fid.vnode);
1474		- *bp++ = htonl(vnode->fid.unique);
	1235	+ *bp++ = htonl(vp->fid.vid);
	1236	+ *bp++ = htonl(vp->fid.vnode);
	1237	+ *bp++ = htonl(vp->fid.unique);
1475	1238
1476	1239	xdr_encode_AFS_StoreStatus(&bp, attr);
1477	1240
1478		- bp++ = 0; / position of start of write */
	1241	+ bp++ = htonl(upper_32_bits(attr->ia_size)); / position of start of write */
	1242	+ *bp++ = htonl(lower_32_bits(attr->ia_size));
	1243	+ bp++ = 0; / size of write */
1479	1244	*bp++ = 0;
1480		- bp++ = 0; / size of write */
1481		- *bp++ = 0;
1482		- bp++ = htonl(attr->ia_size >> 32); / new file length */
1483		- *bp++ = htonl((u32) attr->ia_size);
	1245	+ bp++ = htonl(upper_32_bits(attr->ia_size)); / new file length */
	1246	+ *bp++ = htonl(lower_32_bits(attr->ia_size));
1484	1247
1485		- afs_use_fs_server(call, fc->cbi);
1486		- trace_afs_make_fs_call(call, &vnode->fid);
1487		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1248	+ trace_afs_make_fs_call(call, &vp->fid);
	1249	+ afs_make_op_call(op, call, GFP_NOFS);
1488	1250	}
1489	1251
1490	1252	/*
1491	1253	* set the attributes on a file, using FS.StoreData rather than FS.StoreStatus
1492	1254	* so as to alter the file size also
1493	1255	*/
1494		-static int afs_fs_setattr_size(struct afs_fs_cursor fc, struct iattr attr)
	1256	+static void afs_fs_setattr_size(struct afs_operation *op)
1495	1257	{
1496		- struct afs_vnode *vnode = fc->vnode;
	1258	+ struct afs_vnode_param *vp = &op->file[0];
1497	1259	struct afs_call *call;
1498		- struct afs_net *net = afs_v2net(vnode);
	1260	+ struct iattr *attr = op->setattr.attr;
1499	1261	__be32 *bp;
1500	1262
1501		- _enter(",%x,{%x:%u},,",
1502		- key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
	1263	+ _enter(",%x,{%llx:%llu},,",
	1264	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1503	1265
1504	1266	ASSERT(attr->ia_valid & ATTR_SIZE);
1505		- if (attr->ia_size >> 32)
1506		- return afs_fs_setattr_size64(fc, attr);
	1267	+ if (upper_32_bits(attr->ia_size))
	1268	+ return afs_fs_setattr_size64(op);
1507	1269
1508		- call = afs_alloc_flat_call(net, &afs_RXFSStoreData_as_Status,
	1270	+ call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status,
1509	1271	(4 + 6 + 3) * 4,
1510	1272	(21 + 6) * 4);
1511	1273	if (!call)
1512		- return -ENOMEM;
1513		-
1514		- call->key = fc->key;
1515		- call->reply[0] = vnode;
1516		- call->expected_version = vnode->status.data_version + 1;
	1274	+ return afs_op_nomem(op);
1517	1275
1518	1276	/* marshall the parameters */
1519	1277	bp = call->request;
1520	1278	*bp++ = htonl(FSSTOREDATA);
1521		- *bp++ = htonl(vnode->fid.vid);
1522		- *bp++ = htonl(vnode->fid.vnode);
1523		- *bp++ = htonl(vnode->fid.unique);
	1279	+ *bp++ = htonl(vp->fid.vid);
	1280	+ *bp++ = htonl(vp->fid.vnode);
	1281	+ *bp++ = htonl(vp->fid.unique);
1524	1282
1525	1283	xdr_encode_AFS_StoreStatus(&bp, attr);
1526	1284
1527		- bp++ = 0; / position of start of write */
	1285	+ bp++ = htonl(attr->ia_size); / position of start of write */
1528	1286	bp++ = 0; / size of write */
1529	1287	bp++ = htonl(attr->ia_size); / new file length */
1530	1288
1531		- afs_use_fs_server(call, fc->cbi);
1532		- trace_afs_make_fs_call(call, &vnode->fid);
1533		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1289	+ trace_afs_make_fs_call(call, &vp->fid);
	1290	+ afs_make_op_call(op, call, GFP_NOFS);
1534	1291	}
1535	1292
1536	1293	/*
1537	1294	* set the attributes on a file, using FS.StoreData if there's a change in file
1538	1295	* size, and FS.StoreStatus otherwise
1539	1296	*/
1540		-int afs_fs_setattr(struct afs_fs_cursor fc, struct iattr attr)
	1297	+void afs_fs_setattr(struct afs_operation *op)
1541	1298	{
1542		- struct afs_vnode *vnode = fc->vnode;
	1299	+ struct afs_vnode_param *vp = &op->file[0];
1543	1300	struct afs_call *call;
1544		- struct afs_net *net = afs_v2net(vnode);
	1301	+ struct iattr *attr = op->setattr.attr;
1545	1302	__be32 *bp;
1546	1303
1547	1304	if (attr->ia_valid & ATTR_SIZE)
1548		- return afs_fs_setattr_size(fc, attr);
	1305	+ return afs_fs_setattr_size(op);
1549	1306
1550		- _enter(",%x,{%x:%u},,",
1551		- key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
	1307	+ _enter(",%x,{%llx:%llu},,",
	1308	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1552	1309
1553		- call = afs_alloc_flat_call(net, &afs_RXFSStoreStatus,
	1310	+ call = afs_alloc_flat_call(op->net, &afs_RXFSStoreStatus,
1554	1311	(4 + 6) * 4,
1555	1312	(21 + 6) * 4);
1556	1313	if (!call)
1557		- return -ENOMEM;
1558		-
1559		- call->key = fc->key;
1560		- call->reply[0] = vnode;
1561		- call->expected_version = vnode->status.data_version;
	1314	+ return afs_op_nomem(op);
1562	1315
1563	1316	/* marshall the parameters */
1564	1317	bp = call->request;
1565	1318	*bp++ = htonl(FSSTORESTATUS);
1566		- *bp++ = htonl(vnode->fid.vid);
1567		- *bp++ = htonl(vnode->fid.vnode);
1568		- *bp++ = htonl(vnode->fid.unique);
	1319	+ *bp++ = htonl(vp->fid.vid);
	1320	+ *bp++ = htonl(vp->fid.vnode);
	1321	+ *bp++ = htonl(vp->fid.unique);
1569	1322
1570		- xdr_encode_AFS_StoreStatus(&bp, attr);
	1323	+ xdr_encode_AFS_StoreStatus(&bp, op->setattr.attr);
1571	1324
1572		- afs_use_fs_server(call, fc->cbi);
1573		- trace_afs_make_fs_call(call, &vnode->fid);
1574		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1325	+ trace_afs_make_fs_call(call, &vp->fid);
	1326	+ afs_make_op_call(op, call, GFP_NOFS);
1575	1327	}
1576	1328
1577	1329	/*
..	..	@@ -1579,181 +1331,126 @@
1579	1331	*/
1580	1332	static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1581	1333	{
	1334	+ struct afs_operation *op = call->op;
1582	1335	const __be32 *bp;
1583	1336	char *p;
	1337	+ u32 size;
1584	1338	int ret;
1585	1339
1586	1340	_enter("{%u}", call->unmarshall);
1587	1341
1588	1342	switch (call->unmarshall) {
1589	1343	case 0:
1590		- call->offset = 0;
1591	1344	call->unmarshall++;
	1345	+ afs_extract_to_buf(call, 12 * 4);
	1346	+ fallthrough;
1592	1347
1593	1348	/* extract the returned status record */
1594	1349	case 1:
1595	1350	_debug("extract status");
1596		- ret = afs_extract_data(call, call->buffer,
1597		- 12 * 4, true);
	1351	+ ret = afs_extract_data(call, true);
1598	1352	if (ret < 0)
1599	1353	return ret;
1600	1354
1601	1355	bp = call->buffer;
1602		- xdr_decode_AFSFetchVolumeStatus(&bp, call->reply[1]);
1603		- call->offset = 0;
	1356	+ xdr_decode_AFSFetchVolumeStatus(&bp, &op->volstatus.vs);
1604	1357	call->unmarshall++;
	1358	+ afs_extract_to_tmp(call);
	1359	+ fallthrough;
1605	1360
1606	1361	/* extract the volume name length */
1607	1362	case 2:
1608		- ret = afs_extract_data(call, &call->tmp, 4, true);
	1363	+ ret = afs_extract_data(call, true);
1609	1364	if (ret < 0)
1610	1365	return ret;
1611	1366
1612	1367	call->count = ntohl(call->tmp);
1613	1368	_debug("volname length: %u", call->count);
1614	1369	if (call->count >= AFSNAMEMAX)
1615		- return afs_protocol_error(call, -EBADMSG);
1616		- call->offset = 0;
	1370	+ return afs_protocol_error(call, afs_eproto_volname_len);
	1371	+ size = (call->count + 3) & ~3; /* It's padded */
	1372	+ afs_extract_to_buf(call, size);
1617	1373	call->unmarshall++;
	1374	+ fallthrough;
1618	1375
1619	1376	/* extract the volume name */
1620	1377	case 3:
1621	1378	_debug("extract volname");
1622		- if (call->count > 0) {
1623		- ret = afs_extract_data(call, call->reply[2],
1624		- call->count, true);
1625		- if (ret < 0)
1626		- return ret;
1627		- }
1628		-
1629		- p = call->reply[2];
1630		- p[call->count] = 0;
1631		- _debug("volname '%s'", p);
1632		-
1633		- call->offset = 0;
1634		- call->unmarshall++;
1635		-
1636		- /* extract the volume name padding */
1637		- if ((call->count & 3) == 0) {
1638		- call->unmarshall++;
1639		- goto no_volname_padding;
1640		- }
1641		- call->count = 4 - (call->count & 3);
1642		-
1643		- case 4:
1644		- ret = afs_extract_data(call, call->buffer,
1645		- call->count, true);
	1379	+ ret = afs_extract_data(call, true);
1646	1380	if (ret < 0)
1647	1381	return ret;
1648	1382
1649		- call->offset = 0;
	1383	+ p = call->buffer;
	1384	+ p[call->count] = 0;
	1385	+ _debug("volname '%s'", p);
	1386	+ afs_extract_to_tmp(call);
1650	1387	call->unmarshall++;
1651		- no_volname_padding:
	1388	+ fallthrough;
1652	1389
1653	1390	/* extract the offline message length */
1654		- case 5:
1655		- ret = afs_extract_data(call, &call->tmp, 4, true);
	1391	+ case 4:
	1392	+ ret = afs_extract_data(call, true);
1656	1393	if (ret < 0)
1657	1394	return ret;
1658	1395
1659	1396	call->count = ntohl(call->tmp);
1660	1397	_debug("offline msg length: %u", call->count);
1661	1398	if (call->count >= AFSNAMEMAX)
1662		- return afs_protocol_error(call, -EBADMSG);
1663		- call->offset = 0;
	1399	+ return afs_protocol_error(call, afs_eproto_offline_msg_len);
	1400	+ size = (call->count + 3) & ~3; /* It's padded */
	1401	+ afs_extract_to_buf(call, size);
1664	1402	call->unmarshall++;
	1403	+ fallthrough;
1665	1404
1666	1405	/* extract the offline message */
1667		- case 6:
	1406	+ case 5:
1668	1407	_debug("extract offline");
1669		- if (call->count > 0) {
1670		- ret = afs_extract_data(call, call->reply[2],
1671		- call->count, true);
1672		- if (ret < 0)
1673		- return ret;
1674		- }
1675		-
1676		- p = call->reply[2];
1677		- p[call->count] = 0;
1678		- _debug("offline '%s'", p);
1679		-
1680		- call->offset = 0;
1681		- call->unmarshall++;
1682		-
1683		- /* extract the offline message padding */
1684		- if ((call->count & 3) == 0) {
1685		- call->unmarshall++;
1686		- goto no_offline_padding;
1687		- }
1688		- call->count = 4 - (call->count & 3);
1689		-
1690		- case 7:
1691		- ret = afs_extract_data(call, call->buffer,
1692		- call->count, true);
	1408	+ ret = afs_extract_data(call, true);
1693	1409	if (ret < 0)
1694	1410	return ret;
1695	1411
1696		- call->offset = 0;
	1412	+ p = call->buffer;
	1413	+ p[call->count] = 0;
	1414	+ _debug("offline '%s'", p);
	1415	+
	1416	+ afs_extract_to_tmp(call);
1697	1417	call->unmarshall++;
1698		- no_offline_padding:
	1418	+ fallthrough;
1699	1419
1700	1420	/* extract the message of the day length */
1701		- case 8:
1702		- ret = afs_extract_data(call, &call->tmp, 4, true);
	1421	+ case 6:
	1422	+ ret = afs_extract_data(call, true);
1703	1423	if (ret < 0)
1704	1424	return ret;
1705	1425
1706	1426	call->count = ntohl(call->tmp);
1707	1427	_debug("motd length: %u", call->count);
1708	1428	if (call->count >= AFSNAMEMAX)
1709		- return afs_protocol_error(call, -EBADMSG);
1710		- call->offset = 0;
	1429	+ return afs_protocol_error(call, afs_eproto_motd_len);
	1430	+ size = (call->count + 3) & ~3; /* It's padded */
	1431	+ afs_extract_to_buf(call, size);
1711	1432	call->unmarshall++;
	1433	+ fallthrough;
1712	1434
1713	1435	/* extract the message of the day */
1714		- case 9:
	1436	+ case 7:
1715	1437	_debug("extract motd");
1716		- if (call->count > 0) {
1717		- ret = afs_extract_data(call, call->reply[2],
1718		- call->count, true);
1719		- if (ret < 0)
1720		- return ret;
1721		- }
1722		-
1723		- p = call->reply[2];
1724		- p[call->count] = 0;
1725		- _debug("motd '%s'", p);
1726		-
1727		- call->offset = 0;
1728		- call->unmarshall++;
1729		-
1730		- /* extract the message of the day padding */
1731		- call->count = (4 - (call->count & 3)) & 3;
1732		-
1733		- case 10:
1734		- ret = afs_extract_data(call, call->buffer,
1735		- call->count, false);
	1438	+ ret = afs_extract_data(call, false);
1736	1439	if (ret < 0)
1737	1440	return ret;
1738	1441
1739		- call->offset = 0;
	1442	+ p = call->buffer;
	1443	+ p[call->count] = 0;
	1444	+ _debug("motd '%s'", p);
	1445	+
1740	1446	call->unmarshall++;
1741		- case 11:
	1447	+
	1448	+ case 8:
1742	1449	break;
1743	1450	}
1744	1451
1745	1452	_leave(" = 0 [done]");
1746	1453	return 0;
1747		-}
1748		-
1749		-/*
1750		- * destroy an FS.GetVolumeStatus call
1751		- */
1752		-static void afs_get_volume_status_call_destructor(struct afs_call *call)
1753		-{
1754		- kfree(call->reply[2]);
1755		- call->reply[2] = NULL;
1756		- afs_flat_call_destructor(call);
1757	1454	}
1758	1455
1759	1456	/*
..	..	@@ -1763,46 +1460,32 @@
1763	1460	.name = "FS.GetVolumeStatus",
1764	1461	.op = afs_FS_GetVolumeStatus,
1765	1462	.deliver = afs_deliver_fs_get_volume_status,
1766		- .destructor = afs_get_volume_status_call_destructor,
	1463	+ .destructor = afs_flat_call_destructor,
1767	1464	};
1768	1465
1769	1466	/*
1770	1467	* fetch the status of a volume
1771	1468	*/
1772		-int afs_fs_get_volume_status(struct afs_fs_cursor *fc,
1773		- struct afs_volume_status *vs)
	1469	+void afs_fs_get_volume_status(struct afs_operation *op)
1774	1470	{
1775		- struct afs_vnode *vnode = fc->vnode;
	1471	+ struct afs_vnode_param *vp = &op->file[0];
1776	1472	struct afs_call *call;
1777		- struct afs_net *net = afs_v2net(vnode);
1778	1473	__be32 *bp;
1779		- void *tmpbuf;
1780	1474
1781	1475	_enter("");
1782	1476
1783		- tmpbuf = kmalloc(AFSOPAQUEMAX, GFP_KERNEL);
1784		- if (!tmpbuf)
1785		- return -ENOMEM;
1786		-
1787		- call = afs_alloc_flat_call(net, &afs_RXFSGetVolumeStatus, 2 * 4, 12 * 4);
1788		- if (!call) {
1789		- kfree(tmpbuf);
1790		- return -ENOMEM;
1791		- }
1792		-
1793		- call->key = fc->key;
1794		- call->reply[0] = vnode;
1795		- call->reply[1] = vs;
1796		- call->reply[2] = tmpbuf;
	1477	+ call = afs_alloc_flat_call(op->net, &afs_RXFSGetVolumeStatus, 2 * 4,
	1478	+ max(12 * 4, AFSOPAQUEMAX + 1));
	1479	+ if (!call)
	1480	+ return afs_op_nomem(op);
1797	1481
1798	1482	/* marshall the parameters */
1799	1483	bp = call->request;
1800	1484	bp[0] = htonl(FSGETVOLUMESTATUS);
1801		- bp[1] = htonl(vnode->fid.vid);
	1485	+ bp[1] = htonl(vp->fid.vid);
1802	1486
1803		- afs_use_fs_server(call, fc->cbi);
1804		- trace_afs_make_fs_call(call, &vnode->fid);
1805		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1487	+ trace_afs_make_fs_call(call, &vp->fid);
	1488	+ afs_make_op_call(op, call, GFP_NOFS);
1806	1489	}
1807	1490
1808	1491	/*
..	..	@@ -1810,6 +1493,7 @@
1810	1493	*/
1811	1494	static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1812	1495	{
	1496	+ struct afs_operation *op = call->op;
1813	1497	const __be32 *bp;
1814	1498	int ret;
1815	1499
..	..	@@ -1821,7 +1505,7 @@
1821	1505
1822	1506	/* unmarshall the reply once we've received all of it */
1823	1507	bp = call->buffer;
1824		- /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
	1508	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
1825	1509
1826	1510	_leave(" = 0 [done]");
1827	1511	return 0;
..	..	@@ -1834,6 +1518,7 @@
1834	1518	.name = "FS.SetLock",
1835	1519	.op = afs_FS_SetLock,
1836	1520	.deliver = afs_deliver_fs_xxxx_lock,
	1521	+ .done = afs_lock_op_done,
1837	1522	.destructor = afs_flat_call_destructor,
1838	1523	};
1839	1524
..	..	@@ -1844,6 +1529,7 @@
1844	1529	.name = "FS.ExtendLock",
1845	1530	.op = afs_FS_ExtendLock,
1846	1531	.deliver = afs_deliver_fs_xxxx_lock,
	1532	+ .done = afs_lock_op_done,
1847	1533	.destructor = afs_flat_call_destructor,
1848	1534	};
1849	1535
..	..	@@ -1860,95 +1546,80 @@
1860	1546	/*
1861	1547	* Set a lock on a file
1862	1548	*/
1863		-int afs_fs_set_lock(struct afs_fs_cursor *fc, afs_lock_type_t type)
	1549	+void afs_fs_set_lock(struct afs_operation *op)
1864	1550	{
1865		- struct afs_vnode *vnode = fc->vnode;
	1551	+ struct afs_vnode_param *vp = &op->file[0];
1866	1552	struct afs_call *call;
1867		- struct afs_net *net = afs_v2net(vnode);
1868	1553	__be32 *bp;
1869	1554
1870	1555	_enter("");
1871	1556
1872		- call = afs_alloc_flat_call(net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
	1557	+ call = afs_alloc_flat_call(op->net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1873	1558	if (!call)
1874		- return -ENOMEM;
1875		-
1876		- call->key = fc->key;
1877		- call->reply[0] = vnode;
	1559	+ return afs_op_nomem(op);
1878	1560
1879	1561	/* marshall the parameters */
1880	1562	bp = call->request;
1881	1563	*bp++ = htonl(FSSETLOCK);
1882		- *bp++ = htonl(vnode->fid.vid);
1883		- *bp++ = htonl(vnode->fid.vnode);
1884		- *bp++ = htonl(vnode->fid.unique);
1885		- *bp++ = htonl(type);
	1564	+ *bp++ = htonl(vp->fid.vid);
	1565	+ *bp++ = htonl(vp->fid.vnode);
	1566	+ *bp++ = htonl(vp->fid.unique);
	1567	+ *bp++ = htonl(op->lock.type);
1886	1568
1887		- afs_use_fs_server(call, fc->cbi);
1888		- trace_afs_make_fs_call(call, &vnode->fid);
1889		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1569	+ trace_afs_make_fs_calli(call, &vp->fid, op->lock.type);
	1570	+ afs_make_op_call(op, call, GFP_NOFS);
1890	1571	}
1891	1572
1892	1573	/*
1893	1574	* extend a lock on a file
1894	1575	*/
1895		-int afs_fs_extend_lock(struct afs_fs_cursor *fc)
	1576	+void afs_fs_extend_lock(struct afs_operation *op)
1896	1577	{
1897		- struct afs_vnode *vnode = fc->vnode;
	1578	+ struct afs_vnode_param *vp = &op->file[0];
1898	1579	struct afs_call *call;
1899		- struct afs_net *net = afs_v2net(vnode);
1900	1580	__be32 *bp;
1901	1581
1902	1582	_enter("");
1903	1583
1904		- call = afs_alloc_flat_call(net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
	1584	+ call = afs_alloc_flat_call(op->net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1905	1585	if (!call)
1906		- return -ENOMEM;
1907		-
1908		- call->key = fc->key;
1909		- call->reply[0] = vnode;
	1586	+ return afs_op_nomem(op);
1910	1587
1911	1588	/* marshall the parameters */
1912	1589	bp = call->request;
1913	1590	*bp++ = htonl(FSEXTENDLOCK);
1914		- *bp++ = htonl(vnode->fid.vid);
1915		- *bp++ = htonl(vnode->fid.vnode);
1916		- *bp++ = htonl(vnode->fid.unique);
	1591	+ *bp++ = htonl(vp->fid.vid);
	1592	+ *bp++ = htonl(vp->fid.vnode);
	1593	+ *bp++ = htonl(vp->fid.unique);
1917	1594
1918		- afs_use_fs_server(call, fc->cbi);
1919		- trace_afs_make_fs_call(call, &vnode->fid);
1920		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1595	+ trace_afs_make_fs_call(call, &vp->fid);
	1596	+ afs_make_op_call(op, call, GFP_NOFS);
1921	1597	}
1922	1598
1923	1599	/*
1924	1600	* release a lock on a file
1925	1601	*/
1926		-int afs_fs_release_lock(struct afs_fs_cursor *fc)
	1602	+void afs_fs_release_lock(struct afs_operation *op)
1927	1603	{
1928		- struct afs_vnode *vnode = fc->vnode;
	1604	+ struct afs_vnode_param *vp = &op->file[0];
1929	1605	struct afs_call *call;
1930		- struct afs_net *net = afs_v2net(vnode);
1931	1606	__be32 *bp;
1932	1607
1933	1608	_enter("");
1934	1609
1935		- call = afs_alloc_flat_call(net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
	1610	+ call = afs_alloc_flat_call(op->net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1936	1611	if (!call)
1937		- return -ENOMEM;
1938		-
1939		- call->key = fc->key;
1940		- call->reply[0] = vnode;
	1612	+ return afs_op_nomem(op);
1941	1613
1942	1614	/* marshall the parameters */
1943	1615	bp = call->request;
1944	1616	*bp++ = htonl(FSRELEASELOCK);
1945		- *bp++ = htonl(vnode->fid.vid);
1946		- *bp++ = htonl(vnode->fid.vnode);
1947		- *bp++ = htonl(vnode->fid.unique);
	1617	+ *bp++ = htonl(vp->fid.vid);
	1618	+ *bp++ = htonl(vp->fid.vnode);
	1619	+ *bp++ = htonl(vp->fid.unique);
1948	1620
1949		- afs_use_fs_server(call, fc->cbi);
1950		- trace_afs_make_fs_call(call, &vnode->fid);
1951		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1621	+ trace_afs_make_fs_call(call, &vp->fid);
	1622	+ afs_make_op_call(op, call, GFP_NOFS);
1952	1623	}
1953	1624
1954	1625	/*
..	..	@@ -1992,8 +1663,9 @@
1992	1663	bp = call->request;
1993	1664	*bp++ = htonl(FSGIVEUPALLCALLBACKS);
1994	1665
1995		- /* Can't take a ref on server */
1996		- return afs_make_call(ac, call, GFP_NOFS, false);
	1666	+ call->server = afs_use_server(server, afs_server_trace_give_up_cb);
	1667	+ afs_make_call(ac, call, GFP_NOFS);
	1668	+ return afs_wait_for_call_to_complete(call, ac);
1997	1669	}
1998	1670
1999	1671	/*
..	..	@@ -2004,19 +1676,17 @@
2004	1676	u32 count;
2005	1677	int ret;
2006	1678
2007		- _enter("{%u,%zu/%u}", call->unmarshall, call->offset, call->count);
	1679	+ _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));
2008	1680
2009		-again:
2010	1681	switch (call->unmarshall) {
2011	1682	case 0:
2012		- call->offset = 0;
	1683	+ afs_extract_to_tmp(call);
2013	1684	call->unmarshall++;
	1685	+ fallthrough;
2014	1686
2015	1687	/* Extract the capabilities word count */
2016	1688	case 1:
2017		- ret = afs_extract_data(call, &call->tmp,
2018		- 1 * sizeof(__be32),
2019		- true);
	1689	+ ret = afs_extract_data(call, true);
2020	1690	if (ret < 0)
2021	1691	return ret;
2022	1692
..	..	@@ -2024,24 +1694,18 @@
2024	1694
2025	1695	call->count = count;
2026	1696	call->count2 = count;
2027		- call->offset = 0;
	1697	+ afs_extract_discard(call, count * sizeof(__be32));
2028	1698	call->unmarshall++;
	1699	+ fallthrough;
2029	1700
2030	1701	/* Extract capabilities words */
2031	1702	case 2:
2032		- count = min(call->count, 16U);
2033		- ret = afs_extract_data(call, call->buffer,
2034		- count * sizeof(__be32),
2035		- call->count > 16);
	1703	+ ret = afs_extract_data(call, false);
2036	1704	if (ret < 0)
2037	1705	return ret;
2038	1706
2039	1707	/* TODO: Examine capabilities */
2040	1708
2041		- call->count -= count;
2042		- if (call->count > 0)
2043		- goto again;
2044		- call->offset = 0;
2045	1709	call->unmarshall++;
2046	1710	break;
2047	1711	}
..	..	@@ -2057,17 +1721,18 @@
2057	1721	.name = "FS.GetCapabilities",
2058	1722	.op = afs_FS_GetCapabilities,
2059	1723	.deliver = afs_deliver_fs_get_capabilities,
	1724	+ .done = afs_fileserver_probe_result,
2060	1725	.destructor = afs_flat_call_destructor,
2061	1726	};
2062	1727
2063	1728	/*
2064		- * Probe a fileserver for the capabilities that it supports. This can
2065		- * return up to 196 words.
	1729	+ * Probe a fileserver for the capabilities that it supports. This RPC can
	1730	+ * reply with up to 196 words. The operation is asynchronous and if we managed
	1731	+ * to allocate a call, true is returned the result is delivered through the
	1732	+ * ->done() - otherwise we return false to indicate we didn't even try.
2066	1733	*/
2067		-int afs_fs_get_capabilities(struct afs_net *net,
2068		- struct afs_server *server,
2069		- struct afs_addr_cursor *ac,
2070		- struct key *key)
	1734	+bool afs_fs_get_capabilities(struct afs_net net, struct afs_server server,
	1735	+ struct afs_addr_cursor ac, struct key key)
2071	1736	{
2072	1737	struct afs_call *call;
2073	1738	__be32 *bp;
..	..	@@ -2076,105 +1741,22 @@
2076	1741
2077	1742	call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
2078	1743	if (!call)
2079		- return -ENOMEM;
	1744	+ return false;
2080	1745
2081	1746	call->key = key;
	1747	+ call->server = afs_use_server(server, afs_server_trace_get_caps);
	1748	+ call->upgrade = true;
	1749	+ call->async = true;
	1750	+ call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
2082	1751
2083	1752	/* marshall the parameters */
2084	1753	bp = call->request;
2085	1754	*bp++ = htonl(FSGETCAPABILITIES);
2086	1755
2087		- /* Can't take a ref on server */
2088	1756	trace_afs_make_fs_call(call, NULL);
2089		- return afs_make_call(ac, call, GFP_NOFS, false);
2090		-}
2091		-
2092		-/*
2093		- * Deliver reply data to an FS.FetchStatus with no vnode.
2094		- */
2095		-static int afs_deliver_fs_fetch_status(struct afs_call *call)
2096		-{
2097		- struct afs_file_status *status = call->reply[1];
2098		- struct afs_callback *callback = call->reply[2];
2099		- struct afs_volsync *volsync = call->reply[3];
2100		- struct afs_vnode *vnode = call->reply[0];
2101		- const __be32 *bp;
2102		- int ret;
2103		-
2104		- ret = afs_transfer_reply(call);
2105		- if (ret < 0)
2106		- return ret;
2107		-
2108		- _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
2109		-
2110		- /* unmarshall the reply once we've received all of it */
2111		- bp = call->buffer;
2112		- afs_decode_status(call, &bp, status, vnode,
2113		- &call->expected_version, NULL);
2114		- callback[call->count].version = ntohl(bp[0]);
2115		- callback[call->count].expiry = ntohl(bp[1]);
2116		- callback[call->count].type = ntohl(bp[2]);
2117		- if (vnode)
2118		- xdr_decode_AFSCallBack(call, vnode, &bp);
2119		- else
2120		- bp += 3;
2121		- if (volsync)
2122		- xdr_decode_AFSVolSync(&bp, volsync);
2123		-
2124		- _leave(" = 0 [done]");
2125		- return 0;
2126		-}
2127		-
2128		-/*
2129		- * FS.FetchStatus operation type
2130		- */
2131		-static const struct afs_call_type afs_RXFSFetchStatus = {
2132		- .name = "FS.FetchStatus",
2133		- .op = afs_FS_FetchStatus,
2134		- .deliver = afs_deliver_fs_fetch_status,
2135		- .destructor = afs_flat_call_destructor,
2136		-};
2137		-
2138		-/*
2139		- * Fetch the status information for a fid without needing a vnode handle.
2140		- */
2141		-int afs_fs_fetch_status(struct afs_fs_cursor *fc,
2142		- struct afs_net *net,
2143		- struct afs_fid *fid,
2144		- struct afs_file_status *status,
2145		- struct afs_callback *callback,
2146		- struct afs_volsync *volsync)
2147		-{
2148		- struct afs_call *call;
2149		- __be32 *bp;
2150		-
2151		- _enter(",%x,{%x:%u},,",
2152		- key_serial(fc->key), fid->vid, fid->vnode);
2153		-
2154		- call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4);
2155		- if (!call) {
2156		- fc->ac.error = -ENOMEM;
2157		- return -ENOMEM;
2158		- }
2159		-
2160		- call->key = fc->key;
2161		- call->reply[0] = NULL; /* vnode for fid[0] */
2162		- call->reply[1] = status;
2163		- call->reply[2] = callback;
2164		- call->reply[3] = volsync;
2165		- call->expected_version = 1; /* vnode->status.data_version */
2166		-
2167		- /* marshall the parameters */
2168		- bp = call->request;
2169		- bp[0] = htonl(FSFETCHSTATUS);
2170		- bp[1] = htonl(fid->vid);
2171		- bp[2] = htonl(fid->vnode);
2172		- bp[3] = htonl(fid->unique);
2173		-
2174		- call->cb_break = fc->cb_break;
2175		- afs_use_fs_server(call, fc->cbi);
2176		- trace_afs_make_fs_call(call, fid);
2177		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1757	+ afs_make_call(ac, call, GFP_NOFS);
	1758	+ afs_put_call(call);
	1759	+ return true;
2178	1760	}
2179	1761
2180	1762	/*
..	..	@@ -2182,9 +1764,8 @@
2182	1764	*/
2183	1765	static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
2184	1766	{
2185		- struct afs_file_status *statuses;
2186		- struct afs_callback *callbacks;
2187		- struct afs_vnode *vnode = call->reply[0];
	1767	+ struct afs_operation *op = call->op;
	1768	+ struct afs_status_cb *scb;
2188	1769	const __be32 *bp;
2189	1770	u32 tmp;
2190	1771	int ret;
..	..	@@ -2193,95 +1774,112 @@
2193	1774
2194	1775	switch (call->unmarshall) {
2195	1776	case 0:
2196		- call->offset = 0;
	1777	+ afs_extract_to_tmp(call);
2197	1778	call->unmarshall++;
	1779	+ fallthrough;
2198	1780
2199	1781	/* Extract the file status count and array in two steps */
2200	1782	case 1:
2201	1783	_debug("extract status count");
2202		- ret = afs_extract_data(call, &call->tmp, 4, true);
	1784	+ ret = afs_extract_data(call, true);
2203	1785	if (ret < 0)
2204	1786	return ret;
2205	1787
2206	1788	tmp = ntohl(call->tmp);
2207		- _debug("status count: %u/%u", tmp, call->count2);
2208		- if (tmp != call->count2)
2209		- return afs_protocol_error(call, -EBADMSG);
	1789	+ _debug("status count: %u/%u", tmp, op->nr_files);
	1790	+ if (tmp != op->nr_files)
	1791	+ return afs_protocol_error(call, afs_eproto_ibulkst_count);
2210	1792
2211	1793	call->count = 0;
2212	1794	call->unmarshall++;
2213	1795	more_counts:
2214		- call->offset = 0;
	1796	+ afs_extract_to_buf(call, 21 * sizeof(__be32));
	1797	+ fallthrough;
2215	1798
2216	1799	case 2:
2217	1800	_debug("extract status array %u", call->count);
2218		- ret = afs_extract_data(call, call->buffer, 21 * 4, true);
	1801	+ ret = afs_extract_data(call, true);
2219	1802	if (ret < 0)
2220	1803	return ret;
2221	1804
	1805	+ switch (call->count) {
	1806	+ case 0:
	1807	+ scb = &op->file[0].scb;
	1808	+ break;
	1809	+ case 1:
	1810	+ scb = &op->file[1].scb;
	1811	+ break;
	1812	+ default:
	1813	+ scb = &op->more_files[call->count - 2].scb;
	1814	+ break;
	1815	+ }
	1816	+
2222	1817	bp = call->buffer;
2223		- statuses = call->reply[1];
2224		- if (afs_decode_status(call, &bp, &statuses[call->count],
2225		- call->count == 0 ? vnode : NULL,
2226		- NULL, NULL) < 0)
2227		- return afs_protocol_error(call, -EBADMSG);
	1818	+ xdr_decode_AFSFetchStatus(&bp, call, scb);
2228	1819
2229	1820	call->count++;
2230		- if (call->count < call->count2)
	1821	+ if (call->count < op->nr_files)
2231	1822	goto more_counts;
2232	1823
2233	1824	call->count = 0;
2234	1825	call->unmarshall++;
2235		- call->offset = 0;
	1826	+ afs_extract_to_tmp(call);
	1827	+ fallthrough;
2236	1828
2237	1829	/* Extract the callback count and array in two steps */
2238	1830	case 3:
2239	1831	_debug("extract CB count");
2240		- ret = afs_extract_data(call, &call->tmp, 4, true);
	1832	+ ret = afs_extract_data(call, true);
2241	1833	if (ret < 0)
2242	1834	return ret;
2243	1835
2244	1836	tmp = ntohl(call->tmp);
2245	1837	_debug("CB count: %u", tmp);
2246		- if (tmp != call->count2)
2247		- return afs_protocol_error(call, -EBADMSG);
	1838	+ if (tmp != op->nr_files)
	1839	+ return afs_protocol_error(call, afs_eproto_ibulkst_cb_count);
2248	1840	call->count = 0;
2249	1841	call->unmarshall++;
2250	1842	more_cbs:
2251		- call->offset = 0;
	1843	+ afs_extract_to_buf(call, 3 * sizeof(__be32));
	1844	+ fallthrough;
2252	1845
2253	1846	case 4:
2254	1847	_debug("extract CB array");
2255		- ret = afs_extract_data(call, call->buffer, 3 * 4, true);
	1848	+ ret = afs_extract_data(call, true);
2256	1849	if (ret < 0)
2257	1850	return ret;
2258	1851
2259	1852	_debug("unmarshall CB array");
	1853	+ switch (call->count) {
	1854	+ case 0:
	1855	+ scb = &op->file[0].scb;
	1856	+ break;
	1857	+ case 1:
	1858	+ scb = &op->file[1].scb;
	1859	+ break;
	1860	+ default:
	1861	+ scb = &op->more_files[call->count - 2].scb;
	1862	+ break;
	1863	+ }
	1864	+
2260	1865	bp = call->buffer;
2261		- callbacks = call->reply[2];
2262		- callbacks[call->count].version = ntohl(bp[0]);
2263		- callbacks[call->count].expiry = ntohl(bp[1]);
2264		- callbacks[call->count].type = ntohl(bp[2]);
2265		- statuses = call->reply[1];
2266		- if (call->count == 0 && vnode && statuses[0].abort_code == 0)
2267		- xdr_decode_AFSCallBack(call, vnode, &bp);
	1866	+ xdr_decode_AFSCallBack(&bp, call, scb);
2268	1867	call->count++;
2269		- if (call->count < call->count2)
	1868	+ if (call->count < op->nr_files)
2270	1869	goto more_cbs;
2271	1870
2272		- call->offset = 0;
	1871	+ afs_extract_to_buf(call, 6 * sizeof(__be32));
2273	1872	call->unmarshall++;
	1873	+ fallthrough;
2274	1874
2275	1875	case 5:
2276		- ret = afs_extract_data(call, call->buffer, 6 * 4, false);
	1876	+ ret = afs_extract_data(call, false);
2277	1877	if (ret < 0)
2278	1878	return ret;
2279	1879
2280	1880	bp = call->buffer;
2281		- if (call->reply[3])
2282		- xdr_decode_AFSVolSync(&bp, call->reply[3]);
	1881	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
2283	1882
2284		- call->offset = 0;
2285	1883	call->unmarshall++;
2286	1884
2287	1885	case 6:
..	..	@@ -2292,6 +1890,16 @@
2292	1890	return 0;
2293	1891	}
2294	1892
	1893	+static void afs_done_fs_inline_bulk_status(struct afs_call *call)
	1894	+{
	1895	+ if (call->error == -ECONNABORTED &&
	1896	+ call->abort_code == RX_INVALID_OPERATION) {
	1897	+ set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags);
	1898	+ if (call->op)
	1899	+ set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags);
	1900	+ }
	1901	+}
	1902	+
2295	1903	/*
2296	1904	* FS.InlineBulkStatus operation type
2297	1905	*/
..	..	@@ -2299,54 +1907,200 @@
2299	1907	.name = "FS.InlineBulkStatus",
2300	1908	.op = afs_FS_InlineBulkStatus,
2301	1909	.deliver = afs_deliver_fs_inline_bulk_status,
	1910	+ .done = afs_done_fs_inline_bulk_status,
2302	1911	.destructor = afs_flat_call_destructor,
2303	1912	};
2304	1913
2305	1914	/*
2306	1915	* Fetch the status information for up to 50 files
2307	1916	*/
2308		-int afs_fs_inline_bulk_status(struct afs_fs_cursor *fc,
2309		- struct afs_net *net,
2310		- struct afs_fid *fids,
2311		- struct afs_file_status *statuses,
2312		- struct afs_callback *callbacks,
2313		- unsigned int nr_fids,
2314		- struct afs_volsync *volsync)
	1917	+void afs_fs_inline_bulk_status(struct afs_operation *op)
2315	1918	{
	1919	+ struct afs_vnode_param *dvp = &op->file[0];
	1920	+ struct afs_vnode_param *vp = &op->file[1];
2316	1921	struct afs_call *call;
2317	1922	__be32 *bp;
2318	1923	int i;
2319	1924
2320		- _enter(",%x,{%x:%u},%u",
2321		- key_serial(fc->key), fids[0].vid, fids[1].vnode, nr_fids);
2322		-
2323		- call = afs_alloc_flat_call(net, &afs_RXFSInlineBulkStatus,
2324		- (2 + nr_fids * 3) * 4,
2325		- 21 * 4);
2326		- if (!call) {
2327		- fc->ac.error = -ENOMEM;
2328		- return -ENOMEM;
	1925	+ if (test_bit(AFS_SERVER_FL_NO_IBULK, &op->server->flags)) {
	1926	+ op->error = -ENOTSUPP;
	1927	+ return;
2329	1928	}
2330	1929
2331		- call->key = fc->key;
2332		- call->reply[0] = NULL; /* vnode for fid[0] */
2333		- call->reply[1] = statuses;
2334		- call->reply[2] = callbacks;
2335		- call->reply[3] = volsync;
2336		- call->count2 = nr_fids;
	1930	+ _enter(",%x,{%llx:%llu},%u",
	1931	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode, op->nr_files);
	1932	+
	1933	+ call = afs_alloc_flat_call(op->net, &afs_RXFSInlineBulkStatus,
	1934	+ (2 + op->nr_files * 3) * 4,
	1935	+ 21 * 4);
	1936	+ if (!call)
	1937	+ return afs_op_nomem(op);
2337	1938
2338	1939	/* marshall the parameters */
2339	1940	bp = call->request;
2340	1941	*bp++ = htonl(FSINLINEBULKSTATUS);
2341		- *bp++ = htonl(nr_fids);
2342		- for (i = 0; i < nr_fids; i++) {
2343		- *bp++ = htonl(fids[i].vid);
2344		- *bp++ = htonl(fids[i].vnode);
2345		- *bp++ = htonl(fids[i].unique);
	1942	+ *bp++ = htonl(op->nr_files);
	1943	+ *bp++ = htonl(dvp->fid.vid);
	1944	+ *bp++ = htonl(dvp->fid.vnode);
	1945	+ *bp++ = htonl(dvp->fid.unique);
	1946	+ *bp++ = htonl(vp->fid.vid);
	1947	+ *bp++ = htonl(vp->fid.vnode);
	1948	+ *bp++ = htonl(vp->fid.unique);
	1949	+ for (i = 0; i < op->nr_files - 2; i++) {
	1950	+ *bp++ = htonl(op->more_files[i].fid.vid);
	1951	+ *bp++ = htonl(op->more_files[i].fid.vnode);
	1952	+ *bp++ = htonl(op->more_files[i].fid.unique);
2346	1953	}
2347	1954
2348		- call->cb_break = fc->cb_break;
2349		- afs_use_fs_server(call, fc->cbi);
2350		- trace_afs_make_fs_call(call, &fids[0]);
2351		- return afs_make_call(&fc->ac, call, GFP_NOFS, false);
	1955	+ trace_afs_make_fs_call(call, &vp->fid);
	1956	+ afs_make_op_call(op, call, GFP_NOFS);
	1957	+}
	1958	+
	1959	+/*
	1960	+ * deliver reply data to an FS.FetchACL
	1961	+ */
	1962	+static int afs_deliver_fs_fetch_acl(struct afs_call *call)
	1963	+{
	1964	+ struct afs_operation *op = call->op;
	1965	+ struct afs_vnode_param *vp = &op->file[0];
	1966	+ struct afs_acl *acl;
	1967	+ const __be32 *bp;
	1968	+ unsigned int size;
	1969	+ int ret;
	1970	+
	1971	+ _enter("{%u}", call->unmarshall);
	1972	+
	1973	+ switch (call->unmarshall) {
	1974	+ case 0:
	1975	+ afs_extract_to_tmp(call);
	1976	+ call->unmarshall++;
	1977	+ fallthrough;
	1978	+
	1979	+ /* extract the returned data length */
	1980	+ case 1:
	1981	+ ret = afs_extract_data(call, true);
	1982	+ if (ret < 0)
	1983	+ return ret;
	1984	+
	1985	+ size = call->count2 = ntohl(call->tmp);
	1986	+ size = round_up(size, 4);
	1987	+
	1988	+ acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
	1989	+ if (!acl)
	1990	+ return -ENOMEM;
	1991	+ op->acl = acl;
	1992	+ acl->size = call->count2;
	1993	+ afs_extract_begin(call, acl->data, size);
	1994	+ call->unmarshall++;
	1995	+ fallthrough;
	1996	+
	1997	+ /* extract the returned data */
	1998	+ case 2:
	1999	+ ret = afs_extract_data(call, true);
	2000	+ if (ret < 0)
	2001	+ return ret;
	2002	+
	2003	+ afs_extract_to_buf(call, (21 + 6) * 4);
	2004	+ call->unmarshall++;
	2005	+ fallthrough;
	2006	+
	2007	+ /* extract the metadata */
	2008	+ case 3:
	2009	+ ret = afs_extract_data(call, false);
	2010	+ if (ret < 0)
	2011	+ return ret;
	2012	+
	2013	+ bp = call->buffer;
	2014	+ xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
	2015	+ xdr_decode_AFSVolSync(&bp, &op->volsync);
	2016	+
	2017	+ call->unmarshall++;
	2018	+
	2019	+ case 4:
	2020	+ break;
	2021	+ }
	2022	+
	2023	+ _leave(" = 0 [done]");
	2024	+ return 0;
	2025	+}
	2026	+
	2027	+/*
	2028	+ * FS.FetchACL operation type
	2029	+ */
	2030	+static const struct afs_call_type afs_RXFSFetchACL = {
	2031	+ .name = "FS.FetchACL",
	2032	+ .op = afs_FS_FetchACL,
	2033	+ .deliver = afs_deliver_fs_fetch_acl,
	2034	+};
	2035	+
	2036	+/*
	2037	+ * Fetch the ACL for a file.
	2038	+ */
	2039	+void afs_fs_fetch_acl(struct afs_operation *op)
	2040	+{
	2041	+ struct afs_vnode_param *vp = &op->file[0];
	2042	+ struct afs_call *call;
	2043	+ __be32 *bp;
	2044	+
	2045	+ _enter(",%x,{%llx:%llu},,",
	2046	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
	2047	+
	2048	+ call = afs_alloc_flat_call(op->net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
	2049	+ if (!call)
	2050	+ return afs_op_nomem(op);
	2051	+
	2052	+ /* marshall the parameters */
	2053	+ bp = call->request;
	2054	+ bp[0] = htonl(FSFETCHACL);
	2055	+ bp[1] = htonl(vp->fid.vid);
	2056	+ bp[2] = htonl(vp->fid.vnode);
	2057	+ bp[3] = htonl(vp->fid.unique);
	2058	+
	2059	+ trace_afs_make_fs_call(call, &vp->fid);
	2060	+ afs_make_op_call(op, call, GFP_KERNEL);
	2061	+}
	2062	+
	2063	+/*
	2064	+ * FS.StoreACL operation type
	2065	+ */
	2066	+static const struct afs_call_type afs_RXFSStoreACL = {
	2067	+ .name = "FS.StoreACL",
	2068	+ .op = afs_FS_StoreACL,
	2069	+ .deliver = afs_deliver_fs_file_status_and_vol,
	2070	+ .destructor = afs_flat_call_destructor,
	2071	+};
	2072	+
	2073	+/*
	2074	+ * Fetch the ACL for a file.
	2075	+ */
	2076	+void afs_fs_store_acl(struct afs_operation *op)
	2077	+{
	2078	+ struct afs_vnode_param *vp = &op->file[0];
	2079	+ struct afs_call *call;
	2080	+ const struct afs_acl *acl = op->acl;
	2081	+ size_t size;
	2082	+ __be32 *bp;
	2083	+
	2084	+ _enter(",%x,{%llx:%llu},,",
	2085	+ key_serial(op->key), vp->fid.vid, vp->fid.vnode);
	2086	+
	2087	+ size = round_up(acl->size, 4);
	2088	+ call = afs_alloc_flat_call(op->net, &afs_RXFSStoreACL,
	2089	+ 5 * 4 + size, (21 + 6) * 4);
	2090	+ if (!call)
	2091	+ return afs_op_nomem(op);
	2092	+
	2093	+ /* marshall the parameters */
	2094	+ bp = call->request;
	2095	+ bp[0] = htonl(FSSTOREACL);
	2096	+ bp[1] = htonl(vp->fid.vid);
	2097	+ bp[2] = htonl(vp->fid.vnode);
	2098	+ bp[3] = htonl(vp->fid.unique);
	2099	+ bp[4] = htonl(acl->size);
	2100	+ memcpy(&bp[5], acl->data, acl->size);
	2101	+ if (acl->size != size)
	2102	+ memset((void *)&bp[5] + acl->size, 0, size - acl->size);
	2103	+
	2104	+ trace_afs_make_fs_call(call, &vp->fid);
	2105	+ afs_make_op_call(op, call, GFP_KERNEL);
2352	2106	}