1/* 2 * linux/fs/inode.c 3 * 4 * (C) 1997 Linus Torvalds 5 */ 6 7#include <linux/fs.h> 8#include <linux/mm.h> 9#include <linux/dcache.h> 10#include <linux/init.h> 11#include <linux/slab.h> 12#include <linux/writeback.h> 13#include <linux/module.h> 14#include <linux/backing-dev.h> 15#include <linux/wait.h> 16#include <linux/rwsem.h> 17#include <linux/hash.h> 18#include <linux/swap.h> 19#include <linux/security.h> 20#include <linux/pagemap.h> 21#include <linux/cdev.h> 22#include <linux/bootmem.h> 23#include <linux/fsnotify.h> 24#include <linux/mount.h> 25#include <linux/async.h> 26#include <linux/posix_acl.h> 27 28#include <linux/buffer_head.h> 29 30/* 31 * New inode.c implementation. 32 * 33 * This implementation has the basic premise of trying 34 * to be extremely low-overhead and SMP-safe, yet be 35 * simple enough to be "obviously correct". 36 * 37 * Famous last words. 38 */ 39 40/* inode dynamic allocation 1999, Andrea Arcangeli <andrea@suse.de> */ 41 42/* #define INODE_PARANOIA 1 */ 43/* #define INODE_DEBUG 1 */ 44 45/* 46 * Inode lookup is no longer as critical as it used to be: 47 * most of the lookups are going to be through the dcache. 48 */ 49#define I_HASHBITS i_hash_shift 50#define I_HASHMASK i_hash_mask 51 52static unsigned int i_hash_mask __read_mostly; 53static unsigned int i_hash_shift __read_mostly; 54 55/* 56 * Each inode can be on two separate lists. One is 57 * the hash list of the inode, used for lookups. The 58 * other linked list is the "type" list: 59 * "in_use" - valid inode, i_count > 0, i_nlink > 0 60 * "dirty" - as "in_use" but also dirty 61 * "unused" - valid inode, i_count = 0 62 * 63 * A "dirty" list is maintained for each super block, 64 * allowing for low-overhead inode sync() operations. 65 */ 66 67LIST_HEAD(inode_in_use); 68LIST_HEAD(inode_unused); 69static struct hlist_head *inode_hashtable __read_mostly; 70 71/* 72 * A simple spinlock to protect the list manipulations. 73 * 74 * NOTE! You also have to own the lock if you change 75 * the i_state of an inode while it is in use.. 76 */ 77DEFINE_SPINLOCK(inode_lock); 78 79/* 80 * iprune_sem provides exclusion between the kswapd or try_to_free_pages 81 * icache shrinking path, and the umount path. Without this exclusion, 82 * by the time prune_icache calls iput for the inode whose pages it has 83 * been invalidating, or by the time it calls clear_inode & destroy_inode 84 * from its final dispose_list, the struct super_block they refer to 85 * (for inode->i_sb->s_op) may already have been freed and reused. 86 * 87 * We make this an rwsem because the fastpath is icache shrinking. In 88 * some cases a filesystem may be doing a significant amount of work in 89 * its inode reclaim code, so this should improve parallelism. 90 */ 91static DECLARE_RWSEM(iprune_sem); 92 93/* 94 * Statistics gathering.. 95 */ 96struct inodes_stat_t inodes_stat; 97 98static struct kmem_cache *inode_cachep __read_mostly; 99 100static void wake_up_inode(struct inode *inode) 101{ 102 /* 103 * Prevent speculative execution through spin_unlock(&inode_lock); 104 */ 105 smp_mb(); 106 wake_up_bit(&inode->i_state, __I_NEW); 107} 108 109/** 110 * inode_init_always - perform inode structure intialisation 111 * @sb: superblock inode belongs to 112 * @inode: inode to initialise 113 * 114 * These are initializations that need to be done on every inode 115 * allocation as the fields are not initialised by slab allocation. 116 */ 117int inode_init_always(struct super_block *sb, struct inode *inode) 118{ 119 static const struct address_space_operations empty_aops; 120 static const struct inode_operations empty_iops; 121 static const struct file_operations empty_fops; 122 struct address_space *const mapping = &inode->i_data; 123 124 inode->i_sb = sb; 125 inode->i_blkbits = sb->s_blocksize_bits; 126 inode->i_flags = 0; 127 atomic_set(&inode->i_count, 1); 128 inode->i_op = &empty_iops; 129 inode->i_fop = &empty_fops; 130 inode->i_nlink = 1; 131 inode->i_uid = 0; 132 inode->i_gid = 0; 133 atomic_set(&inode->i_writecount, 0); 134 inode->i_size = 0; 135 inode->i_blocks = 0; 136 inode->i_bytes = 0; 137 inode->i_generation = 0; 138#ifdef CONFIG_QUOTA 139 memset(&inode->i_dquot, 0, sizeof(inode->i_dquot)); 140#endif 141 inode->i_pipe = NULL; 142 inode->i_bdev = NULL; 143 inode->i_cdev = NULL; 144 inode->i_rdev = 0; 145 inode->dirtied_when = 0; 146 147 if (security_inode_alloc(inode)) 148 goto out; 149 spin_lock_init(&inode->i_lock); 150 lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key); 151 152 mutex_init(&inode->i_mutex); 153 lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key); 154 155 init_rwsem(&inode->i_alloc_sem); 156 lockdep_set_class(&inode->i_alloc_sem, &sb->s_type->i_alloc_sem_key); 157 158 mapping->a_ops = &empty_aops; 159 mapping->host = inode; 160 mapping->flags = 0; 161 mapping_set_gfp_mask(mapping, GFP_HIGHUSER_MOVABLE); 162 mapping->assoc_mapping = NULL; 163 mapping->backing_dev_info = &default_backing_dev_info; 164 mapping->writeback_index = 0; 165 166 /* 167 * If the block_device provides a backing_dev_info for client 168 * inodes then use that. Otherwise the inode share the bdev's 169 * backing_dev_info. 170 */ 171 if (sb->s_bdev) { 172 struct backing_dev_info *bdi; 173 174 bdi = sb->s_bdev->bd_inode->i_mapping->backing_dev_info; 175 mapping->backing_dev_info = bdi; 176 } 177 inode->i_private = NULL; 178 inode->i_mapping = mapping; 179#ifdef CONFIG_FS_POSIX_ACL 180 inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED; 181#endif 182 183#ifdef CONFIG_FSNOTIFY 184 inode->i_fsnotify_mask = 0; 185#endif 186 187 return 0; 188out: 189 return -ENOMEM; 190} 191EXPORT_SYMBOL(inode_init_always); 192 193static struct inode *alloc_inode(struct super_block *sb) 194{ 195 struct inode *inode; 196 197 if (sb->s_op->alloc_inode) 198 inode = sb->s_op->alloc_inode(sb); 199 else 200 inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL); 201 202 if (!inode) 203 return NULL; 204 205 if (unlikely(inode_init_always(sb, inode))) { 206 if (inode->i_sb->s_op->destroy_inode) 207 inode->i_sb->s_op->destroy_inode(inode); 208 else 209 kmem_cache_free(inode_cachep, inode); 210 return NULL; 211 } 212 213 return inode; 214} 215 216void __destroy_inode(struct inode *inode) 217{ 218 BUG_ON(inode_has_buffers(inode)); 219 security_inode_free(inode); 220 fsnotify_inode_delete(inode); 221#ifdef CONFIG_FS_POSIX_ACL 222 if (inode->i_acl && inode->i_acl != ACL_NOT_CACHED) 223 posix_acl_release(inode->i_acl); 224 if (inode->i_default_acl && inode->i_default_acl != ACL_NOT_CACHED) 225 posix_acl_release(inode->i_default_acl); 226#endif 227} 228EXPORT_SYMBOL(__destroy_inode); 229 230void destroy_inode(struct inode *inode) 231{ 232 __destroy_inode(inode); 233 if (inode->i_sb->s_op->destroy_inode) 234 inode->i_sb->s_op->destroy_inode(inode); 235 else 236 kmem_cache_free(inode_cachep, (inode)); 237} 238 239/* 240 * These are initializations that only need to be done 241 * once, because the fields are idempotent across use 242 * of the inode, so let the slab aware of that. 243 */ 244void inode_init_once(struct inode *inode) 245{ 246 memset(inode, 0, sizeof(*inode)); 247 INIT_HLIST_NODE(&inode->i_hash); 248 INIT_LIST_HEAD(&inode->i_dentry); 249 INIT_LIST_HEAD(&inode->i_devices); 250 INIT_RADIX_TREE(&inode->i_data.page_tree, GFP_ATOMIC); 251 spin_lock_init(&inode->i_data.tree_lock); 252 spin_lock_init(&inode->i_data.i_mmap_lock); 253 INIT_LIST_HEAD(&inode->i_data.private_list); 254 spin_lock_init(&inode->i_data.private_lock); 255 INIT_RAW_PRIO_TREE_ROOT(&inode->i_data.i_mmap); 256 INIT_LIST_HEAD(&inode->i_data.i_mmap_nonlinear); 257 i_size_ordered_init(inode); 258#ifdef CONFIG_FSNOTIFY 259 INIT_HLIST_HEAD(&inode->i_fsnotify_marks); 260#endif 261} 262EXPORT_SYMBOL(inode_init_once); 263 264static void init_once(void *foo) 265{ 266 struct inode *inode = (struct inode *) foo; 267 268 inode_init_once(inode); 269} 270 271/* 272 * inode_lock must be held 273 */ 274void __iget(struct inode *inode) 275{ 276 if (atomic_inc_return(&inode->i_count) != 1) 277 return; 278 279 if (!(inode->i_state & (I_DIRTY|I_SYNC))) 280 list_move(&inode->i_list, &inode_in_use); 281 inodes_stat.nr_unused--; 282} 283 284void end_writeback(struct inode *inode) 285{ 286 might_sleep(); 287 BUG_ON(inode->i_data.nrpages); 288 BUG_ON(!list_empty(&inode->i_data.private_list)); 289 BUG_ON(!(inode->i_state & I_FREEING)); 290 BUG_ON(inode->i_state & I_CLEAR); 291 inode_sync_wait(inode); 292 inode->i_state = I_FREEING | I_CLEAR; 293} 294EXPORT_SYMBOL(end_writeback); 295 296static void evict(struct inode *inode) 297{ 298 const struct super_operations *op = inode->i_sb->s_op; 299 300 if (op->evict_inode) { 301 op->evict_inode(inode); 302 } else { 303 if (inode->i_data.nrpages) 304 truncate_inode_pages(&inode->i_data, 0); 305 end_writeback(inode); 306 } 307 if (S_ISBLK(inode->i_mode) && inode->i_bdev) 308 bd_forget(inode); 309 if (S_ISCHR(inode->i_mode) && inode->i_cdev) 310 cd_forget(inode); 311} 312 313/* 314 * dispose_list - dispose of the contents of a local list 315 * @head: the head of the list to free 316 * 317 * Dispose-list gets a local list with local inodes in it, so it doesn't 318 * need to worry about list corruption and SMP locks. 319 */ 320static void dispose_list(struct list_head *head) 321{ 322 int nr_disposed = 0; 323 324 while (!list_empty(head)) { 325 struct inode *inode; 326 327 inode = list_first_entry(head, struct inode, i_list); 328 list_del(&inode->i_list); 329 330 evict(inode); 331 332 spin_lock(&inode_lock); 333 hlist_del_init(&inode->i_hash); 334 list_del_init(&inode->i_sb_list); 335 spin_unlock(&inode_lock); 336 337 wake_up_inode(inode); 338 destroy_inode(inode); 339 nr_disposed++; 340 } 341 spin_lock(&inode_lock); 342 inodes_stat.nr_inodes -= nr_disposed; 343 spin_unlock(&inode_lock); 344} 345 346/* 347 * Invalidate all inodes for a device. 348 */ 349static int invalidate_list(struct list_head *head, struct list_head *dispose) 350{ 351 struct list_head *next; 352 int busy = 0, count = 0; 353 354 next = head->next; 355 for (;;) { 356 struct list_head *tmp = next; 357 struct inode *inode; 358 359 /* 360 * We can reschedule here without worrying about the list's 361 * consistency because the per-sb list of inodes must not 362 * change during umount anymore, and because iprune_sem keeps 363 * shrink_icache_memory() away. 364 */ 365 cond_resched_lock(&inode_lock); 366 367 next = next->next; 368 if (tmp == head) 369 break; 370 inode = list_entry(tmp, struct inode, i_sb_list); 371 if (inode->i_state & I_NEW) 372 continue; 373 invalidate_inode_buffers(inode); 374 if (!atomic_read(&inode->i_count)) { 375 list_move(&inode->i_list, dispose); 376 WARN_ON(inode->i_state & I_NEW); 377 inode->i_state |= I_FREEING; 378 count++; 379 continue; 380 } 381 busy = 1; 382 } 383 /* only unused inodes may be cached with i_count zero */ 384 inodes_stat.nr_unused -= count; 385 return busy; 386} 387 388/** 389 * invalidate_inodes - discard the inodes on a device 390 * @sb: superblock 391 * 392 * Discard all of the inodes for a given superblock. If the discard 393 * fails because there are busy inodes then a non zero value is returned. 394 * If the discard is successful all the inodes have been discarded. 395 */ 396int invalidate_inodes(struct super_block *sb) 397{ 398 int busy; 399 LIST_HEAD(throw_away); 400 401 down_write(&iprune_sem); 402 spin_lock(&inode_lock); 403 fsnotify_unmount_inodes(&sb->s_inodes); 404 busy = invalidate_list(&sb->s_inodes, &throw_away); 405 spin_unlock(&inode_lock); 406 407 dispose_list(&throw_away); 408 up_write(&iprune_sem); 409 410 return busy; 411} 412EXPORT_SYMBOL(invalidate_inodes); 413 414static int can_unuse(struct inode *inode) 415{ 416 if (inode->i_state) 417 return 0; 418 if (inode_has_buffers(inode)) 419 return 0; 420 if (atomic_read(&inode->i_count)) 421 return 0; 422 if (inode->i_data.nrpages) 423 return 0; 424 return 1; 425} 426 427/* 428 * Scan `goal' inodes on the unused list for freeable ones. They are moved to 429 * a temporary list and then are freed outside inode_lock by dispose_list(). 430 * 431 * Any inodes which are pinned purely because of attached pagecache have their 432 * pagecache removed. We expect the final iput() on that inode to add it to 433 * the front of the inode_unused list. So look for it there and if the 434 * inode is still freeable, proceed. The right inode is found 99.9% of the 435 * time in testing on a 4-way. 436 * 437 * If the inode has metadata buffers attached to mapping->private_list then 438 * try to remove them. 439 */ 440static void prune_icache(int nr_to_scan) 441{ 442 LIST_HEAD(freeable); 443 int nr_pruned = 0; 444 int nr_scanned; 445 unsigned long reap = 0; 446 447 down_read(&iprune_sem); 448 spin_lock(&inode_lock); 449 for (nr_scanned = 0; nr_scanned < nr_to_scan; nr_scanned++) { 450 struct inode *inode; 451 452 if (list_empty(&inode_unused)) 453 break; 454 455 inode = list_entry(inode_unused.prev, struct inode, i_list); 456 457 if (inode->i_state || atomic_read(&inode->i_count)) { 458 list_move(&inode->i_list, &inode_unused); 459 continue; 460 } 461 if (inode_has_buffers(inode) || inode->i_data.nrpages) { 462 __iget(inode); 463 spin_unlock(&inode_lock); 464 if (remove_inode_buffers(inode)) 465 reap += invalidate_mapping_pages(&inode->i_data, 466 0, -1); 467 iput(inode); 468 spin_lock(&inode_lock); 469 470 if (inode != list_entry(inode_unused.next, 471 struct inode, i_list)) 472 continue; /* wrong inode or list_empty */ 473 if (!can_unuse(inode)) 474 continue; 475 } 476 list_move(&inode->i_list, &freeable); 477 WARN_ON(inode->i_state & I_NEW); 478 inode->i_state |= I_FREEING; 479 nr_pruned++; 480 } 481 inodes_stat.nr_unused -= nr_pruned; 482 if (current_is_kswapd()) 483 __count_vm_events(KSWAPD_INODESTEAL, reap); 484 else 485 __count_vm_events(PGINODESTEAL, reap); 486 spin_unlock(&inode_lock); 487 488 dispose_list(&freeable); 489 up_read(&iprune_sem); 490} 491 492/* 493 * shrink_icache_memory() will attempt to reclaim some unused inodes. Here, 494 * "unused" means that no dentries are referring to the inodes: the files are 495 * not open and the dcache references to those inodes have already been 496 * reclaimed. 497 * 498 * This function is passed the number of inodes to scan, and it returns the 499 * total number of remaining possibly-reclaimable inodes. 500 */ 501static int shrink_icache_memory(struct shrinker *shrink, int nr, gfp_t gfp_mask) 502{ 503 if (nr) { 504 /* 505 * Nasty deadlock avoidance. We may hold various FS locks, 506 * and we don't want to recurse into the FS that called us 507 * in clear_inode() and friends.. 508 */ 509 if (!(gfp_mask & __GFP_FS)) 510 return -1; 511 prune_icache(nr); 512 } 513 return (inodes_stat.nr_unused / 100) * sysctl_vfs_cache_pressure; 514} 515 516static struct shrinker icache_shrinker = { 517 .shrink = shrink_icache_memory, 518 .seeks = DEFAULT_SEEKS, 519}; 520 521static void __wait_on_freeing_inode(struct inode *inode); 522/* 523 * Called with the inode lock held. 524 * NOTE: we are not increasing the inode-refcount, you must call __iget() 525 * by hand after calling find_inode now! This simplifies iunique and won't 526 * add any additional branch in the common code. 527 */ 528static struct inode *find_inode(struct super_block *sb, 529 struct hlist_head *head, 530 int (*test)(struct inode *, void *), 531 void *data) 532{ 533 struct hlist_node *node; 534 struct inode *inode = NULL; 535 536repeat: 537 hlist_for_each_entry(inode, node, head, i_hash) { 538 if (inode->i_sb != sb) 539 continue; 540 if (!test(inode, data)) 541 continue; 542 if (inode->i_state & (I_FREEING|I_WILL_FREE)) { 543 __wait_on_freeing_inode(inode); 544 goto repeat; 545 } 546 break; 547 } 548 return node ? inode : NULL; 549} 550 551/* 552 * find_inode_fast is the fast path version of find_inode, see the comment at 553 * iget_locked for details. 554 */ 555static struct inode *find_inode_fast(struct super_block *sb, 556 struct hlist_head *head, unsigned long ino) 557{ 558 struct hlist_node *node; 559 struct inode *inode = NULL; 560 561repeat: 562 hlist_for_each_entry(inode, node, head, i_hash) { 563 if (inode->i_ino != ino) 564 continue; 565 if (inode->i_sb != sb) 566 continue; 567 if (inode->i_state & (I_FREEING|I_WILL_FREE)) { 568 __wait_on_freeing_inode(inode); 569 goto repeat; 570 } 571 break; 572 } 573 return node ? inode : NULL; 574} 575 576static unsigned long hash(struct super_block *sb, unsigned long hashval) 577{ 578 unsigned long tmp; 579 580 tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) / 581 L1_CACHE_BYTES; 582 tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> I_HASHBITS); 583 return tmp & I_HASHMASK; 584} 585 586static inline void 587__inode_add_to_lists(struct super_block *sb, struct hlist_head *head, 588 struct inode *inode) 589{ 590 inodes_stat.nr_inodes++; 591 list_add(&inode->i_list, &inode_in_use); 592 list_add(&inode->i_sb_list, &sb->s_inodes); 593 if (head) 594 hlist_add_head(&inode->i_hash, head); 595} 596 597/** 598 * inode_add_to_lists - add a new inode to relevant lists 599 * @sb: superblock inode belongs to 600 * @inode: inode to mark in use 601 * 602 * When an inode is allocated it needs to be accounted for, added to the in use 603 * list, the owning superblock and the inode hash. This needs to be done under 604 * the inode_lock, so export a function to do this rather than the inode lock 605 * itself. We calculate the hash list to add to here so it is all internal 606 * which requires the caller to have already set up the inode number in the 607 * inode to add. 608 */ 609void inode_add_to_lists(struct super_block *sb, struct inode *inode) 610{ 611 struct hlist_head *head = inode_hashtable + hash(sb, inode->i_ino); 612 613 spin_lock(&inode_lock); 614 __inode_add_to_lists(sb, head, inode); 615 spin_unlock(&inode_lock); 616} 617EXPORT_SYMBOL_GPL(inode_add_to_lists); 618 619/** 620 * new_inode - obtain an inode 621 * @sb: superblock 622 * 623 * Allocates a new inode for given superblock. The default gfp_mask 624 * for allocations related to inode->i_mapping is GFP_HIGHUSER_MOVABLE. 625 * If HIGHMEM pages are unsuitable or it is known that pages allocated 626 * for the page cache are not reclaimable or migratable, 627 * mapping_set_gfp_mask() must be called with suitable flags on the 628 * newly created inode's mapping 629 * 630 */ 631struct inode *new_inode(struct super_block *sb) 632{ 633 /* 634 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW 635 * error if st_ino won't fit in target struct field. Use 32bit counter 636 * here to attempt to avoid that. 637 */ 638 static unsigned int last_ino; 639 struct inode *inode; 640 641 spin_lock_prefetch(&inode_lock); 642 643 inode = alloc_inode(sb); 644 if (inode) { 645 spin_lock(&inode_lock); 646 __inode_add_to_lists(sb, NULL, inode); 647 inode->i_ino = ++last_ino; 648 inode->i_state = 0; 649 spin_unlock(&inode_lock); 650 } 651 return inode; 652} 653EXPORT_SYMBOL(new_inode); 654 655void unlock_new_inode(struct inode *inode) 656{ 657#ifdef CONFIG_DEBUG_LOCK_ALLOC 658 if (inode->i_mode & S_IFDIR) { 659 struct file_system_type *type = inode->i_sb->s_type; 660 661 /* Set new key only if filesystem hasn't already changed it */ 662 if (!lockdep_match_class(&inode->i_mutex, 663 &type->i_mutex_key)) { 664 /* 665 * ensure nobody is actually holding i_mutex 666 */ 667 mutex_destroy(&inode->i_mutex); 668 mutex_init(&inode->i_mutex); 669 lockdep_set_class(&inode->i_mutex, 670 &type->i_mutex_dir_key); 671 } 672 } 673#endif 674 /* 675 * This is special! We do not need the spinlock when clearing I_NEW, 676 * because we're guaranteed that nobody else tries to do anything about 677 * the state of the inode when it is locked, as we just created it (so 678 * there can be no old holders that haven't tested I_NEW). 679 * However we must emit the memory barrier so that other CPUs reliably 680 * see the clearing of I_NEW after the other inode initialisation has 681 * completed. 682 */ 683 smp_mb(); 684 WARN_ON(!(inode->i_state & I_NEW)); 685 inode->i_state &= ~I_NEW; 686 wake_up_inode(inode); 687} 688EXPORT_SYMBOL(unlock_new_inode); 689 690/* 691 * This is called without the inode lock held.. Be careful. 692 * 693 * We no longer cache the sb_flags in i_flags - see fs.h 694 * -- rmk@arm.uk.linux.org 695 */ 696static struct inode *get_new_inode(struct super_block *sb, 697 struct hlist_head *head, 698 int (*test)(struct inode *, void *), 699 int (*set)(struct inode *, void *), 700 void *data) 701{ 702 struct inode *inode; 703 704 inode = alloc_inode(sb); 705 if (inode) { 706 struct inode *old; 707 708 spin_lock(&inode_lock); 709 /* We released the lock, so.. */ 710 old = find_inode(sb, head, test, data); 711 if (!old) { 712 if (set(inode, data)) 713 goto set_failed; 714 715 __inode_add_to_lists(sb, head, inode); 716 inode->i_state = I_NEW; 717 spin_unlock(&inode_lock); 718 719 /* Return the locked inode with I_NEW set, the 720 * caller is responsible for filling in the contents 721 */ 722 return inode; 723 } 724 725 /* 726 * Uhhuh, somebody else created the same inode under 727 * us. Use the old inode instead of the one we just 728 * allocated. 729 */ 730 __iget(old); 731 spin_unlock(&inode_lock); 732 destroy_inode(inode); 733 inode = old; 734 wait_on_inode(inode); 735 } 736 return inode; 737 738set_failed: 739 spin_unlock(&inode_lock); 740 destroy_inode(inode); 741 return NULL; 742} 743 744/* 745 * get_new_inode_fast is the fast path version of get_new_inode, see the 746 * comment at iget_locked for details. 747 */ 748static struct inode *get_new_inode_fast(struct super_block *sb, 749 struct hlist_head *head, unsigned long ino) 750{ 751 struct inode *inode; 752 753 inode = alloc_inode(sb); 754 if (inode) { 755 struct inode *old; 756 757 spin_lock(&inode_lock); 758 /* We released the lock, so.. */ 759 old = find_inode_fast(sb, head, ino); 760 if (!old) { 761 inode->i_ino = ino; 762 __inode_add_to_lists(sb, head, inode); 763 inode->i_state = I_NEW; 764 spin_unlock(&inode_lock); 765 766 /* Return the locked inode with I_NEW set, the 767 * caller is responsible for filling in the contents 768 */ 769 return inode; 770 } 771 772 /* 773 * Uhhuh, somebody else created the same inode under 774 * us. Use the old inode instead of the one we just 775 * allocated. 776 */ 777 __iget(old); 778 spin_unlock(&inode_lock); 779 destroy_inode(inode); 780 inode = old; 781 wait_on_inode(inode); 782 } 783 return inode; 784} 785 786/** 787 * iunique - get a unique inode number 788 * @sb: superblock 789 * @max_reserved: highest reserved inode number 790 * 791 * Obtain an inode number that is unique on the system for a given 792 * superblock. This is used by file systems that have no natural 793 * permanent inode numbering system. An inode number is returned that 794 * is higher than the reserved limit but unique. 795 * 796 * BUGS: 797 * With a large number of inodes live on the file system this function 798 * currently becomes quite slow. 799 */ 800ino_t iunique(struct super_block *sb, ino_t max_reserved) 801{ 802 /* 803 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW 804 * error if st_ino won't fit in target struct field. Use 32bit counter 805 * here to attempt to avoid that. 806 */ 807 static unsigned int counter; 808 struct inode *inode; 809 struct hlist_head *head; 810 ino_t res; 811 812 spin_lock(&inode_lock); 813 do { 814 if (counter <= max_reserved) 815 counter = max_reserved + 1; 816 res = counter++; 817 head = inode_hashtable + hash(sb, res); 818 inode = find_inode_fast(sb, head, res); 819 } while (inode != NULL); 820 spin_unlock(&inode_lock); 821 822 return res; 823} 824EXPORT_SYMBOL(iunique); 825 826struct inode *igrab(struct inode *inode) 827{ 828 spin_lock(&inode_lock); 829 if (!(inode->i_state & (I_FREEING|I_WILL_FREE))) 830 __iget(inode); 831 else 832 /* 833 * Handle the case where s_op->clear_inode is not been 834 * called yet, and somebody is calling igrab 835 * while the inode is getting freed. 836 */ 837 inode = NULL; 838 spin_unlock(&inode_lock); 839 return inode; 840} 841EXPORT_SYMBOL(igrab); 842 843/** 844 * ifind - internal function, you want ilookup5() or iget5(). 845 * @sb: super block of file system to search 846 * @head: the head of the list to search 847 * @test: callback used for comparisons between inodes 848 * @data: opaque data pointer to pass to @test 849 * @wait: if true wait for the inode to be unlocked, if false do not 850 * 851 * ifind() searches for the inode specified by @data in the inode 852 * cache. This is a generalized version of ifind_fast() for file systems where 853 * the inode number is not sufficient for unique identification of an inode. 854 * 855 * If the inode is in the cache, the inode is returned with an incremented 856 * reference count. 857 * 858 * Otherwise NULL is returned. 859 * 860 * Note, @test is called with the inode_lock held, so can't sleep. 861 */ 862static struct inode *ifind(struct super_block *sb, 863 struct hlist_head *head, int (*test)(struct inode *, void *), 864 void *data, const int wait) 865{ 866 struct inode *inode; 867 868 spin_lock(&inode_lock); 869 inode = find_inode(sb, head, test, data); 870 if (inode) { 871 __iget(inode); 872 spin_unlock(&inode_lock); 873 if (likely(wait)) 874 wait_on_inode(inode); 875 return inode; 876 } 877 spin_unlock(&inode_lock); 878 return NULL; 879} 880 881/** 882 * ifind_fast - internal function, you want ilookup() or iget(). 883 * @sb: super block of file system to search 884 * @head: head of the list to search 885 * @ino: inode number to search for 886 * 887 * ifind_fast() searches for the inode @ino in the inode cache. This is for 888 * file systems where the inode number is sufficient for unique identification 889 * of an inode. 890 * 891 * If the inode is in the cache, the inode is returned with an incremented 892 * reference count. 893 * 894 * Otherwise NULL is returned. 895 */ 896static struct inode *ifind_fast(struct super_block *sb, 897 struct hlist_head *head, unsigned long ino) 898{ 899 struct inode *inode; 900 901 spin_lock(&inode_lock); 902 inode = find_inode_fast(sb, head, ino); 903 if (inode) { 904 __iget(inode); 905 spin_unlock(&inode_lock); 906 wait_on_inode(inode); 907 return inode; 908 } 909 spin_unlock(&inode_lock); 910 return NULL; 911} 912 913/** 914 * ilookup5_nowait - search for an inode in the inode cache 915 * @sb: super block of file system to search 916 * @hashval: hash value (usually inode number) to search for 917 * @test: callback used for comparisons between inodes 918 * @data: opaque data pointer to pass to @test 919 * 920 * ilookup5() uses ifind() to search for the inode specified by @hashval and 921 * @data in the inode cache. This is a generalized version of ilookup() for 922 * file systems where the inode number is not sufficient for unique 923 * identification of an inode. 924 * 925 * If the inode is in the cache, the inode is returned with an incremented 926 * reference count. Note, the inode lock is not waited upon so you have to be 927 * very careful what you do with the returned inode. You probably should be 928 * using ilookup5() instead. 929 * 930 * Otherwise NULL is returned. 931 * 932 * Note, @test is called with the inode_lock held, so can't sleep. 933 */ 934struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval, 935 int (*test)(struct inode *, void *), void *data) 936{ 937 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 938 939 return ifind(sb, head, test, data, 0); 940} 941EXPORT_SYMBOL(ilookup5_nowait); 942 943/** 944 * ilookup5 - search for an inode in the inode cache 945 * @sb: super block of file system to search 946 * @hashval: hash value (usually inode number) to search for 947 * @test: callback used for comparisons between inodes 948 * @data: opaque data pointer to pass to @test 949 * 950 * ilookup5() uses ifind() to search for the inode specified by @hashval and 951 * @data in the inode cache. This is a generalized version of ilookup() for 952 * file systems where the inode number is not sufficient for unique 953 * identification of an inode. 954 * 955 * If the inode is in the cache, the inode lock is waited upon and the inode is 956 * returned with an incremented reference count. 957 * 958 * Otherwise NULL is returned. 959 * 960 * Note, @test is called with the inode_lock held, so can't sleep. 961 */ 962struct inode *ilookup5(struct super_block *sb, unsigned long hashval, 963 int (*test)(struct inode *, void *), void *data) 964{ 965 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 966 967 return ifind(sb, head, test, data, 1); 968} 969EXPORT_SYMBOL(ilookup5); 970 971/** 972 * ilookup - search for an inode in the inode cache 973 * @sb: super block of file system to search 974 * @ino: inode number to search for 975 * 976 * ilookup() uses ifind_fast() to search for the inode @ino in the inode cache. 977 * This is for file systems where the inode number is sufficient for unique 978 * identification of an inode. 979 * 980 * If the inode is in the cache, the inode is returned with an incremented 981 * reference count. 982 * 983 * Otherwise NULL is returned. 984 */ 985struct inode *ilookup(struct super_block *sb, unsigned long ino) 986{ 987 struct hlist_head *head = inode_hashtable + hash(sb, ino); 988 989 return ifind_fast(sb, head, ino); 990} 991EXPORT_SYMBOL(ilookup); 992 993/** 994 * iget5_locked - obtain an inode from a mounted file system 995 * @sb: super block of file system 996 * @hashval: hash value (usually inode number) to get 997 * @test: callback used for comparisons between inodes 998 * @set: callback used to initialize a new struct inode 999 * @data: opaque data pointer to pass to @test and @set 1000 * 1001 * iget5_locked() uses ifind() to search for the inode specified by @hashval 1002 * and @data in the inode cache and if present it is returned with an increased 1003 * reference count. This is a generalized version of iget_locked() for file 1004 * systems where the inode number is not sufficient for unique identification 1005 * of an inode. 1006 * 1007 * If the inode is not in cache, get_new_inode() is called to allocate a new 1008 * inode and this is returned locked, hashed, and with the I_NEW flag set. The 1009 * file system gets to fill it in before unlocking it via unlock_new_inode(). 1010 * 1011 * Note both @test and @set are called with the inode_lock held, so can't sleep. 1012 */ 1013struct inode *iget5_locked(struct super_block *sb, unsigned long hashval, 1014 int (*test)(struct inode *, void *), 1015 int (*set)(struct inode *, void *), void *data) 1016{ 1017 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 1018 struct inode *inode; 1019 1020 inode = ifind(sb, head, test, data, 1); 1021 if (inode) 1022 return inode; 1023 /* 1024 * get_new_inode() will do the right thing, re-trying the search 1025 * in case it had to block at any point. 1026 */ 1027 return get_new_inode(sb, head, test, set, data); 1028} 1029EXPORT_SYMBOL(iget5_locked); 1030 1031/** 1032 * iget_locked - obtain an inode from a mounted file system 1033 * @sb: super block of file system 1034 * @ino: inode number to get 1035 * 1036 * iget_locked() uses ifind_fast() to search for the inode specified by @ino in 1037 * the inode cache and if present it is returned with an increased reference 1038 * count. This is for file systems where the inode number is sufficient for 1039 * unique identification of an inode. 1040 * 1041 * If the inode is not in cache, get_new_inode_fast() is called to allocate a 1042 * new inode and this is returned locked, hashed, and with the I_NEW flag set. 1043 * The file system gets to fill it in before unlocking it via 1044 * unlock_new_inode(). 1045 */ 1046struct inode *iget_locked(struct super_block *sb, unsigned long ino) 1047{ 1048 struct hlist_head *head = inode_hashtable + hash(sb, ino); 1049 struct inode *inode; 1050 1051 inode = ifind_fast(sb, head, ino); 1052 if (inode) 1053 return inode; 1054 /* 1055 * get_new_inode_fast() will do the right thing, re-trying the search 1056 * in case it had to block at any point. 1057 */ 1058 return get_new_inode_fast(sb, head, ino); 1059} 1060EXPORT_SYMBOL(iget_locked); 1061 1062int insert_inode_locked(struct inode *inode) 1063{ 1064 struct super_block *sb = inode->i_sb; 1065 ino_t ino = inode->i_ino; 1066 struct hlist_head *head = inode_hashtable + hash(sb, ino); 1067 1068 inode->i_state |= I_NEW; 1069 while (1) { 1070 struct hlist_node *node; 1071 struct inode *old = NULL; 1072 spin_lock(&inode_lock); 1073 hlist_for_each_entry(old, node, head, i_hash) { 1074 if (old->i_ino != ino) 1075 continue; 1076 if (old->i_sb != sb) 1077 continue; 1078 if (old->i_state & (I_FREEING|I_WILL_FREE)) 1079 continue; 1080 break; 1081 } 1082 if (likely(!node)) { 1083 hlist_add_head(&inode->i_hash, head); 1084 spin_unlock(&inode_lock); 1085 return 0; 1086 } 1087 __iget(old); 1088 spin_unlock(&inode_lock); 1089 wait_on_inode(old); 1090 if (unlikely(!hlist_unhashed(&old->i_hash))) { 1091 iput(old); 1092 return -EBUSY; 1093 } 1094 iput(old); 1095 } 1096} 1097EXPORT_SYMBOL(insert_inode_locked); 1098 1099int insert_inode_locked4(struct inode *inode, unsigned long hashval, 1100 int (*test)(struct inode *, void *), void *data) 1101{ 1102 struct super_block *sb = inode->i_sb; 1103 struct hlist_head *head = inode_hashtable + hash(sb, hashval); 1104 1105 inode->i_state |= I_NEW; 1106 1107 while (1) { 1108 struct hlist_node *node; 1109 struct inode *old = NULL; 1110 1111 spin_lock(&inode_lock); 1112 hlist_for_each_entry(old, node, head, i_hash) { 1113 if (old->i_sb != sb) 1114 continue; 1115 if (!test(old, data)) 1116 continue; 1117 if (old->i_state & (I_FREEING|I_WILL_FREE)) 1118 continue; 1119 break; 1120 } 1121 if (likely(!node)) { 1122 hlist_add_head(&inode->i_hash, head); 1123 spin_unlock(&inode_lock); 1124 return 0; 1125 } 1126 __iget(old); 1127 spin_unlock(&inode_lock); 1128 wait_on_inode(old); 1129 if (unlikely(!hlist_unhashed(&old->i_hash))) { 1130 iput(old); 1131 return -EBUSY; 1132 } 1133 iput(old); 1134 } 1135} 1136EXPORT_SYMBOL(insert_inode_locked4); 1137 1138/** 1139 * __insert_inode_hash - hash an inode 1140 * @inode: unhashed inode 1141 * @hashval: unsigned long value used to locate this object in the 1142 * inode_hashtable. 1143 * 1144 * Add an inode to the inode hash for this superblock. 1145 */ 1146void __insert_inode_hash(struct inode *inode, unsigned long hashval) 1147{ 1148 struct hlist_head *head = inode_hashtable + hash(inode->i_sb, hashval); 1149 spin_lock(&inode_lock); 1150 hlist_add_head(&inode->i_hash, head); 1151 spin_unlock(&inode_lock); 1152} 1153EXPORT_SYMBOL(__insert_inode_hash); 1154 1155/** 1156 * remove_inode_hash - remove an inode from the hash 1157 * @inode: inode to unhash 1158 * 1159 * Remove an inode from the superblock. 1160 */ 1161void remove_inode_hash(struct inode *inode) 1162{ 1163 spin_lock(&inode_lock); 1164 hlist_del_init(&inode->i_hash); 1165 spin_unlock(&inode_lock); 1166} 1167EXPORT_SYMBOL(remove_inode_hash); 1168 1169int generic_delete_inode(struct inode *inode) 1170{ 1171 return 1; 1172} 1173EXPORT_SYMBOL(generic_delete_inode); 1174 1175/* 1176 * Normal UNIX filesystem behaviour: delete the 1177 * inode when the usage count drops to zero, and 1178 * i_nlink is zero. 1179 */ 1180int generic_drop_inode(struct inode *inode) 1181{ 1182 return !inode->i_nlink || hlist_unhashed(&inode->i_hash); 1183} 1184EXPORT_SYMBOL_GPL(generic_drop_inode); 1185 1186/* 1187 * Called when we're dropping the last reference 1188 * to an inode. 1189 * 1190 * Call the FS "drop_inode()" function, defaulting to 1191 * the legacy UNIX filesystem behaviour. If it tells 1192 * us to evict inode, do so. Otherwise, retain inode 1193 * in cache if fs is alive, sync and evict if fs is 1194 * shutting down. 1195 */ 1196static void iput_final(struct inode *inode) 1197{ 1198 struct super_block *sb = inode->i_sb; 1199 const struct super_operations *op = inode->i_sb->s_op; 1200 int drop; 1201 1202 if (op && op->drop_inode) 1203 drop = op->drop_inode(inode); 1204 else 1205 drop = generic_drop_inode(inode); 1206 1207 if (!drop) { 1208 if (!(inode->i_state & (I_DIRTY|I_SYNC))) 1209 list_move(&inode->i_list, &inode_unused); 1210 inodes_stat.nr_unused++; 1211 if (sb->s_flags & MS_ACTIVE) { 1212 spin_unlock(&inode_lock); 1213 return; 1214 } 1215 WARN_ON(inode->i_state & I_NEW); 1216 inode->i_state |= I_WILL_FREE; 1217 spin_unlock(&inode_lock); 1218 write_inode_now(inode, 1); 1219 spin_lock(&inode_lock); 1220 WARN_ON(inode->i_state & I_NEW); 1221 inode->i_state &= ~I_WILL_FREE; 1222 inodes_stat.nr_unused--; 1223 hlist_del_init(&inode->i_hash); 1224 } 1225 list_del_init(&inode->i_list); 1226 list_del_init(&inode->i_sb_list); 1227 WARN_ON(inode->i_state & I_NEW); 1228 inode->i_state |= I_FREEING; 1229 inodes_stat.nr_inodes--; 1230 spin_unlock(&inode_lock); 1231 evict(inode); 1232 spin_lock(&inode_lock); 1233 hlist_del_init(&inode->i_hash); 1234 spin_unlock(&inode_lock); 1235 wake_up_inode(inode); 1236 BUG_ON(inode->i_state != (I_FREEING | I_CLEAR)); 1237 destroy_inode(inode); 1238} 1239 1240/** 1241 * iput - put an inode 1242 * @inode: inode to put 1243 * 1244 * Puts an inode, dropping its usage count. If the inode use count hits 1245 * zero, the inode is then freed and may also be destroyed. 1246 * 1247 * Consequently, iput() can sleep. 1248 */ 1249void iput(struct inode *inode) 1250{ 1251 if (inode) { 1252 BUG_ON(inode->i_state & I_CLEAR); 1253 1254 if (atomic_dec_and_lock(&inode->i_count, &inode_lock)) 1255 iput_final(inode); 1256 } 1257} 1258EXPORT_SYMBOL(iput); 1259 1260/** 1261 * bmap - find a block number in a file 1262 * @inode: inode of file 1263 * @block: block to find 1264 * 1265 * Returns the block number on the device holding the inode that 1266 * is the disk block number for the block of the file requested. 1267 * That is, asked for block 4 of inode 1 the function will return the 1268 * disk block relative to the disk start that holds that block of the 1269 * file. 1270 */ 1271sector_t bmap(struct inode *inode, sector_t block) 1272{ 1273 sector_t res = 0; 1274 if (inode->i_mapping->a_ops->bmap) 1275 res = inode->i_mapping->a_ops->bmap(inode->i_mapping, block); 1276 return res; 1277} 1278EXPORT_SYMBOL(bmap); 1279 1280/* 1281 * With relative atime, only update atime if the previous atime is 1282 * earlier than either the ctime or mtime or if at least a day has 1283 * passed since the last atime update. 1284 */ 1285static int relatime_need_update(struct vfsmount *mnt, struct inode *inode, 1286 struct timespec now) 1287{ 1288 1289 if (!(mnt->mnt_flags & MNT_RELATIME)) 1290 return 1; 1291 /* 1292 * Is mtime younger than atime? If yes, update atime: 1293 */ 1294 if (timespec_compare(&inode->i_mtime, &inode->i_atime) >= 0) 1295 return 1; 1296 /* 1297 * Is ctime younger than atime? If yes, update atime: 1298 */ 1299 if (timespec_compare(&inode->i_ctime, &inode->i_atime) >= 0) 1300 return 1; 1301 1302 /* 1303 * Is the previous atime value older than a day? If yes, 1304 * update atime: 1305 */ 1306 if ((long)(now.tv_sec - inode->i_atime.tv_sec) >= 24*60*60) 1307 return 1; 1308 /* 1309 * Good, we can skip the atime update: 1310 */ 1311 return 0; 1312} 1313 1314/** 1315 * touch_atime - update the access time 1316 * @mnt: mount the inode is accessed on 1317 * @dentry: dentry accessed 1318 * 1319 * Update the accessed time on an inode and mark it for writeback. 1320 * This function automatically handles read only file systems and media, 1321 * as well as the "noatime" flag and inode specific "noatime" markers. 1322 */ 1323void touch_atime(struct vfsmount *mnt, struct dentry *dentry) 1324{ 1325 struct inode *inode = dentry->d_inode; 1326 struct timespec now; 1327 1328 if (inode->i_flags & S_NOATIME) 1329 return; 1330 if (IS_NOATIME(inode)) 1331 return; 1332 if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)) 1333 return; 1334 1335 if (mnt->mnt_flags & MNT_NOATIME) 1336 return; 1337 if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)) 1338 return; 1339 1340 now = current_fs_time(inode->i_sb); 1341 1342 if (!relatime_need_update(mnt, inode, now)) 1343 return; 1344 1345 if (timespec_equal(&inode->i_atime, &now)) 1346 return; 1347 1348 if (mnt_want_write(mnt)) 1349 return; 1350 1351 inode->i_atime = now; 1352 mark_inode_dirty_sync(inode); 1353 mnt_drop_write(mnt); 1354} 1355EXPORT_SYMBOL(touch_atime); 1356 1357/** 1358 * file_update_time - update mtime and ctime time 1359 * @file: file accessed 1360 * 1361 * Update the mtime and ctime members of an inode and mark the inode 1362 * for writeback. Note that this function is meant exclusively for 1363 * usage in the file write path of filesystems, and filesystems may 1364 * choose to explicitly ignore update via this function with the 1365 * S_NOCMTIME inode flag, e.g. for network filesystem where these 1366 * timestamps are handled by the server. 1367 */ 1368 1369void file_update_time(struct file *file) 1370{ 1371 struct inode *inode = file->f_path.dentry->d_inode; 1372 struct timespec now; 1373 enum { S_MTIME = 1, S_CTIME = 2, S_VERSION = 4 } sync_it = 0; 1374 1375 /* First try to exhaust all avenues to not sync */ 1376 if (IS_NOCMTIME(inode)) 1377 return; 1378 1379 now = current_fs_time(inode->i_sb); 1380 if (!timespec_equal(&inode->i_mtime, &now)) 1381 sync_it = S_MTIME; 1382 1383 if (!timespec_equal(&inode->i_ctime, &now)) 1384 sync_it |= S_CTIME; 1385 1386 if (IS_I_VERSION(inode)) 1387 sync_it |= S_VERSION; 1388 1389 if (!sync_it) 1390 return; 1391 1392 /* Finally allowed to write? Takes lock. */ 1393 if (mnt_want_write_file(file)) 1394 return; 1395 1396 /* Only change inode inside the lock region */ 1397 if (sync_it & S_VERSION) 1398 inode_inc_iversion(inode); 1399 if (sync_it & S_CTIME) 1400 inode->i_ctime = now; 1401 if (sync_it & S_MTIME) 1402 inode->i_mtime = now; 1403 mark_inode_dirty_sync(inode); 1404 mnt_drop_write(file->f_path.mnt); 1405} 1406EXPORT_SYMBOL(file_update_time); 1407 1408int inode_needs_sync(struct inode *inode) 1409{ 1410 if (IS_SYNC(inode)) 1411 return 1; 1412 if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode)) 1413 return 1; 1414 return 0; 1415} 1416EXPORT_SYMBOL(inode_needs_sync); 1417 1418int inode_wait(void *word) 1419{ 1420 schedule(); 1421 return 0; 1422} 1423EXPORT_SYMBOL(inode_wait); 1424 1425/* 1426 * If we try to find an inode in the inode hash while it is being 1427 * deleted, we have to wait until the filesystem completes its 1428 * deletion before reporting that it isn't found. This function waits 1429 * until the deletion _might_ have completed. Callers are responsible 1430 * to recheck inode state. 1431 * 1432 * It doesn't matter if I_NEW is not set initially, a call to 1433 * wake_up_inode() after removing from the hash list will DTRT. 1434 * 1435 * This is called with inode_lock held. 1436 */ 1437static void __wait_on_freeing_inode(struct inode *inode) 1438{ 1439 wait_queue_head_t *wq; 1440 DEFINE_WAIT_BIT(wait, &inode->i_state, __I_NEW); 1441 wq = bit_waitqueue(&inode->i_state, __I_NEW); 1442 prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE); 1443 spin_unlock(&inode_lock); 1444 schedule(); 1445 finish_wait(wq, &wait.wait); 1446 spin_lock(&inode_lock); 1447} 1448 1449static __initdata unsigned long ihash_entries; 1450static int __init set_ihash_entries(char *str) 1451{ 1452 if (!str) 1453 return 0; 1454 ihash_entries = simple_strtoul(str, &str, 0); 1455 return 1; 1456} 1457__setup("ihash_entries=", set_ihash_entries); 1458 1459/* 1460 * Initialize the waitqueues and inode hash table. 1461 */ 1462void __init inode_init_early(void) 1463{ 1464 int loop; 1465 1466 /* If hashes are distributed across NUMA nodes, defer 1467 * hash allocation until vmalloc space is available. 1468 */ 1469 if (hashdist) 1470 return; 1471 1472 inode_hashtable = 1473 alloc_large_system_hash("Inode-cache", 1474 sizeof(struct hlist_head), 1475 ihash_entries, 1476 14, 1477 HASH_EARLY, 1478 &i_hash_shift, 1479 &i_hash_mask, 1480 0); 1481 1482 for (loop = 0; loop < (1 << i_hash_shift); loop++) 1483 INIT_HLIST_HEAD(&inode_hashtable[loop]); 1484} 1485 1486void __init inode_init(void) 1487{ 1488 int loop; 1489 1490 /* inode slab cache */ 1491 inode_cachep = kmem_cache_create("inode_cache", 1492 sizeof(struct inode), 1493 0, 1494 (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC| 1495 SLAB_MEM_SPREAD), 1496 init_once); 1497 register_shrinker(&icache_shrinker); 1498 1499 /* Hash may have been set up in inode_init_early */ 1500 if (!hashdist) 1501 return; 1502 1503 inode_hashtable = 1504 alloc_large_system_hash("Inode-cache", 1505 sizeof(struct hlist_head), 1506 ihash_entries, 1507 14, 1508 0, 1509 &i_hash_shift, 1510 &i_hash_mask, 1511 0); 1512 1513 for (loop = 0; loop < (1 << i_hash_shift); loop++) 1514 INIT_HLIST_HEAD(&inode_hashtable[loop]); 1515} 1516 1517void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev) 1518{ 1519 inode->i_mode = mode; 1520 if (S_ISCHR(mode)) { 1521 inode->i_fop = &def_chr_fops; 1522 inode->i_rdev = rdev; 1523 } else if (S_ISBLK(mode)) { 1524 inode->i_fop = &def_blk_fops; 1525 inode->i_rdev = rdev; 1526 } else if (S_ISFIFO(mode)) 1527 inode->i_fop = &def_fifo_fops; 1528 else if (S_ISSOCK(mode)) 1529 inode->i_fop = &bad_sock_fops; 1530 else 1531 printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for" 1532 " inode %s:%lu\n", mode, inode->i_sb->s_id, 1533 inode->i_ino); 1534} 1535EXPORT_SYMBOL(init_special_inode); 1536 1537/** 1538 * Init uid,gid,mode for new inode according to posix standards 1539 * @inode: New inode 1540 * @dir: Directory inode 1541 * @mode: mode of the new inode 1542 */ 1543void inode_init_owner(struct inode *inode, const struct inode *dir, 1544 mode_t mode) 1545{ 1546 inode->i_uid = current_fsuid(); 1547 if (dir && dir->i_mode & S_ISGID) { 1548 inode->i_gid = dir->i_gid; 1549 if (S_ISDIR(mode)) 1550 mode |= S_ISGID; 1551 } else 1552 inode->i_gid = current_fsgid(); 1553 inode->i_mode = mode; 1554} 1555EXPORT_SYMBOL(inode_init_owner); 1556