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