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