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 (dhowells@redhat.com)
   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         int ret;
  69
  70         abort_code = ntohl(xdr->abort_code);
  71
  72         if (xdr->if_version != htonl(AFS_FSTATUS_VERSION)) {
  73                 if (xdr->if_version == htonl(0) &&
  74                     abort_code != 0 &&
  75                     inline_error) {
  76                         /* The OpenAFS fileserver has a bug in FS.InlineBulkStatus
  77                          * whereby it doesn't set the interface version in the error
  78                          * case.
  79                          */
  80                         status->abort_code = abort_code;
  81                         scb->have_error = true;
  82                         goto good;
  83                 }
  84
  85                 pr_warn("Unknown AFSFetchStatus version %u\n", ntohl(xdr->if_version));
  86                 goto bad;
  87         }
  88
  89         if (abort_code != 0 && inline_error) {
  90                 status->abort_code = abort_code;
  91                 scb->have_error = true;
  92                 goto good;
  93         }
  94
  95         type = ntohl(xdr->type);
  96         switch (type) {
  97         case AFS_FTYPE_FILE:
  98         case AFS_FTYPE_DIR:
  99         case AFS_FTYPE_SYMLINK:
 100                 status->type = type;
 101                 break;
 102         default:
 103                 goto bad;
 104         }
 105
 106         status->nlink           = ntohl(xdr->nlink);
 107         status->author          = ntohl(xdr->author);
 108         status->owner           = ntohl(xdr->owner);
 109         status->caller_access   = ntohl(xdr->caller_access); /* Ticket dependent */
 110         status->anon_access     = ntohl(xdr->anon_access);
 111         status->mode            = ntohl(xdr->mode) & S_IALLUGO;
 112         status->group           = ntohl(xdr->group);
 113         status->lock_count      = ntohl(xdr->lock_count);
 114
 115         status->mtime_client.tv_sec = ntohl(xdr->mtime_client);
 116         status->mtime_client.tv_nsec = 0;
 117         status->mtime_server.tv_sec = ntohl(xdr->mtime_server);
 118         status->mtime_server.tv_nsec = 0;
 119
 120         size  = (u64)ntohl(xdr->size_lo);
 121         size |= (u64)ntohl(xdr->size_hi) << 32;
 122         status->size = size;
 123
 124         data_version  = (u64)ntohl(xdr->data_version_lo);
 125         data_version |= (u64)ntohl(xdr->data_version_hi) << 32;
 126         status->data_version = data_version;
 127         scb->have_status = true;
 128 good:
 129         ret = 0;
 130 advance:
 131         *_bp = (const void *)*_bp + sizeof(*xdr);
 132         return ret;
 133
 134 bad:
 135         xdr_dump_bad(*_bp);
 136         ret = afs_protocol_error(call, -EBADMSG, afs_eproto_bad_status);
 137         goto advance;
 138 }
 139
 140 static time64_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
 141 {
 142         return ktime_divns(call->reply_time, NSEC_PER_SEC) + expiry;
 143 }
 144
 145 static void xdr_decode_AFSCallBack(const __be32 **_bp,
 146                                    struct afs_call *call,
 147                                    struct afs_status_cb *scb)
 148 {
 149         struct afs_callback *cb = &scb->callback;
 150         const __be32 *bp = *_bp;
 151
 152         bp++; /* version */
 153         cb->expires_at  = xdr_decode_expiry(call, ntohl(*bp++));
 154         bp++; /* type */
 155         scb->have_cb    = true;
 156         *_bp = bp;
 157 }
 158
 159 /*
 160  * decode an AFSVolSync block
 161  */
 162 static void xdr_decode_AFSVolSync(const __be32 **_bp,
 163                                   struct afs_volsync *volsync)
 164 {
 165         const __be32 *bp = *_bp;
 166         u32 creation;
 167
 168         creation = ntohl(*bp++);
 169         bp++; /* spare2 */
 170         bp++; /* spare3 */
 171         bp++; /* spare4 */
 172         bp++; /* spare5 */
 173         bp++; /* spare6 */
 174         *_bp = bp;
 175
 176         if (volsync)
 177                 volsync->creation = creation;
 178 }
 179
 180 /*
 181  * encode the requested attributes into an AFSStoreStatus block
 182  */
 183 static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr)
 184 {
 185         __be32 *bp = *_bp;
 186         u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0;
 187
 188         mask = 0;
 189         if (attr->ia_valid & ATTR_MTIME) {
 190                 mask |= AFS_SET_MTIME;
 191                 mtime = attr->ia_mtime.tv_sec;
 192         }
 193
 194         if (attr->ia_valid & ATTR_UID) {
 195                 mask |= AFS_SET_OWNER;
 196                 owner = from_kuid(&init_user_ns, attr->ia_uid);
 197         }
 198
 199         if (attr->ia_valid & ATTR_GID) {
 200                 mask |= AFS_SET_GROUP;
 201                 group = from_kgid(&init_user_ns, attr->ia_gid);
 202         }
 203
 204         if (attr->ia_valid & ATTR_MODE) {
 205                 mask |= AFS_SET_MODE;
 206                 mode = attr->ia_mode & S_IALLUGO;
 207         }
 208
 209         *bp++ = htonl(mask);
 210         *bp++ = htonl(mtime);
 211         *bp++ = htonl(owner);
 212         *bp++ = htonl(group);
 213         *bp++ = htonl(mode);
 214         *bp++ = 0;              /* segment size */
 215         *_bp = bp;
 216 }
 217
 218 /*
 219  * decode an AFSFetchVolumeStatus block
 220  */
 221 static void xdr_decode_AFSFetchVolumeStatus(const __be32 **_bp,
 222                                             struct afs_volume_status *vs)
 223 {
 224         const __be32 *bp = *_bp;
 225
 226         vs->vid                 = ntohl(*bp++);
 227         vs->parent_id           = ntohl(*bp++);
 228         vs->online              = ntohl(*bp++);
 229         vs->in_service          = ntohl(*bp++);
 230         vs->blessed             = ntohl(*bp++);
 231         vs->needs_salvage       = ntohl(*bp++);
 232         vs->type                = ntohl(*bp++);
 233         vs->min_quota           = ntohl(*bp++);
 234         vs->max_quota           = ntohl(*bp++);
 235         vs->blocks_in_use       = ntohl(*bp++);
 236         vs->part_blocks_avail   = ntohl(*bp++);
 237         vs->part_max_blocks     = ntohl(*bp++);
 238         vs->vol_copy_date       = 0;
 239         vs->vol_backup_date     = 0;
 240         *_bp = bp;
 241 }
 242
 243 /*
 244  * deliver reply data to an FS.FetchStatus
 245  */
 246 static int afs_deliver_fs_fetch_status_vnode(struct afs_call *call)
 247 {
 248         const __be32 *bp;
 249         int ret;
 250
 251         ret = afs_transfer_reply(call);
 252         if (ret < 0)
 253                 return ret;
 254
 255         /* unmarshall the reply once we've received all of it */
 256         bp = call->buffer;
 257         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 258         if (ret < 0)
 259                 return ret;
 260         xdr_decode_AFSCallBack(&bp, call, call->out_scb);
 261         xdr_decode_AFSVolSync(&bp, call->out_volsync);
 262
 263         _leave(" = 0 [done]");
 264         return 0;
 265 }
 266
 267 /*
 268  * FS.FetchStatus operation type
 269  */
 270 static const struct afs_call_type afs_RXFSFetchStatus_vnode = {
 271         .name           = "FS.FetchStatus(vnode)",
 272         .op             = afs_FS_FetchStatus,
 273         .deliver        = afs_deliver_fs_fetch_status_vnode,
 274         .destructor     = afs_flat_call_destructor,
 275 };
 276
 277 /*
 278  * fetch the status information for a file
 279  */
 280 int afs_fs_fetch_file_status(struct afs_fs_cursor *fc, struct afs_status_cb *scb,
 281                              struct afs_volsync *volsync)
 282 {
 283         struct afs_vnode *vnode = fc->vnode;
 284         struct afs_call *call;
 285         struct afs_net *net = afs_v2net(vnode);
 286         __be32 *bp;
 287
 288         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 289                 return yfs_fs_fetch_file_status(fc, scb, volsync);
 290
 291         _enter(",%x,{%llx:%llu},,",
 292                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
 293
 294         call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus_vnode,
 295                                    16, (21 + 3 + 6) * 4);
 296         if (!call) {
 297                 fc->ac.error = -ENOMEM;
 298                 return -ENOMEM;
 299         }
 300
 301         call->key = fc->key;
 302         call->out_scb = scb;
 303         call->out_volsync = volsync;
 304
 305         /* marshall the parameters */
 306         bp = call->request;
 307         bp[0] = htonl(FSFETCHSTATUS);
 308         bp[1] = htonl(vnode->fid.vid);
 309         bp[2] = htonl(vnode->fid.vnode);
 310         bp[3] = htonl(vnode->fid.unique);
 311
 312         afs_use_fs_server(call, fc->cbi);
 313         trace_afs_make_fs_call(call, &vnode->fid);
 314
 315         afs_set_fc_call(call, fc);
 316         afs_make_call(&fc->ac, call, GFP_NOFS);
 317         return afs_wait_for_call_to_complete(call, &fc->ac);
 318 }
 319
 320 /*
 321  * deliver reply data to an FS.FetchData
 322  */
 323 static int afs_deliver_fs_fetch_data(struct afs_call *call)
 324 {
 325         struct afs_read *req = call->read_request;
 326         const __be32 *bp;
 327         unsigned int size;
 328         int ret;
 329
 330         _enter("{%u,%zu/%llu}",
 331                call->unmarshall, iov_iter_count(call->iter), req->actual_len);
 332
 333         switch (call->unmarshall) {
 334         case 0:
 335                 req->actual_len = 0;
 336                 req->index = 0;
 337                 req->offset = req->pos & (PAGE_SIZE - 1);
 338                 call->unmarshall++;
 339                 if (call->operation_ID == FSFETCHDATA64) {
 340                         afs_extract_to_tmp64(call);
 341                 } else {
 342                         call->tmp_u = htonl(0);
 343                         afs_extract_to_tmp(call);
 344                 }
 345                 /* Fall through */
 346
 347                 /* 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->def_iter, READ, call->bvec, 1, size);
 372                 ASSERTCMP(size, <=, PAGE_SIZE);
 373                 /* Fall through */
 374
 375                 /* extract the returned data */
 376         case 2:
 377                 _debug("extract data %zu/%llu",
 378                        iov_iter_count(call->iter), req->remain);
 379
 380                 ret = afs_extract_data(call, true);
 381                 if (ret < 0)
 382                         return ret;
 383                 req->remain -= call->bvec[0].bv_len;
 384                 req->offset += call->bvec[0].bv_len;
 385                 ASSERTCMP(req->offset, <=, PAGE_SIZE);
 386                 if (req->offset == PAGE_SIZE) {
 387                         req->offset = 0;
 388                         req->index++;
 389                         if (req->remain > 0)
 390                                 goto begin_page;
 391                 }
 392
 393                 ASSERTCMP(req->remain, ==, 0);
 394                 if (req->actual_len <= req->len)
 395                         goto no_more_data;
 396
 397                 /* Discard any excess data the server gave us */
 398                 afs_extract_discard(call, req->actual_len - req->len);
 399                 call->unmarshall = 3;
 400                 /* Fall through */
 401
 402         case 3:
 403                 _debug("extract discard %zu/%llu",
 404                        iov_iter_count(call->iter), req->actual_len - req->len);
 405
 406                 ret = afs_extract_data(call, true);
 407                 if (ret < 0)
 408                         return ret;
 409
 410         no_more_data:
 411                 call->unmarshall = 4;
 412                 afs_extract_to_buf(call, (21 + 3 + 6) * 4);
 413                 /* Fall through */
 414
 415                 /* 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                 req->offset = 0;
 442         }
 443
 444         if (req->page_done)
 445                 for (req->index = 0; req->index < req->nr_pages; req->index++)
 446                         req->page_done(req);
 447
 448         _leave(" = 0 [done]");
 449         return 0;
 450 }
 451
 452 static void afs_fetch_data_destructor(struct afs_call *call)
 453 {
 454         struct afs_read *req = call->read_request;
 455
 456         afs_put_read(req);
 457         afs_flat_call_destructor(call);
 458 }
 459
 460 /*
 461  * FS.FetchData operation type
 462  */
 463 static const struct afs_call_type afs_RXFSFetchData = {
 464         .name           = "FS.FetchData",
 465         .op             = afs_FS_FetchData,
 466         .deliver        = afs_deliver_fs_fetch_data,
 467         .destructor     = afs_fetch_data_destructor,
 468 };
 469
 470 static const struct afs_call_type afs_RXFSFetchData64 = {
 471         .name           = "FS.FetchData64",
 472         .op             = afs_FS_FetchData64,
 473         .deliver        = afs_deliver_fs_fetch_data,
 474         .destructor     = afs_fetch_data_destructor,
 475 };
 476
 477 /*
 478  * fetch data from a very large file
 479  */
 480 static int afs_fs_fetch_data64(struct afs_fs_cursor *fc,
 481                                struct afs_status_cb *scb,
 482                                struct afs_read *req)
 483 {
 484         struct afs_vnode *vnode = fc->vnode;
 485         struct afs_call *call;
 486         struct afs_net *net = afs_v2net(vnode);
 487         __be32 *bp;
 488
 489         _enter("");
 490
 491         call = afs_alloc_flat_call(net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
 492         if (!call)
 493                 return -ENOMEM;
 494
 495         call->key = fc->key;
 496         call->out_scb = scb;
 497         call->out_volsync = NULL;
 498         call->read_request = afs_get_read(req);
 499
 500         /* marshall the parameters */
 501         bp = call->request;
 502         bp[0] = htonl(FSFETCHDATA64);
 503         bp[1] = htonl(vnode->fid.vid);
 504         bp[2] = htonl(vnode->fid.vnode);
 505         bp[3] = htonl(vnode->fid.unique);
 506         bp[4] = htonl(upper_32_bits(req->pos));
 507         bp[5] = htonl(lower_32_bits(req->pos));
 508         bp[6] = 0;
 509         bp[7] = htonl(lower_32_bits(req->len));
 510
 511         afs_use_fs_server(call, fc->cbi);
 512         trace_afs_make_fs_call(call, &vnode->fid);
 513         afs_set_fc_call(call, fc);
 514         afs_make_call(&fc->ac, call, GFP_NOFS);
 515         return afs_wait_for_call_to_complete(call, &fc->ac);
 516 }
 517
 518 /*
 519  * fetch data from a file
 520  */
 521 int afs_fs_fetch_data(struct afs_fs_cursor *fc,
 522                       struct afs_status_cb *scb,
 523                       struct afs_read *req)
 524 {
 525         struct afs_vnode *vnode = fc->vnode;
 526         struct afs_call *call;
 527         struct afs_net *net = afs_v2net(vnode);
 528         __be32 *bp;
 529
 530         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
 531                 return yfs_fs_fetch_data(fc, scb, req);
 532
 533         if (upper_32_bits(req->pos) ||
 534             upper_32_bits(req->len) ||
 535             upper_32_bits(req->pos + req->len))
 536                 return afs_fs_fetch_data64(fc, scb, req);
 537
 538         _enter("");
 539
 540         call = afs_alloc_flat_call(net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
 541         if (!call)
 542                 return -ENOMEM;
 543
 544         call->key = fc->key;
 545         call->out_scb = scb;
 546         call->out_volsync = NULL;
 547         call->read_request = afs_get_read(req);
 548
 549         /* marshall the parameters */
 550         bp = call->request;
 551         bp[0] = htonl(FSFETCHDATA);
 552         bp[1] = htonl(vnode->fid.vid);
 553         bp[2] = htonl(vnode->fid.vnode);
 554         bp[3] = htonl(vnode->fid.unique);
 555         bp[4] = htonl(lower_32_bits(req->pos));
 556         bp[5] = htonl(lower_32_bits(req->len));
 557
 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         /* If the two dirs are the same, we have two copies of the same status
 990          * report, so we just decode it twice.
 991          */
 992         bp = call->buffer;
 993         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_dir_scb);
 994         if (ret < 0)
 995                 return ret;
 996         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
 997         if (ret < 0)
 998                 return ret;
 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                 /* Fall through */
1479
1480                 /* extract the returned status record */
1481         case 1:
1482                 _debug("extract status");
1483                 ret = afs_extract_data(call, true);
1484                 if (ret < 0)
1485                         return ret;
1486
1487                 bp = call->buffer;
1488                 xdr_decode_AFSFetchVolumeStatus(&bp, call->out_volstatus);
1489                 call->unmarshall++;
1490                 afs_extract_to_tmp(call);
1491                 /* Fall through */
1492
1493                 /* extract the volume name length */
1494         case 2:
1495                 ret = afs_extract_data(call, true);
1496                 if (ret < 0)
1497                         return ret;
1498
1499                 call->count = ntohl(call->tmp);
1500                 _debug("volname length: %u", call->count);
1501                 if (call->count >= AFSNAMEMAX)
1502                         return afs_protocol_error(call, -EBADMSG,
1503                                                   afs_eproto_volname_len);
1504                 size = (call->count + 3) & ~3; /* It's padded */
1505                 afs_extract_to_buf(call, size);
1506                 call->unmarshall++;
1507                 /* Fall through */
1508
1509                 /* extract the volume name */
1510         case 3:
1511                 _debug("extract volname");
1512                 ret = afs_extract_data(call, true);
1513                 if (ret < 0)
1514                         return ret;
1515
1516                 p = call->buffer;
1517                 p[call->count] = 0;
1518                 _debug("volname '%s'", p);
1519                 afs_extract_to_tmp(call);
1520                 call->unmarshall++;
1521                 /* Fall through */
1522
1523                 /* extract the offline message length */
1524         case 4:
1525                 ret = afs_extract_data(call, true);
1526                 if (ret < 0)
1527                         return ret;
1528
1529                 call->count = ntohl(call->tmp);
1530                 _debug("offline msg length: %u", call->count);
1531                 if (call->count >= AFSNAMEMAX)
1532                         return afs_protocol_error(call, -EBADMSG,
1533                                                   afs_eproto_offline_msg_len);
1534                 size = (call->count + 3) & ~3; /* It's padded */
1535                 afs_extract_to_buf(call, size);
1536                 call->unmarshall++;
1537                 /* Fall through */
1538
1539                 /* extract the offline message */
1540         case 5:
1541                 _debug("extract offline");
1542                 ret = afs_extract_data(call, true);
1543                 if (ret < 0)
1544                         return ret;
1545
1546                 p = call->buffer;
1547                 p[call->count] = 0;
1548                 _debug("offline '%s'", p);
1549
1550                 afs_extract_to_tmp(call);
1551                 call->unmarshall++;
1552                 /* Fall through */
1553
1554                 /* extract the message of the day length */
1555         case 6:
1556                 ret = afs_extract_data(call, true);
1557                 if (ret < 0)
1558                         return ret;
1559
1560                 call->count = ntohl(call->tmp);
1561                 _debug("motd length: %u", call->count);
1562                 if (call->count >= AFSNAMEMAX)
1563                         return afs_protocol_error(call, -EBADMSG,
1564                                                   afs_eproto_motd_len);
1565                 size = (call->count + 3) & ~3; /* It's padded */
1566                 afs_extract_to_buf(call, size);
1567                 call->unmarshall++;
1568                 /* Fall through */
1569
1570                 /* extract the message of the day */
1571         case 7:
1572                 _debug("extract motd");
1573                 ret = afs_extract_data(call, false);
1574                 if (ret < 0)
1575                         return ret;
1576
1577                 p = call->buffer;
1578                 p[call->count] = 0;
1579                 _debug("motd '%s'", p);
1580
1581                 call->unmarshall++;
1582
1583         case 8:
1584                 break;
1585         }
1586
1587         _leave(" = 0 [done]");
1588         return 0;
1589 }
1590
1591 /*
1592  * FS.GetVolumeStatus operation type
1593  */
1594 static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1595         .name           = "FS.GetVolumeStatus",
1596         .op             = afs_FS_GetVolumeStatus,
1597         .deliver        = afs_deliver_fs_get_volume_status,
1598         .destructor     = afs_flat_call_destructor,
1599 };
1600
1601 /*
1602  * fetch the status of a volume
1603  */
1604 int afs_fs_get_volume_status(struct afs_fs_cursor *fc,
1605                              struct afs_volume_status *vs)
1606 {
1607         struct afs_vnode *vnode = fc->vnode;
1608         struct afs_call *call;
1609         struct afs_net *net = afs_v2net(vnode);
1610         __be32 *bp;
1611
1612         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1613                 return yfs_fs_get_volume_status(fc, vs);
1614
1615         _enter("");
1616
1617         call = afs_alloc_flat_call(net, &afs_RXFSGetVolumeStatus, 2 * 4,
1618                                    max(12 * 4, AFSOPAQUEMAX + 1));
1619         if (!call)
1620                 return -ENOMEM;
1621
1622         call->key = fc->key;
1623         call->out_volstatus = vs;
1624
1625         /* marshall the parameters */
1626         bp = call->request;
1627         bp[0] = htonl(FSGETVOLUMESTATUS);
1628         bp[1] = htonl(vnode->fid.vid);
1629
1630         afs_use_fs_server(call, fc->cbi);
1631         trace_afs_make_fs_call(call, &vnode->fid);
1632         afs_set_fc_call(call, fc);
1633         afs_make_call(&fc->ac, call, GFP_NOFS);
1634         return afs_wait_for_call_to_complete(call, &fc->ac);
1635 }
1636
1637 /*
1638  * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
1639  */
1640 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1641 {
1642         const __be32 *bp;
1643         int ret;
1644
1645         _enter("{%u}", call->unmarshall);
1646
1647         ret = afs_transfer_reply(call);
1648         if (ret < 0)
1649                 return ret;
1650
1651         /* unmarshall the reply once we've received all of it */
1652         bp = call->buffer;
1653         xdr_decode_AFSVolSync(&bp, call->out_volsync);
1654
1655         _leave(" = 0 [done]");
1656         return 0;
1657 }
1658
1659 /*
1660  * FS.SetLock operation type
1661  */
1662 static const struct afs_call_type afs_RXFSSetLock = {
1663         .name           = "FS.SetLock",
1664         .op             = afs_FS_SetLock,
1665         .deliver        = afs_deliver_fs_xxxx_lock,
1666         .done           = afs_lock_op_done,
1667         .destructor     = afs_flat_call_destructor,
1668 };
1669
1670 /*
1671  * FS.ExtendLock operation type
1672  */
1673 static const struct afs_call_type afs_RXFSExtendLock = {
1674         .name           = "FS.ExtendLock",
1675         .op             = afs_FS_ExtendLock,
1676         .deliver        = afs_deliver_fs_xxxx_lock,
1677         .done           = afs_lock_op_done,
1678         .destructor     = afs_flat_call_destructor,
1679 };
1680
1681 /*
1682  * FS.ReleaseLock operation type
1683  */
1684 static const struct afs_call_type afs_RXFSReleaseLock = {
1685         .name           = "FS.ReleaseLock",
1686         .op             = afs_FS_ReleaseLock,
1687         .deliver        = afs_deliver_fs_xxxx_lock,
1688         .destructor     = afs_flat_call_destructor,
1689 };
1690
1691 /*
1692  * Set a lock on a file
1693  */
1694 int afs_fs_set_lock(struct afs_fs_cursor *fc, afs_lock_type_t type,
1695                     struct afs_status_cb *scb)
1696 {
1697         struct afs_vnode *vnode = fc->vnode;
1698         struct afs_call *call;
1699         struct afs_net *net = afs_v2net(vnode);
1700         __be32 *bp;
1701
1702         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1703                 return yfs_fs_set_lock(fc, type, scb);
1704
1705         _enter("");
1706
1707         call = afs_alloc_flat_call(net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1708         if (!call)
1709                 return -ENOMEM;
1710
1711         call->key = fc->key;
1712         call->lvnode = vnode;
1713         call->out_scb = scb;
1714
1715         /* marshall the parameters */
1716         bp = call->request;
1717         *bp++ = htonl(FSSETLOCK);
1718         *bp++ = htonl(vnode->fid.vid);
1719         *bp++ = htonl(vnode->fid.vnode);
1720         *bp++ = htonl(vnode->fid.unique);
1721         *bp++ = htonl(type);
1722
1723         afs_use_fs_server(call, fc->cbi);
1724         trace_afs_make_fs_calli(call, &vnode->fid, type);
1725         afs_set_fc_call(call, fc);
1726         afs_make_call(&fc->ac, call, GFP_NOFS);
1727         return afs_wait_for_call_to_complete(call, &fc->ac);
1728 }
1729
1730 /*
1731  * extend a lock on a file
1732  */
1733 int afs_fs_extend_lock(struct afs_fs_cursor *fc, struct afs_status_cb *scb)
1734 {
1735         struct afs_vnode *vnode = fc->vnode;
1736         struct afs_call *call;
1737         struct afs_net *net = afs_v2net(vnode);
1738         __be32 *bp;
1739
1740         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1741                 return yfs_fs_extend_lock(fc, scb);
1742
1743         _enter("");
1744
1745         call = afs_alloc_flat_call(net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1746         if (!call)
1747                 return -ENOMEM;
1748
1749         call->key = fc->key;
1750         call->lvnode = vnode;
1751         call->out_scb = scb;
1752
1753         /* marshall the parameters */
1754         bp = call->request;
1755         *bp++ = htonl(FSEXTENDLOCK);
1756         *bp++ = htonl(vnode->fid.vid);
1757         *bp++ = htonl(vnode->fid.vnode);
1758         *bp++ = htonl(vnode->fid.unique);
1759
1760         afs_use_fs_server(call, fc->cbi);
1761         trace_afs_make_fs_call(call, &vnode->fid);
1762         afs_set_fc_call(call, fc);
1763         afs_make_call(&fc->ac, call, GFP_NOFS);
1764         return afs_wait_for_call_to_complete(call, &fc->ac);
1765 }
1766
1767 /*
1768  * release a lock on a file
1769  */
1770 int afs_fs_release_lock(struct afs_fs_cursor *fc, struct afs_status_cb *scb)
1771 {
1772         struct afs_vnode *vnode = fc->vnode;
1773         struct afs_call *call;
1774         struct afs_net *net = afs_v2net(vnode);
1775         __be32 *bp;
1776
1777         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1778                 return yfs_fs_release_lock(fc, scb);
1779
1780         _enter("");
1781
1782         call = afs_alloc_flat_call(net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1783         if (!call)
1784                 return -ENOMEM;
1785
1786         call->key = fc->key;
1787         call->lvnode = vnode;
1788         call->out_scb = scb;
1789
1790         /* marshall the parameters */
1791         bp = call->request;
1792         *bp++ = htonl(FSRELEASELOCK);
1793         *bp++ = htonl(vnode->fid.vid);
1794         *bp++ = htonl(vnode->fid.vnode);
1795         *bp++ = htonl(vnode->fid.unique);
1796
1797         afs_use_fs_server(call, fc->cbi);
1798         trace_afs_make_fs_call(call, &vnode->fid);
1799         afs_set_fc_call(call, fc);
1800         afs_make_call(&fc->ac, call, GFP_NOFS);
1801         return afs_wait_for_call_to_complete(call, &fc->ac);
1802 }
1803
1804 /*
1805  * Deliver reply data to an FS.GiveUpAllCallBacks operation.
1806  */
1807 static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1808 {
1809         return afs_transfer_reply(call);
1810 }
1811
1812 /*
1813  * FS.GiveUpAllCallBacks operation type
1814  */
1815 static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = {
1816         .name           = "FS.GiveUpAllCallBacks",
1817         .op             = afs_FS_GiveUpAllCallBacks,
1818         .deliver        = afs_deliver_fs_give_up_all_callbacks,
1819         .destructor     = afs_flat_call_destructor,
1820 };
1821
1822 /*
1823  * Flush all the callbacks we have on a server.
1824  */
1825 int afs_fs_give_up_all_callbacks(struct afs_net *net,
1826                                  struct afs_server *server,
1827                                  struct afs_addr_cursor *ac,
1828                                  struct key *key)
1829 {
1830         struct afs_call *call;
1831         __be32 *bp;
1832
1833         _enter("");
1834
1835         call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1836         if (!call)
1837                 return -ENOMEM;
1838
1839         call->key = key;
1840
1841         /* marshall the parameters */
1842         bp = call->request;
1843         *bp++ = htonl(FSGIVEUPALLCALLBACKS);
1844
1845         /* Can't take a ref on server */
1846         afs_make_call(ac, call, GFP_NOFS);
1847         return afs_wait_for_call_to_complete(call, ac);
1848 }
1849
1850 /*
1851  * Deliver reply data to an FS.GetCapabilities operation.
1852  */
1853 static int afs_deliver_fs_get_capabilities(struct afs_call *call)
1854 {
1855         u32 count;
1856         int ret;
1857
1858         _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));
1859
1860         switch (call->unmarshall) {
1861         case 0:
1862                 afs_extract_to_tmp(call);
1863                 call->unmarshall++;
1864                 /* Fall through */
1865
1866                 /* Extract the capabilities word count */
1867         case 1:
1868                 ret = afs_extract_data(call, true);
1869                 if (ret < 0)
1870                         return ret;
1871
1872                 count = ntohl(call->tmp);
1873
1874                 call->count = count;
1875                 call->count2 = count;
1876                 afs_extract_discard(call, count * sizeof(__be32));
1877                 call->unmarshall++;
1878                 /* Fall through */
1879
1880                 /* Extract capabilities words */
1881         case 2:
1882                 ret = afs_extract_data(call, false);
1883                 if (ret < 0)
1884                         return ret;
1885
1886                 /* TODO: Examine capabilities */
1887
1888                 call->unmarshall++;
1889                 break;
1890         }
1891
1892         _leave(" = 0 [done]");
1893         return 0;
1894 }
1895
1896 /*
1897  * FS.GetCapabilities operation type
1898  */
1899 static const struct afs_call_type afs_RXFSGetCapabilities = {
1900         .name           = "FS.GetCapabilities",
1901         .op             = afs_FS_GetCapabilities,
1902         .deliver        = afs_deliver_fs_get_capabilities,
1903         .done           = afs_fileserver_probe_result,
1904         .destructor     = afs_flat_call_destructor,
1905 };
1906
1907 /*
1908  * Probe a fileserver for the capabilities that it supports.  This can
1909  * return up to 196 words.
1910  */
1911 struct afs_call *afs_fs_get_capabilities(struct afs_net *net,
1912                                          struct afs_server *server,
1913                                          struct afs_addr_cursor *ac,
1914                                          struct key *key,
1915                                          unsigned int server_index)
1916 {
1917         struct afs_call *call;
1918         __be32 *bp;
1919
1920         _enter("");
1921
1922         call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
1923         if (!call)
1924                 return ERR_PTR(-ENOMEM);
1925
1926         call->key = key;
1927         call->server = afs_get_server(server, afs_server_trace_get_caps);
1928         call->server_index = server_index;
1929         call->upgrade = true;
1930         call->async = true;
1931         call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
1932
1933         /* marshall the parameters */
1934         bp = call->request;
1935         *bp++ = htonl(FSGETCAPABILITIES);
1936
1937         /* Can't take a ref on server */
1938         trace_afs_make_fs_call(call, NULL);
1939         afs_make_call(ac, call, GFP_NOFS);
1940         return call;
1941 }
1942
1943 /*
1944  * Deliver reply data to an FS.FetchStatus with no vnode.
1945  */
1946 static int afs_deliver_fs_fetch_status(struct afs_call *call)
1947 {
1948         const __be32 *bp;
1949         int ret;
1950
1951         ret = afs_transfer_reply(call);
1952         if (ret < 0)
1953                 return ret;
1954
1955         /* unmarshall the reply once we've received all of it */
1956         bp = call->buffer;
1957         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
1958         if (ret < 0)
1959                 return ret;
1960         xdr_decode_AFSCallBack(&bp, call, call->out_scb);
1961         xdr_decode_AFSVolSync(&bp, call->out_volsync);
1962
1963         _leave(" = 0 [done]");
1964         return 0;
1965 }
1966
1967 /*
1968  * FS.FetchStatus operation type
1969  */
1970 static const struct afs_call_type afs_RXFSFetchStatus = {
1971         .name           = "FS.FetchStatus",
1972         .op             = afs_FS_FetchStatus,
1973         .deliver        = afs_deliver_fs_fetch_status,
1974         .destructor     = afs_flat_call_destructor,
1975 };
1976
1977 /*
1978  * Fetch the status information for a fid without needing a vnode handle.
1979  */
1980 int afs_fs_fetch_status(struct afs_fs_cursor *fc,
1981                         struct afs_net *net,
1982                         struct afs_fid *fid,
1983                         struct afs_status_cb *scb,
1984                         struct afs_volsync *volsync)
1985 {
1986         struct afs_call *call;
1987         __be32 *bp;
1988
1989         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
1990                 return yfs_fs_fetch_status(fc, net, fid, scb, volsync);
1991
1992         _enter(",%x,{%llx:%llu},,",
1993                key_serial(fc->key), fid->vid, fid->vnode);
1994
1995         call = afs_alloc_flat_call(net, &afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4);
1996         if (!call) {
1997                 fc->ac.error = -ENOMEM;
1998                 return -ENOMEM;
1999         }
2000
2001         call->key = fc->key;
2002         call->out_fid = fid;
2003         call->out_scb = scb;
2004         call->out_volsync = volsync;
2005
2006         /* marshall the parameters */
2007         bp = call->request;
2008         bp[0] = htonl(FSFETCHSTATUS);
2009         bp[1] = htonl(fid->vid);
2010         bp[2] = htonl(fid->vnode);
2011         bp[3] = htonl(fid->unique);
2012
2013         afs_use_fs_server(call, fc->cbi);
2014         trace_afs_make_fs_call(call, fid);
2015         afs_set_fc_call(call, fc);
2016         afs_make_call(&fc->ac, call, GFP_NOFS);
2017         return afs_wait_for_call_to_complete(call, &fc->ac);
2018 }
2019
2020 /*
2021  * Deliver reply data to an FS.InlineBulkStatus call
2022  */
2023 static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
2024 {
2025         struct afs_status_cb *scb;
2026         const __be32 *bp;
2027         u32 tmp;
2028         int ret;
2029
2030         _enter("{%u}", call->unmarshall);
2031
2032         switch (call->unmarshall) {
2033         case 0:
2034                 afs_extract_to_tmp(call);
2035                 call->unmarshall++;
2036                 /* Fall through */
2037
2038                 /* Extract the file status count and array in two steps */
2039         case 1:
2040                 _debug("extract status count");
2041                 ret = afs_extract_data(call, true);
2042                 if (ret < 0)
2043                         return ret;
2044
2045                 tmp = ntohl(call->tmp);
2046                 _debug("status count: %u/%u", tmp, call->count2);
2047                 if (tmp != call->count2)
2048                         return afs_protocol_error(call, -EBADMSG,
2049                                                   afs_eproto_ibulkst_count);
2050
2051                 call->count = 0;
2052                 call->unmarshall++;
2053         more_counts:
2054                 afs_extract_to_buf(call, 21 * sizeof(__be32));
2055                 /* Fall through */
2056
2057         case 2:
2058                 _debug("extract status array %u", call->count);
2059                 ret = afs_extract_data(call, true);
2060                 if (ret < 0)
2061                         return ret;
2062
2063                 bp = call->buffer;
2064                 scb = &call->out_scb[call->count];
2065                 ret = xdr_decode_AFSFetchStatus(&bp, call, scb);
2066                 if (ret < 0)
2067                         return ret;
2068
2069                 call->count++;
2070                 if (call->count < call->count2)
2071                         goto more_counts;
2072
2073                 call->count = 0;
2074                 call->unmarshall++;
2075                 afs_extract_to_tmp(call);
2076                 /* Fall through */
2077
2078                 /* Extract the callback count and array in two steps */
2079         case 3:
2080                 _debug("extract CB count");
2081                 ret = afs_extract_data(call, true);
2082                 if (ret < 0)
2083                         return ret;
2084
2085                 tmp = ntohl(call->tmp);
2086                 _debug("CB count: %u", tmp);
2087                 if (tmp != call->count2)
2088                         return afs_protocol_error(call, -EBADMSG,
2089                                                   afs_eproto_ibulkst_cb_count);
2090                 call->count = 0;
2091                 call->unmarshall++;
2092         more_cbs:
2093                 afs_extract_to_buf(call, 3 * sizeof(__be32));
2094                 /* Fall through */
2095
2096         case 4:
2097                 _debug("extract CB array");
2098                 ret = afs_extract_data(call, true);
2099                 if (ret < 0)
2100                         return ret;
2101
2102                 _debug("unmarshall CB array");
2103                 bp = call->buffer;
2104                 scb = &call->out_scb[call->count];
2105                 xdr_decode_AFSCallBack(&bp, call, scb);
2106                 call->count++;
2107                 if (call->count < call->count2)
2108                         goto more_cbs;
2109
2110                 afs_extract_to_buf(call, 6 * sizeof(__be32));
2111                 call->unmarshall++;
2112                 /* Fall through */
2113
2114         case 5:
2115                 ret = afs_extract_data(call, false);
2116                 if (ret < 0)
2117                         return ret;
2118
2119                 bp = call->buffer;
2120                 xdr_decode_AFSVolSync(&bp, call->out_volsync);
2121
2122                 call->unmarshall++;
2123
2124         case 6:
2125                 break;
2126         }
2127
2128         _leave(" = 0 [done]");
2129         return 0;
2130 }
2131
2132 /*
2133  * FS.InlineBulkStatus operation type
2134  */
2135 static const struct afs_call_type afs_RXFSInlineBulkStatus = {
2136         .name           = "FS.InlineBulkStatus",
2137         .op             = afs_FS_InlineBulkStatus,
2138         .deliver        = afs_deliver_fs_inline_bulk_status,
2139         .destructor     = afs_flat_call_destructor,
2140 };
2141
2142 /*
2143  * Fetch the status information for up to 50 files
2144  */
2145 int afs_fs_inline_bulk_status(struct afs_fs_cursor *fc,
2146                               struct afs_net *net,
2147                               struct afs_fid *fids,
2148                               struct afs_status_cb *statuses,
2149                               unsigned int nr_fids,
2150                               struct afs_volsync *volsync)
2151 {
2152         struct afs_call *call;
2153         __be32 *bp;
2154         int i;
2155
2156         if (test_bit(AFS_SERVER_FL_IS_YFS, &fc->cbi->server->flags))
2157                 return yfs_fs_inline_bulk_status(fc, net, fids, statuses,
2158                                                  nr_fids, volsync);
2159
2160         _enter(",%x,{%llx:%llu},%u",
2161                key_serial(fc->key), fids[0].vid, fids[1].vnode, nr_fids);
2162
2163         call = afs_alloc_flat_call(net, &afs_RXFSInlineBulkStatus,
2164                                    (2 + nr_fids * 3) * 4,
2165                                    21 * 4);
2166         if (!call) {
2167                 fc->ac.error = -ENOMEM;
2168                 return -ENOMEM;
2169         }
2170
2171         call->key = fc->key;
2172         call->out_scb = statuses;
2173         call->out_volsync = volsync;
2174         call->count2 = nr_fids;
2175
2176         /* marshall the parameters */
2177         bp = call->request;
2178         *bp++ = htonl(FSINLINEBULKSTATUS);
2179         *bp++ = htonl(nr_fids);
2180         for (i = 0; i < nr_fids; i++) {
2181                 *bp++ = htonl(fids[i].vid);
2182                 *bp++ = htonl(fids[i].vnode);
2183                 *bp++ = htonl(fids[i].unique);
2184         }
2185
2186         afs_use_fs_server(call, fc->cbi);
2187         trace_afs_make_fs_call(call, &fids[0]);
2188         afs_set_fc_call(call, fc);
2189         afs_make_call(&fc->ac, call, GFP_NOFS);
2190         return afs_wait_for_call_to_complete(call, &fc->ac);
2191 }
2192
2193 /*
2194  * deliver reply data to an FS.FetchACL
2195  */
2196 static int afs_deliver_fs_fetch_acl(struct afs_call *call)
2197 {
2198         struct afs_acl *acl;
2199         const __be32 *bp;
2200         unsigned int size;
2201         int ret;
2202
2203         _enter("{%u}", call->unmarshall);
2204
2205         switch (call->unmarshall) {
2206         case 0:
2207                 afs_extract_to_tmp(call);
2208                 call->unmarshall++;
2209                 /* Fall through */
2210
2211                 /* extract the returned data length */
2212         case 1:
2213                 ret = afs_extract_data(call, true);
2214                 if (ret < 0)
2215                         return ret;
2216
2217                 size = call->count2 = ntohl(call->tmp);
2218                 size = round_up(size, 4);
2219
2220                 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
2221                 if (!acl)
2222                         return -ENOMEM;
2223                 call->ret_acl = acl;
2224                 acl->size = call->count2;
2225                 afs_extract_begin(call, acl->data, size);
2226                 call->unmarshall++;
2227                 /* Fall through */
2228
2229                 /* extract the returned data */
2230         case 2:
2231                 ret = afs_extract_data(call, true);
2232                 if (ret < 0)
2233                         return ret;
2234
2235                 afs_extract_to_buf(call, (21 + 6) * 4);
2236                 call->unmarshall++;
2237                 /* Fall through */
2238
2239                 /* extract the metadata */
2240         case 3:
2241                 ret = afs_extract_data(call, false);
2242                 if (ret < 0)
2243                         return ret;
2244
2245                 bp = call->buffer;
2246                 ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
2247                 if (ret < 0)
2248                         return ret;
2249                 xdr_decode_AFSVolSync(&bp, call->out_volsync);
2250
2251                 call->unmarshall++;
2252
2253         case 4:
2254                 break;
2255         }
2256
2257         _leave(" = 0 [done]");
2258         return 0;
2259 }
2260
2261 static void afs_destroy_fs_fetch_acl(struct afs_call *call)
2262 {
2263         kfree(call->ret_acl);
2264         afs_flat_call_destructor(call);
2265 }
2266
2267 /*
2268  * FS.FetchACL operation type
2269  */
2270 static const struct afs_call_type afs_RXFSFetchACL = {
2271         .name           = "FS.FetchACL",
2272         .op             = afs_FS_FetchACL,
2273         .deliver        = afs_deliver_fs_fetch_acl,
2274         .destructor     = afs_destroy_fs_fetch_acl,
2275 };
2276
2277 /*
2278  * Fetch the ACL for a file.
2279  */
2280 struct afs_acl *afs_fs_fetch_acl(struct afs_fs_cursor *fc,
2281                                  struct afs_status_cb *scb)
2282 {
2283         struct afs_vnode *vnode = fc->vnode;
2284         struct afs_call *call;
2285         struct afs_net *net = afs_v2net(vnode);
2286         __be32 *bp;
2287
2288         _enter(",%x,{%llx:%llu},,",
2289                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
2290
2291         call = afs_alloc_flat_call(net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
2292         if (!call) {
2293                 fc->ac.error = -ENOMEM;
2294                 return ERR_PTR(-ENOMEM);
2295         }
2296
2297         call->key = fc->key;
2298         call->ret_acl = NULL;
2299         call->out_scb = scb;
2300         call->out_volsync = NULL;
2301
2302         /* marshall the parameters */
2303         bp = call->request;
2304         bp[0] = htonl(FSFETCHACL);
2305         bp[1] = htonl(vnode->fid.vid);
2306         bp[2] = htonl(vnode->fid.vnode);
2307         bp[3] = htonl(vnode->fid.unique);
2308
2309         afs_use_fs_server(call, fc->cbi);
2310         trace_afs_make_fs_call(call, &vnode->fid);
2311         afs_make_call(&fc->ac, call, GFP_KERNEL);
2312         return (struct afs_acl *)afs_wait_for_call_to_complete(call, &fc->ac);
2313 }
2314
2315 /*
2316  * Deliver reply data to any operation that returns file status and volume
2317  * sync.
2318  */
2319 static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
2320 {
2321         const __be32 *bp;
2322         int ret;
2323
2324         ret = afs_transfer_reply(call);
2325         if (ret < 0)
2326                 return ret;
2327
2328         bp = call->buffer;
2329         ret = xdr_decode_AFSFetchStatus(&bp, call, call->out_scb);
2330         if (ret < 0)
2331                 return ret;
2332         xdr_decode_AFSVolSync(&bp, call->out_volsync);
2333
2334         _leave(" = 0 [done]");
2335         return 0;
2336 }
2337
2338 /*
2339  * FS.StoreACL operation type
2340  */
2341 static const struct afs_call_type afs_RXFSStoreACL = {
2342         .name           = "FS.StoreACL",
2343         .op             = afs_FS_StoreACL,
2344         .deliver        = afs_deliver_fs_file_status_and_vol,
2345         .destructor     = afs_flat_call_destructor,
2346 };
2347
2348 /*
2349  * Fetch the ACL for a file.
2350  */
2351 int afs_fs_store_acl(struct afs_fs_cursor *fc, const struct afs_acl *acl,
2352                      struct afs_status_cb *scb)
2353 {
2354         struct afs_vnode *vnode = fc->vnode;
2355         struct afs_call *call;
2356         struct afs_net *net = afs_v2net(vnode);
2357         size_t size;
2358         __be32 *bp;
2359
2360         _enter(",%x,{%llx:%llu},,",
2361                key_serial(fc->key), vnode->fid.vid, vnode->fid.vnode);
2362
2363         size = round_up(acl->size, 4);
2364         call = afs_alloc_flat_call(net, &afs_RXFSStoreACL,
2365                                    5 * 4 + size, (21 + 6) * 4);
2366         if (!call) {
2367                 fc->ac.error = -ENOMEM;
2368                 return -ENOMEM;
2369         }
2370
2371         call->key = fc->key;
2372         call->out_scb = scb;
2373         call->out_volsync = NULL;
2374
2375         /* marshall the parameters */
2376         bp = call->request;
2377         bp[0] = htonl(FSSTOREACL);
2378         bp[1] = htonl(vnode->fid.vid);
2379         bp[2] = htonl(vnode->fid.vnode);
2380         bp[3] = htonl(vnode->fid.unique);
2381         bp[4] = htonl(acl->size);
2382         memcpy(&bp[5], acl->data, acl->size);
2383         if (acl->size != size)
2384                 memset((void *)&bp[5] + acl->size, 0, size - acl->size);
2385
2386         trace_afs_make_fs_call(call, &vnode->fid);
2387         afs_make_call(&fc->ac, call, GFP_KERNEL);
2388         return afs_wait_for_call_to_complete(call, &fc->ac);
2389 }