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 "internal.h"
  17 #include "afs_fs.h"
  18
  19 /*
  20  * decode an AFSFid block
  21  */
  22 static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid)
  23 {
  24         const __be32 *bp = *_bp;
  25
  26         fid->vid                = ntohl(*bp++);
  27         fid->vnode              = ntohl(*bp++);
  28         fid->unique             = ntohl(*bp++);
  29         *_bp = bp;
  30 }
  31
  32 /*
  33  * decode an AFSFetchStatus block
  34  */
  35 static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
  36                                       struct afs_file_status *status,
  37                                       struct afs_vnode *vnode,
  38                                       afs_dataversion_t *store_version)
  39 {
  40         afs_dataversion_t expected_version;
  41         const __be32 *bp = *_bp;
  42         umode_t mode;
  43         u64 data_version, size;
  44         u32 changed = 0; /* becomes non-zero if ctime-type changes seen */
  45         kuid_t owner;
  46         kgid_t group;
  47
  48 #define EXTRACT(DST)                            \
  49         do {                                    \
  50                 u32 x = ntohl(*bp++);           \
  51                 changed |= DST - x;             \
  52                 DST = x;                        \
  53         } while (0)
  54
  55         status->if_version = ntohl(*bp++);
  56         EXTRACT(status->type);
  57         EXTRACT(status->nlink);
  58         size = ntohl(*bp++);
  59         data_version = ntohl(*bp++);
  60         EXTRACT(status->author);
  61         owner = make_kuid(&init_user_ns, ntohl(*bp++));
  62         changed |= !uid_eq(owner, status->owner);
  63         status->owner = owner;
  64         EXTRACT(status->caller_access); /* call ticket dependent */
  65         EXTRACT(status->anon_access);
  66         EXTRACT(status->mode);
  67         EXTRACT(status->parent.vnode);
  68         EXTRACT(status->parent.unique);
  69         bp++; /* seg size */
  70         status->mtime_client = ntohl(*bp++);
  71         status->mtime_server = ntohl(*bp++);
  72         group = make_kgid(&init_user_ns, ntohl(*bp++));
  73         changed |= !gid_eq(group, status->group);
  74         status->group = group;
  75         bp++; /* sync counter */
  76         data_version |= (u64) ntohl(*bp++) << 32;
  77         EXTRACT(status->lock_count);
  78         size |= (u64) ntohl(*bp++) << 32;
  79         bp++; /* spare 4 */
  80         *_bp = bp;
  81
  82         if (size != status->size) {
  83                 status->size = size;
  84                 changed |= true;
  85         }
  86         status->mode &= S_IALLUGO;
  87
  88         _debug("vnode time %lx, %lx",
  89                status->mtime_client, status->mtime_server);
  90
  91         if (vnode) {
  92                 status->parent.vid = vnode->fid.vid;
  93                 if (changed && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
  94                         _debug("vnode changed");
  95                         i_size_write(&vnode->vfs_inode, size);
  96                         vnode->vfs_inode.i_uid = status->owner;
  97                         vnode->vfs_inode.i_gid = status->group;
  98                         vnode->vfs_inode.i_generation = vnode->fid.unique;
  99                         set_nlink(&vnode->vfs_inode, status->nlink);
 100
 101                         mode = vnode->vfs_inode.i_mode;
 102                         mode &= ~S_IALLUGO;
 103                         mode |= status->mode;
 104                         barrier();
 105                         vnode->vfs_inode.i_mode = mode;
 106                 }
 107
 108                 vnode->vfs_inode.i_ctime.tv_sec = status->mtime_server;
 109                 vnode->vfs_inode.i_mtime        = vnode->vfs_inode.i_ctime;
 110                 vnode->vfs_inode.i_atime        = vnode->vfs_inode.i_ctime;
 111                 vnode->vfs_inode.i_version      = data_version;
 112         }
 113
 114         expected_version = status->data_version;
 115         if (store_version)
 116                 expected_version = *store_version;
 117
 118         if (expected_version != data_version) {
 119                 status->data_version = data_version;
 120                 if (vnode && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
 121                         _debug("vnode modified %llx on {%x:%u}",
 122                                (unsigned long long) data_version,
 123                                vnode->fid.vid, vnode->fid.vnode);
 124                         set_bit(AFS_VNODE_MODIFIED, &vnode->flags);
 125                         set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
 126                 }
 127         } else if (store_version) {
 128                 status->data_version = data_version;
 129         }
 130 }
 131
 132 /*
 133  * decode an AFSCallBack block
 134  */
 135 static void xdr_decode_AFSCallBack(const __be32 **_bp, struct afs_vnode *vnode)
 136 {
 137         const __be32 *bp = *_bp;
 138
 139         vnode->cb_version       = ntohl(*bp++);
 140         vnode->cb_expiry        = ntohl(*bp++);
 141         vnode->cb_type          = ntohl(*bp++);
 142         vnode->cb_expires       = vnode->cb_expiry + get_seconds();
 143         *_bp = bp;
 144 }
 145
 146 static void xdr_decode_AFSCallBack_raw(const __be32 **_bp,
 147                                        struct afs_callback *cb)
 148 {
 149         const __be32 *bp = *_bp;
 150
 151         cb->version     = ntohl(*bp++);
 152         cb->expiry      = ntohl(*bp++);
 153         cb->type        = ntohl(*bp++);
 154         *_bp = bp;
 155 }
 156
 157 /*
 158  * decode an AFSVolSync block
 159  */
 160 static void xdr_decode_AFSVolSync(const __be32 **_bp,
 161                                   struct afs_volsync *volsync)
 162 {
 163         const __be32 *bp = *_bp;
 164
 165         volsync->creation = ntohl(*bp++);
 166         bp++; /* spare2 */
 167         bp++; /* spare3 */
 168         bp++; /* spare4 */
 169         bp++; /* spare5 */
 170         bp++; /* spare6 */
 171         *_bp = bp;
 172 }
 173
 174 /*
 175  * encode the requested attributes into an AFSStoreStatus block
 176  */
 177 static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr)
 178 {
 179         __be32 *bp = *_bp;
 180         u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0;
 181
 182         mask = 0;
 183         if (attr->ia_valid & ATTR_MTIME) {
 184                 mask |= AFS_SET_MTIME;
 185                 mtime = attr->ia_mtime.tv_sec;
 186         }
 187
 188         if (attr->ia_valid & ATTR_UID) {
 189                 mask |= AFS_SET_OWNER;
 190                 owner = from_kuid(&init_user_ns, attr->ia_uid);
 191         }
 192
 193         if (attr->ia_valid & ATTR_GID) {
 194                 mask |= AFS_SET_GROUP;
 195                 group = from_kgid(&init_user_ns, attr->ia_gid);
 196         }
 197
 198         if (attr->ia_valid & ATTR_MODE) {
 199                 mask |= AFS_SET_MODE;
 200                 mode = attr->ia_mode & S_IALLUGO;
 201         }
 202
 203         *bp++ = htonl(mask);
 204         *bp++ = htonl(mtime);
 205         *bp++ = htonl(owner);
 206         *bp++ = htonl(group);
 207         *bp++ = htonl(mode);
 208         *bp++ = 0;              /* segment size */
 209         *_bp = bp;
 210 }
 211
 212 /*
 213  * decode an AFSFetchVolumeStatus block
 214  */
 215 static void xdr_decode_AFSFetchVolumeStatus(const __be32 **_bp,
 216                                             struct afs_volume_status *vs)
 217 {
 218         const __be32 *bp = *_bp;
 219
 220         vs->vid                 = ntohl(*bp++);
 221         vs->parent_id           = ntohl(*bp++);
 222         vs->online              = ntohl(*bp++);
 223         vs->in_service          = ntohl(*bp++);
 224         vs->blessed             = ntohl(*bp++);
 225         vs->needs_salvage       = ntohl(*bp++);
 226         vs->type                = ntohl(*bp++);
 227         vs->min_quota           = ntohl(*bp++);
 228         vs->max_quota           = ntohl(*bp++);
 229         vs->blocks_in_use       = ntohl(*bp++);
 230         vs->part_blocks_avail   = ntohl(*bp++);
 231         vs->part_max_blocks     = ntohl(*bp++);
 232         *_bp = bp;
 233 }
 234
 235 /*
 236  * deliver reply data to an FS.FetchStatus
 237  */
 238 static int afs_deliver_fs_fetch_status(struct afs_call *call)
 239 {
 240         struct afs_vnode *vnode = call->reply;
 241         const __be32 *bp;
 242         int ret;
 243
 244         _enter("");
 245
 246         ret = afs_transfer_reply(call);
 247         if (ret < 0)
 248                 return ret;
 249
 250         /* unmarshall the reply once we've received all of it */
 251         bp = call->buffer;
 252         xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
 253         xdr_decode_AFSCallBack(&bp, vnode);
 254         if (call->reply2)
 255                 xdr_decode_AFSVolSync(&bp, call->reply2);
 256
 257         _leave(" = 0 [done]");
 258         return 0;
 259 }
 260
 261 /*
 262  * FS.FetchStatus operation type
 263  */
 264 static const struct afs_call_type afs_RXFSFetchStatus = {
 265         .name           = "FS.FetchStatus",
 266         .deliver        = afs_deliver_fs_fetch_status,
 267         .abort_to_error = afs_abort_to_error,
 268         .destructor     = afs_flat_call_destructor,
 269 };
 270
 271 /*
 272  * fetch the status information for a file
 273  */
 274 int afs_fs_fetch_file_status(struct afs_server *server,
 275                              struct key *key,
 276                              struct afs_vnode *vnode,
 277                              struct afs_volsync *volsync,
 278                              const struct afs_wait_mode *wait_mode)
 279 {
 280         struct afs_call *call;
 281         __be32 *bp;
 282
 283         _enter(",%x,{%x:%u},,",
 284                key_serial(key), vnode->fid.vid, vnode->fid.vnode);
 285
 286         call = afs_alloc_flat_call(&afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4);
 287         if (!call)
 288                 return -ENOMEM;
 289
 290         call->key = key;
 291         call->reply = vnode;
 292         call->reply2 = volsync;
 293         call->service_id = FS_SERVICE;
 294         call->port = htons(AFS_FS_PORT);
 295
 296         /* marshall the parameters */
 297         bp = call->request;
 298         bp[0] = htonl(FSFETCHSTATUS);
 299         bp[1] = htonl(vnode->fid.vid);
 300         bp[2] = htonl(vnode->fid.vnode);
 301         bp[3] = htonl(vnode->fid.unique);
 302
 303         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 304 }
 305
 306 /*
 307  * deliver reply data to an FS.FetchData
 308  */
 309 static int afs_deliver_fs_fetch_data(struct afs_call *call)
 310 {
 311         struct afs_vnode *vnode = call->reply;
 312         const __be32 *bp;
 313         struct page *page;
 314         void *buffer;
 315         int ret;
 316
 317         _enter("{%u}", call->unmarshall);
 318
 319         switch (call->unmarshall) {
 320         case 0:
 321                 call->offset = 0;
 322                 call->unmarshall++;
 323                 if (call->operation_ID != FSFETCHDATA64) {
 324                         call->unmarshall++;
 325                         goto no_msw;
 326                 }
 327
 328                 /* extract the upper part of the returned data length of an
 329                  * FSFETCHDATA64 op (which should always be 0 using this
 330                  * client) */
 331         case 1:
 332                 _debug("extract data length (MSW)");
 333                 ret = afs_extract_data(call, &call->tmp, 4, true);
 334                 if (ret < 0)
 335                         return ret;
 336
 337                 call->count = ntohl(call->tmp);
 338                 _debug("DATA length MSW: %u", call->count);
 339                 if (call->count > 0)
 340                         return -EBADMSG;
 341                 call->offset = 0;
 342                 call->unmarshall++;
 343
 344         no_msw:
 345                 /* extract the returned data length */
 346         case 2:
 347                 _debug("extract data length");
 348                 ret = afs_extract_data(call, &call->tmp, 4, true);
 349                 if (ret < 0)
 350                         return ret;
 351
 352                 call->count = ntohl(call->tmp);
 353                 _debug("DATA length: %u", call->count);
 354                 if (call->count > PAGE_SIZE)
 355                         return -EBADMSG;
 356                 call->offset = 0;
 357                 call->unmarshall++;
 358
 359                 /* extract the returned data */
 360         case 3:
 361                 _debug("extract data");
 362                 if (call->count > 0) {
 363                         page = call->reply3;
 364                         buffer = kmap(page);
 365                         ret = afs_extract_data(call, buffer,
 366                                                call->count, true);
 367                         kunmap(buffer);
 368                         if (ret < 0)
 369                                 return ret;
 370                 }
 371
 372                 call->offset = 0;
 373                 call->unmarshall++;
 374
 375                 /* extract the metadata */
 376         case 4:
 377                 ret = afs_extract_data(call, call->buffer,
 378                                        (21 + 3 + 6) * 4, false);
 379                 if (ret < 0)
 380                         return ret;
 381
 382                 bp = call->buffer;
 383                 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
 384                 xdr_decode_AFSCallBack(&bp, vnode);
 385                 if (call->reply2)
 386                         xdr_decode_AFSVolSync(&bp, call->reply2);
 387
 388                 call->offset = 0;
 389                 call->unmarshall++;
 390
 391         case 5:
 392                 break;
 393         }
 394
 395         if (call->count < PAGE_SIZE) {
 396                 _debug("clear");
 397                 page = call->reply3;
 398                 buffer = kmap(page);
 399                 memset(buffer + call->count, 0, PAGE_SIZE - call->count);
 400                 kunmap(buffer);
 401         }
 402
 403         _leave(" = 0 [done]");
 404         return 0;
 405 }
 406
 407 /*
 408  * FS.FetchData operation type
 409  */
 410 static const struct afs_call_type afs_RXFSFetchData = {
 411         .name           = "FS.FetchData",
 412         .deliver        = afs_deliver_fs_fetch_data,
 413         .abort_to_error = afs_abort_to_error,
 414         .destructor     = afs_flat_call_destructor,
 415 };
 416
 417 static const struct afs_call_type afs_RXFSFetchData64 = {
 418         .name           = "FS.FetchData64",
 419         .deliver        = afs_deliver_fs_fetch_data,
 420         .abort_to_error = afs_abort_to_error,
 421         .destructor     = afs_flat_call_destructor,
 422 };
 423
 424 /*
 425  * fetch data from a very large file
 426  */
 427 static int afs_fs_fetch_data64(struct afs_server *server,
 428                                struct key *key,
 429                                struct afs_vnode *vnode,
 430                                off_t offset, size_t length,
 431                                struct page *buffer,
 432                                const struct afs_wait_mode *wait_mode)
 433 {
 434         struct afs_call *call;
 435         __be32 *bp;
 436
 437         _enter("");
 438
 439         ASSERTCMP(length, <, ULONG_MAX);
 440
 441         call = afs_alloc_flat_call(&afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
 442         if (!call)
 443                 return -ENOMEM;
 444
 445         call->key = key;
 446         call->reply = vnode;
 447         call->reply2 = NULL; /* volsync */
 448         call->reply3 = buffer;
 449         call->service_id = FS_SERVICE;
 450         call->port = htons(AFS_FS_PORT);
 451         call->operation_ID = FSFETCHDATA64;
 452
 453         /* marshall the parameters */
 454         bp = call->request;
 455         bp[0] = htonl(FSFETCHDATA64);
 456         bp[1] = htonl(vnode->fid.vid);
 457         bp[2] = htonl(vnode->fid.vnode);
 458         bp[3] = htonl(vnode->fid.unique);
 459         bp[4] = htonl(upper_32_bits(offset));
 460         bp[5] = htonl((u32) offset);
 461         bp[6] = 0;
 462         bp[7] = htonl((u32) length);
 463
 464         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 465 }
 466
 467 /*
 468  * fetch data from a file
 469  */
 470 int afs_fs_fetch_data(struct afs_server *server,
 471                       struct key *key,
 472                       struct afs_vnode *vnode,
 473                       off_t offset, size_t length,
 474                       struct page *buffer,
 475                       const struct afs_wait_mode *wait_mode)
 476 {
 477         struct afs_call *call;
 478         __be32 *bp;
 479
 480         if (upper_32_bits(offset) || upper_32_bits(offset + length))
 481                 return afs_fs_fetch_data64(server, key, vnode, offset, length,
 482                                            buffer, wait_mode);
 483
 484         _enter("");
 485
 486         call = afs_alloc_flat_call(&afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
 487         if (!call)
 488                 return -ENOMEM;
 489
 490         call->key = key;
 491         call->reply = vnode;
 492         call->reply2 = NULL; /* volsync */
 493         call->reply3 = buffer;
 494         call->service_id = FS_SERVICE;
 495         call->port = htons(AFS_FS_PORT);
 496         call->operation_ID = FSFETCHDATA;
 497
 498         /* marshall the parameters */
 499         bp = call->request;
 500         bp[0] = htonl(FSFETCHDATA);
 501         bp[1] = htonl(vnode->fid.vid);
 502         bp[2] = htonl(vnode->fid.vnode);
 503         bp[3] = htonl(vnode->fid.unique);
 504         bp[4] = htonl(offset);
 505         bp[5] = htonl(length);
 506
 507         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 508 }
 509
 510 /*
 511  * deliver reply data to an FS.GiveUpCallBacks
 512  */
 513 static int afs_deliver_fs_give_up_callbacks(struct afs_call *call)
 514 {
 515         _enter("");
 516
 517         /* shouldn't be any reply data */
 518         return afs_extract_data(call, NULL, 0, false);
 519 }
 520
 521 /*
 522  * FS.GiveUpCallBacks operation type
 523  */
 524 static const struct afs_call_type afs_RXFSGiveUpCallBacks = {
 525         .name           = "FS.GiveUpCallBacks",
 526         .deliver        = afs_deliver_fs_give_up_callbacks,
 527         .abort_to_error = afs_abort_to_error,
 528         .destructor     = afs_flat_call_destructor,
 529 };
 530
 531 /*
 532  * give up a set of callbacks
 533  * - the callbacks are held in the server->cb_break ring
 534  */
 535 int afs_fs_give_up_callbacks(struct afs_server *server,
 536                              const struct afs_wait_mode *wait_mode)
 537 {
 538         struct afs_call *call;
 539         size_t ncallbacks;
 540         __be32 *bp, *tp;
 541         int loop;
 542
 543         ncallbacks = CIRC_CNT(server->cb_break_head, server->cb_break_tail,
 544                               ARRAY_SIZE(server->cb_break));
 545
 546         _enter("{%zu},", ncallbacks);
 547
 548         if (ncallbacks == 0)
 549                 return 0;
 550         if (ncallbacks > AFSCBMAX)
 551                 ncallbacks = AFSCBMAX;
 552
 553         _debug("break %zu callbacks", ncallbacks);
 554
 555         call = afs_alloc_flat_call(&afs_RXFSGiveUpCallBacks,
 556                                    12 + ncallbacks * 6 * 4, 0);
 557         if (!call)
 558                 return -ENOMEM;
 559
 560         call->service_id = FS_SERVICE;
 561         call->port = htons(AFS_FS_PORT);
 562
 563         /* marshall the parameters */
 564         bp = call->request;
 565         tp = bp + 2 + ncallbacks * 3;
 566         *bp++ = htonl(FSGIVEUPCALLBACKS);
 567         *bp++ = htonl(ncallbacks);
 568         *tp++ = htonl(ncallbacks);
 569
 570         atomic_sub(ncallbacks, &server->cb_break_n);
 571         for (loop = ncallbacks; loop > 0; loop--) {
 572                 struct afs_callback *cb =
 573                         &server->cb_break[server->cb_break_tail];
 574
 575                 *bp++ = htonl(cb->fid.vid);
 576                 *bp++ = htonl(cb->fid.vnode);
 577                 *bp++ = htonl(cb->fid.unique);
 578                 *tp++ = htonl(cb->version);
 579                 *tp++ = htonl(cb->expiry);
 580                 *tp++ = htonl(cb->type);
 581                 smp_mb();
 582                 server->cb_break_tail =
 583                         (server->cb_break_tail + 1) &
 584                         (ARRAY_SIZE(server->cb_break) - 1);
 585         }
 586
 587         ASSERT(ncallbacks > 0);
 588         wake_up_nr(&server->cb_break_waitq, ncallbacks);
 589
 590         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 591 }
 592
 593 /*
 594  * deliver reply data to an FS.CreateFile or an FS.MakeDir
 595  */
 596 static int afs_deliver_fs_create_vnode(struct afs_call *call)
 597 {
 598         struct afs_vnode *vnode = call->reply;
 599         const __be32 *bp;
 600         int ret;
 601
 602         _enter("{%u}", call->unmarshall);
 603
 604         ret = afs_transfer_reply(call);
 605         if (ret < 0)
 606                 return ret;
 607
 608         /* unmarshall the reply once we've received all of it */
 609         bp = call->buffer;
 610         xdr_decode_AFSFid(&bp, call->reply2);
 611         xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL);
 612         xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
 613         xdr_decode_AFSCallBack_raw(&bp, call->reply4);
 614         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
 615
 616         _leave(" = 0 [done]");
 617         return 0;
 618 }
 619
 620 /*
 621  * FS.CreateFile and FS.MakeDir operation type
 622  */
 623 static const struct afs_call_type afs_RXFSCreateXXXX = {
 624         .name           = "FS.CreateXXXX",
 625         .deliver        = afs_deliver_fs_create_vnode,
 626         .abort_to_error = afs_abort_to_error,
 627         .destructor     = afs_flat_call_destructor,
 628 };
 629
 630 /*
 631  * create a file or make a directory
 632  */
 633 int afs_fs_create(struct afs_server *server,
 634                   struct key *key,
 635                   struct afs_vnode *vnode,
 636                   const char *name,
 637                   umode_t mode,
 638                   struct afs_fid *newfid,
 639                   struct afs_file_status *newstatus,
 640                   struct afs_callback *newcb,
 641                   const struct afs_wait_mode *wait_mode)
 642 {
 643         struct afs_call *call;
 644         size_t namesz, reqsz, padsz;
 645         __be32 *bp;
 646
 647         _enter("");
 648
 649         namesz = strlen(name);
 650         padsz = (4 - (namesz & 3)) & 3;
 651         reqsz = (5 * 4) + namesz + padsz + (6 * 4);
 652
 653         call = afs_alloc_flat_call(&afs_RXFSCreateXXXX, reqsz,
 654                                    (3 + 21 + 21 + 3 + 6) * 4);
 655         if (!call)
 656                 return -ENOMEM;
 657
 658         call->key = key;
 659         call->reply = vnode;
 660         call->reply2 = newfid;
 661         call->reply3 = newstatus;
 662         call->reply4 = newcb;
 663         call->service_id = FS_SERVICE;
 664         call->port = htons(AFS_FS_PORT);
 665
 666         /* marshall the parameters */
 667         bp = call->request;
 668         *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE);
 669         *bp++ = htonl(vnode->fid.vid);
 670         *bp++ = htonl(vnode->fid.vnode);
 671         *bp++ = htonl(vnode->fid.unique);
 672         *bp++ = htonl(namesz);
 673         memcpy(bp, name, namesz);
 674         bp = (void *) bp + namesz;
 675         if (padsz > 0) {
 676                 memset(bp, 0, padsz);
 677                 bp = (void *) bp + padsz;
 678         }
 679         *bp++ = htonl(AFS_SET_MODE);
 680         *bp++ = 0; /* mtime */
 681         *bp++ = 0; /* owner */
 682         *bp++ = 0; /* group */
 683         *bp++ = htonl(mode & S_IALLUGO); /* unix mode */
 684         *bp++ = 0; /* segment size */
 685
 686         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 687 }
 688
 689 /*
 690  * deliver reply data to an FS.RemoveFile or FS.RemoveDir
 691  */
 692 static int afs_deliver_fs_remove(struct afs_call *call)
 693 {
 694         struct afs_vnode *vnode = call->reply;
 695         const __be32 *bp;
 696         int ret;
 697
 698         _enter("{%u}", call->unmarshall);
 699
 700         ret = afs_transfer_reply(call);
 701         if (ret < 0)
 702                 return ret;
 703
 704         /* unmarshall the reply once we've received all of it */
 705         bp = call->buffer;
 706         xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
 707         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
 708
 709         _leave(" = 0 [done]");
 710         return 0;
 711 }
 712
 713 /*
 714  * FS.RemoveDir/FS.RemoveFile operation type
 715  */
 716 static const struct afs_call_type afs_RXFSRemoveXXXX = {
 717         .name           = "FS.RemoveXXXX",
 718         .deliver        = afs_deliver_fs_remove,
 719         .abort_to_error = afs_abort_to_error,
 720         .destructor     = afs_flat_call_destructor,
 721 };
 722
 723 /*
 724  * remove a file or directory
 725  */
 726 int afs_fs_remove(struct afs_server *server,
 727                   struct key *key,
 728                   struct afs_vnode *vnode,
 729                   const char *name,
 730                   bool isdir,
 731                   const struct afs_wait_mode *wait_mode)
 732 {
 733         struct afs_call *call;
 734         size_t namesz, reqsz, padsz;
 735         __be32 *bp;
 736
 737         _enter("");
 738
 739         namesz = strlen(name);
 740         padsz = (4 - (namesz & 3)) & 3;
 741         reqsz = (5 * 4) + namesz + padsz;
 742
 743         call = afs_alloc_flat_call(&afs_RXFSRemoveXXXX, reqsz, (21 + 6) * 4);
 744         if (!call)
 745                 return -ENOMEM;
 746
 747         call->key = key;
 748         call->reply = vnode;
 749         call->service_id = FS_SERVICE;
 750         call->port = htons(AFS_FS_PORT);
 751
 752         /* marshall the parameters */
 753         bp = call->request;
 754         *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE);
 755         *bp++ = htonl(vnode->fid.vid);
 756         *bp++ = htonl(vnode->fid.vnode);
 757         *bp++ = htonl(vnode->fid.unique);
 758         *bp++ = htonl(namesz);
 759         memcpy(bp, name, namesz);
 760         bp = (void *) bp + namesz;
 761         if (padsz > 0) {
 762                 memset(bp, 0, padsz);
 763                 bp = (void *) bp + padsz;
 764         }
 765
 766         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 767 }
 768
 769 /*
 770  * deliver reply data to an FS.Link
 771  */
 772 static int afs_deliver_fs_link(struct afs_call *call)
 773 {
 774         struct afs_vnode *dvnode = call->reply, *vnode = call->reply2;
 775         const __be32 *bp;
 776         int ret;
 777
 778         _enter("{%u}", call->unmarshall);
 779
 780         ret = afs_transfer_reply(call);
 781         if (ret < 0)
 782                 return ret;
 783
 784         /* unmarshall the reply once we've received all of it */
 785         bp = call->buffer;
 786         xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
 787         xdr_decode_AFSFetchStatus(&bp, &dvnode->status, dvnode, NULL);
 788         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
 789
 790         _leave(" = 0 [done]");
 791         return 0;
 792 }
 793
 794 /*
 795  * FS.Link operation type
 796  */
 797 static const struct afs_call_type afs_RXFSLink = {
 798         .name           = "FS.Link",
 799         .deliver        = afs_deliver_fs_link,
 800         .abort_to_error = afs_abort_to_error,
 801         .destructor     = afs_flat_call_destructor,
 802 };
 803
 804 /*
 805  * make a hard link
 806  */
 807 int afs_fs_link(struct afs_server *server,
 808                 struct key *key,
 809                 struct afs_vnode *dvnode,
 810                 struct afs_vnode *vnode,
 811                 const char *name,
 812                 const struct afs_wait_mode *wait_mode)
 813 {
 814         struct afs_call *call;
 815         size_t namesz, reqsz, padsz;
 816         __be32 *bp;
 817
 818         _enter("");
 819
 820         namesz = strlen(name);
 821         padsz = (4 - (namesz & 3)) & 3;
 822         reqsz = (5 * 4) + namesz + padsz + (3 * 4);
 823
 824         call = afs_alloc_flat_call(&afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
 825         if (!call)
 826                 return -ENOMEM;
 827
 828         call->key = key;
 829         call->reply = dvnode;
 830         call->reply2 = vnode;
 831         call->service_id = FS_SERVICE;
 832         call->port = htons(AFS_FS_PORT);
 833
 834         /* marshall the parameters */
 835         bp = call->request;
 836         *bp++ = htonl(FSLINK);
 837         *bp++ = htonl(dvnode->fid.vid);
 838         *bp++ = htonl(dvnode->fid.vnode);
 839         *bp++ = htonl(dvnode->fid.unique);
 840         *bp++ = htonl(namesz);
 841         memcpy(bp, name, namesz);
 842         bp = (void *) bp + namesz;
 843         if (padsz > 0) {
 844                 memset(bp, 0, padsz);
 845                 bp = (void *) bp + padsz;
 846         }
 847         *bp++ = htonl(vnode->fid.vid);
 848         *bp++ = htonl(vnode->fid.vnode);
 849         *bp++ = htonl(vnode->fid.unique);
 850
 851         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 852 }
 853
 854 /*
 855  * deliver reply data to an FS.Symlink
 856  */
 857 static int afs_deliver_fs_symlink(struct afs_call *call)
 858 {
 859         struct afs_vnode *vnode = call->reply;
 860         const __be32 *bp;
 861         int ret;
 862
 863         _enter("{%u}", call->unmarshall);
 864
 865         ret = afs_transfer_reply(call);
 866         if (ret < 0)
 867                 return ret;
 868
 869         /* unmarshall the reply once we've received all of it */
 870         bp = call->buffer;
 871         xdr_decode_AFSFid(&bp, call->reply2);
 872         xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL);
 873         xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
 874         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
 875
 876         _leave(" = 0 [done]");
 877         return 0;
 878 }
 879
 880 /*
 881  * FS.Symlink operation type
 882  */
 883 static const struct afs_call_type afs_RXFSSymlink = {
 884         .name           = "FS.Symlink",
 885         .deliver        = afs_deliver_fs_symlink,
 886         .abort_to_error = afs_abort_to_error,
 887         .destructor     = afs_flat_call_destructor,
 888 };
 889
 890 /*
 891  * create a symbolic link
 892  */
 893 int afs_fs_symlink(struct afs_server *server,
 894                    struct key *key,
 895                    struct afs_vnode *vnode,
 896                    const char *name,
 897                    const char *contents,
 898                    struct afs_fid *newfid,
 899                    struct afs_file_status *newstatus,
 900                    const struct afs_wait_mode *wait_mode)
 901 {
 902         struct afs_call *call;
 903         size_t namesz, reqsz, padsz, c_namesz, c_padsz;
 904         __be32 *bp;
 905
 906         _enter("");
 907
 908         namesz = strlen(name);
 909         padsz = (4 - (namesz & 3)) & 3;
 910
 911         c_namesz = strlen(contents);
 912         c_padsz = (4 - (c_namesz & 3)) & 3;
 913
 914         reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
 915
 916         call = afs_alloc_flat_call(&afs_RXFSSymlink, reqsz,
 917                                    (3 + 21 + 21 + 6) * 4);
 918         if (!call)
 919                 return -ENOMEM;
 920
 921         call->key = key;
 922         call->reply = vnode;
 923         call->reply2 = newfid;
 924         call->reply3 = newstatus;
 925         call->service_id = FS_SERVICE;
 926         call->port = htons(AFS_FS_PORT);
 927
 928         /* marshall the parameters */
 929         bp = call->request;
 930         *bp++ = htonl(FSSYMLINK);
 931         *bp++ = htonl(vnode->fid.vid);
 932         *bp++ = htonl(vnode->fid.vnode);
 933         *bp++ = htonl(vnode->fid.unique);
 934         *bp++ = htonl(namesz);
 935         memcpy(bp, name, namesz);
 936         bp = (void *) bp + namesz;
 937         if (padsz > 0) {
 938                 memset(bp, 0, padsz);
 939                 bp = (void *) bp + padsz;
 940         }
 941         *bp++ = htonl(c_namesz);
 942         memcpy(bp, contents, c_namesz);
 943         bp = (void *) bp + c_namesz;
 944         if (c_padsz > 0) {
 945                 memset(bp, 0, c_padsz);
 946                 bp = (void *) bp + c_padsz;
 947         }
 948         *bp++ = htonl(AFS_SET_MODE);
 949         *bp++ = 0; /* mtime */
 950         *bp++ = 0; /* owner */
 951         *bp++ = 0; /* group */
 952         *bp++ = htonl(S_IRWXUGO); /* unix mode */
 953         *bp++ = 0; /* segment size */
 954
 955         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 956 }
 957
 958 /*
 959  * deliver reply data to an FS.Rename
 960  */
 961 static int afs_deliver_fs_rename(struct afs_call *call)
 962 {
 963         struct afs_vnode *orig_dvnode = call->reply, *new_dvnode = call->reply2;
 964         const __be32 *bp;
 965         int ret;
 966
 967         _enter("{%u}", call->unmarshall);
 968
 969         ret = afs_transfer_reply(call);
 970         if (ret < 0)
 971                 return ret;
 972
 973         /* unmarshall the reply once we've received all of it */
 974         bp = call->buffer;
 975         xdr_decode_AFSFetchStatus(&bp, &orig_dvnode->status, orig_dvnode, NULL);
 976         if (new_dvnode != orig_dvnode)
 977                 xdr_decode_AFSFetchStatus(&bp, &new_dvnode->status, new_dvnode,
 978                                           NULL);
 979         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
 980
 981         _leave(" = 0 [done]");
 982         return 0;
 983 }
 984
 985 /*
 986  * FS.Rename operation type
 987  */
 988 static const struct afs_call_type afs_RXFSRename = {
 989         .name           = "FS.Rename",
 990         .deliver        = afs_deliver_fs_rename,
 991         .abort_to_error = afs_abort_to_error,
 992         .destructor     = afs_flat_call_destructor,
 993 };
 994
 995 /*
 996  * create a symbolic link
 997  */
 998 int afs_fs_rename(struct afs_server *server,
 999                   struct key *key,
1000                   struct afs_vnode *orig_dvnode,
1001                   const char *orig_name,
1002                   struct afs_vnode *new_dvnode,
1003                   const char *new_name,
1004                   const struct afs_wait_mode *wait_mode)
1005 {
1006         struct afs_call *call;
1007         size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
1008         __be32 *bp;
1009
1010         _enter("");
1011
1012         o_namesz = strlen(orig_name);
1013         o_padsz = (4 - (o_namesz & 3)) & 3;
1014
1015         n_namesz = strlen(new_name);
1016         n_padsz = (4 - (n_namesz & 3)) & 3;
1017
1018         reqsz = (4 * 4) +
1019                 4 + o_namesz + o_padsz +
1020                 (3 * 4) +
1021                 4 + n_namesz + n_padsz;
1022
1023         call = afs_alloc_flat_call(&afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
1024         if (!call)
1025                 return -ENOMEM;
1026
1027         call->key = key;
1028         call->reply = orig_dvnode;
1029         call->reply2 = new_dvnode;
1030         call->service_id = FS_SERVICE;
1031         call->port = htons(AFS_FS_PORT);
1032
1033         /* marshall the parameters */
1034         bp = call->request;
1035         *bp++ = htonl(FSRENAME);
1036         *bp++ = htonl(orig_dvnode->fid.vid);
1037         *bp++ = htonl(orig_dvnode->fid.vnode);
1038         *bp++ = htonl(orig_dvnode->fid.unique);
1039         *bp++ = htonl(o_namesz);
1040         memcpy(bp, orig_name, o_namesz);
1041         bp = (void *) bp + o_namesz;
1042         if (o_padsz > 0) {
1043                 memset(bp, 0, o_padsz);
1044                 bp = (void *) bp + o_padsz;
1045         }
1046
1047         *bp++ = htonl(new_dvnode->fid.vid);
1048         *bp++ = htonl(new_dvnode->fid.vnode);
1049         *bp++ = htonl(new_dvnode->fid.unique);
1050         *bp++ = htonl(n_namesz);
1051         memcpy(bp, new_name, n_namesz);
1052         bp = (void *) bp + n_namesz;
1053         if (n_padsz > 0) {
1054                 memset(bp, 0, n_padsz);
1055                 bp = (void *) bp + n_padsz;
1056         }
1057
1058         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1059 }
1060
1061 /*
1062  * deliver reply data to an FS.StoreData
1063  */
1064 static int afs_deliver_fs_store_data(struct afs_call *call)
1065 {
1066         struct afs_vnode *vnode = call->reply;
1067         const __be32 *bp;
1068         int ret;
1069
1070         _enter("");
1071
1072         ret = afs_transfer_reply(call);
1073         if (ret < 0)
1074                 return ret;
1075
1076         /* unmarshall the reply once we've received all of it */
1077         bp = call->buffer;
1078         xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode,
1079                                   &call->store_version);
1080         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
1081
1082         afs_pages_written_back(vnode, call);
1083
1084         _leave(" = 0 [done]");
1085         return 0;
1086 }
1087
1088 /*
1089  * FS.StoreData operation type
1090  */
1091 static const struct afs_call_type afs_RXFSStoreData = {
1092         .name           = "FS.StoreData",
1093         .deliver        = afs_deliver_fs_store_data,
1094         .abort_to_error = afs_abort_to_error,
1095         .destructor     = afs_flat_call_destructor,
1096 };
1097
1098 static const struct afs_call_type afs_RXFSStoreData64 = {
1099         .name           = "FS.StoreData64",
1100         .deliver        = afs_deliver_fs_store_data,
1101         .abort_to_error = afs_abort_to_error,
1102         .destructor     = afs_flat_call_destructor,
1103 };
1104
1105 /*
1106  * store a set of pages to a very large file
1107  */
1108 static int afs_fs_store_data64(struct afs_server *server,
1109                                struct afs_writeback *wb,
1110                                pgoff_t first, pgoff_t last,
1111                                unsigned offset, unsigned to,
1112                                loff_t size, loff_t pos, loff_t i_size,
1113                                const struct afs_wait_mode *wait_mode)
1114 {
1115         struct afs_vnode *vnode = wb->vnode;
1116         struct afs_call *call;
1117         __be32 *bp;
1118
1119         _enter(",%x,{%x:%u},,",
1120                key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode);
1121
1122         call = afs_alloc_flat_call(&afs_RXFSStoreData64,
1123                                    (4 + 6 + 3 * 2) * 4,
1124                                    (21 + 6) * 4);
1125         if (!call)
1126                 return -ENOMEM;
1127
1128         call->wb = wb;
1129         call->key = wb->key;
1130         call->reply = vnode;
1131         call->service_id = FS_SERVICE;
1132         call->port = htons(AFS_FS_PORT);
1133         call->mapping = vnode->vfs_inode.i_mapping;
1134         call->first = first;
1135         call->last = last;
1136         call->first_offset = offset;
1137         call->last_to = to;
1138         call->send_pages = true;
1139         call->store_version = vnode->status.data_version + 1;
1140
1141         /* marshall the parameters */
1142         bp = call->request;
1143         *bp++ = htonl(FSSTOREDATA64);
1144         *bp++ = htonl(vnode->fid.vid);
1145         *bp++ = htonl(vnode->fid.vnode);
1146         *bp++ = htonl(vnode->fid.unique);
1147
1148         *bp++ = 0; /* mask */
1149         *bp++ = 0; /* mtime */
1150         *bp++ = 0; /* owner */
1151         *bp++ = 0; /* group */
1152         *bp++ = 0; /* unix mode */
1153         *bp++ = 0; /* segment size */
1154
1155         *bp++ = htonl(pos >> 32);
1156         *bp++ = htonl((u32) pos);
1157         *bp++ = htonl(size >> 32);
1158         *bp++ = htonl((u32) size);
1159         *bp++ = htonl(i_size >> 32);
1160         *bp++ = htonl((u32) i_size);
1161
1162         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1163 }
1164
1165 /*
1166  * store a set of pages
1167  */
1168 int afs_fs_store_data(struct afs_server *server, struct afs_writeback *wb,
1169                       pgoff_t first, pgoff_t last,
1170                       unsigned offset, unsigned to,
1171                       const struct afs_wait_mode *wait_mode)
1172 {
1173         struct afs_vnode *vnode = wb->vnode;
1174         struct afs_call *call;
1175         loff_t size, pos, i_size;
1176         __be32 *bp;
1177
1178         _enter(",%x,{%x:%u},,",
1179                key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode);
1180
1181         size = to - offset;
1182         if (first != last)
1183                 size += (loff_t)(last - first) << PAGE_SHIFT;
1184         pos = (loff_t)first << PAGE_SHIFT;
1185         pos += offset;
1186
1187         i_size = i_size_read(&vnode->vfs_inode);
1188         if (pos + size > i_size)
1189                 i_size = size + pos;
1190
1191         _debug("size %llx, at %llx, i_size %llx",
1192                (unsigned long long) size, (unsigned long long) pos,
1193                (unsigned long long) i_size);
1194
1195         if (pos >> 32 || i_size >> 32 || size >> 32 || (pos + size) >> 32)
1196                 return afs_fs_store_data64(server, wb, first, last, offset, to,
1197                                            size, pos, i_size, wait_mode);
1198
1199         call = afs_alloc_flat_call(&afs_RXFSStoreData,
1200                                    (4 + 6 + 3) * 4,
1201                                    (21 + 6) * 4);
1202         if (!call)
1203                 return -ENOMEM;
1204
1205         call->wb = wb;
1206         call->key = wb->key;
1207         call->reply = vnode;
1208         call->service_id = FS_SERVICE;
1209         call->port = htons(AFS_FS_PORT);
1210         call->mapping = vnode->vfs_inode.i_mapping;
1211         call->first = first;
1212         call->last = last;
1213         call->first_offset = offset;
1214         call->last_to = to;
1215         call->send_pages = true;
1216         call->store_version = vnode->status.data_version + 1;
1217
1218         /* marshall the parameters */
1219         bp = call->request;
1220         *bp++ = htonl(FSSTOREDATA);
1221         *bp++ = htonl(vnode->fid.vid);
1222         *bp++ = htonl(vnode->fid.vnode);
1223         *bp++ = htonl(vnode->fid.unique);
1224
1225         *bp++ = 0; /* mask */
1226         *bp++ = 0; /* mtime */
1227         *bp++ = 0; /* owner */
1228         *bp++ = 0; /* group */
1229         *bp++ = 0; /* unix mode */
1230         *bp++ = 0; /* segment size */
1231
1232         *bp++ = htonl(pos);
1233         *bp++ = htonl(size);
1234         *bp++ = htonl(i_size);
1235
1236         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1237 }
1238
1239 /*
1240  * deliver reply data to an FS.StoreStatus
1241  */
1242 static int afs_deliver_fs_store_status(struct afs_call *call)
1243 {
1244         afs_dataversion_t *store_version;
1245         struct afs_vnode *vnode = call->reply;
1246         const __be32 *bp;
1247         int ret;
1248
1249         _enter("");
1250
1251         ret = afs_transfer_reply(call);
1252         if (ret < 0)
1253                 return ret;
1254
1255         /* unmarshall the reply once we've received all of it */
1256         store_version = NULL;
1257         if (call->operation_ID == FSSTOREDATA)
1258                 store_version = &call->store_version;
1259
1260         bp = call->buffer;
1261         xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, store_version);
1262         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
1263
1264         _leave(" = 0 [done]");
1265         return 0;
1266 }
1267
1268 /*
1269  * FS.StoreStatus operation type
1270  */
1271 static const struct afs_call_type afs_RXFSStoreStatus = {
1272         .name           = "FS.StoreStatus",
1273         .deliver        = afs_deliver_fs_store_status,
1274         .abort_to_error = afs_abort_to_error,
1275         .destructor     = afs_flat_call_destructor,
1276 };
1277
1278 static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1279         .name           = "FS.StoreData",
1280         .deliver        = afs_deliver_fs_store_status,
1281         .abort_to_error = afs_abort_to_error,
1282         .destructor     = afs_flat_call_destructor,
1283 };
1284
1285 static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1286         .name           = "FS.StoreData64",
1287         .deliver        = afs_deliver_fs_store_status,
1288         .abort_to_error = afs_abort_to_error,
1289         .destructor     = afs_flat_call_destructor,
1290 };
1291
1292 /*
1293  * set the attributes on a very large file, using FS.StoreData rather than
1294  * FS.StoreStatus so as to alter the file size also
1295  */
1296 static int afs_fs_setattr_size64(struct afs_server *server, struct key *key,
1297                                  struct afs_vnode *vnode, struct iattr *attr,
1298                                  const struct afs_wait_mode *wait_mode)
1299 {
1300         struct afs_call *call;
1301         __be32 *bp;
1302
1303         _enter(",%x,{%x:%u},,",
1304                key_serial(key), vnode->fid.vid, vnode->fid.vnode);
1305
1306         ASSERT(attr->ia_valid & ATTR_SIZE);
1307
1308         call = afs_alloc_flat_call(&afs_RXFSStoreData64_as_Status,
1309                                    (4 + 6 + 3 * 2) * 4,
1310                                    (21 + 6) * 4);
1311         if (!call)
1312                 return -ENOMEM;
1313
1314         call->key = key;
1315         call->reply = vnode;
1316         call->service_id = FS_SERVICE;
1317         call->port = htons(AFS_FS_PORT);
1318         call->store_version = vnode->status.data_version + 1;
1319         call->operation_ID = FSSTOREDATA;
1320
1321         /* marshall the parameters */
1322         bp = call->request;
1323         *bp++ = htonl(FSSTOREDATA64);
1324         *bp++ = htonl(vnode->fid.vid);
1325         *bp++ = htonl(vnode->fid.vnode);
1326         *bp++ = htonl(vnode->fid.unique);
1327
1328         xdr_encode_AFS_StoreStatus(&bp, attr);
1329
1330         *bp++ = 0;                              /* position of start of write */
1331         *bp++ = 0;
1332         *bp++ = 0;                              /* size of write */
1333         *bp++ = 0;
1334         *bp++ = htonl(attr->ia_size >> 32);     /* new file length */
1335         *bp++ = htonl((u32) attr->ia_size);
1336
1337         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1338 }
1339
1340 /*
1341  * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus
1342  * so as to alter the file size also
1343  */
1344 static int afs_fs_setattr_size(struct afs_server *server, struct key *key,
1345                                struct afs_vnode *vnode, struct iattr *attr,
1346                                const struct afs_wait_mode *wait_mode)
1347 {
1348         struct afs_call *call;
1349         __be32 *bp;
1350
1351         _enter(",%x,{%x:%u},,",
1352                key_serial(key), vnode->fid.vid, vnode->fid.vnode);
1353
1354         ASSERT(attr->ia_valid & ATTR_SIZE);
1355         if (attr->ia_size >> 32)
1356                 return afs_fs_setattr_size64(server, key, vnode, attr,
1357                                              wait_mode);
1358
1359         call = afs_alloc_flat_call(&afs_RXFSStoreData_as_Status,
1360                                    (4 + 6 + 3) * 4,
1361                                    (21 + 6) * 4);
1362         if (!call)
1363                 return -ENOMEM;
1364
1365         call->key = key;
1366         call->reply = vnode;
1367         call->service_id = FS_SERVICE;
1368         call->port = htons(AFS_FS_PORT);
1369         call->store_version = vnode->status.data_version + 1;
1370         call->operation_ID = FSSTOREDATA;
1371
1372         /* marshall the parameters */
1373         bp = call->request;
1374         *bp++ = htonl(FSSTOREDATA);
1375         *bp++ = htonl(vnode->fid.vid);
1376         *bp++ = htonl(vnode->fid.vnode);
1377         *bp++ = htonl(vnode->fid.unique);
1378
1379         xdr_encode_AFS_StoreStatus(&bp, attr);
1380
1381         *bp++ = 0;                              /* position of start of write */
1382         *bp++ = 0;                              /* size of write */
1383         *bp++ = htonl(attr->ia_size);           /* new file length */
1384
1385         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1386 }
1387
1388 /*
1389  * set the attributes on a file, using FS.StoreData if there's a change in file
1390  * size, and FS.StoreStatus otherwise
1391  */
1392 int afs_fs_setattr(struct afs_server *server, struct key *key,
1393                    struct afs_vnode *vnode, struct iattr *attr,
1394                    const struct afs_wait_mode *wait_mode)
1395 {
1396         struct afs_call *call;
1397         __be32 *bp;
1398
1399         if (attr->ia_valid & ATTR_SIZE)
1400                 return afs_fs_setattr_size(server, key, vnode, attr,
1401                                            wait_mode);
1402
1403         _enter(",%x,{%x:%u},,",
1404                key_serial(key), vnode->fid.vid, vnode->fid.vnode);
1405
1406         call = afs_alloc_flat_call(&afs_RXFSStoreStatus,
1407                                    (4 + 6) * 4,
1408                                    (21 + 6) * 4);
1409         if (!call)
1410                 return -ENOMEM;
1411
1412         call->key = key;
1413         call->reply = vnode;
1414         call->service_id = FS_SERVICE;
1415         call->port = htons(AFS_FS_PORT);
1416         call->operation_ID = FSSTORESTATUS;
1417
1418         /* marshall the parameters */
1419         bp = call->request;
1420         *bp++ = htonl(FSSTORESTATUS);
1421         *bp++ = htonl(vnode->fid.vid);
1422         *bp++ = htonl(vnode->fid.vnode);
1423         *bp++ = htonl(vnode->fid.unique);
1424
1425         xdr_encode_AFS_StoreStatus(&bp, attr);
1426
1427         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1428 }
1429
1430 /*
1431  * deliver reply data to an FS.GetVolumeStatus
1432  */
1433 static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1434 {
1435         const __be32 *bp;
1436         char *p;
1437         int ret;
1438
1439         _enter("{%u}", call->unmarshall);
1440
1441         switch (call->unmarshall) {
1442         case 0:
1443                 call->offset = 0;
1444                 call->unmarshall++;
1445
1446                 /* extract the returned status record */
1447         case 1:
1448                 _debug("extract status");
1449                 ret = afs_extract_data(call, call->buffer,
1450                                        12 * 4, true);
1451                 if (ret < 0)
1452                         return ret;
1453
1454                 bp = call->buffer;
1455                 xdr_decode_AFSFetchVolumeStatus(&bp, call->reply2);
1456                 call->offset = 0;
1457                 call->unmarshall++;
1458
1459                 /* extract the volume name length */
1460         case 2:
1461                 ret = afs_extract_data(call, &call->tmp, 4, true);
1462                 if (ret < 0)
1463                         return ret;
1464
1465                 call->count = ntohl(call->tmp);
1466                 _debug("volname length: %u", call->count);
1467                 if (call->count >= AFSNAMEMAX)
1468                         return -EBADMSG;
1469                 call->offset = 0;
1470                 call->unmarshall++;
1471
1472                 /* extract the volume name */
1473         case 3:
1474                 _debug("extract volname");
1475                 if (call->count > 0) {
1476                         ret = afs_extract_data(call, call->reply3,
1477                                                call->count, true);
1478                         if (ret < 0)
1479                                 return ret;
1480                 }
1481
1482                 p = call->reply3;
1483                 p[call->count] = 0;
1484                 _debug("volname '%s'", p);
1485
1486                 call->offset = 0;
1487                 call->unmarshall++;
1488
1489                 /* extract the volume name padding */
1490                 if ((call->count & 3) == 0) {
1491                         call->unmarshall++;
1492                         goto no_volname_padding;
1493                 }
1494                 call->count = 4 - (call->count & 3);
1495
1496         case 4:
1497                 ret = afs_extract_data(call, call->buffer,
1498                                        call->count, true);
1499                 if (ret < 0)
1500                         return ret;
1501
1502                 call->offset = 0;
1503                 call->unmarshall++;
1504         no_volname_padding:
1505
1506                 /* extract the offline message length */
1507         case 5:
1508                 ret = afs_extract_data(call, &call->tmp, 4, true);
1509                 if (ret < 0)
1510                         return ret;
1511
1512                 call->count = ntohl(call->tmp);
1513                 _debug("offline msg length: %u", call->count);
1514                 if (call->count >= AFSNAMEMAX)
1515                         return -EBADMSG;
1516                 call->offset = 0;
1517                 call->unmarshall++;
1518
1519                 /* extract the offline message */
1520         case 6:
1521                 _debug("extract offline");
1522                 if (call->count > 0) {
1523                         ret = afs_extract_data(call, call->reply3,
1524                                                call->count, true);
1525                         if (ret < 0)
1526                                 return ret;
1527                 }
1528
1529                 p = call->reply3;
1530                 p[call->count] = 0;
1531                 _debug("offline '%s'", p);
1532
1533                 call->offset = 0;
1534                 call->unmarshall++;
1535
1536                 /* extract the offline message padding */
1537                 if ((call->count & 3) == 0) {
1538                         call->unmarshall++;
1539                         goto no_offline_padding;
1540                 }
1541                 call->count = 4 - (call->count & 3);
1542
1543         case 7:
1544                 ret = afs_extract_data(call, call->buffer,
1545                                        call->count, true);
1546                 if (ret < 0)
1547                         return ret;
1548
1549                 call->offset = 0;
1550                 call->unmarshall++;
1551         no_offline_padding:
1552
1553                 /* extract the message of the day length */
1554         case 8:
1555                 ret = afs_extract_data(call, &call->tmp, 4, true);
1556                 if (ret < 0)
1557                         return ret;
1558
1559                 call->count = ntohl(call->tmp);
1560                 _debug("motd length: %u", call->count);
1561                 if (call->count >= AFSNAMEMAX)
1562                         return -EBADMSG;
1563                 call->offset = 0;
1564                 call->unmarshall++;
1565
1566                 /* extract the message of the day */
1567         case 9:
1568                 _debug("extract motd");
1569                 if (call->count > 0) {
1570                         ret = afs_extract_data(call, call->reply3,
1571                                                call->count, true);
1572                         if (ret < 0)
1573                                 return ret;
1574                 }
1575
1576                 p = call->reply3;
1577                 p[call->count] = 0;
1578                 _debug("motd '%s'", p);
1579
1580                 call->offset = 0;
1581                 call->unmarshall++;
1582
1583                 /* extract the message of the day padding */
1584                 call->count = (4 - (call->count & 3)) & 3;
1585
1586         case 10:
1587                 ret = afs_extract_data(call, call->buffer,
1588                                        call->count, false);
1589                 if (ret < 0)
1590                         return ret;
1591
1592                 call->offset = 0;
1593                 call->unmarshall++;
1594         case 11:
1595                 break;
1596         }
1597
1598         _leave(" = 0 [done]");
1599         return 0;
1600 }
1601
1602 /*
1603  * destroy an FS.GetVolumeStatus call
1604  */
1605 static void afs_get_volume_status_call_destructor(struct afs_call *call)
1606 {
1607         kfree(call->reply3);
1608         call->reply3 = NULL;
1609         afs_flat_call_destructor(call);
1610 }
1611
1612 /*
1613  * FS.GetVolumeStatus operation type
1614  */
1615 static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1616         .name           = "FS.GetVolumeStatus",
1617         .deliver        = afs_deliver_fs_get_volume_status,
1618         .abort_to_error = afs_abort_to_error,
1619         .destructor     = afs_get_volume_status_call_destructor,
1620 };
1621
1622 /*
1623  * fetch the status of a volume
1624  */
1625 int afs_fs_get_volume_status(struct afs_server *server,
1626                              struct key *key,
1627                              struct afs_vnode *vnode,
1628                              struct afs_volume_status *vs,
1629                              const struct afs_wait_mode *wait_mode)
1630 {
1631         struct afs_call *call;
1632         __be32 *bp;
1633         void *tmpbuf;
1634
1635         _enter("");
1636
1637         tmpbuf = kmalloc(AFSOPAQUEMAX, GFP_KERNEL);
1638         if (!tmpbuf)
1639                 return -ENOMEM;
1640
1641         call = afs_alloc_flat_call(&afs_RXFSGetVolumeStatus, 2 * 4, 12 * 4);
1642         if (!call) {
1643                 kfree(tmpbuf);
1644                 return -ENOMEM;
1645         }
1646
1647         call->key = key;
1648         call->reply = vnode;
1649         call->reply2 = vs;
1650         call->reply3 = tmpbuf;
1651         call->service_id = FS_SERVICE;
1652         call->port = htons(AFS_FS_PORT);
1653
1654         /* marshall the parameters */
1655         bp = call->request;
1656         bp[0] = htonl(FSGETVOLUMESTATUS);
1657         bp[1] = htonl(vnode->fid.vid);
1658
1659         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1660 }
1661
1662 /*
1663  * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
1664  */
1665 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1666 {
1667         const __be32 *bp;
1668         int ret;
1669
1670         _enter("{%u}", call->unmarshall);
1671
1672         ret = afs_transfer_reply(call);
1673         if (ret < 0)
1674                 return ret;
1675
1676         /* unmarshall the reply once we've received all of it */
1677         bp = call->buffer;
1678         /* xdr_decode_AFSVolSync(&bp, call->replyX); */
1679
1680         _leave(" = 0 [done]");
1681         return 0;
1682 }
1683
1684 /*
1685  * FS.SetLock operation type
1686  */
1687 static const struct afs_call_type afs_RXFSSetLock = {
1688         .name           = "FS.SetLock",
1689         .deliver        = afs_deliver_fs_xxxx_lock,
1690         .abort_to_error = afs_abort_to_error,
1691         .destructor     = afs_flat_call_destructor,
1692 };
1693
1694 /*
1695  * FS.ExtendLock operation type
1696  */
1697 static const struct afs_call_type afs_RXFSExtendLock = {
1698         .name           = "FS.ExtendLock",
1699         .deliver        = afs_deliver_fs_xxxx_lock,
1700         .abort_to_error = afs_abort_to_error,
1701         .destructor     = afs_flat_call_destructor,
1702 };
1703
1704 /*
1705  * FS.ReleaseLock operation type
1706  */
1707 static const struct afs_call_type afs_RXFSReleaseLock = {
1708         .name           = "FS.ReleaseLock",
1709         .deliver        = afs_deliver_fs_xxxx_lock,
1710         .abort_to_error = afs_abort_to_error,
1711         .destructor     = afs_flat_call_destructor,
1712 };
1713
1714 /*
1715  * get a lock on a file
1716  */
1717 int afs_fs_set_lock(struct afs_server *server,
1718                     struct key *key,
1719                     struct afs_vnode *vnode,
1720                     afs_lock_type_t type,
1721                     const struct afs_wait_mode *wait_mode)
1722 {
1723         struct afs_call *call;
1724         __be32 *bp;
1725
1726         _enter("");
1727
1728         call = afs_alloc_flat_call(&afs_RXFSSetLock, 5 * 4, 6 * 4);
1729         if (!call)
1730                 return -ENOMEM;
1731
1732         call->key = key;
1733         call->reply = vnode;
1734         call->service_id = FS_SERVICE;
1735         call->port = htons(AFS_FS_PORT);
1736
1737         /* marshall the parameters */
1738         bp = call->request;
1739         *bp++ = htonl(FSSETLOCK);
1740         *bp++ = htonl(vnode->fid.vid);
1741         *bp++ = htonl(vnode->fid.vnode);
1742         *bp++ = htonl(vnode->fid.unique);
1743         *bp++ = htonl(type);
1744
1745         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1746 }
1747
1748 /*
1749  * extend a lock on a file
1750  */
1751 int afs_fs_extend_lock(struct afs_server *server,
1752                        struct key *key,
1753                        struct afs_vnode *vnode,
1754                        const struct afs_wait_mode *wait_mode)
1755 {
1756         struct afs_call *call;
1757         __be32 *bp;
1758
1759         _enter("");
1760
1761         call = afs_alloc_flat_call(&afs_RXFSExtendLock, 4 * 4, 6 * 4);
1762         if (!call)
1763                 return -ENOMEM;
1764
1765         call->key = key;
1766         call->reply = vnode;
1767         call->service_id = FS_SERVICE;
1768         call->port = htons(AFS_FS_PORT);
1769
1770         /* marshall the parameters */
1771         bp = call->request;
1772         *bp++ = htonl(FSEXTENDLOCK);
1773         *bp++ = htonl(vnode->fid.vid);
1774         *bp++ = htonl(vnode->fid.vnode);
1775         *bp++ = htonl(vnode->fid.unique);
1776
1777         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1778 }
1779
1780 /*
1781  * release a lock on a file
1782  */
1783 int afs_fs_release_lock(struct afs_server *server,
1784                         struct key *key,
1785                         struct afs_vnode *vnode,
1786                         const struct afs_wait_mode *wait_mode)
1787 {
1788         struct afs_call *call;
1789         __be32 *bp;
1790
1791         _enter("");
1792
1793         call = afs_alloc_flat_call(&afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1794         if (!call)
1795                 return -ENOMEM;
1796
1797         call->key = key;
1798         call->reply = vnode;
1799         call->service_id = FS_SERVICE;
1800         call->port = htons(AFS_FS_PORT);
1801
1802         /* marshall the parameters */
1803         bp = call->request;
1804         *bp++ = htonl(FSRELEASELOCK);
1805         *bp++ = htonl(vnode->fid.vid);
1806         *bp++ = htonl(vnode->fid.vnode);
1807         *bp++ = htonl(vnode->fid.unique);
1808
1809         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
1810 }