fs: factor inode disposal
[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 void remove_inode_hash(struct inode *inode)
432 {
433         spin_lock(&inode_lock);
434         spin_lock(&inode->i_lock);
435         hlist_del_init(&inode->i_hash);
436         spin_unlock(&inode->i_lock);
437         spin_unlock(&inode_lock);
438 }
439 EXPORT_SYMBOL(remove_inode_hash);
440
441 void end_writeback(struct inode *inode)
442 {
443         might_sleep();
444         BUG_ON(inode->i_data.nrpages);
445         BUG_ON(!list_empty(&inode->i_data.private_list));
446         BUG_ON(!(inode->i_state & I_FREEING));
447         BUG_ON(inode->i_state & I_CLEAR);
448         inode_sync_wait(inode);
449         /* don't need i_lock here, no concurrent mods to i_state */
450         inode->i_state = I_FREEING | I_CLEAR;
451 }
452 EXPORT_SYMBOL(end_writeback);
453
454 /*
455  * Free the inode passed in, removing it from the lists it is still connected
456  * to. We remove any pages still attached to the inode and wait for any IO that
457  * is still in progress before finally destroying the inode.
458  *
459  * An inode must already be marked I_FREEING so that we avoid the inode being
460  * moved back onto lists if we race with other code that manipulates the lists
461  * (e.g. writeback_single_inode). The caller is responsible for setting this.
462  *
463  * An inode must already be removed from the LRU list before being evicted from
464  * the cache. This should occur atomically with setting the I_FREEING state
465  * flag, so no inodes here should ever be on the LRU when being evicted.
466  */
467 static void evict(struct inode *inode)
468 {
469         const struct super_operations *op = inode->i_sb->s_op;
470
471         BUG_ON(!(inode->i_state & I_FREEING));
472         BUG_ON(!list_empty(&inode->i_lru));
473
474         spin_lock(&inode_lock);
475         list_del_init(&inode->i_wb_list);
476         __inode_sb_list_del(inode);
477         spin_unlock(&inode_lock);
478
479         if (op->evict_inode) {
480                 op->evict_inode(inode);
481         } else {
482                 if (inode->i_data.nrpages)
483                         truncate_inode_pages(&inode->i_data, 0);
484                 end_writeback(inode);
485         }
486         if (S_ISBLK(inode->i_mode) && inode->i_bdev)
487                 bd_forget(inode);
488         if (S_ISCHR(inode->i_mode) && inode->i_cdev)
489                 cd_forget(inode);
490
491         remove_inode_hash(inode);
492
493         spin_lock(&inode->i_lock);
494         wake_up_bit(&inode->i_state, __I_NEW);
495         BUG_ON(inode->i_state != (I_FREEING | I_CLEAR));
496         spin_unlock(&inode->i_lock);
497
498         destroy_inode(inode);
499 }
500
501 /*
502  * dispose_list - dispose of the contents of a local list
503  * @head: the head of the list to free
504  *
505  * Dispose-list gets a local list with local inodes in it, so it doesn't
506  * need to worry about list corruption and SMP locks.
507  */
508 static void dispose_list(struct list_head *head)
509 {
510         while (!list_empty(head)) {
511                 struct inode *inode;
512
513                 inode = list_first_entry(head, struct inode, i_lru);
514                 list_del_init(&inode->i_lru);
515
516                 evict(inode);
517         }
518 }
519
520 /**
521  * evict_inodes - evict all evictable inodes for a superblock
522  * @sb:         superblock to operate on
523  *
524  * Make sure that no inodes with zero refcount are retained.  This is
525  * called by superblock shutdown after having MS_ACTIVE flag removed,
526  * so any inode reaching zero refcount during or after that call will
527  * be immediately evicted.
528  */
529 void evict_inodes(struct super_block *sb)
530 {
531         struct inode *inode, *next;
532         LIST_HEAD(dispose);
533
534         spin_lock(&inode_lock);
535         list_for_each_entry_safe(inode, next, &sb->s_inodes, i_sb_list) {
536                 if (atomic_read(&inode->i_count))
537                         continue;
538
539                 spin_lock(&inode->i_lock);
540                 if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
541                         spin_unlock(&inode->i_lock);
542                         continue;
543                 }
544
545                 inode->i_state |= I_FREEING;
546                 if (!(inode->i_state & (I_DIRTY | I_SYNC)))
547                         inodes_stat.nr_unused--;
548                 spin_unlock(&inode->i_lock);
549                 list_move(&inode->i_lru, &dispose);
550         }
551         spin_unlock(&inode_lock);
552
553         dispose_list(&dispose);
554
555         /*
556          * Cycle through iprune_sem to make sure any inode that prune_icache
557          * moved off the list before we took the lock has been fully torn
558          * down.
559          */
560         down_write(&iprune_sem);
561         up_write(&iprune_sem);
562 }
563
564 /**
565  * invalidate_inodes    - attempt to free all inodes on a superblock
566  * @sb:         superblock to operate on
567  * @kill_dirty: flag to guide handling of dirty inodes
568  *
569  * Attempts to free all inodes for a given superblock.  If there were any
570  * busy inodes return a non-zero value, else zero.
571  * If @kill_dirty is set, discard dirty inodes too, otherwise treat
572  * them as busy.
573  */
574 int invalidate_inodes(struct super_block *sb, bool kill_dirty)
575 {
576         int busy = 0;
577         struct inode *inode, *next;
578         LIST_HEAD(dispose);
579
580         spin_lock(&inode_lock);
581         list_for_each_entry_safe(inode, next, &sb->s_inodes, i_sb_list) {
582                 spin_lock(&inode->i_lock);
583                 if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
584                         spin_unlock(&inode->i_lock);
585                         continue;
586                 }
587                 if (inode->i_state & I_DIRTY && !kill_dirty) {
588                         spin_unlock(&inode->i_lock);
589                         busy = 1;
590                         continue;
591                 }
592                 if (atomic_read(&inode->i_count)) {
593                         spin_unlock(&inode->i_lock);
594                         busy = 1;
595                         continue;
596                 }
597
598                 inode->i_state |= I_FREEING;
599                 if (!(inode->i_state & (I_DIRTY | I_SYNC)))
600                         inodes_stat.nr_unused--;
601                 spin_unlock(&inode->i_lock);
602                 list_move(&inode->i_lru, &dispose);
603         }
604         spin_unlock(&inode_lock);
605
606         dispose_list(&dispose);
607
608         return busy;
609 }
610
611 static int can_unuse(struct inode *inode)
612 {
613         if (inode->i_state & ~I_REFERENCED)
614                 return 0;
615         if (inode_has_buffers(inode))
616                 return 0;
617         if (atomic_read(&inode->i_count))
618                 return 0;
619         if (inode->i_data.nrpages)
620                 return 0;
621         return 1;
622 }
623
624 /*
625  * Scan `goal' inodes on the unused list for freeable ones. They are moved to a
626  * temporary list and then are freed outside inode_lock by dispose_list().
627  *
628  * Any inodes which are pinned purely because of attached pagecache have their
629  * pagecache removed.  If the inode has metadata buffers attached to
630  * mapping->private_list then try to remove them.
631  *
632  * If the inode has the I_REFERENCED flag set, then it means that it has been
633  * used recently - the flag is set in iput_final(). When we encounter such an
634  * inode, clear the flag and move it to the back of the LRU so it gets another
635  * pass through the LRU before it gets reclaimed. This is necessary because of
636  * the fact we are doing lazy LRU updates to minimise lock contention so the
637  * LRU does not have strict ordering. Hence we don't want to reclaim inodes
638  * with this flag set because they are the inodes that are out of order.
639  */
640 static void prune_icache(int nr_to_scan)
641 {
642         LIST_HEAD(freeable);
643         int nr_scanned;
644         unsigned long reap = 0;
645
646         down_read(&iprune_sem);
647         spin_lock(&inode_lock);
648         for (nr_scanned = 0; nr_scanned < nr_to_scan; nr_scanned++) {
649                 struct inode *inode;
650
651                 if (list_empty(&inode_lru))
652                         break;
653
654                 inode = list_entry(inode_lru.prev, struct inode, i_lru);
655
656                 /*
657                  * Referenced or dirty inodes are still in use. Give them
658                  * another pass through the LRU as we canot reclaim them now.
659                  */
660                 spin_lock(&inode->i_lock);
661                 if (atomic_read(&inode->i_count) ||
662                     (inode->i_state & ~I_REFERENCED)) {
663                         spin_unlock(&inode->i_lock);
664                         list_del_init(&inode->i_lru);
665                         inodes_stat.nr_unused--;
666                         continue;
667                 }
668
669                 /* recently referenced inodes get one more pass */
670                 if (inode->i_state & I_REFERENCED) {
671                         inode->i_state &= ~I_REFERENCED;
672                         spin_unlock(&inode->i_lock);
673                         list_move(&inode->i_lru, &inode_lru);
674                         continue;
675                 }
676                 if (inode_has_buffers(inode) || inode->i_data.nrpages) {
677                         __iget(inode);
678                         spin_unlock(&inode->i_lock);
679                         spin_unlock(&inode_lock);
680                         if (remove_inode_buffers(inode))
681                                 reap += invalidate_mapping_pages(&inode->i_data,
682                                                                 0, -1);
683                         iput(inode);
684                         spin_lock(&inode_lock);
685
686                         if (inode != list_entry(inode_lru.next,
687                                                 struct inode, i_lru))
688                                 continue;       /* wrong inode or list_empty */
689                         spin_lock(&inode->i_lock);
690                         if (!can_unuse(inode)) {
691                                 spin_unlock(&inode->i_lock);
692                                 continue;
693                         }
694                 }
695                 WARN_ON(inode->i_state & I_NEW);
696                 inode->i_state |= I_FREEING;
697                 spin_unlock(&inode->i_lock);
698
699                 list_move(&inode->i_lru, &freeable);
700                 inodes_stat.nr_unused--;
701         }
702         if (current_is_kswapd())
703                 __count_vm_events(KSWAPD_INODESTEAL, reap);
704         else
705                 __count_vm_events(PGINODESTEAL, reap);
706         spin_unlock(&inode_lock);
707
708         dispose_list(&freeable);
709         up_read(&iprune_sem);
710 }
711
712 /*
713  * shrink_icache_memory() will attempt to reclaim some unused inodes.  Here,
714  * "unused" means that no dentries are referring to the inodes: the files are
715  * not open and the dcache references to those inodes have already been
716  * reclaimed.
717  *
718  * This function is passed the number of inodes to scan, and it returns the
719  * total number of remaining possibly-reclaimable inodes.
720  */
721 static int shrink_icache_memory(struct shrinker *shrink, int nr, gfp_t gfp_mask)
722 {
723         if (nr) {
724                 /*
725                  * Nasty deadlock avoidance.  We may hold various FS locks,
726                  * and we don't want to recurse into the FS that called us
727                  * in clear_inode() and friends..
728                  */
729                 if (!(gfp_mask & __GFP_FS))
730                         return -1;
731                 prune_icache(nr);
732         }
733         return (get_nr_inodes_unused() / 100) * sysctl_vfs_cache_pressure;
734 }
735
736 static struct shrinker icache_shrinker = {
737         .shrink = shrink_icache_memory,
738         .seeks = DEFAULT_SEEKS,
739 };
740
741 static void __wait_on_freeing_inode(struct inode *inode);
742 /*
743  * Called with the inode lock held.
744  */
745 static struct inode *find_inode(struct super_block *sb,
746                                 struct hlist_head *head,
747                                 int (*test)(struct inode *, void *),
748                                 void *data)
749 {
750         struct hlist_node *node;
751         struct inode *inode = NULL;
752
753 repeat:
754         hlist_for_each_entry(inode, node, head, i_hash) {
755                 if (inode->i_sb != sb)
756                         continue;
757                 if (!test(inode, data))
758                         continue;
759                 spin_lock(&inode->i_lock);
760                 if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
761                         __wait_on_freeing_inode(inode);
762                         goto repeat;
763                 }
764                 __iget(inode);
765                 spin_unlock(&inode->i_lock);
766                 return inode;
767         }
768         return NULL;
769 }
770
771 /*
772  * find_inode_fast is the fast path version of find_inode, see the comment at
773  * iget_locked for details.
774  */
775 static struct inode *find_inode_fast(struct super_block *sb,
776                                 struct hlist_head *head, unsigned long ino)
777 {
778         struct hlist_node *node;
779         struct inode *inode = NULL;
780
781 repeat:
782         hlist_for_each_entry(inode, node, head, i_hash) {
783                 if (inode->i_ino != ino)
784                         continue;
785                 if (inode->i_sb != sb)
786                         continue;
787                 spin_lock(&inode->i_lock);
788                 if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
789                         __wait_on_freeing_inode(inode);
790                         goto repeat;
791                 }
792                 __iget(inode);
793                 spin_unlock(&inode->i_lock);
794                 return inode;
795         }
796         return NULL;
797 }
798
799 /*
800  * Each cpu owns a range of LAST_INO_BATCH numbers.
801  * 'shared_last_ino' is dirtied only once out of LAST_INO_BATCH allocations,
802  * to renew the exhausted range.
803  *
804  * This does not significantly increase overflow rate because every CPU can
805  * consume at most LAST_INO_BATCH-1 unused inode numbers. So there is
806  * NR_CPUS*(LAST_INO_BATCH-1) wastage. At 4096 and 1024, this is ~0.1% of the
807  * 2^32 range, and is a worst-case. Even a 50% wastage would only increase
808  * overflow rate by 2x, which does not seem too significant.
809  *
810  * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
811  * error if st_ino won't fit in target struct field. Use 32bit counter
812  * here to attempt to avoid that.
813  */
814 #define LAST_INO_BATCH 1024
815 static DEFINE_PER_CPU(unsigned int, last_ino);
816
817 unsigned int get_next_ino(void)
818 {
819         unsigned int *p = &get_cpu_var(last_ino);
820         unsigned int res = *p;
821
822 #ifdef CONFIG_SMP
823         if (unlikely((res & (LAST_INO_BATCH-1)) == 0)) {
824                 static atomic_t shared_last_ino;
825                 int next = atomic_add_return(LAST_INO_BATCH, &shared_last_ino);
826
827                 res = next - LAST_INO_BATCH;
828         }
829 #endif
830
831         *p = ++res;
832         put_cpu_var(last_ino);
833         return res;
834 }
835 EXPORT_SYMBOL(get_next_ino);
836
837 /**
838  *      new_inode       - obtain an inode
839  *      @sb: superblock
840  *
841  *      Allocates a new inode for given superblock. The default gfp_mask
842  *      for allocations related to inode->i_mapping is GFP_HIGHUSER_MOVABLE.
843  *      If HIGHMEM pages are unsuitable or it is known that pages allocated
844  *      for the page cache are not reclaimable or migratable,
845  *      mapping_set_gfp_mask() must be called with suitable flags on the
846  *      newly created inode's mapping
847  *
848  */
849 struct inode *new_inode(struct super_block *sb)
850 {
851         struct inode *inode;
852
853         spin_lock_prefetch(&inode_lock);
854
855         inode = alloc_inode(sb);
856         if (inode) {
857                 spin_lock(&inode_lock);
858                 spin_lock(&inode->i_lock);
859                 inode->i_state = 0;
860                 spin_unlock(&inode->i_lock);
861                 __inode_sb_list_add(inode);
862                 spin_unlock(&inode_lock);
863         }
864         return inode;
865 }
866 EXPORT_SYMBOL(new_inode);
867
868 /**
869  * unlock_new_inode - clear the I_NEW state and wake up any waiters
870  * @inode:      new inode to unlock
871  *
872  * Called when the inode is fully initialised to clear the new state of the
873  * inode and wake up anyone waiting for the inode to finish initialisation.
874  */
875 void unlock_new_inode(struct inode *inode)
876 {
877 #ifdef CONFIG_DEBUG_LOCK_ALLOC
878         if (S_ISDIR(inode->i_mode)) {
879                 struct file_system_type *type = inode->i_sb->s_type;
880
881                 /* Set new key only if filesystem hasn't already changed it */
882                 if (!lockdep_match_class(&inode->i_mutex,
883                     &type->i_mutex_key)) {
884                         /*
885                          * ensure nobody is actually holding i_mutex
886                          */
887                         mutex_destroy(&inode->i_mutex);
888                         mutex_init(&inode->i_mutex);
889                         lockdep_set_class(&inode->i_mutex,
890                                           &type->i_mutex_dir_key);
891                 }
892         }
893 #endif
894         spin_lock(&inode->i_lock);
895         WARN_ON(!(inode->i_state & I_NEW));
896         inode->i_state &= ~I_NEW;
897         wake_up_bit(&inode->i_state, __I_NEW);
898         spin_unlock(&inode->i_lock);
899 }
900 EXPORT_SYMBOL(unlock_new_inode);
901
902 /*
903  * This is called without the inode lock held.. Be careful.
904  *
905  * We no longer cache the sb_flags in i_flags - see fs.h
906  *      -- rmk@arm.uk.linux.org
907  */
908 static struct inode *get_new_inode(struct super_block *sb,
909                                 struct hlist_head *head,
910                                 int (*test)(struct inode *, void *),
911                                 int (*set)(struct inode *, void *),
912                                 void *data)
913 {
914         struct inode *inode;
915
916         inode = alloc_inode(sb);
917         if (inode) {
918                 struct inode *old;
919
920                 spin_lock(&inode_lock);
921                 /* We released the lock, so.. */
922                 old = find_inode(sb, head, test, data);
923                 if (!old) {
924                         if (set(inode, data))
925                                 goto set_failed;
926
927                         spin_lock(&inode->i_lock);
928                         inode->i_state = I_NEW;
929                         hlist_add_head(&inode->i_hash, head);
930                         spin_unlock(&inode->i_lock);
931                         __inode_sb_list_add(inode);
932                         spin_unlock(&inode_lock);
933
934                         /* Return the locked inode with I_NEW set, the
935                          * caller is responsible for filling in the contents
936                          */
937                         return inode;
938                 }
939
940                 /*
941                  * Uhhuh, somebody else created the same inode under
942                  * us. Use the old inode instead of the one we just
943                  * allocated.
944                  */
945                 spin_unlock(&inode_lock);
946                 destroy_inode(inode);
947                 inode = old;
948                 wait_on_inode(inode);
949         }
950         return inode;
951
952 set_failed:
953         spin_unlock(&inode_lock);
954         destroy_inode(inode);
955         return NULL;
956 }
957
958 /*
959  * get_new_inode_fast is the fast path version of get_new_inode, see the
960  * comment at iget_locked for details.
961  */
962 static struct inode *get_new_inode_fast(struct super_block *sb,
963                                 struct hlist_head *head, unsigned long ino)
964 {
965         struct inode *inode;
966
967         inode = alloc_inode(sb);
968         if (inode) {
969                 struct inode *old;
970
971                 spin_lock(&inode_lock);
972                 /* We released the lock, so.. */
973                 old = find_inode_fast(sb, head, ino);
974                 if (!old) {
975                         inode->i_ino = ino;
976                         spin_lock(&inode->i_lock);
977                         inode->i_state = I_NEW;
978                         hlist_add_head(&inode->i_hash, head);
979                         spin_unlock(&inode->i_lock);
980                         __inode_sb_list_add(inode);
981                         spin_unlock(&inode_lock);
982
983                         /* Return the locked inode with I_NEW set, the
984                          * caller is responsible for filling in the contents
985                          */
986                         return inode;
987                 }
988
989                 /*
990                  * Uhhuh, somebody else created the same inode under
991                  * us. Use the old inode instead of the one we just
992                  * allocated.
993                  */
994                 spin_unlock(&inode_lock);
995                 destroy_inode(inode);
996                 inode = old;
997                 wait_on_inode(inode);
998         }
999         return inode;
1000 }
1001
1002 /*
1003  * search the inode cache for a matching inode number.
1004  * If we find one, then the inode number we are trying to
1005  * allocate is not unique and so we should not use it.
1006  *
1007  * Returns 1 if the inode number is unique, 0 if it is not.
1008  */
1009 static int test_inode_iunique(struct super_block *sb, unsigned long ino)
1010 {
1011         struct hlist_head *b = inode_hashtable + hash(sb, ino);
1012         struct hlist_node *node;
1013         struct inode *inode;
1014
1015         hlist_for_each_entry(inode, node, b, i_hash) {
1016                 if (inode->i_ino == ino && inode->i_sb == sb)
1017                         return 0;
1018         }
1019
1020         return 1;
1021 }
1022
1023 /**
1024  *      iunique - get a unique inode number
1025  *      @sb: superblock
1026  *      @max_reserved: highest reserved inode number
1027  *
1028  *      Obtain an inode number that is unique on the system for a given
1029  *      superblock. This is used by file systems that have no natural
1030  *      permanent inode numbering system. An inode number is returned that
1031  *      is higher than the reserved limit but unique.
1032  *
1033  *      BUGS:
1034  *      With a large number of inodes live on the file system this function
1035  *      currently becomes quite slow.
1036  */
1037 ino_t iunique(struct super_block *sb, ino_t max_reserved)
1038 {
1039         /*
1040          * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
1041          * error if st_ino won't fit in target struct field. Use 32bit counter
1042          * here to attempt to avoid that.
1043          */
1044         static DEFINE_SPINLOCK(iunique_lock);
1045         static unsigned int counter;
1046         ino_t res;
1047
1048         spin_lock(&inode_lock);
1049         spin_lock(&iunique_lock);
1050         do {
1051                 if (counter <= max_reserved)
1052                         counter = max_reserved + 1;
1053                 res = counter++;
1054         } while (!test_inode_iunique(sb, res));
1055         spin_unlock(&iunique_lock);
1056         spin_unlock(&inode_lock);
1057
1058         return res;
1059 }
1060 EXPORT_SYMBOL(iunique);
1061
1062 struct inode *igrab(struct inode *inode)
1063 {
1064         spin_lock(&inode_lock);
1065         spin_lock(&inode->i_lock);
1066         if (!(inode->i_state & (I_FREEING|I_WILL_FREE))) {
1067                 __iget(inode);
1068                 spin_unlock(&inode->i_lock);
1069         } else {
1070                 spin_unlock(&inode->i_lock);
1071                 /*
1072                  * Handle the case where s_op->clear_inode is not been
1073                  * called yet, and somebody is calling igrab
1074                  * while the inode is getting freed.
1075                  */
1076                 inode = NULL;
1077         }
1078         spin_unlock(&inode_lock);
1079         return inode;
1080 }
1081 EXPORT_SYMBOL(igrab);
1082
1083 /**
1084  * ifind - internal function, you want ilookup5() or iget5().
1085  * @sb:         super block of file system to search
1086  * @head:       the head of the list to search
1087  * @test:       callback used for comparisons between inodes
1088  * @data:       opaque data pointer to pass to @test
1089  * @wait:       if true wait for the inode to be unlocked, if false do not
1090  *
1091  * ifind() searches for the inode specified by @data in the inode
1092  * cache. This is a generalized version of ifind_fast() for file systems where
1093  * the inode number is not sufficient for unique identification of an inode.
1094  *
1095  * If the inode is in the cache, the inode is returned with an incremented
1096  * reference count.
1097  *
1098  * Otherwise NULL is returned.
1099  *
1100  * Note, @test is called with the inode_lock held, so can't sleep.
1101  */
1102 static struct inode *ifind(struct super_block *sb,
1103                 struct hlist_head *head, int (*test)(struct inode *, void *),
1104                 void *data, const int wait)
1105 {
1106         struct inode *inode;
1107
1108         spin_lock(&inode_lock);
1109         inode = find_inode(sb, head, test, data);
1110         if (inode) {
1111                 spin_unlock(&inode_lock);
1112                 if (likely(wait))
1113                         wait_on_inode(inode);
1114                 return inode;
1115         }
1116         spin_unlock(&inode_lock);
1117         return NULL;
1118 }
1119
1120 /**
1121  * ifind_fast - internal function, you want ilookup() or iget().
1122  * @sb:         super block of file system to search
1123  * @head:       head of the list to search
1124  * @ino:        inode number to search for
1125  *
1126  * ifind_fast() searches for the inode @ino in the inode cache. This is for
1127  * file systems where the inode number is sufficient for unique identification
1128  * of an inode.
1129  *
1130  * If the inode is in the cache, the inode is returned with an incremented
1131  * reference count.
1132  *
1133  * Otherwise NULL is returned.
1134  */
1135 static struct inode *ifind_fast(struct super_block *sb,
1136                 struct hlist_head *head, unsigned long ino)
1137 {
1138         struct inode *inode;
1139
1140         spin_lock(&inode_lock);
1141         inode = find_inode_fast(sb, head, ino);
1142         if (inode) {
1143                 spin_unlock(&inode_lock);
1144                 wait_on_inode(inode);
1145                 return inode;
1146         }
1147         spin_unlock(&inode_lock);
1148         return NULL;
1149 }
1150
1151 /**
1152  * ilookup5_nowait - search for an inode in the inode cache
1153  * @sb:         super block of file system to search
1154  * @hashval:    hash value (usually inode number) to search for
1155  * @test:       callback used for comparisons between inodes
1156  * @data:       opaque data pointer to pass to @test
1157  *
1158  * ilookup5() uses ifind() to search for the inode specified by @hashval and
1159  * @data in the inode cache. This is a generalized version of ilookup() for
1160  * file systems where the inode number is not sufficient for unique
1161  * identification of an inode.
1162  *
1163  * If the inode is in the cache, the inode is returned with an incremented
1164  * reference count.  Note, the inode lock is not waited upon so you have to be
1165  * very careful what you do with the returned inode.  You probably should be
1166  * using ilookup5() instead.
1167  *
1168  * Otherwise NULL is returned.
1169  *
1170  * Note, @test is called with the inode_lock held, so can't sleep.
1171  */
1172 struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval,
1173                 int (*test)(struct inode *, void *), void *data)
1174 {
1175         struct hlist_head *head = inode_hashtable + hash(sb, hashval);
1176
1177         return ifind(sb, head, test, data, 0);
1178 }
1179 EXPORT_SYMBOL(ilookup5_nowait);
1180
1181 /**
1182  * ilookup5 - search for an inode in the inode cache
1183  * @sb:         super block of file system to search
1184  * @hashval:    hash value (usually inode number) to search for
1185  * @test:       callback used for comparisons between inodes
1186  * @data:       opaque data pointer to pass to @test
1187  *
1188  * ilookup5() uses ifind() to search for the inode specified by @hashval and
1189  * @data in the inode cache. This is a generalized version of ilookup() for
1190  * file systems where the inode number is not sufficient for unique
1191  * identification of an inode.
1192  *
1193  * If the inode is in the cache, the inode lock is waited upon and the inode is
1194  * returned with an incremented reference count.
1195  *
1196  * Otherwise NULL is returned.
1197  *
1198  * Note, @test is called with the inode_lock held, so can't sleep.
1199  */
1200 struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
1201                 int (*test)(struct inode *, void *), void *data)
1202 {
1203         struct hlist_head *head = inode_hashtable + hash(sb, hashval);
1204
1205         return ifind(sb, head, test, data, 1);
1206 }
1207 EXPORT_SYMBOL(ilookup5);
1208
1209 /**
1210  * ilookup - search for an inode in the inode cache
1211  * @sb:         super block of file system to search
1212  * @ino:        inode number to search for
1213  *
1214  * ilookup() uses ifind_fast() to search for the inode @ino in the inode cache.
1215  * This is for file systems where the inode number is sufficient for unique
1216  * identification of an inode.
1217  *
1218  * If the inode is in the cache, the inode is returned with an incremented
1219  * reference count.
1220  *
1221  * Otherwise NULL is returned.
1222  */
1223 struct inode *ilookup(struct super_block *sb, unsigned long ino)
1224 {
1225         struct hlist_head *head = inode_hashtable + hash(sb, ino);
1226
1227         return ifind_fast(sb, head, ino);
1228 }
1229 EXPORT_SYMBOL(ilookup);
1230
1231 /**
1232  * iget5_locked - obtain an inode from a mounted file system
1233  * @sb:         super block of file system
1234  * @hashval:    hash value (usually inode number) to get
1235  * @test:       callback used for comparisons between inodes
1236  * @set:        callback used to initialize a new struct inode
1237  * @data:       opaque data pointer to pass to @test and @set
1238  *
1239  * iget5_locked() uses ifind() to search for the inode specified by @hashval
1240  * and @data in the inode cache and if present it is returned with an increased
1241  * reference count. This is a generalized version of iget_locked() for file
1242  * systems where the inode number is not sufficient for unique identification
1243  * of an inode.
1244  *
1245  * If the inode is not in cache, get_new_inode() is called to allocate a new
1246  * inode and this is returned locked, hashed, and with the I_NEW flag set. The
1247  * file system gets to fill it in before unlocking it via unlock_new_inode().
1248  *
1249  * Note both @test and @set are called with the inode_lock held, so can't sleep.
1250  */
1251 struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
1252                 int (*test)(struct inode *, void *),
1253                 int (*set)(struct inode *, void *), void *data)
1254 {
1255         struct hlist_head *head = inode_hashtable + hash(sb, hashval);
1256         struct inode *inode;
1257
1258         inode = ifind(sb, head, test, data, 1);
1259         if (inode)
1260                 return inode;
1261         /*
1262          * get_new_inode() will do the right thing, re-trying the search
1263          * in case it had to block at any point.
1264          */
1265         return get_new_inode(sb, head, test, set, data);
1266 }
1267 EXPORT_SYMBOL(iget5_locked);
1268
1269 /**
1270  * iget_locked - obtain an inode from a mounted file system
1271  * @sb:         super block of file system
1272  * @ino:        inode number to get
1273  *
1274  * iget_locked() uses ifind_fast() to search for the inode specified by @ino in
1275  * the inode cache and if present it is returned with an increased reference
1276  * count. This is for file systems where the inode number is sufficient for
1277  * unique identification of an inode.
1278  *
1279  * If the inode is not in cache, get_new_inode_fast() is called to allocate a
1280  * new inode and this is returned locked, hashed, and with the I_NEW flag set.
1281  * The file system gets to fill it in before unlocking it via
1282  * unlock_new_inode().
1283  */
1284 struct inode *iget_locked(struct super_block *sb, unsigned long ino)
1285 {
1286         struct hlist_head *head = inode_hashtable + hash(sb, ino);
1287         struct inode *inode;
1288
1289         inode = ifind_fast(sb, head, ino);
1290         if (inode)
1291                 return inode;
1292         /*
1293          * get_new_inode_fast() will do the right thing, re-trying the search
1294          * in case it had to block at any point.
1295          */
1296         return get_new_inode_fast(sb, head, ino);
1297 }
1298 EXPORT_SYMBOL(iget_locked);
1299
1300 int insert_inode_locked(struct inode *inode)
1301 {
1302         struct super_block *sb = inode->i_sb;
1303         ino_t ino = inode->i_ino;
1304         struct hlist_head *head = inode_hashtable + hash(sb, ino);
1305
1306         while (1) {
1307                 struct hlist_node *node;
1308                 struct inode *old = NULL;
1309                 spin_lock(&inode_lock);
1310                 hlist_for_each_entry(old, node, head, i_hash) {
1311                         if (old->i_ino != ino)
1312                                 continue;
1313                         if (old->i_sb != sb)
1314                                 continue;
1315                         spin_lock(&old->i_lock);
1316                         if (old->i_state & (I_FREEING|I_WILL_FREE)) {
1317                                 spin_unlock(&old->i_lock);
1318                                 continue;
1319                         }
1320                         break;
1321                 }
1322                 if (likely(!node)) {
1323                         spin_lock(&inode->i_lock);
1324                         inode->i_state |= I_NEW;
1325                         hlist_add_head(&inode->i_hash, head);
1326                         spin_unlock(&inode->i_lock);
1327                         spin_unlock(&inode_lock);
1328                         return 0;
1329                 }
1330                 __iget(old);
1331                 spin_unlock(&old->i_lock);
1332                 spin_unlock(&inode_lock);
1333                 wait_on_inode(old);
1334                 if (unlikely(!inode_unhashed(old))) {
1335                         iput(old);
1336                         return -EBUSY;
1337                 }
1338                 iput(old);
1339         }
1340 }
1341 EXPORT_SYMBOL(insert_inode_locked);
1342
1343 int insert_inode_locked4(struct inode *inode, unsigned long hashval,
1344                 int (*test)(struct inode *, void *), void *data)
1345 {
1346         struct super_block *sb = inode->i_sb;
1347         struct hlist_head *head = inode_hashtable + hash(sb, hashval);
1348
1349         while (1) {
1350                 struct hlist_node *node;
1351                 struct inode *old = NULL;
1352
1353                 spin_lock(&inode_lock);
1354                 hlist_for_each_entry(old, node, head, i_hash) {
1355                         if (old->i_sb != sb)
1356                                 continue;
1357                         if (!test(old, data))
1358                                 continue;
1359                         spin_lock(&old->i_lock);
1360                         if (old->i_state & (I_FREEING|I_WILL_FREE)) {
1361                                 spin_unlock(&old->i_lock);
1362                                 continue;
1363                         }
1364                         break;
1365                 }
1366                 if (likely(!node)) {
1367                         spin_lock(&inode->i_lock);
1368                         inode->i_state |= I_NEW;
1369                         hlist_add_head(&inode->i_hash, head);
1370                         spin_unlock(&inode->i_lock);
1371                         spin_unlock(&inode_lock);
1372                         return 0;
1373                 }
1374                 __iget(old);
1375                 spin_unlock(&old->i_lock);
1376                 spin_unlock(&inode_lock);
1377                 wait_on_inode(old);
1378                 if (unlikely(!inode_unhashed(old))) {
1379                         iput(old);
1380                         return -EBUSY;
1381                 }
1382                 iput(old);
1383         }
1384 }
1385 EXPORT_SYMBOL(insert_inode_locked4);
1386
1387
1388 int generic_delete_inode(struct inode *inode)
1389 {
1390         return 1;
1391 }
1392 EXPORT_SYMBOL(generic_delete_inode);
1393
1394 /*
1395  * Normal UNIX filesystem behaviour: delete the
1396  * inode when the usage count drops to zero, and
1397  * i_nlink is zero.
1398  */
1399 int generic_drop_inode(struct inode *inode)
1400 {
1401         return !inode->i_nlink || inode_unhashed(inode);
1402 }
1403 EXPORT_SYMBOL_GPL(generic_drop_inode);
1404
1405 /*
1406  * Called when we're dropping the last reference
1407  * to an inode.
1408  *
1409  * Call the FS "drop_inode()" function, defaulting to
1410  * the legacy UNIX filesystem behaviour.  If it tells
1411  * us to evict inode, do so.  Otherwise, retain inode
1412  * in cache if fs is alive, sync and evict if fs is
1413  * shutting down.
1414  */
1415 static void iput_final(struct inode *inode)
1416 {
1417         struct super_block *sb = inode->i_sb;
1418         const struct super_operations *op = inode->i_sb->s_op;
1419         int drop;
1420
1421         spin_lock(&inode->i_lock);
1422         WARN_ON(inode->i_state & I_NEW);
1423
1424         if (op && op->drop_inode)
1425                 drop = op->drop_inode(inode);
1426         else
1427                 drop = generic_drop_inode(inode);
1428
1429         if (!drop && (sb->s_flags & MS_ACTIVE)) {
1430                 inode->i_state |= I_REFERENCED;
1431                 if (!(inode->i_state & (I_DIRTY|I_SYNC)))
1432                         inode_lru_list_add(inode);
1433                 spin_unlock(&inode->i_lock);
1434                 spin_unlock(&inode_lock);
1435                 return;
1436         }
1437
1438         if (!drop) {
1439                 inode->i_state |= I_WILL_FREE;
1440                 spin_unlock(&inode->i_lock);
1441                 spin_unlock(&inode_lock);
1442                 write_inode_now(inode, 1);
1443                 spin_lock(&inode_lock);
1444                 spin_lock(&inode->i_lock);
1445                 WARN_ON(inode->i_state & I_NEW);
1446                 inode->i_state &= ~I_WILL_FREE;
1447         }
1448
1449         inode->i_state |= I_FREEING;
1450         inode_lru_list_del(inode);
1451         spin_unlock(&inode->i_lock);
1452         spin_unlock(&inode_lock);
1453
1454         evict(inode);
1455 }
1456
1457 /**
1458  *      iput    - put an inode
1459  *      @inode: inode to put
1460  *
1461  *      Puts an inode, dropping its usage count. If the inode use count hits
1462  *      zero, the inode is then freed and may also be destroyed.
1463  *
1464  *      Consequently, iput() can sleep.
1465  */
1466 void iput(struct inode *inode)
1467 {
1468         if (inode) {
1469                 BUG_ON(inode->i_state & I_CLEAR);
1470
1471                 if (atomic_dec_and_lock(&inode->i_count, &inode_lock))
1472                         iput_final(inode);
1473         }
1474 }
1475 EXPORT_SYMBOL(iput);
1476
1477 /**
1478  *      bmap    - find a block number in a file
1479  *      @inode: inode of file
1480  *      @block: block to find
1481  *
1482  *      Returns the block number on the device holding the inode that
1483  *      is the disk block number for the block of the file requested.
1484  *      That is, asked for block 4 of inode 1 the function will return the
1485  *      disk block relative to the disk start that holds that block of the
1486  *      file.
1487  */
1488 sector_t bmap(struct inode *inode, sector_t block)
1489 {
1490         sector_t res = 0;
1491         if (inode->i_mapping->a_ops->bmap)
1492                 res = inode->i_mapping->a_ops->bmap(inode->i_mapping, block);
1493         return res;
1494 }
1495 EXPORT_SYMBOL(bmap);
1496
1497 /*
1498  * With relative atime, only update atime if the previous atime is
1499  * earlier than either the ctime or mtime or if at least a day has
1500  * passed since the last atime update.
1501  */
1502 static int relatime_need_update(struct vfsmount *mnt, struct inode *inode,
1503                              struct timespec now)
1504 {
1505
1506         if (!(mnt->mnt_flags & MNT_RELATIME))
1507                 return 1;
1508         /*
1509          * Is mtime younger than atime? If yes, update atime:
1510          */
1511         if (timespec_compare(&inode->i_mtime, &inode->i_atime) >= 0)
1512                 return 1;
1513         /*
1514          * Is ctime younger than atime? If yes, update atime:
1515          */
1516         if (timespec_compare(&inode->i_ctime, &inode->i_atime) >= 0)
1517                 return 1;
1518
1519         /*
1520          * Is the previous atime value older than a day? If yes,
1521          * update atime:
1522          */
1523         if ((long)(now.tv_sec - inode->i_atime.tv_sec) >= 24*60*60)
1524                 return 1;
1525         /*
1526          * Good, we can skip the atime update:
1527          */
1528         return 0;
1529 }
1530
1531 /**
1532  *      touch_atime     -       update the access time
1533  *      @mnt: mount the inode is accessed on
1534  *      @dentry: dentry accessed
1535  *
1536  *      Update the accessed time on an inode and mark it for writeback.
1537  *      This function automatically handles read only file systems and media,
1538  *      as well as the "noatime" flag and inode specific "noatime" markers.
1539  */
1540 void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
1541 {
1542         struct inode *inode = dentry->d_inode;
1543         struct timespec now;
1544
1545         if (inode->i_flags & S_NOATIME)
1546                 return;
1547         if (IS_NOATIME(inode))
1548                 return;
1549         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1550                 return;
1551
1552         if (mnt->mnt_flags & MNT_NOATIME)
1553                 return;
1554         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1555                 return;
1556
1557         now = current_fs_time(inode->i_sb);
1558
1559         if (!relatime_need_update(mnt, inode, now))
1560                 return;
1561
1562         if (timespec_equal(&inode->i_atime, &now))
1563                 return;
1564
1565         if (mnt_want_write(mnt))
1566                 return;
1567
1568         inode->i_atime = now;
1569         mark_inode_dirty_sync(inode);
1570         mnt_drop_write(mnt);
1571 }
1572 EXPORT_SYMBOL(touch_atime);
1573
1574 /**
1575  *      file_update_time        -       update mtime and ctime time
1576  *      @file: file accessed
1577  *
1578  *      Update the mtime and ctime members of an inode and mark the inode
1579  *      for writeback.  Note that this function is meant exclusively for
1580  *      usage in the file write path of filesystems, and filesystems may
1581  *      choose to explicitly ignore update via this function with the
1582  *      S_NOCMTIME inode flag, e.g. for network filesystem where these
1583  *      timestamps are handled by the server.
1584  */
1585
1586 void file_update_time(struct file *file)
1587 {
1588         struct inode *inode = file->f_path.dentry->d_inode;
1589         struct timespec now;
1590         enum { S_MTIME = 1, S_CTIME = 2, S_VERSION = 4 } sync_it = 0;
1591
1592         /* First try to exhaust all avenues to not sync */
1593         if (IS_NOCMTIME(inode))
1594                 return;
1595
1596         now = current_fs_time(inode->i_sb);
1597         if (!timespec_equal(&inode->i_mtime, &now))
1598                 sync_it = S_MTIME;
1599
1600         if (!timespec_equal(&inode->i_ctime, &now))
1601                 sync_it |= S_CTIME;
1602
1603         if (IS_I_VERSION(inode))
1604                 sync_it |= S_VERSION;
1605
1606         if (!sync_it)
1607                 return;
1608
1609         /* Finally allowed to write? Takes lock. */
1610         if (mnt_want_write_file(file))
1611                 return;
1612
1613         /* Only change inode inside the lock region */
1614         if (sync_it & S_VERSION)
1615                 inode_inc_iversion(inode);
1616         if (sync_it & S_CTIME)
1617                 inode->i_ctime = now;
1618         if (sync_it & S_MTIME)
1619                 inode->i_mtime = now;
1620         mark_inode_dirty_sync(inode);
1621         mnt_drop_write(file->f_path.mnt);
1622 }
1623 EXPORT_SYMBOL(file_update_time);
1624
1625 int inode_needs_sync(struct inode *inode)
1626 {
1627         if (IS_SYNC(inode))
1628                 return 1;
1629         if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
1630                 return 1;
1631         return 0;
1632 }
1633 EXPORT_SYMBOL(inode_needs_sync);
1634
1635 int inode_wait(void *word)
1636 {
1637         schedule();
1638         return 0;
1639 }
1640 EXPORT_SYMBOL(inode_wait);
1641
1642 /*
1643  * If we try to find an inode in the inode hash while it is being
1644  * deleted, we have to wait until the filesystem completes its
1645  * deletion before reporting that it isn't found.  This function waits
1646  * until the deletion _might_ have completed.  Callers are responsible
1647  * to recheck inode state.
1648  *
1649  * It doesn't matter if I_NEW is not set initially, a call to
1650  * wake_up_bit(&inode->i_state, __I_NEW) after removing from the hash list
1651  * will DTRT.
1652  */
1653 static void __wait_on_freeing_inode(struct inode *inode)
1654 {
1655         wait_queue_head_t *wq;
1656         DEFINE_WAIT_BIT(wait, &inode->i_state, __I_NEW);
1657         wq = bit_waitqueue(&inode->i_state, __I_NEW);
1658         prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
1659         spin_unlock(&inode->i_lock);
1660         spin_unlock(&inode_lock);
1661         schedule();
1662         finish_wait(wq, &wait.wait);
1663         spin_lock(&inode_lock);
1664 }
1665
1666 static __initdata unsigned long ihash_entries;
1667 static int __init set_ihash_entries(char *str)
1668 {
1669         if (!str)
1670                 return 0;
1671         ihash_entries = simple_strtoul(str, &str, 0);
1672         return 1;
1673 }
1674 __setup("ihash_entries=", set_ihash_entries);
1675
1676 /*
1677  * Initialize the waitqueues and inode hash table.
1678  */
1679 void __init inode_init_early(void)
1680 {
1681         int loop;
1682
1683         /* If hashes are distributed across NUMA nodes, defer
1684          * hash allocation until vmalloc space is available.
1685          */
1686         if (hashdist)
1687                 return;
1688
1689         inode_hashtable =
1690                 alloc_large_system_hash("Inode-cache",
1691                                         sizeof(struct hlist_head),
1692                                         ihash_entries,
1693                                         14,
1694                                         HASH_EARLY,
1695                                         &i_hash_shift,
1696                                         &i_hash_mask,
1697                                         0);
1698
1699         for (loop = 0; loop < (1 << i_hash_shift); loop++)
1700                 INIT_HLIST_HEAD(&inode_hashtable[loop]);
1701 }
1702
1703 void __init inode_init(void)
1704 {
1705         int loop;
1706
1707         /* inode slab cache */
1708         inode_cachep = kmem_cache_create("inode_cache",
1709                                          sizeof(struct inode),
1710                                          0,
1711                                          (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
1712                                          SLAB_MEM_SPREAD),
1713                                          init_once);
1714         register_shrinker(&icache_shrinker);
1715
1716         /* Hash may have been set up in inode_init_early */
1717         if (!hashdist)
1718                 return;
1719
1720         inode_hashtable =
1721                 alloc_large_system_hash("Inode-cache",
1722                                         sizeof(struct hlist_head),
1723                                         ihash_entries,
1724                                         14,
1725                                         0,
1726                                         &i_hash_shift,
1727                                         &i_hash_mask,
1728                                         0);
1729
1730         for (loop = 0; loop < (1 << i_hash_shift); loop++)
1731                 INIT_HLIST_HEAD(&inode_hashtable[loop]);
1732 }
1733
1734 void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
1735 {
1736         inode->i_mode = mode;
1737         if (S_ISCHR(mode)) {
1738                 inode->i_fop = &def_chr_fops;
1739                 inode->i_rdev = rdev;
1740         } else if (S_ISBLK(mode)) {
1741                 inode->i_fop = &def_blk_fops;
1742                 inode->i_rdev = rdev;
1743         } else if (S_ISFIFO(mode))
1744                 inode->i_fop = &def_fifo_fops;
1745         else if (S_ISSOCK(mode))
1746                 inode->i_fop = &bad_sock_fops;
1747         else
1748                 printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for"
1749                                   " inode %s:%lu\n", mode, inode->i_sb->s_id,
1750                                   inode->i_ino);
1751 }
1752 EXPORT_SYMBOL(init_special_inode);
1753
1754 /**
1755  * inode_init_owner - Init uid,gid,mode for new inode according to posix standards
1756  * @inode: New inode
1757  * @dir: Directory inode
1758  * @mode: mode of the new inode
1759  */
1760 void inode_init_owner(struct inode *inode, const struct inode *dir,
1761                         mode_t mode)
1762 {
1763         inode->i_uid = current_fsuid();
1764         if (dir && dir->i_mode & S_ISGID) {
1765                 inode->i_gid = dir->i_gid;
1766                 if (S_ISDIR(mode))
1767                         mode |= S_ISGID;
1768         } else
1769                 inode->i_gid = current_fsgid();
1770         inode->i_mode = mode;
1771 }
1772 EXPORT_SYMBOL(inode_init_owner);
1773
1774 /**
1775  * inode_owner_or_capable - check current task permissions to inode
1776  * @inode: inode being checked
1777  *
1778  * Return true if current either has CAP_FOWNER to the inode, or
1779  * owns the file.
1780  */
1781 bool inode_owner_or_capable(const struct inode *inode)
1782 {
1783         struct user_namespace *ns = inode_userns(inode);
1784
1785         if (current_user_ns() == ns && current_fsuid() == inode->i_uid)
1786                 return true;
1787         if (ns_capable(ns, CAP_FOWNER))
1788                 return true;
1789         return false;
1790 }
1791 EXPORT_SYMBOL(inode_owner_or_capable);