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->issue_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                 fallthrough;
 392
 393         case 5:
 394                 break;
 395         }
 396
 397         _leave(" = 0 [done]");
 398         return 0;
 399 }
 400
 401 /*
 402  * FS.FetchData operation type
 403  */
 404 static const struct afs_call_type afs_RXFSFetchData = {
 405         .name           = "FS.FetchData",
 406         .op             = afs_FS_FetchData,
 407         .deliver        = afs_deliver_fs_fetch_data,
 408         .destructor     = afs_flat_call_destructor,
 409 };
 410
 411 static const struct afs_call_type afs_RXFSFetchData64 = {
 412         .name           = "FS.FetchData64",
 413         .op             = afs_FS_FetchData64,
 414         .deliver        = afs_deliver_fs_fetch_data,
 415         .destructor     = afs_flat_call_destructor,
 416 };
 417
 418 /*
 419  * fetch data from a very large file
 420  */
 421 static void afs_fs_fetch_data64(struct afs_operation *op)
 422 {
 423         struct afs_vnode_param *vp = &op->file[0];
 424         struct afs_read *req = op->fetch.req;
 425         struct afs_call *call;
 426         __be32 *bp;
 427
 428         _enter("");
 429
 430         call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
 431         if (!call)
 432                 return afs_op_nomem(op);
 433
 434         /* marshall the parameters */
 435         bp = call->request;
 436         bp[0] = htonl(FSFETCHDATA64);
 437         bp[1] = htonl(vp->fid.vid);
 438         bp[2] = htonl(vp->fid.vnode);
 439         bp[3] = htonl(vp->fid.unique);
 440         bp[4] = htonl(upper_32_bits(req->pos));
 441         bp[5] = htonl(lower_32_bits(req->pos));
 442         bp[6] = 0;
 443         bp[7] = htonl(lower_32_bits(req->len));
 444
 445         trace_afs_make_fs_call(call, &vp->fid);
 446         afs_make_op_call(op, call, GFP_NOFS);
 447 }
 448
 449 /*
 450  * fetch data from a file
 451  */
 452 void afs_fs_fetch_data(struct afs_operation *op)
 453 {
 454         struct afs_vnode_param *vp = &op->file[0];
 455         struct afs_call *call;
 456         struct afs_read *req = op->fetch.req;
 457         __be32 *bp;
 458
 459         if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
 460                 return afs_fs_fetch_data64(op);
 461
 462         _enter("");
 463
 464         call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
 465         if (!call)
 466                 return afs_op_nomem(op);
 467
 468         req->call_debug_id = call->debug_id;
 469
 470         /* marshall the parameters */
 471         bp = call->request;
 472         bp[0] = htonl(FSFETCHDATA);
 473         bp[1] = htonl(vp->fid.vid);
 474         bp[2] = htonl(vp->fid.vnode);
 475         bp[3] = htonl(vp->fid.unique);
 476         bp[4] = htonl(lower_32_bits(req->pos));
 477         bp[5] = htonl(lower_32_bits(req->len));
 478
 479         trace_afs_make_fs_call(call, &vp->fid);
 480         afs_make_op_call(op, call, GFP_NOFS);
 481 }
 482
 483 /*
 484  * deliver reply data to an FS.CreateFile or an FS.MakeDir
 485  */
 486 static int afs_deliver_fs_create_vnode(struct afs_call *call)
 487 {
 488         struct afs_operation *op = call->op;
 489         struct afs_vnode_param *dvp = &op->file[0];
 490         struct afs_vnode_param *vp = &op->file[1];
 491         const __be32 *bp;
 492         int ret;
 493
 494         ret = afs_transfer_reply(call);
 495         if (ret < 0)
 496                 return ret;
 497
 498         /* unmarshall the reply once we've received all of it */
 499         bp = call->buffer;
 500         xdr_decode_AFSFid(&bp, &op->file[1].fid);
 501         xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
 502         xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
 503         xdr_decode_AFSCallBack(&bp, call, &vp->scb);
 504         xdr_decode_AFSVolSync(&bp, &op->volsync);
 505
 506         _leave(" = 0 [done]");
 507         return 0;
 508 }
 509
 510 /*
 511  * FS.CreateFile and FS.MakeDir operation type
 512  */
 513 static const struct afs_call_type afs_RXFSCreateFile = {
 514         .name           = "FS.CreateFile",
 515         .op             = afs_FS_CreateFile,
 516         .deliver        = afs_deliver_fs_create_vnode,
 517         .destructor     = afs_flat_call_destructor,
 518 };
 519
 520 /*
 521  * Create a file.
 522  */
 523 void afs_fs_create_file(struct afs_operation *op)
 524 {
 525         const struct qstr *name = &op->dentry->d_name;
 526         struct afs_vnode_param *dvp = &op->file[0];
 527         struct afs_call *call;
 528         size_t namesz, reqsz, padsz;
 529         __be32 *bp;
 530
 531         _enter("");
 532
 533         namesz = name->len;
 534         padsz = (4 - (namesz & 3)) & 3;
 535         reqsz = (5 * 4) + namesz + padsz + (6 * 4);
 536
 537         call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile,
 538                                    reqsz, (3 + 21 + 21 + 3 + 6) * 4);
 539         if (!call)
 540                 return afs_op_nomem(op);
 541
 542         /* marshall the parameters */
 543         bp = call->request;
 544         *bp++ = htonl(FSCREATEFILE);
 545         *bp++ = htonl(dvp->fid.vid);
 546         *bp++ = htonl(dvp->fid.vnode);
 547         *bp++ = htonl(dvp->fid.unique);
 548         *bp++ = htonl(namesz);
 549         memcpy(bp, name->name, namesz);
 550         bp = (void *) bp + namesz;
 551         if (padsz > 0) {
 552                 memset(bp, 0, padsz);
 553                 bp = (void *) bp + padsz;
 554         }
 555         *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
 556         *bp++ = htonl(op->mtime.tv_sec); /* mtime */
 557         *bp++ = 0; /* owner */
 558         *bp++ = 0; /* group */
 559         *bp++ = htonl(op->create.mode & S_IALLUGO); /* unix mode */
 560         *bp++ = 0; /* segment size */
 561
 562         trace_afs_make_fs_call1(call, &dvp->fid, name);
 563         afs_make_op_call(op, call, GFP_NOFS);
 564 }
 565
 566 static const struct afs_call_type afs_RXFSMakeDir = {
 567         .name           = "FS.MakeDir",
 568         .op             = afs_FS_MakeDir,
 569         .deliver        = afs_deliver_fs_create_vnode,
 570         .destructor     = afs_flat_call_destructor,
 571 };
 572
 573 /*
 574  * Create a new directory
 575  */
 576 void afs_fs_make_dir(struct afs_operation *op)
 577 {
 578         const struct qstr *name = &op->dentry->d_name;
 579         struct afs_vnode_param *dvp = &op->file[0];
 580         struct afs_call *call;
 581         size_t namesz, reqsz, padsz;
 582         __be32 *bp;
 583
 584         _enter("");
 585
 586         namesz = name->len;
 587         padsz = (4 - (namesz & 3)) & 3;
 588         reqsz = (5 * 4) + namesz + padsz + (6 * 4);
 589
 590         call = afs_alloc_flat_call(op->net, &afs_RXFSMakeDir,
 591                                    reqsz, (3 + 21 + 21 + 3 + 6) * 4);
 592         if (!call)
 593                 return afs_op_nomem(op);
 594
 595         /* marshall the parameters */
 596         bp = call->request;
 597         *bp++ = htonl(FSMAKEDIR);
 598         *bp++ = htonl(dvp->fid.vid);
 599         *bp++ = htonl(dvp->fid.vnode);
 600         *bp++ = htonl(dvp->fid.unique);
 601         *bp++ = htonl(namesz);
 602         memcpy(bp, name->name, namesz);
 603         bp = (void *) bp + namesz;
 604         if (padsz > 0) {
 605                 memset(bp, 0, padsz);
 606                 bp = (void *) bp + padsz;
 607         }
 608         *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
 609         *bp++ = htonl(op->mtime.tv_sec); /* mtime */
 610         *bp++ = 0; /* owner */
 611         *bp++ = 0; /* group */
 612         *bp++ = htonl(op->create.mode & S_IALLUGO); /* unix mode */
 613         *bp++ = 0; /* segment size */
 614
 615         trace_afs_make_fs_call1(call, &dvp->fid, name);
 616         afs_make_op_call(op, call, GFP_NOFS);
 617 }
 618
 619 /*
 620  * Deliver reply data to any operation that returns status and volume sync.
 621  */
 622 static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
 623 {
 624         struct afs_operation *op = call->op;
 625         struct afs_vnode_param *vp = &op->file[0];
 626         const __be32 *bp;
 627         int ret;
 628
 629         ret = afs_transfer_reply(call);
 630         if (ret < 0)
 631                 return ret;
 632
 633         /* unmarshall the reply once we've received all of it */
 634         bp = call->buffer;
 635         xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
 636         xdr_decode_AFSVolSync(&bp, &op->volsync);
 637
 638         _leave(" = 0 [done]");
 639         return 0;
 640 }
 641
 642 /*
 643  * FS.RemoveFile operation type
 644  */
 645 static const struct afs_call_type afs_RXFSRemoveFile = {
 646         .name           = "FS.RemoveFile",
 647         .op             = afs_FS_RemoveFile,
 648         .deliver        = afs_deliver_fs_file_status_and_vol,
 649         .destructor     = afs_flat_call_destructor,
 650 };
 651
 652 /*
 653  * Remove a file.
 654  */
 655 void afs_fs_remove_file(struct afs_operation *op)
 656 {
 657         const struct qstr *name = &op->dentry->d_name;
 658         struct afs_vnode_param *dvp = &op->file[0];
 659         struct afs_call *call;
 660         size_t namesz, reqsz, padsz;
 661         __be32 *bp;
 662
 663         _enter("");
 664
 665         namesz = name->len;
 666         padsz = (4 - (namesz & 3)) & 3;
 667         reqsz = (5 * 4) + namesz + padsz;
 668
 669         call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveFile,
 670                                    reqsz, (21 + 6) * 4);
 671         if (!call)
 672                 return afs_op_nomem(op);
 673
 674         /* marshall the parameters */
 675         bp = call->request;
 676         *bp++ = htonl(FSREMOVEFILE);
 677         *bp++ = htonl(dvp->fid.vid);
 678         *bp++ = htonl(dvp->fid.vnode);
 679         *bp++ = htonl(dvp->fid.unique);
 680         *bp++ = htonl(namesz);
 681         memcpy(bp, name->name, namesz);
 682         bp = (void *) bp + namesz;
 683         if (padsz > 0) {
 684                 memset(bp, 0, padsz);
 685                 bp = (void *) bp + padsz;
 686         }
 687
 688         trace_afs_make_fs_call1(call, &dvp->fid, name);
 689         afs_make_op_call(op, call, GFP_NOFS);
 690 }
 691
 692 static const struct afs_call_type afs_RXFSRemoveDir = {
 693         .name           = "FS.RemoveDir",
 694         .op             = afs_FS_RemoveDir,
 695         .deliver        = afs_deliver_fs_file_status_and_vol,
 696         .destructor     = afs_flat_call_destructor,
 697 };
 698
 699 /*
 700  * Remove a directory.
 701  */
 702 void afs_fs_remove_dir(struct afs_operation *op)
 703 {
 704         const struct qstr *name = &op->dentry->d_name;
 705         struct afs_vnode_param *dvp = &op->file[0];
 706         struct afs_call *call;
 707         size_t namesz, reqsz, padsz;
 708         __be32 *bp;
 709
 710         _enter("");
 711
 712         namesz = name->len;
 713         padsz = (4 - (namesz & 3)) & 3;
 714         reqsz = (5 * 4) + namesz + padsz;
 715
 716         call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveDir,
 717                                    reqsz, (21 + 6) * 4);
 718         if (!call)
 719                 return afs_op_nomem(op);
 720
 721         /* marshall the parameters */
 722         bp = call->request;
 723         *bp++ = htonl(FSREMOVEDIR);
 724         *bp++ = htonl(dvp->fid.vid);
 725         *bp++ = htonl(dvp->fid.vnode);
 726         *bp++ = htonl(dvp->fid.unique);
 727         *bp++ = htonl(namesz);
 728         memcpy(bp, name->name, namesz);
 729         bp = (void *) bp + namesz;
 730         if (padsz > 0) {
 731                 memset(bp, 0, padsz);
 732                 bp = (void *) bp + padsz;
 733         }
 734
 735         trace_afs_make_fs_call1(call, &dvp->fid, name);
 736         afs_make_op_call(op, call, GFP_NOFS);
 737 }
 738
 739 /*
 740  * deliver reply data to an FS.Link
 741  */
 742 static int afs_deliver_fs_link(struct afs_call *call)
 743 {
 744         struct afs_operation *op = call->op;
 745         struct afs_vnode_param *dvp = &op->file[0];
 746         struct afs_vnode_param *vp = &op->file[1];
 747         const __be32 *bp;
 748         int ret;
 749
 750         _enter("{%u}", call->unmarshall);
 751
 752         ret = afs_transfer_reply(call);
 753         if (ret < 0)
 754                 return ret;
 755
 756         /* unmarshall the reply once we've received all of it */
 757         bp = call->buffer;
 758         xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
 759         xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
 760         xdr_decode_AFSVolSync(&bp, &op->volsync);
 761
 762         _leave(" = 0 [done]");
 763         return 0;
 764 }
 765
 766 /*
 767  * FS.Link operation type
 768  */
 769 static const struct afs_call_type afs_RXFSLink = {
 770         .name           = "FS.Link",
 771         .op             = afs_FS_Link,
 772         .deliver        = afs_deliver_fs_link,
 773         .destructor     = afs_flat_call_destructor,
 774 };
 775
 776 /*
 777  * make a hard link
 778  */
 779 void afs_fs_link(struct afs_operation *op)
 780 {
 781         const struct qstr *name = &op->dentry->d_name;
 782         struct afs_vnode_param *dvp = &op->file[0];
 783         struct afs_vnode_param *vp = &op->file[1];
 784         struct afs_call *call;
 785         size_t namesz, reqsz, padsz;
 786         __be32 *bp;
 787
 788         _enter("");
 789
 790         namesz = name->len;
 791         padsz = (4 - (namesz & 3)) & 3;
 792         reqsz = (5 * 4) + namesz + padsz + (3 * 4);
 793
 794         call = afs_alloc_flat_call(op->net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
 795         if (!call)
 796                 return afs_op_nomem(op);
 797
 798         /* marshall the parameters */
 799         bp = call->request;
 800         *bp++ = htonl(FSLINK);
 801         *bp++ = htonl(dvp->fid.vid);
 802         *bp++ = htonl(dvp->fid.vnode);
 803         *bp++ = htonl(dvp->fid.unique);
 804         *bp++ = htonl(namesz);
 805         memcpy(bp, name->name, namesz);
 806         bp = (void *) bp + namesz;
 807         if (padsz > 0) {
 808                 memset(bp, 0, padsz);
 809                 bp = (void *) bp + padsz;
 810         }
 811         *bp++ = htonl(vp->fid.vid);
 812         *bp++ = htonl(vp->fid.vnode);
 813         *bp++ = htonl(vp->fid.unique);
 814
 815         trace_afs_make_fs_call1(call, &vp->fid, name);
 816         afs_make_op_call(op, call, GFP_NOFS);
 817 }
 818
 819 /*
 820  * deliver reply data to an FS.Symlink
 821  */
 822 static int afs_deliver_fs_symlink(struct afs_call *call)
 823 {
 824         struct afs_operation *op = call->op;
 825         struct afs_vnode_param *dvp = &op->file[0];
 826         struct afs_vnode_param *vp = &op->file[1];
 827         const __be32 *bp;
 828         int ret;
 829
 830         _enter("{%u}", call->unmarshall);
 831
 832         ret = afs_transfer_reply(call);
 833         if (ret < 0)
 834                 return ret;
 835
 836         /* unmarshall the reply once we've received all of it */
 837         bp = call->buffer;
 838         xdr_decode_AFSFid(&bp, &vp->fid);
 839         xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
 840         xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
 841         xdr_decode_AFSVolSync(&bp, &op->volsync);
 842
 843         _leave(" = 0 [done]");
 844         return 0;
 845 }
 846
 847 /*
 848  * FS.Symlink operation type
 849  */
 850 static const struct afs_call_type afs_RXFSSymlink = {
 851         .name           = "FS.Symlink",
 852         .op             = afs_FS_Symlink,
 853         .deliver        = afs_deliver_fs_symlink,
 854         .destructor     = afs_flat_call_destructor,
 855 };
 856
 857 /*
 858  * create a symbolic link
 859  */
 860 void afs_fs_symlink(struct afs_operation *op)
 861 {
 862         const struct qstr *name = &op->dentry->d_name;
 863         struct afs_vnode_param *dvp = &op->file[0];
 864         struct afs_call *call;
 865         size_t namesz, reqsz, padsz, c_namesz, c_padsz;
 866         __be32 *bp;
 867
 868         _enter("");
 869
 870         namesz = name->len;
 871         padsz = (4 - (namesz & 3)) & 3;
 872
 873         c_namesz = strlen(op->create.symlink);
 874         c_padsz = (4 - (c_namesz & 3)) & 3;
 875
 876         reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
 877
 878         call = afs_alloc_flat_call(op->net, &afs_RXFSSymlink, reqsz,
 879                                    (3 + 21 + 21 + 6) * 4);
 880         if (!call)
 881                 return afs_op_nomem(op);
 882
 883         /* marshall the parameters */
 884         bp = call->request;
 885         *bp++ = htonl(FSSYMLINK);
 886         *bp++ = htonl(dvp->fid.vid);
 887         *bp++ = htonl(dvp->fid.vnode);
 888         *bp++ = htonl(dvp->fid.unique);
 889         *bp++ = htonl(namesz);
 890         memcpy(bp, name->name, namesz);
 891         bp = (void *) bp + namesz;
 892         if (padsz > 0) {
 893                 memset(bp, 0, padsz);
 894                 bp = (void *) bp + padsz;
 895         }
 896         *bp++ = htonl(c_namesz);
 897         memcpy(bp, op->create.symlink, c_namesz);
 898         bp = (void *) bp + c_namesz;
 899         if (c_padsz > 0) {
 900                 memset(bp, 0, c_padsz);
 901                 bp = (void *) bp + c_padsz;
 902         }
 903         *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
 904         *bp++ = htonl(op->mtime.tv_sec); /* mtime */
 905         *bp++ = 0; /* owner */
 906         *bp++ = 0; /* group */
 907         *bp++ = htonl(S_IRWXUGO); /* unix mode */
 908         *bp++ = 0; /* segment size */
 909
 910         trace_afs_make_fs_call1(call, &dvp->fid, name);
 911         afs_make_op_call(op, call, GFP_NOFS);
 912 }
 913
 914 /*
 915  * deliver reply data to an FS.Rename
 916  */
 917 static int afs_deliver_fs_rename(struct afs_call *call)
 918 {
 919         struct afs_operation *op = call->op;
 920         struct afs_vnode_param *orig_dvp = &op->file[0];
 921         struct afs_vnode_param *new_dvp = &op->file[1];
 922         const __be32 *bp;
 923         int ret;
 924
 925         ret = afs_transfer_reply(call);
 926         if (ret < 0)
 927                 return ret;
 928
 929         bp = call->buffer;
 930         /* If the two dirs are the same, we have two copies of the same status
 931          * report, so we just decode it twice.
 932          */
 933         xdr_decode_AFSFetchStatus(&bp, call, &orig_dvp->scb);
 934         xdr_decode_AFSFetchStatus(&bp, call, &new_dvp->scb);
 935         xdr_decode_AFSVolSync(&bp, &op->volsync);
 936
 937         _leave(" = 0 [done]");
 938         return 0;
 939 }
 940
 941 /*
 942  * FS.Rename operation type
 943  */
 944 static const struct afs_call_type afs_RXFSRename = {
 945         .name           = "FS.Rename",
 946         .op             = afs_FS_Rename,
 947         .deliver        = afs_deliver_fs_rename,
 948         .destructor     = afs_flat_call_destructor,
 949 };
 950
 951 /*
 952  * Rename/move a file or directory.
 953  */
 954 void afs_fs_rename(struct afs_operation *op)
 955 {
 956         struct afs_vnode_param *orig_dvp = &op->file[0];
 957         struct afs_vnode_param *new_dvp = &op->file[1];
 958         const struct qstr *orig_name = &op->dentry->d_name;
 959         const struct qstr *new_name = &op->dentry_2->d_name;
 960         struct afs_call *call;
 961         size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
 962         __be32 *bp;
 963
 964         _enter("");
 965
 966         o_namesz = orig_name->len;
 967         o_padsz = (4 - (o_namesz & 3)) & 3;
 968
 969         n_namesz = new_name->len;
 970         n_padsz = (4 - (n_namesz & 3)) & 3;
 971
 972         reqsz = (4 * 4) +
 973                 4 + o_namesz + o_padsz +
 974                 (3 * 4) +
 975                 4 + n_namesz + n_padsz;
 976
 977         call = afs_alloc_flat_call(op->net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
 978         if (!call)
 979                 return afs_op_nomem(op);
 980
 981         /* marshall the parameters */
 982         bp = call->request;
 983         *bp++ = htonl(FSRENAME);
 984         *bp++ = htonl(orig_dvp->fid.vid);
 985         *bp++ = htonl(orig_dvp->fid.vnode);
 986         *bp++ = htonl(orig_dvp->fid.unique);
 987         *bp++ = htonl(o_namesz);
 988         memcpy(bp, orig_name->name, o_namesz);
 989         bp = (void *) bp + o_namesz;
 990         if (o_padsz > 0) {
 991                 memset(bp, 0, o_padsz);
 992                 bp = (void *) bp + o_padsz;
 993         }
 994
 995         *bp++ = htonl(new_dvp->fid.vid);
 996         *bp++ = htonl(new_dvp->fid.vnode);
 997         *bp++ = htonl(new_dvp->fid.unique);
 998         *bp++ = htonl(n_namesz);
 999         memcpy(bp, new_name->name, n_namesz);
1000         bp = (void *) bp + n_namesz;
1001         if (n_padsz > 0) {
1002                 memset(bp, 0, n_padsz);
1003                 bp = (void *) bp + n_padsz;
1004         }
1005
1006         trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name);
1007         afs_make_op_call(op, call, GFP_NOFS);
1008 }
1009
1010 /*
1011  * Deliver reply data to FS.StoreData or FS.StoreStatus
1012  */
1013 static int afs_deliver_fs_store_data(struct afs_call *call)
1014 {
1015         struct afs_operation *op = call->op;
1016         struct afs_vnode_param *vp = &op->file[0];
1017         const __be32 *bp;
1018         int ret;
1019
1020         _enter("");
1021
1022         ret = afs_transfer_reply(call);
1023         if (ret < 0)
1024                 return ret;
1025
1026         /* unmarshall the reply once we've received all of it */
1027         bp = call->buffer;
1028         xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
1029         xdr_decode_AFSVolSync(&bp, &op->volsync);
1030
1031         _leave(" = 0 [done]");
1032         return 0;
1033 }
1034
1035 /*
1036  * FS.StoreData operation type
1037  */
1038 static const struct afs_call_type afs_RXFSStoreData = {
1039         .name           = "FS.StoreData",
1040         .op             = afs_FS_StoreData,
1041         .deliver        = afs_deliver_fs_store_data,
1042         .destructor     = afs_flat_call_destructor,
1043 };
1044
1045 static const struct afs_call_type afs_RXFSStoreData64 = {
1046         .name           = "FS.StoreData64",
1047         .op             = afs_FS_StoreData64,
1048         .deliver        = afs_deliver_fs_store_data,
1049         .destructor     = afs_flat_call_destructor,
1050 };
1051
1052 /*
1053  * store a set of pages to a very large file
1054  */
1055 static void afs_fs_store_data64(struct afs_operation *op)
1056 {
1057         struct afs_vnode_param *vp = &op->file[0];
1058         struct afs_call *call;
1059         __be32 *bp;
1060
1061         _enter(",%x,{%llx:%llu},,",
1062                key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1063
1064         call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64,
1065                                    (4 + 6 + 3 * 2) * 4,
1066                                    (21 + 6) * 4);
1067         if (!call)
1068                 return afs_op_nomem(op);
1069
1070         call->write_iter = op->store.write_iter;
1071
1072         /* marshall the parameters */
1073         bp = call->request;
1074         *bp++ = htonl(FSSTOREDATA64);
1075         *bp++ = htonl(vp->fid.vid);
1076         *bp++ = htonl(vp->fid.vnode);
1077         *bp++ = htonl(vp->fid.unique);
1078
1079         *bp++ = htonl(AFS_SET_MTIME); /* mask */
1080         *bp++ = htonl(op->mtime.tv_sec); /* mtime */
1081         *bp++ = 0; /* owner */
1082         *bp++ = 0; /* group */
1083         *bp++ = 0; /* unix mode */
1084         *bp++ = 0; /* segment size */
1085
1086         *bp++ = htonl(upper_32_bits(op->store.pos));
1087         *bp++ = htonl(lower_32_bits(op->store.pos));
1088         *bp++ = htonl(upper_32_bits(op->store.size));
1089         *bp++ = htonl(lower_32_bits(op->store.size));
1090         *bp++ = htonl(upper_32_bits(op->store.i_size));
1091         *bp++ = htonl(lower_32_bits(op->store.i_size));
1092
1093         trace_afs_make_fs_call(call, &vp->fid);
1094         afs_make_op_call(op, call, GFP_NOFS);
1095 }
1096
1097 /*
1098  * Write data to a file on the server.
1099  */
1100 void afs_fs_store_data(struct afs_operation *op)
1101 {
1102         struct afs_vnode_param *vp = &op->file[0];
1103         struct afs_call *call;
1104         __be32 *bp;
1105
1106         _enter(",%x,{%llx:%llu},,",
1107                key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1108
1109         _debug("size %llx, at %llx, i_size %llx",
1110                (unsigned long long)op->store.size,
1111                (unsigned long long)op->store.pos,
1112                (unsigned long long)op->store.i_size);
1113
1114         if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
1115                 return afs_fs_store_data64(op);
1116
1117         call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData,
1118                                    (4 + 6 + 3) * 4,
1119                                    (21 + 6) * 4);
1120         if (!call)
1121                 return afs_op_nomem(op);
1122
1123         call->write_iter = op->store.write_iter;
1124
1125         /* marshall the parameters */
1126         bp = call->request;
1127         *bp++ = htonl(FSSTOREDATA);
1128         *bp++ = htonl(vp->fid.vid);
1129         *bp++ = htonl(vp->fid.vnode);
1130         *bp++ = htonl(vp->fid.unique);
1131
1132         *bp++ = htonl(AFS_SET_MTIME); /* mask */
1133         *bp++ = htonl(op->mtime.tv_sec); /* mtime */
1134         *bp++ = 0; /* owner */
1135         *bp++ = 0; /* group */
1136         *bp++ = 0; /* unix mode */
1137         *bp++ = 0; /* segment size */
1138
1139         *bp++ = htonl(lower_32_bits(op->store.pos));
1140         *bp++ = htonl(lower_32_bits(op->store.size));
1141         *bp++ = htonl(lower_32_bits(op->store.i_size));
1142
1143         trace_afs_make_fs_call(call, &vp->fid);
1144         afs_make_op_call(op, call, GFP_NOFS);
1145 }
1146
1147 /*
1148  * FS.StoreStatus operation type
1149  */
1150 static const struct afs_call_type afs_RXFSStoreStatus = {
1151         .name           = "FS.StoreStatus",
1152         .op             = afs_FS_StoreStatus,
1153         .deliver        = afs_deliver_fs_store_data,
1154         .destructor     = afs_flat_call_destructor,
1155 };
1156
1157 static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1158         .name           = "FS.StoreData",
1159         .op             = afs_FS_StoreData,
1160         .deliver        = afs_deliver_fs_store_data,
1161         .destructor     = afs_flat_call_destructor,
1162 };
1163
1164 static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1165         .name           = "FS.StoreData64",
1166         .op             = afs_FS_StoreData64,
1167         .deliver        = afs_deliver_fs_store_data,
1168         .destructor     = afs_flat_call_destructor,
1169 };
1170
1171 /*
1172  * set the attributes on a very large file, using FS.StoreData rather than
1173  * FS.StoreStatus so as to alter the file size also
1174  */
1175 static void afs_fs_setattr_size64(struct afs_operation *op)
1176 {
1177         struct afs_vnode_param *vp = &op->file[0];
1178         struct afs_call *call;
1179         struct iattr *attr = op->setattr.attr;
1180         __be32 *bp;
1181
1182         _enter(",%x,{%llx:%llu},,",
1183                key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1184
1185         ASSERT(attr->ia_valid & ATTR_SIZE);
1186
1187         call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64_as_Status,
1188                                    (4 + 6 + 3 * 2) * 4,
1189                                    (21 + 6) * 4);
1190         if (!call)
1191                 return afs_op_nomem(op);
1192
1193         /* marshall the parameters */
1194         bp = call->request;
1195         *bp++ = htonl(FSSTOREDATA64);
1196         *bp++ = htonl(vp->fid.vid);
1197         *bp++ = htonl(vp->fid.vnode);
1198         *bp++ = htonl(vp->fid.unique);
1199
1200         xdr_encode_AFS_StoreStatus(&bp, attr);
1201
1202         *bp++ = htonl(upper_32_bits(attr->ia_size));    /* position of start of write */
1203         *bp++ = htonl(lower_32_bits(attr->ia_size));
1204         *bp++ = 0;                                      /* size of write */
1205         *bp++ = 0;
1206         *bp++ = htonl(upper_32_bits(attr->ia_size));    /* new file length */
1207         *bp++ = htonl(lower_32_bits(attr->ia_size));
1208
1209         trace_afs_make_fs_call(call, &vp->fid);
1210         afs_make_op_call(op, call, GFP_NOFS);
1211 }
1212
1213 /*
1214  * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus
1215  * so as to alter the file size also
1216  */
1217 static void afs_fs_setattr_size(struct afs_operation *op)
1218 {
1219         struct afs_vnode_param *vp = &op->file[0];
1220         struct afs_call *call;
1221         struct iattr *attr = op->setattr.attr;
1222         __be32 *bp;
1223
1224         _enter(",%x,{%llx:%llu},,",
1225                key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1226
1227         ASSERT(attr->ia_valid & ATTR_SIZE);
1228         if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
1229                 return afs_fs_setattr_size64(op);
1230
1231         call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status,
1232                                    (4 + 6 + 3) * 4,
1233                                    (21 + 6) * 4);
1234         if (!call)
1235                 return afs_op_nomem(op);
1236
1237         /* marshall the parameters */
1238         bp = call->request;
1239         *bp++ = htonl(FSSTOREDATA);
1240         *bp++ = htonl(vp->fid.vid);
1241         *bp++ = htonl(vp->fid.vnode);
1242         *bp++ = htonl(vp->fid.unique);
1243
1244         xdr_encode_AFS_StoreStatus(&bp, attr);
1245
1246         *bp++ = htonl(attr->ia_size);           /* position of start of write */
1247         *bp++ = 0;                              /* size of write */
1248         *bp++ = htonl(attr->ia_size);           /* new file length */
1249
1250         trace_afs_make_fs_call(call, &vp->fid);
1251         afs_make_op_call(op, call, GFP_NOFS);
1252 }
1253
1254 /*
1255  * set the attributes on a file, using FS.StoreData if there's a change in file
1256  * size, and FS.StoreStatus otherwise
1257  */
1258 void afs_fs_setattr(struct afs_operation *op)
1259 {
1260         struct afs_vnode_param *vp = &op->file[0];
1261         struct afs_call *call;
1262         struct iattr *attr = op->setattr.attr;
1263         __be32 *bp;
1264
1265         if (attr->ia_valid & ATTR_SIZE)
1266                 return afs_fs_setattr_size(op);
1267
1268         _enter(",%x,{%llx:%llu},,",
1269                key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1270
1271         call = afs_alloc_flat_call(op->net, &afs_RXFSStoreStatus,
1272                                    (4 + 6) * 4,
1273                                    (21 + 6) * 4);
1274         if (!call)
1275                 return afs_op_nomem(op);
1276
1277         /* marshall the parameters */
1278         bp = call->request;
1279         *bp++ = htonl(FSSTORESTATUS);
1280         *bp++ = htonl(vp->fid.vid);
1281         *bp++ = htonl(vp->fid.vnode);
1282         *bp++ = htonl(vp->fid.unique);
1283
1284         xdr_encode_AFS_StoreStatus(&bp, op->setattr.attr);
1285
1286         trace_afs_make_fs_call(call, &vp->fid);
1287         afs_make_op_call(op, call, GFP_NOFS);
1288 }
1289
1290 /*
1291  * deliver reply data to an FS.GetVolumeStatus
1292  */
1293 static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1294 {
1295         struct afs_operation *op = call->op;
1296         const __be32 *bp;
1297         char *p;
1298         u32 size;
1299         int ret;
1300
1301         _enter("{%u}", call->unmarshall);
1302
1303         switch (call->unmarshall) {
1304         case 0:
1305                 call->unmarshall++;
1306                 afs_extract_to_buf(call, 12 * 4);
1307                 fallthrough;
1308
1309                 /* extract the returned status record */
1310         case 1:
1311                 _debug("extract status");
1312                 ret = afs_extract_data(call, true);
1313                 if (ret < 0)
1314                         return ret;
1315
1316                 bp = call->buffer;
1317                 xdr_decode_AFSFetchVolumeStatus(&bp, &op->volstatus.vs);
1318                 call->unmarshall++;
1319                 afs_extract_to_tmp(call);
1320                 fallthrough;
1321
1322                 /* extract the volume name length */
1323         case 2:
1324                 ret = afs_extract_data(call, true);
1325                 if (ret < 0)
1326                         return ret;
1327
1328                 call->count = ntohl(call->tmp);
1329                 _debug("volname length: %u", call->count);
1330                 if (call->count >= AFSNAMEMAX)
1331                         return afs_protocol_error(call, afs_eproto_volname_len);
1332                 size = (call->count + 3) & ~3; /* It's padded */
1333                 afs_extract_to_buf(call, size);
1334                 call->unmarshall++;
1335                 fallthrough;
1336
1337                 /* extract the volume name */
1338         case 3:
1339                 _debug("extract volname");
1340                 ret = afs_extract_data(call, true);
1341                 if (ret < 0)
1342                         return ret;
1343
1344                 p = call->buffer;
1345                 p[call->count] = 0;
1346                 _debug("volname '%s'", p);
1347                 afs_extract_to_tmp(call);
1348                 call->unmarshall++;
1349                 fallthrough;
1350
1351                 /* extract the offline message length */
1352         case 4:
1353                 ret = afs_extract_data(call, true);
1354                 if (ret < 0)
1355                         return ret;
1356
1357                 call->count = ntohl(call->tmp);
1358                 _debug("offline msg length: %u", call->count);
1359                 if (call->count >= AFSNAMEMAX)
1360                         return afs_protocol_error(call, afs_eproto_offline_msg_len);
1361                 size = (call->count + 3) & ~3; /* It's padded */
1362                 afs_extract_to_buf(call, size);
1363                 call->unmarshall++;
1364                 fallthrough;
1365
1366                 /* extract the offline message */
1367         case 5:
1368                 _debug("extract offline");
1369                 ret = afs_extract_data(call, true);
1370                 if (ret < 0)
1371                         return ret;
1372
1373                 p = call->buffer;
1374                 p[call->count] = 0;
1375                 _debug("offline '%s'", p);
1376
1377                 afs_extract_to_tmp(call);
1378                 call->unmarshall++;
1379                 fallthrough;
1380
1381                 /* extract the message of the day length */
1382         case 6:
1383                 ret = afs_extract_data(call, true);
1384                 if (ret < 0)
1385                         return ret;
1386
1387                 call->count = ntohl(call->tmp);
1388                 _debug("motd length: %u", call->count);
1389                 if (call->count >= AFSNAMEMAX)
1390                         return afs_protocol_error(call, afs_eproto_motd_len);
1391                 size = (call->count + 3) & ~3; /* It's padded */
1392                 afs_extract_to_buf(call, size);
1393                 call->unmarshall++;
1394                 fallthrough;
1395
1396                 /* extract the message of the day */
1397         case 7:
1398                 _debug("extract motd");
1399                 ret = afs_extract_data(call, false);
1400                 if (ret < 0)
1401                         return ret;
1402
1403                 p = call->buffer;
1404                 p[call->count] = 0;
1405                 _debug("motd '%s'", p);
1406
1407                 call->unmarshall++;
1408                 fallthrough;
1409
1410         case 8:
1411                 break;
1412         }
1413
1414         _leave(" = 0 [done]");
1415         return 0;
1416 }
1417
1418 /*
1419  * FS.GetVolumeStatus operation type
1420  */
1421 static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1422         .name           = "FS.GetVolumeStatus",
1423         .op             = afs_FS_GetVolumeStatus,
1424         .deliver        = afs_deliver_fs_get_volume_status,
1425         .destructor     = afs_flat_call_destructor,
1426 };
1427
1428 /*
1429  * fetch the status of a volume
1430  */
1431 void afs_fs_get_volume_status(struct afs_operation *op)
1432 {
1433         struct afs_vnode_param *vp = &op->file[0];
1434         struct afs_call *call;
1435         __be32 *bp;
1436
1437         _enter("");
1438
1439         call = afs_alloc_flat_call(op->net, &afs_RXFSGetVolumeStatus, 2 * 4,
1440                                    max(12 * 4, AFSOPAQUEMAX + 1));
1441         if (!call)
1442                 return afs_op_nomem(op);
1443
1444         /* marshall the parameters */
1445         bp = call->request;
1446         bp[0] = htonl(FSGETVOLUMESTATUS);
1447         bp[1] = htonl(vp->fid.vid);
1448
1449         trace_afs_make_fs_call(call, &vp->fid);
1450         afs_make_op_call(op, call, GFP_NOFS);
1451 }
1452
1453 /*
1454  * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
1455  */
1456 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1457 {
1458         struct afs_operation *op = call->op;
1459         const __be32 *bp;
1460         int ret;
1461
1462         _enter("{%u}", call->unmarshall);
1463
1464         ret = afs_transfer_reply(call);
1465         if (ret < 0)
1466                 return ret;
1467
1468         /* unmarshall the reply once we've received all of it */
1469         bp = call->buffer;
1470         xdr_decode_AFSVolSync(&bp, &op->volsync);
1471
1472         _leave(" = 0 [done]");
1473         return 0;
1474 }
1475
1476 /*
1477  * FS.SetLock operation type
1478  */
1479 static const struct afs_call_type afs_RXFSSetLock = {
1480         .name           = "FS.SetLock",
1481         .op             = afs_FS_SetLock,
1482         .deliver        = afs_deliver_fs_xxxx_lock,
1483         .done           = afs_lock_op_done,
1484         .destructor     = afs_flat_call_destructor,
1485 };
1486
1487 /*
1488  * FS.ExtendLock operation type
1489  */
1490 static const struct afs_call_type afs_RXFSExtendLock = {
1491         .name           = "FS.ExtendLock",
1492         .op             = afs_FS_ExtendLock,
1493         .deliver        = afs_deliver_fs_xxxx_lock,
1494         .done           = afs_lock_op_done,
1495         .destructor     = afs_flat_call_destructor,
1496 };
1497
1498 /*
1499  * FS.ReleaseLock operation type
1500  */
1501 static const struct afs_call_type afs_RXFSReleaseLock = {
1502         .name           = "FS.ReleaseLock",
1503         .op             = afs_FS_ReleaseLock,
1504         .deliver        = afs_deliver_fs_xxxx_lock,
1505         .destructor     = afs_flat_call_destructor,
1506 };
1507
1508 /*
1509  * Set a lock on a file
1510  */
1511 void afs_fs_set_lock(struct afs_operation *op)
1512 {
1513         struct afs_vnode_param *vp = &op->file[0];
1514         struct afs_call *call;
1515         __be32 *bp;
1516
1517         _enter("");
1518
1519         call = afs_alloc_flat_call(op->net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1520         if (!call)
1521                 return afs_op_nomem(op);
1522
1523         /* marshall the parameters */
1524         bp = call->request;
1525         *bp++ = htonl(FSSETLOCK);
1526         *bp++ = htonl(vp->fid.vid);
1527         *bp++ = htonl(vp->fid.vnode);
1528         *bp++ = htonl(vp->fid.unique);
1529         *bp++ = htonl(op->lock.type);
1530
1531         trace_afs_make_fs_calli(call, &vp->fid, op->lock.type);
1532         afs_make_op_call(op, call, GFP_NOFS);
1533 }
1534
1535 /*
1536  * extend a lock on a file
1537  */
1538 void afs_fs_extend_lock(struct afs_operation *op)
1539 {
1540         struct afs_vnode_param *vp = &op->file[0];
1541         struct afs_call *call;
1542         __be32 *bp;
1543
1544         _enter("");
1545
1546         call = afs_alloc_flat_call(op->net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1547         if (!call)
1548                 return afs_op_nomem(op);
1549
1550         /* marshall the parameters */
1551         bp = call->request;
1552         *bp++ = htonl(FSEXTENDLOCK);
1553         *bp++ = htonl(vp->fid.vid);
1554         *bp++ = htonl(vp->fid.vnode);
1555         *bp++ = htonl(vp->fid.unique);
1556
1557         trace_afs_make_fs_call(call, &vp->fid);
1558         afs_make_op_call(op, call, GFP_NOFS);
1559 }
1560
1561 /*
1562  * release a lock on a file
1563  */
1564 void afs_fs_release_lock(struct afs_operation *op)
1565 {
1566         struct afs_vnode_param *vp = &op->file[0];
1567         struct afs_call *call;
1568         __be32 *bp;
1569
1570         _enter("");
1571
1572         call = afs_alloc_flat_call(op->net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1573         if (!call)
1574                 return afs_op_nomem(op);
1575
1576         /* marshall the parameters */
1577         bp = call->request;
1578         *bp++ = htonl(FSRELEASELOCK);
1579         *bp++ = htonl(vp->fid.vid);
1580         *bp++ = htonl(vp->fid.vnode);
1581         *bp++ = htonl(vp->fid.unique);
1582
1583         trace_afs_make_fs_call(call, &vp->fid);
1584         afs_make_op_call(op, call, GFP_NOFS);
1585 }
1586
1587 /*
1588  * Deliver reply data to an FS.GiveUpAllCallBacks operation.
1589  */
1590 static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1591 {
1592         return afs_transfer_reply(call);
1593 }
1594
1595 /*
1596  * FS.GiveUpAllCallBacks operation type
1597  */
1598 static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = {
1599         .name           = "FS.GiveUpAllCallBacks",
1600         .op             = afs_FS_GiveUpAllCallBacks,
1601         .deliver        = afs_deliver_fs_give_up_all_callbacks,
1602         .destructor     = afs_flat_call_destructor,
1603 };
1604
1605 /*
1606  * Flush all the callbacks we have on a server.
1607  */
1608 int afs_fs_give_up_all_callbacks(struct afs_net *net, struct afs_server *server,
1609                                  struct afs_address *addr, struct key *key)
1610 {
1611         struct afs_call *call;
1612         __be32 *bp;
1613         int ret;
1614
1615         _enter("");
1616
1617         call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1618         if (!call)
1619                 return -ENOMEM;
1620
1621         call->key       = key;
1622         call->peer      = rxrpc_kernel_get_peer(addr->peer);
1623         call->service_id = server->service_id;
1624
1625         /* marshall the parameters */
1626         bp = call->request;
1627         *bp++ = htonl(FSGIVEUPALLCALLBACKS);
1628
1629         call->server = afs_use_server(server, afs_server_trace_give_up_cb);
1630         afs_make_call(call, GFP_NOFS);
1631         afs_wait_for_call_to_complete(call);
1632         ret = call->error;
1633         if (call->responded)
1634                 set_bit(AFS_SERVER_FL_RESPONDING, &server->flags);
1635         afs_put_call(call);
1636         return ret;
1637 }
1638
1639 /*
1640  * Deliver reply data to an FS.GetCapabilities operation.
1641  */
1642 static int afs_deliver_fs_get_capabilities(struct afs_call *call)
1643 {
1644         u32 count;
1645         int ret;
1646
1647         _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));
1648
1649         switch (call->unmarshall) {
1650         case 0:
1651                 afs_extract_to_tmp(call);
1652                 call->unmarshall++;
1653                 fallthrough;
1654
1655                 /* Extract the capabilities word count */
1656         case 1:
1657                 ret = afs_extract_data(call, true);
1658                 if (ret < 0)
1659                         return ret;
1660
1661                 count = ntohl(call->tmp);
1662                 call->count = count;
1663                 call->count2 = count;
1664                 if (count == 0) {
1665                         call->unmarshall = 4;
1666                         call->tmp = 0;
1667                         break;
1668                 }
1669
1670                 /* Extract the first word of the capabilities to call->tmp */
1671                 afs_extract_to_tmp(call);
1672                 call->unmarshall++;
1673                 fallthrough;
1674
1675         case 2:
1676                 ret = afs_extract_data(call, false);
1677                 if (ret < 0)
1678                         return ret;
1679
1680                 afs_extract_discard(call, (count - 1) * sizeof(__be32));
1681                 call->unmarshall++;
1682                 fallthrough;
1683
1684                 /* Extract remaining capabilities words */
1685         case 3:
1686                 ret = afs_extract_data(call, false);
1687                 if (ret < 0)
1688                         return ret;
1689
1690                 call->unmarshall++;
1691                 break;
1692         }
1693
1694         _leave(" = 0 [done]");
1695         return 0;
1696 }
1697
1698 static void afs_fs_get_capabilities_destructor(struct afs_call *call)
1699 {
1700         afs_put_endpoint_state(call->probe, afs_estate_trace_put_getcaps);
1701         afs_flat_call_destructor(call);
1702 }
1703
1704 /*
1705  * FS.GetCapabilities operation type
1706  */
1707 static const struct afs_call_type afs_RXFSGetCapabilities = {
1708         .name           = "FS.GetCapabilities",
1709         .op             = afs_FS_GetCapabilities,
1710         .deliver        = afs_deliver_fs_get_capabilities,
1711         .done           = afs_fileserver_probe_result,
1712         .destructor     = afs_fs_get_capabilities_destructor,
1713 };
1714
1715 /*
1716  * Probe a fileserver for the capabilities that it supports.  This RPC can
1717  * reply with up to 196 words.  The operation is asynchronous and if we managed
1718  * to allocate a call, true is returned the result is delivered through the
1719  * ->done() - otherwise we return false to indicate we didn't even try.
1720  */
1721 bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,
1722                              struct afs_endpoint_state *estate, unsigned int addr_index,
1723                              struct key *key)
1724 {
1725         struct afs_call *call;
1726         __be32 *bp;
1727
1728         _enter("");
1729
1730         call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
1731         if (!call)
1732                 return false;
1733
1734         call->key       = key;
1735         call->server    = afs_use_server(server, afs_server_trace_get_caps);
1736         call->peer      = rxrpc_kernel_get_peer(estate->addresses->addrs[addr_index].peer);
1737         call->probe     = afs_get_endpoint_state(estate, afs_estate_trace_get_getcaps);
1738         call->probe_index = addr_index;
1739         call->service_id = server->service_id;
1740         call->upgrade   = true;
1741         call->async     = true;
1742         call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
1743
1744         /* marshall the parameters */
1745         bp = call->request;
1746         *bp++ = htonl(FSGETCAPABILITIES);
1747
1748         trace_afs_make_fs_call(call, NULL);
1749         afs_make_call(call, GFP_NOFS);
1750         afs_put_call(call);
1751         return true;
1752 }
1753
1754 /*
1755  * Deliver reply data to an FS.InlineBulkStatus call
1756  */
1757 static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
1758 {
1759         struct afs_operation *op = call->op;
1760         struct afs_status_cb *scb;
1761         const __be32 *bp;
1762         u32 tmp;
1763         int ret;
1764
1765         _enter("{%u}", call->unmarshall);
1766
1767         switch (call->unmarshall) {
1768         case 0:
1769                 afs_extract_to_tmp(call);
1770                 call->unmarshall++;
1771                 fallthrough;
1772
1773                 /* Extract the file status count and array in two steps */
1774         case 1:
1775                 _debug("extract status count");
1776                 ret = afs_extract_data(call, true);
1777                 if (ret < 0)
1778                         return ret;
1779
1780                 tmp = ntohl(call->tmp);
1781                 _debug("status count: %u/%u", tmp, op->nr_files);
1782                 if (tmp != op->nr_files)
1783                         return afs_protocol_error(call, afs_eproto_ibulkst_count);
1784
1785                 call->count = 0;
1786                 call->unmarshall++;
1787         more_counts:
1788                 afs_extract_to_buf(call, 21 * sizeof(__be32));
1789                 fallthrough;
1790
1791         case 2:
1792                 _debug("extract status array %u", call->count);
1793                 ret = afs_extract_data(call, true);
1794                 if (ret < 0)
1795                         return ret;
1796
1797                 switch (call->count) {
1798                 case 0:
1799                         scb = &op->file[0].scb;
1800                         break;
1801                 case 1:
1802                         scb = &op->file[1].scb;
1803                         break;
1804                 default:
1805                         scb = &op->more_files[call->count - 2].scb;
1806                         break;
1807                 }
1808
1809                 bp = call->buffer;
1810                 xdr_decode_AFSFetchStatus(&bp, call, scb);
1811
1812                 call->count++;
1813                 if (call->count < op->nr_files)
1814                         goto more_counts;
1815
1816                 call->count = 0;
1817                 call->unmarshall++;
1818                 afs_extract_to_tmp(call);
1819                 fallthrough;
1820
1821                 /* Extract the callback count and array in two steps */
1822         case 3:
1823                 _debug("extract CB count");
1824                 ret = afs_extract_data(call, true);
1825                 if (ret < 0)
1826                         return ret;
1827
1828                 tmp = ntohl(call->tmp);
1829                 _debug("CB count: %u", tmp);
1830                 if (tmp != op->nr_files)
1831                         return afs_protocol_error(call, afs_eproto_ibulkst_cb_count);
1832                 call->count = 0;
1833                 call->unmarshall++;
1834         more_cbs:
1835                 afs_extract_to_buf(call, 3 * sizeof(__be32));
1836                 fallthrough;
1837
1838         case 4:
1839                 _debug("extract CB array");
1840                 ret = afs_extract_data(call, true);
1841                 if (ret < 0)
1842                         return ret;
1843
1844                 _debug("unmarshall CB array");
1845                 switch (call->count) {
1846                 case 0:
1847                         scb = &op->file[0].scb;
1848                         break;
1849                 case 1:
1850                         scb = &op->file[1].scb;
1851                         break;
1852                 default:
1853                         scb = &op->more_files[call->count - 2].scb;
1854                         break;
1855                 }
1856
1857                 bp = call->buffer;
1858                 xdr_decode_AFSCallBack(&bp, call, scb);
1859                 call->count++;
1860                 if (call->count < op->nr_files)
1861                         goto more_cbs;
1862
1863                 afs_extract_to_buf(call, 6 * sizeof(__be32));
1864                 call->unmarshall++;
1865                 fallthrough;
1866
1867         case 5:
1868                 ret = afs_extract_data(call, false);
1869                 if (ret < 0)
1870                         return ret;
1871
1872                 bp = call->buffer;
1873                 /* Unfortunately, prior to OpenAFS-1.6, volsync here is filled
1874                  * with rubbish.
1875                  */
1876                 xdr_decode_AFSVolSync(&bp, NULL);
1877
1878                 call->unmarshall++;
1879                 fallthrough;
1880
1881         case 6:
1882                 break;
1883         }
1884
1885         _leave(" = 0 [done]");
1886         return 0;
1887 }
1888
1889 static void afs_done_fs_inline_bulk_status(struct afs_call *call)
1890 {
1891         if (call->error == -ECONNABORTED &&
1892             call->abort_code == RX_INVALID_OPERATION) {
1893                 set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags);
1894                 if (call->op)
1895                         set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags);
1896         }
1897 }
1898
1899 /*
1900  * FS.InlineBulkStatus operation type
1901  */
1902 static const struct afs_call_type afs_RXFSInlineBulkStatus = {
1903         .name           = "FS.InlineBulkStatus",
1904         .op             = afs_FS_InlineBulkStatus,
1905         .deliver        = afs_deliver_fs_inline_bulk_status,
1906         .done           = afs_done_fs_inline_bulk_status,
1907         .destructor     = afs_flat_call_destructor,
1908 };
1909
1910 /*
1911  * Fetch the status information for up to 50 files
1912  */
1913 void afs_fs_inline_bulk_status(struct afs_operation *op)
1914 {
1915         struct afs_vnode_param *dvp = &op->file[0];
1916         struct afs_vnode_param *vp = &op->file[1];
1917         struct afs_call *call;
1918         __be32 *bp;
1919         int i;
1920
1921         if (test_bit(AFS_SERVER_FL_NO_IBULK, &op->server->flags)) {
1922                 afs_op_set_error(op, -ENOTSUPP);
1923                 return;
1924         }
1925
1926         _enter(",%x,{%llx:%llu},%u",
1927                key_serial(op->key), vp->fid.vid, vp->fid.vnode, op->nr_files);
1928
1929         call = afs_alloc_flat_call(op->net, &afs_RXFSInlineBulkStatus,
1930                                    (2 + op->nr_files * 3) * 4,
1931                                    21 * 4);
1932         if (!call)
1933                 return afs_op_nomem(op);
1934
1935         /* marshall the parameters */
1936         bp = call->request;
1937         *bp++ = htonl(FSINLINEBULKSTATUS);
1938         *bp++ = htonl(op->nr_files);
1939         *bp++ = htonl(dvp->fid.vid);
1940         *bp++ = htonl(dvp->fid.vnode);
1941         *bp++ = htonl(dvp->fid.unique);
1942         *bp++ = htonl(vp->fid.vid);
1943         *bp++ = htonl(vp->fid.vnode);
1944         *bp++ = htonl(vp->fid.unique);
1945         for (i = 0; i < op->nr_files - 2; i++) {
1946                 *bp++ = htonl(op->more_files[i].fid.vid);
1947                 *bp++ = htonl(op->more_files[i].fid.vnode);
1948                 *bp++ = htonl(op->more_files[i].fid.unique);
1949         }
1950
1951         trace_afs_make_fs_call(call, &vp->fid);
1952         afs_make_op_call(op, call, GFP_NOFS);
1953 }
1954
1955 /*
1956  * deliver reply data to an FS.FetchACL
1957  */
1958 static int afs_deliver_fs_fetch_acl(struct afs_call *call)
1959 {
1960         struct afs_operation *op = call->op;
1961         struct afs_vnode_param *vp = &op->file[0];
1962         struct afs_acl *acl;
1963         const __be32 *bp;
1964         unsigned int size;
1965         int ret;
1966
1967         _enter("{%u}", call->unmarshall);
1968
1969         switch (call->unmarshall) {
1970         case 0:
1971                 afs_extract_to_tmp(call);
1972                 call->unmarshall++;
1973                 fallthrough;
1974
1975                 /* extract the returned data length */
1976         case 1:
1977                 ret = afs_extract_data(call, true);
1978                 if (ret < 0)
1979                         return ret;
1980
1981                 size = call->count2 = ntohl(call->tmp);
1982                 size = round_up(size, 4);
1983
1984                 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
1985                 if (!acl)
1986                         return -ENOMEM;
1987                 op->acl = acl;
1988                 acl->size = call->count2;
1989                 afs_extract_begin(call, acl->data, size);
1990                 call->unmarshall++;
1991                 fallthrough;
1992
1993                 /* extract the returned data */
1994         case 2:
1995                 ret = afs_extract_data(call, true);
1996                 if (ret < 0)
1997                         return ret;
1998
1999                 afs_extract_to_buf(call, (21 + 6) * 4);
2000                 call->unmarshall++;
2001                 fallthrough;
2002
2003                 /* extract the metadata */
2004         case 3:
2005                 ret = afs_extract_data(call, false);
2006                 if (ret < 0)
2007                         return ret;
2008
2009                 bp = call->buffer;
2010                 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
2011                 xdr_decode_AFSVolSync(&bp, &op->volsync);
2012
2013                 call->unmarshall++;
2014                 fallthrough;
2015
2016         case 4:
2017                 break;
2018         }
2019
2020         _leave(" = 0 [done]");
2021         return 0;
2022 }
2023
2024 /*
2025  * FS.FetchACL operation type
2026  */
2027 static const struct afs_call_type afs_RXFSFetchACL = {
2028         .name           = "FS.FetchACL",
2029         .op             = afs_FS_FetchACL,
2030         .deliver        = afs_deliver_fs_fetch_acl,
2031 };
2032
2033 /*
2034  * Fetch the ACL for a file.
2035  */
2036 void afs_fs_fetch_acl(struct afs_operation *op)
2037 {
2038         struct afs_vnode_param *vp = &op->file[0];
2039         struct afs_call *call;
2040         __be32 *bp;
2041
2042         _enter(",%x,{%llx:%llu},,",
2043                key_serial(op->key), vp->fid.vid, vp->fid.vnode);
2044
2045         call = afs_alloc_flat_call(op->net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
2046         if (!call)
2047                 return afs_op_nomem(op);
2048
2049         /* marshall the parameters */
2050         bp = call->request;
2051         bp[0] = htonl(FSFETCHACL);
2052         bp[1] = htonl(vp->fid.vid);
2053         bp[2] = htonl(vp->fid.vnode);
2054         bp[3] = htonl(vp->fid.unique);
2055
2056         trace_afs_make_fs_call(call, &vp->fid);
2057         afs_make_op_call(op, call, GFP_KERNEL);
2058 }
2059
2060 /*
2061  * FS.StoreACL operation type
2062  */
2063 static const struct afs_call_type afs_RXFSStoreACL = {
2064         .name           = "FS.StoreACL",
2065         .op             = afs_FS_StoreACL,
2066         .deliver        = afs_deliver_fs_file_status_and_vol,
2067         .destructor     = afs_flat_call_destructor,
2068 };
2069
2070 /*
2071  * Fetch the ACL for a file.
2072  */
2073 void afs_fs_store_acl(struct afs_operation *op)
2074 {
2075         struct afs_vnode_param *vp = &op->file[0];
2076         struct afs_call *call;
2077         const struct afs_acl *acl = op->acl;
2078         size_t size;
2079         __be32 *bp;
2080
2081         _enter(",%x,{%llx:%llu},,",
2082                key_serial(op->key), vp->fid.vid, vp->fid.vnode);
2083
2084         size = round_up(acl->size, 4);
2085         call = afs_alloc_flat_call(op->net, &afs_RXFSStoreACL,
2086                                    5 * 4 + size, (21 + 6) * 4);
2087         if (!call)
2088                 return afs_op_nomem(op);
2089
2090         /* marshall the parameters */
2091         bp = call->request;
2092         bp[0] = htonl(FSSTOREACL);
2093         bp[1] = htonl(vp->fid.vid);
2094         bp[2] = htonl(vp->fid.vnode);
2095         bp[3] = htonl(vp->fid.unique);
2096         bp[4] = htonl(acl->size);
2097         memcpy(&bp[5], acl->data, acl->size);
2098         if (acl->size != size)
2099                 memset((void *)&bp[5] + acl->size, 0, size - acl->size);
2100
2101         trace_afs_make_fs_call(call, &vp->fid);
2102         afs_make_op_call(op, call, GFP_KERNEL);
2103 }