ialloc.c 25.4 KB
Newer Older
1
/*
2
 *  linux/fs/ext4/ialloc.c
3 4 5 6 7 8 9 10 11 12 13 14 15 16
 *
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 *  BSD ufs-inspired inode and directory allocation by
 *  Stephen Tweedie (sct@redhat.com), 1993
 *  Big-endian to little-endian byte-swapping/bitmaps by
 *        David S. Miller (davem@caip.rutgers.edu), 1995
 */

#include <linux/time.h>
#include <linux/fs.h>
17
#include <linux/jbd2.h>
18 19 20 21 22 23
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/quotaops.h>
#include <linux/buffer_head.h>
#include <linux/random.h>
#include <linux/bitops.h>
24
#include <linux/blkdev.h>
25
#include <asm/byteorder.h>
26 27
#include "ext4.h"
#include "ext4_jbd2.h"
28 29
#include "xattr.h"
#include "acl.h"
A
Andreas Dilger 已提交
30
#include "group.h"
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

/*
 * ialloc.c contains the inodes allocation and deallocation routines
 */

/*
 * The free inodes are managed by bitmaps.  A file system contains several
 * blocks groups.  Each group contains 1 bitmap block for blocks, 1 bitmap
 * block for inodes, N blocks for the inode table and data blocks.
 *
 * The file system contains group descriptors which are located after the
 * super block.  Each descriptor contains the number of the bitmap block and
 * the free blocks count in the block.
 */

A
Andreas Dilger 已提交
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
/*
 * To avoid calling the atomic setbit hundreds or thousands of times, we only
 * need to use it within a single byte (to ensure we get endianness right).
 * We can use memset for the rest of the bitmap as there are no other users.
 */
void mark_bitmap_end(int start_bit, int end_bit, char *bitmap)
{
	int i;

	if (start_bit >= end_bit)
		return;

	ext4_debug("mark end bits +%d through +%d used\n", start_bit, end_bit);
	for (i = start_bit; i < ((start_bit + 7) & ~7UL); i++)
		ext4_set_bit(i, bitmap);
	if (i < end_bit)
		memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
}

/* Initializes an uninitialized inode bitmap */
66 67
unsigned ext4_init_inode_bitmap(struct super_block *sb, struct buffer_head *bh,
				ext4_group_t block_group,
A
Andreas Dilger 已提交
68 69 70 71 72 73 74 75 76
				struct ext4_group_desc *gdp)
{
	struct ext4_sb_info *sbi = EXT4_SB(sb);

	J_ASSERT_BH(bh, buffer_locked(bh));

	/* If checksum is bad mark all blocks and inodes use to prevent
	 * allocation, essentially implementing a per-group read-only flag. */
	if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
77
		ext4_error(sb, __func__, "Checksum bad for group %lu\n",
A
Andreas Dilger 已提交
78 79 80 81 82 83 84 85 86 87 88 89 90 91
			   block_group);
		gdp->bg_free_blocks_count = 0;
		gdp->bg_free_inodes_count = 0;
		gdp->bg_itable_unused = 0;
		memset(bh->b_data, 0xff, sb->s_blocksize);
		return 0;
	}

	memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
	mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), EXT4_BLOCKS_PER_GROUP(sb),
			bh->b_data);

	return EXT4_INODES_PER_GROUP(sb);
}
92 93 94 95 96 97 98 99

/*
 * Read the inode allocation bitmap for a given block_group, reading
 * into the specified slot in the superblock's bitmap cache.
 *
 * Return buffer_head of bitmap on success or NULL.
 */
static struct buffer_head *
100
read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
101
{
102
	struct ext4_group_desc *desc;
103 104
	struct buffer_head *bh = NULL;

105
	desc = ext4_get_group_desc(sb, block_group, NULL);
106 107
	if (!desc)
		goto error_out;
A
Andreas Dilger 已提交
108 109 110 111 112 113 114 115 116 117 118 119 120 121
	if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
		bh = sb_getblk(sb, ext4_inode_bitmap(sb, desc));
		if (!buffer_uptodate(bh)) {
			lock_buffer(bh);
			if (!buffer_uptodate(bh)) {
				ext4_init_inode_bitmap(sb, bh, block_group,
						       desc);
				set_buffer_uptodate(bh);
			}
			unlock_buffer(bh);
		}
	} else {
		bh = sb_bread(sb, ext4_inode_bitmap(sb, desc));
	}
122
	if (!bh)
123
		ext4_error(sb, "read_inode_bitmap",
124
			    "Cannot read inode bitmap - "
L
Laurent Vivier 已提交
125
			    "block_group = %lu, inode_bitmap = %llu",
126
			    block_group, ext4_inode_bitmap(sb, desc));
127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
error_out:
	return bh;
}

/*
 * NOTE! When we get the inode, we're the only people
 * that have access to it, and as such there are no
 * race conditions we have to worry about. The inode
 * is not on the hash-lists, and it cannot be reached
 * through the filesystem because the directory entry
 * has been deleted earlier.
 *
 * HOWEVER: we must make sure that we get no aliases,
 * which means that we have to call "clear_inode()"
 * _before_ we mark the inode not in use in the inode
 * bitmaps. Otherwise a newly created file might use
 * the same inode number (not actually the same pointer
 * though), and then we'd have two inodes sharing the
 * same inode number and space on the harddisk.
 */
147
void ext4_free_inode (handle_t *handle, struct inode * inode)
148 149 150 151 152 153
{
	struct super_block * sb = inode->i_sb;
	int is_directory;
	unsigned long ino;
	struct buffer_head *bitmap_bh = NULL;
	struct buffer_head *bh2;
154
	ext4_group_t block_group;
155
	unsigned long bit;
156 157 158
	struct ext4_group_desc * gdp;
	struct ext4_super_block * es;
	struct ext4_sb_info *sbi;
159 160 161
	int fatal = 0, err;

	if (atomic_read(&inode->i_count) > 1) {
162
		printk ("ext4_free_inode: inode has count=%d\n",
163 164 165 166
					atomic_read(&inode->i_count));
		return;
	}
	if (inode->i_nlink) {
167
		printk ("ext4_free_inode: inode has nlink=%d\n",
168 169 170 171
			inode->i_nlink);
		return;
	}
	if (!sb) {
172
		printk("ext4_free_inode: inode on nonexistent device\n");
173 174
		return;
	}
175
	sbi = EXT4_SB(sb);
176 177

	ino = inode->i_ino;
178
	ext4_debug ("freeing inode %lu\n", ino);
179 180 181 182 183 184

	/*
	 * Note: we must free any quota before locking the superblock,
	 * as writing the quota to disk may need the lock as well.
	 */
	DQUOT_INIT(inode);
185
	ext4_xattr_delete_inode(handle, inode);
186 187 188 189 190 191 192 193
	DQUOT_FREE_INODE(inode);
	DQUOT_DROP(inode);

	is_directory = S_ISDIR(inode->i_mode);

	/* Do this BEFORE marking the inode not in use or returning an error */
	clear_inode (inode);

194 195 196
	es = EXT4_SB(sb)->s_es;
	if (ino < EXT4_FIRST_INO(sb) || ino > le32_to_cpu(es->s_inodes_count)) {
		ext4_error (sb, "ext4_free_inode",
197 198 199
			    "reserved or nonexistent inode %lu", ino);
		goto error_return;
	}
200 201
	block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
202 203 204 205 206
	bitmap_bh = read_inode_bitmap(sb, block_group);
	if (!bitmap_bh)
		goto error_return;

	BUFFER_TRACE(bitmap_bh, "get_write_access");
207
	fatal = ext4_journal_get_write_access(handle, bitmap_bh);
208 209 210 211
	if (fatal)
		goto error_return;

	/* Ok, now we can actually update the inode bitmaps.. */
212
	if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
213
					bit, bitmap_bh->b_data))
214
		ext4_error (sb, "ext4_free_inode",
215 216
			      "bit already cleared for inode %lu", ino);
	else {
217
		gdp = ext4_get_group_desc (sb, block_group, &bh2);
218 219

		BUFFER_TRACE(bh2, "get_write_access");
220
		fatal = ext4_journal_get_write_access(handle, bh2);
221 222 223 224
		if (fatal) goto error_return;

		if (gdp) {
			spin_lock(sb_bgl_lock(sbi, block_group));
M
Marcin Slusarz 已提交
225
			le16_add_cpu(&gdp->bg_free_inodes_count, 1);
226
			if (is_directory)
M
Marcin Slusarz 已提交
227
				le16_add_cpu(&gdp->bg_used_dirs_count, -1);
A
Andreas Dilger 已提交
228 229
			gdp->bg_checksum = ext4_group_desc_csum(sbi,
							block_group, gdp);
230 231 232 233 234 235
			spin_unlock(sb_bgl_lock(sbi, block_group));
			percpu_counter_inc(&sbi->s_freeinodes_counter);
			if (is_directory)
				percpu_counter_dec(&sbi->s_dirs_counter);

		}
236 237
		BUFFER_TRACE(bh2, "call ext4_journal_dirty_metadata");
		err = ext4_journal_dirty_metadata(handle, bh2);
238 239
		if (!fatal) fatal = err;
	}
240 241
	BUFFER_TRACE(bitmap_bh, "call ext4_journal_dirty_metadata");
	err = ext4_journal_dirty_metadata(handle, bitmap_bh);
242 243 244 245 246
	if (!fatal)
		fatal = err;
	sb->s_dirt = 1;
error_return:
	brelse(bitmap_bh);
247
	ext4_std_error(sb, fatal);
248 249 250 251 252 253 254 255 256 257 258 259
}

/*
 * There are two policies for allocating an inode.  If the new inode is
 * a directory, then a forward search is made for a block group with both
 * free space and a low directory-to-inode ratio; if that fails, then of
 * the groups with above-average free space, that group with the fewest
 * directories already is chosen.
 *
 * For other inodes, search forward from the parent directory\'s block
 * group to find a free inode.
 */
260 261
static int find_group_dir(struct super_block *sb, struct inode *parent,
				ext4_group_t *best_group)
262
{
263
	ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
264
	unsigned int freei, avefreei;
265
	struct ext4_group_desc *desc, *best_desc = NULL;
266 267
	ext4_group_t group;
	int ret = -1;
268

269
	freei = percpu_counter_read_positive(&EXT4_SB(sb)->s_freeinodes_counter);
270 271 272
	avefreei = freei / ngroups;

	for (group = 0; group < ngroups; group++) {
273
		desc = ext4_get_group_desc (sb, group, NULL);
274 275 276 277 278 279 280
		if (!desc || !desc->bg_free_inodes_count)
			continue;
		if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
			continue;
		if (!best_desc ||
		    (le16_to_cpu(desc->bg_free_blocks_count) >
		     le16_to_cpu(best_desc->bg_free_blocks_count))) {
281
			*best_group = group;
282
			best_desc = desc;
283
			ret = 0;
284 285
		}
	}
286
	return ret;
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
}

/*
 * Orlov's allocator for directories.
 *
 * We always try to spread first-level directories.
 *
 * If there are blockgroups with both free inodes and free blocks counts
 * not worse than average we return one with smallest directory count.
 * Otherwise we simply return a random group.
 *
 * For the rest rules look so:
 *
 * It's OK to put directory into a group unless
 * it has too many directories already (max_dirs) or
 * it has too few free inodes left (min_inodes) or
 * it has too few free blocks left (min_blocks) or
 * it's already running too large debt (max_debt).
305
 * Parent's group is preferred, if it doesn't satisfy these
306 307 308 309 310 311 312 313 314 315 316
 * conditions we search cyclically through the rest. If none
 * of the groups look good we just look for a group with more
 * free inodes than average (starting at parent's group).
 *
 * Debt is incremented each time we allocate a directory and decremented
 * when we allocate an inode, within 0--255.
 */

#define INODE_COST 64
#define BLOCK_COST 256

317 318
static int find_group_orlov(struct super_block *sb, struct inode *parent,
				ext4_group_t *group)
319
{
320
	ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
321 322
	struct ext4_sb_info *sbi = EXT4_SB(sb);
	struct ext4_super_block *es = sbi->s_es;
323
	ext4_group_t ngroups = sbi->s_groups_count;
324
	int inodes_per_group = EXT4_INODES_PER_GROUP(sb);
325
	unsigned int freei, avefreei;
326 327
	ext4_fsblk_t freeb, avefreeb;
	ext4_fsblk_t blocks_per_dir;
328 329
	unsigned int ndirs;
	int max_debt, max_dirs, min_inodes;
330
	ext4_grpblk_t min_blocks;
331
	ext4_group_t i;
332
	struct ext4_group_desc *desc;
333 334 335 336

	freei = percpu_counter_read_positive(&sbi->s_freeinodes_counter);
	avefreei = freei / ngroups;
	freeb = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
337
	avefreeb = freeb;
A
Andrew Morton 已提交
338
	do_div(avefreeb, ngroups);
339 340 341
	ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter);

	if ((parent == sb->s_root->d_inode) ||
342
	    (EXT4_I(parent)->i_flags & EXT4_TOPDIR_FL)) {
343
		int best_ndir = inodes_per_group;
344 345
		ext4_group_t grp;
		int ret = -1;
346

347 348
		get_random_bytes(&grp, sizeof(grp));
		parent_group = (unsigned)grp % ngroups;
349
		for (i = 0; i < ngroups; i++) {
350 351
			grp = (parent_group + i) % ngroups;
			desc = ext4_get_group_desc(sb, grp, NULL);
352 353 354 355 356 357 358 359
			if (!desc || !desc->bg_free_inodes_count)
				continue;
			if (le16_to_cpu(desc->bg_used_dirs_count) >= best_ndir)
				continue;
			if (le16_to_cpu(desc->bg_free_inodes_count) < avefreei)
				continue;
			if (le16_to_cpu(desc->bg_free_blocks_count) < avefreeb)
				continue;
360 361
			*group = grp;
			ret = 0;
362 363
			best_ndir = le16_to_cpu(desc->bg_used_dirs_count);
		}
364 365
		if (ret == 0)
			return ret;
366 367 368
		goto fallback;
	}

L
Laurent Vivier 已提交
369
	blocks_per_dir = ext4_blocks_count(es) - freeb;
A
Andrew Morton 已提交
370
	do_div(blocks_per_dir, ndirs);
371 372 373

	max_dirs = ndirs / ngroups + inodes_per_group / 16;
	min_inodes = avefreei - inodes_per_group / 4;
374
	min_blocks = avefreeb - EXT4_BLOCKS_PER_GROUP(sb) / 4;
375

376
	max_debt = EXT4_BLOCKS_PER_GROUP(sb);
A
Andrew Morton 已提交
377
	max_debt /= max_t(int, blocks_per_dir, BLOCK_COST);
378 379 380 381 382 383 384 385
	if (max_debt * INODE_COST > inodes_per_group)
		max_debt = inodes_per_group / INODE_COST;
	if (max_debt > 255)
		max_debt = 255;
	if (max_debt == 0)
		max_debt = 1;

	for (i = 0; i < ngroups; i++) {
386 387
		*group = (parent_group + i) % ngroups;
		desc = ext4_get_group_desc(sb, *group, NULL);
388 389 390 391 392 393 394 395
		if (!desc || !desc->bg_free_inodes_count)
			continue;
		if (le16_to_cpu(desc->bg_used_dirs_count) >= max_dirs)
			continue;
		if (le16_to_cpu(desc->bg_free_inodes_count) < min_inodes)
			continue;
		if (le16_to_cpu(desc->bg_free_blocks_count) < min_blocks)
			continue;
396
		return 0;
397 398 399 400
	}

fallback:
	for (i = 0; i < ngroups; i++) {
401 402 403 404 405
		*group = (parent_group + i) % ngroups;
		desc = ext4_get_group_desc(sb, *group, NULL);
		if (desc && desc->bg_free_inodes_count &&
			le16_to_cpu(desc->bg_free_inodes_count) >= avefreei)
			return 0;
406 407 408 409 410 411 412 413 414 415 416 417 418 419
	}

	if (avefreei) {
		/*
		 * The free-inodes counter is approximate, and for really small
		 * filesystems the above test can fail to find any blockgroups
		 */
		avefreei = 0;
		goto fallback;
	}

	return -1;
}

420 421
static int find_group_other(struct super_block *sb, struct inode *parent,
				ext4_group_t *group)
422
{
423 424
	ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
	ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
425
	struct ext4_group_desc *desc;
426
	ext4_group_t i;
427 428 429 430

	/*
	 * Try to place the inode in its parent directory
	 */
431 432
	*group = parent_group;
	desc = ext4_get_group_desc(sb, *group, NULL);
433 434
	if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
			le16_to_cpu(desc->bg_free_blocks_count))
435
		return 0;
436 437 438 439 440 441 442 443 444 445

	/*
	 * We're going to place this inode in a different blockgroup from its
	 * parent.  We want to cause files in a common directory to all land in
	 * the same blockgroup.  But we want files which are in a different
	 * directory which shares a blockgroup with our parent to land in a
	 * different blockgroup.
	 *
	 * So add our directory's i_ino into the starting point for the hash.
	 */
446
	*group = (*group + parent->i_ino) % ngroups;
447 448 449 450 451 452

	/*
	 * Use a quadratic hash to find a group with a free inode and some free
	 * blocks.
	 */
	for (i = 1; i < ngroups; i <<= 1) {
453 454 455 456
		*group += i;
		if (*group >= ngroups)
			*group -= ngroups;
		desc = ext4_get_group_desc(sb, *group, NULL);
457 458
		if (desc && le16_to_cpu(desc->bg_free_inodes_count) &&
				le16_to_cpu(desc->bg_free_blocks_count))
459
			return 0;
460 461 462 463 464 465
	}

	/*
	 * That failed: try linear search for a free inode, even if that group
	 * has no free blocks.
	 */
466
	*group = parent_group;
467
	for (i = 0; i < ngroups; i++) {
468 469 470
		if (++*group >= ngroups)
			*group = 0;
		desc = ext4_get_group_desc(sb, *group, NULL);
471
		if (desc && le16_to_cpu(desc->bg_free_inodes_count))
472
			return 0;
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
	}

	return -1;
}

/*
 * There are two policies for allocating an inode.  If the new inode is
 * a directory, then a forward search is made for a block group with both
 * free space and a low directory-to-inode ratio; if that fails, then of
 * the groups with above-average free space, that group with the fewest
 * directories already is chosen.
 *
 * For other inodes, search forward from the parent directory's block
 * group to find a free inode.
 */
488
struct inode *ext4_new_inode(handle_t *handle, struct inode * dir, int mode)
489 490 491 492
{
	struct super_block *sb;
	struct buffer_head *bitmap_bh = NULL;
	struct buffer_head *bh2;
493
	ext4_group_t group = 0;
494 495
	unsigned long ino = 0;
	struct inode * inode;
496 497 498 499
	struct ext4_group_desc * gdp = NULL;
	struct ext4_super_block * es;
	struct ext4_inode_info *ei;
	struct ext4_sb_info *sbi;
500
	int ret2, err = 0;
501
	struct inode *ret;
502 503
	ext4_group_t i;
	int free = 0;
504 505 506 507 508 509 510 511 512

	/* Cannot create files in a deleted directory */
	if (!dir || !dir->i_nlink)
		return ERR_PTR(-EPERM);

	sb = dir->i_sb;
	inode = new_inode(sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);
513
	ei = EXT4_I(inode);
514

515
	sbi = EXT4_SB(sb);
516 517 518
	es = sbi->s_es;
	if (S_ISDIR(mode)) {
		if (test_opt (sb, OLDALLOC))
519
			ret2 = find_group_dir(sb, dir, &group);
520
		else
521
			ret2 = find_group_orlov(sb, dir, &group);
522
	} else
523
		ret2 = find_group_other(sb, dir, &group);
524 525

	err = -ENOSPC;
526
	if (ret2 == -1)
527 528 529 530 531
		goto out;

	for (i = 0; i < sbi->s_groups_count; i++) {
		err = -EIO;

532
		gdp = ext4_get_group_desc(sb, group, &bh2);
533 534 535 536 537 538 539 540 541 542 543
		if (!gdp)
			goto fail;

		brelse(bitmap_bh);
		bitmap_bh = read_inode_bitmap(sb, group);
		if (!bitmap_bh)
			goto fail;

		ino = 0;

repeat_in_this_group:
544 545 546
		ino = ext4_find_next_zero_bit((unsigned long *)
				bitmap_bh->b_data, EXT4_INODES_PER_GROUP(sb), ino);
		if (ino < EXT4_INODES_PER_GROUP(sb)) {
547 548

			BUFFER_TRACE(bitmap_bh, "get_write_access");
549
			err = ext4_journal_get_write_access(handle, bitmap_bh);
550 551 552
			if (err)
				goto fail;

553
			if (!ext4_set_bit_atomic(sb_bgl_lock(sbi, group),
554 555 556
						ino, bitmap_bh->b_data)) {
				/* we won it */
				BUFFER_TRACE(bitmap_bh,
557 558
					"call ext4_journal_dirty_metadata");
				err = ext4_journal_dirty_metadata(handle,
559 560 561 562 563 564
								bitmap_bh);
				if (err)
					goto fail;
				goto got;
			}
			/* we lost it */
565
			jbd2_journal_release_buffer(handle, bitmap_bh);
566

567
			if (++ino < EXT4_INODES_PER_GROUP(sb))
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
				goto repeat_in_this_group;
		}

		/*
		 * This case is possible in concurrent environment.  It is very
		 * rare.  We cannot repeat the find_group_xxx() call because
		 * that will simply return the same blockgroup, because the
		 * group descriptor metadata has not yet been updated.
		 * So we just go onto the next blockgroup.
		 */
		if (++group == sbi->s_groups_count)
			group = 0;
	}
	err = -ENOSPC;
	goto out;

got:
A
Andreas Dilger 已提交
585 586 587
	ino++;
	if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
	    ino > EXT4_INODES_PER_GROUP(sb)) {
588
		ext4_error(sb, __func__,
A
Andreas Dilger 已提交
589
			   "reserved inode or inode > inodes count - "
590
			   "block_group = %lu, inode=%lu", group,
A
Andreas Dilger 已提交
591
			   ino + group * EXT4_INODES_PER_GROUP(sb));
592 593 594 595 596
		err = -EIO;
		goto fail;
	}

	BUFFER_TRACE(bh2, "get_write_access");
597
	err = ext4_journal_get_write_access(handle, bh2);
598
	if (err) goto fail;
A
Andreas Dilger 已提交
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632

	/* We may have to initialize the block bitmap if it isn't already */
	if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM) &&
	    gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
		struct buffer_head *block_bh = read_block_bitmap(sb, group);

		BUFFER_TRACE(block_bh, "get block bitmap access");
		err = ext4_journal_get_write_access(handle, block_bh);
		if (err) {
			brelse(block_bh);
			goto fail;
		}

		free = 0;
		spin_lock(sb_bgl_lock(sbi, group));
		/* recheck and clear flag under lock if we still need to */
		if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
			gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
			free = ext4_free_blocks_after_init(sb, group, gdp);
			gdp->bg_free_blocks_count = cpu_to_le16(free);
		}
		spin_unlock(sb_bgl_lock(sbi, group));

		/* Don't need to dirty bitmap block if we didn't change it */
		if (free) {
			BUFFER_TRACE(block_bh, "dirty block bitmap");
			err = ext4_journal_dirty_metadata(handle, block_bh);
		}

		brelse(block_bh);
		if (err)
			goto fail;
	}

633
	spin_lock(sb_bgl_lock(sbi, group));
A
Andreas Dilger 已提交
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
	/* If we didn't allocate from within the initialized part of the inode
	 * table then we need to initialize up to this inode. */
	if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
		if (gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
			gdp->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);

			/* When marking the block group with
			 * ~EXT4_BG_INODE_UNINIT we don't want to depend
			 * on the value of bg_itable_unsed even though
			 * mke2fs could have initialized the same for us.
			 * Instead we calculated the value below
			 */

			free = 0;
		} else {
			free = EXT4_INODES_PER_GROUP(sb) -
				le16_to_cpu(gdp->bg_itable_unused);
		}

		/*
		 * Check the relative inode number against the last used
		 * relative inode number in this group. if it is greater
		 * we need to  update the bg_itable_unused count
		 *
		 */
		if (ino > free)
			gdp->bg_itable_unused =
				cpu_to_le16(EXT4_INODES_PER_GROUP(sb) - ino);
	}

M
Marcin Slusarz 已提交
664
	le16_add_cpu(&gdp->bg_free_inodes_count, -1);
665
	if (S_ISDIR(mode)) {
M
Marcin Slusarz 已提交
666
		le16_add_cpu(&gdp->bg_used_dirs_count, 1);
667
	}
A
Andreas Dilger 已提交
668
	gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp);
669
	spin_unlock(sb_bgl_lock(sbi, group));
670 671
	BUFFER_TRACE(bh2, "call ext4_journal_dirty_metadata");
	err = ext4_journal_dirty_metadata(handle, bh2);
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
	if (err) goto fail;

	percpu_counter_dec(&sbi->s_freeinodes_counter);
	if (S_ISDIR(mode))
		percpu_counter_inc(&sbi->s_dirs_counter);
	sb->s_dirt = 1;

	inode->i_uid = current->fsuid;
	if (test_opt (sb, GRPID))
		inode->i_gid = dir->i_gid;
	else if (dir->i_mode & S_ISGID) {
		inode->i_gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else
		inode->i_gid = current->fsgid;
	inode->i_mode = mode;

A
Andreas Dilger 已提交
690
	inode->i_ino = ino + group * EXT4_INODES_PER_GROUP(sb);
691 692
	/* This is the optimal IO size (for stat), not the fs block size */
	inode->i_blocks = 0;
K
Kalpak Shah 已提交
693 694
	inode->i_mtime = inode->i_atime = inode->i_ctime = ei->i_crtime =
						       ext4_current_time(inode);
695 696 697 698 699

	memset(ei->i_data, 0, sizeof(ei->i_data));
	ei->i_dir_start_lookup = 0;
	ei->i_disksize = 0;

700 701 702 703 704 705
	/*
	 * Don't inherit extent flag from directory. We set extent flag on
	 * newly created directory and file only if -o extent mount option is
	 * specified
	 */
	ei->i_flags = EXT4_I(dir)->i_flags & ~(EXT4_INDEX_FL|EXT4_EXTENTS_FL);
706
	if (S_ISLNK(mode))
707
		ei->i_flags &= ~(EXT4_IMMUTABLE_FL|EXT4_APPEND_FL);
708 709
	/* dirsync only applies to directories */
	if (!S_ISDIR(mode))
710
		ei->i_flags &= ~EXT4_DIRSYNC_FL;
711 712 713 714 715
	ei->i_file_acl = 0;
	ei->i_dtime = 0;
	ei->i_block_alloc_info = NULL;
	ei->i_block_group = group;

716
	ext4_set_inode_flags(inode);
717 718 719 720 721 722 723
	if (IS_DIRSYNC(inode))
		handle->h_sync = 1;
	insert_inode_hash(inode);
	spin_lock(&sbi->s_next_gen_lock);
	inode->i_generation = sbi->s_next_generation++;
	spin_unlock(&sbi->s_next_gen_lock);

724
	ei->i_state = EXT4_STATE_NEW;
K
Kalpak Shah 已提交
725 726

	ei->i_extra_isize = EXT4_SB(sb)->s_want_extra_isize;
727 728 729 730 731 732 733

	ret = inode;
	if(DQUOT_ALLOC_INODE(inode)) {
		err = -EDQUOT;
		goto fail_drop;
	}

734
	err = ext4_init_acl(handle, inode, dir);
735 736 737
	if (err)
		goto fail_free_drop;

738
	err = ext4_init_security(handle,inode, dir);
739 740 741
	if (err)
		goto fail_free_drop;

A
Alex Tomas 已提交
742
	if (test_opt(sb, EXTENTS)) {
743 744
		/* set extent flag only for diretory, file and normal symlink*/
		if (S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode)) {
745 746 747 748 749
			EXT4_I(inode)->i_flags |= EXT4_EXTENTS_FL;
			ext4_ext_tree_init(handle, inode);
			err = ext4_update_incompat_feature(handle, sb,
					EXT4_FEATURE_INCOMPAT_EXTENTS);
			if (err)
750
				goto fail_free_drop;
751
		}
A
Alex Tomas 已提交
752
	}
753

754 755 756 757 758 759
	err = ext4_mark_inode_dirty(handle, inode);
	if (err) {
		ext4_std_error(sb, err);
		goto fail_free_drop;
	}

760
	ext4_debug("allocating inode %lu\n", inode->i_ino);
761 762
	goto really_out;
fail:
763
	ext4_std_error(sb, err);
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
out:
	iput(inode);
	ret = ERR_PTR(err);
really_out:
	brelse(bitmap_bh);
	return ret;

fail_free_drop:
	DQUOT_FREE_INODE(inode);

fail_drop:
	DQUOT_DROP(inode);
	inode->i_flags |= S_NOQUOTA;
	inode->i_nlink = 0;
	iput(inode);
	brelse(bitmap_bh);
	return ERR_PTR(err);
}

/* Verify that we are loading a valid orphan from disk */
784
struct inode *ext4_orphan_get(struct super_block *sb, unsigned long ino)
785
{
786
	unsigned long max_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count);
787
	ext4_group_t block_group;
788
	int bit;
789
	struct buffer_head *bitmap_bh;
790
	struct inode *inode = NULL;
791
	long err = -EIO;
792 793 794

	/* Error cases - e2fsck has already cleaned up for us */
	if (ino > max_ino) {
795
		ext4_warning(sb, __func__,
796
			     "bad orphan ino %lu!  e2fsck was run?", ino);
797
		goto error;
798 799
	}

800 801
	block_group = (ino - 1) / EXT4_INODES_PER_GROUP(sb);
	bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
802 803
	bitmap_bh = read_inode_bitmap(sb, block_group);
	if (!bitmap_bh) {
804
		ext4_warning(sb, __func__,
805
			     "inode bitmap error for orphan %lu", ino);
806
		goto error;
807 808 809 810 811 812
	}

	/* Having the inode bit set should be a 100% indicator that this
	 * is a valid orphan (no e2fsck run on fs).  Orphans also include
	 * inodes that were being truncated, so we can't check i_nlink==0.
	 */
813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
	if (!ext4_test_bit(bit, bitmap_bh->b_data))
		goto bad_orphan;

	inode = ext4_iget(sb, ino);
	if (IS_ERR(inode))
		goto iget_failed;

	if (NEXT_ORPHAN(inode) > max_ino)
		goto bad_orphan;
	brelse(bitmap_bh);
	return inode;

iget_failed:
	err = PTR_ERR(inode);
	inode = NULL;
bad_orphan:
829
	ext4_warning(sb, __func__,
830 831 832 833 834 835 836 837 838 839 840
		     "bad orphan inode %lu!  e2fsck was run?", ino);
	printk(KERN_NOTICE "ext4_test_bit(bit=%d, block=%llu) = %d\n",
	       bit, (unsigned long long)bitmap_bh->b_blocknr,
	       ext4_test_bit(bit, bitmap_bh->b_data));
	printk(KERN_NOTICE "inode=%p\n", inode);
	if (inode) {
		printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
		       is_bad_inode(inode));
		printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
		       NEXT_ORPHAN(inode));
		printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
841
		/* Avoid freeing blocks if we got a bad deleted inode */
842
		if (inode->i_nlink == 0)
843 844 845 846
			inode->i_blocks = 0;
		iput(inode);
	}
	brelse(bitmap_bh);
847 848
error:
	return ERR_PTR(err);
849 850
}

851
unsigned long ext4_count_free_inodes (struct super_block * sb)
852 853
{
	unsigned long desc_count;
854
	struct ext4_group_desc *gdp;
855
	ext4_group_t i;
856 857
#ifdef EXT4FS_DEBUG
	struct ext4_super_block *es;
858 859 860
	unsigned long bitmap_count, x;
	struct buffer_head *bitmap_bh = NULL;

861
	es = EXT4_SB(sb)->s_es;
862 863 864
	desc_count = 0;
	bitmap_count = 0;
	gdp = NULL;
865 866
	for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
		gdp = ext4_get_group_desc (sb, i, NULL);
867 868 869 870 871 872 873 874
		if (!gdp)
			continue;
		desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
		brelse(bitmap_bh);
		bitmap_bh = read_inode_bitmap(sb, i);
		if (!bitmap_bh)
			continue;

875
		x = ext4_count_free(bitmap_bh, EXT4_INODES_PER_GROUP(sb) / 8);
E
Eric Sandeen 已提交
876
		printk(KERN_DEBUG "group %lu: stored = %d, counted = %lu\n",
877 878 879 880
			i, le16_to_cpu(gdp->bg_free_inodes_count), x);
		bitmap_count += x;
	}
	brelse(bitmap_bh);
881
	printk("ext4_count_free_inodes: stored = %u, computed = %lu, %lu\n",
882 883 884 885
		le32_to_cpu(es->s_free_inodes_count), desc_count, bitmap_count);
	return desc_count;
#else
	desc_count = 0;
886 887
	for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
		gdp = ext4_get_group_desc (sb, i, NULL);
888 889 890 891 892 893 894 895 896 897
		if (!gdp)
			continue;
		desc_count += le16_to_cpu(gdp->bg_free_inodes_count);
		cond_resched();
	}
	return desc_count;
#endif
}

/* Called at mount-time, super-block is locked */
898
unsigned long ext4_count_dirs (struct super_block * sb)
899 900
{
	unsigned long count = 0;
901
	ext4_group_t i;
902

903 904
	for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
		struct ext4_group_desc *gdp = ext4_get_group_desc (sb, i, NULL);
905 906 907 908 909 910 911
		if (!gdp)
			continue;
		count += le16_to_cpu(gdp->bg_used_dirs_count);
	}
	return count;
}