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 (upper_32_bits(req->pos) || 460 upper_32_bits(req->len) || 461 upper_32_bits(req->pos + req->len)) 462 return afs_fs_fetch_data64(op); 463 464 _enter(""); 465 466 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4); 467 if (!call) 468 return afs_op_nomem(op); 469 470 req->call_debug_id = call->debug_id; 471 472 /* marshall the parameters */ 473 bp = call->request; 474 bp[0] = htonl(FSFETCHDATA); 475 bp[1] = htonl(vp->fid.vid); 476 bp[2] = htonl(vp->fid.vnode); 477 bp[3] = htonl(vp->fid.unique); 478 bp[4] = htonl(lower_32_bits(req->pos)); 479 bp[5] = htonl(lower_32_bits(req->len)); 480 481 trace_afs_make_fs_call(call, &vp->fid); 482 afs_make_op_call(op, call, GFP_NOFS); 483 } 484 485 /* 486 * deliver reply data to an FS.CreateFile or an FS.MakeDir 487 */ 488 static int afs_deliver_fs_create_vnode(struct afs_call *call) 489 { 490 struct afs_operation *op = call->op; 491 struct afs_vnode_param *dvp = &op->file[0]; 492 struct afs_vnode_param *vp = &op->file[1]; 493 const __be32 *bp; 494 int ret; 495 496 ret = afs_transfer_reply(call); 497 if (ret < 0) 498 return ret; 499 500 /* unmarshall the reply once we've received all of it */ 501 bp = call->buffer; 502 xdr_decode_AFSFid(&bp, &op->file[1].fid); 503 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb); 504 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb); 505 xdr_decode_AFSCallBack(&bp, call, &vp->scb); 506 xdr_decode_AFSVolSync(&bp, &op->volsync); 507 508 _leave(" = 0 [done]"); 509 return 0; 510 } 511 512 /* 513 * FS.CreateFile and FS.MakeDir operation type 514 */ 515 static const struct afs_call_type afs_RXFSCreateFile = { 516 .name = "FS.CreateFile", 517 .op = afs_FS_CreateFile, 518 .deliver = afs_deliver_fs_create_vnode, 519 .destructor = afs_flat_call_destructor, 520 }; 521 522 /* 523 * Create a file. 524 */ 525 void afs_fs_create_file(struct afs_operation *op) 526 { 527 const struct qstr *name = &op->dentry->d_name; 528 struct afs_vnode_param *dvp = &op->file[0]; 529 struct afs_call *call; 530 size_t namesz, reqsz, padsz; 531 __be32 *bp; 532 533 _enter(""); 534 535 namesz = name->len; 536 padsz = (4 - (namesz & 3)) & 3; 537 reqsz = (5 * 4) + namesz + padsz + (6 * 4); 538 539 call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile, 540 reqsz, (3 + 21 + 21 + 3 + 6) * 4); 541 if (!call) 542 return afs_op_nomem(op); 543 544 /* marshall the parameters */ 545 bp = call->request; 546 *bp++ = htonl(FSCREATEFILE); 547 *bp++ = htonl(dvp->fid.vid); 548 *bp++ = htonl(dvp->fid.vnode); 549 *bp++ = htonl(dvp->fid.unique); 550 *bp++ = htonl(namesz); 551 memcpy(bp, name->name, namesz); 552 bp = (void *) bp + namesz; 553 if (padsz > 0) { 554 memset(bp, 0, padsz); 555 bp = (void *) bp + padsz; 556 } 557 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); 558 *bp++ = htonl(op->mtime.tv_sec); /* mtime */ 559 *bp++ = 0; /* owner */ 560 *bp++ = 0; /* group */ 561 *bp++ = htonl(op->create.mode & S_IALLUGO); /* unix mode */ 562 *bp++ = 0; /* segment size */ 563 564 trace_afs_make_fs_call1(call, &dvp->fid, name); 565 afs_make_op_call(op, call, GFP_NOFS); 566 } 567 568 static const struct afs_call_type afs_RXFSMakeDir = { 569 .name = "FS.MakeDir", 570 .op = afs_FS_MakeDir, 571 .deliver = afs_deliver_fs_create_vnode, 572 .destructor = afs_flat_call_destructor, 573 }; 574 575 /* 576 * Create a new directory 577 */ 578 void afs_fs_make_dir(struct afs_operation *op) 579 { 580 const struct qstr *name = &op->dentry->d_name; 581 struct afs_vnode_param *dvp = &op->file[0]; 582 struct afs_call *call; 583 size_t namesz, reqsz, padsz; 584 __be32 *bp; 585 586 _enter(""); 587 588 namesz = name->len; 589 padsz = (4 - (namesz & 3)) & 3; 590 reqsz = (5 * 4) + namesz + padsz + (6 * 4); 591 592 call = afs_alloc_flat_call(op->net, &afs_RXFSMakeDir, 593 reqsz, (3 + 21 + 21 + 3 + 6) * 4); 594 if (!call) 595 return afs_op_nomem(op); 596 597 /* marshall the parameters */ 598 bp = call->request; 599 *bp++ = htonl(FSMAKEDIR); 600 *bp++ = htonl(dvp->fid.vid); 601 *bp++ = htonl(dvp->fid.vnode); 602 *bp++ = htonl(dvp->fid.unique); 603 *bp++ = htonl(namesz); 604 memcpy(bp, name->name, namesz); 605 bp = (void *) bp + namesz; 606 if (padsz > 0) { 607 memset(bp, 0, padsz); 608 bp = (void *) bp + padsz; 609 } 610 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); 611 *bp++ = htonl(op->mtime.tv_sec); /* mtime */ 612 *bp++ = 0; /* owner */ 613 *bp++ = 0; /* group */ 614 *bp++ = htonl(op->create.mode & S_IALLUGO); /* unix mode */ 615 *bp++ = 0; /* segment size */ 616 617 trace_afs_make_fs_call1(call, &dvp->fid, name); 618 afs_make_op_call(op, call, GFP_NOFS); 619 } 620 621 /* 622 * Deliver reply data to any operation that returns status and volume sync. 623 */ 624 static int afs_deliver_fs_file_status_and_vol(struct afs_call *call) 625 { 626 struct afs_operation *op = call->op; 627 struct afs_vnode_param *vp = &op->file[0]; 628 const __be32 *bp; 629 int ret; 630 631 ret = afs_transfer_reply(call); 632 if (ret < 0) 633 return ret; 634 635 /* unmarshall the reply once we've received all of it */ 636 bp = call->buffer; 637 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb); 638 xdr_decode_AFSVolSync(&bp, &op->volsync); 639 640 _leave(" = 0 [done]"); 641 return 0; 642 } 643 644 /* 645 * FS.RemoveFile operation type 646 */ 647 static const struct afs_call_type afs_RXFSRemoveFile = { 648 .name = "FS.RemoveFile", 649 .op = afs_FS_RemoveFile, 650 .deliver = afs_deliver_fs_file_status_and_vol, 651 .destructor = afs_flat_call_destructor, 652 }; 653 654 /* 655 * Remove a file. 656 */ 657 void afs_fs_remove_file(struct afs_operation *op) 658 { 659 const struct qstr *name = &op->dentry->d_name; 660 struct afs_vnode_param *dvp = &op->file[0]; 661 struct afs_call *call; 662 size_t namesz, reqsz, padsz; 663 __be32 *bp; 664 665 _enter(""); 666 667 namesz = name->len; 668 padsz = (4 - (namesz & 3)) & 3; 669 reqsz = (5 * 4) + namesz + padsz; 670 671 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveFile, 672 reqsz, (21 + 6) * 4); 673 if (!call) 674 return afs_op_nomem(op); 675 676 /* marshall the parameters */ 677 bp = call->request; 678 *bp++ = htonl(FSREMOVEFILE); 679 *bp++ = htonl(dvp->fid.vid); 680 *bp++ = htonl(dvp->fid.vnode); 681 *bp++ = htonl(dvp->fid.unique); 682 *bp++ = htonl(namesz); 683 memcpy(bp, name->name, namesz); 684 bp = (void *) bp + namesz; 685 if (padsz > 0) { 686 memset(bp, 0, padsz); 687 bp = (void *) bp + padsz; 688 } 689 690 trace_afs_make_fs_call1(call, &dvp->fid, name); 691 afs_make_op_call(op, call, GFP_NOFS); 692 } 693 694 static const struct afs_call_type afs_RXFSRemoveDir = { 695 .name = "FS.RemoveDir", 696 .op = afs_FS_RemoveDir, 697 .deliver = afs_deliver_fs_file_status_and_vol, 698 .destructor = afs_flat_call_destructor, 699 }; 700 701 /* 702 * Remove a directory. 703 */ 704 void afs_fs_remove_dir(struct afs_operation *op) 705 { 706 const struct qstr *name = &op->dentry->d_name; 707 struct afs_vnode_param *dvp = &op->file[0]; 708 struct afs_call *call; 709 size_t namesz, reqsz, padsz; 710 __be32 *bp; 711 712 _enter(""); 713 714 namesz = name->len; 715 padsz = (4 - (namesz & 3)) & 3; 716 reqsz = (5 * 4) + namesz + padsz; 717 718 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveDir, 719 reqsz, (21 + 6) * 4); 720 if (!call) 721 return afs_op_nomem(op); 722 723 /* marshall the parameters */ 724 bp = call->request; 725 *bp++ = htonl(FSREMOVEDIR); 726 *bp++ = htonl(dvp->fid.vid); 727 *bp++ = htonl(dvp->fid.vnode); 728 *bp++ = htonl(dvp->fid.unique); 729 *bp++ = htonl(namesz); 730 memcpy(bp, name->name, namesz); 731 bp = (void *) bp + namesz; 732 if (padsz > 0) { 733 memset(bp, 0, padsz); 734 bp = (void *) bp + padsz; 735 } 736 737 trace_afs_make_fs_call1(call, &dvp->fid, name); 738 afs_make_op_call(op, call, GFP_NOFS); 739 } 740 741 /* 742 * deliver reply data to an FS.Link 743 */ 744 static int afs_deliver_fs_link(struct afs_call *call) 745 { 746 struct afs_operation *op = call->op; 747 struct afs_vnode_param *dvp = &op->file[0]; 748 struct afs_vnode_param *vp = &op->file[1]; 749 const __be32 *bp; 750 int ret; 751 752 _enter("{%u}", call->unmarshall); 753 754 ret = afs_transfer_reply(call); 755 if (ret < 0) 756 return ret; 757 758 /* unmarshall the reply once we've received all of it */ 759 bp = call->buffer; 760 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb); 761 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb); 762 xdr_decode_AFSVolSync(&bp, &op->volsync); 763 764 _leave(" = 0 [done]"); 765 return 0; 766 } 767 768 /* 769 * FS.Link operation type 770 */ 771 static const struct afs_call_type afs_RXFSLink = { 772 .name = "FS.Link", 773 .op = afs_FS_Link, 774 .deliver = afs_deliver_fs_link, 775 .destructor = afs_flat_call_destructor, 776 }; 777 778 /* 779 * make a hard link 780 */ 781 void afs_fs_link(struct afs_operation *op) 782 { 783 const struct qstr *name = &op->dentry->d_name; 784 struct afs_vnode_param *dvp = &op->file[0]; 785 struct afs_vnode_param *vp = &op->file[1]; 786 struct afs_call *call; 787 size_t namesz, reqsz, padsz; 788 __be32 *bp; 789 790 _enter(""); 791 792 namesz = name->len; 793 padsz = (4 - (namesz & 3)) & 3; 794 reqsz = (5 * 4) + namesz + padsz + (3 * 4); 795 796 call = afs_alloc_flat_call(op->net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4); 797 if (!call) 798 return afs_op_nomem(op); 799 800 /* marshall the parameters */ 801 bp = call->request; 802 *bp++ = htonl(FSLINK); 803 *bp++ = htonl(dvp->fid.vid); 804 *bp++ = htonl(dvp->fid.vnode); 805 *bp++ = htonl(dvp->fid.unique); 806 *bp++ = htonl(namesz); 807 memcpy(bp, name->name, namesz); 808 bp = (void *) bp + namesz; 809 if (padsz > 0) { 810 memset(bp, 0, padsz); 811 bp = (void *) bp + padsz; 812 } 813 *bp++ = htonl(vp->fid.vid); 814 *bp++ = htonl(vp->fid.vnode); 815 *bp++ = htonl(vp->fid.unique); 816 817 trace_afs_make_fs_call1(call, &vp->fid, name); 818 afs_make_op_call(op, call, GFP_NOFS); 819 } 820 821 /* 822 * deliver reply data to an FS.Symlink 823 */ 824 static int afs_deliver_fs_symlink(struct afs_call *call) 825 { 826 struct afs_operation *op = call->op; 827 struct afs_vnode_param *dvp = &op->file[0]; 828 struct afs_vnode_param *vp = &op->file[1]; 829 const __be32 *bp; 830 int ret; 831 832 _enter("{%u}", call->unmarshall); 833 834 ret = afs_transfer_reply(call); 835 if (ret < 0) 836 return ret; 837 838 /* unmarshall the reply once we've received all of it */ 839 bp = call->buffer; 840 xdr_decode_AFSFid(&bp, &vp->fid); 841 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb); 842 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb); 843 xdr_decode_AFSVolSync(&bp, &op->volsync); 844 845 _leave(" = 0 [done]"); 846 return 0; 847 } 848 849 /* 850 * FS.Symlink operation type 851 */ 852 static const struct afs_call_type afs_RXFSSymlink = { 853 .name = "FS.Symlink", 854 .op = afs_FS_Symlink, 855 .deliver = afs_deliver_fs_symlink, 856 .destructor = afs_flat_call_destructor, 857 }; 858 859 /* 860 * create a symbolic link 861 */ 862 void afs_fs_symlink(struct afs_operation *op) 863 { 864 const struct qstr *name = &op->dentry->d_name; 865 struct afs_vnode_param *dvp = &op->file[0]; 866 struct afs_call *call; 867 size_t namesz, reqsz, padsz, c_namesz, c_padsz; 868 __be32 *bp; 869 870 _enter(""); 871 872 namesz = name->len; 873 padsz = (4 - (namesz & 3)) & 3; 874 875 c_namesz = strlen(op->create.symlink); 876 c_padsz = (4 - (c_namesz & 3)) & 3; 877 878 reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4); 879 880 call = afs_alloc_flat_call(op->net, &afs_RXFSSymlink, reqsz, 881 (3 + 21 + 21 + 6) * 4); 882 if (!call) 883 return afs_op_nomem(op); 884 885 /* marshall the parameters */ 886 bp = call->request; 887 *bp++ = htonl(FSSYMLINK); 888 *bp++ = htonl(dvp->fid.vid); 889 *bp++ = htonl(dvp->fid.vnode); 890 *bp++ = htonl(dvp->fid.unique); 891 *bp++ = htonl(namesz); 892 memcpy(bp, name->name, namesz); 893 bp = (void *) bp + namesz; 894 if (padsz > 0) { 895 memset(bp, 0, padsz); 896 bp = (void *) bp + padsz; 897 } 898 *bp++ = htonl(c_namesz); 899 memcpy(bp, op->create.symlink, c_namesz); 900 bp = (void *) bp + c_namesz; 901 if (c_padsz > 0) { 902 memset(bp, 0, c_padsz); 903 bp = (void *) bp + c_padsz; 904 } 905 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME); 906 *bp++ = htonl(op->mtime.tv_sec); /* mtime */ 907 *bp++ = 0; /* owner */ 908 *bp++ = 0; /* group */ 909 *bp++ = htonl(S_IRWXUGO); /* unix mode */ 910 *bp++ = 0; /* segment size */ 911 912 trace_afs_make_fs_call1(call, &dvp->fid, name); 913 afs_make_op_call(op, call, GFP_NOFS); 914 } 915 916 /* 917 * deliver reply data to an FS.Rename 918 */ 919 static int afs_deliver_fs_rename(struct afs_call *call) 920 { 921 struct afs_operation *op = call->op; 922 struct afs_vnode_param *orig_dvp = &op->file[0]; 923 struct afs_vnode_param *new_dvp = &op->file[1]; 924 const __be32 *bp; 925 int ret; 926 927 ret = afs_transfer_reply(call); 928 if (ret < 0) 929 return ret; 930 931 bp = call->buffer; 932 /* If the two dirs are the same, we have two copies of the same status 933 * report, so we just decode it twice. 934 */ 935 xdr_decode_AFSFetchStatus(&bp, call, &orig_dvp->scb); 936 xdr_decode_AFSFetchStatus(&bp, call, &new_dvp->scb); 937 xdr_decode_AFSVolSync(&bp, &op->volsync); 938 939 _leave(" = 0 [done]"); 940 return 0; 941 } 942 943 /* 944 * FS.Rename operation type 945 */ 946 static const struct afs_call_type afs_RXFSRename = { 947 .name = "FS.Rename", 948 .op = afs_FS_Rename, 949 .deliver = afs_deliver_fs_rename, 950 .destructor = afs_flat_call_destructor, 951 }; 952 953 /* 954 * Rename/move a file or directory. 955 */ 956 void afs_fs_rename(struct afs_operation *op) 957 { 958 struct afs_vnode_param *orig_dvp = &op->file[0]; 959 struct afs_vnode_param *new_dvp = &op->file[1]; 960 const struct qstr *orig_name = &op->dentry->d_name; 961 const struct qstr *new_name = &op->dentry_2->d_name; 962 struct afs_call *call; 963 size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz; 964 __be32 *bp; 965 966 _enter(""); 967 968 o_namesz = orig_name->len; 969 o_padsz = (4 - (o_namesz & 3)) & 3; 970 971 n_namesz = new_name->len; 972 n_padsz = (4 - (n_namesz & 3)) & 3; 973 974 reqsz = (4 * 4) + 975 4 + o_namesz + o_padsz + 976 (3 * 4) + 977 4 + n_namesz + n_padsz; 978 979 call = afs_alloc_flat_call(op->net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4); 980 if (!call) 981 return afs_op_nomem(op); 982 983 /* marshall the parameters */ 984 bp = call->request; 985 *bp++ = htonl(FSRENAME); 986 *bp++ = htonl(orig_dvp->fid.vid); 987 *bp++ = htonl(orig_dvp->fid.vnode); 988 *bp++ = htonl(orig_dvp->fid.unique); 989 *bp++ = htonl(o_namesz); 990 memcpy(bp, orig_name->name, o_namesz); 991 bp = (void *) bp + o_namesz; 992 if (o_padsz > 0) { 993 memset(bp, 0, o_padsz); 994 bp = (void *) bp + o_padsz; 995 } 996 997 *bp++ = htonl(new_dvp->fid.vid); 998 *bp++ = htonl(new_dvp->fid.vnode); 999 *bp++ = htonl(new_dvp->fid.unique); 1000 *bp++ = htonl(n_namesz); 1001 memcpy(bp, new_name->name, n_namesz); 1002 bp = (void *) bp + n_namesz; 1003 if (n_padsz > 0) { 1004 memset(bp, 0, n_padsz); 1005 bp = (void *) bp + n_padsz; 1006 } 1007 1008 trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name); 1009 afs_make_op_call(op, call, GFP_NOFS); 1010 } 1011 1012 /* 1013 * Deliver reply data to FS.StoreData or FS.StoreStatus 1014 */ 1015 static int afs_deliver_fs_store_data(struct afs_call *call) 1016 { 1017 struct afs_operation *op = call->op; 1018 struct afs_vnode_param *vp = &op->file[0]; 1019 const __be32 *bp; 1020 int ret; 1021 1022 _enter(""); 1023 1024 ret = afs_transfer_reply(call); 1025 if (ret < 0) 1026 return ret; 1027 1028 /* unmarshall the reply once we've received all of it */ 1029 bp = call->buffer; 1030 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb); 1031 xdr_decode_AFSVolSync(&bp, &op->volsync); 1032 1033 _leave(" = 0 [done]"); 1034 return 0; 1035 } 1036 1037 /* 1038 * FS.StoreData operation type 1039 */ 1040 static const struct afs_call_type afs_RXFSStoreData = { 1041 .name = "FS.StoreData", 1042 .op = afs_FS_StoreData, 1043 .deliver = afs_deliver_fs_store_data, 1044 .destructor = afs_flat_call_destructor, 1045 }; 1046 1047 static const struct afs_call_type afs_RXFSStoreData64 = { 1048 .name = "FS.StoreData64", 1049 .op = afs_FS_StoreData64, 1050 .deliver = afs_deliver_fs_store_data, 1051 .destructor = afs_flat_call_destructor, 1052 }; 1053 1054 /* 1055 * store a set of pages to a very large file 1056 */ 1057 static void afs_fs_store_data64(struct afs_operation *op) 1058 { 1059 struct afs_vnode_param *vp = &op->file[0]; 1060 struct afs_call *call; 1061 __be32 *bp; 1062 1063 _enter(",%x,{%llx:%llu},,", 1064 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1065 1066 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64, 1067 (4 + 6 + 3 * 2) * 4, 1068 (21 + 6) * 4); 1069 if (!call) 1070 return afs_op_nomem(op); 1071 1072 call->write_iter = op->store.write_iter; 1073 1074 /* marshall the parameters */ 1075 bp = call->request; 1076 *bp++ = htonl(FSSTOREDATA64); 1077 *bp++ = htonl(vp->fid.vid); 1078 *bp++ = htonl(vp->fid.vnode); 1079 *bp++ = htonl(vp->fid.unique); 1080 1081 *bp++ = htonl(AFS_SET_MTIME); /* mask */ 1082 *bp++ = htonl(op->mtime.tv_sec); /* mtime */ 1083 *bp++ = 0; /* owner */ 1084 *bp++ = 0; /* group */ 1085 *bp++ = 0; /* unix mode */ 1086 *bp++ = 0; /* segment size */ 1087 1088 *bp++ = htonl(upper_32_bits(op->store.pos)); 1089 *bp++ = htonl(lower_32_bits(op->store.pos)); 1090 *bp++ = htonl(upper_32_bits(op->store.size)); 1091 *bp++ = htonl(lower_32_bits(op->store.size)); 1092 *bp++ = htonl(upper_32_bits(op->store.i_size)); 1093 *bp++ = htonl(lower_32_bits(op->store.i_size)); 1094 1095 trace_afs_make_fs_call(call, &vp->fid); 1096 afs_make_op_call(op, call, GFP_NOFS); 1097 } 1098 1099 /* 1100 * Write data to a file on the server. 1101 */ 1102 void afs_fs_store_data(struct afs_operation *op) 1103 { 1104 struct afs_vnode_param *vp = &op->file[0]; 1105 struct afs_call *call; 1106 __be32 *bp; 1107 1108 _enter(",%x,{%llx:%llu},,", 1109 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1110 1111 _debug("size %llx, at %llx, i_size %llx", 1112 (unsigned long long)op->store.size, 1113 (unsigned long long)op->store.pos, 1114 (unsigned long long)op->store.i_size); 1115 1116 if (upper_32_bits(op->store.pos) || 1117 upper_32_bits(op->store.size) || 1118 upper_32_bits(op->store.i_size)) 1119 return afs_fs_store_data64(op); 1120 1121 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData, 1122 (4 + 6 + 3) * 4, 1123 (21 + 6) * 4); 1124 if (!call) 1125 return afs_op_nomem(op); 1126 1127 call->write_iter = op->store.write_iter; 1128 1129 /* marshall the parameters */ 1130 bp = call->request; 1131 *bp++ = htonl(FSSTOREDATA); 1132 *bp++ = htonl(vp->fid.vid); 1133 *bp++ = htonl(vp->fid.vnode); 1134 *bp++ = htonl(vp->fid.unique); 1135 1136 *bp++ = htonl(AFS_SET_MTIME); /* mask */ 1137 *bp++ = htonl(op->mtime.tv_sec); /* mtime */ 1138 *bp++ = 0; /* owner */ 1139 *bp++ = 0; /* group */ 1140 *bp++ = 0; /* unix mode */ 1141 *bp++ = 0; /* segment size */ 1142 1143 *bp++ = htonl(lower_32_bits(op->store.pos)); 1144 *bp++ = htonl(lower_32_bits(op->store.size)); 1145 *bp++ = htonl(lower_32_bits(op->store.i_size)); 1146 1147 trace_afs_make_fs_call(call, &vp->fid); 1148 afs_make_op_call(op, call, GFP_NOFS); 1149 } 1150 1151 /* 1152 * FS.StoreStatus operation type 1153 */ 1154 static const struct afs_call_type afs_RXFSStoreStatus = { 1155 .name = "FS.StoreStatus", 1156 .op = afs_FS_StoreStatus, 1157 .deliver = afs_deliver_fs_store_data, 1158 .destructor = afs_flat_call_destructor, 1159 }; 1160 1161 static const struct afs_call_type afs_RXFSStoreData_as_Status = { 1162 .name = "FS.StoreData", 1163 .op = afs_FS_StoreData, 1164 .deliver = afs_deliver_fs_store_data, 1165 .destructor = afs_flat_call_destructor, 1166 }; 1167 1168 static const struct afs_call_type afs_RXFSStoreData64_as_Status = { 1169 .name = "FS.StoreData64", 1170 .op = afs_FS_StoreData64, 1171 .deliver = afs_deliver_fs_store_data, 1172 .destructor = afs_flat_call_destructor, 1173 }; 1174 1175 /* 1176 * set the attributes on a very large file, using FS.StoreData rather than 1177 * FS.StoreStatus so as to alter the file size also 1178 */ 1179 static void afs_fs_setattr_size64(struct afs_operation *op) 1180 { 1181 struct afs_vnode_param *vp = &op->file[0]; 1182 struct afs_call *call; 1183 struct iattr *attr = op->setattr.attr; 1184 __be32 *bp; 1185 1186 _enter(",%x,{%llx:%llu},,", 1187 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1188 1189 ASSERT(attr->ia_valid & ATTR_SIZE); 1190 1191 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64_as_Status, 1192 (4 + 6 + 3 * 2) * 4, 1193 (21 + 6) * 4); 1194 if (!call) 1195 return afs_op_nomem(op); 1196 1197 /* marshall the parameters */ 1198 bp = call->request; 1199 *bp++ = htonl(FSSTOREDATA64); 1200 *bp++ = htonl(vp->fid.vid); 1201 *bp++ = htonl(vp->fid.vnode); 1202 *bp++ = htonl(vp->fid.unique); 1203 1204 xdr_encode_AFS_StoreStatus(&bp, attr); 1205 1206 *bp++ = htonl(upper_32_bits(attr->ia_size)); /* position of start of write */ 1207 *bp++ = htonl(lower_32_bits(attr->ia_size)); 1208 *bp++ = 0; /* size of write */ 1209 *bp++ = 0; 1210 *bp++ = htonl(upper_32_bits(attr->ia_size)); /* new file length */ 1211 *bp++ = htonl(lower_32_bits(attr->ia_size)); 1212 1213 trace_afs_make_fs_call(call, &vp->fid); 1214 afs_make_op_call(op, call, GFP_NOFS); 1215 } 1216 1217 /* 1218 * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus 1219 * so as to alter the file size also 1220 */ 1221 static void afs_fs_setattr_size(struct afs_operation *op) 1222 { 1223 struct afs_vnode_param *vp = &op->file[0]; 1224 struct afs_call *call; 1225 struct iattr *attr = op->setattr.attr; 1226 __be32 *bp; 1227 1228 _enter(",%x,{%llx:%llu},,", 1229 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1230 1231 ASSERT(attr->ia_valid & ATTR_SIZE); 1232 if (upper_32_bits(attr->ia_size)) 1233 return afs_fs_setattr_size64(op); 1234 1235 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status, 1236 (4 + 6 + 3) * 4, 1237 (21 + 6) * 4); 1238 if (!call) 1239 return afs_op_nomem(op); 1240 1241 /* marshall the parameters */ 1242 bp = call->request; 1243 *bp++ = htonl(FSSTOREDATA); 1244 *bp++ = htonl(vp->fid.vid); 1245 *bp++ = htonl(vp->fid.vnode); 1246 *bp++ = htonl(vp->fid.unique); 1247 1248 xdr_encode_AFS_StoreStatus(&bp, attr); 1249 1250 *bp++ = htonl(attr->ia_size); /* position of start of write */ 1251 *bp++ = 0; /* size of write */ 1252 *bp++ = htonl(attr->ia_size); /* new file length */ 1253 1254 trace_afs_make_fs_call(call, &vp->fid); 1255 afs_make_op_call(op, call, GFP_NOFS); 1256 } 1257 1258 /* 1259 * set the attributes on a file, using FS.StoreData if there's a change in file 1260 * size, and FS.StoreStatus otherwise 1261 */ 1262 void afs_fs_setattr(struct afs_operation *op) 1263 { 1264 struct afs_vnode_param *vp = &op->file[0]; 1265 struct afs_call *call; 1266 struct iattr *attr = op->setattr.attr; 1267 __be32 *bp; 1268 1269 if (attr->ia_valid & ATTR_SIZE) 1270 return afs_fs_setattr_size(op); 1271 1272 _enter(",%x,{%llx:%llu},,", 1273 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 1274 1275 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreStatus, 1276 (4 + 6) * 4, 1277 (21 + 6) * 4); 1278 if (!call) 1279 return afs_op_nomem(op); 1280 1281 /* marshall the parameters */ 1282 bp = call->request; 1283 *bp++ = htonl(FSSTORESTATUS); 1284 *bp++ = htonl(vp->fid.vid); 1285 *bp++ = htonl(vp->fid.vnode); 1286 *bp++ = htonl(vp->fid.unique); 1287 1288 xdr_encode_AFS_StoreStatus(&bp, op->setattr.attr); 1289 1290 trace_afs_make_fs_call(call, &vp->fid); 1291 afs_make_op_call(op, call, GFP_NOFS); 1292 } 1293 1294 /* 1295 * deliver reply data to an FS.GetVolumeStatus 1296 */ 1297 static int afs_deliver_fs_get_volume_status(struct afs_call *call) 1298 { 1299 struct afs_operation *op = call->op; 1300 const __be32 *bp; 1301 char *p; 1302 u32 size; 1303 int ret; 1304 1305 _enter("{%u}", call->unmarshall); 1306 1307 switch (call->unmarshall) { 1308 case 0: 1309 call->unmarshall++; 1310 afs_extract_to_buf(call, 12 * 4); 1311 fallthrough; 1312 1313 /* extract the returned status record */ 1314 case 1: 1315 _debug("extract status"); 1316 ret = afs_extract_data(call, true); 1317 if (ret < 0) 1318 return ret; 1319 1320 bp = call->buffer; 1321 xdr_decode_AFSFetchVolumeStatus(&bp, &op->volstatus.vs); 1322 call->unmarshall++; 1323 afs_extract_to_tmp(call); 1324 fallthrough; 1325 1326 /* extract the volume name length */ 1327 case 2: 1328 ret = afs_extract_data(call, true); 1329 if (ret < 0) 1330 return ret; 1331 1332 call->count = ntohl(call->tmp); 1333 _debug("volname length: %u", call->count); 1334 if (call->count >= AFSNAMEMAX) 1335 return afs_protocol_error(call, afs_eproto_volname_len); 1336 size = (call->count + 3) & ~3; /* It's padded */ 1337 afs_extract_to_buf(call, size); 1338 call->unmarshall++; 1339 fallthrough; 1340 1341 /* extract the volume name */ 1342 case 3: 1343 _debug("extract volname"); 1344 ret = afs_extract_data(call, true); 1345 if (ret < 0) 1346 return ret; 1347 1348 p = call->buffer; 1349 p[call->count] = 0; 1350 _debug("volname '%s'", p); 1351 afs_extract_to_tmp(call); 1352 call->unmarshall++; 1353 fallthrough; 1354 1355 /* extract the offline message length */ 1356 case 4: 1357 ret = afs_extract_data(call, true); 1358 if (ret < 0) 1359 return ret; 1360 1361 call->count = ntohl(call->tmp); 1362 _debug("offline msg length: %u", call->count); 1363 if (call->count >= AFSNAMEMAX) 1364 return afs_protocol_error(call, afs_eproto_offline_msg_len); 1365 size = (call->count + 3) & ~3; /* It's padded */ 1366 afs_extract_to_buf(call, size); 1367 call->unmarshall++; 1368 fallthrough; 1369 1370 /* extract the offline message */ 1371 case 5: 1372 _debug("extract offline"); 1373 ret = afs_extract_data(call, true); 1374 if (ret < 0) 1375 return ret; 1376 1377 p = call->buffer; 1378 p[call->count] = 0; 1379 _debug("offline '%s'", p); 1380 1381 afs_extract_to_tmp(call); 1382 call->unmarshall++; 1383 fallthrough; 1384 1385 /* extract the message of the day length */ 1386 case 6: 1387 ret = afs_extract_data(call, true); 1388 if (ret < 0) 1389 return ret; 1390 1391 call->count = ntohl(call->tmp); 1392 _debug("motd length: %u", call->count); 1393 if (call->count >= AFSNAMEMAX) 1394 return afs_protocol_error(call, afs_eproto_motd_len); 1395 size = (call->count + 3) & ~3; /* It's padded */ 1396 afs_extract_to_buf(call, size); 1397 call->unmarshall++; 1398 fallthrough; 1399 1400 /* extract the message of the day */ 1401 case 7: 1402 _debug("extract motd"); 1403 ret = afs_extract_data(call, false); 1404 if (ret < 0) 1405 return ret; 1406 1407 p = call->buffer; 1408 p[call->count] = 0; 1409 _debug("motd '%s'", p); 1410 1411 call->unmarshall++; 1412 fallthrough; 1413 1414 case 8: 1415 break; 1416 } 1417 1418 _leave(" = 0 [done]"); 1419 return 0; 1420 } 1421 1422 /* 1423 * FS.GetVolumeStatus operation type 1424 */ 1425 static const struct afs_call_type afs_RXFSGetVolumeStatus = { 1426 .name = "FS.GetVolumeStatus", 1427 .op = afs_FS_GetVolumeStatus, 1428 .deliver = afs_deliver_fs_get_volume_status, 1429 .destructor = afs_flat_call_destructor, 1430 }; 1431 1432 /* 1433 * fetch the status of a volume 1434 */ 1435 void afs_fs_get_volume_status(struct afs_operation *op) 1436 { 1437 struct afs_vnode_param *vp = &op->file[0]; 1438 struct afs_call *call; 1439 __be32 *bp; 1440 1441 _enter(""); 1442 1443 call = afs_alloc_flat_call(op->net, &afs_RXFSGetVolumeStatus, 2 * 4, 1444 max(12 * 4, AFSOPAQUEMAX + 1)); 1445 if (!call) 1446 return afs_op_nomem(op); 1447 1448 /* marshall the parameters */ 1449 bp = call->request; 1450 bp[0] = htonl(FSGETVOLUMESTATUS); 1451 bp[1] = htonl(vp->fid.vid); 1452 1453 trace_afs_make_fs_call(call, &vp->fid); 1454 afs_make_op_call(op, call, GFP_NOFS); 1455 } 1456 1457 /* 1458 * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock 1459 */ 1460 static int afs_deliver_fs_xxxx_lock(struct afs_call *call) 1461 { 1462 struct afs_operation *op = call->op; 1463 const __be32 *bp; 1464 int ret; 1465 1466 _enter("{%u}", call->unmarshall); 1467 1468 ret = afs_transfer_reply(call); 1469 if (ret < 0) 1470 return ret; 1471 1472 /* unmarshall the reply once we've received all of it */ 1473 bp = call->buffer; 1474 xdr_decode_AFSVolSync(&bp, &op->volsync); 1475 1476 _leave(" = 0 [done]"); 1477 return 0; 1478 } 1479 1480 /* 1481 * FS.SetLock operation type 1482 */ 1483 static const struct afs_call_type afs_RXFSSetLock = { 1484 .name = "FS.SetLock", 1485 .op = afs_FS_SetLock, 1486 .deliver = afs_deliver_fs_xxxx_lock, 1487 .done = afs_lock_op_done, 1488 .destructor = afs_flat_call_destructor, 1489 }; 1490 1491 /* 1492 * FS.ExtendLock operation type 1493 */ 1494 static const struct afs_call_type afs_RXFSExtendLock = { 1495 .name = "FS.ExtendLock", 1496 .op = afs_FS_ExtendLock, 1497 .deliver = afs_deliver_fs_xxxx_lock, 1498 .done = afs_lock_op_done, 1499 .destructor = afs_flat_call_destructor, 1500 }; 1501 1502 /* 1503 * FS.ReleaseLock operation type 1504 */ 1505 static const struct afs_call_type afs_RXFSReleaseLock = { 1506 .name = "FS.ReleaseLock", 1507 .op = afs_FS_ReleaseLock, 1508 .deliver = afs_deliver_fs_xxxx_lock, 1509 .destructor = afs_flat_call_destructor, 1510 }; 1511 1512 /* 1513 * Set a lock on a file 1514 */ 1515 void afs_fs_set_lock(struct afs_operation *op) 1516 { 1517 struct afs_vnode_param *vp = &op->file[0]; 1518 struct afs_call *call; 1519 __be32 *bp; 1520 1521 _enter(""); 1522 1523 call = afs_alloc_flat_call(op->net, &afs_RXFSSetLock, 5 * 4, 6 * 4); 1524 if (!call) 1525 return afs_op_nomem(op); 1526 1527 /* marshall the parameters */ 1528 bp = call->request; 1529 *bp++ = htonl(FSSETLOCK); 1530 *bp++ = htonl(vp->fid.vid); 1531 *bp++ = htonl(vp->fid.vnode); 1532 *bp++ = htonl(vp->fid.unique); 1533 *bp++ = htonl(op->lock.type); 1534 1535 trace_afs_make_fs_calli(call, &vp->fid, op->lock.type); 1536 afs_make_op_call(op, call, GFP_NOFS); 1537 } 1538 1539 /* 1540 * extend a lock on a file 1541 */ 1542 void afs_fs_extend_lock(struct afs_operation *op) 1543 { 1544 struct afs_vnode_param *vp = &op->file[0]; 1545 struct afs_call *call; 1546 __be32 *bp; 1547 1548 _enter(""); 1549 1550 call = afs_alloc_flat_call(op->net, &afs_RXFSExtendLock, 4 * 4, 6 * 4); 1551 if (!call) 1552 return afs_op_nomem(op); 1553 1554 /* marshall the parameters */ 1555 bp = call->request; 1556 *bp++ = htonl(FSEXTENDLOCK); 1557 *bp++ = htonl(vp->fid.vid); 1558 *bp++ = htonl(vp->fid.vnode); 1559 *bp++ = htonl(vp->fid.unique); 1560 1561 trace_afs_make_fs_call(call, &vp->fid); 1562 afs_make_op_call(op, call, GFP_NOFS); 1563 } 1564 1565 /* 1566 * release a lock on a file 1567 */ 1568 void afs_fs_release_lock(struct afs_operation *op) 1569 { 1570 struct afs_vnode_param *vp = &op->file[0]; 1571 struct afs_call *call; 1572 __be32 *bp; 1573 1574 _enter(""); 1575 1576 call = afs_alloc_flat_call(op->net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4); 1577 if (!call) 1578 return afs_op_nomem(op); 1579 1580 /* marshall the parameters */ 1581 bp = call->request; 1582 *bp++ = htonl(FSRELEASELOCK); 1583 *bp++ = htonl(vp->fid.vid); 1584 *bp++ = htonl(vp->fid.vnode); 1585 *bp++ = htonl(vp->fid.unique); 1586 1587 trace_afs_make_fs_call(call, &vp->fid); 1588 afs_make_op_call(op, call, GFP_NOFS); 1589 } 1590 1591 /* 1592 * Deliver reply data to an FS.GiveUpAllCallBacks operation. 1593 */ 1594 static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call) 1595 { 1596 return afs_transfer_reply(call); 1597 } 1598 1599 /* 1600 * FS.GiveUpAllCallBacks operation type 1601 */ 1602 static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = { 1603 .name = "FS.GiveUpAllCallBacks", 1604 .op = afs_FS_GiveUpAllCallBacks, 1605 .deliver = afs_deliver_fs_give_up_all_callbacks, 1606 .destructor = afs_flat_call_destructor, 1607 }; 1608 1609 /* 1610 * Flush all the callbacks we have on a server. 1611 */ 1612 int afs_fs_give_up_all_callbacks(struct afs_net *net, 1613 struct afs_server *server, 1614 struct afs_addr_cursor *ac, 1615 struct key *key) 1616 { 1617 struct afs_call *call; 1618 __be32 *bp; 1619 1620 _enter(""); 1621 1622 call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0); 1623 if (!call) 1624 return -ENOMEM; 1625 1626 call->key = key; 1627 1628 /* marshall the parameters */ 1629 bp = call->request; 1630 *bp++ = htonl(FSGIVEUPALLCALLBACKS); 1631 1632 call->server = afs_use_server(server, afs_server_trace_give_up_cb); 1633 afs_make_call(ac, call, GFP_NOFS); 1634 return afs_wait_for_call_to_complete(call, ac); 1635 } 1636 1637 /* 1638 * Deliver reply data to an FS.GetCapabilities operation. 1639 */ 1640 static int afs_deliver_fs_get_capabilities(struct afs_call *call) 1641 { 1642 u32 count; 1643 int ret; 1644 1645 _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter)); 1646 1647 switch (call->unmarshall) { 1648 case 0: 1649 afs_extract_to_tmp(call); 1650 call->unmarshall++; 1651 fallthrough; 1652 1653 /* Extract the capabilities word count */ 1654 case 1: 1655 ret = afs_extract_data(call, true); 1656 if (ret < 0) 1657 return ret; 1658 1659 count = ntohl(call->tmp); 1660 1661 call->count = count; 1662 call->count2 = count; 1663 afs_extract_discard(call, count * sizeof(__be32)); 1664 call->unmarshall++; 1665 fallthrough; 1666 1667 /* Extract capabilities words */ 1668 case 2: 1669 ret = afs_extract_data(call, false); 1670 if (ret < 0) 1671 return ret; 1672 1673 /* TODO: Examine capabilities */ 1674 1675 call->unmarshall++; 1676 break; 1677 } 1678 1679 _leave(" = 0 [done]"); 1680 return 0; 1681 } 1682 1683 /* 1684 * FS.GetCapabilities operation type 1685 */ 1686 static const struct afs_call_type afs_RXFSGetCapabilities = { 1687 .name = "FS.GetCapabilities", 1688 .op = afs_FS_GetCapabilities, 1689 .deliver = afs_deliver_fs_get_capabilities, 1690 .done = afs_fileserver_probe_result, 1691 .destructor = afs_flat_call_destructor, 1692 }; 1693 1694 /* 1695 * Probe a fileserver for the capabilities that it supports. This RPC can 1696 * reply with up to 196 words. The operation is asynchronous and if we managed 1697 * to allocate a call, true is returned the result is delivered through the 1698 * ->done() - otherwise we return false to indicate we didn't even try. 1699 */ 1700 bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server, 1701 struct afs_addr_cursor *ac, struct key *key) 1702 { 1703 struct afs_call *call; 1704 __be32 *bp; 1705 1706 _enter(""); 1707 1708 call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4); 1709 if (!call) 1710 return false; 1711 1712 call->key = key; 1713 call->server = afs_use_server(server, afs_server_trace_get_caps); 1714 call->upgrade = true; 1715 call->async = true; 1716 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN; 1717 1718 /* marshall the parameters */ 1719 bp = call->request; 1720 *bp++ = htonl(FSGETCAPABILITIES); 1721 1722 trace_afs_make_fs_call(call, NULL); 1723 afs_make_call(ac, call, GFP_NOFS); 1724 afs_put_call(call); 1725 return true; 1726 } 1727 1728 /* 1729 * Deliver reply data to an FS.InlineBulkStatus call 1730 */ 1731 static int afs_deliver_fs_inline_bulk_status(struct afs_call *call) 1732 { 1733 struct afs_operation *op = call->op; 1734 struct afs_status_cb *scb; 1735 const __be32 *bp; 1736 u32 tmp; 1737 int ret; 1738 1739 _enter("{%u}", call->unmarshall); 1740 1741 switch (call->unmarshall) { 1742 case 0: 1743 afs_extract_to_tmp(call); 1744 call->unmarshall++; 1745 fallthrough; 1746 1747 /* Extract the file status count and array in two steps */ 1748 case 1: 1749 _debug("extract status count"); 1750 ret = afs_extract_data(call, true); 1751 if (ret < 0) 1752 return ret; 1753 1754 tmp = ntohl(call->tmp); 1755 _debug("status count: %u/%u", tmp, op->nr_files); 1756 if (tmp != op->nr_files) 1757 return afs_protocol_error(call, afs_eproto_ibulkst_count); 1758 1759 call->count = 0; 1760 call->unmarshall++; 1761 more_counts: 1762 afs_extract_to_buf(call, 21 * sizeof(__be32)); 1763 fallthrough; 1764 1765 case 2: 1766 _debug("extract status array %u", call->count); 1767 ret = afs_extract_data(call, true); 1768 if (ret < 0) 1769 return ret; 1770 1771 switch (call->count) { 1772 case 0: 1773 scb = &op->file[0].scb; 1774 break; 1775 case 1: 1776 scb = &op->file[1].scb; 1777 break; 1778 default: 1779 scb = &op->more_files[call->count - 2].scb; 1780 break; 1781 } 1782 1783 bp = call->buffer; 1784 xdr_decode_AFSFetchStatus(&bp, call, scb); 1785 1786 call->count++; 1787 if (call->count < op->nr_files) 1788 goto more_counts; 1789 1790 call->count = 0; 1791 call->unmarshall++; 1792 afs_extract_to_tmp(call); 1793 fallthrough; 1794 1795 /* Extract the callback count and array in two steps */ 1796 case 3: 1797 _debug("extract CB count"); 1798 ret = afs_extract_data(call, true); 1799 if (ret < 0) 1800 return ret; 1801 1802 tmp = ntohl(call->tmp); 1803 _debug("CB count: %u", tmp); 1804 if (tmp != op->nr_files) 1805 return afs_protocol_error(call, afs_eproto_ibulkst_cb_count); 1806 call->count = 0; 1807 call->unmarshall++; 1808 more_cbs: 1809 afs_extract_to_buf(call, 3 * sizeof(__be32)); 1810 fallthrough; 1811 1812 case 4: 1813 _debug("extract CB array"); 1814 ret = afs_extract_data(call, true); 1815 if (ret < 0) 1816 return ret; 1817 1818 _debug("unmarshall CB array"); 1819 switch (call->count) { 1820 case 0: 1821 scb = &op->file[0].scb; 1822 break; 1823 case 1: 1824 scb = &op->file[1].scb; 1825 break; 1826 default: 1827 scb = &op->more_files[call->count - 2].scb; 1828 break; 1829 } 1830 1831 bp = call->buffer; 1832 xdr_decode_AFSCallBack(&bp, call, scb); 1833 call->count++; 1834 if (call->count < op->nr_files) 1835 goto more_cbs; 1836 1837 afs_extract_to_buf(call, 6 * sizeof(__be32)); 1838 call->unmarshall++; 1839 fallthrough; 1840 1841 case 5: 1842 ret = afs_extract_data(call, false); 1843 if (ret < 0) 1844 return ret; 1845 1846 bp = call->buffer; 1847 xdr_decode_AFSVolSync(&bp, &op->volsync); 1848 1849 call->unmarshall++; 1850 fallthrough; 1851 1852 case 6: 1853 break; 1854 } 1855 1856 _leave(" = 0 [done]"); 1857 return 0; 1858 } 1859 1860 static void afs_done_fs_inline_bulk_status(struct afs_call *call) 1861 { 1862 if (call->error == -ECONNABORTED && 1863 call->abort_code == RX_INVALID_OPERATION) { 1864 set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags); 1865 if (call->op) 1866 set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags); 1867 } 1868 } 1869 1870 /* 1871 * FS.InlineBulkStatus operation type 1872 */ 1873 static const struct afs_call_type afs_RXFSInlineBulkStatus = { 1874 .name = "FS.InlineBulkStatus", 1875 .op = afs_FS_InlineBulkStatus, 1876 .deliver = afs_deliver_fs_inline_bulk_status, 1877 .done = afs_done_fs_inline_bulk_status, 1878 .destructor = afs_flat_call_destructor, 1879 }; 1880 1881 /* 1882 * Fetch the status information for up to 50 files 1883 */ 1884 void afs_fs_inline_bulk_status(struct afs_operation *op) 1885 { 1886 struct afs_vnode_param *dvp = &op->file[0]; 1887 struct afs_vnode_param *vp = &op->file[1]; 1888 struct afs_call *call; 1889 __be32 *bp; 1890 int i; 1891 1892 if (test_bit(AFS_SERVER_FL_NO_IBULK, &op->server->flags)) { 1893 op->error = -ENOTSUPP; 1894 return; 1895 } 1896 1897 _enter(",%x,{%llx:%llu},%u", 1898 key_serial(op->key), vp->fid.vid, vp->fid.vnode, op->nr_files); 1899 1900 call = afs_alloc_flat_call(op->net, &afs_RXFSInlineBulkStatus, 1901 (2 + op->nr_files * 3) * 4, 1902 21 * 4); 1903 if (!call) 1904 return afs_op_nomem(op); 1905 1906 /* marshall the parameters */ 1907 bp = call->request; 1908 *bp++ = htonl(FSINLINEBULKSTATUS); 1909 *bp++ = htonl(op->nr_files); 1910 *bp++ = htonl(dvp->fid.vid); 1911 *bp++ = htonl(dvp->fid.vnode); 1912 *bp++ = htonl(dvp->fid.unique); 1913 *bp++ = htonl(vp->fid.vid); 1914 *bp++ = htonl(vp->fid.vnode); 1915 *bp++ = htonl(vp->fid.unique); 1916 for (i = 0; i < op->nr_files - 2; i++) { 1917 *bp++ = htonl(op->more_files[i].fid.vid); 1918 *bp++ = htonl(op->more_files[i].fid.vnode); 1919 *bp++ = htonl(op->more_files[i].fid.unique); 1920 } 1921 1922 trace_afs_make_fs_call(call, &vp->fid); 1923 afs_make_op_call(op, call, GFP_NOFS); 1924 } 1925 1926 /* 1927 * deliver reply data to an FS.FetchACL 1928 */ 1929 static int afs_deliver_fs_fetch_acl(struct afs_call *call) 1930 { 1931 struct afs_operation *op = call->op; 1932 struct afs_vnode_param *vp = &op->file[0]; 1933 struct afs_acl *acl; 1934 const __be32 *bp; 1935 unsigned int size; 1936 int ret; 1937 1938 _enter("{%u}", call->unmarshall); 1939 1940 switch (call->unmarshall) { 1941 case 0: 1942 afs_extract_to_tmp(call); 1943 call->unmarshall++; 1944 fallthrough; 1945 1946 /* extract the returned data length */ 1947 case 1: 1948 ret = afs_extract_data(call, true); 1949 if (ret < 0) 1950 return ret; 1951 1952 size = call->count2 = ntohl(call->tmp); 1953 size = round_up(size, 4); 1954 1955 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL); 1956 if (!acl) 1957 return -ENOMEM; 1958 op->acl = acl; 1959 acl->size = call->count2; 1960 afs_extract_begin(call, acl->data, size); 1961 call->unmarshall++; 1962 fallthrough; 1963 1964 /* extract the returned data */ 1965 case 2: 1966 ret = afs_extract_data(call, true); 1967 if (ret < 0) 1968 return ret; 1969 1970 afs_extract_to_buf(call, (21 + 6) * 4); 1971 call->unmarshall++; 1972 fallthrough; 1973 1974 /* extract the metadata */ 1975 case 3: 1976 ret = afs_extract_data(call, false); 1977 if (ret < 0) 1978 return ret; 1979 1980 bp = call->buffer; 1981 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb); 1982 xdr_decode_AFSVolSync(&bp, &op->volsync); 1983 1984 call->unmarshall++; 1985 fallthrough; 1986 1987 case 4: 1988 break; 1989 } 1990 1991 _leave(" = 0 [done]"); 1992 return 0; 1993 } 1994 1995 /* 1996 * FS.FetchACL operation type 1997 */ 1998 static const struct afs_call_type afs_RXFSFetchACL = { 1999 .name = "FS.FetchACL", 2000 .op = afs_FS_FetchACL, 2001 .deliver = afs_deliver_fs_fetch_acl, 2002 }; 2003 2004 /* 2005 * Fetch the ACL for a file. 2006 */ 2007 void afs_fs_fetch_acl(struct afs_operation *op) 2008 { 2009 struct afs_vnode_param *vp = &op->file[0]; 2010 struct afs_call *call; 2011 __be32 *bp; 2012 2013 _enter(",%x,{%llx:%llu},,", 2014 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 2015 2016 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchACL, 16, (21 + 6) * 4); 2017 if (!call) 2018 return afs_op_nomem(op); 2019 2020 /* marshall the parameters */ 2021 bp = call->request; 2022 bp[0] = htonl(FSFETCHACL); 2023 bp[1] = htonl(vp->fid.vid); 2024 bp[2] = htonl(vp->fid.vnode); 2025 bp[3] = htonl(vp->fid.unique); 2026 2027 trace_afs_make_fs_call(call, &vp->fid); 2028 afs_make_op_call(op, call, GFP_KERNEL); 2029 } 2030 2031 /* 2032 * FS.StoreACL operation type 2033 */ 2034 static const struct afs_call_type afs_RXFSStoreACL = { 2035 .name = "FS.StoreACL", 2036 .op = afs_FS_StoreACL, 2037 .deliver = afs_deliver_fs_file_status_and_vol, 2038 .destructor = afs_flat_call_destructor, 2039 }; 2040 2041 /* 2042 * Fetch the ACL for a file. 2043 */ 2044 void afs_fs_store_acl(struct afs_operation *op) 2045 { 2046 struct afs_vnode_param *vp = &op->file[0]; 2047 struct afs_call *call; 2048 const struct afs_acl *acl = op->acl; 2049 size_t size; 2050 __be32 *bp; 2051 2052 _enter(",%x,{%llx:%llu},,", 2053 key_serial(op->key), vp->fid.vid, vp->fid.vnode); 2054 2055 size = round_up(acl->size, 4); 2056 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreACL, 2057 5 * 4 + size, (21 + 6) * 4); 2058 if (!call) 2059 return afs_op_nomem(op); 2060 2061 /* marshall the parameters */ 2062 bp = call->request; 2063 bp[0] = htonl(FSSTOREACL); 2064 bp[1] = htonl(vp->fid.vid); 2065 bp[2] = htonl(vp->fid.vnode); 2066 bp[3] = htonl(vp->fid.unique); 2067 bp[4] = htonl(acl->size); 2068 memcpy(&bp[5], acl->data, acl->size); 2069 if (acl->size != size) 2070 memset((void *)&bp[5] + acl->size, 0, size - acl->size); 2071 2072 trace_afs_make_fs_call(call, &vp->fid); 2073 afs_make_op_call(op, call, GFP_KERNEL); 2074 } 2075