4 * (C) 1997 Linus Torvalds
7 #include <linux/config.h>
9 #include <linux/string.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>
18 * New inode.c implementation.
20 * This implementation has the basic premise of trying
21 * to be extremely low-overhead and SMP-safe, yet be
22 * simple enough to be "obviously correct".
27 /* inode dynamic allocation 1999, Andrea Arcangeli <andrea@suse.de> */
29 /* #define INODE_PARANOIA 1 */
30 /* #define INODE_DEBUG 1 */
33 * Inode lookup is no longer as critical as it used to be:
34 * most of the lookups are going to be through the dcache.
36 #define I_HASHBITS i_hash_shift
37 #define I_HASHMASK i_hash_mask
39 static unsigned int i_hash_mask
;
40 static unsigned int i_hash_shift
;
43 * Each inode can be on two separate lists. One is
44 * the hash list of the inode, used for lookups. The
45 * other linked list is the "type" list:
46 * "in_use" - valid inode, i_count > 0, i_nlink > 0
47 * "dirty" - as "in_use" but also dirty
48 * "unused" - valid inode, i_count = 0
50 * A "dirty" list is maintained for each super block,
51 * allowing for low-overhead inode sync() operations.
54 static LIST_HEAD(inode_in_use
);
55 static LIST_HEAD(inode_unused
);
56 static struct list_head
*inode_hashtable
;
57 static LIST_HEAD(anon_hash_chain
); /* for inodes with NULL i_sb */
60 * A simple spinlock to protect the list manipulations.
62 * NOTE! You also have to own the lock if you change
63 * the i_state of an inode while it is in use..
65 spinlock_t inode_lock
= SPIN_LOCK_UNLOCKED
;
68 * Statistics gathering..
76 static kmem_cache_t
* inode_cachep
;
78 #define alloc_inode() \
79 ((struct inode *) kmem_cache_alloc(inode_cachep, SLAB_KERNEL))
80 static void destroy_inode(struct inode
*inode
)
82 if (!list_empty(&inode
->i_dirty_buffers
))
84 kmem_cache_free(inode_cachep
, (inode
));
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.
93 static void init_once(void * foo
, kmem_cache_t
* cachep
, unsigned long flags
)
95 struct inode
* inode
= (struct inode
*) foo
;
97 if ((flags
& (SLAB_CTOR_VERIFY
|SLAB_CTOR_CONSTRUCTOR
)) ==
98 SLAB_CTOR_CONSTRUCTOR
)
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 sema_init(&inode
->i_sem
, 1);
109 sema_init(&inode
->i_zombie
, 1);
110 spin_lock_init(&inode
->i_data
.i_shared_lock
);
115 * Put the inode on the super block's dirty list.
117 * CAREFUL! We mark it dirty unconditionally, but
118 * move it onto the dirty list only if it is hashed.
119 * If it was not hashed, it will never be added to
120 * the dirty list even if it is later hashed, as it
121 * will have been marked dirty already.
123 * In short, make sure you hash any inodes _before_
124 * you start marking them dirty..
128 * __mark_inode_dirty - internal function
129 * @inode: inode to mark
131 * Mark an inode as dirty. Callers should use mark_inode_dirty.
134 void __mark_inode_dirty(struct inode
*inode
, int flags
)
136 struct super_block
* sb
= inode
->i_sb
;
139 spin_lock(&inode_lock
);
140 if ((inode
->i_state
& flags
) != flags
) {
141 inode
->i_state
|= flags
;
142 /* Only add valid (ie hashed) inodes to the dirty list */
143 if (!list_empty(&inode
->i_hash
)) {
144 list_del(&inode
->i_list
);
145 list_add(&inode
->i_list
, &sb
->s_dirty
);
148 spin_unlock(&inode_lock
);
152 static void __wait_on_inode(struct inode
* inode
)
154 DECLARE_WAITQUEUE(wait
, current
);
156 add_wait_queue(&inode
->i_wait
, &wait
);
158 set_current_state(TASK_UNINTERRUPTIBLE
);
159 if (inode
->i_state
& I_LOCK
) {
163 remove_wait_queue(&inode
->i_wait
, &wait
);
164 current
->state
= TASK_RUNNING
;
167 static inline void wait_on_inode(struct inode
*inode
)
169 if (inode
->i_state
& I_LOCK
)
170 __wait_on_inode(inode
);
174 static inline void write_inode(struct inode
*inode
, int sync
)
176 if (inode
->i_sb
&& inode
->i_sb
->s_op
&& inode
->i_sb
->s_op
->write_inode
)
177 inode
->i_sb
->s_op
->write_inode(inode
, sync
);
180 static inline void __iget(struct inode
* inode
)
182 if (atomic_read(&inode
->i_count
)) {
183 atomic_inc(&inode
->i_count
);
186 atomic_inc(&inode
->i_count
);
187 if (!(inode
->i_state
& I_DIRTY
)) {
188 list_del(&inode
->i_list
);
189 list_add(&inode
->i_list
, &inode_in_use
);
191 inodes_stat
.nr_unused
--;
194 static inline void sync_one(struct inode
*inode
, int sync
)
196 if (inode
->i_state
& I_LOCK
) {
198 spin_unlock(&inode_lock
);
199 __wait_on_inode(inode
);
201 spin_lock(&inode_lock
);
205 list_del(&inode
->i_list
);
206 list_add(&inode
->i_list
, atomic_read(&inode
->i_count
)
209 /* Set I_LOCK, reset I_DIRTY */
210 dirty
= inode
->i_state
& I_DIRTY
;
211 inode
->i_state
|= I_LOCK
;
212 inode
->i_state
&= ~I_DIRTY
;
213 spin_unlock(&inode_lock
);
215 filemap_fdatasync(inode
->i_mapping
);
217 /* Don't write the inode if only I_DIRTY_PAGES was set */
218 if (dirty
& (I_DIRTY_SYNC
| I_DIRTY_DATASYNC
))
219 write_inode(inode
, sync
);
221 filemap_fdatawait(inode
->i_mapping
);
223 spin_lock(&inode_lock
);
224 inode
->i_state
&= ~I_LOCK
;
225 wake_up(&inode
->i_wait
);
229 static inline void sync_list(struct list_head
*head
)
231 struct list_head
* tmp
;
233 while ((tmp
= head
->prev
) != head
)
234 sync_one(list_entry(tmp
, struct inode
, i_list
), 0);
239 * @dev: device to sync the inodes from.
241 * sync_inodes goes through the super block's dirty list,
242 * writes them out, and puts them back on the normal list.
245 void sync_inodes(kdev_t dev
)
247 struct super_block
* sb
= sb_entry(super_blocks
.next
);
250 * Search the super_blocks array for the device(s) to sync.
252 spin_lock(&inode_lock
);
253 for (; sb
!= sb_entry(&super_blocks
); sb
= sb_entry(sb
->s_list
.next
)) {
256 if (dev
&& sb
->s_dev
!= dev
)
259 sync_list(&sb
->s_dirty
);
264 spin_unlock(&inode_lock
);
268 * Called with the spinlock already held..
270 static void sync_all_inodes(void)
272 struct super_block
* sb
= sb_entry(super_blocks
.next
);
273 for (; sb
!= sb_entry(&super_blocks
); sb
= sb_entry(sb
->s_list
.next
)) {
276 sync_list(&sb
->s_dirty
);
281 * write_inode_now - write an inode to disk
282 * @inode: inode to write to disk
283 * @sync: whether the write should be synchronous or not
285 * This function commits an inode to disk immediately if it is
286 * dirty. This is primarily needed by knfsd.
289 void write_inode_now(struct inode
*inode
, int sync
)
291 struct super_block
* sb
= inode
->i_sb
;
294 spin_lock(&inode_lock
);
295 while (inode
->i_state
& I_DIRTY
)
296 sync_one(inode
, sync
);
297 spin_unlock(&inode_lock
);
300 printk("write_inode_now: no super block\n");
304 * generic_osync_inode - flush all dirty data for a given inode to disk
305 * @inode: inode to write
306 * @datasync: if set, don't bother flushing timestamps
308 * This can be called by file_write functions for files which have the
309 * O_SYNC flag set, to flush dirty writes to disk.
312 int generic_osync_inode(struct inode
*inode
, int datasync
)
319 * Currently, the filesystem write path does not pass the
320 * filp down to the low-level write functions. Therefore it
321 * is impossible for (say) __block_commit_write to know if
322 * the operation is O_SYNC or not.
324 * Ideally, O_SYNC writes would have the filesystem call
325 * ll_rw_block as it went to kick-start the writes, and we
326 * could call osync_inode_buffers() here to wait only for
327 * those IOs which have already been submitted to the device
328 * driver layer. As it stands, if we did this we'd not write
329 * anything to disk since our writes have not been queued by
330 * this point: they are still on the dirty LRU.
332 * So, currently we will call fsync_inode_buffers() instead,
333 * to flush _all_ dirty buffers for this inode to disk on
334 * every O_SYNC write, not just the synchronous I/Os. --sct
337 #ifdef WRITERS_QUEUE_IO
338 err
= osync_inode_buffers(inode
);
340 err
= fsync_inode_buffers(inode
);
343 spin_lock(&inode_lock
);
344 if (!(inode
->i_state
& I_DIRTY
))
346 if (datasync
&& !(inode
->i_state
& I_DIRTY_DATASYNC
))
348 spin_unlock(&inode_lock
);
349 write_inode_now(inode
, 1);
353 spin_unlock(&inode_lock
);
358 * clear_inode - clear an inode
359 * @inode: inode to clear
361 * This is called by the filesystem to tell us
362 * that the inode is no longer useful. We just
363 * terminate it with extreme prejudice.
366 void clear_inode(struct inode
*inode
)
368 if (!list_empty(&inode
->i_dirty_buffers
))
369 invalidate_inode_buffers(inode
);
371 if (inode
->i_data
.nrpages
)
373 if (!(inode
->i_state
& I_FREEING
))
375 if (inode
->i_state
& I_CLEAR
)
377 wait_on_inode(inode
);
378 if (IS_QUOTAINIT(inode
))
380 if (inode
->i_sb
&& inode
->i_sb
->s_op
&& inode
->i_sb
->s_op
->clear_inode
)
381 inode
->i_sb
->s_op
->clear_inode(inode
);
383 bdput(inode
->i_bdev
);
384 inode
->i_bdev
= NULL
;
386 inode
->i_state
= I_CLEAR
;
390 * Dispose-list gets a local list with local inodes in it, so it doesn't
391 * need to worry about list corruption and SMP locks.
393 static void dispose_list(struct list_head
* head
)
395 struct list_head
* inode_entry
;
396 struct inode
* inode
;
398 while ((inode_entry
= head
->next
) != head
)
400 list_del(inode_entry
);
402 inode
= list_entry(inode_entry
, struct inode
, i_list
);
403 if (inode
->i_data
.nrpages
)
404 truncate_inode_pages(&inode
->i_data
, 0);
406 destroy_inode(inode
);
407 inodes_stat
.nr_inodes
--;
412 * Invalidate all inodes for a device.
414 static int invalidate_list(struct list_head
*head
, struct super_block
* sb
, struct list_head
* dispose
)
416 struct list_head
*next
;
417 int busy
= 0, count
= 0;
421 struct list_head
* tmp
= next
;
422 struct inode
* inode
;
427 inode
= list_entry(tmp
, struct inode
, i_list
);
428 if (inode
->i_sb
!= sb
)
430 invalidate_inode_buffers(inode
);
431 if (!atomic_read(&inode
->i_count
)) {
432 list_del(&inode
->i_hash
);
433 INIT_LIST_HEAD(&inode
->i_hash
);
434 list_del(&inode
->i_list
);
435 list_add(&inode
->i_list
, dispose
);
436 inode
->i_state
|= I_FREEING
;
442 /* only unused inodes may be cached with i_count zero */
443 inodes_stat
.nr_unused
-= count
;
448 * This is a two-stage process. First we collect all
449 * offending inodes onto the throw-away list, and in
450 * the second stage we actually dispose of them. This
451 * is because we don't want to sleep while messing
452 * with the global lists..
456 * invalidate_inodes - discard the inodes on a device
459 * Discard all of the inodes for a given superblock. If the discard
460 * fails because there are busy inodes then a non zero value is returned.
461 * If the discard is successful all the inodes have been discarded.
464 int invalidate_inodes(struct super_block
* sb
)
467 LIST_HEAD(throw_away
);
469 spin_lock(&inode_lock
);
470 busy
= invalidate_list(&inode_in_use
, sb
, &throw_away
);
471 busy
|= invalidate_list(&inode_unused
, sb
, &throw_away
);
472 busy
|= invalidate_list(&sb
->s_dirty
, sb
, &throw_away
);
473 spin_unlock(&inode_lock
);
475 dispose_list(&throw_away
);
481 * This is called with the inode lock held. It searches
482 * the in-use for freeable inodes, which are moved to a
483 * temporary list and then placed on the unused list by
486 * We don't expect to have to call this very often.
488 * N.B. The spinlock is released during the call to
491 #define CAN_UNUSE(inode) \
492 ((((inode)->i_state | (inode)->i_data.nrpages) == 0) && \
493 !inode_has_buffers(inode))
494 #define INODE(entry) (list_entry(entry, struct inode, i_list))
496 void prune_icache(int goal
)
499 struct list_head
*entry
, *freeable
= &list
;
501 struct inode
* inode
;
503 spin_lock(&inode_lock
);
504 /* go simple and safe syncing everything before starting */
507 entry
= inode_unused
.prev
;
508 while (entry
!= &inode_unused
)
510 struct list_head
*tmp
= entry
;
514 if (inode
->i_state
& (I_FREEING
|I_CLEAR
))
516 if (!CAN_UNUSE(inode
))
518 if (atomic_read(&inode
->i_count
))
521 list_del(&inode
->i_hash
);
522 INIT_LIST_HEAD(&inode
->i_hash
);
523 list_add(tmp
, freeable
);
524 inode
->i_state
|= I_FREEING
;
529 inodes_stat
.nr_unused
-= count
;
530 spin_unlock(&inode_lock
);
532 dispose_list(freeable
);
535 void shrink_icache_memory(int priority
, int gfp_mask
)
540 * Nasty deadlock avoidance..
542 * We may hold various FS locks, and we don't
543 * want to recurse into the FS that called us
544 * in clear_inode() and friends..
546 if (!(gfp_mask
& __GFP_IO
))
550 count
= inodes_stat
.nr_unused
/ priority
;
553 kmem_cache_shrink(inode_cachep
);
557 * Called with the inode lock held.
558 * NOTE: we are not increasing the inode-refcount, you must call __iget()
559 * by hand after calling find_inode now! This simplifies iunique and won't
560 * add any additional branch in the common code.
562 static struct inode
* find_inode(struct super_block
* sb
, unsigned long ino
, struct list_head
*head
, find_inode_t find_actor
, void *opaque
)
564 struct list_head
*tmp
;
565 struct inode
* inode
;
573 inode
= list_entry(tmp
, struct inode
, i_hash
);
574 if (inode
->i_ino
!= ino
)
576 if (inode
->i_sb
!= sb
)
578 if (find_actor
&& !find_actor(inode
, ino
, opaque
))
586 * This just initializes the inode fields
587 * to known values before returning the inode..
589 * i_sb, i_ino, i_count, i_state and the lists have
590 * been initialized elsewhere..
592 static void clean_inode(struct inode
*inode
)
594 static struct address_space_operations empty_aops
;
595 static struct inode_operations empty_iops
;
596 static struct file_operations empty_fops
;
597 memset(&inode
->u
, 0, sizeof(inode
->u
));
599 inode
->i_op
= &empty_iops
;
600 inode
->i_fop
= &empty_fops
;
602 atomic_set(&inode
->i_writecount
, 0);
604 inode
->i_generation
= 0;
605 memset(&inode
->i_dquot
, 0, sizeof(inode
->i_dquot
));
606 inode
->i_pipe
= NULL
;
607 inode
->i_bdev
= NULL
;
608 inode
->i_data
.a_ops
= &empty_aops
;
609 inode
->i_data
.host
= inode
;
610 inode
->i_mapping
= &inode
->i_data
;
614 * get_empty_inode - obtain an inode
616 * This is called by things like the networking layer
617 * etc that want to get an inode without any inode
618 * number, or filesystems that allocate new inodes with
619 * no pre-existing information.
621 * On a successful return the inode pointer is returned. On a failure
622 * a %NULL pointer is returned. The returned inode is not on any superblock
626 struct inode
* get_empty_inode(void)
628 static unsigned long last_ino
;
629 struct inode
* inode
;
631 inode
= alloc_inode();
634 spin_lock(&inode_lock
);
635 inodes_stat
.nr_inodes
++;
636 list_add(&inode
->i_list
, &inode_in_use
);
639 inode
->i_ino
= ++last_ino
;
641 atomic_set(&inode
->i_count
, 1);
643 spin_unlock(&inode_lock
);
650 * This is called without the inode lock held.. Be careful.
652 * We no longer cache the sb_flags in i_flags - see fs.h
653 * -- rmk@arm.uk.linux.org
655 static struct inode
* get_new_inode(struct super_block
*sb
, unsigned long ino
, struct list_head
*head
, find_inode_t find_actor
, void *opaque
)
657 struct inode
* inode
;
659 inode
= alloc_inode();
663 spin_lock(&inode_lock
);
664 /* We released the lock, so.. */
665 old
= find_inode(sb
, ino
, head
, find_actor
, opaque
);
667 inodes_stat
.nr_inodes
++;
668 list_add(&inode
->i_list
, &inode_in_use
);
669 list_add(&inode
->i_hash
, head
);
671 inode
->i_dev
= sb
->s_dev
;
674 atomic_set(&inode
->i_count
, 1);
675 inode
->i_state
= I_LOCK
;
676 spin_unlock(&inode_lock
);
679 sb
->s_op
->read_inode(inode
);
682 * This is special! We do not need the spinlock
683 * when clearing I_LOCK, because we're guaranteed
684 * that nobody else tries to do anything about the
685 * state of the inode when it is locked, as we
686 * just created it (so there can be no old holders
687 * that haven't tested I_LOCK).
689 inode
->i_state
&= ~I_LOCK
;
690 wake_up(&inode
->i_wait
);
696 * Uhhuh, somebody else created the same inode under
697 * us. Use the old inode instead of the one we just
701 spin_unlock(&inode_lock
);
702 destroy_inode(inode
);
704 wait_on_inode(inode
);
709 static inline unsigned long hash(struct super_block
*sb
, unsigned long i_ino
)
711 unsigned long tmp
= i_ino
| ((unsigned long) sb
/ L1_CACHE_BYTES
);
712 tmp
= tmp
+ (tmp
>> I_HASHBITS
) + (tmp
>> I_HASHBITS
*2);
713 return tmp
& I_HASHMASK
;
716 /* Yeah, I know about quadratic hash. Maybe, later. */
719 * iunique - get a unique inode number
721 * @max_reserved: highest reserved inode number
723 * Obtain an inode number that is unique on the system for a given
724 * superblock. This is used by file systems that have no natural
725 * permanent inode numbering system. An inode number is returned that
726 * is higher than the reserved limit but unique.
729 * With a large number of inodes live on the file system this function
730 * currently becomes quite slow.
733 ino_t
iunique(struct super_block
*sb
, ino_t max_reserved
)
735 static ino_t counter
= 0;
737 struct list_head
* head
;
739 spin_lock(&inode_lock
);
741 if (counter
> max_reserved
) {
742 head
= inode_hashtable
+ hash(sb
,counter
);
743 inode
= find_inode(sb
, res
= counter
++, head
, NULL
, NULL
);
745 spin_unlock(&inode_lock
);
749 counter
= max_reserved
+ 1;
755 struct inode
*igrab(struct inode
*inode
)
757 spin_lock(&inode_lock
);
758 if (!(inode
->i_state
& I_FREEING
))
762 * Handle the case where s_op->clear_inode is not been
763 * called yet, and somebody is calling igrab
764 * while the inode is getting freed.
767 spin_unlock(&inode_lock
);
769 wait_on_inode(inode
);
774 struct inode
*iget4(struct super_block
*sb
, unsigned long ino
, find_inode_t find_actor
, void *opaque
)
776 struct list_head
* head
= inode_hashtable
+ hash(sb
,ino
);
777 struct inode
* inode
;
779 spin_lock(&inode_lock
);
780 inode
= find_inode(sb
, ino
, head
, find_actor
, opaque
);
783 spin_unlock(&inode_lock
);
784 wait_on_inode(inode
);
787 spin_unlock(&inode_lock
);
790 * get_new_inode() will do the right thing, re-trying the search
791 * in case it had to block at any point.
793 return get_new_inode(sb
, ino
, head
, find_actor
, opaque
);
797 * insert_inode_hash - hash an inode
798 * @inode: unhashed inode
800 * Add an inode to the inode hash for this superblock. If the inode
801 * has no superblock it is added to a separate anonymous chain.
804 void insert_inode_hash(struct inode
*inode
)
806 struct list_head
*head
= &anon_hash_chain
;
808 head
= inode_hashtable
+ hash(inode
->i_sb
, inode
->i_ino
);
809 spin_lock(&inode_lock
);
810 list_add(&inode
->i_hash
, head
);
811 spin_unlock(&inode_lock
);
815 * remove_inode_hash - remove an inode from the hash
816 * @inode: inode to unhash
818 * Remove an inode from the superblock or anonymous hash.
821 void remove_inode_hash(struct inode
*inode
)
823 spin_lock(&inode_lock
);
824 list_del(&inode
->i_hash
);
825 INIT_LIST_HEAD(&inode
->i_hash
);
826 spin_unlock(&inode_lock
);
830 * iput - put an inode
831 * @inode: inode to put
833 * Puts an inode, dropping its usage count. If the inode use count hits
834 * zero the inode is also then freed and may be destroyed.
837 void iput(struct inode
*inode
)
840 struct super_operations
*op
= NULL
;
842 if (inode
->i_sb
&& inode
->i_sb
->s_op
)
843 op
= inode
->i_sb
->s_op
;
844 if (op
&& op
->put_inode
)
845 op
->put_inode(inode
);
847 if (!atomic_dec_and_lock(&inode
->i_count
, &inode_lock
))
850 if (!inode
->i_nlink
) {
851 list_del(&inode
->i_hash
);
852 INIT_LIST_HEAD(&inode
->i_hash
);
853 list_del(&inode
->i_list
);
854 INIT_LIST_HEAD(&inode
->i_list
);
855 inode
->i_state
|=I_FREEING
;
856 inodes_stat
.nr_inodes
--;
857 spin_unlock(&inode_lock
);
859 if (inode
->i_data
.nrpages
)
860 truncate_inode_pages(&inode
->i_data
, 0);
862 if (op
&& op
->delete_inode
) {
863 void (*delete)(struct inode
*) = op
->delete_inode
;
864 /* s_op->delete_inode internally recalls clear_inode() */
868 if (inode
->i_state
!= I_CLEAR
)
871 if (!list_empty(&inode
->i_hash
)) {
872 if (!(inode
->i_state
& I_DIRTY
)) {
873 list_del(&inode
->i_list
);
874 list_add(&inode
->i_list
,
877 inodes_stat
.nr_unused
++;
878 spin_unlock(&inode_lock
);
882 list_del(&inode
->i_list
);
883 INIT_LIST_HEAD(&inode
->i_list
);
884 inode
->i_state
|=I_FREEING
;
885 inodes_stat
.nr_inodes
--;
886 spin_unlock(&inode_lock
);
890 destroy_inode(inode
);
894 void force_delete(struct inode
*inode
)
897 * Kill off unused inodes ... iput() will unhash and
898 * delete the inode if we set i_nlink to zero.
900 if (atomic_read(&inode
->i_count
) == 1)
905 * bmap - find a block number in a file
906 * @inode: inode of file
907 * @block: block to find
909 * Returns the block number on the device holding the inode that
910 * is the disk block number for the block of the file requested.
911 * That is, asked for block 4 of inode 1 the function will return the
912 * disk block relative to the disk start that holds that block of the
916 int bmap(struct inode
* inode
, int block
)
919 if (inode
->i_mapping
->a_ops
->bmap
)
920 res
= inode
->i_mapping
->a_ops
->bmap(inode
->i_mapping
, block
);
925 * Initialize the hash tables.
927 void __init
inode_init(unsigned long mempages
)
929 struct list_head
*head
;
931 unsigned int nr_hash
;
934 mempages
>>= (14 - PAGE_SHIFT
);
935 mempages
*= sizeof(struct list_head
);
936 for (order
= 0; ((1UL << order
) << PAGE_SHIFT
) < mempages
; order
++)
942 nr_hash
= (1UL << order
) * PAGE_SIZE
/
943 sizeof(struct list_head
);
944 i_hash_mask
= (nr_hash
- 1);
948 while ((tmp
>>= 1UL) != 0UL)
951 inode_hashtable
= (struct list_head
*)
952 __get_free_pages(GFP_ATOMIC
, order
);
953 } while (inode_hashtable
== NULL
&& --order
>= 0);
955 printk("Inode-cache hash table entries: %d (order: %ld, %ld bytes)\n",
956 nr_hash
, order
, (PAGE_SIZE
<< order
));
958 if (!inode_hashtable
)
959 panic("Failed to allocate inode hash table\n");
961 head
= inode_hashtable
;
964 INIT_LIST_HEAD(head
);
969 /* inode slab cache */
970 inode_cachep
= kmem_cache_create("inode_cache", sizeof(struct inode
),
971 0, SLAB_HWCACHE_ALIGN
, init_once
,
974 panic("cannot create inode slab cache");
978 * update_atime - update the access time
979 * @inode: inode accessed
981 * Update the accessed time on an inode and mark it for writeback.
982 * This function automatically handles read only file systems and media,
983 * as well as the "noatime" flag and inode specific "noatime" markers.
986 void update_atime (struct inode
*inode
)
988 if ( IS_NOATIME (inode
) ) return;
989 if ( IS_NODIRATIME (inode
) && S_ISDIR (inode
->i_mode
) ) return;
990 if ( IS_RDONLY (inode
) ) return;
991 inode
->i_atime
= CURRENT_TIME
;
992 mark_inode_dirty_sync (inode
);
993 } /* End Function update_atime */
997 * Quota functions that want to walk the inode lists..
1001 /* Functions back in dquot.c */
1002 void put_dquot_list(struct list_head
*);
1003 int remove_inode_dquot_ref(struct inode
*, short, struct list_head
*);
1005 void remove_dquot_ref(kdev_t dev
, short type
)
1007 struct super_block
*sb
= get_super(dev
);
1008 struct inode
*inode
;
1009 struct list_head
*act_head
;
1010 LIST_HEAD(tofree_head
);
1012 if (!sb
|| !sb
->dq_op
)
1013 return; /* nothing to do */
1015 /* We have to be protected against other CPUs */
1016 spin_lock(&inode_lock
);
1018 for (act_head
= inode_in_use
.next
; act_head
!= &inode_in_use
; act_head
= act_head
->next
) {
1019 inode
= list_entry(act_head
, struct inode
, i_list
);
1020 if (inode
->i_sb
!= sb
|| !IS_QUOTAINIT(inode
))
1022 remove_inode_dquot_ref(inode
, type
, &tofree_head
);
1024 for (act_head
= inode_unused
.next
; act_head
!= &inode_unused
; act_head
= act_head
->next
) {
1025 inode
= list_entry(act_head
, struct inode
, i_list
);
1026 if (inode
->i_sb
!= sb
|| !IS_QUOTAINIT(inode
))
1028 remove_inode_dquot_ref(inode
, type
, &tofree_head
);
1030 for (act_head
= sb
->s_dirty
.next
; act_head
!= &sb
->s_dirty
; act_head
= act_head
->next
) {
1031 inode
= list_entry(act_head
, struct inode
, i_list
);
1032 if (!IS_QUOTAINIT(inode
))
1034 remove_inode_dquot_ref(inode
, type
, &tofree_head
);
1036 spin_unlock(&inode_lock
);
1038 put_dquot_list(&tofree_head
);