fs/afs/fsclient.c

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