1 /* 2 * linux/fs/ext4/resize.c 3 * 4 * Support for resizing an ext4 filesystem while it is mounted. 5 * 6 * Copyright (C) 2001, 2002 Andreas Dilger <adilger@clusterfs.com> 7 * 8 * This could probably be made into a module, because it is not often in use. 9 */ 10 11 12 #define EXT4FS_DEBUG 13 14 #include <linux/errno.h> 15 #include <linux/slab.h> 16 17 #include "ext4_jbd2.h" 18 19 int ext4_resize_begin(struct super_block *sb) 20 { 21 int ret = 0; 22 23 if (!capable(CAP_SYS_RESOURCE)) 24 return -EPERM; 25 26 /* 27 * We are not allowed to do online-resizing on a filesystem mounted 28 * with error, because it can destroy the filesystem easily. 29 */ 30 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) { 31 ext4_warning(sb, "There are errors in the filesystem, " 32 "so online resizing is not allowed\n"); 33 return -EPERM; 34 } 35 36 if (test_and_set_bit_lock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags)) 37 ret = -EBUSY; 38 39 return ret; 40 } 41 42 void ext4_resize_end(struct super_block *sb) 43 { 44 clear_bit_unlock(EXT4_RESIZING, &EXT4_SB(sb)->s_resize_flags); 45 smp_mb__after_clear_bit(); 46 } 47 48 static ext4_group_t ext4_meta_bg_first_group(struct super_block *sb, 49 ext4_group_t group) { 50 return (group >> EXT4_DESC_PER_BLOCK_BITS(sb)) << 51 EXT4_DESC_PER_BLOCK_BITS(sb); 52 } 53 54 static ext4_fsblk_t ext4_meta_bg_first_block_no(struct super_block *sb, 55 ext4_group_t group) { 56 group = ext4_meta_bg_first_group(sb, group); 57 return ext4_group_first_block_no(sb, group); 58 } 59 60 static ext4_grpblk_t ext4_group_overhead_blocks(struct super_block *sb, 61 ext4_group_t group) { 62 ext4_grpblk_t overhead; 63 overhead = ext4_bg_num_gdb(sb, group); 64 if (ext4_bg_has_super(sb, group)) 65 overhead += 1 + 66 le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); 67 return overhead; 68 } 69 70 #define outside(b, first, last) ((b) < (first) || (b) >= (last)) 71 #define inside(b, first, last) ((b) >= (first) && (b) < (last)) 72 73 static int verify_group_input(struct super_block *sb, 74 struct ext4_new_group_data *input) 75 { 76 struct ext4_sb_info *sbi = EXT4_SB(sb); 77 struct ext4_super_block *es = sbi->s_es; 78 ext4_fsblk_t start = ext4_blocks_count(es); 79 ext4_fsblk_t end = start + input->blocks_count; 80 ext4_group_t group = input->group; 81 ext4_fsblk_t itend = input->inode_table + sbi->s_itb_per_group; 82 unsigned overhead = ext4_group_overhead_blocks(sb, group); 83 ext4_fsblk_t metaend = start + overhead; 84 struct buffer_head *bh = NULL; 85 ext4_grpblk_t free_blocks_count, offset; 86 int err = -EINVAL; 87 88 input->free_blocks_count = free_blocks_count = 89 input->blocks_count - 2 - overhead - sbi->s_itb_per_group; 90 91 if (test_opt(sb, DEBUG)) 92 printk(KERN_DEBUG "EXT4-fs: adding %s group %u: %u blocks " 93 "(%d free, %u reserved)\n", 94 ext4_bg_has_super(sb, input->group) ? "normal" : 95 "no-super", input->group, input->blocks_count, 96 free_blocks_count, input->reserved_blocks); 97 98 ext4_get_group_no_and_offset(sb, start, NULL, &offset); 99 if (group != sbi->s_groups_count) 100 ext4_warning(sb, "Cannot add at group %u (only %u groups)", 101 input->group, sbi->s_groups_count); 102 else if (offset != 0) 103 ext4_warning(sb, "Last group not full"); 104 else if (input->reserved_blocks > input->blocks_count / 5) 105 ext4_warning(sb, "Reserved blocks too high (%u)", 106 input->reserved_blocks); 107 else if (free_blocks_count < 0) 108 ext4_warning(sb, "Bad blocks count %u", 109 input->blocks_count); 110 else if (!(bh = sb_bread(sb, end - 1))) 111 ext4_warning(sb, "Cannot read last block (%llu)", 112 end - 1); 113 else if (outside(input->block_bitmap, start, end)) 114 ext4_warning(sb, "Block bitmap not in group (block %llu)", 115 (unsigned long long)input->block_bitmap); 116 else if (outside(input->inode_bitmap, start, end)) 117 ext4_warning(sb, "Inode bitmap not in group (block %llu)", 118 (unsigned long long)input->inode_bitmap); 119 else if (outside(input->inode_table, start, end) || 120 outside(itend - 1, start, end)) 121 ext4_warning(sb, "Inode table not in group (blocks %llu-%llu)", 122 (unsigned long long)input->inode_table, itend - 1); 123 else if (input->inode_bitmap == input->block_bitmap) 124 ext4_warning(sb, "Block bitmap same as inode bitmap (%llu)", 125 (unsigned long long)input->block_bitmap); 126 else if (inside(input->block_bitmap, input->inode_table, itend)) 127 ext4_warning(sb, "Block bitmap (%llu) in inode table " 128 "(%llu-%llu)", 129 (unsigned long long)input->block_bitmap, 130 (unsigned long long)input->inode_table, itend - 1); 131 else if (inside(input->inode_bitmap, input->inode_table, itend)) 132 ext4_warning(sb, "Inode bitmap (%llu) in inode table " 133 "(%llu-%llu)", 134 (unsigned long long)input->inode_bitmap, 135 (unsigned long long)input->inode_table, itend - 1); 136 else if (inside(input->block_bitmap, start, metaend)) 137 ext4_warning(sb, "Block bitmap (%llu) in GDT table (%llu-%llu)", 138 (unsigned long long)input->block_bitmap, 139 start, metaend - 1); 140 else if (inside(input->inode_bitmap, start, metaend)) 141 ext4_warning(sb, "Inode bitmap (%llu) in GDT table (%llu-%llu)", 142 (unsigned long long)input->inode_bitmap, 143 start, metaend - 1); 144 else if (inside(input->inode_table, start, metaend) || 145 inside(itend - 1, start, metaend)) 146 ext4_warning(sb, "Inode table (%llu-%llu) overlaps GDT table " 147 "(%llu-%llu)", 148 (unsigned long long)input->inode_table, 149 itend - 1, start, metaend - 1); 150 else 151 err = 0; 152 brelse(bh); 153 154 return err; 155 } 156 157 /* 158 * ext4_new_flex_group_data is used by 64bit-resize interface to add a flex 159 * group each time. 160 */ 161 struct ext4_new_flex_group_data { 162 struct ext4_new_group_data *groups; /* new_group_data for groups 163 in the flex group */ 164 __u16 *bg_flags; /* block group flags of groups 165 in @groups */ 166 ext4_group_t count; /* number of groups in @groups 167 */ 168 }; 169 170 /* 171 * alloc_flex_gd() allocates a ext4_new_flex_group_data with size of 172 * @flexbg_size. 173 * 174 * Returns NULL on failure otherwise address of the allocated structure. 175 */ 176 static struct ext4_new_flex_group_data *alloc_flex_gd(unsigned long flexbg_size) 177 { 178 struct ext4_new_flex_group_data *flex_gd; 179 180 flex_gd = kmalloc(sizeof(*flex_gd), GFP_NOFS); 181 if (flex_gd == NULL) 182 goto out3; 183 184 if (flexbg_size >= UINT_MAX / sizeof(struct ext4_new_flex_group_data)) 185 goto out2; 186 flex_gd->count = flexbg_size; 187 188 flex_gd->groups = kmalloc(sizeof(struct ext4_new_group_data) * 189 flexbg_size, GFP_NOFS); 190 if (flex_gd->groups == NULL) 191 goto out2; 192 193 flex_gd->bg_flags = kmalloc(flexbg_size * sizeof(__u16), GFP_NOFS); 194 if (flex_gd->bg_flags == NULL) 195 goto out1; 196 197 return flex_gd; 198 199 out1: 200 kfree(flex_gd->groups); 201 out2: 202 kfree(flex_gd); 203 out3: 204 return NULL; 205 } 206 207 static void free_flex_gd(struct ext4_new_flex_group_data *flex_gd) 208 { 209 kfree(flex_gd->bg_flags); 210 kfree(flex_gd->groups); 211 kfree(flex_gd); 212 } 213 214 /* 215 * ext4_alloc_group_tables() allocates block bitmaps, inode bitmaps 216 * and inode tables for a flex group. 217 * 218 * This function is used by 64bit-resize. Note that this function allocates 219 * group tables from the 1st group of groups contained by @flexgd, which may 220 * be a partial of a flex group. 221 * 222 * @sb: super block of fs to which the groups belongs 223 * 224 * Returns 0 on a successful allocation of the metadata blocks in the 225 * block group. 226 */ 227 static int ext4_alloc_group_tables(struct super_block *sb, 228 struct ext4_new_flex_group_data *flex_gd, 229 int flexbg_size) 230 { 231 struct ext4_new_group_data *group_data = flex_gd->groups; 232 ext4_fsblk_t start_blk; 233 ext4_fsblk_t last_blk; 234 ext4_group_t src_group; 235 ext4_group_t bb_index = 0; 236 ext4_group_t ib_index = 0; 237 ext4_group_t it_index = 0; 238 ext4_group_t group; 239 ext4_group_t last_group; 240 unsigned overhead; 241 242 BUG_ON(flex_gd->count == 0 || group_data == NULL); 243 244 src_group = group_data[0].group; 245 last_group = src_group + flex_gd->count - 1; 246 247 BUG_ON((flexbg_size > 1) && ((src_group & ~(flexbg_size - 1)) != 248 (last_group & ~(flexbg_size - 1)))); 249 next_group: 250 group = group_data[0].group; 251 if (src_group >= group_data[0].group + flex_gd->count) 252 return -ENOSPC; 253 start_blk = ext4_group_first_block_no(sb, src_group); 254 last_blk = start_blk + group_data[src_group - group].blocks_count; 255 256 overhead = ext4_group_overhead_blocks(sb, src_group); 257 258 start_blk += overhead; 259 260 /* We collect contiguous blocks as much as possible. */ 261 src_group++; 262 for (; src_group <= last_group; src_group++) { 263 overhead = ext4_group_overhead_blocks(sb, src_group); 264 if (overhead != 0) 265 last_blk += group_data[src_group - group].blocks_count; 266 else 267 break; 268 } 269 270 /* Allocate block bitmaps */ 271 for (; bb_index < flex_gd->count; bb_index++) { 272 if (start_blk >= last_blk) 273 goto next_group; 274 group_data[bb_index].block_bitmap = start_blk++; 275 ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL); 276 group -= group_data[0].group; 277 group_data[group].free_blocks_count--; 278 if (flexbg_size > 1) 279 flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT; 280 } 281 282 /* Allocate inode bitmaps */ 283 for (; ib_index < flex_gd->count; ib_index++) { 284 if (start_blk >= last_blk) 285 goto next_group; 286 group_data[ib_index].inode_bitmap = start_blk++; 287 ext4_get_group_no_and_offset(sb, start_blk - 1, &group, NULL); 288 group -= group_data[0].group; 289 group_data[group].free_blocks_count--; 290 if (flexbg_size > 1) 291 flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT; 292 } 293 294 /* Allocate inode tables */ 295 for (; it_index < flex_gd->count; it_index++) { 296 if (start_blk + EXT4_SB(sb)->s_itb_per_group > last_blk) 297 goto next_group; 298 group_data[it_index].inode_table = start_blk; 299 ext4_get_group_no_and_offset(sb, start_blk, &group, NULL); 300 group -= group_data[0].group; 301 group_data[group].free_blocks_count -= 302 EXT4_SB(sb)->s_itb_per_group; 303 if (flexbg_size > 1) 304 flex_gd->bg_flags[group] &= ~EXT4_BG_BLOCK_UNINIT; 305 306 start_blk += EXT4_SB(sb)->s_itb_per_group; 307 } 308 309 if (test_opt(sb, DEBUG)) { 310 int i; 311 group = group_data[0].group; 312 313 printk(KERN_DEBUG "EXT4-fs: adding a flex group with " 314 "%d groups, flexbg size is %d:\n", flex_gd->count, 315 flexbg_size); 316 317 for (i = 0; i < flex_gd->count; i++) { 318 printk(KERN_DEBUG "adding %s group %u: %u " 319 "blocks (%d free)\n", 320 ext4_bg_has_super(sb, group + i) ? "normal" : 321 "no-super", group + i, 322 group_data[i].blocks_count, 323 group_data[i].free_blocks_count); 324 } 325 } 326 return 0; 327 } 328 329 static struct buffer_head *bclean(handle_t *handle, struct super_block *sb, 330 ext4_fsblk_t blk) 331 { 332 struct buffer_head *bh; 333 int err; 334 335 bh = sb_getblk(sb, blk); 336 if (!bh) 337 return ERR_PTR(-EIO); 338 if ((err = ext4_journal_get_write_access(handle, bh))) { 339 brelse(bh); 340 bh = ERR_PTR(err); 341 } else { 342 memset(bh->b_data, 0, sb->s_blocksize); 343 set_buffer_uptodate(bh); 344 } 345 346 return bh; 347 } 348 349 /* 350 * If we have fewer than thresh credits, extend by EXT4_MAX_TRANS_DATA. 351 * If that fails, restart the transaction & regain write access for the 352 * buffer head which is used for block_bitmap modifications. 353 */ 354 static int extend_or_restart_transaction(handle_t *handle, int thresh) 355 { 356 int err; 357 358 if (ext4_handle_has_enough_credits(handle, thresh)) 359 return 0; 360 361 err = ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA); 362 if (err < 0) 363 return err; 364 if (err) { 365 err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA); 366 if (err) 367 return err; 368 } 369 370 return 0; 371 } 372 373 /* 374 * set_flexbg_block_bitmap() mark @count blocks starting from @block used. 375 * 376 * Helper function for ext4_setup_new_group_blocks() which set . 377 * 378 * @sb: super block 379 * @handle: journal handle 380 * @flex_gd: flex group data 381 */ 382 static int set_flexbg_block_bitmap(struct super_block *sb, handle_t *handle, 383 struct ext4_new_flex_group_data *flex_gd, 384 ext4_fsblk_t block, ext4_group_t count) 385 { 386 ext4_group_t count2; 387 388 ext4_debug("mark blocks [%llu/%u] used\n", block, count); 389 for (count2 = count; count > 0; count -= count2, block += count2) { 390 ext4_fsblk_t start; 391 struct buffer_head *bh; 392 ext4_group_t group; 393 int err; 394 395 ext4_get_group_no_and_offset(sb, block, &group, NULL); 396 start = ext4_group_first_block_no(sb, group); 397 group -= flex_gd->groups[0].group; 398 399 count2 = sb->s_blocksize * 8 - (block - start); 400 if (count2 > count) 401 count2 = count; 402 403 if (flex_gd->bg_flags[group] & EXT4_BG_BLOCK_UNINIT) { 404 BUG_ON(flex_gd->count > 1); 405 continue; 406 } 407 408 err = extend_or_restart_transaction(handle, 1); 409 if (err) 410 return err; 411 412 bh = sb_getblk(sb, flex_gd->groups[group].block_bitmap); 413 if (!bh) 414 return -EIO; 415 416 err = ext4_journal_get_write_access(handle, bh); 417 if (err) 418 return err; 419 ext4_debug("mark block bitmap %#04llx (+%llu/%u)\n", block, 420 block - start, count2); 421 ext4_set_bits(bh->b_data, block - start, count2); 422 423 err = ext4_handle_dirty_metadata(handle, NULL, bh); 424 if (unlikely(err)) 425 return err; 426 brelse(bh); 427 } 428 429 return 0; 430 } 431 432 /* 433 * Set up the block and inode bitmaps, and the inode table for the new groups. 434 * This doesn't need to be part of the main transaction, since we are only 435 * changing blocks outside the actual filesystem. We still do journaling to 436 * ensure the recovery is correct in case of a failure just after resize. 437 * If any part of this fails, we simply abort the resize. 438 * 439 * setup_new_flex_group_blocks handles a flex group as follow: 440 * 1. copy super block and GDT, and initialize group tables if necessary. 441 * In this step, we only set bits in blocks bitmaps for blocks taken by 442 * super block and GDT. 443 * 2. allocate group tables in block bitmaps, that is, set bits in block 444 * bitmap for blocks taken by group tables. 445 */ 446 static int setup_new_flex_group_blocks(struct super_block *sb, 447 struct ext4_new_flex_group_data *flex_gd) 448 { 449 int group_table_count[] = {1, 1, EXT4_SB(sb)->s_itb_per_group}; 450 ext4_fsblk_t start; 451 ext4_fsblk_t block; 452 struct ext4_sb_info *sbi = EXT4_SB(sb); 453 struct ext4_super_block *es = sbi->s_es; 454 struct ext4_new_group_data *group_data = flex_gd->groups; 455 __u16 *bg_flags = flex_gd->bg_flags; 456 handle_t *handle; 457 ext4_group_t group, count; 458 struct buffer_head *bh = NULL; 459 int reserved_gdb, i, j, err = 0, err2; 460 int meta_bg; 461 462 BUG_ON(!flex_gd->count || !group_data || 463 group_data[0].group != sbi->s_groups_count); 464 465 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); 466 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 467 468 /* This transaction may be extended/restarted along the way */ 469 handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 470 if (IS_ERR(handle)) 471 return PTR_ERR(handle); 472 473 group = group_data[0].group; 474 for (i = 0; i < flex_gd->count; i++, group++) { 475 unsigned long gdblocks; 476 ext4_grpblk_t overhead; 477 478 gdblocks = ext4_bg_num_gdb(sb, group); 479 start = ext4_group_first_block_no(sb, group); 480 481 if (meta_bg == 0 && !ext4_bg_has_super(sb, group)) 482 goto handle_itb; 483 484 if (meta_bg == 1) { 485 ext4_group_t first_group; 486 first_group = ext4_meta_bg_first_group(sb, group); 487 if (first_group != group + 1 && 488 first_group != group + EXT4_DESC_PER_BLOCK(sb) - 1) 489 goto handle_itb; 490 } 491 492 block = start + ext4_bg_has_super(sb, group); 493 /* Copy all of the GDT blocks into the backup in this group */ 494 for (j = 0; j < gdblocks; j++, block++) { 495 struct buffer_head *gdb; 496 497 ext4_debug("update backup group %#04llx\n", block); 498 err = extend_or_restart_transaction(handle, 1); 499 if (err) 500 goto out; 501 502 gdb = sb_getblk(sb, block); 503 if (!gdb) { 504 err = -EIO; 505 goto out; 506 } 507 508 err = ext4_journal_get_write_access(handle, gdb); 509 if (err) { 510 brelse(gdb); 511 goto out; 512 } 513 memcpy(gdb->b_data, sbi->s_group_desc[j]->b_data, 514 gdb->b_size); 515 set_buffer_uptodate(gdb); 516 517 err = ext4_handle_dirty_metadata(handle, NULL, gdb); 518 if (unlikely(err)) { 519 brelse(gdb); 520 goto out; 521 } 522 brelse(gdb); 523 } 524 525 /* Zero out all of the reserved backup group descriptor 526 * table blocks 527 */ 528 if (ext4_bg_has_super(sb, group)) { 529 err = sb_issue_zeroout(sb, gdblocks + start + 1, 530 reserved_gdb, GFP_NOFS); 531 if (err) 532 goto out; 533 } 534 535 handle_itb: 536 /* Initialize group tables of the grop @group */ 537 if (!(bg_flags[i] & EXT4_BG_INODE_ZEROED)) 538 goto handle_bb; 539 540 /* Zero out all of the inode table blocks */ 541 block = group_data[i].inode_table; 542 ext4_debug("clear inode table blocks %#04llx -> %#04lx\n", 543 block, sbi->s_itb_per_group); 544 err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group, 545 GFP_NOFS); 546 if (err) 547 goto out; 548 549 handle_bb: 550 if (bg_flags[i] & EXT4_BG_BLOCK_UNINIT) 551 goto handle_ib; 552 553 /* Initialize block bitmap of the @group */ 554 block = group_data[i].block_bitmap; 555 err = extend_or_restart_transaction(handle, 1); 556 if (err) 557 goto out; 558 559 bh = bclean(handle, sb, block); 560 if (IS_ERR(bh)) { 561 err = PTR_ERR(bh); 562 goto out; 563 } 564 overhead = ext4_group_overhead_blocks(sb, group); 565 if (overhead != 0) { 566 ext4_debug("mark backup superblock %#04llx (+0)\n", 567 start); 568 ext4_set_bits(bh->b_data, 0, overhead); 569 } 570 ext4_mark_bitmap_end(group_data[i].blocks_count, 571 sb->s_blocksize * 8, bh->b_data); 572 err = ext4_handle_dirty_metadata(handle, NULL, bh); 573 if (err) 574 goto out; 575 brelse(bh); 576 577 handle_ib: 578 if (bg_flags[i] & EXT4_BG_INODE_UNINIT) 579 continue; 580 581 /* Initialize inode bitmap of the @group */ 582 block = group_data[i].inode_bitmap; 583 err = extend_or_restart_transaction(handle, 1); 584 if (err) 585 goto out; 586 /* Mark unused entries in inode bitmap used */ 587 bh = bclean(handle, sb, block); 588 if (IS_ERR(bh)) { 589 err = PTR_ERR(bh); 590 goto out; 591 } 592 593 ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), 594 sb->s_blocksize * 8, bh->b_data); 595 err = ext4_handle_dirty_metadata(handle, NULL, bh); 596 if (err) 597 goto out; 598 brelse(bh); 599 } 600 bh = NULL; 601 602 /* Mark group tables in block bitmap */ 603 for (j = 0; j < GROUP_TABLE_COUNT; j++) { 604 count = group_table_count[j]; 605 start = (&group_data[0].block_bitmap)[j]; 606 block = start; 607 for (i = 1; i < flex_gd->count; i++) { 608 block += group_table_count[j]; 609 if (block == (&group_data[i].block_bitmap)[j]) { 610 count += group_table_count[j]; 611 continue; 612 } 613 err = set_flexbg_block_bitmap(sb, handle, 614 flex_gd, start, count); 615 if (err) 616 goto out; 617 count = group_table_count[j]; 618 start = group_data[i].block_bitmap; 619 block = start; 620 } 621 622 if (count) { 623 err = set_flexbg_block_bitmap(sb, handle, 624 flex_gd, start, count); 625 if (err) 626 goto out; 627 } 628 } 629 630 out: 631 brelse(bh); 632 err2 = ext4_journal_stop(handle); 633 if (err2 && !err) 634 err = err2; 635 636 return err; 637 } 638 639 /* 640 * Iterate through the groups which hold BACKUP superblock/GDT copies in an 641 * ext4 filesystem. The counters should be initialized to 1, 5, and 7 before 642 * calling this for the first time. In a sparse filesystem it will be the 643 * sequence of powers of 3, 5, and 7: 1, 3, 5, 7, 9, 25, 27, 49, 81, ... 644 * For a non-sparse filesystem it will be every group: 1, 2, 3, 4, ... 645 */ 646 static unsigned ext4_list_backups(struct super_block *sb, unsigned *three, 647 unsigned *five, unsigned *seven) 648 { 649 unsigned *min = three; 650 int mult = 3; 651 unsigned ret; 652 653 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 654 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 655 ret = *min; 656 *min += 1; 657 return ret; 658 } 659 660 if (*five < *min) { 661 min = five; 662 mult = 5; 663 } 664 if (*seven < *min) { 665 min = seven; 666 mult = 7; 667 } 668 669 ret = *min; 670 *min *= mult; 671 672 return ret; 673 } 674 675 /* 676 * Check that all of the backup GDT blocks are held in the primary GDT block. 677 * It is assumed that they are stored in group order. Returns the number of 678 * groups in current filesystem that have BACKUPS, or -ve error code. 679 */ 680 static int verify_reserved_gdb(struct super_block *sb, 681 ext4_group_t end, 682 struct buffer_head *primary) 683 { 684 const ext4_fsblk_t blk = primary->b_blocknr; 685 unsigned three = 1; 686 unsigned five = 5; 687 unsigned seven = 7; 688 unsigned grp; 689 __le32 *p = (__le32 *)primary->b_data; 690 int gdbackups = 0; 691 692 while ((grp = ext4_list_backups(sb, &three, &five, &seven)) < end) { 693 if (le32_to_cpu(*p++) != 694 grp * EXT4_BLOCKS_PER_GROUP(sb) + blk){ 695 ext4_warning(sb, "reserved GDT %llu" 696 " missing grp %d (%llu)", 697 blk, grp, 698 grp * 699 (ext4_fsblk_t)EXT4_BLOCKS_PER_GROUP(sb) + 700 blk); 701 return -EINVAL; 702 } 703 if (++gdbackups > EXT4_ADDR_PER_BLOCK(sb)) 704 return -EFBIG; 705 } 706 707 return gdbackups; 708 } 709 710 /* 711 * Called when we need to bring a reserved group descriptor table block into 712 * use from the resize inode. The primary copy of the new GDT block currently 713 * is an indirect block (under the double indirect block in the resize inode). 714 * The new backup GDT blocks will be stored as leaf blocks in this indirect 715 * block, in group order. Even though we know all the block numbers we need, 716 * we check to ensure that the resize inode has actually reserved these blocks. 717 * 718 * Don't need to update the block bitmaps because the blocks are still in use. 719 * 720 * We get all of the error cases out of the way, so that we are sure to not 721 * fail once we start modifying the data on disk, because JBD has no rollback. 722 */ 723 static int add_new_gdb(handle_t *handle, struct inode *inode, 724 ext4_group_t group) 725 { 726 struct super_block *sb = inode->i_sb; 727 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 728 unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 729 ext4_fsblk_t gdblock = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num; 730 struct buffer_head **o_group_desc, **n_group_desc; 731 struct buffer_head *dind; 732 struct buffer_head *gdb_bh; 733 int gdbackups; 734 struct ext4_iloc iloc; 735 __le32 *data; 736 int err; 737 738 if (test_opt(sb, DEBUG)) 739 printk(KERN_DEBUG 740 "EXT4-fs: ext4_add_new_gdb: adding group block %lu\n", 741 gdb_num); 742 743 /* 744 * If we are not using the primary superblock/GDT copy don't resize, 745 * because the user tools have no way of handling this. Probably a 746 * bad time to do it anyways. 747 */ 748 if (EXT4_SB(sb)->s_sbh->b_blocknr != 749 le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block)) { 750 ext4_warning(sb, "won't resize using backup superblock at %llu", 751 (unsigned long long)EXT4_SB(sb)->s_sbh->b_blocknr); 752 return -EPERM; 753 } 754 755 gdb_bh = sb_bread(sb, gdblock); 756 if (!gdb_bh) 757 return -EIO; 758 759 gdbackups = verify_reserved_gdb(sb, group, gdb_bh); 760 if (gdbackups < 0) { 761 err = gdbackups; 762 goto exit_bh; 763 } 764 765 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; 766 dind = sb_bread(sb, le32_to_cpu(*data)); 767 if (!dind) { 768 err = -EIO; 769 goto exit_bh; 770 } 771 772 data = (__le32 *)dind->b_data; 773 if (le32_to_cpu(data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)]) != gdblock) { 774 ext4_warning(sb, "new group %u GDT block %llu not reserved", 775 group, gdblock); 776 err = -EINVAL; 777 goto exit_dind; 778 } 779 780 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); 781 if (unlikely(err)) 782 goto exit_dind; 783 784 err = ext4_journal_get_write_access(handle, gdb_bh); 785 if (unlikely(err)) 786 goto exit_sbh; 787 788 err = ext4_journal_get_write_access(handle, dind); 789 if (unlikely(err)) 790 ext4_std_error(sb, err); 791 792 /* ext4_reserve_inode_write() gets a reference on the iloc */ 793 err = ext4_reserve_inode_write(handle, inode, &iloc); 794 if (unlikely(err)) 795 goto exit_dindj; 796 797 n_group_desc = ext4_kvmalloc((gdb_num + 1) * 798 sizeof(struct buffer_head *), 799 GFP_NOFS); 800 if (!n_group_desc) { 801 err = -ENOMEM; 802 ext4_warning(sb, "not enough memory for %lu groups", 803 gdb_num + 1); 804 goto exit_inode; 805 } 806 807 /* 808 * Finally, we have all of the possible failures behind us... 809 * 810 * Remove new GDT block from inode double-indirect block and clear out 811 * the new GDT block for use (which also "frees" the backup GDT blocks 812 * from the reserved inode). We don't need to change the bitmaps for 813 * these blocks, because they are marked as in-use from being in the 814 * reserved inode, and will become GDT blocks (primary and backup). 815 */ 816 data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)] = 0; 817 err = ext4_handle_dirty_metadata(handle, NULL, dind); 818 if (unlikely(err)) { 819 ext4_std_error(sb, err); 820 goto exit_inode; 821 } 822 inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9; 823 ext4_mark_iloc_dirty(handle, inode, &iloc); 824 memset(gdb_bh->b_data, 0, sb->s_blocksize); 825 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh); 826 if (unlikely(err)) { 827 ext4_std_error(sb, err); 828 goto exit_inode; 829 } 830 brelse(dind); 831 832 o_group_desc = EXT4_SB(sb)->s_group_desc; 833 memcpy(n_group_desc, o_group_desc, 834 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); 835 n_group_desc[gdb_num] = gdb_bh; 836 EXT4_SB(sb)->s_group_desc = n_group_desc; 837 EXT4_SB(sb)->s_gdb_count++; 838 ext4_kvfree(o_group_desc); 839 840 le16_add_cpu(&es->s_reserved_gdt_blocks, -1); 841 err = ext4_handle_dirty_super(handle, sb); 842 if (err) 843 ext4_std_error(sb, err); 844 845 return err; 846 847 exit_inode: 848 ext4_kvfree(n_group_desc); 849 /* ext4_handle_release_buffer(handle, iloc.bh); */ 850 brelse(iloc.bh); 851 exit_dindj: 852 /* ext4_handle_release_buffer(handle, dind); */ 853 exit_sbh: 854 /* ext4_handle_release_buffer(handle, EXT4_SB(sb)->s_sbh); */ 855 exit_dind: 856 brelse(dind); 857 exit_bh: 858 brelse(gdb_bh); 859 860 ext4_debug("leaving with error %d\n", err); 861 return err; 862 } 863 864 /* 865 * add_new_gdb_meta_bg is the sister of add_new_gdb. 866 */ 867 static int add_new_gdb_meta_bg(struct super_block *sb, 868 handle_t *handle, ext4_group_t group) { 869 ext4_fsblk_t gdblock; 870 struct buffer_head *gdb_bh; 871 struct buffer_head **o_group_desc, **n_group_desc; 872 unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 873 int err; 874 875 gdblock = ext4_meta_bg_first_block_no(sb, group) + 876 ext4_bg_has_super(sb, group); 877 gdb_bh = sb_bread(sb, gdblock); 878 if (!gdb_bh) 879 return -EIO; 880 n_group_desc = ext4_kvmalloc((gdb_num + 1) * 881 sizeof(struct buffer_head *), 882 GFP_NOFS); 883 if (!n_group_desc) { 884 err = -ENOMEM; 885 ext4_warning(sb, "not enough memory for %lu groups", 886 gdb_num + 1); 887 return err; 888 } 889 890 o_group_desc = EXT4_SB(sb)->s_group_desc; 891 memcpy(n_group_desc, o_group_desc, 892 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); 893 n_group_desc[gdb_num] = gdb_bh; 894 EXT4_SB(sb)->s_group_desc = n_group_desc; 895 EXT4_SB(sb)->s_gdb_count++; 896 ext4_kvfree(o_group_desc); 897 err = ext4_journal_get_write_access(handle, gdb_bh); 898 if (unlikely(err)) 899 brelse(gdb_bh); 900 return err; 901 } 902 903 /* 904 * Called when we are adding a new group which has a backup copy of each of 905 * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks. 906 * We need to add these reserved backup GDT blocks to the resize inode, so 907 * that they are kept for future resizing and not allocated to files. 908 * 909 * Each reserved backup GDT block will go into a different indirect block. 910 * The indirect blocks are actually the primary reserved GDT blocks, 911 * so we know in advance what their block numbers are. We only get the 912 * double-indirect block to verify it is pointing to the primary reserved 913 * GDT blocks so we don't overwrite a data block by accident. The reserved 914 * backup GDT blocks are stored in their reserved primary GDT block. 915 */ 916 static int reserve_backup_gdb(handle_t *handle, struct inode *inode, 917 ext4_group_t group) 918 { 919 struct super_block *sb = inode->i_sb; 920 int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); 921 struct buffer_head **primary; 922 struct buffer_head *dind; 923 struct ext4_iloc iloc; 924 ext4_fsblk_t blk; 925 __le32 *data, *end; 926 int gdbackups = 0; 927 int res, i; 928 int err; 929 930 primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS); 931 if (!primary) 932 return -ENOMEM; 933 934 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; 935 dind = sb_bread(sb, le32_to_cpu(*data)); 936 if (!dind) { 937 err = -EIO; 938 goto exit_free; 939 } 940 941 blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count; 942 data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count % 943 EXT4_ADDR_PER_BLOCK(sb)); 944 end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb); 945 946 /* Get each reserved primary GDT block and verify it holds backups */ 947 for (res = 0; res < reserved_gdb; res++, blk++) { 948 if (le32_to_cpu(*data) != blk) { 949 ext4_warning(sb, "reserved block %llu" 950 " not at offset %ld", 951 blk, 952 (long)(data - (__le32 *)dind->b_data)); 953 err = -EINVAL; 954 goto exit_bh; 955 } 956 primary[res] = sb_bread(sb, blk); 957 if (!primary[res]) { 958 err = -EIO; 959 goto exit_bh; 960 } 961 gdbackups = verify_reserved_gdb(sb, group, primary[res]); 962 if (gdbackups < 0) { 963 brelse(primary[res]); 964 err = gdbackups; 965 goto exit_bh; 966 } 967 if (++data >= end) 968 data = (__le32 *)dind->b_data; 969 } 970 971 for (i = 0; i < reserved_gdb; i++) { 972 if ((err = ext4_journal_get_write_access(handle, primary[i]))) { 973 /* 974 int j; 975 for (j = 0; j < i; j++) 976 ext4_handle_release_buffer(handle, primary[j]); 977 */ 978 goto exit_bh; 979 } 980 } 981 982 if ((err = ext4_reserve_inode_write(handle, inode, &iloc))) 983 goto exit_bh; 984 985 /* 986 * Finally we can add each of the reserved backup GDT blocks from 987 * the new group to its reserved primary GDT block. 988 */ 989 blk = group * EXT4_BLOCKS_PER_GROUP(sb); 990 for (i = 0; i < reserved_gdb; i++) { 991 int err2; 992 data = (__le32 *)primary[i]->b_data; 993 /* printk("reserving backup %lu[%u] = %lu\n", 994 primary[i]->b_blocknr, gdbackups, 995 blk + primary[i]->b_blocknr); */ 996 data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr); 997 err2 = ext4_handle_dirty_metadata(handle, NULL, primary[i]); 998 if (!err) 999 err = err2; 1000 } 1001 inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9; 1002 ext4_mark_iloc_dirty(handle, inode, &iloc); 1003 1004 exit_bh: 1005 while (--res >= 0) 1006 brelse(primary[res]); 1007 brelse(dind); 1008 1009 exit_free: 1010 kfree(primary); 1011 1012 return err; 1013 } 1014 1015 /* 1016 * Update the backup copies of the ext4 metadata. These don't need to be part 1017 * of the main resize transaction, because e2fsck will re-write them if there 1018 * is a problem (basically only OOM will cause a problem). However, we 1019 * _should_ update the backups if possible, in case the primary gets trashed 1020 * for some reason and we need to run e2fsck from a backup superblock. The 1021 * important part is that the new block and inode counts are in the backup 1022 * superblocks, and the location of the new group metadata in the GDT backups. 1023 * 1024 * We do not need take the s_resize_lock for this, because these 1025 * blocks are not otherwise touched by the filesystem code when it is 1026 * mounted. We don't need to worry about last changing from 1027 * sbi->s_groups_count, because the worst that can happen is that we 1028 * do not copy the full number of backups at this time. The resize 1029 * which changed s_groups_count will backup again. 1030 */ 1031 static void update_backups(struct super_block *sb, int blk_off, char *data, 1032 int size, int meta_bg) 1033 { 1034 struct ext4_sb_info *sbi = EXT4_SB(sb); 1035 ext4_group_t last; 1036 const int bpg = EXT4_BLOCKS_PER_GROUP(sb); 1037 unsigned three = 1; 1038 unsigned five = 5; 1039 unsigned seven = 7; 1040 ext4_group_t group = 0; 1041 int rest = sb->s_blocksize - size; 1042 handle_t *handle; 1043 int err = 0, err2; 1044 1045 handle = ext4_journal_start_sb(sb, EXT4_MAX_TRANS_DATA); 1046 if (IS_ERR(handle)) { 1047 group = 1; 1048 err = PTR_ERR(handle); 1049 goto exit_err; 1050 } 1051 1052 ext4_superblock_csum_set(sb, (struct ext4_super_block *)data); 1053 1054 if (meta_bg == 0) { 1055 group = ext4_list_backups(sb, &three, &five, &seven); 1056 last = sbi->s_groups_count; 1057 } else { 1058 group = ext4_meta_bg_first_group(sb, group) + 1; 1059 last = (ext4_group_t)(group + EXT4_DESC_PER_BLOCK(sb) - 2); 1060 } 1061 1062 while (group < sbi->s_groups_count) { 1063 struct buffer_head *bh; 1064 ext4_fsblk_t backup_block; 1065 1066 /* Out of journal space, and can't get more - abort - so sad */ 1067 if (ext4_handle_valid(handle) && 1068 handle->h_buffer_credits == 0 && 1069 ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) && 1070 (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA))) 1071 break; 1072 1073 if (meta_bg == 0) 1074 backup_block = group * bpg + blk_off; 1075 else 1076 backup_block = (ext4_group_first_block_no(sb, group) + 1077 ext4_bg_has_super(sb, group)); 1078 1079 bh = sb_getblk(sb, backup_block); 1080 if (!bh) { 1081 err = -EIO; 1082 break; 1083 } 1084 ext4_debug("update metadata backup %llu(+%llu)\n", 1085 backup_block, backup_block - 1086 ext4_group_first_block_no(sb, group)); 1087 if ((err = ext4_journal_get_write_access(handle, bh))) 1088 break; 1089 lock_buffer(bh); 1090 memcpy(bh->b_data, data, size); 1091 if (rest) 1092 memset(bh->b_data + size, 0, rest); 1093 set_buffer_uptodate(bh); 1094 unlock_buffer(bh); 1095 err = ext4_handle_dirty_metadata(handle, NULL, bh); 1096 if (unlikely(err)) 1097 ext4_std_error(sb, err); 1098 brelse(bh); 1099 1100 if (meta_bg == 0) 1101 group = ext4_list_backups(sb, &three, &five, &seven); 1102 else if (group == last) 1103 break; 1104 else 1105 group = last; 1106 } 1107 if ((err2 = ext4_journal_stop(handle)) && !err) 1108 err = err2; 1109 1110 /* 1111 * Ugh! Need to have e2fsck write the backup copies. It is too 1112 * late to revert the resize, we shouldn't fail just because of 1113 * the backup copies (they are only needed in case of corruption). 1114 * 1115 * However, if we got here we have a journal problem too, so we 1116 * can't really start a transaction to mark the superblock. 1117 * Chicken out and just set the flag on the hope it will be written 1118 * to disk, and if not - we will simply wait until next fsck. 1119 */ 1120 exit_err: 1121 if (err) { 1122 ext4_warning(sb, "can't update backup for group %u (err %d), " 1123 "forcing fsck on next reboot", group, err); 1124 sbi->s_mount_state &= ~EXT4_VALID_FS; 1125 sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS); 1126 mark_buffer_dirty(sbi->s_sbh); 1127 } 1128 } 1129 1130 /* 1131 * ext4_add_new_descs() adds @count group descriptor of groups 1132 * starting at @group 1133 * 1134 * @handle: journal handle 1135 * @sb: super block 1136 * @group: the group no. of the first group desc to be added 1137 * @resize_inode: the resize inode 1138 * @count: number of group descriptors to be added 1139 */ 1140 static int ext4_add_new_descs(handle_t *handle, struct super_block *sb, 1141 ext4_group_t group, struct inode *resize_inode, 1142 ext4_group_t count) 1143 { 1144 struct ext4_sb_info *sbi = EXT4_SB(sb); 1145 struct ext4_super_block *es = sbi->s_es; 1146 struct buffer_head *gdb_bh; 1147 int i, gdb_off, gdb_num, err = 0; 1148 int meta_bg; 1149 1150 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1151 for (i = 0; i < count; i++, group++) { 1152 int reserved_gdb = ext4_bg_has_super(sb, group) ? 1153 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 1154 1155 gdb_off = group % EXT4_DESC_PER_BLOCK(sb); 1156 gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1157 1158 /* 1159 * We will only either add reserved group blocks to a backup group 1160 * or remove reserved blocks for the first group in a new group block. 1161 * Doing both would be mean more complex code, and sane people don't 1162 * use non-sparse filesystems anymore. This is already checked above. 1163 */ 1164 if (gdb_off) { 1165 gdb_bh = sbi->s_group_desc[gdb_num]; 1166 err = ext4_journal_get_write_access(handle, gdb_bh); 1167 1168 if (!err && reserved_gdb && ext4_bg_num_gdb(sb, group)) 1169 err = reserve_backup_gdb(handle, resize_inode, group); 1170 } else if (meta_bg != 0) { 1171 err = add_new_gdb_meta_bg(sb, handle, group); 1172 } else { 1173 err = add_new_gdb(handle, resize_inode, group); 1174 } 1175 if (err) 1176 break; 1177 } 1178 return err; 1179 } 1180 1181 static struct buffer_head *ext4_get_bitmap(struct super_block *sb, __u64 block) 1182 { 1183 struct buffer_head *bh = sb_getblk(sb, block); 1184 if (!bh) 1185 return NULL; 1186 1187 if (bitmap_uptodate(bh)) 1188 return bh; 1189 1190 lock_buffer(bh); 1191 if (bh_submit_read(bh) < 0) { 1192 unlock_buffer(bh); 1193 brelse(bh); 1194 return NULL; 1195 } 1196 unlock_buffer(bh); 1197 1198 return bh; 1199 } 1200 1201 static int ext4_set_bitmap_checksums(struct super_block *sb, 1202 ext4_group_t group, 1203 struct ext4_group_desc *gdp, 1204 struct ext4_new_group_data *group_data) 1205 { 1206 struct buffer_head *bh; 1207 1208 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 1209 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) 1210 return 0; 1211 1212 bh = ext4_get_bitmap(sb, group_data->inode_bitmap); 1213 if (!bh) 1214 return -EIO; 1215 ext4_inode_bitmap_csum_set(sb, group, gdp, bh, 1216 EXT4_INODES_PER_GROUP(sb) / 8); 1217 brelse(bh); 1218 1219 bh = ext4_get_bitmap(sb, group_data->block_bitmap); 1220 if (!bh) 1221 return -EIO; 1222 ext4_block_bitmap_csum_set(sb, group, gdp, bh, 1223 EXT4_BLOCKS_PER_GROUP(sb) / 8); 1224 brelse(bh); 1225 1226 return 0; 1227 } 1228 1229 /* 1230 * ext4_setup_new_descs() will set up the group descriptor descriptors of a flex bg 1231 */ 1232 static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb, 1233 struct ext4_new_flex_group_data *flex_gd) 1234 { 1235 struct ext4_new_group_data *group_data = flex_gd->groups; 1236 struct ext4_group_desc *gdp; 1237 struct ext4_sb_info *sbi = EXT4_SB(sb); 1238 struct buffer_head *gdb_bh; 1239 ext4_group_t group; 1240 __u16 *bg_flags = flex_gd->bg_flags; 1241 int i, gdb_off, gdb_num, err = 0; 1242 1243 1244 for (i = 0; i < flex_gd->count; i++, group_data++, bg_flags++) { 1245 group = group_data->group; 1246 1247 gdb_off = group % EXT4_DESC_PER_BLOCK(sb); 1248 gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1249 1250 /* 1251 * get_write_access() has been called on gdb_bh by ext4_add_new_desc(). 1252 */ 1253 gdb_bh = sbi->s_group_desc[gdb_num]; 1254 /* Update group descriptor block for new group */ 1255 gdp = (struct ext4_group_desc *)(gdb_bh->b_data + 1256 gdb_off * EXT4_DESC_SIZE(sb)); 1257 1258 memset(gdp, 0, EXT4_DESC_SIZE(sb)); 1259 ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap); 1260 ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap); 1261 err = ext4_set_bitmap_checksums(sb, group, gdp, group_data); 1262 if (err) { 1263 ext4_std_error(sb, err); 1264 break; 1265 } 1266 1267 ext4_inode_table_set(sb, gdp, group_data->inode_table); 1268 ext4_free_group_clusters_set(sb, gdp, 1269 EXT4_B2C(sbi, group_data->free_blocks_count)); 1270 ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb)); 1271 if (ext4_has_group_desc_csum(sb)) 1272 ext4_itable_unused_set(sb, gdp, 1273 EXT4_INODES_PER_GROUP(sb)); 1274 gdp->bg_flags = cpu_to_le16(*bg_flags); 1275 ext4_group_desc_csum_set(sb, group, gdp); 1276 1277 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh); 1278 if (unlikely(err)) { 1279 ext4_std_error(sb, err); 1280 break; 1281 } 1282 1283 /* 1284 * We can allocate memory for mb_alloc based on the new group 1285 * descriptor 1286 */ 1287 err = ext4_mb_add_groupinfo(sb, group, gdp); 1288 if (err) 1289 break; 1290 } 1291 return err; 1292 } 1293 1294 /* 1295 * ext4_update_super() updates the super block so that the newly added 1296 * groups can be seen by the filesystem. 1297 * 1298 * @sb: super block 1299 * @flex_gd: new added groups 1300 */ 1301 static void ext4_update_super(struct super_block *sb, 1302 struct ext4_new_flex_group_data *flex_gd) 1303 { 1304 ext4_fsblk_t blocks_count = 0; 1305 ext4_fsblk_t free_blocks = 0; 1306 ext4_fsblk_t reserved_blocks = 0; 1307 struct ext4_new_group_data *group_data = flex_gd->groups; 1308 struct ext4_sb_info *sbi = EXT4_SB(sb); 1309 struct ext4_super_block *es = sbi->s_es; 1310 int i; 1311 1312 BUG_ON(flex_gd->count == 0 || group_data == NULL); 1313 /* 1314 * Make the new blocks and inodes valid next. We do this before 1315 * increasing the group count so that once the group is enabled, 1316 * all of its blocks and inodes are already valid. 1317 * 1318 * We always allocate group-by-group, then block-by-block or 1319 * inode-by-inode within a group, so enabling these 1320 * blocks/inodes before the group is live won't actually let us 1321 * allocate the new space yet. 1322 */ 1323 for (i = 0; i < flex_gd->count; i++) { 1324 blocks_count += group_data[i].blocks_count; 1325 free_blocks += group_data[i].free_blocks_count; 1326 } 1327 1328 reserved_blocks = ext4_r_blocks_count(es) * 100; 1329 reserved_blocks = div64_u64(reserved_blocks, ext4_blocks_count(es)); 1330 reserved_blocks *= blocks_count; 1331 do_div(reserved_blocks, 100); 1332 1333 ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count); 1334 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + free_blocks); 1335 le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) * 1336 flex_gd->count); 1337 le32_add_cpu(&es->s_free_inodes_count, EXT4_INODES_PER_GROUP(sb) * 1338 flex_gd->count); 1339 1340 ext4_debug("free blocks count %llu", ext4_free_blocks_count(es)); 1341 /* 1342 * We need to protect s_groups_count against other CPUs seeing 1343 * inconsistent state in the superblock. 1344 * 1345 * The precise rules we use are: 1346 * 1347 * * Writers must perform a smp_wmb() after updating all 1348 * dependent data and before modifying the groups count 1349 * 1350 * * Readers must perform an smp_rmb() after reading the groups 1351 * count and before reading any dependent data. 1352 * 1353 * NB. These rules can be relaxed when checking the group count 1354 * while freeing data, as we can only allocate from a block 1355 * group after serialising against the group count, and we can 1356 * only then free after serialising in turn against that 1357 * allocation. 1358 */ 1359 smp_wmb(); 1360 1361 /* Update the global fs size fields */ 1362 sbi->s_groups_count += flex_gd->count; 1363 1364 /* Update the reserved block counts only once the new group is 1365 * active. */ 1366 ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) + 1367 reserved_blocks); 1368 1369 /* Update the free space counts */ 1370 percpu_counter_add(&sbi->s_freeclusters_counter, 1371 EXT4_B2C(sbi, free_blocks)); 1372 percpu_counter_add(&sbi->s_freeinodes_counter, 1373 EXT4_INODES_PER_GROUP(sb) * flex_gd->count); 1374 1375 ext4_debug("free blocks count %llu", 1376 percpu_counter_read(&sbi->s_freeclusters_counter)); 1377 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 1378 EXT4_FEATURE_INCOMPAT_FLEX_BG) && 1379 sbi->s_log_groups_per_flex) { 1380 ext4_group_t flex_group; 1381 flex_group = ext4_flex_group(sbi, group_data[0].group); 1382 atomic_add(EXT4_B2C(sbi, free_blocks), 1383 &sbi->s_flex_groups[flex_group].free_clusters); 1384 atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count, 1385 &sbi->s_flex_groups[flex_group].free_inodes); 1386 } 1387 1388 /* 1389 * Update the fs overhead information 1390 */ 1391 ext4_calculate_overhead(sb); 1392 1393 if (test_opt(sb, DEBUG)) 1394 printk(KERN_DEBUG "EXT4-fs: added group %u:" 1395 "%llu blocks(%llu free %llu reserved)\n", flex_gd->count, 1396 blocks_count, free_blocks, reserved_blocks); 1397 } 1398 1399 /* Add a flex group to an fs. Ensure we handle all possible error conditions 1400 * _before_ we start modifying the filesystem, because we cannot abort the 1401 * transaction and not have it write the data to disk. 1402 */ 1403 static int ext4_flex_group_add(struct super_block *sb, 1404 struct inode *resize_inode, 1405 struct ext4_new_flex_group_data *flex_gd) 1406 { 1407 struct ext4_sb_info *sbi = EXT4_SB(sb); 1408 struct ext4_super_block *es = sbi->s_es; 1409 ext4_fsblk_t o_blocks_count; 1410 ext4_grpblk_t last; 1411 ext4_group_t group; 1412 handle_t *handle; 1413 unsigned reserved_gdb; 1414 int err = 0, err2 = 0, credit; 1415 1416 BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags); 1417 1418 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); 1419 o_blocks_count = ext4_blocks_count(es); 1420 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1421 BUG_ON(last); 1422 1423 err = setup_new_flex_group_blocks(sb, flex_gd); 1424 if (err) 1425 goto exit; 1426 /* 1427 * We will always be modifying at least the superblock and GDT 1428 * block. If we are adding a group past the last current GDT block, 1429 * we will also modify the inode and the dindirect block. If we 1430 * are adding a group with superblock/GDT backups we will also 1431 * modify each of the reserved GDT dindirect blocks. 1432 */ 1433 credit = flex_gd->count * 4 + reserved_gdb; 1434 handle = ext4_journal_start_sb(sb, credit); 1435 if (IS_ERR(handle)) { 1436 err = PTR_ERR(handle); 1437 goto exit; 1438 } 1439 1440 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 1441 if (err) 1442 goto exit_journal; 1443 1444 group = flex_gd->groups[0].group; 1445 BUG_ON(group != EXT4_SB(sb)->s_groups_count); 1446 err = ext4_add_new_descs(handle, sb, group, 1447 resize_inode, flex_gd->count); 1448 if (err) 1449 goto exit_journal; 1450 1451 err = ext4_setup_new_descs(handle, sb, flex_gd); 1452 if (err) 1453 goto exit_journal; 1454 1455 ext4_update_super(sb, flex_gd); 1456 1457 err = ext4_handle_dirty_super(handle, sb); 1458 1459 exit_journal: 1460 err2 = ext4_journal_stop(handle); 1461 if (!err) 1462 err = err2; 1463 1464 if (!err) { 1465 int gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1466 int gdb_num_end = ((group + flex_gd->count - 1) / 1467 EXT4_DESC_PER_BLOCK(sb)); 1468 int meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, 1469 EXT4_FEATURE_INCOMPAT_META_BG); 1470 1471 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es, 1472 sizeof(struct ext4_super_block), 0); 1473 for (; gdb_num <= gdb_num_end; gdb_num++) { 1474 struct buffer_head *gdb_bh; 1475 1476 gdb_bh = sbi->s_group_desc[gdb_num]; 1477 update_backups(sb, gdb_bh->b_blocknr, gdb_bh->b_data, 1478 gdb_bh->b_size, meta_bg); 1479 } 1480 } 1481 exit: 1482 return err; 1483 } 1484 1485 static int ext4_setup_next_flex_gd(struct super_block *sb, 1486 struct ext4_new_flex_group_data *flex_gd, 1487 ext4_fsblk_t n_blocks_count, 1488 unsigned long flexbg_size) 1489 { 1490 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 1491 struct ext4_new_group_data *group_data = flex_gd->groups; 1492 ext4_fsblk_t o_blocks_count; 1493 ext4_group_t n_group; 1494 ext4_group_t group; 1495 ext4_group_t last_group; 1496 ext4_grpblk_t last; 1497 ext4_grpblk_t blocks_per_group; 1498 unsigned long i; 1499 1500 blocks_per_group = EXT4_BLOCKS_PER_GROUP(sb); 1501 1502 o_blocks_count = ext4_blocks_count(es); 1503 1504 if (o_blocks_count == n_blocks_count) 1505 return 0; 1506 1507 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1508 BUG_ON(last); 1509 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last); 1510 1511 last_group = group | (flexbg_size - 1); 1512 if (last_group > n_group) 1513 last_group = n_group; 1514 1515 flex_gd->count = last_group - group + 1; 1516 1517 for (i = 0; i < flex_gd->count; i++) { 1518 int overhead; 1519 1520 group_data[i].group = group + i; 1521 group_data[i].blocks_count = blocks_per_group; 1522 overhead = ext4_group_overhead_blocks(sb, group + i); 1523 group_data[i].free_blocks_count = blocks_per_group - overhead; 1524 if (ext4_has_group_desc_csum(sb)) 1525 flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT | 1526 EXT4_BG_INODE_UNINIT; 1527 else 1528 flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED; 1529 } 1530 1531 if (last_group == n_group && ext4_has_group_desc_csum(sb)) 1532 /* We need to initialize block bitmap of last group. */ 1533 flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT; 1534 1535 if ((last_group == n_group) && (last != blocks_per_group - 1)) { 1536 group_data[i - 1].blocks_count = last + 1; 1537 group_data[i - 1].free_blocks_count -= blocks_per_group- 1538 last - 1; 1539 } 1540 1541 return 1; 1542 } 1543 1544 /* Add group descriptor data to an existing or new group descriptor block. 1545 * Ensure we handle all possible error conditions _before_ we start modifying 1546 * the filesystem, because we cannot abort the transaction and not have it 1547 * write the data to disk. 1548 * 1549 * If we are on a GDT block boundary, we need to get the reserved GDT block. 1550 * Otherwise, we may need to add backup GDT blocks for a sparse group. 1551 * 1552 * We only need to hold the superblock lock while we are actually adding 1553 * in the new group's counts to the superblock. Prior to that we have 1554 * not really "added" the group at all. We re-check that we are still 1555 * adding in the last group in case things have changed since verifying. 1556 */ 1557 int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) 1558 { 1559 struct ext4_new_flex_group_data flex_gd; 1560 struct ext4_sb_info *sbi = EXT4_SB(sb); 1561 struct ext4_super_block *es = sbi->s_es; 1562 int reserved_gdb = ext4_bg_has_super(sb, input->group) ? 1563 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 1564 struct inode *inode = NULL; 1565 int gdb_off, gdb_num; 1566 int err; 1567 __u16 bg_flags = 0; 1568 1569 gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb); 1570 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); 1571 1572 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb, 1573 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 1574 ext4_warning(sb, "Can't resize non-sparse filesystem further"); 1575 return -EPERM; 1576 } 1577 1578 if (ext4_blocks_count(es) + input->blocks_count < 1579 ext4_blocks_count(es)) { 1580 ext4_warning(sb, "blocks_count overflow"); 1581 return -EINVAL; 1582 } 1583 1584 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < 1585 le32_to_cpu(es->s_inodes_count)) { 1586 ext4_warning(sb, "inodes_count overflow"); 1587 return -EINVAL; 1588 } 1589 1590 if (reserved_gdb || gdb_off == 0) { 1591 if (!EXT4_HAS_COMPAT_FEATURE(sb, 1592 EXT4_FEATURE_COMPAT_RESIZE_INODE) 1593 || !le16_to_cpu(es->s_reserved_gdt_blocks)) { 1594 ext4_warning(sb, 1595 "No reserved GDT blocks, can't resize"); 1596 return -EPERM; 1597 } 1598 inode = ext4_iget(sb, EXT4_RESIZE_INO); 1599 if (IS_ERR(inode)) { 1600 ext4_warning(sb, "Error opening resize inode"); 1601 return PTR_ERR(inode); 1602 } 1603 } 1604 1605 1606 err = verify_group_input(sb, input); 1607 if (err) 1608 goto out; 1609 1610 err = ext4_alloc_flex_bg_array(sb, input->group + 1); 1611 if (err) 1612 return err; 1613 1614 err = ext4_mb_alloc_groupinfo(sb, input->group + 1); 1615 if (err) 1616 goto out; 1617 1618 flex_gd.count = 1; 1619 flex_gd.groups = input; 1620 flex_gd.bg_flags = &bg_flags; 1621 err = ext4_flex_group_add(sb, inode, &flex_gd); 1622 out: 1623 iput(inode); 1624 return err; 1625 } /* ext4_group_add */ 1626 1627 /* 1628 * extend a group without checking assuming that checking has been done. 1629 */ 1630 static int ext4_group_extend_no_check(struct super_block *sb, 1631 ext4_fsblk_t o_blocks_count, ext4_grpblk_t add) 1632 { 1633 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 1634 handle_t *handle; 1635 int err = 0, err2; 1636 1637 /* We will update the superblock, one block bitmap, and 1638 * one group descriptor via ext4_group_add_blocks(). 1639 */ 1640 handle = ext4_journal_start_sb(sb, 3); 1641 if (IS_ERR(handle)) { 1642 err = PTR_ERR(handle); 1643 ext4_warning(sb, "error %d on journal start", err); 1644 return err; 1645 } 1646 1647 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); 1648 if (err) { 1649 ext4_warning(sb, "error %d on journal write access", err); 1650 goto errout; 1651 } 1652 1653 ext4_blocks_count_set(es, o_blocks_count + add); 1654 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + add); 1655 ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count, 1656 o_blocks_count + add); 1657 /* We add the blocks to the bitmap and set the group need init bit */ 1658 err = ext4_group_add_blocks(handle, sb, o_blocks_count, add); 1659 if (err) 1660 goto errout; 1661 ext4_handle_dirty_super(handle, sb); 1662 ext4_debug("freed blocks %llu through %llu\n", o_blocks_count, 1663 o_blocks_count + add); 1664 errout: 1665 err2 = ext4_journal_stop(handle); 1666 if (err2 && !err) 1667 err = err2; 1668 1669 if (!err) { 1670 ext4_fsblk_t first_block; 1671 first_block = ext4_group_first_block_no(sb, 0); 1672 if (test_opt(sb, DEBUG)) 1673 printk(KERN_DEBUG "EXT4-fs: extended group to %llu " 1674 "blocks\n", ext4_blocks_count(es)); 1675 update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr - first_block, 1676 (char *)es, sizeof(struct ext4_super_block), 0); 1677 } 1678 return err; 1679 } 1680 1681 /* 1682 * Extend the filesystem to the new number of blocks specified. This entry 1683 * point is only used to extend the current filesystem to the end of the last 1684 * existing group. It can be accessed via ioctl, or by "remount,resize=<size>" 1685 * for emergencies (because it has no dependencies on reserved blocks). 1686 * 1687 * If we _really_ wanted, we could use default values to call ext4_group_add() 1688 * allow the "remount" trick to work for arbitrary resizing, assuming enough 1689 * GDT blocks are reserved to grow to the desired size. 1690 */ 1691 int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es, 1692 ext4_fsblk_t n_blocks_count) 1693 { 1694 ext4_fsblk_t o_blocks_count; 1695 ext4_grpblk_t last; 1696 ext4_grpblk_t add; 1697 struct buffer_head *bh; 1698 int err; 1699 ext4_group_t group; 1700 1701 o_blocks_count = ext4_blocks_count(es); 1702 1703 if (test_opt(sb, DEBUG)) 1704 ext4_msg(sb, KERN_DEBUG, 1705 "extending last group from %llu to %llu blocks", 1706 o_blocks_count, n_blocks_count); 1707 1708 if (n_blocks_count == 0 || n_blocks_count == o_blocks_count) 1709 return 0; 1710 1711 if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { 1712 ext4_msg(sb, KERN_ERR, 1713 "filesystem too large to resize to %llu blocks safely", 1714 n_blocks_count); 1715 if (sizeof(sector_t) < 8) 1716 ext4_warning(sb, "CONFIG_LBDAF not enabled"); 1717 return -EINVAL; 1718 } 1719 1720 if (n_blocks_count < o_blocks_count) { 1721 ext4_warning(sb, "can't shrink FS - resize aborted"); 1722 return -EINVAL; 1723 } 1724 1725 /* Handle the remaining blocks in the last group only. */ 1726 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1727 1728 if (last == 0) { 1729 ext4_warning(sb, "need to use ext2online to resize further"); 1730 return -EPERM; 1731 } 1732 1733 add = EXT4_BLOCKS_PER_GROUP(sb) - last; 1734 1735 if (o_blocks_count + add < o_blocks_count) { 1736 ext4_warning(sb, "blocks_count overflow"); 1737 return -EINVAL; 1738 } 1739 1740 if (o_blocks_count + add > n_blocks_count) 1741 add = n_blocks_count - o_blocks_count; 1742 1743 if (o_blocks_count + add < n_blocks_count) 1744 ext4_warning(sb, "will only finish group (%llu blocks, %u new)", 1745 o_blocks_count + add, add); 1746 1747 /* See if the device is actually as big as what was requested */ 1748 bh = sb_bread(sb, o_blocks_count + add - 1); 1749 if (!bh) { 1750 ext4_warning(sb, "can't read last block, resize aborted"); 1751 return -ENOSPC; 1752 } 1753 brelse(bh); 1754 1755 err = ext4_group_extend_no_check(sb, o_blocks_count, add); 1756 return err; 1757 } /* ext4_group_extend */ 1758 1759 /* 1760 * ext4_resize_fs() resizes a fs to new size specified by @n_blocks_count 1761 * 1762 * @sb: super block of the fs to be resized 1763 * @n_blocks_count: the number of blocks resides in the resized fs 1764 */ 1765 int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count) 1766 { 1767 struct ext4_new_flex_group_data *flex_gd = NULL; 1768 struct ext4_sb_info *sbi = EXT4_SB(sb); 1769 struct ext4_super_block *es = sbi->s_es; 1770 struct buffer_head *bh; 1771 struct inode *resize_inode = NULL; 1772 ext4_grpblk_t add, offset; 1773 unsigned long n_desc_blocks; 1774 unsigned long o_desc_blocks; 1775 unsigned long desc_blocks; 1776 ext4_group_t o_group; 1777 ext4_group_t n_group; 1778 ext4_fsblk_t o_blocks_count; 1779 int err = 0, flexbg_size = 1 << sbi->s_log_groups_per_flex; 1780 int meta_bg; 1781 1782 o_blocks_count = ext4_blocks_count(es); 1783 1784 if (test_opt(sb, DEBUG)) 1785 ext4_msg(sb, KERN_DEBUG, "resizing filesystem from %llu " 1786 "to %llu blocks", o_blocks_count, n_blocks_count); 1787 1788 if (n_blocks_count < o_blocks_count) { 1789 /* On-line shrinking not supported */ 1790 ext4_warning(sb, "can't shrink FS - resize aborted"); 1791 return -EINVAL; 1792 } 1793 1794 if (n_blocks_count == o_blocks_count) 1795 /* Nothing need to do */ 1796 return 0; 1797 1798 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &offset); 1799 ext4_get_group_no_and_offset(sb, o_blocks_count - 1, &o_group, &offset); 1800 1801 n_desc_blocks = (n_group + EXT4_DESC_PER_BLOCK(sb)) / 1802 EXT4_DESC_PER_BLOCK(sb); 1803 o_desc_blocks = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) / 1804 EXT4_DESC_PER_BLOCK(sb); 1805 desc_blocks = n_desc_blocks - o_desc_blocks; 1806 1807 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1808 1809 if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE)) { 1810 if (meta_bg) { 1811 ext4_error(sb, "resize_inode and meta_bg enabled " 1812 "simultaneously"); 1813 return -EINVAL; 1814 } 1815 if (le16_to_cpu(es->s_reserved_gdt_blocks) < desc_blocks) { 1816 ext4_warning(sb, 1817 "No reserved GDT blocks, can't resize"); 1818 return -EPERM; 1819 } 1820 resize_inode = ext4_iget(sb, EXT4_RESIZE_INO); 1821 if (IS_ERR(resize_inode)) { 1822 ext4_warning(sb, "Error opening resize inode"); 1823 return PTR_ERR(resize_inode); 1824 } 1825 } else if (!meta_bg) { 1826 ext4_warning(sb, "File system features do not permit " 1827 "online resize"); 1828 return -EPERM; 1829 } 1830 1831 /* See if the device is actually as big as what was requested */ 1832 bh = sb_bread(sb, n_blocks_count - 1); 1833 if (!bh) { 1834 ext4_warning(sb, "can't read last block, resize aborted"); 1835 return -ENOSPC; 1836 } 1837 brelse(bh); 1838 1839 /* extend the last group */ 1840 if (n_group == o_group) 1841 add = n_blocks_count - o_blocks_count; 1842 else 1843 add = EXT4_BLOCKS_PER_GROUP(sb) - (offset + 1); 1844 if (add > 0) { 1845 err = ext4_group_extend_no_check(sb, o_blocks_count, add); 1846 if (err) 1847 goto out; 1848 } 1849 1850 if (ext4_blocks_count(es) == n_blocks_count) 1851 goto out; 1852 1853 err = ext4_alloc_flex_bg_array(sb, n_group + 1); 1854 if (err) 1855 return err; 1856 1857 err = ext4_mb_alloc_groupinfo(sb, n_group + 1); 1858 if (err) 1859 goto out; 1860 1861 flex_gd = alloc_flex_gd(flexbg_size); 1862 if (flex_gd == NULL) { 1863 err = -ENOMEM; 1864 goto out; 1865 } 1866 1867 /* Add flex groups. Note that a regular group is a 1868 * flex group with 1 group. 1869 */ 1870 while (ext4_setup_next_flex_gd(sb, flex_gd, n_blocks_count, 1871 flexbg_size)) { 1872 if (ext4_alloc_group_tables(sb, flex_gd, flexbg_size) != 0) 1873 break; 1874 err = ext4_flex_group_add(sb, resize_inode, flex_gd); 1875 if (unlikely(err)) 1876 break; 1877 } 1878 1879 out: 1880 if (flex_gd) 1881 free_flex_gd(flex_gd); 1882 if (resize_inode != NULL) 1883 iput(resize_inode); 1884 if (test_opt(sb, DEBUG)) 1885 ext4_msg(sb, KERN_DEBUG, "resized filesystem from %llu " 1886 "upto %llu blocks", o_blocks_count, n_blocks_count); 1887 return err; 1888 } 1889