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