1 /* 2 * fs/dcache.c 3 * 4 * Complete reimplementation 5 * (C) 1997 Thomas Schoebel-Theuer, 6 * with heavy changes by Linus Torvalds 7 */ 8 9 /* 10 * Notes on the allocation strategy: 11 * 12 * The dcache is a master of the icache - whenever a dcache entry 13 * exists, the inode will always exist. "iput()" is done either when 14 * the dcache entry is deleted or garbage collected. 15 */ 16 17 #include <linux/syscalls.h> 18 #include <linux/string.h> 19 #include <linux/mm.h> 20 #include <linux/fs.h> 21 #include <linux/fsnotify.h> 22 #include <linux/slab.h> 23 #include <linux/init.h> 24 #include <linux/hash.h> 25 #include <linux/cache.h> 26 #include <linux/module.h> 27 #include <linux/mount.h> 28 #include <linux/file.h> 29 #include <asm/uaccess.h> 30 #include <linux/security.h> 31 #include <linux/seqlock.h> 32 #include <linux/swap.h> 33 #include <linux/bootmem.h> 34 #include <linux/fs_struct.h> 35 #include <linux/hardirq.h> 36 #include <linux/bit_spinlock.h> 37 #include <linux/rculist_bl.h> 38 #include <linux/prefetch.h> 39 #include "internal.h" 40 41 /* 42 * Usage: 43 * dcache->d_inode->i_lock protects: 44 * - i_dentry, d_alias, d_inode of aliases 45 * dcache_hash_bucket lock protects: 46 * - the dcache hash table 47 * s_anon bl list spinlock protects: 48 * - the s_anon list (see __d_drop) 49 * dcache_lru_lock protects: 50 * - the dcache lru lists and counters 51 * d_lock protects: 52 * - d_flags 53 * - d_name 54 * - d_lru 55 * - d_count 56 * - d_unhashed() 57 * - d_parent and d_subdirs 58 * - childrens' d_child and d_parent 59 * - d_alias, d_inode 60 * 61 * Ordering: 62 * dentry->d_inode->i_lock 63 * dentry->d_lock 64 * dcache_lru_lock 65 * dcache_hash_bucket lock 66 * s_anon lock 67 * 68 * If there is an ancestor relationship: 69 * dentry->d_parent->...->d_parent->d_lock 70 * ... 71 * dentry->d_parent->d_lock 72 * dentry->d_lock 73 * 74 * If no ancestor relationship: 75 * if (dentry1 < dentry2) 76 * dentry1->d_lock 77 * dentry2->d_lock 78 */ 79 int sysctl_vfs_cache_pressure __read_mostly = 100; 80 EXPORT_SYMBOL_GPL(sysctl_vfs_cache_pressure); 81 82 static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dcache_lru_lock); 83 __cacheline_aligned_in_smp DEFINE_SEQLOCK(rename_lock); 84 85 EXPORT_SYMBOL(rename_lock); 86 87 static struct kmem_cache *dentry_cache __read_mostly; 88 89 /* 90 * This is the single most critical data structure when it comes 91 * to the dcache: the hashtable for lookups. Somebody should try 92 * to make this good - I've just made it work. 93 * 94 * This hash-function tries to avoid losing too many bits of hash 95 * information, yet avoid using a prime hash-size or similar. 96 */ 97 #define D_HASHBITS d_hash_shift 98 #define D_HASHMASK d_hash_mask 99 100 static unsigned int d_hash_mask __read_mostly; 101 static unsigned int d_hash_shift __read_mostly; 102 103 static struct hlist_bl_head *dentry_hashtable __read_mostly; 104 105 static inline struct hlist_bl_head *d_hash(struct dentry *parent, 106 unsigned long hash) 107 { 108 hash += ((unsigned long) parent ^ GOLDEN_RATIO_PRIME) / L1_CACHE_BYTES; 109 hash = hash ^ ((hash ^ GOLDEN_RATIO_PRIME) >> D_HASHBITS); 110 return dentry_hashtable + (hash & D_HASHMASK); 111 } 112 113 /* Statistics gathering. */ 114 struct dentry_stat_t dentry_stat = { 115 .age_limit = 45, 116 }; 117 118 static DEFINE_PER_CPU(unsigned int, nr_dentry); 119 120 #if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS) 121 static int get_nr_dentry(void) 122 { 123 int i; 124 int sum = 0; 125 for_each_possible_cpu(i) 126 sum += per_cpu(nr_dentry, i); 127 return sum < 0 ? 0 : sum; 128 } 129 130 int proc_nr_dentry(ctl_table *table, int write, void __user *buffer, 131 size_t *lenp, loff_t *ppos) 132 { 133 dentry_stat.nr_dentry = get_nr_dentry(); 134 return proc_dointvec(table, write, buffer, lenp, ppos); 135 } 136 #endif 137 138 static void __d_free(struct rcu_head *head) 139 { 140 struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu); 141 142 WARN_ON(!list_empty(&dentry->d_alias)); 143 if (dname_external(dentry)) 144 kfree(dentry->d_name.name); 145 kmem_cache_free(dentry_cache, dentry); 146 } 147 148 /* 149 * no locks, please. 150 */ 151 static void d_free(struct dentry *dentry) 152 { 153 BUG_ON(dentry->d_count); 154 this_cpu_dec(nr_dentry); 155 if (dentry->d_op && dentry->d_op->d_release) 156 dentry->d_op->d_release(dentry); 157 158 /* if dentry was never visible to RCU, immediate free is OK */ 159 if (!(dentry->d_flags & DCACHE_RCUACCESS)) 160 __d_free(&dentry->d_u.d_rcu); 161 else 162 call_rcu(&dentry->d_u.d_rcu, __d_free); 163 } 164 165 /** 166 * dentry_rcuwalk_barrier - invalidate in-progress rcu-walk lookups 167 * @dentry: the target dentry 168 * After this call, in-progress rcu-walk path lookup will fail. This 169 * should be called after unhashing, and after changing d_inode (if 170 * the dentry has not already been unhashed). 171 */ 172 static inline void dentry_rcuwalk_barrier(struct dentry *dentry) 173 { 174 assert_spin_locked(&dentry->d_lock); 175 /* Go through a barrier */ 176 write_seqcount_barrier(&dentry->d_seq); 177 } 178 179 /* 180 * Release the dentry's inode, using the filesystem 181 * d_iput() operation if defined. Dentry has no refcount 182 * and is unhashed. 183 */ 184 static void dentry_iput(struct dentry * dentry) 185 __releases(dentry->d_lock) 186 __releases(dentry->d_inode->i_lock) 187 { 188 struct inode *inode = dentry->d_inode; 189 if (inode) { 190 dentry->d_inode = NULL; 191 list_del_init(&dentry->d_alias); 192 spin_unlock(&dentry->d_lock); 193 spin_unlock(&inode->i_lock); 194 if (!inode->i_nlink) 195 fsnotify_inoderemove(inode); 196 if (dentry->d_op && dentry->d_op->d_iput) 197 dentry->d_op->d_iput(dentry, inode); 198 else 199 iput(inode); 200 } else { 201 spin_unlock(&dentry->d_lock); 202 } 203 } 204 205 /* 206 * Release the dentry's inode, using the filesystem 207 * d_iput() operation if defined. dentry remains in-use. 208 */ 209 static void dentry_unlink_inode(struct dentry * dentry) 210 __releases(dentry->d_lock) 211 __releases(dentry->d_inode->i_lock) 212 { 213 struct inode *inode = dentry->d_inode; 214 dentry->d_inode = NULL; 215 list_del_init(&dentry->d_alias); 216 dentry_rcuwalk_barrier(dentry); 217 spin_unlock(&dentry->d_lock); 218 spin_unlock(&inode->i_lock); 219 if (!inode->i_nlink) 220 fsnotify_inoderemove(inode); 221 if (dentry->d_op && dentry->d_op->d_iput) 222 dentry->d_op->d_iput(dentry, inode); 223 else 224 iput(inode); 225 } 226 227 /* 228 * dentry_lru_(add|del|move_tail) must be called with d_lock held. 229 */ 230 static void dentry_lru_add(struct dentry *dentry) 231 { 232 if (list_empty(&dentry->d_lru)) { 233 spin_lock(&dcache_lru_lock); 234 list_add(&dentry->d_lru, &dentry->d_sb->s_dentry_lru); 235 dentry->d_sb->s_nr_dentry_unused++; 236 dentry_stat.nr_unused++; 237 spin_unlock(&dcache_lru_lock); 238 } 239 } 240 241 static void __dentry_lru_del(struct dentry *dentry) 242 { 243 list_del_init(&dentry->d_lru); 244 dentry->d_sb->s_nr_dentry_unused--; 245 dentry_stat.nr_unused--; 246 } 247 248 static void dentry_lru_del(struct dentry *dentry) 249 { 250 if (!list_empty(&dentry->d_lru)) { 251 spin_lock(&dcache_lru_lock); 252 __dentry_lru_del(dentry); 253 spin_unlock(&dcache_lru_lock); 254 } 255 } 256 257 static void dentry_lru_move_tail(struct dentry *dentry) 258 { 259 spin_lock(&dcache_lru_lock); 260 if (list_empty(&dentry->d_lru)) { 261 list_add_tail(&dentry->d_lru, &dentry->d_sb->s_dentry_lru); 262 dentry->d_sb->s_nr_dentry_unused++; 263 dentry_stat.nr_unused++; 264 } else { 265 list_move_tail(&dentry->d_lru, &dentry->d_sb->s_dentry_lru); 266 } 267 spin_unlock(&dcache_lru_lock); 268 } 269 270 /** 271 * d_kill - kill dentry and return parent 272 * @dentry: dentry to kill 273 * @parent: parent dentry 274 * 275 * The dentry must already be unhashed and removed from the LRU. 276 * 277 * If this is the root of the dentry tree, return NULL. 278 * 279 * dentry->d_lock and parent->d_lock must be held by caller, and are dropped by 280 * d_kill. 281 */ 282 static struct dentry *d_kill(struct dentry *dentry, struct dentry *parent) 283 __releases(dentry->d_lock) 284 __releases(parent->d_lock) 285 __releases(dentry->d_inode->i_lock) 286 { 287 list_del(&dentry->d_u.d_child); 288 /* 289 * Inform try_to_ascend() that we are no longer attached to the 290 * dentry tree 291 */ 292 dentry->d_flags |= DCACHE_DISCONNECTED; 293 if (parent) 294 spin_unlock(&parent->d_lock); 295 dentry_iput(dentry); 296 /* 297 * dentry_iput drops the locks, at which point nobody (except 298 * transient RCU lookups) can reach this dentry. 299 */ 300 d_free(dentry); 301 return parent; 302 } 303 304 /** 305 * d_drop - drop a dentry 306 * @dentry: dentry to drop 307 * 308 * d_drop() unhashes the entry from the parent dentry hashes, so that it won't 309 * be found through a VFS lookup any more. Note that this is different from 310 * deleting the dentry - d_delete will try to mark the dentry negative if 311 * possible, giving a successful _negative_ lookup, while d_drop will 312 * just make the cache lookup fail. 313 * 314 * d_drop() is used mainly for stuff that wants to invalidate a dentry for some 315 * reason (NFS timeouts or autofs deletes). 316 * 317 * __d_drop requires dentry->d_lock. 318 */ 319 void __d_drop(struct dentry *dentry) 320 { 321 if (!d_unhashed(dentry)) { 322 struct hlist_bl_head *b; 323 if (unlikely(dentry->d_flags & DCACHE_DISCONNECTED)) 324 b = &dentry->d_sb->s_anon; 325 else 326 b = d_hash(dentry->d_parent, dentry->d_name.hash); 327 328 hlist_bl_lock(b); 329 __hlist_bl_del(&dentry->d_hash); 330 dentry->d_hash.pprev = NULL; 331 hlist_bl_unlock(b); 332 333 dentry_rcuwalk_barrier(dentry); 334 } 335 } 336 EXPORT_SYMBOL(__d_drop); 337 338 void d_drop(struct dentry *dentry) 339 { 340 spin_lock(&dentry->d_lock); 341 __d_drop(dentry); 342 spin_unlock(&dentry->d_lock); 343 } 344 EXPORT_SYMBOL(d_drop); 345 346 /* 347 * Finish off a dentry we've decided to kill. 348 * dentry->d_lock must be held, returns with it unlocked. 349 * If ref is non-zero, then decrement the refcount too. 350 * Returns dentry requiring refcount drop, or NULL if we're done. 351 */ 352 static inline struct dentry *dentry_kill(struct dentry *dentry, int ref) 353 __releases(dentry->d_lock) 354 { 355 struct inode *inode; 356 struct dentry *parent; 357 358 inode = dentry->d_inode; 359 if (inode && !spin_trylock(&inode->i_lock)) { 360 relock: 361 spin_unlock(&dentry->d_lock); 362 cpu_relax(); 363 return dentry; /* try again with same dentry */ 364 } 365 if (IS_ROOT(dentry)) 366 parent = NULL; 367 else 368 parent = dentry->d_parent; 369 if (parent && !spin_trylock(&parent->d_lock)) { 370 if (inode) 371 spin_unlock(&inode->i_lock); 372 goto relock; 373 } 374 375 if (ref) 376 dentry->d_count--; 377 /* if dentry was on the d_lru list delete it from there */ 378 dentry_lru_del(dentry); 379 /* if it was on the hash then remove it */ 380 __d_drop(dentry); 381 return d_kill(dentry, parent); 382 } 383 384 /* 385 * This is dput 386 * 387 * This is complicated by the fact that we do not want to put 388 * dentries that are no longer on any hash chain on the unused 389 * list: we'd much rather just get rid of them immediately. 390 * 391 * However, that implies that we have to traverse the dentry 392 * tree upwards to the parents which might _also_ now be 393 * scheduled for deletion (it may have been only waiting for 394 * its last child to go away). 395 * 396 * This tail recursion is done by hand as we don't want to depend 397 * on the compiler to always get this right (gcc generally doesn't). 398 * Real recursion would eat up our stack space. 399 */ 400 401 /* 402 * dput - release a dentry 403 * @dentry: dentry to release 404 * 405 * Release a dentry. This will drop the usage count and if appropriate 406 * call the dentry unlink method as well as removing it from the queues and 407 * releasing its resources. If the parent dentries were scheduled for release 408 * they too may now get deleted. 409 */ 410 void dput(struct dentry *dentry) 411 { 412 if (!dentry) 413 return; 414 415 repeat: 416 if (dentry->d_count == 1) 417 might_sleep(); 418 spin_lock(&dentry->d_lock); 419 BUG_ON(!dentry->d_count); 420 if (dentry->d_count > 1) { 421 dentry->d_count--; 422 spin_unlock(&dentry->d_lock); 423 return; 424 } 425 426 if (dentry->d_flags & DCACHE_OP_DELETE) { 427 if (dentry->d_op->d_delete(dentry)) 428 goto kill_it; 429 } 430 431 /* Unreachable? Get rid of it */ 432 if (d_unhashed(dentry)) 433 goto kill_it; 434 435 /* Otherwise leave it cached and ensure it's on the LRU */ 436 dentry->d_flags |= DCACHE_REFERENCED; 437 dentry_lru_add(dentry); 438 439 dentry->d_count--; 440 spin_unlock(&dentry->d_lock); 441 return; 442 443 kill_it: 444 dentry = dentry_kill(dentry, 1); 445 if (dentry) 446 goto repeat; 447 } 448 EXPORT_SYMBOL(dput); 449 450 /** 451 * d_invalidate - invalidate a dentry 452 * @dentry: dentry to invalidate 453 * 454 * Try to invalidate the dentry if it turns out to be 455 * possible. If there are other dentries that can be 456 * reached through this one we can't delete it and we 457 * return -EBUSY. On success we return 0. 458 * 459 * no dcache lock. 460 */ 461 462 int d_invalidate(struct dentry * dentry) 463 { 464 /* 465 * If it's already been dropped, return OK. 466 */ 467 spin_lock(&dentry->d_lock); 468 if (d_unhashed(dentry)) { 469 spin_unlock(&dentry->d_lock); 470 return 0; 471 } 472 /* 473 * Check whether to do a partial shrink_dcache 474 * to get rid of unused child entries. 475 */ 476 if (!list_empty(&dentry->d_subdirs)) { 477 spin_unlock(&dentry->d_lock); 478 shrink_dcache_parent(dentry); 479 spin_lock(&dentry->d_lock); 480 } 481 482 /* 483 * Somebody else still using it? 484 * 485 * If it's a directory, we can't drop it 486 * for fear of somebody re-populating it 487 * with children (even though dropping it 488 * would make it unreachable from the root, 489 * we might still populate it if it was a 490 * working directory or similar). 491 */ 492 if (dentry->d_count > 1) { 493 if (dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)) { 494 spin_unlock(&dentry->d_lock); 495 return -EBUSY; 496 } 497 } 498 499 __d_drop(dentry); 500 spin_unlock(&dentry->d_lock); 501 return 0; 502 } 503 EXPORT_SYMBOL(d_invalidate); 504 505 /* This must be called with d_lock held */ 506 static inline void __dget_dlock(struct dentry *dentry) 507 { 508 dentry->d_count++; 509 } 510 511 static inline void __dget(struct dentry *dentry) 512 { 513 spin_lock(&dentry->d_lock); 514 __dget_dlock(dentry); 515 spin_unlock(&dentry->d_lock); 516 } 517 518 struct dentry *dget_parent(struct dentry *dentry) 519 { 520 struct dentry *ret; 521 522 repeat: 523 /* 524 * Don't need rcu_dereference because we re-check it was correct under 525 * the lock. 526 */ 527 rcu_read_lock(); 528 ret = dentry->d_parent; 529 if (!ret) { 530 rcu_read_unlock(); 531 goto out; 532 } 533 spin_lock(&ret->d_lock); 534 if (unlikely(ret != dentry->d_parent)) { 535 spin_unlock(&ret->d_lock); 536 rcu_read_unlock(); 537 goto repeat; 538 } 539 rcu_read_unlock(); 540 BUG_ON(!ret->d_count); 541 ret->d_count++; 542 spin_unlock(&ret->d_lock); 543 out: 544 return ret; 545 } 546 EXPORT_SYMBOL(dget_parent); 547 548 /** 549 * d_find_alias - grab a hashed alias of inode 550 * @inode: inode in question 551 * @want_discon: flag, used by d_splice_alias, to request 552 * that only a DISCONNECTED alias be returned. 553 * 554 * If inode has a hashed alias, or is a directory and has any alias, 555 * acquire the reference to alias and return it. Otherwise return NULL. 556 * Notice that if inode is a directory there can be only one alias and 557 * it can be unhashed only if it has no children, or if it is the root 558 * of a filesystem. 559 * 560 * If the inode has an IS_ROOT, DCACHE_DISCONNECTED alias, then prefer 561 * any other hashed alias over that one unless @want_discon is set, 562 * in which case only return an IS_ROOT, DCACHE_DISCONNECTED alias. 563 */ 564 static struct dentry *__d_find_alias(struct inode *inode, int want_discon) 565 { 566 struct dentry *alias, *discon_alias; 567 568 again: 569 discon_alias = NULL; 570 list_for_each_entry(alias, &inode->i_dentry, d_alias) { 571 spin_lock(&alias->d_lock); 572 if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) { 573 if (IS_ROOT(alias) && 574 (alias->d_flags & DCACHE_DISCONNECTED)) { 575 discon_alias = alias; 576 } else if (!want_discon) { 577 __dget_dlock(alias); 578 spin_unlock(&alias->d_lock); 579 return alias; 580 } 581 } 582 spin_unlock(&alias->d_lock); 583 } 584 if (discon_alias) { 585 alias = discon_alias; 586 spin_lock(&alias->d_lock); 587 if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) { 588 if (IS_ROOT(alias) && 589 (alias->d_flags & DCACHE_DISCONNECTED)) { 590 __dget_dlock(alias); 591 spin_unlock(&alias->d_lock); 592 return alias; 593 } 594 } 595 spin_unlock(&alias->d_lock); 596 goto again; 597 } 598 return NULL; 599 } 600 601 struct dentry *d_find_alias(struct inode *inode) 602 { 603 struct dentry *de = NULL; 604 605 if (!list_empty(&inode->i_dentry)) { 606 spin_lock(&inode->i_lock); 607 de = __d_find_alias(inode, 0); 608 spin_unlock(&inode->i_lock); 609 } 610 return de; 611 } 612 EXPORT_SYMBOL(d_find_alias); 613 614 /* 615 * Try to kill dentries associated with this inode. 616 * WARNING: you must own a reference to inode. 617 */ 618 void d_prune_aliases(struct inode *inode) 619 { 620 struct dentry *dentry; 621 restart: 622 spin_lock(&inode->i_lock); 623 list_for_each_entry(dentry, &inode->i_dentry, d_alias) { 624 spin_lock(&dentry->d_lock); 625 if (!dentry->d_count) { 626 __dget_dlock(dentry); 627 __d_drop(dentry); 628 spin_unlock(&dentry->d_lock); 629 spin_unlock(&inode->i_lock); 630 dput(dentry); 631 goto restart; 632 } 633 spin_unlock(&dentry->d_lock); 634 } 635 spin_unlock(&inode->i_lock); 636 } 637 EXPORT_SYMBOL(d_prune_aliases); 638 639 /* 640 * Try to throw away a dentry - free the inode, dput the parent. 641 * Requires dentry->d_lock is held, and dentry->d_count == 0. 642 * Releases dentry->d_lock. 643 * 644 * This may fail if locks cannot be acquired no problem, just try again. 645 */ 646 static void try_prune_one_dentry(struct dentry *dentry) 647 __releases(dentry->d_lock) 648 { 649 struct dentry *parent; 650 651 parent = dentry_kill(dentry, 0); 652 /* 653 * If dentry_kill returns NULL, we have nothing more to do. 654 * if it returns the same dentry, trylocks failed. In either 655 * case, just loop again. 656 * 657 * Otherwise, we need to prune ancestors too. This is necessary 658 * to prevent quadratic behavior of shrink_dcache_parent(), but 659 * is also expected to be beneficial in reducing dentry cache 660 * fragmentation. 661 */ 662 if (!parent) 663 return; 664 if (parent == dentry) 665 return; 666 667 /* Prune ancestors. */ 668 dentry = parent; 669 while (dentry) { 670 spin_lock(&dentry->d_lock); 671 if (dentry->d_count > 1) { 672 dentry->d_count--; 673 spin_unlock(&dentry->d_lock); 674 return; 675 } 676 dentry = dentry_kill(dentry, 1); 677 } 678 } 679 680 static void shrink_dentry_list(struct list_head *list) 681 { 682 struct dentry *dentry; 683 684 rcu_read_lock(); 685 for (;;) { 686 dentry = list_entry_rcu(list->prev, struct dentry, d_lru); 687 if (&dentry->d_lru == list) 688 break; /* empty */ 689 spin_lock(&dentry->d_lock); 690 if (dentry != list_entry(list->prev, struct dentry, d_lru)) { 691 spin_unlock(&dentry->d_lock); 692 continue; 693 } 694 695 /* 696 * We found an inuse dentry which was not removed from 697 * the LRU because of laziness during lookup. Do not free 698 * it - just keep it off the LRU list. 699 */ 700 if (dentry->d_count) { 701 dentry_lru_del(dentry); 702 spin_unlock(&dentry->d_lock); 703 continue; 704 } 705 706 rcu_read_unlock(); 707 708 try_prune_one_dentry(dentry); 709 710 rcu_read_lock(); 711 } 712 rcu_read_unlock(); 713 } 714 715 /** 716 * __shrink_dcache_sb - shrink the dentry LRU on a given superblock 717 * @sb: superblock to shrink dentry LRU. 718 * @count: number of entries to prune 719 * @flags: flags to control the dentry processing 720 * 721 * If flags contains DCACHE_REFERENCED reference dentries will not be pruned. 722 */ 723 static void __shrink_dcache_sb(struct super_block *sb, int *count, int flags) 724 { 725 /* called from prune_dcache() and shrink_dcache_parent() */ 726 struct dentry *dentry; 727 LIST_HEAD(referenced); 728 LIST_HEAD(tmp); 729 int cnt = *count; 730 731 relock: 732 spin_lock(&dcache_lru_lock); 733 while (!list_empty(&sb->s_dentry_lru)) { 734 dentry = list_entry(sb->s_dentry_lru.prev, 735 struct dentry, d_lru); 736 BUG_ON(dentry->d_sb != sb); 737 738 if (!spin_trylock(&dentry->d_lock)) { 739 spin_unlock(&dcache_lru_lock); 740 cpu_relax(); 741 goto relock; 742 } 743 744 /* 745 * If we are honouring the DCACHE_REFERENCED flag and the 746 * dentry has this flag set, don't free it. Clear the flag 747 * and put it back on the LRU. 748 */ 749 if (flags & DCACHE_REFERENCED && 750 dentry->d_flags & DCACHE_REFERENCED) { 751 dentry->d_flags &= ~DCACHE_REFERENCED; 752 list_move(&dentry->d_lru, &referenced); 753 spin_unlock(&dentry->d_lock); 754 } else { 755 list_move_tail(&dentry->d_lru, &tmp); 756 spin_unlock(&dentry->d_lock); 757 if (!--cnt) 758 break; 759 } 760 cond_resched_lock(&dcache_lru_lock); 761 } 762 if (!list_empty(&referenced)) 763 list_splice(&referenced, &sb->s_dentry_lru); 764 spin_unlock(&dcache_lru_lock); 765 766 shrink_dentry_list(&tmp); 767 768 *count = cnt; 769 } 770 771 /** 772 * prune_dcache - shrink the dcache 773 * @count: number of entries to try to free 774 * 775 * Shrink the dcache. This is done when we need more memory, or simply when we 776 * need to unmount something (at which point we need to unuse all dentries). 777 * 778 * This function may fail to free any resources if all the dentries are in use. 779 */ 780 static void prune_dcache(int count) 781 { 782 struct super_block *sb, *p = NULL; 783 int w_count; 784 int unused = dentry_stat.nr_unused; 785 int prune_ratio; 786 int pruned; 787 788 if (unused == 0 || count == 0) 789 return; 790 if (count >= unused) 791 prune_ratio = 1; 792 else 793 prune_ratio = unused / count; 794 spin_lock(&sb_lock); 795 list_for_each_entry(sb, &super_blocks, s_list) { 796 if (list_empty(&sb->s_instances)) 797 continue; 798 if (sb->s_nr_dentry_unused == 0) 799 continue; 800 sb->s_count++; 801 /* Now, we reclaim unused dentrins with fairness. 802 * We reclaim them same percentage from each superblock. 803 * We calculate number of dentries to scan on this sb 804 * as follows, but the implementation is arranged to avoid 805 * overflows: 806 * number of dentries to scan on this sb = 807 * count * (number of dentries on this sb / 808 * number of dentries in the machine) 809 */ 810 spin_unlock(&sb_lock); 811 if (prune_ratio != 1) 812 w_count = (sb->s_nr_dentry_unused / prune_ratio) + 1; 813 else 814 w_count = sb->s_nr_dentry_unused; 815 pruned = w_count; 816 /* 817 * We need to be sure this filesystem isn't being unmounted, 818 * otherwise we could race with generic_shutdown_super(), and 819 * end up holding a reference to an inode while the filesystem 820 * is unmounted. So we try to get s_umount, and make sure 821 * s_root isn't NULL. 822 */ 823 if (down_read_trylock(&sb->s_umount)) { 824 if ((sb->s_root != NULL) && 825 (!list_empty(&sb->s_dentry_lru))) { 826 __shrink_dcache_sb(sb, &w_count, 827 DCACHE_REFERENCED); 828 pruned -= w_count; 829 } 830 up_read(&sb->s_umount); 831 } 832 spin_lock(&sb_lock); 833 if (p) 834 __put_super(p); 835 count -= pruned; 836 p = sb; 837 /* more work left to do? */ 838 if (count <= 0) 839 break; 840 } 841 if (p) 842 __put_super(p); 843 spin_unlock(&sb_lock); 844 } 845 846 /** 847 * shrink_dcache_sb - shrink dcache for a superblock 848 * @sb: superblock 849 * 850 * Shrink the dcache for the specified super block. This is used to free 851 * the dcache before unmounting a file system. 852 */ 853 void shrink_dcache_sb(struct super_block *sb) 854 { 855 LIST_HEAD(tmp); 856 857 spin_lock(&dcache_lru_lock); 858 while (!list_empty(&sb->s_dentry_lru)) { 859 list_splice_init(&sb->s_dentry_lru, &tmp); 860 spin_unlock(&dcache_lru_lock); 861 shrink_dentry_list(&tmp); 862 spin_lock(&dcache_lru_lock); 863 } 864 spin_unlock(&dcache_lru_lock); 865 } 866 EXPORT_SYMBOL(shrink_dcache_sb); 867 868 /* 869 * destroy a single subtree of dentries for unmount 870 * - see the comments on shrink_dcache_for_umount() for a description of the 871 * locking 872 */ 873 static void shrink_dcache_for_umount_subtree(struct dentry *dentry) 874 { 875 struct dentry *parent; 876 unsigned detached = 0; 877 878 BUG_ON(!IS_ROOT(dentry)); 879 880 /* detach this root from the system */ 881 spin_lock(&dentry->d_lock); 882 dentry_lru_del(dentry); 883 __d_drop(dentry); 884 spin_unlock(&dentry->d_lock); 885 886 for (;;) { 887 /* descend to the first leaf in the current subtree */ 888 while (!list_empty(&dentry->d_subdirs)) { 889 struct dentry *loop; 890 891 /* this is a branch with children - detach all of them 892 * from the system in one go */ 893 spin_lock(&dentry->d_lock); 894 list_for_each_entry(loop, &dentry->d_subdirs, 895 d_u.d_child) { 896 spin_lock_nested(&loop->d_lock, 897 DENTRY_D_LOCK_NESTED); 898 dentry_lru_del(loop); 899 __d_drop(loop); 900 spin_unlock(&loop->d_lock); 901 } 902 spin_unlock(&dentry->d_lock); 903 904 /* move to the first child */ 905 dentry = list_entry(dentry->d_subdirs.next, 906 struct dentry, d_u.d_child); 907 } 908 909 /* consume the dentries from this leaf up through its parents 910 * until we find one with children or run out altogether */ 911 do { 912 struct inode *inode; 913 914 if (dentry->d_count != 0) { 915 printk(KERN_ERR 916 "BUG: Dentry %p{i=%lx,n=%s}" 917 " still in use (%d)" 918 " [unmount of %s %s]\n", 919 dentry, 920 dentry->d_inode ? 921 dentry->d_inode->i_ino : 0UL, 922 dentry->d_name.name, 923 dentry->d_count, 924 dentry->d_sb->s_type->name, 925 dentry->d_sb->s_id); 926 BUG(); 927 } 928 929 if (IS_ROOT(dentry)) { 930 parent = NULL; 931 list_del(&dentry->d_u.d_child); 932 } else { 933 parent = dentry->d_parent; 934 spin_lock(&parent->d_lock); 935 parent->d_count--; 936 list_del(&dentry->d_u.d_child); 937 spin_unlock(&parent->d_lock); 938 } 939 940 detached++; 941 942 inode = dentry->d_inode; 943 if (inode) { 944 dentry->d_inode = NULL; 945 list_del_init(&dentry->d_alias); 946 if (dentry->d_op && dentry->d_op->d_iput) 947 dentry->d_op->d_iput(dentry, inode); 948 else 949 iput(inode); 950 } 951 952 d_free(dentry); 953 954 /* finished when we fall off the top of the tree, 955 * otherwise we ascend to the parent and move to the 956 * next sibling if there is one */ 957 if (!parent) 958 return; 959 dentry = parent; 960 } while (list_empty(&dentry->d_subdirs)); 961 962 dentry = list_entry(dentry->d_subdirs.next, 963 struct dentry, d_u.d_child); 964 } 965 } 966 967 /* 968 * destroy the dentries attached to a superblock on unmounting 969 * - we don't need to use dentry->d_lock because: 970 * - the superblock is detached from all mountings and open files, so the 971 * dentry trees will not be rearranged by the VFS 972 * - s_umount is write-locked, so the memory pressure shrinker will ignore 973 * any dentries belonging to this superblock that it comes across 974 * - the filesystem itself is no longer permitted to rearrange the dentries 975 * in this superblock 976 */ 977 void shrink_dcache_for_umount(struct super_block *sb) 978 { 979 struct dentry *dentry; 980 981 if (down_read_trylock(&sb->s_umount)) 982 BUG(); 983 984 dentry = sb->s_root; 985 sb->s_root = NULL; 986 spin_lock(&dentry->d_lock); 987 dentry->d_count--; 988 spin_unlock(&dentry->d_lock); 989 shrink_dcache_for_umount_subtree(dentry); 990 991 while (!hlist_bl_empty(&sb->s_anon)) { 992 dentry = hlist_bl_entry(hlist_bl_first(&sb->s_anon), struct dentry, d_hash); 993 shrink_dcache_for_umount_subtree(dentry); 994 } 995 } 996 997 /* 998 * This tries to ascend one level of parenthood, but 999 * we can race with renaming, so we need to re-check 1000 * the parenthood after dropping the lock and check 1001 * that the sequence number still matches. 1002 */ 1003 static struct dentry *try_to_ascend(struct dentry *old, int locked, unsigned seq) 1004 { 1005 struct dentry *new = old->d_parent; 1006 1007 rcu_read_lock(); 1008 spin_unlock(&old->d_lock); 1009 spin_lock(&new->d_lock); 1010 1011 /* 1012 * might go back up the wrong parent if we have had a rename 1013 * or deletion 1014 */ 1015 if (new != old->d_parent || 1016 (old->d_flags & DCACHE_DISCONNECTED) || 1017 (!locked && read_seqretry(&rename_lock, seq))) { 1018 spin_unlock(&new->d_lock); 1019 new = NULL; 1020 } 1021 rcu_read_unlock(); 1022 return new; 1023 } 1024 1025 1026 /* 1027 * Search for at least 1 mount point in the dentry's subdirs. 1028 * We descend to the next level whenever the d_subdirs 1029 * list is non-empty and continue searching. 1030 */ 1031 1032 /** 1033 * have_submounts - check for mounts over a dentry 1034 * @parent: dentry to check. 1035 * 1036 * Return true if the parent or its subdirectories contain 1037 * a mount point 1038 */ 1039 int have_submounts(struct dentry *parent) 1040 { 1041 struct dentry *this_parent; 1042 struct list_head *next; 1043 unsigned seq; 1044 int locked = 0; 1045 1046 seq = read_seqbegin(&rename_lock); 1047 again: 1048 this_parent = parent; 1049 1050 if (d_mountpoint(parent)) 1051 goto positive; 1052 spin_lock(&this_parent->d_lock); 1053 repeat: 1054 next = this_parent->d_subdirs.next; 1055 resume: 1056 while (next != &this_parent->d_subdirs) { 1057 struct list_head *tmp = next; 1058 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child); 1059 next = tmp->next; 1060 1061 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); 1062 /* Have we found a mount point ? */ 1063 if (d_mountpoint(dentry)) { 1064 spin_unlock(&dentry->d_lock); 1065 spin_unlock(&this_parent->d_lock); 1066 goto positive; 1067 } 1068 if (!list_empty(&dentry->d_subdirs)) { 1069 spin_unlock(&this_parent->d_lock); 1070 spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_); 1071 this_parent = dentry; 1072 spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_); 1073 goto repeat; 1074 } 1075 spin_unlock(&dentry->d_lock); 1076 } 1077 /* 1078 * All done at this level ... ascend and resume the search. 1079 */ 1080 if (this_parent != parent) { 1081 struct dentry *child = this_parent; 1082 this_parent = try_to_ascend(this_parent, locked, seq); 1083 if (!this_parent) 1084 goto rename_retry; 1085 next = child->d_u.d_child.next; 1086 goto resume; 1087 } 1088 spin_unlock(&this_parent->d_lock); 1089 if (!locked && read_seqretry(&rename_lock, seq)) 1090 goto rename_retry; 1091 if (locked) 1092 write_sequnlock(&rename_lock); 1093 return 0; /* No mount points found in tree */ 1094 positive: 1095 if (!locked && read_seqretry(&rename_lock, seq)) 1096 goto rename_retry; 1097 if (locked) 1098 write_sequnlock(&rename_lock); 1099 return 1; 1100 1101 rename_retry: 1102 locked = 1; 1103 write_seqlock(&rename_lock); 1104 goto again; 1105 } 1106 EXPORT_SYMBOL(have_submounts); 1107 1108 /* 1109 * Search the dentry child list for the specified parent, 1110 * and move any unused dentries to the end of the unused 1111 * list for prune_dcache(). We descend to the next level 1112 * whenever the d_subdirs list is non-empty and continue 1113 * searching. 1114 * 1115 * It returns zero iff there are no unused children, 1116 * otherwise it returns the number of children moved to 1117 * the end of the unused list. This may not be the total 1118 * number of unused children, because select_parent can 1119 * drop the lock and return early due to latency 1120 * constraints. 1121 */ 1122 static int select_parent(struct dentry * parent) 1123 { 1124 struct dentry *this_parent; 1125 struct list_head *next; 1126 unsigned seq; 1127 int found = 0; 1128 int locked = 0; 1129 1130 seq = read_seqbegin(&rename_lock); 1131 again: 1132 this_parent = parent; 1133 spin_lock(&this_parent->d_lock); 1134 repeat: 1135 next = this_parent->d_subdirs.next; 1136 resume: 1137 while (next != &this_parent->d_subdirs) { 1138 struct list_head *tmp = next; 1139 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child); 1140 next = tmp->next; 1141 1142 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); 1143 1144 /* 1145 * move only zero ref count dentries to the end 1146 * of the unused list for prune_dcache 1147 */ 1148 if (!dentry->d_count) { 1149 dentry_lru_move_tail(dentry); 1150 found++; 1151 } else { 1152 dentry_lru_del(dentry); 1153 } 1154 1155 /* 1156 * We can return to the caller if we have found some (this 1157 * ensures forward progress). We'll be coming back to find 1158 * the rest. 1159 */ 1160 if (found && need_resched()) { 1161 spin_unlock(&dentry->d_lock); 1162 goto out; 1163 } 1164 1165 /* 1166 * Descend a level if the d_subdirs list is non-empty. 1167 */ 1168 if (!list_empty(&dentry->d_subdirs)) { 1169 spin_unlock(&this_parent->d_lock); 1170 spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_); 1171 this_parent = dentry; 1172 spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_); 1173 goto repeat; 1174 } 1175 1176 spin_unlock(&dentry->d_lock); 1177 } 1178 /* 1179 * All done at this level ... ascend and resume the search. 1180 */ 1181 if (this_parent != parent) { 1182 struct dentry *child = this_parent; 1183 this_parent = try_to_ascend(this_parent, locked, seq); 1184 if (!this_parent) 1185 goto rename_retry; 1186 next = child->d_u.d_child.next; 1187 goto resume; 1188 } 1189 out: 1190 spin_unlock(&this_parent->d_lock); 1191 if (!locked && read_seqretry(&rename_lock, seq)) 1192 goto rename_retry; 1193 if (locked) 1194 write_sequnlock(&rename_lock); 1195 return found; 1196 1197 rename_retry: 1198 if (found) 1199 return found; 1200 locked = 1; 1201 write_seqlock(&rename_lock); 1202 goto again; 1203 } 1204 1205 /** 1206 * shrink_dcache_parent - prune dcache 1207 * @parent: parent of entries to prune 1208 * 1209 * Prune the dcache to remove unused children of the parent dentry. 1210 */ 1211 1212 void shrink_dcache_parent(struct dentry * parent) 1213 { 1214 struct super_block *sb = parent->d_sb; 1215 int found; 1216 1217 while ((found = select_parent(parent)) != 0) 1218 __shrink_dcache_sb(sb, &found, 0); 1219 } 1220 EXPORT_SYMBOL(shrink_dcache_parent); 1221 1222 /* 1223 * Scan `sc->nr_slab_to_reclaim' dentries and return the number which remain. 1224 * 1225 * We need to avoid reentering the filesystem if the caller is performing a 1226 * GFP_NOFS allocation attempt. One example deadlock is: 1227 * 1228 * ext2_new_block->getblk->GFP->shrink_dcache_memory->prune_dcache-> 1229 * prune_one_dentry->dput->dentry_iput->iput->inode->i_sb->s_op->put_inode-> 1230 * ext2_discard_prealloc->ext2_free_blocks->lock_super->DEADLOCK. 1231 * 1232 * In this case we return -1 to tell the caller that we baled. 1233 */ 1234 static int shrink_dcache_memory(struct shrinker *shrink, 1235 struct shrink_control *sc) 1236 { 1237 int nr = sc->nr_to_scan; 1238 gfp_t gfp_mask = sc->gfp_mask; 1239 1240 if (nr) { 1241 if (!(gfp_mask & __GFP_FS)) 1242 return -1; 1243 prune_dcache(nr); 1244 } 1245 1246 return (dentry_stat.nr_unused / 100) * sysctl_vfs_cache_pressure; 1247 } 1248 1249 static struct shrinker dcache_shrinker = { 1250 .shrink = shrink_dcache_memory, 1251 .seeks = DEFAULT_SEEKS, 1252 }; 1253 1254 /** 1255 * d_alloc - allocate a dcache entry 1256 * @parent: parent of entry to allocate 1257 * @name: qstr of the name 1258 * 1259 * Allocates a dentry. It returns %NULL if there is insufficient memory 1260 * available. On a success the dentry is returned. The name passed in is 1261 * copied and the copy passed in may be reused after this call. 1262 */ 1263 1264 struct dentry *d_alloc(struct dentry * parent, const struct qstr *name) 1265 { 1266 struct dentry *dentry; 1267 char *dname; 1268 1269 dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL); 1270 if (!dentry) 1271 return NULL; 1272 1273 if (name->len > DNAME_INLINE_LEN-1) { 1274 dname = kmalloc(name->len + 1, GFP_KERNEL); 1275 if (!dname) { 1276 kmem_cache_free(dentry_cache, dentry); 1277 return NULL; 1278 } 1279 } else { 1280 dname = dentry->d_iname; 1281 } 1282 dentry->d_name.name = dname; 1283 1284 dentry->d_name.len = name->len; 1285 dentry->d_name.hash = name->hash; 1286 memcpy(dname, name->name, name->len); 1287 dname[name->len] = 0; 1288 1289 dentry->d_count = 1; 1290 dentry->d_flags = 0; 1291 spin_lock_init(&dentry->d_lock); 1292 seqcount_init(&dentry->d_seq); 1293 dentry->d_inode = NULL; 1294 dentry->d_parent = NULL; 1295 dentry->d_sb = NULL; 1296 dentry->d_op = NULL; 1297 dentry->d_fsdata = NULL; 1298 INIT_HLIST_BL_NODE(&dentry->d_hash); 1299 INIT_LIST_HEAD(&dentry->d_lru); 1300 INIT_LIST_HEAD(&dentry->d_subdirs); 1301 INIT_LIST_HEAD(&dentry->d_alias); 1302 INIT_LIST_HEAD(&dentry->d_u.d_child); 1303 1304 if (parent) { 1305 spin_lock(&parent->d_lock); 1306 /* 1307 * don't need child lock because it is not subject 1308 * to concurrency here 1309 */ 1310 __dget_dlock(parent); 1311 dentry->d_parent = parent; 1312 dentry->d_sb = parent->d_sb; 1313 d_set_d_op(dentry, dentry->d_sb->s_d_op); 1314 list_add(&dentry->d_u.d_child, &parent->d_subdirs); 1315 spin_unlock(&parent->d_lock); 1316 } 1317 1318 this_cpu_inc(nr_dentry); 1319 1320 return dentry; 1321 } 1322 EXPORT_SYMBOL(d_alloc); 1323 1324 struct dentry *d_alloc_pseudo(struct super_block *sb, const struct qstr *name) 1325 { 1326 struct dentry *dentry = d_alloc(NULL, name); 1327 if (dentry) { 1328 dentry->d_sb = sb; 1329 d_set_d_op(dentry, dentry->d_sb->s_d_op); 1330 dentry->d_parent = dentry; 1331 dentry->d_flags |= DCACHE_DISCONNECTED; 1332 } 1333 return dentry; 1334 } 1335 EXPORT_SYMBOL(d_alloc_pseudo); 1336 1337 struct dentry *d_alloc_name(struct dentry *parent, const char *name) 1338 { 1339 struct qstr q; 1340 1341 q.name = name; 1342 q.len = strlen(name); 1343 q.hash = full_name_hash(q.name, q.len); 1344 return d_alloc(parent, &q); 1345 } 1346 EXPORT_SYMBOL(d_alloc_name); 1347 1348 void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op) 1349 { 1350 WARN_ON_ONCE(dentry->d_op); 1351 WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH | 1352 DCACHE_OP_COMPARE | 1353 DCACHE_OP_REVALIDATE | 1354 DCACHE_OP_DELETE )); 1355 dentry->d_op = op; 1356 if (!op) 1357 return; 1358 if (op->d_hash) 1359 dentry->d_flags |= DCACHE_OP_HASH; 1360 if (op->d_compare) 1361 dentry->d_flags |= DCACHE_OP_COMPARE; 1362 if (op->d_revalidate) 1363 dentry->d_flags |= DCACHE_OP_REVALIDATE; 1364 if (op->d_delete) 1365 dentry->d_flags |= DCACHE_OP_DELETE; 1366 1367 } 1368 EXPORT_SYMBOL(d_set_d_op); 1369 1370 static void __d_instantiate(struct dentry *dentry, struct inode *inode) 1371 { 1372 spin_lock(&dentry->d_lock); 1373 if (inode) { 1374 if (unlikely(IS_AUTOMOUNT(inode))) 1375 dentry->d_flags |= DCACHE_NEED_AUTOMOUNT; 1376 list_add(&dentry->d_alias, &inode->i_dentry); 1377 } 1378 dentry->d_inode = inode; 1379 dentry_rcuwalk_barrier(dentry); 1380 spin_unlock(&dentry->d_lock); 1381 fsnotify_d_instantiate(dentry, inode); 1382 } 1383 1384 /** 1385 * d_instantiate - fill in inode information for a dentry 1386 * @entry: dentry to complete 1387 * @inode: inode to attach to this dentry 1388 * 1389 * Fill in inode information in the entry. 1390 * 1391 * This turns negative dentries into productive full members 1392 * of society. 1393 * 1394 * NOTE! This assumes that the inode count has been incremented 1395 * (or otherwise set) by the caller to indicate that it is now 1396 * in use by the dcache. 1397 */ 1398 1399 void d_instantiate(struct dentry *entry, struct inode * inode) 1400 { 1401 BUG_ON(!list_empty(&entry->d_alias)); 1402 if (inode) 1403 spin_lock(&inode->i_lock); 1404 __d_instantiate(entry, inode); 1405 if (inode) 1406 spin_unlock(&inode->i_lock); 1407 security_d_instantiate(entry, inode); 1408 } 1409 EXPORT_SYMBOL(d_instantiate); 1410 1411 /** 1412 * d_instantiate_unique - instantiate a non-aliased dentry 1413 * @entry: dentry to instantiate 1414 * @inode: inode to attach to this dentry 1415 * 1416 * Fill in inode information in the entry. On success, it returns NULL. 1417 * If an unhashed alias of "entry" already exists, then we return the 1418 * aliased dentry instead and drop one reference to inode. 1419 * 1420 * Note that in order to avoid conflicts with rename() etc, the caller 1421 * had better be holding the parent directory semaphore. 1422 * 1423 * This also assumes that the inode count has been incremented 1424 * (or otherwise set) by the caller to indicate that it is now 1425 * in use by the dcache. 1426 */ 1427 static struct dentry *__d_instantiate_unique(struct dentry *entry, 1428 struct inode *inode) 1429 { 1430 struct dentry *alias; 1431 int len = entry->d_name.len; 1432 const char *name = entry->d_name.name; 1433 unsigned int hash = entry->d_name.hash; 1434 1435 if (!inode) { 1436 __d_instantiate(entry, NULL); 1437 return NULL; 1438 } 1439 1440 list_for_each_entry(alias, &inode->i_dentry, d_alias) { 1441 struct qstr *qstr = &alias->d_name; 1442 1443 /* 1444 * Don't need alias->d_lock here, because aliases with 1445 * d_parent == entry->d_parent are not subject to name or 1446 * parent changes, because the parent inode i_mutex is held. 1447 */ 1448 if (qstr->hash != hash) 1449 continue; 1450 if (alias->d_parent != entry->d_parent) 1451 continue; 1452 if (dentry_cmp(qstr->name, qstr->len, name, len)) 1453 continue; 1454 __dget(alias); 1455 return alias; 1456 } 1457 1458 __d_instantiate(entry, inode); 1459 return NULL; 1460 } 1461 1462 struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode) 1463 { 1464 struct dentry *result; 1465 1466 BUG_ON(!list_empty(&entry->d_alias)); 1467 1468 if (inode) 1469 spin_lock(&inode->i_lock); 1470 result = __d_instantiate_unique(entry, inode); 1471 if (inode) 1472 spin_unlock(&inode->i_lock); 1473 1474 if (!result) { 1475 security_d_instantiate(entry, inode); 1476 return NULL; 1477 } 1478 1479 BUG_ON(!d_unhashed(result)); 1480 iput(inode); 1481 return result; 1482 } 1483 1484 EXPORT_SYMBOL(d_instantiate_unique); 1485 1486 /** 1487 * d_alloc_root - allocate root dentry 1488 * @root_inode: inode to allocate the root for 1489 * 1490 * Allocate a root ("/") dentry for the inode given. The inode is 1491 * instantiated and returned. %NULL is returned if there is insufficient 1492 * memory or the inode passed is %NULL. 1493 */ 1494 1495 struct dentry * d_alloc_root(struct inode * root_inode) 1496 { 1497 struct dentry *res = NULL; 1498 1499 if (root_inode) { 1500 static const struct qstr name = { .name = "/", .len = 1 }; 1501 1502 res = d_alloc(NULL, &name); 1503 if (res) { 1504 res->d_sb = root_inode->i_sb; 1505 d_set_d_op(res, res->d_sb->s_d_op); 1506 res->d_parent = res; 1507 d_instantiate(res, root_inode); 1508 } 1509 } 1510 return res; 1511 } 1512 EXPORT_SYMBOL(d_alloc_root); 1513 1514 static struct dentry * __d_find_any_alias(struct inode *inode) 1515 { 1516 struct dentry *alias; 1517 1518 if (list_empty(&inode->i_dentry)) 1519 return NULL; 1520 alias = list_first_entry(&inode->i_dentry, struct dentry, d_alias); 1521 __dget(alias); 1522 return alias; 1523 } 1524 1525 static struct dentry * d_find_any_alias(struct inode *inode) 1526 { 1527 struct dentry *de; 1528 1529 spin_lock(&inode->i_lock); 1530 de = __d_find_any_alias(inode); 1531 spin_unlock(&inode->i_lock); 1532 return de; 1533 } 1534 1535 1536 /** 1537 * d_obtain_alias - find or allocate a dentry for a given inode 1538 * @inode: inode to allocate the dentry for 1539 * 1540 * Obtain a dentry for an inode resulting from NFS filehandle conversion or 1541 * similar open by handle operations. The returned dentry may be anonymous, 1542 * or may have a full name (if the inode was already in the cache). 1543 * 1544 * When called on a directory inode, we must ensure that the inode only ever 1545 * has one dentry. If a dentry is found, that is returned instead of 1546 * allocating a new one. 1547 * 1548 * On successful return, the reference to the inode has been transferred 1549 * to the dentry. In case of an error the reference on the inode is released. 1550 * To make it easier to use in export operations a %NULL or IS_ERR inode may 1551 * be passed in and will be the error will be propagate to the return value, 1552 * with a %NULL @inode replaced by ERR_PTR(-ESTALE). 1553 */ 1554 struct dentry *d_obtain_alias(struct inode *inode) 1555 { 1556 static const struct qstr anonstring = { .name = "" }; 1557 struct dentry *tmp; 1558 struct dentry *res; 1559 1560 if (!inode) 1561 return ERR_PTR(-ESTALE); 1562 if (IS_ERR(inode)) 1563 return ERR_CAST(inode); 1564 1565 res = d_find_any_alias(inode); 1566 if (res) 1567 goto out_iput; 1568 1569 tmp = d_alloc(NULL, &anonstring); 1570 if (!tmp) { 1571 res = ERR_PTR(-ENOMEM); 1572 goto out_iput; 1573 } 1574 tmp->d_parent = tmp; /* make sure dput doesn't croak */ 1575 1576 1577 spin_lock(&inode->i_lock); 1578 res = __d_find_any_alias(inode); 1579 if (res) { 1580 spin_unlock(&inode->i_lock); 1581 dput(tmp); 1582 goto out_iput; 1583 } 1584 1585 /* attach a disconnected dentry */ 1586 spin_lock(&tmp->d_lock); 1587 tmp->d_sb = inode->i_sb; 1588 d_set_d_op(tmp, tmp->d_sb->s_d_op); 1589 tmp->d_inode = inode; 1590 tmp->d_flags |= DCACHE_DISCONNECTED; 1591 list_add(&tmp->d_alias, &inode->i_dentry); 1592 hlist_bl_lock(&tmp->d_sb->s_anon); 1593 hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon); 1594 hlist_bl_unlock(&tmp->d_sb->s_anon); 1595 spin_unlock(&tmp->d_lock); 1596 spin_unlock(&inode->i_lock); 1597 security_d_instantiate(tmp, inode); 1598 1599 return tmp; 1600 1601 out_iput: 1602 if (res && !IS_ERR(res)) 1603 security_d_instantiate(res, inode); 1604 iput(inode); 1605 return res; 1606 } 1607 EXPORT_SYMBOL(d_obtain_alias); 1608 1609 /** 1610 * d_splice_alias - splice a disconnected dentry into the tree if one exists 1611 * @inode: the inode which may have a disconnected dentry 1612 * @dentry: a negative dentry which we want to point to the inode. 1613 * 1614 * If inode is a directory and has a 'disconnected' dentry (i.e. IS_ROOT and 1615 * DCACHE_DISCONNECTED), then d_move that in place of the given dentry 1616 * and return it, else simply d_add the inode to the dentry and return NULL. 1617 * 1618 * This is needed in the lookup routine of any filesystem that is exportable 1619 * (via knfsd) so that we can build dcache paths to directories effectively. 1620 * 1621 * If a dentry was found and moved, then it is returned. Otherwise NULL 1622 * is returned. This matches the expected return value of ->lookup. 1623 * 1624 */ 1625 struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry) 1626 { 1627 struct dentry *new = NULL; 1628 1629 if (inode && S_ISDIR(inode->i_mode)) { 1630 spin_lock(&inode->i_lock); 1631 new = __d_find_alias(inode, 1); 1632 if (new) { 1633 BUG_ON(!(new->d_flags & DCACHE_DISCONNECTED)); 1634 spin_unlock(&inode->i_lock); 1635 security_d_instantiate(new, inode); 1636 d_move(new, dentry); 1637 iput(inode); 1638 } else { 1639 /* already taking inode->i_lock, so d_add() by hand */ 1640 __d_instantiate(dentry, inode); 1641 spin_unlock(&inode->i_lock); 1642 security_d_instantiate(dentry, inode); 1643 d_rehash(dentry); 1644 } 1645 } else 1646 d_add(dentry, inode); 1647 return new; 1648 } 1649 EXPORT_SYMBOL(d_splice_alias); 1650 1651 /** 1652 * d_add_ci - lookup or allocate new dentry with case-exact name 1653 * @inode: the inode case-insensitive lookup has found 1654 * @dentry: the negative dentry that was passed to the parent's lookup func 1655 * @name: the case-exact name to be associated with the returned dentry 1656 * 1657 * This is to avoid filling the dcache with case-insensitive names to the 1658 * same inode, only the actual correct case is stored in the dcache for 1659 * case-insensitive filesystems. 1660 * 1661 * For a case-insensitive lookup match and if the the case-exact dentry 1662 * already exists in in the dcache, use it and return it. 1663 * 1664 * If no entry exists with the exact case name, allocate new dentry with 1665 * the exact case, and return the spliced entry. 1666 */ 1667 struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode, 1668 struct qstr *name) 1669 { 1670 int error; 1671 struct dentry *found; 1672 struct dentry *new; 1673 1674 /* 1675 * First check if a dentry matching the name already exists, 1676 * if not go ahead and create it now. 1677 */ 1678 found = d_hash_and_lookup(dentry->d_parent, name); 1679 if (!found) { 1680 new = d_alloc(dentry->d_parent, name); 1681 if (!new) { 1682 error = -ENOMEM; 1683 goto err_out; 1684 } 1685 1686 found = d_splice_alias(inode, new); 1687 if (found) { 1688 dput(new); 1689 return found; 1690 } 1691 return new; 1692 } 1693 1694 /* 1695 * If a matching dentry exists, and it's not negative use it. 1696 * 1697 * Decrement the reference count to balance the iget() done 1698 * earlier on. 1699 */ 1700 if (found->d_inode) { 1701 if (unlikely(found->d_inode != inode)) { 1702 /* This can't happen because bad inodes are unhashed. */ 1703 BUG_ON(!is_bad_inode(inode)); 1704 BUG_ON(!is_bad_inode(found->d_inode)); 1705 } 1706 iput(inode); 1707 return found; 1708 } 1709 1710 /* 1711 * Negative dentry: instantiate it unless the inode is a directory and 1712 * already has a dentry. 1713 */ 1714 spin_lock(&inode->i_lock); 1715 if (!S_ISDIR(inode->i_mode) || list_empty(&inode->i_dentry)) { 1716 __d_instantiate(found, inode); 1717 spin_unlock(&inode->i_lock); 1718 security_d_instantiate(found, inode); 1719 return found; 1720 } 1721 1722 /* 1723 * In case a directory already has a (disconnected) entry grab a 1724 * reference to it, move it in place and use it. 1725 */ 1726 new = list_entry(inode->i_dentry.next, struct dentry, d_alias); 1727 __dget(new); 1728 spin_unlock(&inode->i_lock); 1729 security_d_instantiate(found, inode); 1730 d_move(new, found); 1731 iput(inode); 1732 dput(found); 1733 return new; 1734 1735 err_out: 1736 iput(inode); 1737 return ERR_PTR(error); 1738 } 1739 EXPORT_SYMBOL(d_add_ci); 1740 1741 /** 1742 * __d_lookup_rcu - search for a dentry (racy, store-free) 1743 * @parent: parent dentry 1744 * @name: qstr of name we wish to find 1745 * @seq: returns d_seq value at the point where the dentry was found 1746 * @inode: returns dentry->d_inode when the inode was found valid. 1747 * Returns: dentry, or NULL 1748 * 1749 * __d_lookup_rcu is the dcache lookup function for rcu-walk name 1750 * resolution (store-free path walking) design described in 1751 * Documentation/filesystems/path-lookup.txt. 1752 * 1753 * This is not to be used outside core vfs. 1754 * 1755 * __d_lookup_rcu must only be used in rcu-walk mode, ie. with vfsmount lock 1756 * held, and rcu_read_lock held. The returned dentry must not be stored into 1757 * without taking d_lock and checking d_seq sequence count against @seq 1758 * returned here. 1759 * 1760 * A refcount may be taken on the found dentry with the __d_rcu_to_refcount 1761 * function. 1762 * 1763 * Alternatively, __d_lookup_rcu may be called again to look up the child of 1764 * the returned dentry, so long as its parent's seqlock is checked after the 1765 * child is looked up. Thus, an interlocking stepping of sequence lock checks 1766 * is formed, giving integrity down the path walk. 1767 */ 1768 struct dentry *__d_lookup_rcu(struct dentry *parent, struct qstr *name, 1769 unsigned *seq, struct inode **inode) 1770 { 1771 unsigned int len = name->len; 1772 unsigned int hash = name->hash; 1773 const unsigned char *str = name->name; 1774 struct hlist_bl_head *b = d_hash(parent, hash); 1775 struct hlist_bl_node *node; 1776 struct dentry *dentry; 1777 1778 /* 1779 * Note: There is significant duplication with __d_lookup_rcu which is 1780 * required to prevent single threaded performance regressions 1781 * especially on architectures where smp_rmb (in seqcounts) are costly. 1782 * Keep the two functions in sync. 1783 */ 1784 1785 /* 1786 * The hash list is protected using RCU. 1787 * 1788 * Carefully use d_seq when comparing a candidate dentry, to avoid 1789 * races with d_move(). 1790 * 1791 * It is possible that concurrent renames can mess up our list 1792 * walk here and result in missing our dentry, resulting in the 1793 * false-negative result. d_lookup() protects against concurrent 1794 * renames using rename_lock seqlock. 1795 * 1796 * See Documentation/filesystems/path-lookup.txt for more details. 1797 */ 1798 hlist_bl_for_each_entry_rcu(dentry, node, b, d_hash) { 1799 struct inode *i; 1800 const char *tname; 1801 int tlen; 1802 1803 if (dentry->d_name.hash != hash) 1804 continue; 1805 1806 seqretry: 1807 *seq = read_seqcount_begin(&dentry->d_seq); 1808 if (dentry->d_parent != parent) 1809 continue; 1810 if (d_unhashed(dentry)) 1811 continue; 1812 tlen = dentry->d_name.len; 1813 tname = dentry->d_name.name; 1814 i = dentry->d_inode; 1815 prefetch(tname); 1816 if (i) 1817 prefetch(i); 1818 /* 1819 * This seqcount check is required to ensure name and 1820 * len are loaded atomically, so as not to walk off the 1821 * edge of memory when walking. If we could load this 1822 * atomically some other way, we could drop this check. 1823 */ 1824 if (read_seqcount_retry(&dentry->d_seq, *seq)) 1825 goto seqretry; 1826 if (parent->d_flags & DCACHE_OP_COMPARE) { 1827 if (parent->d_op->d_compare(parent, *inode, 1828 dentry, i, 1829 tlen, tname, name)) 1830 continue; 1831 } else { 1832 if (dentry_cmp(tname, tlen, str, len)) 1833 continue; 1834 } 1835 /* 1836 * No extra seqcount check is required after the name 1837 * compare. The caller must perform a seqcount check in 1838 * order to do anything useful with the returned dentry 1839 * anyway. 1840 */ 1841 *inode = i; 1842 return dentry; 1843 } 1844 return NULL; 1845 } 1846 1847 /** 1848 * d_lookup - search for a dentry 1849 * @parent: parent dentry 1850 * @name: qstr of name we wish to find 1851 * Returns: dentry, or NULL 1852 * 1853 * d_lookup searches the children of the parent dentry for the name in 1854 * question. If the dentry is found its reference count is incremented and the 1855 * dentry is returned. The caller must use dput to free the entry when it has 1856 * finished using it. %NULL is returned if the dentry does not exist. 1857 */ 1858 struct dentry *d_lookup(struct dentry *parent, struct qstr *name) 1859 { 1860 struct dentry *dentry; 1861 unsigned seq; 1862 1863 do { 1864 seq = read_seqbegin(&rename_lock); 1865 dentry = __d_lookup(parent, name); 1866 if (dentry) 1867 break; 1868 } while (read_seqretry(&rename_lock, seq)); 1869 return dentry; 1870 } 1871 EXPORT_SYMBOL(d_lookup); 1872 1873 /** 1874 * __d_lookup - search for a dentry (racy) 1875 * @parent: parent dentry 1876 * @name: qstr of name we wish to find 1877 * Returns: dentry, or NULL 1878 * 1879 * __d_lookup is like d_lookup, however it may (rarely) return a 1880 * false-negative result due to unrelated rename activity. 1881 * 1882 * __d_lookup is slightly faster by avoiding rename_lock read seqlock, 1883 * however it must be used carefully, eg. with a following d_lookup in 1884 * the case of failure. 1885 * 1886 * __d_lookup callers must be commented. 1887 */ 1888 struct dentry *__d_lookup(struct dentry *parent, struct qstr *name) 1889 { 1890 unsigned int len = name->len; 1891 unsigned int hash = name->hash; 1892 const unsigned char *str = name->name; 1893 struct hlist_bl_head *b = d_hash(parent, hash); 1894 struct hlist_bl_node *node; 1895 struct dentry *found = NULL; 1896 struct dentry *dentry; 1897 1898 /* 1899 * Note: There is significant duplication with __d_lookup_rcu which is 1900 * required to prevent single threaded performance regressions 1901 * especially on architectures where smp_rmb (in seqcounts) are costly. 1902 * Keep the two functions in sync. 1903 */ 1904 1905 /* 1906 * The hash list is protected using RCU. 1907 * 1908 * Take d_lock when comparing a candidate dentry, to avoid races 1909 * with d_move(). 1910 * 1911 * It is possible that concurrent renames can mess up our list 1912 * walk here and result in missing our dentry, resulting in the 1913 * false-negative result. d_lookup() protects against concurrent 1914 * renames using rename_lock seqlock. 1915 * 1916 * See Documentation/filesystems/path-lookup.txt for more details. 1917 */ 1918 rcu_read_lock(); 1919 1920 hlist_bl_for_each_entry_rcu(dentry, node, b, d_hash) { 1921 const char *tname; 1922 int tlen; 1923 1924 if (dentry->d_name.hash != hash) 1925 continue; 1926 1927 spin_lock(&dentry->d_lock); 1928 if (dentry->d_parent != parent) 1929 goto next; 1930 if (d_unhashed(dentry)) 1931 goto next; 1932 1933 /* 1934 * It is safe to compare names since d_move() cannot 1935 * change the qstr (protected by d_lock). 1936 */ 1937 tlen = dentry->d_name.len; 1938 tname = dentry->d_name.name; 1939 if (parent->d_flags & DCACHE_OP_COMPARE) { 1940 if (parent->d_op->d_compare(parent, parent->d_inode, 1941 dentry, dentry->d_inode, 1942 tlen, tname, name)) 1943 goto next; 1944 } else { 1945 if (dentry_cmp(tname, tlen, str, len)) 1946 goto next; 1947 } 1948 1949 dentry->d_count++; 1950 found = dentry; 1951 spin_unlock(&dentry->d_lock); 1952 break; 1953 next: 1954 spin_unlock(&dentry->d_lock); 1955 } 1956 rcu_read_unlock(); 1957 1958 return found; 1959 } 1960 1961 /** 1962 * d_hash_and_lookup - hash the qstr then search for a dentry 1963 * @dir: Directory to search in 1964 * @name: qstr of name we wish to find 1965 * 1966 * On hash failure or on lookup failure NULL is returned. 1967 */ 1968 struct dentry *d_hash_and_lookup(struct dentry *dir, struct qstr *name) 1969 { 1970 struct dentry *dentry = NULL; 1971 1972 /* 1973 * Check for a fs-specific hash function. Note that we must 1974 * calculate the standard hash first, as the d_op->d_hash() 1975 * routine may choose to leave the hash value unchanged. 1976 */ 1977 name->hash = full_name_hash(name->name, name->len); 1978 if (dir->d_flags & DCACHE_OP_HASH) { 1979 if (dir->d_op->d_hash(dir, dir->d_inode, name) < 0) 1980 goto out; 1981 } 1982 dentry = d_lookup(dir, name); 1983 out: 1984 return dentry; 1985 } 1986 1987 /** 1988 * d_validate - verify dentry provided from insecure source (deprecated) 1989 * @dentry: The dentry alleged to be valid child of @dparent 1990 * @dparent: The parent dentry (known to be valid) 1991 * 1992 * An insecure source has sent us a dentry, here we verify it and dget() it. 1993 * This is used by ncpfs in its readdir implementation. 1994 * Zero is returned in the dentry is invalid. 1995 * 1996 * This function is slow for big directories, and deprecated, do not use it. 1997 */ 1998 int d_validate(struct dentry *dentry, struct dentry *dparent) 1999 { 2000 struct dentry *child; 2001 2002 spin_lock(&dparent->d_lock); 2003 list_for_each_entry(child, &dparent->d_subdirs, d_u.d_child) { 2004 if (dentry == child) { 2005 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); 2006 __dget_dlock(dentry); 2007 spin_unlock(&dentry->d_lock); 2008 spin_unlock(&dparent->d_lock); 2009 return 1; 2010 } 2011 } 2012 spin_unlock(&dparent->d_lock); 2013 2014 return 0; 2015 } 2016 EXPORT_SYMBOL(d_validate); 2017 2018 /* 2019 * When a file is deleted, we have two options: 2020 * - turn this dentry into a negative dentry 2021 * - unhash this dentry and free it. 2022 * 2023 * Usually, we want to just turn this into 2024 * a negative dentry, but if anybody else is 2025 * currently using the dentry or the inode 2026 * we can't do that and we fall back on removing 2027 * it from the hash queues and waiting for 2028 * it to be deleted later when it has no users 2029 */ 2030 2031 /** 2032 * d_delete - delete a dentry 2033 * @dentry: The dentry to delete 2034 * 2035 * Turn the dentry into a negative dentry if possible, otherwise 2036 * remove it from the hash queues so it can be deleted later 2037 */ 2038 2039 void d_delete(struct dentry * dentry) 2040 { 2041 struct inode *inode; 2042 int isdir = 0; 2043 /* 2044 * Are we the only user? 2045 */ 2046 again: 2047 spin_lock(&dentry->d_lock); 2048 inode = dentry->d_inode; 2049 isdir = S_ISDIR(inode->i_mode); 2050 if (dentry->d_count == 1) { 2051 if (inode && !spin_trylock(&inode->i_lock)) { 2052 spin_unlock(&dentry->d_lock); 2053 cpu_relax(); 2054 goto again; 2055 } 2056 dentry->d_flags &= ~DCACHE_CANT_MOUNT; 2057 dentry_unlink_inode(dentry); 2058 fsnotify_nameremove(dentry, isdir); 2059 return; 2060 } 2061 2062 if (!d_unhashed(dentry)) 2063 __d_drop(dentry); 2064 2065 spin_unlock(&dentry->d_lock); 2066 2067 fsnotify_nameremove(dentry, isdir); 2068 } 2069 EXPORT_SYMBOL(d_delete); 2070 2071 static void __d_rehash(struct dentry * entry, struct hlist_bl_head *b) 2072 { 2073 BUG_ON(!d_unhashed(entry)); 2074 hlist_bl_lock(b); 2075 entry->d_flags |= DCACHE_RCUACCESS; 2076 hlist_bl_add_head_rcu(&entry->d_hash, b); 2077 hlist_bl_unlock(b); 2078 } 2079 2080 static void _d_rehash(struct dentry * entry) 2081 { 2082 __d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash)); 2083 } 2084 2085 /** 2086 * d_rehash - add an entry back to the hash 2087 * @entry: dentry to add to the hash 2088 * 2089 * Adds a dentry to the hash according to its name. 2090 */ 2091 2092 void d_rehash(struct dentry * entry) 2093 { 2094 spin_lock(&entry->d_lock); 2095 _d_rehash(entry); 2096 spin_unlock(&entry->d_lock); 2097 } 2098 EXPORT_SYMBOL(d_rehash); 2099 2100 /** 2101 * dentry_update_name_case - update case insensitive dentry with a new name 2102 * @dentry: dentry to be updated 2103 * @name: new name 2104 * 2105 * Update a case insensitive dentry with new case of name. 2106 * 2107 * dentry must have been returned by d_lookup with name @name. Old and new 2108 * name lengths must match (ie. no d_compare which allows mismatched name 2109 * lengths). 2110 * 2111 * Parent inode i_mutex must be held over d_lookup and into this call (to 2112 * keep renames and concurrent inserts, and readdir(2) away). 2113 */ 2114 void dentry_update_name_case(struct dentry *dentry, struct qstr *name) 2115 { 2116 BUG_ON(!mutex_is_locked(&dentry->d_parent->d_inode->i_mutex)); 2117 BUG_ON(dentry->d_name.len != name->len); /* d_lookup gives this */ 2118 2119 spin_lock(&dentry->d_lock); 2120 write_seqcount_begin(&dentry->d_seq); 2121 memcpy((unsigned char *)dentry->d_name.name, name->name, name->len); 2122 write_seqcount_end(&dentry->d_seq); 2123 spin_unlock(&dentry->d_lock); 2124 } 2125 EXPORT_SYMBOL(dentry_update_name_case); 2126 2127 static void switch_names(struct dentry *dentry, struct dentry *target) 2128 { 2129 if (dname_external(target)) { 2130 if (dname_external(dentry)) { 2131 /* 2132 * Both external: swap the pointers 2133 */ 2134 swap(target->d_name.name, dentry->d_name.name); 2135 } else { 2136 /* 2137 * dentry:internal, target:external. Steal target's 2138 * storage and make target internal. 2139 */ 2140 memcpy(target->d_iname, dentry->d_name.name, 2141 dentry->d_name.len + 1); 2142 dentry->d_name.name = target->d_name.name; 2143 target->d_name.name = target->d_iname; 2144 } 2145 } else { 2146 if (dname_external(dentry)) { 2147 /* 2148 * dentry:external, target:internal. Give dentry's 2149 * storage to target and make dentry internal 2150 */ 2151 memcpy(dentry->d_iname, target->d_name.name, 2152 target->d_name.len + 1); 2153 target->d_name.name = dentry->d_name.name; 2154 dentry->d_name.name = dentry->d_iname; 2155 } else { 2156 /* 2157 * Both are internal. Just copy target to dentry 2158 */ 2159 memcpy(dentry->d_iname, target->d_name.name, 2160 target->d_name.len + 1); 2161 dentry->d_name.len = target->d_name.len; 2162 return; 2163 } 2164 } 2165 swap(dentry->d_name.len, target->d_name.len); 2166 } 2167 2168 static void dentry_lock_for_move(struct dentry *dentry, struct dentry *target) 2169 { 2170 /* 2171 * XXXX: do we really need to take target->d_lock? 2172 */ 2173 if (IS_ROOT(dentry) || dentry->d_parent == target->d_parent) 2174 spin_lock(&target->d_parent->d_lock); 2175 else { 2176 if (d_ancestor(dentry->d_parent, target->d_parent)) { 2177 spin_lock(&dentry->d_parent->d_lock); 2178 spin_lock_nested(&target->d_parent->d_lock, 2179 DENTRY_D_LOCK_NESTED); 2180 } else { 2181 spin_lock(&target->d_parent->d_lock); 2182 spin_lock_nested(&dentry->d_parent->d_lock, 2183 DENTRY_D_LOCK_NESTED); 2184 } 2185 } 2186 if (target < dentry) { 2187 spin_lock_nested(&target->d_lock, 2); 2188 spin_lock_nested(&dentry->d_lock, 3); 2189 } else { 2190 spin_lock_nested(&dentry->d_lock, 2); 2191 spin_lock_nested(&target->d_lock, 3); 2192 } 2193 } 2194 2195 static void dentry_unlock_parents_for_move(struct dentry *dentry, 2196 struct dentry *target) 2197 { 2198 if (target->d_parent != dentry->d_parent) 2199 spin_unlock(&dentry->d_parent->d_lock); 2200 if (target->d_parent != target) 2201 spin_unlock(&target->d_parent->d_lock); 2202 } 2203 2204 /* 2205 * When switching names, the actual string doesn't strictly have to 2206 * be preserved in the target - because we're dropping the target 2207 * anyway. As such, we can just do a simple memcpy() to copy over 2208 * the new name before we switch. 2209 * 2210 * Note that we have to be a lot more careful about getting the hash 2211 * switched - we have to switch the hash value properly even if it 2212 * then no longer matches the actual (corrupted) string of the target. 2213 * The hash value has to match the hash queue that the dentry is on.. 2214 */ 2215 /* 2216 * d_move - move a dentry 2217 * @dentry: entry to move 2218 * @target: new dentry 2219 * 2220 * Update the dcache to reflect the move of a file name. Negative 2221 * dcache entries should not be moved in this way. 2222 */ 2223 void d_move(struct dentry * dentry, struct dentry * target) 2224 { 2225 if (!dentry->d_inode) 2226 printk(KERN_WARNING "VFS: moving negative dcache entry\n"); 2227 2228 BUG_ON(d_ancestor(dentry, target)); 2229 BUG_ON(d_ancestor(target, dentry)); 2230 2231 write_seqlock(&rename_lock); 2232 2233 dentry_lock_for_move(dentry, target); 2234 2235 write_seqcount_begin(&dentry->d_seq); 2236 write_seqcount_begin(&target->d_seq); 2237 2238 /* __d_drop does write_seqcount_barrier, but they're OK to nest. */ 2239 2240 /* 2241 * Move the dentry to the target hash queue. Don't bother checking 2242 * for the same hash queue because of how unlikely it is. 2243 */ 2244 __d_drop(dentry); 2245 __d_rehash(dentry, d_hash(target->d_parent, target->d_name.hash)); 2246 2247 /* Unhash the target: dput() will then get rid of it */ 2248 __d_drop(target); 2249 2250 list_del(&dentry->d_u.d_child); 2251 list_del(&target->d_u.d_child); 2252 2253 /* Switch the names.. */ 2254 switch_names(dentry, target); 2255 swap(dentry->d_name.hash, target->d_name.hash); 2256 2257 /* ... and switch the parents */ 2258 if (IS_ROOT(dentry)) { 2259 dentry->d_parent = target->d_parent; 2260 target->d_parent = target; 2261 INIT_LIST_HEAD(&target->d_u.d_child); 2262 } else { 2263 swap(dentry->d_parent, target->d_parent); 2264 2265 /* And add them back to the (new) parent lists */ 2266 list_add(&target->d_u.d_child, &target->d_parent->d_subdirs); 2267 } 2268 2269 list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs); 2270 2271 write_seqcount_end(&target->d_seq); 2272 write_seqcount_end(&dentry->d_seq); 2273 2274 dentry_unlock_parents_for_move(dentry, target); 2275 spin_unlock(&target->d_lock); 2276 fsnotify_d_move(dentry); 2277 spin_unlock(&dentry->d_lock); 2278 write_sequnlock(&rename_lock); 2279 } 2280 EXPORT_SYMBOL(d_move); 2281 2282 /** 2283 * d_ancestor - search for an ancestor 2284 * @p1: ancestor dentry 2285 * @p2: child dentry 2286 * 2287 * Returns the ancestor dentry of p2 which is a child of p1, if p1 is 2288 * an ancestor of p2, else NULL. 2289 */ 2290 struct dentry *d_ancestor(struct dentry *p1, struct dentry *p2) 2291 { 2292 struct dentry *p; 2293 2294 for (p = p2; !IS_ROOT(p); p = p->d_parent) { 2295 if (p->d_parent == p1) 2296 return p; 2297 } 2298 return NULL; 2299 } 2300 2301 /* 2302 * This helper attempts to cope with remotely renamed directories 2303 * 2304 * It assumes that the caller is already holding 2305 * dentry->d_parent->d_inode->i_mutex and the inode->i_lock 2306 * 2307 * Note: If ever the locking in lock_rename() changes, then please 2308 * remember to update this too... 2309 */ 2310 static struct dentry *__d_unalias(struct inode *inode, 2311 struct dentry *dentry, struct dentry *alias) 2312 { 2313 struct mutex *m1 = NULL, *m2 = NULL; 2314 struct dentry *ret; 2315 2316 /* If alias and dentry share a parent, then no extra locks required */ 2317 if (alias->d_parent == dentry->d_parent) 2318 goto out_unalias; 2319 2320 /* Check for loops */ 2321 ret = ERR_PTR(-ELOOP); 2322 if (d_ancestor(alias, dentry)) 2323 goto out_err; 2324 2325 /* See lock_rename() */ 2326 ret = ERR_PTR(-EBUSY); 2327 if (!mutex_trylock(&dentry->d_sb->s_vfs_rename_mutex)) 2328 goto out_err; 2329 m1 = &dentry->d_sb->s_vfs_rename_mutex; 2330 if (!mutex_trylock(&alias->d_parent->d_inode->i_mutex)) 2331 goto out_err; 2332 m2 = &alias->d_parent->d_inode->i_mutex; 2333 out_unalias: 2334 d_move(alias, dentry); 2335 ret = alias; 2336 out_err: 2337 spin_unlock(&inode->i_lock); 2338 if (m2) 2339 mutex_unlock(m2); 2340 if (m1) 2341 mutex_unlock(m1); 2342 return ret; 2343 } 2344 2345 /* 2346 * Prepare an anonymous dentry for life in the superblock's dentry tree as a 2347 * named dentry in place of the dentry to be replaced. 2348 * returns with anon->d_lock held! 2349 */ 2350 static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon) 2351 { 2352 struct dentry *dparent, *aparent; 2353 2354 dentry_lock_for_move(anon, dentry); 2355 2356 write_seqcount_begin(&dentry->d_seq); 2357 write_seqcount_begin(&anon->d_seq); 2358 2359 dparent = dentry->d_parent; 2360 aparent = anon->d_parent; 2361 2362 switch_names(dentry, anon); 2363 swap(dentry->d_name.hash, anon->d_name.hash); 2364 2365 dentry->d_parent = (aparent == anon) ? dentry : aparent; 2366 list_del(&dentry->d_u.d_child); 2367 if (!IS_ROOT(dentry)) 2368 list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs); 2369 else 2370 INIT_LIST_HEAD(&dentry->d_u.d_child); 2371 2372 anon->d_parent = (dparent == dentry) ? anon : dparent; 2373 list_del(&anon->d_u.d_child); 2374 if (!IS_ROOT(anon)) 2375 list_add(&anon->d_u.d_child, &anon->d_parent->d_subdirs); 2376 else 2377 INIT_LIST_HEAD(&anon->d_u.d_child); 2378 2379 write_seqcount_end(&dentry->d_seq); 2380 write_seqcount_end(&anon->d_seq); 2381 2382 dentry_unlock_parents_for_move(anon, dentry); 2383 spin_unlock(&dentry->d_lock); 2384 2385 /* anon->d_lock still locked, returns locked */ 2386 anon->d_flags &= ~DCACHE_DISCONNECTED; 2387 } 2388 2389 /** 2390 * d_materialise_unique - introduce an inode into the tree 2391 * @dentry: candidate dentry 2392 * @inode: inode to bind to the dentry, to which aliases may be attached 2393 * 2394 * Introduces an dentry into the tree, substituting an extant disconnected 2395 * root directory alias in its place if there is one 2396 */ 2397 struct dentry *d_materialise_unique(struct dentry *dentry, struct inode *inode) 2398 { 2399 struct dentry *actual; 2400 2401 BUG_ON(!d_unhashed(dentry)); 2402 2403 if (!inode) { 2404 actual = dentry; 2405 __d_instantiate(dentry, NULL); 2406 d_rehash(actual); 2407 goto out_nolock; 2408 } 2409 2410 spin_lock(&inode->i_lock); 2411 2412 if (S_ISDIR(inode->i_mode)) { 2413 struct dentry *alias; 2414 2415 /* Does an aliased dentry already exist? */ 2416 alias = __d_find_alias(inode, 0); 2417 if (alias) { 2418 actual = alias; 2419 /* Is this an anonymous mountpoint that we could splice 2420 * into our tree? */ 2421 if (IS_ROOT(alias)) { 2422 __d_materialise_dentry(dentry, alias); 2423 __d_drop(alias); 2424 goto found; 2425 } 2426 /* Nope, but we must(!) avoid directory aliasing */ 2427 actual = __d_unalias(inode, dentry, alias); 2428 if (IS_ERR(actual)) 2429 dput(alias); 2430 goto out_nolock; 2431 } 2432 } 2433 2434 /* Add a unique reference */ 2435 actual = __d_instantiate_unique(dentry, inode); 2436 if (!actual) 2437 actual = dentry; 2438 else 2439 BUG_ON(!d_unhashed(actual)); 2440 2441 spin_lock(&actual->d_lock); 2442 found: 2443 _d_rehash(actual); 2444 spin_unlock(&actual->d_lock); 2445 spin_unlock(&inode->i_lock); 2446 out_nolock: 2447 if (actual == dentry) { 2448 security_d_instantiate(dentry, inode); 2449 return NULL; 2450 } 2451 2452 iput(inode); 2453 return actual; 2454 } 2455 EXPORT_SYMBOL_GPL(d_materialise_unique); 2456 2457 static int prepend(char **buffer, int *buflen, const char *str, int namelen) 2458 { 2459 *buflen -= namelen; 2460 if (*buflen < 0) 2461 return -ENAMETOOLONG; 2462 *buffer -= namelen; 2463 memcpy(*buffer, str, namelen); 2464 return 0; 2465 } 2466 2467 static int prepend_name(char **buffer, int *buflen, struct qstr *name) 2468 { 2469 return prepend(buffer, buflen, name->name, name->len); 2470 } 2471 2472 /** 2473 * prepend_path - Prepend path string to a buffer 2474 * @path: the dentry/vfsmount to report 2475 * @root: root vfsmnt/dentry (may be modified by this function) 2476 * @buffer: pointer to the end of the buffer 2477 * @buflen: pointer to buffer length 2478 * 2479 * Caller holds the rename_lock. 2480 * 2481 * If path is not reachable from the supplied root, then the value of 2482 * root is changed (without modifying refcounts). 2483 */ 2484 static int prepend_path(const struct path *path, struct path *root, 2485 char **buffer, int *buflen) 2486 { 2487 struct dentry *dentry = path->dentry; 2488 struct vfsmount *vfsmnt = path->mnt; 2489 bool slash = false; 2490 int error = 0; 2491 2492 br_read_lock(vfsmount_lock); 2493 while (dentry != root->dentry || vfsmnt != root->mnt) { 2494 struct dentry * parent; 2495 2496 if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) { 2497 /* Global root? */ 2498 if (vfsmnt->mnt_parent == vfsmnt) { 2499 goto global_root; 2500 } 2501 dentry = vfsmnt->mnt_mountpoint; 2502 vfsmnt = vfsmnt->mnt_parent; 2503 continue; 2504 } 2505 parent = dentry->d_parent; 2506 prefetch(parent); 2507 spin_lock(&dentry->d_lock); 2508 error = prepend_name(buffer, buflen, &dentry->d_name); 2509 spin_unlock(&dentry->d_lock); 2510 if (!error) 2511 error = prepend(buffer, buflen, "/", 1); 2512 if (error) 2513 break; 2514 2515 slash = true; 2516 dentry = parent; 2517 } 2518 2519 out: 2520 if (!error && !slash) 2521 error = prepend(buffer, buflen, "/", 1); 2522 2523 br_read_unlock(vfsmount_lock); 2524 return error; 2525 2526 global_root: 2527 /* 2528 * Filesystems needing to implement special "root names" 2529 * should do so with ->d_dname() 2530 */ 2531 if (IS_ROOT(dentry) && 2532 (dentry->d_name.len != 1 || dentry->d_name.name[0] != '/')) { 2533 WARN(1, "Root dentry has weird name <%.*s>\n", 2534 (int) dentry->d_name.len, dentry->d_name.name); 2535 } 2536 root->mnt = vfsmnt; 2537 root->dentry = dentry; 2538 goto out; 2539 } 2540 2541 /** 2542 * __d_path - return the path of a dentry 2543 * @path: the dentry/vfsmount to report 2544 * @root: root vfsmnt/dentry (may be modified by this function) 2545 * @buf: buffer to return value in 2546 * @buflen: buffer length 2547 * 2548 * Convert a dentry into an ASCII path name. 2549 * 2550 * Returns a pointer into the buffer or an error code if the 2551 * path was too long. 2552 * 2553 * "buflen" should be positive. 2554 * 2555 * If path is not reachable from the supplied root, then the value of 2556 * root is changed (without modifying refcounts). 2557 */ 2558 char *__d_path(const struct path *path, struct path *root, 2559 char *buf, int buflen) 2560 { 2561 char *res = buf + buflen; 2562 int error; 2563 2564 prepend(&res, &buflen, "\0", 1); 2565 write_seqlock(&rename_lock); 2566 error = prepend_path(path, root, &res, &buflen); 2567 write_sequnlock(&rename_lock); 2568 2569 if (error) 2570 return ERR_PTR(error); 2571 return res; 2572 } 2573 2574 /* 2575 * same as __d_path but appends "(deleted)" for unlinked files. 2576 */ 2577 static int path_with_deleted(const struct path *path, struct path *root, 2578 char **buf, int *buflen) 2579 { 2580 prepend(buf, buflen, "\0", 1); 2581 if (d_unlinked(path->dentry)) { 2582 int error = prepend(buf, buflen, " (deleted)", 10); 2583 if (error) 2584 return error; 2585 } 2586 2587 return prepend_path(path, root, buf, buflen); 2588 } 2589 2590 static int prepend_unreachable(char **buffer, int *buflen) 2591 { 2592 return prepend(buffer, buflen, "(unreachable)", 13); 2593 } 2594 2595 /** 2596 * d_path - return the path of a dentry 2597 * @path: path to report 2598 * @buf: buffer to return value in 2599 * @buflen: buffer length 2600 * 2601 * Convert a dentry into an ASCII path name. If the entry has been deleted 2602 * the string " (deleted)" is appended. Note that this is ambiguous. 2603 * 2604 * Returns a pointer into the buffer or an error code if the path was 2605 * too long. Note: Callers should use the returned pointer, not the passed 2606 * in buffer, to use the name! The implementation often starts at an offset 2607 * into the buffer, and may leave 0 bytes at the start. 2608 * 2609 * "buflen" should be positive. 2610 */ 2611 char *d_path(const struct path *path, char *buf, int buflen) 2612 { 2613 char *res = buf + buflen; 2614 struct path root; 2615 struct path tmp; 2616 int error; 2617 2618 /* 2619 * We have various synthetic filesystems that never get mounted. On 2620 * these filesystems dentries are never used for lookup purposes, and 2621 * thus don't need to be hashed. They also don't need a name until a 2622 * user wants to identify the object in /proc/pid/fd/. The little hack 2623 * below allows us to generate a name for these objects on demand: 2624 */ 2625 if (path->dentry->d_op && path->dentry->d_op->d_dname) 2626 return path->dentry->d_op->d_dname(path->dentry, buf, buflen); 2627 2628 get_fs_root(current->fs, &root); 2629 write_seqlock(&rename_lock); 2630 tmp = root; 2631 error = path_with_deleted(path, &tmp, &res, &buflen); 2632 if (error) 2633 res = ERR_PTR(error); 2634 write_sequnlock(&rename_lock); 2635 path_put(&root); 2636 return res; 2637 } 2638 EXPORT_SYMBOL(d_path); 2639 2640 /** 2641 * d_path_with_unreachable - return the path of a dentry 2642 * @path: path to report 2643 * @buf: buffer to return value in 2644 * @buflen: buffer length 2645 * 2646 * The difference from d_path() is that this prepends "(unreachable)" 2647 * to paths which are unreachable from the current process' root. 2648 */ 2649 char *d_path_with_unreachable(const struct path *path, char *buf, int buflen) 2650 { 2651 char *res = buf + buflen; 2652 struct path root; 2653 struct path tmp; 2654 int error; 2655 2656 if (path->dentry->d_op && path->dentry->d_op->d_dname) 2657 return path->dentry->d_op->d_dname(path->dentry, buf, buflen); 2658 2659 get_fs_root(current->fs, &root); 2660 write_seqlock(&rename_lock); 2661 tmp = root; 2662 error = path_with_deleted(path, &tmp, &res, &buflen); 2663 if (!error && !path_equal(&tmp, &root)) 2664 error = prepend_unreachable(&res, &buflen); 2665 write_sequnlock(&rename_lock); 2666 path_put(&root); 2667 if (error) 2668 res = ERR_PTR(error); 2669 2670 return res; 2671 } 2672 2673 /* 2674 * Helper function for dentry_operations.d_dname() members 2675 */ 2676 char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen, 2677 const char *fmt, ...) 2678 { 2679 va_list args; 2680 char temp[64]; 2681 int sz; 2682 2683 va_start(args, fmt); 2684 sz = vsnprintf(temp, sizeof(temp), fmt, args) + 1; 2685 va_end(args); 2686 2687 if (sz > sizeof(temp) || sz > buflen) 2688 return ERR_PTR(-ENAMETOOLONG); 2689 2690 buffer += buflen - sz; 2691 return memcpy(buffer, temp, sz); 2692 } 2693 2694 /* 2695 * Write full pathname from the root of the filesystem into the buffer. 2696 */ 2697 static char *__dentry_path(struct dentry *dentry, char *buf, int buflen) 2698 { 2699 char *end = buf + buflen; 2700 char *retval; 2701 2702 prepend(&end, &buflen, "\0", 1); 2703 if (buflen < 1) 2704 goto Elong; 2705 /* Get '/' right */ 2706 retval = end-1; 2707 *retval = '/'; 2708 2709 while (!IS_ROOT(dentry)) { 2710 struct dentry *parent = dentry->d_parent; 2711 int error; 2712 2713 prefetch(parent); 2714 spin_lock(&dentry->d_lock); 2715 error = prepend_name(&end, &buflen, &dentry->d_name); 2716 spin_unlock(&dentry->d_lock); 2717 if (error != 0 || prepend(&end, &buflen, "/", 1) != 0) 2718 goto Elong; 2719 2720 retval = end; 2721 dentry = parent; 2722 } 2723 return retval; 2724 Elong: 2725 return ERR_PTR(-ENAMETOOLONG); 2726 } 2727 2728 char *dentry_path_raw(struct dentry *dentry, char *buf, int buflen) 2729 { 2730 char *retval; 2731 2732 write_seqlock(&rename_lock); 2733 retval = __dentry_path(dentry, buf, buflen); 2734 write_sequnlock(&rename_lock); 2735 2736 return retval; 2737 } 2738 EXPORT_SYMBOL(dentry_path_raw); 2739 2740 char *dentry_path(struct dentry *dentry, char *buf, int buflen) 2741 { 2742 char *p = NULL; 2743 char *retval; 2744 2745 write_seqlock(&rename_lock); 2746 if (d_unlinked(dentry)) { 2747 p = buf + buflen; 2748 if (prepend(&p, &buflen, "//deleted", 10) != 0) 2749 goto Elong; 2750 buflen++; 2751 } 2752 retval = __dentry_path(dentry, buf, buflen); 2753 write_sequnlock(&rename_lock); 2754 if (!IS_ERR(retval) && p) 2755 *p = '/'; /* restore '/' overriden with '\0' */ 2756 return retval; 2757 Elong: 2758 return ERR_PTR(-ENAMETOOLONG); 2759 } 2760 2761 /* 2762 * NOTE! The user-level library version returns a 2763 * character pointer. The kernel system call just 2764 * returns the length of the buffer filled (which 2765 * includes the ending '\0' character), or a negative 2766 * error value. So libc would do something like 2767 * 2768 * char *getcwd(char * buf, size_t size) 2769 * { 2770 * int retval; 2771 * 2772 * retval = sys_getcwd(buf, size); 2773 * if (retval >= 0) 2774 * return buf; 2775 * errno = -retval; 2776 * return NULL; 2777 * } 2778 */ 2779 SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size) 2780 { 2781 int error; 2782 struct path pwd, root; 2783 char *page = (char *) __get_free_page(GFP_USER); 2784 2785 if (!page) 2786 return -ENOMEM; 2787 2788 get_fs_root_and_pwd(current->fs, &root, &pwd); 2789 2790 error = -ENOENT; 2791 write_seqlock(&rename_lock); 2792 if (!d_unlinked(pwd.dentry)) { 2793 unsigned long len; 2794 struct path tmp = root; 2795 char *cwd = page + PAGE_SIZE; 2796 int buflen = PAGE_SIZE; 2797 2798 prepend(&cwd, &buflen, "\0", 1); 2799 error = prepend_path(&pwd, &tmp, &cwd, &buflen); 2800 write_sequnlock(&rename_lock); 2801 2802 if (error) 2803 goto out; 2804 2805 /* Unreachable from current root */ 2806 if (!path_equal(&tmp, &root)) { 2807 error = prepend_unreachable(&cwd, &buflen); 2808 if (error) 2809 goto out; 2810 } 2811 2812 error = -ERANGE; 2813 len = PAGE_SIZE + page - cwd; 2814 if (len <= size) { 2815 error = len; 2816 if (copy_to_user(buf, cwd, len)) 2817 error = -EFAULT; 2818 } 2819 } else { 2820 write_sequnlock(&rename_lock); 2821 } 2822 2823 out: 2824 path_put(&pwd); 2825 path_put(&root); 2826 free_page((unsigned long) page); 2827 return error; 2828 } 2829 2830 /* 2831 * Test whether new_dentry is a subdirectory of old_dentry. 2832 * 2833 * Trivially implemented using the dcache structure 2834 */ 2835 2836 /** 2837 * is_subdir - is new dentry a subdirectory of old_dentry 2838 * @new_dentry: new dentry 2839 * @old_dentry: old dentry 2840 * 2841 * Returns 1 if new_dentry is a subdirectory of the parent (at any depth). 2842 * Returns 0 otherwise. 2843 * Caller must ensure that "new_dentry" is pinned before calling is_subdir() 2844 */ 2845 2846 int is_subdir(struct dentry *new_dentry, struct dentry *old_dentry) 2847 { 2848 int result; 2849 unsigned seq; 2850 2851 if (new_dentry == old_dentry) 2852 return 1; 2853 2854 do { 2855 /* for restarting inner loop in case of seq retry */ 2856 seq = read_seqbegin(&rename_lock); 2857 /* 2858 * Need rcu_readlock to protect against the d_parent trashing 2859 * due to d_move 2860 */ 2861 rcu_read_lock(); 2862 if (d_ancestor(old_dentry, new_dentry)) 2863 result = 1; 2864 else 2865 result = 0; 2866 rcu_read_unlock(); 2867 } while (read_seqretry(&rename_lock, seq)); 2868 2869 return result; 2870 } 2871 2872 int path_is_under(struct path *path1, struct path *path2) 2873 { 2874 struct vfsmount *mnt = path1->mnt; 2875 struct dentry *dentry = path1->dentry; 2876 int res; 2877 2878 br_read_lock(vfsmount_lock); 2879 if (mnt != path2->mnt) { 2880 for (;;) { 2881 if (mnt->mnt_parent == mnt) { 2882 br_read_unlock(vfsmount_lock); 2883 return 0; 2884 } 2885 if (mnt->mnt_parent == path2->mnt) 2886 break; 2887 mnt = mnt->mnt_parent; 2888 } 2889 dentry = mnt->mnt_mountpoint; 2890 } 2891 res = is_subdir(dentry, path2->dentry); 2892 br_read_unlock(vfsmount_lock); 2893 return res; 2894 } 2895 EXPORT_SYMBOL(path_is_under); 2896 2897 void d_genocide(struct dentry *root) 2898 { 2899 struct dentry *this_parent; 2900 struct list_head *next; 2901 unsigned seq; 2902 int locked = 0; 2903 2904 seq = read_seqbegin(&rename_lock); 2905 again: 2906 this_parent = root; 2907 spin_lock(&this_parent->d_lock); 2908 repeat: 2909 next = this_parent->d_subdirs.next; 2910 resume: 2911 while (next != &this_parent->d_subdirs) { 2912 struct list_head *tmp = next; 2913 struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child); 2914 next = tmp->next; 2915 2916 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); 2917 if (d_unhashed(dentry) || !dentry->d_inode) { 2918 spin_unlock(&dentry->d_lock); 2919 continue; 2920 } 2921 if (!list_empty(&dentry->d_subdirs)) { 2922 spin_unlock(&this_parent->d_lock); 2923 spin_release(&dentry->d_lock.dep_map, 1, _RET_IP_); 2924 this_parent = dentry; 2925 spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_); 2926 goto repeat; 2927 } 2928 if (!(dentry->d_flags & DCACHE_GENOCIDE)) { 2929 dentry->d_flags |= DCACHE_GENOCIDE; 2930 dentry->d_count--; 2931 } 2932 spin_unlock(&dentry->d_lock); 2933 } 2934 if (this_parent != root) { 2935 struct dentry *child = this_parent; 2936 if (!(this_parent->d_flags & DCACHE_GENOCIDE)) { 2937 this_parent->d_flags |= DCACHE_GENOCIDE; 2938 this_parent->d_count--; 2939 } 2940 this_parent = try_to_ascend(this_parent, locked, seq); 2941 if (!this_parent) 2942 goto rename_retry; 2943 next = child->d_u.d_child.next; 2944 goto resume; 2945 } 2946 spin_unlock(&this_parent->d_lock); 2947 if (!locked && read_seqretry(&rename_lock, seq)) 2948 goto rename_retry; 2949 if (locked) 2950 write_sequnlock(&rename_lock); 2951 return; 2952 2953 rename_retry: 2954 locked = 1; 2955 write_seqlock(&rename_lock); 2956 goto again; 2957 } 2958 2959 /** 2960 * find_inode_number - check for dentry with name 2961 * @dir: directory to check 2962 * @name: Name to find. 2963 * 2964 * Check whether a dentry already exists for the given name, 2965 * and return the inode number if it has an inode. Otherwise 2966 * 0 is returned. 2967 * 2968 * This routine is used to post-process directory listings for 2969 * filesystems using synthetic inode numbers, and is necessary 2970 * to keep getcwd() working. 2971 */ 2972 2973 ino_t find_inode_number(struct dentry *dir, struct qstr *name) 2974 { 2975 struct dentry * dentry; 2976 ino_t ino = 0; 2977 2978 dentry = d_hash_and_lookup(dir, name); 2979 if (dentry) { 2980 if (dentry->d_inode) 2981 ino = dentry->d_inode->i_ino; 2982 dput(dentry); 2983 } 2984 return ino; 2985 } 2986 EXPORT_SYMBOL(find_inode_number); 2987 2988 static __initdata unsigned long dhash_entries; 2989 static int __init set_dhash_entries(char *str) 2990 { 2991 if (!str) 2992 return 0; 2993 dhash_entries = simple_strtoul(str, &str, 0); 2994 return 1; 2995 } 2996 __setup("dhash_entries=", set_dhash_entries); 2997 2998 static void __init dcache_init_early(void) 2999 { 3000 int loop; 3001 3002 /* If hashes are distributed across NUMA nodes, defer 3003 * hash allocation until vmalloc space is available. 3004 */ 3005 if (hashdist) 3006 return; 3007 3008 dentry_hashtable = 3009 alloc_large_system_hash("Dentry cache", 3010 sizeof(struct hlist_bl_head), 3011 dhash_entries, 3012 13, 3013 HASH_EARLY, 3014 &d_hash_shift, 3015 &d_hash_mask, 3016 0); 3017 3018 for (loop = 0; loop < (1 << d_hash_shift); loop++) 3019 INIT_HLIST_BL_HEAD(dentry_hashtable + loop); 3020 } 3021 3022 static void __init dcache_init(void) 3023 { 3024 int loop; 3025 3026 /* 3027 * A constructor could be added for stable state like the lists, 3028 * but it is probably not worth it because of the cache nature 3029 * of the dcache. 3030 */ 3031 dentry_cache = KMEM_CACHE(dentry, 3032 SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD); 3033 3034 register_shrinker(&dcache_shrinker); 3035 3036 /* Hash may have been set up in dcache_init_early */ 3037 if (!hashdist) 3038 return; 3039 3040 dentry_hashtable = 3041 alloc_large_system_hash("Dentry cache", 3042 sizeof(struct hlist_bl_head), 3043 dhash_entries, 3044 13, 3045 0, 3046 &d_hash_shift, 3047 &d_hash_mask, 3048 0); 3049 3050 for (loop = 0; loop < (1 << d_hash_shift); loop++) 3051 INIT_HLIST_BL_HEAD(dentry_hashtable + loop); 3052 } 3053 3054 /* SLAB cache for __getname() consumers */ 3055 struct kmem_cache *names_cachep __read_mostly; 3056 EXPORT_SYMBOL(names_cachep); 3057 3058 EXPORT_SYMBOL(d_genocide); 3059 3060 void __init vfs_caches_init_early(void) 3061 { 3062 dcache_init_early(); 3063 inode_init_early(); 3064 } 3065 3066 void __init vfs_caches_init(unsigned long mempages) 3067 { 3068 unsigned long reserve; 3069 3070 /* Base hash sizes on available memory, with a reserve equal to 3071 150% of current kernel size */ 3072 3073 reserve = min((mempages - nr_free_pages()) * 3/2, mempages - 1); 3074 mempages -= reserve; 3075 3076 names_cachep = kmem_cache_create("names_cache", PATH_MAX, 0, 3077 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL); 3078 3079 dcache_init(); 3080 inode_init(); 3081 files_init(mempages); 3082 mnt_init(); 3083 bdev_cache_init(); 3084 chrdev_init(); 3085 } 3086