inode.c 43 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
 * (C) 1997 Linus Torvalds
3
 * (C) 1999 Andrea Arcangeli <andrea@suse.de> (dynamic inode allocation)
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13
 */
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/dcache.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/writeback.h>
#include <linux/module.h>
#include <linux/backing-dev.h>
#include <linux/wait.h>
14
#include <linux/rwsem.h>
Linus Torvalds's avatar
Linus Torvalds committed
15 16 17 18 19 20
#include <linux/hash.h>
#include <linux/swap.h>
#include <linux/security.h>
#include <linux/pagemap.h>
#include <linux/cdev.h>
#include <linux/bootmem.h>
21
#include <linux/fsnotify.h>
22
#include <linux/mount.h>
23
#include <linux/async.h>
24
#include <linux/posix_acl.h>
25
#include <linux/prefetch.h>
26
#include <linux/ima.h>
27
#include <linux/cred.h>
28
#include <linux/buffer_head.h> /* for inode_has_buffers */
29
#include "internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
30

31
/*
32
 * Inode locking rules:
33 34 35
 *
 * inode->i_lock protects:
 *   inode->i_state, inode->i_hash, __iget()
36 37
 * inode_lru_lock protects:
 *   inode_lru, inode->i_lru
38 39
 * inode_sb_list_lock protects:
 *   sb->s_inodes, inode->i_sb_list
40
 * bdi->wb.list_lock protects:
41
 *   bdi->wb.b_{dirty,io,more_io}, inode->i_wb_list
42 43
 * inode_hash_lock protects:
 *   inode_hashtable, inode->i_hash
44 45
 *
 * Lock ordering:
46 47 48
 *
 * inode_sb_list_lock
 *   inode->i_lock
49
 *     inode_lru_lock
50
 *
51
 * bdi->wb.list_lock
52
 *   inode->i_lock
53 54 55 56 57 58 59
 *
 * inode_hash_lock
 *   inode_sb_list_lock
 *   inode->i_lock
 *
 * iunique_lock
 *   inode_hash_lock
60 61
 */

62 63
static unsigned int i_hash_mask __read_mostly;
static unsigned int i_hash_shift __read_mostly;
64 65
static struct hlist_head *inode_hashtable __read_mostly;
static __cacheline_aligned_in_smp DEFINE_SPINLOCK(inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
66

67
static LIST_HEAD(inode_lru);
68
static DEFINE_SPINLOCK(inode_lru_lock);
Linus Torvalds's avatar
Linus Torvalds committed
69

70 71
__cacheline_aligned_in_smp DEFINE_SPINLOCK(inode_sb_list_lock);

Linus Torvalds's avatar
Linus Torvalds committed
72
/*
Christoph Hellwig's avatar
Christoph Hellwig committed
73 74
 * iprune_sem provides exclusion between the icache shrinking and the
 * umount path.
75
 *
Christoph Hellwig's avatar
Christoph Hellwig committed
76 77 78 79
 * We don't actually need it to protect anything in the umount path,
 * but only need to cycle through it to make sure any inode that
 * prune_icache took off the LRU list has been fully torn down by the
 * time we are past evict_inodes.
Linus Torvalds's avatar
Linus Torvalds committed
80
 */
81
static DECLARE_RWSEM(iprune_sem);
Linus Torvalds's avatar
Linus Torvalds committed
82

Jens Axboe's avatar
Jens Axboe committed
83 84 85 86 87 88 89 90
/*
 * Empty aops. Can be used for the cases where the user does not
 * define any of the address_space operations.
 */
const struct address_space_operations empty_aops = {
};
EXPORT_SYMBOL(empty_aops);

Linus Torvalds's avatar
Linus Torvalds committed
91 92 93 94 95
/*
 * Statistics gathering..
 */
struct inodes_stat_t inodes_stat;

96
static DEFINE_PER_CPU(unsigned int, nr_inodes);
97

98
static struct kmem_cache *inode_cachep __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
99

100
static int get_nr_inodes(void)
101
{
102 103 104 105 106
	int i;
	int sum = 0;
	for_each_possible_cpu(i)
		sum += per_cpu(nr_inodes, i);
	return sum < 0 ? 0 : sum;
107 108 109 110
}

static inline int get_nr_inodes_unused(void)
{
111
	return inodes_stat.nr_unused;
112 113 114 115
}

int get_nr_dirty_inodes(void)
{
116
	/* not actually dirty inodes, but a wild approximation */
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
	int nr_dirty = get_nr_inodes() - get_nr_inodes_unused();
	return nr_dirty > 0 ? nr_dirty : 0;
}

/*
 * Handle nr_inode sysctl
 */
#ifdef CONFIG_SYSCTL
int proc_nr_inodes(ctl_table *table, int write,
		   void __user *buffer, size_t *lenp, loff_t *ppos)
{
	inodes_stat.nr_inodes = get_nr_inodes();
	return proc_dointvec(table, write, buffer, lenp, ppos);
}
#endif

133 134
/**
 * inode_init_always - perform inode structure intialisation
135 136
 * @sb: superblock inode belongs to
 * @inode: inode to initialise
137 138 139 140
 *
 * These are initializations that need to be done on every inode
 * allocation as the fields are not initialised by slab allocation.
 */
141
int inode_init_always(struct super_block *sb, struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
142
{
143
	static const struct inode_operations empty_iops;
144
	static const struct file_operations empty_fops;
145
	struct address_space *const mapping = &inode->i_data;
146 147 148 149 150 151 152 153

	inode->i_sb = sb;
	inode->i_blkbits = sb->s_blocksize_bits;
	inode->i_flags = 0;
	atomic_set(&inode->i_count, 1);
	inode->i_op = &empty_iops;
	inode->i_fop = &empty_fops;
	inode->i_nlink = 1;
154 155
	inode->i_uid = 0;
	inode->i_gid = 0;
156 157 158 159 160
	atomic_set(&inode->i_writecount, 0);
	inode->i_size = 0;
	inode->i_blocks = 0;
	inode->i_bytes = 0;
	inode->i_generation = 0;
Linus Torvalds's avatar
Linus Torvalds committed
161
#ifdef CONFIG_QUOTA
162
	memset(&inode->i_dquot, 0, sizeof(inode->i_dquot));
Linus Torvalds's avatar
Linus Torvalds committed
163
#endif
164 165 166 167 168
	inode->i_pipe = NULL;
	inode->i_bdev = NULL;
	inode->i_cdev = NULL;
	inode->i_rdev = 0;
	inode->dirtied_when = 0;
Mimi Zohar's avatar
Mimi Zohar committed
169 170

	if (security_inode_alloc(inode))
171
		goto out;
172 173 174 175 176 177 178 179 180 181 182 183
	spin_lock_init(&inode->i_lock);
	lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key);

	mutex_init(&inode->i_mutex);
	lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key);

	init_rwsem(&inode->i_alloc_sem);
	lockdep_set_class(&inode->i_alloc_sem, &sb->s_type->i_alloc_sem_key);

	mapping->a_ops = &empty_aops;
	mapping->host = inode;
	mapping->flags = 0;
184
	mapping_set_gfp_mask(mapping, GFP_HIGHUSER_MOVABLE);
185 186 187 188 189 190 191 192 193 194 195 196
	mapping->assoc_mapping = NULL;
	mapping->backing_dev_info = &default_backing_dev_info;
	mapping->writeback_index = 0;

	/*
	 * If the block_device provides a backing_dev_info for client
	 * inodes then use that.  Otherwise the inode share the bdev's
	 * backing_dev_info.
	 */
	if (sb->s_bdev) {
		struct backing_dev_info *bdi;

197
		bdi = sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
198 199 200 201
		mapping->backing_dev_info = bdi;
	}
	inode->i_private = NULL;
	inode->i_mapping = mapping;
202 203 204
#ifdef CONFIG_FS_POSIX_ACL
	inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
#endif
205

206 207 208 209
#ifdef CONFIG_FSNOTIFY
	inode->i_fsnotify_mask = 0;
#endif

210
	this_cpu_inc(nr_inodes);
211

212 213 214
	return 0;
out:
	return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
215
}
216 217 218 219 220 221 222 223 224 225 226
EXPORT_SYMBOL(inode_init_always);

static struct inode *alloc_inode(struct super_block *sb)
{
	struct inode *inode;

	if (sb->s_op->alloc_inode)
		inode = sb->s_op->alloc_inode(sb);
	else
		inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL);

227 228 229 230 231 232 233 234 235 236 237 238
	if (!inode)
		return NULL;

	if (unlikely(inode_init_always(sb, inode))) {
		if (inode->i_sb->s_op->destroy_inode)
			inode->i_sb->s_op->destroy_inode(inode);
		else
			kmem_cache_free(inode_cachep, inode);
		return NULL;
	}

	return inode;
239
}
Linus Torvalds's avatar
Linus Torvalds committed
240

241 242 243 244 245 246
void free_inode_nonrcu(struct inode *inode)
{
	kmem_cache_free(inode_cachep, inode);
}
EXPORT_SYMBOL(free_inode_nonrcu);

Christoph Hellwig's avatar
Christoph Hellwig committed
247
void __destroy_inode(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
248
{
249
	BUG_ON(inode_has_buffers(inode));
Linus Torvalds's avatar
Linus Torvalds committed
250
	security_inode_free(inode);
251
	fsnotify_inode_delete(inode);
252 253 254 255 256 257
#ifdef CONFIG_FS_POSIX_ACL
	if (inode->i_acl && inode->i_acl != ACL_NOT_CACHED)
		posix_acl_release(inode->i_acl);
	if (inode->i_default_acl && inode->i_default_acl != ACL_NOT_CACHED)
		posix_acl_release(inode->i_default_acl);
#endif
258
	this_cpu_dec(nr_inodes);
Christoph Hellwig's avatar
Christoph Hellwig committed
259 260 261
}
EXPORT_SYMBOL(__destroy_inode);

Nick Piggin's avatar
Nick Piggin committed
262 263 264 265 266 267 268
static void i_callback(struct rcu_head *head)
{
	struct inode *inode = container_of(head, struct inode, i_rcu);
	INIT_LIST_HEAD(&inode->i_dentry);
	kmem_cache_free(inode_cachep, inode);
}

269
static void destroy_inode(struct inode *inode)
Christoph Hellwig's avatar
Christoph Hellwig committed
270
{
271
	BUG_ON(!list_empty(&inode->i_lru));
Christoph Hellwig's avatar
Christoph Hellwig committed
272
	__destroy_inode(inode);
Linus Torvalds's avatar
Linus Torvalds committed
273 274 275
	if (inode->i_sb->s_op->destroy_inode)
		inode->i_sb->s_op->destroy_inode(inode);
	else
Nick Piggin's avatar
Nick Piggin committed
276
		call_rcu(&inode->i_rcu, i_callback);
Linus Torvalds's avatar
Linus Torvalds committed
277 278
}

279 280 281 282 283
void address_space_init_once(struct address_space *mapping)
{
	memset(mapping, 0, sizeof(*mapping));
	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
	spin_lock_init(&mapping->tree_lock);
284
	mutex_init(&mapping->i_mmap_mutex);
285 286 287 288 289 290 291
	INIT_LIST_HEAD(&mapping->private_list);
	spin_lock_init(&mapping->private_lock);
	INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
	INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
}
EXPORT_SYMBOL(address_space_init_once);

Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295 296 297 298 299 300 301 302
/*
 * These are initializations that only need to be done
 * once, because the fields are idempotent across use
 * of the inode, so let the slab aware of that.
 */
void inode_init_once(struct inode *inode)
{
	memset(inode, 0, sizeof(*inode));
	INIT_HLIST_NODE(&inode->i_hash);
	INIT_LIST_HEAD(&inode->i_dentry);
	INIT_LIST_HEAD(&inode->i_devices);
303 304
	INIT_LIST_HEAD(&inode->i_wb_list);
	INIT_LIST_HEAD(&inode->i_lru);
305
	address_space_init_once(&inode->i_data);
Linus Torvalds's avatar
Linus Torvalds committed
306
	i_size_ordered_init(inode);
307
#ifdef CONFIG_FSNOTIFY
308
	INIT_HLIST_HEAD(&inode->i_fsnotify_marks);
309
#endif
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312
}
EXPORT_SYMBOL(inode_init_once);

313
static void init_once(void *foo)
Linus Torvalds's avatar
Linus Torvalds committed
314
{
315
	struct inode *inode = (struct inode *) foo;
Linus Torvalds's avatar
Linus Torvalds committed
316

317
	inode_init_once(inode);
Linus Torvalds's avatar
Linus Torvalds committed
318 319 320
}

/*
321
 * inode->i_lock must be held
Linus Torvalds's avatar
Linus Torvalds committed
322
 */
323
void __iget(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
324
{
325 326
	atomic_inc(&inode->i_count);
}
327

Al Viro's avatar
Al Viro committed
328 329 330 331 332 333 334 335 336
/*
 * get additional reference to inode; caller must already hold one.
 */
void ihold(struct inode *inode)
{
	WARN_ON(atomic_inc_return(&inode->i_count) < 2);
}
EXPORT_SYMBOL(ihold);

337 338
static void inode_lru_list_add(struct inode *inode)
{
339
	spin_lock(&inode_lru_lock);
340 341
	if (list_empty(&inode->i_lru)) {
		list_add(&inode->i_lru, &inode_lru);
342
		inodes_stat.nr_unused++;
343
	}
344
	spin_unlock(&inode_lru_lock);
345
}
346

347 348
static void inode_lru_list_del(struct inode *inode)
{
349
	spin_lock(&inode_lru_lock);
350 351
	if (!list_empty(&inode->i_lru)) {
		list_del_init(&inode->i_lru);
352
		inodes_stat.nr_unused--;
353
	}
354
	spin_unlock(&inode_lru_lock);
Linus Torvalds's avatar
Linus Torvalds committed
355 356
}

357 358 359 360 361 362
/**
 * inode_sb_list_add - add inode to the superblock list of inodes
 * @inode: inode to add
 */
void inode_sb_list_add(struct inode *inode)
{
363 364 365
	spin_lock(&inode_sb_list_lock);
	list_add(&inode->i_sb_list, &inode->i_sb->s_inodes);
	spin_unlock(&inode_sb_list_lock);
366 367 368
}
EXPORT_SYMBOL_GPL(inode_sb_list_add);

369
static inline void inode_sb_list_del(struct inode *inode)
370
{
371
	spin_lock(&inode_sb_list_lock);
372
	list_del_init(&inode->i_sb_list);
373
	spin_unlock(&inode_sb_list_lock);
374 375
}

376 377 378 379 380 381
static unsigned long hash(struct super_block *sb, unsigned long hashval)
{
	unsigned long tmp;

	tmp = (hashval * (unsigned long)sb) ^ (GOLDEN_RATIO_PRIME + hashval) /
			L1_CACHE_BYTES;
382 383
	tmp = tmp ^ ((tmp ^ GOLDEN_RATIO_PRIME) >> i_hash_shift);
	return tmp & i_hash_mask;
384 385 386 387 388 389 390 391 392 393 394 395
}

/**
 *	__insert_inode_hash - hash an inode
 *	@inode: unhashed inode
 *	@hashval: unsigned long value used to locate this object in the
 *		inode_hashtable.
 *
 *	Add an inode to the inode hash for this superblock.
 */
void __insert_inode_hash(struct inode *inode, unsigned long hashval)
{
396 397
	struct hlist_head *b = inode_hashtable + hash(inode->i_sb, hashval);

398
	spin_lock(&inode_hash_lock);
399
	spin_lock(&inode->i_lock);
400
	hlist_add_head(&inode->i_hash, b);
401
	spin_unlock(&inode->i_lock);
402
	spin_unlock(&inode_hash_lock);
403 404 405 406 407 408 409 410 411 412 413
}
EXPORT_SYMBOL(__insert_inode_hash);

/**
 *	remove_inode_hash - remove an inode from the hash
 *	@inode: inode to unhash
 *
 *	Remove an inode from the superblock.
 */
void remove_inode_hash(struct inode *inode)
{
414
	spin_lock(&inode_hash_lock);
415
	spin_lock(&inode->i_lock);
416
	hlist_del_init(&inode->i_hash);
417
	spin_unlock(&inode->i_lock);
418
	spin_unlock(&inode_hash_lock);
419 420 421
}
EXPORT_SYMBOL(remove_inode_hash);

Al Viro's avatar
Al Viro committed
422 423 424 425 426 427 428 429
void end_writeback(struct inode *inode)
{
	might_sleep();
	BUG_ON(inode->i_data.nrpages);
	BUG_ON(!list_empty(&inode->i_data.private_list));
	BUG_ON(!(inode->i_state & I_FREEING));
	BUG_ON(inode->i_state & I_CLEAR);
	inode_sync_wait(inode);
Nick Piggin's avatar
Nick Piggin committed
430
	/* don't need i_lock here, no concurrent mods to i_state */
Al Viro's avatar
Al Viro committed
431 432 433 434
	inode->i_state = I_FREEING | I_CLEAR;
}
EXPORT_SYMBOL(end_writeback);

Dave Chinner's avatar
Dave Chinner committed
435 436 437 438 439 440 441 442 443 444 445 446 447
/*
 * Free the inode passed in, removing it from the lists it is still connected
 * to. We remove any pages still attached to the inode and wait for any IO that
 * is still in progress before finally destroying the inode.
 *
 * An inode must already be marked I_FREEING so that we avoid the inode being
 * moved back onto lists if we race with other code that manipulates the lists
 * (e.g. writeback_single_inode). The caller is responsible for setting this.
 *
 * An inode must already be removed from the LRU list before being evicted from
 * the cache. This should occur atomically with setting the I_FREEING state
 * flag, so no inodes here should ever be on the LRU when being evicted.
 */
448
static void evict(struct inode *inode)
449 450 451
{
	const struct super_operations *op = inode->i_sb->s_op;

Dave Chinner's avatar
Dave Chinner committed
452 453 454
	BUG_ON(!(inode->i_state & I_FREEING));
	BUG_ON(!list_empty(&inode->i_lru));

455
	inode_wb_list_del(inode);
456 457
	inode_sb_list_del(inode);

Al Viro's avatar
Al Viro committed
458 459
	if (op->evict_inode) {
		op->evict_inode(inode);
460 461 462
	} else {
		if (inode->i_data.nrpages)
			truncate_inode_pages(&inode->i_data, 0);
Al Viro's avatar
Al Viro committed
463
		end_writeback(inode);
464
	}
465 466 467 468
	if (S_ISBLK(inode->i_mode) && inode->i_bdev)
		bd_forget(inode);
	if (S_ISCHR(inode->i_mode) && inode->i_cdev)
		cd_forget(inode);
Dave Chinner's avatar
Dave Chinner committed
469 470 471 472 473 474 475 476 477

	remove_inode_hash(inode);

	spin_lock(&inode->i_lock);
	wake_up_bit(&inode->i_state, __I_NEW);
	BUG_ON(inode->i_state != (I_FREEING | I_CLEAR));
	spin_unlock(&inode->i_lock);

	destroy_inode(inode);
478 479
}

Linus Torvalds's avatar
Linus Torvalds committed
480 481 482 483 484 485 486 487 488 489 490 491
/*
 * dispose_list - dispose of the contents of a local list
 * @head: the head of the list to free
 *
 * Dispose-list gets a local list with local inodes in it, so it doesn't
 * need to worry about list corruption and SMP locks.
 */
static void dispose_list(struct list_head *head)
{
	while (!list_empty(head)) {
		struct inode *inode;

492 493
		inode = list_first_entry(head, struct inode, i_lru);
		list_del_init(&inode->i_lru);
Linus Torvalds's avatar
Linus Torvalds committed
494

495
		evict(inode);
Linus Torvalds's avatar
Linus Torvalds committed
496 497 498
	}
}

Al Viro's avatar
Al Viro committed
499 500 501 502 503 504 505 506
/**
 * evict_inodes	- evict all evictable inodes for a superblock
 * @sb:		superblock to operate on
 *
 * Make sure that no inodes with zero refcount are retained.  This is
 * called by superblock shutdown after having MS_ACTIVE flag removed,
 * so any inode reaching zero refcount during or after that call will
 * be immediately evicted.
Linus Torvalds's avatar
Linus Torvalds committed
507
 */
Al Viro's avatar
Al Viro committed
508
void evict_inodes(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
509
{
Al Viro's avatar
Al Viro committed
510 511
	struct inode *inode, *next;
	LIST_HEAD(dispose);
Linus Torvalds's avatar
Linus Torvalds committed
512

513
	spin_lock(&inode_sb_list_lock);
Al Viro's avatar
Al Viro committed
514 515
	list_for_each_entry_safe(inode, next, &sb->s_inodes, i_sb_list) {
		if (atomic_read(&inode->i_count))
Nick Piggin's avatar
Nick Piggin committed
516
			continue;
517 518 519 520

		spin_lock(&inode->i_lock);
		if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
			spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
521
			continue;
522
		}
Al Viro's avatar
Al Viro committed
523 524

		inode->i_state |= I_FREEING;
525
		inode_lru_list_del(inode);
526
		spin_unlock(&inode->i_lock);
527
		list_add(&inode->i_lru, &dispose);
Linus Torvalds's avatar
Linus Torvalds committed
528
	}
529
	spin_unlock(&inode_sb_list_lock);
Al Viro's avatar
Al Viro committed
530 531

	dispose_list(&dispose);
Christoph Hellwig's avatar
Christoph Hellwig committed
532 533 534 535 536 537 538

	/*
	 * Cycle through iprune_sem to make sure any inode that prune_icache
	 * moved off the list before we took the lock has been fully torn
	 * down.
	 */
	down_write(&iprune_sem);
Al Viro's avatar
Al Viro committed
539
	up_write(&iprune_sem);
Linus Torvalds's avatar
Linus Torvalds committed
540 541 542
}

/**
543 544
 * invalidate_inodes	- attempt to free all inodes on a superblock
 * @sb:		superblock to operate on
545
 * @kill_dirty: flag to guide handling of dirty inodes
Linus Torvalds's avatar
Linus Torvalds committed
546
 *
547 548
 * Attempts to free all inodes for a given superblock.  If there were any
 * busy inodes return a non-zero value, else zero.
549 550
 * If @kill_dirty is set, discard dirty inodes too, otherwise treat
 * them as busy.
Linus Torvalds's avatar
Linus Torvalds committed
551
 */
552
int invalidate_inodes(struct super_block *sb, bool kill_dirty)
Linus Torvalds's avatar
Linus Torvalds committed
553
{
554
	int busy = 0;
555 556
	struct inode *inode, *next;
	LIST_HEAD(dispose);
Linus Torvalds's avatar
Linus Torvalds committed
557

558
	spin_lock(&inode_sb_list_lock);
559
	list_for_each_entry_safe(inode, next, &sb->s_inodes, i_sb_list) {
560 561 562
		spin_lock(&inode->i_lock);
		if (inode->i_state & (I_NEW | I_FREEING | I_WILL_FREE)) {
			spin_unlock(&inode->i_lock);
Nick Piggin's avatar
Nick Piggin committed
563
			continue;
564
		}
565
		if (inode->i_state & I_DIRTY && !kill_dirty) {
566
			spin_unlock(&inode->i_lock);
567 568 569
			busy = 1;
			continue;
		}
570
		if (atomic_read(&inode->i_count)) {
571
			spin_unlock(&inode->i_lock);
572
			busy = 1;
Linus Torvalds's avatar
Linus Torvalds committed
573 574
			continue;
		}
575 576

		inode->i_state |= I_FREEING;
577
		inode_lru_list_del(inode);
578
		spin_unlock(&inode->i_lock);
579
		list_add(&inode->i_lru, &dispose);
Linus Torvalds's avatar
Linus Torvalds committed
580
	}
581
	spin_unlock(&inode_sb_list_lock);
Linus Torvalds's avatar
Linus Torvalds committed
582

583
	dispose_list(&dispose);
Linus Torvalds's avatar
Linus Torvalds committed
584 585 586 587 588 589

	return busy;
}

static int can_unuse(struct inode *inode)
{
590
	if (inode->i_state & ~I_REFERENCED)
Linus Torvalds's avatar
Linus Torvalds committed
591 592 593 594 595 596 597 598 599 600 601
		return 0;
	if (inode_has_buffers(inode))
		return 0;
	if (atomic_read(&inode->i_count))
		return 0;
	if (inode->i_data.nrpages)
		return 0;
	return 1;
}

/*
602
 * Scan `goal' inodes on the unused list for freeable ones. They are moved to a
603
 * temporary list and then are freed outside inode_lru_lock by dispose_list().
Linus Torvalds's avatar
Linus Torvalds committed
604 605
 *
 * Any inodes which are pinned purely because of attached pagecache have their
606 607
 * pagecache removed.  If the inode has metadata buffers attached to
 * mapping->private_list then try to remove them.
Linus Torvalds's avatar
Linus Torvalds committed
608
 *
609 610 611 612 613 614 615
 * If the inode has the I_REFERENCED flag set, then it means that it has been
 * used recently - the flag is set in iput_final(). When we encounter such an
 * inode, clear the flag and move it to the back of the LRU so it gets another
 * pass through the LRU before it gets reclaimed. This is necessary because of
 * the fact we are doing lazy LRU updates to minimise lock contention so the
 * LRU does not have strict ordering. Hence we don't want to reclaim inodes
 * with this flag set because they are the inodes that are out of order.
Linus Torvalds's avatar
Linus Torvalds committed
616 617 618 619 620 621 622
 */
static void prune_icache(int nr_to_scan)
{
	LIST_HEAD(freeable);
	int nr_scanned;
	unsigned long reap = 0;

623
	down_read(&iprune_sem);
624
	spin_lock(&inode_lru_lock);
Linus Torvalds's avatar
Linus Torvalds committed
625 626 627
	for (nr_scanned = 0; nr_scanned < nr_to_scan; nr_scanned++) {
		struct inode *inode;

628
		if (list_empty(&inode_lru))
Linus Torvalds's avatar
Linus Torvalds committed
629 630
			break;

631
		inode = list_entry(inode_lru.prev, struct inode, i_lru);
Linus Torvalds's avatar
Linus Torvalds committed
632

633 634 635 636 637 638 639 640 641 642
		/*
		 * we are inverting the inode_lru_lock/inode->i_lock here,
		 * so use a trylock. If we fail to get the lock, just move the
		 * inode to the back of the list so we don't spin on it.
		 */
		if (!spin_trylock(&inode->i_lock)) {
			list_move(&inode->i_lru, &inode_lru);
			continue;
		}

643 644 645 646 647 648
		/*
		 * Referenced or dirty inodes are still in use. Give them
		 * another pass through the LRU as we canot reclaim them now.
		 */
		if (atomic_read(&inode->i_count) ||
		    (inode->i_state & ~I_REFERENCED)) {
649
			list_del_init(&inode->i_lru);
650
			spin_unlock(&inode->i_lock);
651
			inodes_stat.nr_unused--;
652 653 654 655 656 657
			continue;
		}

		/* recently referenced inodes get one more pass */
		if (inode->i_state & I_REFERENCED) {
			inode->i_state &= ~I_REFERENCED;
658
			list_move(&inode->i_lru, &inode_lru);
659
			spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
660 661 662 663
			continue;
		}
		if (inode_has_buffers(inode) || inode->i_data.nrpages) {
			__iget(inode);
664
			spin_unlock(&inode->i_lock);
665
			spin_unlock(&inode_lru_lock);
Linus Torvalds's avatar
Linus Torvalds committed
666
			if (remove_inode_buffers(inode))
667 668
				reap += invalidate_mapping_pages(&inode->i_data,
								0, -1);
Linus Torvalds's avatar
Linus Torvalds committed
669
			iput(inode);
670
			spin_lock(&inode_lru_lock);
Linus Torvalds's avatar
Linus Torvalds committed
671

672 673
			if (inode != list_entry(inode_lru.next,
						struct inode, i_lru))
Linus Torvalds's avatar
Linus Torvalds committed
674
				continue;	/* wrong inode or list_empty */
675 676 677
			/* avoid lock inversions with trylock */
			if (!spin_trylock(&inode->i_lock))
				continue;
678 679
			if (!can_unuse(inode)) {
				spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
680
				continue;
681
			}
Linus Torvalds's avatar
Linus Torvalds committed
682
		}
683
		WARN_ON(inode->i_state & I_NEW);
Linus Torvalds's avatar
Linus Torvalds committed
684
		inode->i_state |= I_FREEING;
685
		spin_unlock(&inode->i_lock);
686 687

		list_move(&inode->i_lru, &freeable);
688
		inodes_stat.nr_unused--;
Linus Torvalds's avatar
Linus Torvalds committed
689
	}
690 691 692 693
	if (current_is_kswapd())
		__count_vm_events(KSWAPD_INODESTEAL, reap);
	else
		__count_vm_events(PGINODESTEAL, reap);
694
	spin_unlock(&inode_lru_lock);
Linus Torvalds's avatar
Linus Torvalds committed
695 696

	dispose_list(&freeable);
697
	up_read(&iprune_sem);
Linus Torvalds's avatar
Linus Torvalds committed
698 699 700 701 702 703 704 705 706 707 708
}

/*
 * shrink_icache_memory() will attempt to reclaim some unused inodes.  Here,
 * "unused" means that no dentries are referring to the inodes: the files are
 * not open and the dcache references to those inodes have already been
 * reclaimed.
 *
 * This function is passed the number of inodes to scan, and it returns the
 * total number of remaining possibly-reclaimable inodes.
 */
709 710
static int shrink_icache_memory(struct shrinker *shrink,
				struct shrink_control *sc)
Linus Torvalds's avatar
Linus Torvalds committed
711
{
712 713 714
	int nr = sc->nr_to_scan;
	gfp_t gfp_mask = sc->gfp_mask;

Linus Torvalds's avatar
Linus Torvalds committed
715 716 717 718 719
	if (nr) {
		/*
		 * Nasty deadlock avoidance.  We may hold various FS locks,
		 * and we don't want to recurse into the FS that called us
		 * in clear_inode() and friends..
720
		 */
Linus Torvalds's avatar
Linus Torvalds committed
721 722 723 724
		if (!(gfp_mask & __GFP_FS))
			return -1;
		prune_icache(nr);
	}
725
	return (get_nr_inodes_unused() / 100) * sysctl_vfs_cache_pressure;
Linus Torvalds's avatar
Linus Torvalds committed
726 727
}

728 729 730 731 732
static struct shrinker icache_shrinker = {
	.shrink = shrink_icache_memory,
	.seeks = DEFAULT_SEEKS,
};

Linus Torvalds's avatar
Linus Torvalds committed
733 734 735 736
static void __wait_on_freeing_inode(struct inode *inode);
/*
 * Called with the inode lock held.
 */
737 738 739 740
static struct inode *find_inode(struct super_block *sb,
				struct hlist_head *head,
				int (*test)(struct inode *, void *),
				void *data)
Linus Torvalds's avatar
Linus Torvalds committed
741 742
{
	struct hlist_node *node;
743
	struct inode *inode = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
744 745

repeat:
746
	hlist_for_each_entry(inode, node, head, i_hash) {
747 748 749
		spin_lock(&inode->i_lock);
		if (inode->i_sb != sb) {
			spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
750
			continue;
751 752 753
		}
		if (!test(inode, data)) {
			spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
754
			continue;
755
		}
756
		if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
Linus Torvalds's avatar
Linus Torvalds committed
757 758 759
			__wait_on_freeing_inode(inode);
			goto repeat;
		}
760
		__iget(inode);
761
		spin_unlock(&inode->i_lock);
762
		return inode;
Linus Torvalds's avatar
Linus Torvalds committed
763
	}
764
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767 768 769 770
}

/*
 * find_inode_fast is the fast path version of find_inode, see the comment at
 * iget_locked for details.
 */
771 772
static struct inode *find_inode_fast(struct super_block *sb,
				struct hlist_head *head, unsigned long ino)
Linus Torvalds's avatar
Linus Torvalds committed
773 774
{
	struct hlist_node *node;
775
	struct inode *inode = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
776 777

repeat:
778
	hlist_for_each_entry(inode, node, head, i_hash) {
779 780 781
		spin_lock(&inode->i_lock);
		if (inode->i_ino != ino) {
			spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
782
			continue;
783 784 785
		}
		if (inode->i_sb != sb) {
			spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
786
			continue;
787
		}
788
		if (inode->i_state & (I_FREEING|I_WILL_FREE)) {
Linus Torvalds's avatar
Linus Torvalds committed
789 790 791
			__wait_on_freeing_inode(inode);
			goto repeat;
		}
792
		__iget(inode);
793
		spin_unlock(&inode->i_lock);
794
		return inode;
Linus Torvalds's avatar
Linus Torvalds committed
795
	}
796
	return NULL;
797 798
}

799 800 801 802
/*
 * Each cpu owns a range of LAST_INO_BATCH numbers.
 * 'shared_last_ino' is dirtied only once out of LAST_INO_BATCH allocations,
 * to renew the exhausted range.
803
 *
804 805 806 807 808 809 810 811 812
 * This does not significantly increase overflow rate because every CPU can
 * consume at most LAST_INO_BATCH-1 unused inode numbers. So there is
 * NR_CPUS*(LAST_INO_BATCH-1) wastage. At 4096 and 1024, this is ~0.1% of the
 * 2^32 range, and is a worst-case. Even a 50% wastage would only increase
 * overflow rate by 2x, which does not seem too significant.
 *
 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
 * error if st_ino won't fit in target struct field. Use 32bit counter
 * here to attempt to avoid that.
813
 */
814 815 816
#define LAST_INO_BATCH 1024
static DEFINE_PER_CPU(unsigned int, last_ino);

817
unsigned int get_next_ino(void)
818
{
819 820
	unsigned int *p = &get_cpu_var(last_ino);
	unsigned int res = *p;
821

822 823 824 825 826 827 828 829 830 831 832 833
#ifdef CONFIG_SMP
	if (unlikely((res & (LAST_INO_BATCH-1)) == 0)) {
		static atomic_t shared_last_ino;
		int next = atomic_add_return(LAST_INO_BATCH, &shared_last_ino);

		res = next - LAST_INO_BATCH;
	}
#endif

	*p = ++res;
	put_cpu_var(last_ino);
	return res;
834
}
835
EXPORT_SYMBOL(get_next_ino);
836

Linus Torvalds's avatar
Linus Torvalds committed
837 838 839 840
/**
 *	new_inode 	- obtain an inode
 *	@sb: superblock
 *
841
 *	Allocates a new inode for given superblock. The default gfp_mask
842
 *	for allocations related to inode->i_mapping is GFP_HIGHUSER_MOVABLE.
843 844 845 846 847
 *	If HIGHMEM pages are unsuitable or it is known that pages allocated
 *	for the page cache are not reclaimable or migratable,
 *	mapping_set_gfp_mask() must be called with suitable flags on the
 *	newly created inode's mapping
 *
Linus Torvalds's avatar
Linus Torvalds committed
848 849 850
 */
struct inode *new_inode(struct super_block *sb)
{
851
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
852

853
	spin_lock_prefetch(&inode_sb_list_lock);
854

Linus Torvalds's avatar
Linus Torvalds committed
855 856
	inode = alloc_inode(sb);
	if (inode) {
857
		spin_lock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
858
		inode->i_state = 0;
859
		spin_unlock(&inode->i_lock);
860
		inode_sb_list_add(inode);
Linus Torvalds's avatar
Linus Torvalds committed
861 862 863 864 865
	}
	return inode;
}
EXPORT_SYMBOL(new_inode);

866 867 868 869 870 871 872
/**
 * unlock_new_inode - clear the I_NEW state and wake up any waiters
 * @inode:	new inode to unlock
 *
 * Called when the inode is fully initialised to clear the new state of the
 * inode and wake up anyone waiting for the inode to finish initialisation.
 */
Linus Torvalds's avatar
Linus Torvalds committed
873 874
void unlock_new_inode(struct inode *inode)
{
875
#ifdef CONFIG_DEBUG_LOCK_ALLOC
876
	if (S_ISDIR(inode->i_mode)) {
877 878
		struct file_system_type *type = inode->i_sb->s_type;

879 880 881 882 883 884 885 886 887 888 889
		/* Set new key only if filesystem hasn't already changed it */
		if (!lockdep_match_class(&inode->i_mutex,
		    &type->i_mutex_key)) {
			/*
			 * ensure nobody is actually holding i_mutex
			 */
			mutex_destroy(&inode->i_mutex);
			mutex_init(&inode->i_mutex);
			lockdep_set_class(&inode->i_mutex,
					  &type->i_mutex_dir_key);
		}
890
	}
891
#endif
892
	spin_lock(&inode->i_lock);
Christoph Hellwig's avatar
Christoph Hellwig committed
893 894
	WARN_ON(!(inode->i_state & I_NEW));
	inode->i_state &= ~I_NEW;
895 896
	wake_up_bit(&inode->i_state, __I_NEW);
	spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
897 898 899
}
EXPORT_SYMBOL(unlock_new_inode);

900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
/**
 * iget5_locked - obtain an inode from a mounted file system
 * @sb:		super block of file system
 * @hashval:	hash value (usually inode number) to get
 * @test:	callback used for comparisons between inodes
 * @set:	callback used to initialize a new struct inode
 * @data:	opaque data pointer to pass to @test and @set
 *
 * Search for the inode specified by @hashval and @data in the inode cache,
 * and if present it is return it with an increased reference count. This is
 * a generalized version of iget_locked() for file systems where the inode
 * number is not sufficient for unique identification of an inode.
 *
 * If the inode is not in cache, allocate a new inode and return it locked,
 * hashed, and with the I_NEW flag set. The file system gets to fill it in
 * before unlocking it via unlock_new_inode().
Linus Torvalds's avatar
Linus Torvalds committed
916
 *
917 918
 * Note both @test and @set are called with the inode_hash_lock held, so can't
 * sleep.
Linus Torvalds's avatar
Linus Torvalds committed
919
 */
920 921 922
struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
		int (*test)(struct inode *, void *),
		int (*set)(struct inode *, void *), void *data)
Linus Torvalds's avatar
Linus Torvalds committed
923
{
924
	struct hlist_head *head = inode_hashtable + hash(sb, hashval);
925
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
926

927 928 929 930 931 932 933 934 935
	spin_lock(&inode_hash_lock);
	inode = find_inode(sb, head, test, data);
	spin_unlock(&inode_hash_lock);

	if (inode) {
		wait_on_inode(inode);
		return inode;
	}

Linus Torvalds's avatar
Linus Torvalds committed
936 937
	inode = alloc_inode(sb);
	if (inode) {
938
		struct inode *old;
Linus Torvalds's avatar
Linus Torvalds committed
939

940
		spin_lock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
941 942 943 944 945 946
		/* We released the lock, so.. */
		old = find_inode(sb, head, test, data);
		if (!old) {
			if (set(inode, data))
				goto set_failed;

947 948
			spin_lock(&inode->i_lock);
			inode->i_state = I_NEW;
949
			hlist_add_head(&inode->i_hash, head);
950
			spin_unlock(&inode->i_lock);
951
			inode_sb_list_add(inode);
952
			spin_unlock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
953 954 955 956 957 958 959 960 961 962 963 964

			/* Return the locked inode with I_NEW set, the
			 * caller is responsible for filling in the contents
			 */
			return inode;
		}

		/*
		 * Uhhuh, somebody else created the same inode under
		 * us. Use the old inode instead of the one we just
		 * allocated.
		 */
965
		spin_unlock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
966 967 968 969 970 971 972
		destroy_inode(inode);
		inode = old;
		wait_on_inode(inode);
	}
	return inode;

set_failed:
973
	spin_unlock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
974 975 976
	destroy_inode(inode);
	return NULL;
}
977
EXPORT_SYMBOL(iget5_locked);
Linus Torvalds's avatar
Linus Torvalds committed
978

979 980 981 982 983 984 985 986 987 988 989 990
/**
 * iget_locked - obtain an inode from a mounted file system
 * @sb:		super block of file system
 * @ino:	inode number to get
 *
 * Search for the inode specified by @ino in the inode cache and if present
 * return it with an increased reference count. This is for file systems
 * where the inode number is sufficient for unique identification of an inode.
 *
 * If the inode is not in cache, allocate a new inode and return it locked,
 * hashed, and with the I_NEW flag set.  The file system gets to fill it in
 * before unlocking it via unlock_new_inode().
Linus Torvalds's avatar
Linus Torvalds committed
991
 */
992
struct inode *iget_locked(struct super_block *sb, unsigned long ino)
Linus Torvalds's avatar
Linus Torvalds committed
993
{
994
	struct hlist_head *head = inode_hashtable + hash(sb, ino);
995
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
996

997 998 999 1000 1001 1002 1003 1004
	spin_lock(&inode_hash_lock);
	inode = find_inode_fast(sb, head, ino);
	spin_unlock(&inode_hash_lock);
	if (inode) {
		wait_on_inode(inode);
		return inode;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1005 1006
	inode = alloc_inode(sb);
	if (inode) {
1007
		struct inode *old;
Linus Torvalds's avatar
Linus Torvalds committed
1008

1009
		spin_lock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1010 1011 1012 1013
		/* We released the lock, so.. */
		old = find_inode_fast(sb, head, ino);
		if (!old) {
			inode->i_ino = ino;
1014 1015
			spin_lock(&inode->i_lock);
			inode->i_state = I_NEW;
1016
			hlist_add_head(&inode->i_hash, head);
1017
			spin_unlock(&inode->i_lock);
1018
			inode_sb_list_add(inode);
1019
			spin_unlock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031

			/* Return the locked inode with I_NEW set, the
			 * caller is responsible for filling in the contents
			 */
			return inode;
		}

		/*
		 * Uhhuh, somebody else created the same inode under
		 * us. Use the old inode instead of the one we just
		 * allocated.
		 */
1032
		spin_unlock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1033 1034 1035 1036 1037 1038
		destroy_inode(inode);
		inode = old;
		wait_on_inode(inode);
	}
	return inode;
}
1039
EXPORT_SYMBOL(iget_locked);
Linus Torvalds's avatar
Linus Torvalds committed
1040

1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
/*
 * search the inode cache for a matching inode number.
 * If we find one, then the inode number we are trying to
 * allocate is not unique and so we should not use it.
 *
 * Returns 1 if the inode number is unique, 0 if it is not.
 */
static int test_inode_iunique(struct super_block *sb, unsigned long ino)
{
	struct hlist_head *b = inode_hashtable + hash(sb, ino);
	struct hlist_node *node;
	struct inode *inode;

1054
	spin_lock(&inode_hash_lock);
1055
	hlist_for_each_entry(inode, node, b, i_hash) {
1056 1057
		if (inode->i_ino == ino && inode->i_sb == sb) {
			spin_unlock(&inode_hash_lock);
1058
			return 0;
1059
		}
1060
	}
1061
	spin_unlock(&inode_hash_lock);
1062 1063 1064 1065

	return 1;
}

Linus Torvalds's avatar
Linus Torvalds committed
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
/**
 *	iunique - get a unique inode number
 *	@sb: superblock
 *	@max_reserved: highest reserved inode number
 *
 *	Obtain an inode number that is unique on the system for a given
 *	superblock. This is used by file systems that have no natural
 *	permanent inode numbering system. An inode number is returned that
 *	is higher than the reserved limit but unique.
 *
 *	BUGS:
 *	With a large number of inodes live on the file system this function
 *	currently becomes quite slow.
 */
ino_t iunique(struct super_block *sb, ino_t max_reserved)
{
1082 1083 1084 1085 1086
	/*
	 * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
	 * error if st_ino won't fit in target struct field. Use 32bit counter
	 * here to attempt to avoid that.
	 */
1087
	static DEFINE_SPINLOCK(iunique_lock);
1088
	static unsigned int counter;
Linus Torvalds's avatar
Linus Torvalds committed
1089
	ino_t res;
1090

1091
	spin_lock(&iunique_lock);
1092 1093 1094
	do {
		if (counter <= max_reserved)
			counter = max_reserved + 1;
Linus Torvalds's avatar
Linus Torvalds committed
1095
		res = counter++;
1096 1097
	} while (!test_inode_iunique(sb, res));
	spin_unlock(&iunique_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1098

1099 1100
	return res;
}
Linus Torvalds's avatar
Linus Torvalds committed
1101 1102 1103 1104
EXPORT_SYMBOL(iunique);

struct inode *igrab(struct inode *inode)
{
1105 1106
	spin_lock(&inode->i_lock);
	if (!(inode->i_state & (I_FREEING|I_WILL_FREE))) {
Linus Torvalds's avatar
Linus Torvalds committed
1107
		__iget(inode);
1108 1109 1110
		spin_unlock(&inode->i_lock);
	} else {
		spin_unlock(&inode->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1111 1112 1113 1114 1115 1116
		/*
		 * Handle the case where s_op->clear_inode is not been
		 * called yet, and somebody is calling igrab
		 * while the inode is getting freed.
		 */
		inode = NULL;
1117
	}
Linus Torvalds's avatar
Linus Torvalds committed
1118 1119 1120 1121 1122
	return inode;
}
EXPORT_SYMBOL(igrab);

/**
1123
 * ilookup5_nowait - search for an inode in the inode cache
Linus Torvalds's avatar
Linus Torvalds committed
1124
 * @sb:		super block of file system to search
1125
 * @hashval:	hash value (usually inode number) to search for
Linus Torvalds's avatar
Linus Torvalds committed
1126 1127 1128
 * @test:	callback used for comparisons between inodes
 * @data:	opaque data pointer to pass to @test
 *
1129
 * Search for the inode specified by @hashval and @data in the inode cache.
Linus Torvalds's avatar
Linus Torvalds committed
1130 1131 1132
 * If the inode is in the cache, the inode is returned with an incremented
 * reference count.
 *
1133 1134
 * Note: I_NEW is not waited upon so you have to be very careful what you do
 * with the returned inode.  You probably should be using ilookup5() instead.
Linus Torvalds's avatar
Linus Torvalds committed
1135
 *
1136
 * Note2: @test is called with the inode_hash_lock held, so can't sleep.
Linus Torvalds's avatar
Linus Torvalds committed
1137
 */
1138 1139
struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval,
		int (*test)(struct inode *, void *), void *data)
Linus Torvalds's avatar
Linus Torvalds committed
1140
{
1141
	struct hlist_head *head = inode_hashtable + hash(sb, hashval);
Linus Torvalds's avatar
Linus Torvalds committed
1142 1143
	struct inode *inode;

1144
	spin_lock(&inode_hash_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1145
	inode = find_inode(sb, head, test, data);
1146
	spin_unlock(&inode_hash_lock);
1147

1148
	return inode;
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
}
EXPORT_SYMBOL(ilookup5_nowait);

/**
 * ilookup5 - search for an inode in the inode cache
 * @sb:		super block of file system to search
 * @hashval:	hash value (usually inode number) to search for
 * @test:	callback used for comparisons between inodes
 * @data:	opaque data pointer to pass to @test
 *
1159 1160 1161
 * Search for the inode specified by @hashval and @data in the inode cache,
 * and if the inode is in the cache, return the inode with an incremented
 * reference count.  Waits on I_NEW before returning the inode.
1162
 * returned with an incremented reference count.
Linus Torvalds's avatar
Linus Torvalds committed
1163
 *
1164 1165
 * This is a generalized version of ilookup() for file systems where the
 * inode number is not sufficient for unique identification of an inode.
Linus Torvalds's avatar
Linus Torvalds committed
1166
 *
1167
 * Note: @test is called with the inode_hash_lock held, so can't sleep.
Linus Torvalds's avatar
Linus Torvalds committed
1168 1169 1170 1171
 */
struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
		int (*test)(struct inode *, void *), void *data)
{
1172
	struct inode *inode = ilookup5_nowait(sb, hashval, test, data);
Linus Torvalds's avatar
Linus Torvalds committed
1173

1174 1175 1176
	if (inode)
		wait_on_inode(inode);
	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
1177 1178 1179 1180 1181 1182 1183 1184
}
EXPORT_SYMBOL(ilookup5);

/**
 * ilookup - search for an inode in the inode cache
 * @sb:		super block of file system to search
 * @ino:	inode number to search for
 *
1185 1186
 * Search for the inode @ino in the inode cache, and if the inode is in the
 * cache, the inode is returned with an incremented reference count.