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