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