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 */
  21static 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 */
  34static 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 */
  54static 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;
 122advance:
 123	*_bp = (const void *)*_bp + sizeof(*xdr);
 124	return;
 125
 126bad:
 127	xdr_dump_bad(*_bp);
 128	afs_protocol_error(call, afs_eproto_bad_status);
 129	goto advance;
 130}
 131
 132static 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
 137static 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 */
 154static 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 */
 175static 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 */
 213static 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 */
 238static 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 */
 262static 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 */
 272void 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 */
 300static 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 */
 404static 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
 411static 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 */
 421static 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 */
 452void 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 */
 486static 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 */
 513static 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 */
 523void 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
 566static 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 */
 576void 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 */
 622static 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 */
 645static 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 */
 655void 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
 692static 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 */
 702void 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 */
 742static 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 */
 769static 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 */
 779void 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 */
 822static 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 */
 850static 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 */
 860void 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 */
 917static 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 */
 944static 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 */
 954void 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 */
1013static 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 */
1038static 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
1045static 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 */
1055static 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 */
1100void 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 */
1150static 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
1157static 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
1164static 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 */
1175static 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 */
1217static 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 */
1258void 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 */
1293static 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 */
1421static 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 */
1431void 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 */
1456static 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 */
1479static 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 */
1490static 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 */
1501static 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 */
1511void 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 */
1538void 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 */
1564void 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 */
1590static 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 */
1598static 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 */
1608int 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 */
1636static 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 */
1695static 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 */
1709bool 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 */
1740static 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
1869static 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 */
1882static 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 */
1893void 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 */
1938static 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 */
2007static 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 */
2016void 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 */
2043static 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 */
2053void 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}