resize.c 34.4 KB
Newer Older
1
/*
2
 *  linux/fs/ext4/resize.c
3
 *
4
 * Support for resizing an ext4 filesystem while it is mounted.
5 6 7 8 9 10 11
 *
 * Copyright (C) 2001, 2002 Andreas Dilger <adilger@clusterfs.com>
 *
 * This could probably be made into a module, because it is not often in use.
 */


12
#define EXT4FS_DEBUG
13 14 15 16

#include <linux/errno.h>
#include <linux/slab.h>

17
#include "ext4_jbd2.h"
A
Andreas Dilger 已提交
18
#include "group.h"
19 20 21 22 23

#define outside(b, first, last)	((b) < (first) || (b) >= (last))
#define inside(b, first, last)	((b) >= (first) && (b) < (last))

static int verify_group_input(struct super_block *sb,
24
			      struct ext4_new_group_data *input)
25
{
26 27
	struct ext4_sb_info *sbi = EXT4_SB(sb);
	struct ext4_super_block *es = sbi->s_es;
L
Laurent Vivier 已提交
28
	ext4_fsblk_t start = ext4_blocks_count(es);
29
	ext4_fsblk_t end = start + input->blocks_count;
30
	ext4_group_t group = input->group;
31 32 33
	ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group;
	unsigned overhead = ext4_bg_has_super(sb, group) ?
		(1 + ext4_bg_num_gdb(sb, group) +
34
		 le16_to_cpu(es->s_reserved_gdt_blocks)) : 0;
35
	ext4_fsblk_t metaend = start + overhead;
36
	struct buffer_head *bh = NULL;
37
	ext4_grpblk_t free_blocks_count, offset;
38 39 40 41 42 43
	int err = -EINVAL;

	input->free_blocks_count = free_blocks_count =
		input->blocks_count - 2 - overhead - sbi->s_itb_per_group;

	if (test_opt(sb, DEBUG))
44
		printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks "
45
		       "(%d free, %u reserved)\n",
46
		       ext4_bg_has_super(sb, input->group) ? "normal" :
47 48 49
		       "no-super", input->group, input->blocks_count,
		       free_blocks_count, input->reserved_blocks);

50
	ext4_get_group_no_and_offset(sb, start, NULL, &offset);
51
	if (group != sbi->s_groups_count)
52
		ext4_warning(sb, __func__,
53 54
			     "Cannot add at group %u (only %lu groups)",
			     input->group, sbi->s_groups_count);
55
	else if (offset != 0)
56
			ext4_warning(sb, __func__, "Last group not full");
57
	else if (input->reserved_blocks > input->blocks_count / 5)
58
		ext4_warning(sb, __func__, "Reserved blocks too high (%u)",
59 60
			     input->reserved_blocks);
	else if (free_blocks_count < 0)
61
		ext4_warning(sb, __func__, "Bad blocks count %u",
62 63
			     input->blocks_count);
	else if (!(bh = sb_bread(sb, end - 1)))
64
		ext4_warning(sb, __func__,
65
			     "Cannot read last block (%llu)",
66 67
			     end - 1);
	else if (outside(input->block_bitmap, start, end))
68
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
69
			     "Block bitmap not in group (block %llu)",
70
			     (unsigned long long)input->block_bitmap);
71
	else if (outside(input->inode_bitmap, start, end))
72
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
73
			     "Inode bitmap not in group (block %llu)",
74
			     (unsigned long long)input->inode_bitmap);
75
	else if (outside(input->inode_table, start, end) ||
76
		 outside(itend - 1, start, end))
77
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
78
			     "Inode table not in group (blocks %llu-%llu)",
79
			     (unsigned long long)input->inode_table, itend - 1);
80
	else if (input->inode_bitmap == input->block_bitmap)
81
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
82
			     "Block bitmap same as inode bitmap (%llu)",
83
			     (unsigned long long)input->block_bitmap);
84
	else if (inside(input->block_bitmap, input->inode_table, itend))
85
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
86
			     "Block bitmap (%llu) in inode table (%llu-%llu)",
87 88
			     (unsigned long long)input->block_bitmap,
			     (unsigned long long)input->inode_table, itend - 1);
89
	else if (inside(input->inode_bitmap, input->inode_table, itend))
90
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
91
			     "Inode bitmap (%llu) in inode table (%llu-%llu)",
92 93
			     (unsigned long long)input->inode_bitmap,
			     (unsigned long long)input->inode_table, itend - 1);
94
	else if (inside(input->block_bitmap, start, metaend))
95
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
96
			     "Block bitmap (%llu) in GDT table"
97
			     " (%llu-%llu)",
98 99
			     (unsigned long long)input->block_bitmap,
			     start, metaend - 1);
100
	else if (inside(input->inode_bitmap, start, metaend))
101
		ext4_warning(sb, __func__,
L
Laurent Vivier 已提交
102
			     "Inode bitmap (%llu) in GDT table"
103
			     " (%llu-%llu)",
104 105
			     (unsigned long long)input->inode_bitmap,
			     start, metaend - 1);
106
	else if (inside(input->inode_table, start, metaend) ||
107
		 inside(itend - 1, start, metaend))
108
		ext4_warning(sb, __func__,
109 110
			     "Inode table (%llu-%llu) overlaps"
			     "GDT table (%llu-%llu)",
111 112
			     (unsigned long long)input->inode_table,
			     itend - 1, start, metaend - 1);
113 114 115 116 117 118 119 120
	else
		err = 0;
	brelse(bh);

	return err;
}

static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
121
				  ext4_fsblk_t blk)
122 123 124 125 126 127 128
{
	struct buffer_head *bh;
	int err;

	bh = sb_getblk(sb, blk);
	if (!bh)
		return ERR_PTR(-EIO);
129
	if ((err = ext4_journal_get_write_access(handle, bh))) {
130 131 132 133 134 135 136 137 138 139 140 141
		brelse(bh);
		bh = ERR_PTR(err);
	} else {
		lock_buffer(bh);
		memset(bh->b_data, 0, sb->s_blocksize);
		set_buffer_uptodate(bh);
		unlock_buffer(bh);
	}

	return bh;
}

142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
/*
 * If we have fewer than thresh credits, extend by EXT4_MAX_TRANS_DATA.
 * If that fails, restart the transaction & regain write access for the
 * buffer head which is used for block_bitmap modifications.
 */
static int extend_or_restart_transaction(handle_t *handle, int thresh,
					 struct buffer_head *bh)
{
	int err;

	if (handle->h_buffer_credits >= thresh)
		return 0;

	err = ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA);
	if (err < 0)
		return err;
	if (err) {
		if ((err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA)))
			return err;
161
		if ((err = ext4_journal_get_write_access(handle, bh)))
162
			return err;
163
	}
164 165 166 167

	return 0;
}

168 169 170 171 172 173 174 175
/*
 * Set up the block and inode bitmaps, and the inode table for the new group.
 * This doesn't need to be part of the main transaction, since we are only
 * changing blocks outside the actual filesystem.  We still do journaling to
 * ensure the recovery is correct in case of a failure just after resize.
 * If any part of this fails, we simply abort the resize.
 */
static int setup_new_group_blocks(struct super_block *sb,
176
				  struct ext4_new_group_data *input)
177
{
178 179 180
	struct ext4_sb_info *sbi = EXT4_SB(sb);
	ext4_fsblk_t start = ext4_group_first_block_no(sb, input->group);
	int reserved_gdb = ext4_bg_has_super(sb, input->group) ?
181
		le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0;
182
	unsigned long gdblocks = ext4_bg_num_gdb(sb, input->group);
183 184
	struct buffer_head *bh;
	handle_t *handle;
185 186
	ext4_fsblk_t block;
	ext4_grpblk_t bit;
187 188 189
	int i;
	int err = 0, err2;

190 191 192
	/* This transaction may be extended/restarted along the way */
	handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);

193 194 195 196 197 198 199 200 201 202 203 204 205 206
	if (IS_ERR(handle))
		return PTR_ERR(handle);

	lock_super(sb);
	if (input->group != sbi->s_groups_count) {
		err = -EBUSY;
		goto exit_journal;
	}

	if (IS_ERR(bh = bclean(handle, sb, input->block_bitmap))) {
		err = PTR_ERR(bh);
		goto exit_journal;
	}

207
	if (ext4_bg_has_super(sb, input->group)) {
E
Eric Sandeen 已提交
208
		ext4_debug("mark backup superblock %#04llx (+0)\n", start);
209
		ext4_set_bit(0, bh->b_data);
210 211 212 213 214 215 216
	}

	/* Copy all of the GDT blocks into the backup in this group */
	for (i = 0, bit = 1, block = start + 1;
	     i < gdblocks; i++, block++, bit++) {
		struct buffer_head *gdb;

E
Eric Sandeen 已提交
217
		ext4_debug("update backup group %#04llx (+%d)\n", block, bit);
218

219 220 221
		if ((err = extend_or_restart_transaction(handle, 1, bh)))
			goto exit_bh;

222 223 224 225 226
		gdb = sb_getblk(sb, block);
		if (!gdb) {
			err = -EIO;
			goto exit_bh;
		}
227
		if ((err = ext4_journal_get_write_access(handle, gdb))) {
228 229 230
			brelse(gdb);
			goto exit_bh;
		}
231 232
		lock_buffer(gdb);
		memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, gdb->b_size);
233
		set_buffer_uptodate(gdb);
234
		unlock_buffer(gdb);
235 236
		ext4_journal_dirty_metadata(handle, gdb);
		ext4_set_bit(bit, bh->b_data);
237 238 239 240 241 242 243 244
		brelse(gdb);
	}

	/* Zero out all of the reserved backup group descriptor table blocks */
	for (i = 0, bit = gdblocks + 1, block = start + bit;
	     i < reserved_gdb; i++, block++, bit++) {
		struct buffer_head *gdb;

E
Eric Sandeen 已提交
245
		ext4_debug("clear reserved block %#04llx (+%d)\n", block, bit);
246

247 248 249
		if ((err = extend_or_restart_transaction(handle, 1, bh)))
			goto exit_bh;

250 251 252 253
		if (IS_ERR(gdb = bclean(handle, sb, block))) {
			err = PTR_ERR(bh);
			goto exit_bh;
		}
254 255
		ext4_journal_dirty_metadata(handle, gdb);
		ext4_set_bit(bit, bh->b_data);
256 257
		brelse(gdb);
	}
E
Eric Sandeen 已提交
258
	ext4_debug("mark block bitmap %#04llx (+%llu)\n", input->block_bitmap,
259
		   input->block_bitmap - start);
260
	ext4_set_bit(input->block_bitmap - start, bh->b_data);
E
Eric Sandeen 已提交
261
	ext4_debug("mark inode bitmap %#04llx (+%llu)\n", input->inode_bitmap,
262
		   input->inode_bitmap - start);
263
	ext4_set_bit(input->inode_bitmap - start, bh->b_data);
264 265 266 267 268 269

	/* Zero out all of the inode table blocks */
	for (i = 0, block = input->inode_table, bit = block - start;
	     i < sbi->s_itb_per_group; i++, bit++, block++) {
		struct buffer_head *it;

E
Eric Sandeen 已提交
270
		ext4_debug("clear inode block %#04llx (+%d)\n", block, bit);
271 272 273 274

		if ((err = extend_or_restart_transaction(handle, 1, bh)))
			goto exit_bh;

275 276 277 278
		if (IS_ERR(it = bclean(handle, sb, block))) {
			err = PTR_ERR(it);
			goto exit_bh;
		}
279
		ext4_journal_dirty_metadata(handle, it);
280
		brelse(it);
281
		ext4_set_bit(bit, bh->b_data);
282
	}
283 284 285 286

	if ((err = extend_or_restart_transaction(handle, 2, bh)))
		goto exit_bh;

287
	mark_bitmap_end(input->blocks_count, EXT4_BLOCKS_PER_GROUP(sb),
288
			bh->b_data);
289
	ext4_journal_dirty_metadata(handle, bh);
290 291 292
	brelse(bh);

	/* Mark unused entries in inode bitmap used */
E
Eric Sandeen 已提交
293
	ext4_debug("clear inode bitmap %#04llx (+%llu)\n",
294 295 296 297 298 299
		   input->inode_bitmap, input->inode_bitmap - start);
	if (IS_ERR(bh = bclean(handle, sb, input->inode_bitmap))) {
		err = PTR_ERR(bh);
		goto exit_journal;
	}

300
	mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), EXT4_BLOCKS_PER_GROUP(sb),
301
			bh->b_data);
302
	ext4_journal_dirty_metadata(handle, bh);
303 304 305 306 307
exit_bh:
	brelse(bh);

exit_journal:
	unlock_super(sb);
308
	if ((err2 = ext4_journal_stop(handle)) && !err)
309 310 311 312 313 314 315
		err = err2;

	return err;
}

/*
 * Iterate through the groups which hold BACKUP superblock/GDT copies in an
316
 * ext4 filesystem.  The counters should be initialized to 1, 5, and 7 before
317 318 319 320
 * calling this for the first time.  In a sparse filesystem it will be the
 * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ...
 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ...
 */
321
static unsigned ext4_list_backups(struct super_block *sb, unsigned *three,
322 323 324 325 326 327
				  unsigned *five, unsigned *seven)
{
	unsigned *min = three;
	int mult = 3;
	unsigned ret;

328 329
	if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
					EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
		ret = *min;
		*min += 1;
		return ret;
	}

	if (*five < *min) {
		min = five;
		mult = 5;
	}
	if (*seven < *min) {
		min = seven;
		mult = 7;
	}

	ret = *min;
	*min *= mult;

	return ret;
}

/*
 * Check that all of the backup GDT blocks are held in the primary GDT block.
 * It is assumed that they are stored in group order.  Returns the number of
 * groups in current filesystem that have BACKUPS, or -ve error code.
 */
static int verify_reserved_gdb(struct super_block *sb,
			       struct buffer_head *primary)
{
358
	const ext4_fsblk_t blk = primary->b_blocknr;
359
	const ext4_group_t end = EXT4_SB(sb)->s_groups_count;
360 361 362 363 364 365 366
	unsigned three = 1;
	unsigned five = 5;
	unsigned seven = 7;
	unsigned grp;
	__le32 *p = (__le32 *)primary->b_data;
	int gdbackups = 0;

367
	while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) {
L
Laurent Vivier 已提交
368 369
		if (le32_to_cpu(*p++) !=
		    grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){
370
			ext4_warning(sb, __func__,
371 372
				     "reserved GDT %llu"
				     " missing grp %d (%llu)",
373
				     blk, grp,
L
Laurent Vivier 已提交
374 375 376
				     grp *
				     (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) +
				     blk);
377 378
			return -EINVAL;
		}
379
		if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb))
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
			return -EFBIG;
	}

	return gdbackups;
}

/*
 * Called when we need to bring a reserved group descriptor table block into
 * use from the resize inode.  The primary copy of the new GDT block currently
 * is an indirect block (under the double indirect block in the resize inode).
 * The new backup GDT blocks will be stored as leaf blocks in this indirect
 * block, in group order.  Even though we know all the block numbers we need,
 * we check to ensure that the resize inode has actually reserved these blocks.
 *
 * Don't need to update the block bitmaps because the blocks are still in use.
 *
 * We get all of the error cases out of the way, so that we are sure to not
 * fail once we start modifying the data on disk, because JBD has no rollback.
 */
static int add_new_gdb(handle_t *handle, struct inode *inode,
400
		       struct ext4_new_group_data *input,
401 402 403
		       struct buffer_head **primary)
{
	struct super_block *sb = inode->i_sb;
404 405 406
	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
	unsigned long gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb);
	ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num;
407 408 409
	struct buffer_head **o_group_desc, **n_group_desc;
	struct buffer_head *dind;
	int gdbackups;
410
	struct ext4_iloc iloc;
411 412 413 414 415
	__le32 *data;
	int err;

	if (test_opt(sb, DEBUG))
		printk(KERN_DEBUG
416
		       "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n",
417 418
		       gdb_num);

419 420 421 422 423
        /*
         * If we are not using the primary superblock/GDT copy don't resize,
         * because the user tools have no way of handling this.  Probably a
         * bad time to do it anyways.
         */
424 425
	if (EXT4_SB(sb)->s_sbh->b_blocknr !=
	    le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) {
426
		ext4_warning(sb, __func__,
427
			"won't resize using backup superblock at %llu",
428
			(unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr);
429 430 431 432 433 434 435 436 437 438 439 440
		return -EPERM;
	}

	*primary = sb_bread(sb, gdblock);
	if (!*primary)
		return -EIO;

	if ((gdbackups = verify_reserved_gdb(sb, *primary)) < 0) {
		err = gdbackups;
		goto exit_bh;
	}

441
	data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK;
442 443 444 445 446 447 448
	dind = sb_bread(sb, le32_to_cpu(*data));
	if (!dind) {
		err = -EIO;
		goto exit_bh;
	}

	data = (__le32 *)dind->b_data;
449
	if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) {
450
		ext4_warning(sb, __func__,
451
			     "new group %u GDT block %llu not reserved",
452 453 454 455 456
			     input->group, gdblock);
		err = -EINVAL;
		goto exit_dind;
	}

457
	if ((err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh)))
458 459
		goto exit_dind;

460
	if ((err = ext4_journal_get_write_access(handle, *primary)))
461 462
		goto exit_sbh;

463
	if ((err = ext4_journal_get_write_access(handle, dind)))
464 465
		goto exit_primary;

466 467
	/* ext4_reserve_inode_write() gets a reference on the iloc */
	if ((err = ext4_reserve_inode_write(handle, inode, &iloc)))
468 469 470
		goto exit_dindj;

	n_group_desc = kmalloc((gdb_num + 1) * sizeof(struct buffer_head *),
471
			GFP_NOFS);
472 473
	if (!n_group_desc) {
		err = -ENOMEM;
474
		ext4_warning(sb, __func__,
475 476 477 478 479 480 481 482 483 484 485 486 487
			      "not enough memory for %lu groups", gdb_num + 1);
		goto exit_inode;
	}

	/*
	 * Finally, we have all of the possible failures behind us...
	 *
	 * Remove new GDT block from inode double-indirect block and clear out
	 * the new GDT block for use (which also "frees" the backup GDT blocks
	 * from the reserved inode).  We don't need to change the bitmaps for
	 * these blocks, because they are marked as in-use from being in the
	 * reserved inode, and will become GDT blocks (primary and backup).
	 */
488 489
	data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)] = 0;
	ext4_journal_dirty_metadata(handle, dind);
490 491
	brelse(dind);
	inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9;
492
	ext4_mark_iloc_dirty(handle, inode, &iloc);
493
	memset((*primary)->b_data, 0, sb->s_blocksize);
494
	ext4_journal_dirty_metadata(handle, *primary);
495

496
	o_group_desc = EXT4_SB(sb)->s_group_desc;
497
	memcpy(n_group_desc, o_group_desc,
498
	       EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *));
499
	n_group_desc[gdb_num] = *primary;
500 501
	EXT4_SB(sb)->s_group_desc = n_group_desc;
	EXT4_SB(sb)->s_gdb_count++;
502 503
	kfree(o_group_desc);

M
Marcin Slusarz 已提交
504
	le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
505
	ext4_journal_dirty_metadata(handle, EXT4_SB(sb)->s_sbh);
506 507 508 509

	return 0;

exit_inode:
510
	/* ext4_journal_release_buffer(handle, iloc.bh); */
511 512
	brelse(iloc.bh);
exit_dindj:
513
	/* ext4_journal_release_buffer(handle, dind); */
514
exit_primary:
515
	/* ext4_journal_release_buffer(handle, *primary); */
516
exit_sbh:
517
	/* ext4_journal_release_buffer(handle, *primary); */
518 519 520 521 522
exit_dind:
	brelse(dind);
exit_bh:
	brelse(*primary);

523
	ext4_debug("leaving with error %d\n", err);
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
	return err;
}

/*
 * Called when we are adding a new group which has a backup copy of each of
 * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks.
 * We need to add these reserved backup GDT blocks to the resize inode, so
 * that they are kept for future resizing and not allocated to files.
 *
 * Each reserved backup GDT block will go into a different indirect block.
 * The indirect blocks are actually the primary reserved GDT blocks,
 * so we know in advance what their block numbers are.  We only get the
 * double-indirect block to verify it is pointing to the primary reserved
 * GDT blocks so we don't overwrite a data block by accident.  The reserved
 * backup GDT blocks are stored in their reserved primary GDT block.
 */
static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
541
			      struct ext4_new_group_data *input)
542 543
{
	struct super_block *sb = inode->i_sb;
544
	int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks);
545 546
	struct buffer_head **primary;
	struct buffer_head *dind;
547 548
	struct ext4_iloc iloc;
	ext4_fsblk_t blk;
549 550 551 552 553
	__le32 *data, *end;
	int gdbackups = 0;
	int res, i;
	int err;

554
	primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS);
555 556 557
	if (!primary)
		return -ENOMEM;

558
	data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK;
559 560 561 562 563 564
	dind = sb_bread(sb, le32_to_cpu(*data));
	if (!dind) {
		err = -EIO;
		goto exit_free;
	}

565
	blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count;
J
Josef Bacik 已提交
566 567
	data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count %
					 EXT4_ADDR_PER_BLOCK(sb));
568
	end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb);
569 570 571 572

	/* Get each reserved primary GDT block and verify it holds backups */
	for (res = 0; res < reserved_gdb; res++, blk++) {
		if (le32_to_cpu(*data) != blk) {
573
			ext4_warning(sb, __func__,
574
				     "reserved block %llu"
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
				     " not at offset %ld",
				     blk,
				     (long)(data - (__le32 *)dind->b_data));
			err = -EINVAL;
			goto exit_bh;
		}
		primary[res] = sb_bread(sb, blk);
		if (!primary[res]) {
			err = -EIO;
			goto exit_bh;
		}
		if ((gdbackups = verify_reserved_gdb(sb, primary[res])) < 0) {
			brelse(primary[res]);
			err = gdbackups;
			goto exit_bh;
		}
		if (++data >= end)
			data = (__le32 *)dind->b_data;
	}

	for (i = 0; i < reserved_gdb; i++) {
596
		if ((err = ext4_journal_get_write_access(handle, primary[i]))) {
597 598 599
			/*
			int j;
			for (j = 0; j < i; j++)
600
				ext4_journal_release_buffer(handle, primary[j]);
601 602 603 604 605
			 */
			goto exit_bh;
		}
	}

606
	if ((err = ext4_reserve_inode_write(handle, inode, &iloc)))
607 608 609 610 611 612
		goto exit_bh;

	/*
	 * Finally we can add each of the reserved backup GDT blocks from
	 * the new group to its reserved primary GDT block.
	 */
613
	blk = input->group * EXT4_BLOCKS_PER_GROUP(sb);
614 615 616 617 618 619 620
	for (i = 0; i < reserved_gdb; i++) {
		int err2;
		data = (__le32 *)primary[i]->b_data;
		/* printk("reserving backup %lu[%u] = %lu\n",
		       primary[i]->b_blocknr, gdbackups,
		       blk + primary[i]->b_blocknr); */
		data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr);
621
		err2 = ext4_journal_dirty_metadata(handle, primary[i]);
622 623 624 625
		if (!err)
			err = err2;
	}
	inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9;
626
	ext4_mark_iloc_dirty(handle, inode, &iloc);
627 628 629 630 631 632 633 634 635 636 637 638 639

exit_bh:
	while (--res >= 0)
		brelse(primary[res]);
	brelse(dind);

exit_free:
	kfree(primary);

	return err;
}

/*
640
 * Update the backup copies of the ext4 metadata.  These don't need to be part
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
 * of the main resize transaction, because e2fsck will re-write them if there
 * is a problem (basically only OOM will cause a problem).  However, we
 * _should_ update the backups if possible, in case the primary gets trashed
 * for some reason and we need to run e2fsck from a backup superblock.  The
 * important part is that the new block and inode counts are in the backup
 * superblocks, and the location of the new group metadata in the GDT backups.
 *
 * We do not need lock_super() for this, because these blocks are not
 * otherwise touched by the filesystem code when it is mounted.  We don't
 * need to worry about last changing from sbi->s_groups_count, because the
 * worst that can happen is that we do not copy the full number of backups
 * at this time.  The resize which changed s_groups_count will backup again.
 */
static void update_backups(struct super_block *sb,
			   int blk_off, char *data, int size)
{
657
	struct ext4_sb_info *sbi = EXT4_SB(sb);
658
	const ext4_group_t last = sbi->s_groups_count;
659
	const int bpg = EXT4_BLOCKS_PER_GROUP(sb);
660 661 662
	unsigned three = 1;
	unsigned five = 5;
	unsigned seven = 7;
663
	ext4_group_t group;
664 665 666 667
	int rest = sb->s_blocksize - size;
	handle_t *handle;
	int err = 0, err2;

668
	handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA);
669 670 671 672 673 674
	if (IS_ERR(handle)) {
		group = 1;
		err = PTR_ERR(handle);
		goto exit_err;
	}

675
	while ((group = ext4_list_backups(sb, &three, &five, &seven)) < last) {
676 677 678 679
		struct buffer_head *bh;

		/* Out of journal space, and can't get more - abort - so sad */
		if (handle->h_buffer_credits == 0 &&
680 681
		    ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) &&
		    (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA)))
682 683 684 685 686 687 688
			break;

		bh = sb_getblk(sb, group * bpg + blk_off);
		if (!bh) {
			err = -EIO;
			break;
		}
689
		ext4_debug("update metadata backup %#04lx\n",
690
			  (unsigned long)bh->b_blocknr);
691
		if ((err = ext4_journal_get_write_access(handle, bh)))
692 693 694 695 696 697 698
			break;
		lock_buffer(bh);
		memcpy(bh->b_data, data, size);
		if (rest)
			memset(bh->b_data + size, 0, rest);
		set_buffer_uptodate(bh);
		unlock_buffer(bh);
699
		ext4_journal_dirty_metadata(handle, bh);
700 701
		brelse(bh);
	}
702
	if ((err2 = ext4_journal_stop(handle)) && !err)
703 704 705 706 707 708 709 710 711 712 713 714 715 716
		err = err2;

	/*
	 * Ugh! Need to have e2fsck write the backup copies.  It is too
	 * late to revert the resize, we shouldn't fail just because of
	 * the backup copies (they are only needed in case of corruption).
	 *
	 * However, if we got here we have a journal problem too, so we
	 * can't really start a transaction to mark the superblock.
	 * Chicken out and just set the flag on the hope it will be written
	 * to disk, and if not - we will simply wait until next fsck.
	 */
exit_err:
	if (err) {
717
		ext4_warning(sb, __func__,
718
			     "can't update backup for group %lu (err %d), "
719
			     "forcing fsck on next reboot", group, err);
720 721
		sbi->s_mount_state &= ~EXT4_VALID_FS;
		sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
		mark_buffer_dirty(sbi->s_sbh);
	}
}

/* Add group descriptor data to an existing or new group descriptor block.
 * Ensure we handle all possible error conditions _before_ we start modifying
 * the filesystem, because we cannot abort the transaction and not have it
 * write the data to disk.
 *
 * If we are on a GDT block boundary, we need to get the reserved GDT block.
 * Otherwise, we may need to add backup GDT blocks for a sparse group.
 *
 * We only need to hold the superblock lock while we are actually adding
 * in the new group's counts to the superblock.  Prior to that we have
 * not really "added" the group at all.  We re-check that we are still
 * adding in the last group in case things have changed since verifying.
 */
739
int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
740
{
741 742 743
	struct ext4_sb_info *sbi = EXT4_SB(sb);
	struct ext4_super_block *es = sbi->s_es;
	int reserved_gdb = ext4_bg_has_super(sb, input->group) ?
744 745
		le16_to_cpu(es->s_reserved_gdt_blocks) : 0;
	struct buffer_head *primary = NULL;
746
	struct ext4_group_desc *gdp;
747 748 749 750 751
	struct inode *inode = NULL;
	handle_t *handle;
	int gdb_off, gdb_num;
	int err, err2;

752 753
	gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb);
	gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb);
754

755 756
	if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb,
					EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
757
		ext4_warning(sb, __func__,
758 759 760 761
			     "Can't resize non-sparse filesystem further");
		return -EPERM;
	}

L
Laurent Vivier 已提交
762 763
	if (ext4_blocks_count(es) + input->blocks_count <
	    ext4_blocks_count(es)) {
764
		ext4_warning(sb, __func__, "blocks_count overflow\n");
765 766 767
		return -EINVAL;
	}

768
	if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) <
769
	    le32_to_cpu(es->s_inodes_count)) {
770
		ext4_warning(sb, __func__, "inodes_count overflow\n");
771 772 773 774
		return -EINVAL;
	}

	if (reserved_gdb || gdb_off == 0) {
775 776
		if (!EXT4_HAS_COMPAT_FEATURE(sb,
					     EXT4_FEATURE_COMPAT_RESIZE_INODE)){
777
			ext4_warning(sb, __func__,
778 779 780
				     "No reserved GDT blocks, can't resize");
			return -EPERM;
		}
781 782
		inode = ext4_iget(sb, EXT4_RESIZE_INO);
		if (IS_ERR(inode)) {
783
			ext4_warning(sb, __func__,
784
				     "Error opening resize inode");
785
			return PTR_ERR(inode);
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
		}
	}

	if ((err = verify_group_input(sb, input)))
		goto exit_put;

	if ((err = setup_new_group_blocks(sb, input)))
		goto exit_put;

	/*
	 * We will always be modifying at least the superblock and a GDT
	 * block.  If we are adding a group past the last current GDT block,
	 * we will also modify the inode and the dindirect block.  If we
	 * are adding a group with superblock/GDT backups  we will also
	 * modify each of the reserved GDT dindirect blocks.
	 */
802 803
	handle = ext4_journal_start_sb(sb,
				       ext4_bg_has_super(sb, input->group) ?
804 805 806 807 808 809 810 811
				       3 + reserved_gdb : 4);
	if (IS_ERR(handle)) {
		err = PTR_ERR(handle);
		goto exit_put;
	}

	lock_super(sb);
	if (input->group != sbi->s_groups_count) {
812
		ext4_warning(sb, __func__,
813 814 815 816 817
			     "multiple resizers run on filesystem!");
		err = -EBUSY;
		goto exit_journal;
	}

818
	if ((err = ext4_journal_get_write_access(handle, sbi->s_sbh)))
819 820
		goto exit_journal;

821 822 823 824 825 826
        /*
         * We will only either add reserved group blocks to a backup group
         * or remove reserved blocks for the first group in a new group block.
         * Doing both would be mean more complex code, and sane people don't
         * use non-sparse filesystems anymore.  This is already checked above.
         */
827 828
	if (gdb_off) {
		primary = sbi->s_group_desc[gdb_num];
829
		if ((err = ext4_journal_get_write_access(handle, primary)))
830 831
			goto exit_journal;

832
		if (reserved_gdb && ext4_bg_num_gdb(sb, input->group) &&
833 834 835 836 837
		    (err = reserve_backup_gdb(handle, inode, input)))
			goto exit_journal;
	} else if ((err = add_new_gdb(handle, inode, input, &primary)))
		goto exit_journal;

838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
        /*
         * OK, now we've set up the new group.  Time to make it active.
         *
         * Current kernels don't lock all allocations via lock_super(),
         * so we have to be safe wrt. concurrent accesses the group
         * data.  So we need to be careful to set all of the relevant
         * group descriptor data etc. *before* we enable the group.
         *
         * The key field here is sbi->s_groups_count: as long as
         * that retains its old value, nobody is going to access the new
         * group.
         *
         * So first we update all the descriptor metadata for the new
         * group; then we update the total disk blocks count; then we
         * update the groups count to enable the group; then finally we
         * update the free space counts so that the system can start
         * using the new disk blocks.
         */
856 857

	/* Update group descriptor block for new group */
858 859
	gdp = (struct ext4_group_desc *)((char *)primary->b_data +
					 gdb_off * EXT4_DESC_SIZE(sb));
860

861 862 863
	ext4_block_bitmap_set(sb, gdp, input->block_bitmap); /* LV FIXME */
	ext4_inode_bitmap_set(sb, gdp, input->inode_bitmap); /* LV FIXME */
	ext4_inode_table_set(sb, gdp, input->inode_table); /* LV FIXME */
864
	gdp->bg_free_blocks_count = cpu_to_le16(input->free_blocks_count);
865
	gdp->bg_free_inodes_count = cpu_to_le16(EXT4_INODES_PER_GROUP(sb));
A
Andreas Dilger 已提交
866
	gdp->bg_checksum = ext4_group_desc_csum(sbi, input->group, gdp);
867

868 869 870 871 872 873 874 875 876
	/*
	 * We can allocate memory for mb_alloc based on the new group
	 * descriptor
	 */
	if (test_opt(sb, MBALLOC)) {
		err = ext4_mb_add_more_groupinfo(sb, input->group, gdp);
		if (err)
			goto exit_journal;
	}
877 878 879 880 881 882 883 884 885 886
	/*
	 * Make the new blocks and inodes valid next.  We do this before
	 * increasing the group count so that once the group is enabled,
	 * all of its blocks and inodes are already valid.
	 *
	 * We always allocate group-by-group, then block-by-block or
	 * inode-by-inode within a group, so enabling these
	 * blocks/inodes before the group is live won't actually let us
	 * allocate the new space yet.
	 */
L
Laurent Vivier 已提交
887
	ext4_blocks_count_set(es, ext4_blocks_count(es) +
888
		input->blocks_count);
M
Marcin Slusarz 已提交
889
	le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb));
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917

	/*
	 * We need to protect s_groups_count against other CPUs seeing
	 * inconsistent state in the superblock.
	 *
	 * The precise rules we use are:
	 *
	 * * Writers of s_groups_count *must* hold lock_super
	 * AND
	 * * Writers must perform a smp_wmb() after updating all dependent
	 *   data and before modifying the groups count
	 *
	 * * Readers must hold lock_super() over the access
	 * OR
	 * * Readers must perform an smp_rmb() after reading the groups count
	 *   and before reading any dependent data.
	 *
	 * NB. These rules can be relaxed when checking the group count
	 * while freeing data, as we can only allocate from a block
	 * group after serialising against the group count, and we can
	 * only then free after serialising in turn against that
	 * allocation.
	 */
	smp_wmb();

	/* Update the global fs size fields */
	sbi->s_groups_count++;

918
	ext4_journal_dirty_metadata(handle, primary);
919 920 921

	/* Update the reserved block counts only once the new group is
	 * active. */
L
Laurent Vivier 已提交
922
	ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) +
923 924 925
		input->reserved_blocks);

	/* Update the free space counts */
P
Peter Zijlstra 已提交
926
	percpu_counter_add(&sbi->s_freeblocks_counter,
927
			   input->free_blocks_count);
P
Peter Zijlstra 已提交
928
	percpu_counter_add(&sbi->s_freeinodes_counter,
929
			   EXT4_INODES_PER_GROUP(sb));
930

931
	ext4_journal_dirty_metadata(handle, sbi->s_sbh);
932 933 934 935
	sb->s_dirt = 1;

exit_journal:
	unlock_super(sb);
936
	if ((err2 = ext4_journal_stop(handle)) && !err)
937 938 939
		err = err2;
	if (!err) {
		update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es,
940
			       sizeof(struct ext4_super_block));
941 942 943 944 945 946
		update_backups(sb, primary->b_blocknr, primary->b_data,
			       primary->b_size);
	}
exit_put:
	iput(inode);
	return err;
947
} /* ext4_group_add */
948

949 950
/*
 * Extend the filesystem to the new number of blocks specified.  This entry
951 952 953 954
 * point is only used to extend the current filesystem to the end of the last
 * existing group.  It can be accessed via ioctl, or by "remount,resize=<size>"
 * for emergencies (because it has no dependencies on reserved blocks).
 *
955
 * If we _really_ wanted, we could use default values to call ext4_group_add()
956 957 958
 * allow the "remount" trick to work for arbitrary resizing, assuming enough
 * GDT blocks are reserved to grow to the desired size.
 */
959 960
int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
		      ext4_fsblk_t n_blocks_count)
961
{
962
	ext4_fsblk_t o_blocks_count;
963
	ext4_group_t o_groups_count;
964 965
	ext4_grpblk_t last;
	ext4_grpblk_t add;
966 967 968 969
	struct buffer_head * bh;
	handle_t *handle;
	int err;
	unsigned long freed_blocks;
970 971
	ext4_group_t group;
	struct ext4_group_info *grp;
972 973 974 975

	/* We don't need to worry about locking wrt other resizers just
	 * yet: we're going to revalidate es->s_blocks_count after
	 * taking lock_super() below. */
L
Laurent Vivier 已提交
976
	o_blocks_count = ext4_blocks_count(es);
977
	o_groups_count = EXT4_SB(sb)->s_groups_count;
978 979

	if (test_opt(sb, DEBUG))
980
		printk(KERN_DEBUG "EXT4-fs: extending last group from %llu uto %llu blocks\n",
981 982 983 984 985 986
		       o_blocks_count, n_blocks_count);

	if (n_blocks_count == 0 || n_blocks_count == o_blocks_count)
		return 0;

	if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
987
		printk(KERN_ERR "EXT4-fs: filesystem on %s:"
988
			" too large to resize to %llu blocks safely\n",
989 990
			sb->s_id, n_blocks_count);
		if (sizeof(sector_t) < 8)
991
			ext4_warning(sb, __func__,
992 993 994 995 996
			"CONFIG_LBD not enabled\n");
		return -EINVAL;
	}

	if (n_blocks_count < o_blocks_count) {
997
		ext4_warning(sb, __func__,
998 999 1000 1001 1002
			     "can't shrink FS - resize aborted");
		return -EBUSY;
	}

	/* Handle the remaining blocks in the last group only. */
1003
	ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last);
1004 1005

	if (last == 0) {
1006
		ext4_warning(sb, __func__,
1007 1008 1009 1010
			     "need to use ext2online to resize further");
		return -EPERM;
	}

1011
	add = EXT4_BLOCKS_PER_GROUP(sb) - last;
1012 1013

	if (o_blocks_count + add < o_blocks_count) {
1014
		ext4_warning(sb, __func__, "blocks_count overflow");
1015 1016 1017 1018 1019 1020 1021
		return -EINVAL;
	}

	if (o_blocks_count + add > n_blocks_count)
		add = n_blocks_count - o_blocks_count;

	if (o_blocks_count + add < n_blocks_count)
1022
		ext4_warning(sb, __func__,
1023
			     "will only finish group (%llu"
1024 1025 1026 1027
			     " blocks, %u new)",
			     o_blocks_count + add, add);

	/* See if the device is actually as big as what was requested */
1028
	bh = sb_bread(sb, o_blocks_count + add - 1);
1029
	if (!bh) {
1030
		ext4_warning(sb, __func__,
1031 1032 1033 1034 1035 1036
			     "can't read last block, resize aborted");
		return -ENOSPC;
	}
	brelse(bh);

	/* We will update the superblock, one block bitmap, and
1037
	 * one group descriptor via ext4_free_blocks().
1038
	 */
1039
	handle = ext4_journal_start_sb(sb, 3);
1040 1041
	if (IS_ERR(handle)) {
		err = PTR_ERR(handle);
1042
		ext4_warning(sb, __func__, "error %d on journal start", err);
1043 1044 1045 1046
		goto exit_put;
	}

	lock_super(sb);
L
Laurent Vivier 已提交
1047
	if (o_blocks_count != ext4_blocks_count(es)) {
1048
		ext4_warning(sb, __func__,
1049 1050
			     "multiple resizers run on filesystem!");
		unlock_super(sb);
1051
		ext4_journal_stop(handle);
1052 1053 1054 1055
		err = -EBUSY;
		goto exit_put;
	}

1056 1057
	if ((err = ext4_journal_get_write_access(handle,
						 EXT4_SB(sb)->s_sbh))) {
1058
		ext4_warning(sb, __func__,
1059 1060
			     "error %d on journal write access", err);
		unlock_super(sb);
1061
		ext4_journal_stop(handle);
1062 1063
		goto exit_put;
	}
L
Laurent Vivier 已提交
1064
	ext4_blocks_count_set(es, o_blocks_count + add);
1065
	ext4_journal_dirty_metadata(handle, EXT4_SB(sb)->s_sbh);
1066 1067
	sb->s_dirt = 1;
	unlock_super(sb);
E
Eric Sandeen 已提交
1068
	ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
1069
		   o_blocks_count + add);
1070
	ext4_free_blocks_sb(handle, sb, o_blocks_count, add, &freed_blocks);
1071
	ext4_debug("freed blocks %llu through %llu\n", o_blocks_count,
1072
		   o_blocks_count + add);
1073
	if ((err = ext4_journal_stop(handle)))
1074
		goto exit_put;
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113

	/*
	 * Mark mballoc pages as not up to date so that they will be updated
	 * next time they are loaded by ext4_mb_load_buddy.
	 */
	if (test_opt(sb, MBALLOC)) {
		struct ext4_sb_info *sbi = EXT4_SB(sb);
		struct inode *inode = sbi->s_buddy_cache;
		int blocks_per_page;
		int block;
		int pnum;
		struct page *page;

		/* Set buddy page as not up to date */
		blocks_per_page = PAGE_CACHE_SIZE / sb->s_blocksize;
		block = group * 2;
		pnum = block / blocks_per_page;
		page = find_get_page(inode->i_mapping, pnum);
		if (page != NULL) {
			ClearPageUptodate(page);
			page_cache_release(page);
		}

		/* Set bitmap page as not up to date */
		block++;
		pnum = block / blocks_per_page;
		page = find_get_page(inode->i_mapping, pnum);
		if (page != NULL) {
			ClearPageUptodate(page);
			page_cache_release(page);
		}

		/* Get the info on the last group */
		grp = ext4_get_group_info(sb, group);

		/* Update free blocks in group info */
		ext4_mb_update_group_info(grp, add);
	}

1114
	if (test_opt(sb, DEBUG))
L
Laurent Vivier 已提交
1115 1116
		printk(KERN_DEBUG "EXT4-fs: extended group to %llu blocks\n",
		       ext4_blocks_count(es));
1117 1118
	update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr, (char *)es,
		       sizeof(struct ext4_super_block));
1119 1120
exit_put:
	return err;
1121
} /* ext4_group_extend */