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