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