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