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