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_metadata(handle, NULL, EXT4_SB(sb)->s_sbh); 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 while ((group = ext4_list_backups(sb, &three, &five, &seven)) < last) { 972 struct buffer_head *bh; 973 974 /* Out of journal space, and can't get more - abort - so sad */ 975 if (ext4_handle_valid(handle) && 976 handle->h_buffer_credits == 0 && 977 ext4_journal_extend(handle, EXT4_MAX_TRANS_DATA) && 978 (err = ext4_journal_restart(handle, EXT4_MAX_TRANS_DATA))) 979 break; 980 981 bh = sb_getblk(sb, group * bpg + blk_off); 982 if (!bh) { 983 err = -EIO; 984 break; 985 } 986 ext4_debug("update metadata backup %#04lx\n", 987 (unsigned long)bh->b_blocknr); 988 if ((err = ext4_journal_get_write_access(handle, bh))) 989 break; 990 lock_buffer(bh); 991 memcpy(bh->b_data, data, size); 992 if (rest) 993 memset(bh->b_data + size, 0, rest); 994 set_buffer_uptodate(bh); 995 unlock_buffer(bh); 996 err = ext4_handle_dirty_metadata(handle, NULL, bh); 997 if (unlikely(err)) 998 ext4_std_error(sb, err); 999 brelse(bh); 1000 } 1001 if ((err2 = ext4_journal_stop(handle)) && !err) 1002 err = err2; 1003 1004 /* 1005 * Ugh! Need to have e2fsck write the backup copies. It is too 1006 * late to revert the resize, we shouldn't fail just because of 1007 * the backup copies (they are only needed in case of corruption). 1008 * 1009 * However, if we got here we have a journal problem too, so we 1010 * can't really start a transaction to mark the superblock. 1011 * Chicken out and just set the flag on the hope it will be written 1012 * to disk, and if not - we will simply wait until next fsck. 1013 */ 1014 exit_err: 1015 if (err) { 1016 ext4_warning(sb, "can't update backup for group %u (err %d), " 1017 "forcing fsck on next reboot", group, err); 1018 sbi->s_mount_state &= ~EXT4_VALID_FS; 1019 sbi->s_es->s_state &= cpu_to_le16(~EXT4_VALID_FS); 1020 mark_buffer_dirty(sbi->s_sbh); 1021 } 1022 } 1023 1024 /* 1025 * ext4_add_new_descs() adds @count group descriptor of groups 1026 * starting at @group 1027 * 1028 * @handle: journal handle 1029 * @sb: super block 1030 * @group: the group no. of the first group desc to be added 1031 * @resize_inode: the resize inode 1032 * @count: number of group descriptors to be added 1033 */ 1034 static int ext4_add_new_descs(handle_t *handle, struct super_block *sb, 1035 ext4_group_t group, struct inode *resize_inode, 1036 ext4_group_t count) 1037 { 1038 struct ext4_sb_info *sbi = EXT4_SB(sb); 1039 struct ext4_super_block *es = sbi->s_es; 1040 struct buffer_head *gdb_bh; 1041 int i, gdb_off, gdb_num, err = 0; 1042 1043 for (i = 0; i < count; i++, group++) { 1044 int reserved_gdb = ext4_bg_has_super(sb, group) ? 1045 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 1046 1047 gdb_off = group % EXT4_DESC_PER_BLOCK(sb); 1048 gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1049 1050 /* 1051 * We will only either add reserved group blocks to a backup group 1052 * or remove reserved blocks for the first group in a new group block. 1053 * Doing both would be mean more complex code, and sane people don't 1054 * use non-sparse filesystems anymore. This is already checked above. 1055 */ 1056 if (gdb_off) { 1057 gdb_bh = sbi->s_group_desc[gdb_num]; 1058 err = ext4_journal_get_write_access(handle, gdb_bh); 1059 1060 if (!err && reserved_gdb && ext4_bg_num_gdb(sb, group)) 1061 err = reserve_backup_gdb(handle, resize_inode, group); 1062 } else 1063 err = add_new_gdb(handle, resize_inode, group); 1064 if (err) 1065 break; 1066 } 1067 return err; 1068 } 1069 1070 /* 1071 * ext4_setup_new_descs() will set up the group descriptor descriptors of a flex bg 1072 */ 1073 static int ext4_setup_new_descs(handle_t *handle, struct super_block *sb, 1074 struct ext4_new_flex_group_data *flex_gd) 1075 { 1076 struct ext4_new_group_data *group_data = flex_gd->groups; 1077 struct ext4_group_desc *gdp; 1078 struct ext4_sb_info *sbi = EXT4_SB(sb); 1079 struct buffer_head *gdb_bh; 1080 ext4_group_t group; 1081 __u16 *bg_flags = flex_gd->bg_flags; 1082 int i, gdb_off, gdb_num, err = 0; 1083 1084 1085 for (i = 0; i < flex_gd->count; i++, group_data++, bg_flags++) { 1086 group = group_data->group; 1087 1088 gdb_off = group % EXT4_DESC_PER_BLOCK(sb); 1089 gdb_num = group / EXT4_DESC_PER_BLOCK(sb); 1090 1091 /* 1092 * get_write_access() has been called on gdb_bh by ext4_add_new_desc(). 1093 */ 1094 gdb_bh = sbi->s_group_desc[gdb_num]; 1095 /* Update group descriptor block for new group */ 1096 gdp = (struct ext4_group_desc *)((char *)gdb_bh->b_data + 1097 gdb_off * EXT4_DESC_SIZE(sb)); 1098 1099 memset(gdp, 0, EXT4_DESC_SIZE(sb)); 1100 ext4_block_bitmap_set(sb, gdp, group_data->block_bitmap); 1101 ext4_inode_bitmap_set(sb, gdp, group_data->inode_bitmap); 1102 ext4_inode_table_set(sb, gdp, group_data->inode_table); 1103 ext4_free_group_clusters_set(sb, gdp, 1104 EXT4_B2C(sbi, group_data->free_blocks_count)); 1105 ext4_free_inodes_set(sb, gdp, EXT4_INODES_PER_GROUP(sb)); 1106 gdp->bg_flags = cpu_to_le16(*bg_flags); 1107 gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp); 1108 1109 err = ext4_handle_dirty_metadata(handle, NULL, gdb_bh); 1110 if (unlikely(err)) { 1111 ext4_std_error(sb, err); 1112 break; 1113 } 1114 1115 /* 1116 * We can allocate memory for mb_alloc based on the new group 1117 * descriptor 1118 */ 1119 err = ext4_mb_add_groupinfo(sb, group, gdp); 1120 if (err) 1121 break; 1122 } 1123 return err; 1124 } 1125 1126 /* 1127 * ext4_update_super() updates the super block so that the newly added 1128 * groups can be seen by the filesystem. 1129 * 1130 * @sb: super block 1131 * @flex_gd: new added groups 1132 */ 1133 static void ext4_update_super(struct super_block *sb, 1134 struct ext4_new_flex_group_data *flex_gd) 1135 { 1136 ext4_fsblk_t blocks_count = 0; 1137 ext4_fsblk_t free_blocks = 0; 1138 ext4_fsblk_t reserved_blocks = 0; 1139 struct ext4_new_group_data *group_data = flex_gd->groups; 1140 struct ext4_sb_info *sbi = EXT4_SB(sb); 1141 struct ext4_super_block *es = sbi->s_es; 1142 int i; 1143 1144 BUG_ON(flex_gd->count == 0 || group_data == NULL); 1145 /* 1146 * Make the new blocks and inodes valid next. We do this before 1147 * increasing the group count so that once the group is enabled, 1148 * all of its blocks and inodes are already valid. 1149 * 1150 * We always allocate group-by-group, then block-by-block or 1151 * inode-by-inode within a group, so enabling these 1152 * blocks/inodes before the group is live won't actually let us 1153 * allocate the new space yet. 1154 */ 1155 for (i = 0; i < flex_gd->count; i++) { 1156 blocks_count += group_data[i].blocks_count; 1157 free_blocks += group_data[i].free_blocks_count; 1158 } 1159 1160 reserved_blocks = ext4_r_blocks_count(es) * 100; 1161 do_div(reserved_blocks, ext4_blocks_count(es)); 1162 reserved_blocks *= blocks_count; 1163 do_div(reserved_blocks, 100); 1164 1165 ext4_blocks_count_set(es, ext4_blocks_count(es) + blocks_count); 1166 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + free_blocks); 1167 le32_add_cpu(&es->s_inodes_count, EXT4_INODES_PER_GROUP(sb) * 1168 flex_gd->count); 1169 le32_add_cpu(&es->s_free_inodes_count, EXT4_INODES_PER_GROUP(sb) * 1170 flex_gd->count); 1171 1172 /* 1173 * We need to protect s_groups_count against other CPUs seeing 1174 * inconsistent state in the superblock. 1175 * 1176 * The precise rules we use are: 1177 * 1178 * * Writers must perform a smp_wmb() after updating all 1179 * dependent data and before modifying the groups count 1180 * 1181 * * Readers must perform an smp_rmb() after reading the groups 1182 * count and before reading any dependent data. 1183 * 1184 * NB. These rules can be relaxed when checking the group count 1185 * while freeing data, as we can only allocate from a block 1186 * group after serialising against the group count, and we can 1187 * only then free after serialising in turn against that 1188 * allocation. 1189 */ 1190 smp_wmb(); 1191 1192 /* Update the global fs size fields */ 1193 sbi->s_groups_count += flex_gd->count; 1194 1195 /* Update the reserved block counts only once the new group is 1196 * active. */ 1197 ext4_r_blocks_count_set(es, ext4_r_blocks_count(es) + 1198 reserved_blocks); 1199 1200 /* Update the free space counts */ 1201 percpu_counter_add(&sbi->s_freeclusters_counter, 1202 EXT4_B2C(sbi, free_blocks)); 1203 percpu_counter_add(&sbi->s_freeinodes_counter, 1204 EXT4_INODES_PER_GROUP(sb) * flex_gd->count); 1205 1206 if (EXT4_HAS_INCOMPAT_FEATURE(sb, 1207 EXT4_FEATURE_INCOMPAT_FLEX_BG) && 1208 sbi->s_log_groups_per_flex) { 1209 ext4_group_t flex_group; 1210 flex_group = ext4_flex_group(sbi, group_data[0].group); 1211 atomic_add(EXT4_B2C(sbi, free_blocks), 1212 &sbi->s_flex_groups[flex_group].free_clusters); 1213 atomic_add(EXT4_INODES_PER_GROUP(sb) * flex_gd->count, 1214 &sbi->s_flex_groups[flex_group].free_inodes); 1215 } 1216 1217 if (test_opt(sb, DEBUG)) 1218 printk(KERN_DEBUG "EXT4-fs: added group %u:" 1219 "%llu blocks(%llu free %llu reserved)\n", flex_gd->count, 1220 blocks_count, free_blocks, reserved_blocks); 1221 } 1222 1223 /* Add a flex group to an fs. Ensure we handle all possible error conditions 1224 * _before_ we start modifying the filesystem, because we cannot abort the 1225 * transaction and not have it write the data to disk. 1226 */ 1227 static int ext4_flex_group_add(struct super_block *sb, 1228 struct inode *resize_inode, 1229 struct ext4_new_flex_group_data *flex_gd) 1230 { 1231 struct ext4_sb_info *sbi = EXT4_SB(sb); 1232 struct ext4_super_block *es = sbi->s_es; 1233 ext4_fsblk_t o_blocks_count; 1234 ext4_grpblk_t last; 1235 ext4_group_t group; 1236 handle_t *handle; 1237 unsigned reserved_gdb; 1238 int err = 0, err2 = 0, credit; 1239 1240 BUG_ON(!flex_gd->count || !flex_gd->groups || !flex_gd->bg_flags); 1241 1242 reserved_gdb = le16_to_cpu(es->s_reserved_gdt_blocks); 1243 o_blocks_count = ext4_blocks_count(es); 1244 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1245 BUG_ON(last); 1246 1247 err = setup_new_flex_group_blocks(sb, flex_gd); 1248 if (err) 1249 goto exit; 1250 /* 1251 * We will always be modifying at least the superblock and GDT 1252 * block. If we are adding a group past the last current GDT block, 1253 * we will also modify the inode and the dindirect block. If we 1254 * are adding a group with superblock/GDT backups we will also 1255 * modify each of the reserved GDT dindirect blocks. 1256 */ 1257 credit = flex_gd->count * 4 + reserved_gdb; 1258 handle = ext4_journal_start_sb(sb, credit); 1259 if (IS_ERR(handle)) { 1260 err = PTR_ERR(handle); 1261 goto exit; 1262 } 1263 1264 err = ext4_journal_get_write_access(handle, sbi->s_sbh); 1265 if (err) 1266 goto exit_journal; 1267 1268 group = flex_gd->groups[0].group; 1269 BUG_ON(group != EXT4_SB(sb)->s_groups_count); 1270 err = ext4_add_new_descs(handle, sb, group, 1271 resize_inode, flex_gd->count); 1272 if (err) 1273 goto exit_journal; 1274 1275 err = ext4_setup_new_descs(handle, sb, flex_gd); 1276 if (err) 1277 goto exit_journal; 1278 1279 ext4_update_super(sb, flex_gd); 1280 1281 err = ext4_handle_dirty_super(handle, sb); 1282 1283 exit_journal: 1284 err2 = ext4_journal_stop(handle); 1285 if (!err) 1286 err = err2; 1287 1288 if (!err) { 1289 int i; 1290 update_backups(sb, sbi->s_sbh->b_blocknr, (char *)es, 1291 sizeof(struct ext4_super_block)); 1292 for (i = 0; i < flex_gd->count; i++, group++) { 1293 struct buffer_head *gdb_bh; 1294 int gdb_num; 1295 gdb_num = group / EXT4_BLOCKS_PER_GROUP(sb); 1296 gdb_bh = sbi->s_group_desc[gdb_num]; 1297 update_backups(sb, gdb_bh->b_blocknr, gdb_bh->b_data, 1298 gdb_bh->b_size); 1299 } 1300 } 1301 exit: 1302 return err; 1303 } 1304 1305 static int ext4_setup_next_flex_gd(struct super_block *sb, 1306 struct ext4_new_flex_group_data *flex_gd, 1307 ext4_fsblk_t n_blocks_count, 1308 unsigned long flexbg_size) 1309 { 1310 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 1311 struct ext4_new_group_data *group_data = flex_gd->groups; 1312 ext4_fsblk_t o_blocks_count; 1313 ext4_group_t n_group; 1314 ext4_group_t group; 1315 ext4_group_t last_group; 1316 ext4_grpblk_t last; 1317 ext4_grpblk_t blocks_per_group; 1318 unsigned long i; 1319 1320 blocks_per_group = EXT4_BLOCKS_PER_GROUP(sb); 1321 1322 o_blocks_count = ext4_blocks_count(es); 1323 1324 if (o_blocks_count == n_blocks_count) 1325 return 0; 1326 1327 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1328 BUG_ON(last); 1329 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &last); 1330 1331 last_group = group | (flexbg_size - 1); 1332 if (last_group > n_group) 1333 last_group = n_group; 1334 1335 flex_gd->count = last_group - group + 1; 1336 1337 for (i = 0; i < flex_gd->count; i++) { 1338 int overhead; 1339 1340 group_data[i].group = group + i; 1341 group_data[i].blocks_count = blocks_per_group; 1342 overhead = ext4_bg_has_super(sb, group + i) ? 1343 (1 + ext4_bg_num_gdb(sb, group + i) + 1344 le16_to_cpu(es->s_reserved_gdt_blocks)) : 0; 1345 group_data[i].free_blocks_count = blocks_per_group - overhead; 1346 if (EXT4_HAS_RO_COMPAT_FEATURE(sb, 1347 EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) 1348 flex_gd->bg_flags[i] = EXT4_BG_BLOCK_UNINIT | 1349 EXT4_BG_INODE_UNINIT; 1350 else 1351 flex_gd->bg_flags[i] = EXT4_BG_INODE_ZEROED; 1352 } 1353 1354 if (last_group == n_group && 1355 EXT4_HAS_RO_COMPAT_FEATURE(sb, 1356 EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) 1357 /* We need to initialize block bitmap of last group. */ 1358 flex_gd->bg_flags[i - 1] &= ~EXT4_BG_BLOCK_UNINIT; 1359 1360 if ((last_group == n_group) && (last != blocks_per_group - 1)) { 1361 group_data[i - 1].blocks_count = last + 1; 1362 group_data[i - 1].free_blocks_count -= blocks_per_group- 1363 last - 1; 1364 } 1365 1366 return 1; 1367 } 1368 1369 /* Add group descriptor data to an existing or new group descriptor block. 1370 * Ensure we handle all possible error conditions _before_ we start modifying 1371 * the filesystem, because we cannot abort the transaction and not have it 1372 * write the data to disk. 1373 * 1374 * If we are on a GDT block boundary, we need to get the reserved GDT block. 1375 * Otherwise, we may need to add backup GDT blocks for a sparse group. 1376 * 1377 * We only need to hold the superblock lock while we are actually adding 1378 * in the new group's counts to the superblock. Prior to that we have 1379 * not really "added" the group at all. We re-check that we are still 1380 * adding in the last group in case things have changed since verifying. 1381 */ 1382 int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input) 1383 { 1384 struct ext4_new_flex_group_data flex_gd; 1385 struct ext4_sb_info *sbi = EXT4_SB(sb); 1386 struct ext4_super_block *es = sbi->s_es; 1387 int reserved_gdb = ext4_bg_has_super(sb, input->group) ? 1388 le16_to_cpu(es->s_reserved_gdt_blocks) : 0; 1389 struct inode *inode = NULL; 1390 int gdb_off, gdb_num; 1391 int err; 1392 __u16 bg_flags = 0; 1393 1394 gdb_num = input->group / EXT4_DESC_PER_BLOCK(sb); 1395 gdb_off = input->group % EXT4_DESC_PER_BLOCK(sb); 1396 1397 if (gdb_off == 0 && !EXT4_HAS_RO_COMPAT_FEATURE(sb, 1398 EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) { 1399 ext4_warning(sb, "Can't resize non-sparse filesystem further"); 1400 return -EPERM; 1401 } 1402 1403 if (ext4_blocks_count(es) + input->blocks_count < 1404 ext4_blocks_count(es)) { 1405 ext4_warning(sb, "blocks_count overflow"); 1406 return -EINVAL; 1407 } 1408 1409 if (le32_to_cpu(es->s_inodes_count) + EXT4_INODES_PER_GROUP(sb) < 1410 le32_to_cpu(es->s_inodes_count)) { 1411 ext4_warning(sb, "inodes_count overflow"); 1412 return -EINVAL; 1413 } 1414 1415 if (reserved_gdb || gdb_off == 0) { 1416 if (!EXT4_HAS_COMPAT_FEATURE(sb, 1417 EXT4_FEATURE_COMPAT_RESIZE_INODE) 1418 || !le16_to_cpu(es->s_reserved_gdt_blocks)) { 1419 ext4_warning(sb, 1420 "No reserved GDT blocks, can't resize"); 1421 return -EPERM; 1422 } 1423 inode = ext4_iget(sb, EXT4_RESIZE_INO); 1424 if (IS_ERR(inode)) { 1425 ext4_warning(sb, "Error opening resize inode"); 1426 return PTR_ERR(inode); 1427 } 1428 } 1429 1430 1431 err = verify_group_input(sb, input); 1432 if (err) 1433 goto out; 1434 1435 flex_gd.count = 1; 1436 flex_gd.groups = input; 1437 flex_gd.bg_flags = &bg_flags; 1438 err = ext4_flex_group_add(sb, inode, &flex_gd); 1439 out: 1440 iput(inode); 1441 return err; 1442 } /* ext4_group_add */ 1443 1444 /* 1445 * extend a group without checking assuming that checking has been done. 1446 */ 1447 static int ext4_group_extend_no_check(struct super_block *sb, 1448 ext4_fsblk_t o_blocks_count, ext4_grpblk_t add) 1449 { 1450 struct ext4_super_block *es = EXT4_SB(sb)->s_es; 1451 handle_t *handle; 1452 int err = 0, err2; 1453 1454 /* We will update the superblock, one block bitmap, and 1455 * one group descriptor via ext4_group_add_blocks(). 1456 */ 1457 handle = ext4_journal_start_sb(sb, 3); 1458 if (IS_ERR(handle)) { 1459 err = PTR_ERR(handle); 1460 ext4_warning(sb, "error %d on journal start", err); 1461 return err; 1462 } 1463 1464 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh); 1465 if (err) { 1466 ext4_warning(sb, "error %d on journal write access", err); 1467 goto errout; 1468 } 1469 1470 ext4_blocks_count_set(es, o_blocks_count + add); 1471 ext4_free_blocks_count_set(es, ext4_free_blocks_count(es) + add); 1472 ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count, 1473 o_blocks_count + add); 1474 /* We add the blocks to the bitmap and set the group need init bit */ 1475 err = ext4_group_add_blocks(handle, sb, o_blocks_count, add); 1476 if (err) 1477 goto errout; 1478 ext4_handle_dirty_super(handle, sb); 1479 ext4_debug("freed blocks %llu through %llu\n", o_blocks_count, 1480 o_blocks_count + add); 1481 errout: 1482 err2 = ext4_journal_stop(handle); 1483 if (err2 && !err) 1484 err = err2; 1485 1486 if (!err) { 1487 if (test_opt(sb, DEBUG)) 1488 printk(KERN_DEBUG "EXT4-fs: extended group to %llu " 1489 "blocks\n", ext4_blocks_count(es)); 1490 update_backups(sb, EXT4_SB(sb)->s_sbh->b_blocknr, (char *)es, 1491 sizeof(struct ext4_super_block)); 1492 } 1493 return err; 1494 } 1495 1496 /* 1497 * Extend the filesystem to the new number of blocks specified. This entry 1498 * point is only used to extend the current filesystem to the end of the last 1499 * existing group. It can be accessed via ioctl, or by "remount,resize=<size>" 1500 * for emergencies (because it has no dependencies on reserved blocks). 1501 * 1502 * If we _really_ wanted, we could use default values to call ext4_group_add() 1503 * allow the "remount" trick to work for arbitrary resizing, assuming enough 1504 * GDT blocks are reserved to grow to the desired size. 1505 */ 1506 int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es, 1507 ext4_fsblk_t n_blocks_count) 1508 { 1509 ext4_fsblk_t o_blocks_count; 1510 ext4_grpblk_t last; 1511 ext4_grpblk_t add; 1512 struct buffer_head *bh; 1513 int err; 1514 ext4_group_t group; 1515 1516 o_blocks_count = ext4_blocks_count(es); 1517 1518 if (test_opt(sb, DEBUG)) 1519 ext4_msg(sb, KERN_DEBUG, 1520 "extending last group from %llu to %llu blocks", 1521 o_blocks_count, n_blocks_count); 1522 1523 if (n_blocks_count == 0 || n_blocks_count == o_blocks_count) 1524 return 0; 1525 1526 if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) { 1527 ext4_msg(sb, KERN_ERR, 1528 "filesystem too large to resize to %llu blocks safely", 1529 n_blocks_count); 1530 if (sizeof(sector_t) < 8) 1531 ext4_warning(sb, "CONFIG_LBDAF not enabled"); 1532 return -EINVAL; 1533 } 1534 1535 if (n_blocks_count < o_blocks_count) { 1536 ext4_warning(sb, "can't shrink FS - resize aborted"); 1537 return -EINVAL; 1538 } 1539 1540 /* Handle the remaining blocks in the last group only. */ 1541 ext4_get_group_no_and_offset(sb, o_blocks_count, &group, &last); 1542 1543 if (last == 0) { 1544 ext4_warning(sb, "need to use ext2online to resize further"); 1545 return -EPERM; 1546 } 1547 1548 add = EXT4_BLOCKS_PER_GROUP(sb) - last; 1549 1550 if (o_blocks_count + add < o_blocks_count) { 1551 ext4_warning(sb, "blocks_count overflow"); 1552 return -EINVAL; 1553 } 1554 1555 if (o_blocks_count + add > n_blocks_count) 1556 add = n_blocks_count - o_blocks_count; 1557 1558 if (o_blocks_count + add < n_blocks_count) 1559 ext4_warning(sb, "will only finish group (%llu blocks, %u new)", 1560 o_blocks_count + add, add); 1561 1562 /* See if the device is actually as big as what was requested */ 1563 bh = sb_bread(sb, o_blocks_count + add - 1); 1564 if (!bh) { 1565 ext4_warning(sb, "can't read last block, resize aborted"); 1566 return -ENOSPC; 1567 } 1568 brelse(bh); 1569 1570 err = ext4_group_extend_no_check(sb, o_blocks_count, add); 1571 return err; 1572 } /* ext4_group_extend */ 1573 1574 /* 1575 * ext4_resize_fs() resizes a fs to new size specified by @n_blocks_count 1576 * 1577 * @sb: super block of the fs to be resized 1578 * @n_blocks_count: the number of blocks resides in the resized fs 1579 */ 1580 int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count) 1581 { 1582 struct ext4_new_flex_group_data *flex_gd = NULL; 1583 struct ext4_sb_info *sbi = EXT4_SB(sb); 1584 struct ext4_super_block *es = sbi->s_es; 1585 struct buffer_head *bh; 1586 struct inode *resize_inode; 1587 ext4_fsblk_t o_blocks_count; 1588 ext4_group_t o_group; 1589 ext4_group_t n_group; 1590 ext4_grpblk_t offset, add; 1591 unsigned long n_desc_blocks; 1592 unsigned long o_desc_blocks; 1593 unsigned long desc_blocks; 1594 int err = 0, flexbg_size = 1; 1595 1596 o_blocks_count = ext4_blocks_count(es); 1597 1598 if (test_opt(sb, DEBUG)) 1599 ext4_msg(sb, KERN_DEBUG, "resizing filesystem from %llu " 1600 "to %llu blocks", o_blocks_count, n_blocks_count); 1601 1602 if (n_blocks_count < o_blocks_count) { 1603 /* On-line shrinking not supported */ 1604 ext4_warning(sb, "can't shrink FS - resize aborted"); 1605 return -EINVAL; 1606 } 1607 1608 if (n_blocks_count == o_blocks_count) 1609 /* Nothing need to do */ 1610 return 0; 1611 1612 ext4_get_group_no_and_offset(sb, n_blocks_count - 1, &n_group, &offset); 1613 ext4_get_group_no_and_offset(sb, o_blocks_count - 1, &o_group, &offset); 1614 1615 n_desc_blocks = (n_group + EXT4_DESC_PER_BLOCK(sb)) / 1616 EXT4_DESC_PER_BLOCK(sb); 1617 o_desc_blocks = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) / 1618 EXT4_DESC_PER_BLOCK(sb); 1619 desc_blocks = n_desc_blocks - o_desc_blocks; 1620 1621 if (desc_blocks && 1622 (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_RESIZE_INODE) || 1623 le16_to_cpu(es->s_reserved_gdt_blocks) < desc_blocks)) { 1624 ext4_warning(sb, "No reserved GDT blocks, can't resize"); 1625 return -EPERM; 1626 } 1627 1628 resize_inode = ext4_iget(sb, EXT4_RESIZE_INO); 1629 if (IS_ERR(resize_inode)) { 1630 ext4_warning(sb, "Error opening resize inode"); 1631 return PTR_ERR(resize_inode); 1632 } 1633 1634 /* See if the device is actually as big as what was requested */ 1635 bh = sb_bread(sb, n_blocks_count - 1); 1636 if (!bh) { 1637 ext4_warning(sb, "can't read last block, resize aborted"); 1638 return -ENOSPC; 1639 } 1640 brelse(bh); 1641 1642 /* extend the last group */ 1643 if (n_group == o_group) 1644 add = n_blocks_count - o_blocks_count; 1645 else 1646 add = EXT4_BLOCKS_PER_GROUP(sb) - (offset + 1); 1647 if (add > 0) { 1648 err = ext4_group_extend_no_check(sb, o_blocks_count, add); 1649 if (err) 1650 goto out; 1651 } 1652 1653 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG) && 1654 es->s_log_groups_per_flex) 1655 flexbg_size = 1 << es->s_log_groups_per_flex; 1656 1657 o_blocks_count = ext4_blocks_count(es); 1658 if (o_blocks_count == n_blocks_count) 1659 goto out; 1660 1661 flex_gd = alloc_flex_gd(flexbg_size); 1662 if (flex_gd == NULL) { 1663 err = -ENOMEM; 1664 goto out; 1665 } 1666 1667 /* Add flex groups. Note that a regular group is a 1668 * flex group with 1 group. 1669 */ 1670 while (ext4_setup_next_flex_gd(sb, flex_gd, n_blocks_count, 1671 flexbg_size)) { 1672 ext4_alloc_group_tables(sb, flex_gd, flexbg_size); 1673 err = ext4_flex_group_add(sb, resize_inode, flex_gd); 1674 if (unlikely(err)) 1675 break; 1676 } 1677 1678 out: 1679 if (flex_gd) 1680 free_flex_gd(flex_gd); 1681 1682 iput(resize_inode); 1683 if (test_opt(sb, DEBUG)) 1684 ext4_msg(sb, KERN_DEBUG, "resized filesystem from %llu " 1685 "upto %llu blocks", o_blocks_count, n_blocks_count); 1686 return err; 1687 } 1688