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