blob: 2bee20ae3d65ba74f970129ec8d147ab7cd4fe50 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/inode.c
3 *
4 * (C) 1997 Linus Torvalds
5 */
6
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/fs.h>
8#include <linux/mm.h>
9#include <linux/dcache.h>
10#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/slab.h>
12#include <linux/writeback.h>
13#include <linux/module.h>
14#include <linux/backing-dev.h>
15#include <linux/wait.h>
Nick Piggin88e0fbc2009-09-22 16:43:50 -070016#include <linux/rwsem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#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>
Robert Love0eeca282005-07-12 17:06:03 -040023#include <linux/inotify.h>
Eric Paris3be25f42009-05-21 17:01:26 -040024#include <linux/fsnotify.h>
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -080025#include <linux/mount.h>
Arjan van de Venefaee192009-01-06 07:20:54 -080026#include <linux/async.h>
Al Virof19d4a82009-06-08 19:50:45 -040027#include <linux/posix_acl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29/*
30 * This is needed for the following functions:
31 * - inode_has_buffers
32 * - invalidate_inode_buffers
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 * - invalidate_bdev
34 *
35 * FIXME: remove all knowledge of the buffer layer from this file
36 */
37#include <linux/buffer_head.h>
38
39/*
40 * New inode.c implementation.
41 *
42 * This implementation has the basic premise of trying
43 * to be extremely low-overhead and SMP-safe, yet be
44 * simple enough to be "obviously correct".
45 *
46 * Famous last words.
47 */
48
49/* inode dynamic allocation 1999, Andrea Arcangeli <andrea@suse.de> */
50
51/* #define INODE_PARANOIA 1 */
52/* #define INODE_DEBUG 1 */
53
54/*
55 * Inode lookup is no longer as critical as it used to be:
56 * most of the lookups are going to be through the dcache.
57 */
58#define I_HASHBITS i_hash_shift
59#define I_HASHMASK i_hash_mask
60
Eric Dumazetfa3536c2006-03-26 01:37:24 -080061static unsigned int i_hash_mask __read_mostly;
62static unsigned int i_hash_shift __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64/*
65 * Each inode can be on two separate lists. One is
66 * the hash list of the inode, used for lookups. The
67 * other linked list is the "type" list:
68 * "in_use" - valid inode, i_count > 0, i_nlink > 0
69 * "dirty" - as "in_use" but also dirty
70 * "unused" - valid inode, i_count = 0
71 *
72 * A "dirty" list is maintained for each super block,
73 * allowing for low-overhead inode sync() operations.
74 */
75
76LIST_HEAD(inode_in_use);
77LIST_HEAD(inode_unused);
Eric Dumazetfa3536c2006-03-26 01:37:24 -080078static struct hlist_head *inode_hashtable __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80/*
81 * A simple spinlock to protect the list manipulations.
82 *
83 * NOTE! You also have to own the lock if you change
84 * the i_state of an inode while it is in use..
85 */
86DEFINE_SPINLOCK(inode_lock);
87
88/*
Nick Piggin88e0fbc2009-09-22 16:43:50 -070089 * iprune_sem provides exclusion between the kswapd or try_to_free_pages
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 * icache shrinking path, and the umount path. Without this exclusion,
91 * by the time prune_icache calls iput for the inode whose pages it has
92 * been invalidating, or by the time it calls clear_inode & destroy_inode
93 * from its final dispose_list, the struct super_block they refer to
94 * (for inode->i_sb->s_op) may already have been freed and reused.
Nick Piggin88e0fbc2009-09-22 16:43:50 -070095 *
96 * We make this an rwsem because the fastpath is icache shrinking. In
97 * some cases a filesystem may be doing a significant amount of work in
98 * its inode reclaim code, so this should improve parallelism.
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 */
Nick Piggin88e0fbc2009-09-22 16:43:50 -0700100static DECLARE_RWSEM(iprune_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
102/*
103 * Statistics gathering..
104 */
105struct inodes_stat_t inodes_stat;
106
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530107static struct kmem_cache *inode_cachep __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Joern Engel1c0eeaf2007-10-16 23:30:44 -0700109static void wake_up_inode(struct inode *inode)
110{
111 /*
112 * Prevent speculative execution through spin_unlock(&inode_lock);
113 */
114 smp_mb();
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100115 wake_up_bit(&inode->i_state, __I_NEW);
Joern Engel1c0eeaf2007-10-16 23:30:44 -0700116}
117
David Chinner2cb15992008-10-30 17:32:23 +1100118/**
119 * inode_init_always - perform inode structure intialisation
Randy Dunlap0bc02f32009-01-06 14:41:13 -0800120 * @sb: superblock inode belongs to
121 * @inode: inode to initialise
David Chinner2cb15992008-10-30 17:32:23 +1100122 *
123 * These are initializations that need to be done on every inode
124 * allocation as the fields are not initialised by slab allocation.
125 */
Christoph Hellwig54e34622009-08-07 14:38:25 -0300126int inode_init_always(struct super_block *sb, struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127{
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700128 static const struct address_space_operations empty_aops;
Alexey Dobriyan6e1d5dc2009-09-21 17:01:11 -0700129 static const struct inode_operations empty_iops;
Arjan van de Ven99ac48f2006-03-28 01:56:41 -0800130 static const struct file_operations empty_fops;
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530131 struct address_space *const mapping = &inode->i_data;
David Chinner2cb15992008-10-30 17:32:23 +1100132
133 inode->i_sb = sb;
134 inode->i_blkbits = sb->s_blocksize_bits;
135 inode->i_flags = 0;
136 atomic_set(&inode->i_count, 1);
137 inode->i_op = &empty_iops;
138 inode->i_fop = &empty_fops;
139 inode->i_nlink = 1;
Al Viro56ff5ef2008-12-09 09:34:39 -0500140 inode->i_uid = 0;
141 inode->i_gid = 0;
David Chinner2cb15992008-10-30 17:32:23 +1100142 atomic_set(&inode->i_writecount, 0);
143 inode->i_size = 0;
144 inode->i_blocks = 0;
145 inode->i_bytes = 0;
146 inode->i_generation = 0;
147#ifdef CONFIG_QUOTA
148 memset(&inode->i_dquot, 0, sizeof(inode->i_dquot));
149#endif
150 inode->i_pipe = NULL;
151 inode->i_bdev = NULL;
152 inode->i_cdev = NULL;
153 inode->i_rdev = 0;
154 inode->dirtied_when = 0;
Mimi Zohar6146f0d2009-02-04 09:06:57 -0500155
156 if (security_inode_alloc(inode))
Christoph Hellwig54e34622009-08-07 14:38:25 -0300157 goto out;
David Chinner2cb15992008-10-30 17:32:23 +1100158 spin_lock_init(&inode->i_lock);
159 lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key);
160
161 mutex_init(&inode->i_mutex);
162 lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key);
163
164 init_rwsem(&inode->i_alloc_sem);
165 lockdep_set_class(&inode->i_alloc_sem, &sb->s_type->i_alloc_sem_key);
166
167 mapping->a_ops = &empty_aops;
168 mapping->host = inode;
169 mapping->flags = 0;
Hugh Dickins3c1d4372009-01-06 14:39:23 -0800170 mapping_set_gfp_mask(mapping, GFP_HIGHUSER_MOVABLE);
David Chinner2cb15992008-10-30 17:32:23 +1100171 mapping->assoc_mapping = NULL;
172 mapping->backing_dev_info = &default_backing_dev_info;
173 mapping->writeback_index = 0;
174
175 /*
176 * If the block_device provides a backing_dev_info for client
177 * inodes then use that. Otherwise the inode share the bdev's
178 * backing_dev_info.
179 */
180 if (sb->s_bdev) {
181 struct backing_dev_info *bdi;
182
Jens Axboe2c96ce92009-09-15 09:43:56 +0200183 bdi = sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
David Chinner2cb15992008-10-30 17:32:23 +1100184 mapping->backing_dev_info = bdi;
185 }
186 inode->i_private = NULL;
187 inode->i_mapping = mapping;
Al Virof19d4a82009-06-08 19:50:45 -0400188#ifdef CONFIG_FS_POSIX_ACL
189 inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
190#endif
David Chinner2cb15992008-10-30 17:32:23 +1100191
Eric Paris3be25f42009-05-21 17:01:26 -0400192#ifdef CONFIG_FSNOTIFY
193 inode->i_fsnotify_mask = 0;
194#endif
195
Christoph Hellwig54e34622009-08-07 14:38:25 -0300196 return 0;
Christoph Hellwig54e34622009-08-07 14:38:25 -0300197out:
198 return -ENOMEM;
David Chinner2cb15992008-10-30 17:32:23 +1100199}
200EXPORT_SYMBOL(inode_init_always);
201
202static struct inode *alloc_inode(struct super_block *sb)
203{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 struct inode *inode;
205
206 if (sb->s_op->alloc_inode)
207 inode = sb->s_op->alloc_inode(sb);
208 else
David Chinner2cb15992008-10-30 17:32:23 +1100209 inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
Christoph Hellwig54e34622009-08-07 14:38:25 -0300211 if (!inode)
212 return NULL;
213
214 if (unlikely(inode_init_always(sb, inode))) {
215 if (inode->i_sb->s_op->destroy_inode)
216 inode->i_sb->s_op->destroy_inode(inode);
217 else
218 kmem_cache_free(inode_cachep, inode);
219 return NULL;
220 }
221
222 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223}
224
Christoph Hellwig2e00c972009-08-07 14:38:29 -0300225void __destroy_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
Eric Sesterhennb7542f82006-04-02 13:38:18 +0200227 BUG_ON(inode_has_buffers(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 security_inode_free(inode);
Eric Paris3be25f42009-05-21 17:01:26 -0400229 fsnotify_inode_delete(inode);
Al Virof19d4a82009-06-08 19:50:45 -0400230#ifdef CONFIG_FS_POSIX_ACL
231 if (inode->i_acl && inode->i_acl != ACL_NOT_CACHED)
232 posix_acl_release(inode->i_acl);
233 if (inode->i_default_acl && inode->i_default_acl != ACL_NOT_CACHED)
234 posix_acl_release(inode->i_default_acl);
235#endif
Christoph Hellwig2e00c972009-08-07 14:38:29 -0300236}
237EXPORT_SYMBOL(__destroy_inode);
238
239void destroy_inode(struct inode *inode)
240{
241 __destroy_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 if (inode->i_sb->s_op->destroy_inode)
243 inode->i_sb->s_op->destroy_inode(inode);
244 else
245 kmem_cache_free(inode_cachep, (inode));
246}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
248/*
249 * These are initializations that only need to be done
250 * once, because the fields are idempotent across use
251 * of the inode, so let the slab aware of that.
252 */
253void inode_init_once(struct inode *inode)
254{
255 memset(inode, 0, sizeof(*inode));
256 INIT_HLIST_NODE(&inode->i_hash);
257 INIT_LIST_HEAD(&inode->i_dentry);
258 INIT_LIST_HEAD(&inode->i_devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 INIT_RADIX_TREE(&inode->i_data.page_tree, GFP_ATOMIC);
Nick Piggin19fd6232008-07-25 19:45:32 -0700260 spin_lock_init(&inode->i_data.tree_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 spin_lock_init(&inode->i_data.i_mmap_lock);
262 INIT_LIST_HEAD(&inode->i_data.private_list);
263 spin_lock_init(&inode->i_data.private_lock);
264 INIT_RAW_PRIO_TREE_ROOT(&inode->i_data.i_mmap);
265 INIT_LIST_HEAD(&inode->i_data.i_mmap_nonlinear);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 i_size_ordered_init(inode);
Robert Love0eeca282005-07-12 17:06:03 -0400267#ifdef CONFIG_INOTIFY
268 INIT_LIST_HEAD(&inode->inotify_watches);
Ingo Molnard4f9af92006-03-23 03:00:30 -0800269 mutex_init(&inode->inotify_mutex);
Robert Love0eeca282005-07-12 17:06:03 -0400270#endif
Eric Paris3be25f42009-05-21 17:01:26 -0400271#ifdef CONFIG_FSNOTIFY
272 INIT_HLIST_HEAD(&inode->i_fsnotify_mark_entries);
273#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275EXPORT_SYMBOL(inode_init_once);
276
Alexey Dobriyan51cc5062008-07-25 19:45:34 -0700277static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278{
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530279 struct inode *inode = (struct inode *) foo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Christoph Lametera35afb82007-05-16 22:10:57 -0700281 inode_init_once(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282}
283
284/*
285 * inode_lock must be held
286 */
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530287void __iget(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
Richard Kennedy2e147f12010-05-14 10:49:22 +0100289 if (atomic_inc_return(&inode->i_count) != 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 return;
Richard Kennedy2e147f12010-05-14 10:49:22 +0100291
Joern Engel1c0eeaf2007-10-16 23:30:44 -0700292 if (!(inode->i_state & (I_DIRTY|I_SYNC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 list_move(&inode->i_list, &inode_in_use);
294 inodes_stat.nr_unused--;
295}
296
297/**
298 * clear_inode - clear an inode
299 * @inode: inode to clear
300 *
301 * This is called by the filesystem to tell us
302 * that the inode is no longer useful. We just
303 * terminate it with extreme prejudice.
304 */
305void clear_inode(struct inode *inode)
306{
307 might_sleep();
308 invalidate_inode_buffers(inode);
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530309
Eric Sesterhennb7542f82006-04-02 13:38:18 +0200310 BUG_ON(inode->i_data.nrpages);
311 BUG_ON(!(inode->i_state & I_FREEING));
312 BUG_ON(inode->i_state & I_CLEAR);
Joern Engel1c0eeaf2007-10-16 23:30:44 -0700313 inode_sync_wait(inode);
Christoph Hellwigacb0c852007-05-08 00:25:52 -0700314 if (inode->i_sb->s_op->clear_inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 inode->i_sb->s_op->clear_inode(inode);
Theodore Ts'oeaf796e2006-09-27 01:50:48 -0700316 if (S_ISBLK(inode->i_mode) && inode->i_bdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 bd_forget(inode);
Theodore Ts'o577c4eb2006-09-27 01:50:49 -0700318 if (S_ISCHR(inode->i_mode) && inode->i_cdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 cd_forget(inode);
320 inode->i_state = I_CLEAR;
321}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322EXPORT_SYMBOL(clear_inode);
323
324/*
325 * dispose_list - dispose of the contents of a local list
326 * @head: the head of the list to free
327 *
328 * Dispose-list gets a local list with local inodes in it, so it doesn't
329 * need to worry about list corruption and SMP locks.
330 */
331static void dispose_list(struct list_head *head)
332{
333 int nr_disposed = 0;
334
335 while (!list_empty(head)) {
336 struct inode *inode;
337
Pavel Emelianovb5e61812007-05-08 00:30:19 -0700338 inode = list_first_entry(head, struct inode, i_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 list_del(&inode->i_list);
340
341 if (inode->i_data.nrpages)
342 truncate_inode_pages(&inode->i_data, 0);
343 clear_inode(inode);
Artem B. Bityuckiy4120db42005-07-12 13:58:12 -0700344
345 spin_lock(&inode_lock);
346 hlist_del_init(&inode->i_hash);
347 list_del_init(&inode->i_sb_list);
348 spin_unlock(&inode_lock);
349
350 wake_up_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 destroy_inode(inode);
352 nr_disposed++;
353 }
354 spin_lock(&inode_lock);
355 inodes_stat.nr_inodes -= nr_disposed;
356 spin_unlock(&inode_lock);
357}
358
359/*
360 * Invalidate all inodes for a device.
361 */
362static int invalidate_list(struct list_head *head, struct list_head *dispose)
363{
364 struct list_head *next;
365 int busy = 0, count = 0;
366
367 next = head->next;
368 for (;;) {
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530369 struct list_head *tmp = next;
370 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
372 /*
373 * We can reschedule here without worrying about the list's
374 * consistency because the per-sb list of inodes must not
Nick Piggin88e0fbc2009-09-22 16:43:50 -0700375 * change during umount anymore, and because iprune_sem keeps
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 * shrink_icache_memory() away.
377 */
378 cond_resched_lock(&inode_lock);
379
380 next = next->next;
381 if (tmp == head)
382 break;
383 inode = list_entry(tmp, struct inode, i_sb_list);
Nick Pigginaabb8fd2009-03-11 13:17:36 -0700384 if (inode->i_state & I_NEW)
385 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 invalidate_inode_buffers(inode);
387 if (!atomic_read(&inode->i_count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 list_move(&inode->i_list, dispose);
Nick Piggin7ef0d732009-03-12 14:31:38 -0700389 WARN_ON(inode->i_state & I_NEW);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 inode->i_state |= I_FREEING;
391 count++;
392 continue;
393 }
394 busy = 1;
395 }
396 /* only unused inodes may be cached with i_count zero */
397 inodes_stat.nr_unused -= count;
398 return busy;
399}
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401/**
402 * invalidate_inodes - discard the inodes on a device
403 * @sb: superblock
404 *
405 * Discard all of the inodes for a given superblock. If the discard
406 * fails because there are busy inodes then a non zero value is returned.
407 * If the discard is successful all the inodes have been discarded.
408 */
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530409int invalidate_inodes(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410{
411 int busy;
412 LIST_HEAD(throw_away);
413
Nick Piggin88e0fbc2009-09-22 16:43:50 -0700414 down_write(&iprune_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 spin_lock(&inode_lock);
Robert Love0eeca282005-07-12 17:06:03 -0400416 inotify_unmount_inodes(&sb->s_inodes);
Eric Paris164bc612009-05-21 17:01:58 -0400417 fsnotify_unmount_inodes(&sb->s_inodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 busy = invalidate_list(&sb->s_inodes, &throw_away);
419 spin_unlock(&inode_lock);
420
421 dispose_list(&throw_away);
Nick Piggin88e0fbc2009-09-22 16:43:50 -0700422 up_write(&iprune_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 return busy;
425}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426EXPORT_SYMBOL(invalidate_inodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428static int can_unuse(struct inode *inode)
429{
430 if (inode->i_state)
431 return 0;
432 if (inode_has_buffers(inode))
433 return 0;
434 if (atomic_read(&inode->i_count))
435 return 0;
436 if (inode->i_data.nrpages)
437 return 0;
438 return 1;
439}
440
441/*
442 * Scan `goal' inodes on the unused list for freeable ones. They are moved to
443 * a temporary list and then are freed outside inode_lock by dispose_list().
444 *
445 * Any inodes which are pinned purely because of attached pagecache have their
446 * pagecache removed. We expect the final iput() on that inode to add it to
447 * the front of the inode_unused list. So look for it there and if the
448 * inode is still freeable, proceed. The right inode is found 99.9% of the
449 * time in testing on a 4-way.
450 *
451 * If the inode has metadata buffers attached to mapping->private_list then
452 * try to remove them.
453 */
454static void prune_icache(int nr_to_scan)
455{
456 LIST_HEAD(freeable);
457 int nr_pruned = 0;
458 int nr_scanned;
459 unsigned long reap = 0;
460
Nick Piggin88e0fbc2009-09-22 16:43:50 -0700461 down_read(&iprune_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 spin_lock(&inode_lock);
463 for (nr_scanned = 0; nr_scanned < nr_to_scan; nr_scanned++) {
464 struct inode *inode;
465
466 if (list_empty(&inode_unused))
467 break;
468
469 inode = list_entry(inode_unused.prev, struct inode, i_list);
470
471 if (inode->i_state || atomic_read(&inode->i_count)) {
472 list_move(&inode->i_list, &inode_unused);
473 continue;
474 }
475 if (inode_has_buffers(inode) || inode->i_data.nrpages) {
476 __iget(inode);
477 spin_unlock(&inode_lock);
478 if (remove_inode_buffers(inode))
Andrew Mortonfc0ecff2007-02-10 01:45:39 -0800479 reap += invalidate_mapping_pages(&inode->i_data,
480 0, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 iput(inode);
482 spin_lock(&inode_lock);
483
484 if (inode != list_entry(inode_unused.next,
485 struct inode, i_list))
486 continue; /* wrong inode or list_empty */
487 if (!can_unuse(inode))
488 continue;
489 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 list_move(&inode->i_list, &freeable);
Nick Piggin7ef0d732009-03-12 14:31:38 -0700491 WARN_ON(inode->i_state & I_NEW);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 inode->i_state |= I_FREEING;
493 nr_pruned++;
494 }
495 inodes_stat.nr_unused -= nr_pruned;
Christoph Lameterf8891e52006-06-30 01:55:45 -0700496 if (current_is_kswapd())
497 __count_vm_events(KSWAPD_INODESTEAL, reap);
498 else
499 __count_vm_events(PGINODESTEAL, reap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 spin_unlock(&inode_lock);
501
502 dispose_list(&freeable);
Nick Piggin88e0fbc2009-09-22 16:43:50 -0700503 up_read(&iprune_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504}
505
506/*
507 * shrink_icache_memory() will attempt to reclaim some unused inodes. Here,
508 * "unused" means that no dentries are referring to the inodes: the files are
509 * not open and the dcache references to those inodes have already been
510 * reclaimed.
511 *
512 * This function is passed the number of inodes to scan, and it returns the
513 * total number of remaining possibly-reclaimable inodes.
514 */
Al Viro27496a82005-10-21 03:20:48 -0400515static int shrink_icache_memory(int nr, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
517 if (nr) {
518 /*
519 * Nasty deadlock avoidance. We may hold various FS locks,
520 * and we don't want to recurse into the FS that called us
521 * in clear_inode() and friends..
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530522 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (!(gfp_mask & __GFP_FS))
524 return -1;
525 prune_icache(nr);
526 }
527 return (inodes_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
528}
529
Rusty Russell8e1f9362007-07-17 04:03:17 -0700530static struct shrinker icache_shrinker = {
531 .shrink = shrink_icache_memory,
532 .seeks = DEFAULT_SEEKS,
533};
534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535static void __wait_on_freeing_inode(struct inode *inode);
536/*
537 * Called with the inode lock held.
538 * NOTE: we are not increasing the inode-refcount, you must call __iget()
539 * by hand after calling find_inode now! This simplifies iunique and won't
540 * add any additional branch in the common code.
541 */
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530542static struct inode *find_inode(struct super_block *sb,
543 struct hlist_head *head,
544 int (*test)(struct inode *, void *),
545 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546{
547 struct hlist_node *node;
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530548 struct inode *inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550repeat:
Matthias Kaehlckec5c8be32008-04-29 00:59:40 -0700551 hlist_for_each_entry(inode, node, head, i_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 if (inode->i_sb != sb)
553 continue;
554 if (!test(inode, data))
555 continue;
Alexander Viro991114c2005-06-23 00:09:01 -0700556 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 __wait_on_freeing_inode(inode);
558 goto repeat;
559 }
560 break;
561 }
562 return node ? inode : NULL;
563}
564
565/*
566 * find_inode_fast is the fast path version of find_inode, see the comment at
567 * iget_locked for details.
568 */
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530569static struct inode *find_inode_fast(struct super_block *sb,
570 struct hlist_head *head, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571{
572 struct hlist_node *node;
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530573 struct inode *inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575repeat:
Matthias Kaehlckec5c8be32008-04-29 00:59:40 -0700576 hlist_for_each_entry(inode, node, head, i_hash) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 if (inode->i_ino != ino)
578 continue;
579 if (inode->i_sb != sb)
580 continue;
Alexander Viro991114c2005-06-23 00:09:01 -0700581 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 __wait_on_freeing_inode(inode);
583 goto repeat;
584 }
585 break;
586 }
587 return node ? inode : NULL;
588}
589
David Chinner8290c352008-10-30 17:35:24 +1100590static unsigned long hash(struct super_block *sb, unsigned long hashval)
591{
592 unsigned long tmp;
593
594 tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) /
595 L1_CACHE_BYTES;
596 tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> I_HASHBITS);
597 return tmp & I_HASHMASK;
598}
599
600static inline void
601__inode_add_to_lists(struct super_block *sb, struct hlist_head *head,
602 struct inode *inode)
603{
604 inodes_stat.nr_inodes++;
605 list_add(&inode->i_list, &inode_in_use);
606 list_add(&inode->i_sb_list, &sb->s_inodes);
607 if (head)
608 hlist_add_head(&inode->i_hash, head);
609}
610
611/**
612 * inode_add_to_lists - add a new inode to relevant lists
Randy Dunlap0bc02f32009-01-06 14:41:13 -0800613 * @sb: superblock inode belongs to
614 * @inode: inode to mark in use
David Chinner8290c352008-10-30 17:35:24 +1100615 *
616 * When an inode is allocated it needs to be accounted for, added to the in use
617 * list, the owning superblock and the inode hash. This needs to be done under
618 * the inode_lock, so export a function to do this rather than the inode lock
619 * itself. We calculate the hash list to add to here so it is all internal
620 * which requires the caller to have already set up the inode number in the
621 * inode to add.
622 */
623void inode_add_to_lists(struct super_block *sb, struct inode *inode)
624{
625 struct hlist_head *head = inode_hashtable + hash(sb, inode->i_ino);
626
627 spin_lock(&inode_lock);
628 __inode_add_to_lists(sb, head, inode);
629 spin_unlock(&inode_lock);
630}
631EXPORT_SYMBOL_GPL(inode_add_to_lists);
632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633/**
634 * new_inode - obtain an inode
635 * @sb: superblock
636 *
Mel Gorman769848c2007-07-17 04:03:05 -0700637 * Allocates a new inode for given superblock. The default gfp_mask
Hugh Dickins3c1d4372009-01-06 14:39:23 -0800638 * for allocations related to inode->i_mapping is GFP_HIGHUSER_MOVABLE.
Mel Gorman769848c2007-07-17 04:03:05 -0700639 * If HIGHMEM pages are unsuitable or it is known that pages allocated
640 * for the page cache are not reclaimable or migratable,
641 * mapping_set_gfp_mask() must be called with suitable flags on the
642 * newly created inode's mapping
643 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 */
645struct inode *new_inode(struct super_block *sb)
646{
Jeff Layton866b04f2007-05-08 00:32:29 -0700647 /*
648 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
649 * error if st_ino won't fit in target struct field. Use 32bit counter
650 * here to attempt to avoid that.
651 */
652 static unsigned int last_ino;
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530653 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655 spin_lock_prefetch(&inode_lock);
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 inode = alloc_inode(sb);
658 if (inode) {
659 spin_lock(&inode_lock);
David Chinner8290c352008-10-30 17:35:24 +1100660 __inode_add_to_lists(sb, NULL, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 inode->i_ino = ++last_ino;
662 inode->i_state = 0;
663 spin_unlock(&inode_lock);
664 }
665 return inode;
666}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667EXPORT_SYMBOL(new_inode);
668
669void unlock_new_inode(struct inode *inode)
670{
Peter Zijlstra14358e62007-10-14 01:38:33 +0200671#ifdef CONFIG_DEBUG_LOCK_ALLOC
Peter Zijlstra1e89a5e2007-10-16 06:47:54 +0200672 if (inode->i_mode & S_IFDIR) {
673 struct file_system_type *type = inode->i_sb->s_type;
674
Jan Kara9a7aa122009-06-04 15:26:49 +0200675 /* Set new key only if filesystem hasn't already changed it */
676 if (!lockdep_match_class(&inode->i_mutex,
677 &type->i_mutex_key)) {
678 /*
679 * ensure nobody is actually holding i_mutex
680 */
681 mutex_destroy(&inode->i_mutex);
682 mutex_init(&inode->i_mutex);
683 lockdep_set_class(&inode->i_mutex,
684 &type->i_mutex_dir_key);
685 }
Peter Zijlstra1e89a5e2007-10-16 06:47:54 +0200686 }
Peter Zijlstra14358e62007-10-14 01:38:33 +0200687#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 /*
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100689 * This is special! We do not need the spinlock when clearing I_NEW,
Jan Kara580be082009-09-21 17:01:06 -0700690 * because we're guaranteed that nobody else tries to do anything about
691 * the state of the inode when it is locked, as we just created it (so
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100692 * there can be no old holders that haven't tested I_NEW).
Jan Kara580be082009-09-21 17:01:06 -0700693 * However we must emit the memory barrier so that other CPUs reliably
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100694 * see the clearing of I_NEW after the other inode initialisation has
Jan Kara580be082009-09-21 17:01:06 -0700695 * completed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 */
Jan Kara580be082009-09-21 17:01:06 -0700697 smp_mb();
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100698 WARN_ON(!(inode->i_state & I_NEW));
699 inode->i_state &= ~I_NEW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 wake_up_inode(inode);
701}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702EXPORT_SYMBOL(unlock_new_inode);
703
704/*
705 * This is called without the inode lock held.. Be careful.
706 *
707 * We no longer cache the sb_flags in i_flags - see fs.h
708 * -- rmk@arm.uk.linux.org
709 */
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530710static struct inode *get_new_inode(struct super_block *sb,
711 struct hlist_head *head,
712 int (*test)(struct inode *, void *),
713 int (*set)(struct inode *, void *),
714 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715{
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530716 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
718 inode = alloc_inode(sb);
719 if (inode) {
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530720 struct inode *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
722 spin_lock(&inode_lock);
723 /* We released the lock, so.. */
724 old = find_inode(sb, head, test, data);
725 if (!old) {
726 if (set(inode, data))
727 goto set_failed;
728
David Chinner8290c352008-10-30 17:35:24 +1100729 __inode_add_to_lists(sb, head, inode);
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100730 inode->i_state = I_NEW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 spin_unlock(&inode_lock);
732
733 /* Return the locked inode with I_NEW set, the
734 * caller is responsible for filling in the contents
735 */
736 return inode;
737 }
738
739 /*
740 * Uhhuh, somebody else created the same inode under
741 * us. Use the old inode instead of the one we just
742 * allocated.
743 */
744 __iget(old);
745 spin_unlock(&inode_lock);
746 destroy_inode(inode);
747 inode = old;
748 wait_on_inode(inode);
749 }
750 return inode;
751
752set_failed:
753 spin_unlock(&inode_lock);
754 destroy_inode(inode);
755 return NULL;
756}
757
758/*
759 * get_new_inode_fast is the fast path version of get_new_inode, see the
760 * comment at iget_locked for details.
761 */
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530762static struct inode *get_new_inode_fast(struct super_block *sb,
763 struct hlist_head *head, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764{
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530765 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767 inode = alloc_inode(sb);
768 if (inode) {
Manish Katiyar6b3304b2009-03-31 19:35:54 +0530769 struct inode *old;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
771 spin_lock(&inode_lock);
772 /* We released the lock, so.. */
773 old = find_inode_fast(sb, head, ino);
774 if (!old) {
775 inode->i_ino = ino;
David Chinner8290c352008-10-30 17:35:24 +1100776 __inode_add_to_lists(sb, head, inode);
Christoph Hellwigeaff8072009-12-17 14:25:01 +0100777 inode->i_state = I_NEW;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 spin_unlock(&inode_lock);
779
780 /* Return the locked inode with I_NEW set, the
781 * caller is responsible for filling in the contents
782 */
783 return inode;
784 }
785
786 /*
787 * Uhhuh, somebody else created the same inode under
788 * us. Use the old inode instead of the one we just
789 * allocated.
790 */
791 __iget(old);
792 spin_unlock(&inode_lock);
793 destroy_inode(inode);
794 inode = old;
795 wait_on_inode(inode);
796 }
797 return inode;
798}
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800/**
801 * iunique - get a unique inode number
802 * @sb: superblock
803 * @max_reserved: highest reserved inode number
804 *
805 * Obtain an inode number that is unique on the system for a given
806 * superblock. This is used by file systems that have no natural
807 * permanent inode numbering system. An inode number is returned that
808 * is higher than the reserved limit but unique.
809 *
810 * BUGS:
811 * With a large number of inodes live on the file system this function
812 * currently becomes quite slow.
813 */
814ino_t iunique(struct super_block *sb, ino_t max_reserved)
815{
Jeff Layton866b04f2007-05-08 00:32:29 -0700816 /*
817 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
818 * error if st_ino won't fit in target struct field. Use 32bit counter
819 * here to attempt to avoid that.
820 */
821 static unsigned int counter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 struct inode *inode;
Jeffrey Layton3361c7b2007-05-08 00:29:48 -0700823 struct hlist_head *head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 ino_t res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Jeffrey Layton3361c7b2007-05-08 00:29:48 -0700826 spin_lock(&inode_lock);
827 do {
828 if (counter <= max_reserved)
829 counter = max_reserved + 1;
830 res = counter++;
831 head = inode_hashtable + hash(sb, res);
832 inode = find_inode_fast(sb, head, res);
833 } while (inode != NULL);
834 spin_unlock(&inode_lock);
835
836 return res;
837}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838EXPORT_SYMBOL(iunique);
839
840struct inode *igrab(struct inode *inode)
841{
842 spin_lock(&inode_lock);
Jan Blunck4a3b0a42007-02-10 01:44:59 -0800843 if (!(inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 __iget(inode);
845 else
846 /*
847 * Handle the case where s_op->clear_inode is not been
848 * called yet, and somebody is calling igrab
849 * while the inode is getting freed.
850 */
851 inode = NULL;
852 spin_unlock(&inode_lock);
853 return inode;
854}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855EXPORT_SYMBOL(igrab);
856
857/**
858 * ifind - internal function, you want ilookup5() or iget5().
859 * @sb: super block of file system to search
860 * @head: the head of the list to search
861 * @test: callback used for comparisons between inodes
862 * @data: opaque data pointer to pass to @test
Anton Altaparmakov88bd5122005-07-13 01:10:44 -0700863 * @wait: if true wait for the inode to be unlocked, if false do not
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 *
865 * ifind() searches for the inode specified by @data in the inode
866 * cache. This is a generalized version of ifind_fast() for file systems where
867 * the inode number is not sufficient for unique identification of an inode.
868 *
869 * If the inode is in the cache, the inode is returned with an incremented
870 * reference count.
871 *
872 * Otherwise NULL is returned.
873 *
874 * Note, @test is called with the inode_lock held, so can't sleep.
875 */
Matt Mackall5d2bea42006-01-08 01:05:21 -0800876static struct inode *ifind(struct super_block *sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 struct hlist_head *head, int (*test)(struct inode *, void *),
Anton Altaparmakov88bd5122005-07-13 01:10:44 -0700878 void *data, const int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879{
880 struct inode *inode;
881
882 spin_lock(&inode_lock);
883 inode = find_inode(sb, head, test, data);
884 if (inode) {
885 __iget(inode);
886 spin_unlock(&inode_lock);
Anton Altaparmakov88bd5122005-07-13 01:10:44 -0700887 if (likely(wait))
888 wait_on_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 return inode;
890 }
891 spin_unlock(&inode_lock);
892 return NULL;
893}
894
895/**
896 * ifind_fast - internal function, you want ilookup() or iget().
897 * @sb: super block of file system to search
898 * @head: head of the list to search
899 * @ino: inode number to search for
900 *
901 * ifind_fast() searches for the inode @ino in the inode cache. This is for
902 * file systems where the inode number is sufficient for unique identification
903 * of an inode.
904 *
905 * If the inode is in the cache, the inode is returned with an incremented
906 * reference count.
907 *
908 * Otherwise NULL is returned.
909 */
Matt Mackall5d2bea42006-01-08 01:05:21 -0800910static struct inode *ifind_fast(struct super_block *sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 struct hlist_head *head, unsigned long ino)
912{
913 struct inode *inode;
914
915 spin_lock(&inode_lock);
916 inode = find_inode_fast(sb, head, ino);
917 if (inode) {
918 __iget(inode);
919 spin_unlock(&inode_lock);
920 wait_on_inode(inode);
921 return inode;
922 }
923 spin_unlock(&inode_lock);
924 return NULL;
925}
926
927/**
Anton Altaparmakov88bd5122005-07-13 01:10:44 -0700928 * ilookup5_nowait - search for an inode in the inode cache
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 * @sb: super block of file system to search
930 * @hashval: hash value (usually inode number) to search for
931 * @test: callback used for comparisons between inodes
932 * @data: opaque data pointer to pass to @test
933 *
934 * ilookup5() uses ifind() to search for the inode specified by @hashval and
935 * @data in the inode cache. This is a generalized version of ilookup() for
936 * file systems where the inode number is not sufficient for unique
937 * identification of an inode.
938 *
939 * If the inode is in the cache, the inode is returned with an incremented
Anton Altaparmakov88bd5122005-07-13 01:10:44 -0700940 * reference count. Note, the inode lock is not waited upon so you have to be
941 * very careful what you do with the returned inode. You probably should be
942 * using ilookup5() instead.
943 *
944 * Otherwise NULL is returned.
945 *
946 * Note, @test is called with the inode_lock held, so can't sleep.
947 */
948struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval,
949 int (*test)(struct inode *, void *), void *data)
950{
951 struct hlist_head *head = inode_hashtable + hash(sb, hashval);
952
953 return ifind(sb, head, test, data, 0);
954}
Anton Altaparmakov88bd5122005-07-13 01:10:44 -0700955EXPORT_SYMBOL(ilookup5_nowait);
956
957/**
958 * ilookup5 - search for an inode in the inode cache
959 * @sb: super block of file system to search
960 * @hashval: hash value (usually inode number) to search for
961 * @test: callback used for comparisons between inodes
962 * @data: opaque data pointer to pass to @test
963 *
964 * ilookup5() uses ifind() to search for the inode specified by @hashval and
965 * @data in the inode cache. This is a generalized version of ilookup() for
966 * file systems where the inode number is not sufficient for unique
967 * identification of an inode.
968 *
969 * If the inode is in the cache, the inode lock is waited upon and the inode is
970 * returned with an incremented reference count.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 *
972 * Otherwise NULL is returned.
973 *
974 * Note, @test is called with the inode_lock held, so can't sleep.
975 */
976struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
977 int (*test)(struct inode *, void *), void *data)
978{
979 struct hlist_head *head = inode_hashtable + hash(sb, hashval);
980
Anton Altaparmakov88bd5122005-07-13 01:10:44 -0700981 return ifind(sb, head, test, data, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983EXPORT_SYMBOL(ilookup5);
984
985/**
986 * ilookup - search for an inode in the inode cache
987 * @sb: super block of file system to search
988 * @ino: inode number to search for
989 *
990 * ilookup() uses ifind_fast() to search for the inode @ino in the inode cache.
991 * This is for file systems where the inode number is sufficient for unique
992 * identification of an inode.
993 *
994 * If the inode is in the cache, the inode is returned with an incremented
995 * reference count.
996 *
997 * Otherwise NULL is returned.
998 */
999struct inode *ilookup(struct super_block *sb, unsigned long ino)
1000{
1001 struct hlist_head *head = inode_hashtable + hash(sb, ino);
1002
1003 return ifind_fast(sb, head, ino);
1004}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005EXPORT_SYMBOL(ilookup);
1006
1007/**
1008 * iget5_locked - obtain an inode from a mounted file system
1009 * @sb: super block of file system
1010 * @hashval: hash value (usually inode number) to get
1011 * @test: callback used for comparisons between inodes
1012 * @set: callback used to initialize a new struct inode
1013 * @data: opaque data pointer to pass to @test and @set
1014 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 * iget5_locked() uses ifind() to search for the inode specified by @hashval
1016 * and @data in the inode cache and if present it is returned with an increased
1017 * reference count. This is a generalized version of iget_locked() for file
1018 * systems where the inode number is not sufficient for unique identification
1019 * of an inode.
1020 *
1021 * If the inode is not in cache, get_new_inode() is called to allocate a new
1022 * inode and this is returned locked, hashed, and with the I_NEW flag set. The
1023 * file system gets to fill it in before unlocking it via unlock_new_inode().
1024 *
1025 * Note both @test and @set are called with the inode_lock held, so can't sleep.
1026 */
1027struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
1028 int (*test)(struct inode *, void *),
1029 int (*set)(struct inode *, void *), void *data)
1030{
1031 struct hlist_head *head = inode_hashtable + hash(sb, hashval);
1032 struct inode *inode;
1033
Anton Altaparmakov88bd5122005-07-13 01:10:44 -07001034 inode = ifind(sb, head, test, data, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 if (inode)
1036 return inode;
1037 /*
1038 * get_new_inode() will do the right thing, re-trying the search
1039 * in case it had to block at any point.
1040 */
1041 return get_new_inode(sb, head, test, set, data);
1042}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043EXPORT_SYMBOL(iget5_locked);
1044
1045/**
1046 * iget_locked - obtain an inode from a mounted file system
1047 * @sb: super block of file system
1048 * @ino: inode number to get
1049 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 * iget_locked() uses ifind_fast() to search for the inode specified by @ino in
1051 * the inode cache and if present it is returned with an increased reference
1052 * count. This is for file systems where the inode number is sufficient for
1053 * unique identification of an inode.
1054 *
1055 * If the inode is not in cache, get_new_inode_fast() is called to allocate a
1056 * new inode and this is returned locked, hashed, and with the I_NEW flag set.
1057 * The file system gets to fill it in before unlocking it via
1058 * unlock_new_inode().
1059 */
1060struct inode *iget_locked(struct super_block *sb, unsigned long ino)
1061{
1062 struct hlist_head *head = inode_hashtable + hash(sb, ino);
1063 struct inode *inode;
1064
1065 inode = ifind_fast(sb, head, ino);
1066 if (inode)
1067 return inode;
1068 /*
1069 * get_new_inode_fast() will do the right thing, re-trying the search
1070 * in case it had to block at any point.
1071 */
1072 return get_new_inode_fast(sb, head, ino);
1073}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074EXPORT_SYMBOL(iget_locked);
1075
Al Viro261bca82008-12-30 01:48:21 -05001076int insert_inode_locked(struct inode *inode)
1077{
1078 struct super_block *sb = inode->i_sb;
1079 ino_t ino = inode->i_ino;
1080 struct hlist_head *head = inode_hashtable + hash(sb, ino);
Al Viro261bca82008-12-30 01:48:21 -05001081
Christoph Hellwigeaff8072009-12-17 14:25:01 +01001082 inode->i_state |= I_NEW;
Al Viro261bca82008-12-30 01:48:21 -05001083 while (1) {
Al Viro72a43d62009-05-13 19:13:40 +01001084 struct hlist_node *node;
1085 struct inode *old = NULL;
Al Viro261bca82008-12-30 01:48:21 -05001086 spin_lock(&inode_lock);
Al Viro72a43d62009-05-13 19:13:40 +01001087 hlist_for_each_entry(old, node, head, i_hash) {
1088 if (old->i_ino != ino)
1089 continue;
1090 if (old->i_sb != sb)
1091 continue;
1092 if (old->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE))
1093 continue;
1094 break;
1095 }
1096 if (likely(!node)) {
Al Viro261bca82008-12-30 01:48:21 -05001097 hlist_add_head(&inode->i_hash, head);
1098 spin_unlock(&inode_lock);
1099 return 0;
1100 }
1101 __iget(old);
1102 spin_unlock(&inode_lock);
1103 wait_on_inode(old);
1104 if (unlikely(!hlist_unhashed(&old->i_hash))) {
1105 iput(old);
1106 return -EBUSY;
1107 }
1108 iput(old);
1109 }
1110}
Al Viro261bca82008-12-30 01:48:21 -05001111EXPORT_SYMBOL(insert_inode_locked);
1112
1113int insert_inode_locked4(struct inode *inode, unsigned long hashval,
1114 int (*test)(struct inode *, void *), void *data)
1115{
1116 struct super_block *sb = inode->i_sb;
1117 struct hlist_head *head = inode_hashtable + hash(sb, hashval);
Al Viro261bca82008-12-30 01:48:21 -05001118
Christoph Hellwigeaff8072009-12-17 14:25:01 +01001119 inode->i_state |= I_NEW;
Al Viro261bca82008-12-30 01:48:21 -05001120
1121 while (1) {
Al Viro72a43d62009-05-13 19:13:40 +01001122 struct hlist_node *node;
1123 struct inode *old = NULL;
1124
Al Viro261bca82008-12-30 01:48:21 -05001125 spin_lock(&inode_lock);
Al Viro72a43d62009-05-13 19:13:40 +01001126 hlist_for_each_entry(old, node, head, i_hash) {
1127 if (old->i_sb != sb)
1128 continue;
1129 if (!test(old, data))
1130 continue;
1131 if (old->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE))
1132 continue;
1133 break;
1134 }
1135 if (likely(!node)) {
Al Viro261bca82008-12-30 01:48:21 -05001136 hlist_add_head(&inode->i_hash, head);
1137 spin_unlock(&inode_lock);
1138 return 0;
1139 }
1140 __iget(old);
1141 spin_unlock(&inode_lock);
1142 wait_on_inode(old);
1143 if (unlikely(!hlist_unhashed(&old->i_hash))) {
1144 iput(old);
1145 return -EBUSY;
1146 }
1147 iput(old);
1148 }
1149}
Al Viro261bca82008-12-30 01:48:21 -05001150EXPORT_SYMBOL(insert_inode_locked4);
1151
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152/**
1153 * __insert_inode_hash - hash an inode
1154 * @inode: unhashed inode
1155 * @hashval: unsigned long value used to locate this object in the
1156 * inode_hashtable.
1157 *
1158 * Add an inode to the inode hash for this superblock.
1159 */
1160void __insert_inode_hash(struct inode *inode, unsigned long hashval)
1161{
1162 struct hlist_head *head = inode_hashtable + hash(inode->i_sb, hashval);
1163 spin_lock(&inode_lock);
1164 hlist_add_head(&inode->i_hash, head);
1165 spin_unlock(&inode_lock);
1166}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167EXPORT_SYMBOL(__insert_inode_hash);
1168
1169/**
1170 * remove_inode_hash - remove an inode from the hash
1171 * @inode: inode to unhash
1172 *
1173 * Remove an inode from the superblock.
1174 */
1175void remove_inode_hash(struct inode *inode)
1176{
1177 spin_lock(&inode_lock);
1178 hlist_del_init(&inode->i_hash);
1179 spin_unlock(&inode_lock);
1180}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181EXPORT_SYMBOL(remove_inode_hash);
1182
1183/*
1184 * Tell the filesystem that this inode is no longer of any interest and should
1185 * be completely destroyed.
1186 *
1187 * We leave the inode in the inode hash table until *after* the filesystem's
1188 * ->delete_inode completes. This ensures that an iget (such as nfsd might
1189 * instigate) will always find up-to-date information either in the hash or on
1190 * disk.
1191 *
1192 * I_FREEING is set so that no-one will take a new reference to the inode while
1193 * it is being deleted.
1194 */
Arjan van de Venb32714b2009-01-09 07:04:15 -08001195void generic_delete_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196{
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -08001197 const struct super_operations *op = inode->i_sb->s_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
Arjan van de Venb32714b2009-01-09 07:04:15 -08001199 list_del_init(&inode->i_list);
1200 list_del_init(&inode->i_sb_list);
Nick Piggin7ef0d732009-03-12 14:31:38 -07001201 WARN_ON(inode->i_state & I_NEW);
Arjan van de Venb32714b2009-01-09 07:04:15 -08001202 inode->i_state |= I_FREEING;
1203 inodes_stat.nr_inodes--;
1204 spin_unlock(&inode_lock);
1205
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 if (op->delete_inode) {
1207 void (*delete)(struct inode *) = op->delete_inode;
Mark Fashehe85b5652005-09-09 13:01:29 -07001208 /* Filesystems implementing their own
1209 * s_op->delete_inode are required to call
1210 * truncate_inode_pages and clear_inode()
1211 * internally */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 delete(inode);
Mark Fashehe85b5652005-09-09 13:01:29 -07001213 } else {
1214 truncate_inode_pages(&inode->i_data, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 clear_inode(inode);
Mark Fashehe85b5652005-09-09 13:01:29 -07001216 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 spin_lock(&inode_lock);
1218 hlist_del_init(&inode->i_hash);
1219 spin_unlock(&inode_lock);
1220 wake_up_inode(inode);
Eric Sesterhennb7542f82006-04-02 13:38:18 +02001221 BUG_ON(inode->i_state != I_CLEAR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 destroy_inode(inode);
1223}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224EXPORT_SYMBOL(generic_delete_inode);
1225
Jan Kara22fe40422009-09-18 13:05:44 -07001226/**
1227 * generic_detach_inode - remove inode from inode lists
1228 * @inode: inode to remove
1229 *
1230 * Remove inode from inode lists, write it if it's dirty. This is just an
1231 * internal VFS helper exported for hugetlbfs. Do not use!
1232 *
1233 * Returns 1 if inode should be completely destroyed.
1234 */
1235int generic_detach_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236{
1237 struct super_block *sb = inode->i_sb;
1238
1239 if (!hlist_unhashed(&inode->i_hash)) {
Joern Engel1c0eeaf2007-10-16 23:30:44 -07001240 if (!(inode->i_state & (I_DIRTY|I_SYNC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 list_move(&inode->i_list, &inode_unused);
1242 inodes_stat.nr_unused++;
Christoph Hellwigacb0c852007-05-08 00:25:52 -07001243 if (sb->s_flags & MS_ACTIVE) {
Alexander Viro991114c2005-06-23 00:09:01 -07001244 spin_unlock(&inode_lock);
Jan Kara22fe40422009-09-18 13:05:44 -07001245 return 0;
Alexander Viro991114c2005-06-23 00:09:01 -07001246 }
Nick Piggin7ef0d732009-03-12 14:31:38 -07001247 WARN_ON(inode->i_state & I_NEW);
Alexander Viro991114c2005-06-23 00:09:01 -07001248 inode->i_state |= I_WILL_FREE;
1249 spin_unlock(&inode_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 write_inode_now(inode, 1);
1251 spin_lock(&inode_lock);
Nick Piggin7ef0d732009-03-12 14:31:38 -07001252 WARN_ON(inode->i_state & I_NEW);
Alexander Viro991114c2005-06-23 00:09:01 -07001253 inode->i_state &= ~I_WILL_FREE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 inodes_stat.nr_unused--;
1255 hlist_del_init(&inode->i_hash);
1256 }
1257 list_del_init(&inode->i_list);
1258 list_del_init(&inode->i_sb_list);
Nick Piggin7ef0d732009-03-12 14:31:38 -07001259 WARN_ON(inode->i_state & I_NEW);
Alexander Viro991114c2005-06-23 00:09:01 -07001260 inode->i_state |= I_FREEING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 inodes_stat.nr_inodes--;
1262 spin_unlock(&inode_lock);
Jan Kara22fe40422009-09-18 13:05:44 -07001263 return 1;
1264}
1265EXPORT_SYMBOL_GPL(generic_detach_inode);
1266
1267static void generic_forget_inode(struct inode *inode)
1268{
1269 if (!generic_detach_inode(inode))
1270 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 if (inode->i_data.nrpages)
1272 truncate_inode_pages(&inode->i_data, 0);
1273 clear_inode(inode);
Andrea Arcangeli7f04c262005-10-30 15:03:05 -08001274 wake_up_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 destroy_inode(inode);
1276}
1277
1278/*
1279 * Normal UNIX filesystem behaviour: delete the
1280 * inode when the usage count drops to zero, and
1281 * i_nlink is zero.
1282 */
Mark Fashehcb2c0232005-07-07 17:56:03 -07001283void generic_drop_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284{
1285 if (!inode->i_nlink)
1286 generic_delete_inode(inode);
1287 else
1288 generic_forget_inode(inode);
1289}
Mark Fashehcb2c0232005-07-07 17:56:03 -07001290EXPORT_SYMBOL_GPL(generic_drop_inode);
1291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292/*
1293 * Called when we're dropping the last reference
Manish Katiyar6b3304b2009-03-31 19:35:54 +05301294 * to an inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 *
1296 * Call the FS "drop()" function, defaulting to
1297 * the legacy UNIX filesystem behaviour..
1298 *
1299 * NOTE! NOTE! NOTE! We're called with the inode lock
1300 * held, and the drop function is supposed to release
1301 * the lock!
1302 */
1303static inline void iput_final(struct inode *inode)
1304{
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -08001305 const struct super_operations *op = inode->i_sb->s_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 void (*drop)(struct inode *) = generic_drop_inode;
1307
1308 if (op && op->drop_inode)
1309 drop = op->drop_inode;
1310 drop(inode);
1311}
1312
1313/**
Manish Katiyar6b3304b2009-03-31 19:35:54 +05301314 * iput - put an inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 * @inode: inode to put
1316 *
1317 * Puts an inode, dropping its usage count. If the inode use count hits
1318 * zero, the inode is then freed and may also be destroyed.
1319 *
1320 * Consequently, iput() can sleep.
1321 */
1322void iput(struct inode *inode)
1323{
1324 if (inode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 BUG_ON(inode->i_state == I_CLEAR);
1326
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 if (atomic_dec_and_lock(&inode->i_count, &inode_lock))
1328 iput_final(inode);
1329 }
1330}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331EXPORT_SYMBOL(iput);
1332
1333/**
1334 * bmap - find a block number in a file
1335 * @inode: inode of file
1336 * @block: block to find
1337 *
1338 * Returns the block number on the device holding the inode that
1339 * is the disk block number for the block of the file requested.
1340 * That is, asked for block 4 of inode 1 the function will return the
Manish Katiyar6b3304b2009-03-31 19:35:54 +05301341 * disk block relative to the disk start that holds that block of the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 * file.
1343 */
Manish Katiyar6b3304b2009-03-31 19:35:54 +05301344sector_t bmap(struct inode *inode, sector_t block)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345{
1346 sector_t res = 0;
1347 if (inode->i_mapping->a_ops->bmap)
1348 res = inode->i_mapping->a_ops->bmap(inode->i_mapping, block);
1349 return res;
1350}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351EXPORT_SYMBOL(bmap);
1352
Matthew Garrett11ff6f052009-03-26 17:32:14 +00001353/*
1354 * With relative atime, only update atime if the previous atime is
1355 * earlier than either the ctime or mtime or if at least a day has
1356 * passed since the last atime update.
1357 */
1358static int relatime_need_update(struct vfsmount *mnt, struct inode *inode,
1359 struct timespec now)
1360{
1361
1362 if (!(mnt->mnt_flags & MNT_RELATIME))
1363 return 1;
1364 /*
1365 * Is mtime younger than atime? If yes, update atime:
1366 */
1367 if (timespec_compare(&inode->i_mtime, &inode->i_atime) >= 0)
1368 return 1;
1369 /*
1370 * Is ctime younger than atime? If yes, update atime:
1371 */
1372 if (timespec_compare(&inode->i_ctime, &inode->i_atime) >= 0)
1373 return 1;
1374
1375 /*
1376 * Is the previous atime value older than a day? If yes,
1377 * update atime:
1378 */
1379 if ((long)(now.tv_sec - inode->i_atime.tv_sec) >= 24*60*60)
1380 return 1;
1381 /*
1382 * Good, we can skip the atime update:
1383 */
1384 return 0;
1385}
1386
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387/**
Christoph Hellwig869243a2006-01-09 20:52:03 -08001388 * touch_atime - update the access time
1389 * @mnt: mount the inode is accessed on
Martin Waitz7045f372006-02-01 03:06:57 -08001390 * @dentry: dentry accessed
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 *
1392 * Update the accessed time on an inode and mark it for writeback.
1393 * This function automatically handles read only file systems and media,
1394 * as well as the "noatime" flag and inode specific "noatime" markers.
1395 */
Christoph Hellwig869243a2006-01-09 20:52:03 -08001396void touch_atime(struct vfsmount *mnt, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397{
Christoph Hellwig869243a2006-01-09 20:52:03 -08001398 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 struct timespec now;
1400
Andrew Mortonb2276132006-12-13 00:34:33 -08001401 if (inode->i_flags & S_NOATIME)
Andi Kleenb12536c2009-09-18 13:05:47 -07001402 return;
Eric Dumazet37756ce2007-02-10 01:44:49 -08001403 if (IS_NOATIME(inode))
Andi Kleenb12536c2009-09-18 13:05:47 -07001404 return;
Andrew Mortonb2276132006-12-13 00:34:33 -08001405 if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))
Andi Kleenb12536c2009-09-18 13:05:47 -07001406 return;
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -08001407
Dave Hansencdb70f32008-02-15 14:37:41 -08001408 if (mnt->mnt_flags & MNT_NOATIME)
Andi Kleenb12536c2009-09-18 13:05:47 -07001409 return;
Dave Hansencdb70f32008-02-15 14:37:41 -08001410 if ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode))
Andi Kleenb12536c2009-09-18 13:05:47 -07001411 return;
Christoph Hellwigfc33a7b2006-01-09 20:52:17 -08001412
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 now = current_fs_time(inode->i_sb);
Matthew Garrett11ff6f052009-03-26 17:32:14 +00001414
1415 if (!relatime_need_update(mnt, inode, now))
Andi Kleenb12536c2009-09-18 13:05:47 -07001416 return;
Matthew Garrett11ff6f052009-03-26 17:32:14 +00001417
Valerie Henson47ae32d2006-12-13 00:34:34 -08001418 if (timespec_equal(&inode->i_atime, &now))
Andi Kleenb12536c2009-09-18 13:05:47 -07001419 return;
1420
1421 if (mnt_want_write(mnt))
1422 return;
Valerie Henson47ae32d2006-12-13 00:34:34 -08001423
1424 inode->i_atime = now;
1425 mark_inode_dirty_sync(inode);
Dave Hansencdb70f32008-02-15 14:37:41 -08001426 mnt_drop_write(mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427}
Christoph Hellwig869243a2006-01-09 20:52:03 -08001428EXPORT_SYMBOL(touch_atime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
1430/**
Christoph Hellwig870f4812006-01-09 20:52:01 -08001431 * file_update_time - update mtime and ctime time
1432 * @file: file accessed
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 *
Christoph Hellwig870f4812006-01-09 20:52:01 -08001434 * Update the mtime and ctime members of an inode and mark the inode
1435 * for writeback. Note that this function is meant exclusively for
1436 * usage in the file write path of filesystems, and filesystems may
1437 * choose to explicitly ignore update via this function with the
Wolfram Sang2eadfc02009-04-02 15:23:37 +02001438 * S_NOCMTIME inode flag, e.g. for network filesystem where these
Christoph Hellwig870f4812006-01-09 20:52:01 -08001439 * timestamps are handled by the server.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 */
1441
Christoph Hellwig870f4812006-01-09 20:52:01 -08001442void file_update_time(struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443{
Josef "Jeff" Sipek0f7fc9e2006-12-08 02:36:35 -08001444 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 struct timespec now;
Andi Kleence06e0b2009-09-18 13:05:48 -07001446 enum { S_MTIME = 1, S_CTIME = 2, S_VERSION = 4 } sync_it = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
Andi Kleence06e0b2009-09-18 13:05:48 -07001448 /* First try to exhaust all avenues to not sync */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001449 if (IS_NOCMTIME(inode))
1450 return;
Dave Hansen20ddee22008-02-15 14:37:43 -08001451
Andi Kleence06e0b2009-09-18 13:05:48 -07001452 now = current_fs_time(inode->i_sb);
1453 if (!timespec_equal(&inode->i_mtime, &now))
1454 sync_it = S_MTIME;
1455
1456 if (!timespec_equal(&inode->i_ctime, &now))
1457 sync_it |= S_CTIME;
1458
1459 if (IS_I_VERSION(inode))
1460 sync_it |= S_VERSION;
1461
1462 if (!sync_it)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 return;
1464
Andi Kleence06e0b2009-09-18 13:05:48 -07001465 /* Finally allowed to write? Takes lock. */
1466 if (mnt_want_write_file(file))
1467 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
Andi Kleence06e0b2009-09-18 13:05:48 -07001469 /* Only change inode inside the lock region */
1470 if (sync_it & S_VERSION)
Jean Noel Cordenner7a224222008-01-28 23:58:27 -05001471 inode_inc_iversion(inode);
Andi Kleence06e0b2009-09-18 13:05:48 -07001472 if (sync_it & S_CTIME)
1473 inode->i_ctime = now;
1474 if (sync_it & S_MTIME)
1475 inode->i_mtime = now;
1476 mark_inode_dirty_sync(inode);
Dave Hansen20ddee22008-02-15 14:37:43 -08001477 mnt_drop_write(file->f_path.mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478}
Christoph Hellwig870f4812006-01-09 20:52:01 -08001479EXPORT_SYMBOL(file_update_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
1481int inode_needs_sync(struct inode *inode)
1482{
1483 if (IS_SYNC(inode))
1484 return 1;
1485 if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
1486 return 1;
1487 return 0;
1488}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489EXPORT_SYMBOL(inode_needs_sync);
1490
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491int inode_wait(void *word)
1492{
1493 schedule();
1494 return 0;
1495}
Stephen Rothwelld44dab82008-11-10 17:06:05 +11001496EXPORT_SYMBOL(inode_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
1498/*
Miklos Szeredi168a9fd2005-07-12 13:58:10 -07001499 * If we try to find an inode in the inode hash while it is being
1500 * deleted, we have to wait until the filesystem completes its
1501 * deletion before reporting that it isn't found. This function waits
1502 * until the deletion _might_ have completed. Callers are responsible
1503 * to recheck inode state.
1504 *
Christoph Hellwigeaff8072009-12-17 14:25:01 +01001505 * It doesn't matter if I_NEW is not set initially, a call to
Miklos Szeredi168a9fd2005-07-12 13:58:10 -07001506 * wake_up_inode() after removing from the hash list will DTRT.
1507 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 * This is called with inode_lock held.
1509 */
1510static void __wait_on_freeing_inode(struct inode *inode)
1511{
1512 wait_queue_head_t *wq;
Christoph Hellwigeaff8072009-12-17 14:25:01 +01001513 DEFINE_WAIT_BIT(wait, &inode->i_state, __I_NEW);
1514 wq = bit_waitqueue(&inode->i_state, __I_NEW);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 prepare_to_wait(wq, &wait.wait, TASK_UNINTERRUPTIBLE);
1516 spin_unlock(&inode_lock);
1517 schedule();
1518 finish_wait(wq, &wait.wait);
1519 spin_lock(&inode_lock);
1520}
1521
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522static __initdata unsigned long ihash_entries;
1523static int __init set_ihash_entries(char *str)
1524{
1525 if (!str)
1526 return 0;
1527 ihash_entries = simple_strtoul(str, &str, 0);
1528 return 1;
1529}
1530__setup("ihash_entries=", set_ihash_entries);
1531
1532/*
1533 * Initialize the waitqueues and inode hash table.
1534 */
1535void __init inode_init_early(void)
1536{
1537 int loop;
1538
1539 /* If hashes are distributed across NUMA nodes, defer
1540 * hash allocation until vmalloc space is available.
1541 */
1542 if (hashdist)
1543 return;
1544
1545 inode_hashtable =
1546 alloc_large_system_hash("Inode-cache",
1547 sizeof(struct hlist_head),
1548 ihash_entries,
1549 14,
1550 HASH_EARLY,
1551 &i_hash_shift,
1552 &i_hash_mask,
1553 0);
1554
1555 for (loop = 0; loop < (1 << i_hash_shift); loop++)
1556 INIT_HLIST_HEAD(&inode_hashtable[loop]);
1557}
1558
Denis Cheng74bf17c2007-10-16 23:26:30 -07001559void __init inode_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560{
1561 int loop;
1562
1563 /* inode slab cache */
Paul Jacksonb0196002006-03-24 03:16:09 -08001564 inode_cachep = kmem_cache_create("inode_cache",
1565 sizeof(struct inode),
1566 0,
1567 (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
1568 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +09001569 init_once);
Rusty Russell8e1f9362007-07-17 04:03:17 -07001570 register_shrinker(&icache_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571
1572 /* Hash may have been set up in inode_init_early */
1573 if (!hashdist)
1574 return;
1575
1576 inode_hashtable =
1577 alloc_large_system_hash("Inode-cache",
1578 sizeof(struct hlist_head),
1579 ihash_entries,
1580 14,
1581 0,
1582 &i_hash_shift,
1583 &i_hash_mask,
1584 0);
1585
1586 for (loop = 0; loop < (1 << i_hash_shift); loop++)
1587 INIT_HLIST_HEAD(&inode_hashtable[loop]);
1588}
1589
1590void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
1591{
1592 inode->i_mode = mode;
1593 if (S_ISCHR(mode)) {
1594 inode->i_fop = &def_chr_fops;
1595 inode->i_rdev = rdev;
1596 } else if (S_ISBLK(mode)) {
1597 inode->i_fop = &def_blk_fops;
1598 inode->i_rdev = rdev;
1599 } else if (S_ISFIFO(mode))
1600 inode->i_fop = &def_fifo_fops;
1601 else if (S_ISSOCK(mode))
1602 inode->i_fop = &bad_sock_fops;
1603 else
Manish Katiyaraf0d9ae2009-09-18 13:05:43 -07001604 printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for"
1605 " inode %s:%lu\n", mode, inode->i_sb->s_id,
1606 inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607}
1608EXPORT_SYMBOL(init_special_inode);
Dmitry Monakhova1bd1202010-03-04 17:29:14 +03001609
1610/**
1611 * Init uid,gid,mode for new inode according to posix standards
1612 * @inode: New inode
1613 * @dir: Directory inode
1614 * @mode: mode of the new inode
1615 */
1616void inode_init_owner(struct inode *inode, const struct inode *dir,
1617 mode_t mode)
1618{
1619 inode->i_uid = current_fsuid();
1620 if (dir && dir->i_mode & S_ISGID) {
1621 inode->i_gid = dir->i_gid;
1622 if (S_ISDIR(mode))
1623 mode |= S_ISGID;
1624 } else
1625 inode->i_gid = current_fsgid();
1626 inode->i_mode = mode;
1627}
1628EXPORT_SYMBOL(inode_init_owner);