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 "internal.h" 17 #include "afs_fs.h" 18 19 /* 20 * We need somewhere to discard into in case the server helpfully returns more 21 * than we asked for in FS.FetchData{,64}. 22 */ 23 static u8 afs_discard_buffer[64]; 24 25 /* 26 * decode an AFSFid block 27 */ 28 static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid) 29 { 30 const __be32 *bp = *_bp; 31 32 fid->vid = ntohl(*bp++); 33 fid->vnode = ntohl(*bp++); 34 fid->unique = ntohl(*bp++); 35 *_bp = bp; 36 } 37 38 /* 39 * decode an AFSFetchStatus block 40 */ 41 static void xdr_decode_AFSFetchStatus(const __be32 **_bp, 42 struct afs_file_status *status, 43 struct afs_vnode *vnode, 44 afs_dataversion_t *store_version) 45 { 46 afs_dataversion_t expected_version; 47 const __be32 *bp = *_bp; 48 umode_t mode; 49 u64 data_version, size; 50 u32 changed = 0; /* becomes non-zero if ctime-type changes seen */ 51 kuid_t owner; 52 kgid_t group; 53 54 #define EXTRACT(DST) \ 55 do { \ 56 u32 x = ntohl(*bp++); \ 57 changed |= DST - x; \ 58 DST = x; \ 59 } while (0) 60 61 status->if_version = ntohl(*bp++); 62 EXTRACT(status->type); 63 EXTRACT(status->nlink); 64 size = ntohl(*bp++); 65 data_version = ntohl(*bp++); 66 EXTRACT(status->author); 67 owner = make_kuid(&init_user_ns, ntohl(*bp++)); 68 changed |= !uid_eq(owner, status->owner); 69 status->owner = owner; 70 EXTRACT(status->caller_access); /* call ticket dependent */ 71 EXTRACT(status->anon_access); 72 EXTRACT(status->mode); 73 EXTRACT(status->parent.vnode); 74 EXTRACT(status->parent.unique); 75 bp++; /* seg size */ 76 status->mtime_client = ntohl(*bp++); 77 status->mtime_server = ntohl(*bp++); 78 group = make_kgid(&init_user_ns, ntohl(*bp++)); 79 changed |= !gid_eq(group, status->group); 80 status->group = group; 81 bp++; /* sync counter */ 82 data_version |= (u64) ntohl(*bp++) << 32; 83 EXTRACT(status->lock_count); 84 size |= (u64) ntohl(*bp++) << 32; 85 bp++; /* spare 4 */ 86 *_bp = bp; 87 88 if (size != status->size) { 89 status->size = size; 90 changed |= true; 91 } 92 status->mode &= S_IALLUGO; 93 94 _debug("vnode time %lx, %lx", 95 status->mtime_client, status->mtime_server); 96 97 if (vnode) { 98 status->parent.vid = vnode->fid.vid; 99 if (changed && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) { 100 _debug("vnode changed"); 101 i_size_write(&vnode->vfs_inode, size); 102 vnode->vfs_inode.i_uid = status->owner; 103 vnode->vfs_inode.i_gid = status->group; 104 vnode->vfs_inode.i_generation = vnode->fid.unique; 105 set_nlink(&vnode->vfs_inode, status->nlink); 106 107 mode = vnode->vfs_inode.i_mode; 108 mode &= ~S_IALLUGO; 109 mode |= status->mode; 110 barrier(); 111 vnode->vfs_inode.i_mode = mode; 112 } 113 114 vnode->vfs_inode.i_ctime.tv_sec = status->mtime_client; 115 vnode->vfs_inode.i_mtime = vnode->vfs_inode.i_ctime; 116 vnode->vfs_inode.i_atime = vnode->vfs_inode.i_ctime; 117 vnode->vfs_inode.i_version = data_version; 118 } 119 120 expected_version = status->data_version; 121 if (store_version) 122 expected_version = *store_version; 123 124 if (expected_version != data_version) { 125 status->data_version = data_version; 126 if (vnode && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) { 127 _debug("vnode modified %llx on {%x:%u}", 128 (unsigned long long) data_version, 129 vnode->fid.vid, vnode->fid.vnode); 130 set_bit(AFS_VNODE_MODIFIED, &vnode->flags); 131 set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags); 132 } 133 } else if (store_version) { 134 status->data_version = data_version; 135 } 136 } 137 138 /* 139 * decode an AFSCallBack block 140 */ 141 static void xdr_decode_AFSCallBack(const __be32 **_bp, struct afs_vnode *vnode) 142 { 143 const __be32 *bp = *_bp; 144 145 vnode->cb_version = ntohl(*bp++); 146 vnode->cb_expiry = ntohl(*bp++); 147 vnode->cb_type = ntohl(*bp++); 148 vnode->cb_expires = vnode->cb_expiry + ktime_get_real_seconds(); 149 *_bp = bp; 150 } 151 152 static void xdr_decode_AFSCallBack_raw(const __be32 **_bp, 153 struct afs_callback *cb) 154 { 155 const __be32 *bp = *_bp; 156 157 cb->version = ntohl(*bp++); 158 cb->expiry = ntohl(*bp++); 159 cb->type = ntohl(*bp++); 160 *_bp = bp; 161 } 162 163 /* 164 * decode an AFSVolSync block 165 */ 166 static void xdr_decode_AFSVolSync(const __be32 **_bp, 167 struct afs_volsync *volsync) 168 { 169 const __be32 *bp = *_bp; 170 171 volsync->creation = ntohl(*bp++); 172 bp++; /* spare2 */ 173 bp++; /* spare3 */ 174 bp++; /* spare4 */ 175 bp++; /* spare5 */ 176 bp++; /* spare6 */ 177 *_bp = bp; 178 } 179 180 /* 181 * encode the requested attributes into an AFSStoreStatus block 182 */ 183 static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr) 184 { 185 __be32 *bp = *_bp; 186 u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0; 187 188 mask = 0; 189 if (attr->ia_valid & ATTR_MTIME) { 190 mask |= AFS_SET_MTIME; 191 mtime = attr->ia_mtime.tv_sec; 192 } 193 194 if (attr->ia_valid & ATTR_UID) { 195 mask |= AFS_SET_OWNER; 196 owner = from_kuid(&init_user_ns, attr->ia_uid); 197 } 198 199 if (attr->ia_valid & ATTR_GID) { 200 mask |= AFS_SET_GROUP; 201 group = from_kgid(&init_user_ns, attr->ia_gid); 202 } 203 204 if (attr->ia_valid & ATTR_MODE) { 205 mask |= AFS_SET_MODE; 206 mode = attr->ia_mode & S_IALLUGO; 207 } 208 209 *bp++ = htonl(mask); 210 *bp++ = htonl(mtime); 211 *bp++ = htonl(owner); 212 *bp++ = htonl(group); 213 *bp++ = htonl(mode); 214 *bp++ = 0; /* segment size */ 215 *_bp = bp; 216 } 217 218 /* 219 * decode an AFSFetchVolumeStatus block 220 */ 221 static void xdr_decode_AFSFetchVolumeStatus(const __be32 **_bp, 222 struct afs_volume_status *vs) 223 { 224 const __be32 *bp = *_bp; 225 226 vs->vid = ntohl(*bp++); 227 vs->parent_id = ntohl(*bp++); 228 vs->online = ntohl(*bp++); 229 vs->in_service = ntohl(*bp++); 230 vs->blessed = ntohl(*bp++); 231 vs->needs_salvage = ntohl(*bp++); 232 vs->type = ntohl(*bp++); 233 vs->min_quota = ntohl(*bp++); 234 vs->max_quota = ntohl(*bp++); 235 vs->blocks_in_use = ntohl(*bp++); 236 vs->part_blocks_avail = ntohl(*bp++); 237 vs->part_max_blocks = ntohl(*bp++); 238 *_bp = bp; 239 } 240 241 /* 242 * deliver reply data to an FS.FetchStatus 243 */ 244 static int afs_deliver_fs_fetch_status(struct afs_call *call) 245 { 246 struct afs_vnode *vnode = call->reply; 247 const __be32 *bp; 248 int ret; 249 250 _enter(""); 251 252 ret = afs_transfer_reply(call); 253 if (ret < 0) 254 return ret; 255 256 /* unmarshall the reply once we've received all of it */ 257 bp = call->buffer; 258 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL); 259 xdr_decode_AFSCallBack(&bp, vnode); 260 if (call->reply2) 261 xdr_decode_AFSVolSync(&bp, call->reply2); 262 263 _leave(" = 0 [done]"); 264 return 0; 265 } 266 267 /* 268 * FS.FetchStatus operation type 269 */ 270 static const struct afs_call_type afs_RXFSFetchStatus = { 271 .name = "FS.FetchStatus", 272 .deliver = afs_deliver_fs_fetch_status, 273 .abort_to_error = afs_abort_to_error, 274 .destructor = afs_flat_call_destructor, 275 }; 276 277 /* 278 * fetch the status information for a file 279 */ 280 int afs_fs_fetch_file_status(struct afs_server *server, 281 struct key *key, 282 struct afs_vnode *vnode, 283 struct afs_volsync *volsync, 284 bool async) 285 { 286 struct afs_call *call; 287 __be32 *bp; 288 289 _enter(",%x,{%x:%u},,", 290 key_serial(key), vnode->fid.vid, vnode->fid.vnode); 291 292 call = afs_alloc_flat_call(&afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4); 293 if (!call) 294 return -ENOMEM; 295 296 call->key = key; 297 call->reply = vnode; 298 call->reply2 = volsync; 299 call->service_id = FS_SERVICE; 300 call->port = htons(AFS_FS_PORT); 301 302 /* marshall the parameters */ 303 bp = call->request; 304 bp[0] = htonl(FSFETCHSTATUS); 305 bp[1] = htonl(vnode->fid.vid); 306 bp[2] = htonl(vnode->fid.vnode); 307 bp[3] = htonl(vnode->fid.unique); 308 309 return afs_make_call(&server->addr, call, GFP_NOFS, async); 310 } 311 312 /* 313 * deliver reply data to an FS.FetchData 314 */ 315 static int afs_deliver_fs_fetch_data(struct afs_call *call) 316 { 317 struct afs_vnode *vnode = call->reply; 318 struct afs_read *req = call->reply3; 319 const __be32 *bp; 320 unsigned int size; 321 void *buffer; 322 int ret; 323 324 _enter("{%u,%zu/%u;%llu/%llu}", 325 call->unmarshall, call->offset, call->count, 326 req->remain, req->actual_len); 327 328 switch (call->unmarshall) { 329 case 0: 330 req->actual_len = 0; 331 call->offset = 0; 332 call->unmarshall++; 333 if (call->operation_ID != FSFETCHDATA64) { 334 call->unmarshall++; 335 goto no_msw; 336 } 337 338 /* extract the upper part of the returned data length of an 339 * FSFETCHDATA64 op (which should always be 0 using this 340 * client) */ 341 case 1: 342 _debug("extract data length (MSW)"); 343 ret = afs_extract_data(call, &call->tmp, 4, true); 344 if (ret < 0) 345 return ret; 346 347 req->actual_len = ntohl(call->tmp); 348 req->actual_len <<= 32; 349 call->offset = 0; 350 call->unmarshall++; 351 352 no_msw: 353 /* extract the returned data length */ 354 case 2: 355 _debug("extract data length"); 356 ret = afs_extract_data(call, &call->tmp, 4, true); 357 if (ret < 0) 358 return ret; 359 360 req->actual_len |= ntohl(call->tmp); 361 _debug("DATA length: %llu", req->actual_len); 362 363 req->remain = req->actual_len; 364 call->offset = req->pos & (PAGE_SIZE - 1); 365 req->index = 0; 366 if (req->actual_len == 0) 367 goto no_more_data; 368 call->unmarshall++; 369 370 begin_page: 371 ASSERTCMP(req->index, <, req->nr_pages); 372 if (req->remain > PAGE_SIZE - call->offset) 373 size = PAGE_SIZE - call->offset; 374 else 375 size = req->remain; 376 call->count = call->offset + size; 377 ASSERTCMP(call->count, <=, PAGE_SIZE); 378 req->remain -= size; 379 380 /* extract the returned data */ 381 case 3: 382 _debug("extract data %llu/%llu %zu/%u", 383 req->remain, req->actual_len, call->offset, call->count); 384 385 buffer = kmap(req->pages[req->index]); 386 ret = afs_extract_data(call, buffer, call->count, true); 387 kunmap(req->pages[req->index]); 388 if (ret < 0) 389 return ret; 390 if (call->offset == PAGE_SIZE) { 391 if (req->page_done) 392 req->page_done(call, req); 393 req->index++; 394 if (req->remain > 0) { 395 call->offset = 0; 396 if (req->index >= req->nr_pages) { 397 call->unmarshall = 4; 398 goto begin_discard; 399 } 400 goto begin_page; 401 } 402 } 403 goto no_more_data; 404 405 /* Discard any excess data the server gave us */ 406 begin_discard: 407 case 4: 408 size = min_t(loff_t, sizeof(afs_discard_buffer), req->remain); 409 call->count = size; 410 _debug("extract discard %llu/%llu %zu/%u", 411 req->remain, req->actual_len, call->offset, call->count); 412 413 call->offset = 0; 414 ret = afs_extract_data(call, afs_discard_buffer, call->count, true); 415 req->remain -= call->offset; 416 if (ret < 0) 417 return ret; 418 if (req->remain > 0) 419 goto begin_discard; 420 421 no_more_data: 422 call->offset = 0; 423 call->unmarshall = 5; 424 425 /* extract the metadata */ 426 case 5: 427 ret = afs_extract_data(call, call->buffer, 428 (21 + 3 + 6) * 4, false); 429 if (ret < 0) 430 return ret; 431 432 bp = call->buffer; 433 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL); 434 xdr_decode_AFSCallBack(&bp, vnode); 435 if (call->reply2) 436 xdr_decode_AFSVolSync(&bp, call->reply2); 437 438 call->offset = 0; 439 call->unmarshall++; 440 441 case 6: 442 break; 443 } 444 445 for (; req->index < req->nr_pages; req->index++) { 446 if (call->count < PAGE_SIZE) 447 zero_user_segment(req->pages[req->index], 448 call->count, PAGE_SIZE); 449 if (req->page_done) 450 req->page_done(call, req); 451 call->count = 0; 452 } 453 454 _leave(" = 0 [done]"); 455 return 0; 456 } 457 458 static void afs_fetch_data_destructor(struct afs_call *call) 459 { 460 struct afs_read *req = call->reply3; 461 462 afs_put_read(req); 463 afs_flat_call_destructor(call); 464 } 465 466 /* 467 * FS.FetchData operation type 468 */ 469 static const struct afs_call_type afs_RXFSFetchData = { 470 .name = "FS.FetchData", 471 .deliver = afs_deliver_fs_fetch_data, 472 .abort_to_error = afs_abort_to_error, 473 .destructor = afs_fetch_data_destructor, 474 }; 475 476 static const struct afs_call_type afs_RXFSFetchData64 = { 477 .name = "FS.FetchData64", 478 .deliver = afs_deliver_fs_fetch_data, 479 .abort_to_error = afs_abort_to_error, 480 .destructor = afs_fetch_data_destructor, 481 }; 482 483 /* 484 * fetch data from a very large file 485 */ 486 static int afs_fs_fetch_data64(struct afs_server *server, 487 struct key *key, 488 struct afs_vnode *vnode, 489 struct afs_read *req, 490 bool async) 491 { 492 struct afs_call *call; 493 __be32 *bp; 494 495 _enter(""); 496 497 call = afs_alloc_flat_call(&afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4); 498 if (!call) 499 return -ENOMEM; 500 501 call->key = key; 502 call->reply = vnode; 503 call->reply2 = NULL; /* volsync */ 504 call->reply3 = req; 505 call->service_id = FS_SERVICE; 506 call->port = htons(AFS_FS_PORT); 507 call->operation_ID = FSFETCHDATA64; 508 509 /* marshall the parameters */ 510 bp = call->request; 511 bp[0] = htonl(FSFETCHDATA64); 512 bp[1] = htonl(vnode->fid.vid); 513 bp[2] = htonl(vnode->fid.vnode); 514 bp[3] = htonl(vnode->fid.unique); 515 bp[4] = htonl(upper_32_bits(req->pos)); 516 bp[5] = htonl(lower_32_bits(req->pos)); 517 bp[6] = 0; 518 bp[7] = htonl(lower_32_bits(req->len)); 519 520 atomic_inc(&req->usage); 521 return afs_make_call(&server->addr, call, GFP_NOFS, async); 522 } 523 524 /* 525 * fetch data from a file 526 */ 527 int afs_fs_fetch_data(struct afs_server *server, 528 struct key *key, 529 struct afs_vnode *vnode, 530 struct afs_read *req, 531 bool async) 532 { 533 struct afs_call *call; 534 __be32 *bp; 535 536 if (upper_32_bits(req->pos) || 537 upper_32_bits(req->len) || 538 upper_32_bits(req->pos + req->len)) 539 return afs_fs_fetch_data64(server, key, vnode, req, async); 540 541 _enter(""); 542 543 call = afs_alloc_flat_call(&afs_RXFSFetchData, 24, (21 + 3 + 6) * 4); 544 if (!call) 545 return -ENOMEM; 546 547 call->key = key; 548 call->reply = vnode; 549 call->reply2 = NULL; /* volsync */ 550 call->reply3 = req; 551 call->service_id = FS_SERVICE; 552 call->port = htons(AFS_FS_PORT); 553 call->operation_ID = FSFETCHDATA; 554 555 /* marshall the parameters */ 556 bp = call->request; 557 bp[0] = htonl(FSFETCHDATA); 558 bp[1] = htonl(vnode->fid.vid); 559 bp[2] = htonl(vnode->fid.vnode); 560 bp[3] = htonl(vnode->fid.unique); 561 bp[4] = htonl(lower_32_bits(req->pos)); 562 bp[5] = htonl(lower_32_bits(req->len)); 563 564 atomic_inc(&req->usage); 565 return afs_make_call(&server->addr, call, GFP_NOFS, async); 566 } 567 568 /* 569 * deliver reply data to an FS.GiveUpCallBacks 570 */ 571 static int afs_deliver_fs_give_up_callbacks(struct afs_call *call) 572 { 573 _enter(""); 574 575 /* shouldn't be any reply data */ 576 return afs_extract_data(call, NULL, 0, false); 577 } 578 579 /* 580 * FS.GiveUpCallBacks operation type 581 */ 582 static const struct afs_call_type afs_RXFSGiveUpCallBacks = { 583 .name = "FS.GiveUpCallBacks", 584 .deliver = afs_deliver_fs_give_up_callbacks, 585 .abort_to_error = afs_abort_to_error, 586 .destructor = afs_flat_call_destructor, 587 }; 588 589 /* 590 * give up a set of callbacks 591 * - the callbacks are held in the server->cb_break ring 592 */ 593 int afs_fs_give_up_callbacks(struct afs_server *server, 594 bool async) 595 { 596 struct afs_call *call; 597 size_t ncallbacks; 598 __be32 *bp, *tp; 599 int loop; 600 601 ncallbacks = CIRC_CNT(server->cb_break_head, server->cb_break_tail, 602 ARRAY_SIZE(server->cb_break)); 603 604 _enter("{%zu},", ncallbacks); 605 606 if (ncallbacks == 0) 607 return 0; 608 if (ncallbacks > AFSCBMAX) 609 ncallbacks = AFSCBMAX; 610 611 _debug("break %zu callbacks", ncallbacks); 612 613 call = afs_alloc_flat_call(&afs_RXFSGiveUpCallBacks, 614 12 + ncallbacks * 6 * 4, 0); 615 if (!call) 616 return -ENOMEM; 617 618 call->service_id = FS_SERVICE; 619 call->port = htons(AFS_FS_PORT); 620 621 /* marshall the parameters */ 622 bp = call->request; 623 tp = bp + 2 + ncallbacks * 3; 624 *bp++ = htonl(FSGIVEUPCALLBACKS); 625 *bp++ = htonl(ncallbacks); 626 *tp++ = htonl(ncallbacks); 627 628 atomic_sub(ncallbacks, &server->cb_break_n); 629 for (loop = ncallbacks; loop > 0; loop--) { 630 struct afs_callback *cb = 631 &server->cb_break[server->cb_break_tail]; 632 633 *bp++ = htonl(cb->fid.vid); 634 *bp++ = htonl(cb->fid.vnode); 635 *bp++ = htonl(cb->fid.unique); 636 *tp++ = htonl(cb->version); 637 *tp++ = htonl(cb->expiry); 638 *tp++ = htonl(cb->type); 639 smp_mb(); 640 server->cb_break_tail = 641 (server->cb_break_tail + 1) & 642 (ARRAY_SIZE(server->cb_break) - 1); 643 } 644 645 ASSERT(ncallbacks > 0); 646 wake_up_nr(&server->cb_break_waitq, ncallbacks); 647 648 return afs_make_call(&server->addr, call, GFP_NOFS, async); 649 } 650 651 /* 652 * deliver reply data to an FS.CreateFile or an FS.MakeDir 653 */ 654 static int afs_deliver_fs_create_vnode(struct afs_call *call) 655 { 656 struct afs_vnode *vnode = call->reply; 657 const __be32 *bp; 658 int ret; 659 660 _enter("{%u}", call->unmarshall); 661 662 ret = afs_transfer_reply(call); 663 if (ret < 0) 664 return ret; 665 666 /* unmarshall the reply once we've received all of it */ 667 bp = call->buffer; 668 xdr_decode_AFSFid(&bp, call->reply2); 669 xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL); 670 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL); 671 xdr_decode_AFSCallBack_raw(&bp, call->reply4); 672 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 673 674 _leave(" = 0 [done]"); 675 return 0; 676 } 677 678 /* 679 * FS.CreateFile and FS.MakeDir operation type 680 */ 681 static const struct afs_call_type afs_RXFSCreateXXXX = { 682 .name = "FS.CreateXXXX", 683 .deliver = afs_deliver_fs_create_vnode, 684 .abort_to_error = afs_abort_to_error, 685 .destructor = afs_flat_call_destructor, 686 }; 687 688 /* 689 * create a file or make a directory 690 */ 691 int afs_fs_create(struct afs_server *server, 692 struct key *key, 693 struct afs_vnode *vnode, 694 const char *name, 695 umode_t mode, 696 struct afs_fid *newfid, 697 struct afs_file_status *newstatus, 698 struct afs_callback *newcb, 699 bool async) 700 { 701 struct afs_call *call; 702 size_t namesz, reqsz, padsz; 703 __be32 *bp; 704 705 _enter(""); 706 707 namesz = strlen(name); 708 padsz = (4 - (namesz & 3)) & 3; 709 reqsz = (5 * 4) + namesz + padsz + (6 * 4); 710 711 call = afs_alloc_flat_call(&afs_RXFSCreateXXXX, reqsz, 712 (3 + 21 + 21 + 3 + 6) * 4); 713 if (!call) 714 return -ENOMEM; 715 716 call->key = key; 717 call->reply = vnode; 718 call->reply2 = newfid; 719 call->reply3 = newstatus; 720 call->reply4 = newcb; 721 call->service_id = FS_SERVICE; 722 call->port = htons(AFS_FS_PORT); 723 724 /* marshall the parameters */ 725 bp = call->request; 726 *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE); 727 *bp++ = htonl(vnode->fid.vid); 728 *bp++ = htonl(vnode->fid.vnode); 729 *bp++ = htonl(vnode->fid.unique); 730 *bp++ = htonl(namesz); 731 memcpy(bp, name, namesz); 732 bp = (void *) bp + namesz; 733 if (padsz > 0) { 734 memset(bp, 0, padsz); 735 bp = (void *) bp + padsz; 736 } 737 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); 738 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 739 *bp++ = 0; /* owner */ 740 *bp++ = 0; /* group */ 741 *bp++ = htonl(mode & S_IALLUGO); /* unix mode */ 742 *bp++ = 0; /* segment size */ 743 744 return afs_make_call(&server->addr, call, GFP_NOFS, async); 745 } 746 747 /* 748 * deliver reply data to an FS.RemoveFile or FS.RemoveDir 749 */ 750 static int afs_deliver_fs_remove(struct afs_call *call) 751 { 752 struct afs_vnode *vnode = call->reply; 753 const __be32 *bp; 754 int ret; 755 756 _enter("{%u}", call->unmarshall); 757 758 ret = afs_transfer_reply(call); 759 if (ret < 0) 760 return ret; 761 762 /* unmarshall the reply once we've received all of it */ 763 bp = call->buffer; 764 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL); 765 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 766 767 _leave(" = 0 [done]"); 768 return 0; 769 } 770 771 /* 772 * FS.RemoveDir/FS.RemoveFile operation type 773 */ 774 static const struct afs_call_type afs_RXFSRemoveXXXX = { 775 .name = "FS.RemoveXXXX", 776 .deliver = afs_deliver_fs_remove, 777 .abort_to_error = afs_abort_to_error, 778 .destructor = afs_flat_call_destructor, 779 }; 780 781 /* 782 * remove a file or directory 783 */ 784 int afs_fs_remove(struct afs_server *server, 785 struct key *key, 786 struct afs_vnode *vnode, 787 const char *name, 788 bool isdir, 789 bool async) 790 { 791 struct afs_call *call; 792 size_t namesz, reqsz, padsz; 793 __be32 *bp; 794 795 _enter(""); 796 797 namesz = strlen(name); 798 padsz = (4 - (namesz & 3)) & 3; 799 reqsz = (5 * 4) + namesz + padsz; 800 801 call = afs_alloc_flat_call(&afs_RXFSRemoveXXXX, reqsz, (21 + 6) * 4); 802 if (!call) 803 return -ENOMEM; 804 805 call->key = key; 806 call->reply = vnode; 807 call->service_id = FS_SERVICE; 808 call->port = htons(AFS_FS_PORT); 809 810 /* marshall the parameters */ 811 bp = call->request; 812 *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE); 813 *bp++ = htonl(vnode->fid.vid); 814 *bp++ = htonl(vnode->fid.vnode); 815 *bp++ = htonl(vnode->fid.unique); 816 *bp++ = htonl(namesz); 817 memcpy(bp, name, namesz); 818 bp = (void *) bp + namesz; 819 if (padsz > 0) { 820 memset(bp, 0, padsz); 821 bp = (void *) bp + padsz; 822 } 823 824 return afs_make_call(&server->addr, call, GFP_NOFS, async); 825 } 826 827 /* 828 * deliver reply data to an FS.Link 829 */ 830 static int afs_deliver_fs_link(struct afs_call *call) 831 { 832 struct afs_vnode *dvnode = call->reply, *vnode = call->reply2; 833 const __be32 *bp; 834 int ret; 835 836 _enter("{%u}", call->unmarshall); 837 838 ret = afs_transfer_reply(call); 839 if (ret < 0) 840 return ret; 841 842 /* unmarshall the reply once we've received all of it */ 843 bp = call->buffer; 844 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL); 845 xdr_decode_AFSFetchStatus(&bp, &dvnode->status, dvnode, NULL); 846 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 847 848 _leave(" = 0 [done]"); 849 return 0; 850 } 851 852 /* 853 * FS.Link operation type 854 */ 855 static const struct afs_call_type afs_RXFSLink = { 856 .name = "FS.Link", 857 .deliver = afs_deliver_fs_link, 858 .abort_to_error = afs_abort_to_error, 859 .destructor = afs_flat_call_destructor, 860 }; 861 862 /* 863 * make a hard link 864 */ 865 int afs_fs_link(struct afs_server *server, 866 struct key *key, 867 struct afs_vnode *dvnode, 868 struct afs_vnode *vnode, 869 const char *name, 870 bool async) 871 { 872 struct afs_call *call; 873 size_t namesz, reqsz, padsz; 874 __be32 *bp; 875 876 _enter(""); 877 878 namesz = strlen(name); 879 padsz = (4 - (namesz & 3)) & 3; 880 reqsz = (5 * 4) + namesz + padsz + (3 * 4); 881 882 call = afs_alloc_flat_call(&afs_RXFSLink, reqsz, (21 + 21 + 6) * 4); 883 if (!call) 884 return -ENOMEM; 885 886 call->key = key; 887 call->reply = dvnode; 888 call->reply2 = vnode; 889 call->service_id = FS_SERVICE; 890 call->port = htons(AFS_FS_PORT); 891 892 /* marshall the parameters */ 893 bp = call->request; 894 *bp++ = htonl(FSLINK); 895 *bp++ = htonl(dvnode->fid.vid); 896 *bp++ = htonl(dvnode->fid.vnode); 897 *bp++ = htonl(dvnode->fid.unique); 898 *bp++ = htonl(namesz); 899 memcpy(bp, name, namesz); 900 bp = (void *) bp + namesz; 901 if (padsz > 0) { 902 memset(bp, 0, padsz); 903 bp = (void *) bp + padsz; 904 } 905 *bp++ = htonl(vnode->fid.vid); 906 *bp++ = htonl(vnode->fid.vnode); 907 *bp++ = htonl(vnode->fid.unique); 908 909 return afs_make_call(&server->addr, call, GFP_NOFS, async); 910 } 911 912 /* 913 * deliver reply data to an FS.Symlink 914 */ 915 static int afs_deliver_fs_symlink(struct afs_call *call) 916 { 917 struct afs_vnode *vnode = call->reply; 918 const __be32 *bp; 919 int ret; 920 921 _enter("{%u}", call->unmarshall); 922 923 ret = afs_transfer_reply(call); 924 if (ret < 0) 925 return ret; 926 927 /* unmarshall the reply once we've received all of it */ 928 bp = call->buffer; 929 xdr_decode_AFSFid(&bp, call->reply2); 930 xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL); 931 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL); 932 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 933 934 _leave(" = 0 [done]"); 935 return 0; 936 } 937 938 /* 939 * FS.Symlink operation type 940 */ 941 static const struct afs_call_type afs_RXFSSymlink = { 942 .name = "FS.Symlink", 943 .deliver = afs_deliver_fs_symlink, 944 .abort_to_error = afs_abort_to_error, 945 .destructor = afs_flat_call_destructor, 946 }; 947 948 /* 949 * create a symbolic link 950 */ 951 int afs_fs_symlink(struct afs_server *server, 952 struct key *key, 953 struct afs_vnode *vnode, 954 const char *name, 955 const char *contents, 956 struct afs_fid *newfid, 957 struct afs_file_status *newstatus, 958 bool async) 959 { 960 struct afs_call *call; 961 size_t namesz, reqsz, padsz, c_namesz, c_padsz; 962 __be32 *bp; 963 964 _enter(""); 965 966 namesz = strlen(name); 967 padsz = (4 - (namesz & 3)) & 3; 968 969 c_namesz = strlen(contents); 970 c_padsz = (4 - (c_namesz & 3)) & 3; 971 972 reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4); 973 974 call = afs_alloc_flat_call(&afs_RXFSSymlink, reqsz, 975 (3 + 21 + 21 + 6) * 4); 976 if (!call) 977 return -ENOMEM; 978 979 call->key = key; 980 call->reply = vnode; 981 call->reply2 = newfid; 982 call->reply3 = newstatus; 983 call->service_id = FS_SERVICE; 984 call->port = htons(AFS_FS_PORT); 985 986 /* marshall the parameters */ 987 bp = call->request; 988 *bp++ = htonl(FSSYMLINK); 989 *bp++ = htonl(vnode->fid.vid); 990 *bp++ = htonl(vnode->fid.vnode); 991 *bp++ = htonl(vnode->fid.unique); 992 *bp++ = htonl(namesz); 993 memcpy(bp, name, namesz); 994 bp = (void *) bp + namesz; 995 if (padsz > 0) { 996 memset(bp, 0, padsz); 997 bp = (void *) bp + padsz; 998 } 999 *bp++ = htonl(c_namesz); 1000 memcpy(bp, contents, c_namesz); 1001 bp = (void *) bp + c_namesz; 1002 if (c_padsz > 0) { 1003 memset(bp, 0, c_padsz); 1004 bp = (void *) bp + c_padsz; 1005 } 1006 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); 1007 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 1008 *bp++ = 0; /* owner */ 1009 *bp++ = 0; /* group */ 1010 *bp++ = htonl(S_IRWXUGO); /* unix mode */ 1011 *bp++ = 0; /* segment size */ 1012 1013 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1014 } 1015 1016 /* 1017 * deliver reply data to an FS.Rename 1018 */ 1019 static int afs_deliver_fs_rename(struct afs_call *call) 1020 { 1021 struct afs_vnode *orig_dvnode = call->reply, *new_dvnode = call->reply2; 1022 const __be32 *bp; 1023 int ret; 1024 1025 _enter("{%u}", call->unmarshall); 1026 1027 ret = afs_transfer_reply(call); 1028 if (ret < 0) 1029 return ret; 1030 1031 /* unmarshall the reply once we've received all of it */ 1032 bp = call->buffer; 1033 xdr_decode_AFSFetchStatus(&bp, &orig_dvnode->status, orig_dvnode, NULL); 1034 if (new_dvnode != orig_dvnode) 1035 xdr_decode_AFSFetchStatus(&bp, &new_dvnode->status, new_dvnode, 1036 NULL); 1037 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 1038 1039 _leave(" = 0 [done]"); 1040 return 0; 1041 } 1042 1043 /* 1044 * FS.Rename operation type 1045 */ 1046 static const struct afs_call_type afs_RXFSRename = { 1047 .name = "FS.Rename", 1048 .deliver = afs_deliver_fs_rename, 1049 .abort_to_error = afs_abort_to_error, 1050 .destructor = afs_flat_call_destructor, 1051 }; 1052 1053 /* 1054 * create a symbolic link 1055 */ 1056 int afs_fs_rename(struct afs_server *server, 1057 struct key *key, 1058 struct afs_vnode *orig_dvnode, 1059 const char *orig_name, 1060 struct afs_vnode *new_dvnode, 1061 const char *new_name, 1062 bool async) 1063 { 1064 struct afs_call *call; 1065 size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz; 1066 __be32 *bp; 1067 1068 _enter(""); 1069 1070 o_namesz = strlen(orig_name); 1071 o_padsz = (4 - (o_namesz & 3)) & 3; 1072 1073 n_namesz = strlen(new_name); 1074 n_padsz = (4 - (n_namesz & 3)) & 3; 1075 1076 reqsz = (4 * 4) + 1077 4 + o_namesz + o_padsz + 1078 (3 * 4) + 1079 4 + n_namesz + n_padsz; 1080 1081 call = afs_alloc_flat_call(&afs_RXFSRename, reqsz, (21 + 21 + 6) * 4); 1082 if (!call) 1083 return -ENOMEM; 1084 1085 call->key = key; 1086 call->reply = orig_dvnode; 1087 call->reply2 = new_dvnode; 1088 call->service_id = FS_SERVICE; 1089 call->port = htons(AFS_FS_PORT); 1090 1091 /* marshall the parameters */ 1092 bp = call->request; 1093 *bp++ = htonl(FSRENAME); 1094 *bp++ = htonl(orig_dvnode->fid.vid); 1095 *bp++ = htonl(orig_dvnode->fid.vnode); 1096 *bp++ = htonl(orig_dvnode->fid.unique); 1097 *bp++ = htonl(o_namesz); 1098 memcpy(bp, orig_name, o_namesz); 1099 bp = (void *) bp + o_namesz; 1100 if (o_padsz > 0) { 1101 memset(bp, 0, o_padsz); 1102 bp = (void *) bp + o_padsz; 1103 } 1104 1105 *bp++ = htonl(new_dvnode->fid.vid); 1106 *bp++ = htonl(new_dvnode->fid.vnode); 1107 *bp++ = htonl(new_dvnode->fid.unique); 1108 *bp++ = htonl(n_namesz); 1109 memcpy(bp, new_name, n_namesz); 1110 bp = (void *) bp + n_namesz; 1111 if (n_padsz > 0) { 1112 memset(bp, 0, n_padsz); 1113 bp = (void *) bp + n_padsz; 1114 } 1115 1116 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1117 } 1118 1119 /* 1120 * deliver reply data to an FS.StoreData 1121 */ 1122 static int afs_deliver_fs_store_data(struct afs_call *call) 1123 { 1124 struct afs_vnode *vnode = call->reply; 1125 const __be32 *bp; 1126 int ret; 1127 1128 _enter(""); 1129 1130 ret = afs_transfer_reply(call); 1131 if (ret < 0) 1132 return ret; 1133 1134 /* unmarshall the reply once we've received all of it */ 1135 bp = call->buffer; 1136 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, 1137 &call->store_version); 1138 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 1139 1140 afs_pages_written_back(vnode, call); 1141 1142 _leave(" = 0 [done]"); 1143 return 0; 1144 } 1145 1146 /* 1147 * FS.StoreData operation type 1148 */ 1149 static const struct afs_call_type afs_RXFSStoreData = { 1150 .name = "FS.StoreData", 1151 .deliver = afs_deliver_fs_store_data, 1152 .abort_to_error = afs_abort_to_error, 1153 .destructor = afs_flat_call_destructor, 1154 }; 1155 1156 static const struct afs_call_type afs_RXFSStoreData64 = { 1157 .name = "FS.StoreData64", 1158 .deliver = afs_deliver_fs_store_data, 1159 .abort_to_error = afs_abort_to_error, 1160 .destructor = afs_flat_call_destructor, 1161 }; 1162 1163 /* 1164 * store a set of pages to a very large file 1165 */ 1166 static int afs_fs_store_data64(struct afs_server *server, 1167 struct afs_writeback *wb, 1168 pgoff_t first, pgoff_t last, 1169 unsigned offset, unsigned to, 1170 loff_t size, loff_t pos, loff_t i_size, 1171 bool async) 1172 { 1173 struct afs_vnode *vnode = wb->vnode; 1174 struct afs_call *call; 1175 __be32 *bp; 1176 1177 _enter(",%x,{%x:%u},,", 1178 key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode); 1179 1180 call = afs_alloc_flat_call(&afs_RXFSStoreData64, 1181 (4 + 6 + 3 * 2) * 4, 1182 (21 + 6) * 4); 1183 if (!call) 1184 return -ENOMEM; 1185 1186 call->wb = wb; 1187 call->key = wb->key; 1188 call->reply = vnode; 1189 call->service_id = FS_SERVICE; 1190 call->port = htons(AFS_FS_PORT); 1191 call->mapping = vnode->vfs_inode.i_mapping; 1192 call->first = first; 1193 call->last = last; 1194 call->first_offset = offset; 1195 call->last_to = to; 1196 call->send_pages = true; 1197 call->store_version = vnode->status.data_version + 1; 1198 1199 /* marshall the parameters */ 1200 bp = call->request; 1201 *bp++ = htonl(FSSTOREDATA64); 1202 *bp++ = htonl(vnode->fid.vid); 1203 *bp++ = htonl(vnode->fid.vnode); 1204 *bp++ = htonl(vnode->fid.unique); 1205 1206 *bp++ = htonl(AFS_SET_MTIME); /* mask */ 1207 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 1208 *bp++ = 0; /* owner */ 1209 *bp++ = 0; /* group */ 1210 *bp++ = 0; /* unix mode */ 1211 *bp++ = 0; /* segment size */ 1212 1213 *bp++ = htonl(pos >> 32); 1214 *bp++ = htonl((u32) pos); 1215 *bp++ = htonl(size >> 32); 1216 *bp++ = htonl((u32) size); 1217 *bp++ = htonl(i_size >> 32); 1218 *bp++ = htonl((u32) i_size); 1219 1220 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1221 } 1222 1223 /* 1224 * store a set of pages 1225 */ 1226 int afs_fs_store_data(struct afs_server *server, struct afs_writeback *wb, 1227 pgoff_t first, pgoff_t last, 1228 unsigned offset, unsigned to, 1229 bool async) 1230 { 1231 struct afs_vnode *vnode = wb->vnode; 1232 struct afs_call *call; 1233 loff_t size, pos, i_size; 1234 __be32 *bp; 1235 1236 _enter(",%x,{%x:%u},,", 1237 key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode); 1238 1239 size = (loff_t)to - (loff_t)offset; 1240 if (first != last) 1241 size += (loff_t)(last - first) << PAGE_SHIFT; 1242 pos = (loff_t)first << PAGE_SHIFT; 1243 pos += offset; 1244 1245 i_size = i_size_read(&vnode->vfs_inode); 1246 if (pos + size > i_size) 1247 i_size = size + pos; 1248 1249 _debug("size %llx, at %llx, i_size %llx", 1250 (unsigned long long) size, (unsigned long long) pos, 1251 (unsigned long long) i_size); 1252 1253 if (pos >> 32 || i_size >> 32 || size >> 32 || (pos + size) >> 32) 1254 return afs_fs_store_data64(server, wb, first, last, offset, to, 1255 size, pos, i_size, async); 1256 1257 call = afs_alloc_flat_call(&afs_RXFSStoreData, 1258 (4 + 6 + 3) * 4, 1259 (21 + 6) * 4); 1260 if (!call) 1261 return -ENOMEM; 1262 1263 call->wb = wb; 1264 call->key = wb->key; 1265 call->reply = vnode; 1266 call->service_id = FS_SERVICE; 1267 call->port = htons(AFS_FS_PORT); 1268 call->mapping = vnode->vfs_inode.i_mapping; 1269 call->first = first; 1270 call->last = last; 1271 call->first_offset = offset; 1272 call->last_to = to; 1273 call->send_pages = true; 1274 call->store_version = vnode->status.data_version + 1; 1275 1276 /* marshall the parameters */ 1277 bp = call->request; 1278 *bp++ = htonl(FSSTOREDATA); 1279 *bp++ = htonl(vnode->fid.vid); 1280 *bp++ = htonl(vnode->fid.vnode); 1281 *bp++ = htonl(vnode->fid.unique); 1282 1283 *bp++ = htonl(AFS_SET_MTIME); /* mask */ 1284 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */ 1285 *bp++ = 0; /* owner */ 1286 *bp++ = 0; /* group */ 1287 *bp++ = 0; /* unix mode */ 1288 *bp++ = 0; /* segment size */ 1289 1290 *bp++ = htonl(pos); 1291 *bp++ = htonl(size); 1292 *bp++ = htonl(i_size); 1293 1294 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1295 } 1296 1297 /* 1298 * deliver reply data to an FS.StoreStatus 1299 */ 1300 static int afs_deliver_fs_store_status(struct afs_call *call) 1301 { 1302 afs_dataversion_t *store_version; 1303 struct afs_vnode *vnode = call->reply; 1304 const __be32 *bp; 1305 int ret; 1306 1307 _enter(""); 1308 1309 ret = afs_transfer_reply(call); 1310 if (ret < 0) 1311 return ret; 1312 1313 /* unmarshall the reply once we've received all of it */ 1314 store_version = NULL; 1315 if (call->operation_ID == FSSTOREDATA) 1316 store_version = &call->store_version; 1317 1318 bp = call->buffer; 1319 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, store_version); 1320 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 1321 1322 _leave(" = 0 [done]"); 1323 return 0; 1324 } 1325 1326 /* 1327 * FS.StoreStatus operation type 1328 */ 1329 static const struct afs_call_type afs_RXFSStoreStatus = { 1330 .name = "FS.StoreStatus", 1331 .deliver = afs_deliver_fs_store_status, 1332 .abort_to_error = afs_abort_to_error, 1333 .destructor = afs_flat_call_destructor, 1334 }; 1335 1336 static const struct afs_call_type afs_RXFSStoreData_as_Status = { 1337 .name = "FS.StoreData", 1338 .deliver = afs_deliver_fs_store_status, 1339 .abort_to_error = afs_abort_to_error, 1340 .destructor = afs_flat_call_destructor, 1341 }; 1342 1343 static const struct afs_call_type afs_RXFSStoreData64_as_Status = { 1344 .name = "FS.StoreData64", 1345 .deliver = afs_deliver_fs_store_status, 1346 .abort_to_error = afs_abort_to_error, 1347 .destructor = afs_flat_call_destructor, 1348 }; 1349 1350 /* 1351 * set the attributes on a very large file, using FS.StoreData rather than 1352 * FS.StoreStatus so as to alter the file size also 1353 */ 1354 static int afs_fs_setattr_size64(struct afs_server *server, struct key *key, 1355 struct afs_vnode *vnode, struct iattr *attr, 1356 bool async) 1357 { 1358 struct afs_call *call; 1359 __be32 *bp; 1360 1361 _enter(",%x,{%x:%u},,", 1362 key_serial(key), vnode->fid.vid, vnode->fid.vnode); 1363 1364 ASSERT(attr->ia_valid & ATTR_SIZE); 1365 1366 call = afs_alloc_flat_call(&afs_RXFSStoreData64_as_Status, 1367 (4 + 6 + 3 * 2) * 4, 1368 (21 + 6) * 4); 1369 if (!call) 1370 return -ENOMEM; 1371 1372 call->key = key; 1373 call->reply = vnode; 1374 call->service_id = FS_SERVICE; 1375 call->port = htons(AFS_FS_PORT); 1376 call->store_version = vnode->status.data_version + 1; 1377 call->operation_ID = FSSTOREDATA; 1378 1379 /* marshall the parameters */ 1380 bp = call->request; 1381 *bp++ = htonl(FSSTOREDATA64); 1382 *bp++ = htonl(vnode->fid.vid); 1383 *bp++ = htonl(vnode->fid.vnode); 1384 *bp++ = htonl(vnode->fid.unique); 1385 1386 xdr_encode_AFS_StoreStatus(&bp, attr); 1387 1388 *bp++ = 0; /* position of start of write */ 1389 *bp++ = 0; 1390 *bp++ = 0; /* size of write */ 1391 *bp++ = 0; 1392 *bp++ = htonl(attr->ia_size >> 32); /* new file length */ 1393 *bp++ = htonl((u32) attr->ia_size); 1394 1395 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1396 } 1397 1398 /* 1399 * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus 1400 * so as to alter the file size also 1401 */ 1402 static int afs_fs_setattr_size(struct afs_server *server, struct key *key, 1403 struct afs_vnode *vnode, struct iattr *attr, 1404 bool async) 1405 { 1406 struct afs_call *call; 1407 __be32 *bp; 1408 1409 _enter(",%x,{%x:%u},,", 1410 key_serial(key), vnode->fid.vid, vnode->fid.vnode); 1411 1412 ASSERT(attr->ia_valid & ATTR_SIZE); 1413 if (attr->ia_size >> 32) 1414 return afs_fs_setattr_size64(server, key, vnode, attr, 1415 async); 1416 1417 call = afs_alloc_flat_call(&afs_RXFSStoreData_as_Status, 1418 (4 + 6 + 3) * 4, 1419 (21 + 6) * 4); 1420 if (!call) 1421 return -ENOMEM; 1422 1423 call->key = key; 1424 call->reply = vnode; 1425 call->service_id = FS_SERVICE; 1426 call->port = htons(AFS_FS_PORT); 1427 call->store_version = vnode->status.data_version + 1; 1428 call->operation_ID = FSSTOREDATA; 1429 1430 /* marshall the parameters */ 1431 bp = call->request; 1432 *bp++ = htonl(FSSTOREDATA); 1433 *bp++ = htonl(vnode->fid.vid); 1434 *bp++ = htonl(vnode->fid.vnode); 1435 *bp++ = htonl(vnode->fid.unique); 1436 1437 xdr_encode_AFS_StoreStatus(&bp, attr); 1438 1439 *bp++ = 0; /* position of start of write */ 1440 *bp++ = 0; /* size of write */ 1441 *bp++ = htonl(attr->ia_size); /* new file length */ 1442 1443 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1444 } 1445 1446 /* 1447 * set the attributes on a file, using FS.StoreData if there's a change in file 1448 * size, and FS.StoreStatus otherwise 1449 */ 1450 int afs_fs_setattr(struct afs_server *server, struct key *key, 1451 struct afs_vnode *vnode, struct iattr *attr, 1452 bool async) 1453 { 1454 struct afs_call *call; 1455 __be32 *bp; 1456 1457 if (attr->ia_valid & ATTR_SIZE) 1458 return afs_fs_setattr_size(server, key, vnode, attr, 1459 async); 1460 1461 _enter(",%x,{%x:%u},,", 1462 key_serial(key), vnode->fid.vid, vnode->fid.vnode); 1463 1464 call = afs_alloc_flat_call(&afs_RXFSStoreStatus, 1465 (4 + 6) * 4, 1466 (21 + 6) * 4); 1467 if (!call) 1468 return -ENOMEM; 1469 1470 call->key = key; 1471 call->reply = vnode; 1472 call->service_id = FS_SERVICE; 1473 call->port = htons(AFS_FS_PORT); 1474 call->operation_ID = FSSTORESTATUS; 1475 1476 /* marshall the parameters */ 1477 bp = call->request; 1478 *bp++ = htonl(FSSTORESTATUS); 1479 *bp++ = htonl(vnode->fid.vid); 1480 *bp++ = htonl(vnode->fid.vnode); 1481 *bp++ = htonl(vnode->fid.unique); 1482 1483 xdr_encode_AFS_StoreStatus(&bp, attr); 1484 1485 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1486 } 1487 1488 /* 1489 * deliver reply data to an FS.GetVolumeStatus 1490 */ 1491 static int afs_deliver_fs_get_volume_status(struct afs_call *call) 1492 { 1493 const __be32 *bp; 1494 char *p; 1495 int ret; 1496 1497 _enter("{%u}", call->unmarshall); 1498 1499 switch (call->unmarshall) { 1500 case 0: 1501 call->offset = 0; 1502 call->unmarshall++; 1503 1504 /* extract the returned status record */ 1505 case 1: 1506 _debug("extract status"); 1507 ret = afs_extract_data(call, call->buffer, 1508 12 * 4, true); 1509 if (ret < 0) 1510 return ret; 1511 1512 bp = call->buffer; 1513 xdr_decode_AFSFetchVolumeStatus(&bp, call->reply2); 1514 call->offset = 0; 1515 call->unmarshall++; 1516 1517 /* extract the volume name length */ 1518 case 2: 1519 ret = afs_extract_data(call, &call->tmp, 4, true); 1520 if (ret < 0) 1521 return ret; 1522 1523 call->count = ntohl(call->tmp); 1524 _debug("volname length: %u", call->count); 1525 if (call->count >= AFSNAMEMAX) 1526 return -EBADMSG; 1527 call->offset = 0; 1528 call->unmarshall++; 1529 1530 /* extract the volume name */ 1531 case 3: 1532 _debug("extract volname"); 1533 if (call->count > 0) { 1534 ret = afs_extract_data(call, call->reply3, 1535 call->count, true); 1536 if (ret < 0) 1537 return ret; 1538 } 1539 1540 p = call->reply3; 1541 p[call->count] = 0; 1542 _debug("volname '%s'", p); 1543 1544 call->offset = 0; 1545 call->unmarshall++; 1546 1547 /* extract the volume name padding */ 1548 if ((call->count & 3) == 0) { 1549 call->unmarshall++; 1550 goto no_volname_padding; 1551 } 1552 call->count = 4 - (call->count & 3); 1553 1554 case 4: 1555 ret = afs_extract_data(call, call->buffer, 1556 call->count, true); 1557 if (ret < 0) 1558 return ret; 1559 1560 call->offset = 0; 1561 call->unmarshall++; 1562 no_volname_padding: 1563 1564 /* extract the offline message length */ 1565 case 5: 1566 ret = afs_extract_data(call, &call->tmp, 4, true); 1567 if (ret < 0) 1568 return ret; 1569 1570 call->count = ntohl(call->tmp); 1571 _debug("offline msg length: %u", call->count); 1572 if (call->count >= AFSNAMEMAX) 1573 return -EBADMSG; 1574 call->offset = 0; 1575 call->unmarshall++; 1576 1577 /* extract the offline message */ 1578 case 6: 1579 _debug("extract offline"); 1580 if (call->count > 0) { 1581 ret = afs_extract_data(call, call->reply3, 1582 call->count, true); 1583 if (ret < 0) 1584 return ret; 1585 } 1586 1587 p = call->reply3; 1588 p[call->count] = 0; 1589 _debug("offline '%s'", p); 1590 1591 call->offset = 0; 1592 call->unmarshall++; 1593 1594 /* extract the offline message padding */ 1595 if ((call->count & 3) == 0) { 1596 call->unmarshall++; 1597 goto no_offline_padding; 1598 } 1599 call->count = 4 - (call->count & 3); 1600 1601 case 7: 1602 ret = afs_extract_data(call, call->buffer, 1603 call->count, true); 1604 if (ret < 0) 1605 return ret; 1606 1607 call->offset = 0; 1608 call->unmarshall++; 1609 no_offline_padding: 1610 1611 /* extract the message of the day length */ 1612 case 8: 1613 ret = afs_extract_data(call, &call->tmp, 4, true); 1614 if (ret < 0) 1615 return ret; 1616 1617 call->count = ntohl(call->tmp); 1618 _debug("motd length: %u", call->count); 1619 if (call->count >= AFSNAMEMAX) 1620 return -EBADMSG; 1621 call->offset = 0; 1622 call->unmarshall++; 1623 1624 /* extract the message of the day */ 1625 case 9: 1626 _debug("extract motd"); 1627 if (call->count > 0) { 1628 ret = afs_extract_data(call, call->reply3, 1629 call->count, true); 1630 if (ret < 0) 1631 return ret; 1632 } 1633 1634 p = call->reply3; 1635 p[call->count] = 0; 1636 _debug("motd '%s'", p); 1637 1638 call->offset = 0; 1639 call->unmarshall++; 1640 1641 /* extract the message of the day padding */ 1642 call->count = (4 - (call->count & 3)) & 3; 1643 1644 case 10: 1645 ret = afs_extract_data(call, call->buffer, 1646 call->count, false); 1647 if (ret < 0) 1648 return ret; 1649 1650 call->offset = 0; 1651 call->unmarshall++; 1652 case 11: 1653 break; 1654 } 1655 1656 _leave(" = 0 [done]"); 1657 return 0; 1658 } 1659 1660 /* 1661 * destroy an FS.GetVolumeStatus call 1662 */ 1663 static void afs_get_volume_status_call_destructor(struct afs_call *call) 1664 { 1665 kfree(call->reply3); 1666 call->reply3 = NULL; 1667 afs_flat_call_destructor(call); 1668 } 1669 1670 /* 1671 * FS.GetVolumeStatus operation type 1672 */ 1673 static const struct afs_call_type afs_RXFSGetVolumeStatus = { 1674 .name = "FS.GetVolumeStatus", 1675 .deliver = afs_deliver_fs_get_volume_status, 1676 .abort_to_error = afs_abort_to_error, 1677 .destructor = afs_get_volume_status_call_destructor, 1678 }; 1679 1680 /* 1681 * fetch the status of a volume 1682 */ 1683 int afs_fs_get_volume_status(struct afs_server *server, 1684 struct key *key, 1685 struct afs_vnode *vnode, 1686 struct afs_volume_status *vs, 1687 bool async) 1688 { 1689 struct afs_call *call; 1690 __be32 *bp; 1691 void *tmpbuf; 1692 1693 _enter(""); 1694 1695 tmpbuf = kmalloc(AFSOPAQUEMAX, GFP_KERNEL); 1696 if (!tmpbuf) 1697 return -ENOMEM; 1698 1699 call = afs_alloc_flat_call(&afs_RXFSGetVolumeStatus, 2 * 4, 12 * 4); 1700 if (!call) { 1701 kfree(tmpbuf); 1702 return -ENOMEM; 1703 } 1704 1705 call->key = key; 1706 call->reply = vnode; 1707 call->reply2 = vs; 1708 call->reply3 = tmpbuf; 1709 call->service_id = FS_SERVICE; 1710 call->port = htons(AFS_FS_PORT); 1711 1712 /* marshall the parameters */ 1713 bp = call->request; 1714 bp[0] = htonl(FSGETVOLUMESTATUS); 1715 bp[1] = htonl(vnode->fid.vid); 1716 1717 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1718 } 1719 1720 /* 1721 * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock 1722 */ 1723 static int afs_deliver_fs_xxxx_lock(struct afs_call *call) 1724 { 1725 const __be32 *bp; 1726 int ret; 1727 1728 _enter("{%u}", call->unmarshall); 1729 1730 ret = afs_transfer_reply(call); 1731 if (ret < 0) 1732 return ret; 1733 1734 /* unmarshall the reply once we've received all of it */ 1735 bp = call->buffer; 1736 /* xdr_decode_AFSVolSync(&bp, call->replyX); */ 1737 1738 _leave(" = 0 [done]"); 1739 return 0; 1740 } 1741 1742 /* 1743 * FS.SetLock operation type 1744 */ 1745 static const struct afs_call_type afs_RXFSSetLock = { 1746 .name = "FS.SetLock", 1747 .deliver = afs_deliver_fs_xxxx_lock, 1748 .abort_to_error = afs_abort_to_error, 1749 .destructor = afs_flat_call_destructor, 1750 }; 1751 1752 /* 1753 * FS.ExtendLock operation type 1754 */ 1755 static const struct afs_call_type afs_RXFSExtendLock = { 1756 .name = "FS.ExtendLock", 1757 .deliver = afs_deliver_fs_xxxx_lock, 1758 .abort_to_error = afs_abort_to_error, 1759 .destructor = afs_flat_call_destructor, 1760 }; 1761 1762 /* 1763 * FS.ReleaseLock operation type 1764 */ 1765 static const struct afs_call_type afs_RXFSReleaseLock = { 1766 .name = "FS.ReleaseLock", 1767 .deliver = afs_deliver_fs_xxxx_lock, 1768 .abort_to_error = afs_abort_to_error, 1769 .destructor = afs_flat_call_destructor, 1770 }; 1771 1772 /* 1773 * get a lock on a file 1774 */ 1775 int afs_fs_set_lock(struct afs_server *server, 1776 struct key *key, 1777 struct afs_vnode *vnode, 1778 afs_lock_type_t type, 1779 bool async) 1780 { 1781 struct afs_call *call; 1782 __be32 *bp; 1783 1784 _enter(""); 1785 1786 call = afs_alloc_flat_call(&afs_RXFSSetLock, 5 * 4, 6 * 4); 1787 if (!call) 1788 return -ENOMEM; 1789 1790 call->key = key; 1791 call->reply = vnode; 1792 call->service_id = FS_SERVICE; 1793 call->port = htons(AFS_FS_PORT); 1794 1795 /* marshall the parameters */ 1796 bp = call->request; 1797 *bp++ = htonl(FSSETLOCK); 1798 *bp++ = htonl(vnode->fid.vid); 1799 *bp++ = htonl(vnode->fid.vnode); 1800 *bp++ = htonl(vnode->fid.unique); 1801 *bp++ = htonl(type); 1802 1803 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1804 } 1805 1806 /* 1807 * extend a lock on a file 1808 */ 1809 int afs_fs_extend_lock(struct afs_server *server, 1810 struct key *key, 1811 struct afs_vnode *vnode, 1812 bool async) 1813 { 1814 struct afs_call *call; 1815 __be32 *bp; 1816 1817 _enter(""); 1818 1819 call = afs_alloc_flat_call(&afs_RXFSExtendLock, 4 * 4, 6 * 4); 1820 if (!call) 1821 return -ENOMEM; 1822 1823 call->key = key; 1824 call->reply = vnode; 1825 call->service_id = FS_SERVICE; 1826 call->port = htons(AFS_FS_PORT); 1827 1828 /* marshall the parameters */ 1829 bp = call->request; 1830 *bp++ = htonl(FSEXTENDLOCK); 1831 *bp++ = htonl(vnode->fid.vid); 1832 *bp++ = htonl(vnode->fid.vnode); 1833 *bp++ = htonl(vnode->fid.unique); 1834 1835 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1836 } 1837 1838 /* 1839 * release a lock on a file 1840 */ 1841 int afs_fs_release_lock(struct afs_server *server, 1842 struct key *key, 1843 struct afs_vnode *vnode, 1844 bool async) 1845 { 1846 struct afs_call *call; 1847 __be32 *bp; 1848 1849 _enter(""); 1850 1851 call = afs_alloc_flat_call(&afs_RXFSReleaseLock, 4 * 4, 6 * 4); 1852 if (!call) 1853 return -ENOMEM; 1854 1855 call->key = key; 1856 call->reply = vnode; 1857 call->service_id = FS_SERVICE; 1858 call->port = htons(AFS_FS_PORT); 1859 1860 /* marshall the parameters */ 1861 bp = call->request; 1862 *bp++ = htonl(FSRELEASELOCK); 1863 *bp++ = htonl(vnode->fid.vid); 1864 *bp++ = htonl(vnode->fid.vnode); 1865 *bp++ = htonl(vnode->fid.unique); 1866 1867 return afs_make_call(&server->addr, call, GFP_NOFS, async); 1868 } 1869