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