fs/afs/yfsclient.c

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