cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

fsclient.c (48956B)


      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->reply_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}