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