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