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