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