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