fs/afs/fsclient.c

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