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