1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* dir.c: AFS filesystem directory handling 3 * 4 * Copyright (C) 2002, 2018 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/fs.h> 10 #include <linux/namei.h> 11 #include <linux/pagemap.h> 12 #include <linux/swap.h> 13 #include <linux/ctype.h> 14 #include <linux/sched.h> 15 #include <linux/task_io_accounting_ops.h> 16 #include "internal.h" 17 #include "afs_fs.h" 18 #include "xdr_fs.h" 19 20 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 21 unsigned int flags); 22 static int afs_dir_open(struct inode *inode, struct file *file); 23 static int afs_readdir(struct file *file, struct dir_context *ctx); 24 static int afs_d_revalidate(struct dentry *dentry, unsigned int flags); 25 static int afs_d_delete(const struct dentry *dentry); 26 static void afs_d_iput(struct dentry *dentry, struct inode *inode); 27 static int afs_lookup_one_filldir(struct dir_context *ctx, const char *name, int nlen, 28 loff_t fpos, u64 ino, unsigned dtype); 29 static int afs_lookup_filldir(struct dir_context *ctx, const char *name, int nlen, 30 loff_t fpos, u64 ino, unsigned dtype); 31 static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode, 32 bool excl); 33 static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode); 34 static int afs_rmdir(struct inode *dir, struct dentry *dentry); 35 static int afs_unlink(struct inode *dir, struct dentry *dentry); 36 static int afs_link(struct dentry *from, struct inode *dir, 37 struct dentry *dentry); 38 static int afs_symlink(struct inode *dir, struct dentry *dentry, 39 const char *content); 40 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry, 41 struct inode *new_dir, struct dentry *new_dentry, 42 unsigned int flags); 43 static int afs_dir_releasepage(struct page *page, gfp_t gfp_flags); 44 static void afs_dir_invalidatepage(struct page *page, unsigned int offset, 45 unsigned int length); 46 47 static int afs_dir_set_page_dirty(struct page *page) 48 { 49 BUG(); /* This should never happen. */ 50 } 51 52 const struct file_operations afs_dir_file_operations = { 53 .open = afs_dir_open, 54 .release = afs_release, 55 .iterate_shared = afs_readdir, 56 .lock = afs_lock, 57 .llseek = generic_file_llseek, 58 }; 59 60 const struct inode_operations afs_dir_inode_operations = { 61 .create = afs_create, 62 .lookup = afs_lookup, 63 .link = afs_link, 64 .unlink = afs_unlink, 65 .symlink = afs_symlink, 66 .mkdir = afs_mkdir, 67 .rmdir = afs_rmdir, 68 .rename = afs_rename, 69 .permission = afs_permission, 70 .getattr = afs_getattr, 71 .setattr = afs_setattr, 72 }; 73 74 const struct address_space_operations afs_dir_aops = { 75 .set_page_dirty = afs_dir_set_page_dirty, 76 .releasepage = afs_dir_releasepage, 77 .invalidatepage = afs_dir_invalidatepage, 78 }; 79 80 const struct dentry_operations afs_fs_dentry_operations = { 81 .d_revalidate = afs_d_revalidate, 82 .d_delete = afs_d_delete, 83 .d_release = afs_d_release, 84 .d_automount = afs_d_automount, 85 .d_iput = afs_d_iput, 86 }; 87 88 struct afs_lookup_one_cookie { 89 struct dir_context ctx; 90 struct qstr name; 91 bool found; 92 struct afs_fid fid; 93 }; 94 95 struct afs_lookup_cookie { 96 struct dir_context ctx; 97 struct qstr name; 98 bool found; 99 bool one_only; 100 unsigned short nr_fids; 101 struct afs_fid fids[50]; 102 }; 103 104 /* 105 * check that a directory page is valid 106 */ 107 static bool afs_dir_check_page(struct afs_vnode *dvnode, struct page *page, 108 loff_t i_size) 109 { 110 struct afs_xdr_dir_page *dbuf; 111 loff_t latter, off; 112 int tmp, qty; 113 114 /* Determine how many magic numbers there should be in this page, but 115 * we must take care because the directory may change size under us. 116 */ 117 off = page_offset(page); 118 if (i_size <= off) 119 goto checked; 120 121 latter = i_size - off; 122 if (latter >= PAGE_SIZE) 123 qty = PAGE_SIZE; 124 else 125 qty = latter; 126 qty /= sizeof(union afs_xdr_dir_block); 127 128 /* check them */ 129 dbuf = kmap(page); 130 for (tmp = 0; tmp < qty; tmp++) { 131 if (dbuf->blocks[tmp].hdr.magic != AFS_DIR_MAGIC) { 132 printk("kAFS: %s(%lx): bad magic %d/%d is %04hx\n", 133 __func__, dvnode->vfs_inode.i_ino, tmp, qty, 134 ntohs(dbuf->blocks[tmp].hdr.magic)); 135 trace_afs_dir_check_failed(dvnode, off, i_size); 136 kunmap(page); 137 trace_afs_file_error(dvnode, -EIO, afs_file_error_dir_bad_magic); 138 goto error; 139 } 140 141 /* Make sure each block is NUL terminated so we can reasonably 142 * use string functions on it. The filenames in the page 143 * *should* be NUL-terminated anyway. 144 */ 145 ((u8 *)&dbuf->blocks[tmp])[AFS_DIR_BLOCK_SIZE - 1] = 0; 146 } 147 148 kunmap(page); 149 150 checked: 151 afs_stat_v(dvnode, n_read_dir); 152 return true; 153 154 error: 155 return false; 156 } 157 158 /* 159 * Check the contents of a directory that we've just read. 160 */ 161 static bool afs_dir_check_pages(struct afs_vnode *dvnode, struct afs_read *req) 162 { 163 struct afs_xdr_dir_page *dbuf; 164 unsigned int i, j, qty = PAGE_SIZE / sizeof(union afs_xdr_dir_block); 165 166 for (i = 0; i < req->nr_pages; i++) 167 if (!afs_dir_check_page(dvnode, req->pages[i], req->actual_len)) 168 goto bad; 169 return true; 170 171 bad: 172 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx r=%llx\n", 173 dvnode->fid.vid, dvnode->fid.vnode, 174 req->file_size, req->len, req->actual_len, req->remain); 175 pr_warn("DIR %llx %x %x %x\n", 176 req->pos, req->index, req->nr_pages, req->offset); 177 178 for (i = 0; i < req->nr_pages; i++) { 179 dbuf = kmap(req->pages[i]); 180 for (j = 0; j < qty; j++) { 181 union afs_xdr_dir_block *block = &dbuf->blocks[j]; 182 183 pr_warn("[%02x] %32phN\n", i * qty + j, block); 184 } 185 kunmap(req->pages[i]); 186 } 187 return false; 188 } 189 190 /* 191 * open an AFS directory file 192 */ 193 static int afs_dir_open(struct inode *inode, struct file *file) 194 { 195 _enter("{%lu}", inode->i_ino); 196 197 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048); 198 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32); 199 200 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags)) 201 return -ENOENT; 202 203 return afs_open(inode, file); 204 } 205 206 /* 207 * Read the directory into the pagecache in one go, scrubbing the previous 208 * contents. The list of pages is returned, pinning them so that they don't 209 * get reclaimed during the iteration. 210 */ 211 static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key) 212 __acquires(&dvnode->validate_lock) 213 { 214 struct afs_read *req; 215 loff_t i_size; 216 int nr_pages, nr_inline, i, n; 217 int ret = -ENOMEM; 218 219 retry: 220 i_size = i_size_read(&dvnode->vfs_inode); 221 if (i_size < 2048) 222 return ERR_PTR(afs_bad(dvnode, afs_file_error_dir_small)); 223 if (i_size > 2048 * 1024) { 224 trace_afs_file_error(dvnode, -EFBIG, afs_file_error_dir_big); 225 return ERR_PTR(-EFBIG); 226 } 227 228 _enter("%llu", i_size); 229 230 /* Get a request record to hold the page list. We want to hold it 231 * inline if we can, but we don't want to make an order 1 allocation. 232 */ 233 nr_pages = (i_size + PAGE_SIZE - 1) / PAGE_SIZE; 234 nr_inline = nr_pages; 235 if (nr_inline > (PAGE_SIZE - sizeof(*req)) / sizeof(struct page *)) 236 nr_inline = 0; 237 238 req = kzalloc(struct_size(req, array, nr_inline), GFP_KERNEL); 239 if (!req) 240 return ERR_PTR(-ENOMEM); 241 242 refcount_set(&req->usage, 1); 243 req->nr_pages = nr_pages; 244 req->actual_len = i_size; /* May change */ 245 req->len = nr_pages * PAGE_SIZE; /* We can ask for more than there is */ 246 req->data_version = dvnode->status.data_version; /* May change */ 247 if (nr_inline > 0) { 248 req->pages = req->array; 249 } else { 250 req->pages = kcalloc(nr_pages, sizeof(struct page *), 251 GFP_KERNEL); 252 if (!req->pages) 253 goto error; 254 } 255 256 /* Get a list of all the pages that hold or will hold the directory 257 * content. We need to fill in any gaps that we might find where the 258 * memory reclaimer has been at work. If there are any gaps, we will 259 * need to reread the entire directory contents. 260 */ 261 i = 0; 262 do { 263 n = find_get_pages_contig(dvnode->vfs_inode.i_mapping, i, 264 req->nr_pages - i, 265 req->pages + i); 266 _debug("find %u at %u/%u", n, i, req->nr_pages); 267 if (n == 0) { 268 gfp_t gfp = dvnode->vfs_inode.i_mapping->gfp_mask; 269 270 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 271 afs_stat_v(dvnode, n_inval); 272 273 ret = -ENOMEM; 274 req->pages[i] = __page_cache_alloc(gfp); 275 if (!req->pages[i]) 276 goto error; 277 ret = add_to_page_cache_lru(req->pages[i], 278 dvnode->vfs_inode.i_mapping, 279 i, gfp); 280 if (ret < 0) 281 goto error; 282 283 attach_page_private(req->pages[i], (void *)1); 284 unlock_page(req->pages[i]); 285 i++; 286 } else { 287 i += n; 288 } 289 } while (i < req->nr_pages); 290 291 /* If we're going to reload, we need to lock all the pages to prevent 292 * races. 293 */ 294 ret = -ERESTARTSYS; 295 if (down_read_killable(&dvnode->validate_lock) < 0) 296 goto error; 297 298 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 299 goto success; 300 301 up_read(&dvnode->validate_lock); 302 if (down_write_killable(&dvnode->validate_lock) < 0) 303 goto error; 304 305 if (!test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) { 306 trace_afs_reload_dir(dvnode); 307 ret = afs_fetch_data(dvnode, key, req); 308 if (ret < 0) 309 goto error_unlock; 310 311 task_io_account_read(PAGE_SIZE * req->nr_pages); 312 313 if (req->len < req->file_size) 314 goto content_has_grown; 315 316 /* Validate the data we just read. */ 317 ret = -EIO; 318 if (!afs_dir_check_pages(dvnode, req)) 319 goto error_unlock; 320 321 // TODO: Trim excess pages 322 323 set_bit(AFS_VNODE_DIR_VALID, &dvnode->flags); 324 } 325 326 downgrade_write(&dvnode->validate_lock); 327 success: 328 return req; 329 330 error_unlock: 331 up_write(&dvnode->validate_lock); 332 error: 333 afs_put_read(req); 334 _leave(" = %d", ret); 335 return ERR_PTR(ret); 336 337 content_has_grown: 338 up_write(&dvnode->validate_lock); 339 afs_put_read(req); 340 goto retry; 341 } 342 343 /* 344 * deal with one block in an AFS directory 345 */ 346 static int afs_dir_iterate_block(struct afs_vnode *dvnode, 347 struct dir_context *ctx, 348 union afs_xdr_dir_block *block, 349 unsigned blkoff) 350 { 351 union afs_xdr_dirent *dire; 352 unsigned offset, next, curr; 353 size_t nlen; 354 int tmp; 355 356 _enter("%u,%x,%p,,",(unsigned)ctx->pos,blkoff,block); 357 358 curr = (ctx->pos - blkoff) / sizeof(union afs_xdr_dirent); 359 360 /* walk through the block, an entry at a time */ 361 for (offset = (blkoff == 0 ? AFS_DIR_RESV_BLOCKS0 : AFS_DIR_RESV_BLOCKS); 362 offset < AFS_DIR_SLOTS_PER_BLOCK; 363 offset = next 364 ) { 365 next = offset + 1; 366 367 /* skip entries marked unused in the bitmap */ 368 if (!(block->hdr.bitmap[offset / 8] & 369 (1 << (offset % 8)))) { 370 _debug("ENT[%zu.%u]: unused", 371 blkoff / sizeof(union afs_xdr_dir_block), offset); 372 if (offset >= curr) 373 ctx->pos = blkoff + 374 next * sizeof(union afs_xdr_dirent); 375 continue; 376 } 377 378 /* got a valid entry */ 379 dire = &block->dirents[offset]; 380 nlen = strnlen(dire->u.name, 381 sizeof(*block) - 382 offset * sizeof(union afs_xdr_dirent)); 383 384 _debug("ENT[%zu.%u]: %s %zu \"%s\"", 385 blkoff / sizeof(union afs_xdr_dir_block), offset, 386 (offset < curr ? "skip" : "fill"), 387 nlen, dire->u.name); 388 389 /* work out where the next possible entry is */ 390 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_xdr_dirent)) { 391 if (next >= AFS_DIR_SLOTS_PER_BLOCK) { 392 _debug("ENT[%zu.%u]:" 393 " %u travelled beyond end dir block" 394 " (len %u/%zu)", 395 blkoff / sizeof(union afs_xdr_dir_block), 396 offset, next, tmp, nlen); 397 return afs_bad(dvnode, afs_file_error_dir_over_end); 398 } 399 if (!(block->hdr.bitmap[next / 8] & 400 (1 << (next % 8)))) { 401 _debug("ENT[%zu.%u]:" 402 " %u unmarked extension (len %u/%zu)", 403 blkoff / sizeof(union afs_xdr_dir_block), 404 offset, next, tmp, nlen); 405 return afs_bad(dvnode, afs_file_error_dir_unmarked_ext); 406 } 407 408 _debug("ENT[%zu.%u]: ext %u/%zu", 409 blkoff / sizeof(union afs_xdr_dir_block), 410 next, tmp, nlen); 411 next++; 412 } 413 414 /* skip if starts before the current position */ 415 if (offset < curr) 416 continue; 417 418 /* found the next entry */ 419 if (!dir_emit(ctx, dire->u.name, nlen, 420 ntohl(dire->u.vnode), 421 (ctx->actor == afs_lookup_filldir || 422 ctx->actor == afs_lookup_one_filldir)? 423 ntohl(dire->u.unique) : DT_UNKNOWN)) { 424 _leave(" = 0 [full]"); 425 return 0; 426 } 427 428 ctx->pos = blkoff + next * sizeof(union afs_xdr_dirent); 429 } 430 431 _leave(" = 1 [more]"); 432 return 1; 433 } 434 435 /* 436 * iterate through the data blob that lists the contents of an AFS directory 437 */ 438 static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx, 439 struct key *key, afs_dataversion_t *_dir_version) 440 { 441 struct afs_vnode *dvnode = AFS_FS_I(dir); 442 struct afs_xdr_dir_page *dbuf; 443 union afs_xdr_dir_block *dblock; 444 struct afs_read *req; 445 struct page *page; 446 unsigned blkoff, limit; 447 int ret; 448 449 _enter("{%lu},%u,,", dir->i_ino, (unsigned)ctx->pos); 450 451 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) { 452 _leave(" = -ESTALE"); 453 return -ESTALE; 454 } 455 456 req = afs_read_dir(dvnode, key); 457 if (IS_ERR(req)) 458 return PTR_ERR(req); 459 *_dir_version = req->data_version; 460 461 /* round the file position up to the next entry boundary */ 462 ctx->pos += sizeof(union afs_xdr_dirent) - 1; 463 ctx->pos &= ~(sizeof(union afs_xdr_dirent) - 1); 464 465 /* walk through the blocks in sequence */ 466 ret = 0; 467 while (ctx->pos < req->actual_len) { 468 blkoff = ctx->pos & ~(sizeof(union afs_xdr_dir_block) - 1); 469 470 /* Fetch the appropriate page from the directory and re-add it 471 * to the LRU. 472 */ 473 page = req->pages[blkoff / PAGE_SIZE]; 474 if (!page) { 475 ret = afs_bad(dvnode, afs_file_error_dir_missing_page); 476 break; 477 } 478 mark_page_accessed(page); 479 480 limit = blkoff & ~(PAGE_SIZE - 1); 481 482 dbuf = kmap(page); 483 484 /* deal with the individual blocks stashed on this page */ 485 do { 486 dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) / 487 sizeof(union afs_xdr_dir_block)]; 488 ret = afs_dir_iterate_block(dvnode, ctx, dblock, blkoff); 489 if (ret != 1) { 490 kunmap(page); 491 goto out; 492 } 493 494 blkoff += sizeof(union afs_xdr_dir_block); 495 496 } while (ctx->pos < dir->i_size && blkoff < limit); 497 498 kunmap(page); 499 ret = 0; 500 } 501 502 out: 503 up_read(&dvnode->validate_lock); 504 afs_put_read(req); 505 _leave(" = %d", ret); 506 return ret; 507 } 508 509 /* 510 * read an AFS directory 511 */ 512 static int afs_readdir(struct file *file, struct dir_context *ctx) 513 { 514 afs_dataversion_t dir_version; 515 516 return afs_dir_iterate(file_inode(file), ctx, afs_file_key(file), 517 &dir_version); 518 } 519 520 /* 521 * Search the directory for a single name 522 * - if afs_dir_iterate_block() spots this function, it'll pass the FID 523 * uniquifier through dtype 524 */ 525 static int afs_lookup_one_filldir(struct dir_context *ctx, const char *name, 526 int nlen, loff_t fpos, u64 ino, unsigned dtype) 527 { 528 struct afs_lookup_one_cookie *cookie = 529 container_of(ctx, struct afs_lookup_one_cookie, ctx); 530 531 _enter("{%s,%u},%s,%u,,%llu,%u", 532 cookie->name.name, cookie->name.len, name, nlen, 533 (unsigned long long) ino, dtype); 534 535 /* insanity checks first */ 536 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048); 537 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32); 538 539 if (cookie->name.len != nlen || 540 memcmp(cookie->name.name, name, nlen) != 0) { 541 _leave(" = 0 [no]"); 542 return 0; 543 } 544 545 cookie->fid.vnode = ino; 546 cookie->fid.unique = dtype; 547 cookie->found = 1; 548 549 _leave(" = -1 [found]"); 550 return -1; 551 } 552 553 /* 554 * Do a lookup of a single name in a directory 555 * - just returns the FID the dentry name maps to if found 556 */ 557 static int afs_do_lookup_one(struct inode *dir, struct dentry *dentry, 558 struct afs_fid *fid, struct key *key, 559 afs_dataversion_t *_dir_version) 560 { 561 struct afs_super_info *as = dir->i_sb->s_fs_info; 562 struct afs_lookup_one_cookie cookie = { 563 .ctx.actor = afs_lookup_one_filldir, 564 .name = dentry->d_name, 565 .fid.vid = as->volume->vid 566 }; 567 int ret; 568 569 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry); 570 571 /* search the directory */ 572 ret = afs_dir_iterate(dir, &cookie.ctx, key, _dir_version); 573 if (ret < 0) { 574 _leave(" = %d [iter]", ret); 575 return ret; 576 } 577 578 ret = -ENOENT; 579 if (!cookie.found) { 580 _leave(" = -ENOENT [not found]"); 581 return -ENOENT; 582 } 583 584 *fid = cookie.fid; 585 _leave(" = 0 { vn=%llu u=%u }", fid->vnode, fid->unique); 586 return 0; 587 } 588 589 /* 590 * search the directory for a name 591 * - if afs_dir_iterate_block() spots this function, it'll pass the FID 592 * uniquifier through dtype 593 */ 594 static int afs_lookup_filldir(struct dir_context *ctx, const char *name, 595 int nlen, loff_t fpos, u64 ino, unsigned dtype) 596 { 597 struct afs_lookup_cookie *cookie = 598 container_of(ctx, struct afs_lookup_cookie, ctx); 599 int ret; 600 601 _enter("{%s,%u},%s,%u,,%llu,%u", 602 cookie->name.name, cookie->name.len, name, nlen, 603 (unsigned long long) ino, dtype); 604 605 /* insanity checks first */ 606 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048); 607 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32); 608 609 if (cookie->found) { 610 if (cookie->nr_fids < 50) { 611 cookie->fids[cookie->nr_fids].vnode = ino; 612 cookie->fids[cookie->nr_fids].unique = dtype; 613 cookie->nr_fids++; 614 } 615 } else if (cookie->name.len == nlen && 616 memcmp(cookie->name.name, name, nlen) == 0) { 617 cookie->fids[1].vnode = ino; 618 cookie->fids[1].unique = dtype; 619 cookie->found = 1; 620 if (cookie->one_only) 621 return -1; 622 } 623 624 ret = cookie->nr_fids >= 50 ? -1 : 0; 625 _leave(" = %d", ret); 626 return ret; 627 } 628 629 /* 630 * Deal with the result of a successful lookup operation. Turn all the files 631 * into inodes and save the first one - which is the one we actually want. 632 */ 633 static void afs_do_lookup_success(struct afs_operation *op) 634 { 635 struct afs_vnode_param *vp; 636 struct afs_vnode *vnode; 637 struct inode *inode; 638 u32 abort_code; 639 int i; 640 641 _enter(""); 642 643 for (i = 0; i < op->nr_files; i++) { 644 switch (i) { 645 case 0: 646 vp = &op->file[0]; 647 abort_code = vp->scb.status.abort_code; 648 if (abort_code != 0) { 649 op->ac.abort_code = abort_code; 650 op->error = afs_abort_to_error(abort_code); 651 } 652 break; 653 654 case 1: 655 vp = &op->file[1]; 656 break; 657 658 default: 659 vp = &op->more_files[i - 2]; 660 break; 661 } 662 663 if (!vp->scb.have_status && !vp->scb.have_error) 664 continue; 665 666 _debug("do [%u]", i); 667 if (vp->vnode) { 668 if (!test_bit(AFS_VNODE_UNSET, &vp->vnode->flags)) 669 afs_vnode_commit_status(op, vp); 670 } else if (vp->scb.status.abort_code == 0) { 671 inode = afs_iget(op, vp); 672 if (!IS_ERR(inode)) { 673 vnode = AFS_FS_I(inode); 674 afs_cache_permit(vnode, op->key, 675 0 /* Assume vnode->cb_break is 0 */ + 676 op->cb_v_break, 677 &vp->scb); 678 vp->vnode = vnode; 679 vp->put_vnode = true; 680 } 681 } else { 682 _debug("- abort %d %llx:%llx.%x", 683 vp->scb.status.abort_code, 684 vp->fid.vid, vp->fid.vnode, vp->fid.unique); 685 } 686 } 687 688 _leave(""); 689 } 690 691 static const struct afs_operation_ops afs_inline_bulk_status_operation = { 692 .issue_afs_rpc = afs_fs_inline_bulk_status, 693 .issue_yfs_rpc = yfs_fs_inline_bulk_status, 694 .success = afs_do_lookup_success, 695 }; 696 697 static const struct afs_operation_ops afs_lookup_fetch_status_operation = { 698 .issue_afs_rpc = afs_fs_fetch_status, 699 .issue_yfs_rpc = yfs_fs_fetch_status, 700 .success = afs_do_lookup_success, 701 .aborted = afs_check_for_remote_deletion, 702 }; 703 704 /* 705 * See if we know that the server we expect to use doesn't support 706 * FS.InlineBulkStatus. 707 */ 708 static bool afs_server_supports_ibulk(struct afs_vnode *dvnode) 709 { 710 struct afs_server_list *slist; 711 struct afs_volume *volume = dvnode->volume; 712 struct afs_server *server; 713 bool ret = true; 714 int i; 715 716 if (!test_bit(AFS_VOLUME_MAYBE_NO_IBULK, &volume->flags)) 717 return true; 718 719 rcu_read_lock(); 720 slist = rcu_dereference(volume->servers); 721 722 for (i = 0; i < slist->nr_servers; i++) { 723 server = slist->servers[i].server; 724 if (server == dvnode->cb_server) { 725 if (test_bit(AFS_SERVER_FL_NO_IBULK, &server->flags)) 726 ret = false; 727 break; 728 } 729 } 730 731 rcu_read_unlock(); 732 return ret; 733 } 734 735 /* 736 * Do a lookup in a directory. We make use of bulk lookup to query a slew of 737 * files in one go and create inodes for them. The inode of the file we were 738 * asked for is returned. 739 */ 740 static struct inode *afs_do_lookup(struct inode *dir, struct dentry *dentry, 741 struct key *key) 742 { 743 struct afs_lookup_cookie *cookie; 744 struct afs_vnode_param *vp; 745 struct afs_operation *op; 746 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode; 747 struct inode *inode = NULL, *ti; 748 afs_dataversion_t data_version = READ_ONCE(dvnode->status.data_version); 749 long ret; 750 int i; 751 752 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry); 753 754 cookie = kzalloc(sizeof(struct afs_lookup_cookie), GFP_KERNEL); 755 if (!cookie) 756 return ERR_PTR(-ENOMEM); 757 758 for (i = 0; i < ARRAY_SIZE(cookie->fids); i++) 759 cookie->fids[i].vid = dvnode->fid.vid; 760 cookie->ctx.actor = afs_lookup_filldir; 761 cookie->name = dentry->d_name; 762 cookie->nr_fids = 2; /* slot 0 is saved for the fid we actually want 763 * and slot 1 for the directory */ 764 765 if (!afs_server_supports_ibulk(dvnode)) 766 cookie->one_only = true; 767 768 /* search the directory */ 769 ret = afs_dir_iterate(dir, &cookie->ctx, key, &data_version); 770 if (ret < 0) 771 goto out; 772 773 dentry->d_fsdata = (void *)(unsigned long)data_version; 774 775 ret = -ENOENT; 776 if (!cookie->found) 777 goto out; 778 779 /* Check to see if we already have an inode for the primary fid. */ 780 inode = ilookup5(dir->i_sb, cookie->fids[1].vnode, 781 afs_ilookup5_test_by_fid, &cookie->fids[1]); 782 if (inode) 783 goto out; /* We do */ 784 785 /* Okay, we didn't find it. We need to query the server - and whilst 786 * we're doing that, we're going to attempt to look up a bunch of other 787 * vnodes also. 788 */ 789 op = afs_alloc_operation(NULL, dvnode->volume); 790 if (IS_ERR(op)) { 791 ret = PTR_ERR(op); 792 goto out; 793 } 794 795 afs_op_set_vnode(op, 0, dvnode); 796 afs_op_set_fid(op, 1, &cookie->fids[1]); 797 798 op->nr_files = cookie->nr_fids; 799 _debug("nr_files %u", op->nr_files); 800 801 /* Need space for examining all the selected files */ 802 op->error = -ENOMEM; 803 if (op->nr_files > 2) { 804 op->more_files = kvcalloc(op->nr_files - 2, 805 sizeof(struct afs_vnode_param), 806 GFP_KERNEL); 807 if (!op->more_files) 808 goto out_op; 809 810 for (i = 2; i < op->nr_files; i++) { 811 vp = &op->more_files[i - 2]; 812 vp->fid = cookie->fids[i]; 813 814 /* Find any inodes that already exist and get their 815 * callback counters. 816 */ 817 ti = ilookup5_nowait(dir->i_sb, vp->fid.vnode, 818 afs_ilookup5_test_by_fid, &vp->fid); 819 if (!IS_ERR_OR_NULL(ti)) { 820 vnode = AFS_FS_I(ti); 821 vp->dv_before = vnode->status.data_version; 822 vp->cb_break_before = afs_calc_vnode_cb_break(vnode); 823 vp->vnode = vnode; 824 vp->put_vnode = true; 825 vp->speculative = true; /* vnode not locked */ 826 } 827 } 828 } 829 830 /* Try FS.InlineBulkStatus first. Abort codes for the individual 831 * lookups contained therein are stored in the reply without aborting 832 * the whole operation. 833 */ 834 op->error = -ENOTSUPP; 835 if (!cookie->one_only) { 836 op->ops = &afs_inline_bulk_status_operation; 837 afs_begin_vnode_operation(op); 838 afs_wait_for_operation(op); 839 } 840 841 if (op->error == -ENOTSUPP) { 842 /* We could try FS.BulkStatus next, but this aborts the entire 843 * op if any of the lookups fails - so, for the moment, revert 844 * to FS.FetchStatus for op->file[1]. 845 */ 846 op->fetch_status.which = 1; 847 op->ops = &afs_lookup_fetch_status_operation; 848 afs_begin_vnode_operation(op); 849 afs_wait_for_operation(op); 850 } 851 inode = ERR_PTR(op->error); 852 853 out_op: 854 if (op->error == 0) { 855 inode = &op->file[1].vnode->vfs_inode; 856 op->file[1].vnode = NULL; 857 } 858 859 if (op->file[0].scb.have_status) 860 dentry->d_fsdata = (void *)(unsigned long)op->file[0].scb.status.data_version; 861 else 862 dentry->d_fsdata = (void *)(unsigned long)op->file[0].dv_before; 863 ret = afs_put_operation(op); 864 out: 865 kfree(cookie); 866 _leave(""); 867 return inode ?: ERR_PTR(ret); 868 } 869 870 /* 871 * Look up an entry in a directory with @sys substitution. 872 */ 873 static struct dentry *afs_lookup_atsys(struct inode *dir, struct dentry *dentry, 874 struct key *key) 875 { 876 struct afs_sysnames *subs; 877 struct afs_net *net = afs_i2net(dir); 878 struct dentry *ret; 879 char *buf, *p, *name; 880 int len, i; 881 882 _enter(""); 883 884 ret = ERR_PTR(-ENOMEM); 885 p = buf = kmalloc(AFSNAMEMAX, GFP_KERNEL); 886 if (!buf) 887 goto out_p; 888 if (dentry->d_name.len > 4) { 889 memcpy(p, dentry->d_name.name, dentry->d_name.len - 4); 890 p += dentry->d_name.len - 4; 891 } 892 893 /* There is an ordered list of substitutes that we have to try. */ 894 read_lock(&net->sysnames_lock); 895 subs = net->sysnames; 896 refcount_inc(&subs->usage); 897 read_unlock(&net->sysnames_lock); 898 899 for (i = 0; i < subs->nr; i++) { 900 name = subs->subs[i]; 901 len = dentry->d_name.len - 4 + strlen(name); 902 if (len >= AFSNAMEMAX) { 903 ret = ERR_PTR(-ENAMETOOLONG); 904 goto out_s; 905 } 906 907 strcpy(p, name); 908 ret = lookup_one_len(buf, dentry->d_parent, len); 909 if (IS_ERR(ret) || d_is_positive(ret)) 910 goto out_s; 911 dput(ret); 912 } 913 914 /* We don't want to d_add() the @sys dentry here as we don't want to 915 * the cached dentry to hide changes to the sysnames list. 916 */ 917 ret = NULL; 918 out_s: 919 afs_put_sysnames(subs); 920 kfree(buf); 921 out_p: 922 key_put(key); 923 return ret; 924 } 925 926 /* 927 * look up an entry in a directory 928 */ 929 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 930 unsigned int flags) 931 { 932 struct afs_vnode *dvnode = AFS_FS_I(dir); 933 struct afs_fid fid = {}; 934 struct inode *inode; 935 struct dentry *d; 936 struct key *key; 937 int ret; 938 939 _enter("{%llx:%llu},%p{%pd},", 940 dvnode->fid.vid, dvnode->fid.vnode, dentry, dentry); 941 942 ASSERTCMP(d_inode(dentry), ==, NULL); 943 944 if (dentry->d_name.len >= AFSNAMEMAX) { 945 _leave(" = -ENAMETOOLONG"); 946 return ERR_PTR(-ENAMETOOLONG); 947 } 948 949 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) { 950 _leave(" = -ESTALE"); 951 return ERR_PTR(-ESTALE); 952 } 953 954 key = afs_request_key(dvnode->volume->cell); 955 if (IS_ERR(key)) { 956 _leave(" = %ld [key]", PTR_ERR(key)); 957 return ERR_CAST(key); 958 } 959 960 ret = afs_validate(dvnode, key); 961 if (ret < 0) { 962 key_put(key); 963 _leave(" = %d [val]", ret); 964 return ERR_PTR(ret); 965 } 966 967 if (dentry->d_name.len >= 4 && 968 dentry->d_name.name[dentry->d_name.len - 4] == '@' && 969 dentry->d_name.name[dentry->d_name.len - 3] == 's' && 970 dentry->d_name.name[dentry->d_name.len - 2] == 'y' && 971 dentry->d_name.name[dentry->d_name.len - 1] == 's') 972 return afs_lookup_atsys(dir, dentry, key); 973 974 afs_stat_v(dvnode, n_lookup); 975 inode = afs_do_lookup(dir, dentry, key); 976 key_put(key); 977 if (inode == ERR_PTR(-ENOENT)) 978 inode = afs_try_auto_mntpt(dentry, dir); 979 980 if (!IS_ERR_OR_NULL(inode)) 981 fid = AFS_FS_I(inode)->fid; 982 983 _debug("splice %p", dentry->d_inode); 984 d = d_splice_alias(inode, dentry); 985 if (!IS_ERR_OR_NULL(d)) { 986 d->d_fsdata = dentry->d_fsdata; 987 trace_afs_lookup(dvnode, &d->d_name, &fid); 988 } else { 989 trace_afs_lookup(dvnode, &dentry->d_name, &fid); 990 } 991 _leave(""); 992 return d; 993 } 994 995 /* 996 * Check the validity of a dentry under RCU conditions. 997 */ 998 static int afs_d_revalidate_rcu(struct dentry *dentry) 999 { 1000 struct afs_vnode *dvnode, *vnode; 1001 struct dentry *parent; 1002 struct inode *dir, *inode; 1003 long dir_version, de_version; 1004 1005 _enter("%p", dentry); 1006 1007 /* Check the parent directory is still valid first. */ 1008 parent = READ_ONCE(dentry->d_parent); 1009 dir = d_inode_rcu(parent); 1010 if (!dir) 1011 return -ECHILD; 1012 dvnode = AFS_FS_I(dir); 1013 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) 1014 return -ECHILD; 1015 1016 if (!afs_check_validity(dvnode)) 1017 return -ECHILD; 1018 1019 /* We only need to invalidate a dentry if the server's copy changed 1020 * behind our back. If we made the change, it's no problem. Note that 1021 * on a 32-bit system, we only have 32 bits in the dentry to store the 1022 * version. 1023 */ 1024 dir_version = (long)READ_ONCE(dvnode->status.data_version); 1025 de_version = (long)READ_ONCE(dentry->d_fsdata); 1026 if (de_version != dir_version) { 1027 dir_version = (long)READ_ONCE(dvnode->invalid_before); 1028 if (de_version - dir_version < 0) 1029 return -ECHILD; 1030 } 1031 1032 /* Check to see if the vnode referred to by the dentry still 1033 * has a callback. 1034 */ 1035 if (d_really_is_positive(dentry)) { 1036 inode = d_inode_rcu(dentry); 1037 if (inode) { 1038 vnode = AFS_FS_I(inode); 1039 if (!afs_check_validity(vnode)) 1040 return -ECHILD; 1041 } 1042 } 1043 1044 return 1; /* Still valid */ 1045 } 1046 1047 /* 1048 * check that a dentry lookup hit has found a valid entry 1049 * - NOTE! the hit can be a negative hit too, so we can't assume we have an 1050 * inode 1051 */ 1052 static int afs_d_revalidate(struct dentry *dentry, unsigned int flags) 1053 { 1054 struct afs_vnode *vnode, *dir; 1055 struct afs_fid fid; 1056 struct dentry *parent; 1057 struct inode *inode; 1058 struct key *key; 1059 afs_dataversion_t dir_version, invalid_before; 1060 long de_version; 1061 int ret; 1062 1063 if (flags & LOOKUP_RCU) 1064 return afs_d_revalidate_rcu(dentry); 1065 1066 if (d_really_is_positive(dentry)) { 1067 vnode = AFS_FS_I(d_inode(dentry)); 1068 _enter("{v={%llx:%llu} n=%pd fl=%lx},", 1069 vnode->fid.vid, vnode->fid.vnode, dentry, 1070 vnode->flags); 1071 } else { 1072 _enter("{neg n=%pd}", dentry); 1073 } 1074 1075 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell); 1076 if (IS_ERR(key)) 1077 key = NULL; 1078 1079 if (d_really_is_positive(dentry)) { 1080 inode = d_inode(dentry); 1081 if (inode) { 1082 vnode = AFS_FS_I(inode); 1083 afs_validate(vnode, key); 1084 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 1085 goto out_bad; 1086 } 1087 } 1088 1089 /* lock down the parent dentry so we can peer at it */ 1090 parent = dget_parent(dentry); 1091 dir = AFS_FS_I(d_inode(parent)); 1092 1093 /* validate the parent directory */ 1094 afs_validate(dir, key); 1095 1096 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) { 1097 _debug("%pd: parent dir deleted", dentry); 1098 goto out_bad_parent; 1099 } 1100 1101 /* We only need to invalidate a dentry if the server's copy changed 1102 * behind our back. If we made the change, it's no problem. Note that 1103 * on a 32-bit system, we only have 32 bits in the dentry to store the 1104 * version. 1105 */ 1106 dir_version = dir->status.data_version; 1107 de_version = (long)dentry->d_fsdata; 1108 if (de_version == (long)dir_version) 1109 goto out_valid_noupdate; 1110 1111 invalid_before = dir->invalid_before; 1112 if (de_version - (long)invalid_before >= 0) 1113 goto out_valid; 1114 1115 _debug("dir modified"); 1116 afs_stat_v(dir, n_reval); 1117 1118 /* search the directory for this vnode */ 1119 ret = afs_do_lookup_one(&dir->vfs_inode, dentry, &fid, key, &dir_version); 1120 switch (ret) { 1121 case 0: 1122 /* the filename maps to something */ 1123 if (d_really_is_negative(dentry)) 1124 goto out_bad_parent; 1125 inode = d_inode(dentry); 1126 if (is_bad_inode(inode)) { 1127 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n", 1128 dentry); 1129 goto out_bad_parent; 1130 } 1131 1132 vnode = AFS_FS_I(inode); 1133 1134 /* if the vnode ID has changed, then the dirent points to a 1135 * different file */ 1136 if (fid.vnode != vnode->fid.vnode) { 1137 _debug("%pd: dirent changed [%llu != %llu]", 1138 dentry, fid.vnode, 1139 vnode->fid.vnode); 1140 goto not_found; 1141 } 1142 1143 /* if the vnode ID uniqifier has changed, then the file has 1144 * been deleted and replaced, and the original vnode ID has 1145 * been reused */ 1146 if (fid.unique != vnode->fid.unique) { 1147 _debug("%pd: file deleted (uq %u -> %u I:%u)", 1148 dentry, fid.unique, 1149 vnode->fid.unique, 1150 vnode->vfs_inode.i_generation); 1151 write_seqlock(&vnode->cb_lock); 1152 set_bit(AFS_VNODE_DELETED, &vnode->flags); 1153 write_sequnlock(&vnode->cb_lock); 1154 goto not_found; 1155 } 1156 goto out_valid; 1157 1158 case -ENOENT: 1159 /* the filename is unknown */ 1160 _debug("%pd: dirent not found", dentry); 1161 if (d_really_is_positive(dentry)) 1162 goto not_found; 1163 goto out_valid; 1164 1165 default: 1166 _debug("failed to iterate dir %pd: %d", 1167 parent, ret); 1168 goto out_bad_parent; 1169 } 1170 1171 out_valid: 1172 dentry->d_fsdata = (void *)(unsigned long)dir_version; 1173 out_valid_noupdate: 1174 dput(parent); 1175 key_put(key); 1176 _leave(" = 1 [valid]"); 1177 return 1; 1178 1179 /* the dirent, if it exists, now points to a different vnode */ 1180 not_found: 1181 spin_lock(&dentry->d_lock); 1182 dentry->d_flags |= DCACHE_NFSFS_RENAMED; 1183 spin_unlock(&dentry->d_lock); 1184 1185 out_bad_parent: 1186 _debug("dropping dentry %pd2", dentry); 1187 dput(parent); 1188 out_bad: 1189 key_put(key); 1190 1191 _leave(" = 0 [bad]"); 1192 return 0; 1193 } 1194 1195 /* 1196 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't 1197 * sleep) 1198 * - called from dput() when d_count is going to 0. 1199 * - return 1 to request dentry be unhashed, 0 otherwise 1200 */ 1201 static int afs_d_delete(const struct dentry *dentry) 1202 { 1203 _enter("%pd", dentry); 1204 1205 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1206 goto zap; 1207 1208 if (d_really_is_positive(dentry) && 1209 (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) || 1210 test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags))) 1211 goto zap; 1212 1213 _leave(" = 0 [keep]"); 1214 return 0; 1215 1216 zap: 1217 _leave(" = 1 [zap]"); 1218 return 1; 1219 } 1220 1221 /* 1222 * Clean up sillyrename files on dentry removal. 1223 */ 1224 static void afs_d_iput(struct dentry *dentry, struct inode *inode) 1225 { 1226 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1227 afs_silly_iput(dentry, inode); 1228 iput(inode); 1229 } 1230 1231 /* 1232 * handle dentry release 1233 */ 1234 void afs_d_release(struct dentry *dentry) 1235 { 1236 _enter("%pd", dentry); 1237 } 1238 1239 void afs_check_for_remote_deletion(struct afs_operation *op) 1240 { 1241 struct afs_vnode *vnode = op->file[0].vnode; 1242 1243 switch (op->ac.abort_code) { 1244 case VNOVNODE: 1245 set_bit(AFS_VNODE_DELETED, &vnode->flags); 1246 afs_break_callback(vnode, afs_cb_break_for_deleted); 1247 } 1248 } 1249 1250 /* 1251 * Create a new inode for create/mkdir/symlink 1252 */ 1253 static void afs_vnode_new_inode(struct afs_operation *op) 1254 { 1255 struct afs_vnode_param *vp = &op->file[1]; 1256 struct afs_vnode *vnode; 1257 struct inode *inode; 1258 1259 _enter(""); 1260 1261 ASSERTCMP(op->error, ==, 0); 1262 1263 inode = afs_iget(op, vp); 1264 if (IS_ERR(inode)) { 1265 /* ENOMEM or EINTR at a really inconvenient time - just abandon 1266 * the new directory on the server. 1267 */ 1268 op->error = PTR_ERR(inode); 1269 return; 1270 } 1271 1272 vnode = AFS_FS_I(inode); 1273 set_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags); 1274 if (!op->error) 1275 afs_cache_permit(vnode, op->key, vnode->cb_break, &vp->scb); 1276 d_instantiate(op->dentry, inode); 1277 } 1278 1279 static void afs_create_success(struct afs_operation *op) 1280 { 1281 _enter("op=%08x", op->debug_id); 1282 op->ctime = op->file[0].scb.status.mtime_client; 1283 afs_vnode_commit_status(op, &op->file[0]); 1284 afs_update_dentry_version(op, &op->file[0], op->dentry); 1285 afs_vnode_new_inode(op); 1286 } 1287 1288 static void afs_create_edit_dir(struct afs_operation *op) 1289 { 1290 struct afs_vnode_param *dvp = &op->file[0]; 1291 struct afs_vnode_param *vp = &op->file[1]; 1292 struct afs_vnode *dvnode = dvp->vnode; 1293 1294 _enter("op=%08x", op->debug_id); 1295 1296 down_write(&dvnode->validate_lock); 1297 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) && 1298 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta) 1299 afs_edit_dir_add(dvnode, &op->dentry->d_name, &vp->fid, 1300 op->create.reason); 1301 up_write(&dvnode->validate_lock); 1302 } 1303 1304 static void afs_create_put(struct afs_operation *op) 1305 { 1306 _enter("op=%08x", op->debug_id); 1307 1308 if (op->error) 1309 d_drop(op->dentry); 1310 } 1311 1312 static const struct afs_operation_ops afs_mkdir_operation = { 1313 .issue_afs_rpc = afs_fs_make_dir, 1314 .issue_yfs_rpc = yfs_fs_make_dir, 1315 .success = afs_create_success, 1316 .aborted = afs_check_for_remote_deletion, 1317 .edit_dir = afs_create_edit_dir, 1318 .put = afs_create_put, 1319 }; 1320 1321 /* 1322 * create a directory on an AFS filesystem 1323 */ 1324 static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 1325 { 1326 struct afs_operation *op; 1327 struct afs_vnode *dvnode = AFS_FS_I(dir); 1328 1329 _enter("{%llx:%llu},{%pd},%ho", 1330 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode); 1331 1332 op = afs_alloc_operation(NULL, dvnode->volume); 1333 if (IS_ERR(op)) { 1334 d_drop(dentry); 1335 return PTR_ERR(op); 1336 } 1337 1338 afs_op_set_vnode(op, 0, dvnode); 1339 op->file[0].dv_delta = 1; 1340 op->file[0].modification = true; 1341 op->file[0].update_ctime = true; 1342 op->dentry = dentry; 1343 op->create.mode = S_IFDIR | mode; 1344 op->create.reason = afs_edit_dir_for_mkdir; 1345 op->ops = &afs_mkdir_operation; 1346 return afs_do_sync_operation(op); 1347 } 1348 1349 /* 1350 * Remove a subdir from a directory. 1351 */ 1352 static void afs_dir_remove_subdir(struct dentry *dentry) 1353 { 1354 if (d_really_is_positive(dentry)) { 1355 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); 1356 1357 clear_nlink(&vnode->vfs_inode); 1358 set_bit(AFS_VNODE_DELETED, &vnode->flags); 1359 clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags); 1360 clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags); 1361 } 1362 } 1363 1364 static void afs_rmdir_success(struct afs_operation *op) 1365 { 1366 _enter("op=%08x", op->debug_id); 1367 op->ctime = op->file[0].scb.status.mtime_client; 1368 afs_vnode_commit_status(op, &op->file[0]); 1369 afs_update_dentry_version(op, &op->file[0], op->dentry); 1370 } 1371 1372 static void afs_rmdir_edit_dir(struct afs_operation *op) 1373 { 1374 struct afs_vnode_param *dvp = &op->file[0]; 1375 struct afs_vnode *dvnode = dvp->vnode; 1376 1377 _enter("op=%08x", op->debug_id); 1378 afs_dir_remove_subdir(op->dentry); 1379 1380 down_write(&dvnode->validate_lock); 1381 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) && 1382 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta) 1383 afs_edit_dir_remove(dvnode, &op->dentry->d_name, 1384 afs_edit_dir_for_rmdir); 1385 up_write(&dvnode->validate_lock); 1386 } 1387 1388 static void afs_rmdir_put(struct afs_operation *op) 1389 { 1390 _enter("op=%08x", op->debug_id); 1391 if (op->file[1].vnode) 1392 up_write(&op->file[1].vnode->rmdir_lock); 1393 } 1394 1395 static const struct afs_operation_ops afs_rmdir_operation = { 1396 .issue_afs_rpc = afs_fs_remove_dir, 1397 .issue_yfs_rpc = yfs_fs_remove_dir, 1398 .success = afs_rmdir_success, 1399 .aborted = afs_check_for_remote_deletion, 1400 .edit_dir = afs_rmdir_edit_dir, 1401 .put = afs_rmdir_put, 1402 }; 1403 1404 /* 1405 * remove a directory from an AFS filesystem 1406 */ 1407 static int afs_rmdir(struct inode *dir, struct dentry *dentry) 1408 { 1409 struct afs_operation *op; 1410 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode = NULL; 1411 int ret; 1412 1413 _enter("{%llx:%llu},{%pd}", 1414 dvnode->fid.vid, dvnode->fid.vnode, dentry); 1415 1416 op = afs_alloc_operation(NULL, dvnode->volume); 1417 if (IS_ERR(op)) 1418 return PTR_ERR(op); 1419 1420 afs_op_set_vnode(op, 0, dvnode); 1421 op->file[0].dv_delta = 1; 1422 op->file[0].modification = true; 1423 op->file[0].update_ctime = true; 1424 1425 op->dentry = dentry; 1426 op->ops = &afs_rmdir_operation; 1427 1428 /* Try to make sure we have a callback promise on the victim. */ 1429 if (d_really_is_positive(dentry)) { 1430 vnode = AFS_FS_I(d_inode(dentry)); 1431 ret = afs_validate(vnode, op->key); 1432 if (ret < 0) 1433 goto error; 1434 } 1435 1436 if (vnode) { 1437 ret = down_write_killable(&vnode->rmdir_lock); 1438 if (ret < 0) 1439 goto error; 1440 op->file[1].vnode = vnode; 1441 } 1442 1443 return afs_do_sync_operation(op); 1444 1445 error: 1446 return afs_put_operation(op); 1447 } 1448 1449 /* 1450 * Remove a link to a file or symlink from a directory. 1451 * 1452 * If the file was not deleted due to excess hard links, the fileserver will 1453 * break the callback promise on the file - if it had one - before it returns 1454 * to us, and if it was deleted, it won't 1455 * 1456 * However, if we didn't have a callback promise outstanding, or it was 1457 * outstanding on a different server, then it won't break it either... 1458 */ 1459 static void afs_dir_remove_link(struct afs_operation *op) 1460 { 1461 struct afs_vnode *dvnode = op->file[0].vnode; 1462 struct afs_vnode *vnode = op->file[1].vnode; 1463 struct dentry *dentry = op->dentry; 1464 int ret; 1465 1466 if (op->error != 0 || 1467 (op->file[1].scb.have_status && op->file[1].scb.have_error)) 1468 return; 1469 if (d_really_is_positive(dentry)) 1470 return; 1471 1472 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { 1473 /* Already done */ 1474 } else if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) { 1475 write_seqlock(&vnode->cb_lock); 1476 drop_nlink(&vnode->vfs_inode); 1477 if (vnode->vfs_inode.i_nlink == 0) { 1478 set_bit(AFS_VNODE_DELETED, &vnode->flags); 1479 __afs_break_callback(vnode, afs_cb_break_for_unlink); 1480 } 1481 write_sequnlock(&vnode->cb_lock); 1482 } else { 1483 afs_break_callback(vnode, afs_cb_break_for_unlink); 1484 1485 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 1486 _debug("AFS_VNODE_DELETED"); 1487 1488 ret = afs_validate(vnode, op->key); 1489 if (ret != -ESTALE) 1490 op->error = ret; 1491 } 1492 1493 _debug("nlink %d [val %d]", vnode->vfs_inode.i_nlink, op->error); 1494 } 1495 1496 static void afs_unlink_success(struct afs_operation *op) 1497 { 1498 _enter("op=%08x", op->debug_id); 1499 op->ctime = op->file[0].scb.status.mtime_client; 1500 afs_check_dir_conflict(op, &op->file[0]); 1501 afs_vnode_commit_status(op, &op->file[0]); 1502 afs_vnode_commit_status(op, &op->file[1]); 1503 afs_update_dentry_version(op, &op->file[0], op->dentry); 1504 afs_dir_remove_link(op); 1505 } 1506 1507 static void afs_unlink_edit_dir(struct afs_operation *op) 1508 { 1509 struct afs_vnode_param *dvp = &op->file[0]; 1510 struct afs_vnode *dvnode = dvp->vnode; 1511 1512 _enter("op=%08x", op->debug_id); 1513 down_write(&dvnode->validate_lock); 1514 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) && 1515 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta) 1516 afs_edit_dir_remove(dvnode, &op->dentry->d_name, 1517 afs_edit_dir_for_unlink); 1518 up_write(&dvnode->validate_lock); 1519 } 1520 1521 static void afs_unlink_put(struct afs_operation *op) 1522 { 1523 _enter("op=%08x", op->debug_id); 1524 if (op->unlink.need_rehash && op->error < 0 && op->error != -ENOENT) 1525 d_rehash(op->dentry); 1526 } 1527 1528 static const struct afs_operation_ops afs_unlink_operation = { 1529 .issue_afs_rpc = afs_fs_remove_file, 1530 .issue_yfs_rpc = yfs_fs_remove_file, 1531 .success = afs_unlink_success, 1532 .aborted = afs_check_for_remote_deletion, 1533 .edit_dir = afs_unlink_edit_dir, 1534 .put = afs_unlink_put, 1535 }; 1536 1537 /* 1538 * Remove a file or symlink from an AFS filesystem. 1539 */ 1540 static int afs_unlink(struct inode *dir, struct dentry *dentry) 1541 { 1542 struct afs_operation *op; 1543 struct afs_vnode *dvnode = AFS_FS_I(dir); 1544 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); 1545 int ret; 1546 1547 _enter("{%llx:%llu},{%pd}", 1548 dvnode->fid.vid, dvnode->fid.vnode, dentry); 1549 1550 if (dentry->d_name.len >= AFSNAMEMAX) 1551 return -ENAMETOOLONG; 1552 1553 op = afs_alloc_operation(NULL, dvnode->volume); 1554 if (IS_ERR(op)) 1555 return PTR_ERR(op); 1556 1557 afs_op_set_vnode(op, 0, dvnode); 1558 op->file[0].dv_delta = 1; 1559 op->file[0].modification = true; 1560 op->file[0].update_ctime = true; 1561 1562 /* Try to make sure we have a callback promise on the victim. */ 1563 ret = afs_validate(vnode, op->key); 1564 if (ret < 0) { 1565 op->error = ret; 1566 goto error; 1567 } 1568 1569 spin_lock(&dentry->d_lock); 1570 if (d_count(dentry) > 1) { 1571 spin_unlock(&dentry->d_lock); 1572 /* Start asynchronous writeout of the inode */ 1573 write_inode_now(d_inode(dentry), 0); 1574 op->error = afs_sillyrename(dvnode, vnode, dentry, op->key); 1575 goto error; 1576 } 1577 if (!d_unhashed(dentry)) { 1578 /* Prevent a race with RCU lookup. */ 1579 __d_drop(dentry); 1580 op->unlink.need_rehash = true; 1581 } 1582 spin_unlock(&dentry->d_lock); 1583 1584 op->file[1].vnode = vnode; 1585 op->file[1].update_ctime = true; 1586 op->file[1].op_unlinked = true; 1587 op->dentry = dentry; 1588 op->ops = &afs_unlink_operation; 1589 afs_begin_vnode_operation(op); 1590 afs_wait_for_operation(op); 1591 1592 /* If there was a conflict with a third party, check the status of the 1593 * unlinked vnode. 1594 */ 1595 if (op->error == 0 && (op->flags & AFS_OPERATION_DIR_CONFLICT)) { 1596 op->file[1].update_ctime = false; 1597 op->fetch_status.which = 1; 1598 op->ops = &afs_fetch_status_operation; 1599 afs_begin_vnode_operation(op); 1600 afs_wait_for_operation(op); 1601 } 1602 1603 return afs_put_operation(op); 1604 1605 error: 1606 return afs_put_operation(op); 1607 } 1608 1609 static const struct afs_operation_ops afs_create_operation = { 1610 .issue_afs_rpc = afs_fs_create_file, 1611 .issue_yfs_rpc = yfs_fs_create_file, 1612 .success = afs_create_success, 1613 .aborted = afs_check_for_remote_deletion, 1614 .edit_dir = afs_create_edit_dir, 1615 .put = afs_create_put, 1616 }; 1617 1618 /* 1619 * create a regular file on an AFS filesystem 1620 */ 1621 static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode, 1622 bool excl) 1623 { 1624 struct afs_operation *op; 1625 struct afs_vnode *dvnode = AFS_FS_I(dir); 1626 int ret = -ENAMETOOLONG; 1627 1628 _enter("{%llx:%llu},{%pd},%ho", 1629 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode); 1630 1631 if (dentry->d_name.len >= AFSNAMEMAX) 1632 goto error; 1633 1634 op = afs_alloc_operation(NULL, dvnode->volume); 1635 if (IS_ERR(op)) { 1636 ret = PTR_ERR(op); 1637 goto error; 1638 } 1639 1640 afs_op_set_vnode(op, 0, dvnode); 1641 op->file[0].dv_delta = 1; 1642 op->file[0].modification = true; 1643 op->file[0].update_ctime = true; 1644 1645 op->dentry = dentry; 1646 op->create.mode = S_IFREG | mode; 1647 op->create.reason = afs_edit_dir_for_create; 1648 op->ops = &afs_create_operation; 1649 return afs_do_sync_operation(op); 1650 1651 error: 1652 d_drop(dentry); 1653 _leave(" = %d", ret); 1654 return ret; 1655 } 1656 1657 static void afs_link_success(struct afs_operation *op) 1658 { 1659 struct afs_vnode_param *dvp = &op->file[0]; 1660 struct afs_vnode_param *vp = &op->file[1]; 1661 1662 _enter("op=%08x", op->debug_id); 1663 op->ctime = dvp->scb.status.mtime_client; 1664 afs_vnode_commit_status(op, dvp); 1665 afs_vnode_commit_status(op, vp); 1666 afs_update_dentry_version(op, dvp, op->dentry); 1667 if (op->dentry_2->d_parent == op->dentry->d_parent) 1668 afs_update_dentry_version(op, dvp, op->dentry_2); 1669 ihold(&vp->vnode->vfs_inode); 1670 d_instantiate(op->dentry, &vp->vnode->vfs_inode); 1671 } 1672 1673 static void afs_link_put(struct afs_operation *op) 1674 { 1675 _enter("op=%08x", op->debug_id); 1676 if (op->error) 1677 d_drop(op->dentry); 1678 } 1679 1680 static const struct afs_operation_ops afs_link_operation = { 1681 .issue_afs_rpc = afs_fs_link, 1682 .issue_yfs_rpc = yfs_fs_link, 1683 .success = afs_link_success, 1684 .aborted = afs_check_for_remote_deletion, 1685 .edit_dir = afs_create_edit_dir, 1686 .put = afs_link_put, 1687 }; 1688 1689 /* 1690 * create a hard link between files in an AFS filesystem 1691 */ 1692 static int afs_link(struct dentry *from, struct inode *dir, 1693 struct dentry *dentry) 1694 { 1695 struct afs_operation *op; 1696 struct afs_vnode *dvnode = AFS_FS_I(dir); 1697 struct afs_vnode *vnode = AFS_FS_I(d_inode(from)); 1698 int ret = -ENAMETOOLONG; 1699 1700 _enter("{%llx:%llu},{%llx:%llu},{%pd}", 1701 vnode->fid.vid, vnode->fid.vnode, 1702 dvnode->fid.vid, dvnode->fid.vnode, 1703 dentry); 1704 1705 if (dentry->d_name.len >= AFSNAMEMAX) 1706 goto error; 1707 1708 op = afs_alloc_operation(NULL, dvnode->volume); 1709 if (IS_ERR(op)) { 1710 ret = PTR_ERR(op); 1711 goto error; 1712 } 1713 1714 afs_op_set_vnode(op, 0, dvnode); 1715 afs_op_set_vnode(op, 1, vnode); 1716 op->file[0].dv_delta = 1; 1717 op->file[0].modification = true; 1718 op->file[0].update_ctime = true; 1719 op->file[1].update_ctime = true; 1720 1721 op->dentry = dentry; 1722 op->dentry_2 = from; 1723 op->ops = &afs_link_operation; 1724 op->create.reason = afs_edit_dir_for_link; 1725 return afs_do_sync_operation(op); 1726 1727 error: 1728 d_drop(dentry); 1729 _leave(" = %d", ret); 1730 return ret; 1731 } 1732 1733 static const struct afs_operation_ops afs_symlink_operation = { 1734 .issue_afs_rpc = afs_fs_symlink, 1735 .issue_yfs_rpc = yfs_fs_symlink, 1736 .success = afs_create_success, 1737 .aborted = afs_check_for_remote_deletion, 1738 .edit_dir = afs_create_edit_dir, 1739 .put = afs_create_put, 1740 }; 1741 1742 /* 1743 * create a symlink in an AFS filesystem 1744 */ 1745 static int afs_symlink(struct inode *dir, struct dentry *dentry, 1746 const char *content) 1747 { 1748 struct afs_operation *op; 1749 struct afs_vnode *dvnode = AFS_FS_I(dir); 1750 int ret; 1751 1752 _enter("{%llx:%llu},{%pd},%s", 1753 dvnode->fid.vid, dvnode->fid.vnode, dentry, 1754 content); 1755 1756 ret = -ENAMETOOLONG; 1757 if (dentry->d_name.len >= AFSNAMEMAX) 1758 goto error; 1759 1760 ret = -EINVAL; 1761 if (strlen(content) >= AFSPATHMAX) 1762 goto error; 1763 1764 op = afs_alloc_operation(NULL, dvnode->volume); 1765 if (IS_ERR(op)) { 1766 ret = PTR_ERR(op); 1767 goto error; 1768 } 1769 1770 afs_op_set_vnode(op, 0, dvnode); 1771 op->file[0].dv_delta = 1; 1772 1773 op->dentry = dentry; 1774 op->ops = &afs_symlink_operation; 1775 op->create.reason = afs_edit_dir_for_symlink; 1776 op->create.symlink = content; 1777 return afs_do_sync_operation(op); 1778 1779 error: 1780 d_drop(dentry); 1781 _leave(" = %d", ret); 1782 return ret; 1783 } 1784 1785 static void afs_rename_success(struct afs_operation *op) 1786 { 1787 _enter("op=%08x", op->debug_id); 1788 1789 op->ctime = op->file[0].scb.status.mtime_client; 1790 afs_check_dir_conflict(op, &op->file[1]); 1791 afs_vnode_commit_status(op, &op->file[0]); 1792 if (op->file[1].vnode != op->file[0].vnode) { 1793 op->ctime = op->file[1].scb.status.mtime_client; 1794 afs_vnode_commit_status(op, &op->file[1]); 1795 } 1796 } 1797 1798 static void afs_rename_edit_dir(struct afs_operation *op) 1799 { 1800 struct afs_vnode_param *orig_dvp = &op->file[0]; 1801 struct afs_vnode_param *new_dvp = &op->file[1]; 1802 struct afs_vnode *orig_dvnode = orig_dvp->vnode; 1803 struct afs_vnode *new_dvnode = new_dvp->vnode; 1804 struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry)); 1805 struct dentry *old_dentry = op->dentry; 1806 struct dentry *new_dentry = op->dentry_2; 1807 struct inode *new_inode; 1808 1809 _enter("op=%08x", op->debug_id); 1810 1811 if (op->rename.rehash) { 1812 d_rehash(op->rename.rehash); 1813 op->rename.rehash = NULL; 1814 } 1815 1816 down_write(&orig_dvnode->validate_lock); 1817 if (test_bit(AFS_VNODE_DIR_VALID, &orig_dvnode->flags) && 1818 orig_dvnode->status.data_version == orig_dvp->dv_before + orig_dvp->dv_delta) 1819 afs_edit_dir_remove(orig_dvnode, &old_dentry->d_name, 1820 afs_edit_dir_for_rename_0); 1821 1822 if (new_dvnode != orig_dvnode) { 1823 up_write(&orig_dvnode->validate_lock); 1824 down_write(&new_dvnode->validate_lock); 1825 } 1826 1827 if (test_bit(AFS_VNODE_DIR_VALID, &new_dvnode->flags) && 1828 new_dvnode->status.data_version == new_dvp->dv_before + new_dvp->dv_delta) { 1829 if (!op->rename.new_negative) 1830 afs_edit_dir_remove(new_dvnode, &new_dentry->d_name, 1831 afs_edit_dir_for_rename_1); 1832 1833 afs_edit_dir_add(new_dvnode, &new_dentry->d_name, 1834 &vnode->fid, afs_edit_dir_for_rename_2); 1835 } 1836 1837 new_inode = d_inode(new_dentry); 1838 if (new_inode) { 1839 spin_lock(&new_inode->i_lock); 1840 if (new_inode->i_nlink > 0) 1841 drop_nlink(new_inode); 1842 spin_unlock(&new_inode->i_lock); 1843 } 1844 1845 /* Now we can update d_fsdata on the dentries to reflect their 1846 * new parent's data_version. 1847 * 1848 * Note that if we ever implement RENAME_EXCHANGE, we'll have 1849 * to update both dentries with opposing dir versions. 1850 */ 1851 afs_update_dentry_version(op, new_dvp, op->dentry); 1852 afs_update_dentry_version(op, new_dvp, op->dentry_2); 1853 1854 d_move(old_dentry, new_dentry); 1855 1856 up_write(&new_dvnode->validate_lock); 1857 } 1858 1859 static void afs_rename_put(struct afs_operation *op) 1860 { 1861 _enter("op=%08x", op->debug_id); 1862 if (op->rename.rehash) 1863 d_rehash(op->rename.rehash); 1864 dput(op->rename.tmp); 1865 if (op->error) 1866 d_rehash(op->dentry); 1867 } 1868 1869 static const struct afs_operation_ops afs_rename_operation = { 1870 .issue_afs_rpc = afs_fs_rename, 1871 .issue_yfs_rpc = yfs_fs_rename, 1872 .success = afs_rename_success, 1873 .edit_dir = afs_rename_edit_dir, 1874 .put = afs_rename_put, 1875 }; 1876 1877 /* 1878 * rename a file in an AFS filesystem and/or move it between directories 1879 */ 1880 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry, 1881 struct inode *new_dir, struct dentry *new_dentry, 1882 unsigned int flags) 1883 { 1884 struct afs_operation *op; 1885 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode; 1886 int ret; 1887 1888 if (flags) 1889 return -EINVAL; 1890 1891 /* Don't allow silly-rename files be moved around. */ 1892 if (old_dentry->d_flags & DCACHE_NFSFS_RENAMED) 1893 return -EINVAL; 1894 1895 vnode = AFS_FS_I(d_inode(old_dentry)); 1896 orig_dvnode = AFS_FS_I(old_dir); 1897 new_dvnode = AFS_FS_I(new_dir); 1898 1899 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}", 1900 orig_dvnode->fid.vid, orig_dvnode->fid.vnode, 1901 vnode->fid.vid, vnode->fid.vnode, 1902 new_dvnode->fid.vid, new_dvnode->fid.vnode, 1903 new_dentry); 1904 1905 op = afs_alloc_operation(NULL, orig_dvnode->volume); 1906 if (IS_ERR(op)) 1907 return PTR_ERR(op); 1908 1909 afs_op_set_vnode(op, 0, orig_dvnode); 1910 afs_op_set_vnode(op, 1, new_dvnode); /* May be same as orig_dvnode */ 1911 op->file[0].dv_delta = 1; 1912 op->file[1].dv_delta = 1; 1913 op->file[0].modification = true; 1914 op->file[1].modification = true; 1915 op->file[0].update_ctime = true; 1916 op->file[1].update_ctime = true; 1917 1918 op->dentry = old_dentry; 1919 op->dentry_2 = new_dentry; 1920 op->rename.new_negative = d_is_negative(new_dentry); 1921 op->ops = &afs_rename_operation; 1922 1923 /* For non-directories, check whether the target is busy and if so, 1924 * make a copy of the dentry and then do a silly-rename. If the 1925 * silly-rename succeeds, the copied dentry is hashed and becomes the 1926 * new target. 1927 */ 1928 if (d_is_positive(new_dentry) && !d_is_dir(new_dentry)) { 1929 /* To prevent any new references to the target during the 1930 * rename, we unhash the dentry in advance. 1931 */ 1932 if (!d_unhashed(new_dentry)) { 1933 d_drop(new_dentry); 1934 op->rename.rehash = new_dentry; 1935 } 1936 1937 if (d_count(new_dentry) > 2) { 1938 /* copy the target dentry's name */ 1939 ret = -ENOMEM; 1940 op->rename.tmp = d_alloc(new_dentry->d_parent, 1941 &new_dentry->d_name); 1942 if (!op->rename.tmp) 1943 goto error; 1944 1945 ret = afs_sillyrename(new_dvnode, 1946 AFS_FS_I(d_inode(new_dentry)), 1947 new_dentry, op->key); 1948 if (ret) 1949 goto error; 1950 1951 op->dentry_2 = op->rename.tmp; 1952 op->rename.rehash = NULL; 1953 op->rename.new_negative = true; 1954 } 1955 } 1956 1957 /* This bit is potentially nasty as there's a potential race with 1958 * afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry 1959 * to reflect it's new parent's new data_version after the op, but 1960 * d_revalidate may see old_dentry between the op having taken place 1961 * and the version being updated. 1962 * 1963 * So drop the old_dentry for now to make other threads go through 1964 * lookup instead - which we hold a lock against. 1965 */ 1966 d_drop(old_dentry); 1967 1968 return afs_do_sync_operation(op); 1969 1970 error: 1971 return afs_put_operation(op); 1972 } 1973 1974 /* 1975 * Release a directory page and clean up its private state if it's not busy 1976 * - return true if the page can now be released, false if not 1977 */ 1978 static int afs_dir_releasepage(struct page *page, gfp_t gfp_flags) 1979 { 1980 struct afs_vnode *dvnode = AFS_FS_I(page->mapping->host); 1981 1982 _enter("{{%llx:%llu}[%lu]}", dvnode->fid.vid, dvnode->fid.vnode, page->index); 1983 1984 detach_page_private(page); 1985 1986 /* The directory will need reloading. */ 1987 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1988 afs_stat_v(dvnode, n_relpg); 1989 return 1; 1990 } 1991 1992 /* 1993 * invalidate part or all of a page 1994 * - release a page and clean up its private data if offset is 0 (indicating 1995 * the entire page) 1996 */ 1997 static void afs_dir_invalidatepage(struct page *page, unsigned int offset, 1998 unsigned int length) 1999 { 2000 struct afs_vnode *dvnode = AFS_FS_I(page->mapping->host); 2001 2002 _enter("{%lu},%u,%u", page->index, offset, length); 2003 2004 BUG_ON(!PageLocked(page)); 2005 2006 /* The directory will need reloading. */ 2007 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 2008 afs_stat_v(dvnode, n_inval); 2009 2010 /* we clean up only if the entire page is being invalidated */ 2011 if (offset == 0 && length == PAGE_SIZE) 2012 detach_page_private(page); 2013 } 2014