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 group = ext4_get_group_number(sb, start_blk - 1); 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 group = ext4_get_group_number(sb, start_blk - 1); 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 group = ext4_get_group_number(sb, start_blk - 1); 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 (unlikely(!bh)) 337 return ERR_PTR(-ENOMEM); 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 group = ext4_get_group_number(sb, block); 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 (unlikely(!bh)) 414 return -ENOMEM; 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_HT_RESIZE, 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 (unlikely(!gdb)) { 504 err = -ENOMEM; 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_dind; 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_dind; 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 brelse(iloc.bh); 850 exit_dind: 851 brelse(dind); 852 exit_bh: 853 brelse(gdb_bh); 854 855 ext4_debug("leaving with error %d\n", err); 856 return err; 857 } 858 859 /* 860 * add_new_gdb_meta_bg is the sister of add_new_gdb. 861 */ 862 static int add_new_gdb_meta_bg(struct super_block *sb, 863 handle_t *handle, ext4_group_t group) { 864 ext4_fsblk_t gdblock; 865 struct buffer_head *gdb_bh; 866 struct buffer_head **o_group_desc, **n_group_desc; 867 unsigned long gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 868 int err; 869 870 gdblock = ext4_meta_bg_first_block_no(sb, group) + 871 ext4_bg_has_super(sb, group); 872 gdb_bh = sb_bread(sb, gdblock); 873 if (!gdb_bh) 874 return -EIO; 875 n_group_desc = ext4_kvmalloc((gdb_num + 1) * 876 sizeof(struct buffer_head *), 877 GFP_NOFS); 878 if (!n_group_desc) { 879 err = -ENOMEM; 880 ext4_warning(sb, "not enough memory for %lu groups", 881 gdb_num + 1); 882 return err; 883 } 884 885 o_group_desc = EXT4_SB(sb)->s_group_desc; 886 memcpy(n_group_desc, o_group_desc, 887 EXT4_SB(sb)->s_gdb_count * sizeof(struct buffer_head *)); 888 n_group_desc[gdb_num] = gdb_bh; 889 EXT4_SB(sb)->s_group_desc = n_group_desc; 890 EXT4_SB(sb)->s_gdb_count++; 891 ext4_kvfree(o_group_desc); 892 err = ext4_journal_get_write_access(handle, gdb_bh); 893 if (unlikely(err)) 894 brelse(gdb_bh); 895 return err; 896 } 897 898 /* 899 * Called when we are adding a new group which has a backup copy of each of 900 * the GDT blocks (i.e. sparse group) and there are reserved GDT blocks. 901 * We need to add these reserved backup GDT blocks to the resize inode, so 902 * that they are kept for future resizing and not allocated to files. 903 * 904 * Each reserved backup GDT block will go into a different indirect block. 905 * The indirect blocks are actually the primary reserved GDT blocks, 906 * so we know in advance what their block numbers are. We only get the 907 * double-indirect block to verify it is pointing to the primary reserved 908 * GDT blocks so we don't overwrite a data block by accident. The reserved 909 * backup GDT blocks are stored in their reserved primary GDT block. 910 */ 911 static int reserve_backup_gdb(handle_t *handle, struct inode *inode, 912 ext4_group_t group) 913 { 914 struct super_block *sb = inode->i_sb; 915 int reserved_gdb =le16_to_cpu(EXT4_SB(sb)->s_es->s_reserved_gdt_blocks); 916 struct buffer_head **primary; 917 struct buffer_head *dind; 918 struct ext4_iloc iloc; 919 ext4_fsblk_t blk; 920 __le32 *data, *end; 921 int gdbackups = 0; 922 int res, i; 923 int err; 924 925 primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS); 926 if (!primary) 927 return -ENOMEM; 928 929 data = EXT4_I(inode)->i_data + EXT4_DIND_BLOCK; 930 dind = sb_bread(sb, le32_to_cpu(*data)); 931 if (!dind) { 932 err = -EIO; 933 goto exit_free; 934 } 935 936 blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count; 937 data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count % 938 EXT4_ADDR_PER_BLOCK(sb)); 939 end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb); 940 941 /* Get each reserved primary GDT block and verify it holds backups */ 942 for (res = 0; res < reserved_gdb; res++, blk++) { 943 if (le32_to_cpu(*data) != blk) { 944 ext4_warning(sb, "reserved block %llu" 945 " not at offset %ld", 946 blk, 947 (long)(data - (__le32 *)dind->b_data)); 948 err = -EINVAL; 949 goto exit_bh; 950 } 951 primary[res] = sb_bread(sb, blk); 952 if (!primary[res]) { 953 err = -EIO; 954 goto exit_bh; 955 } 956 gdbackups = verify_reserved_gdb(sb, group, primary[res]); 957 if (gdbackups < 0) { 958 brelse(primary[res]); 959 err = gdbackups; 960 goto exit_bh; 961 } 962 if (++data >= end) 963 data = (__le32 *)dind->b_data; 964 } 965 966 for (i = 0; i < reserved_gdb; i++) { 967 if ((err = ext4_journal_get_write_access(handle, primary[i]))) 968 goto exit_bh; 969 } 970 971 if ((err = ext4_reserve_inode_write(handle, inode, &iloc))) 972 goto exit_bh; 973 974 /* 975 * Finally we can add each of the reserved backup GDT blocks from 976 * the new group to its reserved primary GDT block. 977 */ 978 blk = group * EXT4_BLOCKS_PER_GROUP(sb); 979 for (i = 0; i < reserved_gdb; i++) { 980 int err2; 981 data = (__le32 *)primary[i]->b_data; 982 /* printk("reserving backup %lu[%u] = %lu\n", 983 primary[i]->b_blocknr, gdbackups, 984 blk + primary[i]->b_blocknr); */ 985 data[gdbackups] = cpu_to_le32(blk + primary[i]->b_blocknr); 986 err2 = ext4_handle_dirty_metadata(handle, NULL, primary[i]); 987 if (!err) 988 err = err2; 989 } 990 inode->i_blocks += reserved_gdb * sb->s_blocksize >> 9; 991 ext4_mark_iloc_dirty(handle, inode, &iloc); 992 993 exit_bh: 994 while (--res >= 0) 995 brelse(primary[res]); 996 brelse(dind); 997 998 exit_free: 999 kfree(primary); 1000 1001 return err; 1002 } 1003 1004 /* 1005 * Update the backup copies of the ext4 metadata. These don't need to be part 1006 * of the main resize transaction, because e2fsck will re-write them if there 1007 * is a problem (basically only OOM will cause a problem). However, we 1008 * _should_ update the backups if possible, in case the primary gets trashed 1009 * for some reason and we need to run e2fsck from a backup superblock. The 1010 * important part is that the new block and inode counts are in the backup 1011 * superblocks, and the location of the new group metadata in the GDT backups. 1012 * 1013 * We do not need take the s_resize_lock for this, because these 1014 * blocks are not otherwise touched by the filesystem code when it is 1015 * mounted. We don't need to worry about last changing from 1016 * sbi->s_groups_count, because the worst that can happen is that we 1017 * do not copy the full number of backups at this time. The resize 1018 * which changed s_groups_count will backup again. 1019 */ 1020 static void update_backups(struct super_block *sb, int blk_off, char *data, 1021 int size, int meta_bg) 1022 { 1023 struct ext4_sb_info *sbi = EXT4_SB(sb); 1024 ext4_group_t last; 1025 const int bpg = EXT4_BLOCKS_PER_GROUP(sb); 1026 unsigned three = 1; 1027 unsigned five = 5; 1028 unsigned seven = 7; 1029 ext4_group_t group = 0; 1030 int rest = sb->s_blocksize - size; 1031 handle_t *handle; 1032 int err = 0, err2; 1033 1034 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, EXT4_MAX_TRANS_DATA); 1035 if (IS_ERR(handle)) { 1036 group = 1; 1037 err = PTR_ERR(handle); 1038 goto exit_err; 1039 } 1040 1041 if (meta_bg == 0) { 1042 group = ext4_list_backups(sb, &three, &five, &seven); 1043 last = sbi->s_groups_count; 1044 } else { 1045 group = ext4_meta_bg_first_group(sb, group) + 1; 1046 last = (ext4_group_t)(group + EXT4_DESC_PER_BLOCK(sb) - 2); 1047 } 1048 1049 while (group < sbi->s_groups_count) { 1050 struct buffer_head *bh; 1051 ext4_fsblk_t backup_block; 1052 1053 /* Out of journal space, and can't get more - abort - so sad */ 1054 if (ext4_handle_valid(handle) && 1055 handle->h_buffer_credits == 0 && 1056 ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) && 1057 (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA))) 1058 break; 1059 1060 if (meta_bg == 0) 1061 backup_block = group * bpg + blk_off; 1062 else 1063 backup_block = (ext4_group_first_block_no(sb, group) + 1064 ext4_bg_has_super(sb, group)); 1065 1066 bh = sb_getblk(sb, backup_block); 1067 if (unlikely(!bh)) { 1068 err = -ENOMEM; 1069 break; 1070 } 1071 ext4_debug("update metadata backup %llu(+%llu)\n", 1072 backup_block, backup_block - 1073 ext4_group_first_block_no(sb, group)); 1074 if ((err = ext4_journal_get_write_access(handle, bh))) 1075 break; 1076 lock_buffer(bh); 1077 memcpy(bh->b_data, data, size); 1078 if (rest) 1079 memset(bh->b_data + size, 0, rest); 1080 set_buffer_uptodate(bh); 1081 unlock_buffer(bh); 1082 err = ext4_handle_dirty_metadata(handle, NULL, bh); 1083 if (unlikely(err)) 1084 ext4_std_error(sb, err); 1085 brelse(bh); 1086 1087 if (meta_bg == 0) 1088 group = ext4_list_backups(sb, &three, &five, &seven); 1089 else if (group == last) 1090 break; 1091 else 1092 group = last; 1093 } 1094 if ((err2 = ext4_journal_stop(handle)) && !err) 1095 err = err2; 1096 1097 /* 1098 * Ugh! Need to have e2fsck write the backup copies. It is too 1099 * late to revert the resize, we shouldn't fail just because of 1100 * the backup copies (they are only needed in case of corruption). 1101 * 1102 * However, if we got here we have a journal problem too, so we 1103 * can't really start a transaction to mark the superblock. 1104 * Chicken out and just set the flag on the hope it will be written 1105 * to disk, and if not - we will simply wait until next fsck. 1106 */ 1107 exit_err: 1108 if (err) { 1109 ext4_warning(sb, "can't update backup for group %u (err %d), " 1110 "forcing fsck on next reboot", group, err); 1111 sbi->s_mount_state &= ~EXT4_VALID_FS; 1112 sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS); 1113 mark_buffer_dirty(sbi->s_sbh); 1114 } 1115 } 1116 1117 /* 1118 * ext4_add_new_descs() adds @count group descriptor of groups 1119 * starting at @group 1120 * 1121 * @handle: journal handle 1122 * @sb: super block 1123 * @group: the group no. of the first group desc to be added 1124 * @resize_inode: the resize inode 1125 * @count: number of group descriptors to be added 1126 */ 1127 static int ext4_add_new_descs(handle_t *handle, struct super_block *sb, 1128 ext4_group_t group, struct inode *resize_inode, 1129 ext4_group_t count) 1130 { 1131 struct ext4_sb_info *sbi = EXT4_SB(sb); 1132 struct ext4_super_block *es = sbi->s_es; 1133 struct buffer_head *gdb_bh; 1134 int i, gdb_off, gdb_num, err = 0; 1135 int meta_bg; 1136 1137 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1138 for (i = 0; i < count; i++, group++) { 1139 int reserved_gdb = ext4_bg_has_super(sb, group) ? 1140 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 1141 1142 gdb_off = group % EXT4_DESC_PER_BLOCK(sb); 1143 gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1144 1145 /* 1146 * We will only either add reserved group blocks to a backup group 1147 * or remove reserved blocks for the first group in a new group block. 1148 * Doing both would be mean more complex code, and sane people don't 1149 * use non-sparse filesystems anymore. This is already checked above. 1150 */ 1151 if (gdb_off) { 1152 gdb_bh = sbi->s_group_desc[gdb_num]; 1153 err = ext4_journal_get_write_access(handle, gdb_bh); 1154 1155 if (!err && reserved_gdb && ext4_bg_num_gdb(sb, group)) 1156 err = reserve_backup_gdb(handle, resize_inode, group); 1157 } else if (meta_bg != 0) { 1158 err = add_new_gdb_meta_bg(sb, handle, group); 1159 } else { 1160 err = add_new_gdb(handle, resize_inode, group); 1161 } 1162 if (err) 1163 break; 1164 } 1165 return err; 1166 } 1167 1168 static struct buffer_head *ext4_get_bitmap(struct super_block *sb, __u64 block) 1169 { 1170 struct buffer_head *bh = sb_getblk(sb, block); 1171 if (unlikely(!bh)) 1172 return NULL; 1173 if (!bh_uptodate_or_lock(bh)) { 1174 if (bh_submit_read(bh) < 0) { 1175 brelse(bh); 1176 return NULL; 1177 } 1178 } 1179 1180 return bh; 1181 } 1182 1183 static int ext4_set_bitmap_checksums(struct super_block *sb, 1184 ext4_group_t group, 1185 struct ext4_group_desc *gdp, 1186 struct ext4_new_group_data *group_data) 1187 { 1188 struct buffer_head *bh; 1189 1190 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, 1191 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) 1192 return 0; 1193 1194 bh = ext4_get_bitmap(sb, group_data->inode_bitmap); 1195 if (!bh) 1196 return -EIO; 1197 ext4_inode_bitmap_csum_set(sb, group, gdp, bh, 1198 EXT4_INODES_PER_GROUP(sb) / 8); 1199 brelse(bh); 1200 1201 bh = ext4_get_bitmap(sb, group_data->block_bitmap); 1202 if (!bh) 1203 return -EIO; 1204 ext4_block_bitmap_csum_set(sb, group, gdp, bh); 1205 brelse(bh); 1206 1207 return 0; 1208 } 1209 1210 /* 1211 * ext4_setup_new_descs() will set up the group descriptor descriptors of a flex bg 1212 */ 1213 static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb, 1214 struct ext4_new_flex_group_data *flex_gd) 1215 { 1216 struct ext4_new_group_data *group_data = flex_gd->groups; 1217 struct ext4_group_desc *gdp; 1218 struct ext4_sb_info *sbi = EXT4_SB(sb); 1219 struct buffer_head *gdb_bh; 1220 ext4_group_t group; 1221 __u16 *bg_flags = flex_gd->bg_flags; 1222 int i, gdb_off, gdb_num, err = 0; 1223 1224 1225 for (i = 0; i < flex_gd->count; i++, group_data++, bg_flags++) { 1226 group = group_data->group; 1227 1228 gdb_off = group % EXT4_DESC_PER_BLOCK(sb); 1229 gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1230 1231 /* 1232 * get_write_access() has been called on gdb_bh by ext4_add_new_desc(). 1233 */ 1234 gdb_bh = sbi->s_group_desc[gdb_num]; 1235 /* Update group descriptor block for new group */ 1236 gdp = (struct ext4_group_desc *)(gdb_bh->b_data + 1237 gdb_off * EXT4_DESC_SIZE(sb)); 1238 1239 memset(gdp, 0, EXT4_DESC_SIZE(sb)); 1240 ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap); 1241 ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap); 1242 err = ext4_set_bitmap_checksums(sb, group, gdp, group_data); 1243 if (err) { 1244 ext4_std_error(sb, err); 1245 break; 1246 } 1247 1248 ext4_inode_table_set(sb, gdp, group_data->inode_table); 1249 ext4_free_group_clusters_set(sb, gdp, 1250 EXT4_NUM_B2C(sbi, group_data->free_blocks_count)); 1251 ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb)); 1252 if (ext4_has_group_desc_csum(sb)) 1253 ext4_itable_unused_set(sb, gdp, 1254 EXT4_INODES_PER_GROUP(sb)); 1255 gdp->bg_flags = cpu_to_le16(*bg_flags); 1256 ext4_group_desc_csum_set(sb, group, gdp); 1257 1258 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh); 1259 if (unlikely(err)) { 1260 ext4_std_error(sb, err); 1261 break; 1262 } 1263 1264 /* 1265 * We can allocate memory for mb_alloc based on the new group 1266 * descriptor 1267 */ 1268 err = ext4_mb_add_groupinfo(sb, group, gdp); 1269 if (err) 1270 break; 1271 } 1272 return err; 1273 } 1274 1275 /* 1276 * ext4_update_super() updates the super block so that the newly added 1277 * groups can be seen by the filesystem. 1278 * 1279 * @sb: super block 1280 * @flex_gd: new added groups 1281 */ 1282 static void ext4_update_super(struct super_block *sb, 1283 struct ext4_new_flex_group_data *flex_gd) 1284 { 1285 ext4_fsblk_t blocks_count = 0; 1286 ext4_fsblk_t free_blocks = 0; 1287 ext4_fsblk_t reserved_blocks = 0; 1288 struct ext4_new_group_data *group_data = flex_gd->groups; 1289 struct ext4_sb_info *sbi = EXT4_SB(sb); 1290 struct ext4_super_block *es = sbi->s_es; 1291 int i; 1292 1293 BUG_ON(flex_gd->count == 0 || group_data == NULL); 1294 /* 1295 * Make the new blocks and inodes valid next. We do this before 1296 * increasing the group count so that once the group is enabled, 1297 * all of its blocks and inodes are already valid. 1298 * 1299 * We always allocate group-by-group, then block-by-block or 1300 * inode-by-inode within a group, so enabling these 1301 * blocks/inodes before the group is live won't actually let us 1302 * allocate the new space yet. 1303 */ 1304 for (i = 0; i < flex_gd->count; i++) { 1305 blocks_count += group_data[i].blocks_count; 1306 free_blocks += group_data[i].free_blocks_count; 1307 } 1308 1309 reserved_blocks = ext4_r_blocks_count(es) * 100; 1310 reserved_blocks = div64_u64(reserved_blocks, ext4_blocks_count(es)); 1311 reserved_blocks *= blocks_count; 1312 do_div(reserved_blocks, 100); 1313 1314 ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count); 1315 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + free_blocks); 1316 le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) * 1317 flex_gd->count); 1318 le32_add_cpu(&es->s_free_inodes_count, EXT4_INODES_PER_GROUP(sb) * 1319 flex_gd->count); 1320 1321 ext4_debug("free blocks count %llu", ext4_free_blocks_count(es)); 1322 /* 1323 * We need to protect s_groups_count against other CPUs seeing 1324 * inconsistent state in the superblock. 1325 * 1326 * The precise rules we use are: 1327 * 1328 * * Writers must perform a smp_wmb() after updating all 1329 * dependent data and before modifying the groups count 1330 * 1331 * * Readers must perform an smp_rmb() after reading the groups 1332 * count and before reading any dependent data. 1333 * 1334 * NB. These rules can be relaxed when checking the group count 1335 * while freeing data, as we can only allocate from a block 1336 * group after serialising against the group count, and we can 1337 * only then free after serialising in turn against that 1338 * allocation. 1339 */ 1340 smp_wmb(); 1341 1342 /* Update the global fs size fields */ 1343 sbi->s_groups_count += flex_gd->count; 1344 sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count, 1345 (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb))); 1346 1347 /* Update the reserved block counts only once the new group is 1348 * active. */ 1349 ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) + 1350 reserved_blocks); 1351 1352 /* Update the free space counts */ 1353 percpu_counter_add(&sbi->s_freeclusters_counter, 1354 EXT4_NUM_B2C(sbi, free_blocks)); 1355 percpu_counter_add(&sbi->s_freeinodes_counter, 1356 EXT4_INODES_PER_GROUP(sb) * flex_gd->count); 1357 1358 ext4_debug("free blocks count %llu", 1359 percpu_counter_read(&sbi->s_freeclusters_counter)); 1360 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 1361 EXT4_FEATURE_INCOMPAT_FLEX_BG) && 1362 sbi->s_log_groups_per_flex) { 1363 ext4_group_t flex_group; 1364 flex_group = ext4_flex_group(sbi, group_data[0].group); 1365 atomic64_add(EXT4_NUM_B2C(sbi, free_blocks), 1366 &sbi->s_flex_groups[flex_group].free_clusters); 1367 atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count, 1368 &sbi->s_flex_groups[flex_group].free_inodes); 1369 } 1370 1371 /* 1372 * Update the fs overhead information 1373 */ 1374 ext4_calculate_overhead(sb); 1375 1376 if (test_opt(sb, DEBUG)) 1377 printk(KERN_DEBUG "EXT4-fs: added group %u:" 1378 "%llu blocks(%llu free %llu reserved)\n", flex_gd->count, 1379 blocks_count, free_blocks, reserved_blocks); 1380 } 1381 1382 /* Add a flex group to an fs. Ensure we handle all possible error conditions 1383 * _before_ we start modifying the filesystem, because we cannot abort the 1384 * transaction and not have it write the data to disk. 1385 */ 1386 static int ext4_flex_group_add(struct super_block *sb, 1387 struct inode *resize_inode, 1388 struct ext4_new_flex_group_data *flex_gd) 1389 { 1390 struct ext4_sb_info *sbi = EXT4_SB(sb); 1391 struct ext4_super_block *es = sbi->s_es; 1392 ext4_fsblk_t o_blocks_count; 1393 ext4_grpblk_t last; 1394 ext4_group_t group; 1395 handle_t *handle; 1396 unsigned reserved_gdb; 1397 int err = 0, err2 = 0, credit; 1398 1399 BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags); 1400 1401 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); 1402 o_blocks_count = ext4_blocks_count(es); 1403 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1404 BUG_ON(last); 1405 1406 err = setup_new_flex_group_blocks(sb, flex_gd); 1407 if (err) 1408 goto exit; 1409 /* 1410 * We will always be modifying at least the superblock and GDT 1411 * block. If we are adding a group past the last current GDT block, 1412 * we will also modify the inode and the dindirect block. If we 1413 * are adding a group with superblock/GDT backups we will also 1414 * modify each of the reserved GDT dindirect blocks. 1415 */ 1416 credit = flex_gd->count * 4 + reserved_gdb; 1417 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credit); 1418 if (IS_ERR(handle)) { 1419 err = PTR_ERR(handle); 1420 goto exit; 1421 } 1422 1423 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 1424 if (err) 1425 goto exit_journal; 1426 1427 group = flex_gd->groups[0].group; 1428 BUG_ON(group != EXT4_SB(sb)->s_groups_count); 1429 err = ext4_add_new_descs(handle, sb, group, 1430 resize_inode, flex_gd->count); 1431 if (err) 1432 goto exit_journal; 1433 1434 err = ext4_setup_new_descs(handle, sb, flex_gd); 1435 if (err) 1436 goto exit_journal; 1437 1438 ext4_update_super(sb, flex_gd); 1439 1440 err = ext4_handle_dirty_super(handle, sb); 1441 1442 exit_journal: 1443 err2 = ext4_journal_stop(handle); 1444 if (!err) 1445 err = err2; 1446 1447 if (!err) { 1448 int gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1449 int gdb_num_end = ((group + flex_gd->count - 1) / 1450 EXT4_DESC_PER_BLOCK(sb)); 1451 int meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, 1452 EXT4_FEATURE_INCOMPAT_META_BG); 1453 sector_t old_gdb = 0; 1454 1455 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es, 1456 sizeof(struct ext4_super_block), 0); 1457 for (; gdb_num <= gdb_num_end; gdb_num++) { 1458 struct buffer_head *gdb_bh; 1459 1460 gdb_bh = sbi->s_group_desc[gdb_num]; 1461 if (old_gdb == gdb_bh->b_blocknr) 1462 continue; 1463 update_backups(sb, gdb_bh->b_blocknr, gdb_bh->b_data, 1464 gdb_bh->b_size, meta_bg); 1465 old_gdb = gdb_bh->b_blocknr; 1466 } 1467 } 1468 exit: 1469 return err; 1470 } 1471 1472 static int ext4_setup_next_flex_gd(struct super_block *sb, 1473 struct ext4_new_flex_group_data *flex_gd, 1474 ext4_fsblk_t n_blocks_count, 1475 unsigned long flexbg_size) 1476 { 1477 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 1478 struct ext4_new_group_data *group_data = flex_gd->groups; 1479 ext4_fsblk_t o_blocks_count; 1480 ext4_group_t n_group; 1481 ext4_group_t group; 1482 ext4_group_t last_group; 1483 ext4_grpblk_t last; 1484 ext4_grpblk_t blocks_per_group; 1485 unsigned long i; 1486 1487 blocks_per_group = EXT4_BLOCKS_PER_GROUP(sb); 1488 1489 o_blocks_count = ext4_blocks_count(es); 1490 1491 if (o_blocks_count == n_blocks_count) 1492 return 0; 1493 1494 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1495 BUG_ON(last); 1496 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last); 1497 1498 last_group = group | (flexbg_size - 1); 1499 if (last_group > n_group) 1500 last_group = n_group; 1501 1502 flex_gd->count = last_group - group + 1; 1503 1504 for (i = 0; i < flex_gd->count; i++) { 1505 int overhead; 1506 1507 group_data[i].group = group + i; 1508 group_data[i].blocks_count = blocks_per_group; 1509 overhead = ext4_group_overhead_blocks(sb, group + i); 1510 group_data[i].free_blocks_count = blocks_per_group - overhead; 1511 if (ext4_has_group_desc_csum(sb)) { 1512 flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT | 1513 EXT4_BG_INODE_UNINIT; 1514 if (!test_opt(sb, INIT_INODE_TABLE)) 1515 flex_gd->bg_flags[i] |= EXT4_BG_INODE_ZEROED; 1516 } else 1517 flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED; 1518 } 1519 1520 if (last_group == n_group && ext4_has_group_desc_csum(sb)) 1521 /* We need to initialize block bitmap of last group. */ 1522 flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT; 1523 1524 if ((last_group == n_group) && (last != blocks_per_group - 1)) { 1525 group_data[i - 1].blocks_count = last + 1; 1526 group_data[i - 1].free_blocks_count -= blocks_per_group- 1527 last - 1; 1528 } 1529 1530 return 1; 1531 } 1532 1533 /* Add group descriptor data to an existing or new group descriptor block. 1534 * Ensure we handle all possible error conditions _before_ we start modifying 1535 * the filesystem, because we cannot abort the transaction and not have it 1536 * write the data to disk. 1537 * 1538 * If we are on a GDT block boundary, we need to get the reserved GDT block. 1539 * Otherwise, we may need to add backup GDT blocks for a sparse group. 1540 * 1541 * We only need to hold the superblock lock while we are actually adding 1542 * in the new group's counts to the superblock. Prior to that we have 1543 * not really "added" the group at all. We re-check that we are still 1544 * adding in the last group in case things have changed since verifying. 1545 */ 1546 int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) 1547 { 1548 struct ext4_new_flex_group_data flex_gd; 1549 struct ext4_sb_info *sbi = EXT4_SB(sb); 1550 struct ext4_super_block *es = sbi->s_es; 1551 int reserved_gdb = ext4_bg_has_super(sb, input->group) ? 1552 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 1553 struct inode *inode = NULL; 1554 int gdb_off, gdb_num; 1555 int err; 1556 __u16 bg_flags = 0; 1557 1558 gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb); 1559 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); 1560 1561 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb, 1562 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 1563 ext4_warning(sb, "Can't resize non-sparse filesystem further"); 1564 return -EPERM; 1565 } 1566 1567 if (ext4_blocks_count(es) + input->blocks_count < 1568 ext4_blocks_count(es)) { 1569 ext4_warning(sb, "blocks_count overflow"); 1570 return -EINVAL; 1571 } 1572 1573 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < 1574 le32_to_cpu(es->s_inodes_count)) { 1575 ext4_warning(sb, "inodes_count overflow"); 1576 return -EINVAL; 1577 } 1578 1579 if (reserved_gdb || gdb_off == 0) { 1580 if (!EXT4_HAS_COMPAT_FEATURE(sb, 1581 EXT4_FEATURE_COMPAT_RESIZE_INODE) 1582 || !le16_to_cpu(es->s_reserved_gdt_blocks)) { 1583 ext4_warning(sb, 1584 "No reserved GDT blocks, can't resize"); 1585 return -EPERM; 1586 } 1587 inode = ext4_iget(sb, EXT4_RESIZE_INO); 1588 if (IS_ERR(inode)) { 1589 ext4_warning(sb, "Error opening resize inode"); 1590 return PTR_ERR(inode); 1591 } 1592 } 1593 1594 1595 err = verify_group_input(sb, input); 1596 if (err) 1597 goto out; 1598 1599 err = ext4_alloc_flex_bg_array(sb, input->group + 1); 1600 if (err) 1601 goto out; 1602 1603 err = ext4_mb_alloc_groupinfo(sb, input->group + 1); 1604 if (err) 1605 goto out; 1606 1607 flex_gd.count = 1; 1608 flex_gd.groups = input; 1609 flex_gd.bg_flags = &bg_flags; 1610 err = ext4_flex_group_add(sb, inode, &flex_gd); 1611 out: 1612 iput(inode); 1613 return err; 1614 } /* ext4_group_add */ 1615 1616 /* 1617 * extend a group without checking assuming that checking has been done. 1618 */ 1619 static int ext4_group_extend_no_check(struct super_block *sb, 1620 ext4_fsblk_t o_blocks_count, ext4_grpblk_t add) 1621 { 1622 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 1623 handle_t *handle; 1624 int err = 0, err2; 1625 1626 /* We will update the superblock, one block bitmap, and 1627 * one group descriptor via ext4_group_add_blocks(). 1628 */ 1629 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, 3); 1630 if (IS_ERR(handle)) { 1631 err = PTR_ERR(handle); 1632 ext4_warning(sb, "error %d on journal start", err); 1633 return err; 1634 } 1635 1636 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); 1637 if (err) { 1638 ext4_warning(sb, "error %d on journal write access", err); 1639 goto errout; 1640 } 1641 1642 ext4_blocks_count_set(es, o_blocks_count + add); 1643 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + add); 1644 ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count, 1645 o_blocks_count + add); 1646 /* We add the blocks to the bitmap and set the group need init bit */ 1647 err = ext4_group_add_blocks(handle, sb, o_blocks_count, add); 1648 if (err) 1649 goto errout; 1650 ext4_handle_dirty_super(handle, sb); 1651 ext4_debug("freed blocks %llu through %llu\n", o_blocks_count, 1652 o_blocks_count + add); 1653 errout: 1654 err2 = ext4_journal_stop(handle); 1655 if (err2 && !err) 1656 err = err2; 1657 1658 if (!err) { 1659 ext4_fsblk_t first_block; 1660 first_block = ext4_group_first_block_no(sb, 0); 1661 if (test_opt(sb, DEBUG)) 1662 printk(KERN_DEBUG "EXT4-fs: extended group to %llu " 1663 "blocks\n", ext4_blocks_count(es)); 1664 update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr - first_block, 1665 (char *)es, sizeof(struct ext4_super_block), 0); 1666 } 1667 return err; 1668 } 1669 1670 /* 1671 * Extend the filesystem to the new number of blocks specified. This entry 1672 * point is only used to extend the current filesystem to the end of the last 1673 * existing group. It can be accessed via ioctl, or by "remount,resize=<size>" 1674 * for emergencies (because it has no dependencies on reserved blocks). 1675 * 1676 * If we _really_ wanted, we could use default values to call ext4_group_add() 1677 * allow the "remount" trick to work for arbitrary resizing, assuming enough 1678 * GDT blocks are reserved to grow to the desired size. 1679 */ 1680 int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es, 1681 ext4_fsblk_t n_blocks_count) 1682 { 1683 ext4_fsblk_t o_blocks_count; 1684 ext4_grpblk_t last; 1685 ext4_grpblk_t add; 1686 struct buffer_head *bh; 1687 int err; 1688 ext4_group_t group; 1689 1690 o_blocks_count = ext4_blocks_count(es); 1691 1692 if (test_opt(sb, DEBUG)) 1693 ext4_msg(sb, KERN_DEBUG, 1694 "extending last group from %llu to %llu blocks", 1695 o_blocks_count, n_blocks_count); 1696 1697 if (n_blocks_count == 0 || n_blocks_count == o_blocks_count) 1698 return 0; 1699 1700 if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { 1701 ext4_msg(sb, KERN_ERR, 1702 "filesystem too large to resize to %llu blocks safely", 1703 n_blocks_count); 1704 if (sizeof(sector_t) < 8) 1705 ext4_warning(sb, "CONFIG_LBDAF not enabled"); 1706 return -EINVAL; 1707 } 1708 1709 if (n_blocks_count < o_blocks_count) { 1710 ext4_warning(sb, "can't shrink FS - resize aborted"); 1711 return -EINVAL; 1712 } 1713 1714 /* Handle the remaining blocks in the last group only. */ 1715 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1716 1717 if (last == 0) { 1718 ext4_warning(sb, "need to use ext2online to resize further"); 1719 return -EPERM; 1720 } 1721 1722 add = EXT4_BLOCKS_PER_GROUP(sb) - last; 1723 1724 if (o_blocks_count + add < o_blocks_count) { 1725 ext4_warning(sb, "blocks_count overflow"); 1726 return -EINVAL; 1727 } 1728 1729 if (o_blocks_count + add > n_blocks_count) 1730 add = n_blocks_count - o_blocks_count; 1731 1732 if (o_blocks_count + add < n_blocks_count) 1733 ext4_warning(sb, "will only finish group (%llu blocks, %u new)", 1734 o_blocks_count + add, add); 1735 1736 /* See if the device is actually as big as what was requested */ 1737 bh = sb_bread(sb, o_blocks_count + add - 1); 1738 if (!bh) { 1739 ext4_warning(sb, "can't read last block, resize aborted"); 1740 return -ENOSPC; 1741 } 1742 brelse(bh); 1743 1744 err = ext4_group_extend_no_check(sb, o_blocks_count, add); 1745 return err; 1746 } /* ext4_group_extend */ 1747 1748 1749 static int num_desc_blocks(struct super_block *sb, ext4_group_t groups) 1750 { 1751 return (groups + EXT4_DESC_PER_BLOCK(sb) - 1) / EXT4_DESC_PER_BLOCK(sb); 1752 } 1753 1754 /* 1755 * Release the resize inode and drop the resize_inode feature if there 1756 * are no more reserved gdt blocks, and then convert the file system 1757 * to enable meta_bg 1758 */ 1759 static int ext4_convert_meta_bg(struct super_block *sb, struct inode *inode) 1760 { 1761 handle_t *handle; 1762 struct ext4_sb_info *sbi = EXT4_SB(sb); 1763 struct ext4_super_block *es = sbi->s_es; 1764 struct ext4_inode_info *ei = EXT4_I(inode); 1765 ext4_fsblk_t nr; 1766 int i, ret, err = 0; 1767 int credits = 1; 1768 1769 ext4_msg(sb, KERN_INFO, "Converting file system to meta_bg"); 1770 if (inode) { 1771 if (es->s_reserved_gdt_blocks) { 1772 ext4_error(sb, "Unexpected non-zero " 1773 "s_reserved_gdt_blocks"); 1774 return -EPERM; 1775 } 1776 1777 /* Do a quick sanity check of the resize inode */ 1778 if (inode->i_blocks != 1 << (inode->i_blkbits - 9)) 1779 goto invalid_resize_inode; 1780 for (i = 0; i < EXT4_N_BLOCKS; i++) { 1781 if (i == EXT4_DIND_BLOCK) { 1782 if (ei->i_data[i]) 1783 continue; 1784 else 1785 goto invalid_resize_inode; 1786 } 1787 if (ei->i_data[i]) 1788 goto invalid_resize_inode; 1789 } 1790 credits += 3; /* block bitmap, bg descriptor, resize inode */ 1791 } 1792 1793 handle = ext4_journal_start_sb(sb, EXT4_HT_RESIZE, credits); 1794 if (IS_ERR(handle)) 1795 return PTR_ERR(handle); 1796 1797 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 1798 if (err) 1799 goto errout; 1800 1801 EXT4_CLEAR_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE); 1802 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1803 sbi->s_es->s_first_meta_bg = 1804 cpu_to_le32(num_desc_blocks(sb, sbi->s_groups_count)); 1805 1806 err = ext4_handle_dirty_super(handle, sb); 1807 if (err) { 1808 ext4_std_error(sb, err); 1809 goto errout; 1810 } 1811 1812 if (inode) { 1813 nr = le32_to_cpu(ei->i_data[EXT4_DIND_BLOCK]); 1814 ext4_free_blocks(handle, inode, NULL, nr, 1, 1815 EXT4_FREE_BLOCKS_METADATA | 1816 EXT4_FREE_BLOCKS_FORGET); 1817 ei->i_data[EXT4_DIND_BLOCK] = 0; 1818 inode->i_blocks = 0; 1819 1820 err = ext4_mark_inode_dirty(handle, inode); 1821 if (err) 1822 ext4_std_error(sb, err); 1823 } 1824 1825 errout: 1826 ret = ext4_journal_stop(handle); 1827 if (!err) 1828 err = ret; 1829 return ret; 1830 1831 invalid_resize_inode: 1832 ext4_error(sb, "corrupted/inconsistent resize inode"); 1833 return -EINVAL; 1834 } 1835 1836 /* 1837 * ext4_resize_fs() resizes a fs to new size specified by @n_blocks_count 1838 * 1839 * @sb: super block of the fs to be resized 1840 * @n_blocks_count: the number of blocks resides in the resized fs 1841 */ 1842 int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count) 1843 { 1844 struct ext4_new_flex_group_data *flex_gd = NULL; 1845 struct ext4_sb_info *sbi = EXT4_SB(sb); 1846 struct ext4_super_block *es = sbi->s_es; 1847 struct buffer_head *bh; 1848 struct inode *resize_inode = NULL; 1849 ext4_grpblk_t add, offset; 1850 unsigned long n_desc_blocks; 1851 unsigned long o_desc_blocks; 1852 ext4_group_t o_group; 1853 ext4_group_t n_group; 1854 ext4_fsblk_t o_blocks_count; 1855 ext4_fsblk_t n_blocks_count_retry = 0; 1856 unsigned long last_update_time = 0; 1857 int err = 0, flexbg_size = 1 << sbi->s_log_groups_per_flex; 1858 int meta_bg; 1859 1860 /* See if the device is actually as big as what was requested */ 1861 bh = sb_bread(sb, n_blocks_count - 1); 1862 if (!bh) { 1863 ext4_warning(sb, "can't read last block, resize aborted"); 1864 return -ENOSPC; 1865 } 1866 brelse(bh); 1867 1868 retry: 1869 o_blocks_count = ext4_blocks_count(es); 1870 1871 ext4_msg(sb, KERN_INFO, "resizing filesystem from %llu " 1872 "to %llu blocks", o_blocks_count, n_blocks_count); 1873 1874 if (n_blocks_count < o_blocks_count) { 1875 /* On-line shrinking not supported */ 1876 ext4_warning(sb, "can't shrink FS - resize aborted"); 1877 return -EINVAL; 1878 } 1879 1880 if (n_blocks_count == o_blocks_count) 1881 /* Nothing need to do */ 1882 return 0; 1883 1884 n_group = ext4_get_group_number(sb, n_blocks_count - 1); 1885 if (n_group > (0xFFFFFFFFUL / EXT4_INODES_PER_GROUP(sb))) { 1886 ext4_warning(sb, "resize would cause inodes_count overflow"); 1887 return -EINVAL; 1888 } 1889 ext4_get_group_no_and_offset(sb, o_blocks_count - 1, &o_group, &offset); 1890 1891 n_desc_blocks = num_desc_blocks(sb, n_group + 1); 1892 o_desc_blocks = num_desc_blocks(sb, sbi->s_groups_count); 1893 1894 meta_bg = EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG); 1895 1896 if (EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE)) { 1897 if (meta_bg) { 1898 ext4_error(sb, "resize_inode and meta_bg enabled " 1899 "simultaneously"); 1900 return -EINVAL; 1901 } 1902 if (n_desc_blocks > o_desc_blocks + 1903 le16_to_cpu(es->s_reserved_gdt_blocks)) { 1904 n_blocks_count_retry = n_blocks_count; 1905 n_desc_blocks = o_desc_blocks + 1906 le16_to_cpu(es->s_reserved_gdt_blocks); 1907 n_group = n_desc_blocks * EXT4_DESC_PER_BLOCK(sb); 1908 n_blocks_count = n_group * EXT4_BLOCKS_PER_GROUP(sb); 1909 n_group--; /* set to last group number */ 1910 } 1911 1912 if (!resize_inode) 1913 resize_inode = ext4_iget(sb, EXT4_RESIZE_INO); 1914 if (IS_ERR(resize_inode)) { 1915 ext4_warning(sb, "Error opening resize inode"); 1916 return PTR_ERR(resize_inode); 1917 } 1918 } 1919 1920 if ((!resize_inode && !meta_bg) || n_blocks_count == o_blocks_count) { 1921 err = ext4_convert_meta_bg(sb, resize_inode); 1922 if (err) 1923 goto out; 1924 if (resize_inode) { 1925 iput(resize_inode); 1926 resize_inode = NULL; 1927 } 1928 if (n_blocks_count_retry) { 1929 n_blocks_count = n_blocks_count_retry; 1930 n_blocks_count_retry = 0; 1931 goto retry; 1932 } 1933 } 1934 1935 /* extend the last group */ 1936 if (n_group == o_group) 1937 add = n_blocks_count - o_blocks_count; 1938 else 1939 add = EXT4_BLOCKS_PER_GROUP(sb) - (offset + 1); 1940 if (add > 0) { 1941 err = ext4_group_extend_no_check(sb, o_blocks_count, add); 1942 if (err) 1943 goto out; 1944 } 1945 1946 if (ext4_blocks_count(es) == n_blocks_count) 1947 goto out; 1948 1949 err = ext4_alloc_flex_bg_array(sb, n_group + 1); 1950 if (err) 1951 return err; 1952 1953 err = ext4_mb_alloc_groupinfo(sb, n_group + 1); 1954 if (err) 1955 goto out; 1956 1957 flex_gd = alloc_flex_gd(flexbg_size); 1958 if (flex_gd == NULL) { 1959 err = -ENOMEM; 1960 goto out; 1961 } 1962 1963 /* Add flex groups. Note that a regular group is a 1964 * flex group with 1 group. 1965 */ 1966 while (ext4_setup_next_flex_gd(sb, flex_gd, n_blocks_count, 1967 flexbg_size)) { 1968 if (jiffies - last_update_time > HZ * 10) { 1969 if (last_update_time) 1970 ext4_msg(sb, KERN_INFO, 1971 "resized to %llu blocks", 1972 ext4_blocks_count(es)); 1973 last_update_time = jiffies; 1974 } 1975 if (ext4_alloc_group_tables(sb, flex_gd, flexbg_size) != 0) 1976 break; 1977 err = ext4_flex_group_add(sb, resize_inode, flex_gd); 1978 if (unlikely(err)) 1979 break; 1980 } 1981 1982 if (!err && n_blocks_count_retry) { 1983 n_blocks_count = n_blocks_count_retry; 1984 n_blocks_count_retry = 0; 1985 free_flex_gd(flex_gd); 1986 flex_gd = NULL; 1987 goto retry; 1988 } 1989 1990 out: 1991 if (flex_gd) 1992 free_flex_gd(flex_gd); 1993 if (resize_inode != NULL) 1994 iput(resize_inode); 1995 ext4_msg(sb, KERN_INFO, "resized filesystem to %llu", n_blocks_count); 1996 return err; 1997 } 1998