inode.c 35.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * linux/fs/inode.c
 *
 * (C) 1997 Linus Torvalds
 */

#include <linux/config.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/dcache.h>
#include <linux/init.h>
#include <linux/quotaops.h>
#include <linux/slab.h>
14
#include <linux/writeback.h>
Jan Harkes's avatar
Jan Harkes committed
15
#include <linux/module.h>
16
#include <linux/backing-dev.h>
Andrew Morton's avatar
Andrew Morton committed
17 18
#include <linux/wait.h>
#include <linux/hash.h>
19
#include <linux/swap.h>
20
#include <linux/security.h>
21
#include <linux/cdev.h>
Andrew Morton's avatar
Andrew Morton committed
22

23 24 25 26 27 28 29 30 31 32
/*
 * This is needed for the following functions:
 *  - inode_has_buffers
 *  - invalidate_inode_buffers
 *  - fsync_bdev
 *  - invalidate_bdev
 *
 * FIXME: remove all knowledge of the buffer layer from this file
 */
#include <linux/buffer_head.h>
Linus Torvalds's avatar
Linus Torvalds committed
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

/*
 * New inode.c implementation.
 *
 * This implementation has the basic premise of trying
 * to be extremely low-overhead and SMP-safe, yet be
 * simple enough to be "obviously correct".
 *
 * Famous last words.
 */

/* inode dynamic allocation 1999, Andrea Arcangeli <andrea@suse.de> */

/* #define INODE_PARANOIA 1 */
/* #define INODE_DEBUG 1 */

/*
 * Inode lookup is no longer as critical as it used to be:
 * most of the lookups are going to be through the dcache.
 */
#define I_HASHBITS	i_hash_shift
#define I_HASHMASK	i_hash_mask

static unsigned int i_hash_mask;
static unsigned int i_hash_shift;

/*
 * Each inode can be on two separate lists. One is
 * the hash list of the inode, used for lookups. The
 * other linked list is the "type" list:
 *  "in_use" - valid inode, i_count > 0, i_nlink > 0
 *  "dirty"  - as "in_use" but also dirty
 *  "unused" - valid inode, i_count = 0
 *
 * A "dirty" list is maintained for each super block,
 * allowing for low-overhead inode sync() operations.
 */

71 72
LIST_HEAD(inode_in_use);
LIST_HEAD(inode_unused);
73
static struct hlist_head *inode_hashtable;
Linus Torvalds's avatar
Linus Torvalds committed
74 75 76 77 78 79 80

/*
 * A simple spinlock to protect the list manipulations.
 *
 * NOTE! You also have to own the lock if you change
 * the i_state of an inode while it is in use..
 */
81
spinlock_t inode_lock = SPIN_LOCK_UNLOCKED;
Linus Torvalds's avatar
Linus Torvalds committed
82

83 84 85 86 87 88 89 90 91 92
/*
 * iprune_sem provides exclusion between the kswapd or try_to_free_pages
 * icache shrinking path, and the umount path.  Without this exclusion,
 * by the time prune_icache calls iput for the inode whose pages it has
 * been invalidating, or by the time it calls clear_inode & destroy_inode
 * from its final dispose_list, the struct super_block they refer to
 * (for inode->i_sb->s_op) may already have been freed and reused.
 */
static DECLARE_MUTEX(iprune_sem);

Linus Torvalds's avatar
Linus Torvalds committed
93 94 95
/*
 * Statistics gathering..
 */
Linus Torvalds's avatar
Linus Torvalds committed
96
struct inodes_stat_t inodes_stat;
Linus Torvalds's avatar
Linus Torvalds committed
97 98 99

static kmem_cache_t * inode_cachep;

Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103 104 105 106 107 108 109 110 111 112
static struct inode *alloc_inode(struct super_block *sb)
{
	static struct address_space_operations empty_aops;
	static struct inode_operations empty_iops;
	static struct file_operations empty_fops;
	struct inode *inode;

	if (sb->s_op->alloc_inode)
		inode = sb->s_op->alloc_inode(sb);
	else
		inode = (struct inode *) kmem_cache_alloc(inode_cachep, SLAB_KERNEL);

	if (inode) {
113 114
		struct address_space * const mapping = &inode->i_data;

Linus Torvalds's avatar
Linus Torvalds committed
115 116 117 118 119 120 121 122 123 124 125
		inode->i_sb = sb;
		inode->i_blkbits = sb->s_blocksize_bits;
		inode->i_flags = 0;
		atomic_set(&inode->i_count, 1);
		inode->i_sock = 0;
		inode->i_op = &empty_iops;
		inode->i_fop = &empty_fops;
		inode->i_nlink = 1;
		atomic_set(&inode->i_writecount, 0);
		inode->i_size = 0;
		inode->i_blocks = 0;
Jan Kara's avatar
Jan Kara committed
126
		inode->i_bytes = 0;
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130
		inode->i_generation = 0;
		memset(&inode->i_dquot, 0, sizeof(inode->i_dquot));
		inode->i_pipe = NULL;
		inode->i_bdev = NULL;
Alexander Viro's avatar
Alexander Viro committed
131
		inode->i_cdev = NULL;
132
		inode->i_rdev = to_kdev_t(0);
133
		inode->i_security = NULL;
134
		if (security_inode_alloc(inode)) {
135 136 137 138 139 140
			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;
		}
141 142 143 144 145 146 147

		mapping->a_ops = &empty_aops;
 		mapping->host = inode;
		mapping->gfp_mask = GFP_HIGHUSER;
		mapping->dirtied_when = 0;
		mapping->assoc_mapping = NULL;
		mapping->backing_dev_info = &default_backing_dev_info;
Andrew Morton's avatar
Andrew Morton committed
148
		if (sb->s_bdev)
149
			mapping->backing_dev_info = sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
Linus Torvalds's avatar
Linus Torvalds committed
150
		memset(&inode->u, 0, sizeof(inode->u));
151
		inode->i_mapping = mapping;
Linus Torvalds's avatar
Linus Torvalds committed
152 153 154 155
	}
	return inode;
}

156
void destroy_inode(struct inode *inode) 
Linus Torvalds's avatar
Linus Torvalds committed
157
{
Linus Torvalds's avatar
Linus Torvalds committed
158
	if (inode_has_buffers(inode))
Linus Torvalds's avatar
Linus Torvalds committed
159
		BUG();
160
	security_inode_free(inode);
Andrew Morton's avatar
Andrew Morton committed
161
	if (inode->i_sb->s_op->destroy_inode)
Linus Torvalds's avatar
Linus Torvalds committed
162
		inode->i_sb->s_op->destroy_inode(inode);
Andrew Morton's avatar
Andrew Morton committed
163
	else
Linus Torvalds's avatar
Linus Torvalds committed
164
		kmem_cache_free(inode_cachep, (inode));
Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168 169 170 171 172
}


/*
 * 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.
 */
Linus Torvalds's avatar
Linus Torvalds committed
173 174 175
void inode_init_once(struct inode *inode)
{
	memset(inode, 0, sizeof(*inode));
176
	INIT_HLIST_NODE(&inode->i_hash);
Linus Torvalds's avatar
Linus Torvalds committed
177 178 179
	INIT_LIST_HEAD(&inode->i_data.clean_pages);
	INIT_LIST_HEAD(&inode->i_data.dirty_pages);
	INIT_LIST_HEAD(&inode->i_data.locked_pages);
180
	INIT_LIST_HEAD(&inode->i_data.io_pages);
Linus Torvalds's avatar
Linus Torvalds committed
181 182 183
	INIT_LIST_HEAD(&inode->i_dentry);
	INIT_LIST_HEAD(&inode->i_devices);
	sema_init(&inode->i_sem, 1);
184
	INIT_RADIX_TREE(&inode->i_data.page_tree, GFP_ATOMIC);
185
	spin_lock_init(&inode->i_data.page_lock);
186
	init_MUTEX(&inode->i_data.i_shared_sem);
187 188
	INIT_LIST_HEAD(&inode->i_data.private_list);
	spin_lock_init(&inode->i_data.private_lock);
189 190
	INIT_LIST_HEAD(&inode->i_data.i_mmap);
	INIT_LIST_HEAD(&inode->i_data.i_mmap_shared);
191
	spin_lock_init(&inode->i_lock);
Andrew Morton's avatar
Andrew Morton committed
192
	i_size_ordered_init(inode);
Linus Torvalds's avatar
Linus Torvalds committed
193 194
}

Linus Torvalds's avatar
Linus Torvalds committed
195 196 197 198 199 200
static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
{
	struct inode * inode = (struct inode *) foo;

	if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
	    SLAB_CTOR_CONSTRUCTOR)
Linus Torvalds's avatar
Linus Torvalds committed
201
		inode_init_once(inode);
Linus Torvalds's avatar
Linus Torvalds committed
202 203
}

204 205 206 207
/*
 * inode_lock must be held
 */
void __iget(struct inode * inode)
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211 212 213
{
	if (atomic_read(&inode->i_count)) {
		atomic_inc(&inode->i_count);
		return;
	}
	atomic_inc(&inode->i_count);
Linus Torvalds's avatar
Linus Torvalds committed
214
	if (!(inode->i_state & (I_DIRTY|I_LOCK))) {
Linus Torvalds's avatar
Linus Torvalds committed
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
		list_del(&inode->i_list);
		list_add(&inode->i_list, &inode_in_use);
	}
	inodes_stat.nr_unused--;
}

/**
 * clear_inode - clear an inode
 * @inode: inode to clear
 *
 * This is called by the filesystem to tell us
 * that the inode is no longer useful. We just
 * terminate it with extreme prejudice.
 */
 
void clear_inode(struct inode *inode)
{
Linus Torvalds's avatar
Linus Torvalds committed
232
	invalidate_inode_buffers(inode);
Linus Torvalds's avatar
Linus Torvalds committed
233 234 235 236 237 238 239 240
       
	if (inode->i_data.nrpages)
		BUG();
	if (!(inode->i_state & I_FREEING))
		BUG();
	if (inode->i_state & I_CLEAR)
		BUG();
	wait_on_inode(inode);
Linus Torvalds's avatar
Linus Torvalds committed
241
	DQUOT_DROP(inode);
242
	if (inode->i_sb && inode->i_sb->s_op->clear_inode)
Linus Torvalds's avatar
Linus Torvalds committed
243
		inode->i_sb->s_op->clear_inode(inode);
Linus Torvalds's avatar
Linus Torvalds committed
244 245
	if (inode->i_bdev)
		bd_forget(inode);
Alexander Viro's avatar
Alexander Viro committed
246 247
	if (inode->i_cdev)
		cd_forget(inode);
Linus Torvalds's avatar
Linus Torvalds committed
248 249 250 251 252 253 254
	inode->i_state = I_CLEAR;
}

/*
 * Dispose-list gets a local list with local inodes in it, so it doesn't
 * need to worry about list corruption and SMP locks.
 */
255
static void dispose_list(struct list_head *head)
Linus Torvalds's avatar
Linus Torvalds committed
256
{
257 258 259 260
	int nr_disposed = 0;

	while (!list_empty(head)) {
		struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
261

262 263
		inode = list_entry(head->next, struct inode, i_list);
		list_del(&inode->i_list);
Linus Torvalds's avatar
Linus Torvalds committed
264 265 266 267 268

		if (inode->i_data.nrpages)
			truncate_inode_pages(&inode->i_data, 0);
		clear_inode(inode);
		destroy_inode(inode);
269
		nr_disposed++;
Linus Torvalds's avatar
Linus Torvalds committed
270
	}
271 272 273
	spin_lock(&inode_lock);
	inodes_stat.nr_inodes -= nr_disposed;
	spin_unlock(&inode_lock);
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
}

/*
 * Invalidate all inodes for a device.
 */
static int invalidate_list(struct list_head *head, struct super_block * sb, struct list_head * dispose)
{
	struct list_head *next;
	int busy = 0, count = 0;

	next = head->next;
	for (;;) {
		struct list_head * tmp = next;
		struct inode * inode;

		next = next->next;
		if (tmp == head)
			break;
		inode = list_entry(tmp, struct inode, i_list);
		if (inode->i_sb != sb)
			continue;
		invalidate_inode_buffers(inode);
		if (!atomic_read(&inode->i_count)) {
297
			hlist_del_init(&inode->i_hash);
Linus Torvalds's avatar
Linus Torvalds committed
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
			list_del(&inode->i_list);
			list_add(&inode->i_list, dispose);
			inode->i_state |= I_FREEING;
			count++;
			continue;
		}
		busy = 1;
	}
	/* only unused inodes may be cached with i_count zero */
	inodes_stat.nr_unused -= count;
	return busy;
}

/*
 * This is a two-stage process. First we collect all
 * offending inodes onto the throw-away list, and in
 * the second stage we actually dispose of them. This
 * is because we don't want to sleep while messing
 * with the global lists..
 */
 
/**
 *	invalidate_inodes	- discard the inodes on a device
 *	@sb: superblock
 *
 *	Discard all of the inodes for a given superblock. If the discard
 *	fails because there are busy inodes then a non zero value is returned.
 *	If the discard is successful all the inodes have been discarded.
 */
 
int invalidate_inodes(struct super_block * sb)
{
	int busy;
	LIST_HEAD(throw_away);

333
	down(&iprune_sem);
Linus Torvalds's avatar
Linus Torvalds committed
334 335 336 337
	spin_lock(&inode_lock);
	busy = invalidate_list(&inode_in_use, sb, &throw_away);
	busy |= invalidate_list(&inode_unused, sb, &throw_away);
	busy |= invalidate_list(&sb->s_dirty, sb, &throw_away);
338
	busy |= invalidate_list(&sb->s_io, sb, &throw_away);
Linus Torvalds's avatar
Linus Torvalds committed
339 340 341
	spin_unlock(&inode_lock);

	dispose_list(&throw_away);
342
	up(&iprune_sem);
Linus Torvalds's avatar
Linus Torvalds committed
343 344 345

	return busy;
}
Linus Torvalds's avatar
Linus Torvalds committed
346
 
347
int __invalidate_device(struct block_device *bdev, int do_sync)
Linus Torvalds's avatar
Linus Torvalds committed
348
{
Linus Torvalds's avatar
Linus Torvalds committed
349
	struct super_block *sb;
Linus Torvalds's avatar
Linus Torvalds committed
350 351 352
	int res;

	if (do_sync)
353
		fsync_bdev(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
354 355

	res = 0;
Alexander Viro's avatar
Alexander Viro committed
356
	sb = get_super(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
357
	if (sb) {
Linus Torvalds's avatar
Linus Torvalds committed
358 359 360 361 362 363 364
		/*
		 * no need to lock the super, get_super holds the
		 * read semaphore so the filesystem cannot go away
		 * under us (->put_super runs with the write lock
		 * hold).
		 */
		shrink_dcache_sb(sb);
Linus Torvalds's avatar
Linus Torvalds committed
365
		res = invalidate_inodes(sb);
Linus Torvalds's avatar
Linus Torvalds committed
366 367
		drop_super(sb);
	}
368
	invalidate_bdev(bdev, 0);
369 370 371
	return res;
}

372 373 374 375 376 377 378 379
static int can_unuse(struct inode *inode)
{
	if (inode->i_state)
		return 0;
	if (inode_has_buffers(inode))
		return 0;
	if (atomic_read(&inode->i_count))
		return 0;
380 381
	if (inode->i_data.nrpages)
		return 0;
382 383
	return 1;
}
Linus Torvalds's avatar
Linus Torvalds committed
384 385

/*
386 387
 * Scan `goal' inodes on the unused list for freeable ones. They are moved to
 * a temporary list and then are freed outside inode_lock by dispose_list().
Linus Torvalds's avatar
Linus Torvalds committed
388
 *
389 390 391 392 393
 * Any inodes which are pinned purely because of attached pagecache have their
 * pagecache removed.  We expect the final iput() on that inode to add it to
 * the front of the inode_unused list.  So look for it there and if the
 * inode is still freeable, proceed.  The right inode is found 99.9% of the
 * time in testing on a 4-way.
394 395 396
 *
 * If the inode has metadata buffers attached to mapping->private_list then
 * try to remove them.
Linus Torvalds's avatar
Linus Torvalds committed
397
 */
398
static void prune_icache(int nr_to_scan)
Linus Torvalds's avatar
Linus Torvalds committed
399
{
400 401 402
	LIST_HEAD(freeable);
	int nr_pruned = 0;
	int nr_scanned;
403
	unsigned long reap = 0;
Linus Torvalds's avatar
Linus Torvalds committed
404

405
	down(&iprune_sem);
Linus Torvalds's avatar
Linus Torvalds committed
406
	spin_lock(&inode_lock);
407 408
	for (nr_scanned = 0; nr_scanned < nr_to_scan; nr_scanned++) {
		struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
409

410
		if (list_empty(&inode_unused))
411
			break;
412 413 414

		inode = list_entry(inode_unused.prev, struct inode, i_list);

415
		if (inode->i_state || atomic_read(&inode->i_count)) {
416
			list_move(&inode->i_list, &inode_unused);
Linus Torvalds's avatar
Linus Torvalds committed
417
			continue;
418
		}
419
		if (inode_has_buffers(inode) || inode->i_data.nrpages) {
420 421
			__iget(inode);
			spin_unlock(&inode_lock);
422
			if (remove_inode_buffers(inode))
423
				reap += invalidate_inode_pages(&inode->i_data);
424 425 426 427 428 429 430 431 432
			iput(inode);
			spin_lock(&inode_lock);

			if (inode != list_entry(inode_unused.next,
						struct inode, i_list))
				continue;	/* wrong inode or list_empty */
			if (!can_unuse(inode))
				continue;
		}
433
		hlist_del_init(&inode->i_hash);
434
		list_move(&inode->i_list, &freeable);
Linus Torvalds's avatar
Linus Torvalds committed
435
		inode->i_state |= I_FREEING;
436
		nr_pruned++;
Linus Torvalds's avatar
Linus Torvalds committed
437
	}
438
	inodes_stat.nr_unused -= nr_pruned;
Linus Torvalds's avatar
Linus Torvalds committed
439
	spin_unlock(&inode_lock);
440

441
	dispose_list(&freeable);
442 443
	up(&iprune_sem);

444 445 446 447
	if (current_is_kswapd)
		mod_page_state(kswapd_inodesteal, reap);
	else
		mod_page_state(pginodesteal, reap);
Linus Torvalds's avatar
Linus Torvalds committed
448
}
Andrew Morton's avatar
Andrew Morton committed
449

Linus Torvalds's avatar
Linus Torvalds committed
450
/*
451 452 453 454 455 456 457
 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
458
 */
459
static int shrink_icache_memory(int nr, unsigned int gfp_mask)
Linus Torvalds's avatar
Linus Torvalds committed
460
{
461 462 463 464 465 466 467 468 469
	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..
	 	 */
		if (gfp_mask & __GFP_FS)
			prune_icache(nr);
	}
470
	return inodes_stat.nr_unused;
Linus Torvalds's avatar
Linus Torvalds committed
471 472
}

473
static void __wait_on_freeing_inode(struct inode *inode);
Linus Torvalds's avatar
Linus Torvalds committed
474 475 476 477 478 479
/*
 * Called with the inode lock held.
 * NOTE: we are not increasing the inode-refcount, you must call __iget()
 * by hand after calling find_inode now! This simplifies iunique and won't
 * add any additional branch in the common code.
 */
480
static struct inode * find_inode(struct super_block * sb, struct hlist_head *head, int (*test)(struct inode *, void *), void *data)
Jan Harkes's avatar
Jan Harkes committed
481
{
482 483
	struct hlist_node *node;
	struct inode * inode = NULL;
Jan Harkes's avatar
Jan Harkes committed
484

485
repeat:
486 487
	hlist_for_each (node, head) { 
		inode = hlist_entry(node, struct inode, i_hash);
Jan Harkes's avatar
Jan Harkes committed
488 489 490 491
		if (inode->i_sb != sb)
			continue;
		if (!test(inode, data))
			continue;
492 493 494 495
		if (inode->i_state & (I_FREEING|I_CLEAR)) {
			__wait_on_freeing_inode(inode);
			goto repeat;
		}
Jan Harkes's avatar
Jan Harkes committed
496 497
		break;
	}
498
	return node ? inode : NULL;
Jan Harkes's avatar
Jan Harkes committed
499 500 501 502 503 504
}

/*
 * find_inode_fast is the fast path version of find_inode, see the comment at
 * iget_locked for details.
 */
505
static struct inode * find_inode_fast(struct super_block * sb, struct hlist_head *head, unsigned long ino)
Linus Torvalds's avatar
Linus Torvalds committed
506
{
507 508
	struct hlist_node *node;
	struct inode * inode = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
509

510
repeat:
511
	hlist_for_each (node, head) {
512
		inode = hlist_entry(node, struct inode, i_hash);
Linus Torvalds's avatar
Linus Torvalds committed
513 514 515 516
		if (inode->i_ino != ino)
			continue;
		if (inode->i_sb != sb)
			continue;
517 518 519 520
		if (inode->i_state & (I_FREEING|I_CLEAR)) {
			__wait_on_freeing_inode(inode);
			goto repeat;
		}
Linus Torvalds's avatar
Linus Torvalds committed
521 522
		break;
	}
523
	return node ? inode : NULL;
Linus Torvalds's avatar
Linus Torvalds committed
524 525 526
}

/**
Linus Torvalds's avatar
Linus Torvalds committed
527 528
 *	new_inode 	- obtain an inode
 *	@sb: superblock
Linus Torvalds's avatar
Linus Torvalds committed
529
 *
Linus Torvalds's avatar
Linus Torvalds committed
530
 *	Allocates a new inode for given superblock.
Linus Torvalds's avatar
Linus Torvalds committed
531 532
 */
 
Linus Torvalds's avatar
Linus Torvalds committed
533
struct inode *new_inode(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
534 535 536 537
{
	static unsigned long last_ino;
	struct inode * inode;

Linus Torvalds's avatar
Linus Torvalds committed
538 539
	spin_lock_prefetch(&inode_lock);
	
Linus Torvalds's avatar
Linus Torvalds committed
540 541
	inode = alloc_inode(sb);
	if (inode) {
Linus Torvalds's avatar
Linus Torvalds committed
542 543 544 545 546 547 548 549 550 551
		spin_lock(&inode_lock);
		inodes_stat.nr_inodes++;
		list_add(&inode->i_list, &inode_in_use);
		inode->i_ino = ++last_ino;
		inode->i_state = 0;
		spin_unlock(&inode_lock);
	}
	return inode;
}

Jan Harkes's avatar
Jan Harkes committed
552 553 554 555 556 557 558 559 560 561 562
void unlock_new_inode(struct inode *inode)
{
	/*
	 * This is special!  We do not need the spinlock
	 * when clearing I_LOCK, because we're guaranteed
	 * that nobody else tries to do anything about the
	 * state of the inode when it is locked, as we
	 * just created it (so there can be no old holders
	 * that haven't tested I_LOCK).
	 */
	inode->i_state &= ~(I_LOCK|I_NEW);
Andrew Morton's avatar
Andrew Morton committed
563
	wake_up_inode(inode);
Jan Harkes's avatar
Jan Harkes committed
564
}
565
EXPORT_SYMBOL(unlock_new_inode);
Jan Harkes's avatar
Jan Harkes committed
566

Linus Torvalds's avatar
Linus Torvalds committed
567 568 569 570 571 572
/*
 * This is called without the inode lock held.. Be careful.
 *
 * We no longer cache the sb_flags in i_flags - see fs.h
 *	-- rmk@arm.uk.linux.org
 */
573
static struct inode * get_new_inode(struct super_block *sb, struct hlist_head *head, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *data)
Linus Torvalds's avatar
Linus Torvalds committed
574 575 576
{
	struct inode * inode;

Linus Torvalds's avatar
Linus Torvalds committed
577
	inode = alloc_inode(sb);
Linus Torvalds's avatar
Linus Torvalds committed
578 579 580 581 582
	if (inode) {
		struct inode * old;

		spin_lock(&inode_lock);
		/* We released the lock, so.. */
Jan Harkes's avatar
Jan Harkes committed
583
		old = find_inode(sb, head, test, data);
Linus Torvalds's avatar
Linus Torvalds committed
584
		if (!old) {
Jan Harkes's avatar
Jan Harkes committed
585
			if (set(inode, data))
Jan Harkes's avatar
Jan Harkes committed
586 587
				goto set_failed;

Linus Torvalds's avatar
Linus Torvalds committed
588 589
			inodes_stat.nr_inodes++;
			list_add(&inode->i_list, &inode_in_use);
590
			hlist_add_head(&inode->i_hash, head);
Jan Harkes's avatar
Jan Harkes committed
591
			inode->i_state = I_LOCK|I_NEW;
Linus Torvalds's avatar
Linus Torvalds committed
592 593
			spin_unlock(&inode_lock);

Jan Harkes's avatar
Jan Harkes committed
594 595
			/* Return the locked inode with I_NEW set, the
			 * caller is responsible for filling in the contents
Linus Torvalds's avatar
Linus Torvalds committed
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612
			 */
			return inode;
		}

		/*
		 * Uhhuh, somebody else created the same inode under
		 * us. Use the old inode instead of the one we just
		 * allocated.
		 */
		__iget(old);
		spin_unlock(&inode_lock);
		destroy_inode(inode);
		inode = old;
		wait_on_inode(inode);
	}
	return inode;

Jan Harkes's avatar
Jan Harkes committed
613 614 615 616
set_failed:
	spin_unlock(&inode_lock);
	destroy_inode(inode);
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
617 618
}

Jan Harkes's avatar
Jan Harkes committed
619 620 621 622
/*
 * get_new_inode_fast is the fast path version of get_new_inode, see the
 * comment at iget_locked for details.
 */
623
static struct inode * get_new_inode_fast(struct super_block *sb, struct hlist_head *head, unsigned long ino)
Jan Harkes's avatar
Jan Harkes committed
624 625 626 627 628 629 630 631 632 633 634 635 636 637
{
	struct inode * inode;

	inode = alloc_inode(sb);
	if (inode) {
		struct inode * old;

		spin_lock(&inode_lock);
		/* We released the lock, so.. */
		old = find_inode_fast(sb, head, ino);
		if (!old) {
			inode->i_ino = ino;
			inodes_stat.nr_inodes++;
			list_add(&inode->i_list, &inode_in_use);
638
			hlist_add_head(&inode->i_hash, head);
Jan Harkes's avatar
Jan Harkes committed
639 640 641 642 643 644
			inode->i_state = I_LOCK|I_NEW;
			spin_unlock(&inode_lock);

			/* Return the locked inode with I_NEW set, the
			 * caller is responsible for filling in the contents
			 */
Linus Torvalds's avatar
Linus Torvalds committed
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
			return inode;
		}

		/*
		 * Uhhuh, somebody else created the same inode under
		 * us. Use the old inode instead of the one we just
		 * allocated.
		 */
		__iget(old);
		spin_unlock(&inode_lock);
		destroy_inode(inode);
		inode = old;
		wait_on_inode(inode);
	}
	return inode;
}

Jan Harkes's avatar
Jan Harkes committed
662
static inline unsigned long hash(struct super_block *sb, unsigned long hashval)
Linus Torvalds's avatar
Linus Torvalds committed
663
{
Jan Harkes's avatar
Jan Harkes committed
664
	unsigned long tmp = hashval + ((unsigned long) sb / L1_CACHE_BYTES);
Linus Torvalds's avatar
Linus Torvalds committed
665
	tmp = tmp + (tmp >> I_HASHBITS);
Linus Torvalds's avatar
Linus Torvalds committed
666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
	return tmp & I_HASHMASK;
}

/* Yeah, I know about quadratic hash. Maybe, later. */

/**
 *	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)
{
	static ino_t counter = 0;
	struct inode *inode;
690
	struct hlist_head * head;
Linus Torvalds's avatar
Linus Torvalds committed
691 692 693 694 695
	ino_t res;
	spin_lock(&inode_lock);
retry:
	if (counter > max_reserved) {
		head = inode_hashtable + hash(sb,counter);
Jan Harkes's avatar
Jan Harkes committed
696 697
		res = counter++;
		inode = find_inode_fast(sb, head, res);
Linus Torvalds's avatar
Linus Torvalds committed
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
		if (!inode) {
			spin_unlock(&inode_lock);
			return res;
		}
	} else {
		counter = max_reserved + 1;
	}
	goto retry;
	
}

struct inode *igrab(struct inode *inode)
{
	spin_lock(&inode_lock);
	if (!(inode->i_state & I_FREEING))
		__iget(inode);
	else
		/*
		 * 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;
	spin_unlock(&inode_lock);
	return inode;
}

725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
/**
 * ifind - internal function, you want ilookup5() or iget5().
 * @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
 *
 * ifind() searches for the inode specified by @hashval and @data in the inode
 * cache. This is a generalized version of ifind_fast() for file systems where
 * the inode number is not sufficient for unique identification of an inode.
 *
 * If the inode is in the cache, the inode is returned with an incremented
 * reference count.
 *
 * Otherwise NULL is returned.
 *
 * Note, @test is called with the inode_lock held, so can't sleep.
Jan Harkes's avatar
Jan Harkes committed
742
 */
743
static inline struct inode *ifind(struct super_block *sb,
744
		struct hlist_head *head, int (*test)(struct inode *, void *),
745
		void *data)
Linus Torvalds's avatar
Linus Torvalds committed
746
{
747
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
748 749

	spin_lock(&inode_lock);
Jan Harkes's avatar
Jan Harkes committed
750
	inode = find_inode(sb, head, test, data);
Linus Torvalds's avatar
Linus Torvalds committed
751 752 753 754 755 756 757
	if (inode) {
		__iget(inode);
		spin_unlock(&inode_lock);
		wait_on_inode(inode);
		return inode;
	}
	spin_unlock(&inode_lock);
758
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
759 760
}

761 762 763 764 765 766 767 768 769 770 771 772 773
/**
 * ifind_fast - internal function, you want ilookup() or iget().
 * @sb:		super block of file system to search
 * @ino:	inode number to search for
 *
 * ifind_fast() searches for the inode @ino in the inode cache. This is for
 * file systems where the inode number is sufficient for unique identification
 * of an inode.
 *
 * If the inode is in the cache, the inode is returned with an incremented
 * reference count.
 *
 * Otherwise NULL is returned.
Jan Harkes's avatar
Jan Harkes committed
774
 */
775
static inline struct inode *ifind_fast(struct super_block *sb,
776
		struct hlist_head *head, unsigned long ino)
Jan Harkes's avatar
Jan Harkes committed
777
{
778
	struct inode *inode;
Jan Harkes's avatar
Jan Harkes committed
779 780 781 782 783 784 785 786 787 788

	spin_lock(&inode_lock);
	inode = find_inode_fast(sb, head, ino);
	if (inode) {
		__iget(inode);
		spin_unlock(&inode_lock);
		wait_on_inode(inode);
		return inode;
	}
	spin_unlock(&inode_lock);
789 790
	return NULL;
}
Jan Harkes's avatar
Jan Harkes committed
791

792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
/**
 * 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
 *
 * ilookup5() uses ifind() to search for the inode specified by @hashval and
 * @data in the inode cache. This is a generalized version of ilookup() for
 * file systems where the inode number is not sufficient for unique
 * identification of an inode.
 *
 * If the inode is in the cache, the inode is returned with an incremented
 * reference count.
 *
 * Otherwise NULL is returned.
 *
 * Note, @test is called with the inode_lock held, so can't sleep.
 */
struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
		int (*test)(struct inode *, void *), void *data)
{
814
	struct hlist_head *head = inode_hashtable + hash(sb, hashval);
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835

	return ifind(sb, head, test, data);
}
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
 *
 * ilookup() uses ifind_fast() to search for the inode @ino in the inode cache.
 * This is for file systems where the inode number is sufficient for unique
 * identification of an inode.
 *
 * If the inode is in the cache, the inode is returned with an incremented
 * reference count.
 *
 * Otherwise NULL is returned.
 */
struct inode *ilookup(struct super_block *sb, unsigned long ino)
{
836
	struct hlist_head *head = inode_hashtable + hash(sb, ino);
837 838 839 840 841

	return ifind_fast(sb, head, ino);
}
EXPORT_SYMBOL(ilookup);

842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
/**
 * 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
 *
 * This is iget() without the read_inode() portion of get_new_inode().
 *
 * iget5_locked() uses ifind() to search for the inode specified by @hashval
 * and @data in the inode cache and if present it is returned 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, get_new_inode() is called to allocate a new
 * inode and this is returned locked, hashed, and with the I_NEW flag set. The
 * file system gets to fill it in before unlocking it via unlock_new_inode().
 *
 * Note both @test and @set are called with the inode_lock held, so can't sleep.
Jan Harkes's avatar
Jan Harkes committed
863
 */
864 865 866
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
867
{
868
	struct hlist_head *head = inode_hashtable + hash(sb, hashval);
869
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
870

871 872
	inode = ifind(sb, head, test, data);
	if (inode)
Linus Torvalds's avatar
Linus Torvalds committed
873 874 875 876 877
		return inode;
	/*
	 * get_new_inode() will do the right thing, re-trying the search
	 * in case it had to block at any point.
	 */
Jan Harkes's avatar
Jan Harkes committed
878
	return get_new_inode(sb, head, test, set, data);
Linus Torvalds's avatar
Linus Torvalds committed
879
}
880
EXPORT_SYMBOL(iget5_locked);
Linus Torvalds's avatar
Linus Torvalds committed
881

882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
/**
 * iget_locked - obtain an inode from a mounted file system
 * @sb:		super block of file system
 * @ino:	inode number to get
 *
 * This is iget() without the read_inode() portion of get_new_inode_fast().
 *
 * iget_locked() uses ifind_fast() to search for the inode specified by @ino in
 * the inode cache and if present it is returned 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, get_new_inode_fast() is called to allocate a
 * new inode and this is returned locked, hashed, and with the I_NEW flag set.
 * The file system gets to fill it in before unlocking it via
 * unlock_new_inode().
Jan Harkes's avatar
Jan Harkes committed
898
 */
Jan Harkes's avatar
Jan Harkes committed
899 900
struct inode *iget_locked(struct super_block *sb, unsigned long ino)
{
901
	struct hlist_head *head = inode_hashtable + hash(sb, ino);
902
	struct inode *inode;
Jan Harkes's avatar
Jan Harkes committed
903

904 905
	inode = ifind_fast(sb, head, ino);
	if (inode)
Jan Harkes's avatar
Jan Harkes committed
906 907 908 909 910 911
		return inode;
	/*
	 * get_new_inode_fast() will do the right thing, re-trying the search
	 * in case it had to block at any point.
	 */
	return get_new_inode_fast(sb, head, ino);
Linus Torvalds's avatar
Linus Torvalds committed
912
}
Jan Harkes's avatar
Jan Harkes committed
913 914
EXPORT_SYMBOL(iget_locked);

Linus Torvalds's avatar
Linus Torvalds committed
915
/**
Jan Harkes's avatar
Jan Harkes committed
916
 *	__insert_inode_hash - hash an inode
Linus Torvalds's avatar
Linus Torvalds committed
917
 *	@inode: unhashed inode
Jan Harkes's avatar
Jan Harkes committed
918 919
 *	@hashval: unsigned long value used to locate this object in the
 *		inode_hashtable.
Linus Torvalds's avatar
Linus Torvalds committed
920
 *
921
 *	Add an inode to the inode hash for this superblock.
Linus Torvalds's avatar
Linus Torvalds committed
922 923
 */
 
Jan Harkes's avatar
Jan Harkes committed
924
void __insert_inode_hash(struct inode *inode, unsigned long hashval)
Linus Torvalds's avatar
Linus Torvalds committed
925
{
926
	struct hlist_head *head = inode_hashtable + hash(inode->i_sb, hashval);
Linus Torvalds's avatar
Linus Torvalds committed
927
	spin_lock(&inode_lock);
928
	hlist_add_head(&inode->i_hash, head);
Linus Torvalds's avatar
Linus Torvalds committed
929 930 931 932 933 934 935
	spin_unlock(&inode_lock);
}

/**
 *	remove_inode_hash - remove an inode from the hash
 *	@inode: inode to unhash
 *
936
 *	Remove an inode from the superblock.
Linus Torvalds's avatar
Linus Torvalds committed
937 938 939 940 941
 */
 
void remove_inode_hash(struct inode *inode)
{
	spin_lock(&inode_lock);
942
	hlist_del_init(&inode->i_hash);
Linus Torvalds's avatar
Linus Torvalds committed
943 944 945
	spin_unlock(&inode_lock);
}

946 947 948 949 950 951 952 953 954 955 956 957
/*
 * Tell the filesystem that this inode is no longer of any interest and should
 * be completely destroyed.
 *
 * We leave the inode in the inode hash table until *after* the filesystem's
 * ->delete_inode completes.  This ensures that an iget (such as nfsd might
 * instigate) will always find up-to-date information either in the hash or on
 * disk.
 *
 * I_FREEING is set so that no-one will take a new reference to the inode while
 * it is being deleted.
 */
958 959 960 961
void generic_delete_inode(struct inode *inode)
{
	struct super_operations *op = inode->i_sb->s_op;

962
	list_del_init(&inode->i_list);
963 964 965 966 967 968 969
	inode->i_state|=I_FREEING;
	inodes_stat.nr_inodes--;
	spin_unlock(&inode_lock);

	if (inode->i_data.nrpages)
		truncate_inode_pages(&inode->i_data, 0);

970
	security_inode_delete(inode);
971

972
	if (op->delete_inode) {
973 974 975 976 977 978 979
		void (*delete)(struct inode *) = op->delete_inode;
		if (!is_bad_inode(inode))
			DQUOT_INIT(inode);
		/* s_op->delete_inode internally recalls clear_inode() */
		delete(inode);
	} else
		clear_inode(inode);
980 981 982 983
	spin_lock(&inode_lock);
	hlist_del_init(&inode->i_hash);
	spin_unlock(&inode_lock);
	wake_up_inode(inode);
984 985 986 987 988 989 990 991 992 993
	if (inode->i_state != I_CLEAR)
		BUG();
	destroy_inode(inode);
}
EXPORT_SYMBOL(generic_delete_inode);

static void generic_forget_inode(struct inode *inode)
{
	struct super_block *sb = inode->i_sb;

994
	if (!hlist_unhashed(&inode->i_hash)) {
995 996 997 998 999 1000 1001 1002 1003 1004 1005
		if (!(inode->i_state & (I_DIRTY|I_LOCK))) {
			list_del(&inode->i_list);
			list_add(&inode->i_list, &inode_unused);
		}
		inodes_stat.nr_unused++;
		spin_unlock(&inode_lock);
		if (!sb || (sb->s_flags & MS_ACTIVE))
			return;
		write_inode_now(inode, 1);
		spin_lock(&inode_lock);
		inodes_stat.nr_unused--;
1006
		hlist_del_init(&inode->i_hash);
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
	}
	list_del_init(&inode->i_list);
	inode->i_state|=I_FREEING;
	inodes_stat.nr_inodes--;
	spin_unlock(&inode_lock);
	if (inode->i_data.nrpages)
		truncate_inode_pages(&inode->i_data, 0);
	clear_inode(inode);
	destroy_inode(inode);
}

/*
 * Normal UNIX filesystem behaviour: delete the
 * inode when the usage count drops to zero, and
 * i_nlink is zero.
 */
static void generic_drop_inode(struct inode *inode)
{
	if (!inode->i_nlink)
		generic_delete_inode(inode);
	else
		generic_forget_inode(inode);
}

/*
 * Called when we're dropping the last reference
 * to an inode. 
 *
 * Call the FS "drop()" function, defaulting to
 * the legacy UNIX filesystem behaviour..
 *
 * NOTE! NOTE! NOTE! We're called with the inode lock
 * held, and the drop function is supposed to release
 * the lock!
 */
static inline void iput_final(struct inode *inode)
{
	struct super_operations *op = inode->i_sb->s_op;
	void (*drop)(struct inode *) = generic_drop_inode;

	if (op && op->drop_inode)
		drop = op->drop_inode;
	drop(inode);
}

Linus Torvalds's avatar
Linus Torvalds committed
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
/**
 *	iput	- put an inode 
 *	@inode: inode to put
 *
 *	Puts an inode, dropping its usage count. If the inode use count hits
 *	zero the inode is also then freed and may be destroyed.
 */
 
void iput(struct inode *inode)
{
	if (inode) {
1063
		struct super_operations *op = inode->i_sb->s_op;
Linus Torvalds's avatar
Linus Torvalds committed
1064

Linus Torvalds's avatar
Linus Torvalds committed
1065 1066 1067
		if (inode->i_state == I_CLEAR)
			BUG();

Linus Torvalds's avatar
Linus Torvalds committed
1068 1069 1070
		if (op && op->put_inode)
			op->put_inode(inode);

1071 1072
		if (atomic_dec_and_lock(&inode->i_count, &inode_lock))
			iput_final(inode);
Linus Torvalds's avatar
Linus Torvalds committed
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087
	}
}

/**
 *	bmap	- find a block number in a file
 *	@inode: inode of file
 *	@block: block to find
 *
 *	Returns the block number on the device holding the inode that
 *	is the disk block number for the block of the file requested.
 *	That is, asked for block 4 of inode 1 the function will return the
 *	disk block relative to the disk start that holds that block of the 
 *	file.
 */
 
1088
sector_t bmap(struct inode * inode, sector_t block)
Linus Torvalds's avatar
Linus Torvalds committed
1089
{
1090
	sector_t res = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1091 1092 1093 1094 1095
	if (inode->i_mapping->a_ops->bmap)
		res = inode->i_mapping->a_ops->bmap(inode->i_mapping, block);
	return res;
}

1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108
/*
 * Return true if the filesystem which backs this inode considers the two
 * passed timespecs to be sufficiently different to warrant flushing the
 * altered time out to disk.
 */
static int inode_times_differ(struct inode *inode,
			struct timespec *old, struct timespec *new)
{
	if (IS_ONE_SECOND(inode))
		return old->tv_sec != new->tv_sec;
	return !timespec_equal(old, new);
}

Linus Torvalds's avatar
Linus Torvalds committed
1109 1110 1111 1112 1113 1114 1115 1116 1117
/**
 *	update_atime	-	update the access time
 *	@inode: inode accessed
 *
 *	Update the accessed time on an inode and mark it for writeback.
 *	This function automatically handles read only file systems and media,
 *	as well as the "noatime" flag and inode specific "noatime" markers.
 */
 
Andrew Morton's avatar
Andrew Morton committed
1118
void update_atime(struct inode *inode)
Linus Torvalds's avatar
Linus Torvalds committed
1119
{
1120
	struct timespec now;
1121

Andrew Morton's avatar
Andrew Morton committed
1122 1123 1124 1125 1126 1127
	if (IS_NOATIME(inode))
		return;
	if (IS_NODIRATIME(inode) && S_ISDIR(inode->i_mode))
		return;
	if (IS_RDONLY(inode))
		return;
1128 1129 1130 1131 1132 1133 1134 1135 1136

	now = current_kernel_time();
	if (inode_times_differ(inode, &inode->i_atime, &now)) {
		inode->i_atime = now;
		mark_inode_dirty_sync(inode);
	} else {
		if (!timespec_equal(&inode->i_atime, &now))
			inode->i_atime = now;
	}
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
}

/**
 *	inode_update_time	-	update mtime and ctime time
 *	@inode: inode accessed
 *	@ctime_too: update ctime too
 *
 *	Update the mtime time on an inode and mark it for writeback.
 *	When ctime_too is specified update the ctime too.
 */

void inode_update_time(struct inode *inode, int ctime_too)
{
1150 1151 1152 1153 1154
	struct timespec now = current_kernel_time();
	int sync_it = 0;

	if (inode_times_differ(inode, &inode->i_mtime, &now))
		sync_it = 1;
1155
	inode->i_mtime = now;
1156 1157 1158 1159

	if (ctime_too) {
		if (inode_times_differ(inode, &inode->i_ctime, &now))
			sync_it = 1;
1160
		inode->i_ctime = now;
1161 1162 1163
	}
	if (sync_it)
		mark_inode_dirty_sync(inode);
Andrew Morton's avatar
Andrew Morton committed
1164
}
1165
EXPORT_SYMBOL(inode_update_time);
Linus Torvalds's avatar
Linus Torvalds committed
1166

Andrew Morton's avatar
Andrew Morton committed
1167 1168 1169 1170 1171 1172 1173 1174 1175
int inode_needs_sync(struct inode *inode)
{
	if (IS_SYNC(inode))
		return 1;
	if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
		return 1;
	return 0;
}
EXPORT_SYMBOL(inode_needs_sync);
Linus Torvalds's avatar
Linus Torvalds committed
1176 1177 1178 1179 1180 1181 1182 1183

/*
 *	Quota functions that want to walk the inode lists..
 */
#ifdef CONFIG_QUOTA

/* Functions back in dquot.c */
void put_dquot_list(struct list_head *);
Jan Kara's avatar
Jan Kara committed
1184
int remove_inode_dquot_ref(struct inode *, int, struct list_head *);
Linus Torvalds's avatar
Linus Torvalds committed
1185

Jan Kara's avatar
Jan Kara committed
1186
void remove_dquot_ref(struct super_block *sb, int type)
Linus Torvalds's avatar
Linus Torvalds committed
1187 1188 1189 1190 1191
{
	struct inode *inode;
	struct list_head *act_head;
	LIST_HEAD(tofree_head);

Linus Torvalds's avatar
Linus Torvalds committed
1192
	if (!sb->dq_op)
Linus Torvalds's avatar
Linus Torvalds committed
1193
		return;	/* nothing to do */
Linus Torvalds's avatar
Linus Torvalds committed
1194
	spin_lock(&inode_lock);	/* This lock is for inodes code */
Andrew Morton's avatar
Andrew Morton committed
1195
	/* We don't have to lock against quota code - test IS_QUOTAINIT is just for speedup... */
Linus Torvalds's avatar
Linus Torvalds committed
1196
 
Linus Torvalds's avatar
Linus Torvalds committed
1197
	list_for_each(act_head, &inode_in_use) {
Linus Torvalds's avatar
Linus Torvalds committed
1198
		inode = list_entry(act_head, struct inode, i_list);
Linus Torvalds's avatar
Linus Torvalds committed
1199 1200
		if (inode->i_sb == sb && IS_QUOTAINIT(inode))
			remove_inode_dquot_ref(inode, type, &tofree_head);
Linus Torvalds's avatar
Linus Torvalds committed
1201
	}
Linus Torvalds's avatar
Linus Torvalds committed
1202
	list_for_each(act_head, &inode_unused) {
Linus Torvalds's avatar
Linus Torvalds committed
1203
		inode = list_entry(act_head, struct inode, i_list);
Linus Torvalds's avatar
Linus Torvalds committed
1204 1205
		if (inode->i_sb == sb && IS_QUOTAINIT(inode))
			remove_inode_dquot_ref(inode, type, &tofree_head);
Linus Torvalds's avatar
Linus Torvalds committed
1206
	}
Linus Torvalds's avatar
Linus Torvalds committed
1207
	list_for_each(act_head, &sb->s_dirty) {
Linus Torvalds's avatar
Linus Torvalds committed
1208
		inode = list_entry(act_head, struct inode, i_list);
Linus Torvalds's avatar
Linus Torvalds committed
1209 1210 1211
		if (IS_QUOTAINIT(inode))
			remove_inode_dquot_ref(inode, type, &tofree_head);
	}
1212 1213 1214 1215 1216
	list_for_each(act_head, &sb->s_io) {
		inode = list_entry(act_head, struct inode, i_list);
		if (IS_QUOTAINIT(inode))
			remove_inode_dquot_ref(inode, type, &tofree_head);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1217 1218 1219 1220 1221 1222
	spin_unlock(&inode_lock);

	put_dquot_list(&tofree_head);
}

#endif
Andrew Morton's avatar
Andrew Morton committed
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253

/*
 * Hashed waitqueues for wait_on_inode().  The table is pretty small - the
 * kernel doesn't lock many inodes at the same time.
 */
#define I_WAIT_TABLE_ORDER	3
static struct i_wait_queue_head {
	wait_queue_head_t wqh;
} ____cacheline_aligned_in_smp i_wait_queue_heads[1<<I_WAIT_TABLE_ORDER];

/*
 * Return the address of the waitqueue_head to be used for this inode
 */
static wait_queue_head_t *i_waitq_head(struct inode *inode)
{
	return &i_wait_queue_heads[hash_ptr(inode, I_WAIT_TABLE_ORDER)].wqh;
}

void __wait_on_inode(struct inode *inode)
{
	DECLARE_WAITQUEUE(wait, current);
	wait_queue_head_t *wq = i_waitq_head(inode);

	add_wait_queue(wq, &wait);
repeat:
	set_current_state(TASK_UNINTERRUPTIBLE);
	if (inode->i_state & I_LOCK) {
		schedule();
		goto repeat;
	}
	remove_wait_queue(wq, &wait);
1254
	__set_current_state(TASK_RUNNING);
Andrew Morton's avatar
Andrew Morton committed
1255 1256
}

1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
/*
 * If we try to find an inode in the inode hash while it is being deleted, we
 * have to wait until the filesystem completes its deletion before reporting
 * that it isn't found.  This is because iget will immediately call
 * ->read_inode, and we want to be sure that evidence of the deletion is found
 * by ->read_inode.
 *
 * This call might return early if an inode which shares the waitq is woken up.
 * This is most easily handled by the caller which will loop around again
 * looking for the inode.
 *
 * This is called with inode_lock held.
 */
static void __wait_on_freeing_inode(struct inode *inode)
{
	DECLARE_WAITQUEUE(wait, current);
	wait_queue_head_t *wq = i_waitq_head(inode);

	add_wait_queue(wq, &wait);
	set_current_state(TASK_UNINTERRUPTIBLE);
	spin_unlock(&inode_lock);
	schedule();
	remove_wait_queue(wq, &wait);
	spin_lock(&inode_lock);
}

Andrew Morton's avatar
Andrew Morton committed
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
void wake_up_inode(struct inode *inode)
{
	wait_queue_head_t *wq = i_waitq_head(inode);

	/*
	 * Prevent speculative execution through spin_unlock(&inode_lock);
	 */
	smp_mb();
	if (waitqueue_active(wq))
		wake_up_all(wq);
}

/*
 * Initialize the waitqueues and inode hash table.
 */
void __init inode_init(unsigned long mempages)
{
1300
	struct hlist_head *head;
Andrew Morton's avatar
Andrew Morton committed
1301 1302 1303 1304 1305 1306 1307 1308
	unsigned long order;
	unsigned int nr_hash;
	int i;

	for (i = 0; i < ARRAY_SIZE(i_wait_queue_heads); i++)
		init_waitqueue_head(&i_wait_queue_heads[i].wqh);

	mempages >>= (14 - PAGE_SHIFT);
1309
	mempages *= sizeof(struct hlist_head);
Andrew Morton's avatar
Andrew Morton committed
1310 1311 1312 1313 1314 1315 1316
	for (order = 0; ((1UL << order) << PAGE_SHIFT) < mempages; order++)
		;

	do {
		unsigned long tmp;

		nr_hash = (1UL << order) * PAGE_SIZE /
1317
			sizeof(struct hlist_head);
Andrew Morton's avatar
Andrew Morton committed
1318 1319 1320 1321 1322 1323 1324
		i_hash_mask = (nr_hash - 1);

		tmp = nr_hash;
		i_hash_shift = 0;
		while ((tmp >>= 1UL) != 0UL)
			i_hash_shift++;

1325
		inode_hashtable = (struct hlist_head *)
Andrew Morton's avatar
Andrew Morton committed
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
			__get_free_pages(GFP_ATOMIC, order);
	} while (inode_hashtable == NULL && --order >= 0);

	printk("Inode-cache hash table entries: %d (order: %ld, %ld bytes)\n",
			nr_hash, order, (PAGE_SIZE << order));

	if (!inode_hashtable)
		panic("Failed to allocate inode hash table\n");

	head = inode_hashtable;
	i = nr_hash;
	do {
1338
		INIT_HLIST_HEAD(head);
Andrew Morton's avatar
Andrew Morton committed
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
		head++;
		i--;
	} while (i);

	/* inode slab cache */
	inode_cachep = kmem_cache_create("inode_cache", sizeof(struct inode),
					 0, SLAB_HWCACHE_ALIGN, init_once,
					 NULL);
	if (!inode_cachep)
		panic("cannot create inode slab cache");
1349 1350

	set_shrinker(DEFAULT_SEEKS, shrink_icache_memory);
Andrew Morton's avatar
Andrew Morton committed
1351
}
Brian Gerst's avatar
Brian Gerst committed
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366

void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev)
{
	inode->i_mode = mode;
	if (S_ISCHR(mode)) {
		inode->i_fop = &def_chr_fops;
		inode->i_rdev = to_kdev_t(rdev);
	} else if (S_ISBLK(mode)) {
		inode->i_fop = &def_blk_fops;
		inode->i_rdev = to_kdev_t(rdev);
	} else if (S_ISFIFO(mode))
		inode->i_fop = &def_fifo_fops;
	else if (S_ISSOCK(mode))
		inode->i_fop = &bad_sock_fops;
	else
1367 1368
		printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o)\n",
		       mode);
Brian Gerst's avatar
Brian Gerst committed
1369
}