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