fs/afs/fsclient.c

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