v2.4.14.9 -> v2.4.15
[opensuse:kernel.git] / fs / inode.c
1 /*
2  * linux/fs/inode.c
3  *
4  * (C) 1997 Linus Torvalds
5  */
6
7 #include <linux/config.h>
8 #include <linux/fs.h>
9 #include <linux/string.h>
10 #include <linux/mm.h>
11 #include <linux/dcache.h>
12 #include <linux/init.h>
13 #include <linux/quotaops.h>
14 #include <linux/slab.h>
15 #include <linux/cache.h>
16 #include <linux/swap.h>
17 #include <linux/swapctl.h>
18 #include <linux/prefetch.h>
19 #include <linux/locks.h>
20
21 /*
22  * New inode.c implementation.
23  *
24  * This implementation has the basic premise of trying
25  * to be extremely low-overhead and SMP-safe, yet be
26  * simple enough to be "obviously correct".
27  *
28  * Famous last words.
29  */
30
31 /* inode dynamic allocation 1999, Andrea Arcangeli <andrea@suse.de> */
32
33 /* #define INODE_PARANOIA 1 */
34 /* #define INODE_DEBUG 1 */
35
36 /*
37  * Inode lookup is no longer as critical as it used to be:
38  * most of the lookups are going to be through the dcache.
39  */
40 #define I_HASHBITS      i_hash_shift
41 #define I_HASHMASK      i_hash_mask
42
43 static unsigned int i_hash_mask;
44 static unsigned int i_hash_shift;
45
46 /*
47  * Each inode can be on two separate lists. One is
48  * the hash list of the inode, used for lookups. The
49  * other linked list is the "type" list:
50  *  "in_use" - valid inode, i_count > 0, i_nlink > 0
51  *  "dirty"  - as "in_use" but also dirty
52  *  "unused" - valid inode, i_count = 0
53  *
54  * A "dirty" list is maintained for each super block,
55  * allowing for low-overhead inode sync() operations.
56  */
57
58 static LIST_HEAD(inode_in_use);
59 static LIST_HEAD(inode_unused);
60 static struct list_head *inode_hashtable;
61 static LIST_HEAD(anon_hash_chain); /* for inodes with NULL i_sb */
62
63 /*
64  * A simple spinlock to protect the list manipulations.
65  *
66  * NOTE! You also have to own the lock if you change
67  * the i_state of an inode while it is in use..
68  */
69 static spinlock_t inode_lock = SPIN_LOCK_UNLOCKED;
70
71 /*
72  * Statistics gathering..
73  */
74 struct inodes_stat_t inodes_stat;
75
76 static kmem_cache_t * inode_cachep;
77
78 #define alloc_inode() \
79          ((struct inode *) kmem_cache_alloc(inode_cachep, SLAB_KERNEL))
80 static void destroy_inode(struct inode *inode) 
81 {
82         if (inode_has_buffers(inode))
83                 BUG();
84         kmem_cache_free(inode_cachep, (inode));
85 }
86
87
88 /*
89  * These are initializations that only need to be done
90  * once, because the fields are idempotent across use
91  * of the inode, so let the slab aware of that.
92  */
93 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
94 {
95         struct inode * inode = (struct inode *) foo;
96
97         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
98             SLAB_CTOR_CONSTRUCTOR)
99         {
100                 memset(inode, 0, sizeof(*inode));
101                 init_waitqueue_head(&inode->i_wait);
102                 INIT_LIST_HEAD(&inode->i_hash);
103                 INIT_LIST_HEAD(&inode->i_data.clean_pages);
104                 INIT_LIST_HEAD(&inode->i_data.dirty_pages);
105                 INIT_LIST_HEAD(&inode->i_data.locked_pages);
106                 INIT_LIST_HEAD(&inode->i_dentry);
107                 INIT_LIST_HEAD(&inode->i_dirty_buffers);
108                 INIT_LIST_HEAD(&inode->i_dirty_data_buffers);
109                 INIT_LIST_HEAD(&inode->i_devices);
110                 sema_init(&inode->i_sem, 1);
111                 sema_init(&inode->i_zombie, 1);
112                 spin_lock_init(&inode->i_data.i_shared_lock);
113         }
114 }
115
116 /*
117  * Put the inode on the super block's dirty list.
118  *
119  * CAREFUL! We mark it dirty unconditionally, but
120  * move it onto the dirty list only if it is hashed.
121  * If it was not hashed, it will never be added to
122  * the dirty list even if it is later hashed, as it
123  * will have been marked dirty already.
124  *
125  * In short, make sure you hash any inodes _before_
126  * you start marking them dirty..
127  */
128  
129 /**
130  *      __mark_inode_dirty -    internal function
131  *      @inode: inode to mark
132  *      @flags: what kind of dirty (i.e. I_DIRTY_SYNC)
133  *      Mark an inode as dirty. Callers should use mark_inode_dirty or
134  *      mark_inode_dirty_sync.
135  */
136  
137 void __mark_inode_dirty(struct inode *inode, int flags)
138 {
139         struct super_block * sb = inode->i_sb;
140
141         if (!sb)
142                 return;
143
144         /* Don't do this for I_DIRTY_PAGES - that doesn't actually dirty the inode itself */
145         if (flags & (I_DIRTY_SYNC | I_DIRTY_DATASYNC)) {
146                 if (sb->s_op && sb->s_op->dirty_inode)
147                         sb->s_op->dirty_inode(inode);
148         }
149
150         /* avoid the locking if we can */
151         if ((inode->i_state & flags) == flags)
152                 return;
153
154         spin_lock(&inode_lock);
155         if ((inode->i_state & flags) != flags) {
156                 inode->i_state |= flags;
157                 /* Only add valid (ie hashed) inodes to the dirty list */
158                 if (!(inode->i_state & I_LOCK) && !list_empty(&inode->i_hash)) {
159                         list_del(&inode->i_list);
160                         list_add(&inode->i_list, &sb->s_dirty);
161                 }
162         }
163         spin_unlock(&inode_lock);
164 }
165
166 static void __wait_on_inode(struct inode * inode)
167 {
168         DECLARE_WAITQUEUE(wait, current);
169
170         add_wait_queue(&inode->i_wait, &wait);
171 repeat:
172         set_current_state(TASK_UNINTERRUPTIBLE);
173         if (inode->i_state & I_LOCK) {
174                 schedule();
175                 goto repeat;
176         }
177         remove_wait_queue(&inode->i_wait, &wait);
178         current->state = TASK_RUNNING;
179 }
180
181 static inline void wait_on_inode(struct inode *inode)
182 {
183         if (inode->i_state & I_LOCK)
184                 __wait_on_inode(inode);
185 }
186
187
188 static inline void write_inode(struct inode *inode, int sync)
189 {
190         if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->write_inode && !is_bad_inode(inode))
191                 inode->i_sb->s_op->write_inode(inode, sync);
192 }
193
194 static inline void __iget(struct inode * inode)
195 {
196         if (atomic_read(&inode->i_count)) {
197                 atomic_inc(&inode->i_count);
198                 return;
199         }
200         atomic_inc(&inode->i_count);
201         if (!(inode->i_state & (I_DIRTY|I_LOCK))) {
202                 list_del(&inode->i_list);
203                 list_add(&inode->i_list, &inode_in_use);
204         }
205         inodes_stat.nr_unused--;
206 }
207
208 static inline void __sync_one(struct inode *inode, int sync)
209 {
210         unsigned dirty;
211
212         list_del(&inode->i_list);
213         list_add(&inode->i_list, &inode->i_sb->s_locked_inodes);
214
215         if (inode->i_state & I_LOCK)
216                 BUG();
217
218         /* Set I_LOCK, reset I_DIRTY */
219         dirty = inode->i_state & I_DIRTY;
220         inode->i_state |= I_LOCK;
221         inode->i_state &= ~I_DIRTY;
222         spin_unlock(&inode_lock);
223
224         filemap_fdatasync(inode->i_mapping);
225
226         /* Don't write the inode if only I_DIRTY_PAGES was set */
227         if (dirty & (I_DIRTY_SYNC | I_DIRTY_DATASYNC))
228                 write_inode(inode, sync);
229
230         filemap_fdatawait(inode->i_mapping);
231
232         spin_lock(&inode_lock);
233         inode->i_state &= ~I_LOCK;
234         if (!(inode->i_state & I_FREEING)) {
235                 struct list_head *to;
236                 if (inode->i_state & I_DIRTY)
237                         to = &inode->i_sb->s_dirty;
238                 else if (atomic_read(&inode->i_count))
239                         to = &inode_in_use;
240                 else
241                         to = &inode_unused;
242                 list_del(&inode->i_list);
243                 list_add(&inode->i_list, to);
244         }
245         wake_up(&inode->i_wait);
246 }
247
248 static inline void sync_one(struct inode *inode, int sync)
249 {
250         if (inode->i_state & I_LOCK) {
251                 __iget(inode);
252                 spin_unlock(&inode_lock);
253                 __wait_on_inode(inode);
254                 iput(inode);
255                 spin_lock(&inode_lock);
256         } else {
257                 __sync_one(inode, sync);
258         }
259 }
260
261 static inline void sync_list(struct list_head *head)
262 {
263         struct list_head * tmp;
264
265         while ((tmp = head->prev) != head) 
266                 __sync_one(list_entry(tmp, struct inode, i_list), 0);
267 }
268
269 static inline void wait_on_locked(struct list_head *head)
270 {
271         struct list_head * tmp;
272         while ((tmp = head->prev) != head) {
273                 struct inode *inode = list_entry(tmp, struct inode, i_list);
274                 __iget(inode);
275                 spin_unlock(&inode_lock);
276                 __wait_on_inode(inode);
277                 iput(inode);
278                 spin_lock(&inode_lock);
279         }
280 }
281
282 static inline int try_to_sync_unused_list(struct list_head *head, int nr_inodes)
283 {
284         struct list_head *tmp = head;
285         struct inode *inode;
286
287         while (nr_inodes && (tmp = tmp->prev) != head) {
288                 inode = list_entry(tmp, struct inode, i_list);
289
290                 if (!atomic_read(&inode->i_count)) {
291                         __sync_one(inode, 0);
292                         nr_inodes--;
293
294                         /* 
295                          * __sync_one moved the inode to another list,
296                          * so we have to start looking from the list head.
297                          */
298                         tmp = head;
299                 }
300         }
301
302         return nr_inodes;
303 }
304
305 void sync_inodes_sb(struct super_block *sb)
306 {
307         spin_lock(&inode_lock);
308         while (!list_empty(&sb->s_dirty)||!list_empty(&sb->s_locked_inodes)) {
309                 sync_list(&sb->s_dirty);
310                 wait_on_locked(&sb->s_locked_inodes);
311         }
312         spin_unlock(&inode_lock);
313 }
314
315 /*
316  * Note:
317  * We don't need to grab a reference to superblock here. If it has non-empty
318  * ->s_dirty it's hadn't been killed yet and kill_super() won't proceed
319  * past sync_inodes_sb() until both ->s_dirty and ->s_locked_inodes are
320  * empty. Since __sync_one() regains inode_lock before it finally moves
321  * inode from superblock lists we are OK.
322  */
323
324 void sync_unlocked_inodes(void)
325 {
326         struct super_block * sb;
327         spin_lock(&inode_lock);
328         spin_lock(&sb_lock);
329         sb = sb_entry(super_blocks.next);
330         for (; sb != sb_entry(&super_blocks); sb = sb_entry(sb->s_list.next)) {
331                 if (!list_empty(&sb->s_dirty)) {
332                         spin_unlock(&sb_lock);
333                         sync_list(&sb->s_dirty);
334                         spin_lock(&sb_lock);
335                 }
336         }
337         spin_unlock(&sb_lock);
338         spin_unlock(&inode_lock);
339 }
340
341 /*
342  * Find a superblock with inodes that need to be synced
343  */
344
345 static struct super_block *get_super_to_sync(void)
346 {
347         struct list_head *p;
348 restart:
349         spin_lock(&inode_lock);
350         spin_lock(&sb_lock);
351         list_for_each(p, &super_blocks) {
352                 struct super_block *s = list_entry(p,struct super_block,s_list);
353                 if (list_empty(&s->s_dirty) && list_empty(&s->s_locked_inodes))
354                         continue;
355                 s->s_count++;
356                 spin_unlock(&sb_lock);
357                 spin_unlock(&inode_lock);
358                 down_read(&s->s_umount);
359                 if (!s->s_root) {
360                         drop_super(s);
361                         goto restart;
362                 }
363                 return s;
364         }
365         spin_unlock(&sb_lock);
366         spin_unlock(&inode_lock);
367         return NULL;
368 }
369
370 /**
371  *      sync_inodes
372  *      @dev: device to sync the inodes from.
373  *
374  *      sync_inodes goes through the super block's dirty list, 
375  *      writes them out, and puts them back on the normal list.
376  */
377
378 void sync_inodes(kdev_t dev)
379 {
380         struct super_block * s;
381
382         /*
383          * Search the super_blocks array for the device(s) to sync.
384          */
385         if (dev) {
386                 if ((s = get_super(dev)) != NULL) {
387                         sync_inodes_sb(s);
388                         drop_super(s);
389                 }
390         } else {
391                 while ((s = get_super_to_sync()) != NULL) {
392                         sync_inodes_sb(s);
393                         drop_super(s);
394                 }
395         }
396 }
397
398 static void try_to_sync_unused_inodes(void * arg)
399 {
400         struct super_block * sb;
401         int nr_inodes = inodes_stat.nr_unused;
402
403         spin_lock(&inode_lock);
404         spin_lock(&sb_lock);
405         sb = sb_entry(super_blocks.next);
406         for (; nr_inodes && sb != sb_entry(&super_blocks); sb = sb_entry(sb->s_list.next)) {
407                 if (list_empty(&sb->s_dirty))
408                         continue;
409                 spin_unlock(&sb_lock);
410                 nr_inodes = try_to_sync_unused_list(&sb->s_dirty, nr_inodes);
411                 spin_lock(&sb_lock);
412         }
413         spin_unlock(&sb_lock);
414         spin_unlock(&inode_lock);
415 }
416
417 static struct tq_struct unused_inodes_flush_task;
418
419 /**
420  *      write_inode_now -       write an inode to disk
421  *      @inode: inode to write to disk
422  *      @sync: whether the write should be synchronous or not
423  *
424  *      This function commits an inode to disk immediately if it is
425  *      dirty. This is primarily needed by knfsd.
426  */
427  
428 void write_inode_now(struct inode *inode, int sync)
429 {
430         struct super_block * sb = inode->i_sb;
431
432         if (sb) {
433                 spin_lock(&inode_lock);
434                 while (inode->i_state & I_DIRTY)
435                         sync_one(inode, sync);
436                 spin_unlock(&inode_lock);
437                 if (sync)
438                         wait_on_inode(inode);
439         }
440         else
441                 printk(KERN_ERR "write_inode_now: no super block\n");
442 }
443
444 /**
445  * generic_osync_inode - flush all dirty data for a given inode to disk
446  * @inode: inode to write
447  * @datasync: if set, don't bother flushing timestamps
448  *
449  * This can be called by file_write functions for files which have the
450  * O_SYNC flag set, to flush dirty writes to disk.  
451  */
452
453 int generic_osync_inode(struct inode *inode, int what)
454 {
455         int err = 0, err2 = 0, need_write_inode_now = 0;
456         
457         /* 
458          * WARNING
459          *
460          * Currently, the filesystem write path does not pass the
461          * filp down to the low-level write functions.  Therefore it
462          * is impossible for (say) __block_commit_write to know if
463          * the operation is O_SYNC or not.
464          *
465          * Ideally, O_SYNC writes would have the filesystem call
466          * ll_rw_block as it went to kick-start the writes, and we
467          * could call osync_inode_buffers() here to wait only for
468          * those IOs which have already been submitted to the device
469          * driver layer.  As it stands, if we did this we'd not write
470          * anything to disk since our writes have not been queued by
471          * this point: they are still on the dirty LRU.
472          * 
473          * So, currently we will call fsync_inode_buffers() instead,
474          * to flush _all_ dirty buffers for this inode to disk on 
475          * every O_SYNC write, not just the synchronous I/Os.  --sct
476          */
477
478         if (what & OSYNC_METADATA)
479                 err = fsync_inode_buffers(inode);
480         if (what & OSYNC_DATA)
481                 err2 = fsync_inode_data_buffers(inode);
482         if (!err)
483                 err = err2;
484
485         spin_lock(&inode_lock);
486         if ((inode->i_state & I_DIRTY) &&
487             ((what & OSYNC_INODE) || (inode->i_state & I_DIRTY_DATASYNC)))
488                 need_write_inode_now = 1;
489         spin_unlock(&inode_lock);
490
491         if (need_write_inode_now)
492                 write_inode_now(inode, 1);
493         else
494                 wait_on_inode(inode);
495
496         return err;
497 }
498
499 /**
500  * clear_inode - clear an inode
501  * @inode: inode to clear
502  *
503  * This is called by the filesystem to tell us
504  * that the inode is no longer useful. We just
505  * terminate it with extreme prejudice.
506  */
507  
508 void clear_inode(struct inode *inode)
509 {
510         invalidate_inode_buffers(inode);
511        
512         if (inode->i_data.nrpages)
513                 BUG();
514         if (!(inode->i_state & I_FREEING))
515                 BUG();
516         if (inode->i_state & I_CLEAR)
517                 BUG();
518         wait_on_inode(inode);
519         DQUOT_DROP(inode);
520         if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->clear_inode)
521                 inode->i_sb->s_op->clear_inode(inode);
522         if (inode->i_bdev)
523                 bd_forget(inode);
524         else if (inode->i_cdev) {
525                 cdput(inode->i_cdev);
526                 inode->i_cdev = NULL;
527         }
528         inode->i_state = I_CLEAR;
529 }
530
531 /*
532  * Dispose-list gets a local list with local inodes in it, so it doesn't
533  * need to worry about list corruption and SMP locks.
534  */
535 static void dispose_list(struct list_head * head)
536 {
537         struct list_head * inode_entry;
538         struct inode * inode;
539
540         while ((inode_entry = head->next) != head)
541         {
542                 list_del(inode_entry);
543
544                 inode = list_entry(inode_entry, struct inode, i_list);
545                 if (inode->i_data.nrpages)
546                         truncate_inode_pages(&inode->i_data, 0);
547                 clear_inode(inode);
548                 destroy_inode(inode);
549                 inodes_stat.nr_inodes--;
550         }
551 }
552
553 /*
554  * Invalidate all inodes for a device.
555  */
556 static int invalidate_list(struct list_head *head, struct super_block * sb, struct list_head * dispose)
557 {
558         struct list_head *next;
559         int busy = 0, count = 0;
560
561         next = head->next;
562         for (;;) {
563                 struct list_head * tmp = next;
564                 struct inode * inode;
565
566                 next = next->next;
567                 if (tmp == head)
568                         break;
569                 inode = list_entry(tmp, struct inode, i_list);
570                 if (inode->i_sb != sb)
571                         continue;
572                 invalidate_inode_buffers(inode);
573                 if (!atomic_read(&inode->i_count)) {
574                         list_del_init(&inode->i_hash);
575                         list_del(&inode->i_list);
576                         list_add(&inode->i_list, dispose);
577                         inode->i_state |= I_FREEING;
578                         count++;
579                         continue;
580                 }
581                 busy = 1;
582         }
583         /* only unused inodes may be cached with i_count zero */
584         inodes_stat.nr_unused -= count;
585         return busy;
586 }
587
588 /*
589  * This is a two-stage process. First we collect all
590  * offending inodes onto the throw-away list, and in
591  * the second stage we actually dispose of them. This
592  * is because we don't want to sleep while messing
593  * with the global lists..
594  */
595  
596 /**
597  *      invalidate_inodes       - discard the inodes on a device
598  *      @sb: superblock
599  *
600  *      Discard all of the inodes for a given superblock. If the discard
601  *      fails because there are busy inodes then a non zero value is returned.
602  *      If the discard is successful all the inodes have been discarded.
603  */
604  
605 int invalidate_inodes(struct super_block * sb)
606 {
607         int busy;
608         LIST_HEAD(throw_away);
609
610         spin_lock(&inode_lock);
611         busy = invalidate_list(&inode_in_use, sb, &throw_away);
612         busy |= invalidate_list(&inode_unused, sb, &throw_away);
613         busy |= invalidate_list(&sb->s_dirty, sb, &throw_away);
614         busy |= invalidate_list(&sb->s_locked_inodes, sb, &throw_away);
615         spin_unlock(&inode_lock);
616
617         dispose_list(&throw_away);
618
619         return busy;
620 }
621  
622 int invalidate_device(kdev_t dev, int do_sync)
623 {
624         struct super_block *sb;
625         int res;
626
627         if (do_sync)
628                 fsync_dev(dev);
629
630         res = 0;
631         sb = get_super(dev);
632         if (sb) {
633                 /*
634                  * no need to lock the super, get_super holds the
635                  * read semaphore so the filesystem cannot go away
636                  * under us (->put_super runs with the write lock
637                  * hold).
638                  */
639                 shrink_dcache_sb(sb);
640                 res = invalidate_inodes(sb);
641                 drop_super(sb);
642         }
643         invalidate_buffers(dev);
644         return res;
645 }
646
647
648 /*
649  * This is called with the inode lock held. It searches
650  * the in-use for freeable inodes, which are moved to a
651  * temporary list and then placed on the unused list by
652  * dispose_list. 
653  *
654  * We don't expect to have to call this very often.
655  *
656  * N.B. The spinlock is released during the call to
657  *      dispose_list.
658  */
659 #define CAN_UNUSE(inode) \
660         ((((inode)->i_state | (inode)->i_data.nrpages) == 0)  && \
661          !inode_has_buffers(inode))
662 #define INODE(entry)    (list_entry(entry, struct inode, i_list))
663
664 void prune_icache(int goal)
665 {
666         LIST_HEAD(list);
667         struct list_head *entry, *freeable = &list;
668         int count;
669         struct inode * inode;
670
671         spin_lock(&inode_lock);
672
673         count = 0;
674         entry = inode_unused.prev;
675         while (entry != &inode_unused)
676         {
677                 struct list_head *tmp = entry;
678
679                 entry = entry->prev;
680                 inode = INODE(tmp);
681                 if (inode->i_state & (I_FREEING|I_CLEAR|I_LOCK))
682                         continue;
683                 if (!CAN_UNUSE(inode))
684                         continue;
685                 if (atomic_read(&inode->i_count))
686                         continue;
687                 list_del(tmp);
688                 list_del(&inode->i_hash);
689                 INIT_LIST_HEAD(&inode->i_hash);
690                 list_add(tmp, freeable);
691                 inode->i_state |= I_FREEING;
692                 count++;
693                 if (!--goal)
694                         break;
695         }
696         inodes_stat.nr_unused -= count;
697         spin_unlock(&inode_lock);
698
699         dispose_list(freeable);
700
701         /* 
702          * If we didn't freed enough clean inodes schedule
703          * a sync of the dirty inodes, we cannot do it
704          * from here or we're either synchronously dogslow
705          * or we deadlock with oom.
706          */
707         if (goal)
708                 schedule_task(&unused_inodes_flush_task);
709 }
710
711 int shrink_icache_memory(int priority, int gfp_mask)
712 {
713         int count = 0;
714
715         /*
716          * Nasty deadlock avoidance..
717          *
718          * We may hold various FS locks, and we don't
719          * want to recurse into the FS that called us
720          * in clear_inode() and friends..
721          */
722         if (!(gfp_mask & __GFP_FS))
723                 return 0;
724
725         count = inodes_stat.nr_unused / priority;
726
727         prune_icache(count);
728         kmem_cache_shrink(inode_cachep);
729         return 0;
730 }
731
732 /*
733  * Called with the inode lock held.
734  * NOTE: we are not increasing the inode-refcount, you must call __iget()
735  * by hand after calling find_inode now! This simplifies iunique and won't
736  * add any additional branch in the common code.
737  */
738 static struct inode * find_inode(struct super_block * sb, unsigned long ino, struct list_head *head, find_inode_t find_actor, void *opaque)
739 {
740         struct list_head *tmp;
741         struct inode * inode;
742
743         tmp = head;
744         for (;;) {
745                 tmp = tmp->next;
746                 inode = NULL;
747                 if (tmp == head)
748                         break;
749                 inode = list_entry(tmp, struct inode, i_hash);
750                 if (inode->i_ino != ino)
751                         continue;
752                 if (inode->i_sb != sb)
753                         continue;
754                 if (find_actor && !find_actor(inode, ino, opaque))
755                         continue;
756                 break;
757         }
758         return inode;
759 }
760
761 /*
762  * This just initializes the inode fields
763  * to known values before returning the inode..
764  *
765  * i_sb, i_ino, i_count, i_state and the lists have
766  * been initialized elsewhere..
767  */
768 static void clean_inode(struct inode *inode)
769 {
770         static struct address_space_operations empty_aops;
771         static struct inode_operations empty_iops;
772         static struct file_operations empty_fops;
773         memset(&inode->u, 0, sizeof(inode->u));
774         inode->i_sock = 0;
775         inode->i_op = &empty_iops;
776         inode->i_fop = &empty_fops;
777         inode->i_nlink = 1;
778         atomic_set(&inode->i_writecount, 0);
779         inode->i_size = 0;
780         inode->i_blocks = 0;
781         inode->i_generation = 0;
782         memset(&inode->i_dquot, 0, sizeof(inode->i_dquot));
783         inode->i_pipe = NULL;
784         inode->i_bdev = NULL;
785         inode->i_cdev = NULL;
786         inode->i_data.a_ops = &empty_aops;
787         inode->i_data.host = inode;
788         inode->i_data.gfp_mask = GFP_HIGHUSER;
789         inode->i_mapping = &inode->i_data;
790 }
791
792 /**
793  * get_empty_inode      - obtain an inode
794  *
795  * This is called by things like the networking layer
796  * etc that want to get an inode without any inode
797  * number, or filesystems that allocate new inodes with
798  * no pre-existing information.
799  *
800  * On a successful return the inode pointer is returned. On a failure
801  * a %NULL pointer is returned. The returned inode is not on any superblock
802  * lists.
803  */
804  
805 struct inode * get_empty_inode(void)
806 {
807         static unsigned long last_ino;
808         struct inode * inode;
809
810         spin_lock_prefetch(&inode_lock);
811         
812         inode = alloc_inode();
813         if (inode)
814         {
815                 spin_lock(&inode_lock);
816                 inodes_stat.nr_inodes++;
817                 list_add(&inode->i_list, &inode_in_use);
818                 inode->i_sb = NULL;
819                 inode->i_dev = 0;
820                 inode->i_blkbits = 0;
821                 inode->i_ino = ++last_ino;
822                 inode->i_flags = 0;
823                 atomic_set(&inode->i_count, 1);
824                 inode->i_state = 0;
825                 spin_unlock(&inode_lock);
826                 clean_inode(inode);
827         }
828         return inode;
829 }
830
831 /*
832  * This is called without the inode lock held.. Be careful.
833  *
834  * We no longer cache the sb_flags in i_flags - see fs.h
835  *      -- rmk@arm.uk.linux.org
836  */
837 static struct inode * get_new_inode(struct super_block *sb, unsigned long ino, struct list_head *head, find_inode_t find_actor, void *opaque)
838 {
839         struct inode * inode;
840
841         inode = alloc_inode();
842         if (inode) {
843                 struct inode * old;
844
845                 spin_lock(&inode_lock);
846                 /* We released the lock, so.. */
847                 old = find_inode(sb, ino, head, find_actor, opaque);
848                 if (!old) {
849                         inodes_stat.nr_inodes++;
850                         list_add(&inode->i_list, &inode_in_use);
851                         list_add(&inode->i_hash, head);
852                         inode->i_sb = sb;
853                         inode->i_dev = sb->s_dev;
854                         inode->i_blkbits = sb->s_blocksize_bits;
855                         inode->i_ino = ino;
856                         inode->i_flags = 0;
857                         atomic_set(&inode->i_count, 1);
858                         inode->i_state = I_LOCK;
859                         spin_unlock(&inode_lock);
860
861                         clean_inode(inode);
862
863                         /* reiserfs specific hack right here.  We don't
864                         ** want this to last, and are looking for VFS changes
865                         ** that will allow us to get rid of it.
866                         ** -- mason@suse.com 
867                         */
868                         if (sb->s_op->read_inode2) {
869                                 sb->s_op->read_inode2(inode, opaque) ;
870                         } else {
871                                 sb->s_op->read_inode(inode);
872                         }
873
874                         /*
875                          * This is special!  We do not need the spinlock
876                          * when clearing I_LOCK, because we're guaranteed
877                          * that nobody else tries to do anything about the
878                          * state of the inode when it is locked, as we
879                          * just created it (so there can be no old holders
880                          * that haven't tested I_LOCK).
881                          */
882                         inode->i_state &= ~I_LOCK;
883                         wake_up(&inode->i_wait);
884
885                         return inode;
886                 }
887
888                 /*
889                  * Uhhuh, somebody else created the same inode under
890                  * us. Use the old inode instead of the one we just
891                  * allocated.
892                  */
893                 __iget(old);
894                 spin_unlock(&inode_lock);
895                 destroy_inode(inode);
896                 inode = old;
897                 wait_on_inode(inode);
898         }
899         return inode;
900 }
901
902 static inline unsigned long hash(struct super_block *sb, unsigned long i_ino)
903 {
904         unsigned long tmp = i_ino + ((unsigned long) sb / L1_CACHE_BYTES);
905         tmp = tmp + (tmp >> I_HASHBITS);
906         return tmp & I_HASHMASK;
907 }
908
909 /* Yeah, I know about quadratic hash. Maybe, later. */
910
911 /**
912  *      iunique - get a unique inode number
913  *      @sb: superblock
914  *      @max_reserved: highest reserved inode number
915  *
916  *      Obtain an inode number that is unique on the system for a given
917  *      superblock. This is used by file systems that have no natural
918  *      permanent inode numbering system. An inode number is returned that
919  *      is higher than the reserved limit but unique.
920  *
921  *      BUGS:
922  *      With a large number of inodes live on the file system this function
923  *      currently becomes quite slow.
924  */
925  
926 ino_t iunique(struct super_block *sb, ino_t max_reserved)
927 {
928         static ino_t counter = 0;
929         struct inode *inode;
930         struct list_head * head;
931         ino_t res;
932         spin_lock(&inode_lock);
933 retry:
934         if (counter > max_reserved) {
935                 head = inode_hashtable + hash(sb,counter);
936                 inode = find_inode(sb, res = counter++, head, NULL, NULL);
937                 if (!inode) {
938                         spin_unlock(&inode_lock);
939                         return res;
940                 }
941         } else {
942                 counter = max_reserved + 1;
943         }
944         goto retry;
945         
946 }
947
948 struct inode *igrab(struct inode *inode)
949 {
950         spin_lock(&inode_lock);
951         if (!(inode->i_state & I_FREEING))
952                 __iget(inode);
953         else
954                 /*
955                  * Handle the case where s_op->clear_inode is not been
956                  * called yet, and somebody is calling igrab
957                  * while the inode is getting freed.
958                  */
959                 inode = NULL;
960         spin_unlock(&inode_lock);
961         return inode;
962 }
963
964
965 struct inode *iget4(struct super_block *sb, unsigned long ino, find_inode_t find_actor, void *opaque)
966 {
967         struct list_head * head = inode_hashtable + hash(sb,ino);
968         struct inode * inode;
969
970         spin_lock(&inode_lock);
971         inode = find_inode(sb, ino, head, find_actor, opaque);
972         if (inode) {
973                 __iget(inode);
974                 spin_unlock(&inode_lock);
975                 wait_on_inode(inode);
976                 return inode;
977         }
978         spin_unlock(&inode_lock);
979
980         /*
981          * get_new_inode() will do the right thing, re-trying the search
982          * in case it had to block at any point.
983          */
984         return get_new_inode(sb, ino, head, find_actor, opaque);
985 }
986
987 /**
988  *      insert_inode_hash - hash an inode
989  *      @inode: unhashed inode
990  *
991  *      Add an inode to the inode hash for this superblock. If the inode
992  *      has no superblock it is added to a separate anonymous chain.
993  */
994  
995 void insert_inode_hash(struct inode *inode)
996 {
997         struct list_head *head = &anon_hash_chain;
998         if (inode->i_sb)
999                 head = inode_hashtable + hash(inode->i_sb, inode->i_ino);
1000         spin_lock(&inode_lock);
1001         list_add(&inode->i_hash, head);
1002         spin_unlock(&inode_lock);
1003 }
1004
1005 /**
1006  *      remove_inode_hash - remove an inode from the hash
1007  *      @inode: inode to unhash
1008  *
1009  *      Remove an inode from the superblock or anonymous hash.
1010  */
1011  
1012 void remove_inode_hash(struct inode *inode)
1013 {
1014         spin_lock(&inode_lock);
1015         list_del(&inode->i_hash);
1016         INIT_LIST_HEAD(&inode->i_hash);
1017         spin_unlock(&inode_lock);
1018 }
1019
1020 /**
1021  *      iput    - put an inode 
1022  *      @inode: inode to put
1023  *
1024  *      Puts an inode, dropping its usage count. If the inode use count hits
1025  *      zero the inode is also then freed and may be destroyed.
1026  */
1027  
1028 void iput(struct inode *inode)
1029 {
1030         if (inode) {
1031                 struct super_block *sb = inode->i_sb;
1032                 struct super_operations *op = NULL;
1033
1034                 if (inode->i_state == I_CLEAR)
1035                         BUG();
1036
1037                 if (sb && sb->s_op)
1038                         op = sb->s_op;
1039                 if (op && op->put_inode)
1040                         op->put_inode(inode);
1041
1042                 if (!atomic_dec_and_lock(&inode->i_count, &inode_lock))
1043                         return;
1044
1045                 if (!inode->i_nlink) {
1046                         list_del(&inode->i_hash);
1047                         INIT_LIST_HEAD(&inode->i_hash);
1048                         list_del(&inode->i_list);
1049                         INIT_LIST_HEAD(&inode->i_list);
1050                         inode->i_state|=I_FREEING;
1051                         inodes_stat.nr_inodes--;
1052                         spin_unlock(&inode_lock);
1053
1054                         if (inode->i_data.nrpages)
1055                                 truncate_inode_pages(&inode->i_data, 0);
1056
1057                         if (op && op->delete_inode) {
1058                                 void (*delete)(struct inode *) = op->delete_inode;
1059                                 if (!is_bad_inode(inode))
1060                                         DQUOT_INIT(inode);
1061                                 /* s_op->delete_inode internally recalls clear_inode() */
1062                                 delete(inode);
1063                         } else
1064                                 clear_inode(inode);
1065                         if (inode->i_state != I_CLEAR)
1066                                 BUG();
1067                 } else {
1068                         if (!list_empty(&inode->i_hash) && sb && sb->s_root) {
1069                                 if (!(inode->i_state & (I_DIRTY|I_LOCK))) {
1070                                         list_del(&inode->i_list);
1071                                         list_add(&inode->i_list, &inode_unused);
1072                                 }
1073                                 inodes_stat.nr_unused++;
1074                                 spin_unlock(&inode_lock);
1075                                 return;
1076                         } else {
1077                                 list_del_init(&inode->i_list);
1078                                 list_del_init(&inode->i_hash);
1079                                 inode->i_state|=I_FREEING;
1080                                 inodes_stat.nr_inodes--;
1081                                 spin_unlock(&inode_lock);
1082                                 if (inode->i_data.nrpages)
1083                                         truncate_inode_pages(&inode->i_data, 0);
1084                                 clear_inode(inode);
1085                         }
1086                 }
1087                 destroy_inode(inode);
1088         }
1089 }
1090
1091 void force_delete(struct inode *inode)
1092 {
1093         /*
1094          * Kill off unused inodes ... iput() will unhash and
1095          * delete the inode if we set i_nlink to zero.
1096          */
1097         if (atomic_read(&inode->i_count) == 1)
1098                 inode->i_nlink = 0;
1099 }
1100
1101 /**
1102  *      bmap    - find a block number in a file
1103  *      @inode: inode of file
1104  *      @block: block to find
1105  *
1106  *      Returns the block number on the device holding the inode that
1107  *      is the disk block number for the block of the file requested.
1108  *      That is, asked for block 4 of inode 1 the function will return the
1109  *      disk block relative to the disk start that holds that block of the 
1110  *      file.
1111  */
1112  
1113 int bmap(struct inode * inode, int block)
1114 {
1115         int res = 0;
1116         if (inode->i_mapping->a_ops->bmap)
1117                 res = inode->i_mapping->a_ops->bmap(inode->i_mapping, block);
1118         return res;
1119 }
1120
1121 /*
1122  * Initialize the hash tables.
1123  */
1124 void __init inode_init(unsigned long mempages)
1125 {
1126         struct list_head *head;
1127         unsigned long order;
1128         unsigned int nr_hash;
1129         int i;
1130
1131         mempages >>= (14 - PAGE_SHIFT);
1132         mempages *= sizeof(struct list_head);
1133         for (order = 0; ((1UL << order) << PAGE_SHIFT) < mempages; order++)
1134                 ;
1135
1136         do {
1137                 unsigned long tmp;
1138
1139                 nr_hash = (1UL << order) * PAGE_SIZE /
1140                         sizeof(struct list_head);
1141                 i_hash_mask = (nr_hash - 1);
1142
1143                 tmp = nr_hash;
1144                 i_hash_shift = 0;
1145                 while ((tmp >>= 1UL) != 0UL)
1146                         i_hash_shift++;
1147
1148                 inode_hashtable = (struct list_head *)
1149                         __get_free_pages(GFP_ATOMIC, order);
1150         } while (inode_hashtable == NULL && --order >= 0);
1151
1152         printk("Inode-cache hash table entries: %d (order: %ld, %ld bytes)\n",
1153                         nr_hash, order, (PAGE_SIZE << order));
1154
1155         if (!inode_hashtable)
1156                 panic("Failed to allocate inode hash table\n");
1157
1158         head = inode_hashtable;
1159         i = nr_hash;
1160         do {
1161                 INIT_LIST_HEAD(head);
1162                 head++;
1163                 i--;
1164         } while (i);
1165
1166         /* inode slab cache */
1167         inode_cachep = kmem_cache_create("inode_cache", sizeof(struct inode),
1168                                          0, SLAB_HWCACHE_ALIGN, init_once,
1169                                          NULL);
1170         if (!inode_cachep)
1171                 panic("cannot create inode slab cache");
1172
1173         unused_inodes_flush_task.routine = try_to_sync_unused_inodes;
1174 }
1175
1176 /**
1177  *      update_atime    -       update the access time
1178  *      @inode: inode accessed
1179  *
1180  *      Update the accessed time on an inode and mark it for writeback.
1181  *      This function automatically handles read only file systems and media,
1182  *      as well as the "noatime" flag and inode specific "noatime" markers.
1183  */
1184  
1185 void update_atime (struct inode *inode)
1186 {
1187         if ( IS_NOATIME (inode) ) return;
1188         if ( IS_NODIRATIME (inode) && S_ISDIR (inode->i_mode) ) return;
1189         if ( IS_RDONLY (inode) ) return;
1190         inode->i_atime = CURRENT_TIME;
1191         mark_inode_dirty_sync (inode);
1192 }   /*  End Function update_atime  */
1193
1194
1195 /*
1196  *      Quota functions that want to walk the inode lists..
1197  */
1198 #ifdef CONFIG_QUOTA
1199
1200 /* Functions back in dquot.c */
1201 void put_dquot_list(struct list_head *);
1202 int remove_inode_dquot_ref(struct inode *, short, struct list_head *);
1203
1204 void remove_dquot_ref(struct super_block *sb, short type)
1205 {
1206         struct inode *inode;
1207         struct list_head *act_head;
1208         LIST_HEAD(tofree_head);
1209
1210         if (!sb->dq_op)
1211                 return; /* nothing to do */
1212         /* We have to be protected against other CPUs */
1213         lock_kernel();          /* This lock is for quota code */
1214         spin_lock(&inode_lock); /* This lock is for inodes code */
1215  
1216         list_for_each(act_head, &inode_in_use) {
1217                 inode = list_entry(act_head, struct inode, i_list);
1218                 if (inode->i_sb == sb && IS_QUOTAINIT(inode))
1219                         remove_inode_dquot_ref(inode, type, &tofree_head);
1220         }
1221         list_for_each(act_head, &inode_unused) {
1222                 inode = list_entry(act_head, struct inode, i_list);
1223                 if (inode->i_sb == sb && IS_QUOTAINIT(inode))
1224                         remove_inode_dquot_ref(inode, type, &tofree_head);
1225         }
1226         list_for_each(act_head, &sb->s_dirty) {
1227                 inode = list_entry(act_head, struct inode, i_list);
1228                 if (IS_QUOTAINIT(inode))
1229                         remove_inode_dquot_ref(inode, type, &tofree_head);
1230         }
1231         list_for_each(act_head, &sb->s_locked_inodes) {
1232                 inode = list_entry(act_head, struct inode, i_list);
1233                 if (IS_QUOTAINIT(inode))
1234                         remove_inode_dquot_ref(inode, type, &tofree_head);
1235         }
1236         spin_unlock(&inode_lock);
1237         unlock_kernel();
1238
1239         put_dquot_list(&tofree_head);
1240 }
1241
1242 #endif