fs/afs/fsclient.c

   1 /* AFS File Server client stubs
   2  *
   3  * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/init.h>
  13 #include <linux/slab.h>
  14 #include <linux/sched.h>
  15 #include <linux/circ_buf.h>
  16 #include <linux/iversion.h>
  17 #include "internal.h"
  18 #include "afs_fs.h"
  19 #include "xdr_fs.h"
  20 #include "protocol_yfs.h"
  21
  22 static const struct afs_fid afs_zero_fid;
  23
  24 static inline void afs_use_fs_server(struct afs_call *call, struct afs_cb_interest *cbi)
  25 {
  26         call->cbi = afs_get_cb_interest(cbi);
  27 }
  28
  29 /*
  30  * decode an AFSFid block
  31  */
  32 static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid)
  33 {
  34         const __be32 *bp = *_bp;
  35
  36         fid->vid                = ntohl(*bp++);
  37         fid->vnode              = ntohl(*bp++);
  38         fid->unique             = ntohl(*bp++);
  39         *_bp = bp;
  40 }
  41
  42 /*
  43  * Dump a bad file status record.
  44  */
  45 static void xdr_dump_bad(const __be32 *bp)
  46 {
  47         __be32 x[4];
  48         int i;
  49
  50         pr_notice("AFS XDR: Bad status record\n");
  51         for (i = 0; i < 5 * 4 * 4; i += 16) {
  52                 memcpy(x, bp, 16);
  53                 bp += 4;
  54                 pr_notice("%03x: %08x %08x %08x %08x\n",
  55                           i, ntohl(x[0]), ntohl(x[1]), ntohl(x[2]), ntohl(x[3]));
  56         }
  57
  58         memcpy(x, bp, 4);
  59         pr_notice("0x50: %08x\n", ntohl(x[0]));
  60 }
  61
  62 /*
  63  * Update the core inode struct from a returned status record.
  64  */
  65 void afs_update_inode_from_status(struct afs_vnode *vnode,
  66                                   struct afs_file_status *status,
  67                                   const afs_dataversion_t *expected_version,
  68                                   u8 flags)
  69 {
  70         struct timespec64 t;
  71         umode_t mode;
  72
  73         t = status->mtime_client;
  74         vnode->vfs_inode.i_ctime = t;
  75         vnode->vfs_inode.i_mtime = t;
  76         vnode->vfs_inode.i_atime = t;
  77
  78         if (flags & (AFS_VNODE_META_CHANGED | AFS_VNODE_NOT_YET_SET)) {
  79                 vnode->vfs_inode.i_uid = make_kuid(&init_user_ns, status->owner);
  80                 vnode->vfs_inode.i_gid = make_kgid(&init_user_ns, status->group);
  81                 set_nlink(&vnode->vfs_inode, status->nlink);
  82
  83                 mode = vnode->vfs_inode.i_mode;
  84                 mode &= ~S_IALLUGO;
  85                 mode |= status->mode;
  86                 barrier();
  87                 vnode->vfs_inode.i_mode = mode;
  88         }
  89
  90         if (!(flags & AFS_VNODE_NOT_YET_SET)) {
  91                 if (expected_version &&
  92                     *expected_version != status->data_version) {
  93                         _debug("vnode modified %llx on {%llx:%llu} [exp %llx]",
  94                                (unsigned long long) status->data_version,
  95                                vnode->fid.vid, vnode->fid.vnode,
  96                                (unsigned long long) *expected_version);
  97                         vnode->invalid_before = status->data_version;
  98                         if (vnode->status.type == AFS_FTYPE_DIR) {
  99                                 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
 100                                         afs_stat_v(vnode, n_inval);
 101                         } else {
 102                                 set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
 103                         }
 104                 } else if (vnode->status.type == AFS_FTYPE_DIR) {
 105                         /* Expected directory change is handled elsewhere so
 106                          * that we can locally edit the directory and save on a
 107                          * download.
 108                          */
 109                         if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
 110                                 flags &= ~AFS_VNODE_DATA_CHANGED;
 111                 }
 112         }
 113
 114         if (flags & (AFS_VNODE_DATA_CHANGED | AFS_VNODE_NOT_YET_SET)) {
 115                 inode_set_iversion_raw(&vnode->vfs_inode, status->data_version);
 116                 i_size_write(&vnode->vfs_inode, status->size);
 117         }
 118 }
 119
 120 /*
 121  * decode an AFSFetchStatus block
 122  */
 123 static int xdr_decode_AFSFetchStatus(struct afs_call *call,
 124                                      const __be32 **_bp,
 125                                      struct afs_file_status *status,
 126                                      struct afs_vnode *vnode,
 127                                      const afs_dataversion_t *expected_version,
 128                                      struct afs_read *read_req)
 129 {
 130         const struct afs_xdr_AFSFetchStatus *xdr = (const void *)*_bp;
 131         bool inline_error = (call->operation_ID == afs_FS_InlineBulkStatus);
 132         u64 data_version, size;
 133         u32 type, abort_code;
 134         u8 flags = 0;
 135
 136         abort_code = ntohl(xdr->abort_code);
 137
 138         if (xdr->if_version != htonl(AFS_FSTATUS_VERSION)) {
 139                 if (xdr->if_version == htonl(0) &&
 140                     abort_code != 0 &&
 141                     inline_error) {
 142                         /* The OpenAFS fileserver has a bug in FS.InlineBulkStatus
 143                          * whereby it doesn't set the interface version in the error
 144                          * case.
 145                          */
 146                         status->abort_code = abort_code;
 147                         return 0;
 148                 }
 149
 150                 pr_warn("Unknown AFSFetchStatus version %u\n", ntohl(xdr->if_version));
 151                 goto bad;
 152         }
 153
 154         if (abort_code != 0 && inline_error) {
 155                 status->abort_code = abort_code;
 156                 return 0;
 157         }
 158
 159         type = ntohl(xdr->type);
 160         switch (type) {
 161         case AFS_FTYPE_FILE:
 162         case AFS_FTYPE_DIR:
 163         case AFS_FTYPE_SYMLINK:
 164                 if (type != status->type &&
 165                     vnode &&
 166                     !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
 167                         pr_warning("Vnode %llx:%llx:%x changed type %u to %u\n",
 168                                    vnode->fid.vid,
 169                                    vnode->fid.vnode,
 170                                    vnode->fid.unique,
 171                                    status->type, type);
 172                         goto bad;
 173                 }
 174                 status->type = type;
 175                 break;
 176         default:
 177                 goto bad;
 178         }
 179
 180 #define EXTRACT_M(FIELD)                                        \
 181         do {                                                    \
 182                 u32 x = ntohl(xdr->FIELD);                      \
 183                 if (status->FIELD != x) {                       \
 184                         flags |= AFS_VNODE_META_CHANGED;        \
 185                         status->FIELD = x;                      \
 186                 }                                               \
 187         } while (0)
 188
 189         EXTRACT_M(nlink);
 190         EXTRACT_M(author);
 191         EXTRACT_M(owner);
 192         EXTRACT_M(caller_access); /* call ticket dependent */
 193         EXTRACT_M(anon_access);
 194         EXTRACT_M(mode);
 195         EXTRACT_M(group);
 196
 197         status->mtime_client.tv_sec = ntohl(xdr->mtime_client);
 198         status->mtime_client.tv_nsec = 0;
 199         status->mtime_server.tv_sec = ntohl(xdr->mtime_server);
 200         status->mtime_server.tv_nsec = 0;
 201         status->lock_count   = ntohl(xdr->lock_count);
 202
 203         size  = (u64)ntohl(xdr->size_lo);
 204         size |= (u64)ntohl(xdr->size_hi) << 32;
 205         status->size = size;
 206
 207         data_version  = (u64)ntohl(xdr->data_version_lo);
 208         data_version |= (u64)ntohl(xdr->data_version_hi) << 32;
 209         if (data_version != status->data_version) {
 210                 status->data_version = data_version;
 211                 flags |= AFS_VNODE_DATA_CHANGED;
 212         }
 213
 214         if (read_req) {
 215                 read_req->data_version = data_version;
 216                 read_req->file_size = size;
 217         }
 218
 219         *_bp = (const void *)*_bp + sizeof(*xdr);
 220
 221         if (vnode) {
 222                 if (test_bit(AFS_VNODE_UNSET, &vnode->flags))
 223                         flags |= AFS_VNODE_NOT_YET_SET;
 224                 afs_update_inode_from_status(vnode, status, expected_version,
 225                                              flags);
 226         }
 227
 228         return 0;
 229
 230 bad:
 231         xdr_dump_bad(*_bp);
 232         return afs_protocol_error(call, -EBADMSG, afs_eproto_bad_status);
 233 }
 234
 235 /*
 236  * Decode the file status.  We need to lock the target vnode if we're going to
 237  * update its status so that stat() sees the attributes update atomically.
 238  */
 239 static int afs_decode_status(struct afs_call *call,
 240                              const __be32 **_bp,
 241                              struct afs_file_status *status,
 242                              struct afs_vnode *vnode,
 243                              const afs_dataversion_t *expected_version,
 244                              struct afs_read *read_req)
 245 {
 246         int ret;
 247
 248         if (!vnode)
 249                 return xdr_decode_AFSFetchStatus(call, _bp, status, vnode,
 250                                                  expected_version, read_req);
 251
 252         write_seqlock(&vnode->cb_lock);
 253         ret = xdr_decode_AFSFetchStatus(call, _bp, status, vnode,
 254                                         expected_version, read_req);
 255         write_sequnlock(&vnode->cb_lock);
 256         return ret;
 257 }
 258
 259 /*
 260  * decode an AFSCallBack block
 261  */
 262 static void xdr_decode_AFSCallBack(struct afs_call *call,
 263                                    struct afs_vnode *vnode,
 264                                    const __be32 **_bp)
 265 {
 266         struct afs_cb_interest *old, *cbi = call->cbi;
 267         const __be32 *bp = *_bp;
 268         u32 cb_expiry;
 269
 270         write_seqlock(&vnode->cb_lock);
 271
 272         if (!afs_cb_is_broken(call->cb_break, vnode, cbi)) {
 273                 vnode->cb_version       = ntohl(*bp++);
 274                 cb_expiry               = ntohl(*bp++);
 275                 vnode->cb_type          = ntohl(*bp++);
 276                 vnode->cb_expires_at    = cb_expiry + ktime_get_real_seconds();
 277                 old = vnode->cb_interest;
 278                 if (old != call->cbi) {
 279                         vnode->cb_interest = cbi;
 280                         cbi = old;
 281                 }
 282                 set_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
 283         } else {
 284                 bp += 3;
 285         }
 286
 287         write_sequnlock(&vnode->cb_lock);
 288         call->cbi = cbi;
 289         *_bp = bp;
 290 }
 291
 292 static ktime_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
 293 {
 294         return ktime_add_ns(call->reply_time, expiry * NSEC_PER_SEC);
 295 }
 296
 297 static void xdr_decode_AFSCallBack_raw(struct afs_call *call,
 298                                        const __be32 **_bp,
 299                                        struct afs_callback *cb)
 300 {
 301         const __be32 *bp = *_bp;
 302
 303         cb->version     = ntohl(*bp++);
 304         cb->expires_at  = xdr_decode_expiry(call, ntohl(*bp++));
 305         cb->type        = ntohl(*bp++);
 306         *_bp = bp;
 307 }
 308
 309 /*
 310  * decode an AFSVolSync block
 311  */
 312 static void xdr_decode_AFSVolSync(const __be32 **_bp,
 313                                   struct afs_volsync *volsync)
 314 {
 315         const __be32 *bp = *_bp;
 316         u32 creation;
 317
 318         creation = ntohl(*bp++);
 319         bp++; /* spare2 */
 320         bp++; /* spare3 */
 321         bp++; /* spare4 */
 322         bp++; /* spare5 */
 323         bp++; /* spare6 */
 324         *_bp = bp;
 325
 326         if (volsync)
 327                 volsync->creation = creation;
 328 }
 329
 330 /*
 331  * encode the requested attributes into an AFSStoreStatus block
 332  */
 333 static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr)
 334 {
 335         __be32 *bp = *_bp;
 336         u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0;
 337
 338         mask = 0;
 339         if (attr->ia_valid & ATTR_MTIME) {
 340                 mask |= AFS_SET_MTIME;
 341                 mtime = attr->ia_mtime.tv_sec;
 342         }
 343
 344         if (attr->ia_valid & ATTR_UID) {
 345                 mask |= AFS_SET_OWNER;
 346                 owner = from_kuid(&init_user_ns, attr->ia_uid);
 347         }
 348
 349         if (attr->ia_valid & ATTR_GID) {
 350                 mask |= AFS_SET_GROUP;
 351                 group = from_kgid(&init_user_ns, attr->ia_gid);
 352         }
 353
 354         if (attr->ia_valid & ATTR_MODE) {
 355                 mask |= AFS_SET_MODE;
 356                 mode = attr->ia_mode & S_IALLUGO;
 357         }
 358
 359         *bp++ = htonl(mask);
 360         *bp++ = htonl(mtime);
 361         *bp++ = htonl(owner);
 362         *bp++ = htonl(group);
 363         *bp++ = htonl(mode);
 364         *bp++ = 0;              /* segment size */
 365         *_bp = bp;
 366 }
 367
 368 /*
 369  * decode an AFSFetchVolumeStatus block
 370  */
 371 static void xdr_decode_AFSFetchVolumeStatus(const __be32 **_bp,
 372                                             struct afs_volume_status *vs)
 373 {
 374         const __be32 *bp = *_bp;
 375
 376         vs->vid                 = ntohl(*bp++);
 377         vs->parent_id           = ntohl(*bp++);
 378         vs->online              = ntohl(*bp++);
 379         vs->in_service          = ntohl(*bp++);
 380         vs->blessed             = ntohl(*bp++);
 381         vs->needs_salvage       = ntohl(*bp++);
 382         vs->type                = ntohl(*bp++);
 383         vs->min_quota           = ntohl(*bp++);
 384         vs->max_quota           = ntohl(*bp++);
 385         vs->blocks_in_use       = ntohl(*bp++);
 386         vs->part_blocks_avail   = ntohl(*bp++);
 387         vs->part_max_blocks     = ntohl(*bp++);
 388         vs->vol_copy_date       = 0;
 389         vs->vol_backup_date     = 0;
 390         *_bp = bp;
 391 }
 392
 393 /*
 394  * deliver reply data to an FS.FetchStatus
 395  */
 396 static int afs_deliver_fs_fetch_status_vnode(struct afs_call *call)
 397 {
 398         struct afs_vnode *vnode = call->reply[0];
 399         const __be32 *bp;
 400         int ret;
 401
 402         ret = afs_transfer_reply(call);
 403         if (ret < 0)
 404                 return ret;
 405
 406         _enter("{%llx:%llu}", vnode->fid.vid, vnode->fid.vnode);
 407
 408         /* unmarshall the reply once we've received all of it */
 409         bp = call->buffer;
 410         ret = afs_decode_status(call, &bp, &vnode->status, vnode,
 411                                 &call->expected_version, NULL);
 412         if (ret < 0)
 413                 return ret;
 414         xdr_decode_AFSCallBack(call, vnode, &bp);
 415         xdr_decode_AFSVolSync(&bp, call->reply[1]);
 416
 417         _leave(" = 0 [done]");
 418         return 0;
 419 }
 420
 421 /*
 422  * FS.FetchStatus operation type
 423  */
 424 static const struct afs_call_type afs_RXFSFetchStatus_vnode = {
 425         .name           = "FS.FetchStatus(vnode)",
 426         .op             = afs_FS_FetchStatus,
 427         .deliver        = afs_deliver_fs_fetch_status_vnode,
 428         .destructor     = afs_flat_call_destructor,
 429 };
 430
 431 /*
 432  * fetch the status information for a file
 433  */
 434 int afs_fs_fetch_file_status(struct afs_fs_cursor *fc, struct afs_volsync *volsync,
 435                              bool new_inode)
 436 {
 437         struct afs_vnode *vnode = fc->vnode;
 438         struct afs_call *call;
 439         struct afs_net *net = afs_v2net(vnode);
 440         __be32 *bp;
 441
 442         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 443                 return yfs_fs_fetch_file_status(fc, volsync, new_inode);
 444
 445         _enter(",%x,{%llx:%llu},,",
 446                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
 447
 448         call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus_vnode,
 449                                    16, (21 + 3 + 6) * 4);
 450         if (!call) {
 451                 fc->ac.error = -ENOMEM;
 452                 return -ENOMEM;
 453         }
 454
 455         call->key = fc->key;
 456         call->reply[0] = vnode;
 457         call->reply[1] = volsync;
 458         call->expected_version = new_inode ? 1 : vnode->status.data_version;
 459         call->want_reply_time = true;
 460
 461         /* marshall the parameters */
 462         bp = call->request;
 463         bp[0] = htonl(FSFETCHSTATUS);
 464         bp[1] = htonl(vnode->fid.vid);
 465         bp[2] = htonl(vnode->fid.vnode);
 466         bp[3] = htonl(vnode->fid.unique);
 467
 468         call->cb_break = fc->cb_break;
 469         afs_use_fs_server(call, fc->cbi);
 470         trace_afs_make_fs_call(call, &vnode->fid);
 471         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
 472 }
 473
 474 /*
 475  * deliver reply data to an FS.FetchData
 476  */
 477 static int afs_deliver_fs_fetch_data(struct afs_call *call)
 478 {
 479         struct afs_vnode *vnode = call->reply[0];
 480         struct afs_read *req = call->reply[2];
 481         const __be32 *bp;
 482         unsigned int size;
 483         int ret;
 484
 485         _enter("{%u,%zu/%llu}",
 486                call->unmarshall, iov_iter_count(&call->iter), req->actual_len);
 487
 488         switch (call->unmarshall) {
 489         case 0:
 490                 req->actual_len = 0;
 491                 req->index = 0;
 492                 req->offset = req->pos & (PAGE_SIZE - 1);
 493                 call->unmarshall++;
 494                 if (call->operation_ID == FSFETCHDATA64) {
 495                         afs_extract_to_tmp64(call);
 496                 } else {
 497                         call->tmp_u = htonl(0);
 498                         afs_extract_to_tmp(call);
 499                 }
 500
 501                 /* extract the returned data length */
 502         case 1:
 503                 _debug("extract data length");
 504                 ret = afs_extract_data(call, true);
 505                 if (ret < 0)
 506                         return ret;
 507
 508                 req->actual_len = be64_to_cpu(call->tmp64);
 509                 _debug("DATA length: %llu", req->actual_len);
 510                 req->remain = min(req->len, req->actual_len);
 511                 if (req->remain == 0)
 512                         goto no_more_data;
 513
 514                 call->unmarshall++;
 515
 516         begin_page:
 517                 ASSERTCMP(req->index, <, req->nr_pages);
 518                 if (req->remain > PAGE_SIZE - req->offset)
 519                         size = PAGE_SIZE - req->offset;
 520                 else
 521                         size = req->remain;
 522                 call->bvec[0].bv_len = size;
 523                 call->bvec[0].bv_offset = req->offset;
 524                 call->bvec[0].bv_page = req->pages[req->index];
 525                 iov_iter_bvec(&call->iter, READ, call->bvec, 1, size);
 526                 ASSERTCMP(size, <=, PAGE_SIZE);
 527
 528                 /* extract the returned data */
 529         case 2:
 530                 _debug("extract data %zu/%llu",
 531                        iov_iter_count(&call->iter), req->remain);
 532
 533                 ret = afs_extract_data(call, true);
 534                 if (ret < 0)
 535                         return ret;
 536                 req->remain -= call->bvec[0].bv_len;
 537                 req->offset += call->bvec[0].bv_len;
 538                 ASSERTCMP(req->offset, <=, PAGE_SIZE);
 539                 if (req->offset == PAGE_SIZE) {
 540                         req->offset = 0;
 541                         if (req->page_done)
 542                                 req->page_done(call, req);
 543                         req->index++;
 544                         if (req->remain > 0)
 545                                 goto begin_page;
 546                 }
 547
 548                 ASSERTCMP(req->remain, ==, 0);
 549                 if (req->actual_len <= req->len)
 550                         goto no_more_data;
 551
 552                 /* Discard any excess data the server gave us */
 553                 iov_iter_discard(&call->iter, READ, req->actual_len - req->len);
 554                 call->unmarshall = 3;
 555         case 3:
 556                 _debug("extract discard %zu/%llu",
 557                        iov_iter_count(&call->iter), req->actual_len - req->len);
 558
 559                 ret = afs_extract_data(call, true);
 560                 if (ret < 0)
 561                         return ret;
 562
 563         no_more_data:
 564                 call->unmarshall = 4;
 565                 afs_extract_to_buf(call, (21 + 3 + 6) * 4);
 566
 567                 /* extract the metadata */
 568         case 4:
 569                 ret = afs_extract_data(call, false);
 570                 if (ret < 0)
 571                         return ret;
 572
 573                 bp = call->buffer;
 574                 ret = afs_decode_status(call, &bp, &vnode->status, vnode,
 575                                         &vnode->status.data_version, req);
 576                 if (ret < 0)
 577                         return ret;
 578                 xdr_decode_AFSCallBack(call, vnode, &bp);
 579                 xdr_decode_AFSVolSync(&bp, call->reply[1]);
 580
 581                 call->unmarshall++;
 582
 583         case 5:
 584                 break;
 585         }
 586
 587         for (; req->index < req->nr_pages; req->index++) {
 588                 if (req->offset < PAGE_SIZE)
 589                         zero_user_segment(req->pages[req->index],
 590                                           req->offset, PAGE_SIZE);
 591                 if (req->page_done)
 592                         req->page_done(call, req);
 593                 req->offset = 0;
 594         }
 595
 596         _leave(" = 0 [done]");
 597         return 0;
 598 }
 599
 600 static void afs_fetch_data_destructor(struct afs_call *call)
 601 {
 602         struct afs_read *req = call->reply[2];
 603
 604         afs_put_read(req);
 605         afs_flat_call_destructor(call);
 606 }
 607
 608 /*
 609  * FS.FetchData operation type
 610  */
 611 static const struct afs_call_type afs_RXFSFetchData = {
 612         .name           = "FS.FetchData",
 613         .op             = afs_FS_FetchData,
 614         .deliver        = afs_deliver_fs_fetch_data,
 615         .destructor     = afs_fetch_data_destructor,
 616 };
 617
 618 static const struct afs_call_type afs_RXFSFetchData64 = {
 619         .name           = "FS.FetchData64",
 620         .op             = afs_FS_FetchData64,
 621         .deliver        = afs_deliver_fs_fetch_data,
 622         .destructor     = afs_fetch_data_destructor,
 623 };
 624
 625 /*
 626  * fetch data from a very large file
 627  */
 628 static int afs_fs_fetch_data64(struct afs_fs_cursor *fc, struct afs_read *req)
 629 {
 630         struct afs_vnode *vnode = fc->vnode;
 631         struct afs_call *call;
 632         struct afs_net *net = afs_v2net(vnode);
 633         __be32 *bp;
 634
 635         _enter("");
 636
 637         call = afs_alloc_flat_call(net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
 638         if (!call)
 639                 return -ENOMEM;
 640
 641         call->key = fc->key;
 642         call->reply[0] = vnode;
 643         call->reply[1] = NULL; /* volsync */
 644         call->reply[2] = req;
 645         call->expected_version = vnode->status.data_version;
 646         call->want_reply_time = true;
 647
 648         /* marshall the parameters */
 649         bp = call->request;
 650         bp[0] = htonl(FSFETCHDATA64);
 651         bp[1] = htonl(vnode->fid.vid);
 652         bp[2] = htonl(vnode->fid.vnode);
 653         bp[3] = htonl(vnode->fid.unique);
 654         bp[4] = htonl(upper_32_bits(req->pos));
 655         bp[5] = htonl(lower_32_bits(req->pos));
 656         bp[6] = 0;
 657         bp[7] = htonl(lower_32_bits(req->len));
 658
 659         refcount_inc(&req->usage);
 660         call->cb_break = fc->cb_break;
 661         afs_use_fs_server(call, fc->cbi);
 662         trace_afs_make_fs_call(call, &vnode->fid);
 663         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
 664 }
 665
 666 /*
 667  * fetch data from a file
 668  */
 669 int afs_fs_fetch_data(struct afs_fs_cursor *fc, struct afs_read *req)
 670 {
 671         struct afs_vnode *vnode = fc->vnode;
 672         struct afs_call *call;
 673         struct afs_net *net = afs_v2net(vnode);
 674         __be32 *bp;
 675
 676         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 677                 return yfs_fs_fetch_data(fc, req);
 678
 679         if (upper_32_bits(req->pos) ||
 680             upper_32_bits(req->len) ||
 681             upper_32_bits(req->pos + req->len))
 682                 return afs_fs_fetch_data64(fc, req);
 683
 684         _enter("");
 685
 686         call = afs_alloc_flat_call(net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
 687         if (!call)
 688                 return -ENOMEM;
 689
 690         call->key = fc->key;
 691         call->reply[0] = vnode;
 692         call->reply[1] = NULL; /* volsync */
 693         call->reply[2] = req;
 694         call->expected_version = vnode->status.data_version;
 695         call->want_reply_time = true;
 696
 697         /* marshall the parameters */
 698         bp = call->request;
 699         bp[0] = htonl(FSFETCHDATA);
 700         bp[1] = htonl(vnode->fid.vid);
 701         bp[2] = htonl(vnode->fid.vnode);
 702         bp[3] = htonl(vnode->fid.unique);
 703         bp[4] = htonl(lower_32_bits(req->pos));
 704         bp[5] = htonl(lower_32_bits(req->len));
 705
 706         refcount_inc(&req->usage);
 707         call->cb_break = fc->cb_break;
 708         afs_use_fs_server(call, fc->cbi);
 709         trace_afs_make_fs_call(call, &vnode->fid);
 710         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
 711 }
 712
 713 /*
 714  * deliver reply data to an FS.CreateFile or an FS.MakeDir
 715  */
 716 static int afs_deliver_fs_create_vnode(struct afs_call *call)
 717 {
 718         struct afs_vnode *vnode = call->reply[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         /* unmarshall the reply once we've received all of it */
 729         bp = call->buffer;
 730         xdr_decode_AFSFid(&bp, call->reply[1]);
 731         ret = afs_decode_status(call, &bp, call->reply[2], NULL, NULL, NULL);
 732         if (ret < 0)
 733                 return ret;
 734         ret = afs_decode_status(call, &bp, &vnode->status, vnode,
 735                                 &call->expected_version, NULL);
 736         if (ret < 0)
 737                 return ret;
 738         xdr_decode_AFSCallBack_raw(call, &bp, call->reply[3]);
 739         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
 740
 741         _leave(" = 0 [done]");
 742         return 0;
 743 }
 744
 745 /*
 746  * FS.CreateFile and FS.MakeDir operation type
 747  */
 748 static const struct afs_call_type afs_RXFSCreateFile = {
 749         .name           = "FS.CreateFile",
 750         .op             = afs_FS_CreateFile,
 751         .deliver        = afs_deliver_fs_create_vnode,
 752         .destructor     = afs_flat_call_destructor,
 753 };
 754
 755 static const struct afs_call_type afs_RXFSMakeDir = {
 756         .name           = "FS.MakeDir",
 757         .op             = afs_FS_MakeDir,
 758         .deliver        = afs_deliver_fs_create_vnode,
 759         .destructor     = afs_flat_call_destructor,
 760 };
 761
 762 /*
 763  * create a file or make a directory
 764  */
 765 int afs_fs_create(struct afs_fs_cursor *fc,
 766                   const char *name,
 767                   umode_t mode,
 768                   u64 current_data_version,
 769                   struct afs_fid *newfid,
 770                   struct afs_file_status *newstatus,
 771                   struct afs_callback *newcb)
 772 {
 773         struct afs_vnode *vnode = fc->vnode;
 774         struct afs_call *call;
 775         struct afs_net *net = afs_v2net(vnode);
 776         size_t namesz, reqsz, padsz;
 777         __be32 *bp;
 778
 779         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags)){
 780                 if (S_ISDIR(mode))
 781                         return yfs_fs_make_dir(fc, name, mode, current_data_version,
 782                                                newfid, newstatus, newcb);
 783                 else
 784                         return yfs_fs_create_file(fc, name, mode, current_data_version,
 785                                                   newfid, newstatus, newcb);
 786         }
 787
 788         _enter("");
 789
 790         namesz = strlen(name);
 791         padsz = (4 - (namesz & 3)) & 3;
 792         reqsz = (5 * 4) + namesz + padsz + (6 * 4);
 793
 794         call = afs_alloc_flat_call(
 795                 net, S_ISDIR(mode) ? &afs_RXFSMakeDir : &afs_RXFSCreateFile,
 796                 reqsz, (3 + 21 + 21 + 3 + 6) * 4);
 797         if (!call)
 798                 return -ENOMEM;
 799
 800         call->key = fc->key;
 801         call->reply[0] = vnode;
 802         call->reply[1] = newfid;
 803         call->reply[2] = newstatus;
 804         call->reply[3] = newcb;
 805         call->expected_version = current_data_version + 1;
 806         call->want_reply_time = true;
 807
 808         /* marshall the parameters */
 809         bp = call->request;
 810         *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE);
 811         *bp++ = htonl(vnode->fid.vid);
 812         *bp++ = htonl(vnode->fid.vnode);
 813         *bp++ = htonl(vnode->fid.unique);
 814         *bp++ = htonl(namesz);
 815         memcpy(bp, name, namesz);
 816         bp = (void *) bp + namesz;
 817         if (padsz > 0) {
 818                 memset(bp, 0, padsz);
 819                 bp = (void *) bp + padsz;
 820         }
 821         *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
 822         *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
 823         *bp++ = 0; /* owner */
 824         *bp++ = 0; /* group */
 825         *bp++ = htonl(mode & S_IALLUGO); /* unix mode */
 826         *bp++ = 0; /* segment size */
 827
 828         afs_use_fs_server(call, fc->cbi);
 829         trace_afs_make_fs_call(call, &vnode->fid);
 830         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
 831 }
 832
 833 /*
 834  * deliver reply data to an FS.RemoveFile or FS.RemoveDir
 835  */
 836 static int afs_deliver_fs_remove(struct afs_call *call)
 837 {
 838         struct afs_vnode *vnode = call->reply[0];
 839         const __be32 *bp;
 840         int ret;
 841
 842         _enter("{%u}", call->unmarshall);
 843
 844         ret = afs_transfer_reply(call);
 845         if (ret < 0)
 846                 return ret;
 847
 848         /* unmarshall the reply once we've received all of it */
 849         bp = call->buffer;
 850         ret = afs_decode_status(call, &bp, &vnode->status, vnode,
 851                                 &call->expected_version, NULL);
 852         if (ret < 0)
 853                 return ret;
 854         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
 855
 856         _leave(" = 0 [done]");
 857         return 0;
 858 }
 859
 860 /*
 861  * FS.RemoveDir/FS.RemoveFile operation type
 862  */
 863 static const struct afs_call_type afs_RXFSRemoveFile = {
 864         .name           = "FS.RemoveFile",
 865         .op             = afs_FS_RemoveFile,
 866         .deliver        = afs_deliver_fs_remove,
 867         .destructor     = afs_flat_call_destructor,
 868 };
 869
 870 static const struct afs_call_type afs_RXFSRemoveDir = {
 871         .name           = "FS.RemoveDir",
 872         .op             = afs_FS_RemoveDir,
 873         .deliver        = afs_deliver_fs_remove,
 874         .destructor     = afs_flat_call_destructor,
 875 };
 876
 877 /*
 878  * remove a file or directory
 879  */
 880 int afs_fs_remove(struct afs_fs_cursor *fc, struct afs_vnode *vnode,
 881                   const char *name, bool isdir, u64 current_data_version)
 882 {
 883         struct afs_vnode *dvnode = fc->vnode;
 884         struct afs_call *call;
 885         struct afs_net *net = afs_v2net(dvnode);
 886         size_t namesz, reqsz, padsz;
 887         __be32 *bp;
 888
 889         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 890                 return yfs_fs_remove(fc, vnode, name, isdir, current_data_version);
 891
 892         _enter("");
 893
 894         namesz = strlen(name);
 895         padsz = (4 - (namesz & 3)) & 3;
 896         reqsz = (5 * 4) + namesz + padsz;
 897
 898         call = afs_alloc_flat_call(
 899                 net, isdir ? &afs_RXFSRemoveDir : &afs_RXFSRemoveFile,
 900                 reqsz, (21 + 6) * 4);
 901         if (!call)
 902                 return -ENOMEM;
 903
 904         call->key = fc->key;
 905         call->reply[0] = dvnode;
 906         call->reply[1] = vnode;
 907         call->expected_version = current_data_version + 1;
 908
 909         /* marshall the parameters */
 910         bp = call->request;
 911         *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE);
 912         *bp++ = htonl(dvnode->fid.vid);
 913         *bp++ = htonl(dvnode->fid.vnode);
 914         *bp++ = htonl(dvnode->fid.unique);
 915         *bp++ = htonl(namesz);
 916         memcpy(bp, name, namesz);
 917         bp = (void *) bp + namesz;
 918         if (padsz > 0) {
 919                 memset(bp, 0, padsz);
 920                 bp = (void *) bp + padsz;
 921         }
 922
 923         afs_use_fs_server(call, fc->cbi);
 924         trace_afs_make_fs_call(call, &dvnode->fid);
 925         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
 926 }
 927
 928 /*
 929  * deliver reply data to an FS.Link
 930  */
 931 static int afs_deliver_fs_link(struct afs_call *call)
 932 {
 933         struct afs_vnode *dvnode = call->reply[0], *vnode = call->reply[1];
 934         const __be32 *bp;
 935         int ret;
 936
 937         _enter("{%u}", call->unmarshall);
 938
 939         ret = afs_transfer_reply(call);
 940         if (ret < 0)
 941                 return ret;
 942
 943         /* unmarshall the reply once we've received all of it */
 944         bp = call->buffer;
 945         ret = afs_decode_status(call, &bp, &vnode->status, vnode, NULL, NULL);
 946         if (ret < 0)
 947                 return ret;
 948         ret = afs_decode_status(call, &bp, &dvnode->status, dvnode,
 949                                 &call->expected_version, NULL);
 950         if (ret < 0)
 951                 return ret;
 952         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
 953
 954         _leave(" = 0 [done]");
 955         return 0;
 956 }
 957
 958 /*
 959  * FS.Link operation type
 960  */
 961 static const struct afs_call_type afs_RXFSLink = {
 962         .name           = "FS.Link",
 963         .op             = afs_FS_Link,
 964         .deliver        = afs_deliver_fs_link,
 965         .destructor     = afs_flat_call_destructor,
 966 };
 967
 968 /*
 969  * make a hard link
 970  */
 971 int afs_fs_link(struct afs_fs_cursor *fc, struct afs_vnode *vnode,
 972                 const char *name, u64 current_data_version)
 973 {
 974         struct afs_vnode *dvnode = fc->vnode;
 975         struct afs_call *call;
 976         struct afs_net *net = afs_v2net(vnode);
 977         size_t namesz, reqsz, padsz;
 978         __be32 *bp;
 979
 980         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 981                 return yfs_fs_link(fc, vnode, name, current_data_version);
 982
 983         _enter("");
 984
 985         namesz = strlen(name);
 986         padsz = (4 - (namesz & 3)) & 3;
 987         reqsz = (5 * 4) + namesz + padsz + (3 * 4);
 988
 989         call = afs_alloc_flat_call(net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
 990         if (!call)
 991                 return -ENOMEM;
 992
 993         call->key = fc->key;
 994         call->reply[0] = dvnode;
 995         call->reply[1] = vnode;
 996         call->expected_version = current_data_version + 1;
 997
 998         /* marshall the parameters */
 999         bp = call->request;
1000         *bp++ = htonl(FSLINK);
1001         *bp++ = htonl(dvnode->fid.vid);
1002         *bp++ = htonl(dvnode->fid.vnode);
1003         *bp++ = htonl(dvnode->fid.unique);
1004         *bp++ = htonl(namesz);
1005         memcpy(bp, name, namesz);
1006         bp = (void *) bp + namesz;
1007         if (padsz > 0) {
1008                 memset(bp, 0, padsz);
1009                 bp = (void *) bp + padsz;
1010         }
1011         *bp++ = htonl(vnode->fid.vid);
1012         *bp++ = htonl(vnode->fid.vnode);
1013         *bp++ = htonl(vnode->fid.unique);
1014
1015         afs_use_fs_server(call, fc->cbi);
1016         trace_afs_make_fs_call(call, &vnode->fid);
1017         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1018 }
1019
1020 /*
1021  * deliver reply data to an FS.Symlink
1022  */
1023 static int afs_deliver_fs_symlink(struct afs_call *call)
1024 {
1025         struct afs_vnode *vnode = call->reply[0];
1026         const __be32 *bp;
1027         int ret;
1028
1029         _enter("{%u}", call->unmarshall);
1030
1031         ret = afs_transfer_reply(call);
1032         if (ret < 0)
1033                 return ret;
1034
1035         /* unmarshall the reply once we've received all of it */
1036         bp = call->buffer;
1037         xdr_decode_AFSFid(&bp, call->reply[1]);
1038         ret = afs_decode_status(call, &bp, call->reply[2], NULL, NULL, NULL);
1039         if (ret < 0)
1040                 return ret;
1041         ret = afs_decode_status(call, &bp, &vnode->status, vnode,
1042                                 &call->expected_version, NULL);
1043         if (ret < 0)
1044                 return ret;
1045         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
1046
1047         _leave(" = 0 [done]");
1048         return 0;
1049 }
1050
1051 /*
1052  * FS.Symlink operation type
1053  */
1054 static const struct afs_call_type afs_RXFSSymlink = {
1055         .name           = "FS.Symlink",
1056         .op             = afs_FS_Symlink,
1057         .deliver        = afs_deliver_fs_symlink,
1058         .destructor     = afs_flat_call_destructor,
1059 };
1060
1061 /*
1062  * create a symbolic link
1063  */
1064 int afs_fs_symlink(struct afs_fs_cursor *fc,
1065                    const char *name,
1066                    const char *contents,
1067                    u64 current_data_version,
1068                    struct afs_fid *newfid,
1069                    struct afs_file_status *newstatus)
1070 {
1071         struct afs_vnode *vnode = fc->vnode;
1072         struct afs_call *call;
1073         struct afs_net *net = afs_v2net(vnode);
1074         size_t namesz, reqsz, padsz, c_namesz, c_padsz;
1075         __be32 *bp;
1076
1077         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1078                 return yfs_fs_symlink(fc, name, contents, current_data_version,
1079                                       newfid, newstatus);
1080
1081         _enter("");
1082
1083         namesz = strlen(name);
1084         padsz = (4 - (namesz & 3)) & 3;
1085
1086         c_namesz = strlen(contents);
1087         c_padsz = (4 - (c_namesz & 3)) & 3;
1088
1089         reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
1090
1091         call = afs_alloc_flat_call(net, &afs_RXFSSymlink, reqsz,
1092                                    (3 + 21 + 21 + 6) * 4);
1093         if (!call)
1094                 return -ENOMEM;
1095
1096         call->key = fc->key;
1097         call->reply[0] = vnode;
1098         call->reply[1] = newfid;
1099         call->reply[2] = newstatus;
1100         call->expected_version = current_data_version + 1;
1101
1102         /* marshall the parameters */
1103         bp = call->request;
1104         *bp++ = htonl(FSSYMLINK);
1105         *bp++ = htonl(vnode->fid.vid);
1106         *bp++ = htonl(vnode->fid.vnode);
1107         *bp++ = htonl(vnode->fid.unique);
1108         *bp++ = htonl(namesz);
1109         memcpy(bp, name, namesz);
1110         bp = (void *) bp + namesz;
1111         if (padsz > 0) {
1112                 memset(bp, 0, padsz);
1113                 bp = (void *) bp + padsz;
1114         }
1115         *bp++ = htonl(c_namesz);
1116         memcpy(bp, contents, c_namesz);
1117         bp = (void *) bp + c_namesz;
1118         if (c_padsz > 0) {
1119                 memset(bp, 0, c_padsz);
1120                 bp = (void *) bp + c_padsz;
1121         }
1122         *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
1123         *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1124         *bp++ = 0; /* owner */
1125         *bp++ = 0; /* group */
1126         *bp++ = htonl(S_IRWXUGO); /* unix mode */
1127         *bp++ = 0; /* segment size */
1128
1129         afs_use_fs_server(call, fc->cbi);
1130         trace_afs_make_fs_call(call, &vnode->fid);
1131         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1132 }
1133
1134 /*
1135  * deliver reply data to an FS.Rename
1136  */
1137 static int afs_deliver_fs_rename(struct afs_call *call)
1138 {
1139         struct afs_vnode *orig_dvnode = call->reply[0], *new_dvnode = call->reply[1];
1140         const __be32 *bp;
1141         int ret;
1142
1143         _enter("{%u}", call->unmarshall);
1144
1145         ret = afs_transfer_reply(call);
1146         if (ret < 0)
1147                 return ret;
1148
1149         /* unmarshall the reply once we've received all of it */
1150         bp = call->buffer;
1151         ret = afs_decode_status(call, &bp, &orig_dvnode->status, orig_dvnode,
1152                                 &call->expected_version, NULL);
1153         if (ret < 0)
1154                 return ret;
1155         if (new_dvnode != orig_dvnode) {
1156                 ret = afs_decode_status(call, &bp, &new_dvnode->status, new_dvnode,
1157                                         &call->expected_version_2, NULL);
1158                 if (ret < 0)
1159                         return ret;
1160         }
1161         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
1162
1163         _leave(" = 0 [done]");
1164         return 0;
1165 }
1166
1167 /*
1168  * FS.Rename operation type
1169  */
1170 static const struct afs_call_type afs_RXFSRename = {
1171         .name           = "FS.Rename",
1172         .op             = afs_FS_Rename,
1173         .deliver        = afs_deliver_fs_rename,
1174         .destructor     = afs_flat_call_destructor,
1175 };
1176
1177 /*
1178  * create a symbolic link
1179  */
1180 int afs_fs_rename(struct afs_fs_cursor *fc,
1181                   const char *orig_name,
1182                   struct afs_vnode *new_dvnode,
1183                   const char *new_name,
1184                   u64 current_orig_data_version,
1185                   u64 current_new_data_version)
1186 {
1187         struct afs_vnode *orig_dvnode = fc->vnode;
1188         struct afs_call *call;
1189         struct afs_net *net = afs_v2net(orig_dvnode);
1190         size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
1191         __be32 *bp;
1192
1193         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1194                 return yfs_fs_rename(fc, orig_name,
1195                                      new_dvnode, new_name,
1196                                      current_orig_data_version,
1197                                      current_new_data_version);
1198
1199         _enter("");
1200
1201         o_namesz = strlen(orig_name);
1202         o_padsz = (4 - (o_namesz & 3)) & 3;
1203
1204         n_namesz = strlen(new_name);
1205         n_padsz = (4 - (n_namesz & 3)) & 3;
1206
1207         reqsz = (4 * 4) +
1208                 4 + o_namesz + o_padsz +
1209                 (3 * 4) +
1210                 4 + n_namesz + n_padsz;
1211
1212         call = afs_alloc_flat_call(net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
1213         if (!call)
1214                 return -ENOMEM;
1215
1216         call->key = fc->key;
1217         call->reply[0] = orig_dvnode;
1218         call->reply[1] = new_dvnode;
1219         call->expected_version = current_orig_data_version + 1;
1220         call->expected_version_2 = current_new_data_version + 1;
1221
1222         /* marshall the parameters */
1223         bp = call->request;
1224         *bp++ = htonl(FSRENAME);
1225         *bp++ = htonl(orig_dvnode->fid.vid);
1226         *bp++ = htonl(orig_dvnode->fid.vnode);
1227         *bp++ = htonl(orig_dvnode->fid.unique);
1228         *bp++ = htonl(o_namesz);
1229         memcpy(bp, orig_name, o_namesz);
1230         bp = (void *) bp + o_namesz;
1231         if (o_padsz > 0) {
1232                 memset(bp, 0, o_padsz);
1233                 bp = (void *) bp + o_padsz;
1234         }
1235
1236         *bp++ = htonl(new_dvnode->fid.vid);
1237         *bp++ = htonl(new_dvnode->fid.vnode);
1238         *bp++ = htonl(new_dvnode->fid.unique);
1239         *bp++ = htonl(n_namesz);
1240         memcpy(bp, new_name, n_namesz);
1241         bp = (void *) bp + n_namesz;
1242         if (n_padsz > 0) {
1243                 memset(bp, 0, n_padsz);
1244                 bp = (void *) bp + n_padsz;
1245         }
1246
1247         afs_use_fs_server(call, fc->cbi);
1248         trace_afs_make_fs_call(call, &orig_dvnode->fid);
1249         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1250 }
1251
1252 /*
1253  * deliver reply data to an FS.StoreData
1254  */
1255 static int afs_deliver_fs_store_data(struct afs_call *call)
1256 {
1257         struct afs_vnode *vnode = call->reply[0];
1258         const __be32 *bp;
1259         int ret;
1260
1261         _enter("");
1262
1263         ret = afs_transfer_reply(call);
1264         if (ret < 0)
1265                 return ret;
1266
1267         /* unmarshall the reply once we've received all of it */
1268         bp = call->buffer;
1269         ret = afs_decode_status(call, &bp, &vnode->status, vnode,
1270                                 &call->expected_version, NULL);
1271         if (ret < 0)
1272                 return ret;
1273         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
1274
1275         afs_pages_written_back(vnode, call);
1276
1277         _leave(" = 0 [done]");
1278         return 0;
1279 }
1280
1281 /*
1282  * FS.StoreData operation type
1283  */
1284 static const struct afs_call_type afs_RXFSStoreData = {
1285         .name           = "FS.StoreData",
1286         .op             = afs_FS_StoreData,
1287         .deliver        = afs_deliver_fs_store_data,
1288         .destructor     = afs_flat_call_destructor,
1289 };
1290
1291 static const struct afs_call_type afs_RXFSStoreData64 = {
1292         .name           = "FS.StoreData64",
1293         .op             = afs_FS_StoreData64,
1294         .deliver        = afs_deliver_fs_store_data,
1295         .destructor     = afs_flat_call_destructor,
1296 };
1297
1298 /*
1299  * store a set of pages to a very large file
1300  */
1301 static int afs_fs_store_data64(struct afs_fs_cursor *fc,
1302                                struct address_space *mapping,
1303                                pgoff_t first, pgoff_t last,
1304                                unsigned offset, unsigned to,
1305                                loff_t size, loff_t pos, loff_t i_size)
1306 {
1307         struct afs_vnode *vnode = fc->vnode;
1308         struct afs_call *call;
1309         struct afs_net *net = afs_v2net(vnode);
1310         __be32 *bp;
1311
1312         _enter(",%x,{%llx:%llu},,",
1313                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1314
1315         call = afs_alloc_flat_call(net, &afs_RXFSStoreData64,
1316                                    (4 + 6 + 3 * 2) * 4,
1317                                    (21 + 6) * 4);
1318         if (!call)
1319                 return -ENOMEM;
1320
1321         call->key = fc->key;
1322         call->mapping = mapping;
1323         call->reply[0] = vnode;
1324         call->first = first;
1325         call->last = last;
1326         call->first_offset = offset;
1327         call->last_to = to;
1328         call->send_pages = true;
1329         call->expected_version = vnode->status.data_version + 1;
1330
1331         /* marshall the parameters */
1332         bp = call->request;
1333         *bp++ = htonl(FSSTOREDATA64);
1334         *bp++ = htonl(vnode->fid.vid);
1335         *bp++ = htonl(vnode->fid.vnode);
1336         *bp++ = htonl(vnode->fid.unique);
1337
1338         *bp++ = htonl(AFS_SET_MTIME); /* mask */
1339         *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1340         *bp++ = 0; /* owner */
1341         *bp++ = 0; /* group */
1342         *bp++ = 0; /* unix mode */
1343         *bp++ = 0; /* segment size */
1344
1345         *bp++ = htonl(pos >> 32);
1346         *bp++ = htonl((u32) pos);
1347         *bp++ = htonl(size >> 32);
1348         *bp++ = htonl((u32) size);
1349         *bp++ = htonl(i_size >> 32);
1350         *bp++ = htonl((u32) i_size);
1351
1352         trace_afs_make_fs_call(call, &vnode->fid);
1353         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1354 }
1355
1356 /*
1357  * store a set of pages
1358  */
1359 int afs_fs_store_data(struct afs_fs_cursor *fc, struct address_space *mapping,
1360                       pgoff_t first, pgoff_t last,
1361                       unsigned offset, unsigned to)
1362 {
1363         struct afs_vnode *vnode = fc->vnode;
1364         struct afs_call *call;
1365         struct afs_net *net = afs_v2net(vnode);
1366         loff_t size, pos, i_size;
1367         __be32 *bp;
1368
1369         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1370                 return yfs_fs_store_data(fc, mapping, first, last, offset, to);
1371
1372         _enter(",%x,{%llx:%llu},,",
1373                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1374
1375         size = (loff_t)to - (loff_t)offset;
1376         if (first != last)
1377                 size += (loff_t)(last - first) << PAGE_SHIFT;
1378         pos = (loff_t)first << PAGE_SHIFT;
1379         pos += offset;
1380
1381         i_size = i_size_read(&vnode->vfs_inode);
1382         if (pos + size > i_size)
1383                 i_size = size + pos;
1384
1385         _debug("size %llx, at %llx, i_size %llx",
1386                (unsigned long long) size, (unsigned long long) pos,
1387                (unsigned long long) i_size);
1388
1389         if (pos >> 32 || i_size >> 32 || size >> 32 || (pos + size) >> 32)
1390                 return afs_fs_store_data64(fc, mapping, first, last, offset, to,
1391                                            size, pos, i_size);
1392
1393         call = afs_alloc_flat_call(net, &afs_RXFSStoreData,
1394                                    (4 + 6 + 3) * 4,
1395                                    (21 + 6) * 4);
1396         if (!call)
1397                 return -ENOMEM;
1398
1399         call->key = fc->key;
1400         call->mapping = mapping;
1401         call->reply[0] = vnode;
1402         call->first = first;
1403         call->last = last;
1404         call->first_offset = offset;
1405         call->last_to = to;
1406         call->send_pages = true;
1407         call->expected_version = vnode->status.data_version + 1;
1408
1409         /* marshall the parameters */
1410         bp = call->request;
1411         *bp++ = htonl(FSSTOREDATA);
1412         *bp++ = htonl(vnode->fid.vid);
1413         *bp++ = htonl(vnode->fid.vnode);
1414         *bp++ = htonl(vnode->fid.unique);
1415
1416         *bp++ = htonl(AFS_SET_MTIME); /* mask */
1417         *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1418         *bp++ = 0; /* owner */
1419         *bp++ = 0; /* group */
1420         *bp++ = 0; /* unix mode */
1421         *bp++ = 0; /* segment size */
1422
1423         *bp++ = htonl(pos);
1424         *bp++ = htonl(size);
1425         *bp++ = htonl(i_size);
1426
1427         afs_use_fs_server(call, fc->cbi);
1428         trace_afs_make_fs_call(call, &vnode->fid);
1429         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1430 }
1431
1432 /*
1433  * deliver reply data to an FS.StoreStatus
1434  */
1435 static int afs_deliver_fs_store_status(struct afs_call *call)
1436 {
1437         struct afs_vnode *vnode = call->reply[0];
1438         const __be32 *bp;
1439         int ret;
1440
1441         _enter("");
1442
1443         ret = afs_transfer_reply(call);
1444         if (ret < 0)
1445                 return ret;
1446
1447         /* unmarshall the reply once we've received all of it */
1448         bp = call->buffer;
1449         ret = afs_decode_status(call, &bp, &vnode->status, vnode,
1450                                 &call->expected_version, NULL);
1451         if (ret < 0)
1452                 return ret;
1453         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
1454
1455         _leave(" = 0 [done]");
1456         return 0;
1457 }
1458
1459 /*
1460  * FS.StoreStatus operation type
1461  */
1462 static const struct afs_call_type afs_RXFSStoreStatus = {
1463         .name           = "FS.StoreStatus",
1464         .op             = afs_FS_StoreStatus,
1465         .deliver        = afs_deliver_fs_store_status,
1466         .destructor     = afs_flat_call_destructor,
1467 };
1468
1469 static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1470         .name           = "FS.StoreData",
1471         .op             = afs_FS_StoreData,
1472         .deliver        = afs_deliver_fs_store_status,
1473         .destructor     = afs_flat_call_destructor,
1474 };
1475
1476 static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1477         .name           = "FS.StoreData64",
1478         .op             = afs_FS_StoreData64,
1479         .deliver        = afs_deliver_fs_store_status,
1480         .destructor     = afs_flat_call_destructor,
1481 };
1482
1483 /*
1484  * set the attributes on a very large file, using FS.StoreData rather than
1485  * FS.StoreStatus so as to alter the file size also
1486  */
1487 static int afs_fs_setattr_size64(struct afs_fs_cursor *fc, struct iattr *attr)
1488 {
1489         struct afs_vnode *vnode = fc->vnode;
1490         struct afs_call *call;
1491         struct afs_net *net = afs_v2net(vnode);
1492         __be32 *bp;
1493
1494         _enter(",%x,{%llx:%llu},,",
1495                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1496
1497         ASSERT(attr->ia_valid & ATTR_SIZE);
1498
1499         call = afs_alloc_flat_call(net, &afs_RXFSStoreData64_as_Status,
1500                                    (4 + 6 + 3 * 2) * 4,
1501                                    (21 + 6) * 4);
1502         if (!call)
1503                 return -ENOMEM;
1504
1505         call->key = fc->key;
1506         call->reply[0] = vnode;
1507         call->expected_version = vnode->status.data_version + 1;
1508
1509         /* marshall the parameters */
1510         bp = call->request;
1511         *bp++ = htonl(FSSTOREDATA64);
1512         *bp++ = htonl(vnode->fid.vid);
1513         *bp++ = htonl(vnode->fid.vnode);
1514         *bp++ = htonl(vnode->fid.unique);
1515
1516         xdr_encode_AFS_StoreStatus(&bp, attr);
1517
1518         *bp++ = 0;                              /* position of start of write */
1519         *bp++ = 0;
1520         *bp++ = 0;                              /* size of write */
1521         *bp++ = 0;
1522         *bp++ = htonl(attr->ia_size >> 32);     /* new file length */
1523         *bp++ = htonl((u32) attr->ia_size);
1524
1525         afs_use_fs_server(call, fc->cbi);
1526         trace_afs_make_fs_call(call, &vnode->fid);
1527         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1528 }
1529
1530 /*
1531  * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus
1532  * so as to alter the file size also
1533  */
1534 static int afs_fs_setattr_size(struct afs_fs_cursor *fc, struct iattr *attr)
1535 {
1536         struct afs_vnode *vnode = fc->vnode;
1537         struct afs_call *call;
1538         struct afs_net *net = afs_v2net(vnode);
1539         __be32 *bp;
1540
1541         _enter(",%x,{%llx:%llu},,",
1542                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1543
1544         ASSERT(attr->ia_valid & ATTR_SIZE);
1545         if (attr->ia_size >> 32)
1546                 return afs_fs_setattr_size64(fc, attr);
1547
1548         call = afs_alloc_flat_call(net, &afs_RXFSStoreData_as_Status,
1549                                    (4 + 6 + 3) * 4,
1550                                    (21 + 6) * 4);
1551         if (!call)
1552                 return -ENOMEM;
1553
1554         call->key = fc->key;
1555         call->reply[0] = vnode;
1556         call->expected_version = vnode->status.data_version + 1;
1557
1558         /* marshall the parameters */
1559         bp = call->request;
1560         *bp++ = htonl(FSSTOREDATA);
1561         *bp++ = htonl(vnode->fid.vid);
1562         *bp++ = htonl(vnode->fid.vnode);
1563         *bp++ = htonl(vnode->fid.unique);
1564
1565         xdr_encode_AFS_StoreStatus(&bp, attr);
1566
1567         *bp++ = 0;                              /* position of start of write */
1568         *bp++ = 0;                              /* size of write */
1569         *bp++ = htonl(attr->ia_size);           /* new file length */
1570
1571         afs_use_fs_server(call, fc->cbi);
1572         trace_afs_make_fs_call(call, &vnode->fid);
1573         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1574 }
1575
1576 /*
1577  * set the attributes on a file, using FS.StoreData if there's a change in file
1578  * size, and FS.StoreStatus otherwise
1579  */
1580 int afs_fs_setattr(struct afs_fs_cursor *fc, struct iattr *attr)
1581 {
1582         struct afs_vnode *vnode = fc->vnode;
1583         struct afs_call *call;
1584         struct afs_net *net = afs_v2net(vnode);
1585         __be32 *bp;
1586
1587         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1588                 return yfs_fs_setattr(fc, attr);
1589
1590         if (attr->ia_valid & ATTR_SIZE)
1591                 return afs_fs_setattr_size(fc, attr);
1592
1593         _enter(",%x,{%llx:%llu},,",
1594                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1595
1596         call = afs_alloc_flat_call(net, &afs_RXFSStoreStatus,
1597                                    (4 + 6) * 4,
1598                                    (21 + 6) * 4);
1599         if (!call)
1600                 return -ENOMEM;
1601
1602         call->key = fc->key;
1603         call->reply[0] = vnode;
1604         call->expected_version = vnode->status.data_version;
1605
1606         /* marshall the parameters */
1607         bp = call->request;
1608         *bp++ = htonl(FSSTORESTATUS);
1609         *bp++ = htonl(vnode->fid.vid);
1610         *bp++ = htonl(vnode->fid.vnode);
1611         *bp++ = htonl(vnode->fid.unique);
1612
1613         xdr_encode_AFS_StoreStatus(&bp, attr);
1614
1615         afs_use_fs_server(call, fc->cbi);
1616         trace_afs_make_fs_call(call, &vnode->fid);
1617         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1618 }
1619
1620 /*
1621  * deliver reply data to an FS.GetVolumeStatus
1622  */
1623 static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1624 {
1625         const __be32 *bp;
1626         char *p;
1627         u32 size;
1628         int ret;
1629
1630         _enter("{%u}", call->unmarshall);
1631
1632         switch (call->unmarshall) {
1633         case 0:
1634                 call->unmarshall++;
1635                 afs_extract_to_buf(call, 12 * 4);
1636
1637                 /* extract the returned status record */
1638         case 1:
1639                 _debug("extract status");
1640                 ret = afs_extract_data(call, true);
1641                 if (ret < 0)
1642                         return ret;
1643
1644                 bp = call->buffer;
1645                 xdr_decode_AFSFetchVolumeStatus(&bp, call->reply[1]);
1646                 call->unmarshall++;
1647                 afs_extract_to_tmp(call);
1648
1649                 /* extract the volume name length */
1650         case 2:
1651                 ret = afs_extract_data(call, true);
1652                 if (ret < 0)
1653                         return ret;
1654
1655                 call->count = ntohl(call->tmp);
1656                 _debug("volname length: %u", call->count);
1657                 if (call->count >= AFSNAMEMAX)
1658                         return afs_protocol_error(call, -EBADMSG,
1659                                                   afs_eproto_volname_len);
1660                 size = (call->count + 3) & ~3; /* It's padded */
1661                 afs_extract_begin(call, call->reply[2], size);
1662                 call->unmarshall++;
1663
1664                 /* extract the volume name */
1665         case 3:
1666                 _debug("extract volname");
1667                 ret = afs_extract_data(call, true);
1668                 if (ret < 0)
1669                         return ret;
1670
1671                 p = call->reply[2];
1672                 p[call->count] = 0;
1673                 _debug("volname '%s'", p);
1674                 afs_extract_to_tmp(call);
1675                 call->unmarshall++;
1676
1677                 /* extract the offline message length */
1678         case 4:
1679                 ret = afs_extract_data(call, true);
1680                 if (ret < 0)
1681                         return ret;
1682
1683                 call->count = ntohl(call->tmp);
1684                 _debug("offline msg length: %u", call->count);
1685                 if (call->count >= AFSNAMEMAX)
1686                         return afs_protocol_error(call, -EBADMSG,
1687                                                   afs_eproto_offline_msg_len);
1688                 size = (call->count + 3) & ~3; /* It's padded */
1689                 afs_extract_begin(call, call->reply[2], size);
1690                 call->unmarshall++;
1691
1692                 /* extract the offline message */
1693         case 5:
1694                 _debug("extract offline");
1695                 ret = afs_extract_data(call, true);
1696                 if (ret < 0)
1697                         return ret;
1698
1699                 p = call->reply[2];
1700                 p[call->count] = 0;
1701                 _debug("offline '%s'", p);
1702
1703                 afs_extract_to_tmp(call);
1704                 call->unmarshall++;
1705
1706                 /* extract the message of the day length */
1707         case 6:
1708                 ret = afs_extract_data(call, true);
1709                 if (ret < 0)
1710                         return ret;
1711
1712                 call->count = ntohl(call->tmp);
1713                 _debug("motd length: %u", call->count);
1714                 if (call->count >= AFSNAMEMAX)
1715                         return afs_protocol_error(call, -EBADMSG,
1716                                                   afs_eproto_motd_len);
1717                 size = (call->count + 3) & ~3; /* It's padded */
1718                 afs_extract_begin(call, call->reply[2], size);
1719                 call->unmarshall++;
1720
1721                 /* extract the message of the day */
1722         case 7:
1723                 _debug("extract motd");
1724                 ret = afs_extract_data(call, false);
1725                 if (ret < 0)
1726                         return ret;
1727
1728                 p = call->reply[2];
1729                 p[call->count] = 0;
1730                 _debug("motd '%s'", p);
1731
1732                 call->unmarshall++;
1733
1734         case 8:
1735                 break;
1736         }
1737
1738         _leave(" = 0 [done]");
1739         return 0;
1740 }
1741
1742 /*
1743  * destroy an FS.GetVolumeStatus call
1744  */
1745 static void afs_get_volume_status_call_destructor(struct afs_call *call)
1746 {
1747         kfree(call->reply[2]);
1748         call->reply[2] = NULL;
1749         afs_flat_call_destructor(call);
1750 }
1751
1752 /*
1753  * FS.GetVolumeStatus operation type
1754  */
1755 static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1756         .name           = "FS.GetVolumeStatus",
1757         .op             = afs_FS_GetVolumeStatus,
1758         .deliver        = afs_deliver_fs_get_volume_status,
1759         .destructor     = afs_get_volume_status_call_destructor,
1760 };
1761
1762 /*
1763  * fetch the status of a volume
1764  */
1765 int afs_fs_get_volume_status(struct afs_fs_cursor *fc,
1766                              struct afs_volume_status *vs)
1767 {
1768         struct afs_vnode *vnode = fc->vnode;
1769         struct afs_call *call;
1770         struct afs_net *net = afs_v2net(vnode);
1771         __be32 *bp;
1772         void *tmpbuf;
1773
1774         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1775                 return yfs_fs_get_volume_status(fc, vs);
1776
1777         _enter("");
1778
1779         tmpbuf = kmalloc(AFSOPAQUEMAX, GFP_KERNEL);
1780         if (!tmpbuf)
1781                 return -ENOMEM;
1782
1783         call = afs_alloc_flat_call(net, &afs_RXFSGetVolumeStatus, 2 * 4, 12 * 4);
1784         if (!call) {
1785                 kfree(tmpbuf);
1786                 return -ENOMEM;
1787         }
1788
1789         call->key = fc->key;
1790         call->reply[0] = vnode;
1791         call->reply[1] = vs;
1792         call->reply[2] = tmpbuf;
1793
1794         /* marshall the parameters */
1795         bp = call->request;
1796         bp[0] = htonl(FSGETVOLUMESTATUS);
1797         bp[1] = htonl(vnode->fid.vid);
1798
1799         afs_use_fs_server(call, fc->cbi);
1800         trace_afs_make_fs_call(call, &vnode->fid);
1801         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1802 }
1803
1804 /*
1805  * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
1806  */
1807 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1808 {
1809         const __be32 *bp;
1810         int ret;
1811
1812         _enter("{%u}", call->unmarshall);
1813
1814         ret = afs_transfer_reply(call);
1815         if (ret < 0)
1816                 return ret;
1817
1818         /* unmarshall the reply once we've received all of it */
1819         bp = call->buffer;
1820         /* xdr_decode_AFSVolSync(&bp, call->reply[X]); */
1821
1822         _leave(" = 0 [done]");
1823         return 0;
1824 }
1825
1826 /*
1827  * FS.SetLock operation type
1828  */
1829 static const struct afs_call_type afs_RXFSSetLock = {
1830         .name           = "FS.SetLock",
1831         .op             = afs_FS_SetLock,
1832         .deliver        = afs_deliver_fs_xxxx_lock,
1833         .destructor     = afs_flat_call_destructor,
1834 };
1835
1836 /*
1837  * FS.ExtendLock operation type
1838  */
1839 static const struct afs_call_type afs_RXFSExtendLock = {
1840         .name           = "FS.ExtendLock",
1841         .op             = afs_FS_ExtendLock,
1842         .deliver        = afs_deliver_fs_xxxx_lock,
1843         .destructor     = afs_flat_call_destructor,
1844 };
1845
1846 /*
1847  * FS.ReleaseLock operation type
1848  */
1849 static const struct afs_call_type afs_RXFSReleaseLock = {
1850         .name           = "FS.ReleaseLock",
1851         .op             = afs_FS_ReleaseLock,
1852         .deliver        = afs_deliver_fs_xxxx_lock,
1853         .destructor     = afs_flat_call_destructor,
1854 };
1855
1856 /*
1857  * Set a lock on a file
1858  */
1859 int afs_fs_set_lock(struct afs_fs_cursor *fc, afs_lock_type_t type)
1860 {
1861         struct afs_vnode *vnode = fc->vnode;
1862         struct afs_call *call;
1863         struct afs_net *net = afs_v2net(vnode);
1864         __be32 *bp;
1865
1866         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1867                 return yfs_fs_set_lock(fc, type);
1868
1869         _enter("");
1870
1871         call = afs_alloc_flat_call(net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1872         if (!call)
1873                 return -ENOMEM;
1874
1875         call->key = fc->key;
1876         call->reply[0] = vnode;
1877
1878         /* marshall the parameters */
1879         bp = call->request;
1880         *bp++ = htonl(FSSETLOCK);
1881         *bp++ = htonl(vnode->fid.vid);
1882         *bp++ = htonl(vnode->fid.vnode);
1883         *bp++ = htonl(vnode->fid.unique);
1884         *bp++ = htonl(type);
1885
1886         afs_use_fs_server(call, fc->cbi);
1887         trace_afs_make_fs_call(call, &vnode->fid);
1888         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1889 }
1890
1891 /*
1892  * extend a lock on a file
1893  */
1894 int afs_fs_extend_lock(struct afs_fs_cursor *fc)
1895 {
1896         struct afs_vnode *vnode = fc->vnode;
1897         struct afs_call *call;
1898         struct afs_net *net = afs_v2net(vnode);
1899         __be32 *bp;
1900
1901         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1902                 return yfs_fs_extend_lock(fc);
1903
1904         _enter("");
1905
1906         call = afs_alloc_flat_call(net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1907         if (!call)
1908                 return -ENOMEM;
1909
1910         call->key = fc->key;
1911         call->reply[0] = vnode;
1912
1913         /* marshall the parameters */
1914         bp = call->request;
1915         *bp++ = htonl(FSEXTENDLOCK);
1916         *bp++ = htonl(vnode->fid.vid);
1917         *bp++ = htonl(vnode->fid.vnode);
1918         *bp++ = htonl(vnode->fid.unique);
1919
1920         afs_use_fs_server(call, fc->cbi);
1921         trace_afs_make_fs_call(call, &vnode->fid);
1922         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1923 }
1924
1925 /*
1926  * release a lock on a file
1927  */
1928 int afs_fs_release_lock(struct afs_fs_cursor *fc)
1929 {
1930         struct afs_vnode *vnode = fc->vnode;
1931         struct afs_call *call;
1932         struct afs_net *net = afs_v2net(vnode);
1933         __be32 *bp;
1934
1935         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1936                 return yfs_fs_release_lock(fc);
1937
1938         _enter("");
1939
1940         call = afs_alloc_flat_call(net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1941         if (!call)
1942                 return -ENOMEM;
1943
1944         call->key = fc->key;
1945         call->reply[0] = vnode;
1946
1947         /* marshall the parameters */
1948         bp = call->request;
1949         *bp++ = htonl(FSRELEASELOCK);
1950         *bp++ = htonl(vnode->fid.vid);
1951         *bp++ = htonl(vnode->fid.vnode);
1952         *bp++ = htonl(vnode->fid.unique);
1953
1954         afs_use_fs_server(call, fc->cbi);
1955         trace_afs_make_fs_call(call, &vnode->fid);
1956         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
1957 }
1958
1959 /*
1960  * Deliver reply data to an FS.GiveUpAllCallBacks operation.
1961  */
1962 static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1963 {
1964         return afs_transfer_reply(call);
1965 }
1966
1967 /*
1968  * FS.GiveUpAllCallBacks operation type
1969  */
1970 static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = {
1971         .name           = "FS.GiveUpAllCallBacks",
1972         .op             = afs_FS_GiveUpAllCallBacks,
1973         .deliver        = afs_deliver_fs_give_up_all_callbacks,
1974         .destructor     = afs_flat_call_destructor,
1975 };
1976
1977 /*
1978  * Flush all the callbacks we have on a server.
1979  */
1980 int afs_fs_give_up_all_callbacks(struct afs_net *net,
1981                                  struct afs_server *server,
1982                                  struct afs_addr_cursor *ac,
1983                                  struct key *key)
1984 {
1985         struct afs_call *call;
1986         __be32 *bp;
1987
1988         _enter("");
1989
1990         call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1991         if (!call)
1992                 return -ENOMEM;
1993
1994         call->key = key;
1995
1996         /* marshall the parameters */
1997         bp = call->request;
1998         *bp++ = htonl(FSGIVEUPALLCALLBACKS);
1999
2000         /* Can't take a ref on server */
2001         return afs_make_call(ac, call, GFP_NOFS, false);
2002 }
2003
2004 /*
2005  * Deliver reply data to an FS.GetCapabilities operation.
2006  */
2007 static int afs_deliver_fs_get_capabilities(struct afs_call *call)
2008 {
2009         u32 count;
2010         int ret;
2011
2012         _enter("{%u,%zu}", call->unmarshall, iov_iter_count(&call->iter));
2013
2014         switch (call->unmarshall) {
2015         case 0:
2016                 afs_extract_to_tmp(call);
2017                 call->unmarshall++;
2018
2019                 /* Extract the capabilities word count */
2020         case 1:
2021                 ret = afs_extract_data(call, true);
2022                 if (ret < 0)
2023                         return ret;
2024
2025                 count = ntohl(call->tmp);
2026
2027                 call->count = count;
2028                 call->count2 = count;
2029                 iov_iter_discard(&call->iter, READ, count * sizeof(__be32));
2030                 call->unmarshall++;
2031
2032                 /* Extract capabilities words */
2033         case 2:
2034                 ret = afs_extract_data(call, false);
2035                 if (ret < 0)
2036                         return ret;
2037
2038                 /* TODO: Examine capabilities */
2039
2040                 call->unmarshall++;
2041                 break;
2042         }
2043
2044         _leave(" = 0 [done]");
2045         return 0;
2046 }
2047
2048 static void afs_destroy_fs_get_capabilities(struct afs_call *call)
2049 {
2050         struct afs_server *server = call->reply[0];
2051
2052         afs_put_server(call->net, server);
2053         afs_flat_call_destructor(call);
2054 }
2055
2056 /*
2057  * FS.GetCapabilities operation type
2058  */
2059 static const struct afs_call_type afs_RXFSGetCapabilities = {
2060         .name           = "FS.GetCapabilities",
2061         .op             = afs_FS_GetCapabilities,
2062         .deliver        = afs_deliver_fs_get_capabilities,
2063         .done           = afs_fileserver_probe_result,
2064         .destructor     = afs_destroy_fs_get_capabilities,
2065 };
2066
2067 /*
2068  * Probe a fileserver for the capabilities that it supports.  This can
2069  * return up to 196 words.
2070  */
2071 int afs_fs_get_capabilities(struct afs_net *net,
2072                             struct afs_server *server,
2073                             struct afs_addr_cursor *ac,
2074                             struct key *key,
2075                             unsigned int server_index,
2076                             bool async)
2077 {
2078         struct afs_call *call;
2079         __be32 *bp;
2080
2081         _enter("");
2082
2083         call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
2084         if (!call)
2085                 return -ENOMEM;
2086
2087         call->key = key;
2088         call->reply[0] = afs_get_server(server);
2089         call->reply[1] = (void *)(long)server_index;
2090         call->upgrade = true;
2091         call->want_reply_time = true;
2092
2093         /* marshall the parameters */
2094         bp = call->request;
2095         *bp++ = htonl(FSGETCAPABILITIES);
2096
2097         /* Can't take a ref on server */
2098         trace_afs_make_fs_call(call, NULL);
2099         return afs_make_call(ac, call, GFP_NOFS, async);
2100 }
2101
2102 /*
2103  * Deliver reply data to an FS.FetchStatus with no vnode.
2104  */
2105 static int afs_deliver_fs_fetch_status(struct afs_call *call)
2106 {
2107         struct afs_file_status *status = call->reply[1];
2108         struct afs_callback *callback = call->reply[2];
2109         struct afs_volsync *volsync = call->reply[3];
2110         struct afs_fid *fid = call->reply[0];
2111         const __be32 *bp;
2112         int ret;
2113
2114         ret = afs_transfer_reply(call);
2115         if (ret < 0)
2116                 return ret;
2117
2118         _enter("{%llx:%llu}", fid->vid, fid->vnode);
2119
2120         /* unmarshall the reply once we've received all of it */
2121         bp = call->buffer;
2122         ret = afs_decode_status(call, &bp, status, NULL,
2123                                 &call->expected_version, NULL);
2124         if (ret < 0)
2125                 return ret;
2126         xdr_decode_AFSCallBack_raw(call, &bp, callback);
2127         xdr_decode_AFSVolSync(&bp, volsync);
2128
2129         _leave(" = 0 [done]");
2130         return 0;
2131 }
2132
2133 /*
2134  * FS.FetchStatus operation type
2135  */
2136 static const struct afs_call_type afs_RXFSFetchStatus = {
2137         .name           = "FS.FetchStatus",
2138         .op             = afs_FS_FetchStatus,
2139         .deliver        = afs_deliver_fs_fetch_status,
2140         .destructor     = afs_flat_call_destructor,
2141 };
2142
2143 /*
2144  * Fetch the status information for a fid without needing a vnode handle.
2145  */
2146 int afs_fs_fetch_status(struct afs_fs_cursor *fc,
2147                         struct afs_net *net,
2148                         struct afs_fid *fid,
2149                         struct afs_file_status *status,
2150                         struct afs_callback *callback,
2151                         struct afs_volsync *volsync)
2152 {
2153         struct afs_call *call;
2154         __be32 *bp;
2155
2156         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
2157                 return yfs_fs_fetch_status(fc, net, fid, status, callback, volsync);
2158
2159         _enter(",%x,{%llx:%llu},,",
2160                key_serial(fc->key), fid->vid, fid->vnode);
2161
2162         call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4);
2163         if (!call) {
2164                 fc->ac.error = -ENOMEM;
2165                 return -ENOMEM;
2166         }
2167
2168         call->key = fc->key;
2169         call->reply[0] = fid;
2170         call->reply[1] = status;
2171         call->reply[2] = callback;
2172         call->reply[3] = volsync;
2173         call->expected_version = 1; /* vnode->status.data_version */
2174         call->want_reply_time = true;
2175
2176         /* marshall the parameters */
2177         bp = call->request;
2178         bp[0] = htonl(FSFETCHSTATUS);
2179         bp[1] = htonl(fid->vid);
2180         bp[2] = htonl(fid->vnode);
2181         bp[3] = htonl(fid->unique);
2182
2183         call->cb_break = fc->cb_break;
2184         afs_use_fs_server(call, fc->cbi);
2185         trace_afs_make_fs_call(call, fid);
2186         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
2187 }
2188
2189 /*
2190  * Deliver reply data to an FS.InlineBulkStatus call
2191  */
2192 static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
2193 {
2194         struct afs_file_status *statuses;
2195         struct afs_callback *callbacks;
2196         struct afs_vnode *vnode = call->reply[0];
2197         const __be32 *bp;
2198         u32 tmp;
2199         int ret;
2200
2201         _enter("{%u}", call->unmarshall);
2202
2203         switch (call->unmarshall) {
2204         case 0:
2205                 afs_extract_to_tmp(call);
2206                 call->unmarshall++;
2207
2208                 /* Extract the file status count and array in two steps */
2209         case 1:
2210                 _debug("extract status count");
2211                 ret = afs_extract_data(call, true);
2212                 if (ret < 0)
2213                         return ret;
2214
2215                 tmp = ntohl(call->tmp);
2216                 _debug("status count: %u/%u", tmp, call->count2);
2217                 if (tmp != call->count2)
2218                         return afs_protocol_error(call, -EBADMSG,
2219                                                   afs_eproto_ibulkst_count);
2220
2221                 call->count = 0;
2222                 call->unmarshall++;
2223         more_counts:
2224                 afs_extract_to_buf(call, 21 * sizeof(__be32));
2225
2226         case 2:
2227                 _debug("extract status array %u", call->count);
2228                 ret = afs_extract_data(call, true);
2229                 if (ret < 0)
2230                         return ret;
2231
2232                 bp = call->buffer;
2233                 statuses = call->reply[1];
2234                 ret = afs_decode_status(call, &bp, &statuses[call->count],
2235                                         call->count == 0 ? vnode : NULL,
2236                                         NULL, NULL);
2237                 if (ret < 0)
2238                         return ret;
2239
2240                 call->count++;
2241                 if (call->count < call->count2)
2242                         goto more_counts;
2243
2244                 call->count = 0;
2245                 call->unmarshall++;
2246                 afs_extract_to_tmp(call);
2247
2248                 /* Extract the callback count and array in two steps */
2249         case 3:
2250                 _debug("extract CB count");
2251                 ret = afs_extract_data(call, true);
2252                 if (ret < 0)
2253                         return ret;
2254
2255                 tmp = ntohl(call->tmp);
2256                 _debug("CB count: %u", tmp);
2257                 if (tmp != call->count2)
2258                         return afs_protocol_error(call, -EBADMSG,
2259                                                   afs_eproto_ibulkst_cb_count);
2260                 call->count = 0;
2261                 call->unmarshall++;
2262         more_cbs:
2263                 afs_extract_to_buf(call, 3 * sizeof(__be32));
2264
2265         case 4:
2266                 _debug("extract CB array");
2267                 ret = afs_extract_data(call, true);
2268                 if (ret < 0)
2269                         return ret;
2270
2271                 _debug("unmarshall CB array");
2272                 bp = call->buffer;
2273                 callbacks = call->reply[2];
2274                 callbacks[call->count].version  = ntohl(bp[0]);
2275                 callbacks[call->count].expires_at = xdr_decode_expiry(call, ntohl(bp[1]));
2276                 callbacks[call->count].type     = ntohl(bp[2]);
2277                 statuses = call->reply[1];
2278                 if (call->count == 0 && vnode && statuses[0].abort_code == 0)
2279                         xdr_decode_AFSCallBack(call, vnode, &bp);
2280                 call->count++;
2281                 if (call->count < call->count2)
2282                         goto more_cbs;
2283
2284                 afs_extract_to_buf(call, 6 * sizeof(__be32));
2285                 call->unmarshall++;
2286
2287         case 5:
2288                 ret = afs_extract_data(call, false);
2289                 if (ret < 0)
2290                         return ret;
2291
2292                 bp = call->buffer;
2293                 xdr_decode_AFSVolSync(&bp, call->reply[3]);
2294
2295                 call->unmarshall++;
2296
2297         case 6:
2298                 break;
2299         }
2300
2301         _leave(" = 0 [done]");
2302         return 0;
2303 }
2304
2305 /*
2306  * FS.InlineBulkStatus operation type
2307  */
2308 static const struct afs_call_type afs_RXFSInlineBulkStatus = {
2309         .name           = "FS.InlineBulkStatus",
2310         .op             = afs_FS_InlineBulkStatus,
2311         .deliver        = afs_deliver_fs_inline_bulk_status,
2312         .destructor     = afs_flat_call_destructor,
2313 };
2314
2315 /*
2316  * Fetch the status information for up to 50 files
2317  */
2318 int afs_fs_inline_bulk_status(struct afs_fs_cursor *fc,
2319                               struct afs_net *net,
2320                               struct afs_fid *fids,
2321                               struct afs_file_status *statuses,
2322                               struct afs_callback *callbacks,
2323                               unsigned int nr_fids,
2324                               struct afs_volsync *volsync)
2325 {
2326         struct afs_call *call;
2327         __be32 *bp;
2328         int i;
2329
2330         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
2331                 return yfs_fs_inline_bulk_status(fc, net, fids, statuses, callbacks,
2332                                                  nr_fids, volsync);
2333
2334         _enter(",%x,{%llx:%llu},%u",
2335                key_serial(fc->key), fids[0].vid, fids[1].vnode, nr_fids);
2336
2337         call = afs_alloc_flat_call(net, &afs_RXFSInlineBulkStatus,
2338                                    (2 + nr_fids * 3) * 4,
2339                                    21 * 4);
2340         if (!call) {
2341                 fc->ac.error = -ENOMEM;
2342                 return -ENOMEM;
2343         }
2344
2345         call->key = fc->key;
2346         call->reply[0] = NULL; /* vnode for fid[0] */
2347         call->reply[1] = statuses;
2348         call->reply[2] = callbacks;
2349         call->reply[3] = volsync;
2350         call->count2 = nr_fids;
2351         call->want_reply_time = true;
2352
2353         /* marshall the parameters */
2354         bp = call->request;
2355         *bp++ = htonl(FSINLINEBULKSTATUS);
2356         *bp++ = htonl(nr_fids);
2357         for (i = 0; i < nr_fids; i++) {
2358                 *bp++ = htonl(fids[i].vid);
2359                 *bp++ = htonl(fids[i].vnode);
2360                 *bp++ = htonl(fids[i].unique);
2361         }
2362
2363         call->cb_break = fc->cb_break;
2364         afs_use_fs_server(call, fc->cbi);
2365         trace_afs_make_fs_call(call, &fids[0]);
2366         return afs_make_call(&fc->ac, call, GFP_NOFS, false);
2367 }