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