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