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