1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* YFS File Server client stubs 3 * 4 * Copyright (C) 2018 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 #define xdr_size(x) (sizeof(*x) / sizeof(__be32)) 19 20 static void xdr_decode_YFSFid(const __be32 **_bp, struct afs_fid *fid) 21 { 22 const struct yfs_xdr_YFSFid *x = (const void *)*_bp; 23 24 fid->vid = xdr_to_u64(x->volume); 25 fid->vnode = xdr_to_u64(x->vnode.lo); 26 fid->vnode_hi = ntohl(x->vnode.hi); 27 fid->unique = ntohl(x->vnode.unique); 28 *_bp += xdr_size(x); 29 } 30 31 static __be32 *xdr_encode_u32(__be32 *bp, u32 n) 32 { 33 *bp++ = htonl(n); 34 return bp; 35 } 36 37 static __be32 *xdr_encode_u64(__be32 *bp, u64 n) 38 { 39 struct yfs_xdr_u64 *x = (void *)bp; 40 41 *x = u64_to_xdr(n); 42 return bp + xdr_size(x); 43 } 44 45 static __be32 *xdr_encode_YFSFid(__be32 *bp, struct afs_fid *fid) 46 { 47 struct yfs_xdr_YFSFid *x = (void *)bp; 48 49 x->volume = u64_to_xdr(fid->vid); 50 x->vnode.lo = u64_to_xdr(fid->vnode); 51 x->vnode.hi = htonl(fid->vnode_hi); 52 x->vnode.unique = htonl(fid->unique); 53 return bp + xdr_size(x); 54 } 55 56 static size_t xdr_strlen(unsigned int len) 57 { 58 return sizeof(__be32) + round_up(len, sizeof(__be32)); 59 } 60 61 static __be32 *xdr_encode_string(__be32 *bp, const char *p, unsigned int len) 62 { 63 bp = xdr_encode_u32(bp, len); 64 bp = memcpy(bp, p, len); 65 if (len & 3) { 66 unsigned int pad = 4 - (len & 3); 67 68 memset((u8 *)bp + len, 0, pad); 69 len += pad; 70 } 71 72 return bp + len / sizeof(__be32); 73 } 74 75 static __be32 *xdr_encode_name(__be32 *bp, const struct qstr *p) 76 { 77 return xdr_encode_string(bp, p->name, p->len); 78 } 79 80 static s64 linux_to_yfs_time(const struct timespec64 *t) 81 { 82 /* Convert to 100ns intervals. */ 83 return (u64)t->tv_sec * 10000000 + t->tv_nsec/100; 84 } 85 86 static __be32 *xdr_encode_YFSStoreStatus_mode(__be32 *bp, mode_t mode) 87 { 88 struct yfs_xdr_YFSStoreStatus *x = (void *)bp; 89 90 x->mask = htonl(AFS_SET_MODE); 91 x->mode = htonl(mode & S_IALLUGO); 92 x->mtime_client = u64_to_xdr(0); 93 x->owner = u64_to_xdr(0); 94 x->group = u64_to_xdr(0); 95 return bp + xdr_size(x); 96 } 97 98 static __be32 *xdr_encode_YFSStoreStatus_mtime(__be32 *bp, const struct timespec64 *t) 99 { 100 struct yfs_xdr_YFSStoreStatus *x = (void *)bp; 101 s64 mtime = linux_to_yfs_time(t); 102 103 x->mask = htonl(AFS_SET_MTIME); 104 x->mode = htonl(0); 105 x->mtime_client = u64_to_xdr(mtime); 106 x->owner = u64_to_xdr(0); 107 x->group = u64_to_xdr(0); 108 return bp + xdr_size(x); 109 } 110 111 /* 112 * Convert a signed 100ns-resolution 64-bit time into a timespec. 113 */ 114 static struct timespec64 yfs_time_to_linux(s64 t) 115 { 116 struct timespec64 ts; 117 u64 abs_t; 118 119 /* 120 * Unfortunately can not use normal 64 bit division on 32 bit arch, but 121 * the alternative, do_div, does not work with negative numbers so have 122 * to special case them 123 */ 124 if (t < 0) { 125 abs_t = -t; 126 ts.tv_nsec = (time64_t)(do_div(abs_t, 10000000) * 100); 127 ts.tv_nsec = -ts.tv_nsec; 128 ts.tv_sec = -abs_t; 129 } else { 130 abs_t = t; 131 ts.tv_nsec = (time64_t)do_div(abs_t, 10000000) * 100; 132 ts.tv_sec = abs_t; 133 } 134 135 return ts; 136 } 137 138 static struct timespec64 xdr_to_time(const struct yfs_xdr_u64 xdr) 139 { 140 s64 t = xdr_to_u64(xdr); 141 142 return yfs_time_to_linux(t); 143 } 144 145 static void yfs_check_req(struct afs_call *call, __be32 *bp) 146 { 147 size_t len = (void *)bp - call->request; 148 149 if (len > call->request_size) 150 pr_err("kAFS: %s: Request buffer overflow (%zu>%u)\n", 151 call->type->name, len, call->request_size); 152 else if (len < call->request_size) 153 pr_warn("kAFS: %s: Request buffer underflow (%zu<%u)\n", 154 call->type->name, len, call->request_size); 155 } 156 157 /* 158 * Dump a bad file status record. 159 */ 160 static void xdr_dump_bad(const __be32 *bp) 161 { 162 __be32 x[4]; 163 int i; 164 165 pr_notice("YFS XDR: Bad status record\n"); 166 for (i = 0; i < 6 * 4 * 4; i += 16) { 167 memcpy(x, bp, 16); 168 bp += 4; 169 pr_notice("%03x: %08x %08x %08x %08x\n", 170 i, ntohl(x[0]), ntohl(x[1]), ntohl(x[2]), ntohl(x[3])); 171 } 172 173 memcpy(x, bp, 8); 174 pr_notice("0x60: %08x %08x\n", ntohl(x[0]), ntohl(x[1])); 175 } 176 177 /* 178 * Decode a YFSFetchStatus block 179 */ 180 static void xdr_decode_YFSFetchStatus(const __be32 **_bp, 181 struct afs_call *call, 182 struct afs_status_cb *scb) 183 { 184 const struct yfs_xdr_YFSFetchStatus *xdr = (const void *)*_bp; 185 struct afs_file_status *status = &scb->status; 186 u32 type; 187 188 status->abort_code = ntohl(xdr->abort_code); 189 if (status->abort_code != 0) { 190 if (status->abort_code == VNOVNODE) 191 status->nlink = 0; 192 scb->have_error = true; 193 goto advance; 194 } 195 196 type = ntohl(xdr->type); 197 switch (type) { 198 case AFS_FTYPE_FILE: 199 case AFS_FTYPE_DIR: 200 case AFS_FTYPE_SYMLINK: 201 status->type = type; 202 break; 203 default: 204 goto bad; 205 } 206 207 status->nlink = ntohl(xdr->nlink); 208 status->author = xdr_to_u64(xdr->author); 209 status->owner = xdr_to_u64(xdr->owner); 210 status->caller_access = ntohl(xdr->caller_access); /* Ticket dependent */ 211 status->anon_access = ntohl(xdr->anon_access); 212 status->mode = ntohl(xdr->mode) & S_IALLUGO; 213 status->group = xdr_to_u64(xdr->group); 214 status->lock_count = ntohl(xdr->lock_count); 215 216 status->mtime_client = xdr_to_time(xdr->mtime_client); 217 status->mtime_server = xdr_to_time(xdr->mtime_server); 218 status->size = xdr_to_u64(xdr->size); 219 status->data_version = xdr_to_u64(xdr->data_version); 220 scb->have_status = true; 221 advance: 222 *_bp += xdr_size(xdr); 223 return; 224 225 bad: 226 xdr_dump_bad(*_bp); 227 afs_protocol_error(call, afs_eproto_bad_status); 228 goto advance; 229 } 230 231 /* 232 * Decode a YFSCallBack block 233 */ 234 static void xdr_decode_YFSCallBack(const __be32 **_bp, 235 struct afs_call *call, 236 struct afs_status_cb *scb) 237 { 238 struct yfs_xdr_YFSCallBack *x = (void *)*_bp; 239 struct afs_callback *cb = &scb->callback; 240 ktime_t cb_expiry; 241 242 cb_expiry = call->reply_time; 243 cb_expiry = ktime_add(cb_expiry, xdr_to_u64(x->expiration_time) * 100); 244 cb->expires_at = ktime_divns(cb_expiry, NSEC_PER_SEC); 245 scb->have_cb = true; 246 *_bp += xdr_size(x); 247 } 248 249 /* 250 * Decode a YFSVolSync block 251 */ 252 static void xdr_decode_YFSVolSync(const __be32 **_bp, 253 struct afs_volsync *volsync) 254 { 255 struct yfs_xdr_YFSVolSync *x = (void *)*_bp; 256 u64 creation; 257 258 if (volsync) { 259 creation = xdr_to_u64(x->vol_creation_date); 260 do_div(creation, 10 * 1000 * 1000); 261 volsync->creation = creation; 262 } 263 264 *_bp += xdr_size(x); 265 } 266 267 /* 268 * Encode the requested attributes into a YFSStoreStatus block 269 */ 270 static __be32 *xdr_encode_YFS_StoreStatus(__be32 *bp, struct iattr *attr) 271 { 272 struct yfs_xdr_YFSStoreStatus *x = (void *)bp; 273 s64 mtime = 0, owner = 0, group = 0; 274 u32 mask = 0, mode = 0; 275 276 mask = 0; 277 if (attr->ia_valid & ATTR_MTIME) { 278 mask |= AFS_SET_MTIME; 279 mtime = linux_to_yfs_time(&attr->ia_mtime); 280 } 281 282 if (attr->ia_valid & ATTR_UID) { 283 mask |= AFS_SET_OWNER; 284 owner = from_kuid(&init_user_ns, attr->ia_uid); 285 } 286 287 if (attr->ia_valid & ATTR_GID) { 288 mask |= AFS_SET_GROUP; 289 group = from_kgid(&init_user_ns, attr->ia_gid); 290 } 291 292 if (attr->ia_valid & ATTR_MODE) { 293 mask |= AFS_SET_MODE; 294 mode = attr->ia_mode & S_IALLUGO; 295 } 296 297 x->mask = htonl(mask); 298 x->mode = htonl(mode); 299 x->mtime_client = u64_to_xdr(mtime); 300 x->owner = u64_to_xdr(owner); 301 x->group = u64_to_xdr(group); 302 return bp + xdr_size(x); 303 } 304 305 /* 306 * Decode a YFSFetchVolumeStatus block. 307 */ 308 static void xdr_decode_YFSFetchVolumeStatus(const __be32 **_bp, 309 struct afs_volume_status *vs) 310 { 311 const struct yfs_xdr_YFSFetchVolumeStatus *x = (const void *)*_bp; 312 u32 flags; 313 314 vs->vid = xdr_to_u64(x->vid); 315 vs->parent_id = xdr_to_u64(x->parent_id); 316 flags = ntohl(x->flags); 317 vs->online = flags & yfs_FVSOnline; 318 vs->in_service = flags & yfs_FVSInservice; 319 vs->blessed = flags & yfs_FVSBlessed; 320 vs->needs_salvage = flags & yfs_FVSNeedsSalvage; 321 vs->type = ntohl(x->type); 322 vs->min_quota = 0; 323 vs->max_quota = xdr_to_u64(x->max_quota); 324 vs->blocks_in_use = xdr_to_u64(x->blocks_in_use); 325 vs->part_blocks_avail = xdr_to_u64(x->part_blocks_avail); 326 vs->part_max_blocks = xdr_to_u64(x->part_max_blocks); 327 vs->vol_copy_date = xdr_to_u64(x->vol_copy_date); 328 vs->vol_backup_date = xdr_to_u64(x->vol_backup_date); 329 *_bp += sizeof(*x) / sizeof(__be32); 330 } 331 332 /* 333 * Deliver reply data to operations that just return a file status and a volume 334 * sync record. 335 */ 336 static int yfs_deliver_status_and_volsync(struct afs_call *call) 337 { 338 struct afs_operation *op = call->op; 339 const __be32 *bp; 340 int ret; 341 342 ret = afs_transfer_reply(call); 343 if (ret < 0) 344 return ret; 345 346 bp = call->buffer; 347 xdr_decode_YFSFetchStatus(&bp, call, &op->file[0].scb); 348 xdr_decode_YFSVolSync(&bp, &op->volsync); 349 350 _leave(" = 0 [done]"); 351 return 0; 352 } 353 354 /* 355 * Deliver reply data to an YFS.FetchData64. 356 */ 357 static int yfs_deliver_fs_fetch_data64(struct afs_call *call) 358 { 359 struct afs_operation *op = call->op; 360 struct afs_vnode_param *vp = &op->file[0]; 361 struct afs_read *req = op->fetch.req; 362 const __be32 *bp; 363 unsigned int size; 364 int ret; 365 366 _enter("{%u,%zu/%llu}", 367 call->unmarshall, iov_iter_count(call->iter), req->actual_len); 368 369 switch (call->unmarshall) { 370 case 0: 371 req->actual_len = 0; 372 req->index = 0; 373 req->offset = req->pos & (PAGE_SIZE - 1); 374 afs_extract_to_tmp64(call); 375 call->unmarshall++; 376 fallthrough; 377 378 /* extract the returned data length */ 379 case 1: 380 _debug("extract data length"); 381 ret = afs_extract_data(call, true); 382 if (ret < 0) 383 return ret; 384 385 req->actual_len = be64_to_cpu(call->tmp64); 386 _debug("DATA length: %llu", req->actual_len); 387 req->remain = min(req->len, req->actual_len); 388 if (req->remain == 0) 389 goto no_more_data; 390 391 call->unmarshall++; 392 393 begin_page: 394 ASSERTCMP(req->index, <, req->nr_pages); 395 if (req->remain > PAGE_SIZE - req->offset) 396 size = PAGE_SIZE - req->offset; 397 else 398 size = req->remain; 399 call->bvec[0].bv_len = size; 400 call->bvec[0].bv_offset = req->offset; 401 call->bvec[0].bv_page = req->pages[req->index]; 402 iov_iter_bvec(&call->def_iter, READ, call->bvec, 1, size); 403 ASSERTCMP(size, <=, PAGE_SIZE); 404 fallthrough; 405 406 /* extract the returned data */ 407 case 2: 408 _debug("extract data %zu/%llu", 409 iov_iter_count(call->iter), req->remain); 410 411 ret = afs_extract_data(call, true); 412 if (ret < 0) 413 return ret; 414 req->remain -= call->bvec[0].bv_len; 415 req->offset += call->bvec[0].bv_len; 416 ASSERTCMP(req->offset, <=, PAGE_SIZE); 417 if (req->offset == PAGE_SIZE) { 418 req->offset = 0; 419 req->index++; 420 if (req->remain > 0) 421 goto begin_page; 422 } 423 424 ASSERTCMP(req->remain, ==, 0); 425 if (req->actual_len <= req->len) 426 goto no_more_data; 427 428 /* Discard any excess data the server gave us */ 429 afs_extract_discard(call, req->actual_len - req->len); 430 call->unmarshall = 3; 431 fallthrough; 432 433 case 3: 434 _debug("extract discard %zu/%llu", 435 iov_iter_count(call->iter), req->actual_len - req->len); 436 437 ret = afs_extract_data(call, true); 438 if (ret < 0) 439 return ret; 440 441 no_more_data: 442 call->unmarshall = 4; 443 afs_extract_to_buf(call, 444 sizeof(struct yfs_xdr_YFSFetchStatus) + 445 sizeof(struct yfs_xdr_YFSCallBack) + 446 sizeof(struct yfs_xdr_YFSVolSync)); 447 fallthrough; 448 449 /* extract the metadata */ 450 case 4: 451 ret = afs_extract_data(call, false); 452 if (ret < 0) 453 return ret; 454 455 bp = call->buffer; 456 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb); 457 xdr_decode_YFSCallBack(&bp, call, &vp->scb); 458 xdr_decode_YFSVolSync(&bp, &op->volsync); 459 460 req->data_version = vp->scb.status.data_version; 461 req->file_size = vp->scb.status.size; 462 463 call->unmarshall++; 464 fallthrough; 465 466 case 5: 467 break; 468 } 469 470 for (; req->index < req->nr_pages; req->index++) { 471 if (req->offset < PAGE_SIZE) 472 zero_user_segment(req->pages[req->index], 473 req->offset, PAGE_SIZE); 474 req->offset = 0; 475 } 476 477 if (req->page_done) 478 for (req->index = 0; req->index < req->nr_pages; req->index++) 479 req->page_done(req); 480 481 _leave(" = 0 [done]"); 482 return 0; 483 } 484 485 /* 486 * YFS.FetchData64 operation type 487 */ 488 static const struct afs_call_type yfs_RXYFSFetchData64 = { 489 .name = "YFS.FetchData64", 490 .op = yfs_FS_FetchData64, 491 .deliver = yfs_deliver_fs_fetch_data64, 492 .destructor = afs_flat_call_destructor, 493 }; 494 495 /* 496 * Fetch data from a file. 497 */ 498 void yfs_fs_fetch_data(struct afs_operation *op) 499 { 500 struct afs_vnode_param *vp = &op->file[0]; 501 struct afs_read *req = op->fetch.req; 502 struct afs_call *call; 503 __be32 *bp; 504 505 _enter(",%x,{%llx:%llu},%llx,%llx", 506 key_serial(op->key), vp->fid.vid, vp->fid.vnode, 507 req->pos, req->len); 508 509 call = afs_alloc_flat_call(op->net, &yfs_RXYFSFetchData64, 510 sizeof(__be32) * 2 + 511 sizeof(struct yfs_xdr_YFSFid) + 512 sizeof(struct yfs_xdr_u64) * 2, 513 sizeof(struct yfs_xdr_YFSFetchStatus) + 514 sizeof(struct yfs_xdr_YFSCallBack) + 515 sizeof(struct yfs_xdr_YFSVolSync)); 516 if (!call) 517 return afs_op_nomem(op); 518 519 /* marshall the parameters */ 520 bp = call->request; 521 bp = xdr_encode_u32(bp, YFSFETCHDATA64); 522 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 523 bp = xdr_encode_YFSFid(bp, &vp->fid); 524 bp = xdr_encode_u64(bp, req->pos); 525 bp = xdr_encode_u64(bp, req->len); 526 yfs_check_req(call, bp); 527 528 trace_afs_make_fs_call(call, &vp->fid); 529 afs_make_op_call(op, call, GFP_NOFS); 530 } 531 532 /* 533 * Deliver reply data for YFS.CreateFile or YFS.MakeDir. 534 */ 535 static int yfs_deliver_fs_create_vnode(struct afs_call *call) 536 { 537 struct afs_operation *op = call->op; 538 struct afs_vnode_param *dvp = &op->file[0]; 539 struct afs_vnode_param *vp = &op->file[1]; 540 const __be32 *bp; 541 int ret; 542 543 _enter("{%u}", call->unmarshall); 544 545 ret = afs_transfer_reply(call); 546 if (ret < 0) 547 return ret; 548 549 /* unmarshall the reply once we've received all of it */ 550 bp = call->buffer; 551 xdr_decode_YFSFid(&bp, &op->file[1].fid); 552 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb); 553 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb); 554 xdr_decode_YFSCallBack(&bp, call, &vp->scb); 555 xdr_decode_YFSVolSync(&bp, &op->volsync); 556 557 _leave(" = 0 [done]"); 558 return 0; 559 } 560 561 /* 562 * FS.CreateFile and FS.MakeDir operation type 563 */ 564 static const struct afs_call_type afs_RXFSCreateFile = { 565 .name = "YFS.CreateFile", 566 .op = yfs_FS_CreateFile, 567 .deliver = yfs_deliver_fs_create_vnode, 568 .destructor = afs_flat_call_destructor, 569 }; 570 571 /* 572 * Create a file. 573 */ 574 void yfs_fs_create_file(struct afs_operation *op) 575 { 576 const struct qstr *name = &op->dentry->d_name; 577 struct afs_vnode_param *dvp = &op->file[0]; 578 struct afs_call *call; 579 size_t reqsz, rplsz; 580 __be32 *bp; 581 582 _enter(""); 583 584 reqsz = (sizeof(__be32) + 585 sizeof(__be32) + 586 sizeof(struct yfs_xdr_YFSFid) + 587 xdr_strlen(name->len) + 588 sizeof(struct yfs_xdr_YFSStoreStatus) + 589 sizeof(__be32)); 590 rplsz = (sizeof(struct yfs_xdr_YFSFid) + 591 sizeof(struct yfs_xdr_YFSFetchStatus) + 592 sizeof(struct yfs_xdr_YFSFetchStatus) + 593 sizeof(struct yfs_xdr_YFSCallBack) + 594 sizeof(struct yfs_xdr_YFSVolSync)); 595 596 call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile, reqsz, rplsz); 597 if (!call) 598 return afs_op_nomem(op); 599 600 /* marshall the parameters */ 601 bp = call->request; 602 bp = xdr_encode_u32(bp, YFSCREATEFILE); 603 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 604 bp = xdr_encode_YFSFid(bp, &dvp->fid); 605 bp = xdr_encode_name(bp, name); 606 bp = xdr_encode_YFSStoreStatus_mode(bp, op->create.mode); 607 bp = xdr_encode_u32(bp, yfs_LockNone); /* ViceLockType */ 608 yfs_check_req(call, bp); 609 610 trace_afs_make_fs_call1(call, &dvp->fid, name); 611 afs_make_op_call(op, call, GFP_NOFS); 612 } 613 614 static const struct afs_call_type yfs_RXFSMakeDir = { 615 .name = "YFS.MakeDir", 616 .op = yfs_FS_MakeDir, 617 .deliver = yfs_deliver_fs_create_vnode, 618 .destructor = afs_flat_call_destructor, 619 }; 620 621 /* 622 * Make a directory. 623 */ 624 void yfs_fs_make_dir(struct afs_operation *op) 625 { 626 const struct qstr *name = &op->dentry->d_name; 627 struct afs_vnode_param *dvp = &op->file[0]; 628 struct afs_call *call; 629 size_t reqsz, rplsz; 630 __be32 *bp; 631 632 _enter(""); 633 634 reqsz = (sizeof(__be32) + 635 sizeof(struct yfs_xdr_RPCFlags) + 636 sizeof(struct yfs_xdr_YFSFid) + 637 xdr_strlen(name->len) + 638 sizeof(struct yfs_xdr_YFSStoreStatus)); 639 rplsz = (sizeof(struct yfs_xdr_YFSFid) + 640 sizeof(struct yfs_xdr_YFSFetchStatus) + 641 sizeof(struct yfs_xdr_YFSFetchStatus) + 642 sizeof(struct yfs_xdr_YFSCallBack) + 643 sizeof(struct yfs_xdr_YFSVolSync)); 644 645 call = afs_alloc_flat_call(op->net, &yfs_RXFSMakeDir, reqsz, rplsz); 646 if (!call) 647 return afs_op_nomem(op); 648 649 /* marshall the parameters */ 650 bp = call->request; 651 bp = xdr_encode_u32(bp, YFSMAKEDIR); 652 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 653 bp = xdr_encode_YFSFid(bp, &dvp->fid); 654 bp = xdr_encode_name(bp, name); 655 bp = xdr_encode_YFSStoreStatus_mode(bp, op->create.mode); 656 yfs_check_req(call, bp); 657 658 trace_afs_make_fs_call1(call, &dvp->fid, name); 659 afs_make_op_call(op, call, GFP_NOFS); 660 } 661 662 /* 663 * Deliver reply data to a YFS.RemoveFile2 operation. 664 */ 665 static int yfs_deliver_fs_remove_file2(struct afs_call *call) 666 { 667 struct afs_operation *op = call->op; 668 struct afs_vnode_param *dvp = &op->file[0]; 669 struct afs_vnode_param *vp = &op->file[1]; 670 struct afs_fid fid; 671 const __be32 *bp; 672 int ret; 673 674 _enter("{%u}", call->unmarshall); 675 676 ret = afs_transfer_reply(call); 677 if (ret < 0) 678 return ret; 679 680 bp = call->buffer; 681 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb); 682 xdr_decode_YFSFid(&bp, &fid); 683 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb); 684 /* Was deleted if vnode->status.abort_code == VNOVNODE. */ 685 686 xdr_decode_YFSVolSync(&bp, &op->volsync); 687 return 0; 688 } 689 690 static void yfs_done_fs_remove_file2(struct afs_call *call) 691 { 692 if (call->error == -ECONNABORTED && 693 call->abort_code == RX_INVALID_OPERATION) { 694 set_bit(AFS_SERVER_FL_NO_RM2, &call->server->flags); 695 call->op->flags |= AFS_OPERATION_DOWNGRADE; 696 } 697 } 698 699 /* 700 * YFS.RemoveFile2 operation type. 701 */ 702 static const struct afs_call_type yfs_RXYFSRemoveFile2 = { 703 .name = "YFS.RemoveFile2", 704 .op = yfs_FS_RemoveFile2, 705 .deliver = yfs_deliver_fs_remove_file2, 706 .done = yfs_done_fs_remove_file2, 707 .destructor = afs_flat_call_destructor, 708 }; 709 710 /* 711 * Remove a file and retrieve new file status. 712 */ 713 void yfs_fs_remove_file2(struct afs_operation *op) 714 { 715 struct afs_vnode_param *dvp = &op->file[0]; 716 const struct qstr *name = &op->dentry->d_name; 717 struct afs_call *call; 718 __be32 *bp; 719 720 _enter(""); 721 722 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRemoveFile2, 723 sizeof(__be32) + 724 sizeof(struct yfs_xdr_RPCFlags) + 725 sizeof(struct yfs_xdr_YFSFid) + 726 xdr_strlen(name->len), 727 sizeof(struct yfs_xdr_YFSFetchStatus) + 728 sizeof(struct yfs_xdr_YFSFid) + 729 sizeof(struct yfs_xdr_YFSFetchStatus) + 730 sizeof(struct yfs_xdr_YFSVolSync)); 731 if (!call) 732 return afs_op_nomem(op); 733 734 /* marshall the parameters */ 735 bp = call->request; 736 bp = xdr_encode_u32(bp, YFSREMOVEFILE2); 737 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 738 bp = xdr_encode_YFSFid(bp, &dvp->fid); 739 bp = xdr_encode_name(bp, name); 740 yfs_check_req(call, bp); 741 742 trace_afs_make_fs_call1(call, &dvp->fid, name); 743 afs_make_op_call(op, call, GFP_NOFS); 744 } 745 746 /* 747 * Deliver reply data to a YFS.RemoveFile or YFS.RemoveDir operation. 748 */ 749 static int yfs_deliver_fs_remove(struct afs_call *call) 750 { 751 struct afs_operation *op = call->op; 752 struct afs_vnode_param *dvp = &op->file[0]; 753 const __be32 *bp; 754 int ret; 755 756 _enter("{%u}", call->unmarshall); 757 758 ret = afs_transfer_reply(call); 759 if (ret < 0) 760 return ret; 761 762 bp = call->buffer; 763 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb); 764 xdr_decode_YFSVolSync(&bp, &op->volsync); 765 return 0; 766 } 767 768 /* 769 * FS.RemoveDir and FS.RemoveFile operation types. 770 */ 771 static const struct afs_call_type yfs_RXYFSRemoveFile = { 772 .name = "YFS.RemoveFile", 773 .op = yfs_FS_RemoveFile, 774 .deliver = yfs_deliver_fs_remove, 775 .destructor = afs_flat_call_destructor, 776 }; 777 778 /* 779 * Remove a file. 780 */ 781 void yfs_fs_remove_file(struct afs_operation *op) 782 { 783 const struct qstr *name = &op->dentry->d_name; 784 struct afs_vnode_param *dvp = &op->file[0]; 785 struct afs_call *call; 786 __be32 *bp; 787 788 _enter(""); 789 790 if (!test_bit(AFS_SERVER_FL_NO_RM2, &op->server->flags)) 791 return yfs_fs_remove_file2(op); 792 793 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRemoveFile, 794 sizeof(__be32) + 795 sizeof(struct yfs_xdr_RPCFlags) + 796 sizeof(struct yfs_xdr_YFSFid) + 797 xdr_strlen(name->len), 798 sizeof(struct yfs_xdr_YFSFetchStatus) + 799 sizeof(struct yfs_xdr_YFSVolSync)); 800 if (!call) 801 return afs_op_nomem(op); 802 803 /* marshall the parameters */ 804 bp = call->request; 805 bp = xdr_encode_u32(bp, YFSREMOVEFILE); 806 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 807 bp = xdr_encode_YFSFid(bp, &dvp->fid); 808 bp = xdr_encode_name(bp, name); 809 yfs_check_req(call, bp); 810 811 trace_afs_make_fs_call1(call, &dvp->fid, name); 812 afs_make_op_call(op, call, GFP_NOFS); 813 } 814 815 static const struct afs_call_type yfs_RXYFSRemoveDir = { 816 .name = "YFS.RemoveDir", 817 .op = yfs_FS_RemoveDir, 818 .deliver = yfs_deliver_fs_remove, 819 .destructor = afs_flat_call_destructor, 820 }; 821 822 /* 823 * Remove a directory. 824 */ 825 void yfs_fs_remove_dir(struct afs_operation *op) 826 { 827 const struct qstr *name = &op->dentry->d_name; 828 struct afs_vnode_param *dvp = &op->file[0]; 829 struct afs_call *call; 830 __be32 *bp; 831 832 _enter(""); 833 834 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRemoveDir, 835 sizeof(__be32) + 836 sizeof(struct yfs_xdr_RPCFlags) + 837 sizeof(struct yfs_xdr_YFSFid) + 838 xdr_strlen(name->len), 839 sizeof(struct yfs_xdr_YFSFetchStatus) + 840 sizeof(struct yfs_xdr_YFSVolSync)); 841 if (!call) 842 return afs_op_nomem(op); 843 844 /* marshall the parameters */ 845 bp = call->request; 846 bp = xdr_encode_u32(bp, YFSREMOVEDIR); 847 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 848 bp = xdr_encode_YFSFid(bp, &dvp->fid); 849 bp = xdr_encode_name(bp, name); 850 yfs_check_req(call, bp); 851 852 trace_afs_make_fs_call1(call, &dvp->fid, name); 853 afs_make_op_call(op, call, GFP_NOFS); 854 } 855 856 /* 857 * Deliver reply data to a YFS.Link operation. 858 */ 859 static int yfs_deliver_fs_link(struct afs_call *call) 860 { 861 struct afs_operation *op = call->op; 862 struct afs_vnode_param *dvp = &op->file[0]; 863 struct afs_vnode_param *vp = &op->file[1]; 864 const __be32 *bp; 865 int ret; 866 867 _enter("{%u}", call->unmarshall); 868 869 ret = afs_transfer_reply(call); 870 if (ret < 0) 871 return ret; 872 873 bp = call->buffer; 874 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb); 875 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb); 876 xdr_decode_YFSVolSync(&bp, &op->volsync); 877 _leave(" = 0 [done]"); 878 return 0; 879 } 880 881 /* 882 * YFS.Link operation type. 883 */ 884 static const struct afs_call_type yfs_RXYFSLink = { 885 .name = "YFS.Link", 886 .op = yfs_FS_Link, 887 .deliver = yfs_deliver_fs_link, 888 .destructor = afs_flat_call_destructor, 889 }; 890 891 /* 892 * Make a hard link. 893 */ 894 void yfs_fs_link(struct afs_operation *op) 895 { 896 const struct qstr *name = &op->dentry->d_name; 897 struct afs_vnode_param *dvp = &op->file[0]; 898 struct afs_vnode_param *vp = &op->file[1]; 899 struct afs_call *call; 900 __be32 *bp; 901 902 _enter(""); 903 904 call = afs_alloc_flat_call(op->net, &yfs_RXYFSLink, 905 sizeof(__be32) + 906 sizeof(struct yfs_xdr_RPCFlags) + 907 sizeof(struct yfs_xdr_YFSFid) + 908 xdr_strlen(name->len) + 909 sizeof(struct yfs_xdr_YFSFid), 910 sizeof(struct yfs_xdr_YFSFetchStatus) + 911 sizeof(struct yfs_xdr_YFSFetchStatus) + 912 sizeof(struct yfs_xdr_YFSVolSync)); 913 if (!call) 914 return afs_op_nomem(op); 915 916 /* marshall the parameters */ 917 bp = call->request; 918 bp = xdr_encode_u32(bp, YFSLINK); 919 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 920 bp = xdr_encode_YFSFid(bp, &dvp->fid); 921 bp = xdr_encode_name(bp, name); 922 bp = xdr_encode_YFSFid(bp, &vp->fid); 923 yfs_check_req(call, bp); 924 925 trace_afs_make_fs_call1(call, &vp->fid, name); 926 afs_make_op_call(op, call, GFP_NOFS); 927 } 928 929 /* 930 * Deliver reply data to a YFS.Symlink operation. 931 */ 932 static int yfs_deliver_fs_symlink(struct afs_call *call) 933 { 934 struct afs_operation *op = call->op; 935 struct afs_vnode_param *dvp = &op->file[0]; 936 struct afs_vnode_param *vp = &op->file[1]; 937 const __be32 *bp; 938 int ret; 939 940 _enter("{%u}", call->unmarshall); 941 942 ret = afs_transfer_reply(call); 943 if (ret < 0) 944 return ret; 945 946 /* unmarshall the reply once we've received all of it */ 947 bp = call->buffer; 948 xdr_decode_YFSFid(&bp, &vp->fid); 949 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb); 950 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb); 951 xdr_decode_YFSVolSync(&bp, &op->volsync); 952 953 _leave(" = 0 [done]"); 954 return 0; 955 } 956 957 /* 958 * YFS.Symlink operation type 959 */ 960 static const struct afs_call_type yfs_RXYFSSymlink = { 961 .name = "YFS.Symlink", 962 .op = yfs_FS_Symlink, 963 .deliver = yfs_deliver_fs_symlink, 964 .destructor = afs_flat_call_destructor, 965 }; 966 967 /* 968 * Create a symbolic link. 969 */ 970 void yfs_fs_symlink(struct afs_operation *op) 971 { 972 const struct qstr *name = &op->dentry->d_name; 973 struct afs_vnode_param *dvp = &op->file[0]; 974 struct afs_call *call; 975 size_t contents_sz; 976 __be32 *bp; 977 978 _enter(""); 979 980 contents_sz = strlen(op->create.symlink); 981 call = afs_alloc_flat_call(op->net, &yfs_RXYFSSymlink, 982 sizeof(__be32) + 983 sizeof(struct yfs_xdr_RPCFlags) + 984 sizeof(struct yfs_xdr_YFSFid) + 985 xdr_strlen(name->len) + 986 xdr_strlen(contents_sz) + 987 sizeof(struct yfs_xdr_YFSStoreStatus), 988 sizeof(struct yfs_xdr_YFSFid) + 989 sizeof(struct yfs_xdr_YFSFetchStatus) + 990 sizeof(struct yfs_xdr_YFSFetchStatus) + 991 sizeof(struct yfs_xdr_YFSVolSync)); 992 if (!call) 993 return afs_op_nomem(op); 994 995 /* marshall the parameters */ 996 bp = call->request; 997 bp = xdr_encode_u32(bp, YFSSYMLINK); 998 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 999 bp = xdr_encode_YFSFid(bp, &dvp->fid); 1000 bp = xdr_encode_name(bp, name); 1001 bp = xdr_encode_string(bp, op->create.symlink, contents_sz); 1002 bp = xdr_encode_YFSStoreStatus_mode(bp, S_IRWXUGO); 1003 yfs_check_req(call, bp); 1004 1005 trace_afs_make_fs_call1(call, &dvp->fid, name); 1006 afs_make_op_call(op, call, GFP_NOFS); 1007 } 1008 1009 /* 1010 * Deliver reply data to a YFS.Rename operation. 1011 */ 1012 static int yfs_deliver_fs_rename(struct afs_call *call) 1013 { 1014 struct afs_operation *op = call->op; 1015 struct afs_vnode_param *orig_dvp = &op->file[0]; 1016 struct afs_vnode_param *new_dvp = &op->file[1]; 1017 const __be32 *bp; 1018 int ret; 1019 1020 _enter("{%u}", call->unmarshall); 1021 1022 ret = afs_transfer_reply(call); 1023 if (ret < 0) 1024 return ret; 1025 1026 bp = call->buffer; 1027 /* If the two dirs are the same, we have two copies of the same status 1028 * report, so we just decode it twice. 1029 */ 1030 xdr_decode_YFSFetchStatus(&bp, call, &orig_dvp->scb); 1031 xdr_decode_YFSFetchStatus(&bp, call, &new_dvp->scb); 1032 xdr_decode_YFSVolSync(&bp, &op->volsync); 1033 _leave(" = 0 [done]"); 1034 return 0; 1035 } 1036 1037 /* 1038 * YFS.Rename operation type 1039 */ 1040 static const struct afs_call_type yfs_RXYFSRename = { 1041 .name = "FS.Rename", 1042 .op = yfs_FS_Rename, 1043 .deliver = yfs_deliver_fs_rename, 1044 .destructor = afs_flat_call_destructor, 1045 }; 1046 1047 /* 1048 * Rename a file or directory. 1049 */ 1050 void yfs_fs_rename(struct afs_operation *op) 1051 { 1052 struct afs_vnode_param *orig_dvp = &op->file[0]; 1053 struct afs_vnode_param *new_dvp = &op->file[1]; 1054 const struct qstr *orig_name = &op->dentry->d_name; 1055 const struct qstr *new_name = &op->dentry_2->d_name; 1056 struct afs_call *call; 1057 __be32 *bp; 1058 1059 _enter(""); 1060 1061 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRename, 1062 sizeof(__be32) + 1063 sizeof(struct yfs_xdr_RPCFlags) + 1064 sizeof(struct yfs_xdr_YFSFid) + 1065 xdr_strlen(orig_name->len) + 1066 sizeof(struct yfs_xdr_YFSFid) + 1067 xdr_strlen(new_name->len), 1068 sizeof(struct yfs_xdr_YFSFetchStatus) + 1069 sizeof(struct yfs_xdr_YFSFetchStatus) + 1070 sizeof(struct yfs_xdr_YFSVolSync)); 1071 if (!call) 1072 return afs_op_nomem(op); 1073 1074 /* marshall the parameters */ 1075 bp = call->request; 1076 bp = xdr_encode_u32(bp, YFSRENAME); 1077 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1078 bp = xdr_encode_YFSFid(bp, &orig_dvp->fid); 1079 bp = xdr_encode_name(bp, orig_name); 1080 bp = xdr_encode_YFSFid(bp, &new_dvp->fid); 1081 bp = xdr_encode_name(bp, new_name); 1082 yfs_check_req(call, bp); 1083 1084 trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name); 1085 afs_make_op_call(op, call, GFP_NOFS); 1086 } 1087 1088 /* 1089 * YFS.StoreData64 operation type. 1090 */ 1091 static const struct afs_call_type yfs_RXYFSStoreData64 = { 1092 .name = "YFS.StoreData64", 1093 .op = yfs_FS_StoreData64, 1094 .deliver = yfs_deliver_status_and_volsync, 1095 .destructor = afs_flat_call_destructor, 1096 }; 1097 1098 /* 1099 * Store a set of pages to a large file. 1100 */ 1101 void yfs_fs_store_data(struct afs_operation *op) 1102 { 1103 struct afs_vnode_param *vp = &op->file[0]; 1104 struct afs_call *call; 1105 loff_t size, pos, i_size; 1106 __be32 *bp; 1107 1108 _enter(",%x,{%llx:%llu},,", 1109 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1110 1111 size = (loff_t)op->store.last_to - (loff_t)op->store.first_offset; 1112 if (op->store.first != op->store.last) 1113 size += (loff_t)(op->store.last - op->store.first) << PAGE_SHIFT; 1114 pos = (loff_t)op->store.first << PAGE_SHIFT; 1115 pos += op->store.first_offset; 1116 1117 i_size = i_size_read(&vp->vnode->vfs_inode); 1118 if (pos + size > i_size) 1119 i_size = size + pos; 1120 1121 _debug("size %llx, at %llx, i_size %llx", 1122 (unsigned long long)size, (unsigned long long)pos, 1123 (unsigned long long)i_size); 1124 1125 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreData64, 1126 sizeof(__be32) + 1127 sizeof(__be32) + 1128 sizeof(struct yfs_xdr_YFSFid) + 1129 sizeof(struct yfs_xdr_YFSStoreStatus) + 1130 sizeof(struct yfs_xdr_u64) * 3, 1131 sizeof(struct yfs_xdr_YFSFetchStatus) + 1132 sizeof(struct yfs_xdr_YFSVolSync)); 1133 if (!call) 1134 return afs_op_nomem(op); 1135 1136 call->key = op->key; 1137 call->send_pages = true; 1138 1139 /* marshall the parameters */ 1140 bp = call->request; 1141 bp = xdr_encode_u32(bp, YFSSTOREDATA64); 1142 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1143 bp = xdr_encode_YFSFid(bp, &vp->fid); 1144 bp = xdr_encode_YFSStoreStatus_mtime(bp, &op->mtime); 1145 bp = xdr_encode_u64(bp, pos); 1146 bp = xdr_encode_u64(bp, size); 1147 bp = xdr_encode_u64(bp, i_size); 1148 yfs_check_req(call, bp); 1149 1150 trace_afs_make_fs_call(call, &vp->fid); 1151 afs_make_op_call(op, call, GFP_NOFS); 1152 } 1153 1154 /* 1155 * YFS.StoreStatus operation type 1156 */ 1157 static const struct afs_call_type yfs_RXYFSStoreStatus = { 1158 .name = "YFS.StoreStatus", 1159 .op = yfs_FS_StoreStatus, 1160 .deliver = yfs_deliver_status_and_volsync, 1161 .destructor = afs_flat_call_destructor, 1162 }; 1163 1164 static const struct afs_call_type yfs_RXYFSStoreData64_as_Status = { 1165 .name = "YFS.StoreData64", 1166 .op = yfs_FS_StoreData64, 1167 .deliver = yfs_deliver_status_and_volsync, 1168 .destructor = afs_flat_call_destructor, 1169 }; 1170 1171 /* 1172 * Set the attributes on a file, using YFS.StoreData64 rather than 1173 * YFS.StoreStatus so as to alter the file size also. 1174 */ 1175 static void yfs_fs_setattr_size(struct afs_operation *op) 1176 { 1177 struct afs_vnode_param *vp = &op->file[0]; 1178 struct afs_call *call; 1179 struct iattr *attr = op->setattr.attr; 1180 __be32 *bp; 1181 1182 _enter(",%x,{%llx:%llu},,", 1183 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1184 1185 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreData64_as_Status, 1186 sizeof(__be32) * 2 + 1187 sizeof(struct yfs_xdr_YFSFid) + 1188 sizeof(struct yfs_xdr_YFSStoreStatus) + 1189 sizeof(struct yfs_xdr_u64) * 3, 1190 sizeof(struct yfs_xdr_YFSFetchStatus) + 1191 sizeof(struct yfs_xdr_YFSVolSync)); 1192 if (!call) 1193 return afs_op_nomem(op); 1194 1195 /* marshall the parameters */ 1196 bp = call->request; 1197 bp = xdr_encode_u32(bp, YFSSTOREDATA64); 1198 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1199 bp = xdr_encode_YFSFid(bp, &vp->fid); 1200 bp = xdr_encode_YFS_StoreStatus(bp, attr); 1201 bp = xdr_encode_u64(bp, attr->ia_size); /* position of start of write */ 1202 bp = xdr_encode_u64(bp, 0); /* size of write */ 1203 bp = xdr_encode_u64(bp, attr->ia_size); /* new file length */ 1204 yfs_check_req(call, bp); 1205 1206 trace_afs_make_fs_call(call, &vp->fid); 1207 afs_make_op_call(op, call, GFP_NOFS); 1208 } 1209 1210 /* 1211 * Set the attributes on a file, using YFS.StoreData64 if there's a change in 1212 * file size, and YFS.StoreStatus otherwise. 1213 */ 1214 void yfs_fs_setattr(struct afs_operation *op) 1215 { 1216 struct afs_vnode_param *vp = &op->file[0]; 1217 struct afs_call *call; 1218 struct iattr *attr = op->setattr.attr; 1219 __be32 *bp; 1220 1221 if (attr->ia_valid & ATTR_SIZE) 1222 return yfs_fs_setattr_size(op); 1223 1224 _enter(",%x,{%llx:%llu},,", 1225 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1226 1227 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreStatus, 1228 sizeof(__be32) * 2 + 1229 sizeof(struct yfs_xdr_YFSFid) + 1230 sizeof(struct yfs_xdr_YFSStoreStatus), 1231 sizeof(struct yfs_xdr_YFSFetchStatus) + 1232 sizeof(struct yfs_xdr_YFSVolSync)); 1233 if (!call) 1234 return afs_op_nomem(op); 1235 1236 /* marshall the parameters */ 1237 bp = call->request; 1238 bp = xdr_encode_u32(bp, YFSSTORESTATUS); 1239 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1240 bp = xdr_encode_YFSFid(bp, &vp->fid); 1241 bp = xdr_encode_YFS_StoreStatus(bp, attr); 1242 yfs_check_req(call, bp); 1243 1244 trace_afs_make_fs_call(call, &vp->fid); 1245 afs_make_op_call(op, call, GFP_NOFS); 1246 } 1247 1248 /* 1249 * Deliver reply data to a YFS.GetVolumeStatus operation. 1250 */ 1251 static int yfs_deliver_fs_get_volume_status(struct afs_call *call) 1252 { 1253 struct afs_operation *op = call->op; 1254 const __be32 *bp; 1255 char *p; 1256 u32 size; 1257 int ret; 1258 1259 _enter("{%u}", call->unmarshall); 1260 1261 switch (call->unmarshall) { 1262 case 0: 1263 call->unmarshall++; 1264 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSFetchVolumeStatus)); 1265 fallthrough; 1266 1267 /* extract the returned status record */ 1268 case 1: 1269 _debug("extract status"); 1270 ret = afs_extract_data(call, true); 1271 if (ret < 0) 1272 return ret; 1273 1274 bp = call->buffer; 1275 xdr_decode_YFSFetchVolumeStatus(&bp, &op->volstatus.vs); 1276 call->unmarshall++; 1277 afs_extract_to_tmp(call); 1278 fallthrough; 1279 1280 /* extract the volume name length */ 1281 case 2: 1282 ret = afs_extract_data(call, true); 1283 if (ret < 0) 1284 return ret; 1285 1286 call->count = ntohl(call->tmp); 1287 _debug("volname length: %u", call->count); 1288 if (call->count >= AFSNAMEMAX) 1289 return afs_protocol_error(call, afs_eproto_volname_len); 1290 size = (call->count + 3) & ~3; /* It's padded */ 1291 afs_extract_to_buf(call, size); 1292 call->unmarshall++; 1293 fallthrough; 1294 1295 /* extract the volume name */ 1296 case 3: 1297 _debug("extract volname"); 1298 ret = afs_extract_data(call, true); 1299 if (ret < 0) 1300 return ret; 1301 1302 p = call->buffer; 1303 p[call->count] = 0; 1304 _debug("volname '%s'", p); 1305 afs_extract_to_tmp(call); 1306 call->unmarshall++; 1307 fallthrough; 1308 1309 /* extract the offline message length */ 1310 case 4: 1311 ret = afs_extract_data(call, true); 1312 if (ret < 0) 1313 return ret; 1314 1315 call->count = ntohl(call->tmp); 1316 _debug("offline msg length: %u", call->count); 1317 if (call->count >= AFSNAMEMAX) 1318 return afs_protocol_error(call, afs_eproto_offline_msg_len); 1319 size = (call->count + 3) & ~3; /* It's padded */ 1320 afs_extract_to_buf(call, size); 1321 call->unmarshall++; 1322 fallthrough; 1323 1324 /* extract the offline message */ 1325 case 5: 1326 _debug("extract offline"); 1327 ret = afs_extract_data(call, true); 1328 if (ret < 0) 1329 return ret; 1330 1331 p = call->buffer; 1332 p[call->count] = 0; 1333 _debug("offline '%s'", p); 1334 1335 afs_extract_to_tmp(call); 1336 call->unmarshall++; 1337 fallthrough; 1338 1339 /* extract the message of the day length */ 1340 case 6: 1341 ret = afs_extract_data(call, true); 1342 if (ret < 0) 1343 return ret; 1344 1345 call->count = ntohl(call->tmp); 1346 _debug("motd length: %u", call->count); 1347 if (call->count >= AFSNAMEMAX) 1348 return afs_protocol_error(call, afs_eproto_motd_len); 1349 size = (call->count + 3) & ~3; /* It's padded */ 1350 afs_extract_to_buf(call, size); 1351 call->unmarshall++; 1352 fallthrough; 1353 1354 /* extract the message of the day */ 1355 case 7: 1356 _debug("extract motd"); 1357 ret = afs_extract_data(call, false); 1358 if (ret < 0) 1359 return ret; 1360 1361 p = call->buffer; 1362 p[call->count] = 0; 1363 _debug("motd '%s'", p); 1364 1365 call->unmarshall++; 1366 fallthrough; 1367 1368 case 8: 1369 break; 1370 } 1371 1372 _leave(" = 0 [done]"); 1373 return 0; 1374 } 1375 1376 /* 1377 * YFS.GetVolumeStatus operation type 1378 */ 1379 static const struct afs_call_type yfs_RXYFSGetVolumeStatus = { 1380 .name = "YFS.GetVolumeStatus", 1381 .op = yfs_FS_GetVolumeStatus, 1382 .deliver = yfs_deliver_fs_get_volume_status, 1383 .destructor = afs_flat_call_destructor, 1384 }; 1385 1386 /* 1387 * fetch the status of a volume 1388 */ 1389 void yfs_fs_get_volume_status(struct afs_operation *op) 1390 { 1391 struct afs_vnode_param *vp = &op->file[0]; 1392 struct afs_call *call; 1393 __be32 *bp; 1394 1395 _enter(""); 1396 1397 call = afs_alloc_flat_call(op->net, &yfs_RXYFSGetVolumeStatus, 1398 sizeof(__be32) * 2 + 1399 sizeof(struct yfs_xdr_u64), 1400 max_t(size_t, 1401 sizeof(struct yfs_xdr_YFSFetchVolumeStatus) + 1402 sizeof(__be32), 1403 AFSOPAQUEMAX + 1)); 1404 if (!call) 1405 return afs_op_nomem(op); 1406 1407 /* marshall the parameters */ 1408 bp = call->request; 1409 bp = xdr_encode_u32(bp, YFSGETVOLUMESTATUS); 1410 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1411 bp = xdr_encode_u64(bp, vp->fid.vid); 1412 yfs_check_req(call, bp); 1413 1414 trace_afs_make_fs_call(call, &vp->fid); 1415 afs_make_op_call(op, call, GFP_NOFS); 1416 } 1417 1418 /* 1419 * YFS.SetLock operation type 1420 */ 1421 static const struct afs_call_type yfs_RXYFSSetLock = { 1422 .name = "YFS.SetLock", 1423 .op = yfs_FS_SetLock, 1424 .deliver = yfs_deliver_status_and_volsync, 1425 .done = afs_lock_op_done, 1426 .destructor = afs_flat_call_destructor, 1427 }; 1428 1429 /* 1430 * YFS.ExtendLock operation type 1431 */ 1432 static const struct afs_call_type yfs_RXYFSExtendLock = { 1433 .name = "YFS.ExtendLock", 1434 .op = yfs_FS_ExtendLock, 1435 .deliver = yfs_deliver_status_and_volsync, 1436 .done = afs_lock_op_done, 1437 .destructor = afs_flat_call_destructor, 1438 }; 1439 1440 /* 1441 * YFS.ReleaseLock operation type 1442 */ 1443 static const struct afs_call_type yfs_RXYFSReleaseLock = { 1444 .name = "YFS.ReleaseLock", 1445 .op = yfs_FS_ReleaseLock, 1446 .deliver = yfs_deliver_status_and_volsync, 1447 .destructor = afs_flat_call_destructor, 1448 }; 1449 1450 /* 1451 * Set a lock on a file 1452 */ 1453 void yfs_fs_set_lock(struct afs_operation *op) 1454 { 1455 struct afs_vnode_param *vp = &op->file[0]; 1456 struct afs_call *call; 1457 __be32 *bp; 1458 1459 _enter(""); 1460 1461 call = afs_alloc_flat_call(op->net, &yfs_RXYFSSetLock, 1462 sizeof(__be32) * 2 + 1463 sizeof(struct yfs_xdr_YFSFid) + 1464 sizeof(__be32), 1465 sizeof(struct yfs_xdr_YFSFetchStatus) + 1466 sizeof(struct yfs_xdr_YFSVolSync)); 1467 if (!call) 1468 return afs_op_nomem(op); 1469 1470 /* marshall the parameters */ 1471 bp = call->request; 1472 bp = xdr_encode_u32(bp, YFSSETLOCK); 1473 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1474 bp = xdr_encode_YFSFid(bp, &vp->fid); 1475 bp = xdr_encode_u32(bp, op->lock.type); 1476 yfs_check_req(call, bp); 1477 1478 trace_afs_make_fs_calli(call, &vp->fid, op->lock.type); 1479 afs_make_op_call(op, call, GFP_NOFS); 1480 } 1481 1482 /* 1483 * extend a lock on a file 1484 */ 1485 void yfs_fs_extend_lock(struct afs_operation *op) 1486 { 1487 struct afs_vnode_param *vp = &op->file[0]; 1488 struct afs_call *call; 1489 __be32 *bp; 1490 1491 _enter(""); 1492 1493 call = afs_alloc_flat_call(op->net, &yfs_RXYFSExtendLock, 1494 sizeof(__be32) * 2 + 1495 sizeof(struct yfs_xdr_YFSFid), 1496 sizeof(struct yfs_xdr_YFSFetchStatus) + 1497 sizeof(struct yfs_xdr_YFSVolSync)); 1498 if (!call) 1499 return afs_op_nomem(op); 1500 1501 /* marshall the parameters */ 1502 bp = call->request; 1503 bp = xdr_encode_u32(bp, YFSEXTENDLOCK); 1504 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1505 bp = xdr_encode_YFSFid(bp, &vp->fid); 1506 yfs_check_req(call, bp); 1507 1508 trace_afs_make_fs_call(call, &vp->fid); 1509 afs_make_op_call(op, call, GFP_NOFS); 1510 } 1511 1512 /* 1513 * release a lock on a file 1514 */ 1515 void yfs_fs_release_lock(struct afs_operation *op) 1516 { 1517 struct afs_vnode_param *vp = &op->file[0]; 1518 struct afs_call *call; 1519 __be32 *bp; 1520 1521 _enter(""); 1522 1523 call = afs_alloc_flat_call(op->net, &yfs_RXYFSReleaseLock, 1524 sizeof(__be32) * 2 + 1525 sizeof(struct yfs_xdr_YFSFid), 1526 sizeof(struct yfs_xdr_YFSFetchStatus) + 1527 sizeof(struct yfs_xdr_YFSVolSync)); 1528 if (!call) 1529 return afs_op_nomem(op); 1530 1531 /* marshall the parameters */ 1532 bp = call->request; 1533 bp = xdr_encode_u32(bp, YFSRELEASELOCK); 1534 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1535 bp = xdr_encode_YFSFid(bp, &vp->fid); 1536 yfs_check_req(call, bp); 1537 1538 trace_afs_make_fs_call(call, &vp->fid); 1539 afs_make_op_call(op, call, GFP_NOFS); 1540 } 1541 1542 /* 1543 * Deliver a reply to YFS.FetchStatus 1544 */ 1545 static int yfs_deliver_fs_fetch_status(struct afs_call *call) 1546 { 1547 struct afs_operation *op = call->op; 1548 struct afs_vnode_param *vp = &op->file[op->fetch_status.which]; 1549 const __be32 *bp; 1550 int ret; 1551 1552 ret = afs_transfer_reply(call); 1553 if (ret < 0) 1554 return ret; 1555 1556 /* unmarshall the reply once we've received all of it */ 1557 bp = call->buffer; 1558 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb); 1559 xdr_decode_YFSCallBack(&bp, call, &vp->scb); 1560 xdr_decode_YFSVolSync(&bp, &op->volsync); 1561 1562 _leave(" = 0 [done]"); 1563 return 0; 1564 } 1565 1566 /* 1567 * YFS.FetchStatus operation type 1568 */ 1569 static const struct afs_call_type yfs_RXYFSFetchStatus = { 1570 .name = "YFS.FetchStatus", 1571 .op = yfs_FS_FetchStatus, 1572 .deliver = yfs_deliver_fs_fetch_status, 1573 .destructor = afs_flat_call_destructor, 1574 }; 1575 1576 /* 1577 * Fetch the status information for a fid without needing a vnode handle. 1578 */ 1579 void yfs_fs_fetch_status(struct afs_operation *op) 1580 { 1581 struct afs_vnode_param *vp = &op->file[op->fetch_status.which]; 1582 struct afs_call *call; 1583 __be32 *bp; 1584 1585 _enter(",%x,{%llx:%llu},,", 1586 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1587 1588 call = afs_alloc_flat_call(op->net, &yfs_RXYFSFetchStatus, 1589 sizeof(__be32) * 2 + 1590 sizeof(struct yfs_xdr_YFSFid), 1591 sizeof(struct yfs_xdr_YFSFetchStatus) + 1592 sizeof(struct yfs_xdr_YFSCallBack) + 1593 sizeof(struct yfs_xdr_YFSVolSync)); 1594 if (!call) 1595 return afs_op_nomem(op); 1596 1597 /* marshall the parameters */ 1598 bp = call->request; 1599 bp = xdr_encode_u32(bp, YFSFETCHSTATUS); 1600 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1601 bp = xdr_encode_YFSFid(bp, &vp->fid); 1602 yfs_check_req(call, bp); 1603 1604 trace_afs_make_fs_call(call, &vp->fid); 1605 afs_make_op_call(op, call, GFP_NOFS); 1606 } 1607 1608 /* 1609 * Deliver reply data to an YFS.InlineBulkStatus call 1610 */ 1611 static int yfs_deliver_fs_inline_bulk_status(struct afs_call *call) 1612 { 1613 struct afs_operation *op = call->op; 1614 struct afs_status_cb *scb; 1615 const __be32 *bp; 1616 u32 tmp; 1617 int ret; 1618 1619 _enter("{%u}", call->unmarshall); 1620 1621 switch (call->unmarshall) { 1622 case 0: 1623 afs_extract_to_tmp(call); 1624 call->unmarshall++; 1625 fallthrough; 1626 1627 /* Extract the file status count and array in two steps */ 1628 case 1: 1629 _debug("extract status count"); 1630 ret = afs_extract_data(call, true); 1631 if (ret < 0) 1632 return ret; 1633 1634 tmp = ntohl(call->tmp); 1635 _debug("status count: %u/%u", tmp, op->nr_files); 1636 if (tmp != op->nr_files) 1637 return afs_protocol_error(call, afs_eproto_ibulkst_count); 1638 1639 call->count = 0; 1640 call->unmarshall++; 1641 more_counts: 1642 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSFetchStatus)); 1643 fallthrough; 1644 1645 case 2: 1646 _debug("extract status array %u", call->count); 1647 ret = afs_extract_data(call, true); 1648 if (ret < 0) 1649 return ret; 1650 1651 switch (call->count) { 1652 case 0: 1653 scb = &op->file[0].scb; 1654 break; 1655 case 1: 1656 scb = &op->file[1].scb; 1657 break; 1658 default: 1659 scb = &op->more_files[call->count - 2].scb; 1660 break; 1661 } 1662 1663 bp = call->buffer; 1664 xdr_decode_YFSFetchStatus(&bp, call, scb); 1665 1666 call->count++; 1667 if (call->count < op->nr_files) 1668 goto more_counts; 1669 1670 call->count = 0; 1671 call->unmarshall++; 1672 afs_extract_to_tmp(call); 1673 fallthrough; 1674 1675 /* Extract the callback count and array in two steps */ 1676 case 3: 1677 _debug("extract CB count"); 1678 ret = afs_extract_data(call, true); 1679 if (ret < 0) 1680 return ret; 1681 1682 tmp = ntohl(call->tmp); 1683 _debug("CB count: %u", tmp); 1684 if (tmp != op->nr_files) 1685 return afs_protocol_error(call, afs_eproto_ibulkst_cb_count); 1686 call->count = 0; 1687 call->unmarshall++; 1688 more_cbs: 1689 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSCallBack)); 1690 fallthrough; 1691 1692 case 4: 1693 _debug("extract CB array"); 1694 ret = afs_extract_data(call, true); 1695 if (ret < 0) 1696 return ret; 1697 1698 _debug("unmarshall CB array"); 1699 switch (call->count) { 1700 case 0: 1701 scb = &op->file[0].scb; 1702 break; 1703 case 1: 1704 scb = &op->file[1].scb; 1705 break; 1706 default: 1707 scb = &op->more_files[call->count - 2].scb; 1708 break; 1709 } 1710 1711 bp = call->buffer; 1712 xdr_decode_YFSCallBack(&bp, call, scb); 1713 call->count++; 1714 if (call->count < op->nr_files) 1715 goto more_cbs; 1716 1717 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSVolSync)); 1718 call->unmarshall++; 1719 fallthrough; 1720 1721 case 5: 1722 ret = afs_extract_data(call, false); 1723 if (ret < 0) 1724 return ret; 1725 1726 bp = call->buffer; 1727 xdr_decode_YFSVolSync(&bp, &op->volsync); 1728 1729 call->unmarshall++; 1730 fallthrough; 1731 1732 case 6: 1733 break; 1734 } 1735 1736 _leave(" = 0 [done]"); 1737 return 0; 1738 } 1739 1740 /* 1741 * FS.InlineBulkStatus operation type 1742 */ 1743 static const struct afs_call_type yfs_RXYFSInlineBulkStatus = { 1744 .name = "YFS.InlineBulkStatus", 1745 .op = yfs_FS_InlineBulkStatus, 1746 .deliver = yfs_deliver_fs_inline_bulk_status, 1747 .destructor = afs_flat_call_destructor, 1748 }; 1749 1750 /* 1751 * Fetch the status information for up to 1024 files 1752 */ 1753 void yfs_fs_inline_bulk_status(struct afs_operation *op) 1754 { 1755 struct afs_vnode_param *dvp = &op->file[0]; 1756 struct afs_vnode_param *vp = &op->file[1]; 1757 struct afs_call *call; 1758 __be32 *bp; 1759 int i; 1760 1761 _enter(",%x,{%llx:%llu},%u", 1762 key_serial(op->key), vp->fid.vid, vp->fid.vnode, op->nr_files); 1763 1764 call = afs_alloc_flat_call(op->net, &yfs_RXYFSInlineBulkStatus, 1765 sizeof(__be32) + 1766 sizeof(__be32) + 1767 sizeof(__be32) + 1768 sizeof(struct yfs_xdr_YFSFid) * op->nr_files, 1769 sizeof(struct yfs_xdr_YFSFetchStatus)); 1770 if (!call) 1771 return afs_op_nomem(op); 1772 1773 /* marshall the parameters */ 1774 bp = call->request; 1775 bp = xdr_encode_u32(bp, YFSINLINEBULKSTATUS); 1776 bp = xdr_encode_u32(bp, 0); /* RPCFlags */ 1777 bp = xdr_encode_u32(bp, op->nr_files); 1778 bp = xdr_encode_YFSFid(bp, &dvp->fid); 1779 bp = xdr_encode_YFSFid(bp, &vp->fid); 1780 for (i = 0; i < op->nr_files - 2; i++) 1781 bp = xdr_encode_YFSFid(bp, &op->more_files[i].fid); 1782 yfs_check_req(call, bp); 1783 1784 trace_afs_make_fs_call(call, &vp->fid); 1785 afs_make_op_call(op, call, GFP_NOFS); 1786 } 1787 1788 /* 1789 * Deliver reply data to an YFS.FetchOpaqueACL. 1790 */ 1791 static int yfs_deliver_fs_fetch_opaque_acl(struct afs_call *call) 1792 { 1793 struct afs_operation *op = call->op; 1794 struct afs_vnode_param *vp = &op->file[0]; 1795 struct yfs_acl *yacl = op->yacl; 1796 struct afs_acl *acl; 1797 const __be32 *bp; 1798 unsigned int size; 1799 int ret; 1800 1801 _enter("{%u}", call->unmarshall); 1802 1803 switch (call->unmarshall) { 1804 case 0: 1805 afs_extract_to_tmp(call); 1806 call->unmarshall++; 1807 fallthrough; 1808 1809 /* Extract the file ACL length */ 1810 case 1: 1811 ret = afs_extract_data(call, true); 1812 if (ret < 0) 1813 return ret; 1814 1815 size = call->count2 = ntohl(call->tmp); 1816 size = round_up(size, 4); 1817 1818 if (yacl->flags & YFS_ACL_WANT_ACL) { 1819 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL); 1820 if (!acl) 1821 return -ENOMEM; 1822 yacl->acl = acl; 1823 acl->size = call->count2; 1824 afs_extract_begin(call, acl->data, size); 1825 } else { 1826 afs_extract_discard(call, size); 1827 } 1828 call->unmarshall++; 1829 fallthrough; 1830 1831 /* Extract the file ACL */ 1832 case 2: 1833 ret = afs_extract_data(call, true); 1834 if (ret < 0) 1835 return ret; 1836 1837 afs_extract_to_tmp(call); 1838 call->unmarshall++; 1839 fallthrough; 1840 1841 /* Extract the volume ACL length */ 1842 case 3: 1843 ret = afs_extract_data(call, true); 1844 if (ret < 0) 1845 return ret; 1846 1847 size = call->count2 = ntohl(call->tmp); 1848 size = round_up(size, 4); 1849 1850 if (yacl->flags & YFS_ACL_WANT_VOL_ACL) { 1851 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL); 1852 if (!acl) 1853 return -ENOMEM; 1854 yacl->vol_acl = acl; 1855 acl->size = call->count2; 1856 afs_extract_begin(call, acl->data, size); 1857 } else { 1858 afs_extract_discard(call, size); 1859 } 1860 call->unmarshall++; 1861 fallthrough; 1862 1863 /* Extract the volume ACL */ 1864 case 4: 1865 ret = afs_extract_data(call, true); 1866 if (ret < 0) 1867 return ret; 1868 1869 afs_extract_to_buf(call, 1870 sizeof(__be32) * 2 + 1871 sizeof(struct yfs_xdr_YFSFetchStatus) + 1872 sizeof(struct yfs_xdr_YFSVolSync)); 1873 call->unmarshall++; 1874 fallthrough; 1875 1876 /* extract the metadata */ 1877 case 5: 1878 ret = afs_extract_data(call, false); 1879 if (ret < 0) 1880 return ret; 1881 1882 bp = call->buffer; 1883 yacl->inherit_flag = ntohl(*bp++); 1884 yacl->num_cleaned = ntohl(*bp++); 1885 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb); 1886 xdr_decode_YFSVolSync(&bp, &op->volsync); 1887 1888 call->unmarshall++; 1889 fallthrough; 1890 1891 case 6: 1892 break; 1893 } 1894 1895 _leave(" = 0 [done]"); 1896 return 0; 1897 } 1898 1899 void yfs_free_opaque_acl(struct yfs_acl *yacl) 1900 { 1901 if (yacl) { 1902 kfree(yacl->acl); 1903 kfree(yacl->vol_acl); 1904 kfree(yacl); 1905 } 1906 } 1907 1908 /* 1909 * YFS.FetchOpaqueACL operation type 1910 */ 1911 static const struct afs_call_type yfs_RXYFSFetchOpaqueACL = { 1912 .name = "YFS.FetchOpaqueACL", 1913 .op = yfs_FS_FetchOpaqueACL, 1914 .deliver = yfs_deliver_fs_fetch_opaque_acl, 1915 .destructor = afs_flat_call_destructor, 1916 }; 1917 1918 /* 1919 * Fetch the YFS advanced ACLs for a file. 1920 */ 1921 void yfs_fs_fetch_opaque_acl(struct afs_operation *op) 1922 { 1923 struct afs_vnode_param *vp = &op->file[0]; 1924 struct afs_call *call; 1925 __be32 *bp; 1926 1927 _enter(",%x,{%llx:%llu},,", 1928 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1929 1930 call = afs_alloc_flat_call(op->net, &yfs_RXYFSFetchOpaqueACL, 1931 sizeof(__be32) * 2 + 1932 sizeof(struct yfs_xdr_YFSFid), 1933 sizeof(__be32) * 2 + 1934 sizeof(struct yfs_xdr_YFSFetchStatus) + 1935 sizeof(struct yfs_xdr_YFSVolSync)); 1936 if (!call) 1937 return afs_op_nomem(op); 1938 1939 /* marshall the parameters */ 1940 bp = call->request; 1941 bp = xdr_encode_u32(bp, YFSFETCHOPAQUEACL); 1942 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1943 bp = xdr_encode_YFSFid(bp, &vp->fid); 1944 yfs_check_req(call, bp); 1945 1946 trace_afs_make_fs_call(call, &vp->fid); 1947 afs_make_op_call(op, call, GFP_KERNEL); 1948 } 1949 1950 /* 1951 * YFS.StoreOpaqueACL2 operation type 1952 */ 1953 static const struct afs_call_type yfs_RXYFSStoreOpaqueACL2 = { 1954 .name = "YFS.StoreOpaqueACL2", 1955 .op = yfs_FS_StoreOpaqueACL2, 1956 .deliver = yfs_deliver_status_and_volsync, 1957 .destructor = afs_flat_call_destructor, 1958 }; 1959 1960 /* 1961 * Fetch the YFS ACL for a file. 1962 */ 1963 void yfs_fs_store_opaque_acl2(struct afs_operation *op) 1964 { 1965 struct afs_vnode_param *vp = &op->file[0]; 1966 struct afs_call *call; 1967 struct afs_acl *acl = op->acl; 1968 size_t size; 1969 __be32 *bp; 1970 1971 _enter(",%x,{%llx:%llu},,", 1972 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1973 1974 size = round_up(acl->size, 4); 1975 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreOpaqueACL2, 1976 sizeof(__be32) * 2 + 1977 sizeof(struct yfs_xdr_YFSFid) + 1978 sizeof(__be32) + size, 1979 sizeof(struct yfs_xdr_YFSFetchStatus) + 1980 sizeof(struct yfs_xdr_YFSVolSync)); 1981 if (!call) 1982 return afs_op_nomem(op); 1983 1984 /* marshall the parameters */ 1985 bp = call->request; 1986 bp = xdr_encode_u32(bp, YFSSTOREOPAQUEACL2); 1987 bp = xdr_encode_u32(bp, 0); /* RPC flags */ 1988 bp = xdr_encode_YFSFid(bp, &vp->fid); 1989 bp = xdr_encode_u32(bp, acl->size); 1990 memcpy(bp, acl->data, acl->size); 1991 if (acl->size != size) 1992 memset((void *)bp + acl->size, 0, size - acl->size); 1993 yfs_check_req(call, bp); 1994 1995 trace_afs_make_fs_call(call, &vp->fid); 1996 afs_make_op_call(op, call, GFP_KERNEL); 1997 } 1998