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