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