Inode: Allow external initialisers
[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/quotaops.h>
12 #include <linux/slab.h>
13 #include <linux/writeback.h>
14 #include <linux/module.h>
15 #include <linux/backing-dev.h>
16 #include <linux/wait.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/inotify.h>
24 #include <linux/mount.h>
25
26 /*
27  * This is needed for the following functions:
28  *  - inode_has_buffers
29  *  - invalidate_inode_buffers
30  *  - invalidate_bdev
31  *
32  * FIXME: remove all knowledge of the buffer layer from this file
33  */
34 #include <linux/buffer_head.h>
35
36 /*
37  * New inode.c implementation.
38  *
39  * This implementation has the basic premise of trying
40  * to be extremely low-overhead and SMP-safe, yet be
41  * simple enough to be "obviously correct".
42  *
43  * Famous last words.
44  */
45
46 /* inode dynamic allocation 1999, Andrea Arcangeli <andrea@suse.de> */
47
48 /* #define INODE_PARANOIA 1 */
49 /* #define INODE_DEBUG 1 */
50
51 /*
52  * Inode lookup is no longer as critical as it used to be:
53  * most of the lookups are going to be through the dcache.
54  */
55 #define I_HASHBITS      i_hash_shift
56 #define I_HASHMASK      i_hash_mask
57
58 static unsigned int i_hash_mask __read_mostly;
59 static unsigned int i_hash_shift __read_mostly;
60
61 /*
62  * Each inode can be on two separate lists. One is
63  * the hash list of the inode, used for lookups. The
64  * other linked list is the "type" list:
65  *  "in_use" - valid inode, i_count > 0, i_nlink > 0
66  *  "dirty"  - as "in_use" but also dirty
67  *  "unused" - valid inode, i_count = 0
68  *
69  * A "dirty" list is maintained for each super block,
70  * allowing for low-overhead inode sync() operations.
71  */
72
73 LIST_HEAD(inode_in_use);
74 LIST_HEAD(inode_unused);
75 static struct hlist_head *inode_hashtable __read_mostly;
76
77 /*
78  * A simple spinlock to protect the list manipulations.
79  *
80  * NOTE! You also have to own the lock if you change
81  * the i_state of an inode while it is in use..
82  */
83 DEFINE_SPINLOCK(inode_lock);
84
85 /*
86  * iprune_mutex provides exclusion between the kswapd or try_to_free_pages
87  * icache shrinking path, and the umount path.  Without this exclusion,
88  * by the time prune_icache calls iput for the inode whose pages it has
89  * been invalidating, or by the time it calls clear_inode & destroy_inode
90  * from its final dispose_list, the struct super_block they refer to
91  * (for inode->i_sb->s_op) may already have been freed and reused.
92  */
93 static DEFINE_MUTEX(iprune_mutex);
94
95 /*
96  * Statistics gathering..
97  */
98 struct inodes_stat_t inodes_stat;
99
100 static struct kmem_cache * inode_cachep __read_mostly;
101
102 static void wake_up_inode(struct inode *inode)
103 {
104         /*
105          * Prevent speculative execution through spin_unlock(&inode_lock);
106          */
107         smp_mb();
108         wake_up_bit(&inode->i_state, __I_LOCK);
109 }
110
111 /**
112  * inode_init_always - perform inode structure intialisation
113  * @sb          - superblock inode belongs to.
114  * @inode       - inode to initialise
115  *
116  * These are initializations that need to be done on every inode
117  * allocation as the fields are not initialised by slab allocation.
118  */
119 struct inode *inode_init_always(struct super_block *sb, struct inode *inode)
120 {
121         static const struct address_space_operations empty_aops;
122         static struct inode_operations empty_iops;
123         static const struct file_operations empty_fops;
124
125         struct address_space * const mapping = &inode->i_data;
126
127         inode->i_sb = sb;
128         inode->i_blkbits = sb->s_blocksize_bits;
129         inode->i_flags = 0;
130         atomic_set(&inode->i_count, 1);
131         inode->i_op = &empty_iops;
132         inode->i_fop = &empty_fops;
133         inode->i_nlink = 1;
134         atomic_set(&inode->i_writecount, 0);
135         inode->i_size = 0;
136         inode->i_blocks = 0;
137         inode->i_bytes = 0;
138         inode->i_generation = 0;
139 #ifdef CONFIG_QUOTA
140         memset(&inode->i_dquot, 0, sizeof(inode->i_dquot));
141 #endif
142         inode->i_pipe = NULL;
143         inode->i_bdev = NULL;
144         inode->i_cdev = NULL;
145         inode->i_rdev = 0;
146         inode->dirtied_when = 0;
147         if (security_inode_alloc(inode)) {
148                 if (inode->i_sb->s_op->destroy_inode)
149                         inode->i_sb->s_op->destroy_inode(inode);
150                 else
151                         kmem_cache_free(inode_cachep, (inode));
152                 return NULL;
153         }
154
155         spin_lock_init(&inode->i_lock);
156         lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key);
157
158         mutex_init(&inode->i_mutex);
159         lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key);
160
161         init_rwsem(&inode->i_alloc_sem);
162         lockdep_set_class(&inode->i_alloc_sem, &sb->s_type->i_alloc_sem_key);
163
164         mapping->a_ops = &empty_aops;
165         mapping->host = inode;
166         mapping->flags = 0;
167         mapping_set_gfp_mask(mapping, GFP_HIGHUSER_PAGECACHE);
168         mapping->assoc_mapping = NULL;
169         mapping->backing_dev_info = &default_backing_dev_info;
170         mapping->writeback_index = 0;
171
172         /*
173          * If the block_device provides a backing_dev_info for client
174          * inodes then use that.  Otherwise the inode share the bdev's
175          * backing_dev_info.
176          */
177         if (sb->s_bdev) {
178                 struct backing_dev_info *bdi;
179
180                 bdi = sb->s_bdev->bd_inode_backing_dev_info;
181                 if (!bdi)
182                         bdi = sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
183                 mapping->backing_dev_info = bdi;
184         }
185         inode->i_private = NULL;
186         inode->i_mapping = mapping;
187
188         return inode;
189 }
190 EXPORT_SYMBOL(inode_init_always);
191
192 static struct inode *alloc_inode(struct super_block *sb)
193 {
194         struct inode *inode;
195
196         if (sb->s_op->alloc_inode)
197                 inode = sb->s_op->alloc_inode(sb);
198         else
199                 inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL);
200
201         if (inode)
202                 return inode_init_always(sb, inode);
203         return NULL;
204 }
205
206 void destroy_inode(struct inode *inode) 
207 {
208         BUG_ON(inode_has_buffers(inode));
209         security_inode_free(inode);
210         if (inode->i_sb->s_op->destroy_inode)
211                 inode->i_sb->s_op->destroy_inode(inode);
212         else
213                 kmem_cache_free(inode_cachep, (inode));
214 }
215
216
217 /*
218  * These are initializations that only need to be done
219  * once, because the fields are idempotent across use
220  * of the inode, so let the slab aware of that.
221  */
222 void inode_init_once(struct inode *inode)
223 {
224         memset(inode, 0, sizeof(*inode));
225         INIT_HLIST_NODE(&inode->i_hash);
226         INIT_LIST_HEAD(&inode->i_dentry);
227         INIT_LIST_HEAD(&inode->i_devices);
228         INIT_RADIX_TREE(&inode->i_data.page_tree, GFP_ATOMIC);
229         spin_lock_init(&inode->i_data.tree_lock);
230         spin_lock_init(&inode->i_data.i_mmap_lock);
231         INIT_LIST_HEAD(&inode->i_data.private_list);
232         spin_lock_init(&inode->i_data.private_lock);
233         INIT_RAW_PRIO_TREE_ROOT(&inode->i_data.i_mmap);
234         INIT_LIST_HEAD(&inode->i_data.i_mmap_nonlinear);
235         i_size_ordered_init(inode);
236 #ifdef CONFIG_INOTIFY
237         INIT_LIST_HEAD(&inode->inotify_watches);
238         mutex_init(&inode->inotify_mutex);
239 #endif
240 }
241
242 EXPORT_SYMBOL(inode_init_once);
243
244 static void init_once(void *foo)
245 {
246         struct inode * inode = (struct inode *) foo;
247
248         inode_init_once(inode);
249 }
250
251 /*
252  * inode_lock must be held
253  */
254 void __iget(struct inode * inode)
255 {
256         if (atomic_read(&inode->i_count)) {
257                 atomic_inc(&inode->i_count);
258                 return;
259         }
260         atomic_inc(&inode->i_count);
261         if (!(inode->i_state & (I_DIRTY|I_SYNC)))
262                 list_move(&inode->i_list, &inode_in_use);
263         inodes_stat.nr_unused--;
264 }
265
266 /**
267  * clear_inode - clear an inode
268  * @inode: inode to clear
269  *
270  * This is called by the filesystem to tell us
271  * that the inode is no longer useful. We just
272  * terminate it with extreme prejudice.
273  */
274 void clear_inode(struct inode *inode)
275 {
276         might_sleep();
277         invalidate_inode_buffers(inode);
278        
279         BUG_ON(inode->i_data.nrpages);
280         BUG_ON(!(inode->i_state & I_FREEING));
281         BUG_ON(inode->i_state & I_CLEAR);
282         inode_sync_wait(inode);
283         DQUOT_DROP(inode);
284         if (inode->i_sb->s_op->clear_inode)
285                 inode->i_sb->s_op->clear_inode(inode);
286         if (S_ISBLK(inode->i_mode) && inode->i_bdev)
287                 bd_forget(inode);
288         if (S_ISCHR(inode->i_mode) && inode->i_cdev)
289                 cd_forget(inode);
290         inode->i_state = I_CLEAR;
291 }
292
293 EXPORT_SYMBOL(clear_inode);
294
295 /*
296  * dispose_list - dispose of the contents of a local list
297  * @head: the head of the list to free
298  *
299  * Dispose-list gets a local list with local inodes in it, so it doesn't
300  * need to worry about list corruption and SMP locks.
301  */
302 static void dispose_list(struct list_head *head)
303 {
304         int nr_disposed = 0;
305
306         while (!list_empty(head)) {
307                 struct inode *inode;
308
309                 inode = list_first_entry(head, struct inode, i_list);
310                 list_del(&inode->i_list);
311
312                 if (inode->i_data.nrpages)
313                         truncate_inode_pages(&inode->i_data, 0);
314                 clear_inode(inode);
315
316                 spin_lock(&inode_lock);
317                 hlist_del_init(&inode->i_hash);
318                 list_del_init(&inode->i_sb_list);
319                 spin_unlock(&inode_lock);
320
321                 wake_up_inode(inode);
322                 destroy_inode(inode);
323                 nr_disposed++;
324         }
325         spin_lock(&inode_lock);
326         inodes_stat.nr_inodes -= nr_disposed;
327         spin_unlock(&inode_lock);
328 }
329
330 /*
331  * Invalidate all inodes for a device.
332  */
333 static int invalidate_list(struct list_head *head, struct list_head *dispose)
334 {
335         struct list_head *next;
336         int busy = 0, count = 0;
337
338         next = head->next;
339         for (;;) {
340                 struct list_head * tmp = next;
341                 struct inode * inode;
342
343                 /*
344                  * We can reschedule here without worrying about the list's
345                  * consistency because the per-sb list of inodes must not
346                  * change during umount anymore, and because iprune_mutex keeps
347                  * shrink_icache_memory() away.
348                  */
349                 cond_resched_lock(&inode_lock);
350
351                 next = next->next;
352                 if (tmp == head)
353                         break;
354                 inode = list_entry(tmp, struct inode, i_sb_list);
355                 invalidate_inode_buffers(inode);
356                 if (!atomic_read(&inode->i_count)) {
357                         list_move(&inode->i_list, dispose);
358                         inode->i_state |= I_FREEING;
359                         count++;
360                         continue;
361                 }
362                 busy = 1;
363         }
364         /* only unused inodes may be cached with i_count zero */
365         inodes_stat.nr_unused -= count;
366         return busy;
367 }
368
369 /**
370  *      invalidate_inodes       - discard the inodes on a device
371  *      @sb: superblock
372  *
373  *      Discard all of the inodes for a given superblock. If the discard
374  *      fails because there are busy inodes then a non zero value is returned.
375  *      If the discard is successful all the inodes have been discarded.
376  */
377 int invalidate_inodes(struct super_block * sb)
378 {
379         int busy;
380         LIST_HEAD(throw_away);
381
382         mutex_lock(&iprune_mutex);
383         spin_lock(&inode_lock);
384         inotify_unmount_inodes(&sb->s_inodes);
385         busy = invalidate_list(&sb->s_inodes, &throw_away);
386         spin_unlock(&inode_lock);
387
388         dispose_list(&throw_away);
389         mutex_unlock(&iprune_mutex);
390
391         return busy;
392 }
393
394 EXPORT_SYMBOL(invalidate_inodes);
395
396 static int can_unuse(struct inode *inode)
397 {
398         if (inode->i_state)
399                 return 0;
400         if (inode_has_buffers(inode))
401                 return 0;
402         if (atomic_read(&inode->i_count))
403                 return 0;
404         if (inode->i_data.nrpages)
405                 return 0;
406         return 1;
407 }
408
409 /*
410  * Scan `goal' inodes on the unused list for freeable ones. They are moved to
411  * a temporary list and then are freed outside inode_lock by dispose_list().
412  *
413  * Any inodes which are pinned purely because of attached pagecache have their
414  * pagecache removed.  We expect the final iput() on that inode to add it to
415  * the front of the inode_unused list.  So look for it there and if the
416  * inode is still freeable, proceed.  The right inode is found 99.9% of the
417  * time in testing on a 4-way.
418  *
419  * If the inode has metadata buffers attached to mapping->private_list then
420  * try to remove them.
421  */
422 static void prune_icache(int nr_to_scan)
423 {
424         LIST_HEAD(freeable);
425         int nr_pruned = 0;
426         int nr_scanned;
427         unsigned long reap = 0;
428
429         mutex_lock(&iprune_mutex);
430         spin_lock(&inode_lock);
431         for (nr_scanned = 0; nr_scanned < nr_to_scan; nr_scanned++) {
432                 struct inode *inode;
433
434                 if (list_empty(&inode_unused))
435                         break;
436
437                 inode = list_entry(inode_unused.prev, struct inode, i_list);
438
439                 if (inode->i_state || atomic_read(&inode->i_count)) {
440                         list_move(&inode->i_list, &inode_unused);
441                         continue;
442                 }
443                 if (inode_has_buffers(inode) || inode->i_data.nrpages) {
444                         __iget(inode);
445                         spin_unlock(&inode_lock);
446                         if (remove_inode_buffers(inode))
447                                 reap += invalidate_mapping_pages(&inode->i_data,
448                                                                 0, -1);
449                         iput(inode);
450                         spin_lock(&inode_lock);
451
452                         if (inode != list_entry(inode_unused.next,
453                                                 struct inode, i_list))
454                                 continue;       /* wrong inode or list_empty */
455                         if (!can_unuse(inode))
456                                 continue;
457                 }
458                 list_move(&inode->i_list, &freeable);
459                 inode->i_state |= I_FREEING;
460                 nr_pruned++;
461         }
462         inodes_stat.nr_unused -= nr_pruned;
463         if (current_is_kswapd())
464                 __count_vm_events(KSWAPD_INODESTEAL, reap);
465         else
466                 __count_vm_events(PGINODESTEAL, reap);
467         spin_unlock(&inode_lock);
468
469         dispose_list(&freeable);
470         mutex_unlock(&iprune_mutex);
471 }
472
473 /*
474  * shrink_icache_memory() will attempt to reclaim some unused inodes.  Here,
475  * "unused" means that no dentries are referring to the inodes: the files are
476  * not open and the dcache references to those inodes have already been
477  * reclaimed.
478  *
479  * This function is passed the number of inodes to scan, and it returns the
480  * total number of remaining possibly-reclaimable inodes.
481  */
482 static int shrink_icache_memory(int nr, gfp_t gfp_mask)
483 {
484         if (nr) {
485                 /*
486                  * Nasty deadlock avoidance.  We may hold various FS locks,
487                  * and we don't want to recurse into the FS that called us
488                  * in clear_inode() and friends..
489                  */
490                 if (!(gfp_mask & __GFP_FS))
491                         return -1;
492                 prune_icache(nr);
493         }
494         return (inodes_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
495 }
496
497 static struct shrinker icache_shrinker = {
498         .shrink = shrink_icache_memory,
499         .seeks = DEFAULT_SEEKS,
500 };
501
502 static void __wait_on_freeing_inode(struct inode *inode);
503 /*
504  * Called with the inode lock held.
505  * NOTE: we are not increasing the inode-refcount, you must call __iget()
506  * by hand after calling find_inode now! This simplifies iunique and won't
507  * add any additional branch in the common code.
508  */
509 static struct inode * find_inode(struct super_block * sb, struct hlist_head *head, int (*test)(struct inode *, void *), void *data)
510 {
511         struct hlist_node *node;
512         struct inode * inode = NULL;
513
514 repeat:
515         hlist_for_each_entry(inode, node, head, i_hash) {
516                 if (inode->i_sb != sb)
517                         continue;
518                 if (!test(inode, data))
519                         continue;
520                 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
521                         __wait_on_freeing_inode(inode);
522                         goto repeat;
523                 }
524                 break;
525         }
526         return node ? inode : NULL;
527 }
528
529 /*
530  * find_inode_fast is the fast path version of find_inode, see the comment at
531  * iget_locked for details.
532  */
533 static struct inode * find_inode_fast(struct super_block * sb, struct hlist_head *head, unsigned long ino)
534 {
535         struct hlist_node *node;
536         struct inode * inode = NULL;
537
538 repeat:
539         hlist_for_each_entry(inode, node, head, i_hash) {
540                 if (inode->i_ino != ino)
541                         continue;
542                 if (inode->i_sb != sb)
543                         continue;
544                 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
545                         __wait_on_freeing_inode(inode);
546                         goto repeat;
547                 }
548                 break;
549         }
550         return node ? inode : NULL;
551 }
552
553 /**
554  *      new_inode       - obtain an inode
555  *      @sb: superblock
556  *
557  *      Allocates a new inode for given superblock. The default gfp_mask
558  *      for allocations related to inode->i_mapping is GFP_HIGHUSER_PAGECACHE.
559  *      If HIGHMEM pages are unsuitable or it is known that pages allocated
560  *      for the page cache are not reclaimable or migratable,
561  *      mapping_set_gfp_mask() must be called with suitable flags on the
562  *      newly created inode's mapping
563  *
564  */
565 struct inode *new_inode(struct super_block *sb)
566 {
567         /*
568          * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
569          * error if st_ino won't fit in target struct field. Use 32bit counter
570          * here to attempt to avoid that.
571          */
572         static unsigned int last_ino;
573         struct inode * inode;
574
575         spin_lock_prefetch(&inode_lock);
576         
577         inode = alloc_inode(sb);
578         if (inode) {
579                 spin_lock(&inode_lock);
580                 inodes_stat.nr_inodes++;
581                 list_add(&inode->i_list, &inode_in_use);
582                 list_add(&inode->i_sb_list, &sb->s_inodes);
583                 inode->i_ino = ++last_ino;
584                 inode->i_state = 0;
585                 spin_unlock(&inode_lock);
586         }
587         return inode;
588 }
589
590 EXPORT_SYMBOL(new_inode);
591
592 void unlock_new_inode(struct inode *inode)
593 {
594 #ifdef CONFIG_DEBUG_LOCK_ALLOC
595         if (inode->i_mode & S_IFDIR) {
596                 struct file_system_type *type = inode->i_sb->s_type;
597
598                 /*
599                  * ensure nobody is actually holding i_mutex
600                  */
601                 mutex_destroy(&inode->i_mutex);
602                 mutex_init(&inode->i_mutex);
603                 lockdep_set_class(&inode->i_mutex, &type->i_mutex_dir_key);
604         }
605 #endif
606         /*
607          * This is special!  We do not need the spinlock
608          * when clearing I_LOCK, because we're guaranteed
609          * that nobody else tries to do anything about the
610          * state of the inode when it is locked, as we
611          * just created it (so there can be no old holders
612          * that haven't tested I_LOCK).
613          */
614         inode->i_state &= ~(I_LOCK|I_NEW);
615         wake_up_inode(inode);
616 }
617
618 EXPORT_SYMBOL(unlock_new_inode);
619
620 /*
621  * This is called without the inode lock held.. Be careful.
622  *
623  * We no longer cache the sb_flags in i_flags - see fs.h
624  *      -- rmk@arm.uk.linux.org
625  */
626 static struct inode * get_new_inode(struct super_block *sb, struct hlist_head *head, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *data)
627 {
628         struct inode * inode;
629
630         inode = alloc_inode(sb);
631         if (inode) {
632                 struct inode * old;
633
634                 spin_lock(&inode_lock);
635                 /* We released the lock, so.. */
636                 old = find_inode(sb, head, test, data);
637                 if (!old) {
638                         if (set(inode, data))
639                                 goto set_failed;
640
641                         inodes_stat.nr_inodes++;
642                         list_add(&inode->i_list, &inode_in_use);
643                         list_add(&inode->i_sb_list, &sb->s_inodes);
644                         hlist_add_head(&inode->i_hash, head);
645                         inode->i_state = I_LOCK|I_NEW;
646                         spin_unlock(&inode_lock);
647
648                         /* Return the locked inode with I_NEW set, the
649                          * caller is responsible for filling in the contents
650                          */
651                         return inode;
652                 }
653
654                 /*
655                  * Uhhuh, somebody else created the same inode under
656                  * us. Use the old inode instead of the one we just
657                  * allocated.
658                  */
659                 __iget(old);
660                 spin_unlock(&inode_lock);
661                 destroy_inode(inode);
662                 inode = old;
663                 wait_on_inode(inode);
664         }
665         return inode;
666
667 set_failed:
668         spin_unlock(&inode_lock);
669         destroy_inode(inode);
670         return NULL;
671 }
672
673 /*
674  * get_new_inode_fast is the fast path version of get_new_inode, see the
675  * comment at iget_locked for details.
676  */
677 static struct inode * get_new_inode_fast(struct super_block *sb, struct hlist_head *head, unsigned long ino)
678 {
679         struct inode * inode;
680
681         inode = alloc_inode(sb);
682         if (inode) {
683                 struct inode * old;
684
685                 spin_lock(&inode_lock);
686                 /* We released the lock, so.. */
687                 old = find_inode_fast(sb, head, ino);
688                 if (!old) {
689                         inode->i_ino = ino;
690                         inodes_stat.nr_inodes++;
691                         list_add(&inode->i_list, &inode_in_use);
692                         list_add(&inode->i_sb_list, &sb->s_inodes);
693                         hlist_add_head(&inode->i_hash, head);
694                         inode->i_state = I_LOCK|I_NEW;
695                         spin_unlock(&inode_lock);
696
697                         /* Return the locked inode with I_NEW set, the
698                          * caller is responsible for filling in the contents
699                          */
700                         return inode;
701                 }
702
703                 /*
704                  * Uhhuh, somebody else created the same inode under
705                  * us. Use the old inode instead of the one we just
706                  * allocated.
707                  */
708                 __iget(old);
709                 spin_unlock(&inode_lock);
710                 destroy_inode(inode);
711                 inode = old;
712                 wait_on_inode(inode);
713         }
714         return inode;
715 }
716
717 static unsigned long hash(struct super_block *sb, unsigned long hashval)
718 {
719         unsigned long tmp;
720
721         tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) /
722                         L1_CACHE_BYTES;
723         tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> I_HASHBITS);
724         return tmp & I_HASHMASK;
725 }
726
727 /**
728  *      iunique - get a unique inode number
729  *      @sb: superblock
730  *      @max_reserved: highest reserved inode number
731  *
732  *      Obtain an inode number that is unique on the system for a given
733  *      superblock. This is used by file systems that have no natural
734  *      permanent inode numbering system. An inode number is returned that
735  *      is higher than the reserved limit but unique.
736  *
737  *      BUGS:
738  *      With a large number of inodes live on the file system this function
739  *      currently becomes quite slow.
740  */
741 ino_t iunique(struct super_block *sb, ino_t max_reserved)
742 {
743         /*
744          * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
745          * error if st_ino won't fit in target struct field. Use 32bit counter
746          * here to attempt to avoid that.
747          */
748         static unsigned int counter;
749         struct inode *inode;
750         struct hlist_head *head;
751         ino_t res;
752
753         spin_lock(&inode_lock);
754         do {
755                 if (counter <= max_reserved)
756                         counter = max_reserved + 1;
757                 res = counter++;
758                 head = inode_hashtable + hash(sb, res);
759                 inode = find_inode_fast(sb, head, res);
760         } while (inode != NULL);
761         spin_unlock(&inode_lock);
762
763         return res;
764 }
765 EXPORT_SYMBOL(iunique);
766
767 struct inode *igrab(struct inode *inode)
768 {
769         spin_lock(&inode_lock);
770         if (!(inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)))
771                 __iget(inode);
772         else
773                 /*
774                  * Handle the case where s_op->clear_inode is not been
775                  * called yet, and somebody is calling igrab
776                  * while the inode is getting freed.
777                  */
778                 inode = NULL;
779         spin_unlock(&inode_lock);
780         return inode;
781 }
782
783 EXPORT_SYMBOL(igrab);
784
785 /**
786  * ifind - internal function, you want ilookup5() or iget5().
787  * @sb:         super block of file system to search
788  * @head:       the head of the list to search
789  * @test:       callback used for comparisons between inodes
790  * @data:       opaque data pointer to pass to @test
791  * @wait:       if true wait for the inode to be unlocked, if false do not
792  *
793  * ifind() searches for the inode specified by @data in the inode
794  * cache. This is a generalized version of ifind_fast() for file systems where
795  * the inode number is not sufficient for unique identification of an inode.
796  *
797  * If the inode is in the cache, the inode is returned with an incremented
798  * reference count.
799  *
800  * Otherwise NULL is returned.
801  *
802  * Note, @test is called with the inode_lock held, so can't sleep.
803  */
804 static struct inode *ifind(struct super_block *sb,
805                 struct hlist_head *head, int (*test)(struct inode *, void *),
806                 void *data, const int wait)
807 {
808         struct inode *inode;
809
810         spin_lock(&inode_lock);
811         inode = find_inode(sb, head, test, data);
812         if (inode) {
813                 __iget(inode);
814                 spin_unlock(&inode_lock);
815                 if (likely(wait))
816                         wait_on_inode(inode);
817                 return inode;
818         }
819         spin_unlock(&inode_lock);
820         return NULL;
821 }
822
823 /**
824  * ifind_fast - internal function, you want ilookup() or iget().
825  * @sb:         super block of file system to search
826  * @head:       head of the list to search
827  * @ino:        inode number to search for
828  *
829  * ifind_fast() searches for the inode @ino in the inode cache. This is for
830  * file systems where the inode number is sufficient for unique identification
831  * of an inode.
832  *
833  * If the inode is in the cache, the inode is returned with an incremented
834  * reference count.
835  *
836  * Otherwise NULL is returned.
837  */
838 static struct inode *ifind_fast(struct super_block *sb,
839                 struct hlist_head *head, unsigned long ino)
840 {
841         struct inode *inode;
842
843         spin_lock(&inode_lock);
844         inode = find_inode_fast(sb, head, ino);
845         if (inode) {
846                 __iget(inode);
847                 spin_unlock(&inode_lock);
848                 wait_on_inode(inode);
849                 return inode;
850         }
851         spin_unlock(&inode_lock);
852         return NULL;
853 }
854
855 /**
856  * ilookup5_nowait - search for an inode in the inode cache
857  * @sb:         super block of file system to search
858  * @hashval:    hash value (usually inode number) to search for
859  * @test:       callback used for comparisons between inodes
860  * @data:       opaque data pointer to pass to @test
861  *
862  * ilookup5() uses ifind() to search for the inode specified by @hashval and
863  * @data in the inode cache. This is a generalized version of ilookup() for
864  * file systems where the inode number is not sufficient for unique
865  * identification of an inode.
866  *
867  * If the inode is in the cache, the inode is returned with an incremented
868  * reference count.  Note, the inode lock is not waited upon so you have to be
869  * very careful what you do with the returned inode.  You probably should be
870  * using ilookup5() instead.
871  *
872  * Otherwise NULL is returned.
873  *
874  * Note, @test is called with the inode_lock held, so can't sleep.
875  */
876 struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval,
877                 int (*test)(struct inode *, void *), void *data)
878 {
879         struct hlist_head *head = inode_hashtable + hash(sb, hashval);
880
881         return ifind(sb, head, test, data, 0);
882 }
883
884 EXPORT_SYMBOL(ilookup5_nowait);
885
886 /**
887  * ilookup5 - search for an inode in the inode cache
888  * @sb:         super block of file system to search
889  * @hashval:    hash value (usually inode number) to search for
890  * @test:       callback used for comparisons between inodes
891  * @data:       opaque data pointer to pass to @test
892  *
893  * ilookup5() uses ifind() to search for the inode specified by @hashval and
894  * @data in the inode cache. This is a generalized version of ilookup() for
895  * file systems where the inode number is not sufficient for unique
896  * identification of an inode.
897  *
898  * If the inode is in the cache, the inode lock is waited upon and the inode is
899  * returned with an incremented reference count.
900  *
901  * Otherwise NULL is returned.
902  *
903  * Note, @test is called with the inode_lock held, so can't sleep.
904  */
905 struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
906                 int (*test)(struct inode *, void *), void *data)
907 {
908         struct hlist_head *head = inode_hashtable + hash(sb, hashval);
909
910         return ifind(sb, head, test, data, 1);
911 }
912
913 EXPORT_SYMBOL(ilookup5);
914
915 /**
916  * ilookup - search for an inode in the inode cache
917  * @sb:         super block of file system to search
918  * @ino:        inode number to search for
919  *
920  * ilookup() uses ifind_fast() to search for the inode @ino in the inode cache.
921  * This is for file systems where the inode number is sufficient for unique
922  * identification of an inode.
923  *
924  * If the inode is in the cache, the inode is returned with an incremented
925  * reference count.
926  *
927  * Otherwise NULL is returned.
928  */
929 struct inode *ilookup(struct super_block *sb, unsigned long ino)
930 {
931         struct hlist_head *head = inode_hashtable + hash(sb, ino);
932
933         return ifind_fast(sb, head, ino);
934 }
935
936 EXPORT_SYMBOL(ilookup);
937
938 /**
939  * iget5_locked - obtain an inode from a mounted file system
940  * @sb:         super block of file system
941  * @hashval:    hash value (usually inode number) to get
942  * @test:       callback used for comparisons between inodes
943  * @set:        callback used to initialize a new struct inode
944  * @data:       opaque data pointer to pass to @test and @set
945  *
946  * iget5_locked() uses ifind() to search for the inode specified by @hashval
947  * and @data in the inode cache and if present it is returned with an increased
948  * reference count. This is a generalized version of iget_locked() for file
949  * systems where the inode number is not sufficient for unique identification
950  * of an inode.
951  *
952  * If the inode is not in cache, get_new_inode() is called to allocate a new
953  * inode and this is returned locked, hashed, and with the I_NEW flag set. The
954  * file system gets to fill it in before unlocking it via unlock_new_inode().
955  *
956  * Note both @test and @set are called with the inode_lock held, so can't sleep.
957  */
958 struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
959                 int (*test)(struct inode *, void *),
960                 int (*set)(struct inode *, void *), void *data)
961 {
962         struct hlist_head *head = inode_hashtable + hash(sb, hashval);
963         struct inode *inode;
964
965         inode = ifind(sb, head, test, data, 1);
966         if (inode)
967                 return inode;
968         /*
969          * get_new_inode() will do the right thing, re-trying the search
970          * in case it had to block at any point.
971          */
972         return get_new_inode(sb, head, test, set, data);
973 }
974
975 EXPORT_SYMBOL(iget5_locked);
976
977 /**
978  * iget_locked - obtain an inode from a mounted file system
979  * @sb:         super block of file system
980  * @ino:        inode number to get
981  *
982  * iget_locked() uses ifind_fast() to search for the inode specified by @ino in
983  * the inode cache and if present it is returned with an increased reference
984  * count. This is for file systems where the inode number is sufficient for
985  * unique identification of an inode.
986  *
987  * If the inode is not in cache, get_new_inode_fast() is called to allocate a
988  * new inode and this is returned locked, hashed, and with the I_NEW flag set.
989  * The file system gets to fill it in before unlocking it via
990  * unlock_new_inode().
991  */
992 struct inode *iget_locked(struct super_block *sb, unsigned long ino)
993 {
994         struct hlist_head *head = inode_hashtable + hash(sb, ino);
995         struct inode *inode;
996
997         inode = ifind_fast(sb, head, ino);
998         if (inode)
999                 return inode;
1000         /*
1001          * get_new_inode_fast() will do the right thing, re-trying the search
1002          * in case it had to block at any point.
1003          */
1004         return get_new_inode_fast(sb, head, ino);
1005 }
1006
1007 EXPORT_SYMBOL(iget_locked);
1008
1009 /**
1010  *      __insert_inode_hash - hash an inode
1011  *      @inode: unhashed inode
1012  *      @hashval: unsigned long value used to locate this object in the
1013  *              inode_hashtable.
1014  *
1015  *      Add an inode to the inode hash for this superblock.
1016  */
1017 void __insert_inode_hash(struct inode *inode, unsigned long hashval)
1018 {
1019         struct hlist_head *head = inode_hashtable + hash(inode->i_sb, hashval);
1020         spin_lock(&inode_lock);
1021         hlist_add_head(&inode->i_hash, head);
1022         spin_unlock(&inode_lock);
1023 }
1024
1025 EXPORT_SYMBOL(__insert_inode_hash);
1026
1027 /**
1028  *      remove_inode_hash - remove an inode from the hash
1029  *      @inode: inode to unhash
1030  *
1031  *      Remove an inode from the superblock.
1032  */
1033 void remove_inode_hash(struct inode *inode)
1034 {
1035         spin_lock(&inode_lock);
1036         hlist_del_init(&inode->i_hash);
1037         spin_unlock(&inode_lock);
1038 }
1039
1040 EXPORT_SYMBOL(remove_inode_hash);
1041
1042 /*
1043  * Tell the filesystem that this inode is no longer of any interest and should
1044  * be completely destroyed.
1045  *
1046  * We leave the inode in the inode hash table until *after* the filesystem's
1047  * ->delete_inode completes.  This ensures that an iget (such as nfsd might
1048  * instigate) will always find up-to-date information either in the hash or on
1049  * disk.
1050  *
1051  * I_FREEING is set so that no-one will take a new reference to the inode while
1052  * it is being deleted.
1053  */
1054 void generic_delete_inode(struct inode *inode)
1055 {
1056         const struct super_operations *op = inode->i_sb->s_op;
1057
1058         list_del_init(&inode->i_list);
1059         list_del_init(&inode->i_sb_list);
1060         inode->i_state |= I_FREEING;
1061         inodes_stat.nr_inodes--;
1062         spin_unlock(&inode_lock);
1063
1064         security_inode_delete(inode);
1065
1066         if (op->delete_inode) {
1067                 void (*delete)(struct inode *) = op->delete_inode;
1068                 if (!is_bad_inode(inode))
1069                         DQUOT_INIT(inode);
1070                 /* Filesystems implementing their own
1071                  * s_op->delete_inode are required to call
1072                  * truncate_inode_pages and clear_inode()
1073                  * internally */
1074                 delete(inode);
1075         } else {
1076                 truncate_inode_pages(&inode->i_data, 0);
1077                 clear_inode(inode);
1078         }
1079         spin_lock(&inode_lock);
1080         hlist_del_init(&inode->i_hash);
1081         spin_unlock(&inode_lock);
1082         wake_up_inode(inode);
1083         BUG_ON(inode->i_state != I_CLEAR);
1084         destroy_inode(inode);
1085 }
1086
1087 EXPORT_SYMBOL(generic_delete_inode);
1088
1089 static void generic_forget_inode(struct inode *inode)
1090 {
1091         struct super_block *sb = inode->i_sb;
1092
1093         if (!hlist_unhashed(&inode->i_hash)) {
1094                 if (!(inode->i_state & (I_DIRTY|I_SYNC)))
1095                         list_move(&inode->i_list, &inode_unused);
1096                 inodes_stat.nr_unused++;
1097                 if (sb->s_flags & MS_ACTIVE) {
1098                         spin_unlock(&inode_lock);
1099                         return;
1100                 }
1101                 inode->i_state |= I_WILL_FREE;
1102                 spin_unlock(&inode_lock);
1103                 write_inode_now(inode, 1);
1104                 spin_lock(&inode_lock);
1105                 inode->i_state &= ~I_WILL_FREE;
1106                 inodes_stat.nr_unused--;
1107                 hlist_del_init(&inode->i_hash);
1108         }
1109         list_del_init(&inode->i_list);
1110         list_del_init(&inode->i_sb_list);
1111         inode->i_state |= I_FREEING;
1112         inodes_stat.nr_inodes--;
1113         spin_unlock(&inode_lock);
1114         if (inode->i_data.nrpages)
1115                 truncate_inode_pages(&inode->i_data, 0);
1116         clear_inode(inode);
1117         wake_up_inode(inode);
1118         destroy_inode(inode);
1119 }
1120
1121 /*
1122  * Normal UNIX filesystem behaviour: delete the
1123  * inode when the usage count drops to zero, and
1124  * i_nlink is zero.
1125  */
1126 void generic_drop_inode(struct inode *inode)
1127 {
1128         if (!inode->i_nlink)
1129                 generic_delete_inode(inode);
1130         else
1131                 generic_forget_inode(inode);
1132 }
1133
1134 EXPORT_SYMBOL_GPL(generic_drop_inode);
1135
1136 /*
1137  * Called when we're dropping the last reference
1138  * to an inode. 
1139  *
1140  * Call the FS "drop()" function, defaulting to
1141  * the legacy UNIX filesystem behaviour..
1142  *
1143  * NOTE! NOTE! NOTE! We're called with the inode lock
1144  * held, and the drop function is supposed to release
1145  * the lock!
1146  */
1147 static inline void iput_final(struct inode *inode)
1148 {
1149         const struct super_operations *op = inode->i_sb->s_op;
1150         void (*drop)(struct inode *) = generic_drop_inode;
1151
1152         if (op && op->drop_inode)
1153                 drop = op->drop_inode;
1154         drop(inode);
1155 }
1156
1157 /**
1158  *      iput    - put an inode 
1159  *      @inode: inode to put
1160  *
1161  *      Puts an inode, dropping its usage count. If the inode use count hits
1162  *      zero, the inode is then freed and may also be destroyed.
1163  *
1164  *      Consequently, iput() can sleep.
1165  */
1166 void iput(struct inode *inode)
1167 {
1168         if (inode) {
1169                 BUG_ON(inode->i_state == I_CLEAR);
1170
1171                 if (atomic_dec_and_lock(&inode->i_count, &inode_lock))
1172                         iput_final(inode);
1173         }
1174 }
1175
1176 EXPORT_SYMBOL(iput);
1177
1178 /**
1179  *      bmap    - find a block number in a file
1180  *      @inode: inode of file
1181  *      @block: block to find
1182  *
1183  *      Returns the block number on the device holding the inode that
1184  *      is the disk block number for the block of the file requested.
1185  *      That is, asked for block 4 of inode 1 the function will return the
1186  *      disk block relative to the disk start that holds that block of the 
1187  *      file.
1188  */
1189 sector_t bmap(struct inode * inode, sector_t block)
1190 {
1191         sector_t res = 0;
1192         if (inode->i_mapping->a_ops->bmap)
1193                 res = inode->i_mapping->a_ops->bmap(inode->i_mapping, block);
1194         return res;
1195 }
1196 EXPORT_SYMBOL(bmap);
1197
1198 /**
1199  *      touch_atime     -       update the access time
1200  *      @mnt: mount the inode is accessed on
1201  *      @dentry: dentry accessed
1202  *
1203  *      Update the accessed time on an inode and mark it for writeback.
1204  *      This function automatically handles read only file systems and media,
1205  *      as well as the "noatime" flag and inode specific "noatime" markers.
1206  */
1207 void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
1208 {
1209         struct inode *inode = dentry->d_inode;
1210         struct timespec now;
1211
1212         if (mnt_want_write(mnt))
1213                 return;
1214         if (inode->i_flags & S_NOATIME)
1215                 goto out;
1216         if (IS_NOATIME(inode))
1217                 goto out;
1218         if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
1219                 goto out;
1220
1221         if (mnt->mnt_flags & MNT_NOATIME)
1222                 goto out;
1223         if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
1224                 goto out;
1225         if (mnt->mnt_flags & MNT_RELATIME) {
1226                 /*
1227                  * With relative atime, only update atime if the previous
1228                  * atime is earlier than either the ctime or mtime.
1229                  */
1230                 if (timespec_compare(&inode->i_mtime, &inode->i_atime) < 0 &&
1231                     timespec_compare(&inode->i_ctime, &inode->i_atime) < 0)
1232                         goto out;
1233         }
1234
1235         now = current_fs_time(inode->i_sb);
1236         if (timespec_equal(&inode->i_atime, &now))
1237                 goto out;
1238
1239         inode->i_atime = now;
1240         mark_inode_dirty_sync(inode);
1241 out:
1242         mnt_drop_write(mnt);
1243 }
1244 EXPORT_SYMBOL(touch_atime);
1245
1246 /**
1247  *      file_update_time        -       update mtime and ctime time
1248  *      @file: file accessed
1249  *
1250  *      Update the mtime and ctime members of an inode and mark the inode
1251  *      for writeback.  Note that this function is meant exclusively for
1252  *      usage in the file write path of filesystems, and filesystems may
1253  *      choose to explicitly ignore update via this function with the
1254  *      S_NOCTIME inode flag, e.g. for network filesystem where these
1255  *      timestamps are handled by the server.
1256  */
1257
1258 void file_update_time(struct file *file)
1259 {
1260         struct inode *inode = file->f_path.dentry->d_inode;
1261         struct timespec now;
1262         int sync_it = 0;
1263         int err;
1264
1265         if (IS_NOCMTIME(inode))
1266                 return;
1267
1268         err = mnt_want_write(file->f_path.mnt);
1269         if (err)
1270                 return;
1271
1272         now = current_fs_time(inode->i_sb);
1273         if (!timespec_equal(&inode->i_mtime, &now)) {
1274                 inode->i_mtime = now;
1275                 sync_it = 1;
1276         }
1277
1278         if (!timespec_equal(&inode->i_ctime, &now)) {
1279                 inode->i_ctime = now;
1280                 sync_it = 1;
1281         }
1282
1283         if (IS_I_VERSION(inode)) {
1284                 inode_inc_iversion(inode);
1285                 sync_it = 1;
1286         }
1287
1288         if (sync_it)
1289                 mark_inode_dirty_sync(inode);
1290         mnt_drop_write(file->f_path.mnt);
1291 }
1292
1293 EXPORT_SYMBOL(file_update_time);
1294
1295 int inode_needs_sync(struct inode *inode)
1296 {
1297         if (IS_SYNC(inode))
1298                 return 1;
1299         if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
1300                 return 1;
1301         return 0;
1302 }
1303
1304 EXPORT_SYMBOL(inode_needs_sync);
1305
1306 int inode_wait(void *word)
1307 {
1308         schedule();
1309         return 0;
1310 }
1311
1312 /*
1313  * If we try to find an inode in the inode hash while it is being
1314  * deleted, we have to wait until the filesystem completes its
1315  * deletion before reporting that it isn't found.  This function waits
1316  * until the deletion _might_ have completed.  Callers are responsible
1317  * to recheck inode state.
1318  *
1319  * It doesn't matter if I_LOCK is not set initially, a call to
1320  * wake_up_inode() after removing from the hash list will DTRT.
1321  *
1322  * This is called with inode_lock held.
1323  */
1324 static void __wait_on_freeing_inode(struct inode *inode)
1325 {
1326         wait_queue_head_t *wq;
1327         DEFINE_WAIT_BIT(wait, &inode->i_state, __I_LOCK);
1328         wq = bit_waitqueue(&inode->i_state, __I_LOCK);
1329         prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
1330         spin_unlock(&inode_lock);
1331         schedule();
1332         finish_wait(wq, &wait.wait);
1333         spin_lock(&inode_lock);
1334 }
1335
1336 /*
1337  * We rarely want to lock two inodes that do not have a parent/child
1338  * relationship (such as directory, child inode) simultaneously. The
1339  * vast majority of file systems should be able to get along fine
1340  * without this. Do not use these functions except as a last resort.
1341  */
1342 void inode_double_lock(struct inode *inode1, struct inode *inode2)
1343 {
1344         if (inode1 == NULL || inode2 == NULL || inode1 == inode2) {
1345                 if (inode1)
1346                         mutex_lock(&inode1->i_mutex);
1347                 else if (inode2)
1348                         mutex_lock(&inode2->i_mutex);
1349                 return;
1350         }
1351
1352         if (inode1 < inode2) {
1353                 mutex_lock_nested(&inode1->i_mutex, I_MUTEX_PARENT);
1354                 mutex_lock_nested(&inode2->i_mutex, I_MUTEX_CHILD);
1355         } else {
1356                 mutex_lock_nested(&inode2->i_mutex, I_MUTEX_PARENT);
1357                 mutex_lock_nested(&inode1->i_mutex, I_MUTEX_CHILD);
1358         }
1359 }
1360 EXPORT_SYMBOL(inode_double_lock);
1361
1362 void inode_double_unlock(struct inode *inode1, struct inode *inode2)
1363 {
1364         if (inode1)
1365                 mutex_unlock(&inode1->i_mutex);
1366
1367         if (inode2 && inode2 != inode1)
1368                 mutex_unlock(&inode2->i_mutex);
1369 }
1370 EXPORT_SYMBOL(inode_double_unlock);
1371
1372 static __initdata unsigned long ihash_entries;
1373 static int __init set_ihash_entries(char *str)
1374 {
1375         if (!str)
1376                 return 0;
1377         ihash_entries = simple_strtoul(str, &str, 0);
1378         return 1;
1379 }
1380 __setup("ihash_entries=", set_ihash_entries);
1381
1382 /*
1383  * Initialize the waitqueues and inode hash table.
1384  */
1385 void __init inode_init_early(void)
1386 {
1387         int loop;
1388
1389         /* If hashes are distributed across NUMA nodes, defer
1390          * hash allocation until vmalloc space is available.
1391          */
1392         if (hashdist)
1393                 return;
1394
1395         inode_hashtable =
1396                 alloc_large_system_hash("Inode-cache",
1397                                         sizeof(struct hlist_head),
1398                                         ihash_entries,
1399                                         14,
1400                                         HASH_EARLY,
1401                                         &i_hash_shift,
1402                                         &i_hash_mask,
1403                                         0);
1404
1405         for (loop = 0; loop < (1 << i_hash_shift); loop++)
1406                 INIT_HLIST_HEAD(&inode_hashtable[loop]);
1407 }
1408
1409 void __init inode_init(void)
1410 {
1411         int loop;
1412
1413         /* inode slab cache */
1414         inode_cachep = kmem_cache_create("inode_cache",
1415                                          sizeof(struct inode),
1416                                          0,
1417                                          (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
1418                                          SLAB_MEM_SPREAD),
1419                                          init_once);
1420         register_shrinker(&icache_shrinker);
1421
1422         /* Hash may have been set up in inode_init_early */
1423         if (!hashdist)
1424                 return;
1425
1426         inode_hashtable =
1427                 alloc_large_system_hash("Inode-cache",
1428                                         sizeof(struct hlist_head),
1429                                         ihash_entries,
1430                                         14,
1431                                         0,
1432                                         &i_hash_shift,
1433                                         &i_hash_mask,
1434                                         0);
1435
1436         for (loop = 0; loop < (1 << i_hash_shift); loop++)
1437                 INIT_HLIST_HEAD(&inode_hashtable[loop]);
1438 }
1439
1440 void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
1441 {
1442         inode->i_mode = mode;
1443         if (S_ISCHR(mode)) {
1444                 inode->i_fop = &def_chr_fops;
1445                 inode->i_rdev = rdev;
1446         } else if (S_ISBLK(mode)) {
1447                 inode->i_fop = &def_blk_fops;
1448                 inode->i_rdev = rdev;
1449         } else if (S_ISFIFO(mode))
1450                 inode->i_fop = &def_fifo_fops;
1451         else if (S_ISSOCK(mode))
1452                 inode->i_fop = &bad_sock_fops;
1453         else
1454                 printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o)\n",
1455                        mode);
1456 }
1457 EXPORT_SYMBOL(init_special_inode);