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 <linux/iversion.h>
  17 #include "internal.h"
  18 #include "afs_fs.h"
  19 #include "xdr_fs.h"
  20 #include "protocol_yfs.h"
  21
  22 static const struct afs_fid afs_zero_fid;
  23
  24 static inline void afs_use_fs_server(struct afs_call *call, struct afs_cb_interest *cbi)
  25 {
  26         call->cbi = afs_get_cb_interest(cbi);
  27 }
  28
  29 /*
  30  * decode an AFSFid block
  31  */
  32 static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid)
  33 {
  34         const __be32 *bp = *_bp;
  35
  36         fid->vid                = ntohl(*bp++);
  37         fid->vnode              = ntohl(*bp++);
  38         fid->unique             = ntohl(*bp++);
  39         *_bp = bp;
  40 }
  41
  42 /*
  43  * Dump a bad file status record.
  44  */
  45 static void xdr_dump_bad(const __be32 *bp)
  46 {
  47         __be32 x[4];
  48         int i;
  49
  50         pr_notice("AFS XDR: Bad status record\n");
  51         for (i = 0; i < 5 * 4 * 4; i += 16) {
  52                 memcpy(x, bp, 16);
  53                 bp += 4;
  54                 pr_notice("%03x: %08x %08x %08x %08x\n",
  55                           i, ntohl(x[0]), ntohl(x[1]), ntohl(x[2]), ntohl(x[3]));
  56         }
  57
  58         memcpy(x, bp, 4);
  59         pr_notice("0x50: %08x\n", ntohl(x[0]));
  60 }
  61
  62 /*
  63  * decode an AFSFetchStatus block
  64  */
  65 static int xdr_decode_AFSFetchStatus(const __be32 **_bp,
  66                                      struct afs_call *call,
  67                                      struct afs_status_cb *scb)
  68 {
  69         const struct afs_xdr_AFSFetchStatus *xdr = (const void *)*_bp;
  70         struct afs_file_status *status = &scb->status;
  71         bool inline_error = (call->operation_ID == afs_FS_InlineBulkStatus);
  72         u64 data_version, size;
  73         u32 type, abort_code;
  74
  75         abort_code = ntohl(xdr->abort_code);
  76
  77         if (xdr->if_version != htonl(AFS_FSTATUS_VERSION)) {
  78                 if (xdr->if_version == htonl(0) &&
  79                     abort_code != 0 &&
  80                     inline_error) {
  81                         /* The OpenAFS fileserver has a bug in FS.InlineBulkStatus
  82                          * whereby it doesn't set the interface version in the error
  83                          * case.
  84                          */
  85                         status->abort_code = abort_code;
  86                         scb->have_error = true;
  87                         return 0;
  88                 }
  89
  90                 pr_warn("Unknown AFSFetchStatus version %u\n", ntohl(xdr->if_version));
  91                 goto bad;
  92         }
  93
  94         if (abort_code != 0 && inline_error) {
  95                 status->abort_code = abort_code;
  96                 return 0;
  97         }
  98
  99         type = ntohl(xdr->type);
 100         switch (type) {
 101         case AFS_FTYPE_FILE:
 102         case AFS_FTYPE_DIR:
 103         case AFS_FTYPE_SYMLINK:
 104                 status->type = type;
 105                 break;
 106         default:
 107                 goto bad;
 108         }
 109
 110         status->nlink           = ntohl(xdr->nlink);
 111         status->author          = ntohl(xdr->author);
 112         status->owner           = ntohl(xdr->owner);
 113         status->caller_access   = ntohl(xdr->caller_access); /* Ticket dependent */
 114         status->anon_access     = ntohl(xdr->anon_access);
 115         status->mode            = ntohl(xdr->mode) & S_IALLUGO;
 116         status->group           = ntohl(xdr->group);
 117         status->lock_count      = ntohl(xdr->lock_count);
 118
 119         status->mtime_client.tv_sec = ntohl(xdr->mtime_client);
 120         status->mtime_client.tv_nsec = 0;
 121         status->mtime_server.tv_sec = ntohl(xdr->mtime_server);
 122         status->mtime_server.tv_nsec = 0;
 123
 124         size  = (u64)ntohl(xdr->size_lo);
 125         size |= (u64)ntohl(xdr->size_hi) << 32;
 126         status->size = size;
 127
 128         data_version  = (u64)ntohl(xdr->data_version_lo);
 129         data_version |= (u64)ntohl(xdr->data_version_hi) << 32;
 130         status->data_version = data_version;
 131         scb->have_status = true;
 132
 133         *_bp = (const void *)*_bp + sizeof(*xdr);
 134         return 0;
 135
 136 bad:
 137         xdr_dump_bad(*_bp);
 138         return afs_protocol_error(call, -EBADMSG, afs_eproto_bad_status);
 139 }
 140
 141 static time64_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
 142 {
 143         return ktime_divns(call->reply_time, NSEC_PER_SEC) + expiry;
 144 }
 145
 146 static void xdr_decode_AFSCallBack(const __be32 **_bp,
 147                                    struct afs_call *call,
 148                                    struct afs_status_cb *scb)
 149 {
 150         struct afs_callback *cb = &scb->callback;
 151         const __be32 *bp = *_bp;
 152
 153         bp++; /* version */
 154         cb->expires_at  = xdr_decode_expiry(call, ntohl(*bp++));
 155         bp++; /* type */
 156         scb->have_cb    = true;
 157         *_bp = bp;
 158 }
 159
 160 /*
 161  * decode an AFSVolSync block
 162  */
 163 static void xdr_decode_AFSVolSync(const __be32 **_bp,
 164                                   struct afs_volsync *volsync)
 165 {
 166         const __be32 *bp = *_bp;
 167         u32 creation;
 168
 169         creation = ntohl(*bp++);
 170         bp++; /* spare2 */
 171         bp++; /* spare3 */
 172         bp++; /* spare4 */
 173         bp++; /* spare5 */
 174         bp++; /* spare6 */
 175         *_bp = bp;
 176
 177         if (volsync)
 178                 volsync->creation = creation;
 179 }
 180
 181 /*
 182  * encode the requested attributes into an AFSStoreStatus block
 183  */
 184 static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr)
 185 {
 186         __be32 *bp = *_bp;
 187         u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0;
 188
 189         mask = 0;
 190         if (attr->ia_valid & ATTR_MTIME) {
 191                 mask |= AFS_SET_MTIME;
 192                 mtime = attr->ia_mtime.tv_sec;
 193         }
 194
 195         if (attr->ia_valid & ATTR_UID) {
 196                 mask |= AFS_SET_OWNER;
 197                 owner = from_kuid(&init_user_ns, attr->ia_uid);
 198         }
 199
 200         if (attr->ia_valid & ATTR_GID) {
 201                 mask |= AFS_SET_GROUP;
 202                 group = from_kgid(&init_user_ns, attr->ia_gid);
 203         }
 204
 205         if (attr->ia_valid & ATTR_MODE) {
 206                 mask |= AFS_SET_MODE;
 207                 mode = attr->ia_mode & S_IALLUGO;
 208         }
 209
 210         *bp++ = htonl(mask);
 211         *bp++ = htonl(mtime);
 212         *bp++ = htonl(owner);
 213         *bp++ = htonl(group);
 214         *bp++ = htonl(mode);
 215         *bp++ = 0;              /* segment size */
 216         *_bp = bp;
 217 }
 218
 219 /*
 220  * decode an AFSFetchVolumeStatus block
 221  */
 222 static void xdr_decode_AFSFetchVolumeStatus(const __be32 **_bp,
 223                                             struct afs_volume_status *vs)
 224 {
 225         const __be32 *bp = *_bp;
 226
 227         vs->vid                 = ntohl(*bp++);
 228         vs->parent_id           = ntohl(*bp++);
 229         vs->online              = ntohl(*bp++);
 230         vs->in_service          = ntohl(*bp++);
 231         vs->blessed             = ntohl(*bp++);
 232         vs->needs_salvage       = ntohl(*bp++);
 233         vs->type                = ntohl(*bp++);
 234         vs->min_quota           = ntohl(*bp++);
 235         vs->max_quota           = ntohl(*bp++);
 236         vs->blocks_in_use       = ntohl(*bp++);
 237         vs->part_blocks_avail   = ntohl(*bp++);
 238         vs->part_max_blocks     = ntohl(*bp++);
 239         vs->vol_copy_date       = 0;
 240         vs->vol_backup_date     = 0;
 241         *_bp = bp;
 242 }
 243
 244 /*
 245  * deliver reply data to an FS.FetchStatus
 246  */
 247 static int afs_deliver_fs_fetch_status_vnode(struct afs_call *call)
 248 {
 249         const __be32 *bp;
 250         int ret;
 251
 252         ret = afs_transfer_reply(call);
 253         if (ret < 0)
 254                 return ret;
 255
 256         /* unmarshall the reply once we've received all of it */
 257         bp = call->buffer;
 258         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 259         if (ret < 0)
 260                 return ret;
 261         xdr_decode_AFSCallBack(&bp, call, call->out_scb);
 262         xdr_decode_AFSVolSync(&bp, call->out_volsync);
 263
 264         _leave(" = 0 [done]");
 265         return 0;
 266 }
 267
 268 /*
 269  * FS.FetchStatus operation type
 270  */
 271 static const struct afs_call_type afs_RXFSFetchStatus_vnode = {
 272         .name           = "FS.FetchStatus(vnode)",
 273         .op             = afs_FS_FetchStatus,
 274         .deliver        = afs_deliver_fs_fetch_status_vnode,
 275         .destructor     = afs_flat_call_destructor,
 276 };
 277
 278 /*
 279  * fetch the status information for a file
 280  */
 281 int afs_fs_fetch_file_status(struct afs_fs_cursor *fc, struct afs_status_cb *scb,
 282                              struct afs_volsync *volsync)
 283 {
 284         struct afs_vnode *vnode = fc->vnode;
 285         struct afs_call *call;
 286         struct afs_net *net = afs_v2net(vnode);
 287         __be32 *bp;
 288
 289         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 290                 return yfs_fs_fetch_file_status(fc, scb, volsync);
 291
 292         _enter(",%x,{%llx:%llu},,",
 293                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
 294
 295         call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus_vnode,
 296                                    16, (21 + 3 + 6) * 4);
 297         if (!call) {
 298                 fc->ac.error = -ENOMEM;
 299                 return -ENOMEM;
 300         }
 301
 302         call->key = fc->key;
 303         call->out_scb = scb;
 304         call->out_volsync = volsync;
 305
 306         /* marshall the parameters */
 307         bp = call->request;
 308         bp[0] = htonl(FSFETCHSTATUS);
 309         bp[1] = htonl(vnode->fid.vid);
 310         bp[2] = htonl(vnode->fid.vnode);
 311         bp[3] = htonl(vnode->fid.unique);
 312
 313         afs_use_fs_server(call, fc->cbi);
 314         trace_afs_make_fs_call(call, &vnode->fid);
 315
 316         afs_set_fc_call(call, fc);
 317         afs_make_call(&fc->ac, call, GFP_NOFS);
 318         return afs_wait_for_call_to_complete(call, &fc->ac);
 319 }
 320
 321 /*
 322  * deliver reply data to an FS.FetchData
 323  */
 324 static int afs_deliver_fs_fetch_data(struct afs_call *call)
 325 {
 326         struct afs_read *req = call->read_request;
 327         const __be32 *bp;
 328         unsigned int size;
 329         int ret;
 330
 331         _enter("{%u,%zu/%llu}",
 332                call->unmarshall, iov_iter_count(&call->iter), req->actual_len);
 333
 334         switch (call->unmarshall) {
 335         case 0:
 336                 req->actual_len = 0;
 337                 req->index = 0;
 338                 req->offset = req->pos & (PAGE_SIZE - 1);
 339                 call->unmarshall++;
 340                 if (call->operation_ID == FSFETCHDATA64) {
 341                         afs_extract_to_tmp64(call);
 342                 } else {
 343                         call->tmp_u = htonl(0);
 344                         afs_extract_to_tmp(call);
 345                 }
 346
 347                 /* Fall through - and extract the returned data length */
 348         case 1:
 349                 _debug("extract data length");
 350                 ret = afs_extract_data(call, true);
 351                 if (ret < 0)
 352                         return ret;
 353
 354                 req->actual_len = be64_to_cpu(call->tmp64);
 355                 _debug("DATA length: %llu", req->actual_len);
 356                 req->remain = min(req->len, req->actual_len);
 357                 if (req->remain == 0)
 358                         goto no_more_data;
 359
 360                 call->unmarshall++;
 361
 362         begin_page:
 363                 ASSERTCMP(req->index, <, req->nr_pages);
 364                 if (req->remain > PAGE_SIZE - req->offset)
 365                         size = PAGE_SIZE - req->offset;
 366                 else
 367                         size = req->remain;
 368                 call->bvec[0].bv_len = size;
 369                 call->bvec[0].bv_offset = req->offset;
 370                 call->bvec[0].bv_page = req->pages[req->index];
 371                 iov_iter_bvec(&call->iter, READ, call->bvec, 1, size);
 372                 ASSERTCMP(size, <=, PAGE_SIZE);
 373
 374                 /* Fall through - and extract the returned data */
 375         case 2:
 376                 _debug("extract data %zu/%llu",
 377                        iov_iter_count(&call->iter), req->remain);
 378
 379                 ret = afs_extract_data(call, true);
 380                 if (ret < 0)
 381                         return ret;
 382                 req->remain -= call->bvec[0].bv_len;
 383                 req->offset += call->bvec[0].bv_len;
 384                 ASSERTCMP(req->offset, <=, PAGE_SIZE);
 385                 if (req->offset == PAGE_SIZE) {
 386                         req->offset = 0;
 387                         if (req->page_done)
 388                                 req->page_done(req);
 389                         req->index++;
 390                         if (req->remain > 0)
 391                                 goto begin_page;
 392                 }
 393
 394                 ASSERTCMP(req->remain, ==, 0);
 395                 if (req->actual_len <= req->len)
 396                         goto no_more_data;
 397
 398                 /* Discard any excess data the server gave us */
 399                 iov_iter_discard(&call->iter, READ, req->actual_len - req->len);
 400                 call->unmarshall = 3;
 401
 402                 /* Fall through */
 403         case 3:
 404                 _debug("extract discard %zu/%llu",
 405                        iov_iter_count(&call->iter), req->actual_len - req->len);
 406
 407                 ret = afs_extract_data(call, true);
 408                 if (ret < 0)
 409                         return ret;
 410
 411         no_more_data:
 412                 call->unmarshall = 4;
 413                 afs_extract_to_buf(call, (21 + 3 + 6) * 4);
 414
 415                 /* Fall through - and extract the metadata */
 416         case 4:
 417                 ret = afs_extract_data(call, false);
 418                 if (ret < 0)
 419                         return ret;
 420
 421                 bp = call->buffer;
 422                 ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 423                 if (ret < 0)
 424                         return ret;
 425                 xdr_decode_AFSCallBack(&bp, call, call->out_scb);
 426                 xdr_decode_AFSVolSync(&bp, call->out_volsync);
 427
 428                 req->data_version = call->out_scb->status.data_version;
 429                 req->file_size = call->out_scb->status.size;
 430
 431                 call->unmarshall++;
 432
 433         case 5:
 434                 break;
 435         }
 436
 437         for (; req->index < req->nr_pages; req->index++) {
 438                 if (req->offset < PAGE_SIZE)
 439                         zero_user_segment(req->pages[req->index],
 440                                           req->offset, PAGE_SIZE);
 441                 if (req->page_done)
 442                         req->page_done(req);
 443                 req->offset = 0;
 444         }
 445
 446         _leave(" = 0 [done]");
 447         return 0;
 448 }
 449
 450 static void afs_fetch_data_destructor(struct afs_call *call)
 451 {
 452         struct afs_read *req = call->read_request;
 453
 454         afs_put_read(req);
 455         afs_flat_call_destructor(call);
 456 }
 457
 458 /*
 459  * FS.FetchData operation type
 460  */
 461 static const struct afs_call_type afs_RXFSFetchData = {
 462         .name           = "FS.FetchData",
 463         .op             = afs_FS_FetchData,
 464         .deliver        = afs_deliver_fs_fetch_data,
 465         .destructor     = afs_fetch_data_destructor,
 466 };
 467
 468 static const struct afs_call_type afs_RXFSFetchData64 = {
 469         .name           = "FS.FetchData64",
 470         .op             = afs_FS_FetchData64,
 471         .deliver        = afs_deliver_fs_fetch_data,
 472         .destructor     = afs_fetch_data_destructor,
 473 };
 474
 475 /*
 476  * fetch data from a very large file
 477  */
 478 static int afs_fs_fetch_data64(struct afs_fs_cursor *fc,
 479                                struct afs_status_cb *scb,
 480                                struct afs_read *req)
 481 {
 482         struct afs_vnode *vnode = fc->vnode;
 483         struct afs_call *call;
 484         struct afs_net *net = afs_v2net(vnode);
 485         __be32 *bp;
 486
 487         _enter("");
 488
 489         call = afs_alloc_flat_call(net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
 490         if (!call)
 491                 return -ENOMEM;
 492
 493         call->key = fc->key;
 494         call->out_scb = scb;
 495         call->out_volsync = NULL;
 496         call->read_request = req;
 497
 498         /* marshall the parameters */
 499         bp = call->request;
 500         bp[0] = htonl(FSFETCHDATA64);
 501         bp[1] = htonl(vnode->fid.vid);
 502         bp[2] = htonl(vnode->fid.vnode);
 503         bp[3] = htonl(vnode->fid.unique);
 504         bp[4] = htonl(upper_32_bits(req->pos));
 505         bp[5] = htonl(lower_32_bits(req->pos));
 506         bp[6] = 0;
 507         bp[7] = htonl(lower_32_bits(req->len));
 508
 509         refcount_inc(&req->usage);
 510         afs_use_fs_server(call, fc->cbi);
 511         trace_afs_make_fs_call(call, &vnode->fid);
 512         afs_set_fc_call(call, fc);
 513         afs_make_call(&fc->ac, call, GFP_NOFS);
 514         return afs_wait_for_call_to_complete(call, &fc->ac);
 515 }
 516
 517 /*
 518  * fetch data from a file
 519  */
 520 int afs_fs_fetch_data(struct afs_fs_cursor *fc,
 521                       struct afs_status_cb *scb,
 522                       struct afs_read *req)
 523 {
 524         struct afs_vnode *vnode = fc->vnode;
 525         struct afs_call *call;
 526         struct afs_net *net = afs_v2net(vnode);
 527         __be32 *bp;
 528
 529         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 530                 return yfs_fs_fetch_data(fc, scb, req);
 531
 532         if (upper_32_bits(req->pos) ||
 533             upper_32_bits(req->len) ||
 534             upper_32_bits(req->pos + req->len))
 535                 return afs_fs_fetch_data64(fc, scb, req);
 536
 537         _enter("");
 538
 539         call = afs_alloc_flat_call(net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
 540         if (!call)
 541                 return -ENOMEM;
 542
 543         call->key = fc->key;
 544         call->out_scb = scb;
 545         call->out_volsync = NULL;
 546         call->read_request = req;
 547
 548         /* marshall the parameters */
 549         bp = call->request;
 550         bp[0] = htonl(FSFETCHDATA);
 551         bp[1] = htonl(vnode->fid.vid);
 552         bp[2] = htonl(vnode->fid.vnode);
 553         bp[3] = htonl(vnode->fid.unique);
 554         bp[4] = htonl(lower_32_bits(req->pos));
 555         bp[5] = htonl(lower_32_bits(req->len));
 556
 557         refcount_inc(&req->usage);
 558         afs_use_fs_server(call, fc->cbi);
 559         trace_afs_make_fs_call(call, &vnode->fid);
 560         afs_set_fc_call(call, fc);
 561         afs_make_call(&fc->ac, call, GFP_NOFS);
 562         return afs_wait_for_call_to_complete(call, &fc->ac);
 563 }
 564
 565 /*
 566  * deliver reply data to an FS.CreateFile or an FS.MakeDir
 567  */
 568 static int afs_deliver_fs_create_vnode(struct afs_call *call)
 569 {
 570         const __be32 *bp;
 571         int ret;
 572
 573         ret = afs_transfer_reply(call);
 574         if (ret < 0)
 575                 return ret;
 576
 577         /* unmarshall the reply once we've received all of it */
 578         bp = call->buffer;
 579         xdr_decode_AFSFid(&bp, call->out_fid);
 580         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 581         if (ret < 0)
 582                 return ret;
 583         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_dir_scb);
 584         if (ret < 0)
 585                 return ret;
 586         xdr_decode_AFSCallBack(&bp, call, call->out_scb);
 587         xdr_decode_AFSVolSync(&bp, call->out_volsync);
 588
 589         _leave(" = 0 [done]");
 590         return 0;
 591 }
 592
 593 /*
 594  * FS.CreateFile and FS.MakeDir operation type
 595  */
 596 static const struct afs_call_type afs_RXFSCreateFile = {
 597         .name           = "FS.CreateFile",
 598         .op             = afs_FS_CreateFile,
 599         .deliver        = afs_deliver_fs_create_vnode,
 600         .destructor     = afs_flat_call_destructor,
 601 };
 602
 603 static const struct afs_call_type afs_RXFSMakeDir = {
 604         .name           = "FS.MakeDir",
 605         .op             = afs_FS_MakeDir,
 606         .deliver        = afs_deliver_fs_create_vnode,
 607         .destructor     = afs_flat_call_destructor,
 608 };
 609
 610 /*
 611  * create a file or make a directory
 612  */
 613 int afs_fs_create(struct afs_fs_cursor *fc,
 614                   const char *name,
 615                   umode_t mode,
 616                   struct afs_status_cb *dvnode_scb,
 617                   struct afs_fid *newfid,
 618                   struct afs_status_cb *new_scb)
 619 {
 620         struct afs_vnode *dvnode = fc->vnode;
 621         struct afs_call *call;
 622         struct afs_net *net = afs_v2net(dvnode);
 623         size_t namesz, reqsz, padsz;
 624         __be32 *bp;
 625
 626         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags)){
 627                 if (S_ISDIR(mode))
 628                         return yfs_fs_make_dir(fc, name, mode, dvnode_scb,
 629                                                newfid, new_scb);
 630                 else
 631                         return yfs_fs_create_file(fc, name, mode, dvnode_scb,
 632                                                   newfid, new_scb);
 633         }
 634
 635         _enter("");
 636
 637         namesz = strlen(name);
 638         padsz = (4 - (namesz & 3)) & 3;
 639         reqsz = (5 * 4) + namesz + padsz + (6 * 4);
 640
 641         call = afs_alloc_flat_call(
 642                 net, S_ISDIR(mode) ? &afs_RXFSMakeDir : &afs_RXFSCreateFile,
 643                 reqsz, (3 + 21 + 21 + 3 + 6) * 4);
 644         if (!call)
 645                 return -ENOMEM;
 646
 647         call->key = fc->key;
 648         call->out_dir_scb = dvnode_scb;
 649         call->out_fid = newfid;
 650         call->out_scb = new_scb;
 651
 652         /* marshall the parameters */
 653         bp = call->request;
 654         *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE);
 655         *bp++ = htonl(dvnode->fid.vid);
 656         *bp++ = htonl(dvnode->fid.vnode);
 657         *bp++ = htonl(dvnode->fid.unique);
 658         *bp++ = htonl(namesz);
 659         memcpy(bp, name, namesz);
 660         bp = (void *) bp + namesz;
 661         if (padsz > 0) {
 662                 memset(bp, 0, padsz);
 663                 bp = (void *) bp + padsz;
 664         }
 665         *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
 666         *bp++ = htonl(dvnode->vfs_inode.i_mtime.tv_sec); /* mtime */
 667         *bp++ = 0; /* owner */
 668         *bp++ = 0; /* group */
 669         *bp++ = htonl(mode & S_IALLUGO); /* unix mode */
 670         *bp++ = 0; /* segment size */
 671
 672         afs_use_fs_server(call, fc->cbi);
 673         trace_afs_make_fs_call1(call, &dvnode->fid, name);
 674         afs_set_fc_call(call, fc);
 675         afs_make_call(&fc->ac, call, GFP_NOFS);
 676         return afs_wait_for_call_to_complete(call, &fc->ac);
 677 }
 678
 679 /*
 680  * Deliver reply data to any operation that returns directory status and volume
 681  * sync.
 682  */
 683 static int afs_deliver_fs_dir_status_and_vol(struct afs_call *call)
 684 {
 685         const __be32 *bp;
 686         int ret;
 687
 688         ret = afs_transfer_reply(call);
 689         if (ret < 0)
 690                 return ret;
 691
 692         /* unmarshall the reply once we've received all of it */
 693         bp = call->buffer;
 694         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_dir_scb);
 695         if (ret < 0)
 696                 return ret;
 697         xdr_decode_AFSVolSync(&bp, call->out_volsync);
 698
 699         _leave(" = 0 [done]");
 700         return 0;
 701 }
 702
 703 /*
 704  * FS.RemoveDir/FS.RemoveFile operation type
 705  */
 706 static const struct afs_call_type afs_RXFSRemoveFile = {
 707         .name           = "FS.RemoveFile",
 708         .op             = afs_FS_RemoveFile,
 709         .deliver        = afs_deliver_fs_dir_status_and_vol,
 710         .destructor     = afs_flat_call_destructor,
 711 };
 712
 713 static const struct afs_call_type afs_RXFSRemoveDir = {
 714         .name           = "FS.RemoveDir",
 715         .op             = afs_FS_RemoveDir,
 716         .deliver        = afs_deliver_fs_dir_status_and_vol,
 717         .destructor     = afs_flat_call_destructor,
 718 };
 719
 720 /*
 721  * remove a file or directory
 722  */
 723 int afs_fs_remove(struct afs_fs_cursor *fc, struct afs_vnode *vnode,
 724                   const char *name, bool isdir, struct afs_status_cb *dvnode_scb)
 725 {
 726         struct afs_vnode *dvnode = fc->vnode;
 727         struct afs_call *call;
 728         struct afs_net *net = afs_v2net(dvnode);
 729         size_t namesz, reqsz, padsz;
 730         __be32 *bp;
 731
 732         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 733                 return yfs_fs_remove(fc, vnode, name, isdir, dvnode_scb);
 734
 735         _enter("");
 736
 737         namesz = strlen(name);
 738         padsz = (4 - (namesz & 3)) & 3;
 739         reqsz = (5 * 4) + namesz + padsz;
 740
 741         call = afs_alloc_flat_call(
 742                 net, isdir ? &afs_RXFSRemoveDir : &afs_RXFSRemoveFile,
 743                 reqsz, (21 + 6) * 4);
 744         if (!call)
 745                 return -ENOMEM;
 746
 747         call->key = fc->key;
 748         call->out_dir_scb = dvnode_scb;
 749
 750         /* marshall the parameters */
 751         bp = call->request;
 752         *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE);
 753         *bp++ = htonl(dvnode->fid.vid);
 754         *bp++ = htonl(dvnode->fid.vnode);
 755         *bp++ = htonl(dvnode->fid.unique);
 756         *bp++ = htonl(namesz);
 757         memcpy(bp, name, namesz);
 758         bp = (void *) bp + namesz;
 759         if (padsz > 0) {
 760                 memset(bp, 0, padsz);
 761                 bp = (void *) bp + padsz;
 762         }
 763
 764         afs_use_fs_server(call, fc->cbi);
 765         trace_afs_make_fs_call1(call, &dvnode->fid, name);
 766         afs_set_fc_call(call, fc);
 767         afs_make_call(&fc->ac, call, GFP_NOFS);
 768         return afs_wait_for_call_to_complete(call, &fc->ac);
 769 }
 770
 771 /*
 772  * deliver reply data to an FS.Link
 773  */
 774 static int afs_deliver_fs_link(struct afs_call *call)
 775 {
 776         const __be32 *bp;
 777         int ret;
 778
 779         _enter("{%u}", call->unmarshall);
 780
 781         ret = afs_transfer_reply(call);
 782         if (ret < 0)
 783                 return ret;
 784
 785         /* unmarshall the reply once we've received all of it */
 786         bp = call->buffer;
 787         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 788         if (ret < 0)
 789                 return ret;
 790         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_dir_scb);
 791         if (ret < 0)
 792                 return ret;
 793         xdr_decode_AFSVolSync(&bp, call->out_volsync);
 794
 795         _leave(" = 0 [done]");
 796         return 0;
 797 }
 798
 799 /*
 800  * FS.Link operation type
 801  */
 802 static const struct afs_call_type afs_RXFSLink = {
 803         .name           = "FS.Link",
 804         .op             = afs_FS_Link,
 805         .deliver        = afs_deliver_fs_link,
 806         .destructor     = afs_flat_call_destructor,
 807 };
 808
 809 /*
 810  * make a hard link
 811  */
 812 int afs_fs_link(struct afs_fs_cursor *fc, struct afs_vnode *vnode,
 813                 const char *name,
 814                 struct afs_status_cb *dvnode_scb,
 815                 struct afs_status_cb *vnode_scb)
 816 {
 817         struct afs_vnode *dvnode = fc->vnode;
 818         struct afs_call *call;
 819         struct afs_net *net = afs_v2net(vnode);
 820         size_t namesz, reqsz, padsz;
 821         __be32 *bp;
 822
 823         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 824                 return yfs_fs_link(fc, vnode, name, dvnode_scb, vnode_scb);
 825
 826         _enter("");
 827
 828         namesz = strlen(name);
 829         padsz = (4 - (namesz & 3)) & 3;
 830         reqsz = (5 * 4) + namesz + padsz + (3 * 4);
 831
 832         call = afs_alloc_flat_call(net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
 833         if (!call)
 834                 return -ENOMEM;
 835
 836         call->key = fc->key;
 837         call->out_dir_scb = dvnode_scb;
 838         call->out_scb = vnode_scb;
 839
 840         /* marshall the parameters */
 841         bp = call->request;
 842         *bp++ = htonl(FSLINK);
 843         *bp++ = htonl(dvnode->fid.vid);
 844         *bp++ = htonl(dvnode->fid.vnode);
 845         *bp++ = htonl(dvnode->fid.unique);
 846         *bp++ = htonl(namesz);
 847         memcpy(bp, name, namesz);
 848         bp = (void *) bp + namesz;
 849         if (padsz > 0) {
 850                 memset(bp, 0, padsz);
 851                 bp = (void *) bp + padsz;
 852         }
 853         *bp++ = htonl(vnode->fid.vid);
 854         *bp++ = htonl(vnode->fid.vnode);
 855         *bp++ = htonl(vnode->fid.unique);
 856
 857         afs_use_fs_server(call, fc->cbi);
 858         trace_afs_make_fs_call1(call, &vnode->fid, name);
 859         afs_set_fc_call(call, fc);
 860         afs_make_call(&fc->ac, call, GFP_NOFS);
 861         return afs_wait_for_call_to_complete(call, &fc->ac);
 862 }
 863
 864 /*
 865  * deliver reply data to an FS.Symlink
 866  */
 867 static int afs_deliver_fs_symlink(struct afs_call *call)
 868 {
 869         const __be32 *bp;
 870         int ret;
 871
 872         _enter("{%u}", call->unmarshall);
 873
 874         ret = afs_transfer_reply(call);
 875         if (ret < 0)
 876                 return ret;
 877
 878         /* unmarshall the reply once we've received all of it */
 879         bp = call->buffer;
 880         xdr_decode_AFSFid(&bp, call->out_fid);
 881         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 882         if (ret < 0)
 883                 return ret;
 884         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_dir_scb);
 885         if (ret < 0)
 886                 return ret;
 887         xdr_decode_AFSVolSync(&bp, call->out_volsync);
 888
 889         _leave(" = 0 [done]");
 890         return 0;
 891 }
 892
 893 /*
 894  * FS.Symlink operation type
 895  */
 896 static const struct afs_call_type afs_RXFSSymlink = {
 897         .name           = "FS.Symlink",
 898         .op             = afs_FS_Symlink,
 899         .deliver        = afs_deliver_fs_symlink,
 900         .destructor     = afs_flat_call_destructor,
 901 };
 902
 903 /*
 904  * create a symbolic link
 905  */
 906 int afs_fs_symlink(struct afs_fs_cursor *fc,
 907                    const char *name,
 908                    const char *contents,
 909                    struct afs_status_cb *dvnode_scb,
 910                    struct afs_fid *newfid,
 911                    struct afs_status_cb *new_scb)
 912 {
 913         struct afs_vnode *dvnode = fc->vnode;
 914         struct afs_call *call;
 915         struct afs_net *net = afs_v2net(dvnode);
 916         size_t namesz, reqsz, padsz, c_namesz, c_padsz;
 917         __be32 *bp;
 918
 919         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 920                 return yfs_fs_symlink(fc, name, contents, dvnode_scb,
 921                                       newfid, new_scb);
 922
 923         _enter("");
 924
 925         namesz = strlen(name);
 926         padsz = (4 - (namesz & 3)) & 3;
 927
 928         c_namesz = strlen(contents);
 929         c_padsz = (4 - (c_namesz & 3)) & 3;
 930
 931         reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
 932
 933         call = afs_alloc_flat_call(net, &afs_RXFSSymlink, reqsz,
 934                                    (3 + 21 + 21 + 6) * 4);
 935         if (!call)
 936                 return -ENOMEM;
 937
 938         call->key = fc->key;
 939         call->out_dir_scb = dvnode_scb;
 940         call->out_fid = newfid;
 941         call->out_scb = new_scb;
 942
 943         /* marshall the parameters */
 944         bp = call->request;
 945         *bp++ = htonl(FSSYMLINK);
 946         *bp++ = htonl(dvnode->fid.vid);
 947         *bp++ = htonl(dvnode->fid.vnode);
 948         *bp++ = htonl(dvnode->fid.unique);
 949         *bp++ = htonl(namesz);
 950         memcpy(bp, name, namesz);
 951         bp = (void *) bp + namesz;
 952         if (padsz > 0) {
 953                 memset(bp, 0, padsz);
 954                 bp = (void *) bp + padsz;
 955         }
 956         *bp++ = htonl(c_namesz);
 957         memcpy(bp, contents, c_namesz);
 958         bp = (void *) bp + c_namesz;
 959         if (c_padsz > 0) {
 960                 memset(bp, 0, c_padsz);
 961                 bp = (void *) bp + c_padsz;
 962         }
 963         *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
 964         *bp++ = htonl(dvnode->vfs_inode.i_mtime.tv_sec); /* mtime */
 965         *bp++ = 0; /* owner */
 966         *bp++ = 0; /* group */
 967         *bp++ = htonl(S_IRWXUGO); /* unix mode */
 968         *bp++ = 0; /* segment size */
 969
 970         afs_use_fs_server(call, fc->cbi);
 971         trace_afs_make_fs_call1(call, &dvnode->fid, name);
 972         afs_set_fc_call(call, fc);
 973         afs_make_call(&fc->ac, call, GFP_NOFS);
 974         return afs_wait_for_call_to_complete(call, &fc->ac);
 975 }
 976
 977 /*
 978  * deliver reply data to an FS.Rename
 979  */
 980 static int afs_deliver_fs_rename(struct afs_call *call)
 981 {
 982         const __be32 *bp;
 983         int ret;
 984
 985         ret = afs_transfer_reply(call);
 986         if (ret < 0)
 987                 return ret;
 988
 989         /* unmarshall the reply once we've received all of it */
 990         bp = call->buffer;
 991         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_dir_scb);
 992         if (ret < 0)
 993                 return ret;
 994         if (call->out_dir_scb != call->out_scb) {
 995                 ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 996                 if (ret < 0)
 997                         return ret;
 998         }
 999         xdr_decode_AFSVolSync(&bp, call->out_volsync);
1000
1001         _leave(" = 0 [done]");
1002         return 0;
1003 }
1004
1005 /*
1006  * FS.Rename operation type
1007  */
1008 static const struct afs_call_type afs_RXFSRename = {
1009         .name           = "FS.Rename",
1010         .op             = afs_FS_Rename,
1011         .deliver        = afs_deliver_fs_rename,
1012         .destructor     = afs_flat_call_destructor,
1013 };
1014
1015 /*
1016  * Rename/move a file or directory.
1017  */
1018 int afs_fs_rename(struct afs_fs_cursor *fc,
1019                   const char *orig_name,
1020                   struct afs_vnode *new_dvnode,
1021                   const char *new_name,
1022                   struct afs_status_cb *orig_dvnode_scb,
1023                   struct afs_status_cb *new_dvnode_scb)
1024 {
1025         struct afs_vnode *orig_dvnode = fc->vnode;
1026         struct afs_call *call;
1027         struct afs_net *net = afs_v2net(orig_dvnode);
1028         size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
1029         __be32 *bp;
1030
1031         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1032                 return yfs_fs_rename(fc, orig_name,
1033                                      new_dvnode, new_name,
1034                                      orig_dvnode_scb,
1035                                      new_dvnode_scb);
1036
1037         _enter("");
1038
1039         o_namesz = strlen(orig_name);
1040         o_padsz = (4 - (o_namesz & 3)) & 3;
1041
1042         n_namesz = strlen(new_name);
1043         n_padsz = (4 - (n_namesz & 3)) & 3;
1044
1045         reqsz = (4 * 4) +
1046                 4 + o_namesz + o_padsz +
1047                 (3 * 4) +
1048                 4 + n_namesz + n_padsz;
1049
1050         call = afs_alloc_flat_call(net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
1051         if (!call)
1052                 return -ENOMEM;
1053
1054         call->key = fc->key;
1055         call->out_dir_scb = orig_dvnode_scb;
1056         call->out_scb = new_dvnode_scb;
1057
1058         /* marshall the parameters */
1059         bp = call->request;
1060         *bp++ = htonl(FSRENAME);
1061         *bp++ = htonl(orig_dvnode->fid.vid);
1062         *bp++ = htonl(orig_dvnode->fid.vnode);
1063         *bp++ = htonl(orig_dvnode->fid.unique);
1064         *bp++ = htonl(o_namesz);
1065         memcpy(bp, orig_name, o_namesz);
1066         bp = (void *) bp + o_namesz;
1067         if (o_padsz > 0) {
1068                 memset(bp, 0, o_padsz);
1069                 bp = (void *) bp + o_padsz;
1070         }
1071
1072         *bp++ = htonl(new_dvnode->fid.vid);
1073         *bp++ = htonl(new_dvnode->fid.vnode);
1074         *bp++ = htonl(new_dvnode->fid.unique);
1075         *bp++ = htonl(n_namesz);
1076         memcpy(bp, new_name, n_namesz);
1077         bp = (void *) bp + n_namesz;
1078         if (n_padsz > 0) {
1079                 memset(bp, 0, n_padsz);
1080                 bp = (void *) bp + n_padsz;
1081         }
1082
1083         afs_use_fs_server(call, fc->cbi);
1084         trace_afs_make_fs_call2(call, &orig_dvnode->fid, orig_name, new_name);
1085         afs_set_fc_call(call, fc);
1086         afs_make_call(&fc->ac, call, GFP_NOFS);
1087         return afs_wait_for_call_to_complete(call, &fc->ac);
1088 }
1089
1090 /*
1091  * deliver reply data to an FS.StoreData
1092  */
1093 static int afs_deliver_fs_store_data(struct afs_call *call)
1094 {
1095         const __be32 *bp;
1096         int ret;
1097
1098         _enter("");
1099
1100         ret = afs_transfer_reply(call);
1101         if (ret < 0)
1102                 return ret;
1103
1104         /* unmarshall the reply once we've received all of it */
1105         bp = call->buffer;
1106         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
1107         if (ret < 0)
1108                 return ret;
1109         xdr_decode_AFSVolSync(&bp, call->out_volsync);
1110
1111         _leave(" = 0 [done]");
1112         return 0;
1113 }
1114
1115 /*
1116  * FS.StoreData operation type
1117  */
1118 static const struct afs_call_type afs_RXFSStoreData = {
1119         .name           = "FS.StoreData",
1120         .op             = afs_FS_StoreData,
1121         .deliver        = afs_deliver_fs_store_data,
1122         .destructor     = afs_flat_call_destructor,
1123 };
1124
1125 static const struct afs_call_type afs_RXFSStoreData64 = {
1126         .name           = "FS.StoreData64",
1127         .op             = afs_FS_StoreData64,
1128         .deliver        = afs_deliver_fs_store_data,
1129         .destructor     = afs_flat_call_destructor,
1130 };
1131
1132 /*
1133  * store a set of pages to a very large file
1134  */
1135 static int afs_fs_store_data64(struct afs_fs_cursor *fc,
1136                                struct address_space *mapping,
1137                                pgoff_t first, pgoff_t last,
1138                                unsigned offset, unsigned to,
1139                                loff_t size, loff_t pos, loff_t i_size,
1140                                struct afs_status_cb *scb)
1141 {
1142         struct afs_vnode *vnode = fc->vnode;
1143         struct afs_call *call;
1144         struct afs_net *net = afs_v2net(vnode);
1145         __be32 *bp;
1146
1147         _enter(",%x,{%llx:%llu},,",
1148                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1149
1150         call = afs_alloc_flat_call(net, &afs_RXFSStoreData64,
1151                                    (4 + 6 + 3 * 2) * 4,
1152                                    (21 + 6) * 4);
1153         if (!call)
1154                 return -ENOMEM;
1155
1156         call->key = fc->key;
1157         call->mapping = mapping;
1158         call->first = first;
1159         call->last = last;
1160         call->first_offset = offset;
1161         call->last_to = to;
1162         call->send_pages = true;
1163         call->out_scb = scb;
1164
1165         /* marshall the parameters */
1166         bp = call->request;
1167         *bp++ = htonl(FSSTOREDATA64);
1168         *bp++ = htonl(vnode->fid.vid);
1169         *bp++ = htonl(vnode->fid.vnode);
1170         *bp++ = htonl(vnode->fid.unique);
1171
1172         *bp++ = htonl(AFS_SET_MTIME); /* mask */
1173         *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1174         *bp++ = 0; /* owner */
1175         *bp++ = 0; /* group */
1176         *bp++ = 0; /* unix mode */
1177         *bp++ = 0; /* segment size */
1178
1179         *bp++ = htonl(pos >> 32);
1180         *bp++ = htonl((u32) pos);
1181         *bp++ = htonl(size >> 32);
1182         *bp++ = htonl((u32) size);
1183         *bp++ = htonl(i_size >> 32);
1184         *bp++ = htonl((u32) i_size);
1185
1186         trace_afs_make_fs_call(call, &vnode->fid);
1187         afs_set_fc_call(call, fc);
1188         afs_make_call(&fc->ac, call, GFP_NOFS);
1189         return afs_wait_for_call_to_complete(call, &fc->ac);
1190 }
1191
1192 /*
1193  * store a set of pages
1194  */
1195 int afs_fs_store_data(struct afs_fs_cursor *fc, struct address_space *mapping,
1196                       pgoff_t first, pgoff_t last,
1197                       unsigned offset, unsigned to,
1198                       struct afs_status_cb *scb)
1199 {
1200         struct afs_vnode *vnode = fc->vnode;
1201         struct afs_call *call;
1202         struct afs_net *net = afs_v2net(vnode);
1203         loff_t size, pos, i_size;
1204         __be32 *bp;
1205
1206         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1207                 return yfs_fs_store_data(fc, mapping, first, last, offset, to, scb);
1208
1209         _enter(",%x,{%llx:%llu},,",
1210                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1211
1212         size = (loff_t)to - (loff_t)offset;
1213         if (first != last)
1214                 size += (loff_t)(last - first) << PAGE_SHIFT;
1215         pos = (loff_t)first << PAGE_SHIFT;
1216         pos += offset;
1217
1218         i_size = i_size_read(&vnode->vfs_inode);
1219         if (pos + size > i_size)
1220                 i_size = size + pos;
1221
1222         _debug("size %llx, at %llx, i_size %llx",
1223                (unsigned long long) size, (unsigned long long) pos,
1224                (unsigned long long) i_size);
1225
1226         if (pos >> 32 || i_size >> 32 || size >> 32 || (pos + size) >> 32)
1227                 return afs_fs_store_data64(fc, mapping, first, last, offset, to,
1228                                            size, pos, i_size, scb);
1229
1230         call = afs_alloc_flat_call(net, &afs_RXFSStoreData,
1231                                    (4 + 6 + 3) * 4,
1232                                    (21 + 6) * 4);
1233         if (!call)
1234                 return -ENOMEM;
1235
1236         call->key = fc->key;
1237         call->mapping = mapping;
1238         call->first = first;
1239         call->last = last;
1240         call->first_offset = offset;
1241         call->last_to = to;
1242         call->send_pages = true;
1243         call->out_scb = scb;
1244
1245         /* marshall the parameters */
1246         bp = call->request;
1247         *bp++ = htonl(FSSTOREDATA);
1248         *bp++ = htonl(vnode->fid.vid);
1249         *bp++ = htonl(vnode->fid.vnode);
1250         *bp++ = htonl(vnode->fid.unique);
1251
1252         *bp++ = htonl(AFS_SET_MTIME); /* mask */
1253         *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1254         *bp++ = 0; /* owner */
1255         *bp++ = 0; /* group */
1256         *bp++ = 0; /* unix mode */
1257         *bp++ = 0; /* segment size */
1258
1259         *bp++ = htonl(pos);
1260         *bp++ = htonl(size);
1261         *bp++ = htonl(i_size);
1262
1263         afs_use_fs_server(call, fc->cbi);
1264         trace_afs_make_fs_call(call, &vnode->fid);
1265         afs_set_fc_call(call, fc);
1266         afs_make_call(&fc->ac, call, GFP_NOFS);
1267         return afs_wait_for_call_to_complete(call, &fc->ac);
1268 }
1269
1270 /*
1271  * deliver reply data to an FS.StoreStatus
1272  */
1273 static int afs_deliver_fs_store_status(struct afs_call *call)
1274 {
1275         const __be32 *bp;
1276         int ret;
1277
1278         _enter("");
1279
1280         ret = afs_transfer_reply(call);
1281         if (ret < 0)
1282                 return ret;
1283
1284         /* unmarshall the reply once we've received all of it */
1285         bp = call->buffer;
1286         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
1287         if (ret < 0)
1288                 return ret;
1289         xdr_decode_AFSVolSync(&bp, call->out_volsync);
1290
1291         _leave(" = 0 [done]");
1292         return 0;
1293 }
1294
1295 /*
1296  * FS.StoreStatus operation type
1297  */
1298 static const struct afs_call_type afs_RXFSStoreStatus = {
1299         .name           = "FS.StoreStatus",
1300         .op             = afs_FS_StoreStatus,
1301         .deliver        = afs_deliver_fs_store_status,
1302         .destructor     = afs_flat_call_destructor,
1303 };
1304
1305 static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1306         .name           = "FS.StoreData",
1307         .op             = afs_FS_StoreData,
1308         .deliver        = afs_deliver_fs_store_status,
1309         .destructor     = afs_flat_call_destructor,
1310 };
1311
1312 static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1313         .name           = "FS.StoreData64",
1314         .op             = afs_FS_StoreData64,
1315         .deliver        = afs_deliver_fs_store_status,
1316         .destructor     = afs_flat_call_destructor,
1317 };
1318
1319 /*
1320  * set the attributes on a very large file, using FS.StoreData rather than
1321  * FS.StoreStatus so as to alter the file size also
1322  */
1323 static int afs_fs_setattr_size64(struct afs_fs_cursor *fc, struct iattr *attr,
1324                                  struct afs_status_cb *scb)
1325 {
1326         struct afs_vnode *vnode = fc->vnode;
1327         struct afs_call *call;
1328         struct afs_net *net = afs_v2net(vnode);
1329         __be32 *bp;
1330
1331         _enter(",%x,{%llx:%llu},,",
1332                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1333
1334         ASSERT(attr->ia_valid & ATTR_SIZE);
1335
1336         call = afs_alloc_flat_call(net, &afs_RXFSStoreData64_as_Status,
1337                                    (4 + 6 + 3 * 2) * 4,
1338                                    (21 + 6) * 4);
1339         if (!call)
1340                 return -ENOMEM;
1341
1342         call->key = fc->key;
1343         call->out_scb = scb;
1344
1345         /* marshall the parameters */
1346         bp = call->request;
1347         *bp++ = htonl(FSSTOREDATA64);
1348         *bp++ = htonl(vnode->fid.vid);
1349         *bp++ = htonl(vnode->fid.vnode);
1350         *bp++ = htonl(vnode->fid.unique);
1351
1352         xdr_encode_AFS_StoreStatus(&bp, attr);
1353
1354         *bp++ = htonl(attr->ia_size >> 32);     /* position of start of write */
1355         *bp++ = htonl((u32) attr->ia_size);
1356         *bp++ = 0;                              /* size of write */
1357         *bp++ = 0;
1358         *bp++ = htonl(attr->ia_size >> 32);     /* new file length */
1359         *bp++ = htonl((u32) attr->ia_size);
1360
1361         afs_use_fs_server(call, fc->cbi);
1362         trace_afs_make_fs_call(call, &vnode->fid);
1363         afs_set_fc_call(call, fc);
1364         afs_make_call(&fc->ac, call, GFP_NOFS);
1365         return afs_wait_for_call_to_complete(call, &fc->ac);
1366 }
1367
1368 /*
1369  * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus
1370  * so as to alter the file size also
1371  */
1372 static int afs_fs_setattr_size(struct afs_fs_cursor *fc, struct iattr *attr,
1373                                struct afs_status_cb *scb)
1374 {
1375         struct afs_vnode *vnode = fc->vnode;
1376         struct afs_call *call;
1377         struct afs_net *net = afs_v2net(vnode);
1378         __be32 *bp;
1379
1380         _enter(",%x,{%llx:%llu},,",
1381                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1382
1383         ASSERT(attr->ia_valid & ATTR_SIZE);
1384         if (attr->ia_size >> 32)
1385                 return afs_fs_setattr_size64(fc, attr, scb);
1386
1387         call = afs_alloc_flat_call(net, &afs_RXFSStoreData_as_Status,
1388                                    (4 + 6 + 3) * 4,
1389                                    (21 + 6) * 4);
1390         if (!call)
1391                 return -ENOMEM;
1392
1393         call->key = fc->key;
1394         call->out_scb = scb;
1395
1396         /* marshall the parameters */
1397         bp = call->request;
1398         *bp++ = htonl(FSSTOREDATA);
1399         *bp++ = htonl(vnode->fid.vid);
1400         *bp++ = htonl(vnode->fid.vnode);
1401         *bp++ = htonl(vnode->fid.unique);
1402
1403         xdr_encode_AFS_StoreStatus(&bp, attr);
1404
1405         *bp++ = htonl(attr->ia_size);           /* position of start of write */
1406         *bp++ = 0;                              /* size of write */
1407         *bp++ = htonl(attr->ia_size);           /* new file length */
1408
1409         afs_use_fs_server(call, fc->cbi);
1410         trace_afs_make_fs_call(call, &vnode->fid);
1411         afs_set_fc_call(call, fc);
1412         afs_make_call(&fc->ac, call, GFP_NOFS);
1413         return afs_wait_for_call_to_complete(call, &fc->ac);
1414 }
1415
1416 /*
1417  * set the attributes on a file, using FS.StoreData if there's a change in file
1418  * size, and FS.StoreStatus otherwise
1419  */
1420 int afs_fs_setattr(struct afs_fs_cursor *fc, struct iattr *attr,
1421                    struct afs_status_cb *scb)
1422 {
1423         struct afs_vnode *vnode = fc->vnode;
1424         struct afs_call *call;
1425         struct afs_net *net = afs_v2net(vnode);
1426         __be32 *bp;
1427
1428         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1429                 return yfs_fs_setattr(fc, attr, scb);
1430
1431         if (attr->ia_valid & ATTR_SIZE)
1432                 return afs_fs_setattr_size(fc, attr, scb);
1433
1434         _enter(",%x,{%llx:%llu},,",
1435                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
1436
1437         call = afs_alloc_flat_call(net, &afs_RXFSStoreStatus,
1438                                    (4 + 6) * 4,
1439                                    (21 + 6) * 4);
1440         if (!call)
1441                 return -ENOMEM;
1442
1443         call->key = fc->key;
1444         call->out_scb = scb;
1445
1446         /* marshall the parameters */
1447         bp = call->request;
1448         *bp++ = htonl(FSSTORESTATUS);
1449         *bp++ = htonl(vnode->fid.vid);
1450         *bp++ = htonl(vnode->fid.vnode);
1451         *bp++ = htonl(vnode->fid.unique);
1452
1453         xdr_encode_AFS_StoreStatus(&bp, attr);
1454
1455         afs_use_fs_server(call, fc->cbi);
1456         trace_afs_make_fs_call(call, &vnode->fid);
1457         afs_set_fc_call(call, fc);
1458         afs_make_call(&fc->ac, call, GFP_NOFS);
1459         return afs_wait_for_call_to_complete(call, &fc->ac);
1460 }
1461
1462 /*
1463  * deliver reply data to an FS.GetVolumeStatus
1464  */
1465 static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1466 {
1467         const __be32 *bp;
1468         char *p;
1469         u32 size;
1470         int ret;
1471
1472         _enter("{%u}", call->unmarshall);
1473
1474         switch (call->unmarshall) {
1475         case 0:
1476                 call->unmarshall++;
1477                 afs_extract_to_buf(call, 12 * 4);
1478
1479                 /* Fall through - and extract the returned status record */
1480         case 1:
1481                 _debug("extract status");
1482                 ret = afs_extract_data(call, true);
1483                 if (ret < 0)
1484                         return ret;
1485
1486                 bp = call->buffer;
1487                 xdr_decode_AFSFetchVolumeStatus(&bp, call->out_volstatus);
1488                 call->unmarshall++;
1489                 afs_extract_to_tmp(call);
1490
1491                 /* Fall through - and extract the volume name length */
1492         case 2:
1493                 ret = afs_extract_data(call, true);
1494                 if (ret < 0)
1495                         return ret;
1496
1497                 call->count = ntohl(call->tmp);
1498                 _debug("volname length: %u", call->count);
1499                 if (call->count >= AFSNAMEMAX)
1500                         return afs_protocol_error(call, -EBADMSG,
1501                                                   afs_eproto_volname_len);
1502                 size = (call->count + 3) & ~3; /* It's padded */
1503                 afs_extract_to_buf(call, size);
1504                 call->unmarshall++;
1505
1506                 /* Fall through - and extract the volume name */
1507         case 3:
1508                 _debug("extract volname");
1509                 ret = afs_extract_data(call, true);
1510                 if (ret < 0)
1511                         return ret;
1512
1513                 p = call->buffer;
1514                 p[call->count] = 0;
1515                 _debug("volname '%s'", p);
1516                 afs_extract_to_tmp(call);
1517                 call->unmarshall++;
1518
1519                 /* Fall through - and extract the offline message length */
1520         case 4:
1521                 ret = afs_extract_data(call, true);
1522                 if (ret < 0)
1523                         return ret;
1524
1525                 call->count = ntohl(call->tmp);
1526                 _debug("offline msg length: %u", call->count);
1527                 if (call->count >= AFSNAMEMAX)
1528                         return afs_protocol_error(call, -EBADMSG,
1529                                                   afs_eproto_offline_msg_len);
1530                 size = (call->count + 3) & ~3; /* It's padded */
1531                 afs_extract_to_buf(call, size);
1532                 call->unmarshall++;
1533
1534                 /* Fall through - and extract the offline message */
1535         case 5:
1536                 _debug("extract offline");
1537                 ret = afs_extract_data(call, true);
1538                 if (ret < 0)
1539                         return ret;
1540
1541                 p = call->buffer;
1542                 p[call->count] = 0;
1543                 _debug("offline '%s'", p);
1544
1545                 afs_extract_to_tmp(call);
1546                 call->unmarshall++;
1547
1548                 /* Fall through - and extract the message of the day length */
1549         case 6:
1550                 ret = afs_extract_data(call, true);
1551                 if (ret < 0)
1552                         return ret;
1553
1554                 call->count = ntohl(call->tmp);
1555                 _debug("motd length: %u", call->count);
1556                 if (call->count >= AFSNAMEMAX)
1557                         return afs_protocol_error(call, -EBADMSG,
1558                                                   afs_eproto_motd_len);
1559                 size = (call->count + 3) & ~3; /* It's padded */
1560                 afs_extract_to_buf(call, size);
1561                 call->unmarshall++;
1562
1563                 /* Fall through - and extract the message of the day */
1564         case 7:
1565                 _debug("extract motd");
1566                 ret = afs_extract_data(call, false);
1567                 if (ret < 0)
1568                         return ret;
1569
1570                 p = call->buffer;
1571                 p[call->count] = 0;
1572                 _debug("motd '%s'", p);
1573
1574                 call->unmarshall++;
1575
1576         case 8:
1577                 break;
1578         }
1579
1580         _leave(" = 0 [done]");
1581         return 0;
1582 }
1583
1584 /*
1585  * FS.GetVolumeStatus operation type
1586  */
1587 static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1588         .name           = "FS.GetVolumeStatus",
1589         .op             = afs_FS_GetVolumeStatus,
1590         .deliver        = afs_deliver_fs_get_volume_status,
1591         .destructor     = afs_flat_call_destructor,
1592 };
1593
1594 /*
1595  * fetch the status of a volume
1596  */
1597 int afs_fs_get_volume_status(struct afs_fs_cursor *fc,
1598                              struct afs_volume_status *vs)
1599 {
1600         struct afs_vnode *vnode = fc->vnode;
1601         struct afs_call *call;
1602         struct afs_net *net = afs_v2net(vnode);
1603         __be32 *bp;
1604
1605         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1606                 return yfs_fs_get_volume_status(fc, vs);
1607
1608         _enter("");
1609
1610         call = afs_alloc_flat_call(net, &afs_RXFSGetVolumeStatus, 2 * 4,
1611                                    max(12 * 4, AFSOPAQUEMAX + 1));
1612         if (!call)
1613                 return -ENOMEM;
1614
1615         call->key = fc->key;
1616         call->out_volstatus = vs;
1617
1618         /* marshall the parameters */
1619         bp = call->request;
1620         bp[0] = htonl(FSGETVOLUMESTATUS);
1621         bp[1] = htonl(vnode->fid.vid);
1622
1623         afs_use_fs_server(call, fc->cbi);
1624         trace_afs_make_fs_call(call, &vnode->fid);
1625         afs_set_fc_call(call, fc);
1626         afs_make_call(&fc->ac, call, GFP_NOFS);
1627         return afs_wait_for_call_to_complete(call, &fc->ac);
1628 }
1629
1630 /*
1631  * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
1632  */
1633 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1634 {
1635         const __be32 *bp;
1636         int ret;
1637
1638         _enter("{%u}", call->unmarshall);
1639
1640         ret = afs_transfer_reply(call);
1641         if (ret < 0)
1642                 return ret;
1643
1644         /* unmarshall the reply once we've received all of it */
1645         bp = call->buffer;
1646         xdr_decode_AFSVolSync(&bp, call->out_volsync);
1647
1648         _leave(" = 0 [done]");
1649         return 0;
1650 }
1651
1652 /*
1653  * FS.SetLock operation type
1654  */
1655 static const struct afs_call_type afs_RXFSSetLock = {
1656         .name           = "FS.SetLock",
1657         .op             = afs_FS_SetLock,
1658         .deliver        = afs_deliver_fs_xxxx_lock,
1659         .done           = afs_lock_op_done,
1660         .destructor     = afs_flat_call_destructor,
1661 };
1662
1663 /*
1664  * FS.ExtendLock operation type
1665  */
1666 static const struct afs_call_type afs_RXFSExtendLock = {
1667         .name           = "FS.ExtendLock",
1668         .op             = afs_FS_ExtendLock,
1669         .deliver        = afs_deliver_fs_xxxx_lock,
1670         .done           = afs_lock_op_done,
1671         .destructor     = afs_flat_call_destructor,
1672 };
1673
1674 /*
1675  * FS.ReleaseLock operation type
1676  */
1677 static const struct afs_call_type afs_RXFSReleaseLock = {
1678         .name           = "FS.ReleaseLock",
1679         .op             = afs_FS_ReleaseLock,
1680         .deliver        = afs_deliver_fs_xxxx_lock,
1681         .destructor     = afs_flat_call_destructor,
1682 };
1683
1684 /*
1685  * Set a lock on a file
1686  */
1687 int afs_fs_set_lock(struct afs_fs_cursor *fc, afs_lock_type_t type,
1688                     struct afs_status_cb *scb)
1689 {
1690         struct afs_vnode *vnode = fc->vnode;
1691         struct afs_call *call;
1692         struct afs_net *net = afs_v2net(vnode);
1693         __be32 *bp;
1694
1695         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1696                 return yfs_fs_set_lock(fc, type, scb);
1697
1698         _enter("");
1699
1700         call = afs_alloc_flat_call(net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1701         if (!call)
1702                 return -ENOMEM;
1703
1704         call->key = fc->key;
1705         call->lvnode = vnode;
1706         call->out_scb = scb;
1707
1708         /* marshall the parameters */
1709         bp = call->request;
1710         *bp++ = htonl(FSSETLOCK);
1711         *bp++ = htonl(vnode->fid.vid);
1712         *bp++ = htonl(vnode->fid.vnode);
1713         *bp++ = htonl(vnode->fid.unique);
1714         *bp++ = htonl(type);
1715
1716         afs_use_fs_server(call, fc->cbi);
1717         trace_afs_make_fs_calli(call, &vnode->fid, type);
1718         afs_set_fc_call(call, fc);
1719         afs_make_call(&fc->ac, call, GFP_NOFS);
1720         return afs_wait_for_call_to_complete(call, &fc->ac);
1721 }
1722
1723 /*
1724  * extend a lock on a file
1725  */
1726 int afs_fs_extend_lock(struct afs_fs_cursor *fc, struct afs_status_cb *scb)
1727 {
1728         struct afs_vnode *vnode = fc->vnode;
1729         struct afs_call *call;
1730         struct afs_net *net = afs_v2net(vnode);
1731         __be32 *bp;
1732
1733         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1734                 return yfs_fs_extend_lock(fc, scb);
1735
1736         _enter("");
1737
1738         call = afs_alloc_flat_call(net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1739         if (!call)
1740                 return -ENOMEM;
1741
1742         call->key = fc->key;
1743         call->lvnode = vnode;
1744         call->out_scb = scb;
1745
1746         /* marshall the parameters */
1747         bp = call->request;
1748         *bp++ = htonl(FSEXTENDLOCK);
1749         *bp++ = htonl(vnode->fid.vid);
1750         *bp++ = htonl(vnode->fid.vnode);
1751         *bp++ = htonl(vnode->fid.unique);
1752
1753         afs_use_fs_server(call, fc->cbi);
1754         trace_afs_make_fs_call(call, &vnode->fid);
1755         afs_set_fc_call(call, fc);
1756         afs_make_call(&fc->ac, call, GFP_NOFS);
1757         return afs_wait_for_call_to_complete(call, &fc->ac);
1758 }
1759
1760 /*
1761  * release a lock on a file
1762  */
1763 int afs_fs_release_lock(struct afs_fs_cursor *fc, struct afs_status_cb *scb)
1764 {
1765         struct afs_vnode *vnode = fc->vnode;
1766         struct afs_call *call;
1767         struct afs_net *net = afs_v2net(vnode);
1768         __be32 *bp;
1769
1770         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1771                 return yfs_fs_release_lock(fc, scb);
1772
1773         _enter("");
1774
1775         call = afs_alloc_flat_call(net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1776         if (!call)
1777                 return -ENOMEM;
1778
1779         call->key = fc->key;
1780         call->lvnode = vnode;
1781         call->out_scb = scb;
1782
1783         /* marshall the parameters */
1784         bp = call->request;
1785         *bp++ = htonl(FSRELEASELOCK);
1786         *bp++ = htonl(vnode->fid.vid);
1787         *bp++ = htonl(vnode->fid.vnode);
1788         *bp++ = htonl(vnode->fid.unique);
1789
1790         afs_use_fs_server(call, fc->cbi);
1791         trace_afs_make_fs_call(call, &vnode->fid);
1792         afs_set_fc_call(call, fc);
1793         afs_make_call(&fc->ac, call, GFP_NOFS);
1794         return afs_wait_for_call_to_complete(call, &fc->ac);
1795 }
1796
1797 /*
1798  * Deliver reply data to an FS.GiveUpAllCallBacks operation.
1799  */
1800 static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1801 {
1802         return afs_transfer_reply(call);
1803 }
1804
1805 /*
1806  * FS.GiveUpAllCallBacks operation type
1807  */
1808 static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = {
1809         .name           = "FS.GiveUpAllCallBacks",
1810         .op             = afs_FS_GiveUpAllCallBacks,
1811         .deliver        = afs_deliver_fs_give_up_all_callbacks,
1812         .destructor     = afs_flat_call_destructor,
1813 };
1814
1815 /*
1816  * Flush all the callbacks we have on a server.
1817  */
1818 int afs_fs_give_up_all_callbacks(struct afs_net *net,
1819                                  struct afs_server *server,
1820                                  struct afs_addr_cursor *ac,
1821                                  struct key *key)
1822 {
1823         struct afs_call *call;
1824         __be32 *bp;
1825
1826         _enter("");
1827
1828         call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1829         if (!call)
1830                 return -ENOMEM;
1831
1832         call->key = key;
1833
1834         /* marshall the parameters */
1835         bp = call->request;
1836         *bp++ = htonl(FSGIVEUPALLCALLBACKS);
1837
1838         /* Can't take a ref on server */
1839         afs_make_call(ac, call, GFP_NOFS);
1840         return afs_wait_for_call_to_complete(call, ac);
1841 }
1842
1843 /*
1844  * Deliver reply data to an FS.GetCapabilities operation.
1845  */
1846 static int afs_deliver_fs_get_capabilities(struct afs_call *call)
1847 {
1848         u32 count;
1849         int ret;
1850
1851         _enter("{%u,%zu}", call->unmarshall, iov_iter_count(&call->iter));
1852
1853         switch (call->unmarshall) {
1854         case 0:
1855                 afs_extract_to_tmp(call);
1856                 call->unmarshall++;
1857
1858                 /* Fall through - and extract the capabilities word count */
1859         case 1:
1860                 ret = afs_extract_data(call, true);
1861                 if (ret < 0)
1862                         return ret;
1863
1864                 count = ntohl(call->tmp);
1865
1866                 call->count = count;
1867                 call->count2 = count;
1868                 iov_iter_discard(&call->iter, READ, count * sizeof(__be32));
1869                 call->unmarshall++;
1870
1871                 /* Fall through - and extract capabilities words */
1872         case 2:
1873                 ret = afs_extract_data(call, false);
1874                 if (ret < 0)
1875                         return ret;
1876
1877                 /* TODO: Examine capabilities */
1878
1879                 call->unmarshall++;
1880                 break;
1881         }
1882
1883         _leave(" = 0 [done]");
1884         return 0;
1885 }
1886
1887 /*
1888  * FS.GetCapabilities operation type
1889  */
1890 static const struct afs_call_type afs_RXFSGetCapabilities = {
1891         .name           = "FS.GetCapabilities",
1892         .op             = afs_FS_GetCapabilities,
1893         .deliver        = afs_deliver_fs_get_capabilities,
1894         .done           = afs_fileserver_probe_result,
1895         .destructor     = afs_flat_call_destructor,
1896 };
1897
1898 /*
1899  * Probe a fileserver for the capabilities that it supports.  This can
1900  * return up to 196 words.
1901  */
1902 struct afs_call *afs_fs_get_capabilities(struct afs_net *net,
1903                                          struct afs_server *server,
1904                                          struct afs_addr_cursor *ac,
1905                                          struct key *key,
1906                                          unsigned int server_index)
1907 {
1908         struct afs_call *call;
1909         __be32 *bp;
1910
1911         _enter("");
1912
1913         call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
1914         if (!call)
1915                 return ERR_PTR(-ENOMEM);
1916
1917         call->key = key;
1918         call->server = afs_get_server(server);
1919         call->server_index = server_index;
1920         call->upgrade = true;
1921         call->async = true;
1922         call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
1923
1924         /* marshall the parameters */
1925         bp = call->request;
1926         *bp++ = htonl(FSGETCAPABILITIES);
1927
1928         /* Can't take a ref on server */
1929         trace_afs_make_fs_call(call, NULL);
1930         afs_make_call(ac, call, GFP_NOFS);
1931         return call;
1932 }
1933
1934 /*
1935  * Deliver reply data to an FS.FetchStatus with no vnode.
1936  */
1937 static int afs_deliver_fs_fetch_status(struct afs_call *call)
1938 {
1939         const __be32 *bp;
1940         int ret;
1941
1942         ret = afs_transfer_reply(call);
1943         if (ret < 0)
1944                 return ret;
1945
1946         /* unmarshall the reply once we've received all of it */
1947         bp = call->buffer;
1948         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
1949         if (ret < 0)
1950                 return ret;
1951         xdr_decode_AFSCallBack(&bp, call, call->out_scb);
1952         xdr_decode_AFSVolSync(&bp, call->out_volsync);
1953
1954         _leave(" = 0 [done]");
1955         return 0;
1956 }
1957
1958 /*
1959  * FS.FetchStatus operation type
1960  */
1961 static const struct afs_call_type afs_RXFSFetchStatus = {
1962         .name           = "FS.FetchStatus",
1963         .op             = afs_FS_FetchStatus,
1964         .deliver        = afs_deliver_fs_fetch_status,
1965         .destructor     = afs_flat_call_destructor,
1966 };
1967
1968 /*
1969  * Fetch the status information for a fid without needing a vnode handle.
1970  */
1971 int afs_fs_fetch_status(struct afs_fs_cursor *fc,
1972                         struct afs_net *net,
1973                         struct afs_fid *fid,
1974                         struct afs_status_cb *scb,
1975                         struct afs_volsync *volsync)
1976 {
1977         struct afs_call *call;
1978         __be32 *bp;
1979
1980         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1981                 return yfs_fs_fetch_status(fc, net, fid, scb, volsync);
1982
1983         _enter(",%x,{%llx:%llu},,",
1984                key_serial(fc->key), fid->vid, fid->vnode);
1985
1986         call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4);
1987         if (!call) {
1988                 fc->ac.error = -ENOMEM;
1989                 return -ENOMEM;
1990         }
1991
1992         call->key = fc->key;
1993         call->out_fid = fid;
1994         call->out_scb = scb;
1995         call->out_volsync = volsync;
1996
1997         /* marshall the parameters */
1998         bp = call->request;
1999         bp[0] = htonl(FSFETCHSTATUS);
2000         bp[1] = htonl(fid->vid);
2001         bp[2] = htonl(fid->vnode);
2002         bp[3] = htonl(fid->unique);
2003
2004         afs_use_fs_server(call, fc->cbi);
2005         trace_afs_make_fs_call(call, fid);
2006         afs_set_fc_call(call, fc);
2007         afs_make_call(&fc->ac, call, GFP_NOFS);
2008         return afs_wait_for_call_to_complete(call, &fc->ac);
2009 }
2010
2011 /*
2012  * Deliver reply data to an FS.InlineBulkStatus call
2013  */
2014 static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
2015 {
2016         struct afs_status_cb *scb;
2017         const __be32 *bp;
2018         u32 tmp;
2019         int ret;
2020
2021         _enter("{%u}", call->unmarshall);
2022
2023         switch (call->unmarshall) {
2024         case 0:
2025                 afs_extract_to_tmp(call);
2026                 call->unmarshall++;
2027
2028                 /* Extract the file status count and array in two steps */
2029                 /* Fall through */
2030         case 1:
2031                 _debug("extract status count");
2032                 ret = afs_extract_data(call, true);
2033                 if (ret < 0)
2034                         return ret;
2035
2036                 tmp = ntohl(call->tmp);
2037                 _debug("status count: %u/%u", tmp, call->count2);
2038                 if (tmp != call->count2)
2039                         return afs_protocol_error(call, -EBADMSG,
2040                                                   afs_eproto_ibulkst_count);
2041
2042                 call->count = 0;
2043                 call->unmarshall++;
2044         more_counts:
2045                 afs_extract_to_buf(call, 21 * sizeof(__be32));
2046
2047                 /* Fall through */
2048         case 2:
2049                 _debug("extract status array %u", call->count);
2050                 ret = afs_extract_data(call, true);
2051                 if (ret < 0)
2052                         return ret;
2053
2054                 bp = call->buffer;
2055                 scb = &call->out_scb[call->count];
2056                 ret = xdr_decode_AFSFetchStatus(&bp, call, scb);
2057                 if (ret < 0)
2058                         return ret;
2059
2060                 call->count++;
2061                 if (call->count < call->count2)
2062                         goto more_counts;
2063
2064                 call->count = 0;
2065                 call->unmarshall++;
2066                 afs_extract_to_tmp(call);
2067
2068                 /* Extract the callback count and array in two steps */
2069                 /* Fall through */
2070         case 3:
2071                 _debug("extract CB count");
2072                 ret = afs_extract_data(call, true);
2073                 if (ret < 0)
2074                         return ret;
2075
2076                 tmp = ntohl(call->tmp);
2077                 _debug("CB count: %u", tmp);
2078                 if (tmp != call->count2)
2079                         return afs_protocol_error(call, -EBADMSG,
2080                                                   afs_eproto_ibulkst_cb_count);
2081                 call->count = 0;
2082                 call->unmarshall++;
2083         more_cbs:
2084                 afs_extract_to_buf(call, 3 * sizeof(__be32));
2085
2086                 /* Fall through */
2087         case 4:
2088                 _debug("extract CB array");
2089                 ret = afs_extract_data(call, true);
2090                 if (ret < 0)
2091                         return ret;
2092
2093                 _debug("unmarshall CB array");
2094                 bp = call->buffer;
2095                 scb = &call->out_scb[call->count];
2096                 xdr_decode_AFSCallBack(&bp, call, scb);
2097                 call->count++;
2098                 if (call->count < call->count2)
2099                         goto more_cbs;
2100
2101                 afs_extract_to_buf(call, 6 * sizeof(__be32));
2102                 call->unmarshall++;
2103
2104                 /* Fall through */
2105         case 5:
2106                 ret = afs_extract_data(call, false);
2107                 if (ret < 0)
2108                         return ret;
2109
2110                 bp = call->buffer;
2111                 xdr_decode_AFSVolSync(&bp, call->out_volsync);
2112
2113                 call->unmarshall++;
2114
2115         case 6:
2116                 break;
2117         }
2118
2119         _leave(" = 0 [done]");
2120         return 0;
2121 }
2122
2123 /*
2124  * FS.InlineBulkStatus operation type
2125  */
2126 static const struct afs_call_type afs_RXFSInlineBulkStatus = {
2127         .name           = "FS.InlineBulkStatus",
2128         .op             = afs_FS_InlineBulkStatus,
2129         .deliver        = afs_deliver_fs_inline_bulk_status,
2130         .destructor     = afs_flat_call_destructor,
2131 };
2132
2133 /*
2134  * Fetch the status information for up to 50 files
2135  */
2136 int afs_fs_inline_bulk_status(struct afs_fs_cursor *fc,
2137                               struct afs_net *net,
2138                               struct afs_fid *fids,
2139                               struct afs_status_cb *statuses,
2140                               unsigned int nr_fids,
2141                               struct afs_volsync *volsync)
2142 {
2143         struct afs_call *call;
2144         __be32 *bp;
2145         int i;
2146
2147         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
2148                 return yfs_fs_inline_bulk_status(fc, net, fids, statuses,
2149                                                  nr_fids, volsync);
2150
2151         _enter(",%x,{%llx:%llu},%u",
2152                key_serial(fc->key), fids[0].vid, fids[1].vnode, nr_fids);
2153
2154         call = afs_alloc_flat_call(net, &afs_RXFSInlineBulkStatus,
2155                                    (2 + nr_fids * 3) * 4,
2156                                    21 * 4);
2157         if (!call) {
2158                 fc->ac.error = -ENOMEM;
2159                 return -ENOMEM;
2160         }
2161
2162         call->key = fc->key;
2163         call->out_scb = statuses;
2164         call->out_volsync = volsync;
2165         call->count2 = nr_fids;
2166
2167         /* marshall the parameters */
2168         bp = call->request;
2169         *bp++ = htonl(FSINLINEBULKSTATUS);
2170         *bp++ = htonl(nr_fids);
2171         for (i = 0; i < nr_fids; i++) {
2172                 *bp++ = htonl(fids[i].vid);
2173                 *bp++ = htonl(fids[i].vnode);
2174                 *bp++ = htonl(fids[i].unique);
2175         }
2176
2177         afs_use_fs_server(call, fc->cbi);
2178         trace_afs_make_fs_call(call, &fids[0]);
2179         afs_set_fc_call(call, fc);
2180         afs_make_call(&fc->ac, call, GFP_NOFS);
2181         return afs_wait_for_call_to_complete(call, &fc->ac);
2182 }
2183
2184 /*
2185  * deliver reply data to an FS.FetchACL
2186  */
2187 static int afs_deliver_fs_fetch_acl(struct afs_call *call)
2188 {
2189         struct afs_acl *acl;
2190         const __be32 *bp;
2191         unsigned int size;
2192         int ret;
2193
2194         _enter("{%u}", call->unmarshall);
2195
2196         switch (call->unmarshall) {
2197         case 0:
2198                 afs_extract_to_tmp(call);
2199                 call->unmarshall++;
2200
2201                 /* extract the returned data length */
2202         case 1:
2203                 ret = afs_extract_data(call, true);
2204                 if (ret < 0)
2205                         return ret;
2206
2207                 size = call->count2 = ntohl(call->tmp);
2208                 size = round_up(size, 4);
2209
2210                 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
2211                 if (!acl)
2212                         return -ENOMEM;
2213                 call->ret_acl = acl;
2214                 acl->size = call->count2;
2215                 afs_extract_begin(call, acl->data, size);
2216                 call->unmarshall++;
2217
2218                 /* extract the returned data */
2219         case 2:
2220                 ret = afs_extract_data(call, true);
2221                 if (ret < 0)
2222                         return ret;
2223
2224                 afs_extract_to_buf(call, (21 + 6) * 4);
2225                 call->unmarshall++;
2226
2227                 /* extract the metadata */
2228         case 3:
2229                 ret = afs_extract_data(call, false);
2230                 if (ret < 0)
2231                         return ret;
2232
2233                 bp = call->buffer;
2234                 ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
2235                 if (ret < 0)
2236                         return ret;
2237                 xdr_decode_AFSVolSync(&bp, call->out_volsync);
2238
2239                 call->unmarshall++;
2240
2241         case 4:
2242                 break;
2243         }
2244
2245         _leave(" = 0 [done]");
2246         return 0;
2247 }
2248
2249 static void afs_destroy_fs_fetch_acl(struct afs_call *call)
2250 {
2251         kfree(call->ret_acl);
2252         afs_flat_call_destructor(call);
2253 }
2254
2255 /*
2256  * FS.FetchACL operation type
2257  */
2258 static const struct afs_call_type afs_RXFSFetchACL = {
2259         .name           = "FS.FetchACL",
2260         .op             = afs_FS_FetchACL,
2261         .deliver        = afs_deliver_fs_fetch_acl,
2262         .destructor     = afs_destroy_fs_fetch_acl,
2263 };
2264
2265 /*
2266  * Fetch the ACL for a file.
2267  */
2268 struct afs_acl *afs_fs_fetch_acl(struct afs_fs_cursor *fc,
2269                                  struct afs_status_cb *scb)
2270 {
2271         struct afs_vnode *vnode = fc->vnode;
2272         struct afs_call *call;
2273         struct afs_net *net = afs_v2net(vnode);
2274         __be32 *bp;
2275
2276         _enter(",%x,{%llx:%llu},,",
2277                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
2278
2279         call = afs_alloc_flat_call(net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
2280         if (!call) {
2281                 fc->ac.error = -ENOMEM;
2282                 return ERR_PTR(-ENOMEM);
2283         }
2284
2285         call->key = fc->key;
2286         call->ret_acl = NULL;
2287         call->out_scb = scb;
2288         call->out_volsync = NULL;
2289
2290         /* marshall the parameters */
2291         bp = call->request;
2292         bp[0] = htonl(FSFETCHACL);
2293         bp[1] = htonl(vnode->fid.vid);
2294         bp[2] = htonl(vnode->fid.vnode);
2295         bp[3] = htonl(vnode->fid.unique);
2296
2297         afs_use_fs_server(call, fc->cbi);
2298         trace_afs_make_fs_call(call, &vnode->fid);
2299         afs_make_call(&fc->ac, call, GFP_KERNEL);
2300         return (struct afs_acl *)afs_wait_for_call_to_complete(call, &fc->ac);
2301 }
2302
2303 /*
2304  * Deliver reply data to any operation that returns file status and volume
2305  * sync.
2306  */
2307 static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
2308 {
2309         const __be32 *bp;
2310         int ret;
2311
2312         ret = afs_transfer_reply(call);
2313         if (ret < 0)
2314                 return ret;
2315
2316         bp = call->buffer;
2317         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
2318         if (ret < 0)
2319                 return ret;
2320         xdr_decode_AFSVolSync(&bp, call->out_volsync);
2321
2322         _leave(" = 0 [done]");
2323         return 0;
2324 }
2325
2326 /*
2327  * FS.StoreACL operation type
2328  */
2329 static const struct afs_call_type afs_RXFSStoreACL = {
2330         .name           = "FS.StoreACL",
2331         .op             = afs_FS_StoreACL,
2332         .deliver        = afs_deliver_fs_file_status_and_vol,
2333         .destructor     = afs_flat_call_destructor,
2334 };
2335
2336 /*
2337  * Fetch the ACL for a file.
2338  */
2339 int afs_fs_store_acl(struct afs_fs_cursor *fc, const struct afs_acl *acl,
2340                      struct afs_status_cb *scb)
2341 {
2342         struct afs_vnode *vnode = fc->vnode;
2343         struct afs_call *call;
2344         struct afs_net *net = afs_v2net(vnode);
2345         size_t size;
2346         __be32 *bp;
2347
2348         _enter(",%x,{%llx:%llu},,",
2349                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
2350
2351         size = round_up(acl->size, 4);
2352         call = afs_alloc_flat_call(net, &afs_RXFSStoreACL,
2353                                    5 * 4 + size, (21 + 6) * 4);
2354         if (!call) {
2355                 fc->ac.error = -ENOMEM;
2356                 return -ENOMEM;
2357         }
2358
2359         call->key = fc->key;
2360         call->out_scb = scb;
2361         call->out_volsync = NULL;
2362
2363         /* marshall the parameters */
2364         bp = call->request;
2365         bp[0] = htonl(FSSTOREACL);
2366         bp[1] = htonl(vnode->fid.vid);
2367         bp[2] = htonl(vnode->fid.vnode);
2368         bp[3] = htonl(vnode->fid.unique);
2369         bp[4] = htonl(acl->size);
2370         memcpy(&bp[5], acl->data, acl->size);
2371         if (acl->size != size)
2372                 memset((void *)&bp[5] + acl->size, 0, size - acl->size);
2373
2374         trace_afs_make_fs_call(call, &vnode->fid);
2375         afs_make_call(&fc->ac, call, GFP_KERNEL);
2376         return afs_wait_for_call_to_complete(call, &fc->ac);
2377 }